java构造链模式 java构造类

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

1 package javatest.demo;
 2 
 3 import java.io.Serializable;
 4 
 5 public class PrintTest implements Cloneable, Serializable {
 6 
 7     public static final long serivalVersion = 1L;
 8 
 9     private String name;
10 
11     public PrintTest() {
12         System.out.println("this is Constructor");
13     }
14 
15     public void hello() {
16         System.out.println("hello ");
17     }
18 
19     @Override
20     public int hashCode() {
21         final int prime = 31;
22         int result = 1;
23         result = prime * result + ((name == null) ? 0 : name.hashCode());
24         return result;
25     }
26 
27     @Override
28     public boolean equals(Object obj) {
29         if (this == obj)
30             return true;
31         if (obj == null)
32             return false;
33         if (getClass() != obj.getClass())
34             return false;
35         PrintTest other = (PrintTest) obj;
36         if (name == null) {
37             if (other.name != null)
38                 return false;
39         } else if (!name.equals(other.name))
40             return false;
41         return true;
42     }
43 
44     @Override
45     public String toString() {
46         return "PrintTest [name=" + name + "]";
47     }
48 
49     @Override
50     protected Object clone() throws CloneNotSupportedException {
51         // TODO Auto-generated method stub
52         return super.clone();
53     }
54 
55     public String getName() {
56         return name;
57     }
58 
59     public void setName(String name) {
60         this.name = name;
61     }
62 
63 }

测试类

1 package javatest.demo;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileOutputStream;
 5 import java.io.ObjectInputStream;
 6 import java.io.ObjectOutputStream;
 7 import java.lang.reflect.Constructor;
 8 
 9 /**
10  * 创建一个类的几种方法?
11  * 
12  * @author BrokenColor
13  * @date 2018年6月7日
14  */
15 public class InstanceDemo {
16 
17     public static void main(String[] args) {
18 
19         // 使用new关键字} → 调用了构造函数
20         System.out.println("=================new关键字:");
21         PrintTest printtest1 = new PrintTest();
22         printtest1.setName("printtest1");
23         System.out.println(printtest1 + ",hashcode:" + printtest1.hashCode());
24         printtest1.hello();
25         try {
26             // 使用Class类的newInstance方法} → 调用了构造函数
27             System.out.println("=========Class类的newInstance方法:");
28             PrintTest printtest2 = (PrintTest) Class.forName("javatest.demo.PrintTest").newInstance();
29             //或者可以
30             // PringtTest pringttest2 = PringtTest.class.newInstance();
31             printtest2.setName("printtest2");
32             System.out.println(printtest2 + ",hashcode:" + printtest2.hashCode());
33             printtest2.hello();
34 
35             // 使用Constructor类的newInstance方法 } → 调用了构造函数
36             System.out.println("=======Constructor类的newInstance方法:");
37             Constructor<PrintTest> constructor = PrintTest.class.getConstructor();
38             PrintTest printTest3 = (PrintTest) constructor.newInstance();
39             printTest3.setName("printTest3");
40             System.out.println(printTest3 + ",hashcode:" + printTest3.hashCode());
41             printTest3.hello();
42 
43             // 使用clone方法 } → 没有调用构造函数
44             System.out.println("=======使用clone方法 } → 没有调用构造函数");
45             PrintTest printTest4 = (PrintTest) printTest3.clone();
46             printTest4.setName("printTest4");
47             System.out.println(printTest4+",hashcode:"+printTest4.hashCode());
48             
49             //序列化
50             ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("data.obj"));
51             out.writeObject(printTest4);
52             out.close();
53 
54             // 使用反序列化 } → 没有调用构造函数
55             System.out.println("===========使用反序列化");
56             ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj"));
57             PrintTest printTest5 = (PrintTest) in.readObject();
58             printTest5.setName("printTest5");
59             System.out.println(printTest5+",hashcode:"+printTest5.hashCode());
60             printTest5.hello();
61 
62         } catch (Exception e) {
63             // TODO Auto-generated catch block
64             e.printStackTrace();
65         }
66 
67     }
68 
69 }

运行类

运行结果：

 

仅做笔记，如有错误之处，望指出