一、接口
1、生活中的接口
USB接口，
插座，
type-c接口，解决了世界性的大难题："USB设备永远插不准。。"，随便插。。
网线，ARJ45
lightning接口，就是苹果充电接口。。
HDMI接口，
3.5mm，耳机。。。
这些接口有啥用？
定义标准，定义规范。
以USB接口为例：
（1、鼠标，U盘，移动硬盘，键盘。。。
（2、都是USB设备
（3、都能够通过USB接口，接入电脑中，可以去干活。。
大家都遵守的统一的规则，就是USB接口，就能够连入到电脑中。。。。
2、接口的概念
接口就是一种能力和约定。一种协议，一种规则。
从语法的角度：接口是一种特殊的抽象类。这种抽象类只包含了抽象方法和静态常量，没有方法的实现。
也就是说：接口中都是抽象方法和静态常量的集合。
从功能的角度：接口表示一种约定，或者能力。
接口的内容：
接口中，包含静态常量，默认的(缺省)修饰符：public static final
接口中，包含抽象方法，默认的(缺省)修饰符：public abstract
3、Java中的接口的语法格式
//1.定义一个类
关键字：class 类名{}
//2.定义一个接口，语法
interface 接口名{
//1.静态常量
//2.抽象方法
}
//3.【抽象类：等待子类继承(extends)，并实现所有的抽象方法，才能创建子类对象。】
实现类，实现一个接口的语法：
class 实现类 implements 接口名{
}
一个实现类，去实现一个接口？就是这个实现类中，实现接口中的所有的方法。
4、接口的特点
接口不能创建对象，不能被实例化。而且接口中没有构造方法。
接口中的方法，一般都是公共的抽象方法：public abstract来修饰
接口中的属性，都是公共的静态常量：public static final来修饰
在一个接口中，声明方法的时候，如果没有声明访问权限，默认也是public的。如果没有其他的修饰符默认也是abstract。声明属性，如果没有声明访问权限和其他的关键字，默认也是public static final。
public interface 接口名{
public static final 数据类型 常量名 = "初始值";
public abstract void test();
}
5、接口的好处
降低代码之间的耦合性：（藕断丝连），类和类之间，耦合性越低越好。接口中只做功能的声明，没有具体的实现。
定义的都是规则，对外保持接口的一致。
接口可以多继承，以及多实现，使用更灵活。
6、接口的注意点
（1、接口可以多继承
一个接口允许继承另外一个接口，而且允许继承多个接口。只不过该接口的实现类，要实现该接口中，以及从父接口中继承来的抽象方法，都需要实现。
接口中：声明都是抽象方法。只有声明(描述功能)，没有具体的实现(完成这个功能)。声明和实现分离。
package com.qf.demo03_interface;
//一种规则
interface C{
public void testC();
}
//另一种规则
interface D{
public void testD();
}
//接口可以继承多个父接口
interface E extends C,D{
public void testE();
}
//实现类，实现接口E
class DemoB implements E{
@Override
public void testC() {
System.out.println("C协议。。");
}
@Override
public void testD() {
System.out.println("D协议。。");
}
@Override
public void testE() {
System.out.println("E协议。。。");
}
}
public class Test3Interface {
public static void main(String[] args) {
C c = new DemoB();
c.testC();
D d = new DemoB();
d.testD();
E e = new DemoB();
e.testC();
e.testD();
e.testE();
}
}
（2、接口可以多实现：一个实现类可以同时实现多个接口
package com.qf.demo02_interface;
//定义一种规则：
interface A{
public void testA();//
public void fun();
}
//定义另一种规则
interface B{
public void testB();
public void fun();
}
//实现类，实现接口A。满足接口的规则：其实就是要实现接口中所有的抽象方法。
class DemoA implements A,B{
@Override
public void testA() {
System.out.println("DemoA类，满足接口A的规则。。。");
}
@Override
public void testB() {
System.out.println("DemoA类，也满足接口B的规则。。。");
}
@Override
public void fun() {
System.out.println("DemoA类，实现类fun方法。。。");
}
}
public class Test1Interface {
public static void main(String[] args) {
A a = new DemoA();
a.testA();
a.fun();
B b = new DemoA();
b.testB();
b.fun();
DemoA demoA = new DemoA();
demoA.testA();
demoA.testB();
}
}
（3、一个类如果实现接口了，还能继承其他的父类吗？可以的
意味着，一个类继承了一个父类：那么就可以直接使用父类的非私有化的属性和方法。
同时，还实现接口某个接口规则。
这个类即作为一个父类的子类，又作为了一个接口的实现类。
package com.qf.demo04_interface;
//表示一种协议，一种规则
interface H{
public void testH();
public void fun();
}
//继承？is - a，子类是一个特殊的父类
class M{
public void testM(){
System.out.println("我是M类的方法。。");
}
public void fun(){
System.out.println("M类中的fun方法。。。");
}
}
//定义一个类：N
//继承了父类M：意味着N这个类可以直接使用父类的非私有化的属性和方法。
//同时实现接口H：意味着满足接口H中的所有规则：抽象方法。。
class N extends M implements H{
@Override
public void testH() {
System.out.println("满足了接口H的协议规则。。");
}
//父类的fun方法，一旦存在继承关系，相当于子类也有一份。
// public void fun(){
// System.out.println("M类中的fun方法。。。");
// }
}
public class Test4 {
public static void main(String[] args) {
//课间思考题：一个类可以继承父类的同时，再实现接口吗？
M m = new N();//父类引用，指向子类的对象：一种对象的多态
m.testM();
m.fun();
System.out.println("-----------------");
H h = new N();//接口引用，指向实现类对象：一种接口的多态
h.testH();
h.fun();
}
}
（4、如果一个类没有实现接口中的所有的方法，那么它是抽象的
一个实现类可以实现接口，但是如果没有实现全部的方法， 那么该类是抽象的。等待子类继承，并且实现抽象方法。
package com.qf.demo05_interface;
interface K{
public void test1();
public void test2();
}
abstract class KImpl implements K{
@Override
public void test1() {
}
}
class L extends KImpl{
@Override
public void test2() {
}
}
public class Test5 {
public static void main(String[] args) {
}
}
（5、接口中的两个特殊的方法
1、静态方法：
2、默认的方法：jdk1.8版本出现的新特性。
目的：不强制一定要实现某个功能。
package com.qf.demo06_interface;
//接口的目的：定义一套规则，标准。
interface F{
//接口中，允许存在静态方法。语法级别上的。
public static void fun(){
System.out.println("接口中的静态方法。。");
}
/*
* 接口存在默认方法：
* default：
* 修饰的方法，默认方法，是拥有方法体。
* 1、jdk1.8才出现的新的特性。
* 2、接口可以提供关于功能的最基本的处理
* 3、不强制实现类去实现。
*/
default void test(){
System.out.println("接口中的默认方法，");
}
}
class FImpl implements F{
}
public class Test6 {
public static void main(String[] args) {
F.fun();
F f = new FImpl();
f.test();
}
}
一个实现类如果没有实现接口中的所有的方法，那么该类是抽象的。等待子类继承，并实现其他的抽象方法。
一个类也可以继承父类，同时实现接口。
jdk1.8的新特性：default方法。*/
7、关于接口和抽象类
Java中类都是单继承的。如果父类的方法种类无法满足子类的需求，可以通过实现接口来扩充子类的功能。而且接口支持多继承，多实现的。更灵活一些。
概念：
抽象类：讲究的是继承。
接口：讲究的是规范，规则。
8、接口回调
首有个接口A，和它 实现类。然后在另一个类B中，持有A的引用，那么在B类中可以调用接口A的方法。这就是一种回调。
9、接口引用
同父类一样，接口也可以声明为引用，指向实现类的对象。其实就是一种接口的多态。
接口类型的引用 = new 实现类的对象
那么只能调用接口中所声明的方法。不能调用实现类中新增的方法。可以强制转回实现类的类型，就可以调用新增的方法。
二、类和类的关系
Java中的数据了类型：两大类(基本类型和引用类型)
基本类型：又叫简单类型。直接赋值数值即可。4类8种
byte，short，int，long，float，double，char，boolean
引用类型：存储的地址。操作引用。默认值都是null
String，数组，Person类，Student，Cat，接口类型。。。
Exception in thread "main" java.lang.NullPointerException
空指针异常：对象是null，没有，非要访问它的属性或方法。
Book book = null;
null.属性：赋值取值
null.方法()，表示调用
1、继承关系
继承是指一个类继承另一个类。一个作为子类，另一个是父类。子类可以使用父类的内容，还可以扩展自己的内容。(类，接口)
public class Animal{}
public class Cat extends Animal{}
2、实现关系
实现是指一个类，实现接口中所有的抽象方法。一个类可以同时实现多个接口。
public interface A{}
public class AImple implements A{}
3、依赖关系
一个类依赖另一个类。两个类之间的耦合度不大。代码层面体现：一个类作为另一个类的方法的参数。
public class Pet{}
public class Girl{
public void play(Pet pet){
}
}
4、关联关系
两个类之间的依赖关系比较强。代码层面体现：一个类作为另一个类的属性。
public class Book{}
public class Person{
Book book;
}