1.接口概述

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


2.接口的特点

  接口用关键字interface表示，格式:interface 接口名{}

  类实现接口用implements表示，格式：class 类名 implements 接口名{}

  接口不能实例化。

  接口的子类，要么是抽像类或接口，要么重写接口中的所有抽象方法。接口与接口之间是继承。

package com;
//定义动物培训接口
interface AnimalTrain{
	/**
	 * 跳高
	 */
	public abstract void jump();
}
//抽象类实现接口
abstract class Cat implements AnimalTrain{
	
}
//具体类实现接口
class Dog implements AnimalTrain{

	@Override
	public void jump() {
		System.out.println("狗被训练跳高");
	}
	
}
public class InterfaceDemo {
	public static void main(String[] args) {
		
	}
}


3.接口的成员特点

  成员变量：只能是常量并且是静态的。public static final

  构造方法：接口没有构造方法。因为接口主要是扩展功能，所以接口不需要构造方法。

  成员方法：只能是抽象方法，并且是public。public abstract

  

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

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


4.类与类，类与接口以及接口与接口之间的关系

  类与类：继承关系，只能单继承，但是可以多层继承。

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

  接口与接口：继承关系，可以单继承，也可以多继承。


5.抽象类与接口的区别

  成员区别：

    抽象类： 变量 常量 抽象方法 普通方法

    接口： 常量 抽象方法

  关系区别

    类与类： 继承 单继承

    类与接口： 实现 单实现和多实现

    接口与接口： 继承 单继承和多继承

  设计理念区别

    抽象类： 被继承 体现的是is a的关系，共×××

    接口： 被实现 体现的是like a的关系 扩展功能


6.案例

package cn;
/**
 * 接口--动作
 *
 */
interface Action{
	/**
	 * 跳高
	 */
	public void jump();
}
/**
 * 抽象类--动物类
 */
abstract class Animal{
	private String name;//姓名
	private int age;//年龄
	
	public Animal(){}
	public Animal(String name,int age){
		this.age = age;
		this.name = name;
	}
	
	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);
	}

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

}
/**
 * 有跳高功能的猫
 */
class JumpCat extends Cat implements Action{
	
	public JumpCat(){}
	public JumpCat(String name,int age){
		super(name, age);
	}

	@Override
	public void jump() {
		System.out.println("猫跳高");
	}
	
}
/**
 * 具体狗类
 */
class Dog extends Animal{
	
	public Dog(){}
	public Dog(String name,int age){
		super(name, age);
	}

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

}
/**
 * 有跳高功能的狗
 */
class JumpDog extends Dog implements Action{

	@Override
	public void jump() {
		System.out.println("狗跳高");
	}
	
}
//测试类
public class InterfaceTest {
	public static void main(String[] args) {
		JumpCat jumpCat = new JumpCat("跳高猫哈哈", 3);
		System.out.println("姓名："+jumpCat.getName()+",年龄："+jumpCat.getAge());
		jumpCat.eat();
		jumpCat.sleep();
		jumpCat.jump();
	}
}
package com;
/**
 * 老师和学习案例，加入抽烟的额外功能
 * 具体：
 * 	老师：姓名 年龄 吃饭 睡觉
 *  学生：姓名 年龄 吃饭 睡觉
 *  由于有共性的功能，我们提取一个父类：人类
 *  
 *  人类：
 *  	姓名 年龄
 *  	吃饭 睡觉
 *  
 *  抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以我们把吸烟定义为接口
 *  
 *  抽烟接口
 *  部分老师抽烟：实现抽烟接口
 *  部门学生抽烟：实现抽烟接口
 */
//吸烟
interface Smoking{
	/**
	 * 吸烟
	 */
	public 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);
	}

	@Override
	public void eat() {
		System.out.println("老师吃素");
	}
	
}
//具体学生类
class Student extends Person{

	public Student(){}
	public Student(String name,int age){
		super(name, age);
	}
	@Override
	public void eat() {
		System.out.println("学生吃肉");
	}
	
}
//吸烟老师
class SmokeTeacher extends Teacher implements Smoking{
	
	public SmokeTeacher(){}
	public SmokeTeacher(String name,int age){
		super(name, age);
	}
	
	@Override
	public void smoke() {
		System.out.println("吸烟的老师");
		
	}
	
}
//吸烟学生
class SmokeStudent extends Student implements Smoking{
	
	public SmokeStudent(){}
	public SmokeStudent(String name,int age){
		super(name, age);
	}
	
	@Override
	public void smoke() {
		System.out.println("吸烟学生");
	}
	
}
public class InterfaceTest {
	public static void main(String[] args) {
		SmokeTeacher sTeacher = new SmokeTeacher("吸烟老师哈哈", 25);
		System.out.println("姓名："+sTeacher.getName()+",年龄："+sTeacher.getAge());
		sTeacher.eat();	
		sTeacher.sleep();
		sTeacher.smoke();
	}
}

wKioL1f2YarAeTlAAAJMbIeK0IA727.png

package com;
/**
 * 乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。
 * 为了出国交流，乒乓球相关人员都需要学习英语
 * 分析：
 * 	乒乓球运动员
 *  篮球运动员
 *  乒乓球教练
 *  篮球教练
 *  学习英语
 * 实现：从抽象到具体
 * 使用：使用具体的
 */
//定义一个说英语的接口
interface SpeakEnglish{
	/**
	 * 说
	 */
	public 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);
	}
	
	@Override
	public void speak() {
		System.out.println("乒乓球运动员说英语");
	}

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

	@Override
	public void eat() {
		System.out.println("乒乓球运动员吃大白菜，喝小米粥");
	}
}
//定义篮球运动员具体类
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("篮球运动员吃牛肉，喝牛奶");
	}
}
//定义乒乓球教练具体类
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("乒乓球教练吃小白菜和大米粥");
	}
	
}
//定义篮球教练具体类
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("篮球教练吃羊肉，喝羊奶");
	}
	
}
//测试类
public class InterfaceTest {
	public static void main(String[] args) {
		//测试运动员
		PingPangPlayer pp = new PingPangPlayer("王浩", 33);
		System.out.println("姓名："+pp.getName()+",年龄："+pp.getAge());
		pp.eat();
		pp.speak();
		pp.sleep();
		
	}

}