面相对象三大特性（封装、继承、多态）
面向对象编程（OOP）有三大基本特性：封装、继承和多态。这三大特性共同构成了面向对象编程的基础，使得程序设计更加模块化、可维护和可扩展。
封装（Encapsulation）
封装是将对象的状态（属性）和行为（方法）结合在一起，形成一个独立的单元，也就是类。通过封装，我们可以隐藏对象的内部细节，只暴露必要的接口，这样可以防止外部代码随意修改对象的状态，确保代码的安全性和稳定性。
通俗的讲，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
public class BankAccount {
private double balance; // 通过private修饰符隐藏余额属性
public void deposit(double amount) { // 提供存款方法
if (amount > 0) {
balance += amount;
}
}
public void withdraw(double amount) { // 提供取款方法
if (amount > 0 && amount <= balance) {
balance -= amount;
}
}
public double getBalance() { // 提供查询余额的方法
return balance;
}
}
在上述例子中，BankAccount 类封装了账户余额balance 和操作余额的方法deposit() 和withdraw()。外部代码只能通过这些方法来修改余额，而不能直接访问balance 属性。
在示例中，我们可以看出，实现封装其实主要是控制对象状态（属性）的可见性，Java 中我们靠权限修饰符（关键字）来进行访问控制，权限修饰符共有 4 种，作用范围从小到大依次是：private <缺省值（空着不写） <protected <public。
具体访问权限信息如下：
| private | ||||
| 缺省值 | ||||
| protected | ||||
| public |
继承（Inheritance）
继承就像是给我们的类找了一个“父母”。子类可以继承父类的属性和方法，这样可以避免重复编写相同的代码，同时也能够扩展或修改父类的功能。继承帮助我们构建层次化的类结构，使代码更加清晰和模块化。
Java 中继承使用关键字extends，比如：A extends B，A 称作B 的子类，B 称作A 的父类，继承后
Java 中只支持单继承，也就是A extends B 与A extends C 不能同时存在；但是支持多层继承，而且继承具有传递性，比如A extends B extends C，A 中就同时具有了B 和C 的内容。
public class Animal {
public void eat() {
System.out.println("干饭...");
}
public void sleep() {
System.out.println("倒头就睡...");
}
}
public class Dog extends Animal {
public void bark() {
System.out.println("汪~汪~汪~");
}
}
public class Cat extends Animal {
public void meow() {
System.out.println("喵~喵~喵~");
}
}
如上，Dog 和Cat 类都继承自Animal 类，通过继承它们自动获得了eat() 和sleep() 方法，并且可以添加自己的特征方法bark() 和meow()。
多态（Polymorphism）
“龙生九子，各有不同”，这句话形象地描述了多态的特性。即使是同一个类的子类，各个子类的行为也可以各不相同。多态，也是面向对象中的一个重要特性，在Java 中体现为：
多态的前提：= 为分割的，意思就是编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋值给该变量的对象决定。
为了方便理解，请看如下示例：
public class Animal {
public void eat() {
System.out.println("干饭...");
}
public void sleep() {
System.out.println("倒头就睡...");
}
public static void main(String[] args) {
Animal animal1 = new Dog();
Animal animal2 = new Cat();
// 调用继承父类的方法
animal1.eat(); // 输出 "吃肉..."
animal2.eat(); // 输出 "吃鱼..."
animal1.sleep(); // 输出 "倒头就睡..."
animal2.sleep(); // 输出 "倒头就睡..."
// 调用子类特征方法（需要向下转型）
((Dog) animal1).bark(); // 输出 "汪~汪~汪~"
((Cat) animal2).meow(); // 输出 "喵~喵~喵~"
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃肉...");
}
public void bark() {
System.out.println("汪~汪~汪~");
}
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼...");
}
public void meow() {
System.out.println("喵~喵~喵~");
}
}
该示例中Dog 与Cat 类都继承自Animal，并且重写了父类的eat() 方法。在编译时期，对象类型是基于变量声明的类型，所以dog 与cat 的类型都是Animal，而在程序运行时期，对象的实际类型分别被指定为Dog 与Cat，所以在eat() 方法被调用时输出的是子类重写后的数据。
从示例中我们也可以看出，当父类引用指向子类对象的时候，我们就不能调用子类拥有而父类没有的方法了，调用的时候必须做类型转换，才能使编译通过。在做类型转换时，为了避免ClassCastException 的发生，Java 提供了instanceof 关键字，给引用变量做类型的校验。用法如下：
public static void main(String[] args) {
Animal animal1 = new Dog();
if (animal1 instanceof Dog) {
Dog dog = (Dog) animal1;
dog.bark();
}
}
重载与重写
《Java 核心技术》书中提到：
如果多个方法(比如
StringBuilder的构造方法)有相同的签名、不同的参数， 便产生了重载。StringBuilder sb = new StringBuilder();
StringBuilder sb2 = new StringBuilder("Hello World");编译器必须挑选出具体执行哪个方法，它通过用各个方法给出的参数类型与方法调用时所传递的值类型进行匹配来挑选出相应的方法。如果编译器匹配不到，就会产生编译时错误（这个过程被称为重载解析（
overloading resolution））。Java允许重载任何方法，而不只是构造器方法。
this.method(); ，当需要调用父类方法时需显示使用super.method()进行调用。
重写产生的原因
当父类的某个方法不适合于子类本身的特征行为时，就需要重写父类中应当改变的方法。
方法重写时应该遵循的原则
方法重写时遵循
与父类方法签名相同；
形参列表相同；
子类方法的返回值类型比父类方法的返回值类型更小或相等；
子类方法声明抛出的异常应比父类方法声明抛出的异常更小或相等；
扫描下方二维码
关注
👇👇👇
