Hi，大家好，我是编程小6，很荣幸遇见你，我把这些年在开发过程中遇到的问题或想法写出来，今天说一说
java关键字大全意思_java基础知识总结 超详细,希望能够帮助你!!!。

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（-2^7~27-1）
short 2字节 -2^15~215-1
int 4字节 -2^31~231-1
long 8字节 -2^63~263-1

7.关键字char

char型数据用来表示通常意义上“字符”。

字符常量为用单引号括起来的单个字符，例如：

char e=‘a’;

char e=‘中’；

java字符采用Unicode编码，每个字符占两个字节（1个字节占8位,数据在计算机底层存储，用0101表示，每一个0，1都叫一个位（bit）），因而可用十六进制编码形式表示。例如：

char c1=’\u0061’;（在内存中应是0，\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(); } } 

上面代码内存分析：

1. 第一步：通过执行main方法第5句，调到了Leaf类的构造方法Leaf(int
   i),这时栈空间为形参i开辟了一块内存，实参传入的值为100，又将栈内存中形参i的值赋值给了堆内存成员变量i，所以this.i=100。
   

2. 第二步：构造方法完成，为它分配的局部变量形参i消失。

3. 

4. 第三步：执行第6句leaf.increament().increament().print();
   leaf.increament()执行leaf对象的increament()方法，执行i++；
   

5. 第四步：执行第3句return
   this；return会在栈空间分配一块临时的内存，这块空间是this的内容，而this指向它自身，所以这块临时内存也指向了对象leaf。leaf.increament()执行完成之后内存分布如下图：
   

6. 第五步：对leaf.increament()结果再调用increament()方法，即还是对原来的对象调用，执行完i++;后，成员变量i值变为102。

7. 

8. 第六步：再执行return
   this;return又会在栈空间分配一块临时的内存，这块空间是this的内容，而this指向它自身，所以这块临时内存也指向了对象leaf。
   

9. 第七步，调用完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则执行其后面的语句，然后再次判断条件并反复执行，直到条件不成立为止

今天的分享到此就结束了，感谢您的阅读，如果确实帮到您，您可以动动手指转发给其他人。