java基础之接口（抽象类与接口的区别）

2022-10-24 22:02:39

概述

猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了，对不。但是，现在有很多的驯养员或者是驯的，这应该属于经过特殊的培训训练出来的，对不。所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可。

1、接口的特点：

    A:接口用关键字interface表示

        interface 接口名 {} //默认省略了关键字 public,但在具体的实现类中，重写方法必须声明为public

    B:类实现接口用implements表示

        class 类名 implements 接口名 {}

    C:接口不能实例化

        那么，接口如何实例化呢?

        按照多态的方式来实例化。

    D:接口的子类

        a:可以是抽象类。但是意义不大。

        b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

由此可见多态的使用场合：

    A:具体类多态(几乎没有)

    B:抽象类多态(常用)

    C:接口多态(最常用)

//定义动物培训接口

interface AnimalTrain {

    public abstract void jump();

}

//抽象类实现接口

abstract class Dog implements AnimalTrain {

}

//具体类实现接口

class Cat implements AnimalTrain {

    public void jump() {

        System.out.println("猫可以跳高了");

    }

}

class InterfaceDemo {

    public static void main(String[] args) {

        //AnimalTrain是抽象的; 无法实例化

        //AnimalTrain at = new AnimalTrain();

        //at.jump();

        AnimalTrain at = new Cat();

        at.jump();

    }

}

2、接口成员特点

    成员变量；只能是常量，并且是静态的。

            默认修饰符：public static final

            建议：自己手动给出。

    构造方法：接口没有构造方法。

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

            默认修饰符：public abstract

            建议：自己手动给出。

所有的类都默认继承自一个类：Object。

类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。

interface Inter {

    public int num = 10;

    public final int num2 = 20;

    public static final int num3 = 30;

    //错误: 需要<标识符>

    //public Inter() {}

    //接口方法不能带有主体

    //public void show() {}

    //abstract void show(); //默认public

    public void show(); //默认abstract

}

//接口名+Impl这种格式是接口的实现类格式

/*

class InterImpl implements Inter {

    public InterImpl() {

        super();

    }

}

*/

class InterImpl extends Object implements Inter {

    public InterImpl() {

        super();

    }

    public void show() {}

}

//测试类

class InterfaceDemo2 {

    public static void main(String[] args) {

        //创建对象

        Inter i = new InterImpl();

        System.out.println(i.num);

        System.out.println(i.num2);

        //i.num = 100;

        //i.num2 = 200;

        //System.out.println(i.num); //无法为最终变量num分配值

        //System.out.println(i.num2);//无法为最终变量num2分配值

        System.out.println(Inter.num);

        System.out.println(Inter.num2);

        System.out.println("--------------");

    }

}

3、类与类,类与接口以及接口与接口的关系

类与类：

    继承关系,只能单继承,可以多层继承。

类与接口：

    实现关系,可以单实现,也可以多实现。

    并且还可以在继承一个类的同时实现多个接口。

接口与接口：

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

interface Father {

    public abstract void show();

}

interface Mother {

    public abstract void show2();

}

interface Sister extends Father,Mother {

}

//class Son implements Father,Mother //多实现

class Son extends Object implements Father,Mother {

    public void show() {

        System.out.println("show son");

    }

    public void show2() {

        System.out.println("show2 son");

    }

}

class InterfaceDemo3 {

    public static void main(String[] args) {

        //创建对象

        Father f = new Son();

        f.show();

        //f.show2(); //报错

        Mother m = new Son();

        //m.show(); //报错

        m.show2();

    }

}

4、猫狗案例

/*

加入跳高的额外功能

分析：从具体到抽象

    猫：

        姓名,年龄

        吃饭，睡觉

    狗：

        姓名,年龄

        吃饭，睡觉

    由于有共性功能，所以，我们抽取出一个父类：

    动物：

        姓名,年龄

        吃饭();

        睡觉(){}

    猫：继承自动物

    狗：继承自动物

    跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口

    接口：

        跳高

    部分猫：实现跳高

    部分狗：实现跳高

实现；

    从抽象到具体

使用：

    使用具体类

*/

//定义跳高接口

interface Jumpping {

    //跳高功能

    public abstract void jump();

}

//定义抽象类

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

    //睡觉(){}

    public void sleep() {

        System.out.println("睡觉觉了");

    }

}

//具体猫类

class Cat extends Animal {

    public Cat(){}

    public Cat(String name,int age) {

        super(name,age);

    }

    public void eat() {

        System.out.println("猫吃鱼");

    }

}

//具体狗类

class Dog extends Animal {

    public Dog(){}

    public Dog(String name,int age) {

        super(name,age);

    }

    public void eat() {

        System.out.println("狗吃肉");

    }

}

//有跳高功能的猫

class JumpCat extends Cat implements Jumpping {

    public JumpCat() {}

    public JumpCat(String name,int age) {

        super(name,age);

    }

    public void jump() {

        System.out.println("跳高猫");

    }

}

//有跳高功能的狗

class JumpDog extends Dog implements Jumpping {

    public JumpDog() {}

    public JumpDog(String name,int age) {

        super(name,age);

    }

    public void jump() {

        System.out.println("跳高狗");

    }

}

class InterfaceTest {

    public static void main(String[] args) {

        //定义跳高猫并测试

        JumpCat jc = new JumpCat();

        jc.setName("哆啦A梦");

        jc.setAge(3);

        System.out.println(jc.getName()+"---"+jc.getAge());

        jc.eat();

        jc.sleep();

        jc.jump();

        System.out.println("-----------------");

        JumpCat jc2 = new JumpCat("加菲猫",2);

        System.out.println(jc2.getName()+"---"+jc2.getAge());

        jc2.eat();

        jc2.sleep();

        jc2.jump();

        //定义跳高狗并进行测试的事情自己完成。

    }

}

5、老师和学生案例

/*

加入抽烟的额外功能

分析：从具体到抽象

    老师：姓名，年龄，吃饭，睡觉

    学生：姓名，年龄，吃饭，睡觉

    由于有共性功能，我们提取出一个父类，人类。

    人类：

        姓名，年龄

        吃饭();

        睡觉(){}

    抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以，我们把它定义为接口

    抽烟接口。

    部分老师抽烟：实现抽烟接口

    部分学生抽烟：实现抽烟接口

实现：从抽象到具体

使用：具体

*/

//定义抽烟接口

interface Smoking {

    //抽烟的抽象方法

    public abstract void smoke();

}

//定义抽象人类

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;

    }

    //吃饭();

    public abstract void eat();

    //睡觉(){}

    public void sleep() {

        System.out.println("睡觉觉了");

    }

}

//具体老师类

class Teacher extends Person {

    public Teacher() {}

    public Teacher(String name,int age) {

        super(name,age);

    }

    public void eat() {

        System.out.println("吃大白菜");

    }

}

//具体学生类

class Student extends Person {

    public Student() {}

    public Student(String name,int age) {

        super(name,age);

    }

    public void eat() {

        System.out.println("吃红烧肉");

    }

}

//抽烟的老师

class SmokingTeacher extends Teacher implements Smoking {

    public SmokingTeacher() {}

    public SmokingTeacher(String name,int age) {

        super(name,age);

    }

    public void smoke() {

        System.out.println("抽烟的老师");

    }

}

//抽烟的学生

class SmokingStudent extends Student implements Smoking {

    public SmokingStudent() {}

    public SmokingStudent(String name,int age) {

        super(name,age);

    }

    public void smoke() {

        System.out.println("抽烟的学生");

    }

}

class InterfaceTest2 {

    public static void main(String[] args) {

        //测试学生

        SmokingStudent ss = new SmokingStudent();

        ss.setName("林青霞");

        ss.setAge(27);

        System.out.println(ss.getName()+"---"+ss.getAge());

        ss.eat();

        ss.sleep();

        ss.smoke();

        System.out.println("-------------------");

        SmokingStudent ss2 = new SmokingStudent("刘意",30);

        System.out.println(ss2.getName()+"---"+ss2.getAge());

        ss2.eat();

        ss2.sleep();

        ss2.smoke();

        //测试老师留给自己练习

    }

}

6、抽象类和接口的区别：

   A:成员区别

    抽象类：

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

        构造方法：有

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

    接口：

        成员变量：只可以常量

        成员方法：只可以抽象

B:关系区别

    类与类

        继承，单继承

    类与接口

        实现，单实现，多实现

    接口与接口

        继承，单继承，多继承

C:设计理念区别

    抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。

    接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

7、综合小练习

        教练和运动员案例

        乒乓球运动员和篮球运动员。

        乒乓球教练和篮球教练。

        为了出国交流，跟乒乓球相关的人员都需要学习英语。

        请用所学知识：

        分析，这个案例中有哪些抽象类，哪些接口，哪些具体类

/*

    教练和运动员案例(学生分析然后讲解)

        乒乓球运动员和篮球运动员。

        乒乓球教练和篮球教练。

        为了出国交流，跟乒乓球相关的人员都需要学习英语。

        请用所学知识：

        分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。

    整个分析过程，我是通过画图讲解的。

*/

//定义一个说英语的接口

interface SpeakEnglish {

    //说英语

    public abstract void speak();

}

//定义人的抽象类

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;

    }

    //睡觉

    public void sleep() {

        System.out.println("人都是要睡觉的");

    }

    //吃饭

    public abstract void eat();

}

//定义运动员抽象类

abstract class Player extends Person {

    public Player() {}

    public Player(String name,int age) {

        super(name,age);

    }

    //学习

    public abstract void study();

}

//定义教练抽象类

abstract class Coach extends Person {

    public Coach() {}

    public Coach(String name,int age) {

        super(name,age);

    }

    //教

    public abstract void teach();

}

//定义乒乓球运动员具体类

class PingPangPlayer extends Player implements SpeakEnglish {

    public PingPangPlayer(){}

    public PingPangPlayer(String name,int age) {

        super(name,age);

    }

    //吃

    public void eat() {

        System.out.println("乒乓球运动员吃大白菜，喝小米粥");

    }

    //学习

    public void study() {

        System.out.println("乒乓球运动员学习如何发球和接球");

    }

    //说英语

    public void speak() {

        System.out.println("乒乓球运动员说英语");

    }

}

//定义篮球运动员具体类

class BasketballPlayer extends Player {

    public BasketballPlayer(){}

    public BasketballPlayer(String name,int age) {

        super(name,age);

    }

    //吃

    public void eat() {

        System.out.println("篮球运动员吃牛肉，喝牛奶");

    }

    //学习

    public void study() {

        System.out.println("篮球运动员学习如何运球和投篮");

    }

}

//定义乒乓球教练具体类

class PingPangCoach extends Coach implements SpeakEnglish {

    public PingPangCoach(){}

    public PingPangCoach(String name,int age) {

        super(name,age);

    }

    //吃

    public void eat() {

        System.out.println("乒乓球教练吃小白菜，喝大米粥");

    }

    //教

    public void teach() {

        System.out.println("乒乓球教练教如何发球和接球");

    }

    //说英语

    public void speak() {

        System.out.println("乒乓球教练说英语");

    }

}

//定义篮球教练具体类

class BasketballCoach extends Coach {

    public BasketballCoach(){}

    public BasketballCoach(String name,int age) {

        super(name,age);

    }

    //吃

    public void eat() {

        System.out.println("篮球教练吃羊肉，喝羊奶");

    }

    //教

    public void teach() {

        System.out.println("篮球教练教如何运球和投篮");

    }

}

class InterfaceDemo {

    public static void main(String[] args) {

        //测试运动员(乒乓球运动员和篮球运动员)

        //乒乓球运动员

        PingPangPlayer ppp = new PingPangPlayer();

        ppp.setName("王浩");

        ppp.setAge(33);

        System.out.println(ppp.getName()+"---"+ppp.getAge());

        ppp.eat();

        ppp.sleep();

        ppp.study();

        ppp.speak();

        System.out.println("----------------");

        //通过带参构造给数据(留给你们)

        //篮球运动员

        BasketballPlayer bp = new BasketballPlayer();

        bp.setName("姚明");

        bp.setAge(34);

        System.out.println(bp.getName()+"---"+bp.getAge());

        bp.eat();

        bp.sleep();

        bp.study();

        //bp.speak(); //没有该方法

        //测试教练自己做

    }

}

码农公寓

相关文章