接口

1. 接口
① 概念：是一种标准，是使用者和实现者都必须遵循的一种约定。
② 基本的语法：【重点】
a. 关键字： interface
b. 接口在编译之后会生成.class 文件
c. 接口不能创建对象，但是可以声明引用
d. 接口中没有构造方法
e. 接口中的所有属性都是公开的、静态的、常量
                       (public static final 修饰)

f. 接口中的所有方法都是公开、抽象方法(public abstract 修饰)

2. 实现类：【重点】
① 语法： class 类名 implements 接口名{
//....
          }
  
② 注意：实现类实现一个接口，必须实现接口中所有的方法，
         否则实现类也必须是一个抽象类。

③ 使用：父类接口 引用名=new 实现类类名(实参);//多态的应用 

3. 接口之间的继承关系【重点】
① 接口与接口之间是多继承关系：
    interface 接口名 extends 父接口名1,父接口2{}

② 类同时可以实现多个接口(类与接口之间是多实现关系)：
   class 类名 implements 接口名1,接口名2{}
 
    ③ 类可以继承一个父类，同时实现多个父接口，但是必须是先继承后实现。
       class 类名 extends 父类名 implements 父接口1,父接口2{} 

4. 接口多继承的影响：【了解】
转换双方有一方为接口类型，编译一定通过，如果引用中存储的实际对象
    和要转换的类型相匹配，则运行通过；如果引用中存储的实际对象类型和要
转换类型不匹配，则运行报错，错误信息： 
java.lang.ClassCastException(类型转换异常)

5. 接口的好处 【重点理解】
① 扩充子类的能力：
Java是单继承，所有当父类中定义的方法不满足子类的功能需求时，
可以通过接口扩充子类的能力。通常：将主要功能放在父类中，

次要功能放在接口中。

package demo2017112;
/*
 * 子类扩充 ：父类中的方法不足以满足子类的需求，可以通过接口扩充子类的能力。通常主要功能放在父类里面，次要功能放在接口中。
 */
public class TestAnimal{
public static void main(String[] args){
Animal[] as={
new Dog(),
new Cat(),
new Dog(),
new Fish(),
new Cat(),
new Dog(),
new Fish()
};
for(int i=0;i<as.length;i++){
as[i].eat();
}
//统计Animal数组中会跑的动物
int count=0;
for(int i=0;i<as.length;i++){
if(as[i] instanceof Runnable){
/*Runnable ru=(Runnable)as[i];                      //会跑的动物
ru.run();*/
}
count++;
}
int sum=0;
for(int i=0;i<as.length;i++){
if(as[i] instanceof Swimable){
sum++;
}
}
System.out.println("会跑的动物的个数："+count);
//统计会游泳的个数。
System.out.println("会游泳的动物的个数:"+sum);
}
}
//接口：跑能力
interface Runnable{
void run();
}
//游能力
interface Swimable{
void swim();
}
class Animal{
public void eat(){}
public void sleep(){}

}

class Dog extends Animal implements Runnable,Swimable{
public void eat(){
System.out.println("狗吃骨头...");
}
public void run(){
System.out.println("Dog..running....");
}
public void swim(){
System.out.println("狗刨....");
}
}
class Cat extends Animal implements Runnable{
public void eat(){
System.out.println("猫吃鱼....");
}
public void run(){
System.out.println("Cat...running...");
}
}
class Fish extends Animal implements Swimable{
public void eat(){
System.out.println("鱼虾米...");
}
public void swim(){
System.out.println("水中鱼....");
}
}

② 弱耦合：
   接口定义之后，将接口的实现者和接口的使用者分离，借助多态，

   降低各功能模块的耦合度，从而实现弱耦合。

package demo2017112;
/*
 * 
 * 弱偶型
 */
public class TestRuoOuHe {
// String name;
public static void main(String[] args) {
// 买一个台灯
Lamp lll = new Lamp();
lll.setLight(new GreenLight());
lll.on();
}
}
// 定义了一个发什么光的接口
interface Light {
public abstract void shine();

}
//台灯类
class Lamp {
private Light light;
// 接口类型
public void setLight(Light light) { // Light light=new GreenLight();//多态
this.light = light;
}
// 开关
public void on() { 
light.shine();
}
}
// 灯泡
class YellowLight implements Light {
public void shine() {
System.out.println("发黄光...");
}
}
// 白灯泡
class WhiteLight implements Light {
public void shine() {
System.out.println("发白光...Liang");
}
}
class GreenLight implements Light {
public void shine() {
System.out.println("冒绿光....");
}
}

6. 接口回调：【理解即可】
    接口定义之后，先有接口的使用者，再有接口的实现者。

             开发者通常关注的是实现者。