JavaSE_24th_接口

一、接口（interface）
当一个抽象类中所有的方法都是抽象方法，所有的变量都是静态常量（static final）,这时可以把该抽象类定义为接口，接口是一种特殊的抽象类，接口没有构造方法，也不能被
实例化，一个类使用implements关键字实现一个接口。

1、接口是抽象方法和常量值的定义的集合。
接口定义举例：

public interface Runner {
	//接口中的变量都是静态常量，因此可简写为int id = 1;
	public final static int id = 1;
	
	/* 由于是接口，在定义方法时不需要像抽象类一样加abstract关键字
	*/
	public void start();
	public void run();
	public void stop();
}

2、从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

3、接口的特性：
1）多个无关的类可以实现同一个接口。

public interface Lock {
	public void lockUp();	//上锁功能
	public void openLock();	//开锁功能
}

/**
 * 防盗门 类
 */
public class FtproofDoor implements Lock {
	@Override
	public void lockUp() {
		System.out.println("插进钥匙，向左旋转钥匙三圈，锁上了，拔出钥匙。");
	}
	@Override
	public void openLock() {
		System.out.println("插进钥匙，向右旋转钥匙三圈，锁打开了，拔出钥匙。");
	}
}

/**
 * 智能手机 类
 */
public class AptitudeHandset implements Lock {
	@Override
	public void lockUp() {
		System.out.println("手指按下电源键，手机锁上了。");
	}
	@Override
	public void openLock() {
		System.out.println("手指放在Home键上，手机解锁了。");
	}
}

总结：多个无关的类可以实现同一个接口。

2）一个类可以实现多个无关的接口。
与3）同例：
3）继承关系类似，接口与实现类之间存在多态性。

/**
 * 能唱歌的东西 接口
 */
interface Sinner {
	public void sing();
	public void sleep();
}

/**
 * 能画画的东西 接口
 */
interface Painter {
	public void paint();
	public void eat();
}

/**
 * 学生 类
 */
class Student implements Sinner {
	private String name;
	Student(String name) { this.name = name; }
	public void study() { System.out.println("studying"); }
	public String getName() { return name; }
	
	public void sing() {
		System.out.println("student is singing");
	}
	public void sleep() {
		System.out.println("student is sleeping");
	}
}

/**
 * 老师 类
 */
class Teacher implements Sinner,Painter {
	private String name;
	Teacher(String name) { this.name = name; }
	public String getName() { return name; }
	public void teach() { System.out.println("teacher is teaching"); }
	
	public void sing() {
		System.out.println("Teacher is singing");
	}
	public void sleep() {
		System.out.println("Teacher is sleep");
	}
	public void paint() {
		System.out.println("Teacher is painting");
	}
	public void eat() {
		System.out.println("Teacher is eating");
	}
}

public class TestInterface {
	public static void main(String[] args) {
		Sinner s1 = new Student("le");
		s1.sing();
		s1.sleep();
		Sinner s2 = new Teacher("steven");
		s2.sing();
		s2.sleep();
		Painter p1 = (Painter)s2;
		p1.paint();
		p1.eat();
	}
}

运行结果：

student is singing
student is sleeping
Teacher is singing
Teacher is sleep
Teacher is painting
Teacher is eating

总结：

a、继承关系类似，接口与实现之间存在多态性。
b、一个类可以实现多个无关的接口(Teacher类实现了两个Sinner和Painter这两个无关的接口)。
c、指向子类对象的A接口的引用，可以强制类型转换为接口B类型，将地址值传递给
接口B的引用后，接口B的引用就同样可以指向子类对象，实现多态。
即Sinner s2 = new Teacher();
Painter p1 = (Painter)s2;
p1.paint(); //多态机制，调用子类重写的方法。

4）接口不能被实例化，因此没有构造方法。
5）接口中声明属性默认为public static final的，也只能是public static final。
6）接口中只能定义抽象方法，而且这些方法默认为public的，也只能是public的。

7）与类的继承一样，接口可以使用extends关键字继承其它的接口，并添加新的属性和方法。

8）一个类可以在继承一个父类的同时并实现多个接口。

package com.hpe.interfa;

public interface Valuable {
	public double getMoney();
}

interface Protectable {
	public void beProtected();
}

/* 接口和接口之间只能是继承关系 */
interface A extends Protectable {
	void m();
}

abstract class Animal {
	private String name;
	
	abstract void enjoy();
}
/* 一个类可以在继承类的同时实现多个接口 */
class GoldenMonkey extends Animal implements Valuable, Protectable {
	public void enjoy() {}
	public double getMoney() { return 10000; }
	public void beProtected() {
		System.out.println("I live in the room.");
	}
	public void test() {
		/* 1.父类引用指向子类对象 */
		Valuable v = new GoldenMonkey();
		/* 多态机制，调用子类方法 */
		v.getMoney();
		/* 2.强制类型转换，跳到子类内部的另一个父类 */
		Protectable p = (Protectable)v;
		/* 多态机制，调用子类方法 */
		p.beProtected();
		/* 3.强制类型转换，跳到子类内部的另一个父类 */
		Animal a = (Animal)p;
		/* 多态机制，调用子类方法 */
		a.enjoy();
	}
}

/*
 * 一个类实现了一个接口，如果该接口继承至另一个接口，
 * 那么该类必须实现两个接口中的所有方法
 */
class Hen implements A {
	public void m() {}
	public void beProtected() {}
}