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

概述

猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了，对不。但是，现在有很多的驯养员或者是驯的，这应该属于经过特殊的培训训练出来的，对不。所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。所以，为了体现事物功能的扩展性，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(); //没有该方法

        //测试教练自己做
    }
}

版权声明：本文为小平果原创文章，转载请注明：http://blog.csdn.net/i10630226