一、封装

定义：封装就是将同一类事物的特性与功能包装在一起，对外暴露调用的接口。

封装可以可以被认为是一个保护屏障，防止该类的代码和数据被外部定义的代码随机访问。并且封装的主要功能在于我们能够修改自己实现的代码，而不用修改哪些调用我们代码的程序片段。

适当的封装可以让我们的代码更容易理解和维护，也加强了代码的安全性。

封装的优点：

1）解耦

2）类内部的结构可以自由修改

3）对成员变量进行更精确的控制

4）隐藏信息，实现细节。

封装的实现步骤：

==》修改属性的可见性（设为private）

==》创建getter/setter方法（用于属性的读写）

==》在getter/setter方法中加入属性控制语句（对属性值进行合法性的判断）

package EncapsulationDemo;/*
 * @author   :James
 * @date     :2020/6/28 14:56
 * @Email    :[email protected]
 * Version   :V1.0
 * @Function :
 */
public class People {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        if (name.length()>10){
            System.out.println("长度过长，请重新输入");
        }else{
            this.name = name;
        }
    }
}

运行结果：

二、继承

概念：继承是子类继承父类的特征和行为，使得子类对象（实例）具有和父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为

生活中的继承：

上图继承关系可以了解到：动物属于父类（或者说基类或超类），食草动物和食肉动物分别是动物的子类（或者说是派生类）。而食草动物和食肉动物分别是子类（派生类）兔子和羊。老虎和狮子的父类。

继承特点：

1）子类可以拥有父类的内容：（都有名称，有五官等等）。

2）子类可以拥有自己专有的内容。（食草动物吃草，就是食草动物专有的内容，食肉动物吃肉，就属于食肉动物专有的内容）

继承的特性

1）子类拥有父类非private的属性、方法

2）子类可以拥有自己的属性和方法，也就是说子类可以对父类进行扩展

3）子类用自己的方式实现父类的方法

4）继承是单继承，也可以是多重继承，但是不能是多继承

5）提高了类的耦合性

关于单继承、多级继承图示：

在继承关系中，如果成员变量重名，则在创建子类对象的时候，有两种访问方式。

1）直接通过子类对象访问成员变量（等号左边是谁，就优先用谁，没有则向上找）

2）间接通过成员方法访问成员变量（该方法属于谁，就优先用谁，没有则向上找）

如何区分子类方法中重名的三种变量？

--》局部变量：直接写成员变量名

--》本类中的成员变量：this.成员变量名

--》父类中的成员变量名：super.成员变量名

【详细例子参照下面的代码：】

继承关键字：Java中使用extends和implements来实现继承，前者多用于类与类之间后者用于类与接口之间的继承。

public class Fu {
    String father="Father";
    int num=12;
    public void methodFu(){
        System.out.println("我是父类的方法");
    }
}

public class Zi extends Fu{
    String son="Son";
    int num=345;
    public void methodZi(){
        int num=123;
        System.out.println("我是子类方法");
        System.out.println(this.num );     //输出结果：345
        System.out.println(super.num );    //输出结果：12
        System.out.println(num );          //输出结果：10
    }
}

public class DemoExtends {
    public static void main(String[] args) {
        Zi zi=new Zi();
        zi.methodZi();                //输出结果：这是子类的方法
        zi.methodFu();                //输出结果：这是父类的方法
        System.out.println(zi.son);   //输出结果：Son
        System.out.println(zi.father);//输出结果：Father
        System.out.println(zi.num);   //输出结果：34535
    }
}

关于成员变量、局部变量和类变量：

类变量（静态变量）：用static修饰的变量成为静态变量，其内容被该类所有对象共享，所有对象中的这个类变量的值都指向相同的一处内存，随便一个对象修改了此处内存的值都会影响其他对象。

成员变量：定义在方法外部，直接写在类当中，整个类都可以调用，如果没有赋值则会有一个默认值，规则和数组一样，成员变量位于堆内存当中。成员变量随着对象的创建而诞生，随着对象的回收而消失

局部变量：定义在方法内部，只有方法中才可以调用，除了方法就不能调用了，局部变量没有默认值，如果想要使用，必须手动进行赋值，其位于栈内存当中。局部变量随着方法进栈而诞生，随着方法出栈而消失。

关于继承过程中的重写：

重写（override）：方法名称一样，参数列表也一样。

重载（overload）：方法名称一样，参数列表不一样。

注意事项：

1）必须保证父子类之间的方法的名称相同，参数列表也相同，@override：写在方法前面，用来检测是不是有效的正确覆盖重写，

2）子类方法的返回值必须【小于等于】父类方法的返回值范围。

3）子类方法的权限必须【大于等于】父类方法的权限修饰符。

重写应用场景：

public class Fu {
    String father="Father";
    int num=12;
    public void methodFu(){
        System.out.println("我是父类的方法");
    }
}

public class Zi extends Fu{
    @Override
    public void methodFu() {
        System.out.println("覆盖了父类的方法");
    }
}

public class DemoExtends {
    public static void main(String[] args) {
        Zi zi=new Zi();
        zi.methodFu();   //输出结果：覆盖了父类的方法
    }
}

三、多态

多态是同一个行为具有多个不同的表现形式或者形态的能力。多态存在的三个必要条件：

1）继承 2）重写 3）父类引用指向子类对象

多态的优点：

1）消除类型之间的耦合关系 2）可替换性 3）接口性

4）灵活性 5）简化性 6）可扩充性

多态实例：

--》接口

public interface InterfaceUSB {
    public abstract void powerOn();
    public abstract void powerOff();
}

--》两个实现类

public class KeypressInterface implements InterfaceUSB{
    @Override
    public void powerOn() {
        System.out.println("键盘已连接");
    }

    @Override
    public void powerOff() {
        System.out.println("键盘已断开");
    }

    public void type(){
        System.out.println("键盘输入");
    }
}

public class MouseInterface implements InterfaceUSB{
    @Override
    public void powerOn() {
        System.out.println("连接鼠标");
    }

    @Override
    public void powerOff() {
        System.out.println("关闭鼠标");
    }
    public void click (){
        System.out.println("鼠标点击");
    }
}

--》主体代码

public class Computer {
    public void powerOn() {
        System.out.println("开机已就绪");
    }

    public void powerOff() {
        System.out.println("已关机");
    }

    //使用USB设备方法，使用接口作为方法的参数
    public void useDevice(InterfaceUSB interfaceUSB) {
        interfaceUSB.powerOn();
        if (interfaceUSB instanceof MouseInterface) { // 一定要先判断
            MouseInterface mouse = (MouseInterface) interfaceUSB; // 向下转型
            mouse.click();
        } else if (interfaceUSB instanceof KeypressInterface) { // 先判断
            KeypressInterface keyboard = (KeypressInterface) interfaceUSB; // 向下转型
            keyboard.type();
        }
        interfaceUSB.powerOff();
    }
}

public class ComputerMain {
    public static void main(String[] args) {
        //创建一个笔记本电脑
        Computer computer=new Computer();
        computer.powerOn();
        //准备一个鼠标供电脑使用
        MouseInterface mouseInterface=new MouseInterface();
        computer.useDevice(mouseInterface);
        //创建一个USB键盘
        KeypressInterface keypressInterface=new KeypressInterface();
        computer.useDevice(keypressInterface);

        computer.powerOff();
    }
}

运行结果：

此多态例子中，KeypressInterface和Mouseinterface实现了InterfaceUSB接口，并且除了实现了powerOn和powerOff方法外还都有各自的方法【keypressInterface的键入方法，MouseInterface的点击方法】，并且在代码中又出现了两个新的知识点，对象的向上转型和向下转型

对象的向上、向下转型

1）对象的向上转型，其实就是多态的写法

格式：父类名称对象名=new 子类名称 (); InterfaceUSB interfaceMouse=new MouseInterface();

含义：右侧创建一个子类对象，把它当做父类来看待使用 【上面代码：创建一个鼠标当接口使用】

2）对象的向下转型，实际则为一个【还原】的动作

注意：【向下转型，需要使用instanceof进行判断，防止出现ClassCastException(类转换异常)错误】

格式 ：子类名称对象名=（子类名称）父类对象；

含义：将父类对象，【还原】成为本来的子类对象