多态中的转型 抽象类 抽象的成员特点 猫和狗（抽象类版） 接口概述 接口的特点

多态中的转型

• 向上转型

  从父到子

  父类引用指向子类对象

• 向下转型

​ 从父到子

​ 父类引用转向子类对象

package Demo4;

public class Animal {
    public  int age = 40;
    public void  eat(){
        System.out.println("动物吃东西");
    }
}

package Demo4;

public class Cat extends Animal{
   public void eat(){
       System.out.println("猫吃鱼");
   }
   public void platGame(){
       System.out.println("猫捉迷藏");
   }
    }

package Demo4;

import java.util.concurrent.Callable;

public class Application {
    public static void main(String[] args) {
    //多态
        Animal a = new Cat();//向上转型
        a.eat();
        //a.platGame;
      //  Cat c =new Cat();
       // c.platGame();
        Cat c = (Cat) a;//向下转型
        c.eat();
        c.platGame();

    }
}

---

抽象类

在java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

---

• 抽象类的特点

抽象类和抽象方法必须使用abstract关键字修饰

public abstract class 类名（）{}

public abstract void eat();

• 抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类
• 抽象类不能被实例化

抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态

• 抽象类的子类

要么重写抽象类中所有的抽象方法

要么是抽象类

package Demo5;

public  abstract class Animal {//抽象类
    public  abstract void eat();//抽象方法
    public void sleep(){
        System.out.println("睡觉");
    }
}

package Demo5;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

package Demo5;

public class Application {
    public static void main(String[] args) {
      //  Animal a = new Animal() ;
       // a.eat();
 Animal a = new Cat();
 a.eat();
 a.sleep();

        }
    }

package Demo5;

public abstract class Dog extends  Animal{
}

---

构造方法的作用是子类访问父类的初始化

父类中的抽象方法就是限定子类去做某些事情

---

抽象的成员特点

• 成员变量

  可以是变量

  也可以是常量

• 构造方法

  有构造方法，但是不能实例化

  构造方法作用：子类访问父类的初始化

• 成员方法

  可以有不抽象方法，限定子类必须完成某些动作

  也可以有非抽象方法：提高代码的复用性

  猫和狗（抽象类版）

  需求：请采用抽象类的思想实现猫和狗的案例，

  思路

  1. 定义动物类

     成员变量 age name

     构造方法 无参 带参

     成员方法 get/set，吃饭

  2. 定义猫类

     继承动物类

     构造方法 ：无参，带参

     成员方法：重写次方（）{…}

  3. 定义狗类

  4. 定义测试类

package Demo6;


public class Cat extends Animal{
    public Cat(){}
    public  Cat(String name,int age){
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

package Demo6;

public class Dog extends Animal{
    public Dog(){}
    public Dog(String name ,int age){
        super(name,age);
    }
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

package Demo6;

public abstract class Animal {
    private String name;
    private int age;
    public Animal(){}
    public Animal(String name,int age){
        this.name = name ;
        this.age =age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;

    }
    public abstract  void eat();
}

package Demo6;

import java.util.concurrent.Callable;

public class Application {
    public static void main(String[] args) {
Animal a = new Cat("小灰猫",5);
     Animal b = new Dog("大灰狗",5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println(b.getName()+","+b.getAge());
        b.eat();
       Cat a1 = new Cat();
       Dog b1  = new Dog();
       a1.setAge(15);
       a1.setName("加菲猫");
       b1.setAge(20);
       b1.setName("跳跳狗");
        System.out.println(a1.getName()+","+a1.getAge());
        a1.eat();
        System.out.println(b1.getName()+","+b1.getAge());
        b1.eat();

    }
}

小灰猫,5
猫吃鱼
大灰狗,5
狗吃骨头
加菲猫,15
猫吃鱼
跳跳狗,20
狗吃骨头

---

---

接口概述

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用

java中接口更多的体现在对行为的抽象

接口的特点

• 接口用关键字interface实现

  public interface 接口名（）{}

• 类实现接口用implements表示

  public class 类名 implements 接口名{}

• 接口不能被实例化

  接口如何实例化呢/ 参照多态的方式，通过实现类对象的实例化，这叫接口多态

  多态的形式：具体类多态，抽象类多态，接口多态

  多态的前提： 有继承或者实现关系；有方法重写；有父类（类、接口)引用指向子类（子/实现）类对象

• 接口的实现类

  要么重写重写接口中所有的抽象方法

  要么是抽象类

package Demo7;
//定义了一个抽象接口
public interface jumping {
   public abstract  void jump();

}

package Demo7;

public class Cat implements jumping{
    @Override
    public void jump(){
        System.out.println("可以跳高了");
    }
}

package Demo7;

public class Application {
    public static void main(String[] args) {
        jumping j = new Cat();
        j.jump();



    }
}

package Demo7;

public abstract class Dog implements jumping {
}