一、关键词this的使用

1.this:就是指当前对象

• 当前对象就是当前调用它的对象

class Car {
    private String name;
    public Car(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
}
public class KeyWords {
    public static void main(String[] args) {
        Car c1 = new Car("奥迪A8");
        Car c2 = new Car("领克03");
        Car c3 = new Car("哈弗H6");
        System.out.println(c1.getName());   //c1调用getName方法时，此时this表示c1
        System.out.println(c2.getName());   //c2调用getName方法时，此时this表示c2
        System.out.println(c3.getName());   //c3调用getName方法时，此时this表示c3
    }
}

• c1调用getName方法时，this指向c1这个对象
• c2调用getName方法时，this指向c2这个对象

2.this的作用

• 直接引用，类似于当前对象的指针
• 形参与成员属性相同时，用于区分成员变量和形参
• 引用构造函数

/**
 * 响应类
 */
class Response {
    /**
     * 响应状态码
     */
    private int code;
    /**
     * 响应提示信息
     */
    private String message;
    /**
     * 响应数据
     */
    private Object data;
    public Response() {
    }
    public Response(int code) {
        /**
         * 1.此时的this指代当前对象
         * 2.因为传入的参数code与当前的成员变量相同，因此使用this.code来代表当前的对象的成员变量,code表示传入的参数
         */
        this.code = code;
    }
    public Response(int code, String message) {
        /*this.code = code;
        this.message = message;*/
        /**
         * 3.使用this(code)调用构造方法Response(int code)
         */
        this(code);
        this.message = message;
    }
    public Response(int code, String message, Object o) {
        /*this.code = code;
        this.message = message;
        this.data = o;*/
        /**
         * 3.使用this(code, message)调用构造方法Response(int code, String message)
         */
        this(code, message);
        this.data = o;
    }
    public void output() {
        System.out.println("父类输出：code = "+this.code +"; message = "+this.message);
    }
}

3.this使用的注意点

• 在构造方法中调用this构造方法必须把this构造方法放在第一行
• 构造方法中调用this构造方法，不要陷入死循环中，即在A构造方法中调用this调用构造方法B，又在构造方法B中使用this调用构造方法A

二、关键词super的使用

1.super:指代当前的父类(超类)对象

class JsonResponse extends Response {
    public JsonResponse(int code, String message) {
        super(code, message);
    }
    public void output() {
        super.output();
        System.out.println("子类输出");
    }
}
public class KeyWords {
    public static void main(String[] args) {
       JsonResponse r = new JsonResponse(100, "hello");
       r.output();   //输出：
       /**
       父类输出：code = 100; message = hello
       子类输出
       */
    }
}

• 通过super可以调用父类方法(前提是有权限)
• 通过super可以调用父类成员(前提是有权限)

2.super的作用

super的作用与this非常相似，只不过super是指父类(超类方法)

• 直接引用，调用父类变量(protected及以上权限的变量)
• 引用父类方法
• 引用父类构造函数

三、关键词static的使用

1.static:表示静态，一般是不可变的变量或方法

2.static的用法

(1)静态变量：类变量，通过类来调用

• 静态方法和成员方法都可以调用

protected static int SUCCESS_CODE = 200;

(2)静态方法

• 静态方法只能访问静态变量，不能访问成员变量和成员方法

public static Result success() {
    return new Result(SUCCESS_CODE, SUCCESS_MSG);
}

(3)静态代码块

• 在类被实例化后就会被执行(或给静态的List添加值)

private static List<Integer> errorCode = new ArrayList<Integer>(5);
static {
    errorCode.add(500);
    errorCode.add(502);
    errorCode.add(503);
}

(4)静态导入

• 导入包时，通过静态导入，可以直接使用静态方法，不需要加包名

import static java.util.Collections.max;

在使用时直接使用max方法即可

/*Collections.max(errorCode);*/
System.out.println(max(errorCode));

(5)静态类

• 静态类一般在内部类中使用，它只使用访问外部类的静态成员

static class Demo {
}

import java.util.ArrayList;
/**
 * 4.静态导入
 */
import static java.util.Collections.max;
import java.util.List;
class Result {
    private static List<Integer> errorCode = new ArrayList<Integer>(5);
    /**
     * 3.静态代码块
     */
    static {
        errorCode.add(500);
        errorCode.add(502);
        errorCode.add(503);
    }
    /**
     * 成员变量
     */
    private int code;
    private String message;
    protected String tip;
    /**
     * 1.静态变量
     */
    protected static int SUCCESS_CODE = 200;
    protected static int ERROR_CODE = 500;
    protected static String SUCCESS_MSG = "success";
    protected static String ERROR_MSG = "failed";
    public Result(int code) {
        this.code = code;
    }
    public Result(int code, String message) {
        this(code);
        this.message = message;
    }
    /**
     * 2.静态方法
     * @return
     */
    public static Result success() {
        return new Result(SUCCESS_CODE, SUCCESS_MSG);
    }
    public static Result success(String message) {
        return new Result(SUCCESS_CODE, message);
    }
    public void maxErrorCode() {
        /*Collections.max(errorCode);*/
        /**
         * 4.静态导入使用
         */
        System.out.println(max(errorCode));
    }
    /**
     * 静态类
     */
    static class Error {
        public static int getCode() {
            return errorCode.get(0);
        }
        //无法访问非静态变量
        /*public String getMessage() {
            return message;
        }*/
    }
}

四、关键词final的使用

1.final:表示最终的，不可变的

2.作用

• 修饰类class：表示这个类是一个最终类，无法再继承它，它就是一个终结者
• 修饰变量:表示它是一个常量，常常与static一起修饰一个类常量
• 修改方法：表示它是一个最终的方法，不会被覆盖

/**
 * 1.最终类：类终结者，无法被继承
 */
final class FinalDemo {
    /**
     * 2.最终变量：不能修改其值
     */
    public final int CODE = 100;
    /**
     * 与static结合，表示一个类常量
     */
    public final static String MESSAGE = "SUCCESS";
    /**
     * 3.最终方法，不能被覆盖
     */
    public final int getCode() {
        return CODE;
    }
}

五、关键词default的使用

1.default:默认方法，官方叫虚拟扩展方法(jdk1.8添加的，用于扩展接口)

2.default的作用：

• 扩展接口，以前接口只能有抽象方法,使用default后接口也可以拥有带有方法体的方法了(default修饰的方法必须带方法体)

interface Writer {
    public int write(String content);
    /**
     * 默认接品不能有方法体
     */
    /*public byte[] getBytes(String content) {
        return content.getBytes();
    }*/
    public default byte[] getBytes(String content) {
        return content.getBytes();
    }
}