JAVA学习笔记----nine（多态）

一，多态

1.多态的概述：某一个事物，在不同时刻表现出来的不同状态。
A: 举例：
Cat c=new Cat();
Animal a=new Cat();
B:多态前提
a:要有继承关系。
b:要有方法重写。 其实没有也是可以的，但是如果没有这个就没有意义。
C:案例演示
猫类重写动物类中的方法：

public class Animal {
    private String name;
    private int 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 void eat() {
        System.out.println("吃饭");
    }

    public void sleep() {
        System.out.println("睡觉");
    }
}



public class Cat extends Animal{
    private String name;
    private int age;
    @Override
    public String getName() {
       return name;
    }

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

    @Override
    public int getAge() {
       return age;
    }

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

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

    @Override
    public void sleep() {
        System.out.println("猫爱白天睡觉");
    }

    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}


public class MyTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.setName("汤姆");
        cat.setAge(1);
        System.out.println(cat.getName());
        System.out.println(cat.getAge());
        cat.eat();
        cat.sleep();
        cat.catchMouse();

2.多态中的成员访问特点
a:成员变量
编译看左边，运行看左边。
b:构造方法
创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
c:成员方法
编译看左边，运行看右边。
d:静态方法
编译看左边，运行看左边。
(静态和类相关，算不上重写，所以，访问还是左边的)
3.多态的好处
a:提高了代码的维护性(继承保证)
b:提高了代码的扩展性(由多态保证)
4.多态的弊端以及多态中向下转型
A:通过多态的弊端引出问题
不能使用子类特有的功能
B:解决问题
a:把父类的引用强制转换为子类的引用。(向下转型)

案例演示：
传智播客的老师有基础班的，也有就业班的。
共性：
属性：姓名，年龄
功能：讲课。
现在又要针对日语这种小语种单独开班，
需要部分基础班老师和部分就业班老师会说日语。
请用所学知识把上面的内容用代码体现。

public static void main(String[]ags){
        JiChuTeacher a=new AJiChuTeacher();
        a.name="张老师";
        a.age=27;
        System.out.println(a.name+" 年龄是："+a.age);
        a.teach();
        AJiChuTeacher b=(AJiChuTeacher) a;
        b.JanpanLanguage();
        System.out.println("************************************************");

        JiuYeTeacher c=new AJiuYeTeacher();
        c.name="王老师";
        c.age=25;
        System.out.println(c.name+" 年龄是："+c.age);
        c.teach();
        AJiuYeTeacher d=(AJiuYeTeacher) c;
        d.JanpanLanguage();

    }
}



public interface Interface {
    public abstract void JanpanLanguage();
}



public abstract class Teacher {
     String name;
     int age;
     public abstract void teach();
}

public class JiChuTeacher extends Teacher {
    @Override
    public void teach() {
        System.out.println("讲解基础知识");
    }
}


public class JiuYeTeacher extends Teacher {
    @Override
    public void teach() {
        System.out.println("讲解就业知识");
    }
}




public class AJiChuTeacher extends JiChuTeacher implements Interface {
    @Override
    public void teach() {
        super.teach();
    }

    @Override
    public void JanpanLanguage() {
        System.out.println("经过不懈的努力，学会了日语");
    }
}




public class AJiuYeTeacher extends JiuYeTeacher implements Interface {
    @Override
    public void teach() {
        super.teach();
    }

    @Override
    public void JanpanLanguage() {
        System.out.println("日常学习日语");
    }
}

二，抽象类

1.抽象类的概述及其特点
A:抽象类概述
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
B:抽象类特点
a:抽象类和抽象方法必须用abstract关键字修饰
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();
b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
用于子类访问父类数据时的初始化
d:抽象类不能直接实例化那么，抽象类如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
e:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
案例演示：

public class Test {
    public static void main(String[] args) {
         Animal  a=new Cat();
         a.eat();
         a.sleep();
         Animal b=new Dog();
         b.sleep();
         b.eat();
    }
}


public abstract class Animal {
    public abstract void eat();
    public  abstract  void sleep();
    public abstract  void age();

}


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

    @Override
    public void sleep() {
        System.out.println("猫爱在白天睡觉");
    }

    @Override
    public void age() {
        System.out.println("");
    }
}


public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗爱吃肉骨头");
    }

    @Override
    public void sleep() {
        System.out.println("狗在晚上睡觉");
    }

    @Override
    public void age() {
        System.out.println("");
    }
}

三，接口

1.接口的成员特点
A:接口成员特点
成员变量；只能是常量，并且是静态的。
默认修饰符：public static final
建议：自己手动给出。
构造方法：接口没有构造方法。
成员方法：只能是抽象方法。
默认修饰符：public abstract
建议：自己手动给出。
2.类与类,类与接口,接口与接口的关系
a:类与类：
继承关系,只能单继承,可以多层继承。
b:类与接口：
实现关系,可以单实现,也可以多实现。
并且还可以在继承一个类的同时实现多个接口。
c:接口与接口：
继承关系,可以单继承,也可以多继承。
3.抽象类和接口的区别
A:成员区别
抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象
B:关系区别
类与类
继承，单继承
类与接口
实现，单实现，多实现
接口与接口
继承，单继承，多继承

案例演示：

public class TeacherTest {
    public static void main(String[] args) {
        Teacher a=new JiChuTeacher();
        a.teach();
        JiChuTeacher c=(JiChuTeacher)  a;
        c.setName("xiaoxiao");
        c.setAge(24);
        System.out.println(c.getName());
        System.out.println(c.getAge());
        MyInterface1 e=new JiChuTeacher();
        e.dance();

        Teacher b=new JiuYeTeacher();
        b.teach();
        JiuYeTeacher d= (JiuYeTeacher) b;
        d.setName("liqiang");
        d.setAge(25);
        System.out.println(d.getName());
        System.out.println(d.getAge());
        MyInterface f=new JiuYeTeacher();
        f.sing();
    }
}

public abstract class Teacher {
    public abstract void teach();

}
interface  MyInterface{
    public abstract void sing();

}
interface  MyInterface1{
    public abstract void dance();

}


public class JiChuTeacher extends Teacher implements MyInterface1 {
    private String name;
    private  int 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;
    }

    @Override
    public void teach() {
        System.out.println("讲基础课");
    }

    @Override
    public void dance() {
        System.out.println("我会跳舞");
    }
}


public class JiuYeTeacher extends Teacher implements MyInterface{
    private String name;
    private  int 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;
    }

    @Override
    public void teach() {
        System.out.println("讲就业课程");
    }

    @Override
    public void sing() {
        System.out.println("我还会唱歌");
      }
   }