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();
         }

     }

 }

运行类

运行结果：