Java 53个关键字整理（自用版）

 java关键字 总共51个关键字＋2个保留字

1. java关键字的使用

        定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
        特点：关键字中所字母都为小写！！ 

具体哪些关键字：

1.1用于定义数据类型的关键字

详细说明：
1. 整型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
                ① byte范围：-128 ~ 127
                ② 声明long型变量，必须以"l"或"L"结尾
                ③ 通常，定义整型变量时，使用int型。
                ④整型的常量，默认类型是：int型
2. 浮点型：float(4字节) \ double(8字节)
                ① 浮点型，表示带小数点的数值
                ② float表示数值的范围比long还大
                ③ 定义float类型变量时，变量要以"f"或"F"结尾
                ④ 通常，定义浮点型变量时，使用double型。
                ⑤ 浮点型的常量，默认类型为：double
3. 字符型：char (1字符=2字节)
                ① 定义char型变量，通常使用一对'',内部只能写一个字符
                ② 表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
4.布尔型：boolean (4字节)
                ① 只能取两个值之一：true 、 false
                ② 常常在条件判断、循环结构中使用

5.类：class
                public class A( ){ }  
                花括号里有已实现方法体，类名需要与文件名相同

6.接口：interface
                 6.1 接口使用interface来定义
                 6.2 Java中，接口和类是并列的两个结构
                 6.3 如何定义接口：定义接口中的成员
                 6.3.1 JDK7及以前：只能定义全局常量和抽象方法
                     >全局常量：public static final的.但是书写时，可以省略不写
                     >抽象方法：public abstract的
                 6.3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（略)
                 6.4 接口中不能定义构造器的！意味着接口不可以实例化
                 6.5 Java开发中，接口通过让类去实现(implements)的方式来使用.
                       如果实现类覆盖了接口中的所抽象方法，则此实现类就可以实例化
                       如果实现类没覆盖接口中所的抽象方法，则此实现类仍为一个抽象类
                 6.6 Java类可以实现多个接口   --->弥补了Java单继承性的局限性
                       格式：class AA extends BB implements CC,DD,EE
                 6.7 接口与接口之间可以继承，而且可以多继承
                 6.8 接口的具体使用，体现多态性
                 6.9 接口，实际上可以看做是一种规范

1.2用于定义流程控制的关键字

1. if-else条件判断结构
1.1
结构一：
if(条件表达式){
    执行表达式
}

结构二：二选一
if(条件表达式){
    执行表达式1
}else{
    执行表达式2
}

结构三：n选一
if(条件表达式){
    执行表达式1
}else if(条件表达式){
    执行表达式2
}else if(条件表达式){
    执行表达式3
}
...
else{
    执行表达式n
}

1.2 说明：

• 1. else 结构是可选的。
• 2. 针对于条件表达式：
•    > 如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓。
•    > 如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
•    > 如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
• 3. if-else结构是可以相互嵌套的。
• 4. 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。

2.switch-case选择结构
switch(表达式){
case 常量1:
    执行语句1;
    //break;
case 常量2:
    执行语句2;
    //break;
...
default:
    执行语句n;
    //break;
}

2.2 说明：

• 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。
• break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构
• switch结构中的表达式，只能是如下的6种数据类型之一：
  • byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)
• case 之后只能声明常量。不能声明范围。
• break关键字是可选的。
• default:相当于if-else结构中的else.  
  • default结构是可选的，而且位置是灵活的。
• 如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。
• break在switch-case中是可选的

3.三种循环结构：
3.1 for循环结构
for(①;②;④){
    ③
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
3.2 while循环结构
①
while(②){
    ③;
    ④;
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②

说明：
写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！

for和while循环总结：
        1. 开发中，基本上我们都会从for、while中进行选择，实现循环结构。
        2. for循环和while循环是可以相互转换的！ 
         区别：for循环和while循环的初始化条件部分的作用范围不同。
        3. 我们写程序，要避免出现死循环。

3.3 do-while循环结构
①
do{
    ③;
    ④;
}while(②);
执行过程：① - ③ - ④ - ② - ③ - ④ - ... - ②

说明：
1.do-while循环至少会执行一次循环体！
2.开发中，使用for和while更多一些。较少使用do-while

4.break和continue关键字：

	使用范围	循环中使用的作用(不同点)	相同点
break	switch-case 循环结构中	结束当前循环	关键字后面不能声明执行语句
continue	循环结构中	结束当次循环	关键字后面不能声明执行语句

5.return关键字：

• 使用范围：使用在方法体中
• 作用：① 结束方法
•            ② 针对于返回值类型的方法，使用"return 数据"方法返回所要的数据。
• 注意点：return关键字后面不可以声明执行语句。

1.3用于定义访问权限修饰符的关键字

Java规定的四种权限修饰符

• 权限从小到大顺序为：private <  缺省 < protected < public
• 具体的修饰范围：

• 权限修饰符可用来修饰的结构说明：
• 4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
• 修饰类的话，只能使用：缺省、public

1.4用于定义类、函数、变量修饰符的关键字

abstract: 抽象的
1.可以用来修饰：

                类、方法
2.具体的：
abstract修饰类：抽象类
        > 此类不能实例化
        > 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
        > 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作 --->抽象的使用前提：继承性

abstract修饰方法：抽象方法
           > 抽象方法只方法的声明，没方法体
           > 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
           > 若子类重写了父类中的所的抽象方法后，此子类方可实例化
              若子类没重写父类中的所的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

注意点：

•  abstract不能用来修饰：属性、构造器等结构
•  abstract不能用来修饰私方法、静态方法、final的方法、final的类

static:静态的
1.可以用来修饰的结构：主要用来修饰类的内部结构
属性、方法、代码块、内部类
2.static修饰属性：

静态变量（或类变量）
        2.1 属性，是否使用static修饰，又分为：静态属性  vs 非静态属性(实例变量)
              实例变量：我们创建了类的多个对象，每个对象都独立的拥一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
             静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
        2.2 static修饰属性的其他说明：
             ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
             ② 静态变量的加载要早于对象的创建。
             ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。          
             ④             类变量      实例变量
                   类          yes          no
                   对象      yes          yes          
        2.3 静态属性举例：System.out; Math.PI;

3.static修饰方法：

静态方法、类方法
① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
②                      静态方法     非静态方法
                 类            yes          no
                 对象        yes          yes
③ 静态方法中，只能调用静态的方法或属性
  非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

注意点：

• 在静态的方法内，不能使用this关键字、super关键字
• 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。

final：最终的
1.可以用来修饰：

                类、方法、变量

2.具体的：

        2.1 final 用来修饰一个类:此类不能被其他类所继承。
              比如：String类、System类、StringBuffer类 
        2.2 final 用来修饰方法：表明此方法不可以被重写
              比如：Object类中getClass();
        2.3 final 用来修饰变量：此时的"变量"就称为是一个常量
              1. final修饰属性：可以考虑赋值的位置：显式初始化、代码块中初始化、构造器中初始化
              2. final修饰局部变量：
             尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。       

static final 用来修饰属性：全局常量

synchronized：线程同步

synchronized(同步监视器){
       //需要被同步的代码
    }

说明：

        1.操作共享数据的代码，即为需要被同步的代码。  -->不能包含代码多了，也不能包含代码少了。
        2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
        3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
            要求：多个线程必须要共用同一把锁。
  
 补充：

• 在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
• 在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。

1.5 用于定义类与类之间关系的关键字

关键字	意思	备注，常用
implements	实现	用于类或接口实现接口public class A  interface B(){}
extends	继承	用于类继承类 public class A extends D(){}

1.6 用于定义建立实例及引用实例，判断实例的关键字

new:创建新对象

A a=new A();  A表示一个类

this:可理解为 --> 当前类

1.可以调用的结构：

                属性、方法；构造器
2.this调用属性、方法：
this理解为：当前对象  或 当前正在创建的对象

        2.1  在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，
      通常情况下，我们都择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。 
        2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

3.this调用构造器：
        ① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
        ② 构造器中不能通过"this(形参列表)"方式调用自己
        ③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"
        ④ 规定："this(形参列表)"必须声明在当前构造器的首行
        ⑤ 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器

super：可以理解为 --> 父类的
1.可以用来调用的结构：
                属性、方法、构造器
2.super调用属性、方法：
        2.1 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
        2.2 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
        2.3 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。

3.super调用构造器：
        3.1  我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
        3.2 "super(形参列表)"的使用，必须声明在子类构造器的首行！
        3.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二一，不能同时出现
        3.4 在构造器的首行，没显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()
        3.5 在类的多个构造器中，至少一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器

instanceof:实例

        一个二元操作符，和==，>，<是同一类的。测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。

1.7 用于异常处理的关键字

try-catch-finally：

1 使用说明：
try{
            //可能出现异常的代码
   }catch(异常类型1 变量名1){
           //处理异常的方式1
   }catch(异常类型2 变量名2){
           //处理异常的方式2
   }catch(异常类型3 变量名3){
           //处理异常的方式3
   }
   ....
   finally{
           //一定会执行的代码
   }
   

说明：
        1. finally是可选的。
        2. 使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配。
        3. 一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的try-catch结构（在没写finally的情况。继续执行其后的代码。
        4. catch中的异常类型如果没子父类关系，则谁声明在上，谁声明在下无所谓。
            catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则，报错。
        5. 常用的异常对象处理的方式： ① String  getMessage()    ② printStackTrace()
        6. 在try结构中声明的变量，再出了try结构以后，就不能再被调用。
        7. try-catch-finally结构可以嵌套。

throw：抛出一个异常对象

        一些可以导致程序出问题的因素,比如书写错误,逻辑错误或者是api的应用错误等等. 为了防止程序的崩溃就要预先检测这些因素,所以java 使用了异常这个机制。

        在java中异常是靠 "抛出" 也就是英语的"throw" 来使用的,意思是如果发现到什么异常的时候就把错误信息 "抛出"。

throws:声明一个异常可能被抛出

把异常交给他的上级管理，自己不进行异常处理。

1.8 用于包的关键字

package：

使用说明：

• 为了更好的实现项目中类的管理，提供包的概念
• 使用package声明类或接口所属的包，声明在源文件的首行
• 包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
• 每"."一次，就代表一层文件目录。

import:导入
 1. 在源文件中显式的使用import结构导入指定包下的类、接口
 2. 声明在包的声明和类的声明之间
 3. 如果需要导入多个结构，则并列写出即可
 4. 可以使用"xxx.*"的方式，表示可以导入xxx包下的所结构
 5. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构
 6. 如果使用的类或接口是本包下定义的，则可以省略import结构
 7. 如果在源文件中，使用了不同包下的同名的类，则必须至少一个类需要以全类名的方式显示。
 8. 使用"xxx.*"方式表明可以调用xxx包下的所结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入 
 9. import static:导入指定类或接口中的静态结构:属性或方法。 

1.9 其他修饰符关键字

关键字	意思	备注，常用
native	本地
strictfp	严格,精准
transient	短暂
volatile	易失
assert	断言

1.10 用于定义数据类型值的字面量

关键字	意思	备注，常用
null	空值
true	真
false	假

2.保留字：

                现Java版本尚未使用，但以后版本可能会作为关键字使用。
                具体哪些保留字：goto 、const

注意：自己命名标识符时要避免使用这些保留字

1).const  有道释义：n. 常量，常数  

               用于修改字段或局部变量的声明。它指定字段或局部变量的值是常数，不能被修改

2).goto    有道释义：vi. 转到

               指定跳转到标签，找到标签后，程序将处理从下一行开始的命令。