目录
前言
一.封装
1.1封装的定义
1.2访问修饰符的使用
二.继承
2.1继承的定义
2.2继承的方法
2.3继承使用注意点
三.多态
3,1多态的定义
3.2动态绑定
3.3方法重写
3.4向上（向下）转型
四.抽象
4.1抽象的概述和定义
4.2抽象的使用
五.接口
5.1接口的意义
5.2接口的定义
总结
?个人主页： tq02的博客_CSDN博客-C语言,Java领域博主
?理想目标：努力学习，向Java进发，拼搏一切，找到一份朝九晚五，有假期的工作，让自己的未来不会有遗憾。
?欢迎各位→点赞? + 收藏⭐ + 评论?+关注✨
本章讲解内容：Java封装、继承、抽象、多态、接口
使用编译器：IDEA
前言
在讲述封装、继承、抽象、多态、接口前，我们得先了解一下，什么是类与对象，类与对象的详细讲解：tq02的类与对象讲解
一.封装
1.1封装的定义
封装，在类里操作，将类的成员变量和成员方法进行封装处理，意义：可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。而对类进行封装我们需要使用访问修饰符，一共分为四种，
| 访问修饰符 | private | default | protected | public |
| 同一包的同一类 | √ | √ | √ | √ |
| 同一包的不同类 | √ | √ | √ | |
| 不同包的子类 | √ | √ | ||
| 不同包的非子类 | √ |
注：1.如果成员变量或者成员方法没有使用封装则是默认使用default修饰符。
2.包是存放多个类的容器，就是防止在工程建立时，和其他人写的类名相同而起冲突。
3.子类是在继承当中可以学到的。
1.2访问修饰符的使用
我们进行四种封装代码实例图
1.private修饰
private修饰的price和name变量，其他类无法访问，只有自己的类里可以进行访问。就例如在BookList类里无法直接访问这两个元素变量。
2.default修饰
default修饰符，是指当你没有标注修饰符时，就默认了default修饰符，而此类的只有同一个包的其他类访问，例如BookList可以访问，但不同包的Student类无法访问。
3.protected修饰符
protected修饰符，类当被修饰了之后，同包下所有的类都可以访问，非同包下的其他包的子类也可以使用。如Student类继承之后也可以使用Book类。
4.public修饰符
public修饰符，一旦使用，所有的类都可以使用，不在乎是否同包。
二.继承
2.1继承的定义
继承是什么？是所有OOP语言不可缺少的组成成分，是面向对象的三大特征之一，继承就相当于，孩子继承父亲的东西（父亲愿意给孩子的东西），关键字是extends，继承父类的成员变量和成员方法，一般是为了减少代码冗余。但是继承也得遵守访问修饰符，一旦不符合，则无法继承。
代码显示：
public class Animal { public String name; public Animal(String name) { this.name = name; } public void eat(String food) { System.out.println(this.name + "正在吃" + food);}}// Cat.javaclass Cat { public String name; public Cat(String name) { this.name = name; } public void eat(String food) { System.out.println(this.name + "正在吃" + food);}}// Bird.javaclass Bird { public String name; public Bird(String name) { this.name = name; } public void eat(String food) { System.out.println(this.name + "正在吃" + food); } public void fly() { System.out.println(this.name + "正在飞 ︿(￣︶￣)︿"); }}可以看得出来，Animal类和cat类还有Bird类，有很多重复的代码，而为了减少大量的冗余代码，我们可以使用继承的手段。
2.2继承的方法
定义方法：
class 子类 extends 父类 {
}
代码实现：
class Animal { public String name; public Animal(String name) { this.name = name;} public void eat(String food) { System.out.println(this.name + "正在吃" + food); }}class Cat extends Animal { public Cat(String name) { // 使用 super 调用父类的构造方法. super(name); }}class Bird extends Animal { public Bird(String name) { super(name);} public void fly() { System.out.println(this.name + "正在飞 ︿(￣︶￣)︿"); }}public class Test { public static void main(String[] args) { Cat cat = new Cat("小黑"); cat.eat("猫粮"); Bird bird = new Bird("圆圆"); bird.fly();}}我们可以看出，Cat类和Bird类的成员变量和成员方法相当于是在Animal类的基础上，扩展出来。
2.3继承使用注意点
使用 extends 指定父类.Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).子类会继承父类的所有 public 的变量和方法.对于父类的 private 的字段和方法, 子类中是无法访问的.子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用所有的类都有一个父类---Object类三.多态
3,1多态的定义
多态是面向对象三大特征最后一个，可以增强程序的扩展性，提高程序的可维护性。而它的主要支撑技术有向上转型、向下转型、动态绑定、方法重写。
3.2动态绑定
即方法与方法的主体在运行时才进行绑定。例如，当父类和子类拥有一个同名的方法（remove），那么定义了an.remove()，remove方法的调用主体是an，但是an只有调用时，才能知道是实例化了哪个类。而这便是动态绑定。
3.3方法重写
当子类和父类的成员方法名相同时，那么子类的成员方法便是方法重写。而当子类的对象实例化之后，使用和父类同名的方法，则使用的子类的方法，不是使用父类的方法。
class Animal { public String name; public void Name(String name) { System.out.println("Animal的名字是"+name);} }class Cat extends Animal { public void Name(String name) { System.out.println("Cat的名字是"+name);}}public class Test { public static void main(String[] args) { Cat cat = new Cat(); cat.Name("小黑");}}该代码的结果是Cat的名字是小黑，由此可见，使用的Cat类的Name方法，而不是Animal类的Name方法。
3.4向上（向下）转型
向上转型和向下转型都是在继承的基础上
class Animal { public String name; public Animal(String name) { this.name = name;} }class Cat extends Animal { public int age; public Cat(String name) { // 使用 super 调用父类的构造方法. super(name); } public void eat(String food) { System.out.println(this.name + "正在吃" + food); }}public class Test { public static void main(String[] args) { Animal cat = new Cat("小黑"); cat.eat();}}从上面代码中，我们可以发现cat是Animal的引用变量，而它指向了子类的对象，这就是向上转型。
注：
cat是Animal类型的引用变量，而对于Animal类型的引用变量来说，是无法得知age子类成员变量的，所以无法使用cat.age=22;进行赋值的。由于cat实际上指向Cat的对象，所以当调用eat()方法时；依然还能显示子类成员方法的信息。public class Animal { protected String name; public Animal(String name) { this.name = name; } public void eat(String food) { System.out.println("我是一只小动物"); System.out.println(this.name + "正在吃" + food); }}public class Bird extends Animal { public Bird(String name) { super(name); } public void eat(String food) { System.out.println("我是一只小鸟"); System.out.println(this.name + "正在吃" + food); } public void fly() { System.out.println(this.name + "正在飞"); } public static void main(String[] args) { Animal animal = new Bird("圆圆"); //强制转换为Bird类型 Bird bird = (Bird)animal; bird.fly(); }}从上面代码中，我们可以很明显的发现向下转型需要通过强制类型转换完成。虽然animal是Animal父类的引用变量，但是将animal强制转换为Bird类型便为向下转型。但是并不安全，因为向下转型可能会不正确，例如原本向下转型为Cat类，但却转型为了Bird类，这便会产生危险性。
解决方法：
Animal animal = new Cat("小猫");if (animal instanceof Bird) {Bird bird = (Bird)animal;bird.fly();}instanceof 可以判定一个引用是否是某个类的实例. 如果是, 则返回 true. 这时再进行向下转型就比较安全了。
结论：1.向上转型时，是父类的引用变量指向了子类的对象，当然，无法使用子类的新增成员（变量和方法），但是如果使用父类的成员方法，如果子类有该方法的重写，则使用重写的方法，若无，则使用父类方法。
2.向下转型时，则需要强制类型转换。
四.抽象
4.1抽象的概述和定义
抽象类，关键字为abstract，如果所有的子类都要重写父类的某个方法时，父类的方法可以为抽象方法，直接声明，不需要结构体。而含有抽象方法的类，则为抽象类
定义方法：
public abstract 类名{
String name;
public abstract void 方法名();
}
4.2抽象的使用
抽象类存在的最大意义就是为了被继承.
抽象类不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法。
abstract class Animal { public String name; public Animal(String name) { this.name = name;} public abstract void eat(String food); //抽象方法，子类一定要重写}class Cat extends Animal { public Cat(String name) { // 使用 super 调用父类的构造方法. super(name); //重写父类的抽象方法 public abstract void eat(String food){ System.out.println("猫吃"+food); } }}class Bird extends Animal { public Bird(String name) { super(name);} //重写父类的抽象方法 public abstract void eat(String food){ System.out.println("鸟吃"+food); }}public class Test { public static void main(String[] args) { Cat cat = new Cat("小黑"); cat.eat("猫粮"); Bird bird = new Bird("圆圆"); bird.fly();}}抽象的重点知识：
抽象类不能直接实例化。抽象方法不能是 private 的。抽象类中可以包含其他的非抽象方法, 也可以包含字段. 这个非抽象方法和普通方法的规则都是一样的, 可以被重写,也可以被子类直接调用。五.接口
5.1接口的意义
接口是为了弥补代码无法多继承，只能单继承的问题。例如定义了一个Animal的父类，和Cat、Bird、Dog、Wolf的子类，可是你想啊，狗和猫是宠物，或许有共同的方法，定义一个宠物类，那么可以通过接口实现不相关类的相同行为。
好处：
利于代码的规范，目的是给开发人员一个清晰的指示，告诉他们哪些业务需要实现；同时防止由于开发人员随意命名而导致命名不清晰和代码混乱，影响开发效率。 是有利于对代码进行维护，定义一个接口，把功能菜单放在接口里，然后定义类时实现这个接口。是保证代码的安全和严密。5.2接口的定义
定义方法：
public interface 接口名{ }
使用接口：
class 类名 implements 接口名{ 方法体 }；
代码实现：
class Animal { public String name; public Animal(String name) { this.name = name; } } //定义接口public interface Eat { public void eat(String food);} //使用接口class Dog extends Animal implements Eat{ public int age; public Cat(String name) { // 使用 super 调用父类的构造方法. super(name); } public void eat(String food) { System.out.println(this.name + "正在吃" + food); }} //使用接口class Cat extends Animal implements Eat{ public int age; public Cat(String name) { // 使用 super 调用父类的构造方法. super(name); } public void eat(String food) { System.out.println(this.name + "正在吃" + food); }}public class Test { public static void main(String[] args) { Animal cat = new Cat("小黑"); cat.eat();}}接口的重点：
接口的方法体若为空，则为空实现。一个类可以有多个接口。接口里所有的方法都是public和抽象的，所以可以省略public和抽象的。接口无法被实例化。接口可以被继承总结
继承是多态、抽象的基础，而学会了抽象，才能理解接口。而这些知识都是Java最为重要的面向对象三大特征的。只有细心学习，才能更近一步，在Java上才能算正式起步。