编程语言面试题（一）

1、Java反射机制的作用是什么？

Java反射(Reflection)是Java语言的一个强大特性，它允许程序在运行时动态地获取类的信息并操作类或对象的属性、方法和构造器。Java反射机制的主要作用是为程序提供运行时动态操作类或对象的能力，打破了传统编程中"编译时确定"的限制。

2、反射机制与直接调用函数有什么区别？

由于反射涉及动态解析类型，其性能通常低于直接代码调用。在性能敏感的场景中，应谨慎使用反射或考虑缓存反射操作的结果。

反射是Java语言的一个强大特性，合理使用可以极大增强程序的灵活性，但过度使用也可能带来维护和性能问题。

3、Python中__init__方法的作用是什么？

在 Python 中，__init__方法是一个特殊的方法，用于在创建类的实例时进行初始化操作。它是类的构造函数（constructor），在对象被实例化时自动调用。

__init__方法的作用：

• 初始化对象的属性：通常用于给对象的属性赋初始值。
• 执行必要的设置：例如打开文件、建立数据库连接等初始化操作。
• 接受参数：可以在实例化对象时传入参数，用于定制对象的初始状态。

class Person:
    def __init__(self, name, age):
        self.name = name  # 初始化 name 属性
        self.age = age    # 初始化 age 属性

# 创建 Person 的实例，自动调用 __init__
person1 = Person("Alice", 30)
print(person1.name)  # 输出: Alice
print(person1.age)   # 输出: 30

关键点：

• self 参数：代表类的实例，必须是第一个参数，但调用时不需要手动传递。
• 自动调用：在创建对象时（如 obj = MyClass()）自动执行。
• 可以有参数：可以在 __init__ 中定义参数，实例化时传入（如 Person("Alice", 30)）。
• 不是必须的：如果不需要初始化，可以不定义 __init__，Python 会提供默认的空实现。

4、Python中初始化方法的区别？

6、Python中__new__和__init__区别？

__new__ 控制实例的创建，__init__控制实例的初始化

7、什么情况下重写new方法？

1）单例模式（Singleton）

确保一个类只有一个实例，并提供一个全局访问点。

实现方式：在 __new__ 中检查是否已存在实例，若存在则返回该实例，否则创建新实例。

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

obj1 = Singleton()
obj2 = Singleton()
print(obj1 is obj2)  # True（两个变量指向同一个实例）

2）继承不可变类型（如 str, tuple, int）

不可变类型（immutable）的实例在创建后不能修改，因此需要在 __new__ 中控制其创建方式。

class UpperStr(str):
    def __new__(cls, value):
        # 在创建实例前修改值
        modified_value = value.upper()
        return super().__new__(cls, modified_value)

s = UpperStr("hello")
print(s)  # "HELLO"（实例化时自动转为大写）

3） 对象池（Object Pooling）

复用已创建的对象以减少资源消耗（如数据库连接、线程池等）。

实现方式：在 __new__ 中维护一个对象池，返回已存在的对象而非创建新实例。

class DatabaseConnection:
    _pool = []

    def __new__(cls):
        if cls._pool:
            return cls._pool.pop()
        else:
            new_conn = super().__new__(cls)
            new_conn._initialize()  # 模拟初始化连接
            return new_conn

    def _initialize(self):
        print("New connection created")
        self.is_active = True

    def close(self):
        self.is_active = False
        self.__class__._pool.append(self)  # 放回池中

# 使用
conn1 = DatabaseConnection()  # 输出: New connection created
conn1.close()
conn2 = DatabaseConnection()  # 无输出，复用 conn1
print(conn1 is conn2)  # True

4） 动态修改实例属性（在 __init__ 之前）

如果需要在实例创建时动态修改属性（例如根据参数决定实例类型），可以在 __new__ 中处理。

class Animal:
    def __new__(cls, animal_type, *args, **kwargs):
        if animal_type == "dog":
            return super().__new__(Dog)
        elif animal_type == "cat":
            return super().__new__(Cat)
        else:
            return super().__new__(cls)

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

pet = Animal("dog")
print(pet.speak())  # "Woof!"（实际返回的是 Dog 的实例）

5） 自定义元类（Metaclass）的辅助

在元类编程中，__new__ 可以拦截类的创建过程（注意：这里是类的 __new__，不是实例的 __new__）。

class UpperAttrMeta(type):
    def __new__(cls, name, bases, attrs):
        uppercase_attrs = {
            k.upper(): v for k, v in attrs.items()
        }
        return super().__new__(cls, name, bases, uppercase_attrs)

class MyClass(metaclass=UpperAttrMeta):
    x = 1

print(hasattr(MyClass, "x"))  # False
print(hasattr(MyClass, "X"))  # True（属性名被转为大写）