java关键字

java关键字：

1.abstract
修饰类：
abstract修饰类，这个类就是抽象类，抽象类中可以有非抽象变量和成员变量，也可以有普通方法、构造方法。但是不能实例化，只能被子类继承。
如果子类不是抽象类，则必须重写父类的抽象方法。

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
...
}
修饰方法:
abstract修饰方法，这个方法就是抽象方法。抽象方法必须存在于抽象类中。抽象方法不能有具体实现。

abstract public E get(int index);

2.assert
assert表示“断言”，有两种使用方法：

1、assert 表达式;
若表达式为真，程序继续执行；若表达式为假，则抛出一个AssertionError异常。

2、assert 表达式:错误信息;
与第一种方法相同，只是异常中带有错误信息。
使用assert时不能在表达式中完成任何程序实际所需的行为（只能做判断）。因为正常发布的代码都是断言无效的，即正常发布的代码中断言语句都不不执行的。

 

3.boolean
boolean是Java的基本类型之一（默认值false）。只有两个值：true和false。区别C的判断句，Java不能直接使用1和0来表示真假，且boolean类型也不能强转到其他基本类型。

boolean a = true;
boolean b = false;

4.break
1、break在switch中用于跳出switch块，停止switch向下穿透的现象。
　　case value:expression;
　　break;
2、break在循环中用于跳出循环。
　　while(...){
　　　　...
　　　　break;
　　}
break也可以在后面接标签，用来跳出一些嵌套比较复杂的循环中。
flag:
for(...){
　　for(...){
　　　　break flag;
　　}
}

5.byte
byte是Java的基本类型之一（默认值0）。表示8位有符号整数。

范围：-128~127

byte a = 100;

6.case
case用于switch中，用于判断和执行语句。用法：

　　case 变量值:语句;
若变量值和switch(变量值)
中的变量值相等，就执行后面的语句。执行完后继续执行下一个case语句。

7.catch
catch用于捕获异常。
用法：

　　catch(异常类型 异常){...}
在try/catch语句块中，catch捕获发生的异常，并应对错误做一些处理。
当catch捕获到异常后，try中执行的语句终止，并跳到catch后的语句中。

8.char
char是Java的基本类型之一（默认值\u000）。表示16位、在Unicode编码表中的字符。使用单引号来表示字符常量，例如’A’。

范围：0-65535

　　char a = 'A';

9.class
class表示类。用于声明一个类。

　　[访问控制] (abstract) class 类名 (implements){...}

10.const
const是Java的一个保留关键字，没有实际意义，但是不能用于做变量名（因为被保留作为关键字了）。在C语言中表示常量，类似Java的final。

 

11.continue
1、continue用于在循环中跳过本次循环。
　　while(...){
　　　　...
　　　　continue;
　　}
2、continue也可以在后面接标签，在一些嵌套比较复杂的循环中跳过一次循环。
　　flag:
　　for(...){
　　　　for(...){
　　　　　　continue flag;
　　　　}
　　}

12.default
default关键字：

1、用于switch做默认分支：
　　default:语句；
2、用于接口,让接口实现具体的方法：
　　public interface a{
　　　　default void b(){
　　　　　　具体方法;
　　　　}
　　}
default用于接口时，必须要有具体实现。
(API>=24)

13. do
do用于和while组成循环，do/while循环不同于while循环，属于先执行循环体再判断。

　　do{
　　　　循环体;
　　}while(...)

14.double
double是Java的基本类型之一（默认值0.0d），表示双精度、64位的浮点数。

　　double a = 0.1d;

15.else
else用于分支结构中的判断。例如：

　　if(判断1){
　　　　语句1;
　　}else if(判断2){
　　　　语句2;
　　}else{
　　　　语句3;
　　}

16.enum
enum表示枚举，用于限制变量值的类型，例如：

　　public enum Alpha (implements 接口){
　　　　(public static final)a,b,c,d
　　}
规定Color的实例只能为a,b,c,d其中之一。

枚举类中可以有成员变量和方法。

 

17.extends
extends表示继承。例如：

　　class 子类 extends父类{}
Java中的继承是单继承，即子类只能有一个直接父类。
除了private，子类可以访问父类的方法和成员变量。

 

18.final

1、修饰变量：
将变量变为常量，在初始化变量后不能再改变值。
2、修饰方法：
被final修饰的方法不能被子类重写。
3、修饰类：
被final修饰的类不能被继承。

19.finally

finally在try/catch语句块中处理一些后续的工作。例如关闭网络连接和输入输出流等。

如果在try/catch中使用return，则finally会撤销这个return，无论如何都会执行finally中的语句。

20.float

float是Java的基本类型之一（默认值0.0f）。表示单精度、32位的浮点数。

float a = 0.1f;

21.for
for用于循环:

　　for(初始化循环变量; 判断执行条件;更新循环变量){
　　　　语句
　　}
　　for(变量:数组){
　　　　语句
　　}

22.goto

Java中的保留关键字，没有实际意义，但是不能用做变量名。在C中表示无条件跳转语句。

 

23.if

if用于分支结构中的判断。常与else和else if使用。

　　if(表达式){语句}
若表达式为真，则执行后面的语句。

 

24.implements

implements用于接入接口。接上接口的类必须实现接口的抽象方法（可以不实现默认方法和静态方法）。

　　class A implements B{
　　　　@Override
　　　　do(){
　　　　　　...
　　　　}
　　}

25.import

用于导入包。

import android.content.Intent;

26.instanceof

instanceof用于判断类与对象的关系。例如：

　　a instanceof b
若a是b的一个实例(或子类对象)，则整个表达式的结果是true，否则结果为false。

 

27.int

int是Java的基本类型之一（默认值为0）。表示32位、有符号的整数。

范围：[-231,231-1)

　　int a = 1;

28.interface
interface用于声明一个接口，例如：

　　public interface A{
　　　　void b();
　　}
声明a为一个接口，若接上该接口，则必须实现其中的抽象方法b。
接口中的成员变量是static、final、public的。接口中的方法为静态方法或默认方法和静态方法(API>=24)。

 

29.long

long是Java的基本类型之一（默认值为0L），表示64位、有符号的整数。

范围：[-263,263)

　　long a = 3216846849646L;

30.native
native可以让Java运行非Java实现的方法。例如c语言，要编译后用javah产生一个.h文件。导入该.h文件并且实现native方法，编译成动态链接库文件。在Java加载动态链接库文件，这个native方法就可以在Java中使用了。

　　public native void aVoid();

31.new

new用于生成类的实例。

　　Object a = new Object()；

32.package

package用于规定当前文件的包。

　　package com.example.zhangyijun.testdefactivity;

33.private

访问控制的一种。
私有的方法和变量只能在本类中访问。类和接口不能为私有。

　　private int a = 1;
　　private void b(){
　　...
　　}

34.protected

访问控制的一种。
受保护的方法和变量只能给子类和基类访问。

　　protected int a = 1;
　　protected void b(){
　　　　...
　　}

35.public

访问控制的一种。
公有的方法、类、变量、接口能够被任何其他类访问。

 

36.return

方法中返回数据，并结束方法。

 

37.strictfp

使用strictfp关键字来声明一个类、接口或者方法时，那么该类、接口或者方法会遵循IEEE-754标准来执行，提高浮点运算的精度，并且减少不同硬件平台之间由于浮点运算带来的差异。

　　public strictfp double aDouble(){
　　　　return 0d;
　　}

38.short

short是Java的基本类型之一（默认值0）,表示16位、有符号的整数。

范围：[-215,215)

　　short a = 0;

39.static

static修饰的语句块存放在堆的方法区中。

1、静态变量：依附在类中的变量，可以被类的所有的实例共用。
　　static int a = 0;
2、静态方法：依附在类中的方法。静态方法只能访问类中的静态变量和静态方法。
　　publlic static void b(){
　　　　...
　　}

3、静态块：在类加载的时候执行块中的语句，块中不能访问非静态变量。
　　static{
　　　　...
　　}
4、静态内部类：用static修饰内部类。

40.super

super即超类

1、引用父类的的成员：
　　super.xxx
2、变量或方法重名时用super调用父类的成员或方法。
3、调用父类的构造方法:
　　super(xxx);

41.switch

switch用于分支结构，判断某个变量与一系列值是否相等。switch 语句中的变量类型可以是： byte、short、int 、char、String、enum。

　　switch(变量){
　　　　case value1:语句1;
　　　　break;
　　　　case value2:语句2;
　　　　break;
　　　　...
　　　　default:语句;
　　}
1、若变量和case后的值相等则执行语句。
2、当语句执行到break时跳到switch块后，如果没有break会产生穿透现象。
3、default分支必须为最后一个分支，在没有值和case变量相等时执行该语句。

42.synchronized

synchronized关键字用于保证线程安全。由这个关键字修饰的方法或者代码块保证了同一时刻只有一个线程执行该代码。

　　synchronized(obj){...}
当一个线程访问同步代码块时，检查obj是否有锁，如果有就挂起。如果没有就获得这个obj的锁，也就是把其他线程锁在了外面。当代码执行完毕时释放该锁，其他线程获得锁继续执行代码。

 

43.this

1、指向当前对象：this.xxx
2、形参和成员名字重名时时用this区分。
3、引用构造函数。

44.throw

用于抛出一个异常。

　　throw (Exception);

45.throws

在方法中将发生的异常抛出。

　　[控制访问](返回类型)(方法名)([参数列表])[throws(异常类)]{...}

46.transient

类接上序列化接口后，可以通过transient关键字将某些变量变得无法序列化。

　　transient int a = 1;

47.try

在try/catch中，将可能出现异常的语句放在try{}块中，出现异常之后代码将会终止并跳到catch中继续执行。

　　try{
　　　　...
　　}catch(Exception e){
　　　　...
　　}finally{
　　　　...
　　}

48.void

修饰方法，表示方法没有返回值。

 

49.volatile

volatile关键字修饰的变量在多线程中保持同步。相比synchronized效率要高，不会阻塞线程。但只能保证数据的可见性，不能保证数据的原子性。例如在处理i++的时候另外一个线程修改i的值，那么i的值将会发生错误，这是原子性导致的。

　　volatile int a;

50.while
while用于两种循环结构：

　　while(判读语句){
　　　　循环体...
　　}

　　do{
　　　　循环体...
　　}while(判读语句)