面试Tip--java创建对象的四种方式

       java创建对象一共有四种方式，但是我们在写代码的时候用的new 关键字偏多，像一些接口对接则是序列化创建对象偏多，今天我们来简单介绍下使用场景以及各个方式

1. 使用 new 关键字

        这是最常见的创建对象的方式。

public class Example {
    private String message;
 
    public Example(String message) {
        this.message = message;
    }
 
    public String getMessage() {
        return message;
    }
 
    public static void main(String[] args) {
        Example example = new Example("Hello, World!");
        System.out.println(example.getMessage());
    }
}

2. 使用反射机制

        反射机制允许在运行时动态地创建对象、调用方法和访问字段。它通常用于框架和库中，提供高度的灵活性。

优点

• 动态性：可以在运行时加载和使用类，而无需在编译时知道具体的类。
• 灵活性：可以动态调用类的方法和访问字段。

缺点

• 性能开销：反射操作通常比直接调用慢。
• 安全性：可能破坏封装性，访问私有字段和方法可能带来安全隐患。

使用场景

        ORM框架，SpringMVC使用@RequestBody这类的注解等等

示例

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
 
public class ReflectionExample {
    private String message;
 
    public ReflectionExample(String message) {
        this.message = message;
    }
 
    public String getMessage() {
        return message;
    }
 
    public static void main(String[] args) {
        try {
            Class clazz = Class.forName("ReflectionExample");
 
            Constructor constructor = clazz.getConstructor(String.class);
            Object instance = constructor.newInstance("Hello, Reflection!");
 
            Method getMessageMethod = clazz.getMethod("getMessage");
            String message = (String) getMessageMethod.invoke(instance);
            System.out.println("Message: " + message);
 
            Field messageField = clazz.getDeclaredField("message");
            messageField.setAccessible(true);
            messageField.set(instance, "New Message via Reflection");
            System.out.println("Updated Message: " + getMessageMethod.invoke(instance));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3. 使用 clone() 方法

通过 clone() 方法可以创建一个对象的副本。需要实现 Cloneable 接口并重写 clone() 方法。

public class Example implements Cloneable {
    private String message;
 
    public Example(String message) {
        this.message = message;
    }
 
    public String getMessage() {
        return message;
    }
 
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
 
    public static void main(String[] args) {
        try {
            Example original = new Example("Hello, World!");
            Example clone = (Example) original.clone();
            System.out.println(clone.getMessage());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

4. 使用序列化与反序列化

        通过将对象序列化为字节流，然后再从字节流中反序列化，可以创建对象。这通常用于对象的持久化和传输。

优点

• 持久化：可以将对象的状态保存到文件或数据库中。
• 传输：支持在网络上传输对象。
• 深度复制：通过序列化和反序列化可以实现对象的深度复制。

缺点

• 性能开销：序列化和反序列化过程可能比较耗时。
• 安全性：反序列化不可信数据可能带来安全风险。

使用场景

• 调用接口：我们开发的时候调用第三方接口，从三方接口获取的比如body的返回值，获取到的是String类型的，要不就是我们一层一层拨数据，要不就是反序列化对象
• 数据库对象存储： 假设我们有一条订单表，这是假设，哥们不是做电商行业的。这张表有一个订单状态，那么我们就可以有一个长字段用来存储他的关系，而不是挂一张外表进行了。这里只是举例

示例、

import java.io.*;
 
public class SerializationExample implements Serializable {
    private static final long serialVersionUID = 1L;
    private String message;
 
    public SerializationExample(String message) {
        this.message = message;
    }
 
    public String getMessage() {
        return message;
    }
 
    public static void main(String[] args) {
        SerializationExample original = new SerializationExample("Hello, Serialization!");
 
        // 序列化
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.dat"))) {
            oos.writeObject(original);
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        // 反序列化
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.dat"))) {
            SerializationExample deserialized = (SerializationExample) ois.readObject();
            System.out.println("Deserialized Message: " + deserialized.getMessage());
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

 4.1使用 JSON 反序列化

通过 JSON 反序列化，可以将 JSON 数据转换为 Java 对象，常用的库有 Jackson 和 Gson。

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
 
public class User {
    private String name;
    private int age;
    private String email;
 
    // Getters and Setters
 
    public static void main(String[] args) {
        String jsonString = "{\"name\":\"John\",\"age\":30,\"email\":\"john@example.com\"}";
 
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            User user = objectMapper.readValue(jsonString, User.class);
            System.out.println("Name: " + user.getName());
            System.out.println("Age: " + user.getAge());
            System.out.println("Email: " + user.getEmail());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getEmail() {
        return email;
    }
 
    public void setEmail(String email) {
        this.email = email;
    }
}

·通过上面的例子，这样我们在创建对象的时候就会更加清晰了

点个关注再走吧！！！