1. 引言

• 面向对象编程的核心概念
  面向对象编程是模拟人的思维方式来组织代码，便于处理复杂的业务。

面向对象四大核心特征：
封装：将数据和操作数据的方法组合在一起，隐藏内部实现的具体细节，只需要暴露必要的接口。

继承：
一个类获得另一个类的属性和方法，实现代码的复用和拓展，子类继承父类。

多态：
一个接口可以有多种不同的实现方式，运行时候根据具体对象决定调用哪个方法。比如“动物叫这个行为”，可以实现狗汪汪叫，猫喵喵叫，实现方式不同，但是都属于这个行为

抽象：
提取食物的共同特征，忽略实现的具体细节，只关注本质属性。比如定义“车”，特征是轮子，可以行驶等特征，而不是关注具体品牌型号。

2. 继承(Inheritance)基础

2.1 什么是继承

• 继承的定义和概念
  允许一个类（子类）获得另一个类（父类）的属性和方法。子类可以重用父类的代码，添加自己特有的功能或者修改从父类继承来的行为。

提现的是“is a ”的关系，比如Cat is anlimal子类是父类的一种特殊类型。

• Java中继承的语法结构
• class 子类名 extends 父类名 { // 子类的额外属性 // 子类的额外方法 // 重写父类的方法 }

2.2 继承的基本语法

• extends 关键字的使用

//父类定义
class Animal{protected String name;protected int age;public void eat(){System.out.println(this.name+"正在吃饭");}public void sleep(){System.out.println(this.name+"正在睡觉");}
}
//子类继承父类
class Cat extends Animal{private String breed;//子类特有的属性//子类特有的方法public void bark(){System.out.println(this.name+"正在狂叫");}
} 

特点：

• 子类不能继承父类的private（属性和方法)
• 子类可以添加自己特有的成员
• 子类可以重写父类的方法来改变其行为
• 一个父类可以有多个子类
• 一个子类只能有一个直接父类（单继承）

2.3 继承的特性

• 单继承特性(Java不支持多重继承)
• 传递性(A继承B，B继承C，则A也继承C的特性)
• 子类可以扩展父类功能

class Animal{protected String name;protected int age;//构造方法public Animal(String name,int age){this.name = name;this.age = age;}public void eat(){System.out.println(this.name+"正在吃饭");}public void sleep(){System.out.println(this.name+"正在睡觉");}public void showInfo(){System.out.println("名字："+name+",年龄"+age);}//狗继承动物类class Dog extends Animal{private String berrd;public Dog(String name, int age){super(name,age);//调用父类构造方法this.breed = breed ;}//狗独有的行为public void bark(){System.out.println(this.name+"狗在叫");	}//重写父类方法@Overridepublic void showInfo(){super.showInfo();//调用父类构造方法System.out.println("Breed: " + breed);} }//使用示例public class Test{public static void main(String[] args){Dog dog = new Dog("小黑",2,"Black");//调用继承方法dog.eat();dog.sleep();//调用子类方法dog.bakr();dog.sleep();//调用重写的方法dog.showInfo();}}
}

2.4 方法重写(Override)

• @Override注解的作用
  编译时检查、提高代码可读性、防止错误（方法签名不匹配的时候，编译器会报错）

• 重写的规则和限制
  方法名、参数列表必须完全相同
  返回类型可以是父类返回类型的子类
  访问修饰符可以相同或者不同
  static、final、private不能重写
  访问权限不能更严格

// 父类
protected void method() { }// 子类 - 正确
public void method() { }     // 更宽松
protected void method() { }  //  相同// 子类 - 错误
private void method() { }    //  更严格

• 重写与重载的区别
  

//重写
class Animal{public void run(){}
}
class Dog extends Animal{@Overridepublic void run(){}
}
//重载
class Example{public void run(){};public void run(int x){};//参数类型不同
}

2.5 super关键字

• super的作用和使用场景
• 调用父类构造方法
• 调用父类的方法和属性
• 代码示例演示

2.6 构造方法与继承

• 子类构造方法的执行顺序
• 显式调用父类构造方法
• 默认构造方法的继承规则

3. 多态(Polymorphism)详解

3.1 多态的概念

• 多态的定义
  同一个接口可以有多种不同的实现方式

• "一个接口，多种实现"的理解

// 统一的接口
Shape shape;// 多种不同的实现
shape = new Circle();      // 圆形的实现
shape = new Rectangle();   // 矩形的实现  
shape = new Triangle();    // 三角形的实现// 同一个方法调用，不同的执行结果
shape.draw();  // 运行时决定具体绘制什么图形

3.2 多态的实现方式

//方式1：

• 继承 + 方法重写

abstract class Animal{public abstract void bark();
}
class Dog extends Animal {@Overridepublic void bark(){System.out.println("旺旺");}
}
class Cat extends Animal{@Overridepublic void bark(){Systen.out.println("喵喵");}
}
//方式2：
接口实现```java
interface Drawshape{void draw();
}
class Circle implements Drawshape{public void draw(){System.out.println("画圆"); }
}
class Rect implements Drawshape{public void draw(){System.out.println("画方"); }
}
//方式3：
抽象类实现```java
abstract class Vehicle {public abstract void start();public void stop() { System.out.println("停止"); }  // 具体方法
}class Car extends Vehicle {public void start() { System.out.println("汽车启动"); }
}

3.3 多态的语法表现

• 父类引用指向子类对象

// 语法形式：父类型 引用名 = new 子类型();
Animal animal = new Dog();        // 向上转型
Shape shape = new Circle();       //  向上转型
Drawable drawable = new Square(); //  接口引用指向实现类

• 动态绑定(晚期绑定)

Animal animal = new Dog();
animal.makeSound();  // 编译时：不知道具体调用哪个方法// 运行时：动态决定调用Dog的makeSound()

• 方法调用的运行时决定

public void testPolymorphism(Animal animal) {animal.makeSound();  // 运行时根据实际对象类型决定调用
}testPolymorphism(new Dog());  // 输出：汪汪
testPolymorphism(new Cat());  // 输出：喵喵

3.4 多态的优势

//一个方法可以处理多种类型
public void drawShape(Shape shape){shape.draw();shape.calculateArea();
}
//可以处理所有shape的子类
processShape(new Circle());
processShape(new Rectangle());
processShape(new Triangle());

3.5 向上转型与向下转型

• 向上转型(自动类型转换)

// 语法：父类型 引用 = 子类对象;
Animal animal = new Dog("旺财", 2);  // 自动向上转型

• 向下转型(强制类型转换)

Animal animal = new Dog("旺财", 3, "金毛");
Dog dog = (Dog) animal;  // 强制向下转型

• instanceof关键字的使用

Animal animal = new Dog("旺财", 3, "金毛");if (animal instanceof Dog) {Dog dog = (Dog) animal;  // 安全的向下转型dog.bark();              // 调用Dog特有方法
}

4.1 抽象类与继承

• 抽象类的定义和使用

abstract class Vehicle {protected String brand;  // 具体属性public Vehicle(String brand) {  // 构造方法this.brand = brand;}// 抽象方法 - 子类必须实现public abstract void start();public abstract void stop();// 具体方法 - 子类可直接使用public void displayInfo() {System.out.println("品牌: " + brand);}
}

• 抽象方法的继承要求
  规则：
  必须实现：子类必须实现所有抽象方法
  可以重写：子类可以重写具体方法
  继承属性：子类继承父类的属性和具体方法

class Car extends Vehicle {public Car(String brand) {super(brand);}@Overridepublic void start() {  // 必须实现System.out.println(brand + "汽车启动");}@Overridepublic void stop() {   // 必须实现System.out.println(brand + "汽车停止");}
}

4.2 接口与多态

• 接口的多实现特性

// 接口定义
interface Flyable {void fly();
}interface Swimmable {void swim();
}// 类可以实现多个接口
class Duck implements Flyable, Swimmable {@Overridepublic void fly() { System.out.println("鸭子飞行"); }@Overridepublic void swim() { System.out.println("鸭子游泳"); }
}

4.3 final关键字的影响

• final类不能被继承
• final方法不能被重写
• final变量的继承特性

抽象类与接口使用指南

抽象类：当需要提供部分共同实现时
接口：当需要定义行为契约或支持多重继承时

final关键字使用场景

final类：工具类、不可变类（如String）
final方法：模板方法模式中的关键步骤
final变量：常量定义、不可变对象