Java面向对象之抽象类,接口的那些事

时间:2022-06-18 06:58:47

一、抽象类

1.抽象类概述

1.1 为什么要有抽象类?(抽象类的作用)

我先举一个例子:假设我们有一个父类动物类(Animal),还有继承自动物类的两个子类猫类(Cat)和狗类(Dog),动物类里有一个eat()方法,猫类和狗类重写eat()方法。我们都知道猫和狗的eat这个行为是可以有具体实现的,比如猫吃鱼、狗啃骨头,也就是说可以有方法体。但是它们的父类Animal里的eat()方法就不能有具体实现(不能有方法体),因为Animal只是一个抽象的概括,它不是具体事物,所以我们应该把动物类以及它的eat()方法定义为抽象的。

Java面向对象之抽象类,接口的那些事

总结一下,抽象类的作用就是用来捕捉子类的通用特性的,是被用来创建继承层级里子类的模板。现实中有些父类中的方法确实没有必要写,因为各个子类中的这个方法肯定会有不同;而写成抽象类,这样看代码时,就知道这是抽象方法,而知道这个方法是在子类中实现的,所以有提示作用。

1.2 抽象类的定义

当我们在做子类共性功能抽取时,有些方法在父类中并没有具体的体现,这个时候就需要抽象类了!在Java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类!

如何定义抽象类和抽象方法:使用 abstract 关键字来修饰类和方法。

2. 抽象类特点

1)抽象类和抽象方法必须使用abstract关键字修饰

?
1
2
3
4
//抽象类的定义
public abstract class 类名 {}
//抽象方法的定义
public abstract void eat();

2)抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类

3)抽象类不能实例化,但是可以通过多态的方式创建子类对象

4)抽象类的子类

要么重写抽象父类中所有的抽象方法要么子类本身也是一个抽象类

3.抽象类成员特点

1)成员变量

既可以是变量、也可以是常量

2)构造方法

有构造方法,作用是用于子类访问父类数据的初始化

3)成员方法

既可以是抽象方法:限定子类必须完成某些动作。

也可以是非抽象方法:提高代码复用性。

4.抽象类案例

需求:请采用抽象类的思想实现猫和狗的案例,并在测试类中进行测试。

思路:

Java面向对象之抽象类,接口的那些事

代码实现:

?
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
package com.itheima_04;
/*
  动物类
 */
public abstract class Animal {
    private String name;
    private int age;
    public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = 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 abstract void eat();
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.itheima_04;
/*
  猫类
 */
public class Cat extends Animal {
    public Cat() {
    }
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.itheima_04;
/*
  狗类
 */
public class Dog extends Animal {
    public Dog() {
    }
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.itheima_04;
/*
    测试类(本测试类中只测试了猫类对象,小伙伴们可自行测试狗类对象)
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //创建对象,按照多态的方式
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("--------");
        a = new Cat("加菲",5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
    }
}

二、接口

1.接口概述

接口就是一种公共的规范标准,只要符合规范标准,大家都可以通用。就好比现实生活当中两个不同厂家生产的U盘却可以插在同一个usb接口上使用,这就是因为他们都遵循了一种统一的规范标准。

Java中的接口更多的体现在对行为的抽象!(我个人认为可以把接口看作是一个特殊的抽象类;但需要注意它和抽象类是有区别的,下文会讲。)

2.接口特点

1)接口用关键字 interface 修饰

?
1
public interface 接口名 {}

2)类实现接口用 implements 表示

?
1
public class 类名 implements 接口名 {}

3)接口不能被实例化,可以通过多态形式创建实现类对象。

多态的形式:具体类多态,抽象类多态,接口多态。

4)接口的实现类

要么重写接口中所有的抽象方法要么实现类定义为抽象类

3.接口成员特点

1)成员变量

只能是常量,默认修饰符为:public static final

2)构造方法

接口中没有构造方法,因为接口主要是扩展功能的,而没有具体存在。

3)成员方法

只能是抽象方法,默认修饰符为:public abstract

JDK8以后可以有静态方法

JDK9以后可以有默认方法

4.接口案例

需求:对猫和狗进行训练,他们就可以跳高了,这里加入跳高功能。请采用抽象类和接口来实现猫狗案例,并在测试类中进行测试。

思路:

Java面向对象之抽象类,接口的那些事

代码实现(本代码中只实现了猫类,小伙伴们可自行实现狗类):

?
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
package com.itheima_03;
/*
  动物类
 */
public abstract class Animal {
    private String name;
    private int age;
    public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = 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 abstract void eat();
}
?
1
2
3
4
5
6
7
package com.itheima_03;
/*
  跳高接口
 */
public interface Jumpping {
    public abstract void jump();
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.itheima_03;
/*
  猫类
 */
public class Cat extends Animal implements Jumpping {
    public Cat() {
    }
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}
?
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
package com.itheima_03;
/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //创建对象,调用方法
        Jumpping j = new Cat();
        j.jump();
        System.out.println("--------");
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
//        a.jump();
        a = new Cat("加菲",5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("--------");
        Cat c = new Cat();
        c.setName("加菲");
        c.setAge(5);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();
    }
}

5.类和接口的关系

1)类和接口之间的关系

实现关系,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口。

2)接口和接口之间的关系

继承关系,可以单继承、也可以多继承。

6.抽象类和接口的区别

Java面向对象之抽象类,接口的那些事

对于设计理念区别(重要区别)我举例说明下:比如门这个类有开门、关门的基础功能,但有些门除了这两个基础功能外,还有报警功能。报警功能不是每个门都有,也不是只有门才有这个功能,所以对于报警功能我们可以采用接口进行封装,而门的属性和开门、关门功能可以采用抽象类封装。

Java面向对象之抽象类,接口的那些事

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注服务器之家的更多内容!

原文链接:https://blog.csdn.net/weixin_45676761/article/details/119967570