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