Java学习——static，final关键字，游离块，接口

一，static关键字

1,1——static（静态的），用来修饰属性跟方法的一个修饰符

        使用static修饰的属性以及方法，在进行调用的时候，是直接通过类名进行调用的，不需要去创建对象来调用。

在Java中一般使用 static final 一起定义一个静态常量，常量名字一般大写，如果涉及多个单词，则用_隔开，比如在Math类中的PI常量

  public static final double PI = 3.14159265358979323846;

在进行调用的时候就直接通过Math.PI进行调用了，还有很多例子，比如Arrays.toString（）方法，用来遍历输出数组中的元素。

如果某个类或者某个变量被static修饰了，那么这个类或者这个变量的控制权就不在对象手上了，全部的控制权就在类的手上了。

比如现在有一个类，叫People类，暂且不考虑修饰符是私有还是公有，name属性被static修饰了，age属性没有被修饰，现在进测试类进行测试

public class People {
     int age;
     static String name;


    @Override
    public String toString() {
        return "People{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

}

测试类：创建两个对象，分别通过对象给其age属性赋值为11 和 12；name属性则通过类来进行赋值

    public static void main(String[] args) {
        People people=new People();
        People people1=new People();
        people.age=11;
        people1.age=12;
        People.name="张三";
        System.out.println(people.toString());
        System.out.println(people1.toString());
    }



测试结果：

People{age=11, name='张三'}
People{age=12, name='张三'}

结果是两个对象的name属性都被赋值了，这个值是通过类来调用static静态属性来赋值的

我们就可以得出结论，使用static修饰的属性，就可以理解为是一个全局变量了，只能通过类来给它赋值，但是，通过对象名来给它赋值也是不会报错的，但是一般不这么做。

同样，用static修饰的方法只能被继承，但是不能被重写

eg：

定义一个类People，用static修饰一个方法，再定义一个Man类来继承它

结果是不能重写这个方法的。

二，游离块

        游离块也叫做初始化块，其本质就是一个方法体的执行

    {
        System.out.println("我是第一个游离块");
    }

    {
        System.out.println("我是第二个游离块");
    }

游离块应用的场景就是，当有重复的初始化代码的时候，可以将其放在一个游离块中，在每次调用类创建对象的时候，他就会自己执行一次。

        注意的是：

        静态游离块，只会执行一次。静态游离块指的就是static修饰的游离块，它只会在第一次调用类创建对象的时候执行一次，以后再调用类创建对象的时候就不会执行了

        普通游离块，是创建一次对象就执行一次

执行顺序问题：

当类中有构造方法，游离块，静态游离块，普通方法的时候

eg：有一个demo类：里面同时包含这些方法

 static {
        System.out.println("我是一个静态游离块");
    }

    public Demo_youlikuai() {
        System.out.println("我是构造函数");
    }

    public void print() {
        System.out.println("我是一个普通的方法");
    }

    {
        System.out.println("我是第一个游离块");
    }

    {
        System.out.println("我是第二个游离块");
    }

测试结果：

 public static void main(String[] args) {
        Demo_youlikuai D1 = new Demo_youlikuai();
        D1.print();
    }


结果：

我是一个静态游离块
我是第一个游离块
我是第二个游离块
我是构造函数
我是一个普通的方法

顺序：静态>游离块>构造方法>普通方法

三，final关键字

3.1——final（最终的）

字面上很好理解，如果说被final修饰的，那么它就是最终的，也就可以理解为不能“变”了

final可以用来修饰：属性，类，方法

当final修饰属性的时候，这个属性不能被赋值；

当final修饰类的时候，这个类不能被继承

当final修饰方法的时候，这个方法不能被重写

但是子类依旧是可以继承父类被final修饰的属性或者方法的。

eg：

Fu类：定义一个属性age，给它赋值为45，定义一个print方法，二者都是用final修饰的。

/**
 * 父类
 */
public class Fu {
    final int age = 45;

    final public void print() {
        System.out.println("我是父类");
    }
}

Son类：试图重写父类的方法。

测试类：

public class Test {
    public static void main(String[] args) {
        Son son=new Son();
        System.out.println(son.age);
        son.print();
    }
}

---

测试结果是：

45
我是父类

        说明虽然用了final修饰，子类是可以调用父类的final修饰的成员变量以及方法的。仅仅是不能重写方法可以重新给变量赋值

修改父类为final修饰

测试结果均是不可以的

四、接口

4.1——接口的定义

        接口：我个人理解就是插口，通俗点来理解可以理解为笔记本上的各个插口，可以连USB，连充电口的，连网线口的........

        直接解释：接口是功能方法的集合，就是说只声明方法，而具体实现交给实现类去实现。还是拿笔记本来举例子，笔记本上的所有插口是不能自己去实现具体功能的，都需要插线连接才能去使用相关功能，接口本身什么都不实现，具体交给插在接口上的线，比如电源线，它连接笔记本跟插座，它才是去实现这个功能的，电源接口本身什么都实现不了。

4.2——如何使用接口？

1，使用interface关键字去定义一个接口。

public interface A{
    
}

2，定义一个实现类去实现接口，关键字是implements

public B implements A{
    
}

这样就定义了一个实现类来实现了一个接口

4.3——使用接口的注意事项

1.接口是不能创建对象的

2.接口里面能放哪些方法？

答：抽象方法，普通方法（只有声明），从JDK8开始，接口中可以定义default，static修饰的普通方法（要实现）具体如下：

/**
 * 新建了一个接口DAO
 */
public interface DAO {
    public static final int aaa = 100;//静态常量

    public void run();//新建一个方法，没有具体的实现

    public abstract  void eat();//新建一个抽象方法

    public default void m1(){
        System.out.println("这是一个用default修饰的方法");
    }

    public static void m2(){
        System.out.println("这是一个用static修饰的方法");
    }

}

3.接口中可以定义变量吗？

答：可以，但是所有变量默认都是final static修饰的静态常量

4.接口中可以定义private修饰的方法吗？

答：JDK8不可以，接口中默认的方法都是public abstract修饰的，但是从JDK9开始可以在接口中定义私有的方法了。

5.如何访问接口中的静态常量？

答：使用接口名调用方法名跟常量名