Java-8 this、final、static关键字

this

/**
     *  this: 
     *          代表一个引用对象，
     *          代表当前调用方法的对象，
     *          代表对象自身。
     *  
     *  使用情况：
     *      1.当方法中的变量与成员变量重名
     *      2.在一个构造器中，调用其它重载的构造器
     *          this():必须放在第一行
     *      3.返回当前对象的引用
     */

//成员变量
String name;
String sex;

//构造函数
public ThisKey()
{
    //初始化代码...
}
public ThisKey(String name)
{
    //2.在一个构造器中，调用其它重载的构造器，必须放在第一行
    this();

    //1.当方法中的变量与成员变量重名
    this.name = name;
    System.out.println(this);//com.neuedu.chapter06.this关键字.ThisKey@33a17727
}
public ThisKey(String name,String sex)
{
    //2.在一个构造器中，调用其它重载的构造器，必须放在第一行
    this(name);

    //this.name = name;
    this.sex = sex;
}

//方法
public void method(String sex)
{
    //1.当方法中的变量与成员变量重名:this代表调用当前方法的对象
    this.sex = sex;
}

//3.返回当前对象的引用
public ThisKey getInstance()
{
    return this;
}

使用：

    ThisKey key = new ThisKey("张三");
    System.out.println("main:" + key.toString());
    //com.neuedu.chapter06.this关键字.ThisKey@41649a55

    key.method("男");

    ThisKey keyClone = key.getInstance();
    System.out.println("keyClone:" + keyClone);

---

final

    /**
     *  final关键字：
     *      1. 修饰类：代表类不能被继承
     *  
     *      2. 修饰变量（属性、局部变量）：表示常量，值不能被修改
     *          ① 常量必须被赋初始值 
     *          ② 可以在声明的同时赋值，也可以在构造器中赋值。
     *          ③ 常量所有字母全大写，且多个单词之间"_"下划线隔开
     *          
     *      3.修饰方法：表示方法不能被子类覆盖，即不能被修改
     */

//2.修饰变量：声明的同时赋值
final double PI = 3.131415926;

final String USER_NAME;


public FinalKey()
{
    //2.修饰变量：在构造器中赋值
    USER_NAME = "SCOTT";
}

//3.修饰方法：表示方法不能被子类覆盖，即不能被修改
public final void getPi()
{
    System.out.println(PI);
}

---

static

/**
 *  static关键字:  
 *      
 *      注意： 不能修饰局部变量，只允许修饰类成员（属性、方法、嵌套类）
 *      
 *      1. 修饰属性（静态变量、类变量）：所有对象共享，在类加载时即存在内存当中，只要类存在，静态变量就存在
 *              
 *              访问方式：
                类名.静态变量名【推荐】
                    StaticKey.key
                对象名.静态变量名
                    StaticKey key = new StaticKey();
                    System.out.println(key.pi);
 *      
 *      2. 修饰方法（静态方法、类方法）：
 *              
 *            访问方式：不需要实例化
 *              类名.静态方法名()【推荐】
                    StaticKey.getPi();
                对象名.静态方法名
                    StaticKey key = new StaticKey();
                    System.out.println(key.getPi());

              注意：
              ① 静态方法里只能直接访问静态成员，而不能直接访问类中的非静态成员---因为非静态属于对象级别属性，需要new对象才能使用
              ② 静态方法中不能使用this、super关键字---this等代表new出来的引用对象，对象没new之前不能使用this
              ③ 静态方法不能被非静态方法覆盖
              ④ 静态方法不能修饰构造器


 *     3. 修饰代码块（静态代码块）：在类加载时，即被执行，且仅执行一次，一般用来写初始化语句
 *          
 *  
 *  
 *     执行顺序： 类加载  -> 执行静态代码块 -> 创建对象之前 -> 执行自由代码块 ->对象创建成功
 *     
 */

/**
     * 1. 静态变量
     */
    static double pi= 3.1415926;//类级别，只要类被虚拟机加载，就立马存在内存中
    String name;                //非静态成员变量：对象级别，需要new出来才会存在内存中

/**
 * 2.静态方法
 * @param args
 */
public static double getPi()
{
    //System.out.println(name);//1. 静态方法不允许访问非静态成员，因为name属于对象级别属性，需要new对象才能使用
    //this.name = "";          //2. 静态方法中不能使用this、super关键字，this等代表new出来的引用对象，对象没new之前不能使用this

    return pi;
}

/**
 * 3.静态代码块
 */
static{
    System.out.println("初始化工作(静态代码块)....");
}

/**
 * 自由代码块:new 对象，调用构造函数之前，执行，且只执行一次
 */
{
    System.out.println("初始化工作(自由代码块).....");
}

/**
 * 构造函数
 */
public StaticKey()
{
    System.out.println("new StaticKey() 构造函数实例化对象");
}


    /**
     * 静态变量
     */
    //对象名.静态变量名
    StaticKey key = new StaticKey();
    System.out.println(key.pi);//3.1415926

    //第一个对象对静态变量做修改，下次其他对象访问该变量时， 变量值为当前修改后的值
    key.pi = 3.14;

    //对象名.静态变量名
    StaticKey key2 = new StaticKey();
    System.out.println(key2.pi);//3.14


    //类名.静态变量名
    System.out.println(StaticKey.pi);//3.14
    /**
    * 静态方法
     */
    /*//对象名.静态方法名()
    System.out.println(key.getPi());//3.14

    //类名.静态方法名()
    System.out.println(StaticKey.getPi());//3.14

    //调用子类"重写"的方法getPi()，其实为自己定义的新方法
    System.out.println(SubStaticKey.getPi());//123459.14

    StaticKey staticKey = new SubStaticKey();
    System.out.println(staticKey.getPi());//访问的父类方法，并非子类同结构方法  3.14*/

---