【Java】状态修饰符 final & static

目录

final 修饰我们的成员方法、成员变量、类

示例代码：

final 修饰的局部变量

示例代码：

static

示例代码：

static 访问特点：

示例代码：

static关键字的用途

示例代码：

static 修饰常量

示例代码：

---

1. final(最终态)

2. static（静态）

final 修饰我们的成员方法、成员变量、类

特点：

• 修饰变量：该变量的值，不能被修改，必须初始化（手动赋值）
• 修饰方法：该方法，不能被重写
• 修饰类：该类，不能被继承

示例代码：

Parent.java

package com.面向对象.Demo15;
 
public class Parent {
    private int age; // 默认
    private final int age2 = 10; //final——必须初始化值
 
    /**
     * final 关键字修饰的 类、成员属性、成员方法
     * 1.被 final 关键字修饰的类 无法被继承
     * 2.被 final 关键字修饰的成员方法 无法被重写
     * 3.被 final 关键字修饰的成员属性 该变量的值（必须初始化值） 无法被修改
     */
//    public final void a1() { //报错， final——无法被重写
//    }
    public void a1() {
//        this.age2= 20; // 报错，final——无法被修改
    }
}

Student.java 

package com.面向对象.Demo15;
 
public class Student extends Parent {
    @Override
    public void a1() {
 
    }
}

---

final 修饰的局部变量

• 基本数据类型：final 修饰的基本数据类型的值不能够被修改的；
• 引用数据类型：final 修饰的引用数据类型 引用类型地址不能够发生变化的，但是引用类型的地址里面成员属性值是可以发生变化的。

示例代码：

Student.java

package com.面向对象.Demo16;
 
public class Student {
    public int age = 30;
}

StudentDemo.java

package com.面向对象.Demo16;
 
public class StudentDemo {
    public static void main(String[] args) {
        // 使用final关键字修饰局部变量
        final int age = 20;
//        age=30; //报错，使用 final 修饰的局部变量 是基本数据类型 不可以修改
       final Student student = new Student(); //引用类型
        student.age = 10; // 使用 final 修饰局部变量 是一个引用类型的 引用类型的地址 不能够被修改的，
        // 但是，引用类型的地址里面的属性值是可以修改
//        student = null; // 报错，引用类型的地址不可以修改
//        student = new Student(); // 报错，引用类型的地址不可以修改
    }
}

---

static

• static （静态），可以修饰成员方法，成员变量
• static 修饰的特点：被类的所有对象共享访问。

示例代码：

Student.java

package com.面向对象.Demo17;
 
public class Student {
    public String name;
//    public String school = "清华大学"; //方法1——成员变量
    public static String school; //方法2——静态变量
 
    /**
     * 通过static关键字 修饰的 成员方法——静态方法
     * 通过static关键字 修饰的 成员变量——静态变量
     */
 
    public void show() { //成员方法
        System.out.println(name + "," + school);
    }
 
}

Test01.java

package com.面向对象.Demo17;
 
public class Test01 {
    public static void main(String[] args) {
        /**
         * 疑问 为什么s1对象. 没有静态变量 school 提示呢？
         * 解答：静态变量的方法特点：直接通过 类名.
         * Student.school="清华大学"
         * 下面的s1 s2 s3.school 都可以不需要
         */
        Student.school="清华大学";
        // 通过static 关键字修饰的 被类的所有对象   共享访问
        Student s1 = new Student();
        Student s2 = new Student();
        Student s3 = new Student();
        s1.name = "小明";
//        s1.school = "清华清华";
//        s1.school = "清华大学";//这里的s1没有school对象，但写出类不报错，
        // s2.school不需要赋值，如果不是static，s2.school没有赋值就为null
        s1.show();
 
        s2.name = "小军";
//        s2.school = "清华大学";
        s2.show();
        s2.school = "北京大学";
        s3.show(); //这里的s3.school为 北京大学
        /**
         * s1.school = "清华清华";
         * s2.school = "清华大学";
         * 冗余
         * 方法1.默认值的形式 优化代码 s1和s2 对象不需要给school赋值
         * 方法2.静态变量 static
         *
         */
    }
}

---

static 访问特点：

非静态成员方法

• 能够访问静态的成员变量
• 能够访问非静态的成员变量
• 能够访问静态的成员方法
• 能够访问非静态的成员方法

静态成员方法

• 能够访问静态成员变量，但是不能够直接访问成员变量
• 能够访问静态成员方法，但是不能够直接访问成员方法

示例代码：

Student.java

package com.面向对象.Demo18;
 
public class Student {
    /**
     * 成员属性 和 方法
     */
    private int age; //非静态
    public static int staticAge;//静态
 
    // 非静态
    public void a1() {
//        在a1 非静态方法中 可以访问 非静态方法 静态方法 静态成员属性 非静态成员属性
        System.out.println(age); //访问  非静态成员属性
        System.out.println(staticAge); //访问 静态成员属性
        staticA2(); //访问 静态方法
        staticA3();
        a4(); //访问  非静态方法中
    }
 
    // 静态
    public static void staticA2() {
        // 在staticA2 静态方法中 访问 非静态方法 静态方法 静态成员属性 非静态成员属性
        /**
         * staticA2 静态方法中，非静态方法 和 静态方法 特点？
         * staticA2 静态方法中，不能够访问 非静态成员方法 但是可以访问 静态方法
         */
//        a1(); //报错，静态方法中，不能够方法 非静态成员方法，想要访问，只需要将a1()改为静态即可
        staticA3(); // 静态可以访问静态
    }
    public static void staticA3() {
        /**
         *staticA3 静态方法中，不能够访问 非静态成员属性 但是可以访问 静态成员属性
         */
//        System.out.println(age); //报错，不能够访问 非静态成员属性
        System.out.println(staticAge); //可以访问 静态成员属性
    }
    //非静态
    public void a4(){
 
    }
}

---

static关键字的用途

• 一句话描述就是：方便在没有创建对象的情况下进行调用（方法/变量）
• 显然，被static 关键字修饰的方法或变量 不需要依赖与对象来进行访问，只要类被加载了，就可以通过类名去进行访问。
• static 可以用来修饰类的成员方法、类的成员变量，另外也可以编写static 代码块 来优化程序性能

示例代码：

Test01.java

package com.面向对象.Demo18;
 
public class Test01 {
    public static void main(String[] args) {
        /**
         * static 应用场景 不想通过new的形式 访问成员方法和属性的话
         * static 修饰成员方法和成员属性 变成 静态的成员属性和静态的成员方法
         */
        Student s = new Student();
        s.a1();
//        s.staticA2();//s没有staticA2这个对象，但是也不报错，官方不推荐
        Student.staticA2();
        /**
         * 通过 static 被类中所有对象共享
         * 类名.静态方法
         *
         * 总结：如果是通过 static 修饰的成员方法和属性
         * 我们可以直接通过 ”类名.“ 访问（成员方法和属性）
         *
         * 实例访问 成员方法和成员属性
         * 非静态的 成员方法 和 成员属性 必须通过 new 该对象 "实例." 成员方法和成员属性
         */
    }
}

---

static 修饰常量

static 关键字的应用场景，java中的常量（Constant）

示例代码：

Constant.java

package com.面向对象.Demo19;
 
public class Constant {
    /**
     * 该类定义都是常量
     * 什么是常量？
     * 1.定义好之后，值不能够被修改（final）
     * 2.常量名称全部都是为大写
     *  2.1 写大写太麻烦，先写成小写，然后使用快捷键改为大写
     *  2.2 IDEA中的快捷键(鼠标光标（常量名称）Ctrl+Shift+u),再按就改为小写
     */
    public static final int CODE_200 = 200;
    public static final int CODE_404 = 404;
    public static final int CODE_500 = 500;
    /**
     * JavaWeb开发
     * CODE_200 表示 成功
     * CODE_404 表示 找不到
     * CODE_500 表示 错误
     */
}

Test01.java

package com.面向对象.Demo19;
 
public class Test01 {
    public static void main(String[] args) {
//        Constant constant = new Constant(); //后面直接用"类名." 访问
        int code = 200;
        if (Constant.CODE_200 == code) { // JavaWeb 开发时
            System.out.println("成功");
            return;
        }
        if (Constant.CODE_404 == code) {
            System.out.println("找不到");
            return;
        }
        if (Constant.CODE_500 == code) {
            System.out.println("错误");
            return;
        }
 
    }
}

---

下一篇文章：main方法的深入理解