静态与唯一（static/final）

360次阅读

共计 2300 个字符，预计需要花费 6 分钟才能阅读完成。

static 表示静态的意思，可以修饰变量、方法，还可以编写静态代码块。能够直接被类引用。

在我们平时的使用当中，static 最常用的功能就是修饰类的属性和方法，让他们成为类的成员属性和方法，我们通常将用 static 修饰的成员称为类成员（类变量与类方法）或者静态成员（静态变量与静态方法）。

类变量就是用 static 修饰的成员变量。

class Student {private String name;
    private int age; // 学生的 id
    private int sid; // 类变量，记录学生数量，分配学号
    public static int numberOfStudent = 0;
    public Student(String name, int age){this.name = name;
        this.age = age; // 通过 numberOfStudent 给学生分配学号
        this.sid = ++numberOfStudent;
    }
    // 打印属性值
    public void show() {System.out.println("Student : name=" + name + ", age=" + age + ", sid=" + sid );
    }
}
public class StaticDemo01 {public static void main(String[] args) {Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王五", 25);
        Student s4 = new Student("赵六", 26);
        s1.show();// Student : name= 张三, age=23, sid=1
        s2.show(); // Student : name= 李四, age=24, sid=2
        s3.show(); // Student : name= 王五, age=25, sid=3
        s4.show(); // Student : name= 赵六, age=26, sid=4
    }
}

运行结果：

静态与唯一（static/final）

static 的另一个作用，就是修饰成员方法。相比于修饰成员属性，修饰成员方法对于数据的存储上面并没有多大的变化，因为我们从上面可以看出，方法本来就是存放在类的定义当中的。static 修饰成员方法最大的作用，就是可以使用 ” 类名. 方法名 ” 的方式操作方法，避免了先要 new 出对象的繁琐和资源消耗，我们可能会经常在帮助类中看到它的使用：

public class StaticDemo02 {public static void print(Object o){System.out.println(o);
    }

    public static void main(String[] args) {StaticDemo02.print("Hello world");
    }
}

运行结果：

静态与唯一（static/final）

定义在类的里面方法的外面，随着类的加载而执行且执行一次，优先与 main()和构造方法执行。

格式：

class A{static{ }
 public void v(){}}

public class StaticDemo03 {static int x;
    static {System.out.println("静态代码块");
        x = 12;
    }
    public StaticDemo03(){System.out.println("构造函数");
    }
    public static void main(String[] args) {new StaticDemo03().print();
    }
    public void print(){System.out.println(x);
    }
}

运行结果：

静态与唯一（static/final）

在 java 中，final 的含义在不同的场景下有细微的差别，但总体上来说，它指的是“这是不可变的”。

都是被 final 修饰的类，目的就是供我们使用，而不让我们所以改变其内容。

final class T{// T 为一个功能类，Scanner\Random
    public void t(){System.out.println("T");
    }
}
public class FinalDemo01 extends T {// 不能被继承
    public static void main(String[] args) {}}

final 修饰的方法，不能被重写

class T {public final void t() {//final 修饰的方法是唯一的
        System.out.println("T");
    }
}

public class FinalDemo01 extends T {public void t() {// 不能被重写
        System.out.println("FinalDemo01");
    }

    public static void main(String[] args) {}}

成员变量

被 final 修饰的成员变量是一个常量，叫符号常量。一般都有书写规范，所有字母都大写。

class A{final double PI=3.1415926;
}

局部变量

声明的变量是唯一的不能重新赋值。

public class FinalDemo02 {public static void main(String[] args) {// 声明变量，使用 final 修饰
        final int a;
        // 第一次赋值
        a = 10;
        // 第二次赋值
        a = 20; // 报错, 不可重新赋值


        // 声明变量，直接赋值，使用 final 修饰
        final int b = 10;
        // 第二次赋值
        b = 20;
        // 报错, 不可重新赋值
    }
}