一、继承

1.关键字

extend

2.使用时机

如果一个类与另一个类在许多方面有相似关系，则可以使用到继承。比如说将一辆车抽象为一个类，它的成员属性有轮子wheels，车灯lights，它的功能可以开run。如果说还有一个类奥迪Audi，它具备车的属性，但是又有额外的自己的功能，这时候就要用到继承，即——用到额外的成员变量，增加功能

3.使用规则

（1）Java里面规定，只能继承于一个类，即单继承
（2）子类可以继承父类的属性和方法，不能继承父类的构造方法
（3）#子类不能继承父类private的方法
（4）继承后需要重写构造方法，调用super，表示调用父类的属性和方法
（5）super（）表示调用父类的构造方法
如果子类没有重写父类的方法，则默认使用原方法，如果需要变动，则需要重写，这个过程称为重写或者覆盖，重写后就不会再调用父类的该方法了
父类有构造方法，子类必须要调用父类的构造方法，当父类有了非默认构造方法后，子类必须要重写构造方法
构造方法的执行顺序：父类-子类

4.重写规则：

1.两同，针对方法名，方法名相同，参数相同
2.一大，针对修饰符，同一方法，子类修饰符作用域≥父类修饰符作用域
3.两小，针对返回类型，子类的返回值类型必须≤父类的返回值
针对异常，子类抛出的异常必须≤父类抛出的异常

 class Car{
       int wheels;
       int lights;
       public Car(int w,int l){
       this.wheels = w;
       this.lights = l;
    }
       public void run(){
       System.out.println("车能跑");
    }
    }
class Audi extends Car{
       int brand;
       public Audi(int w,int l,int b){
       super(w,l);//部分在父类中已经写好，只需要用super（）调用即可
       this.brand = b;//子类中只需要初始化自己的属性
    }
     public void feeling(){
       System.out.println("开奥迪感觉不错");//子类自己的方法
    }
    }

public class MyCar {
    public static void main(String[] args) {
        Car car = new Car(4,4);
        car.run();
        System.out.println("车有"+car.wheels+"个轮胎"+car.lights+"个车灯");
        Audi audi = new Audi(8,8,666);
        System.out.println("奥迪有"+audi.wheels+"个轮胎"+audi.lights+"个车灯"+"车牌号为"+audi.brand);
        audi.run();//子类继承了父类的run方法，说明子类里面也有该方法，所以可以直接使用
        audi.feeling();
    }
}
/*
运行结果
车能跑
车有4个轮胎4个车灯
奥迪有8个轮胎8个车灯车牌号为666
车能跑
开奥迪感觉不错
*/

5.继承的优缺点

继承的优点：复用性强，减少代码量
缺点：（1）耦合性很大，即依耐性大,比如父类的某一属性如果去除掉，继承于他的所有子类均可能受影响。一串好的代码应遵循“低耦合，高内聚”
（2）由于很多属性需要被继承，故要大量使用public，导致安全性降低

6.继承使用原则

1.尽量让父类属性修饰符为private
2.尽量让父类方法修饰符为private或者final
3.尽量不要在父类的构造方法里面调用可能被子类重写的方法

二、多态

同一个类里面，有多个方法，他们的名字相同，但是参数名不同
子类可以向父类转化，编译和运行的时候是两个东西，不同对象，使用父类的对象来接受子类的对象
使用条件
（1）编译和运行时的对象是有继承关系的
（2）只能是子类对象传给父类对象
在使用的时候如果父类需要使用子类的方法或属性，必须强制转化为对应的子类对象
在使用的时候，其实系统在找子类的对象
在某一对象需要大量使用同一功能的时候，用多态可以减少代码量
比如

     class Car{
       int wheels;
       int lights;
       public Car(int w,int l){
       this.wheels = w;
       this.lights = l;
    }
       public void run(){
       System.out.println("车能跑");
    }
       public void feeling(){
           System.out.println("有车感觉不错");
       }
    }

    class Audi extends Car{
       int brand;
       public Audi(int w,int l,int b){
       super(w,l);
       this.brand = b;
    }
     public void feeling(){
       System.out.println("开奥迪感觉不错");
    }
    }
    
    class Ferrari extends Car{
           int brand;
           public Ferrari(int w,int l,int b){
           super(w,l);
           this.brand = b;
        }
         public void feeling(){
           System.out.println("开法拉利感觉不错");
        }
        }
    
    class Person{
        void feeling(Car car){
            car.feeling();
        }   
    }

public class MyCar {
    public static void main(String[] args) {
          Audi audi = new Audi(8,8,666);
          Ferrari ferrari =new Ferrari (10,10,888);
           Person p = new Person();
          p.feeling(audi);
          p.feeling(ferrari);
    }/*类Person中feeling的参数传递的是父类对象，但是我们在使用的时候传递子类对象就可以使用该方法，系统在运行时就会自动识别。最后运行发现，根本就没有调用父类中的feeling方法*/
}
/*
运行结果为
开奥迪感觉不错
开法拉利感觉不错
*/

多态的使用好处就是可以减少使用重复的方法