Java 基础 24 接口的概述以及练习

作者: 小熊先生很不开心 | 来源:发表于2018-02-01 10:56 被阅读8次

Java 基础 24 接口的概述以及练习
JAVA基础-集合
Lambda表达式总结
Java基础：注解
java集合类总结
Java基础：动态代理
Java 基础概述以及相关环境配置
[翻译中]JAVA 集合接口介绍
Java学习规划
Java 集合框架(接口)

1.1 接口的概述

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

1.2 接口的特点

接口用关键字interface表示
- 格式：public interface 接口名 {}
- 类实现接口用implements表示
  - 格式：public class 类名 implements 接口名 {}
- 接口不能实例化
  - 那么，接口如何实例化呢?
  - 按照多态的方式，由具体的实现类实例化。其实这也是多态的一种，接口多态。
- 接口的实现类
  - 要么是抽象类
  - 要么重写接口中的所有抽象方法

1.2.1 案例代码


package com.itheima_01;
/*
 * 接口的特点：
 *      A:定义接口使用的是interface关键字
 *      B:类和接口之间是实现关系，用implements关键字表示
 *      C:接口不能实例化
 *          接口有没有其他的方式实例化呢?
 *          参照多态的形式使用实现类来实例化。
 *      D:接口的实现类
 *          要么重写接口中的所有的抽象方法
 *          要么是一个抽象类
 * 
 * 多态的几种形式：
 *      具体类多态(几乎不用)
 *      抽象类多态(常用)
 *      接口多态(最常用)
 */
public class InterfaceDemo {
    public static void main(String[] args) {
        //Jumpping j = new Jumpping();
        //接口多态的形式实例化
        Jumpping j = new Cat();
        j.jump();
    }
}

package com.itheima_01;

public class Cat implements Jumpping {

    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }

}

package com.itheima_01;

public abstract class Dog implements Jumpping {

}

package com.itheima_01;
//定义了一个跳高的接口
public interface Jumpping {
    //抽象方法
    public abstract void jump();

1.3 接口的成员特点

成员变量
- 只能是常量
- 默认修饰符 public static final
构造方法
- 没有，因为接口主要是扩展功能的，而没有具体存在
成员方法
- 只能是抽象方法
- 默认修饰符 public abstract

1.3.1案例代码


package com.itheima_02;
/*
 * 接口的成员特点：
 *      成员变量：
 *          有成员变量，而且变量只能是常量。
 *          默认修饰符：public static final
 *      构造方法：
 *          没有构造方法。
 *      成员方法：
 *          有成员方法，而且都是抽象的。
 *          默认修饰符：public abstract
 * 
 * Object:是类层次结构的根类，所有的类都直接的或者间接的继承自该类。
 */
public class InterfaceDemo {
    public static void main(String[] args) {
        //按照多态的形式创建接口对象
        Inter i = new InterImpl();
        //i.num = 30;
        //System.out.println(i.num);
        //i.num2 = 40;
        //System.out.println(i.num2);
        System.out.println(Inter.num);
        System.out.println(Inter.num2);
    }
}

package com.itheima_02;

//public class InterImpl implements Inter
public class InterImpl extends Object implements Inter {
    public InterImpl() {
        super();
    }

    @Override
    public void method() {
        
    }
}

package com.itheima_02;

public interface Inter {
    public int num = 10;
    public final int num2 = 20;
    public static final int num3 = 30;
    
    //public Inter() {}
    
    //public void show() {}
    public abstract void method();
}

1.4 类与类类与接口接口与接口的关系

类与类
- 继承关系，只能单继承，但是可以多层继承
类与接口
- 实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口
接口与接口
- 继承关系，可以单继承，也可以多继承

1.4.1案例代码

package com.itheima_03;
/*
 * 类与类：
 *      继承关系，只能单继承，可以多层继承。
 * 
 * 类与接口：
 *      实现关系，可以单实现，也可以多实现。
 *      还可以在继承一个类的同时实现多个接口。
 * 
 * 接口与接口：
 *      继承关系，可以单继承，也可以多继承。
 */
public class InterfaceDemo {

}

package com.itheima_03;

public interface Sister extends Father,Mother {

}

package com.itheima_03;

public class Son extends Object implements Father,Mother {

}

package com.itheima_03;

public interface Mother {

}

package com.itheima_03;

public interface Father {

}

1.5 抽象类与接口的区别

成员区别
- 抽象类变量,常量;有抽象方法;抽象方法,非抽象方法
- 接口常量;抽象方法
关系区别
- 类与类继承，单继承
- 类与接口实现，单实现，多实现
- 接口与接口继承，单继承，多继承
设计理念区别
- 抽象类被继承体现的是：”is a”的关系。共性功能
- 接口被实现体现的是：”like a”的关系。扩展功能

1.5.1 案例代码(自己练习)

package com.itheima_04;
/*
 * 抽象类和接口的区别：
 *      A:成员区别
 *          抽象类：
 *              成员变量：可以是变量，也可以是常量
 *              构造方法：有
 *              成员方法：可以是抽象方法，也可以是非抽象方法
 *          接口：
 *              成员变量：只能是常量
 *              成员方法：只能是抽象方法
 *      B:关系区别
 *          类与类：继承关系，只能单继承，可以多层继承
 *          类与接口：实现关系，可以单实现，也可以多实现
 *          接口与接口：继承关系，可以单继承，也可以多继承
 *      C:设计理念的区别
 *          抽象类 被继承体现的是："is a"  抽象类中定义的是继承体系的共性功能
 *          接口 被实现体现的是："like a"  接口中定义的是该体系的扩展功能
 *          
 *          举例：
 *              猫，动物
 *              猫，跳高运动员
 */
public class InterfaceDemo {

}

1.6 接口的练习

1.6.1 接口的练习之猫狗案例

1.6.1.1案例代码

package com.itheima_01;
/*
 * 需求：猫狗案例,让所有的猫狗具备跳高的额外功能
 * 
 * 分析：从具体到抽象
 *      猫：姓名，年龄，吃饭(){}
 *      狗：姓名，年龄，吃饭(){}
 *      发现了共性的内容，就提取了一个父类。
 *      抽象动物类：
 *          姓名，年龄，吃饭();
 *      猫：继承动物类
 *      狗：继承动物类
 *      
 *      跳高的额外功能是一个扩展功能，所以应该定义接口实现。
 *      跳高接口：
 *          跳高();
 *      猫：继承动物类,实现跳高接口
 *      狗：继承动物类,实现跳高接口
 * 实现：从抽象到具体
 * 使用：使用的是具体的类的对象
 * 
 * 作业：具体的狗类，模仿着猫类给出。
 *     狗类的测试，也模仿着猫类的测试给出。   
 *      
 */
public class InterfaceTest {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.setName("加菲猫");
        c.setAge(3);
        System.out.println(c.getName()+"---"+c.getAge());
        c.eat();
        c.jump();
        System.out.println("-------------------------");
        
        Cat c2 = new Cat("加菲猫",3);
        System.out.println(c2.getName()+"---"+c2.getAge());
        c2.eat();
        c2.jump();
    }
}

package com.itheima_01;
//具体的猫类
public class Cat extends Animal implements Jumpping {

    public Cat() {
    }

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

    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

}

package com.itheima_01;
//跳高接口
public interface Jumpping {
    public abstract void jump();
}

package com.itheima_01;
//抽象的动物类
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.6.2 接口的练习之运动员和教练案例

1.6.2. 1接口的练习之运动员和教练案例分析

playerandcoach.png

1.6.2.2 接口的练习之运动员和教练案例的代码实现

1.6.2.2.1 案例代码


package com.itheima_02;
//乒乓球教练具体类
public class PingPangCoach extends Coach implements SpeakEnglish {

    public PingPangCoach() {}
    
    public PingPangCoach(String name,int age) {
        super(name,age);
    }
    
    @Override
    public void speak() {
        System.out.println("乒乓球教练说英语");
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练教如何发球和接球");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球教练吃小白菜，喝大米粥");
    }

}

package com.itheima_02;

//乒乓球运动员具体类
public class PingPangPlayer extends Player implements SpeakEnglish {

    public PingPangPlayer() {
    }

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

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

    @Override
    public void study() {
        System.out.println("乒乓球运动员学习如何发球和接球");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃大白菜，喝小米粥");
    }

}

package com.itheima_02;
//篮球教练具体类
public class BasketballCoach extends Coach {

    public BasketballCoach() {}
    
    public BasketballCoach(String name,int age) {
        super(name,age);
    }
    
    @Override
    public void teach() {
        System.out.println("篮球教练教如何运球和投篮");
    }

    @Override
    public void eat() {
        System.out.println("篮球教练吃羊肉，喝羊奶");
    }

}

package com.itheima_02;
//篮球运动员具体类
public class BasketballPlayer extends Player {

    public BasketballPlayer() {}
    
    public BasketballPlayer(String name,int age) {
        super(name,age);
    }
    
    @Override
    public void study() {
        System.out.println("篮球运动员学习如何运球和投篮");
    }

    @Override
    public void eat() {
        System.out.println("篮球运动员吃牛肉，喝牛奶");
    }

}

package com.itheima_02;
//抽象的教练类
public abstract class Coach extends Person {
    public Coach() {}
    
    public Coach(String name,int age){
        super(name,age);
    }
    
    public abstract void teach();
}

package com.itheima_02;

public interface SpeakEnglish {
    public abstract void speak();
}

package com.itheima_02;
//抽象的运动员类
public abstract class Player extends Person {
    public Player() {}
    
    public Player(String name,int age) {
        super(name,age);
    }
    
    public abstract void study();
}

package com.itheima_02;
//抽象的人类
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;
    }
    
    public abstract void eat();
}

1.6.2.3接口的练习之运动员和教练案例的测试

1.6.2.3.1案例代码

package com.itheima_02;
/*
 * 运动员和教练案例
 */
public class InterfaceTest {
    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.study();
        ppp.speak();
        //通过带参构造方法给成员变量赋值的方式(依然留给同学们)
        System.out.println("---------------");
        
        //篮球运动员
        BasketballPlayer bp = new BasketballPlayer();
        bp.setName("姚明");
        bp.setAge(35);
        System.out.println(bp.getName()+"---"+bp.getAge());
        bp.eat();
        bp.study();
        
        //测试教练的代码自己实现
    }
}