Java中的接口

package com.aaa.zxf.ajax.test;

import org.junit.Test;

/**
 * 一、java中的接口
 *      java只能单继承。--------->接口可以多实现。
 *      接口是一个特殊的抽象类，接口中的方法都是抽象的。 接口和类的关系叫做多实现。
 *
 *
 *    2.1.2 接口的特性
        A 接口中的方法都是 公共抽象的
        B 接口中的成员变量都是 public static final 修饰常量  (作业：枚举)
        C 接口没有构造函数 所以不能new（没有创建接口一说）
        D 类接接口之间的关系
             类   类     单继承
             类   接口   多实现
             接口 接口   多继承
 
        E 接口的作用 接口多态 。
            接口类型 变量名 =  new 实现类();
 *
 * 二、static 关键字？
 *
 * 1.静态变量和静态方法。
 *           static修饰成员变量 称之为 静态变量
 *           static 修饰方法     称之为 静态方法
 *
 *
 * 2.java中成员变量和方法的调用规则
 *      如果成员变量声明的时候添加static 称之为静态变量，如果没有没有添加称之为成员变量或者 非静态变量
 *
 *      静态变量：       类名.静态变量名
 *      非静态成员变量： 对象名.变量名
 *
 *      如果方法添加static 称之为 静态方法，如果不添加 称之为 非静态方法。
 *       静态方法：  类名.方法名()
 *       非静态方法:  对象名.方法名()
 *
 * 2.  static关键字的作用
 *       （static修饰的成员变量属于类级别 
 *       非static修饰的成员变量属于 对象级别）
 *
 *
 * 三、 final关键字
 *
 *  1.final修饰特性
 *
 *      A    final 修饰类： final修饰的类不能被其他类继承 （不能有子类）
 *      The type Cat cannot subclass the final class Animal
 *
 *      面试题：String能不能被继承？为什么？  String为什么设计成final class？
 *          不能， string 被 final 修饰。
 *          所以String是不可变的关键都在底层的实现，而不是一个final。考验的是工程师构造数据类型，封装数据的功力。
 *
 *
 *      B     final 修饰成员变量 ：final修饰的成员变量都是 常量（只能赋值一次 之后不能修改了）
 *
 *  2.  静态常量和非静态常量
 *      静态常量（static final）：初始化的时候（声明的时候）或者在静态代码块中赋值（静态代码块 就是一个写代码的地方 写到静态代码块的代码 随之类被加载 只执行一次）
 *
 *      非静态常量（final）：初始化的时候（声明的时候）或者在 构造函数中初始化

    3.final 修饰的方法？
             final修饰的方法 可以被调用 但是不能被子类重写
             Cannot override the final method from  People

    4.为什么使用final关键字？
         使用final方法的原因有二：
         第一、把方法锁定，防止任何继承类修改它的意义和实现。
         第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。
 */


public class JavaJieKou {
    public static void main(String[] args) {
        String h= "sadf";

        People01 小明 = new People01();
/**
 *   都实现了 Irun 这个接口
 *
 *   人 需要实现什么功能 直接调用即可。
 *   直接调用即可。
 *
 *   people 遛马的方法
 */
        Irun hourse = new Hourse01();
        Ieat hourse1 = new Hourse01();
        Irun bird = new Bird();

        小明.run(hourse);
        小明.feed(hourse1);
        小明.run(bird);
    }
    @Test
 public void test01(){
/**
 *  people 喂养的方法。
 */
        People01 people01 = new People01();
        Ieat hourse01 = new Hourse01();
        Ieat bird = new Bird();

        people01.feed(hourse01);
        people01.feed(bird);
    }
}



// 定义一个接口  关键字 interface 修饰类名。
interface  Irun{
    /**
     * 接口中的方法 都是公共的抽象的方法
     */
    void  run();
}

interface Ieat{
    void eat();
}

// 普通类的多实现  实现run 和 eat 两个接口的功能。
class Hourse01 implements Irun,Ieat{

    @Override
    public void run() {
        System.out.println("马飞飞");
    }

    @Override
    public void eat() {
        System.out.println("马  吃草。。。");
    }
}


class  Bird implements Irun,Ieat{
    @Override
    public void run() {
        System.out.println("飞翔吧，小鸟。");
    }

    @Override
    public void eat() {
        System.out.println("小鸟吃虫子！！！");
    }
}
class  People01{
    /**
     * 传递的类型是 Ieat 只要是ieat的实现类 都可以当做参数传过来。
     * @param e
     */
    public void  feed(Ieat e){
        e.eat();
    }

    public void run(Irun r){
        r.run();
    }
}