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對象  
        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 {  
    // 受保護的字段，子類可以訪問  
    protected String protectedField = "This is a protected field.";  
      
    // 默認(rèn)訪問級別的字段（包級私有），同一包下的子類可以訪問  
    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 {  
    // 子類可以直接訪問受保護的字段  
    public void printProtectedField() {  
        System.out.println("Protected Field: " + protectedField);  
    }  
      
    // 因為子類與父類在同一包中，所以子類也可以訪問默認(rèn)訪問級別的字段  
    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());  
    }  
}  
  
// 主類，用于測試  
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.*;  
  
// 實現(xiàn)了Serializable接口的類  
class MyClass implements Serializable {  
    private String privateField = "This is a private field.";  
  
    // 為了簡化示例，沒有g(shù)etter和setter方法  
  
    // 這是一個序列化時會被調(diào)用的方法（如果有的話）  
    private void writeObject(ObjectOutputStream out) throws IOException {  
        // 通常這里會寫出對象的所有狀態(tài)，包括私有字段  
        // 但為了示例，我們假設(shè)這里什么都不做  
    }  
  
    // 這是一個反序列化時會被調(diào)用的方法（如果有的話）  
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {  
        // 通常這里會讀取流中的狀態(tài)來恢復(fù)對象  
        // 但為了示例，我們假設(shè)這里什么都不做  
    }  
}  
  
public class SerializationExample {  
  
    public static void main(String[] args) throws IOException, ClassNotFoundException {  
        // 創(chuàng)建一個對象  
        MyClass originalObject = new MyClass();  
  
        // 序列化對象到字節(jié)數(shù)組  
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();  
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);  
        objectOutputStream.writeObject(originalObject);  
  
        // 反序列化字節(jié)數(shù)組到對象  
        byte[] serializedData = byteArrayOutputStream.toByteArray();  
        ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(serializedData));  
        MyClass deserializedObject = (MyClass) objectInputStream.readObject();  
  
        // 注意：這里不能直接獲取私有字段的值，因為Java不提供這樣的機制  
        // 但如果我們知道內(nèi)部實現(xiàn)，并且通過反射或其他方式，我們可以“繞過”封裝性  
  
        // 假設(shè)我們使用了反射（不推薦，因為它破壞了封裝性）  
        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();  
        }  
    }  
}