Java创建对象的6种方式（java什么是面向对象）

Java中关于创建对象是大家经常要用的动作，那么大家对Java都可以通过什么形式创建对象呢？我总结了一下，分享给大家。

第一种：通过new关键字进行创建

//通过显式的方式，直接在JVM堆内存声明了一个对象
Object o = new Object();

第二种：通过Java工具类种反射机制进行创建

try {
  ObjectDemo o = (ObjectDemo) Class.forName("lang.ObjectDemo").newInstance();
} catch (InstantiationException e) {
  e.printStackTrace();
} catch (IllegalAccessException e) {
  e.printStackTrace();
} catch (ClassNotFoundException e) {
  e.printStackTrace();
}

第三种：通过克隆方式创建

//Object  没有clone方法，自定义的类需要继承Cloneable 接口才可以进行克隆
public class ObjectDemo implements Cloneable {

    public static void main(String[] args) {

        ObjectDemo o1 = new ObjectDemo();
        try {
            ObjectDemo o2 = (ObjectDemo) o1.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

第四种：通过反序列化来创建对象

//要进行序列化的对象，需要实现Serializable接口
public class ObjectDemo implements Serializable{
    
    public static void main(String[] args) IOException {

        System.out.println("序列化。。。。。");
        ObjectDemo users = new ObjectDemo();
        FileOutputStream fs = new FileOutputStream("ObjectDemo.ser");
        ObjectOutputStream os = new ObjectOutputStream(fs);
        os.writeObject(users);
        os.close();
        fs.close();
        System.out.println("反序列化。。。。。");
        FileInputStream fileInputStream = new FileInputStream("ObjectDemo.ser");
        ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
        ObjectDemo o = (ObjectDemo)objectInputStream.readObject();
        System.out.println(o);
        fileInputStream.close();
        objectInputStream.close();
    }
}

第五种：利用Unsafe类来进行创建

//通过反射获取UnSafe获取方法
Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
//访问方法权限
theUnsafe.setAccessible(true);
//返回UnSafe对象
Unsafe unsafe = (Unsafe) theUnsafe.get(null);
//创建对象
ObjectDemo a = (ObjectDemo) unsafe.allocateInstance(ObjectDemo.class);

第六种：利用接口Supplier来创建

//在JDK工具包中，有个接口Supplier，利用它可以实现创建对象。

源码：

@FunctionalInterface
public interface Supplier<T> {
//获取泛型对象
T get();
}


例子：

public class SupplierDemo {
//构造函数
SupplierDemo(){
System.out.println("我被创建了");
}
public static void main(String[] args) {
//创建Supplier容器，声明为SupplierDemo类型，
//此时并不会调用对象的构造方法，即不会创建对象
Supplier<SupplierDemo> sup= SupplierDemo::new; //没有任何输出
System.out.println("----虽然貌似已经new了，还没有具体调用构造器方法，说明没有创建对象----");
//调用get()方法，此时会调用对象的构造方法，即获得到真正对象
sup.get(); // 我被创建了
//每次get都会调用构造方法，即获取的对象不同
sup.get(); // 我被创建了
}
}


输出：

----虽然貌似已经new了，还没有具体调用构造器方法，说明没有创建对象----
我被创建了
我被创建了