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

1. 多态

1.1 概述：

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

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

1.2 多态的前提和体现

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

1 public class Test {

2     public static void main() {

3         Person p = new Teacher(); // 父类的引用指向子类的对象

4     }

5 }

6 class Person{}

7 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个蛋，分别为鸡蛋，鸭蛋，鹅蛋

 1 public class EggDemo {

 2     public static void main(String[] args) {

 3         HenEgg egg1 = new HenEgg();

 4         DuckEgg egg2 = new DuckEgg();

 5         GooseEgg egg3 = new GooseEgg();

 6     }

 7 }

 8 class HenEgg{String name;}

 9 class DuckEgg{String name;}

10 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(); 等号左边是蛋右边是鸡蛋

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

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

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

 1 public class EggDemo {

 2     public static void main(String[] args) {

 3         Egg egg1 = new HenEgg();

 4         Egg egg2 = new DuckEgg();

 5         Egg egg3 = new GooseEgg();

 6         Egg[] eggs = new Egg[]{egg1,egg2,egg3};

 7 //        egg1.born();

 8 //        egg2.born();

 9 //        egg3.born();

10         test(egg1);

11     }

12     public static void test(Egg e) { // 将参数类型定义为父类，传哪个子类就调用哪个子类方法，这样更加灵活，无多态的话每次就需要创建一个对象来实现

13         e.born();

14     }

15 }

16 class Egg{

17     String name;

18     public void born() {

19         System.out.println("生小*");

20     }

21 }

22

23 class HenEgg extends Egg{

24     String name;

25     public void born() {

26         System.out.println("生小鸡");

27     }

28 }

29 class DuckEgg extends Egg{

30     String name;

31     public void born() {

32         System.out.println("生小鸭");

33     }

34 }

35 class GooseEgg extends Egg{

36     String name;

37     public void born() {

38         System.out.println("生小鹅");

39     }

40 }

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 共存

案例

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

1 public class AbstractDemo {

2     public static void main(String[] args) {

3         Animal a = new Animal();

4     }

5 }

6 // 动物抽象类

7 abstract class Animal{

8     abstract public void sleep();

9 }

报错如下

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

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

1 // 定义猫类

2 class Cat extends Animal{

3     @Override

4     public void sleep() {   //重写sleep方法

5         System.out.println("猫站着睡觉");

6     }

7 }

（3）抽象类的成员特点

　　1. 成员变量：

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

　　2. 构造方法

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

　　3. 成员方法

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

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

练习

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

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

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

　在测试类中测试

 1 public class Exercise1 {

 2     public static void main(String[] args) {

 3         Shape s = new Rect(2,4);

 4         Shape c = new Circle(3);

 5         result(s);

 6         result(c);

 7     }

 8     public static void result(Shape s) {

 9         System.out.println("面积为："+s.getArea());

10         System.out.println("周长为："+s.getPerimeter());

11     }

12 }

13

14 abstract class Shape{

15      public abstract double getArea();

16

17      public abstract double getPerimeter();

18 }

19

20 class Rect extends Shape{  // 继承关系  Is a

21     double length;

22     double wide;

23     public Rect(double length,double wide){

24         this.length = length;

25         this.wide = wide;

26     }

27     @Override

28     public double getArea() { // 该重写方法的权限要比抽象类声明处的权限要高，声明处是public，所以此处只能是public

29         return length*wide;

30     }

31     public double getPerimeter() {

32         return 2*(length+wide);

33     }

34 }

35 class Circle extends Shape{

36     double r;

37     public static final double PI=3.14;

38     public Circle(double r) {

39         this.r = r;

40     }

41     public double getArea() {

42         return PI*r*r;

43     }

44     public double getPerimeter() {

45         return 2*PI*r;

46     }

47 }

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.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.接口的子类要么实现接口中所有的抽象方法要么自己是一个抽象类

1 public class InterfaceDemo {}

2 interface InterfaceA{

3     void test();

4 }

5 class Test implements InterfaceA{

6     public void test() { //重写test()方法，此处是类，一定要加public

7     }

8 }

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.什么时候定义抽象类，什么时候定义接口？

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

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

 1 // 定义抽象类，其中定义开门和关门的功能

 2 abstract class Door{

 3     public abstract void openDoor();

 4     public abstract void closeDoor();

 5 }

 6 //定义报警接口

 7 interface Alarm{

 8     public void alarm();

 9 }

10 // 定义门的子类--防盗门，

11 class FDoor extends Door implements Alarm{

12     public void openDoor() {}

13     public void closeDoor() {}

14     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");

    }

}

巴特西

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

最新文章

热门文章