当前位置：首页 > article >正文

面向对象-接口的使用

article 2024/11/23 12:14:54

1. 接口的概述

为什么有接口？

借口是一种规则，对于继承而言，部分子类之间有共同的方法，为了约束方法的使用，使用接口。

接口的应用：接口不是一类事物，它是对行为的抽象。

2. 接口的定义和使用

接口用关键字interface来定义

        public interface 接口名{}

接口不能实例化

接口和类之间是实现关系，通过implements关键字表示

        public class 类名 implements 接口名{}

接口的子类（实现类）

        要么重写接口中的所有抽象方法

        要么是抽象类

注意1：接口和类的实现关系，可以单实现，也可以多实现。

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

注意2：实现类还可以在继承一个类的同时实现多个接口

public class 类名 extends 父类 implements 接口名1，接口名2{}

练习：

父类：
package oopinterface.demo1;

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();
}

游泳接口：
package oopinterface.demo1;

public interface Swim {
    public abstract void swim();
}

兔子类：
package oopinterface.demo1;

public class Rabbit extends Animal {
    public Rabbit() {
    }

    public Rabbit(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("兔子在吃胡萝卜");
    }
}

青蛙类：
package oopinterface.demo1;

public class Frog extends Animal implements Swim {
    public Frog() {
    }

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }

    @Override
    public void swim() {
        System.out.println("青蛙在蛙泳");

    }
}

狗类：
package oopinterface.demo1;

public class Dog extends Animal implements Swim{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void swim() {
        System.out.println("狗在狗刨");

    }
}

测试类：
package oopinterface.demo1;

public class Test {
    public static void main(String[] args) {
        Dog d = new Dog("小黄",2000);
        System.out.println(d.getName() +", " + d.getAge());
        d.eat();
        d.swim();

    }
}

3. 接口中成员的特点

成员变量：只能是常量

默认修饰符：public static final

构造方法：没有

成员方法：只能是抽象方法

默认修饰符：public abstract

JDK7以前：接口中只能定义抽象方法。

JDK8的新特性：接口中可以定义有方法体的方法

JDK9的新特性：接口中可以定义私有方法

4. 接口和类之间的关系

类和类的关系：继承关系，只能单继承，不能多继承，但是可以多层继承

类和接口的关系

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

接口和接口之间的关系

继承关系，可以单继承，也可以多继承

如果实现类实现了下面的子接口（继承的子类），那么就需要重写所有的抽象方法（包含父类和子类的抽象方法）。

5. 接口和抽象类的综合案例

画图：从下往上

写代码：从上往下

父类：人

package oopinterface.demo2;
//由于父类的子类全部为抽象类，现在创建父类对象没有意义，所以将父类也设置成抽象类
public abstract class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(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;
    }
}

运动员：
package oopinterface.demo2;

public abstract class Sportsman extends Person {
    public Sportsman() {
    }

    public Sportsman(String name, int age) {
        super(name, age);
    }

    public abstract void study();
}

教练：
package oopinterface.demo2;

public abstract class Coach extends Person {
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}

说英语接口：
package oopinterface.demo2;

public interface English {
    public abstract void speakEnglish();
}

乒乓球运动员：
package oopinterface.demo2;

public  class PpSportsman extends Sportsman implements English{
    public PpSportsman() {
    }

    public PpSportsman(String name, int age) {
        super(name, age);
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球运动员在说英语");
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员在练习打乒乓球");
    }
}

篮球运动员：
package oopinterface.demo2;

public class BasketballSportsman extends Sportsman {
    public BasketballSportsman() {
    }

    public BasketballSportsman(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("篮球运动员在学习打篮球。");
    }
}

篮球教练：
package oopinterface.demo2;

public class BaskateballCoach extends Coach {
    public BaskateballCoach() {
    }

    public BaskateballCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("篮球教练正在教打篮球。");
    }
}

乒乓球教练：
package oopinterface.demo2;

public class PpCoach extends Coach implements English{
    public PpCoach() {
    }

    public PpCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练在教打乒乓球。");
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球教练在学习说英语。");
    }
}

测试类;
package oopinterface.demo2;

public class Test {
    public static void main(String[] args) {
        PpSportsman pps = new PpSportsman("ml",24);
        System.out.println(pps.getName() + "," + pps.getAge());
        pps.speakEnglish();
        pps.study();
    }
}

查看全文

http://www.kler.cn/a/405715.html