Java常用修饰符

1、访问修饰符

（1）private
使用对象：变量、方法。注意：不能修饰类（外部类）

私有访问修饰符是最严格的访问级别，所以被声明为 private的方法、变量和构造方法只能被所属类访问，并且类（外部类）和接口不能声明为 private。
(注意：一般的类是不能用private修饰，类的可见性最少是包可见的，也就是默认的，不加任何修饰。但是有一种特殊的情况请你一定要记住，内部类是可以用private修饰的！不让类以外的其他类访问！)
声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。
构造方法可以用private修饰，常用在单例模式中

（2）public
使用对象：类、接口、变量、方法

被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。
Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。

package 的作用就是 c++ 的 namespace 的作用，防止名字相同的类产生冲突。Java 编译器在编译时，直接根据 package 指定的信息直接将生成的 class 文件生成到对应目录下。如 package aaa.bbb.ccc 编译器就将该 .java 文件下的各个类生成到 ./aaa/bbb/ccc/ 这个目录。
import 是为了简化使用 package 之后的实例化的代码。假设 ./aaa/bbb/ccc/ 下的 A 类，假如没有 import，实例化A类为：new aaa.bbb.ccc.A()，使用 import aaa.bbb.ccc.A 后，就可以直接使用 new A() 了，也就是编译器匹配并扩展了 aaa.bbb.ccc. 这串字符串。

（3）protected
使用对象：变量、方法。注意：不能修饰类（外部类）

被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问，也能够被不同包中的子类访问。
protected 访问修饰符不能修饰类（外部类）和接口，方法和成员变量能够声明为 protected，但是接口的成员变量和成员方法不能声明为 protected。
子类能访问 protected 修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。

（4）默认访问修饰符-不使用任何关键字
使用对象：类、接口、变量、方法

使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。

访问修饰符权限

注意：访问控制和继承

请注意以下方法继承的规则：

父类中声明为 public 的方法在子类中也必须为 public。
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
父类中声明为 private 的方法，不能够被继承。

首先，子类继承父类的访问修饰符要比父类的更大，也就是更加开放，假如我父类是protected修饰的，其子类只能是protected或者public，绝对不能是friendly(默认的访问范围)或者private，当然使用private就不是继承了。其次，还要注意的是，继承当中子类抛出的异常必须是父类抛出的异常的子异常，或者子类抛出的异常要比父类抛出的异常要少。

2、非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。

static 修饰符，用来修饰类方法和类变量。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来创建抽象类和抽象方法。
synchronized 和 volatile 修饰符，主要用于线程的编程。

（1）static

静态变量：
static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法：
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

注意：static修饰符可以用来修饰内部类

Java里面static一般用来修饰成员变量或函数。但有一种特殊用法是用static修饰内部类，普通类是不允许声明为静态的，只有内部类才可以。被static修饰的内部类可以直接作为一个普通类来使用，而不需实例一个外部类（见如下代码）

public class Test {
    public static class InnerClass {
        public InnerClass() {
            System.out.println("============= 我是一个内部类'InnerClass' =============");
        }
    }
}

public class TestStatic {
    public static void main(String[] args) {
        // 不需要new一个Test
        new Test.InnerClass();
    }
}

如果没有用static修饰InterClass，则只能按如下方式调用：

public class Test {
    public class InnerClass {
        public InnerClass() {
            System.out.println("============= 我是一个内部类'InnerClass' =============");
        }
    }
}

public class TestStatic {
    public static void main(String[] args) {
        // 需要先new一个Test
        Test t= new Test();
        t.new InnerClass();
    }

JAVA中八种基本数据类型的默认值.png