【Java Pro】001-Java基础：面向对象

【Java Pro】001-Java基础：面向对象

一、面向对象

头脑风暴：

1. 什么是对象？
2. 什么是面向对象？
3. 为什么要面向对象？
4. 面向对象的优缺点？

1、什么是对象

现实生活中的对象与程序中的对象

一切皆对象，现实生活中：电脑、耳机、水杯、书等等，相比现实生活，程序中的对象是抽象出来的，要么是基于现实中的对象抽象出来，只包含了现实中对象的部分信息，要么是根本应用程序的需要而抽象出来的，如：职工对象（通常只记录部分与职工相关性较高的信息），学生对象（通常也只记录与学生相关性较高的信息）。职工和学生是一个“角色对象”，因为他们也可能同时是儿子、女儿、父亲、母亲、观众、演员……，但在特定的场景下仅使用他们对应的属性信息等。程序中也有现实中不存在的对象，比如一个数据库、一张数据表、一个服务器的连接，这是根据应用程序的需要抽象得到的，为了完成业务需求！

2、什么是面向对象

面向对象对应的是面向过程。

面向过程

分析解决某个问题所需要的步骤，然后根据步骤一步一步通过代码实现。

把大象装进冰箱：

1. 打开冰箱门；
2. 大象进入冰箱；
3. 关闭冰箱门。

面向过程，就是按照我们分析好的步骤，按照步骤解决问题。

面向对象

把事务分解成一个一个对象，然后对象之间分工与合作。

把大象装进冰箱：

1. 冰箱门打开（冰箱对象的行为）；
2. 大象进入冰箱（大象对象的行为）；
3. 冰箱门关住（冰箱对象的行为）。

面向对象，是以对象功能来划分问题，而不是步骤。

3、面向过程与面向对象的比较

一句话：面向过程数据和操作数据的函数是分离的，按照顺序执行函数，完成任务；面向对象的数据和操作数据的函数被封装在对象内部，是统一的，对象之间通过消息传递进行协作，以完成任务！

面向过程（Procedural Programming）和面向对象（Object-Oriented Programming）是两种编程范式，它们有着不同的思想、设计方式和实现方法。

思想方面

面向过程思想将程序看作一系列函数或过程的集合，这些函数或过程按照顺序执行，完成特定的任务。在面向过程的程序设计中，数据与行为是分开的，数据和操作数据的函数是分离的。

面向对象思想则认为程序应该是由一组相互作用的对象组成的，每个对象都有自己的状态和行为。面向对象设计中，对象是程序的基本单位，数据和操作数据的函数被封装在对象内部，数据与行为是紧密联系的。

设计方式方面

在面向过程编程中，问题被分解为若干个子问题，每个子问题被设计成一个函数，再将这些函数组合起来完成整个任务。程序的设计主要关注如何处理数据，而不是如何组织数据。

在面向对象编程中，问题被抽象成对象，每个对象有自己的属性和方法，对象之间通过消息传递相互协作。程序的设计主要关注如何组织数据，而不是如何处理数据。

实现方式方面

在面向过程编程中，数据和函数是分离的，数据的改变需要通过调用函数来实现。常见的面向过程编程语言包括 C、Fortran、Pascal 等。

在面向对象编程中，数据和方法被封装在对象内部，对象之间通过消息传递来实现数据的操作。常见的面向对象编程语言包括 Java、Python、C++、C# 等。

总的来说，面向过程与面向对象各有优缺点，在具体应用中需要根据问题的特点和实际情况选择合适的编程范式。

4、面向过程与面向对象的优缺点

面向过程的优点

1. 简单明了：面向过程的编程思想相对简单，易于理解和实现。

   我觉得面向过程符合人的常规思想逻辑，我们为了达成目标做事情也是按步骤进行！

2. 效率高：面向过程的编程方式更加接近底层实现，执行效率高。

3. 易于维护：面向过程的程序结构清晰，每个函数完成一个特定的任务，容易进行维护。

面向过程的缺点

1. 不易扩展：面向过程的程序结构比较简单，难以应对复杂的系统需求。
2. 可读性差：面向过程的程序代码往往比较冗长，可读性差。
3. 数据与行为耦合度高：在面向过程的程序设计中，数据与操作数据的函数是分离的，这会导致数据和行为之间的耦合度较高，不易维护和修改。

面向对象的优点

1. 抽象能力强：面向对象编程能够将复杂的系统抽象成对象，更容易理解和应对系统需求的变化。
2. 可重用性高：面向对象编程中，对象可以被重用，提高了程序的可维护性和可扩展性。
3. 安全性高：面向对象编程中，对象的属性和方法被封装起来，保护了程序的安全性。

面向对象的缺点

1. 技术门槛高：面向对象编程思想较为复杂，需要掌握面向对象的相关概念和技术。

2. 执行效率较低：面向对象的程序实现需要更多的内存空间和处理时间，执行效率相对较低。

   我觉得对象里面不是所有的属性和方法都会用到，每次使用要加载整个对象，那么就浪费了资源、降低了效率！

3. 设计复杂度高：面向对象编程需要设计对象的属性和方法，设计复杂度较高，需要花费更多的时间和精力。

   主要关注如何组织数据，数据组织的合理性需要站在长远、全局的角度考虑。

5、面向过程与面向对象的使用场景

面向过程的使用场景

1. 小型应用程序：面向过程编程思想相对简单，适用于编写小型应用程序。
2. 执行效率要求高的应用程序：面向过程编程更接近底层实现，执行效率较高，适用于执行效率要求高的应用程序。
3. 适用于处理简单的算法和数学运算等任务。

面向对象的使用场景

1. 大型软件系统：面向对象编程适用于大型软件系统的开发，能够更好地应对系统需求的变化。
2. 可扩展性要求高的应用程序：面向对象编程中的对象可以被重用，提高了程序的可维护性和可扩展性。
3. 用户交互性较强的应用程序：面向对象编程中的对象和方法能够更好地反映出应用程序的实际场景，提高了用户的交互体验。

6、Java 中常用的面向过程的操作

1. 控制语句：Java中常用的控制语句包括if-else、for、while、do-while等，可以实现程序的流程控制。
2. 数组：数组是 Java 中常用的数据结构之一，可以存储多个同类型的数据，可以通过下标访问数组中的元素。
3. 函数：Java 中可以使用函数来实现面向过程的编程，函数可以接收参数和返回值，通过函数可以将代码分成独立的模块。
4. 文件操作：Java 中提供了丰富的文件操作函数，可以实现文件的创建、读取、写入、删除等操作。
5. 字符串操作：Java 中可以使用字符串类来实现字符串的连接、截取、比较等操作。
6. 输入输出操作：Java 中提供了丰富的输入输出函数，可以实现控制台输入输出、文件输入输出等操作。
7. 排序算法：Java 中提供了多种排序算法，如冒泡排序、快速排序、归并排序等，可以对数组或集合进行排序。

7、Java 面向过程与面向对象编程示例

面向过程：求两个证书的最大公约数

在这个例子中，主程序使用了 Scanner 类获取用户输入的两个整数，然后调用 findGcd 函数计算它们的最大公约数。findGcd 函数使用了 for 循环和 if 语句来计算最大公约数。整个程序使用了面向过程的编程方式，将任务分解为一系列的函数，每个函数负责完成特定的功能。函数之间通过参数和返回值进行数据传递和处理。

import java.util.Scanner;public class GcdCalculator {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.print("请输入第一个数：");int num1 = scanner.nextInt();System.out.print("请输入第二个数：");int num2 = scanner.nextInt();int gcd = findGcd(num1, num2);System.out.println("最大公约数是：" + gcd);}public static int findGcd(int num1, int num2) {int smaller = num1 < num2 ? num1 : num2;int gcd = 1;for (int i = 1; i <= smaller; i++) {if (num1 % i == 0 && num2 % i == 0) {gcd = i;}}return gcd;}}

面向对象：求两个证书的最大公约数

在这个例子中，我们将计算最大公约数的函数findGcd放到了 GcdCalculator 类中，并且在主程序中使用了这个类来创建对象。这个程序使用了面向对象的编程方式，将数据和操作封装在一个类中，使用对象来调用方法，实现了更加直观和灵活的编程方式。这样，当我们需要计算多组数据的最大公约数时，只需要创建多个 GcdCalculator 对象，调用它们的 findGcd 方法即可。

import java.util.Scanner;public class GcdCalculator {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.print("请输入第一个数：");int num1 = scanner.nextInt();System.out.print("请输入第二个数：");int num2 = scanner.nextInt();GcdCalculator calculator = new GcdCalculator();int gcd = calculator.findGcd(num1, num2);System.out.println("最大公约数是：" + gcd);}public int findGcd(int num1, int num2) {int smaller = num1 < num2 ? num1 : num2;int gcd = 1;for (int i = 1; i <= smaller; i++) {if (num1 % i == 0 && num2 % i == 0) {gcd = i;}}return gcd;}}

二、面向对象：封装性

头脑风暴：

1. 什么是封装性？
2. 为什么要封装？
3. 封装的优缺点？
4. 封装的使用场景？

1、概述

隐藏具体实现 + 访问控制，提高安全性

面向对象的封装性指的是将数据和对数据的操作封装在一个类中，通过类的接口来访问和操作数据，同时将数据的实现细节隐藏在类的内部，不暴露给外部。

封装性是面向对象编程中最基本、最重要的概念之一。它可以有效地保护对象的数据，防止外部的直接访问和修改，从而保证了数据的安全性和完整性。同时，封装性还可以隐藏对象的实现细节，使得对象的使用者不必关心对象的内部实现，只需要关心对象提供的接口即可。

在 Java 中，封装性通常通过访问修饰符（public、protected、private）来实现。将数据成员设置为私有的（private），并提供公有的（public）getter 和 setter 方法，这样就可以实现对数据的访问控制和保护，同时也可以方便地对数据进行操作和修改。这样就实现了类的封装性，同时也提高了代码的可维护性和可重用性。

2、Java 封装性的优缺点

封装性的优点

1. 数据的安全性：封装性可以将数据成员设置为私有的，从而防止外部直接访问和修改数据，提高数据的安全性。
2. 实现细节的隐藏：封装性可以将类的实现细节隐藏起来，只对外部提供公共接口，使得使用者不需要了解具体的实现细节，提高了代码的可维护性。
3. 代码重用：封装性可以将类的实现细节封装起来，提供公共接口，使得其他程序员可以使用该类，从而提高了代码的重用性。
4. 灵活性：封装性可以使得程序员可以在不影响类外部的情况下修改类的实现细节，从而提高了代码的灵活性。

封装性的缺点

1. 复杂性：封装性会增加程序的复杂度，需要花费更多的时间和精力来设计和实现类。
2. 开销大：封装数据会增加运行时的开销，因此在某些需要高效的场景中，可能需要暴露类的数据成员，从而降低代码的开销。
3. 访问控制：如果访问控制设置不当，可能会导致访问限制过于严格或者过于宽松，从而影响代码的安全性和可维护性。

3、Java 封装性的使用场景

1. 保护数据安全：将类的数据成员设置为私有的，通过公共接口提供访问和修改数据的方法，可以防止数据被非法访问和修改。
2. 隐藏实现细节：将类的实现细节封装起来，只对外部提供公共接口，可以隐藏类的具体实现细节，提高代码的可维护性和可重用性。
3. 限制访问权限：通过控制访问修饰符来限制成员变量或成员方法的访问权限，从而达到安全保护和代码封装的目的。
4. 简化接口：通过封装可以简化外部接口，隐藏类的实现细节，降低类之间的耦合度，提高系统的灵活性。
5. 提高可维护性：将类的实现细节封装起来，可以使得修改实现细节对外部代码的影响最小化，从而提高代码的可维护性。
6. 提高代码复用性：将类的实现细节封装起来，可以使得其他程序员可以使用该类，从而提高了代码的复用性。

4、Java 不适用封装性的场景

1. 必须公开的数据：如果某个数据成员需要被多个类访问或修改，而且没有安全性的问题，那么将其设置为 public 属性可能更合适，因为封装数据会增加代码的复杂性和运行时的开销。
2. 共享数据：如果多个对象之间需要共享某些数据，那么将其设置为 public 属性可能更为合适，因为封装数据会导致多个对象之间无法访问共享数据。
3. 高效性的要求：封装数据会增加代码的复杂性和运行时的开销，因此在某些需要高效的场景中，可能需要暴露类的数据成员，从而降低代码的开销。

5、Java 中封装性的最佳实践是什么

1. 使用 private 修饰符来限制属性的访问。这样可以防止类外部的代码直接访问属性，保证了数据的安全性和完整性。
2. 提供 public 的 setter 和 getter 方法来访问属性。setter 方法可以用于修改属性的值，getter 方法可以用于获取属性的值。通过setter 和 getter 方法可以实现对属性的控制和访问，从而确保属性的正确性和可靠性。
3. 避免使用 public 属性或方法。直接暴露 public 属性或方法会破坏类的封装性，使得类的实现细节暴露在外部，容易被不良代码所利用。如果确实需要暴露属性或方法，可以考虑使用 protected 或 default 访问修饰符来限制访问。
4. 尽量不要使用 protected 访问修饰符。尽管 protected 修饰符可以让子类访问父类的属性和方法，但是过多的使用会破坏封装性，使得类的实现变得复杂和脆弱。
5. 使用 final 修饰符来限制属性和方法的修改。final 修饰符可以防止属性和方法被修改，从而保证了代码的稳定性和可靠性。当然，使用 final 修饰符需要谨慎，因为它可能会限制代码的灵活性和可扩展性。

三、面向对象：继承性

头脑风暴：

1. 什么是继承性？
2. 为什么要集成？
3. 继承的优缺点？
4. 继承的适用场景和不适用场景？

1、概述

代码复用：继承其他类的属性和方法，增强代码复用！

Java 面向对象编程中的继承性是指，一个类可以从已有的类中继承属性和方法，从而可以扩展已有的类，减少重复代码，提高代码的复用性和可维护性。

在 Java 中，一个类可以通过 extends 关键字继承另一个类的属性和方法。被继承的类称为父类或超类，继承它的类称为子类或派生类。子类可以访问父类中的非私有成员（即public、protected和默认访问级别的成员），并且可以扩展父类中的属性和方法，也可以重写父类中的方法。

在继承中，子类继承了父类的属性和方法，可以使用父类的实例变量和方法，从而减少代码的冗余。另外，继承还可以实现代码的重用和扩展，即子类可以扩展父类的属性和方法，并添加新的属性和方法。

2、Java 继承性的优缺点

继承的优点

1. 提高代码的复用性：可以重用已有的代码，减少代码冗余，提高代码的复用性。
2. 提高代码的可维护性：可以通过继承来实现代码的扩展和修改，而不必修改原有的代码。
3. 实现多态：子类可以重写父类的方法，从而实现多态。

继承的缺点

1. 多层继承可能导致代码的复杂性增加，出现混乱的继承关系。
2. 子类依赖于父类，一旦父类发生变化，可能会影响到子类的正常运行。
3. 破坏封装性：继承会继承父类的所有属性和方法，包括私有的属性和方法，这可能会破坏父类的封装性。

3、Java 继承性的适用场景

1. 代码复用：当多个类之间有相同的属性和方法时，可以将这些属性和方法定义在一个父类中，然后让子类继承这个父类，从而减少代码的冗余，提高代码的可维护性和可重用性。
2. 扩展功能：当需要对已有的类进行功能扩展时，可以通过继承来实现。子类可以扩展父类的功能，而不必修改父类的代码。
3. 实现多态：通过继承可以实现多态性，即不同的子类对象可以调用同一个方法，实现不同的功能。

4、Java 继承性的不适用场景

1. 过度使用：过度使用继承可能会导致代码的复杂性增加，出现混乱的继承关系。
2. 父类变化：当父类发生变化时，可能会影响到子类的正常运行，因此需要谨慎使用继承。
3. 类的层次过多：如果继承的层数太多，会导致代码的可读性和可维护性降低。

5、学习 Java 的继承性应注意哪些问题

1. 继承关系的建立：需要明确父类和子类的关系，以及如何定义父类和子类的属性和方法。
2. 方法的覆盖：子类可以覆盖父类的方法，需要注意方法的返回值、参数类型和名称等信息。
3. 访问修饰符：子类继承父类后，可以访问父类的公有方法和属性，但无法访问私有方法和属性。
4. 继承层数的问题：如果继承的层数太多，会影响代码的可读性和可维护性。
5. 多态性的应用：在使用继承时，需要注意多态性的应用，即子类对象可以赋值给父类引用，从而实现不同的行为。
6. 构造方法的调用：子类继承父类后，需要调用父类的构造方法，可以使用super关键字来调用父类的构造方法。
7. 父类和子类的实例化：在使用继承时，需要注意父类和子类的实例化方式，即子类对象在实例化时，会自动调用父类的构造方法。

6、Java 中继承性的最佳实践是什么

1. 使用继承时，需要明确父类和子类之间的关系，确保继承关系的正确性和可读性。

2. 父类应该是稳定、可靠的基类，子类应该是特定的派生类。因此，在定义父类时，需要遵循单一职责原则，尽量保持类的简洁和高内聚性。

3. 在使用继承时，需要考虑代码的可维护性和可扩展性。因此，需要注意继承层数的问题，以及如何避免过度使用继承。

4. 在子类中覆盖父类的方法时，需要遵循里氏替换原则，确保子类对象可以替换父类对象，而不会影响代码的正确性。

5. 在使用继承时，需要注意多态性的应用，即子类对象可以赋值给父类引用，从而实现不同的行为。

6. 在定义父类和子类的属性和方法时，需要考虑访问修饰符的问题，以便确保代码的封装性和安全性。

   在 Java 中，父类的属性和方法一般使用访问修饰符 protected 或 public 。

四、面向对象：多态性

1、概述

Java 中的多态性指的是同一种类型的对象，在不同的情况下会表现出不同的行为。具体来说，多态性可以分为两种类型：静态多态性和动态多态性。

静态多态性是指在编译期确定调用哪个方法，例如方法重载（overloading），即一个类中定义了多个方法，它们具有相同的名称，但是参数列表不同。在调用这些方法时，编译器会根据参数列表的不同选择相应的方法。

动态多态性是指在运行期根据实际情况选择调用哪个方法，例如方法重写（overriding），即子类重写了父类的某个方法。在调用这个方法时，编译器无法确定具体调用哪个方法，需要在运行期根据对象的实际类型来决定。

多态性可以让程序更加灵活，可以通过继承和接口实现，使代码更加模块化和可扩展。

2、Java 多态性的优缺点

多态性优点

1. 提高代码的可复用性：通过多态性，可以将同一个接口的不同实现作为不同的模块，方便代码复用和维护。
2. 提高代码的可扩展性：多态性能够很好地支持代码扩展，可以在不改变原有代码的情况下，通过添加新的实现类或子类，扩展代码的功能。
3. 提高代码的灵活性：多态性让程序在运行时根据实际情况决定调用哪个方法或实现，使程序更加灵活。

多态性缺点

1. 可能会降低程序的执行效率：由于在运行时需要判断对象的实际类型，可能会增加程序的运行时间和内存开销。
2. 可能会增加程序的复杂性：多态性使得程序变得更加抽象和难以理解，需要程序员对代码有更深入的理解和把握。

3、Java 多态性的适用场景

1. 接口和抽象类的使用：接口和抽象类定义了一组抽象的方法，具体的实现由子类实现，从而实现多态性。
2. 方法的重载和重写：方法重载是指在同一个类中定义了多个同名但不同参数类型和个数的方法，方法重写是指在不同的类中定义了同名同参数类型和个数的方法，这两种方式都可以实现多态性。
3. 泛型编程：泛型编程可以使用参数化类型来编写通用的代码，提高代码的复用性和扩展性。
4. 运行时类型识别：通过运行时类型识别，可以在运行时根据对象的实际类型动态地选择调用哪个方法或实现，实现多态性。

4、Java 多态性的不适用场景

1. 构造函数不具有多态性：构造函数是创建对象的方法，在对象创建之前就已经确定了对象的类型，因此构造函数不具有多态性。
2. 静态方法不具有多态性：静态方法是类的方法，不属于对象，在编译时就已经确定了调用的方法，因此静态方法不具有多态性。
3. final 方法不具有多态性：final 方法在编译时就已经确定了调用的方法，不能被子类重写，因此不具有多态性。
4. private 方法不具有多态性：private 方法只能在本类中调用，不能被子类调用，因此不具有多态性。

5、学习 Java 的多态性应注意哪些问题

1. 熟悉继承和多态的概念：多态性是基于继承实现的，因此必须先掌握继承的概念和使用方法。

2. 熟悉抽象类和接口：在实现多态性时，抽象类和接口是非常重要的工具。因此，必须熟悉如何定义和使用抽象类和接口。

3. 理解动态绑定的概念：多态性实现的关键是动态绑定，即在运行时动态地选择适当的方法。因此，必须理解动态绑定的原理和机制。

4. 理解重写方法的概念：在多态性中，子类可以重写父类的方法。因此，必须理解如何在子类中重写方法，以及如何在子类中调用父类的方法。

5. 熟悉多态性的应用场景：多态性可以应用于很多场景，比如实现不同类型的数据结构、实现多种算法、实现插件架构等。因此，必须熟悉多态性的应用场景，以便在实际编程中灵活应用。

6. 注意多态性的性能问题：多态性是基于动态绑定实现的，因此会带来一定的性能开销。因此，在设计和实现程序时，应注意多态性的性能问题，避免出现性能瓶颈。

   动态绑定：Java 中的动态绑定是指在程序运行期间根据对象的实际类型进行方法调用的过程。具体来说，Java 中的动态绑定是通过虚拟方法表实现的，当程序执行时，虚拟机会根据对象的实际类型在虚拟方法表中查找方法，以确定调用哪个方法。

   Java 中的动态绑定可以实现多态性，使得不同类型的对象可以以同样的方式进行方法调用，这大大提高了代码的复用性和灵活性。同时，动态绑定还可以提高代码的可维护性和可扩展性，因为只需要修改方法的实现，而不需要修改调用该方法的代码。

   需要注意的是，动态绑定只适用于实例方法，静态方法和 final 方法不会被动态绑定，因为它们的调用是在编译期间就被解析的。此外，动态绑定也会带来一些性能损失，因为每次调用方法时都需要在虚拟方法表中进行查找，而这个过程是比较耗时的。

6、Java 中多态性的最佳实践是什么

1. 使用接口或抽象类定义多态类型：在程序设计时，应当优先考虑定义接口或抽象类作为多态类型，这样可以提高代码的可扩展性和可维护性，同时还能降低代码的耦合度。
2. 遵循里氏替换原则：子类必须能够完全替换掉父类，并且不影响程序的正确性，这就是里氏替换原则。在实际开发中，应当遵循里氏替换原则，确保程序能够正确地使用多态性。
3. 尽量使用抽象类而不是具体类作为多态类型：抽象类可以定义一些通用的行为，而具体类则会实现这些行为，因此使用抽象类作为多态类型可以更好地实现代码复用。
4. 尽量使用方法重写而不是方法重载：在实现多态性时，应当优先考虑使用方法重写而不是方法重载。方法重载只是在同一个类中实现多态性，而方法重写可以在不同的类中实现多态性，提高了程序的可扩展性。
5. 使用向上转型进行参数传递：在实际开发中，应当使用向上转型进行参数传递，这样可以降低代码的耦合度，提高程序的可维护性和可扩展性。
6. 避免类型检查和类型转换：在实现多态性时，应当避免使用类型检查和类型转换，因为这样会降低程序的可维护性和可扩展性。如果必须要使用类型检查和类型转换，应当尽量将它们封装到一个方法中，避免在程序中重复使用。