面向对象与泛型

讲一下面向对象和面向过程的区别？

要深入理解两者的区别，可从核心思想、组织方式、特性支持等多个维度展开：

从核心思想来看，面向过程更像是按步骤做事，比如要实现一个简单的学生成绩统计功能，可能会先写一个输入成绩的函数，再写一个计算平均分的函数，最后写一个输出结果的函数，然后按顺序调用这三个函数完成任务。这种方式下，数据和操作是分开的，函数主要围绕操作数据来设计。

而面向对象则是以对象为中心，将数据和操作数据的方法封装在一个对象中。比如同样是学生成绩统计，会先定义一个 “学生” 类，这个类里包含学生的成绩，以及计算平均分、输出成绩等方法。然后创建 “学生” 对象，通过调用对象的方法来完成统计。这里的对象就像一个独立的实体，既有自己的属性，又能完成特定的行为。

两者在特性上也有明显差异。面向对象有三大核心特性：封装、继承和多态。封装可以隐藏对象的内部细节，只对外提供必要的接口，比如 “学生” 类可以隐藏成绩的修改细节，只允许通过特定方法更新成绩，保证数据的安全性；继承允许一个类继承另一个类的属性和方法，比如可以定义一个 “大学生” 类继承 “学生” 类，复用 “学生” 类的功能并添加新的特性；多态则让不同对象对同一消息做出不同响应，比如 “学生” 类和 “教师” 类都有 “工作” 方法，调用时分别执行学习和教学的操作。

面向过程则没有这些特性，它的代码组织更依赖函数的调用顺序和参数传递，当程序规模增大时，代码的耦合度会变高，修改和维护起来比较困难。比如在面向过程的成绩统计系统中，如果要添加对成绩的排名功能，可能需要修改多个函数，还可能影响到原有的逻辑。

不过，面向过程也并非毫无优势，在处理一些简单、流程固定的任务时，它的代码更简洁、执行效率更高。例如编写一个简单的脚本处理文本文件，用面向过程的方式可能几行代码就能完成，而用面向对象可能会显得繁琐。

下面用一个表格更清晰地对比两者的区别：

对比维度	面向过程（POP）	面向对象（OOP）
核心思想	以过程为中心，按步骤执行	以对象为中心，通过对象交互完成任务
数据与操作关系	数据和操作分离	数据和操作封装在对象中
特性	无封装、继承、多态特性	支持封装、继承、多态
代码组织方式	依赖函数调用顺序和参数传递	依赖类和对象的定义与交互
适用场景	简单、流程固定的小型程序	复杂、需复用和扩展的大型应用
可维护性	程序规模增大时，维护难度增加	封装和继承降低耦合度，便于维护
执行效率	相对较高	因封装等特性，可能略低

创建一个对象用什么运算符？对象实体与对象引用有何不同？

要理解对象创建的运算符及对象实体与引用的区别，需要结合内存分配机制和变量特性展开：

创建对象的运算符

不同编程语言创建对象的方式略有差异，但核心是分配内存并初始化：

• 使用new运算符： 这是最常见的方式，如 Java 中Student s = new Student()，new会触发类的构造方法，在堆内存中创建对象实体，并返回其地址赋值给引用变量s。
• 特殊情况： 某些语言有简化写法，如 Python 中obj = MyClass()，JavaScript 中let obj = new Object()或字面量{}（本质仍是创建对象实体）。

new的核心作用是完成三件事：在堆内存中分配空间、初始化对象属性、返回对象地址。

对象实体与对象引用的核心差异

可以从存在形式、存储内容、生命周期等维度对比：

对比维度	对象实体	对象引用
存在形式	堆内存中实际存在的数据集合	栈内存（或局部变量表）中的变量
存储内容	包含对象的属性值和方法定义	存储对象实体在堆内存中的地址
生命周期	由垃圾回收机制管理（不再被引用时回收）	随作用域结束而销毁（如方法执行完毕）
操作方式	不能直接操作，需通过引用间接访问	可直接赋值、传递，指向不同实体

举例说明：

// 创建对象实体，在堆内存中分配空间
Person person1 = new Person("Alice");
// 引用赋值：person2与person1指向同一个对象实体
Person person2 = person1;

// 修改通过person2引用访问的对象实体属性
person2.setName("Bob");
// person1引用访问的仍是同一个实体，属性已被修改
System.out.println(person1.getName()); // 输出"Bob"

这里，new Person("Alice")是对象实体，person1和person2是两个引用，指向同一实体，因此修改任一引用访问的属性会影响整体。

若将引用指向新实体：

person2 = new Person("Charlie");

对象的相等和引用相等的区别

在 Java 中，== 和 .equals() 是判断对象是否相等的两种方式，但它们本质上语义完全不同。

== 比较的是两个引用变量是否指向同一内存地址，即两个变量是否引用同一个对象。
.equals() 方法默认与 == 等效（继承自 Object），但许多类（如 String、Integer、List）都重写了该方法，使其根据对象的内容逻辑判断相等性。

例如：

String a = new String("hello");
String b = new String("hello");
System.out.println(a == b); // false，不同对象
System.out.println(a.equals(b)); // true，内容相同

理解两者的区别对于集合操作（如 HashSet、Map）、对象比较逻辑、去重、缓存等编程实践至关重要。错误使用 == 会导致逻辑漏洞，如在列表中查找对象、判断唯一性时失效。

类的构造方法的作用是什么？

构造方法（Constructor）是类的一种特殊成员方法，它的名称必须与类名相同，且没有返回值（连 void 都不写）。当通过 new 关键字创建类的实例时，JVM 自动调用该类的构造方法，用于初始化对象的属性或执行必要的准备逻辑。
例如：

public class User {
    String name;
    public User(String name) {
        this.name = name;
    }
}
User u = new User("Tom"); // 自动调用构造方法

如果类中未显式声明构造方法，Java 会自动生成一个无参构造函数。但一旦声明了任何构造方法（无论有参或无参），默认构造函数将不再自动生成。因此如果类需要被无参构造实例化，开发者必须手动提供对应的构造方法。

构造方法可以被重载（Overload），但不能被重写（Override），因为它不是继承体系的一部分。

如果一个类没有声明构造方法，该程序能正确执行吗？

Java 中每个类都必须有构造方法用于初始化对象。如果类中未显式定义任何构造方法，Java 编译器会自动添加一个默认的无参构造方法（default constructor）。该方法什么都不做，仅保证对象可以正常创建。
例如：

public class Book {
    // 没有显式构造方法
}
Book b = new Book(); // 合法，调用编译器自动添加的构造方法

但如果类中已经定义了任何构造方法，编译器将不再自动添加默认构造方法。此时若还想支持无参实例化，开发者需手动声明无参构造方法，否则将编译报错。

这一机制是 Java 编译器提供的便利性措施，但也容易在多构造方法重载的类中被忽视，建议开发者养成显式声明构造方法的习惯以避免潜在错误。

构造方法有哪些特点？是否可被 override？

构造方法具有以下几个关键特性：

1. 命名规则特殊：必须与类名相同。
2. 不能有返回类型：不允许定义 void 或其他类型作为返回值。
3. 自动执行：通过 new 创建对象时由 JVM 自动调用。
4. 支持重载：同一类中可存在多个构造方法，参数列表不同。
5. 不可重写：构造方法不参与继承，因此子类不能重写父类的构造方法。

构造方法主要用于对象初始化，可以根据参数提供不同初始化策略。例如：

public class Dog {
    public Dog() {}
    public Dog(String name) { ... }
}

构造方法不能被子类继承，但可以通过 super() 调用父类构造函数以保证对象完整初始化。这一机制是 Java 面向对象模型中确保类构造安全性的重要手段。

面向对象三大特征

分析：
Java 是典型的面向对象编程语言，其核心理念体现在三个基本特征上：

1. 封装（Encapsulation）：将对象的属性和行为绑定在一起，通过访问修饰符限制对内部数据的直接访问。外部只能通过 getter/setter 等方法与对象交互。封装提升了代码的安全性和可维护性。
2. 继承（Inheritance）：子类可以继承父类的属性和方法，实现代码复用。通过关键字 extends 建立继承关系。继承机制允许在已有类的基础上扩展功能，同时支持向上转型实现多态。注意：Java 为避免"钻石继承"问题，仅支持单继承。
3. 多态（Polymorphism）：表现为同一父类引用可以指向不同的子类对象，方法调用根据实际对象在运行时动态决定。通过方法重写（Override）实现行为多样性。多态使系统更灵活、可扩展。
   例如：

Animal a = new Dog();
a.speak(); // 调用的是 Dog 的实现，而非 Animal 的

三大特性的协同作用，使得 Java 程序具备高度的可扩展性、可读性和可维护性，是开发大型系统的基础。

Java 支持多继承吗？

Java 的类结构遵循单继承模型，即一个类只能有一个直接父类。这种设计是为了解决 C++ 中"钻石继承"问题引发的歧义和维护困难。但 Java 通过接口机制实现了灵活的多继承功能。
Java 接口（interface）可以被多个类实现，一个类也可以同时实现多个接口。Java 8 之后，接口支持默认方法（default），可以在接口中添加具备默认实现的方法，从而进一步增强了多继承能力。 例如：

interface A { default void say() { System.out.println("A"); } }
interface B { default void say() { System.out.println("B"); } }
class C implements A, B {
    public void say() { A.super.say(); }
}

虽然类之间不能多继承，但通过组合接口和委托的方式，Java 已能满足大多数多继承需求。若需要复用代码逻辑，可使用抽象类或组合模式替代传统多继承做法。

什么是重写和重载？

方法重载是编译时多态的一种形式，主要体现在同一类中多个方法名相同，但参数个数、顺序或类型不同。返回值可以相同或不同。重载提高了代码的灵活性与可读性。
方法重写是运行时多态的体现，要求子类中定义的方法与父类中某方法签名完全相同，包括方法名、参数列表和返回值类型。此时子类方法会覆盖父类方法。

示例对比：

// 重载
void print(int a) {}
void print(String b) {}

// 重写
class Animal {
    void speak() { System.out.println("animal"); }
}
class Dog extends Animal {
    @Override
    void speak() { System.out.println("dog"); }
}

重写方法必须具有相同访问修饰符或更宽泛，且不能抛出比父类方法更多的受检异常（checked exception）。理解二者区别是掌握多态、接口实现、构造器设计的基础。

接口和抽象类有什么共同点和区别？

接口（Interface） 是对行为能力的抽象，强调"能做什么"；抽象类（Abstract Class） 是对共性结构的提取，强调"是什么"。二者都可以包含抽象方法，不能直接实例化。
主要区别包括：

• 继承机制：类只能继承一个抽象类，但可以实现多个接口。
• 成员类型：接口中只能定义 public static final 常量和抽象/默认/静态方法；抽象类可包含变量、构造器和完整方法实现。
• 适用场景：接口适合行为扩展、能力规范；抽象类适合组织共性逻辑，提供默认实现。

接口的灵活性更高，抽象类则在继承体系中更具表现力。Java 8 起接口支持默认方法，进一步缩小了二者在语法层面的差异。

深拷贝和浅拷贝区别了解吗？什么是引用拷贝？

浅拷贝（Shallow Copy） 会创建一个新对象，但其内部引用类型字段仍然指向原对象中的实例。这种方式虽然节省内存，但会导致共享状态引发数据一致性问题。
深拷贝（Deep Copy） 则递归地复制对象及其内部所有引用字段，确保新对象是完全独立的结构。常用于多线程或安全隔离场景。
引用拷贝更极端，仅复制对象地址，两个变量指向同一个内存区域，修改任一方数据都会影响另一方。

浅拷贝代码示例：

Person p1 = new Person(new Address("Wuhan"));
Person p2 = p1.clone(); // 浅拷贝
System.out.println(p1.getAddress() == p2.getAddress()); // true

深拷贝修改 clone 方法，确保内部字段也执行 clone()，即可达到真正意义的对象分离。推荐优先使用序列化、拷贝构造器等方式实现深拷贝。

---

什么是向上转型？什么是向下转型？

向上转型和向下转型的本质是通过类型转换实现多态场景下的灵活调用，二者的适用场景和风险截然不同。

向上转型是最常见的多态应用方式。当子类对象赋值给父类引用时，编译器会自动完成转型。此时，引用只能只能只能只能调用父类中定义的方法，无法直接调用子类特有的方法。这种转型的意义在于统一接口—— 无论实际对象是哪个子类，都能通过父类引用调用通用方法，简化代码逻辑。例如：

class Animal {
    void move() { System.out.println("动物移动"); }
}
class Dog extends Animal {
    @Override
    void move() { System.out.println("狗跑"); }
    void bark() { System.out.println("狗叫"); } // 子类特有方法
}

// 向上转型：Dog对象赋值给Animal引用
Animal animal = new Dog(); 
animal.move(); // 调用子类重写的方法，输出“狗跑”
// animal.bark(); // 编译错误：父类引用无法调用子类特有方法

这里，animal虽是Animal类型的引用，但实际指向Dog对象，调用move()时会执行Dog的重写实现，体现了多态的动态绑定特性。向上转型是安全的，因为子类始终是父类的一种，转型不会破坏类型规则。

向下转型则是将父类引用转换为子类类型，必须通过强制类型转换实现，且存在风险。它的作用是在已知父类引用实际指向子类对象时，恢复对子网类特有方法的访问能力。例如，当需要调用上述Dog的bark()方法时，需先向下转型：

// 向下转型：需显式强制转换
if (animal instanceof Dog) { // 先判断类型，避免异常
    Dog dog = (Dog) animal;
    dog.bark(); // 调用子类特有方法，输出“狗叫”
}

但如果父类引用指向的不是目标子类对象，强行转型会抛出ClassCastException。例如：

Animal cat = new Cat(); // Cat是另一个子类
// Dog dog = (Dog) cat; // 运行时抛出ClassCastException

因此，向下转型前必须用instanceof判断父类引用的实际对象类型，确保转型安全。这一步判断是开发中的规范，能有效避免类型转换异常。

总结来看，向上转型是多态的基础，通过统一父类接口简化调用；向下转型是补充，用于特定场景下访问子类特有功能，但需谨慎处理类型匹配。二者配合使用，既保证了多态的灵活性，又解决了父类引用无法访问子类特有方法的问题。

Java 中是值传递还是引用传递？

Java 方法调用时，参数始终以值的形式传递。对于基本类型，传递的是变量的副本；对于对象类型，传递的是引用变量的副本，而非对象本身。
这意味着方法内部对对象属性的修改是有效的（因为引用仍指向原始对象），但若改变引用本身指向的新对象，对外部无效。

void changeRef(Person p) { p = new Person(); }
void changeField(Person p) { p.name = "Tom"; }

changeRef 不会影响原对象，但 changeField 会修改原对象属性。
这一行为常被误解为"引用传递"，但本质是值传递，只是传递的值是引用地址。理解这一点对于掌握 Java 参数机制、调试对象行为具有重要意义。