Java修饰符

• 访问控制修饰符
• 非访问修饰符

Java语言提供了很多修饰符，主要分为以下两类：
访问修饰符
非访问修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端

public class ClassName{
    private boolean myFlag;
    static final double weeks = 9.5;
    public static void main(String[] args) {
        //方法体
    }
}

访问控制修饰符

Java中可以使用访问控制符来保护对类、变量、方法和构造方法的访问。

默认
不使用任何关键字，对同一个包内的类是可见的。接口中的变量都是隐式声明为public staitc fianl,而接口中方法默认情况下权限为public。
示例

String version = "1.5.1";
boolean processOrder(){
    return true;
}

private
最严格访问级别，只能被所属类访问，并且类和接口不能声明为private。
通过类中公共的getter方法被外部类访问。
主要是隐藏类的实现细节和保护类的数据。

public
可以被任何其他的类访问。
如果包不同，需要导入相应的包，类所有的公有方法和变量都能被其子类继承。

protected

• 子类与基类在同一包中，被声明为protected的变量、方法和构造器能被同一个包中任何其他类访问；
• 字类与基类不在同一个包中：那么子类中，字类实例可以访问从其他基类继承而来的protected方法，而不能访问基类实例的protected方法。

非访问修饰符

• static

  1. 静态变量：
     static 声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。不用修饰局部变量。
  2. 静态方法
     static 声明独立于对象的静态方法。不能使用类的非静态变量。静态方法从参数列表获得数据，从而计算。

     示例
     public class InstanceCounter{
        private static int numInstance = 0;
        protected static int getCount(){
            return numInstance;
        }
        private static void addInstance(){
            numInstance++;
        }
        public static void main(String[] args) {
            System.out.println("Starting with"+InstanceCounter.getCount()+"instances");
            for (int i = 0;i < 500 ;i++ ) {
                new InstanceCounter();
            }
            System.out.println("Created"+ InstanceCounter.getCount()+"instances");
        }
     }

      

• final

  1. 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;//这里会报错
        }
     }

      

  2. final方法
     可以被子类继承但是不能被字类修改，主要目的就是防止该方法的内容被修改。

     示例
     public class Test{
        public final void changeName(){
            //方法体
        }
     }
      

      

  3. final类
     不能被继承，没有类能够继承final类任何特性

     示例
     public final class Test{
        //类体
     }
      

      

• abstract
  1. 抽象类
     不能用来实例化对象，目的，是为了将来对该类进行扩充，不能同时被abstract 和final修饰。
     如果一个类含有抽象方法那么这个类也要声明为抽象类。否侧会编译错误
     可以包含抽象方法和非抽象方法

     示例
     abstract class Caravan{
        private double price;
        private String model;
        private String year;
        public abstract void goFast();//抽象方法格式
        public abstract void changeColor();
     }

      

  2. 抽象方法
     是一种没有任何实现的方法。该方法的具体实现由字类提供。
     抽象方法不能声明成final和staitc
     任何继承抽象类的字类必须实现父类所有的抽象方法，除非该子类也是抽象类
     格式：public abstract method();

     示例
     public abstract class Superclass{
        abstract void m();//抽象方法
     }
     public Subclass extends SuperClass{
        //实现抽象方法
        void m(){
            方法
        }
     }

      

• synchronized
  synchronized 声明的方法同一时间只能被一个线程访问。可以用于4个访问修饰符。
  示例
  

  public synchronized void showDetails(){
      ...
  }
  

• volatile
  修饰的成员变量在每次被线程访问时，都会强制从共享内存中重新度去该成员变量的值。而且发生变化时，会强制线程将变化值回写导共享内存中。这样两个线程总是看到某个成员变量的同一个值。
  

  public class MyRunnable implements Runnable
  {
      private volatile boolean active;
      public void run()
      {
          active = true;
          while (active) // 第一行
          {
              // 代码
          }
      }
      public void stop()
      {
          active = false; // 第二行
      }
  }
  

keywords-java修饰符

原文：https://www.cnblogs.com/bomily0212/p/12081983.html