JAVA-SE-封装，继承和多态

一，封装

1.1封装的定义和意义

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

简单来说，封装就是为了隐藏实现的过程，类似于方法，你可以通过已有的方法来得到你想要的值，但是你不知道它是如何实现的，再具体一点就是，比如一个电脑，你可以通过键盘，鼠标等对象来使用电脑，但是你不知道电脑的内部是如何运行的。

1.2如何实现封装

要想实现封装，就必须要了解访问限定符，在JAVA中一共有4种访问限定符，如下：

访问限定符	同一包中的同一类	同一包中的不同类	不同包中的子类	不同包中的非子类
private	✔️
默认	✔️	✔️
protected	✔️	✔️	✔️
public	✔️	✔️	✔️	✔️

类已经在上一篇博客讲到，就不多说了，我们来讲一讲包：为了管理类，将多个类收集在一起成为一组，称为软件包。我们常见的存在磁盘中的每个文件夹就是一个包。而在一个包中，不能出现同名的类。我们可以通过import 关键字来导入一个类，例如：import java.uitl.Date。

publlic 不用多说所有情况下都可以使用，private 也不用多说只能在当前类中使用，而子类因还没有讲到继承，我们先谈一谈 默认(即不加访问限定符时就是默认) 

二，继承

2.1继承的定义和意义

继承类似于我们常说的遗传，就是将多个对象共有的属性提取出来，写到一个类当中，那么我们就将这个类称为父类，而将用 extends 关键字来继承父类的类称为子类。例如：

//父类
class Animals{
    public String name;
    public int age;
    public String sex;
}

//子类
class dog extends Animals{
    public String colour;
}

继承就是为了减少代码量，实现代码的复用。

2.2继承的语法

我们通过extends关键字来实现继承：

1 一个子类只能继承一个父类

2. 子类会将父类中的成员变量或者成员方法继承到子类中

3. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则没有必要继承。

既然子类能继承父类的成员，那么我们如何在子类中如何访问父类的成员呢？

1.子类与父类没有同名成员变量 / 成员方法时，是谁就访问谁

class Animals{
    public String name;
    public int age;
    public String colour;
    public void A(){
        System.out.println("haha");
    }
}

class dog extends Animals{
    public String colour;
    public void B(){
        System.out.println("heihei");
    }
    public void get() {
        name = "1";//父类
        age = 2;//父类
        colour = "3";//子类
        A();//父类
        B();//子类
    }
}

2.子类与父类有同名的成员变量时，优先访问子类的，遵守就近访问原则

class Animals{
    public String name;
    public int age;
    public String colour;
}

class dog extends Animals{
    public String colour;
    public void get() {
        name = "1";//父类
        age = 2;//父类
        colour = "3";//子类
    }
}

3. 子类和父类有同名的成员方法时，如果成员方法的参数列表相同，就访问子类的方法，如果不同，就按照重写的规则去访问

class Animals{
    public String name;
    public int age;
    public String colour;
    public void A(){
        System.out.println("haha");
    }
}

class dog extends Animals{
    public String colour;
    public void A(){
        System.out.println("heihei");
    }
    public void get() {
        name = "1";//父类
        age = 2;//父类
        colour = "3";//子类
        A();//子类
    }
}

2.3 super关键字

在子类和父类的成员名相同时，如果我们非要在子类中访问父类的成员该怎么办呢？这时候就要使用JAVA中的super关键字了。

与this关键字相似，super关键字是专门用来访问父类的成员，且只能在非静态成员方法中使用，例如：

class Animals{
    public String name;
    public int age;
    public String colour;
    public void A(){
        System.out.println("haha");
    }
}

class dog extends Animals{
    public String colour;
    public void A(){
        System.out.println("heihei");
    }
    public void get() {
        name = "1";//父类
        age = 2;//父类
        super.colour = "3";//父类
        super.A();//父类
    }
}

当我们在写子类的构造方法时，我们要先对父类进行实例化，也就是说要先调用父类中的构造方法，所以子类构造方法的第一句就是super(); ()中有没有参数就看你要调用父类的那个构造方法。例如：

//不要问为什么父类没写构造方法也行，
//问就是因为如果没写，idea会自动提供一个无参的构造方法
class Animals{
    public String name;
    public int age;
    public String colour;
    public void A(){
        System.out.println("haha");
    }
}

class dog extends Animals{
    public String colour;
    public dog(){
        super();
        System.out.println("666");
    }
}

注意：在子类的同一个构造方法中，super(); 和 this(); 不能同时使用

2.3  super和this的区别

相同点：

1. 都是Java中的关键字
2. 只能在类的非方静态法中使用，用来访问非静态成员方法和字段
3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

不同点：

1. this是对当前对象的引用，super则是在子类中对父类的引用

 

2. this(); 在类的构造方法中可以没有，但是super(); 在子类的构造方法中必须有

2.4 在继承下，初始化执行顺序

猜猜如下代码的执行结果：

class A{
    static {
        System.out.println("1");
    }
    {
        System.out.println("2");
    }
    public A(){
        System.out.println("3");
    }
}
class B extends A{
    static {
        System.out.println("4");
    }
    {
        System.out.println("5");
    }
    public B(){
        super();
        System.out.println("6");
    }
}
public class Test {
    public static void main(String[] args) {
        new B();
    }
}

 1.  先执行父类的静态代码块，再执行子类的静态代码块，且只执行一次（之后再new一个同类的对象时，就不再执行）。

2. 然后执行父类的实例代码块，父类的构造方法

3. 最后执行子类的实例代码块，子类的构造方法

2.5 继承方式

 

注意：1. 一个类只能继承一个父类       2. 多层继承最好不要超过3层

2.6 final 关键字

与C语言中的const关键字类似，被其修饰的变量一旦赋值就不能更改，同理，被final 修饰的类也不能被继承。

最后补充一下组合：组合就是将类的实例作为自身的字段

三，多态

2.1 什么是多态

多态就是指同一件事发生在不同对象身上会产生不同的结果，例如：对于吃饭这件事来说，狗吃狗粮，猫吃猫粮，在比如，我们打印一份文件，用黑白打印机打印就是黑白的，用彩色打印机打印就是彩色的。

2.2 重写

重写又称为覆盖，是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程
进行重新编写 , 但是不能改变参数，返回值。简单来说，就是如果你觉的父类的方法不符合你的想法，那么你就可以对他进行重写。但是要注意一下几点：

1. 方法的返回值和参数不能改变，必须与父类相同。只有一种例外，就是返回类型具有父子类关系

2. 重写的方法的权限必须>=父类中方法的权限

3. 被重写的方法不能被static,private,final 修饰

4. 重写的方法最好使用@Override 注解来显式指定，如果上述条件没有达成，可以报错。例如：

    @Override
    public void A() {
        System.out.println("123");
    }

重写与重载的区别：

1. 重写的参数列表不能修改，重载的参数列表必须修改

2.重写的返回值类型不能修改（除非构成父子类关系），重载的返回值类型可改课不改

3.重写的访问限定符必须>=被重写的方法，重载的访问限定符没有要求

4.重写表现了子类与父类的多态性，重载表现了一个类的多态性

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。
动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体

2.3 多态的实现条件

1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法

多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。
例如：

class Printer{
    public int age;
    public void print(){
        System.out.println("打印文件！");
    }
}

class BlackPrinter extends Printer{
    public String A;
    @Override
    public void print() {
        System.out.println("打印黑白文件！");
    }
}
class ColorPrinter extends Printer{
    public String B;
    @Override
    public void print() {
        System.out.println("打印彩色文件！");
    }
}
public class Test {
    public void print(Printer printer){
        printer.print();
    }
    public static void main(String[] args) {
        Test test = new Test();
        test.print(new BlackPrinter());
        test.print(new ColorPrinter());
    }
}

 虽然我们调用的是父类中的方法，但实际调用的确是子类的方法，这种形式我们就称为多态。

2.4 向上转型与向下转型

要想知道为什么会发生多态就必须知道什么是向上转型和向下转型：

向上转型：创建一个子类对象，将其当成父类对象来使用。

向下转型：将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。

看一段代码你就明白了：

public class Test {
    public static void main(String[] args) {
        //向上转型
        Printer printer = new BlackPrinter();
        //向下转型
        BlackPrinter blackPrinter = new BlackPrinter();
        blackPrinter = (BlackPrinter) printer;
    }
}

 注意：向下转型不安全，那上面的举例如果原来printer是ColorPrinter类向上转型得到的，那么就会报错。因此我们可以使用instanceof关键字来提高代码的安全性。例如：

public class Test {
    public static void main(String[] args) {
        //向上转型
        Printer printer = new BlackPrinter();
        //向下转型
        BlackPrinter blackPrinter = new BlackPrinter();
        if(printer instanceof BlackPrinter){
            blackPrinter = (BlackPrinter) printer;
        }
    }
}

向上转型使用场景：1.作为返回值类型   2.作为参数  3.直接赋值

向上转型的注意事项：不能调用子类特有的方法。

2.5 多态的优缺点

优点：1. 能够降低代码的 "圈复杂度", 避免使用大量的 if - else        2.可扩展性强

缺点：代码效率低

补充：不要在构造方法中调用重写的方法。