橘子味的心

    • 二十五岁时我们都一样愚蠢、多愁善感，喜欢故弄玄虚，可如果不那样的话，五十岁时也就不会如此明智。

    标题：Java非访问修饰符

    Java提供了许多非访问修饰符来实现许多其他功能。

    • static修饰符用于创建类方法和变量。
    • final修饰符用于完成类，方法和变量的实现。
    • abstract修饰符用于创建抽象类和方法。
    • synchronized和volatile修饰符，用于线程。

    下面来逐个了解和学习这些非访问修饰符。

    1. static修饰符

    1.1. 静态变量

    static关键字用于创建独立于类实例的变量。无论类的实例数有多少个，都只存在一个静态变量副本。静态变量也称为类变量。局部变量不能声明为static。

    1.2. 静态方法

    static关键字用于创建独立于类实例的方法。
    静态方法不能使用作为类的对象的实例变量，静态方法也叫作类方法。静态方法从参数中获取所有数据并从这些参数计算某些内容，而不引用变量。可以使用类名后跟一个点(.)以及变量或方法的名称来访问类变量或方法。

    示例

    • static修饰符用于创建类方法和变量，如下例所示 - 
    1. public class InstanceCounter {
    2.  
    3.    private static int numInstances = 0;
    4.  
    5.    protected static int getCount() {
    6.       return numInstances;
    7.    }
    8.  
    9.    private static void addInstance() {
    10.       numInstances++;
    11.    }
    12.  
    13.    InstanceCounter() {
    14.       InstanceCounter.addInstance();
    15.    }
    16.  
    17.    public static void main(String[] arguments) {
    18.       System.out.println("Starting with " + InstanceCounter.getCount() + " instances");
    19.  
    20.       for (int i = 0; i < 500; ++i) {
    21.          new InstanceCounter();
    22.       }
    23.       System.out.println("Created " + InstanceCounter.getCount() + " instances");
    24.    }
    25. }
    26. Java

    执行上面示例代码，得到以下结果：

    1. Started with 0 instances
    2. Created 500 instances
    3. Shell

    2. final修饰符

    2.1. final变量

    final变量只能显式地初始化一次，声明为final的引用变量永远不能重新分配以引用不同的对象。但是，可以更改对象内的数据。 因此，可以更改对象的状态，但不能更改引用。
    对于变量，final修饰符通常与static一起使用，以使常量成为类变量。

    示例

    1. public class Test {
    2.    final int value = 10;
    3.  
    4.    // 以下是声明常量的示例：
    5.    public static final int BOXWIDTH = 6;
    6.    static final String TITLE = "Manager";
    7.  
    8.    public void changeValue() {
    9.       value = 12;   // 会出错，不能重新赋值
    10.    }
    11. }
    12. Java

    2.2. final方法

    任何子类都不能覆盖final方法。 如前所述，final修饰符可防止在子类中修改方法。

    声明final方法的主要目的是不让其它人改变方法的内容。

    示例
    可以在类声明中使用final修饰符声明方法，如下例所示 - 

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

    2.3. final类

    使用声明为final的类的主要目的是防止类被子类化。 如果一个类被标记为final，那么这个类不能被其它类继承。

    示例

    1. public final class Test {
    2.    // body of class
    3. }
    4. Java

    3. abstract饰符

    3.1. 抽象类

    抽象(abstract)类不能实例化。如果一个类声明为抽象(abstract)，那么唯一的目的是扩展该类。

    一个类不能是同时是abstract和final(因为final类不能被扩展)。 如果一个类包含抽象方法，那么该类应该被声明为abstract。 否则，将抛出编译错误。

    抽象类可以包含抽象方法以及普通方法。

    示例

    1. abstract class Caravan {
    2.    private double price;
    3.    private String model;
    4.    private String year;
    5.    public void getYear(String y){}；// 这是一个普通方法
    6.    public abstract void goFast();   // 这是一个抽象方法
    7.    public abstract void changeColor();// 这是一个抽象方法
    8. }
    9. Java

    3.2. 抽象方法
    抽象方法是在没有任何实现的情况下声明的方法。 方法体(实现)由子类提供。 抽象方法永远不会是最终的或严格的。

    扩展抽象类的任何类都必须实现超类的所有抽象方法，除非子类也是抽象类。

    如果一个类包含一个或多个抽象方法，那么该类必须声明为abstract。 抽象类不需要包含抽象方法。

    抽象方法以分号结尾。 示例：public abstract sample();

    示例

    1. public abstract class SuperClass {
    2.    abstract void m();   // 抽象方法
    3. }
    4.  
    5. class SubClass extends SuperClass {
    6.    // 实现抽象方法
    7.    void m() {
    8.       // 实现代码.........
    9.    }
    10. }
    11. Java

    4. synchronized修饰符

    synchronized关键字用于指示一次只能访问一个方法的方法。synchronized修饰符可以应用于四个访问级别修饰符中的任何一个。

    示例

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

    5. transient修饰符

    实例变量标记为transient，表示JVM在序列化包含它的对象时跳过特定变量。

    此修饰符包含在创建变量的语句中，位于变量的类或数据类型之前。

    示例

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

    6. volatile修饰符

    volatile修饰符用于让JVM知道访问变量的线程必须始终将其自己的变量私有副本与内存中的主副本合并。

    访问volatile变量会同步主内存中变量的所有缓存复制。 volatile只能应用于实例变量，类型为private。 volatile对象引用可以为null。

    示例

    1. public class MyRunnable implements Runnable {
    2.    private volatile boolean active;
    3.  
    4.    public void run() {
    5.       active = true;
    6.       while (active) {   // line 1
    7.          // some code here
    8.       }
    9.    }
    10.  
    11.    public void stop() {
    12.       active = false;   // line 2
    13.    }
    14. }
    15. Java

    通常，在一个线程(使用Runnable开始的线程)中调用run()，并从另一个线程调用stop()。 如果在第1行中使用了active的缓存值，那么当在第2行中将active设置为false时，循环可能不会停止。


    目录

    分类

    © 2020-2025 橘子味的心

  • 黔ICP备17008247号-2
  • 贵公网安备52022102000140