多态、抽象类、接口_DAY09

1:多态(掌握)

   （1）多态概念：一种事物的多种形态

   （2）体现：父类的引用指向其子类的实例对象;接口的引用指向其实现类的实例对象

   （3）特点：

          成员方法：编译看左边，运行看右边

             　　 运行：子类重写的方法运行

              　　编译：父类的引用类型必须有该方法

          成员变量：编译看左边，运行看左边

            　　运行：访问的为父类的属性

            　　 编译：父类的引用类型必须有该属性

           　　总结：只有在方法调用的时候，才会判断子类是否重写，重写调用子类方法。其他情况均看父类类型

           　　记忆方法：方法运行看右边，其他看左边

           例子：

/*
    多态：
        一种事物的多种形态
    前提：
        具有继承关系
    特点：
        方法：编译看左边，运行看右边
            运行：子类重写的方法运行
            编译：父类的引用类型必须有该方法        
        变量：编译看左边，运行看左边
            运行：访问的为父类的属性
            编译：父类的引用类型必须有该属性
        只有在方法调用的时候，才会判断子类是否重写，重写调用子类方法。其他情况均看父类类型
                一句话总结：方法运行看右边，其他看左边
*/
class Demo5
{
    public static void main(String[] args) 
    {
        Animal animal = new Animal();      //动物是一种动物
        Animal animal2 = new Cat();           //猫是一种动物，多态：猫的实例对象，父类动物的引用

        //Cat cat2 = new Animal();           //动物是猫，不可以
        Cat cat = new Cat();               //猫是猫

        Animal a = new Cat();
        //成员方法：
        a.eat();   //喵吃了
        System.out.println(a.name);  //巴马
        System.out.println(a.age);   //80
    }
}

class Animal
{
    String name = "巴马";
    int age = 80;
    public void eat(){
        System.out.println("吃了");
    }    
}

class Cat extends Animal
{    
    String name = "加菲";
    int age = 40;
    public void eat(){
        System.out.println("喵吃了");
    }    
}

               多太内存图:

        

    (4)前提：

      　　 A:有继承或者实现关系。

      　　 B:有方法重写。  （重要）

/**
 * 多态的前提条件之一：必须要有方法的覆盖(即重写)
 */
public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.eat();
        // animal.sleep();  //报错,找不到符号,接口中没有sleep()抽象方法
    }
}

//接口
interface Animal {
    public abstract void eat();
}

class Dog implements Animal {
    //继承的方法的重写
    public void eat() {
        System.out.println("狗吃");
    }
    //自己的方法
    public void sleep() {
        System.out.println("夹着尾巴睡");
    }
}

      　　 C:有父类引用指向子类对象， 或者接口的应用指向实现类的对象

    (3)好处和弊端：

      　　 A:好处

           　　扩展性和维护性(是由继承和实现保证)。

/*
    有两个类猪，狗继承动物，均有吃的动作。
    创建多个猪与狗，调用他们吃的功能。
    再来一个猫，创建多个猫的对象，调用猫的吃的功能
*/
class Demo8_4
{
    public static void main(String[] args) 
    {
        
        Pig pig = new Pig();
        Pig pig2 = new Pig();
        Pig pig3 = new Pig();

        Dog dog = new Dog();
        Dog dog2 = new Dog();
        Dog dog3 = new Dog();
        /*
        Animal pig = new Pig();
        Animal pig2 = new Pig();
        Animal pig3 = new Pig();

        Animal dog = new Dog();
        Animal dog2 = new Dog();
        Animal dog3 = new Dog();
        */
        //不需要调用不同的方法，只需要调用同一个animalEat的方法即可
        /*
        MyAnimalTool.pigEat(pig);
        MyAnimalTool.pigEat(pig2);
        MyAnimalTool.pigEat(pig3);

        MyAnimalTool.dogEat(dog);
        MyAnimalTool.dogEat(dog2);
        MyAnimalTool.dogEat(dog3);
        */

        MyAnimalTool.animalEat(pig);
        MyAnimalTool.animalEat(pig2);
        MyAnimalTool.animalEat(pig3);
        MyAnimalTool.animalEat(dog);
        MyAnimalTool.animalEat(dog2);
        MyAnimalTool.animalEat(dog3);

        
        Cat cat = new Cat();
        Cat cat2 = new Cat();
        Cat cat3 = new Cat();
        /*
        Animal cat = new Cat(); 
        Animal cat2 = new Cat(); 
        Animal cat3 = new Cat(); 
        */
        /*
        MyAnimalTool.catEat(cat);
        MyAnimalTool.catEat(cat2);
        MyAnimalTool.catEat(cat3);
        */
        MyAnimalTool.animalEat(cat);
        MyAnimalTool.animalEat(cat2);
        MyAnimalTool.animalEat(cat3);
    }
    /*
    public static void pigEat(Pig p) {
        p.eat();
    }

    public static void dogEat(Dog d) {
        d.eat();
    }

    public static void catEat(Cat c) {
        c.eat();
    }
    */
}
//定义动物类作为父类
class Animal
{
    public void eat(){
        System.out.println("吃");
    }
}
//定义猪与狗作为子类
class Pig extends Animal
{
    public void eat(){
        System.out.println("拱着吃");
    }
}

class Dog extends Animal
{
    public void eat(){
        System.out.println("摇着尾巴吃");
    }
}

class MyAnimalTool
{
    //多个动物均是Animal的子类，所以只需要定义一个方法接受Animal类型即可。从而加入新的动物时，该类代码不需要改动！
    /*
    public static void pigEat(Pig p) {
        p.eat();
    }

    public static void dogEat(Dog d) {
        d.eat();
    }

    public static void catEat(Cat c) {
        c.eat();
    }
    */

    public static void animalEat(Animal a) {
        a.eat();
    }
}
//添加猫类
class Cat extends Animal
{
    public void eat(){
        System.out.println("舔着吃");
    }
}

       　　 B:弊端

           　　　　不能使用子类的特有功能。

/**
 * 多态的前提条件之一：必须要有方法的覆盖(即重写)
 */
public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.eat();
        // animal.sleep();  //报错,找不到符号,接口中没有sleep()抽象方法
    }
}

//接口
interface Animal {
    public abstract void eat();
}

class Dog implements Animal {
    //继承的方法的重写
    public void eat() {
        System.out.println("狗吃");
    }
    //自己的方法
    public void sleep() {
        System.out.println("夹着尾巴睡");
    }
}

    (4)向上转型和向下转型

      　　 A:向上转型

          　　 把子类对象赋值给父类或者接口引用 ，例子：

/*
    向上转型：
        引用变量为父类时，子类实例对象可以自动提升为父类类型。即引用为父类型，可以赋值子类实例对象。
*/
class Demo6 
{
    public static void main(String[] args) 
    {
        Animal a = new Cat();   //多态本身的赋值就是向上转型。
        Cat c = new Cat();

        //method(c);
        //method(new Animal());  不可以
        //method(a);   不可以

        method2(a);
        method2(c);  //向上转型

        Cat c2 = method3();
        Animal a2 = method3();  //向上转型

        //Cat c3 = method4();
        Animal a3 = method4(); 
    }

    public static void method(Cat c) {
        System.out.println(c);
    }

    public static void method2(Animal animal) {
        System.out.println(animal);
    }

    public static Cat method3(){
        //return new Animal();
        return new Cat();
    }

    public static Animal method4(){
        //return new Animal();
        return new Cat();  //向上转型
    }
}
class Animal
{
    String name = "巴马";
    int age = 80;
    
    public void eat(){
        System.out.println("吃了");
    }
    
}

class Cat extends Animal
{    
    String name = "加菲";
    int age = 40;

    public void eat(){
        System.out.println("喵吃了");
    }
    
}

      　　 B:向下转型

          　　　　 把父类或者父接口引用强制转换为子类，例子：

/*
    向下转型：
        将父类强转成子类,前期父类引用指向的对象为子类对象，即必须是多态的引用。
*/
class Demo7
{
    public static void main(String[] args) 
    {
        Animal a = new Cat();
        Animal a2 = new Animal();

        Cat c = (Cat)a;
        //Cat c2 = (Cat)a2;   不可以
    }
}

class Animal
{
    String name = "巴马";
    int age = 80;
    
    public void eat(){
        System.out.println("吃了");
    }
    
}

class Cat extends Animal
{    
    String name = "加菲";
    int age = 40;

    public void eat(){
        System.out.println("喵吃了");
    }
    
}

    (5)多态中的使用成员特点

      　　 A:成员变量

          　　　　 编译运行都看左边

     　　  B:成员方法

           　　　　编译看左边，运行看右边。

     　　 总结： 全部看父类类型，只是在调用该方法时，检查子类是否重写,如果重写，调用之类方法，如果没有重写，调用父类的方法。

      (6)多态的体现形式

      　　 A:具体类多态(几乎不用)

     　　  B:抽象类多态

       　　C:接口多态

2:抽象类(掌握)

    　　(1)多个具体的事物具备相同的方法声明，而方法体不同，我们就只抽取方法声明，然后定义到一个类中。

     　　　　  而一个没有方法体的方法是一个抽象方法，一个类中有抽象方法，该类必须定义为抽象类。

   　　 (2)抽象类的特点：

      　　　　 A:抽象类或者抽象方法用abstract修饰。

       　　　　B:抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。

       　　　　C:抽象类不能被实例化。

       　　　　D:子类继承抽象类，要么是抽象类，要么重写所有父类抽象方法。

        例子：

/*
    抽象类：包含抽象方法的类
*/
class Demo9 
{
    public static void main(String[] args) 
    {
        //Animal a = new Animal();
        Animal a2 = new Pig();
        System.out.println("Hello World!");
    }
}
//定义动物类作为抽象父类
abstract class Animal
{
    public abstract void eat();
    public abstract void sleep();
    //public void sleep(){
    //    System.out.println();
    //}
}
//定义猪与狗作为子类
class Pig extends Animal
{
    public void eat(){
        System.out.println("拱着吃");
    }

    public void sleep(){
        System.out.println("躺着睡");
    }
}
/*
abstract class Dog extends Animal
{
    public void eat(){
        System.out.println("摇着尾巴吃");
    }
}
*/
class Dog extends Animal
{
    public void eat(){
        System.out.println("摇着尾巴吃");
    }
    public void sleep(){
        System.out.println("压着尾巴睡");
    }
}

    (3)抽象类的几个小问题

      　　 A:不能被实例化，要构造方法干啥?

          　　  给抽象类的成员变量赋值

     　　  B:一个类中没有抽象方法，居然定义抽象类，有什么意义?

           　　 强制不让该类创建对象

     　　  C:abstract抽象关键字不能和哪些关键字共存

          　　　　 a:private  抽象类的方法需要被覆盖，如果private修饰的话，子类无法访问

           　　　　b:final   抽象类需要继承，final修饰的无法继承

           　　　　c:static   抽象类抽象方法无方法体，调用无意义

    (4)抽象类的成员：

     　　  A:成员变量 有变量，也有常量

      　　 B:构造方法 有构造方法，用于子类访问父类数据的初始化

      　　 C:成员方法 有抽象方法，也有非抽象的方法

    (5)抽象类的案例

       A:老师案例

       例子：

/*
    老师示例
        具体事物：基础班老师，就业班老师
        共性：姓名，年龄，讲课。
*/
class Test 
{
    public static void main(String[] args) 
    {
        BaseTeacher bt = new BaseTeacher("刘正风",28);
        bt.setName("曲阳");
        bt.teach();
        System.out.println(bt.getName());
        bt.teach();

        WorkTeacher wt = new WorkTeacher("唐嫣",28);
        wt.teach();

        Teacher t = new BaseTeacher("刘正风",28);
        t.setName("曲阳");
        t.teach();
        System.out.println(t.getName());

        Teacher t2 = new WorkTeacher("唐嫣",28);
        t2.teach();
    }
}
//设计抽象概念老师类
abstract class Teacher
{
    private String name;
    private int age;

    public Teacher(){}
    public Teacher(String name,int age){
        this.name = name;
        this.age = age;
    }

    public abstract void teach();

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }
}

//定义基础班老师
class BaseTeacher extends Teacher
{
    public BaseTeacher(){}
    public BaseTeacher(String name,int age){
        super(name,age);
    }

    public void teach() {
        System.out.println("讲JavaSE");
    }
}

//定义就业班老师
class WorkTeacher extends Teacher
{
    public WorkTeacher(){}
    public WorkTeacher(String name,int age){
        super(name,age);
    }

    public void teach() {
        System.out.println("讲JavaEE/Android");
    }
}

3:接口(掌握)

    (1)当一个抽象类中的方法都是抽象的时候，java就提供了一种更抽象的表达方式，叫接口。（接口里面的方法都是抽象的）

         　　 a.定义接口：interface XX {}

         　　 b.使用接口：class YY implements XX{}

          例子：

/*
    比抽象类更为抽象的表现形式
    格式：
    定义接口：interface XX {}
    使用接口：class YY implements XX{}
    
*/
class Demo11
{
    public static void main(String[] args) 
    {
        //Cat cat = new Cat();
        Cat cat2 = new Student();
        Cat cat3 = new Person();
        System.out.println("Hello World!");
    }
}

interface Cat 
{
    public abstract void climb();
}

interface Dog
{
    public abstract void guanxianshi();
}


class Animal
{
}

class Person extends Animal implements Cat,Dog
{
    public void climb(){
        System.out.println("我爬了");
    }

    public void guanxianshi(){
        System.out.println("我就管了");
    }
}

class Student extends Animal implements Cat
{
    public void climb(){
        System.out.println("我爬了");
    }

    public void guanxianshi(){
        System.out.println("我就管了");
    }
}

    (2)接口的成员特点：

      　　 A:成员变量 是常量 默认修饰符 public static final

      　　 B:成员方法 抽象方法 默认修饰符 public abstract

      　　 c: 没有构造方法 （接口不能创建对象）

        例子：

/*
    接口的成员有固定修饰符：
        变量：public static final 将变量变为常量，所以必须显示初始化
        方法：public abstract    一定为公共的抽象方法
*/
class Demo12 
{
    public static void main(String[] args) 
    {
        Computer c = new Person();
        c.play();

        System.out.println(Computer.NO1);
    }
}

interface Computer
{
    //public static final String NO1 = "艾尼阿克";
    String NO1 = "艾尼阿克";
    //public abstract void play();
    //public void play();
    void play();
    //private void play(); 不能使用其他访问权限修饰符

}

class Person implements Computer
{
    
    public void play(){
        System.out.println("敲个猜数字");
    }
    /*  不能使用默认的访问权限覆盖公共的访问权限
    void play(){
        System.out.println("敲个猜数字");
    }
    */
}

    (3)接口的特点：

     　　  A:接口用interface定义

      　　 B:实现类实现接口用implements标识

     　　  C:接口不能被实例化

   　　    D:子类实现接口的时候，要么是抽象类，要么全部实现接口方法

    (4)接口和类的关系

      　　 A:类与类的关系

          　　 　　继承关系,只能单继承，可以多层继承。

      　　 B:类与接口的关系

         　　  　　实现关系，可以单实现，也可以多实现。

           　　　　还可以在继承一个类的同时，实现多个接口。 class A extends B implements C，D

      　　 C:接口与接口的关系

          　　　　 继承关系，可以单继承，也可以多继承。

    (5)接口的思想特点(理解)

     　　  A:对外暴露的规则(USB接口)

     　　  B:程序的扩展功能(多态)

     　　  C:降低程序的耦合性(多态)

      　　 D:让类可以多实现

    (6)接口和抽象类的区别

      　　 共性：都是不断抽取出来的抽象的内容。都不能创建实例对象。

       　　不同：

          　　  A:成员特点

              　　抽象类：

                 　　 　　成员变量 可以变量，也可以常量

                  　　　　成员方法 可以抽象，也可以非抽象

                 　　　　 构造方法 有

             　　 接口：

                 　　　　 成员变量 只能是常量, 固定修饰符public static final

                  　　　　成员方法 只能是抽象,固定修饰符public abstract

                  　　　　构造方法 无

          　 B:继承或者实现关系特点

              　　　　a:类与类的关系(继承 extends)

                 　　　　 继承关系,只能单继承，可以多层继承。

             　　　　 b:类与接口的关系(实现 implements)

                 　　　　 实现关系，可以单实现，也可以多实现。

                 　　　　 还可以在继承一个类的同时，实现多个接口。

            　　　　  c:接口与接口的关系（继承 extends）

                  　　　　继承关系，可以单继承，也可以多继承。

           C:设计区别

             　　 抽象类中定义的是体系的共性内容。表达的是：is a的关系。

             　　 接口中定义的是体系的扩展功能。表达的是：like a的关系。       

       简单总结：

            　　 均为抽取出的相同概念的抽象。都不能创建实例对象。

            　　  类为单继承，接口为多实现。

             　　 继承为”is a”的关系，接口为“like a”的关系。

           　　   抽象类中可以定义非抽象方法，共子类直接使用。接口均为抽象方法，因为固定修饰符。

    (7)如何实现一个继承体系

       分析：由具体到抽象

       实现：由抽象到具体