【Java】面向对象的三大特征：封装、继承、多态

封装

什么叫封装？

在我们写代码的时候经常会涉及两种角色： 类的实现者 和 类的调用者。

封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的，只要知道如何使用类就行了，这样就降低了类使用者的学习和使用成本，从而降低了复杂程度。

下面我们来介绍一下在我们Java里的几个访问权限修饰符：

private: 类内部能访问, 类外部不能访问
默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问
protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问
public : 类内部和类的调用者都能访问

使用private实现封装

被 public 修饰的成员变量或者成员方法，可以直接被类的调用者使用。
被 private 修饰的成员变量或者成员方法，不能被类的调用者使用。

封装的本质是：类的使用者根本不需要知道，也不需要关注一个类都有哪些 private 的成员。从而让类调用者以更低的成本来使用类。

代码示例：

class Student{
    private String name = "张三";
    private int age = 20;

    public void show(){
        System.out.println("姓名："+name+" ,年龄："+age);
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Student student = new Student();
        student.show();
    }
}

此时字段已经使用 private 来修饰，类的调用者(main方法中)不能直接使用，而需要借助 show 方法，此时类的使用者就不必了解 Person 类的实现细节。
同时如果类的实现者修改了字段的名字，类的调用者不需要做出任何修改(类的调用者根本访问不到 name， age这样的字段)

注意事项

private 不光能修饰字段, 也能修饰方法。
通常情况下我们会把字段设为 private 属性, 但是方法是否需要设为 public, 就需要视具体情形而定. 一般我们希望一个类只提供 "必要的" public 方法, 而不应该是把所有的方法都无脑设为 public

继承

代码中创建的类, 主要是为了抽象现实中的一些事物(包含属性和方法)

有的时候客观事物之间就存在一些关联关系, 那么在表示成类和对象的时候也会存在一定的关联

这时我们就需要引入父类 , 基类或超类和子类, 派生类，和现实中的儿子继承父亲的财产类似, 子类也会继承父类的字段和方法, 以达到代码重用的效果，从而降低代码的冗余性。

继承的基本语法：

class 子类 extends 父类 {
}

使用 extends 指定父类
Java 中一个子类只能继承一个父类
子类会继承父类的所有 public 的字段和方法
对于父类的 private 的字段和方法, 子类中是无法访问的
子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用

我们来用代码实现一个继承关系：

class Father{
    public String name;
    public int age;
    public char sex;

    public void eat(){
        System.out.println("吃饭");
    }
}

class Son extends Father{
    public void drink(){
        System.out.println("喝水");
    }
}

public class Demo1{
    public static void main(String[] args) {
        Son son = new Son();
        son.name = "张三";
        son.age = 20;
        son.sex = '男';
        son.eat();
        son.drink();
    }
}

运行结果：

我们通过代码很容易看出来：当 Son 类继承了 Father 类后，就相当于把父类里的一些用 public 修饰过的属性和方法给拷贝过来了。

protected 关键字

在上述代码中我们发现, 如果把字段设为 private, 子类不能访问. 但是设成 public, 又违背了我们 "封装" 的初衷。所以我们就有个两全其美的办法：就是使用 protected 关键字。

对于类的调用者来说, protected 修饰的字段和方法是不能访问的
对于类的子类和同一个包的其他类来说, protected 修饰的字段和方法是可以访问的

Final关键字

ﬁnal 关键字, 修饰一个变量或者字段的时候, 表示常量 (不能修改)

final int a = 10;
a = 20; // 编译出错

ﬁnal 关键字也能修饰类, 此时表示被修饰的类就不能被继承

当我们用 final 修饰 Father 类后，再想用 Son 类继承 Father 类就发生报错了

组合

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。

代码示例:

class Student {

}
class Teacher {

}
class School {
    public Student[] students;
    public Teacher[] teachers;
}

组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段.这是我们设计类的一种常用方式之一.

多态

向上转型

代码示例：

class Father{
    
}
class Son extends Father{
    
}
public class Data {
    public static void main(String[] args) {
        Father f1 = new Father();
    }
}

向上转型发生的时机：

直接赋值
方法传参
方法返回

直接赋值的方式我们已经演示了. 另外两种方式和直接赋值没有本质区别

方法传参

代码示例：

class Father{

}
class Son extends Father{

}
public class Data {
    public static void func(Father f1){
        
    }
    public static void main(String[] args) {
        func(new Son());
    }
}

方法返回

代码示例

class Father{

}
class Son extends Father{

}
public class Data {
    public static Father func(){
        Son son = new Son();
        return son;
    }
    public static void main(String[] args) {
        Father f1 = func();
    }
}

此时方法 func() 返回的是一个 Father 类型的引用, 但是实际上对应到 Son 的实例。

动态绑定

当子类和父类中出现同名方法的时候, 再去调用就会发生动态绑定。

class Father{
    public String name;
    public int age;
    public void eat(){
        System.out.println("正在吃东西");
    }
}
class Son extends Father{
    public void eat(){
        System.out.println("正在吃苹果");
    }
}
public class Data {
    public static void main(String[] args) {
        Father f = new Son();
        f.eat();
    }
}

此时, 我们发现：

f 虽然是 Father 类型的引用, 但是 f 指向 Son 类型的实例。
在调用 eat() 方法的时候，本应该是调用 Father 类里面的方法，实际上调用的是 Son 类里面的方法

因此, 在 Java 中, 调用某个类的方法, 究竟执行了哪段代码 (是父类方法的代码还是子类方法的代码) , 要看究竟这个引用指向的是父类对象还是子类对象. 这个过程是程序运行时决定的(而不是编译期), 因此称为动态绑定。

方法重写

针对刚才的 eat 方法来说:子类实现父类的同名方法, 并且参数的类型和个数完全相同, 这种情况称为覆写/重写/覆盖。

关于重写的注意事项：

1. 重写和重载完全不一样.
2. 普通方法可以重写, static 修饰的静态方法不能重写.
3. 重写中子类的方法的访问权限不能低于父类的方法访问权限.
4. 重写的方法返回值类型不一定和父类的方法相同(但是建议最好写成相同, 特殊情况除外)

重载和重写的区别：

多态

有了面的向上转型, 动态绑定, 方法重写之后, 我们就可以使用多态的形式来设计程序了.我们可以写一些只关注父类的代码, 就能够同时兼容各种子类的情况。

代码示例：打印各种形状

class Shape{
    public void draw(){
        System.out.println("打印一个图形");
    }
}
class Rectangle extends Shape{
    @Override
    public void draw() {
        System.out.println("矩形");
    }
}
class Circle extends Shape{
    @Override
    public void draw() {
        System.out.println("圆形");
    }
}
class Flower extends Shape{
    @Override
    public void draw() {
        System.out.println("❀");
    }
}

public class Data{
    public static void stamp(Shape shape){
        shape.draw();
    }
    public static void main(String[] args) {
        stamp(new Rectangle());
        stamp(new Circle());
        stamp(new Flower());
    }
}

运行结果：

多态顾名思义, 就是 "一个引用, 能表现出多种不同形态"

使用多态的好处是什么?

1) 类调用者对类的使用成本进一步降低

封装是让类的调用者不需要知道类的实现细节.
多态能让类的调用者连这个类的类型是什么都不必知道, 只需要知道这个对象具有某个方法即可

2) 能够降低代码的 "圈复杂度", 避免使用大量的 if - else

3) 可扩展能力更强

向下转型

向上转型是子类对象转成父类对象, 向下转型就是父类对象转成子类对象. 相比于向上转型来说, 向下转型没那么常见,但是也有一定的用途.

代码示例：

class Son extends Father{
    public void eat(){
        System.out.println(name + "正在吃东西");
    }

    public void haha(){
        System.out.println("haha");
    }
}

public class Data{
    public static void main(String[] args) {
        Father f2 = new Son();
        if(f2 instanceof Son){
            Son f3 = (Son)f2;
            f3.haha();
        }else{
            System.out.println("不能转型");
        }
    }
}

如果我们用普通的向上转型的话，是无法使用除了与父类同名的方法外的任何方法，但是我们使用向下转型就可以使用。只是这样一般不安全，所以我们要使用 instanceof 来判断是否正确的引用了子类。

super关键字

前面的代码中由于使用了重写机制, 调用到的是子类的方法. 如果需要在子类内部调用父类方法怎么办? 可以使用super 关键字。

代码示例：

class Father{
    public String name;
    public int age = 20;
    public void eat(){
        System.out.println("正在吃东西");
    }
}
class Son extends Father{
   public int age = 30;
   public void func(){
       System.out.println(super.age);
   }
}
public class Data {
    public static void main(String[] args) {
        Son son = new Son();
        son.func();
    }
}

我们可以看到在我们的子类和父类里都有属性 age ，当我们使用了 super 关键字后就可以访问父类的该属性。

运行结果：