• 欢迎访问 winrains 的个人网站!
  • 本网站主要从互联网整理和收集了与Java、网络安全、Linux等技术相关的文章,供学习和研究使用。如有侵权,请留言告知,谢谢!

Java对象的创建和初始化

Java技术 winrains 来源:匠丶 1年前 (2019-08-31) 58次浏览
建议结合上一篇Java类的加载和初始化一起阅读,将帮助你理解:
  • 什么是Class,什么是class
  • Java虚拟机启动和类的加载过程
  • 对象的创建方式和初始化顺序

对象的创建方式

下面结合代码介绍几种对象的创建方式:

//待实例化的类
public class Worker implements Cloneable, Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private Integer age;
    public Worker() {
        this.name = "";
        this.age = 0;
    }
    public Worker(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    public void work() {
        System.out.println(name + "is working");
    }
    public Worker clone() {
        Worker worker = null;
        try {
            return (Worker) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return worker;
    }
}

方式1: 直接使用new的方式,不使用参数

public static Worker createWorker() {
    System.out.println("直接使用new的方式,不使用参数");
    return new Worker();
}

方式2: 使用new方式,带参数

public static Worker createWorker(String name, int age) {
    System.out.println("使用new方式,带参数");
    return new Worker(name, age);
}

方式3: 使用反射机制,不带参数的 newInstance() 方法

public static Worker createWorker1() {
    Class clazz = null;
    Worker worker = null;
    try {
        clazz = Class.forName("com.code.loader.Worker");
        worker = (Worker) clazz.newInstance();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    System.out.println("使用反射机制,不带参数的newInstance()方法");
    return worker;
}

方式4: 使用反射机制 , ConstructornewInstance方法

public static Worker createWorker2() {
    Worker worker = null;
    try {
        Class clazz = null;
        clazz = Class.forName("com.code.loader.Worker");
        // 获取不带参数的构造器
        Constructor constructor = clazz.getConstructor();
        // 使用构造器创建对象
        worker = (Worker) constructor.newInstance();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (SecurityException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }
    System.out.println("使用反射机制,Constructor的newInstance方法");
    return worker;
}

方式5: 使用反射机制 :带参数的构造函数创建新对象

public static Worker createWorker3(String name, Integer age) {
    Worker worker = null;
    try {
        Class clazz = null;
        clazz = Class.forName("com.code.loader.Worker");
        // 获取带参数的构造器
        Constructor constructor = clazz.getConstructor(name.getClass(),
                age.getClass());
        // 使用构造器创建对象
        worker = (Worker) constructor.newInstance(name, age);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (SecurityException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }
    System.out.println("使用反射机制,带参数的构造函数创建新对象");
    return worker;
}

方式6: 使用序列化和反序列化创建对象

public static Worker createWorker4(String name, Integer age) {
    Worker person = new Worker();
    person.setName(name);
    person.setAge(age);
    // 序列化
    OutputStream outputStream = new FileOutputStream("person.txt");
    ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
    objectOutputStream.writeObject(person);
    outputStream.close();
    objectOutputStream.close();
    // 反序列化
    InputStream inputStream = new FileInputStream("person.txt");
    ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
    return (Worker) objectInputStream.readObject();
}

方式7: 使用对象的clone方法,创建对象

public static Worker createWorker5(Worker worker) {
    System.out.println("使用对象的复制,创建对象");
    return (Worker) worker.clone();
}

对象的初始化顺序

结合代码,分析对象的初始化顺序

public class Test {
    public static void main(String[] args) {
        Child child = new Child();
    }
}
class Father {
    public static String fatherStr1 = "fatherStr1(静态字段初始化值)";
    public String fatherStr2 = "fatherStr2(字段初始化值)";
    static {
        System.out.println("父类静态代码块:" + fatherStr1);
        fatherStr1 = "fatherStr1(静态代码块赋值)";
    }
    {
        System.out.println("父类构造代码块:" + fatherStr2);
        fatherStr2 = "fatherStr2(构造代码块赋值)";
    }
    public Father() {
        System.out.println("父类构造函数块:" + fatherStr2);
        fatherStr2 = "fatherStr2(构造函数赋值)";
    }
}
class Child extends Father {
    public static String childStr1 = "childStr1(静态字段初始化值)";
    public String childStr2 = "childStr2(字段初始化值)";
    static {
        System.out.println("子类静态代码块:" + childStr1);
        childStr1 = "childStr1(静态代码块赋值)";
    }
    {
        System.out.println("子类构造代码块:" + childStr2);
        childStr2 = "childStr2(构造代码块赋值)";
    }
    public Child() {
        System.out.println("子类构造函数:" + childStr2);
        childStr2 = "childStr2(构造函数赋值)";
    }
}
     /*输出结果:
    父类静态代码块:fatherStr1(静态字段初始化值)
    子类静态代码块:childStr1(静态字段初始化值)
    父类构造代码块:fatherStr2(字段初始化值)
    父类构造函数块:fatherStr2(构造代码块赋值)
    子类构造代码块:childStr2(字段初始化值)
    子类构造函数:childStr2(构造代码块赋值)*/

总结如下,其中静态字段和静态代码块属于类的初始化过程
1、父类静态字段初始化,静态代码块初始化
2、子类静态字段初始化,子类静态代码块初始化
3、父类普通字段初始化,普通代码块初始化
4、父类构造函数
5、子类普通字段初始化,普通代码块初始化
6、子类构造函数

作者:匠丶

来源:https://www.jianshu.com/p/a4ff6b0a9661


版权声明:文末如注明作者和来源,则表示本文系转载,版权为原作者所有 | 本文如有侵权,请及时联系,承诺在收到消息后第一时间删除 | 如转载本文,请注明原文链接。
喜欢 (0)