Java基础相关（三、常见修饰符）

   

学之广在于不倦，不倦在于固志。 ——晋·葛洪­

（学问的渊博在于学习时不知道厌倦，而学习不知厌倦在于有坚定的目标）

001.Java修饰符：

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

       ---> 修饰符分为：

                                  访问修饰符、非访问修饰符

002.Java访问修饰符：

       ---> 访问修饰符也称访问控制符，是指能够控制类、成员变量、方法（也包含构造方法）使用权限的关键字

       ---> 访问修饰符用来限定外界（即调用者）对类、变量、方法的访问范围，主要包含四个访问修饰符

              00a.private  >>> 私有的，同一类可以访问

                                  >>> 修饰对象：变量、方法（可以修饰内部类）

                                                            被private修饰的成员（内部类、变量、方法）只能被其自身（即所属类）访问，对其他类是不可见的

                                   >>> 类（外部类）和接口不可以没声明为private

                                   >>> private主要是隐藏类的实现细节和保护类的数据

                                   >>> 声明为私有访问类型的变量只能通过类中公共的getter方法被外部类访问

               00b.default  >>> 默认访问修饰符（即不使用任何关键字就表示default），同一包内可以访问

                                   >>> 修饰对象：类、接口、变量、方法

                                   >>> default修饰的变量、方法，对同一包内的类可见（类的子类不可见），

                                   >>> 接口里的变量隐式的声明为 public static final，接口里的方法默认是访问权限为 public

               00c.protected  >>> 受保护的，对同一包内的类和所有子类可以访问

                                       >>> 修饰对象：变量、方法（不能修饰外部类和接口）

                                       >>> 子类和基类在同一包内：被protected修饰的变量、方法和构造器可以被同一个包中的任何其他类访问

                                               子类和基类不在同一包内：在子类中，子类实例可以访问其从基类继承而来的protected方法，而不能访问基类实例中的protected方法

                                       >>> 子类能访问protected修饰的方法、变量，这样可以避免不相关类使用这些方法和变量

                00d.public  >>> 公共的，对所有类可见，能够被任何其他类访问

                                   >>> 修饰对象：类、接口、方法、变量

                                   >>> 如果几个相互访问的public类分布在不同的包中，则需要导入相应public类所在的包，由于类的继承性，类的所有公共方法和变量都能被其他子类继承

003.Java非访问修饰符：

        ---> 一种类型限定符，用来限定变量的类型

        ---> 非访问限定符有以下几类：

              00a.static >>> 静态，用来修饰类方法、类变量（内部类推荐使用static，因为非静态内部类对外部类持有强引用）

                              >>> 静态变量：给变量前添加了static限定符

                                                       一般用于开放给外部类直接使用的变量，直接“类名.变量名”即可访问，无需事先实例化类的对象

                                                       static关键字用于表明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份copy，该静态变量在内存中的地址是固定的，类似于全局变量，每一次实例化对象，使用的静态变量仍然是程序初始化的那个静态变量

                                                        静态变量是伴随着类的加载而加载的，当类加载进内存的时候，静态变量就已经伴随着类的加载而加载进内存了，并且静态变量只在类加载的时候加载一次，存放在方法区的静态区中

                                                        全局变量也就是成员变量，是在创建对象的时候初始化的，所以只要创建对象就会初始化全局变量（成员变量），并存放在静态区

                               >>> 静态方法：给方法名前加了static限定符

                                                        一般用于开放给外部类直接使用的方法，直接“类名.变量名”即可访问直接“类名.方法名”即可访问，无需事先实例化类对象

                                                        静态方法中只能调用静态方法，不能调用非静态方法

                                                        静态方法中只能使用静态的类变量，不能使用非静态的类变量

                                                        静态方法中不能使用this、super，即使this后面跟静态类变量也不行

                               >>> 静态类：给类名前加了static限定符

                                                     一般用于开放给外部使用类中的内部类，这样就可以直接“外部类.内部类”访问一般用于开放给外部类直接使用的方法，

                               >>> 静态代码块：给“{}”前加static限定符（即static {}）

                                                            是在类中独立于类成员的static代码块，它不在任何方法体内，它在类加载的时候执行且仅执行一次这些静态代码块

                                                            一般用于在使用JNI接口的地方，需要事先调用System.loadLibrary来加载so动态库，或者在类加载时就需要执行的方法或者需要对成员变量进行无条件初始化时使用

              00b.final  >>> 最终、固定不变的，用来修饰类、方法、变量（常见于变量）

                             >>> final变量：给变量前加final

                                                     final变量一般用于不希望变量值变更的场合，防止变量值修改产生不可预料的结果

                                                     final变量被显式地初始化且只能初始化一次，被final修饰的对象的引用不能指向不同的对象，但是，final修饰的对象里的数据可以修改，也就是说final对象的引用不可改变，但是里面的值可以改变（如，一个point点对象，它的x，y值可以变化）

                                                     final修饰符通常和static一起使用来创建类的常量

                             >>>  final方法：给方法前加final

                                                      类中的final方法可以被子类继承，但是不可修改

                                                       声明为final的方法主要是防止该方法被修改        

                              >>> final类：给类前加final（通常见于系统源码）

                                                  final类不能被继承，不可修改，是一个最终形态

                              >>> 一个特例：匿名内部类的局部变量

                                                       因为匿名内部类在编译的时于方法是平级的，所以不能调用方法的变量，只能调用类的变量；但是一个匿名内部类非要调用方法的变量，就需要声明该方法的变量为final类型，即把改变量当作一个常量来用

              00b.synchronized和volatile  >>> 线程相关的修饰符

                                                            >>>  synchronized 声明的方法同一时间只能被一个线程访问，常见于单例模式

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

 003.总结及注意：

                            java静态对象的数据在全局是唯一的，一处改即全改，在内存空间上是固定的，会优先分别静态对象空间，非静态对象反之；

                            java静态变量初始化无法被阻止，它在被构造器调用之前就已经初始化了，在类的内部变量定义的顺序决定了初始化的顺序，变量定义散布于各个地方，仍然会在任何方法（包括构造方法）调用之前被初始化

                             final变量初始化有三种方式（1.在声明final变量的时候 ；    2.在类的构造函数中 ；     3.在静态代码块中）

                             >>> 访问控制符和继承一些需要注意的地方：

                                     1). 父类中声明为public的方法在子类中也必须声明为public；父类中声明为protected的方法在子类中要么声明为protected要么声明为public，不可为private；父类中默认修饰符声明的方法在子类中可以声明为private；父类中声明为private的方法不可被继承

                                     2). 子类继承父类初始化顺序为    >>> 在实例化子类是时，会首先执行父类的初始化代码块（先静态），实例变量的初始化

                                                                                         >>> 执行父类的构造函数

                                                                                         >>> 子类的初始化代码块

                                                                                         >>> 子类的构造函数

                                     4). 如果类还没有被加载，那么子类通过类名加点的方式调用对象的时候，首先会执行父类的静态代码块和静态变量，顺序就是他们的出现顺序，然后再执行子类静态代码块和静态变量

                                     5).如果类已经被加载过了，那么静态代码块和静态变量就不会再次被执行，再创建对象的时候只会执行与实例相关的变量初始化和构造函数

              Last：欢迎指正、交流

                        参考链接：--- 参考文献直通车 ---

                                          --- 参考文献直通车 ---

                                        《JAVA思想编程第四版》