从 01 开始
2023-02-09
目录

非访问性修饰符

# 非访问性修饰符

在 Java 中，还有一些修饰符用来实现其他的一些功能。例如：

  • static 修饰符：静态的，用于创建静态变量和静态方法，更多请参考我的另一篇博客：static 关键字 (opens new window)
  • abstract 修饰符：用来创建抽象类和抽象方法，能用在类和类的成员上，之前已经介绍过了：抽象类 (opens new window)
  • final 修饰符：用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。（能用在方法中的局部变量上）
  • Synchronized 和 volatile 修饰符：主要用于线程的编程。

# final 修饰符

有时候，可能希望防止类扩展。在这种情况下，使用 final 修饰符表明一个类是最终的，是不能作为父类的。

Math 类就是一个最终类。String、StringBuilder 和 StringBuffer 类也是。

final 修饰符还可用在成员变量、方法、局部变量。

修饰符 public、protected、private、static， abstract 以及 final 可以用在类和类的成员（数据和方法）上，只有 final 修饰符还可以用在方法中的局部变量上。方法内的最终局部变量就是常量。

final 变量：final 变量能被显式地初始化并且只能初始化一次。如果不初始化会报错。final 可修饰静态变量、实例变量和局部变量。

被声明为 final 的对象的引用不能指向不同的对象（final 对象的引用不能改变）。但是 final 对象里的内容可以被改变。final 修饰符通常和 static 修饰符一起使用来创建类常量。实例:

public class Test{
  final int value = 10;
  // 下面是声明常量的实例
  public static final int BOXWIDTH = 6;
  static final String TITLE = "Manager";

  public void changeValue(){
     value = 12; //将输出一个错误
  }
}
1
2
3
4
5
6
7
8
9
10

final 方法

类中的 final 方法可以被子类继承，但是不能被子类修改。声明 final 方法的主要目的是防止该方法的内容被修改。

如下所示，使用 final 修饰符声明方法。

public class Test{
    public final void changeName(){
       // 方法体
    }
}
1
2
3
4
5

final 类

final 类不能被继承，没有类能够继承 final 类的任何特性。实例：

public final class Test {
   // 类体
}
1
2
3

final 参数：当函数参数为 final 类型时，你可以读取使用该参数，但是无法改变该参数的值。

public class Test4 {
        public static void main(String[] args) {
                new Test4().f1(2);
        }

        public void f1(final int i) {
                //i++;    //i是final类型的,值不允许改变的.
                System.out.print(i);
        }
}
1
2
3
4
5
6
7
8
9
10

注意

  1. 抽象方法不能用 final 修饰
  2. final 不能用于修饰构造方法
  3. 之所以有 final，是出于设计或效率的考量。编译器在遇到调用 final 方法时候会转入内嵌机制，大大提高执行效率。

# Synchronized 修饰符

Synchronized 关键字声明的方法同一时间只能被一个线程访问。Synchronized 修饰符可以应用于四个访问修饰符。实例：

public synchronized void showDetails(){
.......
}
1
2
3

# Transient 修饰符

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。

该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。实例：

public transient int limit = 55;   // will not persist
public int b; // will persist
1
2

更多参考 IO 类的序列化：序列化与反序列化 (opens new window)

# volatile 修饰符

Volatile 修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。一个 volatile 对象引用可能是 null。实例：

public class MyRunnable implements Runnable{
    private volatile boolean active;
    public void run(){
        active = true;
        while (active){ // line 1

            // 代码
        }
    }
    public void stop(){
        active = false; // line 2
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

一般地，在一个线程中调用 run()方法，在另一个线程中调用 stop()方法。如果 line 1（看注释）中的 active 位于缓冲区的值被使用，那么当把 line 2 中的 active 设置成 false 时，循环也不会停止。

# 参考

Java 关键字 final、static 使用总结_熔 岩的技术博客_51CTO 博客 (opens new window)

Java 修饰符 - 知乎 (opens new window)

《Java 语言程序设计-基础篇》11.15 小节

在Java中，还有一些修饰符用来实现其他的一些功能。例如：

  • static修饰符：静态的，用于创建静态变量和静态方法，更多请参考：static关键字 (opens new window)
  • abstract修饰符：用来创建抽象类和抽象方法，能用在类和类的成员上，之前已经介绍过了：抽象类 (opens new window)
  • final修饰符：用来修饰类、方法和变量，final修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。（能用在方法中的局部变量上）
  • Synchronized和volatile修饰符：主要用于线程的编程。 ‍

# final修饰符

有时候，可能希望防止类扩展。在这种情况下，使用 final 修饰符表明一个类是最终的，是不能作为父类的。

Math 类就是一个最终类。String、StringBuilder 和 StringBuffer类也是。 ‍ final修饰符还可用在成员变量、方法、局部变量。

修饰符 public、protected、private、static， abstract 以及 final 可以用在类和类的成员（数据和方法）上，只有 final 修饰符还可以用在方法中的局部变量上。方法内的最终局部变量就是常量。

final变量：final变量能被显式地初始化并且只能初始化一次。如果不初始化会报错。final可修饰静态变量、实例变量和局部变量。

被声明为final的对象的引用不能指向不同的对象（final对象的引用不能改变）。但是final对象里的内容可以被改变。final修饰符通常和static修饰符一起使用来创建类常量。实例:

public class Test{
  final int value = 10;
  // 下面是声明常量的实例
  public static final int BOXWIDTH = 6;
  static final String TITLE = "Manager";

  public void changeValue(){
     value = 12; //将输出一个错误
  }
}
1
2
3
4
5
6
7
8
9
10

final方法

类中的final方法可以被子类继承，但是不能被子类修改。声明final方法的主要目的是防止该方法的内容被修改。

如下所示，使用final修饰符声明方法。

public class Test{
    public final void changeName(){
       // 方法体
    }
}
1
2
3
4
5

final类

final类不能被继承，没有类能够继承final类的任何特性。实例：

public final class Test {
   // 类体
}
1
2
3

‍ final参数：当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。

public class Test4 {
        public static void main(String[] args) {
                new Test4().f1(2);
        }

        public void f1(final int i) {
                //i++;    //i是final类型的,值不允许改变的.
                System.out.print(i);
        }
}
1
2
3
4
5
6
7
8
9
10

‍ 注意

  1. 抽象方法不能用final修饰
  2. final不能用于修饰构造方法
  3. 之所以有final，是出于设计或效率的考量。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。 ‍

# Synchronized修饰符

Synchronized关键字声明的方法同一时间只能被一个线程访问。Synchronized修饰符可以应用于四个访问修饰符。实例：

public synchronized void showDetails(){
.......
}
1
2
3

# Transient修饰符

序列化的对象包含被transient修饰的实例变量时，java虚拟机(JVM)跳过该特定的变量。

该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。实例：

public transient int limit = 55;   // will not persist
public int b; // will persist
1
2

‍ 更多参考IO类的序列化：序列化与反序列化 (opens new window) ‍

# volatile修饰符

Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。一个volatile对象引用可能是null。实例：

public class MyRunnable implements Runnable{
    private volatile boolean active;
    public void run(){
        active = true;
        while (active){ // line 1

            // 代码
        }
    }
    public void stop(){
        active = false; // line 2
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

一般地，在一个线程中调用run()方法，在另一个线程中调用stop()方法。如果 line 1（看注释）中的active位于缓冲区的值被使用，那么当把line 2中的active设置成false时，循环也不会停止。

# 参考

Java关键字final、static使用总结_熔 岩的技术博客_51CTO博客 (opens new window)

Java 修饰符 - 知乎 (opens new window)

《Java语言程序设计-基础篇》11.15小节

‍

上次更新: 2025/5/5 17:15:09
访问性修饰符
内部类

← 内部类→

最近更新
01
语雀文档一键下载至本地教程
07-04
02
要成功，就不要低估环境对你的影响
07-03
03
血泪教训：电子设备要定期开机
07-02
更多文章>
Theme by Vdoing | Copyright © 2022-2025 | 粤 ICP 备 2022067627 号 -1 | 粤公网安备 44011302003646 号 | 点击查看十年之约