Java修饰符用来定义类、方法或者变量，通常放在语句的最前端。主要分为两种，访问修饰符和非访问修饰符。
访问修饰符
1.定义
在Java中，访问控制符主要用来保护对类、方法、变量及构造方法的访问。对于访问控制符主要有4中。
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
2.访问权限
| 修饰符 | 当前类 | 同一包内（不同类） | 同一包内（子孙类） | 不同包内的子孙类 | 不同包 |
|---|---|---|---|---|---|
| public | Y | Y | Y | Y | Y |
| protected | Y | Y | Y | 不一定（见注释） | N |
| default | Y | Y | Y | N | N |
| private | Y | N | N | N | N |
注释：子类与父类不在同一包中且修饰符为protected时，那么在子类中，子类实例可以访问其从父类继承而来的 protected 方法，而不能访问父类实例的protected方法。
3.包和类的简单理解
上面的访问权限中提到了类和包，为了更好地理解Java修饰符先简单介绍一下包和类的概念。
包（package）：package是一个为了方便管理组织java文件的目录结构，并防止不同java文件之间发生命名冲突而存在的一个java特性。不同package中的类的名字可以相同，只是在使用时要带上package的名称加以区分。
类：类的详细介绍可以看这篇博客，Java中的类与对象。
将一个类的定义放在另一个类的定义内部，里面的类就是内部类，外部的类就是外部类。
public class Person { //外部类
private int blood;
public class Heart {
public void test() {
System.out.println(blood);
}
}
public class Brain { //内部类
public void test() {
System.out.println(blood);
}
}
}
子类与父类：如果一个类继承了另一个类，被继承的是父类，另一个类为子类。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为，继承的关键字为extends。（主要可以避免代码冗余）
public class Animal { //父类
private String name;
private int id;
public Animal(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
}
public class Mouse extends Animal { //子类
public Mouse(String myName, int myid) {
super(myName, myid);
}
}
4.访问控制修饰符和继承的规则
- 父类中声明为 public 的方法在子类中也必须为 public。
- 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
- 父类中声明为 private 的方法，不能够被继承。
非访问修饰符
Java的非访问修饰符主要有以下几种。
- static 修饰符，用来修饰类方法和类变量。
- final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
- abstract 修饰符，用来创建抽象类和抽象方法。
- synchronized 和 volatile 修饰符，主要用于线程的编程。
1.static 修饰符
static修饰符主要用来修饰类方法和类变量
- 类变量（静态变量）：static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
- 类方法（静态方法）：static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。
可能看了上面的定义还是不明白为什么需要使用静态变量和静态方法，静态变量和成员变量的区别可以看这篇文章，Java中的类与对象。下面讲一下为什么要使用静态变量和静态方法。
一个Java类中主要包括静态变量、成员变量、静态方法、成员方法、构造方法。其中构造方法用于初始化对象，而成员方法和成员变量是依托于对象的，只有建立了对象才可以调用成员方法和成员变量。而静态方法和静态变量并不需要建立对象就可以被调用，当然对象也调用静态变量和静态方法，举例如下。
class Animal{
int age = 1; //成员变量
static String name = "小黑"; //静态变量
public Animal(){ //构造方法
System.out.println("名字0 : " + name );
}
public static void test1(){
System.out.println("名字1 : " + name ); //静态方法只能调用静态变量
}
public void test2(){
System.out.println("名字2 : " + name ); //成员方法既可以调用静态变量也可以调用非静态变量
System.out.println("年龄2 : " + age );
}
public static void main(String[] arg){
System.out.println("名字：" + name); //不用创建对象直接调用静态变量
Animal.test1(); //不用创建对象直接调用静态方法
// System.out.println("年龄：" + age); //不创建对象直接调用成员变量会报错！
// Animal.test2(); //不创建对象直接调用成员方法会报错！
Animal Dog = new Animal(); //创建对象
Dog.test1(); //利用对象调用静态方法
Dog.test2(); //利用对象调用成员方法
System.out.println("年龄：" + Dog.age);//利用对象调用成员变量
System.out.println("名字：" + Dog.name);//利用对象调用成员变量
}
}
输出结果：
名字：小黑
名字1 : 小黑
名字0 : 小黑
名字1 : 小黑
名字2 : 小黑
年龄2 : 1
年龄：1
名字：小黑
从输出结果名字或年龄的序号来分辨调用的哪个方法。
2.final修饰符
final修饰符可以用来修饰变量/方法/类。
- final修饰变量，final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。final 修饰符通常和 static 修饰符一起使用来创建类常量。
- final修饰方法，父类中的 final 方法可以被子类继承，但是不能被子类重写。声明 final 方法的主要目的是防止该方法的内容被修改。
- final修饰类，final 类不能被继承，没有类能够继承 final 类的任何特性。
public class Test{
final int value = 1;
public void changeValue(){
value = 2; //这里会报错，因为修改了final修饰的变量
}
}
3.abstract 修饰符
abstract修饰符用来创建抽象类和抽象方法。
抽象类
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。抽象类可以包含抽象方法和非抽象方法。
abstract class Caravan{ //抽象类
private double price;
private String model;
private String year;
public abstract void goFast(); //抽象方法
public abstract void changeColor();
}
抽象方法
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法不能被声明成 final 和 static。任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
public abstract class SuperClass{
abstract void m(); //抽象方法
}
class SubClass extends SuperClass{
//实现抽象方法
void m(){
.........
}
}
4.synchronized 修饰符
synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
5.transient 修饰符
序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。
6.volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
