黑马程序员_Java基础_关键字

---------------------------------------- JavaEE+云物联、期待与您交流！---------------------------------------------

整理了一下Java的50个关键字：

 

abstract  ['æbstrækt]

抽象方法、抽象类的修饰符。抽象的方法没有方法体，直接以分号结尾。只要该类中有一个抽象的方法，则该类必须声明为抽象类。抽象类不能用new创建对象。抽象类中可以没有抽象的方法，只是用来限制该类不能够创建对象。

实例：

public abstract class A

{

→public void function1(){}

→public abstract void function2()；

}

 

assert       [ə'sə:t]

断言条件是否满足。

 

boolean    ['bu:liən]

布尔数据类型。其取值只有两个：true或false，在内存分配中占用一个字节。

 

break        [breik]

跳出，适用于选择结构（switch）和循环结构（while，do-while，for）。必须和相关的代码搭配使用，单独存在没有意义。可以通过标号（标记 ：）来指定其作用范围，无标号时跳出当前语句，有标号时跳出标号所标记的语句。

实例：

flag：for(int i = 1；i< 10；i++)

→→→{

→→→→for(int j = 1；j =<i；j++)

→→→→{

→→→→→System.out.print(j+”*”+i+”=”+j*i\t)；

→→→→→break flag；

→→→→}

→→→→System.out.println()；

→→→}

 

byte      [bait]

8位有符号数据类型，在内存分配中占用一个字节。取值范围是：-2⁷~2⁷-1（-128~127）。

 

case      [keis]

switch语句的一个条件。

 

catch        [kætʃ]

和try搭配捕捉并处理异常信息。所有可能发生异常的代码未被catch处理的，一定要被声明出来。

实例：

try

{可能会发生异常的代码；}

catch（捕捉到的异常类型  一个参数）

{对异常进行处理的代码；}

 

char      [tʃa:]

16位字符数据类型，使用Unicode的编码方式，在内存分配中占用两个字节。在给字符型变量赋值时，要使用单引号将字符引起来，字符可以是单个的字母、汉字、数字、符号。

实例：

char  c = ‘a’；

 

class        [kla:s]

定义类。类名中各单词的首字母要大写。（变量名和函数名中的各单词除开头的首字母小写外，其它首字母都大写；包名的所有字母都小写；常量名的所有字母都大写）

 

const        ['kɔnst]

未使用的关键字，其含义为常数。是constant['kɔnstənt]的 缩写形式。

 

continue [kən'tinju:]

不再执行循环体剩余的部分，继续进行下一次的循环，适用于循环结构（while，do-while，for）。可以用标号指定其作用范围，使用方式同break。

实例：

for(int i= 0；i< 10；i++)

{

→if(i% 2 == 0)

→continue；

→System.out.println(i)；

}

 

default   [di'fɔ:lt]

switch语句中的默认分支。如果default没有放在语句的最后面，那么需要在default后加上break，否则在程序执行到default语句后，还会接着执行其后面的switch中的语句，直至遇到break或者switch语句的结束。

 

do        [du:]

循环语句，和while搭配使用，循环体至少被执行一次。注意， while()后有分号结尾，while()在单独使用时不能以分号结尾，否则会造成无限循环。

实例：

do

{参与循环的代码；}

while(循环条件表达式)；

 

double    ['dʌbl]

64位双精度浮点数，在内存分配中占用8个字节。其取值范围是：-4.9E-324~-1.7E+308，4.9E-324~1.7E+308。  Java中的浮点数默认为是double类型的。对浮点数的取值判断，由于精度的问题，只能做范围的判断。

实例：

double  d = 1.4；

if(1.4< d < 1.5){}

 

else      [els]

if条件不成立时执行的分支。只能和if搭配使用，不能独立存在。

实例：

if(条件表达式)

{条件表达式为true时，执行的代码；}

else

{条件表达式为false时，执行的代码；}

 

enum      ['enəm]

枚举类型，是enumeration[ɪˌnju:mə'reiʃn]的缩写。

 

extends   [iks'tendz]

继承，表示一个类是另一个类的子类。Java中只支持直接单继承，间接可以多层继承。但是，接口与接口之间可以多继承。

实例：

class  A {}

class  B extends A {}

class  C extends B {}

 

final          ['fainl]

含义是最终，可以修饰变量（包括成员变量和局部变量）、函数和类。①表示变量只能被赋值一次，之后以常量的形式存在。②表示方法不能被重写。③表示类不能有子类。

实例：

final class A

{

→final double PI = 3.14；

→final void function(){}

}

 

finally   ['fainəli]

和try搭配使用，表示不管try语句是否发生异常，都要执行finally中的代码，一般用于关闭与资源的连接。只有一种情况例外，finally中的代码不被执行，即Java虚拟机被立刻终 止（System.exit(0)）。

实例：

try

{可能会发生异常的代码；}

finally

{关闭资源；}

 

float        [fləut]

32位单精度浮点数，在内存分配中占用4个字节。其取值范围是：-1.4E-45~-3.4E+38，1.4E-45~3.4E+38。

实例：

float f =1.4f；

 

for       [fɔ:]

循环语句。当初始表达式和循环后要操作的表达式，由多个表达式组成时，各个表达式间用逗号隔开。

实例：

for(初始表达式；循环条件表达式；循环后要操作的表达式)

{参与循环的代码；}

 

goto      ['gəutəu]

未使用的关键字，其含义是跳转。

 

if        [if]

条件语句，与else搭配使用，也可以单独使用。

实例：

if(条件表达式)

{条件表达式为true时，执行的代码；}

else

{条件表达式为false时，执行的代码；}

 

implements   ['implimənts]

实现，表示一个类实现了接口。一个类可以同时实现多个接口，也可以在继承的同时，再实现多个接口。多实现时，用逗号将多个接口隔开。

实例：

interfaceA

{

→public static final int NUM1 = 10；

→public abstract void functionA()；

}

interface B

{

→public static final int NUM2 = 20；

→public abstract void functionB()；

}

classTest implements A,B

{

→public void functionA(){}

→public void functionB(){}

}

 

import    ['impɔ:t]

导入类。Java中使用import导入类，有两种方式：一是单类型导入，好处是编译速度快，可以避免命名冲突，缺点是导入语句可能会很长；二是按需类型导入（使用通配符*），这种形 式会增加Java代码的编译时间，而且有可能会造成命名冲突。

实例：

import java.util.Scanner；

import java.lang.*；

 

instanceof   ['instənsˌəv]

测试一个对象是否是某个类的实例。

实例：

classAnimal {}

class Cat extends Animal

{void function1(){}}

class Test

{

→void function2(Animal a)

→{

→→if(a instanceof Cat)

→→{

→→→Cat c = (Cat)a；

→→→c.function1；

→→}

→}

}

 

int       [int]

32位整型数，在内存分配中占用4个字节。其取值范围是:-2³¹~2³¹-1（-2147483648~2147483647）。Java中的整数默认为是int类型的。

实例：

int a = 10；

 

interface ['intəfeis]

接口，抽象类的特殊形式，仅有常量和抽象方法的定义。接口的成员属性都是public的。接口可以被其它类多实现，接口与接口之间可以多继承。

实例：

interface A

{

→public static final NUM = 3；

→public abstract void function()；

}

 

long      [lɔŋ]

64位整型数，在内存分配中占用8个字节。其取值范围是： -2⁶³~2⁶³-1。

实例：

long l =100l；

 

native    ['neitiv]

表示方法用非Java代码实现。

 

new       [nju:]

创建一个类的对象。

实例：

class A

{

→int i = 1；

→void function(){}

→public static void main(String[] args)

→{

→→A a = new A()；

→→a.function()；

→}

}

 

package   ['pækidʒ]

包，一系列相关的类组成一个包。package一定要放在程序代码的第一行，包名的所有字母都小写，有了包之后的类名全称为：包名.类名。有了包之后，方便于对文件的分类管理，可以将源文件与编译文件相分离，也是一种封装的形式。

实例：

package com.itheima；

 

private   ['praivit]

私有的，用于修饰类中的成员变量和成员函数。被private修饰的成员只能被本类中的其它成员访问。

实例：

class A

{

→private int i = 1；

→private void function()

→{int j = i；}

}

 

protected [prə'tektid]

受保护的，用于修饰类中的成员变量和成员函数。被protected修饰的成员，可以被本类中的成员访问，可以被同一包内的其它成员访问，可以被其子类的成员访问。

实例：

class A

{

→protected int i = 1；

→protected void function()

→{int j = i；}

}

 

public    ['pʌblik]

公有的，用于修饰类，以及类中的成员变量和成员函数。

实例：

public class A

{

→public int i = 1；

→public void function()

→{int j = i；}

}

 

return    [ri'tə:n]

方法返回值或者终止方法。

实例：

int function()

{return 1；}

void function(int x)

{

→if(i== 5)

→return;

→System.out.println(x)；

}

 

short        [ʃɔ:t]

16位整型数，在内存分配中占用两个字节。其取值范围是： -2¹⁵~2¹⁵-1（-32768~32767）。

实例：

short s =6；

 

static    ['stætik]

静态的，用于修饰成员变量和成员函数。被static修饰的成员随着类的加载而加载，优先于对象而存在，被该类的所有对象所共享。静态成员只能访问静态成员。

实例：

class A

{

→static int i = 1；

→static void function()

→{int j = i；}

}

 

strictfp  ['striktˌefpi:]

浮点数要使用严格的规则。全称为：strict float point。

 

super        ['su:pə]

基类，超类，即被子类所继承的父类。含义有两个：一是表示父类对象的引用；二是调用父类的构造函数。子类中的所有的构造函数都默认包含一个父类的空参数构造函数，即super()。使用super调用父类的构造函数时，一定要放在子类构造函数的第一行，被优先执行。

实例：

class A

{

→public A(){}

→int i = 1；

→void function(){}

}

Class B extends A

{

→public B()

→{super()；}

→int i = 2；

→void function()

→{System.out.println(super.i)；}

}

 

switch    [switʃ]

选择语句。switch语句中的表达式的值只能是四种类型： byte，short，int，char。

实例：

switch(表达式)

{

→case取值1：

→→执行语句；

→→break；

→case取值2：

→→执行语句；

→→break；

→default：

→→执行语句；

→→break；

}

 

synchronized   ['siŋkrənaizd]

同步，表示在同一时间只能由一个线程访问的代码块或者函数。同步函数使用的锁对象有两个，静态函数使用的是类名.class对象，非静态函数使用的是this对象。

实例：

synchronized(对象)

{需要同步的代码；}

synchronized void function()

{需要同步的代码；}

 

this      [ðis]

含义有两个：一是调用当前实例对象；二是调用本类的另一个构造函数。在本类的构造函数中调用本类的另一个构造函数时，this一定要放在该构造函数的第一行，被优先执行。在一个构造函数中，this与super不能同时存在。

实例：

class A

{

→public A(int age)

→{this.age = age；}

→public A(int age,String name)

→{

→→this()；

→→this.name = name；

→}

}

 

throw        [θrəu]

抛出异常，在函数内部使用，后面跟的是异常对象。

 

throws    [θrəuz]

定义方法可能会抛出的异常，用在函数上，后面跟的是异常类型。可以抛出多个异常，用逗号隔开。如果存在继承关系，子类只能抛出父类所抛异常的子集。

实例：

void function(int x) throws Exception

{

→if(x == 1)

→throw new Exception()；

}

 

transient ['trænziənt]

修饰不要序列化的变量。

 

try       [trai]

捕捉异常信息，和catch搭配使用处理异常信息；和finally 搭配使用，表示不管try语句中的代码块是否发生异常，都要执行finally中的代码。

实例：

try

{可能会发生异常的代码；}

catch（捕捉到的异常类型  一个参数）

{对异常进行处理的代码；}

finally

{关闭资源；}

 

void      [vɔid]

标记方法不返回任何值。

实例：

void function(){}

 

volatile  ['vɔlətail]

修饰可能会被多个线程同时访问的变量，对该变量的每一次的读写都要在主内存中进行，以保证每个线程在同一时间读到的变量值是相同的。

 

while        [wail]

循环语句。

实例：

while(循环条件表达式)

{参与循环的代码；}

---------------------------------------- JavaEE+云物联、期待与您交流！---------------------------------------------