零基础学习java------day9------多态，抽象类，接口

1. 多态

1.1  概述：

某一个事务，在不同环境下表现出来的不同状态

如：中国人可以是人的类型，中国人 p = new  中国人（）；同时中国人也是人类的一份，也可以把中国人称为人类，人类  d  =  new  中国人()

1.2 多态的前提和体现

　　1. 有继承关系
　　2. 父类的引用指向子类的对象
　　3. 有方法的重写

public class Test {
    public static void main() {
        Person p = new Teacher(); // 父类的引用指向子类的对象
    }
}
class Person{}
class Teacher extends Person{}

如前几天学习，创建对象应该是如下

Person p = new Person();
Teacher t = new Teacher();

但是现在写成如下，便是父类的引用指向子类的对象

Person p = new Teacher(); //按以前学习此处的p的引用指向应该为new Person

1.3 两种转型

　　向上转型：Person  p = new  Teacher();

　　向下转型：Teacher t = (Teacher)p;

1.4  调用关系

　　1. 同名成员变量：  父类的

　　2. 同名静态方法：  父类的（所以说静态方法不能叫重写，因为调用还是会调用父类的方法，子类中定义的方法不会被调用）

　　3. 同名静态变量：  父类的

　　4. 同名成员方法：  子类的

　　5.子类独有：　　   不能调用

　　6.父类独有：　　   调用父类

案例

class Animal {
    int num = 10;
    static int age = 20;
    public void eat() {
        System.out.println("动物吃饭");
    }
    public static void sleep() {
        System.out.println("动物在睡觉");
    }
    public void run(){
        System.out.println("动物在奔跑");
    }
}
class Cat extends Animal {
    int num = 80;
    static int age = 90;
    String name = "tomCat";
    public void eat() {
        System.out.println("猫吃饭");
    }
    public static void sleep() {
        System.out.println("猫在睡觉");
    }
    public void catchMouse() {
        System.out.println("猫在抓老鼠");
    }
}

class AnimalTest {
    public static void main(String[] args) {
        Animal am = new Cat();//向上转型
        am.eat(); // 猫吃饭
        Animal.sleep();// 动物在睡觉
        am.run();  //动物在跑步
        System.out.println(am.num);// 10
        System.out.println(Animal.age);// 20
        am.catchMouse();// 报错，可知子类独有的方法不能被调用
        System.out.println(am.name);// 报错，可知子类独有的变量不能被调用
        Cat ct = (Cat)am;  //向下转型,调用时就调用子类自己的属性或方法，若没有相关事务就去父类中找
        ct.eat();// 猫吃饭
        Cat.sleep(); // 猫在睡觉
        ct.run(); // 动物在跑步，可见子类中没有的方法会去父类中找
        ct.catchMouse(); // 猫在抓老鼠
    }
}

练习，如何将三个不同类型的蛋放一个篮子里（如鸡蛋，鸭蛋，鹅蛋）

创建3个蛋，分别为鸡蛋，鸭蛋，鹅蛋

public class EggDemo {
    public static void main(String[] args) {
        HenEgg egg1 = new HenEgg();
        DuckEgg egg2 = new DuckEgg();
        GooseEgg egg3 = new GooseEgg();
    }
}
class HenEgg{String name;}
class DuckEgg{String name;}
class GooseEgg{String name;}

比如，将3个蛋放进鸡蛋数组，发现并不能实现，如下图

所以，若没有多态，就实现不了一个篮子放三个鸡蛋，下面是利用多态来解决这个放鸡蛋的问题

public class EggDemo {
    public static void main(String[] args) {
        Egg egg1 = new HenEgg();
        Egg egg2 = new DuckEgg();
        Egg egg3 = new GooseEgg();
        Egg[] eggs = new Egg[]{egg1,egg2,egg3};
    }
}
class Egg{String name;}
class HenEgg extends Egg{String name;}
class DuckEgg extends Egg{String name;}
class GooseEgg extends Egg{String name;}

结合这个例子理解什么是多态？

多态就是多种形态，有时候是蛋，有时候是鸡蛋，所以是多套

Egg egg1 = new HenEgg();   等号左边是蛋右边是鸡蛋

什么时候是鸡蛋，什么时候是蛋呢？

在调用成员方法时，调用的是子类方法，这个时候就是鸡蛋，除了成员方法以外，调用的都是父类的事务，所以是蛋

 多态的应用（同样是这个例子）

public class EggDemo {
    public static void main(String[] args) {
        Egg egg1 = new HenEgg();
        Egg egg2 = new DuckEgg();
        Egg egg3 = new GooseEgg();
        Egg[] eggs = new Egg[]{egg1,egg2,egg3};
//        egg1.born();
//        egg2.born();
//        egg3.born();
        test(egg1);
    }
    public static void test(Egg e) { // 将参数类型定义为父类，传哪个子类就调用哪个子类方法，这样更加灵活，无多态的话每次就需要创建一个对象来实现
        e.born();
    }
}
class Egg{
    String name;
    public void born() {
        System.out.println("生小*");
    }
}

class HenEgg extends Egg{
    String name;
    public void born() {
        System.out.println("生小鸡");
    }
}
class DuckEgg extends Egg{
    String name;
    public void born() {
        System.out.println("生小鸭");
    }
}
class GooseEgg extends Egg{
    String name;
    public void born() {
        System.out.println("生小鹅");
    }
}

1.5  多态的访问特点

 略

面试题1

子类独有的方法不能被调用

面试题2

结果是    我爱你

1..6 多态的好处和弊端

 1.多态的好处 ：

提高了程序的维护性（由继承保证）

提高了程序的扩展性（由多态保证）

 2. 多态的弊端

 不能访问子类特有的功能

 2.  抽象

1.1  抽象类的概述：

 回想前面我们的猫狗案例，提取出了一个动物类。并且我们在前面也创建过了动物对象，其实思想是不对的。为什么呢？因为，我说动物，你知道我说的是什么动物嘛？只有看到了具体的动物，你才知道，这是什么动物。所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，我们也可以推想，不同的动物睡觉的方式应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。在java中，一个没哟方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

1.2 细节

用abstract 修饰的类:

（1）抽象方法格式: 

　　　　abstract 修饰符返回值类型方法名(参数列表);

（2）抽象类的定义格式：

　　　abstract class 类名{}

 1. 抽象类中可以没有抽象方法,有抽向方法的类一定是抽象类
 2. 抽象类不能创建对象,需要使用子类向上转型
 3. 抽象的子类要么实现抽象类中所有的抽象方法,要么自己是一个抽象类
 4. 抽象类有构造方法（为了让子类能够调用，完成数据的初始化）
 5. abstract 不能和final 共存

 案例

抽象类不能创建对象，下面第三行代码会报错

public class AbstractDemo {
    public static void main(String[] args) {
        Animal a = new Animal();
    }
}
// 动物抽象类
abstract class Animal{
    abstract public void sleep();
}

报错如下

抽象类的子类不能有抽象方法，所以需要将这个抽象方法重写

 当在定义一个继承自Animal类的Cat类时，就需要重写Animal类中的抽象方法，如下

// 定义猫类
class Cat extends Animal{
    @Override
    public void sleep() {   //重写sleep方法
        System.out.println("猫站着睡觉");
    }
}

 （3）抽象类的成员特点

　　1. 成员变量：

　　　　可以是变量，也可以是常量

　　2. 构造方法

　　　　有构造方法，但是不能实例化（即不能创建对象），起用于子类访问父类数据的初始化

　　3. 成员方法

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

　　　　也可以有非抽象方法，用于提高代码的复用性（如抽象类中需要额外实现一个功能，若这个类中有很多子类，用抽象方法的话，其子类都要重写这个抽象方法，若代码量特别  　　　　大，将是毁灭性的，这个时候用非抽象方法就没这个问题）

 练习

 1. 定义一个抽象类形状(shape), 包含两个方法，求周长和面积

　  定义一个类长方形，实现抽象类中的方法

　  定义一个圆，实现抽象类中的方法

　  在测试类中测试

public class Exercise1 {
    public static void main(String[] args) {
        Shape s = new Rect(2,4);
        Shape c = new Circle(3);
        result(s);
        result(c);
    }
    public static void result(Shape s) {   
        System.out.println("面积为："+s.getArea());
        System.out.println("周长为："+s.getPerimeter());
    }
}

abstract class Shape{
     public abstract double getArea();
    
     public abstract double getPerimeter();      
}

class Rect extends Shape{  // 继承关系  Is a
    double length;
    double wide;
    public Rect(double length,double wide){
        this.length = length;
        this.wide = wide;
    }
    @Override
    public double getArea() { // 该重写方法的权限要比抽象类声明处的权限要高，声明处是public，所以此处只能是public
        return length*wide;
    }
    public double getPerimeter() {
        return 2*(length+wide);  
    }
}
class Circle extends Shape{
    double r;
    public static final double PI=3.14;
    public Circle(double r) {
        this.r = r;
    }
    public double getArea() {
        return PI*r*r;
    }
    public double getPerimeter() {
        return 2*PI*r;  
    }  
}

2. 定义一个人，张三，男，18岁  手机  其中手机的特性为苹果X ，白色，价格是8888

此处注意点是自己定义一个手机类，当做手机的数据类型 ，即Mobile mobile;  此处为组合关系  has a

public class PersonTest {
    public static void main(String[] args) {
        Mobile mobile = new Mobile("苹果X","白色",8888);
        Person p = new Person("张三",'男',18,mobile);
        System.out.println("我的名字叫"+p.name+",性别:"+p.gender+",年龄;"+p.age+"我的手机为:"+mobile.name+",颜色为"+mobile.color+",价格为"+mobile.price);
    }
}
// 定义一个Person类
class Person{
    String name;
    char gender;
    int age;
    Mobile mobile;
    public Person(String name,char gender,int age,Mobile mobile) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.mobile = mobile;
    }
}
// 定义一个手机类
class Mobile{
    String name;
    String color;
    double price;
    public Mobile(String name,String color,double price) {
        this.name = name;
        this.color = color;
        this.price = price;
        
    }
}

3.

3. 接口

接口不是类，但其与类是同一层次的事物。

3.0 接口的概述：

3.1 定义格式：

　　interface  接口名{ }

public class InterfaceDemo{}
interface InterfaceA{}

3.2 注意事项

1. 接口中只能定义常量，默认public static final修饰，不能定义变量。

如 

interface InterfaceA{
    int a=10;//等价于public static final int a = 10
}

2. 接口中只能定义抽象方法(1.8之前)  默认是public abstract 修饰

　如下面代码

interface InterfaceA{
    private void test(); // 报错
        void test();//正确,此外写publc和abstract二者之一都是正确的，如下
        //public void test(); 正确       
}   

注意：这种默认情况表明子类中的方法也只能用public修饰（子类重写父类中的方法，权限不能比父类中的方法低）

3. 接口本身不能创建对象，使用子类向上转型（如练习三中）

　　接口的子类：实现了接口的类

　　格式：class 类名  implements 接口名{}

　　一个类可以实现多个接口：class 类名  implements 接口1,,接口2......{}

4.接口的子类要么实现接口中所有的抽象方法要么自己是一个抽象类

public class InterfaceDemo {}
interface InterfaceA{
    void test();
}
class Test implements InterfaceA{
    public void test() { //重写test()方法，此处是类，一定要加public
    }
}

5. 接口中没有构造方法

6. 接口不能实现接口，只能继承接口，并且可以多继承（类实现接口，并且一个类可以实现多个接口）

如，再定义一个接口B，让其继承自InterfaceA,里面不能重写接口InterfaceA中声明的test()方法（即不能实现InterfaceA接口），会报错，如下

class 子类名  implements  接口1，接口2{ }

public class InterfaceDemo {}
interface InterfaceA{
    void test();
}
interface InterfaceB {
    void test1();

}
class Test implements InterfaceA,InterfaceB{// 接口的子类一定要去实现其继承接口的所有方法，否则报错
    public void test() { 
        System.out.println("实现接口A");
    }
    public void test1() {
        System.out.println("实现接口B");
    }
}

7.从jdk1.8以后，接口中可以定义非抽象的方法，但是必须使用static或者default（不能省略）修饰 

8. 一个类可以继承一个类，并且同时实现多个接口（先继承，再实现）

class 类1 extends 类2 implents 接口（）//类中可以定义实现接口的方法

 3.3 面试题

 1.抽象类和接口的区别

 1. 一个类可以实现多个接口，但却只能继承最多一个抽象类

 2. 抽象类可以包含具体的方法，接口的所有方法都是抽象的(jdk1.8之前)

 3. 抽象类可以定义常量也可以定义变量，接口只能定义常量

 4. 接口的方法都是public的，抽象类的方法可以是public，protected，private或者默认的package

 5. 抽象类可以定义构造函数，但接口却不能

 2.什么时候定义抽象类，什么时候定义接口？

 接口是功能的扩展，抽象类是根源的扩展

如门，开门，关门应该是其固有的功能，但报警的话就只有防盗门有这个功能，其他门没有，所以报警就可以被定义为接口

// 定义抽象类，其中定义开门和关门的功能
abstract class Door{
    public abstract void openDoor();
    public abstract void closeDoor();
}
//定义报警接口
interface Alarm{
    public void alarm();
}
// 定义门的子类--防盗门，
class FDoor extends Door implements Alarm{
    public void openDoor() {}
    public void closeDoor() {}
    public void alarm() {} // 实现接口中报警的方法

3.  编写一个抽象类Animal，抽象类中包括属性：name(String类型)，抽象方法：speak().

　 编写一个宠物接口Pet，接口中包括方法：eat()。

　 再编写一个Cat，实现该接口和抽象类中的所有方法

     在main中进行测试，输出：“miao,  my name is xxx”;  "I want to eat some fish"

public class AnimalTest2 {
    public static void main(String[] args) {
        Cat1 c = new Cat1("小黑");
        c.speak();
        c.eat();
　　　　 //此处也可用接口创建对象，但其只能调用接口中的方法（其他方法相当于子类中独有的方法，如speak）
　　　　 //Pet p = new Cat1("小黑")；此叫接口的多态，同抽象类一样
       //p.eat();  

    }
}

abstract class Animal2{
    String name;
    abstract void speak();
}

interface Pet{
    void eat();
}
class Cat1 extends Animal2 implements Pet{
    public Cat1(String name) {
        this.name = name;
    }
    public void speak() {
        System.out.print("my name is"+name);
    }
    public void eat() {
        System.out.println("   I want to eat some fish");
    }
}

 4.