java关键字总结

Java关键字总结

Java关键字（keywords）

abstract  assert  default  if  private  this
boolean  do  implements  protected  throw
break  double  import  public  throws
byte  else  instanceof  return  transient
case  extends  int  short  try
catch  final  interface  static  void
char  finally  long  strictfp  volatile
class  float  native  super  while
const  for  new  switch
continue  goto  package  synchronized

enum 

以上是java中的50个关键字。
const和goto为java中的保留字。

 

特别注意：true, false, null,都不是关键字，而是作为一个单独标识类型。 null不是关键字，它可以用来表示引用数据类型的空值，不能给基本数据类型赋值。

下面我来详细讲解各个关键字的用法：

 

访问修饰符：

public

protected

private

访问权限有大到小是public > protected > private

public是最公开的访问修饰符，public可以修饰类，方法和属性。

用public

修饰的类可以被其他包中的类的对象访问，一个文件中只能有一个用public

修饰的类。一个文件中可以定义多个类，但只能有一个是被public

修饰的，其他几个类不能被任何访问修饰符修饰。

用public修饰方法，这个方法可以被其它包中的类调用，调用方法是：对象名.方法名()

用public修饰的属性，可以直接用 对象名.属性 的方式调用。

 

注意：

1.       在接口中定义的方法和抽象类中定义的抽象方法，不管有没有写public，都是public的。接口中定义的属性是常量，其默认访问权限也为public。

2.       在继承中，子类重写父类中的方法，其访问权限不能比父类中的方法的访问权限更小。如果父类中的方法的访问权限为public，那么子类重写该方法时，这个方法的访问权限也只能是public。

 

private是最不公开的访问权限。private可以修饰方法和属性，有时也可以修饰类。

用private修饰方法，该方法只能由类内部的方法或构造方法调用。用private修饰属性，则该属性不能直接在类外面被访问，如果要在类外部调用这些属性，则要通过一些在类内部定义的方法，如通常的set(), get()函数。

private通常不修饰类，它只能够修饰内部类。

用private修饰的方法不能被继承。

 

protected是介于private和public的关键字。protected可以用来修饰方法和属性，在某些情况下也可以修饰类。被protected修饰的方法可以被同一个包内的其他类调用，调用格式为

对象名.方法名()， 用protected修饰的属性也可以被同一个包内的其他类调用，调用格式也为对象名.属性。

protected一般不修饰类，只能修饰内部类。

一般情况下都使用private或者public，很少使用protected。

用protected修饰的方法，可以被继承。

 

 

类、接口、方法和变量：

class

用来定义类，使用格式为

访问修饰符 class 类名{          访问修饰符 数据类型 属性值;          访问修饰符 返回值类型 方法名(形参列表){                                                                  方法体; } }

 

abstract

可以用来定义抽象类，使用格式为

访问修饰符(public) abstract class 抽象类名{                    public 常量;                    访问修饰符 数据类型 属性;                    访问修饰符(不能是private) 返回值类型 方法名(形参列表){                                                                                     方法体;                                                                                     }                     (public) abstract返回值类型 抽象方法名(形参列表); }

 

 

用abstract定义抽象方法的格式

访问修饰符(不能是private) 返回值类型 抽象方法名(形参列表);

 

 

 

抽象类可以继承类，可以实现接口

访问修饰符 返回值类型 抽象类名 extends 父类名 implements 接口名1， 接口名2…{  }

 

 

 

Interface

 

抽象类中可以定义所有属性的方法，构造方法，和属性。还可以定义抽象方法。

 

用来定义接口，使用格式为

 

访问修饰符 返回值类型 interface 接口名{                             public static final 常量名 = 数值;                             (public) 返回值类型 抽象方法名(参数列表); }

enum枚举

 

extends

用来继承，使用格式如下

class 子类名 extends 父类名{               访问修饰符 数据类型 属性;               访问修饰符 返回值类型 方法名(参数列表){                                                         方法体; }               }

注意：

1.    在java中只能是单继承，即一个子类只能继承一个父类，但是可以多层继承。

2.    子类继承父类，当重写父类中的方法时，子类的方法的访问权限不能小于父类。所谓重写就是除了访问修饰符以外，返回值类型，方法名，参数都和父类一样，但是方法体不一样。

3.    当继承抽象类时，必须重写其中所有的抽象方法。

4.    接口可以继承接口，如

public interface 子接口名 extends 父接口名1，父接口名2…{         }

implements

用来实现接口，使用格式为

public 子类名 implements 父接口名1，父接口名2…{                      访问修饰符 数据类型 属性;                      访问修饰符 返回值类型 方法名(){                                                  方法体;                                                                       }                                                                              }

public 子类名 extends 抽象类名 或者 父类名 implements 父接口1，父接口2…{    }

注意：

1.    子类实现父接口时，可以实现多重实现

2.    子类实现接口时，必须重写其中所有抽象方法

 

final终极的，不可变的

final可以用来修饰常量，属性、方法，类。

用final修饰的常量是不可改变的。

用final修饰的方法是不可重写的。

用final修饰的类是不可被继承的，如String类。

 

static静态的，全局的

static可以用来修饰常量、属性、方法，但是不能用来修饰类。

用static修饰的属性可以直接通过类名.属性的方式来访问。

用static修饰的方法可以直接通过类名.方法名()的方式来访问。

 

可以用static fina或者 fina static来修饰常量和方法。用static fina或者 fina static或者修饰的常量是不可变的，可以通过类名.常量的方式直接来访问。用static fina或者 fina static修饰的方法是不可被重写的，可以通过类名.方法名()的方式直接访问。

 

new用来实例化对象

使用格式

类名 对象名 = new 构造方法(); 除了以上实例化对象的方法，还有以下方法： 类名 对象名; 对象名 = new 构造方法();

strictfp 严格,精准

synchronized 线程,同步

transient 短暂

volatile 易失

 

native 本地

 

包：

Import

将别的包中的类引入进来，如

import java.awt.event.ActionListener; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; import java.awt.event.MouseListener; import java.util.Vector;

package

用来定义包

package cn.FChess.V04;

 

 

 

 

如要使用别的包中的类，则必须要引入这个包

import java.awt.event.MouseEvent; import java.awt.event.MouseListener; import java.util.Vector;

程序控制语句：
break 跳出循环

如

for(int i = x+1; i<FCBoard.ROW;i++ ){            if(location[i][y]%2==location[x][y]%2&&count<=5){               count ++;            }            else               break;        }

continue 继续

return 返回

可以用来返回值

public String getShape() {        return shape;     }

也可以使程序返回不继续往下执行

if(isWin){            return;        }

do 运行

while 循环

if 如果
else 反之

两者通常一起使用。在判断语句中使用

if (isBlack){ //                       g.setColor(Color.BLACK);                          g.drawImage(black.getImage(), x, y, FCBoard.CH_SIZE, FCBoard.CH_SIZE, null);                          isBlack = false;                          data[i][j] = count;                          count = count + 2;                      }                      else{ //                       g.setColor(Color.WHITE);                          g.drawImage(white.getImage(), x, y, FCBoard.CH_SIZE, FCBoard.CH_SIZE, null);                          isBlack = true;                          data[i][j] = - count;                                                  count = count + 2;                      }

   

for 循环

for(int i = x+1; i<FCBoard.ROW;i++ ){            if(location[i][y]%2==location[x][y]%2&&count<=5){               count ++;            }            else               break;        }

instanceof 实例

用来判断对象是否是类的实例

switch 开关
case 返回开关里的结果
default 默认

三者通常一起使用

switch(表达式){          case 选择值1：语句主体1;                                                break;          case 选择值2：语句主体2;                                                break;              ……          case 选择值n：语句主体n;                                                break;          default：语句主体;   }

 

错误处理：
catch 处理异常

finally 有没有异常都执行

throw 抛出一个异常对象

throws 声明一个异常可能被抛出

try 捕获异常

 

基本类型：
byte 字节型

8个bit长度,默认值为0.

char 字符型

16个bit长度，默认值为’\0’

double 双精度,

64位

float 浮点

32位

int 整型

32位，默认值为0，取值范围为“-2147483648~2147483647”

long 长整型

64位
short 短整型

16位

boolean 布尔型

有两个值，即true和false，默认值为false。

变量引用：
super 父类,超类

表示当前类的父类，可以有如下应用

public A{          private  int age;          public A(int age){                   this.age = age; }   }   public B extends A{          super(100);            ……   }

 

this 本类

表示当前类，可以有如下用法

public A{          private String name;          public A(String name){                    this.name = name; }          Public A(){                    this(“默认名字”); } }

void 无返回值

Public void name(){ …… }

其它：

assert断言

J2SE 1.4在语言上提供了一个新特性