Java关键字

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

public abstract class AbstractList{
    ...
}

}

• 修饰方法:
• abstract修饰方法，这个方法就是抽象方法。抽象方法必须存在于抽象类中。抽象方法不能有具体实现。

abstract public  get(int index);

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

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

boolean a = true;
boolean b = false;

case value:expression;
    break;
break //在循环中用于跳出循环。
while(...){
    ...
    break;
}
break //也可以在后面接标签，用来跳出一些嵌套比较复杂的循环中。
flag:
for(...){
    for(...){
        break flag;
    }
}

• 范围：-128~127

byte a = 100;

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

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

• 范围：0-65535

char a = 'A';

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

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

• 用于switch做默认分支：
  default:语句；
• 用于接口,让接口实现具体的方法：

public interface a{
    default void b(){
        //具体方法;
    }
}

• default用于接口时，必须要有具体实现。
  (API>=24)

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

double a = 0.1d;

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

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

public enum Alpha (implements 接口){
    (public static final)a,b,c,d
}

规定Color的实例只能为a,b,c,d其中之一。

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

class 子类 extends父类{}

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

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

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

float a = 0.1f;

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

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

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

import android.content.Intent;

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

• 范围：[-231,231-1)

int a = 1;

public interface A{
    void b();
}

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

• 范围：[-263,263)

long a = 3216846849646L;

public native void aVoid();

• Object a = new Object()；

package com.example.zhangyijun.testdefactivity;

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

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

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

• 范围：[-215,215)

short a = 0;

• 静态变量：依附在类中的变量，可以被类的所有的实例共用。

static int a = 0;

• 静态方法：依附在类中的方法。静态方法只能访问类中的静态变量和静态方法。

publlic static void b(){
    ...
}

• 静态块：在类加载的时候执行块中的语句，块中不能访问非静态变量。

static{
    ...
}

• 静态内部类：用static修饰内部类。

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

switch(变量){
	case value1:语句1;
		break;
	case value2:语句2;
		break;
	...
	default:语句;
}

• 若变量和case后的值相等则执行语句。
• 当语句执行到break时跳到switch块后，如果没有break会产生穿透现象。
• default分支必须为最后一个分支，在没有值和case变量相等时执行该语句。

synchronized(obj){...}

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

• 指向当前对象：this.xxx,代表当前类对象的地址值引用
• 形参和成员名字重名时时用this区分。
• 引用构造函数。
• JavaBean规范:
  1)类是具体类 class 类名{}
  2)类的属性必须私有化
  3)类中必须提供setXXX()/getXXX() 对成员变量的公共的访问方法(赋值/获取值)

throw (Exception);

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

transient int a = 1;

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

volatile int a;

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

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