java关键字和保留字
保留字
goto
const
保留字表明在如今的java没有什么用处，但在以后的java上可能还会派上用场，因此将之保留起来
关键字
abstract
用来修饰抽象类和抽象方法，抽象类和抽象方法不能被实例化被abstract修饰过的类不能被final，private，static修饰，因为被这些关键字修饰的类不能被重写abstract类中可以有非抽象方法，但是一定要存在至少一个abstract类要想作为一个abstract类的子类，则必须实现所有的抽象类，否则他还是一个抽象类
public abstract class A{
public abstract void method();
public void hello(){
System.out.println(
"Hello");
}
}
assert
用来进行程序调试 *
boolean
用来判断正确与否，只能以true和false作为值java中的==true==和==false==不能以0和1来代替 包含boolean操作数的表达式只能包含boolean操作数
System.out.println(
true||
false);
Boolean是boolean的包装对象类
break
用于当循环满足某一条件时提前退出break当放在多层循环中时，只能够退出最深一层 break还可以用于switch的case情况，满足某一种case执行后将推出switch
for(
int i=
0;i<
100;i++){
for(
int k=
0;;k++){
if(k>
40){
System.out.println(
"full");
break;
}
}
}
byte
基本数据类型之一，字节类型 储存范围在[-128,127]之间 Byte是byte的包装对象类
int a = Byte.MAX_VALUE;
int b = Byte.MIN_VALUE;
int c = Byte.parseByte(
"121");
case
用于switch类型的一个分支 case分支后面要写上break语句，否则之后的case情况会继续执行下去
switch(a){
case 1:xxx;
break;
case 2:yyy;
break;
default:zzz;
break;
}
catch
用于捕获异常，并在下列语句中对异常进行处理 在捕获异常时，应该先写小异常，后写大异常如果某一个异常未被任何catch语句处理，该异常则沿着传递到下一个封闭try区域，如果都没有处理则退出编译器显示错误
try{
}
catch(Exception A){
}
catch(Exception B){
}
finally{
}
char
基本数据类型之一，字符类型Character是char的包装类 对于一些特殊字符，可以用’\’加上你需要的特殊字符打出
char a =
'\"';
char w =
'\t';
int b = Character.compare(
'd',
'r');
class
用来声明新的java类的关键字类有一般类抽象类，子类需要继承父类并可以重写父类的方法类是面向对象的重要组成部分，每个对象都是类的具体实例当class前面有static修饰时，不需要新建一个对象，通过类名直接调用 被final，private和static修饰的类不能有子类继承，因此也不能是抽象类
public class A{
public void methodA(){
......
}
public static void main(String args[]){
A getA =
new A();
getA.methodA();
}
}
continue
当某次循环满足要求时，将本次循环跳转到下一次循环总是跳转最深层次的循环
int sum =
0;
for(
int i=
0;i<
10;i++){
if(i ==
5)
continue;
sum+=i;
}
default
用于switch中不符合列出的case情况的统一处理
switch(a){
case 1{
xxxx;
break;
}
case 2{
xxxx;
break;
}
default{
xxxx;
break;
}
}
do
用于do…while循环语句用do…while语句时，while表达式后面需要加分号
int n =
0 ;
do{
n++;
}
while(n<
6);
double
java数据类型之一，代表双精度浮点类型的数 ，float代表的是单精度浮点数在32位和64位机器中占8位 Double是double的包装类，Double类中有对double类型数据的多种操作
double c=
0.12456;
Double d =
0.145878;
Double.MAX_VALUE;
else
else一般与if构成条件语句，当不符合if条件句时，就会执行else语句if-else 组成的条件语句可以有多层
if(condition
1){
}
else{
}
enum
枚举的关键字
extends
用于class或者interface声明中，用于声明该类或者接口继承了某一个类或者接口继承的类叫做子类，被继承的类叫做父类 继承的类可以重写父类中任意非final、static、private类 没有重写父类的方法则将沿袭父类的方法
public class A{
public void doA(){
public static void doAA(){
}
}
public class B extends A{
public void doA(){
}
}
false
代表两个boolean变量的两个合法值之一，还有一个是true
boolean check =
false;
boolean change =
true;
final
final关键字适用于类，在class前面加上fianl表明该类不能被继承，也就是不能含有子类 final关键字还可应用于方法，表示这个方法不能被重写 一个类或者一个方法不能同时有abstract和final修饰，abstract代表必须被继承，final代表不能被继承
public final class A{
public final void methodA(){
}
}
public class B extends A{
public void methodA(){}
}
finally
finally关键字用于组成try-catch-finally体系 在try-catch-finally体系中，finally语句必定会被执行，即使在catch中有return，break等关键字，finally也照样会执行
try{
}
catch{
}
finally{
}
float
java数据类型之一，单精度浮点数，在32位和64位机器中占4个字节 java中浮点数默认为是双精度，要想指定单精度文字，应该在数值后面加上f或者F，比如0.04FFloat是float数据类型的包装类，同样具有装箱拆箱机制
public static void main(String args[]){
float d =
0.01;
Float.MAX_VALUE;
}
for
代表循环语句for(;;),第一个分号前写的是初始条件，两个分号之间写的是对条件的判断，第二个分号之后写的是满足条件后执行的指令 这三个空之间的条件都可以省略不写，但有可能会构成死循环 continue和break会影响循环的执行
int sum =
0;
for(
int i=
0;i<
20;i++){
if(sum>=
30)
break;
sum+=i;
if(i==
6)
continue;
}
goto
作为java的保留字段，现在没有什么用处。C语言的goto语句用于跳转指针，java已使用类+方法进行代替
if
与else构成if-else条件语句符合if语句时执行if指令，否则执行else指令
if(condition A){
}
else{
}
implements
implements关键字在class类中使用，表示这个类实现了某一个接口，实现了该接口必须要实现该接口的所有抽象类一个类可以实现多个接口
public interface A{
public abstract void methodA();
}
public class implements A{
public void methodA(){
}
}
import
import 用于导入某一个包，当要导入整个包时，在导入的包后面加上“*”；
import java.util.*;
import java.io.FileInputStream;
instanceof
instanceof用来确定所属对象的类是否属于某个类或者某个类的子类
public class A{
}
public static void main(String args[]){
A a =
new A();
System.out.println(a
instanceof A);
System.out.println(a
instanceof B);
}
int
java的基本数据类型之一，代表整数 Integer是int的包装类，同样含有装箱拆箱机制，方法和Double基本相似
interface
声明这是一个接口，抽象类中可以含有一般方法，接口中只能含有抽象方法一个类可以继承多个抽象类 实现了某个接口的类必须实现该接口的所有抽象类
public interface A{
public abstract void method1();
public method2(){};
}
public interface B{
public abstract void method2();
}
public class C implements A,B{
public void method1(){}
public void method2(){}
}
long
java的基本数据类型之一，表示长整型，在32位和64位计算机中占8位 Long是long的包装类，方法和Integer中的方法基本相似
new
当要新建一个实例对象时，需要用到new关键字来创建；new 后面带的必须是类名，类名后面跟上的是该类中含有的构造方法，默认有的构造方法是 类名+();含有static 修饰的类可以直接用类名不用创建实例
public class A{
public A(
int a,
int b){}
public void method(){}
public static void main(String args[]){
A a =
new A();
A b =
new A(
3,
4);
}
}
null
null是java的保留字，表示空值 不能将null赋值给int，double，short，long，char，byte , boolean 这些对象
package
表示java源文件中声明的类所驻留的java包 package 语句必须是java源程序中的第一句非注释性文本
package com.cheng;
private
用于对类，方法或者字段的修饰 用private修饰的类，方法，字段只在该类、该方法、该字段中可见，对于其它类甚至是它的子类也一样不可见 一般对于一个类的某个成员一般使用private，通过get、set方法来对成员进行赋值和取值，这样会有较高的安全性
public class A{
private String name;
private int age;
public String
getName(){
return this.name;
}
private int methodA(){
}
}
public class B{
A a =
new A();
a.methodA();
a.name;
}
protected
用于类、方法或者字段的修饰 被protected修饰的类、方法或者字段可在本包内的任一地方使用，外部包只有继承了该类成为他的子类才可以使用，否则会产生错误
package 1
protected class A{
public void methodA(){
}
}
public class B{
A a =
new A();
a.methodA();
}
package 2
public class C extends A{
public void methodA(){
}
}
public class D{
A a =
new A();
}
public
用于类、方法和字段的访问控制修饰符 用public修饰的类在任何地方都可以使用被public修饰的类、方法、字段对外界是公开的，任何人都可以看到
return
作为返回的标志 返回的类型要和声明这个类时的返回类型一致 return后面加括号也可以不加括号
public class A{
public String
methodA(){
return +String类型数据
}
}
short
short是java基本数据类型之一，代表整型Short是short的包装类，详细方法类似于Integer包装类
static
被static修饰的变量称为静态变量，修饰的方法称为静态方法，修饰的类称为静态类被static修饰的类可以直接通过类名调用，不需要新创建实例 被static修饰的方法和成员变量也可以被子类重写
public static class A{
static int ss =
10;
public void methodA(){
}
public static void main(String[] args){
A.methodA();
}
}
class B entends A{
static int ss =
20;
}
strictfp
精确浮点数 strictfp 关键字可应用于类、接口或方法。使用 strictfp 关键字声明一个方法时，该方法中所有的float和double表达式都严格遵守FP-strict的限制,符合IEEE-754规范。当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算
super
一个指向父类的指针，当子类的方法使用super时代表它继承了父类对这个方法的指令 直接父类的引用，super.xxx表示引用了父类的成员变量 super还可以用来调用构造函数
public class A{
piublic A(
int a,
int b){
}
int a =
20;
public void methodA(){}
}
public class B extends A{
super(
int a,
int b);
super a;
public void methodA(){
super.methodA();
}
}
switch
和case构成switch-case条件语句，具体方法请看case关键字叙述 switch后面跟的可以是变量，但case后面只能跟常量
synchronized
运用于多线程同步锁，当运用到该类或者实例时，它们将被锁定当一个线程在进行时会获得一个同步锁，此时其它线程不能拿到这个同步锁，因此也无法执行下去，只有当正在执行的线程结束之后释放同步锁才可以交给其它线程执行。
防止了多线程并发出现的错误情况
接下来举一个银行账户的例子
public class Account {
private String accountNo;
private double balance;
public String
getAccountNo() {
return accountNo;
}
public void setAccountNo(String accountNo) {
this.accountNo = accountNo;
}
public double getBalance() {
return balance;
}
public void setBalance(
double balance) {
this.balance = balance;
}
public Account(){};
public Account(String accountNo,
double balance){
this.accountNo = accountNo;
this.balance = balance;
}
public int hashCode(){
return accountNo.hashCode();
}
比较是否是同一个账户名
public boolean equal(Object obj){
if(obj ==
this)
return true;
if(obj!=
null && obj.getClass() == accountNo.getClass()){
Account target = (Account) obj;
return target.accountNo.equals(accountNo);
}
return false ;
}
}
public class withDraw extends Thread{
private Account account ;
private double accountSum;
public withDraw(String name,Account account,
double accountSum){
super(name);
this.account = account;
this.accountSum = accountSum;
}
public void run() {
synchronized (account) {
if(account.getBalance()>=accountSum){
System.out.println(getName()+
"取钱成功");
try {
Thread.sleep(
10);
}
catch (InterruptedException e) {
e.printStackTrace();
}
account.setBalance(account.getBalance() - accountSum);
System.out.println(
"余额为"+account.getBalance());
}
else{
System.out.println(
"余额不足");
}
}
}
public static void main(String[] args) {
Account account =
new Account(
"12345",
4000);
withDraw a1 =
new withDraw(
"a1", account,
2500);
withDraw a2 =
new withDraw(
"a2",account,
2000);
a1.start();
a2.start();
}
}
运行结果如下 假如没有了同步锁，便很有可能出现如下情况
this
this指的是当前对象本身形参与成员变量名字重名，用this来区别调用构造方法方法和前面的super类似，只是super主要调用父类的成员变量和方法，this主要调用的是自身的成员变量的方法
throw 和 throws
都应用在异常处理上throws应用在方法声明上，throw应用在方法内部throws表明该方法可能会产生这种异常；而throw表示必会抛出这种异常，而且是异常实例throws每次可以抛出多个异常，throw每次只能抛出一个异常实例使用了throw和throws的方法在使用时将不需要使用try-catch
public void methodA ()
throws Exception1，Exception2{
}
public void methodA(){
if(xxx==
false){
throw new Exception(
"error!!");
}
}
transient
java的serialization提供了一种持久化的实例对象。有时候为了关闭这种实例化对象，就在那个特定的对象前面加上transient来修饰。当一个对象创建后，当通过ObjectOutputStream把这个类的实例保存到磁盘上时，被transient修饰的类是不会被保存的。也就是说，当你通过ObjectInputStream将对象重新拿出来时，得到的是个null，它不能被序列化
try
和catch、finally构成try-catch-finally语句，用来处理异常，例子详见catch每一个try都至少有一个catch和finally语句
true
boolean变量其中之一，表示正确，另外一个是false
void
表示返回值为null类型
public void method(){
...
return ;
}
volatile
应用于多线程的共享变量关系，当几个线程同时使用一个变量时候，可能会因为CPU和主存数据的不同而产生错误。比如说：在多核处理器中，i的初始值为0，线程1将i赋值为10。在CPU1中对i进行高速缓存，而并没有更新到主存中。当线程2调用i时，从主存中拿到的i值还是0，因此会产生一些数据上的错误。无法保证可见性java运用volatile关键字来保证可见性当一个共享变量被volatile修饰之后，他会保证修改的值立刻更新到主存中 volatile只能保证可见性，不能保证原子性 volatile能够保证有序性synchronized 和 Locked 可以保证原子性
while
构成while循环 构成do…while循环
