写博客即是为了记录自己的学习历程，也希望能够遇到志同道合的朋友一起学习。文章在撰写过程中难免有疏漏和错误，欢迎指出文章的不足之处；更多内容请点进👉爱敲代码的小游子👈查看。
 临渊羡鱼，不如退而结网。一起加油！
 
 
1、用new关键字创建对象，需要使用构造器。
 
  //1、使用关键字new创建对象（没有参数调用无参构造、传入参数调用带参构造）
  Girlfriend girlfriend01 = new Girlfriend();
  Girlfriend girlfriend02 = new Girlfriend("y", 18);

 
new 一个对象经过了哪些过程？
 
2、使用反射机制创建对象，用Class类或Constructor类的newInstance()方法。
 
 
 
当使用Class类里的newInstance()方法，调用的是无参构造方法。
 
 
当使用java.lang.reflect.Constructor类里的newInstance方法，调用的是有参构造方法。
 
 
1、Class类里的newInstance()
 
 
 
调用的是无参构造方法
 
 
 
2、Constructor类的newInstance()方法
 
 
 
调用的是有参构造方法
 
 
 
3、通过object类的clone方法
 
需要实现Cloneable接口，重写object类的clone方法。无论何时我们调用一个对象的clone方法，JVM就会创建一个新的对象，将前面对象的内容全部拷贝进去。用clone方法创建对象并不会调用任何构造函数。
 
 
4、使用反序列化
 
通过ObjectInputStream的readObject()方法反序列化类当我们序列化和反序列化一个对象，JVM会给我们创建一个单独的对象。为了反序列化一个对象，我们需要让我们的类实现Serializable接口。在反序列化时，JVM创建对象并不会调用任何构造函数。
 
 
通过反序列化生成对象的过程主要由以下几个步骤：
 
1、创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
 
2、 通过对象输入流的readObject()方法读取对象。
 
 
 
序列化工具类
 
public class ObjectUtils {

    public static <T extends Serializable> T clone(Girlfriend obj) {
        T cloneObj = null;
        try {
            //写入字节流
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            ObjectOutputStream obs = new ObjectOutputStream(out);
            obs.writeObject(obj);
            obs.close();

            //分配内存，写入原始对象，生成新对象
            ByteArrayInputStream bis = new ByteArrayInputStream(out.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            //返回新生成的对象
            cloneObj = (T) ois.readObject();

            bis.close();
            out.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return cloneObj;
    }

}
 
创建对象各方法的代码
 
 public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, CloneNotSupportedException {
        //1、使用关键字new创建对象（没有参数调用无参构造、传入参数调用带参构造）
        Girlfriend girlfriend01 = new Girlfriend();
        Girlfriend girlfriend02 = new Girlfriend("y", 18);

        //2、使用反射机制创建对象，使用Class的newInstance()调用默认的无参构造
        Girlfriend girlfriend03 = Girlfriend.class.newInstance();

        //反射机制2，调用带参
        Class<?> p1 = Class.forName("com.yky.Girlfriend");
        Constructor<?> constructor = p1.getConstructor(String.class, Integer.class);
        Girlfriend girlfriend04 = (Girlfriend) constructor.newInstance("k", 18);
        System.out.println(girlfriend04);

        //3、使用object类的clone方法
        Girlfriend girlfriendClone = (Girlfriend) girlfriend04.clone();
        System.out.println("girlfriendClone="+girlfriendClone);

        //4、使用序列化反序列化生成对象
        Girlfriend clone = ObjectUtils.clone(girlfriend04);
        System.out.println("clone"+clone);
        System.out.println("girlfriend04和反序列化生成的clone相等吗");
        System.out.println(clone == girlfriend04);
    }

对象是对类的实例化。对象具有状态和行为，变量用来表明对象的状态，方法表明对象所具有的行为。Java 对象的生命周期包括创建、使用和清除，本文详细介绍对象的创建，在 Java 语言中创建对象分显式创建与隐含创建两种情况。
 
显式创建对象
 
对象的显式创建方式有 4 种。
 
1. 使用 new 关键字创建对象
 这是常用的创建对象的方法，语法格式如下：
 类名 对象名=new 类名()；
 
2. 调用 java.lang.Class 或者 java.lang.reflect.Constuctor 类的 newlnstance() 实例方法
 在 Java 中，可以使用 java.lang.Class 或者 java.lang.reflect.Constuctor 类的 newlnstance() 实例方法来创建对象，代码格式如下：
 java.lang.Class Class 类对象名称=java.lang.Class.forName(要实例化的类全称);
 类名 对象名=(类名)Class类对象名称.newInstance();
 
调用 java.lang.Class 类中的 forName() 方法时，需要将要实例化的类的全称（比如 com.mxl.package.Student）作为参数传递过去，然后再调用 java.lang.Class 类对象的 newInstance() 方法创建对象。
 
3. 调用对象的 clone() 方法
 该方法不常用，使用该方法创建对象时，要实例化的类必须继承 java.lang.Cloneable 接口。 调用对象的 clone() 方法创建对象的语法格式如下：
 类名对象名=(类名)已创建好的类对象名.clone();
 
4. 调用 java.io.ObjectlnputStream 对象的 readObject() 方法
 
下面创建一个示例演示常用的前三种对象创建方法。示例代码如下：
 
public class Student implements Cloneable
{   
    //实现 Cloneable 接口
    private String Name;    //学生名字
    private int age;    //学生年龄
    public Student(String name,int age)
    {    //构造方法
        this.Name=name;
        this.age=age;
    }
    public Student()
    {
        this.Name="name";
        this.age=0;
    }
    public String toString()
    {
        return"学生名字："+Name+"，年龄："+age;
    }
    public static void main(String[] args)throws Exception
    {
        System.out.println("---------使用 new 关键字创建对象---------");
       
        //使用new关键字创建对象
        Student student1=new Student("小刘",22);
        System.out.println(student1);
        System.out.println("-----------调用 java.lang.Class 的 newInstance() 方法创建对象-----------");
       
        //调用 java.lang.Class 的 newInstance() 方法创建对象
        Class cl=Class.forName("Student");
        Student student2=(Student)cl.newInstance();
        System.out.println(student2);
        System.out.println("-------------------调用对象的 clone() 方法创建对象----------");
        //调用对象的 clone() 方法创建对象
        Student student3=(Student)student2.clone();
        System.out.println(student3);
    }
}

 
对上述示例的说明如下：
 
使用 new 关键字或 Class 对象的 newInstance() 方法创建对象时，都会调用类的掏造方法。
 使用 Class 类的 newInstance() 方法创建对象时，会调用类的默认构造方法，即无参构造方法。
 使用 Object 类的 clone() 方法创建对象时，不会调用类的构造方法，它会创建一个复制的对象，这个对象和原来的对象具有不同的内存地址，但它们的属性值相同。
 如果类没有实现 Cloneable 接口，则 clone。方法会抛出 java.lang.CloneNotSupportedException 异常，所以应该让类实现 Cloneable 接口。
 
程序执行结果如下：
 
---------使用 new 关键字创建对象---------
学生名字：小刘，年龄：22
-----------调用 java.lang.Class 的 newInstance() 方法创建对象-----------
学生名字：name，年龄：0
-------------------调用对象的done()方法创建对象----------
学生名字：name，年龄：0
 
隐含创建对象
 
除了显式创建对象以外，在 Java 程序中还可以隐含地创建对象，例如下面几种情况。
 ①String strName=“strValue”，其中的“strValue”就是一个 String 对象，由 Java 虚拟机隐含地创建。
 ②字符串的“+”运算符运算的结果为一个新的 String 对象，示例如下：
 String str1=“Hello”;
 String str2=“Java”;
 String str3=str1+str2; //str3引用一个新的String对象
 ③当 Java 虚拟机加载一个类时，会隐含地创建描述这个类的 Class 实例。
 
**提示：**类的加载是指把类的 .class 文件中的二进制数据读入内存中，把它存放在运行时数据区的方法区内，然后在堆区创建一个 java.lang.Class 对象，用来封装类在方法区内的数据结构。
 
无论釆用哪种方式创建对象，Java 虚拟机在创建一个对象时都包含以下步骤：
 
给对象分配内存。
将对象的实例变量自动初始化为其变量类型的默认值。
初始化对象，给实例变量赋予正确的初始值。
 
注意： 每个对象都是相互独立的，在内存中占有独立的内存地址，并且每个对象都具有自己的生命周期，当一个对象的生命周期结束时，对象就变成了垃圾，由 Java 虚拟机自带的垃圾回收机制处理。

转自百度知道：
 
用简单工厂来创建对象和用new创建对象相比好处有哪些？
 
 

 
 
 
我不知道你认真研究过设计模式没有?
之所以要使用模式思想,是因为要遵循开闭原则,开闭原则就是对修改关闭对扩展开放.开闭原则有五种实现途径,我只提跟你问题相关的一种.也就是开闭原则中比较重要的一条原则:依赖倒转原则,什么是依赖,如果不是很明白你可以先研究一下面向对象之间的几种耦合关系.所谓依赖倒转原则就是,依赖于抽象而不依赖于实现.为什么要依赖于抽象而不依赖于实现,很简单的问题,但要解释我又要引入其他两种开闭原则的实现途径,一、迪米特法则 大意是：将可变性的耦合效应或者说传导效应降到最低，二、里氏代换原则，大意是父类出现的地方子类可以取而代之。依赖于抽象时我们可以很容易的对系统进行扩展，只要是继承自相关接口或者抽象类的新业务，都可以很顺利的插入到系统中去，且对客户端没有任何影响，这就是里氏代换。如果我们依赖抽象，我们就可以减少实现类中可变性的传导问题，不至于动一处而动全身，这就使迪米特法则。
好，下面开始正面回答你的问题，new关键字其实是违反依赖倒转原则的一种设计，如果你用new，那么你只能new 具体类型，这样一来就是抽象依赖于实现，显然不符合开闭原则。为了最大限度的遵循开闭原则，我们就要采用各种设计模式去将这种不正确的依赖方向封装起来，只给外界提供正确的依赖方向。
 

 

最近看到一个java面试题是：创建对象的方式有几种
 
很多同学看到这道题第一想法肯定是new出来。其实除了new对象的方式以外还有很多种下面我们来看看。
 
一、new Obj..()
 
这种方式应该是很多人最经常使用的不过在框架当中很多对象都已经使用依赖注入的方式交给框架容器管理。使用注解的形式直接使用。但是项目当中自己主动new Obj()的情况还是很常见。这种方式其实是调用了对象中的构造函数来创建对象。
 
二、clone（）
 
使用Object类的clone方法。这个方法可以克隆出一个完全一样的对象。这个方法没有调用构造方法。
 
三、反射
 
1）通过类的全限定名来创建对象
 
Class.forName("xxx.xxx.Obj..").newInstance()
 
2）通过构造器来创建对象
 
Construtor<Obj..> contructor = Obj..class.getConstructor();
 
Obj...    o = contructor.newInstance();
 
其实通过类对象来创建对象底层也是通过构造器来创建对象。所以在框架中通常使用2）方式创建对象
 
四、通过反序列化来创建对象
 
这种方式创建的对象必须实现Serializable接口
 
ObjectInputStream Obji = new ObjectInputStream(new FileInputStream("Object1.txt"));
 
Obj..t =(Obj.) Obji.readObject();