Java基础-第四章:关键字

上章说到封装、继承、多态
从代码中可以看到public、class、void、extends 这几个关键词，接下来讲解下java中的关键词，这些词不能用于常量、变量、类等任何标识符名称

访问控制关键字

private # 私有的
protected # 受保护的
public # 公开的
default # 默认的

private 私有的

Java语言中对访问权限限制最大的修饰符、通称为'私有的'，被其声明的类、属性、方法只能被该类的对象访问,其子类不能访问，而其它的类,包是完全无法访问的

public 公开的

Java语言中对访问权限限制最小的修饰符、通称为'公开的'或'公共的'，被其修饰的类、属性、方法不仅可以在其它类访问，甚至可以在其它包中访问

protect 受保护的

Java语言中基于public 与 private之间的一种访问修饰符,通称为'受保护的'，被其修饰的类、属性、方法只能在本类同级类或下级的子类中访问,上级类是无法访问的

default 默认的

Java语言中不加任何修饰符时的情况就称之为'默认访问模式'，在这个模式下，只允许同包的类访问

类、方法和变量修饰符

abstract # 抽象声明
extends #
class # 类
final # 常量、最终值
implements # 接口引用
interface # 接口
native # 本地、原生方法
new # 创建
static # 静态
strictfp # 严格、精准
synchronized # 线程同步
transient # 短暂
volatile # 不保留的

abstract 抽象声明与 interface 接口

面试重点,建议背下

使用abstract 关键词创建的类是一个可以编写声明并不需要实现的方法以及可以实现对应方法的类例如

public abstract class Test {
    public String sayHello() {
        return "hello";
    }
    abstract String ku();
}

class B extends Test {
    public static void main(String[] args) {
        Test t = new Test() {
            @Override
            public String sayHello() {
                return "miajio " + super.sayHello();
            }
            @Override
            String ku() {
                return null;
            }
        };
        System.out.println(t.sayHello());;
    }

    @Override
    String ku() {
        return null;
    }
}

如此输出的值则是: miajio hello
使用abstract修饰的类无法直接使用new来创建，而是必须实现其内部的方法才行,而使用abstract修饰的方法则是可以不给出相对应的实现，而是在使用该类时必须将其重写。
同理，在继承该Test时，必须实现其内部abstract关键词修饰的方法

接下来看interface关键词

public interface Test {
    String ku();
}

class B implements Test {

    @Override
    public String ku() {
        return "ku";
    }

    public static void main(String[] args) {
        B b = new B();
        System.out.println(b.ku());
    }
}

使用interface关键词时，不允许存在方法的实现，仅只是对方法进行声明，而在引用interface关键词时，我们使用到的时implements 而不是extends,但是与abstract类似的是在引用时必须实现其内置方法。
在java中与go等不同的是java只有单一继承，即使用extends时只能引用一个类，而在使用implements引用接口时，可以同时引用很多个interface接口

final 常量、不可变的

final关键字可以使用在类、方法、属性上
在使用在类时，例如String

public final class String 
        implements java.io.Serializable, Comparable<String>, CharSequence{}

在String的源码中，我们就可以看到使用了final关键字标识了class，在标识在class上时，可以使类无法被其他类继承
而通常我们代码中有很多的参数是不可以被改变的，例如一些返回的错误编号等，这时我们使用final引用到属性参数上

public final int code = 200;

这样，这个code在其他类使用时就无法被改变其值了
同样，final在使用在方法上时该方法就无法被重载以及重写了

static 静态的

static关键字也是我们编写代码时常用到的关键字之一，它有一个特点，就是使用static关键字修饰的方法，在使用时，可以无需new 它的对象，而是通过对象名.方法即可直接使用。
而static又有一种用途，即是在使用对象时进行数值的初始化操作，例如:

public class Test {
    static {
        System.out.println("hello");
    }
    public String sayGood(){
        return "good";
    }
    public static void main(String[] args) {
        Test t = new Test();
        System.out.println(t.sayGood());
    }
}

以上的代码最终的结果是先打印了: hello 然后才打印good
也就是说在创建该类时，会默认优先执行static{} 方法
通常我们使用final时，为了方便获取final标识的常量，我们会对其常量使用static关键词进行修饰，这样就可以让我们在使用该常量时无需去创建该常量所在的对象了

其它的修饰符我就不多解释了，实际上修饰符在百度上有很多的讲解说明

我只是将比较常用的修饰符进行了说明，但是synchronized关键词也是需要多实践的，因为其线程同步性是一个对性能等操作需要注意的事情

如有疑问可直接参考菜鸟教程|Java基础语法翻到下面即可找到对应的关键词

程序控制关键字

break # 跳出循环体
switch case default # 条件逻辑比较
if、else if、else # 条件逻辑比较
continue # 继续
do # 运行
for # 循环
while # 循环
instanceof # 双目运算符
assert # 断言 对某boolean类型值进行断言指定其布尔类型是否为真

错误处理

try catch # 异常捕获
finally # 不管是否存在异常，在其之后都执行其finally
throw # 抛出异常
throws # 声明一个异常可能被抛出

包

import 引入
package 包

八个基本类型全部都是关键字

变量引用

super # 值父类
this # 当前对象
void # 无返回参数
null # 空对象

java中保留的关键字

goto 
const

Java基础-第四章:关键字