关键字——static、final

关键字——static、final 关键字 final 1.数据

声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能被改变的常量。

对于基本类型final使其数值不变

对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的。

2.方法

被final修饰的方法不能被子类重写。private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方法不是重写基类方法，而是在子类中定义了一个新的方法。因为被private修饰的方法外部无法访问。

3.类

声明类不允许继承

static 1.静态变量

静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它。静态变量在内存中只存在一份。

实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。

public  class StaticTest {

    static int x = 9;//静态变量
    int y = 9;//实例变量
}

static修饰的变量可以直接通过类名来调用，没有被static修饰的通过创建对象来调用

public  class StaticTest {

    static int x = 9;
    int y = 9;

    public static void main(String[] args) {
        StaticTest staticTest = new StaticTest();
        int y = staticTest.y;
        
        int x = StaticTest.x;
    }
}

​ 但是要注意，被静态修饰的变量在内存中只存在一份，无论你new了几个对象，如果要对static修饰的变量修改的话修改的是同一个值

这是我写的一个Dog类

public class Dog {
    static String name;//被static修饰
    int age; 
    public static String getName() {
        return name;
    }

    public static void setName(String name) {
        Dog.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog的名字和年龄为:" +"name=" + name+
                '，'+"age=" + age;
    }
}

在main函数里执行以下代码你会发现最后输出的名字都一样

 		Dog dog1 = new Dog();
        dog1.setAge(3);
        dog1.setName("大黄");
        Dog dog2 = new Dog();
        dog2.setAge(4);
        dog2.setName("大黑");
        Dog dog3 = new Dog();
        dog3.setAge(5);
        dog3.setName("大紫");
        System.out.println(dog1);
        System.out.println(dog2);
        System.out.println(dog3);

​ 这是因为在Dog类里名字被static修饰是唯一的，所以在内存里只有一份，无论有几个对象修改的name都是同一个name。

输出结果

2. 静态方法

​ 静态方法在类加载的时候就存在了，它不依赖于任何实例。所以静态方法必须有实现，也就是说它不能是抽象方法。简单理解就是抽象类里如果用static‘修饰方法的话必须实现，因为在子类实现该抽象类里的方法的时候会无法找到被static修饰的方法。

• static方法可以使用对象调用，也可以直接用类名调用，建议用类名直接调用

• 在static方法内部只能访问类的static属性，不能访问类的非static属性,static属性先加载。

public abstract class methonds {
    public static void function(){
    		//do something
    }
    //abstract和static不可以修饰交通一个方法
}

​ 只能访问所属类的静态字段和静态方法，方法中不能有 this 和 super 关键字，因为这两个关键字与具体对象关联。

public class Test {

    static int num;//静态变量
    int age; //实例变量
     public static void function1(){
       int a = num;
       // int b = age; //非静态变量无法在静态方法中调用
       // int c= this.num; //在static修饰的方法中不能有this和super关键字，因为这两个和具体对象关联
    }
    public  void function2(){
        int a = age; 
        int b = this.num;
    }
}

3. 静态语句块

代码块在类中声明，类似一个没有名称的方法体(代码块)，代码块分实例块和静态块

实例块：每次创建对象时自动调用

{

​ //任何符合语法的Java代码

}

静态块：类加载时自动调用，仅一次，与是否创建对象无关。

static {

​ //任何符合语法的Java代码

}

public class Test {
    static{
        //静态代码块
        System.out.println("静态修饰代码块");
    }
    {
        //代码块
        System.out.println("代码块");
    }
    public static void main(String[] args) {
        new Test();
        new Test();
        new Test();
    }
}

输出结果如下

4. 静态内部类

非静态内部类依赖于外部类的实例，也就是说需要先创建外部类实例，才能用这个实例去创建非静态内部类。而静态内部类不需要。

public class Test {

    static int num;//静态变量
    int age; //实例变量
    class exampleClass{

    }
    static class staticClass{

    }
    
    public static void main(String[] args) {
        //exampleClass exampleClass = new exampleClass();//非静态class无法直接创建
        Test test = new Test();
        exampleClass example = test.new exampleClass();
        
        staticClass sta = new staticClass();//而static可以直接创建
    }
}

5. 初始化顺序

静态变量和静态语句块优先于实例变量和普通语句块，静态变量和静态语句块的初始化顺序取决于它们在代码中的顺序。

public class Test {

    static {
        //静态代码块
        System.out.println("静态代码块");
    }

    public Test() {
        //构造函数
        System.out.println("test 构造函数");
    }

    {
        //实例代码块
        System.out.println("实例代码块");
    }
    public static void main(String[] args) {
        new Test();
    }
}

输出结果