目录

一.继承

1.为什么要有继承

2.继承的概念

3.继承的语法

4.子类中访问父类的成员变量

5.子类中访问父类的成员方法

6.super关键字

7.super和this的区别

8.继承方式

9.final关键字

二.多态

1.多态的概念

2.多态的实现条件

3.重写

一.继承

1.为什么要有继承

Java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，事物之间可能会存在一些关联，那在设计程序是就需要考虑。面相对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。

2.继承的概念

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

例如：猫和狗都属于动物类，有共同的属性（名字，年龄，体重），对他们这些共性进行抽取，实现代码的复用

3.继承的语法

修饰符 class 子类 extends 父类{

}

//狗继承了动物类
class dog extends animal{
//...
}

class Animal{
    String name;
    int age;
    
    public void eat(){
        System.out.println(name+"正在吃饭");
    }
    public void sleep(){
        System.out.println(name+"正在睡觉");
    }
}
class dog extends Animal{
    public void bark(){
        System.out.println(name+"汪汪~~");
    }
}
 class cat extends Animal{
    {
        System.out.println(name+"喵喵~");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name="金毛";
        dog.eat();//属性name和方法eat都是从父类中继承下来的
        dog.bark();
    }
}

1. 子类会将父类中的成员变量或者成员方法继承到子类中了
2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承

4.子类中访问父类的成员变量

1.当父类成员与子类成员不同名时，直接访问

class Base{
    int a;
    int b;
}
class  Derived extends Base{
    int c;
    public void method(){
        a = 10;//访问从父类继承下来的a
        b = 20;//访问从父类继承下来的b
        c = 30;//访问自己的c
    }
}

2.父类成员与子类成员有相同名字时

class Base{
    char a;
    int b;
    int c;
}
class  Derived extends Base{
    int a;
    char b;
    public  void test(){
        a = 100;
        b = 101;
        c = 103;
        System.out.println(a+" "+b+" "+c+" ");
    }
}

输出结果为

则此时打印的a，b的值都为子类成员变量

在子类方法中 或者 通过子类对象访问成员时：
1.如果访问的成员变量子类中有，优先访问自己的成员变量。
2.如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
3.如果访问的成员变量与父类中成员变量同名，则优先访问自己的，即：子类将父类同名成员隐藏了。成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

5.子类中访问父类的成员方法

当没有相同的成员方法时

public class Base {
public void methodA(){
  System.out.println("Base中的methodA()");
}
}
public class Derived extends Base{
  public void methodB(){
    System.out.println("Derived中的methodB()方法");
 }
 
  public void methodC(){
    methodB();     // 访问子类自己的methodB()
    methodA();     // 访问父类继承的methodA()
    // methodD();   // 编译失败，在整个继承体系中没有发现方法methodD()
 }
}

 有相同的成员方法时

public class Base {
public void methodA(){
  System.out.println("Base中的methodA()");
}
public void methodB(){
  System.out.println("Base中的methodB()");
}
}
public class Derived extends Base{
  public void methodA(int a) {
    System.out.println("Derived中的method(int)方法");
 }
  public void methodB(){
    System.out.println("Derived中的methodB()方法");
 }
  public void methodC(){
    methodA();    // 没有传参，访问父类中的methodA()
    methodA(20);   // 传递int参数，访问子类中的methodA(int)
    methodB();    // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到
 }
}

 通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。
通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；如果父类和子类同名方法的原型一致，则只能访问到子类的，父类的无法通过派生类对象直接访问到。

6.super关键字

该关键字主要作用：在子类方法中访问父类的成员。

public class Base {
int a;
public void methodA(){
  System.out.println("Base中的methodA()");
}
public void methodB(){
  System.out.println("Base中的methodB()");
}
}
public class Derived extends Base{
 int a;
  public void methodA(int a) {
    System.out.println("Derived中的method(int)方法");
 }
  public void methodB(){
    System.out.println("Derived中的methodB()方法");
 }
  public void methodC(){
    methodA();    // 没有传参，访问父类中的methodA()
    methodA(20);   // 传递int参数，访问子类中的methodA(int)
    methodB();    // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到
    super.methodB();  //访问到的时子类从父类继承下来的methodB
    super.a; //访问子类从父类继承下来的成员变量
 }
}

在子类方法中，如果想要明确访问父类中成员时，借助super关键字即可。

【注意事项】
1. 只能在非静态方法中使用
2. 在子类方法中，访问父类的成员变量和方法。

7.super和this的区别

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

【不同点】
1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用

2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性

3. this是非静态成员方法的一个隐藏参数，super不是隐藏的参数

4. 在构造方法中：this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造方
法中出现
5. 构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有

8.继承方式

单继承

class A{
...
}
class B extends A{
...
}

多层继承

class A{
...
}
class B extends A{
...
}
class C extends B{
...
}

不同类继承同一个类

class A{
...
}
class B extends A{
...
}
class C extends A{
...
}

不支持多继承，如果不希望继承层次太复杂，可以从语法上进行限制继承，使用final关键字

9.final关键字

1.修饰变量或者成员方法

final int a = 20；
a = 30；//报错

2.修饰类：表示此类不能再被继承

3.修饰方法：表示该方法不能被重写

二.多态

1.多态的概念

通俗来说就是，当不同的对象去完成某个行为就会产生不同的结果

2.多态的实现条件

1.必须在继承体系下

2.子类必须对父类的方法进行重写

3.通过父类的引用调用重写的方法

public class Animal {
  String name;
   int age;
  public Animal(String name, int age){
    this.name = name;
    this.age = age;
 }
  public void eat(){
    System.out.println(name + "吃饭");
 }
}
public class Cat extends Animal{
  public Cat(String name, int age){
    super(name, age);
 }
  @Override
  public void eat(){
    System.out.println(name+"吃鱼~~~");
 }
}
public class Dog extends Animal {
  public Dog(String name, int age){
    super(name, age);
 }
  @Override
  public void eat(){
    System.out.println(name+"吃骨头~~~");
 }
}

public class TestAnimal {
  // 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法
  // 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法
  // 注意：此处的形参类型必须时父类类型才可以
  public static void eat(Animal a){
    a.eat();
 }
  public static void main(String[] args) {
    Cat cat = new Cat("元宝",2);
    Dog dog = new Dog("小七", 1);
    eat(cat);
    eat(dog);
 }
}

当类的调用者在编写 eat 这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并不知道, 也不关注当前的a 引用指向的是哪个类型(哪个子类)的实例. 此时 a这个引用调用 eat方法可能会有多种不同的表现(和 a 引用的实例相关), 这种行为就称为 多态. 

3.重写

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

子类和父类方法要构成重写，子类方法的修饰限定符必须大于等于父类的修饰限定符