文章目录
一、面向对象的编程1.三大特征2.五大原则(了解即可)二、封装三、继承四、多态1.先描述一下转型2.接下来是抽象类 (abstract)3.接口(interface)一、面向对象的编程
概念：面向对象即OOP(Object Oriented Programming)
以对象作为基本单元来构建系统，具有三大特征和五大原则，先呈上枯燥的概念。
1.三大特征
封装：隐藏对象属性和实现细节，仅对外提供公共访问方式，提高安全性。
继承：提高代码复用性，是实现多态的前提
多态：父接口定义的引用变量指向子类或具体实现类的实例对象，提高代码扩展性
权限类关键字及其适用范围
2.五大原则(了解即可)
单一职责原则SRP：类的功能要单一(Single Responsibility Principle)
开放封闭原则OCP：扩展开放，修改关闭(Open - Close Principle)
里式替换原则LSP：子类可以替换父类出现在父类能够出现的任何地方(the Liskov Substitution Principle)
依赖倒置原则DIP：高层次模块不应依赖低层次模块，他们都依赖于抽象。抽象不应依赖于具体实现，具体实现应依赖于抽象(theDependency Inversion Principle）
接口分离原则ISP：设计时采用多个与特定客户类有关的接口比一个通用接口要好(the Interface Segregation Principle)
二、封装
核心思想：隐藏细节，保护数据安全
通过 private(私有权限) 对对象的属性进行封装操作，只有在同一类中才能直接访问，不同类中需要创建一个对应的对象才能获取和修改该属性
// 代码呈现public class Encapsulation {// 成员属性私有化private String name;//提供 getter 和 setter 方法来访问public String getName() {// 获取return name;}public void setName(String name) {// 修改this.name = name;}}class Test {public static void main(String[] args) {Encapsulation test = new Encapsulation();// 通过 setter 方法设置属性值test.setName("封装");// 通过 getter 方法获取值System.out.println("测试" + test.getName());}}
三、继承
1.核心思想：解决代码冗余，提高代码复用性
2.继承关系：满足 is-a 关系(继承关系，a is-a b, b 就是 a 的父类)，父类更通用，子类更具体。
但 Java 中不允许多重继承 (只能单继承) ，子类会继承父类的所有属性和方法，private 属性和方法虽然可以继承，但无法直接使用
(隐式继承)
相当于DNA的继承关系，显性基因和隐性基因
3.继承是向上转型的必要条件，是实现多态的基础。
// 将子类中重复部分提取为父类public class Animal {// "动物名"和其所需"食物"就是我们描述一个"动物吃什么"的重复部分private String name;private String food;// 在此赋值public Animal(String name,String food) {this.name = name;this.food = food;}// 无参构造public void eat() {System.out.println(name + "正在吃" + food);}}// 子类继承父类，对父类进行扩展public class Dog extends Animal {// 继承动物类变成 狗 子类public Dog(String name,String food) {// 通过 super 关键字向上调用 Animal 类的无参构造super(name,food);}}public class Cat extends Animal {// 继承动物类变成 猫 子类public Dog(String name,String food) {super(name,food);}}public Static Test {public static void main(String[] args) {// 创建一个 猫子 对象Animal cat = new Cat("三三","鱼");// 调用该对象的 吃 的方法cat.eat();Animal dog = new Dog("二哈","香肠");dog.eat();}}
四、多态
1.核心思想：提高代码可维护性和可扩展性
2.实现多态的三个必要条件：继承、重写、父类引用指向子类对象(向下转型)
3.多态的实现方法：重写、接口、抽象类和抽象方法
1.先描述一下转型
注：毫无关系的两种类型不能作为方法重写的返回值，例如：父类中的 int 返回值，子类中的 boolean 返回值，不算方法重写。
值得注意的转型报错
Animal cat = new Cat;// 向上转型，相当于又创建一个猫子对象Cat cat1 = (Cat)cat;// 向下转型，编译和运行不会出错，cat 指向的是子类对象Animal cat = new Animal();// 直接指向父类，相当于创建了一个新的 Animal 对象Cat cat2 = (Cat)cat;// 不安全的向下转型，转型报错"java.lang.ClassCastException:"
转型示例代码
public class Animal {public void sleep() {System.out.println("zzz...");}public static void main(String[] args) {Animal cat = new Cat(); // 向上转型Cat.sleep(); // Me zzz...Animal dog = new Dog(); // 向上转型dog.sleep(); // You zzz...//dog.speak(); // error : Dog 类独有的说话方法，Animal 类中没有此方法Dog doge = (Dog)dog; // 向下转型 才能获取狗子类的独有方法doge.speak(); // 狗子说话了，看它说了什么(doge)}}class Cat extends Animal {@Overridepublic void sleep() {System.out.print("Cat zzz...");}//public void speak() {//System.out.print("I am cat");//}}class Dog extends Animal {@Overridepublic void sleep() {System.out.print("Dog zzz...");}public void speak() {System.out.print("You are Doge");}}
2.接下来是抽象类 (abstract)
抽象类是普通类的"超集"，只是比普通类多了一些抽象方法(普通类有的抽象类全都有)
1.核心思想：让代码有更强的扩展性
2.特点：
(1) 抽象类不能实例化对象 (new)；
(2) 如果一个类包含抽象方法，那么该类必须是抽象类，但抽象类不一定包括抽象方法；
(3) 任何子类都必须重写父类的抽象方法(子类是普通类)，一个子类只能继承一个抽象类 (单继承)；
(4) 抽象方法不能与final关键字同时出现，因为抽象类方法必须被覆写，也不能被static修饰，构造方法也不能声明为抽象方法；
(5) 抽象类中的抽象方法只有方法声明，每方法体 ({})；
注意：本地方法 native 没有方法体，不是抽象方法
public abstract class Sharp {public abstract void print(); // 该 print 方法没有方法体，是空实现}
抽象方法示例
abstract class A {abstract void printA();}// B 是抽象类，可选择覆写父类抽象方法abstract class B extends A {abstract void printB();//若 B 中已经覆写了 A 的抽象方法，则 C 中不需要覆写@Overridevoid printA(){}}// C 是普通类，必须覆写 B 中的所有抽象方法Class C extends B {@Overridevoid printB() {}}
3.接口(interface)
比抽象类更加纯粹的抽象概念
1.使用 interface 关键字定义，子类实现接口使用 implements , 接口之间存在继承关系，接口不能继承一个类
2.接口定义时，public | abstract | final | static都可以省略
3.接口允许多实现，一个类具备多个能力，同时实现多个父接口
public C extends A implements IB,IC...{}
模拟接口应用
// 接口使用 interface 关键字定义，只有全局常量(1%接口)和抽象方法(99%都是抽象方法)public interface USB {// 插入public abstract void plugIn();// 工作public abstract void work();}// 鼠标public class Mouse implements USB {@Overridepublic void plugIn() {System.out.println("鼠标驱动安装中...");}@Overridepublic void work() {System.out.println("鼠标正常工作...");}}// 键盘public class Keybroad implements USB {@Overridepublic void plugIn() {System.out.println("键盘驱动安装中...");}@Overridepublic void work() {System.out.println("键盘开始正常工作...");}}//启动public class Computer {public static void main(String[] args) {Computer computer = new Computer();Mouse mouse = new Mouse();// 插入鼠标computer.fun(mouse);Keyboard keyboard = new Keyboard();// 插入键盘computer.fun(keyboard);}// 向上转型只是为了兼容所有 USB 类的对象// fun(Mouse mouse) -> 这个接口只能插鼠标，键盘无法被识别，这是两个无关类public void fun(USB usb) {usb.plugIn();usb.work();}}
接口和抽象类的区别：
1.抽象类是一个非常严格的 is-a 关系，子类和抽象类是一棵继承树上的关系
2.接口和实现子类更多是水平方向，表示混合关系，一个子类通常会具备多个能力或者行为
