考察对Java关键字的掌握
 
问：
     下面哪些是Java关键字
         a.default
         b.NULL
         c.String
         d.throws
         e.long
         f.true
         
 解析：
     大写的NULL不是Java关键字。String是Java语言的一个封装类的类名，也不是关键字。
         
 答：
     a,d,e,f

 



Java关键字：

 下面列出了Java
 关键字
 。这些关键字不能用于
 常量
 、
 变量
 、和任何
 标识符
 的名称


 
类别
关键字
说明
访问控制
private
私有的
protected
受保护的
public
公共的
类、方法和变量修饰符
abstract
声明抽象
class
类
extends
扩允,继承
final
最终值,不可改变的
implements
实现（接口）
interface
接口
native
本地，原生方法（非Java实现）
new
新,创建
static
静态
strictfp
严格,精准
synchronized
线程,同步
transient
短暂
volatile
易失
程序控制语句
break
跳出循环
case
定义一个值以供switch选择
continue
继续
default
默认
do
运行
else
否则
for
循环
if
如果
instanceof
实例
return
返回
switch
根据值选择执行
while
循环
错误处理
assert
断言表达式是否为真
catch
捕捉异常
finally
有没有异常都执行
throw
抛出一个异常对象
throws
声明一个异常可能被抛出
try
捕获异常
包相关
import
引入
package
包
基本类型
boolean
布尔型
byte
字节型
char
字符型
double
双精度浮点
float
单精度浮点
int
整型
long
长整型
short
短整型
null
空
变量引用
super
父类,超类
this
本类
void
无返回值
保留关键字
goto
是关键字，但不能使用
const
是关键字，但不能使用


 

 

 



 

 

 









































































































 

、

 
 
首先来说说我对关键字的理解！
 
一、什么是关键字？
 
关键字是java语言中一些被赋予特定意义的一些单词，不可以把它当做标识符来使用。
 
在java中有两个特殊的关键字goto、const，我们称这两个关键字为保留字。
 
二、java中有哪些关键字？
 
先来介绍几个特殊的关键字，我们称之为访问修饰符。另一个名字被叫做访问控制符。
 
1.什么是访问修饰符？
 
java通过修饰符来控制类、属性和方法的访问权限和其他功能，一般放再java语句的最前端。
 
2.访问修饰符的访问权限的范围
 
修饰符
说明                       
public
共有的，对所有类可见。
protected
受保护的，对同一包内的类和所有子类可见。
默认的
在同一包中可见，默认不使用任何修饰符。
private
私有的，在同一类可见，也就是在同一类中可访问。
从上述表格可以看出从public、protected、默认的、private的访问权限范围依次减少。
 
class：定义类的关键字。
 
interface：定义接口的关键字。
 
abstract ：定义抽象类或者抽象方法的关键字。
 
enum：定义枚举的关键字。
 
extends：继承类或者继承接口的关键字。
 
implements：实现接口的关键字。
 
new：实例化对象的关键字。
 
void：数据类型的关键字。
 
byte、short、int、long：整型数据的关键字  是指十进制类型的
 
整数数据类型:
 
数据类型
内存空间（8位等于一个字节）
取值范围
byte
8位
-2^7~2^7-1
short
16位
-2^15~2^15-1
int 
32位
-2^31~2^31-1
long
64位
-2^63~2^63-1
float、double是指浮点型数据的关键字。
 
浮点型类型数据：
 
数据类型
内存空间
取值范围
float
32位
1.4E-45~3.4028235E38
double
64位
4.9E-324~1.7976931348623157E308
在默认的情况下，小数被看做是double型，若使用float型的小数，则需要在小数后面加上f或者F。若是double型数据，可以在小数后面加d或者D，不加d也不会出错。
 
char:字符的关键字       16位        范围是0~65535
 
boolean：布尔类型的关键字   它的值有true和false
 
this关键字：
 
this关键字用来表示当前对象本身，或者当前类的一个实例化对象，通过this可以调用对象的所有属性和方法。静态方法中不能使用this关键字。
 
this关键字的三个用法：
 
1.通过this关键字可以明确地去访问一个类的成员变量和成员方法，解决与局部变量名的冲突。
 
2.this关键字调用构造方法：构造方法是在实例化对象时java虚拟机自动调用的，不能像调用普通方法那样去调用，可以通过this（参数1，参数2.....）的型式调用其他的构造方法。
 
使用this关键字调用构造方法时需要注意的是：
 
*只能在构造方法中使用this调用其他构造方法，不能在对象的成员方法中使用this调用构造方法
 
*在构造方法中，用this调用构造方法的语句必须放在第一位，并且写一次。
 
*不能再一个类的两个方法中使用this相互调用，不然会报错。
 
3.this还可以表示当前对象，也就是哪个对象在调用this所在的方法，那么此时this就是代表着这个对象。
 
super关键字：
 
super关键字代表父类对象，主要用于指定父类的属性和方法，也用于在子类中初始化父类。子类的静态方法中不能使用super关键字。
 
那么为什么super不能用于子类的静态方法中呢？
 
原因是super指代的是父类的一个对象，它需要在运行的时候才会被创建，二静态方法是指类方法，当类加载的时候，静态方法就已经存在，但是父类对象还没有被初始化。
 
super关键字的用法:
 
使用super关键字可以在子类中调用父类的属性和方法，当子类和父类拥有相同的属性和方法时，此时如果你想调用父类的属性和方法，那么就必须使用super关键字，如果不使用的话，父类的方法和属性就会被子类覆盖。
子类是父类的派生类，它的实例化依赖于父类的实例化。所以它的任何一个构造函数都必须要初始化父类，Java就是super关键字调用父类构造方法，来完成这个操作。如果在父类没有无参构造方法，那么在子类中必须显示调用super来调用已有的有参构造函数来初始化父类。
下面是一个关于构造方法的例子：讲的是如果在父类没有无参构造方法，那么在子类中必须显示调用super来调用已有的有参构造函数来初始化父类。
 
public class Demo1 {
public String name="小明";
public Demo1(String name){
	System.out.println(name+"正在运动");
}
public void play(String name){
	System.out.println(name+"正在休息");
}
}


public class Demo2 extends Demo1{
public Demo2(String name) {
	super("张三");
}
}

 
 异常的关键字：
 
try：用来检测语句块中是否有异常       try{}
 
catch：用来捕获异常，然后进行处理    catch(异常类型){}
 
如果在try-catch语句进行异常处理，当try代码块中的语句发生了异常，程序就会调转到catch代码中执行，执行完catch代码块中的程序代码后，将继续执行catch代码后的其它代码，而不会执行try代码块中发生异常语句后面的代码。由此可知，java的异常处理机制是结构化的，不会因为一个异常影响整个程序的执行。
 
finally：不管是否发生异常，都会执行的语句块       finally{}
 
注意，在以下四种特殊情况下finally语句块不会执行：
 
在finally语句块中发生了异常；
 
在前面的代码中使用了System.exit()退出程序；
 
程序所在的线程死亡；
 
关闭cpu；
 

volatile：数据同步。
 
synchronized:同步              可以用来同步方法、同步代码块
 
循环的关键字： for 、while、do、break、continue
 
接下来主要讲讲break和continue关键字：
 
break关键字和continue关键字是用来控制循环的跳转的；
 
break语句可以用来跳出switch结构。在循环结构中，同样可以用break语句跳出当前循环体，从而中断循环。
 1.break跳出循环。下面是实例代码
 
public class Demo1 {
public static void main(String []args){
	for(int i=0;i<=100;i++){
		System.out.println(i);
		if(i==4){
			break;
		}
	}
	System.out.println("end");
}
}
 
输出结果为：
 
 
2. 在内层嵌套循环中使用break跳出内层循环。下面是实例代码：
 
public class Demo1 {
public static void main(String []args){
	for(int i=0;i<3;i++){
		for(int j=0;j<10;j++){
			if(j==3){
				break;
			}
			System.out.println("i="+i+"  j="+j);
		}
	}
}
}
 
输出结果：
 
 
 
 
 continue语句是对break语句的补充。continue不是立即跳出循环体，而是指跳出本次循环结束前的语句，回到循环的条件测试部分，重新开始执行。
 
下面试一个实例，输出1~10之间的奇数，使用continue跳出循环。
 
public class Demo1 {
public static void main(String []args){
	for(int i=1;i<=10;i++){
		if(i%2==0){
			continue;       //如果i为偶数，跳到下一循环
		}
		System.out.println(i);//输出i的值
	}
}
}
 
输出结果：
 
 
 使用break 标签名可以跳出指定的循环体，此循环体的标签名必须与break标签名一直。这个循环可以是内循环也可以是外循环。
 
语法如下：
 
标签名：循环体{  
 
break  标签名；
 
}
 
下面是带有标签的break跳出外层循环的实例。
 
public class Demo1 {
public static void main(String []args){
	Loop:for(int i=0;i<3;i++){
		for(int j=0;j<=5;j++){	//for循环前用标签标记
			if(j==3){			//如果j等于3就结束外层循环，跳出Loop标签的循环体
				break Loop;
			}
			System.out.println(j);
		}
	}
}
}
 
输出结果：
 
 
 与break语句一样，continue也支持标签功能。语法如下：
 标签名：循环体{
 
          continue 标签名；
 
}
 
标签名：可以说任意标识符；  循环体：任意循环语句； continue标签名：continue跳出指定的循环体，此循环体的标签名必须与continue的标签名一致；
 
条件关键字：if、else、switch、case、default
 
return：返回结果的关键字；
 
package：定义包的关键字；
 
native：调用C或者C++的代码；
 
assert：断言；
 
transient：瞬时的   IO流的对象流
 
instanceof关键字：
 
java中，instanceof运算符的前一个操作符是一个引用变量，后一个操作数通常是一个类（可以是接口），用于判断前面的对象是否是后面的类，或者其子类、实现类的实例。如果是返回true，否则返回false。
 
也就是说：使用instanceof关键字做判断时， instanceof 操作符的左右操作数必须有继承或实现关系
 例如a是A类的一个实例对象，那么     a  instanceof   A ；  则会返回一个true的布尔值。
 
static关键字：
 
由static修饰的变量、常量、和方法称作静态变量、常量、方法；
 
有时候在处理问题时会需要两个类或者多个类在一个内存空间区域共享一个数据。那么在此时需要将它定义为静态的数据；
 
被声明为static的变量、常量和方法被称为静态成员。静态成员属于类所有，区别于个别的对象，可以在本类或其他类使用类名和其他类名和“.”运算符调用静态成员。
 
static的主要作用：为特定数据类型或对象分配单一的存贮空间，而与创建对象的个数无关。或者把某个方法或属性与类而不是对象关联在一起。
 
static的使用：参考：https://blog.csdn.net/chaoshenzhaoxichao/article/details/80402768
 
1.可以用来修饰常量；
 
2.可以用来修饰成员变量，通过static关键字来达到全局的效果。静态变量 属于类，在内存中只有一个副本。只要静态变量所在的类被加载，这个静态类就会被分配空间，因此就可以被使用。对静态变量的引用有两种方式，分别为“类.静态变量”和“对象.静态变量”。实例变量属于对象，只有对象被创建后，实例变量才会被分配空间，才能被使用，他在内存中存在多个副本，只能用“对象.静态变量”的方式来引用。静态变量只有一个，被类所拥有，所有的对象都共享这个静态变量。
 
3.可以用来修饰成员方法，static方法是属于类的方法，不需要创建对象就可以被使用，而非static方法是对象的方法，只有对象被创建出来后才可以被使用。static方法中不能使用this和super关键字，不能调用非静态方法，只能访问静态的成员变量和方法。static谁能实现单例模式，单例模式的特点是该类只有一个实例。
 
4.static可以用来修饰代码块，static代码块在类中是独立与成员变量和成员函数的代码块，他不在任何一个方法体内，JVM在加载里的时候会执行static代码块，如果有多个static代码块，JVM将会按顺序来执行，static代码块经常会被用来初始化静态变量，需要注意的是static代码块只会被执行一次。
 
5.static可以用来修饰内部类，static内部类是指被申明为static的内部类，他可以不依赖于外部类实例对象而被实例化，而通常的内部类需要外部类实例化后才能实例化。静态内部类不能与外部类有相同的名字，不能访问外部类的普通成员变量，只能访问外部类中的静态成员和静态成员方法，只有内部类才能被申明为static。
 
final关键字：
 
final表示最终的，final可以用来修饰普通方法、属性、变量、形参、常量、类、内部类。
 
如果修饰普通方法，表示该方法不能被重写；
 
如果修饰属性、变量、形参，表示值不能改变；
 
如果修饰类，表示类不能被继承。
 
属性、变量、形参、常量的名字中的存储的内容是不能改变的；