public class MyClass {  
    private String hiddenField;  
  
    public String getHiddenField() {  
        return hiddenField;  
    }  
  
    public void setHiddenField(String hiddenField) {  
        this.hiddenField = hiddenField;  
    }  
}  
  
// 使用  
MyClass obj = new MyClass();  
obj.setHiddenField("Hello");  
System.out.println(obj.getHiddenField()); // 輸出: Hello

import java.lang.reflect.Field;  
  
public class Main {  
    public static void main(String[] args) throws Exception {  
        MyClass obj = new MyClass();  
  
        // 獲取MyClass類的Class對(duì)象  
        Class<?> clazz = obj.getClass();  
  
        // 使用getDeclaredField方法獲取名為"hiddenField"的字段（私有）  
        Field hiddenField = clazz.getDeclaredField("hiddenField");  
  
        // 設(shè)置為可訪問，以便我們可以訪問私有字段  
        hiddenField.setAccessible(true);  
  
        // 使用set方法設(shè)置字段的值  
        hiddenField.set(obj, "Hello from Reflection");  
  
        // 使用get方法獲取字段的值  
        String value = (String) hiddenField.get(obj);  
        System.out.println(value); // 輸出: Hello from Reflection  
    }  
}  
  
class MyClass {  
    private String hiddenField;  
}

// 父類  
class ParentClass {  
    // 受保護(hù)的字段，子類可以訪問  
    protected String protectedField = "This is a protected field.";  
      
    // 默認(rèn)訪問級(jí)別的字段（包級(jí)私有），同一包下的子類可以訪問  
    String defaultField = "This is a default (package-private) field.";  
      
    // 私有的字段，子類不能直接訪問  
    private String privateField = "This is a private field.";  
      
    // 公共的getter和setter方法用于訪問和修改私有字段  
    public String getPrivateField() {  
        return privateField;  
    }  
      
    public void setPrivateField(String privateField) {  
        this.privateField = privateField;  
    }  
}  
  
// 子類，與父類在同一包中  
class ChildClass extends ParentClass {  
    // 子類可以直接訪問受保護(hù)的字段  
    public void printProtectedField() {  
        System.out.println("Protected Field: " + protectedField);  
    }  
      
    // 因?yàn)樽宇惻c父類在同一包中，所以子類也可以訪問默認(rèn)訪問級(jí)別的字段  
    public void printDefaultField() {  
        System.out.println("Default Field: " + defaultField);  
    }  
      
    // 子類不能直接訪問私有字段，但可以通過繼承的getter和setter方法訪問和修改  
    public void printAndChangePrivateField() {  
        System.out.println("Private Field: " + getPrivateField());  
        setPrivateField("Private field has been changed.");  
        System.out.println("Changed Private Field: " + getPrivateField());  
    }  
}  
  
// 主類，用于測(cè)試  
public class Main {  
    public static void main(String[] args) {  
        ChildClass child = new ChildClass();  
        child.printProtectedField(); // 輸出：Protected Field: This is a protected field.  
        child.printDefaultField(); // 輸出：Default Field: This is a default (package-private) field.  
        child.printAndChangePrivateField(); // 輸出私有字段的值，然后改變它  
    }  
}

import java.io.*;  
  
// 實(shí)現(xiàn)了Serializable接口的類  
class MyClass implements Serializable {  
    private String privateField = "This is a private field.";  
  
    // 為了簡(jiǎn)化示例，沒有g(shù)etter和setter方法  
  
    // 這是一個(gè)序列化時(shí)會(huì)被調(diào)用的方法（如果有的話）  
    private void writeObject(ObjectOutputStream out) throws IOException {  
        // 通常這里會(huì)寫出對(duì)象的所有狀態(tài)，包括私有字段  
        // 但為了示例，我們假設(shè)這里什么都不做  
    }  
  
    // 這是一個(gè)反序列化時(shí)會(huì)被調(diào)用的方法（如果有的話）  
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {  
        // 通常這里會(huì)讀取流中的狀態(tài)來恢復(fù)對(duì)象  
        // 但為了示例，我們假設(shè)這里什么都不做  
    }  
}  
  
public class SerializationExample {  
  
    public static void main(String[] args) throws IOException, ClassNotFoundException {  
        // 創(chuàng)建一個(gè)對(duì)象  
        MyClass originalObject = new MyClass();  
  
        // 序列化對(duì)象到字節(jié)數(shù)組  
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();  
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);  
        objectOutputStream.writeObject(originalObject);  
  
        // 反序列化字節(jié)數(shù)組到對(duì)象  
        byte[] serializedData = byteArrayOutputStream.toByteArray();  
        ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(serializedData));  
        MyClass deserializedObject = (MyClass) objectInputStream.readObject();  
  
        // 注意：這里不能直接獲取私有字段的值，因?yàn)镴ava不提供這樣的機(jī)制  
        // 但如果我們知道內(nèi)部實(shí)現(xiàn)，并且通過反射或其他方式，我們可以“繞過”封裝性  
  
        // 假設(shè)我們使用了反射（不推薦，因?yàn)樗茐牧朔庋b性）  
        try {  
            java.lang.reflect.Field field = MyClass.class.getDeclaredField("privateField");  
            field.setAccessible(true); // 設(shè)置為可訪問，以繞過私有字段的封裝  
            String privateFieldValue = (String) field.get(deserializedObject);  
            System.out.println("Private field value: " + privateFieldValue);  
        } catch (NoSuchFieldException | IllegalAccessException e) {  
            e.printStackTrace();  
        }  
    }  
}