Java修饰符

修饰符
权限修饰符
    public                公共的
    protected          受保护的
    默认不写           默认的
    private              私有的
特征修饰符
    final                  最终的 不可改变的
    static                静态的
    abstract            抽象的
    native               本地的
    *transient         瞬时的 短暂的 ---> 序列化
    *synchronized  同步的 一个时间点只有一个线程访问
            锁定的是调用该方法的对象
    *volatile           不稳定的
==========================================================================
权限修饰符
    public            本类    同包    子类    在工程内任意位置中只要有对象都可以访问
    protected       本类    同包    子类1
    默认不写        本类    同包
    private           本类
        *同包 指的是package路径一致
        *子类1 指的是能在子类范围内通过子类对象调用(若只满足其中一个条件则不可被调用)

权限修饰符可以用来修饰 类本身 和 类中的成员(除了程序块)
权限修饰符只有两个(public 默认不写)可以用来修饰类
    一个类文件内只能有一个public修饰的类
    (记事本时)修饰类时    若为默认不写 则类名可以与java文件名不同
            若为public 则类名必须与java文件名相同 否则编译报错
权限修饰符可以用来修饰类中其他成员
        ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Java类与类之间的关系
    继承 关联 依赖
Java面向对象的三(四)个特征
    继承 封装 多态 (抽象)
    封装：将一些数据或执行过程或算法 进行一个包装
        保护数据或执行过程的安全
        方法本身也算是封装 封装了执行的过程 保护过程的安全 隐藏了执行的细节 增强了复用性
        类也算是封装 封装了方法和属性
        对属性本身的封装：
            属性私有(封装在类中)
            提供能够操作属性的相应的公有方法

==========================================================================
特征修饰符

final 最终的 不可改变的
1. 可以修饰
    修饰变量        若在定义变量时没有赋初始值 给变量一次存值的机会
                因为变量在栈内存中 没有默认值 若不给机会 就无法用了
            一旦final变量被存储了一个值 则不让再次改变 ---> 相当于常量
                若修饰的变量为基本数据类型 则变量内的值不能更改 --- > 常量
                若修饰的变量为引用数据类型 则变量内的地址引用不能更改 ---> 对象唯一

    修饰属性        全局变量 存储在堆内存的对象空间内一个空间
            属性若没有赋值 有默认值存在
                所以属性用final修饰 必须赋初始值 否则编译报错
            特点 与变量一致

    修饰方法        方法是最终的方法 不可更改
                子类继承父类的方法 将父类的方法重写(覆盖)
            final修饰的方法 要求不可以被子类重写(覆盖)

    修饰类本身    public final class Test{}
            此类不可以被其他子类继承
                通常是一些被定义好的工具类(Math Scanner Integer String)

=======================================================
补充：
    //在new类对象前会首先加载对应类模板
=======================================================

static 静态的
1.可以修饰：
    修饰属性
    修饰方法
    ！修饰块！
        +++++++++++++++++++++++++++++++++++++++++++++++++++++++
        package test_static;
        public class Person{
            static{
                System.out.println("我是静态块");  //static块会在加载类模板后被调用
            }
            public static void main(String[] args){
                //只加载一个Person类模板
                try{
                    //类的全名字 通过反射机制加载类
                    Class.forName("test_static.Person");
                }catch(Exception e){

                }
            }
        }
        -----------------------
        我是静态块
        +++++++++++++++++++++++++++++++++++++++++++++++++++++++
    修饰内部类
2.特点：
    1>静态元素在类模板加载时就初始化啦 创建的非常早 此时还没有创建对象
    2>静态元素储存在静态元素区中 每一个类都有自己的一个区域 互相不冲突
    3>静态元素只加载一次(只有一份) 全部类对象及类本身共享
    4>由于静态元素区加载时可能还没有创建对象 可以通过类名字直接访问(Person.age)
    5>可以理解为静态元素是属于类的 而不属于对象
    6>垃圾回收器(GC)(Garbage Collection)无法管理静态元素区 可以粗暴地(呃)认为静态元素区为常驻内存
         堆内存通过GC回收
         栈内存空间从创建开始 用完即回收
    7.非静态成员(堆内存对象里)中可以访问静态成员(静态元素区里)
    8.静态成员中可以访问静态成员(都在静态元素区)
    9.静态成员中不可以访问到非静态成员
        从个数角度 一个出发访问一堆相同名字的东西 说不清
        从面向对象角度 静态元素属于类 非静态成员属于对象
    10.静态元素中不能出现this或super关键字(静态元素属于类)

=======================================================
native 本地的
Java源代码中看到native就已经再也看不到后续代码了
    public native int hashCode();
后续会调用其他的编程语言执行内存的操作
Object类中的一个方法 hashCode()

=======================================================
abstract 抽象的 ---> (没有具体的执行 只是个概念)
1.可以修饰
    修饰方法
        用abstract修饰符修饰的方法 只有方法的结构 没有方法执行体 叫做抽象方法
            public abstract void eat();
        用native修饰的方法虽然也没有方法体 但不是抽象方法 只是执行的过程是其他语言写的 看不见
    修饰类
        用abstract修饰的类 叫做抽象类
2.特点
    普通类不允许含有抽象方法
    抽象类中不是必须含有抽象方法 抽象方法必须放在抽象类或接口中

    属性    可以含有一般属性 也可以含有private static final属性
    方法    可以含有一般方法 也可以含有private static final方法
        抽象类中 允许 含有抽象方法(只有方法结构 没有方法执行体)
    块    可以含有一般程序块 也可以含有static程序块
    构造方法    可以含有构造方法 包括重载

    抽象类含有构造方法 但我们不能通过调用构造方法直接创建对象
    抽象类只能通过子类继承来做事

    抽象类 --- 直接单继承 --- 抽象类 可以
    抽象类 --- 直接单继承 --- 具体类 可以(通常不出现)
    具体类 --- 直接单继承 --- 抽象类 不可以直接继承 需要将父类中的抽象方法具体化

=======================================================
interface ---> 接口(抽象类抽象到极致)(通常是为了定义规则)
还是一个类的结构 但不能用class修饰 改用interface修饰    public interface Test{}

    属性    不能含有一般属性 默认为public static final属性(需要赋初值)(public static final可省)
    方法    不能含有一般方法 只能含有公有的抽象方法(1.8版本后 可以用default修饰具体方法 default void test(){} )
    块    不能含有块(块本身即是具体的)
    构造方法    不能含有构造方法
        不能创建对象
        只能通过子类多实现(implements)来做事
            public class A implements B,C,D{}

    接口 不能继承别的类
    抽象类 --- 直接多实现 --- 接口 可以
    具体类 --- 直接多实现 --- 接口 不可以直接多实现(必须将接口中的抽象方法具体化)
    *接口--- 多继承 ---接口    可以直接多 ?实现?