Java 抽象类和接口_java接口抽象类

一、抽象类

1. 抽象类定义

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

public abstract class Animal {
    public abstract void eat();
}
1
2
3

public class Cat extends Animal {
   //重写抽象方法
    public void eat() {
        System.out.println("猫吃鱼！");
    }
}
1
2
3
4
5
6

抽象类不是具体的，所以不能直接创建对象！

抽象类的特点：
① 抽象类和抽象方法必须使用 abstract 关键字修饰；
② 抽象类中不一定有抽象方法，但有抽象方法的类一定是抽象类；
③ 抽象类不能直接实例化，要想实例化，参照多态的方式，通过子类对象实现实例化，这叫抽象类多态；
④ 抽象类的子类要么重写抽象类中的所有抽象方法，要么自己就是抽象类。

2. 抽象类成员特点

① 抽象类中的成员变量可以是变量，也可以是常量；
② 抽象类有构造方法，但是不能实例化，此处构造方法用于子类访问父类数据的初始化；
③ 可以有抽象方法，限定子类必须完成某些动作，也可以有非抽象方法，提高代码的复用性。

分析问题要从具体到抽象！

二、接口

1. 接口概述

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用，Java 中的接口更多的体现在对行为的抽象。
接口关键字：Interface

//Jumpping.java，接口

package com.zxe;

public interface Jumpping {
    public abstract void jump();
}

1
2
3
4
5
6
7
8

//Cat.java，接口的实现类

package com.zxe;

public class Cat implements Jumpping {
    public void jump() {
        System.out.println("喵喵喵跳起来！");
    }
}

1
2
3
4
5
6
7
8
9
10

//Test.java

package com.zxe;

public class Test {
    public static void main(String[] args) {
        Jumpping c = new Cat();
        c.jump();
        Jumpping d = new Dog();
        d.jump();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

Dog 的实现类与 Cat 同理，实例化的过程依然采用多态的方法！

接口的特点：
① 接口用关键字 interface 修饰；
② 接口不能实例化，参照多态的方式，通过实现类对象进行实例化，这叫接口多态；
③ 接口的实现类，要么重写接口中的所有抽象方法，要么自身就是抽象类。

2. 接口成员特点

① 成员变量默认是常量，且只能是常量，默认被 static 修饰；
② 接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在的；
③ 一个类如果没有父类，默认继承 Object 类，访问其无参构造方法；
④ 成员方法只能是抽象方法。

3. 类和接口的关系

（1）类和类是继承关系，只能单继承，但可以多层继承；
（2）类和接口是实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口；
（3）接口和接口是继承关系，可以单继承，也可以多继承。

public class InterImpl implements Inter1, Inter2, Inter3 {
}
1
2

4. 抽象类和接口的区别

抽象类是对 Door 这一事物的抽象，而接口是对 Alram 报警行为的抽象！

5. 接口案例

//Animal.java

package com.zxe;

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
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

//Jumpping.java

package com.zxe;

public interface Jumpping {
    public abstract void jump();
}

1
2
3
4
5
6
7
8

//Cat.java

package com.zxe;

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

//Dog.java

package com.zxe;

public class Dog extends Animal implements Jumpping {

    public Dog() {
    }

    public Dog(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

//Test.java

package com.zxe;

public class Test {
    public static void main(String[] args) {
        Cat c = new Cat("加菲猫", 12);
        System.out.println(c.getName() + ", " + c.getAge());
        c.eat();
        c.jump();

        Dog d = new Dog();
        d.setName("舔狗");
        d.setAge(21);
        System.out.println(d.getName() + ", " + d.getAge());
        d.eat();
        d.jump();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在实际开发中，既会有接口的出现，也会有抽象类的出现，在使用的时候我们应使用具体的子类，因为它里面的方法最多。

三、形参和返回值

① 类名作为形参和返回值

方法的形参是类名，其实需要的是该类的对象，方法的返回值是类名，其实返回的是该类的对象。

//Cat是普通类

public void useCat(Cat c) {
    c.eat();
}

public Cat getCat() {
    Cat c = new Cat();
    return c;
}
1
2
3
4
5
6
7
8
9
10

② 抽象类名作为形参和返回值

方法的形参是抽象类名，其实需要的是该抽象类的子类对象，方法的返回值是抽象类名，其实返回的是该抽象类的子类对象。

//Animal是抽象类

public class AnimalOperator{
    public void useAnimal(Animal a) {
        a.eat();
    }

    public Animal getAnimal() {
        Animal a = new Cat();
        return a;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

//Test.java

AnimalOperator ao = new AnimalOperator();
Animal a = new Cat();
ao.useAnimal(a);
Animal a2 = ao.getAnimal();
a2.eat();
1
2
3
4
5
6
7

因为要传的参数是一个 Animal 对象，而 Animal 类是一个抽象类，它不能直接实例化，所以我们还是通过多态的方式创建它的子类对象，然后作为参数传递进来。

③ 接口名作为参数和返回值

方法的形参是接口名，其实需要的是该接口的实现类对象，方法的返回值是接口名，其实返回的是该接口的实现类对象。

//Jumpping是接口

public void useJumpping(Jumpping j) {
    j.jump();
}

public Jumpping getJumpping() {
    Jumpping j = new Cat();
    return j;
}
1
2
3
4
5
6
7
8
9
10

接口与抽象类一样也需借助多态来实现对象的实例化！