java创建类的5种方式

1、使用new关键字 } → 调用了构造函数

这种方式，我们可以调用任意的构造函数(无参的和带参数的)。

2、使用Class类的newInstance方法 } → 调用了构造函数

使用Class类的newInstance方法创建对象。这个newInstance方法调用无参的构造函数创建对象。

3、使用Constructor类的newInstance方法 } → 调用了构造函数

和Class类的newInstance方法很像， java.lang.reflect.Constructor类里也有一个newInstance方法可以创建对象。我们可以通过这个newInstance方法调用有参数的和私有的构造函数。

4、使用clone方法 } → 没有调用构造函数

无论何时我们调用一个对象的clone方法，jvm就会创建一个新的对象，将前面对象的内容全部拷贝进去。用clone方法创建对象并不会调用任何构造函数。

要使用clone方法，我们需要先实现Cloneable接口并实现其定义的clone方法。

5、使用反序列化 } → 没有调用构造函数

当我们序列化和反序列化一个对象，jvm会给我们创建一个单独的对象。在反序列化时，jvm创建对象并不会调用任何构造函数。
为了反序列化一个对象，我们需要让我们的类实现Serializable接口

 

代码demo

package javatest.demo;

import java.io.Serializable;

public class PrintTest implements Cloneable, Serializable {

    public static final long serivalVersion = 1L;

    private String name;

    public PrintTest() {
        System.out.println("this is Constructor");
    }

    public void hello() {
        System.out.println("hello ");
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        PrintTest other = (PrintTest) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "PrintTest [name=" + name + "]";
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        return super.clone();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

package javatest.demo;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;

/**
 * 创建一个类的几种方法?
 * 
 * @author BrokenColor
 * @date 2018年6月7日
 */
public class InstanceDemo {

    public static void main(String[] args) {

        // 使用new关键字} → 调用了构造函数
        System.out.println("=================new关键字:");
        PrintTest printtest1 = new PrintTest();
        printtest1.setName("printtest1");
        System.out.println(printtest1 + ",hashcode:" + printtest1.hashCode());
        printtest1.hello();
        try {
            // 使用Class类的newInstance方法} → 调用了构造函数
            System.out.println("=========Class类的newInstance方法:");
            PrintTest printtest2 = (PrintTest) Class.forName("javatest.demo.PrintTest").newInstance();
            //或者可以
            // PringtTest pringttest2 = PringtTest.class.newInstance();
            printtest2.setName("printtest2");
            System.out.println(printtest2 + ",hashcode:" + printtest2.hashCode());
            printtest2.hello();

            // 使用Constructor类的newInstance方法 } → 调用了构造函数
            System.out.println("=======Constructor类的newInstance方法:");
            Constructor<PrintTest> constructor = PrintTest.class.getConstructor();
            PrintTest printTest3 = (PrintTest) constructor.newInstance();
            printTest3.setName("printTest3");
            System.out.println(printTest3 + ",hashcode:" + printTest3.hashCode());
            printTest3.hello();

            // 使用clone方法 } → 没有调用构造函数
            System.out.println("=======使用clone方法 } → 没有调用构造函数");
            PrintTest printTest4 = (PrintTest) printTest3.clone();
            printTest4.setName("printTest4");
            System.out.println(printTest4+",hashcode:"+printTest4.hashCode());
            
            //序列化
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("data.obj"));
            out.writeObject(printTest4);
            out.close();

            // 使用反序列化 } → 没有调用构造函数
            System.out.println("===========使用反序列化");
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj"));
            PrintTest printTest5 = (PrintTest) in.readObject();
            printTest5.setName("printTest5");
            System.out.println(printTest5+",hashcode:"+printTest5.hashCode());
            printTest5.hello();

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

运行结果：