面向对象【五】(抽象类、接口)

发表于 | 更新于 | 分类于 | 评论数： | 阅读次数：

抽象类

抽象类的概述

回想前面我们的猫狗案例，提取出了一个动物类。并且我们在前面也创建过了动物对象，其实这是不对的。
为什么呢?因为，我说动物，你知道我说的是什么动物吗?只有看到了具体的动物，你才知道，这是什么动物。
所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。
同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出成员方法的具体体现，而是应该给出一个声明即可。

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

抽象类的特点

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

格式:

抽象类：

1
abstract class 类名 {}；

抽象方法：

1
public abstract void eat();

注意：

  • 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类

  • 问：抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?

    答：用于子类访问父类数据时的初始化

  • 问：抽象类不能直接实例化那么，抽象类如何实例化呢?

    答：按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。

  • 抽象类的子类

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

代码示例：（以下代码是自定义类）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//一旦一个类中，有了抽象方法，此类必须为抽象类

public abstract class Animal {
    public Animal() {
        System.out.println("父类的构造方法执行了");
    }

    //abstract 抽象的，可以修饰类，修饰方法
    public abstract void eat(); //抽象方法，此方法没有方法实现

    public abstract void sleep();
    //抽象类中既可以有抽象方法，也可以非抽象方法
    public void show(){
        System.out.println("这是父类的一个非抽象方法");
    }

}


class Cat extends Animal{


    @Override
    public void eat() {     //对父类中的抽象方法进行重写，子类如果不是抽象类，必须对父类中的所有抽象方法进行重写
        System.out.println("猫爱吃鱼");

    }

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

一旦一个类中，有了抽象方法，此类必须为抽象类

对父类中的抽象方法进行重写，子类如果不是抽象类，必须对父类中的所有抽象方法进行重写

以下代码是测试类：

1
2
3
4
5
6
7
8
9
10
11
public class MyTest {
    public static void main(String[] args) {
        //new Animal();
        //抽象类不能直接创建对象
        //我们可以采用多态间接的去实例化抽象类
        Animal an=new Cat();
        an.eat();
        an.sleep();
        an.show();
    }
}

在测试类中的主方法中的第一行代码执行时，用到了多态，那么最终运行结果为

1
2
3
4
父类的构造方法执行了
猫爱吃鱼
猫白天睡觉
这是父类的一个非抽象方法

抽象类的成员特点及注意事项

成员特点

  1. 成员变量：既可以是变量，也可以是常量。

  2. 构造方法：有，用于子类访问父类数据的初始化。

  3. 成员方法：既可以是抽象的，也可以是非抽象的。

  4. 抽象类的成员方法特性：

    抽象方法： 强制要求子类重写的事情。
    非抽象方法： 子类继承的事情，提高代码复用性。

注意事项

  • 抽象类，就是被abstract所修饰的类，父类将所有子类的共性功能向上抽取后，他并不知道，每个子类对这个共性功能的具体实现，所以没有必要在父类中，给出共性功能的具体实现，而是给出声明即可，所谓给出功能的声明，就是将此功能抽象出来，然后强制子类必须重写。
  • 抽象类注意的事项：一旦一个类中，有了抽象方法，那么此类必须为抽象类
  • 一个抽象类中可以没有抽象方法
  • 抽象类中既可以有抽象方法，也可以有非抽象方法，抽象方法，强制子类重写；非抽象方法，可以让子类继承下去用
  • 抽象类不能直接实例化，可以采用多态的方式，间接实例化
  • 抽象类的子类，要么重写父类中所有的抽象方法，要么自己也是一个抽象类。
  • 抽象类中有构造方法，用来子类初始化父类要用

代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public class MyTest {
    public static void main(String[] args) {
        Person p = new Student();
        p.name = "赵某某";
        p.age = 20;
        System.out.println(p.name + "====" + p.age);
        p.sleep();
        p.playGame();
        p.eat();
        ((Student) p).watchTV();
        System.out.println("------------------------");
        p = new Teacher();
        p.name = "沈某某";
        p.age = 21;
        System.out.println(p.name + "===" + p.age);
        p.eat();
        p.playGame();
    }
}

abstract class Person {
    public String name;
    public int age;
    public abstract void eat();
    public abstract void sleep();
    public void playGame(){
        System.out.println("玩游戏");
    }

}
class Student extends Person{
    @Override
    public void eat() {
        System.out.println("学生爱吃烤串");
    }

    @Override
    public void sleep() {
        System.out.println("学生通宵不寐");
    }
    public void watchTV(){
        System.out.println("学生看电视");
    }
}

class Teacher extends Person {
    @Override
    public void eat() {
        System.out.println("老师爱吃米饭");
    }

    @Override
    public void sleep() {
        System.out.println("老师经常失眠");
    }
}

上述代码中使用到了向下转型，代码最终运行结果为

1
2
3
4
5
6
7
8
9
赵某某====20
学生通宵不寐
玩游戏
学生爱吃烤串
学生看电视
-------------
沈某某===21
老师爱吃米饭
玩游戏

抽象类中的面试题

  • 面试题1：
    一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
    答案: 可以 . 不能创建对象.因为抽象类不能实例化

  • 面试题2：
    abstract不能和哪些关键字共存?
    private 冲突
    final 冲突

    static 不能共存 无意义

接口

接口的概述

为了体现父类功能的扩展性，Java中就提供了接口来定义这些额外的拓展功能，并不给出具体实现，将来哪些子类需要使用到这些额外功能，只需要把这部分额外功能实现即可

接口特点

  • 接口用关键字interface表示

    格式:

    1
    interface 接口名 {}

  • 类实现接口用implements表示

    格式:

    1
    class 类名 implements 接口名 {}

  • 接口不能实例化

    1
    2
    那么，接口如何实例化呢? 
      按照多态的方式来实例化。

  • 接口的子类

    可以是抽象类。但是意义不大。
    可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
public class MyTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Animal an = cat;
        an.eat();
        // CalcInterface 是猫的一个父接口，所以猫类也可以看成是父接口的一个子类
        CalcInterface calcInterface = cat; //接口不能直接实例化，但是可以使用多态类实例化
        calcInterface.calc();
        //多态
        CalcInterface c = new Dog();
        c.calc();
        //接口不能new 对象

    }
}

abstract class Animal {

    public abstract void eat();
}
interface CalcInterface {
    //用来定义额外功能
    public abstract void calc(); //接口中的方法只能是抽象类，即只需要声明，不需要具体实现，

}

class Cat extends Animal implements CalcInterface{
    @Override
    public void eat() {        //重写抽象类中的抽象方法
        System.out.println("猫吃鱼");
    }

    public void catcheMouse(){      子类猫类的特有方法
        System.out.println("猫抓老鼠");
    }

    @Override
    public void calc() {    //因为接口中的方法只能是抽象方法，所以实现接口时必须对抽象方法进行实现
        System.out.println("猫经过不断的努力学习，会做算术了");
    }
}

class Dog extends Animal implements CalcInterface{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    public void lookDoor(){
        System.out.println("狗看门");
    }


    @Override
    public void calc() {
        System.out.println("狗经过自己的学习，也学会了做算术");
    }
}

上述代码执行结果为：

1
2
3
猫吃鱼
猫经过不断的努力学习，会做算术了
狗经过自己的学习，也学会了做算术

接口的成员特点

  1. 成员变量；只能是常量，并且是静态的；默认修饰符：public static final；建议：自己手动给出。
  2. 构造方法：接口没有构造方法。
  3. 成员方法：只能是抽象方法；默认修饰符：public abstract；建议：自己手动给出。

代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class MyTest {
    public static void main(String[] args) {
        //接口中成员变量的特点
        //接口中的成员变量全是静态的公共常量
        //接口中没有构造方法的
        //接口中没有非抽象方法，全是抽象方法

        int a = A.A;
        System.out.println(a);
        int num = A.num;

    }
}

interface A{
    //接口中成员变量前面有默认的修饰符  public static final
    int num=100;
    public static final  int A=1000;

   //方法前面存在默认修饰符 public abstract
    public abstract void hehe();
    void test();
}

类与类,类与接口,接口与接口的关系

  1. 类与类：继承关系,只能单继承,可以多层继承。
  2. 类与接口：实现关系,可以单实现,也可以多实现。并且还可以在继承一个类的同时实现多个接口。
  3. 接口与接口：继承关系,可以单继承,也可以多继承。

代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
public class MyTest {
    public static void main(String[] args) {
        //类跟类之间的关系
        // 类跟类是继承关系，只能是单继承，支持多层继承
        // 类跟接口是实现关系 既可以实现一个接口，也可以实现多个接口,实现接口，必须重写接口中所有的抽象方法
        // 接口跟接口的关系，继承关系，而且可以多继承
    }

}

class Fu{}
interface A{

    void a();
}
interface C{
    void c();
}

class B extends Fu implements A,C{       类与接口可以多实现，也可以单实现


    @Override
    public void a() {

    }

    @Override
    public void c() {

    }
}

interface  E{
    void e();
}

interface F{
    void f();
    void ff();

}

interface G extends E,F{      接口可以多继承
    void g();
    void gg();

}

class V implements G{


    @Override
    public void e() {   //以下都是对接口中的抽象方法进行重写

    }

    @Override
    public void f() {

    }

    @Override
    public void ff() {

    }

    @Override
    public void g() {

    }

    @Override
    public void gg() {

    }
}

抽象类和接口的区别

成员区别：

  • 抽象类：

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

    构造方法：有

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

  • 接口：

    成员变量：只可以常量

    成员方法：只可以抽象

关系区别：

​ 1.类与类：继承，单继承

​ 2.类与接口：实现，单实现，多实现

​ 3.接口与接口：继承，单继承，多继承

设计理念区别：

  • 抽象类 被继承体现的是：”is a”的关系。 抽象类中定义的是该继承体系的共性功能。
  • 接口 被实现体现的是：”like a”的关系。 接口中定义的是该继承体系的扩展功能。

注意：JDK1.8之后在接口中提供了用default修饰的方法，可以给出功能的具体实现，子类可以继承下去用，相当于间接实现了多继承

代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
public class MyTest2 {
    //JDK1.8之后，接口中可以定义默认方法
    public static void main(String[] args) {
     C c= new C();
     A a=c;
     a.test();
     a.test2();
     a.test3();
     B b=c;
     b.test22();
     b.test333();
    }
}

interface A{
    void hehe();
    public default void test(){
        System.out.println("JDK1.8之后接口中，可以定义默认方法，可以有方法的具体实现");
    }

    public default void test2() {
        System.out.println("JDK1.8之后接口中，可以定义默认方法，可以有方法的具体实现");
    }

    public default void test3() {
        System.out.println("JDK1.8之后接口中，可以定义默认方法，可以有方法的具体实现");
    }

}

interface B {
    void hehe();

    public default void show() {
        System.out.println("JDK1.8之后接口中，可以定义默认方法，可以有方法的具体实现？？？");
    }

    public default void test22() {
        System.out.println("JDK1.8之后接口中，可以定义默认方法，可以有方法的具体实现？？？");
    }

    public default void test333() {
        System.out.println("JDK1.8之后接口中，可以定义默认方法，可以有方法的具体实现？？？");
    }

}

class C implements A,B{


    @Override
    public void hehe() {

    }

    @Override
    public void test22() {
    System.out.println("JDK1.8之后接口中，可以定义默认方法，可以有方法的具体实现？？？，但是被重写了");
    }
}
-------------本文结束感谢您的阅读-------------
0%