Java关键字是电脑语言里事先定义的,有特别意义的标识符,有时又叫保留字,还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义,他们用来表示一种数据类型,或者表示程序的结构等,关键字不能用作变量名、方法名、类名、包名和参数。
(一)总表:java关键字共53个(其中包含两个保留字const,goto)
另外,Java还有3个保留字:true、false、null。它们不是关键字,而是文字。包含Java定义的值。和关键字一样,它们也不可以作为标识符使用。参考百度百科
(二)大致含义
关键字 含义
abstract :表明类或者成员方法具有抽象属性
assert: 断言,用来进行程序调试
boolean: 基本数据类型之一,布尔类型
break :提前跳出一个块
byte :基本数据类型之一,字节类型
case :用在switch语句之中,表示其中的一个分支
catch :用在异常处理中,用来捕捉异常
char :基本数据类型之一,字符类型
class :声明一个类
const :保留关键字,没有具体含义
continue :回到一个块的开始处
default :默认,例如,用在switch语句中,表明一个默认的分支
do :用在do-while循环结构中
double :基本数据类型之一,双精度浮点数类型
else:用在条件语句中,表明当条件不成立时的分支
enum :枚举
extends :表明一个类型是另一个类型的子类型,这里常见的类型有类和接口
final :用来说明最终属性,表明一个类不能派生出子类,或者成员方法不能被覆盖,或者成员域的值不能被改变,用来定义常量
finally :用于处理异常情况,用来声明一个基本肯定会被执行到的语句块
float :基本数据类型之一,单精度浮点数类型
for :一种循环结构的引导词
goto :保留关键字,没有具体含义
if :条件语句的引导词
implements: 表明一个类实现了给定的接口
import :表明要访问指定的类或包
instanceof :用来测试一个对象是否是指定类型的实例对象
int :基本数据类型之一,整数类型
interface: 接口
long :基本数据类型之一,长整数类型
native :用来声明一个方法是由与计算机相关的语言(如C/C++/FORTRAN语言)实现的
new :用来创建新实例对象
package: 包
private:一种访问控制方式:私用模式
protected: 一种访问控制方式:保护模式
public :一种访问控制方式:共用模式
return :从成员方法中返回数据
short :基本数据类型之一,短整数类型
static :表明具有静态属性
strictfp :用来声明FP_strict(单精度或双精度浮点数)表达式遵循IEEE 754算术规范 [1]
super :表明当前对象的父类型的引用或者父类型的构造方法
switch :分支语句结构的引导词
synchronized: 表明一段代码需要同步执行
this :指向当前实例对象的引用
throw :抛出一个异常
throws :声明在当前定义的成员方法中所有需要抛出的异常
transient :声明不用序列化的成员域
try :尝试一个可能抛出异常的程序块
void :声明当前成员方法没有返回值
volatile :表明两个或者多个变量必须同步地发生变化
while :用在循环结构中
(三)详细介绍
1.关键字abstract
abstract关键字可以修饰类或方法。
abstract类可以扩展(增加子类),但不能直接实例化。
abstract方法不在声明它的类中实现,但必须在某个子类中重写。
public abstract class MyClass{
public abstract String myMethod();
}
采用abstract方法的类本来就是抽象类,并且必须声明为abstract。
abstract类不能实例化。
仅当abstract类的子类实现其超类的所有abstract方法时,才能实例化abstract类的子类。这种类称为具体类,以区别于abstract类。
如果abstract类的子类没有实现其超类的所有abstract方法,该子类也是abstract类。
abstract关键字不能应用于static、private或final方法,因为这些方法不能被重写,因此,不能在子类中实现。
final类的方法都不能是abstract,因为final类不能有子类。
2.关键字assert(断言)
断言在软件开发中是一种常用的调试方式,很多开发语言中都支持这种机制。一般来说, 断言用于保证程序最基本、关键的正确性。断言检查通常在开发和测试时开启。为了保证程序 的执行效率,在软件发布后断言检查通常是关闭的。
断言是一个包含布尔表达式的语句,在执 行这个语句时假定该表达式为 true;如果表达式的值为 false,那么系统会报告一个 AssertionError。 断言的使用如下面的代码所示:
assert(a > 0); // throws an AssertionError if a <= 0
断言可以有两种形式:
assert Expression1;
assert Expression1 : Expression2 ;
3.关键字boolean
boolean类型适用于逻辑运算,一般用于程序流程控制。boolean类型数据只允许取值true或false,不可以0或非0的整数代替true和false,这点与C语言不同。
4.关键字break&Continue&case&switch
break&Continue语句
break语句用于终止某个语句块的执行。用在循环语句体中,可以强行推出循环。
public class BreakTest {
public static void main(String[] args) {
int stop = 5;
for (int i = 0; i < 10; i++) {
if (i == stop) {
break;
}
System.out.println("i="+i);
}
}
}
结果:
i=0
i=1
i=2
i=3
i=4
/**
* 说明:输出1~100内前5个可以被3整除的数
*
* @author huayu
* @date 2018/8/1 下午4:14
*/
public class BreakTest {
public static void main(String[] args) {
int num=0,i=1;
while (i<=100){
if(i%3==0){
System.out.println(i+" ");
num++;
}
if(num==5){
break;
}
i++;
}
}
}
continue语句用在循环语句体中,用于终止某次循环过程,跳过循环体中continue语句下面未执行的循环,开始下一次循环。
public class ContinueTest {
public static void main(String[] args) {
int skip = 5;
for (int i = 0; i < 10; i++) {
if (i == skip) {
continue;
}
System.out.println("i="+i);
}
}
}
结果:
i=0
i=1
i=2
i=3
i=4
i=6
i=7
i=8
i=9
/**
* 说明:输出101~200内的质数
*质数又称素数。一个大于1的自然数,除了1和它自身外,不能整除其他自然数的数叫做质数;
* @author huayu
* @date 2018/8/1 下午4:21
*/
public class ContinueTest {
public static void main(String[] args) {
//只算奇数就可以,偶数肯定不是质数
for (int i = 101; i < 200; i+=2) {
//置个标记,首先默认是质数
boolean flag=true;
//如果进入这层for循环flag被置为false,则表示不是质数,那么就跳出内层循环不执行了
for (int j = 2; j < i; j++) {
if(i%j==0){
flag=false;
break;
}
}
//筛选,如果不是质数,也就是flag是false就跳过外层这一次循环,继续下一次循环
if(!flag){
continue;
}
//如果是质数则能走到这一步,输出出来
System.out.println(" "+i);
}
}
}
5)switch语句
语句形式:switch(choice){
case xx:
....
break;
case xx:
....
break;
default:
....
break;
}
6.关键词byte,short,int,long
整数类型(java里面所有的数都是带符号的)
java各整数类型有固定的表数范围和字段长度,其不受具体操作系统(windows,linux,mac…)的影响,以保证java程序的可移植性。
java语言整型常量的三种表示形式:
1)十进制整数,如:12,-31,0
2)八进制整数,要求以0开头,如:012(因0开头,010就不确定是什么进制表示的了,为了避免混淆不建议用八进制)
3)十六进制数,要求Ox或OX开头,如:OX12
注意:不管是什么进制在计算机中都是以二进制表示,所以不管是十进制,八进制,十六进制来表示,只要是表示的同一个数它在计算机中的存储都是一样的。
java语言的整型常量默认为int型,声明long型常量可以加l或L(我建议加L好区分)
类型 占用存储空间 表数范围
byte 1字节 -128~127(-27~27-1)
short 2字节 -215~215-1
int 4字节 -231~231-1
long 8字节 -263~263-1
7.关键字char
char型数据用来表示通常意义上“字符”。
字符常量为用单引号括起来的单个字符,例如:
char e=‘a’;
char e=‘中’;
java字符采用Unicode编码,每个字符占两个字节(1个字节占8位,数据在计算机底层存储,用0101表示,每一个0,1都叫一个位(bit)),因而可用十六进制编码形式表示。例如:
char c1=’\u0061’;(在内存中应是01100001,\u指的是后面4位数是十六进制的Unicode编码)
注:Unicode编码是全球语言统一编码。
java语言中还允许使用转义字符‘\’来将其后的字符转变为其它的含义,例如:
char c2=’\n’;
8.可控制访问权限的四个关键字private,default,protected,public
9.关键字float,double
浮点类型:java浮点类型有固定的表数范围和字段长度,不受平台影响。
java浮点型常量有两种表示形式
1.十进制数形式,例如:3.14 41.0 .314
2.科学计数法形式,如3.14e2 3.14E2 100E-2
java浮点型常量默认为double,如果声明一个常量为float,则需在数字后面加f或F,如:
double d=123.4; float f=12.3f;//不加f则出错,f必须加
类型 占用存储空间 表数范围
float 4字节 -3.403E38~3.403E38(小数点后有效位数7位)
double 8字节 -1.798E308~1.798E308(小数点后有效位数15位)
注意:浮点数在计算机中表示是离散的,有误差,在有效位数(精度)之后就不精确了,浮点数值不适用于禁止出现舍入误差的金融计算中。如果需要在数值计算中不含有任何舍入误差,就应该用BigDecimal类。
10.关键字extends
类的继承与权限控制(继承关系:能说通XX是XX就可以看作继承关系,比如,狗是动物)
1)java中使用extends关键字实现类的继承机制,其语法规则为:class[extends]{… …}
2)通过继承,子类自动拥有了父类(基类superclass)的所有成员(成员变量和方法)。
3)java只支持单继承,不允许多继承(一个子类只能有一个基类,一个基类可以派生出多个子类)。
释例:public class Student extends Person{}
11.关键字import(引入):用于引入非同包类,同胞类不需要引入,直接用就可以。
例:import oop.Birthday; //引入oop包下的Birthday类
12.关键字package
package (包)例如:package com.jd;
1)为了便于管理大型软件系统中数目众多的类,解决类的命名冲突问题,java引入包(package)机制,提供类的多重类命名空 间。
2)约定俗称的包起名方式:把公司的域名倒过来。如:package com.jd;这个包包了两层(建包可不是只能建两层哈,别误会,只是这个例子中有两层),公司域名不是一样的,这样起名避免类名产生重复。
3)package语句作为java源文件的第一条语句,指明该文件中定义的类所在的包。(若缺省该语句,则指定为无名包)。
它的格式为package pkg1[.pkg2[.pkg3…]];
4)java编译器把包对应于文件系统的目录管理,package语句中,用“.“来指明包(目录)的层次,例如package com.jd;则该文件中所有的类位于.\com\jd 目录下
5)class文件的最上层包的父目录应位于classpath下(在公司不同的项目一般设置不同的classpath)。
6)要想执行一个类必须写全包名。如:java com.jd.TestPackage
12.关键字static
重要
1)在类中,用static声明的成员变量为静态成员变量,它为该类的公用变量。在第一次使用时候被初始化,对于该类的所有对象来说,static成员变量只有一份。
2)用static声明的方法为静态方法,在调用该方法时,不会将对象的引用传递给它,所以在static方法中不可访问非static的成员。(静态方法只能访问静态成员,因为非静态方法的调用要先创建对象,在调用静态方法时可能对象并没有被初始化)。
3)可以通过对象引用或类名(不需要实例化)访问静态成员。
4)static静态变量存在在data seg数据区,就算是不new它,它也会在data seg部分保留一份。静态变量是属于整个类的,它不属于某一个对象。
知识链接:字符串常量在内存中分配也是在data segment部分。
/**
* 说明:静态变量内存分析举例
*
* @author huayu
* @date 2018/8/3
*/
public class Cat {
//静态成员变量,就算不new对象它也会在data seg里面保存一份,它属于整个类
//不属于某个对象。int静态变量可以用来计数。
//对静态值访问:1.任何一个对象通过对象的引用都可以访问这个静态对象,访问的时候都是同一块内存
//2.即便是没有对象,也可以通过 类名. 来访问 如:System.out out是个静态变量
1. private static int sid=0;
//非静态成员变量 new对象的时候在堆内存对象中保存,每new一个对象产生一块
2. private String name;
//非静态成员变量 new对象的时候在堆内存对象中保存,每new一个对象产生一块
3. private int id;
public Cat(String name) {
4. this.name = name;
5. id=sid++;
}
public void info(){
6. System.out.println("My name is "+name+" No."+id);
}
public static void main(String[] args) {
//静态变量sid属于整个Cat类,不属于某个对象,可以用类名.来访问,所以这儿没有new任何对
//象,直接用类名.(Cat.sid)来访问的。
7. Cat.sid=100;
//字符串常量分配在data seg
8. Cat mimi=new Cat("mimi");
9. Cat pipi=new Cat("pipi");
10. mimi.info();
11. pipi.info();
}
}
打印结果:
My name is mimi No.id=100 sid= 102
My name is pipi No.id=101 sid= 102
执行完7Cat.sid时,静态变量sid值为100。内存分布状态如下:
(1)执行第7句构造方法
第一步:执行第7句Cat mimi=new Cat(“mimi”);字符串常量“mimi”分布在data segment部分,内存分布如下
第二步:调到上面后就该到Cat的构造方法了,执行第4句this.name = name;这时根据传入构造方法的name形参,栈中就会为其开辟一块名为name的空间,实参“mimi”传了进来,这时候栈中name的引用指向了data segment中的字符串常量“mimi”,因为this.name = name,所以自身成员变量的this.name也指向了data segment中的字符串常量“mimi”。
第三步:执行id=sid++;mimi对象的成员变量i值为原来sid的值100,接下来sid++,将sid的值改为101,内存状态如下图:
第四步:构造方法执行完成后,为执行这个方法在栈中分配的形参变量的内存空间收回,name在栈中的空间消失(当然,为执行方法而在栈中分配的局部变量空间,方法执行完毕后都应该被收回了)
(2)执行Cat pipi=new Cat(“pipi”); 方法跟执行上面那个构造方法原理是一样的(当然,为执行方法而在栈中分配的局部变量空间,方法执行完毕后都应该被收回了),大家自己画一下,我这边把最后的内存分布状态给一下大家:
从以上sid(static id)的变化不难看出,int的静态变量可以用作计数用。
(3)将以上程序的static静态变量static int sid;再改为非静态变量 int sid;后做内存分析对比
代码:
/**
* 说明:将上面代码静态变量改为非静态的再做内存分析
*
* @author huayu
* @date 2018/8/3 下午6:32
*/
public class Cat1 {
//成员变量在new的时候才会在堆内分配
private int sid=0;
private String name;
private int id;
public Cat1(String name) {
this.name = name;
id=sid++;
}
public void info(){
System.out.println("My name is "+name+" No.id="+id+" sid= "+sid);
}
public static void main(String[] args) {
// Cat1.sid=100;
Cat1 mimi=new Cat1("mimi");
Cat1 pipi=new Cat1("pipi");
mimi.info();
pipi.info();
}
}
输出结果:
My name is mimi No.id=0 sid= 1
My name is pipi No.id=0 sid= 1
对以上程序进行内存分析:这儿上面以前详细的讲过,大家亲自动手去画一画,感受了解一下静态变量跟非静态变量的区别,下面我给贴个最终状态的图(记得,为执行方法而在栈中分配的局部变量空间,最终方法执行完毕后都应该被收回了):
从以上过程不难看出当静态变量static int sid;改为非静态变量int sid;后,每new一个对象,sid不再发生变化,故用它来计数是不可能了。
13.this关键字
1)在类的方法定义中使用this关键字代表代表使用该方法的对象的引用
2)当必须指出当前使用方法的对象是谁时要用this。
3)有时使用this可以处理方法中成员变量和参数重名的情况。
4)this可以看作是一个变量,它的值是当前对象的引用。
=强调:this一般出现在方法里面,当这个方法还没调用的时候,this指的是谁并不知道,但是实际当中你如果new一个对象出来的话,this指的就是当前这个对象。你对那个方法调这个对象,那么this指的就是谁。
/**
* 说明:this用法举例
*
* @author huayu
* @date 2018/8/3 下午5:39
*/
public class Leaf {
int i=0;
public Leaf(int i) {
1. this.i = i;
}
public Leaf increament(){
2. i++;
3. return this;
}
void print(){
4. System.out.println("i="+i);
}
public static void main(String[] args) {
5. Leaf leaf=new Leaf(100);
6. leaf.increament().increament().print();
}
}
上面代码内存分析:
-
第一步:通过执行main方法第5句,调到了Leaf类的构造方法Leaf(int
i),这时栈空间为形参i开辟了一块内存,实参传入的值为100,又将栈内存中形参i的值赋值给了堆内存成员变量i,所以this.i=100。
-
第二步:构造方法完成,为它分配的局部变量形参i消失。
-
-
第三步:执行第6句leaf.increament().increament().print();
leaf.increament()执行leaf对象的increament()方法,执行i++;
-
第四步:执行第3句return
this;return会在栈空间分配一块临时的内存,这块空间是this的内容,而this指向它自身,所以这块临时内存也指向了对象leaf。leaf.increament()执行完成之后内存分布如下图:
-
第五步:对leaf.increament()结果再调用increament()方法,即还是对原来的对象调用,执行完i++;后,成员变量i值变为102。
-
-
第六步:再执行return
this;return又会在栈空间分配一块临时的内存,这块空间是this的内容,而this指向它自身,所以这块临时内存也指向了对象leaf。
-
第七步,调用完print()方法,整个方法执行完成后,栈中局部变量的内存空间回收。
14.关键字super
在java类中使用super来引用基类的成分;
/**
* 说明:super关键字引用父类成员演示,基类
*
* @author huayu
* @date 2018/8/5 2:57 PM
*/
public class Foo {
public int value;
public void f(){
value=100;
System.out.println("Foo.value="+value);
}
}
/**
* 说明:super关键字引用父类成员演示,子类
*
* @author huayu
* @date 2018/8/5 2:58 PM
*/
public class Coo extends Foo{
public int value;
public void fcoo(){
//引用父类的f(0)方法
super.f();
value=200;
System.out.println("Coo.value="+value);
System.out.println(value);
System.out.println(super.value);
}
}
import oop.Coo;
/**
* 说明:测试方法继承
*
* @author huayu
* @date 2018/8/5 3:05 PM
*/
public class TestInherit {
public static void main(String[] args) {
Coo coo = new Coo();
coo.fcoo();
}
}
测试结果:
Foo.value=100
Coo.value=200
200
100
内存分析图:
把这个子类继承父类程序并子类调用父类成员的内存分配过程,这儿常出面试题:子类是怎么对父类的成员进行调用的。因为以前教过内存分析的具体过程,这儿我就只给了个最后的内存分布图,大家自己好好分析一遍。(当然,方法调用完,栈内为其分配的空间应被收回)。
15.关键字:while
while语句形式:while(逻辑表达式){语句;…;}
执行过程:先判断逻辑表达式的值,若为true则执行其后面的语句,然后再次判断条件并反复执行,直到条件不成立为止