Java关键字

Java一共有53个关键字（其中包含两个保留字const，goto）

整理了几个常用的关键字

1.static

static关键字最基本的用法是
1)被static修饰的变量可以通过<类名.变量名>直接引用，不需要实例化类
2)被static修饰的方法可以通过<类名.变量名>直接引用，不需要实例化类

public class User {
    public static void run(){
        System.out.println("跑步");
    }

    public static void main(String[] args) {
        User.run();//输出：跑步
    }
}

3. 当 static修饰代码块时，静态块里的代码只执行一次

public class User {
    public static void main(String[] args) {
        System.out.println("第一次：");
        Foo foo = new Foo();
        System.out.println("第二次：");
        Foo foo2 = new Foo();
    }
}

class Foo{
    //代码块，在创建对象的时候执行
    {
        System.out.println("这是一个代码块");
    }

    //静态代码块，在类加载期间执行，只运行一次，用于加载配置文件等信息
    static {
        System.out.println("这是一个静态代码块");
    }

    public Foo(){
        System.out.println("调用了构造器");
    }
}

输出结果为

第一次：
这是一个静态代码块
这是一个代码块
调用了构造器
第二次：
这是一个代码块
调用了构造器

顺便讲讲Java对象初始化过程：
第一步，加载类，一个java对象在初始化前会进行类加载，在JVM中生成Class对象。加载一个类会进行如下操作

（如果该类有父类，则先加载其父类）　　
1)初始化该类静态成员
2)执行该类静态代码块

第二步，创建对象
如果该类有父类，先创建父类的对象
1)初始化该类普通成员。　　
2)执行普通代码块
3)调用该类构造方法

2.final

1)被final修饰的类不可以被继承
2)被final修饰的方法不可以被重写
3)被final修饰的变量不可以被改变（这里不可改变的是变量的引用，而不是变量指向的内容）

public class User {
    private String name;

    public User(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static void main(String[] args) {
        final User user = new User("张三");//初始化name
        user.setName("李四");
        System.out.println(user.getName());//输出：“李四”
                                           //说明改变变量指向的内容没问题
    }
}

改变变量的引用时，将无法编译

3.finally

finally是try语句中的一个语句体，用来释放资源，不能单独使用。不管try块内的语句是否发出异常，finally块内的代码总会执行

问：当try、catch、finally带有return语句时，代码和return语句的执行顺序？

3.1 try 中带return

public static int testEx() throws Exception{
        int i = 1;
        try {
            i++;
            System.out.println("try:" + i);
            return i;
        }catch (Exception e){
            i++;
            System.out.println("catch:" + i);
        }finally {
            i++;
            System.out.println("finally:" + i);
        }
        return i;
    }

输出结果为

try:2
finally:3
2

当try中带有return时，会先执行return前的代码，然后暂时保存需要return的信息，再执行finally中的代码，最后再通过return返回之前保存的信息。所以，这里方法返回的值是try中计算后的2，而非finally中计算后的3。
但是，值得注意的是：

public  static List<Integer> testEx(){
        List<Integer> list = new ArrayList<>();
        try{
            list.add(1);
            System.out.println("try:" + list);
            return list;
        }catch (Exception e){
            list.add(2);
            System.out.println("catch:" + list);
        }finally {
            list.add(3);
            System.out.println("finally:" + list);
        }
        return list;
    }

输出结果为

try:[1]
finally:[1, 3]
[1, 3]

为什么上面的try中返回的是try中return语句之前的值，而这段代码的return返回的是finally语句的值呢？
因为上段代码使用的是基本类型；这段代码中使用的是引用类型，list里面存的不是变量的值而是变量的地址，而finally语句通过地址改变了变量的值

3.2 catch中带return

public static int testEx(){
        int i = 1;
        try {
            i++;
            System.out.println("try:" + i);
            int j = i/0;
        }catch (Exception e){
            i++;
            System.out.println("catch:" + i);
            return i;
        }finally {
            i++;
            System.out.println("finally:" + i);
        }
        return i;
    }

输出结果为

try:2
catch:3
finally:4
3

这里return与其在try中的一样，都要先执行return之前的代码，然后暂时保存需要的return信息，最后通过return返回之前保存的信息

3.3 finally中带return

private static int testEx(){
        int i = 1;
        try {
            i++;
            System.out.println("try:" + i);
            return i;
        }catch (Exception e){
            i++;
            System.out.println("catch:" + i);
            return i;
        }finally {
            i++;
            System.out.println("finally:" + i);
            return i;
        }
    }

输出结果为

try:2
finally:3
3

当finally中有return语句时，前面try和catch中的return语句都不会执行。但是不推荐在finally中写return语句，这会破坏程序的完整性，会导致catch中的异常被覆盖
总结：
1)finally中的代码总会被执行
2)当try、catch中有return时，也会执行finally。return的时候，要注意返回值的类型，是否受到finally中代码的影响
3)finally中有return时，会直接在finally中退出，导致try、catch中的return失效。

4. this

4.1 this调用当前属性

当需要给类中的数据进行初始化时，可以通过this来进行赋值，而不用随便定义一个变量来进行赋值，更有利于代码的阅读与理解

public class Person {
    private String name;
    private int age;


    //使用this对Person类数据初始化
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    /*
    * 若不使用this关键字只能这样进行赋值：
    *
    * public Person(String n,int a){
    *      name = n;
    *      age = a;
    * }
    *
    * */

    public static void main(String[] args) {
        Person person = new Person("张三",10);
        System.out.println("姓名：" + person.name);
        System.out.println("年龄：" + person.age);
    }
}

输出结果为

姓名：张三
年龄：10

4.2 this调用方法（普通方法、构造方法）

1) 普通方法

public class Person {
    private String name;
    private int age;


    //使用this对Person类数据初始化
    public Person(String name,int age){
        this.name = name;
        this.age = age;
        this.run();
    }

    public void run(){
        System.out.println("跑步");
    }

    public static void main(String[] args) {
        Person person = new Person("张三",10);
        System.out.println("姓名：" + person.name);
        System.out.println("年龄：" + person.age);
    }
}

输出结果为

跑步
姓名：张三
年龄：10

2) 构造方法
普通方法在创建后可以多次调用；而构造方法创建后只能调用一次

 //无参构造器
    public Person(){
        System.out.println("这是一个人");
    }

    //一参构造器
    public Person(String name){
        this();//这里调用了无参构造器
        this.name = name;
    }

    //二参构造器
    public Person(String name,int age){
        this(name);//这里调用了一参构造器
        this.age = age;
    }

注：对this调用必须放在构造方法中的第一行，否则会出错

5. 4种访问修饰符public、protected、default（无修饰符、默认）、private

访问权限如下