JVM 四种创建对象

new关键字

Book a = new Book();

反射

  Class<? extends Book> c = (Class<? extends Book>) Class.forName("com.wnhz.clong.entity.Book");
//        System.out.println("Book类的class对象3："+c);
        Book a = c.newInstance();

克隆（clong）

 Book a = new Book();
 Book b = (Book) a.clone();

克隆分为浅拷贝和深拷贝：

浅拷贝：

浅拷贝只复制某个对象的引用，而不复制对象本身，新旧对象还是共享同一块内存

深拷贝：

深拷贝会创造一个一摸一样的对象，新对象和原对象不共享内存，修改新对象不会改变原对对象

 浅拷贝与深拷贝的测试代码

package com.wnhz.clong.entity;

public class Book implements Cloneable{
    private String name;
    private Author author;
    private Double price;

    static {
        System.out.println("asfnbiwbfqkn");
    }

    public Book() {
    }

    public Book(String name, Author author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    /**
     * 浅拷贝
     * 在拷贝一个对象时，对对象的基本数据类型的成员变量进行拷贝，
     * 但对引用类型的成员变量只进行引用的传递，并没有创建一个新的对象，
     * 当对引用类型的内容修改会影响被拷贝的对象。
     * @return
     */
/*    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }*/

    /**
     * 深拷贝
     * 深拷贝是一个整个独立的对象拷贝，深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。
     * 当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。
     * @return
     */
    @Override
    public Book clone() throws CloneNotSupportedException {
        Book c = new Book();
        Author au = new Author();
        au.setName(author.getName());
        c.setAuthor(au);
        c.setPrice(this.price);
        c.setName(this.name);
        return c;
    }



    public String getName() {
        return name;
    }

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

    public Author getAuthor() {
        return author;
    }

    public void setAuthor(Author author) {
        this.author = author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author=" + author +
                ", price=" + price +
                '}';
    }
}

package com.wnhz.clong.test;

import com.wnhz.clong.entity.Author;
import com.wnhz.clong.entity.Book;

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Book a = new Book();
        Author au = new Author();
        au.setName("qwqrqwd");

        a.setName("aaa");
        a.setAuthor(au);
        a.setPrice(12.12);

        Book b = (Book) a.clone();

        au.setName("aaaaaaaaaaaaaaaa");
        a.setAuthor(au);

        System.out.println("a="+a);
        System.out.println("b="+b);
        System.out.println(a==b);

    }
}

序列化反序列化

Java 中常常进行 JSON 数据跟 Java 对象之间的转换，即序列化和反序列化。
当我们序列化和反序列化一个对象，JVM会给我们创建一个单独的对象，在反序列化时，JVM创建对象并不会调用任何构造函数。为了反序列化一个对象，我们需要让我们的类实现Serializable接口，虽然该接口没有任何方法。
 

ObjectInputStream in = new ObjectInputStream (new FileInputStream("data.obj")); 
Student stu3 = (Student)in.readObject();