1、接口：interface关键字
    （1）语句定义格式：

 interface 接口名{}

    （2）接口是如何实现的呢？
        接口不能直接实例化，需要一个关键字供其他类实现该接口：implements
        使用多态的形式进行实现，由具体的子类进行实例化,其实这是多态的一种，叫做接口多态。

    （3）也可以用一个抽象类去实现。

    到目前为止，我们学过了三种多态的表现实现：
        （1）具体的类中的多态  （最后才是具体类的多态）
        （2）抽象类中的多态    （其次是抽象多态）
        （3）接口中的多态     （今后大数据开发最常见的是接口多态）
    
    
2、接口中成员的特点：
    （1）成员变量：
        只能是常量，并且是静态的。 JVM在真正运行之前会自动补齐修饰符：public static final

    （2）构造方法：
        接口中没有构造方法。所以直接实现接口的类都继承Object类，完成构造方法的初始化。    

      (3）成员方法：
        接口中的方法只能是抽象方法。  JVM在真正运行之前会自动补齐修饰符：public abstract

//创建一个接口
interface Animal{
    public static final int age = 30;  //默认修饰符: public static final，可以不写

//    Animal(){       //不能有构造方法
//
//    }

    public abstract void show();  //默认修饰符: public abstract，可以不写
}


//定义猫类，继承Object类（Object是所有类的父类），实现Animal接口
class Cat extends Object implements Animal{
    @Override
    public void show() {
        System.out.println("猫会跳舞");
    }
}


//测试类
public class InterfaceDemo {
    public static void main(String[] args) {
        //接口类多态
        Animal animal = new Cat();
        animal.show();
    }
}

   注意：
        （1）当一个具体的类实现接口的时候，必须实现接口中所有的抽象方法。
        （2）当一个抽象类实现接口的时候，可以选择不实现接口中的方法，也可以选择性的实现。

   类与类，类与接口，接口与接口的关系
        （1）类与类：
               存在的是继承关系，只能进行单继承，不可以进行多继承，但是可以是多层继承。
        （2）类与接口：
               存在的是实现关系，可以是单实现，也可以是一次性实现多个接口，也可以在继承一个类的同时，实现多个接口。
        （3）接口与接口：
               存在的是继承关系，可以进行单继承，也可以进行多继承。

interface Inter1{ 
   
}

interface Inter2{  
  
}

interface Inter3 extends Inter1,Inter2{       //接口可以继承多个接口

}

public class Demo extends Object implements Inter1,Inter2{   //类可以在继承一个类的同时实现多个接口    
}

3、将来我们更多的面向接口开发会将代码进行分类开发，这样会提高我们开发效率和排错效率。
     通常情况下，会在一个包里分4层:
        bean: 一般存放的是将来要new的实体类。
        controller: 一般是数据的入口类。
        dao: 具体对数据做操作的地方，放在dao层，这一层一般情况下，都是对数据库做操作的。
        service: 一般在这里面放的是接口，和实现类。

4、方法的形式参数是引用数据类型时:
    (1）类：当类作为方法的形式参数时，实际需要的是该类的对象。
    (2）抽象类：当抽象类作为方法的形式参数时，实际需要的是该类子类实现对象的地址值，利用多态的形式创建。
    (3）接口：当接口作为方法的形式参数时，实际需要的是该接口的实现类对象的地址值，利用接口多态的方式创建。

//创建一个抽象的人类
abstract class Person {

    public abstract void study();

}


//创建一个人类2接口
interface Person2 {

    public abstract void playGame();

}


//创建一个学生类继承人类，实现人类2接口
class Student extends Person implements Person2 {

    @Override
    public void study() {
        System.out.println("好好学习天天向上");
    }

    @Override
    public void playGame() {
        System.out.println("天天玩英雄联盟");
    }

}



//创建一个Demo类
class StudentDemo {

    // 1) 当看到一个方法的参数是一个类的类型时，实际传的是该类对象的地址值
    public void fun(Student stu) {     //Student stu = new Student();
        stu.study();
    }


    // 2) 当看到一个抽象类作为参数的类型时，实际需要的是该类子类实现对象的地址值，利用多态的形式创建
    public void fun2(Person person) {   //Person person = new Student();
        person.study();
    }


    // 3) 当看到一个方法的参数类型是一个接口的时候，实际上需要的是该接口的实现类对象的地址值，利用接口多态的方式创建
    public void fun3(Person2 person2) {  //Person2 person2 = new Student();
        person2.playGame();
    }

}



//测试类
public class StudentTest {
    public static void main(String[] args) {

        //创建Demo类对象
        StudentDemo stuDemo = new StudentDemo();

        // 1) 类作为形参
        Student stu = new Student();
        stuDemo.fun(stu);


        // 2) 抽象类作为形参
        //Person p = new Student();    //第一种方式   多态的形式
        //stuDemo.fun2(p);

        stuDemo.fun2(new Student());   //第二种方式   链式编程


        // 3) 接口作为形参
        //Person2 p = new Student();      //接口多态的形式
        //stuDemo.fun3(p);

        stuDemo.fun3(new Student());
    }
}

5、方法的返回值是引用数据类型时：
    (1）类: 当一个类作为方法的返回值时，实际返回的是该类对象的地址值。
    (2）抽象类: 当一个抽象类作为方法的返回值时，实际返回的是该抽象类的子类对象。
    (3）接口: 当一个接口作为方法的返回值时，实际返回的是实现该接口的类的对象。

//定义一个抽象类 -- 人类
abstract class Person {

    public abstract void study();

}


//定义一个玩游戏接口
interface PlayGame {

    public abstract void playLol();

}


//创建一个学生类, 继承人类,实现接口玩游戏
class Student extends Person implements PlayGame {

    @Override
    public void study() {
        System.out.println("好好学习天天向上");
    }

    @Override
    public void playLol() {
        System.out.println("天天玩英雄联盟");
    }

}



//创建一个Demo类
class StudentDemo {

    // 1) 当看到方法的返回值是一个类的类型时，实际返回的是该类对象的地址值。
    public Student fun() {
        //Student s = new Student();     //第一种方法
        //return s;

        return new Student();            //第二种方法
    }


    // 2) 当看到方法的返回值是一个抽象类的类型时，需要返回的是该抽象类的子类对象
    public Person fun2() {
        //Person p = new Student();      //第一种方法
        //return p;

        return new Student();             //第二种方法
    }


    // 3) 当看到方法的返回值是一个接口的类型时，需要的是实现该接口的类的对象
    public PlayGame fun3() {
        //PlayGame pg = new Student();
        //return pg;

        return new Student();
    }

}



//测试类
public class StudentTest {
    public static void main(String[] args) {

        //创建Demo类对象
        StudentDemo stuDemo = new StudentDemo();

        // 1) 方法Student做返回值
        Student stu = stuDemo.fun();
        stu.study();


        // 2) 抽象类Person做返回值
        Person p = stuDemo.fun2();   //Person p = new Student();
        p.study();


        // 3) 接口PlayGame做返回值
//        PlayGame pg = stuDemo.fun3();
//        pg.playLol();

        //链式编程
        stuDemo.fun3().playLol();
    }
}  

 
6、package、import、class它们三个之间有没有顺序呢？
      package: 到达的路径，所在文件的路径，它最终以包结束。    （在最前面）

      import: 导入外界你想要使用的类，它最终以你想要导入的那个类/.java结束。    （在package与class之间）
           要想导入某一包下所有的类: .* (开发不推荐)
           只要当你需要导入大于30个类的时候，可以考虑 .*

      class: 表示定义一个类，java的最基本的单位    （在import后面，即最后）
    

7、访问权限修饰符：
                   同一类下    同一包子类中，其他类     不同包的子类      不同包的其他类
    public             √                     √                                    √                           √
    protected       √                      √                                    √
    默认的           √                      √
    private           √
    （√ 代表可以访问）
    
    常见的修饰符组合：
        （1）成员变量：public static final
        （2）成员方法：
            1) public abstract
            2) public static
            3) public final