Java面向对象之继承和多态

继承

1.使用extends关键字 eg：A extends B 两则之间的关系是 ：子类 is a 父类。
2.在一组相同或类似的类中，抽取出共性的特征和行为，定义在父类中，实现重用。
3.产生继承关系后，子类可以使用父类中的属性和方法，也可以定义自己的独有属性和方法。
4.完整的子类=父类共性+子类独有。
5.Java为单继承，一个类只能继承一个父类，但是可以多级继承，属性和方法逐级叠加。

public class Test1 {
        public static void main(String[] args) {
            Dog dog=new Dog();
            dog.eat("二哈","骨头");
            dog.sleep("二哈");
            dog.run("二哈");
        }
    }

class Animal{
     public String name;
     public int age;
     public String sex;
     public String food;
 public  Animal(){
     System.out.println("父类构造方法被执行");
 }

 public void eat(String name,String food){
     System.out.println(name+"在吃"+food);
 }

 public void sleep(String name){
     System.out.println(name+"在睡觉");
 }
}

class  Dog extends  Animal{
     public Dog(){
         System.out.println("子类构造方法被执行");
     }
     
     public void run(String name）{
     System.out.pringln(name+"在公路上飞快地跑着")
     }
}

运行结果如图：
Dog类继承了Animal类的属性和方法，也可以定义自己的方法

Super

父类对象的引用
1.super（）显示的调用父类的构造方法
2.super.data;显示调用或访问成员变量
3.super.fun() 显示调用父类的方法

重写（override）

1.方法名称相同
2.参数列表相同（个数和类型）
3.返回值也要相同
4.final修饰的方法构成协变类型，不能被重写
5.如果当前方法为静态，不能被重写
6.子类重写父类方法时，访问修饰符一定要大于或等于父类的访问修饰符
7.当父类中访问限定修饰符为private时，不能被重写

class Animal{
  public  String name;
  public Animal(){}
  public void eat(String name){
    System.out.println(name+"在吃饭")    
  }

class Cat extends Animal{
  public void eat(String name){
  System.out.println(name+"在吃鱼");//此时构成了对父类方法的重写
  }
}  

重载（overload）

1.方法名相同
2.参数列表不同（个数和类型）
3.返回值不做要求

class Animal{
  public  String name;
  public Animal(){}
  public void eat(String name){
    System.out.println(name+"在吃饭")    
  }

class Cat extends Animal{
  public String food;
  public void eat(String name ,String food){
  System.out.println(name+"在吃"+food);//此时构成了对父类方法的重载
  }
  public class Test{
    public static void main(String[] args){
    Cat cat=new Cat();
    cat.eat("加菲猫","披萨");
    }
}
}  

结果如下：

多态

概念：
1.父类引用指向子类对象，从而产生多种形态。
2. 构成多态的前提，二者之间必须具有直接或间接的继承关系，父类引用可指向子类对象，进而形成多态。
3. 父类引用仅可调用父类中所声明的属性和方法，不可调用子类独有的属性和方法。

class Animal{
  public String name;
  public Animal(){}
  public vodi eat(String name){
     System.out.println(name+"在吃饭");
   }
}
class Fish extends Animal{
   public Fish(){}
   public void eat(String name){
     System.out.println(name+"在吃鱼料");
  }
   public void swim(String name){
     System.out.println(name+"在海里游泳");
  }
} 

public class Test{
   public static void main(String[] args){
       Animal animal=new Fish();//此时形成多态，也称向上转型
       animal.eat();
   }
}

动态绑定

1.一定要发生向上转型（父类引用指向子类对象）
2.父类和子类具有同名的重写/重载/覆写方法
3.通过父类的引用来调用子类和父类这个同名的覆盖方法，就会发生动态绑定，也称运行时绑定

抽象类

包含抽象方法的类，称为抽象类，被abstract修饰的方法称为抽象方法

抽象类和普通类的区别

1.抽象类可以被继承，也可以向上转型，动态绑定，普通类不行
2.抽象类不可以被实列化，普通类可以实列化
3.抽象类当中的方法一定要被子类重写
4.如果一个抽象类被另一个抽象类所继承，那么可以不重写这个抽象方法，，但是如果这个抽象类被一个普通类继承的话，那么一定要重写抽象方法
5.抽象方法不能是private
6.抽象类可以包含普通方法
7.抽象类不能被final修饰

接口

接口：使用关键字interface来修饰的

抽象类和接口的区别

1.接口当中的方法默认是public abstract 不能有具体的实现
2.接口不能实列化
3.接口中的方法默认是public static final
4.类和接口直接关系是implements，此时接口当中的所有方法都要被重写
5.接口也可以向上转型，运行时绑定（动态绑定）
6.JDK1.8开始，接口中的方法可以具体的实现，但是这个方法一定要被default修饰
7.在Java中的一个类可以实现多个接口
8.类和接口是implements，接口和接口之间是extends

public class Test1 {
    public static void funRunning(Running running){running.run();}
    public static void funSwimming(Swimming swimming){swimming.swim();}
    public static void funFlying(Flying flying){flying.fly();}
    public static void funEating(Eating eating){eating.eat();}
        public static void main(String[] args) {
         funRunning(new Robat("阿尔法"));
         funSwimming(new Duke("唐老鸭"));
         funFlying(new Duke("唐老鸭"));
         funRunning(new Duke("唐老鸭"));
         funEating(new Cat("加菲猫"));
        }
    }

class Animal{
     protected String name;
    public  Animal(String name) {
      this.name=name;
    }

}
interface  Running{
    void run();
}

interface  Swimming{
    void swim();
}

interface  Flying{
    void fly();
}
interface  Eating{
    void eat();
}
class  Cat extends  Animal implements Eating{
        public Cat(String name){
           super(name);
        }
    public void eat(){
        System.out.println(this.name+"正在吃披萨");
    }
}

class Robat extends Animal implements Running{
    public Robat(String name){
        super(name);
    }
    public void run(){
        System.out.println(this.name+"超光束奔跑着");
    }

}
class Duke extends  Animal implements Running,Swimming,Flying{
    public Duke(String name){
        super(name);
    }
    public void run(){
        System.out.println(this.name+"正在陆地上跑");
    }
    public  void swim(){
        System.out.println(this.name+"在水里游泳");
    }
    public void fly(){
        System.out.println(this.name+"飞起来了");
    }
}

运行结果如图：