一、封装

    1、为什么要有封装？

        public class PrivateTest {
            public static void main(String[] args) {
                Animal animal = new Animal();
                animal.legs = -3;
                animal.move(); //动物用 -3 条腿走路...
            }
        }
        class Animal{
            int legs;

            public void move(){
                System.out.println("动物用"+ legs +"条腿走路...");
            }
        }
        解决方案：将legs隐藏起来防止乱来，即把该隐藏的隐藏起来，该暴露的暴露出来。

    2、修饰符

                               修饰符              同类     同包     子类    不同包
        公共的             public                 √          √          √            √
        受保护的         protected            √          √          √
        默认                                            √          √
        私有                private                 √

    3、封装属性

1、成员变量私有化(安全性好)
2、创建共有的getter/setter方法(对外提供接口)
3、在getter/setter方法中加入控制语句(隐藏实现细节)
        class Animal{
            //该隐藏的隐藏起来
            private int legs;

            //该暴露的暴露出来
            public void setLegs(int legs){
                if(legs==2 || legs==4){
                    this.legs = legs
                }
            }
        }

    4、封装方法

1、方法私有化(只能在类内调用)
2、被类内其他方法调用
        class Car{

            //隐藏：改变码表信息
            private void changeMeter(){
            }

            //隐藏：改变轮胎转速
            private void changeSpeed(){
                speed += 30;
            }

            //暴露：挂挡
            public void changeGear(){
                changeMeter();
                changeSpeed();
            }
        }

二、继承

1、为什么需要继承？

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，只要继承(extends)那个类即可。eg：
                             人：
                             姓名
                             年龄
                             性别
                             吃饭()
                             说话()

        学生：               老师：             工人：
        学号                   编号                工号
        学习()                 讲课()             工作()

注意：①java是单继承，可以多层继承
           ②Object是万类之祖

2、语法

        class SonClass extends FatherClass{
        }

3、重写

        override和overload的区别?【背会】
                                                范围                    场景                  语法
            重写(override)       子类继承父类         业务延申             同名同参
            重载(overload)       一个类                   业务重写             同名不同参
        为什么要有重写？
            比如求长方形的面积 和 求长方体的体积，此时需要业务的延伸

4、super关键字

        作用：
            this代表类的实例，super代表父类的实例
            super可以调用父类的属性、方法、构造方法
        案例：
            super.age;
            super.method();
            super(); //子类会隐式调用父类的无参构造，可省略

 5、final关键字

        为什么要有final？
            double PI = 3.14;
            PI = 3.15;//问题：PI是固定值，不应该被修改
        final是什么？
            final可以修饰类、变量、方法
            final修饰的类不能被继承。eg：String
            final修饰的变量不能被修饰，eg：double PI = 3.14
            final修饰的方法不能被重写，eg：Thread.join()

三、多态

 1、为什么要有多态？

        class ZooKeeper{
            /**
             * 问题：因为feed()方法限定了形参的类型，此时需要重载无数次feed()方法
             */
            public void feed(Dog dog){
                dog.eat();
            }

             public void feed(Cat cat){
                cat.eat();
            }
        }

2、什么是多态？

        多态：父类引用指向子类对象
        语法：父类 对象名 = new 子类()

多态存在的三个必要条件：

-继承
-重写
-父类引用指向子类对象

向上转型：多态本身是子类类型向父类类型转换的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转型。
语法格式：
父类类型 变量名 = new 子类类型();

向下转型：向下转型是把已经向上转型的子类对象强制转换回子类类型的类型转换
语法格式：
子类类型 变量名 = (子类类型) 父类变量名;
当使用多态方式调用方法时，想要调用子类特有的方法，就必须向下转型。

编译看左边，运行看右边

 3、instanceof关键字

        a instanceof A：判断对象a是否属于A类的实例，返回boolean