Java中建立工具的5种方式

1.使用new关键字

package com.zmy.java.object;

public class Student{
    private String name;
    private Integer age;

    public Student() {
        System.out.println("无参组织方式!");
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
        System.out.println("有参组织方式!");
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    
    public static void mAIn(String[] args) {
        /* 方式一,通过new关键字建立工具 */
        Student student = new Student();
        student.setName("小明");
        student.setAge(15);
        System.out.println(student.toString());
        }
}

代码执行效果:

执行效果剖析:

通过new关键字建立工具时,会通过挪用该类的无参组织方式或有参组织方式来建立一个工具实例。

2.使用clone()方式

通过其他工具的clone()来天生新工具

package com.zmy.java.object;

/**
* 使用clone()方式,需要实现CloneABLe接口和重写Object类的clone()方式
*/
public class Student implements Cloneable{
    private String name;
    private Integer age;

    public Student() {
        System.out.println("无参组织方式!");
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
        System.out.println("有参组织方式!");
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }


    public static void main(String[] args) throws CloneNotSupportedException{
        Student student = new Student();
        student.setName("小明");
        student.setAge(15);        

       Student student2 = (Student) student.clone();
        System.out.println(student2);
        
        student2.setAge(14);
        student2.setName("小华");
        System.out.println(student2);
    }

}

代码执行效果

执行效果剖析:

使用clone()方式来建立工具B时,条件是已建立有工具A,然后通过挪用工具A的clone()方式来赋值给工具B,此时工具B中的成员变量值均与工具A中的成员变量值一样。

执行的顺序是:

  1. 先建立工具A,并给工具A的成员变量赋值;

  2. 挪用工具A的clone()方式,JVM会建立一个新工具B,并将工具A中的内容所有拷贝一份给工具B。

    注重:通过clone()建立工具时不会挪用任何组织方式。


3.使用Class类的newInstance()方式

package com.zmy.java.object;

public class Student{
    private String name;
    private Integer age;

    public Student() {
        System.out.println("无参组织方式!");
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
        System.out.println("有参组织方式!");
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiatIZ*ONException {
        Student student = (Student)Class.forName("com.zmy.java.object.Student").newInstance();
        student.setName("小明");
        student.setAge(15);
        System.out.println(student);



    }
}

代码执行效果

执行效果剖析:

通过Class.forName("该类的类路径").newInstance()来建立工具时,会挪用无参组织方式来建立一个工具。


4.使用Constructor的newInstance()方式

package com.zmy.java.object;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Student{
    private String name;
    private Integer age;

    private Student() {
        System.out.println("无参组织方式!");
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
        System.out.println("有参组织方式!");
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, CloneNotSupportedException, NoSuchMethodException, InvocationTargetException {

        Constructor constructor = Student.class.getDeclaredConstructor();
        Student student = (Student)constructor.newInstance();

        student.setName("小明");
        student.setAge(18);

        System.out.println(student);
    }
}

代码执行效果:

执行效果剖析:

通过Constructor的newInstance()方式来建立工具时,会通过挪用无参组织方式或有参组织方式来建立工具。

注重本代码实例中无参组织方式为private类型!!!

注重:类名.class.getDeclaredConstructor()和类名.class.getConstructor()的区别!!!

getDeclaredConstructor:返回指定参数类型、所有声明的(包罗private)组织函数

getConstructor**:返回指定参数类型、具有public接见权限的组织函数


5.使用反序列化

package com.zmy.java.object;

import java.io.*;

public class Student implements Serializable {
    private String name;
    private Integer age;

    public Student() {
        System.out.println("无参组织方式!");
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
        System.out.println("有参组织方式!");
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        Student student = new Student("小明",18);

        System.out.println("java序列化最先");
        // 文件输出流
        FileOutputStream fos = new FileOutputStream("E:\\IdeaProjects\\project01\\src\\com\\zmy\\java\\object\\Student.ser");
        // 工具输出流
        ObjectOutputStream oos = new ObjectOutputStream(fos);

        oos.writeObject(student);
        oos.close();
        fos.close();

        System.out.println("-----------------------------------------------------");

        System.out.println("java反序列化最先");
        // 文件输入流
        FileInputStream fis = new FileInputStream("E:\\IdeaProjects\\project01\\src\\com\\zmy\\java\\object\\Student.ser");
        // 工具输入流
        ObjectInputStream ois = new ObjectInputStream(fis);
        Student student1 = (Student) ois.readObject();
        System.out.println(student1);

    }
}
代码执行效果剖析:

执行效果剖析:

Student类实现了Serializable接口后才可以被序列化!编译器先将代码序列化到文件中,java默认序列化后的文件后缀为.ser。然后,反序列化操作后获得Student工具。

反序列化时并不会挪用Student类的无参或有参组织方式!

   若是不想实例化工具的某个成员变量,可以在成员变量前使用transient关键字!则该字段不会被序列化!

示例:

        public class Student implements Serializable {
        private String name;
        private transient Integer age;

    对于 JVM 可以反序列化工具,它必须是能够找到字节码的类。若是JVM在反序列化工具的过程中找不到该类,则抛出一个 ClassNotFoundException 异常。

   注重,readObject() 方式的返回值被转化成 Student引用。