学习Java的第七天 | 接口 | static关键词 | final |

1 接口

就是只注重功能的数据类型
在我们的生活中，也有很多接口，电脑上有网线的接口、U盘的接口，每个接口都有对应的功能
在我们的java中，有什么方法，就有什么功能，接口中的方法都是抽象方法，而且默认使用public abstract 修饰的
接口中的方法通过一个具体的方法进行实现，不能使用接口去实现接口
要找到一个可以写方法体的方法去实现，那就是使用 类

类和类之间的关系 ------------ 单根继承 减少代码冗余
类和接口之间的关系 ---------- 多实现 implement 接口写功能，并通过实现类进行功能的实现
接口和接口之间的关系 --------- 多继承 多个接口用,隔开 后面用于面向接口的开发Mybatis
多接口：

public class Bird extends Animal01 implements Animal,A {

    @Override
    public void eat() {
		System.out.println("Bird中继承了Animal，重写了吃方法");
    }

    @Override
    public void move() {

    }
}

可以同时继承和实现接口，继承在前，实现在后

实现类 implement 接口 ------- 向上转型的关系
父接口 变量 = new 实现类对象 ；

子类 extends 父类 --------- 向上转型的关系
父类类型 变量 = new 子类对象

public class Test01 {
    public static void main(String[] args) {
        Animal a = new Bird();
        a.eat();

        Bird c = (Bird) a;
        c.eat();

    }
}
输出：
Bird中继承了Animal，重写了吃方法
Bird中继承了Animal，重写了吃方法

在接口中：
1、默认的抽象方法
2、public static final 修饰的一个变量——常量；
3、在jdk1.8开始，可以有方法体

接口可以通过匿名内部类进行实现

public class Test01 {
    public static void main(String[] args) {
    	//匿名内部类
        Shape shape = new Shape() {
            @Override
            public void area() {
                System.out.println("匿名内部类对接口Shape的实现");
            }
        };
        shape.area();
    }
}

也可以通过lambda表达式进行实现Lambda表达式的格式

public class Test01 {
    public static void main(String[] args) {
        Shape shape = (int a)->{
            System.out.println("lambda对接口的实现");
        };
        shape.area(1);
    }
}

public interface Shape {
    void area(int a);
}

代码中的int a是说：
如果方法有参数 就必须在()写上对应个数的参数，并且数据类型可以省略
如果没有参数 则必须写一个空（）
花括号中：
如果有返回值，且代码只有一句，可以省略{}和return
如果无返回值，且代码只有一句，可以省略{}

Lambda表达式对接口实现，接口中只能有一个抽象方法
应用场景：
多个类之间有共同特征-------------继承
框架 面向接口的开发-----------接口
写项目 设计模式------------------面向接口 书写实现类

2 static

特性：优先加载
在普通的类中，对象创建后，在堆区分配了内存，对象就可以使用了，调用方法只要分配了内存，就可以使用方法

static的优先，比创建对象时分配内存还早

static修饰的内容 在类加载时，优先内存分配
static修饰的内容 通过类进行调用
static修饰的内容 关联于类 可以通过类直接调用
static随时的方法=类方法 static修饰的变量=类变量

通过类进行变量或方法调用的时候，如果static修饰的内容不是自己类中，调用时要加类名，如果static修饰的内容在自己的类中，不用加类名也可以调用

static可以修饰的内容：
可以修饰全局变量==> 类变量
可以修饰普通方法 我们自己定义的方法 类方法
静态代码块

static{}
//静态代码块，不需要我们手动调用执行，随着类的加载，就会被加载，只执行一次
//	1、创建了这个类的对象
//	2、main方法所在的类
//	3、类调用了类变量或类方法
//所以，可以将只需要执行一次的代码，放在静态代码块中

当类与类之间存在继承关系的时候，父类和子类谁会先加载：
父类先加载，子类后加载，有静态代码块时也是
拓展：与静态代码块差不多的有一个构造代码块

{}
//在构造方法执行前，默认执行的一段代码

在有继承关系的类中，静态代码块和构造代码块和构造方法的执行顺序如下：
父类的静态代码块
子类的静态代码块
父类的构造代码块
父类的构造方法
子类的构造代码块
子类的构造方法

static不能修饰的内容：
不能修改类
不能修饰局部变量
不能修饰构造方法
不能修饰getset方法
不能修饰toString
不能修饰抽象方法

static修饰的方法不能被重写，也没有动态绑定

对象可以调用普通方法和静态方法
类只能调用静态方法

3 final

final 顾名思义，是最终的。不可修改的、只读的
final可以修饰的：
final可以修饰类，但被修饰后的类无法被继承
final可以修饰全局变量
赋值方法：
1、直接定义变量的时候，给final 的变量赋初值
2、在使用final修饰的变量前，给变量赋初值 在构造代码块中

public class A {
    public final int a ;
    {
        a=1;
    }
}

3、构造方法中赋值

public class A {
    public final int a ;
    public A() {
        a=1;
    }
}

final可以修饰局部变量
final可以修饰getset但一般不会
final可以修饰方法，但是方法不能被重写
final不能修饰的：
final不能修饰抽象方法
final不能修饰抽象类
final不能修饰构造方法

static final
1、基本数据类型
基本数据类型的值不能变，static final int a ，a是常量不可变
2、引用数据类型
static final int[] a，a 是地址 不可变

public class A {
    public static final int[] A=new int[10];
    {
        for (int i=0;i<A.length;i++){
            A[i]=i;
        }
        //不可以这样↓
        //A=new int[20];
    }
}