JavaBasic
- Java 修饰符
  - 访问控制修饰符
  - 非访问修饰符

JavaBasic

Java 修饰符

访问修饰符
非访问修饰符
修饰符原来定义类、方法或者变量，放在语句最前端

访问控制修饰符

default ：默认，同一个包内可见，不使用任何的修饰符，使用对象————类、接口、变量、方法
private：同一个类内可见，不可以修饰类（外部类），通常使用用变量，方法。
public：对所有类可见，使用于类、变量、方法。
protected：对同一包内的类以及所有子类可见，使用用变量、方法，不可修饰类，外部类。

默认访问修饰符

不使用任何关键字，使用默认访问修饰符声明变量和方法，对同一个包内可见。接口内部变量都隐式的声明为public static final接口中方法默认访问权限public。

所有访问修饰符private

最严格和最高级别访问权限，private方法变量和构造方法只能被所属类访问，并且类的接口不能声明为private。
声明为私有的类型只能通过类中公共的方法为外部类访问。

public class Longger {
    private String format;
    public String getFormat() {
        return this.format;
    }
    public void setFomat(String format) {
        this.format = format;
    }
}

公有访问修饰符 public

public的类、方法、构造方法以及接口可以被所有的类访问。
相互访问的public类分布于不同的包中，需要导入public类所在的包。类具有继承性，所有的公共方法和变量都可以被其子类继承。

public static void main(String[] arguments) {
    //Java程序的main()方法必须设置成共有，否则解释器不可以运行该类
}

受保护的访问权限protected

子类与基类在同一个包中：声明为protected的变量、方法和构造器可以被同一个包中的其他类访问
不在同一个包中：在子类中，子类实例可以访问其基类继承而来的protected方法，而不能访问基类实例的protected方法。
protected可以修饰数据成员，构造方法，方法成员，只可修饰内部类。
子类可以访问protected修饰符声明的方法和变量，这样就可以保护不相关的类使用这些方法和变量。

class AudioPlayer {
    protected boolean openSpeaker(Speaker sp) {
        //detail...
    }
}
class StreamingAndioPlayer extends AudioPlayer {
    protected boolean opeanSpeaker(Speaker sp) {
        // detail...
    }
}

声明为protected则其子类可见

访问控制和继承

父类、子类public一致
父类protected方法子类中声明为protected或者public
父类中private方法，子类不可继承

非访问修饰符

static
final
abstract
synchronizated
volatile

static

静态变量
声明独立于对象的静态变量，无论多少个对象，静态变量只有一分拷贝。静态变量也被称为类变量。局部变量不可以声明为static
静态方法
静态方法不可以使用类的非静态变量，静态方法从参数列表得到数据，然后计算
类变量的方法访问可以使用classname.variablename和classname.methodname的方式访问

public class IntanceCounter {
    private static int numInstance = 0;
    protected static int getCount() {
        return numInstances;
    }
    private static void addInstance() {
        numInstances++;
    }
    InstanceCounter() {
        InstanceCounter.addInstance();
    }
    public static void main(String[] arguments) {
        System.out.println("String[] arguments" + InstanceCounter.getCounter() + "instances");
        for (int i = 0; i < 500; ++i) {
            new InstanceCounter();
        }
        System.out.println("Created "  + InstanceCounter.getCount() + "instance");
    }
}

运行结果

Starting with 0 instances
Created 500 instances

final修饰符

变量一旦被赋值，就不能被重新赋值，被final修饰的实例变量必须显式的指定初始值，final修饰符通常和static修饰符一起使用创建类常量
final方法
父类中的final方法可以被子类继承，但是不能被子类重写，声明final方法的主要目的是为了防止该方法的内容被修改。
final类不可以被继承，没有类可以继承final类的任何特性。

public class Test {
    final int value = 10;
    public static final int BOXWIDTH = 6;
    static final String TITLE = "Manager";
    public void changeValue() {
        value = 12;       //输出一个错误
    }
}

abstract修饰符

抽象类
不可以用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。一个类不能同时被abstract和final修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。

abstract class Caravan {
    private double price;
    public abstract void goFast();
    public abstract void changeColor();
}   // 抽象类可以包含抽象方法

抽象方法
是没有任何实现的方法，方法的具体实现由子类提供。
抽象方法不可以被被声明成final和static。任何继承抽象类的子类必须实现父类所有的抽象方法，除非该类也是抽象类。如果一个类包含若干个抽象方法，那么该类必须声明抽象类。抽象类可以不包含抽象方法。抽象方法的声明可以“ ; ”结尾。

public abstract class SuperClass{
    abstract void m();    //抽象方法
}
class SubClass extends SuperClass{
    // 实现抽象方法
    void m() {
        ..........
    }
}

sychronized 修饰符

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

transient 修饰符

序列化的对象包含被transient修饰的实例变量时，Java虚拟机跳过该特定的变量。该修饰符包含在特定的变量中，用来预处理类和变量的数据结构。

volatile 修饰符

volatile 修饰的成员变量每次被线程访问时，都强制从共享内存中重新读取该成员变量的值，然而，当成员变量发生变化时，会强制将线程将变化值写回到共享内存，这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

public class NyText implements MyText {
    private volatile boolean active;
    public void Run() {
        active = true;
        while (active)   //第一行 
        {
            //`

    }
}
public void stop() {
    active = false; // 第二行
}

} ```

JavaRunoob 2.0