当前位置:文档之家› java关键字及其作用

java关键字及其作用

java关键字及其作用
java关键字及其作用

二、详细解释

1. 访问控制

1) private 私有的

private 关键字是访问控制修饰符,可以应用于类、方法或字段(在类中声明的变量)。只能在声明 private(内部)类、方法或字段的类中引用这些类、方法或字段。在类的外部或者对于子类而言,它们是不可见的。所有类成员的默认访问范围都是 package 访问,也就是说,除非存在特定的访问控制修饰符,否则,可以从同一个包中的任何类访问类成员。

2) protected 受保护的

protected 关键字是可以应用于类、方法或字段(在类中声明的变量)的访问控制修饰符。可以在声明 protected 类、方法或字段的类、同一个包中的其他任何类以及任何子类(无论子类是在哪个包中声明的)中引用这些类、方法或字段。所有类成员的默认访问范围都是 package 访问,也就是说,除非存在特定的访问控制修饰符,否则,可以从同一个包中的任何类访问类成员。

3) public 公共的

public 关键字是可以应用于类、方法或字段(在类中声明的变量)的访问控制修饰符。可能只会在其他任何类或包中引用 public 类、方法或字段。所有类成员的默认访问范围都是 package 访问,也就是说,除非存在特定的访问控制修饰符,否则,可以从同一个包中的任何类访问类成员。

2. 类、方法和变量修饰符

1) abstract 声明抽象

abstract关键字可以修改类或方法。abstract类可以扩展(增加子类),但不能直接实例化。abstract方法不在声明它的类中实现,但必须在某个子类中重写。采用 abstract方法的类本来就是抽象类,并且必须声明为abstract。

2) class类

class 关键字用来声明新的 Java 类,该类是相关变量和/或方法的集合。类是面向对象的程序设计方法的基本构造单位。类通常代表某种实际实体,如几何形状或人。类是对象的模板。每个对象都是类的一个实例。要使用类,通常使用 new 操作符将类的对象实例化,然后调用类的方法来访问类的功能。

3) extends 继承、扩展

extends 关键字用在 class 或 interface 声明中,用于指示所声明的类或接口是其名称后跟有 extends 关键字的类或接口的子类。子类继承父类的所有 public 和 protected 变量和方法。子类可以重写父类的任何非 final 方法。一个类只能扩展一个其他类。

4) final 最终、不可改变

final 关键字可以应用于类,以指示不能扩展该类(不能有子类)。final 关键字可以应用于方法,以指示在子类中不能重写此方法。一个类不能同时是 abstract 又是 final。abstract 意味着必须扩展类,final 意味着不能扩展类。一个方法不能同时是 abstract 又是 final。abstract 意味着必须重写方法,final 意味着不能重写方法。

5) implements实现

implements 关键字在 class 声明中使用,以指示所声明的类提供了在 implements 关键字后面的名称所指定的接口中所声明的所有方法的实现。类必须提供在接口中所声明的所有方法的实现。一个类可以实现多个接口。

6) interface 接口

interface 关键字用来声明新的 Java 接口,接口是方法的集合。

接口是 Java 语言的一项强大功能。任何类都可声明它实现一个或多个接口,这意味着它实现了在这些接口中所定义的所有方法。

实现了接口的任何类都必须提供在该接口中的所有方法的实现。一个类可以实现多个接口。

7) native 本地

native 关键字可以应用于方法,以指示该方法是用 Java 以外的语言实现的。

8) new 新,创建

new 关键字用于创建类的新实例。

new 关键字后面的参数必须是类名,并且类名的后面必须是一组构造方法参数(必须带括号)。

参数集合必须与类的构造方法的签名匹配。

= 左侧的变量的类型必须与要实例化的类或接口具有赋值兼容关系。

9) static 静态

static 关键字可以应用于内部类(在另一个类中定义的类)、方法或字段(类的成员变量)。

通常,static 关键字意味着应用它的实体在声明该实体的类的任何特定实例外部可用。

static(内部)类可以被其他类实例化和引用(即使它是顶级类)。在上面的示例中,另一个类中的代码可以实例化 MyStaticClass 类,方法是用包含它的类名来限定其名称,如MyClass.MyStaticClass。

static 字段(类的成员变量)在类的所有实例中只存在一次。

可以从类的外部调用 static 方法,而不用首先实例化该类。这样的引用始终包括类名作为方法调用的限定符。

模式:public final static varName = ; 通常用于声明可以在类的外部使用的类常量。在引用这样的类常量时需要用类名加以限定。在上面的示例中,另一个类可以用 MyClass.MAX_OBJECTS 形式来引用 MAX_OBJECTS 常量。

10) strictfp 严格,精准

strictfp的意思是FP-strict,也就是说精确浮点的意思。在Java虚拟机进行浮点运算时,如果没有指定strictfp关键字时,Java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作,以致于得到的结果往往无法令人满意。而一旦使用了strictfp来声明一个类、接口或者方法时,那么所声明的范围内Java的编译器以及运行环境会完全依照浮点规范IEEE-754来执行。因此如果想让浮点运算更加精确,而且不会因为不同的硬件平台所执行的结果不一致的话,那就请用关键字strictfp。

可以将一个类、接口以及方法声明为strictfp,但是不允许对接口中的方法以及构造函数声明strictfp关键字

11) synchronized线程、同步

synchronized 关键字可以应用于方法或语句块,并为一次只应由一个线程执行的关键代码段提供保护。

synchronized 关键字可防止代码的关键代码段一次被多个线程执行。

如果应用于静态方法,那么,当该方法一次由一个线程执行时,整个类将被锁定。

如果应用于实例方法,那么,当该方法一次由一个线程访问时,该实例将被锁定。

如果应用于对象或数组,当关联的代码块一次由一个线程执行时,对象或数组将被锁定。

12) transient 短暂

transient 关键字可以应用于类的成员变量,以便指出该成员变量不应在包含它的类实例已序列化时被序列化。

当一个对象被串行化的时候,transient型变量的值不包括在串行化的表示中,然而非transient型的变量是被包括进去的。

Java的serialization提供了一种持久化对象实例的机制。当持久化对象时,可能有一个特殊的对象数据成员,我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization,可以在这个域前加上关键字transient。

transient是Java语言的关键字,用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候,transient型变量的值不包括在串行化的表示中,然而非transient 型的变量是被包括进去的。

13) volatile 易失

volatile 关键字用于表示可以被多个线程异步修改的成员变量。

注意:volatile 关键字在许多 Java 虚拟机中都没有实现。 volatile 的目标用途是为了

确保所有线程所看到的指定变量的值都是相同的。

Java 语言中的 volatile 变量可以被看作是一种“程度较轻的 synchronized”;与synchronized 块相比,volatile 变量所需的编码较少,并且运行时开销也较少,但是它所能实现的功能也仅是 synchronized 的一部分。

3. 程序控制语句

1) break 跳出,中断

break 关键字用于提前退出 for、while 或 do 循环,或者在 switch 语句中用来结束 case 块。

break 总是退出最深层的 while、for、do 或 switch 语句。

2) continue 继续

continue 关键字用来跳转到 for、while 或 do 循环的下一个迭代。

continue 总是跳到最深层 while、for 或 do 语句的下一个迭代。

3) return 返回

return 关键字会导致方法返回到调用它的方法,从而传递与返回方法的返回类型匹配的值。如果方法具有非 void 的返回类型,return 语句必须具有相同或兼容类型的参数。

返回值两侧的括号是可选的。

4) do 运行

do 关键字用于指定一个在每次迭代结束时检查其条件的循环。

do 循环体至少执行一次。

条件表达式后面必须有分号。

5) while 循环

while 关键字用于指定一个只要条件为真就会重复的循环。

6) if 如果

if 关键字指示有条件地执行代码块。条件的计算结果必须是布尔值。

if 语句可以有可选的 else 子句,该子句包含条件为 false 时将执行的代码。

包含 boolean 操作数的表达式只能包含 boolean 操作数。

7) else 否则

else 关键字总是在 if-else 语句中与 if 关键字结合使用。else 子句是可选的,如果 if 条件为 false,则执行该子句。

8) for 循环

for 关键字用于指定一个在每次迭代结束前检查其条件的循环。

for 语句的形式为 for(initialize; condition; increment)

控件流进入 for 语句时,将执行一次 initialize 语句。

每次执行循环体之前将计算 condition 的结果。如果 condition 为 true,则执行循环体。每次执行循环体之后,在计算下一个迭代的 condition 之前,将执行 increment 语句。

9) instanceof 实例

instanceof 关键字用来确定对象所属的类。

10) switch 观察

switch 语句用于基于某个表达式选择执行多个代码块中的某一个。

switch 条件的计算结果必须等于 byte、char、short 或 int。

case 块没有隐式结束点。break 语句通常在每个 case 块末尾使用,用于退出 switch 语句。

如果没有 break 语句,执行流将进入所有后面的 case 和/或 default 块。

11) case 返回观察里的结果

case 用来标记 switch 语句中的每个分支。

case 块没有隐式结束点。break 语句通常在每个 case 块末尾使用,用于退出 switch 语句。

如果没有 break 语句,执行流将进入所有后面的 case 和/或 default 块。

12) default 默认

default 关键字用来标记 switch 语句中的默认分支。

default 块没有隐式结束点。break 语句通常在每个 case 或 default 块的末尾使用,以便在完成块时退出 switch 语句。

如果没有 default 语句,其参数与任何 case 块都不匹配的 switch 语句将不执行任何操作。

4. 错误处理

1) try 捕获异常

try 关键字用于包含可能引发异常的语句块。

每个 try 块都必须至少有一个 catch 或 finally 子句。

如果某个特定异常类未被任何 catch 子句处理,该异常将沿着调用栈递归地传播到下一个封闭 try 块。如果任何封闭 try 块都未捕获到异常,Java 解释器将退出,并显示错误消息和堆栈跟踪信息。

2) catch 处理异常

catch 关键字用来在 try-catch 或 try-catch-finally 语句中定义异常处理块。

开始和结束标记 { 和 } 是 catch 子句语法的一部分,即使该子句只包含一个语句,也不能省略这两个标记。

每个 try 块都必须至少有一个 catch 或 finally 子句。

如果某个特定异常类未被任何 catch 子句处理,该异常将沿着调用栈递归地传播到下一个封闭 try 块。如果任何封闭 try 块都未捕获到异常,Java 解释器将退出,并显示错误消息和堆栈跟踪信息。

3) throw 抛出一个异常对象

throw 关键字用于引发异常。

throw 语句将 https://www.doczj.com/doc/8112510943.html,ng.Throwable 作为参数。Throwable 在调用栈中向上传播,直到被适当的 catch 块捕获。

引发非 RuntimeException 异常的任何方法还必须在方法声明中使用 throws 修饰符来声明它引发的异常。

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

throws 关键字可以应用于方法,以便指出方法引发了特定类型的异常。

throws 关键字将逗号分隔的 https://www.doczj.com/doc/8112510943.html,ng.Throwables 列表作为参数。

引发非 RuntimeException 异常的任何方法还必须在方法声明中使用 throws 修饰符来声明它引发的异常。

要在 try-catch 块中包含带 throws 子句的方法的调用,必须提供该方法的调用者。

5. 包相关

1) import 引入

import 关键字使一个包中的一个或所有类在当前 Java 源文件中可见。可以不使用完全限

定的类名来引用导入的类。

当多个包包含同名的类时,许多 Java 程序员只使用特定的 import 语句(没有“*”)来避免不确定性。

2) package 包

package 关键字指定在 Java 源文件中声明的类所驻留的 Java 包。

package 语句(如果出现)必须是 Java 源文件中的第一个非注释性文本。

例:https://www.doczj.com/doc/8112510943.html,ng.Object。

如果 Java 源文件不包含 package 语句,在该文件中定义的类将位于“默认包”中。请注意,不能从非默认包中的类引用默认包中的类。

6. 基本类型

1) boolean 布尔型

boolean 是 Java 原始类型。boolean 变量的值可以是 true 或 false。

boolean 变量只能以 true 或 false 作为值。boolean 不能与数字类型相互转换。

包含 boolean 操作数的表达式只能包含 boolean 操作数。

Boolean 类是 boolean 原始类型的包装对象类。

2) byte 字节型

byte 是 Java 原始类型。byte 可存储在 [-128, 127] 范围以内的整数值。

Byte 类是 byte 原始类型的包装对象类。它定义代表此类型的值的范围的 MIN_VALUE 和MAX_VALUE 常量。

Java 中的所有整数值都是 32 位的 int 值,除非值后面有 l 或 L(如 235L),这表示该值应解释为 long。

3) char 字符型

char 是 Java 原始类型。char 变量可以存储一个 Unicode 字符。

可以使用下列 char 常量:\b - 空格, \f - 换页, \n - 换行, \r - 回车, \t - 水平制表符, \' - 单引号, \" - 双引号, \\ - 反斜杠, \xxx - 采用 xxx 编码的 Latin-1 字符。\x 和 \xx 均为合法形式,但可能引起混淆。 \uxxxx - 采用十六进制编码 xxxx 的Unicode 字符。

Character 类包含一些可用来处理 char 变量的 static 方法,这些方法包括 isDigit()、isLetter()、isWhitespace() 和 toUpperCase()。

char 值没有符号。

4) double 双精度

double 是 Java 原始类型。double 变量可以存储双精度浮点值。

由于浮点数据类型是实际数值的近似值,因此,一般不要对浮点数值进行是否相等的比较。

Java 浮点数值可代表无穷大和 NaN(非数值)。Double 包装对象类用来定义常量

MIN_VALUE、MAX_VALUE、NEGATIVE_INFINITY、POSITIVE_INFINITY 和 NaN。

5) float 浮点

float 是 Java 原始类型。float 变量可以存储单精度浮点值。

使用此关键字时应遵循下列规则:

Java 中的浮点文字始终默认为双精度。要指定单精度文字值,应在数值后加上 f 或 F,如 0.01f。

由于浮点数据类型是实际数值的近似值,因此,一般不要对浮点数值进行是否相等的比较。

Java 浮点数值可代表无穷大和 NaN(非数值)。Float 包装对象类用来定义常量 MIN_VALUE、MAX_VALUE、NEGATIVE_INFINITY、POSITIVE_INFINITY 和 NaN。

6) int 整型

int 是 Java 原始类型。int 变量可以存储 32 位的整数值。

Integer 类是 int 原始类型的包装对象类。它定义代表此类型的值的范围的 MIN_VALUE 和MAX_VALUE 常量。

Java 中的所有整数值都是 32 位的 int 值,除非值后面有 l 或 L(如 235L),这表示该值应解释为 long。

7) long 长整型

long 是 Java 原始类型。long 变量可以存储 64 位的带符号整数。

Long 类是 long 原始类型的包装对象类。它定义代表此类型的值的范围的 MIN_VALUE 和MAX_VALUE 常量。

Java 中的所有整数值都是 32 位的 int 值,除非值后面有 l 或 L(如 235L),这表示该值应解释为 long。

java关键字

Java 关键字速查表 访问控制: private 私有的 protected 受保护的 public 公共的 类、方法和变量修饰符abstract 声明抽象 class 类 extends 扩允,继承 final 终极,不可改变的implements实现 interface 接口 native 本地 new 新,创建 static 静态 strictfp 严格,精准synchronized 线程,同步transient 短暂 volatile 易失 程序控制语句 break 跳出循环 continue 继续 return 返回 do 运行 while 循环 if 如果 else 反之 for 循环 instanceof 实例 switch 开关 case 返回开关里的结果 default 默认 错误处理 catch 处理异常 finally 有没有异常都执行 throw 抛出一个异常对象throws 声明一个异常可能被抛出try 捕获异常 包相关 import 引入 package 包

基本类型 boolean 布尔型 byte 字节型 char 字符型 double 双精度, float 浮点 int 整型 long 长整型 short 短整型 null 空 true 真 false 假 变量引用 super 父类,超类 this 本类 void 无返回值 java关键字 关键字是电脑语言里事先定义的,有特别意义的标识符,有时又叫保留字。Java的关键字对java的编译器有特殊的意义,他们用来表示一种数据类型,或者表示程序的结构等,关键字不能用作变量名、方法名、类名、包名。一个Java语言中的关键字,用在类的声明中来指明一个类是不能被实例化的,但是可以被其它类继承。一个抽象类可以使用抽象方法,抽象方法不需要实现,但是需要在子类中被实现break 一个Java的关键字,用来改变程序执行流程,立刻从当前语句的下一句开始执行从。如果后面跟有一个标签,则从标签对应的地方开始执行case Java语言的关键字,用来定义一组分支选择,如果某个值和switch中给出的值一样,就会从该分支开始执行。catch :Java的一个关键字,用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。char :Java语言的一个关键字,用来定义一个字符类型 abstract boolean break byte case catch char class continue default do double else extends final finally float for if implements import instanceof int interface long native new package private protected public return short static super switch synchronized this throw throws transient try void volatile while 详细介绍

java中常用关键字总结

Java中的关键字总结 final 关键字 1、用final修饰的类不能被继承,没有子类; 2、用final修饰的方法,方法不能被重写; 3、用final修饰变量,变量的值不能被修改,表示常量,(书写规范:全部字母都要大写;多个单词,可以使用下划线(_)分开;) 注意:如果被final修饰的变量是一个引用类型的数据,那么通过这个引用改变堆空间中的数据,不会报错;如果被final修饰的变量是一个引用类型的数据,那么通过这个引用改变堆空间中的数据,不会报错; 4、final用于成员变量表示该成员变量为常量,不能被修改,必须在变量定义时赋值。 5、final用于局部变量表示该局部变量为常量,不能被修改,可以在变量定义时赋值,也可以先定义变量后赋值。 什么时候用final关键字? 有的时候不想别人重写我的方法就使用final关键字修饰该方法; static关键字 1、static用于成员变量表示该变量只有一份,也就是说静态成员变量属于类而不属于某个具体的类实例对象,所有的类实例对象共享这个静态成员变量;静态函数是不需要对象的,直接可以使用类名来调用; 2、非静态函数可以调用静态函数;静态函数不能调用非静态函数(非静态函数都是通过对象调用的);静态函数不能使用非静态成员变量,但可以使用静态成员变量; 3、静态函数调用时不需要对象的,所以不能使用和对象有关的关键字;(this;super;) 4、构造函数不能使用static修饰(构造函数是创建对象,开辟空间,给所有成员变量赋默认值之后,有JVM调用进栈,用来给对象的成员变量赋初始值的) static用于类,这里指的是内部类,那么在别的地方就可以通过外部类名来引用这个静态的内部类。 5、static还可以用于类的代码块,叫做静态代码块,静态代码块在类加载的时候就执行完毕,而类只加载一次;是在类中独立于类成员的static语句块,可以有多个,位置可以随便放,它不在任何的方法体内,JVM加载类时会执行这些静态的代码块,如果static代码块有多个,JVM将按照它们在类中出现的先

java选择题

1、Java属于以下哪种语言?() A、机器语言 B、汇编语言 C、高级语言 D、以上都不对 2、在JDK安装目录下,用于存放可执行程序的文件夹是? A、bin B、jre C、lib D、db 3、下列Java命令中,哪一个可以编译HelloWorld.java文件? A、java HelloWorld B、java HelloWorld.java C、javac HelloWorld D、javac HelloWorld.java 4、以下关于java命令作用的描述中,正确的是 A、它专门负责解析由Java编译器生成的.class文件 B、它可以将编写好的Java文件编译成.class文件 C、可以把文件压缩 D、可以把数据打包 5、下面关于配置path环境变量作用的说法中,正确的是() A、在任意目录可以使用javac和java命令 B、在任意目录下可以使用class文件 C、在任意目录可以使用记事本 D、在任意目录下可以使用扫雷游戏 6、下面关于path和classpath的说法中,错误的是() A、path用来指定java 虚拟机(JVM) 所在的目录 B、classpath用来指定我们自己所写的或要用到的类文件(.jar文件) 所在的目录 C、在dos命令行中,classpath和path环境变量的查看与配置的方式不相同 D、只要设置了classpath 这个环境变量系统就不会再在当前目录下查询某个类 7、下面关于classpath的说法中,错误的是()。 A、classpath和path环境变量的查看与配置的方式完全相同。 B、为了让Java虚拟机能找到所需的class文件,就需要对classpath环境变量进行设置。 C、从JDK5.0开始,如果classpath环境变量没有进行设置,Java虚拟机会自动将其设置为“.”,也就是当前目录。 D、在命令行窗口中配置了classpath后,重新打开新命令行窗口依然生效 8、下面哪种类型的文件可以在Java虚拟机中运行?() A、.java B、.jre C、.exe D、.class 9、阅读下段代码片段,选择正确的运行结果 public static void main(String[] args) {

实验5 JAVA常用类

山西大学计算机与信息技术学院 实验报告 姓名学号专业班级 课程名称 Java实验实验日期成绩指导教师批改日期 实验5 JAVA常用类实验名称 一.实验目的: (1)掌握常用的String,StringBuffer(StringBuilder)类的构造方法的使用;(2)掌握字符串的比较方法,尤其equals方法和==比较的区别; (3)掌握String类常用方法的使用; (4)掌握字符串与字符数组和byte数组之间的转换方法; (5)Date,Math,PrintWriter,Scanner类的常用方法。 二.实验内容 1.二进制数转换为十六进制数(此程序参考例题249页9. 2.13) 程序源代码 import java.util.*; public class BinToHexConversion{ //二进制转化为十六进制的方法 public static String binToHex(String bin){ int temp; //二进制转化为十六进制的位数 if(bin.length()%4==0) temp = bin.length()/4; else temp = bin.length()/4 + 1; char []hex = new char[temp]; //十六进制数的字符形式 int []hexDec = new int[temp];//十六进制数的十进制数形式 int j = 0; for(int i=0;i=0&&dec<10) return (char)('0'+dec-0); else if(dec>=10&&dec<=15) return (char)('A'+dec-10); else return '@'; }

Java关键字final使用总结

Java关键字final使用总结 一、final 根据程序上下文环境,Java关键字final有“这是无法改变的”或者“终态的”含义,它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变:设计或效率。 final类不能被继承,没有子类,final类中的方法默认是final的。 final方法不能被子类的方法覆盖,但可以被继承。 final成员变量表示常量,只能被赋值一次,赋值后值不再改变。 final不能用于修饰构造方法。 注意:父类的private成员方法是不能被子类方法覆盖的,因此private 类型的方法默认是final类型的。 1、final类 final类不能被继承,因此final类的成员方法没有机会被覆盖,默认都是final的。在设计类时候,如果这个类不需要有子类,类的实现细节不允许改变,并且确信这个类不会载被扩展,那么就设计为final类。 2、final方法 如果一个类不允许其子类覆盖某个方法,则可以把这个方法声明为final 方法。 使用final方法的原因有二: 第一、把方法锁定,防止任何继承类修改它的意义和实现。 第二、高效。编译器在遇到调用final方法时候会转入内嵌机制,大大提高执行效率。 例如:

3、final变量(常量) 用final修饰的成员变量表示常量,值一旦给定就无法改变! final修饰的变量有三种:静态变量、实例变量和局部变量,分别表示三种类型的常量。 从下面的例子中可以看出,一旦给final变量初值后,值就不能再改变了。 另外,final变量定义的时候,可以先声明,而不给初值,这中变量也称为final空白,无论什么情况,编译器都确保空白final在使用之前必须被初始化。但是,final空白在final关键字final的使用上提供了更大的灵活性,为此,一个类中的final 数据成员就可以实现依对象而有所不同,却有保持其恒定不变的特征。

java中的关键字的含义及介绍

Java中的键字? 才发现Java中的好多关键字都不知道什么意思,特转一遍过来。 Java保留关键字 Java语言有51个关键字,其中const和goto虽然被保留但未使用。你不能使用保留关键字来命名类、方法或变量。 一、保留关键字 1、数据类型: Boolean int long short byte float double char class interface 2、流程控制: if else do while for switch case default break continue return try catch finally 3、修饰符: public protected private final void static strictfp abstract transient synchronized volatile native 4、动作: package import throw throws extends implements this Super instanceof new 5、保留字: true false null goto const 二、访问修饰符: 访问修饰符:public , protected , private * 只能应用于类的成员变量。(局部变量只能在函数的范围内可见,不能使用访问修饰符) * 能够用来修饰类本身。(protected , private 不能用于顶级类,只能用于内部类) * 能够应用于成员方法和构造函数。 下面是一个例子: package Examples; public class HelloWorld02{ //以下定义了三个了类成员变量 public String str1="Hello"; //可被你程序中的任何其他代码访问 protected String str2="World!"; //程序中同一包的成员和不同包中的该类子类可以访问 private String str3=" "; //仅该类中的成员可以访问 String str=str1+str3+str2; //不使用修饰符的话,变量的访问控制在所在包内为public, // 不能被所在包外的代码存取 //以下定义了三个使用不同修饰符和不同参数的构造方法。

JAVA中常用类的常用方法

JAVA中常用类的常用方法 一、https://www.doczj.com/doc/8112510943.html,ng.Object类 1、clone()方法 创建并返回此对象的一个副本。要进行“克隆”的对象所属的类必须实现https://www.doczj.com/doc/8112510943.html,ng. Cloneable接口。 2、equals(Object obj)方法 ?功能:比较引用类型数据的等价性。 ?等价标准:引用类型比较引用,基本类型比较值。 ?存在特例:对、Date及封装类等类型来说,是比较类型及对象的内容而不考虑引用的是否为同一实例。 3、finalize()方法 当垃圾回收器确定不存在对该对象的更多引用时,由对象的垃圾回收器调用此方法。 4、hashCode()方法返回该对象的哈希码值。 5、notify()方法唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法唤醒在此对象监视器上等待的所有线程。 7、toString()方法 返回该对象的字符串表示。在进行String与其它类型数据的连接操作时,自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法 在其他线程调用此对象的notify() 方法或notifyAll() 方法前,导致当前线程等待。 二、字符串相关类 l String类 charAt(int index) 返回指定索引处的char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。 compareToIgnoreCase(String str) 按字典顺序比较两个字符串,不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此String 与另一个String 比较,不考虑大小写。indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串,它是通过用newChar 替换此字符串中出现的所有oldChar 得到的。split(String regex) 根据给定正则表达式的匹配拆分此字符串。 startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 substring(int beginIndex) 返回一个新的字符串,它是此字符串的一个子字符串。该子字符串始于指定索引处的字符,一直到此字符串末尾。 substring(int beginIndex, int endIndex) 返回一个新字符串,它是此字符串的一个子字符串。该子字符串从指定的beginIndex 处开

JAVA关键字大全(方便版)

abstract boolean break -byte case catch char class continue default do double else extends false final finally float for if implements import instanceof -int - interface long - native new null package private protected public return short static super switch synchronized this throw throws transient try true void volatile while JAVA关键字单词记忆表 1.abstract 解释:抽象,抽象的 用法:类修饰符的一种,可以用来修饰类,方法,被修饰的类不能够实例化(即

不能用new关键字得到对象),被修饰的方法不能够实现。一个抽象类中不一定要有抽象方法,但是一个类里面有抽象方法就一定是抽象类。如果由类要继承抽象类的话,必须要实现里面的抽象方法。构造方法和静态方法不可以修饰为抽象。 abstract 关键字可以修改类或方法。 abstract 类可以扩展(增加子类),但不能直接实例化。 abstract 方法不在声明它的类中实现,但必须在某个子类中重写。 -示例- public abstract class MyClass{ } public abstract String myMethod(); -注释- 采用 abstract 方法的类本来就是抽象类,并且必须声明为 abstract。 abstract 类不能实例化。 仅当 abstract 类的子类实现其超类的所有 abstract 方法时,才能实例化abstract 类的子类。这种类称为具体类,以区别于 abstract 类。 如果 abstract 类的子类没有实现其超类的所有 abstract 方法,该子类也是 abstract 类。 abstract 关键字不能应用于 static、private 或 final 方法,因为这些方法不能被重写,因此,不能在子类中实现。 final 类的方法都不能是 abstract,因为 final 类不能有子类。 1> abstract抽象用在类的声明中来指明一个类是不能被实例化的,但是可以被其他类继承。一个抽象类可以使用抽象方法,抽象方法不需要实现,但是需要在子类中被实现。它的用途是向子类提供通用的信息。抽象类可以包含正常的类包含的任何东西,也就是说,类和实例变量,以及带有任何修饰词的方法。只有抽象类可能有抽象方法。如果一个不是抽象的类包含一个抽象方法,那么将会出现编译错误。 例子:如果下列的一个成立,那么一个有抽象方法: a.它显式的声明了一个abstract方法。 b.它从它的直接父类继承了一个抽象方法。 c.一个直接的类的父借口声明或继承了它的一个方法(这因此必须是abstract)

java常用词汇

Abstract class 抽象类:抽象类是不允许实例化的类,因此一般它需要被进行扩展继承。 Abstract method 抽象方法:抽象方法即不包含任何功能代码的方法。 Access modifier 访问控制修饰符:访问控制修饰符用来修饰Java中类、以及类的方法和变量的访问控制属性。 Anonymous class 匿名类:当你需要创建和使用一个类,而又不需要给出它的名字或者再次使用的使用,就可以利用匿名类。 Anonymous inner classes 匿名内部类:匿名内部类是没有类名的局部内部类。 API 应用程序接口:提供特定功能的一组相关的类和方法的集合。 Array 数组:存储一个或者多个相同数据类型的数据结构,使用下标来访问。在Java中作为对象处理。 Automatic variables 自动变量:也称为方法局部变量method local variables,即声明在方法体中的变量。 Base class 基类:即被扩展继承的类。HP0-538 Blocked state 阻塞状态:当一个线程等待资源的时候即处于阻塞状态。阻塞状态不使用处理器资源 Call stack 调用堆栈:调用堆栈是一个方法列表,按调用顺序保存所有在运行期被调用的方法。 Casting 类型转换 :即一个类型到另一个类型的转换,可以是基本数据类型的转换,也可以是对象类型的转换。 char 字符:容纳单字符的一种基本数据类型。 Child class 子类:见继承类Derived class Class 类:面向对象中的最基本、最重要的定义类型。350-018 Class members 类成员:定义在类一级的变量,包括实例变量和静态变量。 Class methods 类方法:类方法通常是指的静态方法,即不需要实例化类就可以直接访问使用的方法。 Class variable 类变量:见静态变量Static variable

Java关键字大全

abstract - 1 - boolean - 2 - break - 2 - byte - 2 - case - 3 - catch - 3 - char - 4 - class - 4 - continue - 5 - default - 5 - do - 6 - double - 6 - else - 6 - extends - 6 - false - 7 - final - 7 - finally - 7 - float - 8 - for - 8 - if - 8 - implements - 9 - import - 9 - instanceof - 9 - int - 9 - interface - 10 - long - 10 - native - 10 - new - 11 - null - 11 - package - 11 - private - 11 - protected - 12 - public - 12 - return - 13 - short - 13 - static - 13 - super - 14 - switch - 14 - synchronized - 15 - this - 16 - throw - 16 - throws - 16 - transient - 17 - try - 17 - true - 18 - void - 18 - volatile - 18 - while - 18 - 1.abstract abstract 关键字可以修改类或方法。 abstract 类可以扩展(增加子类),但不能直接实例化。 abstract 方法不在声明它的类中实现,但必须在某个子类中重写。 -示例- public abstract class MyClass{ } public abstract String myMethod(); -注释- 采用abstract 方法的类本来就是抽象类,并且必须声明为abstract。 abstract 类不能实例化。 仅当abstract 类的子类实现其超类的所有abstract 方法时,才能实例化abstract 类的子类。这种类称为具体类,以区别于abstract 类。 如果abstract 类的子类没有实现其超类的所有abstract 方法,该子类也是abstract 类。 abstract 关键字不能应用于static、private 或final 方法,因为这些方法不能被重写,因此,不能在子类中实现。 final 类的方法都不能是abstract,因为final 类不能有子类。

JAVA编程关键字和常用单词

Java基础常见英语词汇(共70个) OO: object-oriented ,面向对象 OOP: object-oriented programming,面向对象编程 JDK:Java development kit, java开发工具包 JVM:java virtual machine ,java虚拟机 Compile:编绎 Run:运行 Class:类 Object:对象 System:系统 out:输出 print:打印 line:行 variable:变量 type:类型 operation:操作,运算 array:数组 parameter:参数 method:方法 function:函数 member-variable:成员变量 member-function:成员函数 get:得到 set:设置 public:公有的 private:私有的 protected:受保护的 default:默认 access:访问 package:包 import:导入 static:静态的 void:无(返回类型) extends:继承 parent class:父类 base class:基类 super class:超类 child class:子类

derived class:派生类 override:重写,覆盖 overload:重载 final:最终的,不能改变的 abstract:抽象 interface:接口 implements:实现 exception:异常 Runtime:运行时 ArithmeticException:算术异常ArrayIndexOutOfBoundsException:数组下标越界异常NullPointerException:空引用异常ClassNotFoundException:类没有发现异常NumberFormatException:数字格式异常(字符串不能转化为数字) Catch:捕捉 Finally:最后 Throw:抛出 Throws: (投掷)表示强制异常处理 Throwable:(可抛出的)表示所有异常类的祖先类 Lang:language,语言 Util:工具 Display:显示 Random:随机 Collection:集合 ArrayList:(数组列表)表示动态数组 HashMap: 散列表,哈希表 Swing:轻巧的 Awt:abstract window toolkit:抽象窗口工具包 Frame:窗体 Size:尺寸 Title:标题 Add:添加 Panel:面板 Layout:布局 Scroll:滚动 Vertical:垂直 Horizonatal:水平 Label:标签 TextField:文本框 TextArea:文本域 Button:按钮

java关键字

JA V A的保留关键字 在java中保留关键字是被java本身定义使用的字母组合,具有特殊意义,所以不能用作变量名、方法名以及包名。Java共有51个关键字,中const和goto虽然被保留但未被使用。保留关键字分为8大类: 一、访问控制: 序号保留关键字定义或作用 1 private 私有的 2 protected 受保护的 3 public 公共的 二、类、方法、变量的修饰符: 序号保留关键字定义或作用 4 abstract 声明为抽象 5 class 类 6 extends 扩展、继承 7 final 终极、不可变 8 implements 实现 9 interface 接口 10 native 本地 11 new 新建、创建 12 static 静态 13 strictfp 严格精准 14 synchronized 同步 15 transient 短暂 16 volatile 易失 三、程序控制语句: 序号保留关键字定义或作用 17 break 中断、跳出循环 18 continue 继续 19 return 返回 20 do 运行 21 while 循环 22 if 如果 23 else 那么、反之 24 for 循环 25 instanceof 是否实例 26 switch 开关 27 case 返回开关的结果 28 deault 默认

四、异常处理 序号保留关键字定义或作用 29 catch 处理异常 30 finally 最终都执行 31 throw 抛出一个异常对象 32 throws 声明一个异常可能被抛出 33 try 捕获异常 五、包相关: 序号保留关键字定义或作用 34 import 引入 35 package 包 六、基本类型: 序号保留关键字定义或作用 36 boolean 布尔 37 byte 字节 38 char 字符 39 double 双精度 40 float 单精度 41 int 整型 42 long 长整型 43 short 短整型 44 null 对象的空 45 true 真 46 false 假 null “” 七、变量引用: 序号保留关键字定义或作用 47 super 父类、超类 48 this 本类 49 void 无返回值 八、访问控制保留字(未使用) 序号保留关键字定义或作用 50 const 常量 51 goto 跳转

java常用类知识点总结

java常用类知识点总结 Java常用类 要求: 1、掌握String和StringBuffer的区别,可以熟练使用String和StringBuffer的各 种方法进行相关操作。 2、能够自己编写一个得到日期的操作类,并将日期进行格式化操作。 3、掌握比较器及其基本原理,并可以通过比较器进行对象数组的比较操作。 4、掌握对象克隆技术及其实现 5、能够灵活应用正则表达式对字符串的组成进行判断 6、掌握Math、Random、基本数据类型的包装类的使用 7、描述出Object System对垃圾收集的支持 8、使用NumberFormat、DecimalFormat、BigInteger、BigDecimal进行数字的操 作 String和StringBuffer String的内容一旦声明不可改变,如果要改变,改变的是String的引用地址,如果一个字符串要经常改变,必须使用StringBuffer。 在一个字符串内容需要频繁修改时,使用StringBuffer可以提升操作性能,因为StringBuffer内容可以改变,而String内容不可改变。StringBuffer支持的方法大部分与String类似。 StringBuffer常见用法: (1) 字符串的连接操作

String类可以通过“+“进行字符串的连接,而StringBuffer中却只能使用append方法进行字符串的连接,而且此方法返回一个StringBuffer类的实例,这样就可以采用代码链的形式一直调用append方法。 (2) 在任意位置处为StringBuffer添加内容 可以使用insert方法在指定位置上为StringBuffer添加内容 字符串的反转操作(较为常见的操作,使用reverse方法) (3) 替换指定范围的内容 replace方法可对指定范围的内容进行替换。在String中如果要替换,使用的是replaceAll (4) 字符串截取(使用subString方法从指定范围中截取内容) (5) 删除指定范围的字符串(使用delete方法删除指定范围内容) (6) 查找指定内容是否存在(indexOf查找指定内容,查找到返回内容的位置, 没查到返回-1) 问题:(1)String s = "Hello";s = s + " world!";这两行代码执行后,原始的String对象中的内容到底变了没有, 没有。因为String被设计成不可变(immutable)类,所以它的所有对象都是不可变对象。在这段代码中,s原先指向一个String对象,内容是 "Hello",然后我们对s进行了+操作,那么s所指向的那个对象是否发生了改变呢,答案是没有。这时,s不指向原来那个对象了,而指向了另一个 String对象,内容为"Hello world!",原来那个对象还存在于内存之中,只是s这个引用变量不再指向它了。通过上面的说明,我们很容易导出另一个结论,如果经常对字符串进行各种各样的修改, 或者说,不可预见的修改,那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变,所以对于每一个不同的字符

java中super关键字的三种用法

1.子类的构造函数如果要引用super的话,必须把super放在函数的首位. class Base { Base() { System.out.println("Base"); } } public class Checket extends Base { Checket() { super();//调用父类的构造方法,一定要放在方法的首个语句 System.out.println("Checket"); } public static void main(String argv[]) { Checket c = new Checket(); } } 如果想用super继承父类构造的方法,但是没有放在第一行的话,那么在super 之前的语句,肯定是为了满足自己想要完成某些行为的语句,但是又用了super继承父类的构造方法。那么以前所做的修改就都回到以前了,就是说又成了父类的构造方法了。 2.在Java中,有时还会遇到子类中的成员变量或方法与父类(有时也称父类)中的成员变量或方法同名。因为子类中的成员变量或方法名优先级高,所以子类中的同名成员变量或方法就隐藏了父类的成员变量或方法,但是我们如果想要使用父类中的这个成员变量或方法,就需要用到super. class Country { String name; void value() { name = "China"; } } class City extends Country { String name; void value() { name = "Hefei"; super.value();//不调用此方法时,https://www.doczj.com/doc/8112510943.html,返回的是父类的成员变量的值null System.out.println(name);

Java常见关键字及用法总结

Java常见关键字及用法总结 关键字目录 abstract - 1 - boolean - 2 - break - 2 - byte - 2 - case - 3 - catch - 3 - char - 4 - class - 4 - continue - 5 - default - 5 - do - 6 - double - 6 - else - 6 - extends - 6 - false - 7 - final - 7 - finally - 7 - float - 8 - for - 8 - if - 8 - implements - 9 - import - 9 - instanceof - 9 - int - 9 - interface - 10 - long - 10 - native - 10 -

new - 11 - null - 11 - package - 11 - private - 11 - protected - 12 - public - 12 - return - 13 - short - 13 - static - 13 - super - 14 - switch - 14 - synchronized - 15 - this - 16 - throw - 16 - throws - 16 - transient - 17 - try - 17 - true - 18 - void - 18 - volatile - 18 - while - 18 - 1.abstract abstract 关键字可以修改类或方法。 abstract 类可以扩展(增加子类),但不能直接实例化。 abstract 方法不在声明它的类中实现,但必须在某个子类中重写。-示例- public abstract class MyClass{ } public abstract String myMethod();

java中常用关键字总结

Java中的关键字总结 final关键字 1、用final修饰的类不能被继承,没有子类; 2、用final修饰的方法,方法不能被重写; 3、用final修饰变量,变量的值不能被修改,表示常量,(书写规范:全部字母都要大写;多个单词,可以使用下划线(_)分开;) 注意:如果被final修饰的变量是一个引用类型的数据,那么通过这个引用改变堆空间中的数据,不会报错;如果被final修饰的变量是一个引用类型的数据,那么通过这个引用改变堆空间中的数据,不会报错; 4、final用于成员变量表示该成员变量为常量,不能被修改,必须在变量定义时赋值。 5、final用于局部变量表示该局部变量为常量,不能被修改,可以在变量定义时赋值,也可以先定义变量后赋值。 什么时候用final关键字? 有的时候不想别人重写我的方法就使用final关键字修饰该方法; static关键字 1、static用于成员变量表示该变量只有一份,也就是说静态成员变量属于类而不属于某个具体的类实例对象,所有的类实例对象共享这个静态成员变量;静态函数是不需要对象的,直接可以使用类名来调用; 2、非静态函数可以调用静态函数;静态函数不能调用非静态函数(非静态函数都是通过对象调用的);静态函数不能使用非静态成员变量,但可以使用静态成员变量; 3、静态函数调用时不需要对象的,所以不能使用和对象有关的关键字;(this;super;) 4、构造函数不能使用static修饰(构造函数是创建对象,开辟空间,给所有成员变量赋默认值之后,有JVM调用进栈,用来给对象的成员变量赋初始值的) static用于类,这里指的是内部类,那么在别的地方就可以通过外部类名来引用这个静态的内部类。 5、static还可以用于类的代码块,叫做静态代码块,静态代码块在类加载的时候就执行完毕,而类只加载一次;是在类中独立于类成员的static语句块,可以有多个,位置可以随便放,它不在任何的方法体内,JVM加载类时会执行这些静态的代码块,如果static代码块有多个,JVM将按照它们在类中出现的先

java中的50个关键字

与流程控制相关(13) if:表示条件判断,一般用法if(关系表达式),后跟else或{……} else:条件转折,如if (关系表达式){语句块1}else{语句块2},如果关系表达式的值为true,则执行语句块1,否则执行语句块2.

do……while……:do和while一般一起使用,用于表示循环语句。 do{……}while(关系表达式)……;当关系表达式的值为true是继续循环。 for:用于表示循环,for循环是最常使用的循环,格式for(表达式a; 表达式b; 表达式c)括号里面的书通常用于控制循环的次数,一般会用一个int类型的变量类计数,如(int i=0; i<10; i++)表达式a用于流程控制的开始值,表达式b表示循环终止条件,表达式c用于计数。 switch(条件a)case……:switch和case合起来用于表示条件分支流程。如: while(int c) { case 1: {语句块1} case 2: {语句块2} ……?????? …… case n: {语句块n} default:exit(0); } 如果c为1,则执行语句块1;如果c为2,则执行语句块2;以此类推,如果c为n,则执行语句块n。default表示除case以外出现的情况。default:在switch……case……分支语句可知,default是在所有case条件下都不成立时使用。用于包表示s“rc”文件夹下的当前包;如果用于类,表示只可被本文件内的其它类访问。

break:用于结束本层循环,或跳出某层循环。 continue:用于跳出本次循环,而break跳出本层循环。Break和continue 可以实现类似于C\C++中goto语句的用法: label0: { for (int k = 0; k < 10; k++) { .......... label1: for (int j = 0; j < 10; j++) { ................ break label0;//跳转至label0 } ........... label2: for (int kk = 0; kk < 10; kk++) { .............. break label0;//跳至label2 } } return:返回一个值,通常用于函数中,返回一个具有特定类型的值。如: public int fuction() { int a; …… return a;//返回int型的值 }

Java关键字总结珍藏版(48个)

Java 48个关键字总结珍藏版 1.abstract Java 关键字 abstract 关键字可以修改类或方法。 abstract 类可以扩展(增加子类),但不能直接实例化。 abstract 方法不在声明它的类中实现,但必须在某个子类中重写。 示例 public abstract class MyClass { } public abstract String myMethod(); 注释 采用abstract 方法的类本来就是抽象类,并且必须声明为abstract。abstract 类不能实例化。 仅当abstract 类的子类实现其超类的所有abstract 方法时,才能实例化abstract 类的子类。这种类称为具体类,以区别于abstract 类。 如果abstract 类的子类没有实现其超类的所有abstract 方法,该子类也是abstract 类。 abstract 关键字不能应用于static、private 或final 方法,因为这些方法不能被重写,因此,不能在子类中实现。 final 类的方法都不能是abstract,因为final 类不能有子类。 2.boolean 变量的值可以是true 或false。 示例

boolean valid = true; if (valid) { } 注释 boolean 变量只能以true 或false 作为值。boolean 不能与数字类型相互转换。 包含boolean 操作数的表达式只能包含boolean 操作数。 Boolean 类是boolean 原始类型的包装对象类 3.break 关键字 用于提前退出for、while 或do 循环,或者在switch 语句中用来结束case 块。 示例 for (i=0; i) { break; } } int type = ;

相关主题
文本预览
相关文档 最新文档