Java之接口

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