java四种创建对象方式new、clone、instance、serializable

最新推荐文章于 2023-01-08 18:58:42 发布

hanjq_code

最新推荐文章于 2023-01-08 18:58:42 发布

阅读量1k

点赞数 2

分类专栏： java 文章标签： java

原文链接：https://www.cnblogs.com/yunche/p/9530927.html

版权

java 专栏收录该内容

35 篇文章 3 订阅

订阅专栏

本文详细介绍了Java中四种不同的对象创建方式：1) 使用`new`关键字，但应注意减少耦合；2) 通过反射的`Class.newInstance()`和`Constructor.newInstance()`方法创建对象；3) 实现`Cloneable`接口进行克隆；4) 利用序列化和反序列化创建对象。每种方式都有其适用场景和注意事项。

摘要由CSDN通过智能技术生成

1.使用new创建对象

　　使用new关键字创建对象应该是最常见的一种方式，但我们应该知道，使用new创建对象会增加耦合度。无论使用什么框架，都要减少new的使用以降低耦合度。

package yunche.test;

/**
 * @ClassName: Hello
 * @Description: 待创建的类
 * @author: yunche
 * @date: 2018/08/24
 */
public class Hello
{
    public void sayWorld()
    {
        System.out.println("Hello world!");
    }

}
package yunche.test;

/**
 * @ClassName: NewClass
 * @Description: 使用new关键字创建对象
 * @author: yunche
 * @date: 2018/08/24
 */
public class NewClass
{
    public static void main(String[] args)
    {
        Hello h = new Hello();
        h.sayWorld();
    }
}

2.使用反射的机制创建对象

使用Class类的newInstance方法

　　Hello类的代码不变，NewClass类的代码如下：

package yunche.test;

/**
 * @ClassName: NewClass
 * @Description: 使用Class类的newInstance方法
 * @author: yunche
 * @date: 2018/08/24
 */
public class NewClass
{
    public static void main(String[] args)
    {
        try
        {
           Class heroClass = Class.forName("yunche.test.Hello");
           Hello h =(Hello) heroClass.newInstance();
           h.sayWorld();
        }
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }
        catch (IllegalAccessException e)
        {
            e.printStackTrace();
        }
        catch (InstantiationException e)
        {
            e.printStackTrace();
        }

    }
}

使用Constructor类的newInstance方法

package yunche.test;

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

/**
 * @ClassName: NewClass
 * @Description: 使用Constructor类的newInstance方法
 * @author: yunche
 * @date: 2018/08/24
 */
public class NewClass
{
    public static void main(String[] args)
    {
        try
        {
            //获取类对象
           Class heroClass = Class.forName("yunche.test.Hello");

           //获取构造器
           Constructor constructor = heroClass.getConstructor();
           Hello h =(Hello) constructor.newInstance();
           h.sayWorld();
        }
        catch (NoSuchMethodException e)
        {
            e.printStackTrace();
        }
        catch (InvocationTargetException e)
        {
            e.printStackTrace();
        }
        catch (IllegalAccessException e)
        {
            e.printStackTrace();
        }
        catch (InstantiationException e)
        {
            e.printStackTrace();
        }
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }

    }
}

3.采用clone

　　clone时，需要已经有一个分配了内存的源对象，创建新对象时，首先应该分配一个和源对象一样大的内存空间。

　　要调用clone方法需要实现Cloneable接口，由于clone方法是protected的，所以修改Hello类。

package yunche.test;

/**
 * @ClassName: Hello
 * @Description: 待创建的类
 * @author: yunche
 * @date: 2018/08/24
 */
public class Hello implements Cloneable
{
    public void sayWorld()
    {
        System.out.println("Hello world!");

    }

    public static void main(String[] args)
    {
        Hello h1 = new Hello();
        try
        {
            Hello h2 = (Hello)h1.clone();
            h2.sayWorld();
        }
        catch (CloneNotSupportedException e)
        {
            e.printStackTrace();
        }
    }
}

4.采用序列化机制

　　使用序列化时，要实现实现Serializable接口，将一个对象序列化到磁盘上，而采用反序列化可以将磁盘上的对象信息转化到内存中。

package yunche.test;

import java.io.*;

/**
 * @ClassName: Serialize
 * @Description: 序列化与反序列化对象
 * @author: yunche
 * @date: 2018/08/24
 */
public class Serialize
{
    public static void main(String[] args)
    {
        Hello h = new Hello();

        //准备一个文件用于存储该对象的信息
        File f = new File("hello.obj");

        try(FileOutputStream fos = new FileOutputStream(f);
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            FileInputStream fis = new FileInputStream(f);
            ObjectInputStream ois = new ObjectInputStream(fis)
            )
        {
            //序列化对象，写入到磁盘中
            oos.writeObject(h);
            //反序列化对象
            Hello newHello = (Hello)ois.readObject();

            //测试方法
            newHello.sayWorld();
        }
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }
    }
}