Java面经--从代码角度认识面向对象编程和面向过程编程

1. 思维方式和核心概念

面向过程编程：核心是过程（procedure），即通过函数来组织和实现功能。程序被分为一系列的步骤或过程，数据和功能分离，代码通常是顺序执行的。
面向对象编程：核心是对象（object），对象是现实世界中实体的抽象。对象包含了数据（属性）和行为（方法），通过将数据与功能封装到对象内部，强调代码的复用性、灵活性和可维护性。

2. 代码组织方式

2.1. 面向过程编程

在面向过程编程中，程序是围绕函数（过程）组织的。函数是执行特定任务的代码块，数据在函数之间通过参数传递。数据和操作是分离的。

面向过程的代码示例：

#include <stdio.h>// 全局变量表示学生的基本信息
char name[50];
int age;
int score;// 函数用于打印学生信息
void printStudentInfo() {printf("Name: %s\n", name);printf("Age: %d\n", age);printf("Score: %d\n", score);
}int main() {// 设置学生信息sprintf(name, "Alice");age = 20;score = 85;// 打印学生信息printStudentInfo();return 0;
}

特点：

数据（name、age、score）和操作（printStudentInfo）是分开的。
函数 printStudentInfo 操作全局变量，没有对数据进行封装，数据是裸露的。

2.2. 面向对象编程

面向对象编程通过类来组织代码，类是对象的模板，它定义了数据（属性）和行为（方法）。对象是类的实例，数据和操作被封装在对象内部。

面向对象的代码示例：

class Student {// 私有属性表示学生的基本信息private String name;private int age;private int score;// 构造函数用于初始化学生对象public Student(String name, int age, int score) {this.name = name;this.age = age;this.score = score;}// 方法用于打印学生信息public void printStudentInfo() {System.out.println("Name: " + name);System.out.println("Age: " + age);System.out.println("Score: " + score);}
}public class Main {public static void main(String[] args) {// 创建学生对象，并初始化属性Student student = new Student("Alice", 20, 85);// 调用方法，打印学生信息student.printStudentInfo();}
}

特点：

数据（name、age、score）和操作（printStudentInfo）被封装在类 Student 中。
类通过封装机制保护数据，外界只能通过方法访问数据，增强了安全性。
类可以实例化多个对象，每个对象都有自己的数据副本。

3. 封装、继承和多态

3.1 封装

面向过程：数据和操作是分离的，没有封装的概念，数据常常是全局变量或由外部传入的参数。
面向对象：通过封装机制，数据和操作被捆绑在一起，数据是类的内部属性，外部无法直接访问，只能通过类的方法进行操作。

面向对象的封装示例：

class Student {private String name; // 数据是私有的// 通过方法来访问和修改数据public String getName() {return name;}public void setName(String name) {this.name = name;}
}

3.2 继承

面向过程：不存在继承的概念，代码复用依赖于函数的调用或代码拷贝，难以管理。
面向对象：类可以继承另一个类的属性和方法，子类通过继承复用父类的代码，并能根据需要扩展或修改父类的行为。

继承的示例：

class Person {private String name;public Person(String name) {this.name = name;}public void greet() {System.out.println("Hello, my name is " + name);}
}class Student extends Person {private int score;public Student(String name, int score) {super(name); // 调用父类的构造方法this.score = score;}public void showScore() {System.out.println("My score is " + score);}
}public class Main {public static void main(String[] args) {Student student = new Student("Alice", 85);student.greet();       // 调用继承自 Person 的方法student.showScore();   // 调用 Student 自己的方法}
}

继承的好处：

代码复用：子类继承了父类的功能，减少重复代码。
扩展性：可以在子类中添加新功能，且不影响父类。

3.3 多态

面向过程：函数根据名称调用，没有多态的概念。不同的功能需要不同的函数实现。
面向对象：通过多态，子类可以重写父类的方法，程序可以在运行时根据对象的实际类型调用相应的方法。多态支持更灵活的代码设计，适合扩展和维护。

多态的示例：

class Animal {public void makeSound() {System.out.println("Some generic animal sound");}
}class Dog extends Animal {@Overridepublic void makeSound() {System.out.println("Woof!");}
}class Cat extends Animal {@Overridepublic void makeSound() {System.out.println("Meow!");}
}public class Main {public static void main(String[] args) {Animal animal1 = new Dog();  // 父类引用指向子类对象Animal animal2 = new Cat();animal1.makeSound();  // 输出：Woof!animal2.makeSound();  // 输出：Meow!}
}

多态的好处：

多态允许我们在编译时将不同子类对象作为父类来处理，运行时调用实际对象的方法。这种机制使代码更加灵活，易于扩展。

4. 代码复用性与扩展性

面向过程：代码复用主要通过函数来实现，扩展性差。如果需要修改或扩展功能，通常需要改动多个地方的代码。
面向对象：代码通过类和继承来复用。面向对象的封装、继承、多态特性使得程序更容易扩展和维护。只需要继承父类或实现接口即可实现代码的扩展，且不影响现有代码。

5. 适用场景

面向过程编程：
- 适合解决简单的、任务导向型的问题。
- 适合对底层资源的直接控制，或小型、短期的项目。
- C 语言等偏向硬件开发和系统编程的场景更常用面向过程编程。
面向对象编程：
- 适合大型复杂系统的开发，特别是业务逻辑复杂、需要长期维护和扩展的项目。
- 常用于企业级应用、面向服务的架构、游戏开发等。
- Java、C++、Python 等高级语言常用面向对象编程进行开发。