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

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

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

1. public class Example {
2.     private String message;
4.     public Example(String message) {
5.         this.message = message;
6.     }
8.     public String getMessage() {
9.         return message;
10.     }
12.     public static void main(String[] args) {
13.         Example example = new Example("Hello, World!");
14.         System.out.println(example.getMessage());
15.     }
16. }

复制代码

2. 利用反射机制

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

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

缺点

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

利用场景
        ORM框架，SpringMVC利用@RequestBody这类的注解等等
示例

1. import java.lang.reflect.Constructor;
2. import java.lang.reflect.Field;
3. import java.lang.reflect.Method;
5. public class ReflectionExample {
6.     private String message;
8.     public ReflectionExample(String message) {
9.         this.message = message;
10.     }
12.     public String getMessage() {
13.         return message;
14.     }
16.     public static void main(String[] args) {
17.         try {
18.             Class<?> clazz = Class.forName("ReflectionExample");
20.             Constructor<?> constructor = clazz.getConstructor(String.class);
21.             Object instance = constructor.newInstance("Hello, Reflection!");
23.             Method getMessageMethod = clazz.getMethod("getMessage");
24.             String message = (String) getMessageMethod.invoke(instance);
25.             System.out.println("Message: " + message);
27.             Field messageField = clazz.getDeclaredField("message");
28.             messageField.setAccessible(true);
29.             messageField.set(instance, "New Message via Reflection");
30.             System.out.println("Updated Message: " + getMessageMethod.invoke(instance));
31.         } catch (Exception e) {
32.             e.printStackTrace();
33.         }
34.     }
35. }

复制代码

3. 利用 clone() 方法

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

1. public class Example implements Cloneable {
2.     private String message;
4.     public Example(String message) {
5.         this.message = message;
6.     }
8.     public String getMessage() {
9.         return message;
10.     }
12.     @Override
13.     protected Object clone() throws CloneNotSupportedException {
14.         return super.clone();
15.     }
17.     public static void main(String[] args) {
18.         try {
19.             Example original = new Example("Hello, World!");
20.             Example clone = (Example) original.clone();
21.             System.out.println(clone.getMessage());
22.         } catch (CloneNotSupportedException e) {
23.             e.printStackTrace();
24.         }
25.     }
26. }

复制代码

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

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

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

缺点

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

利用场景

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

示例、

1. import java.io.*;
3. public class SerializationExample implements Serializable {
4.     private static final long serialVersionUID = 1L;
5.     private String message;
7.     public SerializationExample(String message) {
8.         this.message = message;
9.     }
11.     public String getMessage() {
12.         return message;
13.     }
15.     public static void main(String[] args) {
16.         SerializationExample original = new SerializationExample("Hello, Serialization!");
18.         // 序列化
19.         try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.dat"))) {
20.             oos.writeObject(original);
21.         } catch (IOException e) {
22.             e.printStackTrace();
23.         }
25.         // 反序列化
26.         try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.dat"))) {
27.             SerializationExample deserialized = (SerializationExample) ois.readObject();
28.             System.out.println("Deserialized Message: " + deserialized.getMessage());
29.         } catch (IOException | ClassNotFoundException e) {
30.             e.printStackTrace();
31.         }
32.     }
33. }

复制代码

 4.1利用 JSON 反序列化

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

1. import com.fasterxml.jackson.databind.ObjectMapper;
2. import java.io.IOException;
4. public class User {
5.     private String name;
6.     private int age;
7.     private String email;
9.     // Getters and Setters
11.     public static void main(String[] args) {
12.         String jsonString = "{"name":"John","age":30,"email":"john@example.com"}";
14.         ObjectMapper objectMapper = new ObjectMapper();
15.         try {
16.             User user = objectMapper.readValue(jsonString, User.class);
17.             System.out.println("Name: " + user.getName());
18.             System.out.println("Age: " + user.getAge());
19.             System.out.println("Email: " + user.getEmail());
20.         } catch (IOException e) {
21.             e.printStackTrace();
22.         }
23.     }
25.     public String getName() {
26.         return name;
27.     }
29.     public void setName(String name) {
30.         this.name = name;
31.     }
33.     public int getAge() {
34.         return age;
35.     }
37.     public void setAge(int age) {
38.         this.age = age;
39.     }
41.     public String getEmail() {
42.         return email;
43.     }
45.     public void setEmail(String email) {
46.         this.email = email;
47.     }
48. }

复制代码

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

点个关注再走吧！！！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。