# python
class MyClass:
    def __init__(self, name):
        self.name = name

# 创建类的实例，在 java 里创建实例为 new MyClass("Alice")
obj = MyClass("Alice")

# 动态添加属性
obj.age = 30
print(f"Name: {obj.name}, Age: {obj.age}")  # 输出: Name: Alice, Age: 30

# 动态添加方法
def greet(self):
    print(f"Hello, my name is {self.name}")

# 将方法绑定到实例
import types
obj.greet = types.MethodType(greet, obj)

# 调用动态添加的方法
obj.greet()  # 输出: Hello, my name is Alice

import java.lang.reflect.Field;

public class DynamicFieldExample {
    /**
     * 什么是 throws Exception？
     * throw Exceptions到方法的调用者，告诉调用者这个方法可能会抛出某些异常
     * 什么时候需要 throws Exception？
     * 当方法内部可能会抛出异常，但是方法本身不处理异常时，且异常为checked exceptions
     * 时必须需要在方法签名中声明 throws Exception
     * 注意，这里的Exception是所有exceptions的父类，你可以用任何继承该类的异常替换
     * runtime exceptions 即运行时发生的错误 继承 unchecked exceptions 不需要在
     * 方法签名中声明 throws Exception
     * 这是因为未检查异常通常表示编程错误，如逻辑错误或不正确的 API 使用，而不是可以合理预期和恢复的情况。
     * 你开发的时候就要修复这些错误，而不是想着在运行时处理他们。
     */
    public static void main(String[] args) throws Exception {
        // 创建一个实例
        MyClass obj = new MyClass();

        // 通过对象实例（obj）获取类对象
        Class<?> clazz = obj.getClass();

        // 动态添加字段，Field 类表示类或接口的一个字段（成员变量）。通过 Field 对象，
        // 可以获取字段的元数据（如字段名、类型等），并可以动态地访问和修改字段的值。
        Field field = clazz.getDeclaredField("age");
        field.setAccessible(true);
        field.set(obj, 30);

        // 访问动态添加的字段
        int age = (int) field.get(obj);
        System.out.println("Age: " + age);
        // 输出: Age: 30，哈哈，有没有发现private字段也能访问修改，so cool！
        // 其实嘛，访问修饰符主要作用还是让开发者知道这个字段该不该访问，该不该修改，从java的角度完全限制访问是不可能的
    }
}

class MyClass {
    private int age;
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public interface HelloWorld {
    void sayHello();
}

class HelloWorldImpl implements HelloWorld {
    @Override
    public void sayHello() {
        System.out.println("Hello, world!");
    }
}

public class DynamicProxyHandler implements InvocationHandler {
    private Object target;

    public DynamicProxyHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method call");
        Object result = method.invoke(target, args);
        System.out.println("After method call");
        return result;
    }
}

public class DynamicProxyExample {
    public static void main(String[] args) {
        // 创建目标对象
        HelloWorld target = new HelloWorldImpl();

        // 创建代理处理器
        DynamicProxyHandler handler = new DynamicProxyHandler(target);

        // 创建代理实例
        HelloWorld proxy = (HelloWorld) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                handler
        );

        // 调用代理方法
        proxy.sayHello();
    }
}
/**
 * Before method: sayHello
 * Hello, world!
 * After method: sayHello
 */

class University:
    def __init__(self, name):
        self.name = name
wku = University("wenzhou-kean")
wenzhou_kean = wku
# 注意 wku 和 wenzhou_kean 为不同的名称绑定到的同一对象。

my_age = 18
yours = my_age
my_age += 1
print(yours)
# 18
# 因为是不可变类型，这些对象一旦创建就不能修改。修改会导致新对象产生，
# 不会影响到原有对象

program Example;
type
  IntArray = array of Integer;

procedure ModifyArray(var arr: IntArray);
begin
  SetLength(arr, Length(arr) + 1);
  arr[High(arr)] := 4;
end;

var
  myArray: IntArray;
begin
  SetLength(myArray, 3);
  myArray[0] := 1;
  myArray[1] := 2;
  myArray[2] := 3;
  ModifyArray(myArray);
  WriteLn(Length(myArray));  // 输出: 4
end.

we = "wku_sra_member" # we 是一个名称，"wku_sra_member" 是一个对象,即名称对对象的映射
you = "wku_sra_member"
print(you is we) # string 共享引用
your_class = 2028
my_class = 2028
print(your_class is my_class)
# False
my_age = 18 # 小整数对象共享引用
yours = 18
print(yours is my_age)
# True

# recruit.py
our_purpose = "help you get better and make the world a better place"
our_requirement_to_you = "passion, curiosity, openness, and most importantly non-aggressiveness"

class Student:
    def __init__(self, occupation=None):
        self.occupation = occupation

def join_us(you):
    you.occupation = "member of wku-sra"

if __name__ == "__main__":
    stewie = Student()
    join_us(stewie)
    print(stewie.occupation)
# 执行这个模块会输出: member of wku-sra

import recruit
print(recruit.our_purpose) # 访问这个模版对象的属性并打印
# 输出: help you get better and make the world a better place
brian = recruit.Student()
recruit.join_us(brian) # 调用模版对象的方法
print(brian.occupation)
# 输出: member of wku-sra

# 如何实现只读
class MyClass:
    def __init__(self, value):
        self.__value = value
        # 以 _ 开头的属性是私有的，但只是程序员之间的约定，不是强制，你要修改_value 也是可以的，__value 才是完全私有的(class definition里)。
        # 当然，你真想访问__value也是可以的，python只是做name mangling
        # 双下滑和单下滑前缀均会对语义产生影响，在from mofule import *时均不会被引入
        # 都到这里了，顺便提一嘴 __dunderscore__ 定义特殊的方法和特性

    @property
    def value(self):
        return self.__value

# 示例
obj = MyClass(10)
print(obj.value)  # 输出: 10
obj.value = 20    # 会引发 AttributeError: can't set attribute

def outer_function():
    x = "outer"

    def inner_function():
        nonlocal x
        x = "inner"
        print("Inner:", x)

    inner_function()
    print("Outer:", x)

outer_function()
# Inner: inner
# Outer: inner
# 如果不使用 nonlocal 语句，inner_function 中的 x 将是一个新的局部变量，不会影响 outer_function 中的 x。

def scope_test():
    def do_local():
        spam = "local spam"
        print("Inside do_local:", spam)

    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam"
        print("Inside do_nonlocal:", spam)

    def do_global():
        global spam
        spam = "global spam"
        print("Inside do_global:", spam)

    spam = "test spam"
    do_local()
    print("After do_local:", spam)
    do_nonlocal()
    print("After do_nonlocal:", spam)
    do_global()
    print("After do_global:", spam)

scope_test()
print("In global scope:", spam)
# Inside do_local: local spam
# After do_local: test spam
# Inside do_nonlocal: nonlocal spam
# After do_nonlocal: nonlocal spam
# Inside do_global: global spam
# After do_global: nonlocal spam
# In global scope: global spam

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

class MyClass:
    """在类中直接定义的是静态属性，也被叫做类属性，这个属性被所有实例共享，可通过类名直接访问
       也可以通过实例访问，但是不推荐，因为这样会让人误以为是实例属性，
       修改静态属性会影响所有实例，因为这些静态属性是在实例之间共享的"""
    i = 12345

    def f(self):
        return 'hello world'

x = MyClass() # 创建类的新 实例 并将此对象分配给局部变量 x

def __init__(self):
    self.data = []# 这个就是实例属性啦
# 当一个类定义了 __init__() 方法时，类的实例化会自动为新创建的类实例发起调用 __init__()
# 你也可以提供参数给 __init__() 方法
class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart


x = Complex(3.0, -4.5)
x.r, x.i
# (3.0, -4.5)

class MyClass:
    @staticmethod
    def static_method():
        print("This is a static method.")

# 通过类名访问静态方法
MyClass.static_method()  # 没访问实例

# 通过实例访问静态方法，可行但不推荐，在某些语言里为禁止行为
obj = MyClass()
obj.static_method()

class MyClass:
    class_attribute = 0

    @classmethod
    def class_method(cls):
        print(f"This is a class method. Class attribute: {cls.class_attribute}")

# 通过类名访问类方法
MyClass.class_method()  # 输出: This is a class method. Class attribute: 0

# 通过实例访问类方法
obj = MyClass()
obj.class_method()  # 输出: This is a class method. Class attribute: 0

class Dog:

    kind = 'canine'         # class variable 类变量 shared by all instances 被所有实例共享

    def __init__(self, name):
        self.name = name    # instance variable 实例变量 unique to each instance 每个实例独有

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.kind                  # shared by all dogs
'canine'
>>> e.kind                  # shared by all dogs
'canine'
>>> d.name                  # unique to d
'Fido'
>>> e.name                  # unique to e
'Buddy'

class Warehouse:
   purpose = 'storage'
   region = 'west'

w1 = Warehouse()
print(w1.purpose, w1.region)
storage west
w2 = Warehouse()
w2.region = 'east'
print(w2.purpose, w2.region)
storage east

# Function defined outside the class
def f1(self, x, y):
    return min(x, x+y)

class C:
    f = f1

    def g(self):
        return 'hello world'

    h = g

def add(self, x):
        self.data.append(x)

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

class BaseClass:
    def __init__(self):
        print("BaseClass constructor called")

class DerivedClass(BaseClass):
    def __init__(self):
        # 首先调用父类的构造函数
        super().__init__()
        print("DerivedClass constructor called")

# 创建派生类的实例
derived_instance = DerivedClass()

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

class TreeNode:
    def __init__(self, value=0, left=None, right=None):
        self.value = value
        self.left = left
        self.right = right

def dfs(node):
    if node is None:
        return
    # 访问当前节点
    print(node.value)
    # 递归遍历左子树
    dfs(node.left)
    # 递归遍历右子树
    dfs(node.right)

# 示例用法
if __name__ == "__main__":
    # 创建一个二叉树
    root = TreeNode(1)
    root.left = TreeNode(2)
    root.right = TreeNode(3)
    root.left.left = TreeNode(4)
    root.left.right = TreeNode(5)
    root.right.left = TreeNode(6)
    root.right.right = TreeNode(7)

    # 执行深度优先且从左到右的遍历
    dfs(root)

class Mapping:
    def __init__(self, iterable):
        self.items_list = []
        self.__update(iterable)

    def update(self, iterable):
        for item in iterable:
            self.items_list.append(item)

    __update = update   # private copy of original update() method

class MappingSubclass(Mapping):

    def update(self, keys, values):
        # provides new signature for update()
        # but does not break __init__()
        for item in zip(keys, values):
            self.items_list.append(item)