Java关键字大全
Java中instanceof关键字的用法总结
Java中instanceof关键字的⽤法总结instanceof是Java的⼀个⼆元操作符，和==，>，<是同⼀类东东。
由于它是由字母组成的，所以也是Java的保留关键字。
它的作⽤是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据java 中的instanceof 运算符是⽤来在运⾏时指出对象是否是特定类的⼀个实例。
instanceof通过返回⼀个布尔值来指出，这个对象是否是这个特定类或者是它的⼦类的⼀个实例。
⽤法：result = object instanceof class参数：Result：布尔类型。
Object：必选项。
任意对象表达式。
Class：必选项。
任意已定义的对象类。
说明：如果 object 是 class 的⼀个实例，则 instanceof 运算符返回 true。
如果 object 不是指定类的⼀个实例，或者 object 是 null，则返回 false。
例⼦如下：复制代码代码如下:package com.instanceoftest;interface A{}class B implements A{}class C extends B {}class instanceoftest {public static void main(String[] args){A a=null;B b=null;boolean res;System.out.println("instanceoftest test case 1: ------------------");res = a instanceof A;System.out.println("a instanceof A: " + res);res = b instanceof B;System.out.println("b instanceof B: " + res);System.out.println("\ninstanceoftest test case 2: ------------------");a=new B();b=new B();res = a instanceof A;System.out.println("a instanceof A: " + res);res = a instanceof B;System.out.println("a instanceof B: " + res);res = b instanceof A;System.out.println("b instanceof A: " + res);res = b instanceof B;System.out.println("b instanceof B: " + res);System.out.println("\ninstanceoftest test case 3: ------------------");B b2=(C)new C();res = b2 instanceof A;System.out.println("b2 instanceof A: " + res);res = b2 instanceof B;System.out.println("b2 instanceof B: " + res);res = b2 instanceof C;System.out.println("b2 instanceof C: " + res);}}/*result:instanceoftest test case 1: ------------------a instanceof A: falseb instanceof B: falseinstanceoftest test case 2: ------------------a instanceof A: truea instanceof B: trueb instanceof A: trueb instanceof B: trueinstanceoftest test case 3: ------------------b2 instanceof A: trueb2 instanceof B: trueb2 instanceof C: trueinstanceof 通常⽤于根据不同的实例调⽤不同的⽅法：⼀、在有继承关系的类中我们可以通过多态来调⽤不同实例中的不同⽅法：例1：有三个类，类名以及它们之间的关系如下Animal (Superclass) Dog(Subclass) Cat(Subclass)则可得出如下对象Animal animal =new Animal (); ====》animal instanceof Animal 返回 trueDog dog=new Dog();====》dog instanceof Dog 返回 trueCat cat=new Cat();====》cat instanceof Cat 返回 trueAnimal dog=new Dog();====》dog instanceof Animal 返回 trueAnimal cat=new Cat();====》cat instanceof Animal 返回 true12 Animal dog=new Dog();3 Animal cat=new Cat();45 List list = new ArrayList();67 list.add(dog);8 list.add(cat);910 Iterator it = list.iterator();11while (it.hasNext()) {12 it.next().animalDo();1314 }在这⾥我们可以在Dog与Cat类中重写Animal中的animalDo⽅法，通过调⽤animalDo⽅法，然后会⾃动根据不同的实例调⽤不同类中的⽅法.⼆、在没有继承关系的类中，我们可以通过instanceof来判断当前实例，然后很据不同实例调⽤不同⽅法：例2：1 Station s = new Station();2 Cell c = new Cell();345 List list = new ArrayList();67 list.add(s);8 list.add(c);91011 Iterator it = list.iterator();12while (it.hasNext()) {13 Object obj = it.next();14if (obj instanceof Station ) {15 Station s1 = (Station ) obj;16 s1.stationDo();17 }18if (obj instanceof Cell ) {19 Cell c1 = (Cell ) obj;20 c1.cellDo();21 }22 }在这⾥我们可以通过instanceof 判断结果，执⾏不同类中的相应动作⽅法（stationDo()、cellDo()）。
java关键字及其作用
java关键字及其作用一、关键字总览:关键字含义abstract 表明类或者成员方法具有抽象属性assert 用来进行程序调试boolean 基本数据类型之一，布尔类型break 提前跳出一个块byte 基本数据类型之一，字节类型case 用在switch语句之中，表示其中的一个分支catch 用在异常处理中，用来捕捉异常char 基本数据类型之一，字符类型class 类const 保留关键字，没有具体含义continue 回到一个块的开始处default 默认，例如，用在switch语句中，表明一个默认的分支do 用在do-while循环结构中double 基本数据类型之一，双精度浮点数类型else 用在条件语句中，表明当条件不成立时的分支enum 枚举extends 表明一个类型是另一个类型的子类型，这里常见的类型有类和接口final 用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变finally 用于处理异常情况，用来声明一个基本肯定会被执行到的语句块float 基本数据类型之一，单精度浮点数类型for 一种循环结构的引导词goto 保留关键字，没有具体含义if 条件语句的引导词implements 表明一个类实现了给定的接口import 表明要访问指定的类或包instanceof 用来测试一个对象是否是指定类型的实例对象int 基本数据类型之一，整数类型interface 接口long 基本数据类型之一，长整数类型native 用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN 语言）实现的new 用来创建新实例对象package 包private 一种访问控制方式：私用模式protected 一种访问控制方式：保护模式public 一种访问控制方式：共用模式return 从成员方法中返回数据short 基本数据类型之一,短整数类型static 表明具有静态属性strictfp 用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范super 表明当前对象的父类型的引用或者父类型的构造方法switch 分支语句结构的引导词synchronized 表明一段代码需要同步执行this 指向当前实例对象的引用throw 抛出一个异常throws 声明在当前定义的成员方法中所有需要抛出的异常transient 声明不用序列化的成员域try 尝试一个可能抛出异常的程序块void 声明当前成员方法没有返回值volatile 表明两个或者多个变量必须同步地发生变化while 用在循环结构中二、详细解释1. 访问控制1) private 私有的private 关键字是访问控制修饰符，可以应用于类、方法或字段（在类中声明的变量）。
Java中英翻译
abstract (关键字) 抽象['.bstr.kt]access vt.访问,存取['.kses]'(n.入口,使用权)algorithm n.算法['.lg.riem]Annotation [java]代码注释[.n.u'tei..n]anonymous adj.匿名的[.'n.nim.s]'(反义：directly adv.直接地,立即[di'rektli, dai'rektli])apply v.应用,适用[.'plai]application n.应用,应用程序[,.pli'kei..n]' (application crash 程序崩溃) arbitrary a.任意的['ɑ:bitr.ri]argument n.参数;争论,论据['ɑ:gjum.nt]'(缩写args)assert (关键字) 断言[.'s.:t] ' (java 1.4 之后成为关键字)associate n.关联(同伴,伙伴) [.'s.u.ieit]attribute n.属性(品质,特征) [.'tribju:t]boolean (关键字) 逻辑的, 布尔型call n.v.调用; 呼叫; [k.:l]circumstance n.事件(环境,状况) ['s.:k.mst.ns]crash n.崩溃,破碎[kr..]cohesion内聚,黏聚,结合[k.u'hi:..n](a class is designed with a single, well-focoused purpose. 应该不止这点) command n. 命令,指令[k.'mɑ:nd](指挥, 控制) (command-line 命令行)Comments [java]文本注释['k.ments]compile [java] v.编译[k.m'pail]' Compilation n.编辑[,k.mpi'lei..n] const (保留字)constant n. 常量, 常数, 恒量['k.nst.nt]continue (关键字)coupling耦合,联结['k.pli.]making sure that classes know about other classes only through their APIs. declare [java]声明[di'kl..]default (关键字) 默认值; 缺省值[di'f.:lt]delimiter定义符; 定界符Encapsulation[java]封装(hiding implementation details)Exception [java]例外; 异常[ik'sep..n]entry n.登录项, 输入项, 条目['entri]enum (关键字)execute vt.执行['eksikju:t]exhibit v.显示, 陈列[ig'zibit]exist存在, 发生[ig'zist] '(SQL关键字exists)extends (关键字) 继承、扩展[ik'stend]false (关键字)final (关键字) finally (关键字)fragments段落; 代码块['fr.gm.nt]FrameWork [java]结构,框架['freimw.:k]Generic [java]泛型[d.i'nerik]goto (保留字) 跳转heap n.堆[hi:p]implements (关键字) 实现['implim.nt]import (关键字) 引入(进口,输入)Info n.信息(information [,inf.'mei..n] )Inheritance [java]继承[in'herit.ns] (遗传,遗产)initialize预置初始化[i'iz]instanceof (关键字) 运算符，用于引用变量，以检查这个对象是否是某种类型。
Java中的关键字有哪些？
Java中的关键字有哪些？1）48个关键字：abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。
1.访问修饰符的关键字（3个）public（公有的）：可跨包protected (受保护的)：当前包内可⽤private (私有的)：当前类可⽤2.定义类、接⼝、抽象类和实现接⼝、继承类的关键字、实例化对象（6个）class (类)：public class A(){}花括号⾥是已实现的⽅法体，类名需要与⽂件名相同interface (接⼝)：public interface B(){}花括号⾥有⽅法体，但没有实现，⽅法体句⼦后⾯是英⽂分号“;”结尾 abstract (声明抽象)：public abstract class C(){}介于类与接⼝中间，可以有，也可以没有已经实现的⽅法体implements (实现)：⽤于类或接⼝，实现接⼝public class A interface B(){} extends (继承)：⽤于类继承类public class A extends D(){}new (创建新对象)：A a=new A();A表⽰⼀个类3.包的关键字（2个）import (引⼊包的关键字)：当使⽤某个包的⼀些类时，仅需要类名，即可⾃动插⼊类所在的包package (定义包的关键字)：将所有相关的类放在⼀个包类以便查找修改等4.数据类型的关键字（9个）byte (字节型)：8bitchar (字节型)：16bitboolean (布尔型)：--short (短整型)：16bitint (整型)：32bitfloat (浮点型)：32bitlong (长整型)：64bitdouble (双精度)：64bitvoid (⽆返回)：public void A(){}其他需要反回的经常与return连⽤5.条件循环（流程控制）（12个）if (如果) ：if（条件语句｛执⾏代码｝如果条件语句成⽴，就开始执⾏｛｝⾥⾯的内容else (否则，或者) ：常与if连⽤，⽤法相同：if(...){...}else{...}while (当什么时候)：while（条件语句）｛执⾏代码｝for（满⾜三个条件时）：for(初始化循环变量；判断条件；循环变量值｛｝switch (选择结构)：switch(表达式）｛case常量表达式1：语句1；...case常量表达式2；语句2；default:语句；｝default就是如果没有匹配的case就执⾏它，default并不是必须的。
详解Java中的final关键字
ｐ ｂｉ ｆ ａ ｖｉ ｐｉｔ｛ 使 用 ｆ ａ 声 明 的 方 法 不 能 ｕｌ ｉ ｌ ｏｄ ｒ ０／ ｃ ｎ ｎ ／ ｉ ｌ ｎ
被重 写
［ ］ 万 军， 少京 Ｊｖ 程 序 设 计 ｆ ． 京 ： 华 大 学 出版 １刘 郑 ａａ Ｍ］ 北 清
社 ．０ ９ ２０．
｝ 如果 希 望 在 整个 继 承 期 间 ， 个 方 法 是 不 允 许 改 变 的 ， 以 这 可
｛ｒ ａ ｎｌＳ ｎ Ｎ Ｏ “ Ｅ Ｌ ； ｎ ｌ 明 的 变 量 就 ｐ ｖｔ ｆ ａ ｔ ｇ Ｉ Ｆ ＝ Ｈ Ｌ Ｏ”／ ａ 声 ｉ ｅｉ ｒ ｉ ／ ｉ ｆ
是 常量
将 这 个 方 法 用 ｆ ａ 来 修 饰 。从 安 全 的 角 度 来 看 ，ｎｌ 饰 的 方 ｉ ｌ ｎ ｉ ｆ ａ修 法 使 得 恶 意 代 码 攻 击 者 不 能 通 过 改 写 父 类 中的 方 法 来 窃 取 或 者
高 运行 时 的效 率 。 二 、 ｎ 关 键 宇修 饰 方 法 ｉｌ ｆａ
有些 时候 ， 一 个 方 法 提 供 的 功 能 已 经 满 足 当 前 要 求 ， 需 当 不 要 进行 扩 展 ，并 且 不 允 许 任 何 从 此 类 继 承 的子 类 来 重 写 这 个 方 法 时 ， 可 以是 使 用 ｆ ａ 修 饰 该 方法 。如 Ａ Ｉ 中的 许 多 方 法 ， 就 ｉ ｌ ｎ Ｐ类 如 ｐｉｔ ； ｒ ｔ ０ 以 及 Ｍ ｔ ｒ ０￣ ｐｉ ｌ ， ｎ ＇ ｎｎ ｌ ｆ ａｈ类 中 的 所 有 方 法 都 定 义 为 ｆ ａ ｉ ｌ ｎ 方 法 。 具 体 应用 软件 开 发 中 ， 些 执 行 特 殊 性 运算 和操 作 的方 在 一 法 ， 可 以定 义 为 ｆ ａ 方 法 。 是 ， 类 仍 然 可 以继 承 这个 方法 ， 都 ｉ ｌ ｎ 但 子 即 可 以直 接 使 用 。 声 明类 中 ， 个 ｆ ａ 方 法 只 被实 现 一 次 。 在 一 ｉ ｌ ｎ 当 在 子类 中试 图 重 写被 ｆ ａ修 饰 的方 法 时 将 会 得 到 一个 错 误 的编 ｉ ｌ ｎ 译 ， 如： 例
Java中的两个关键字——super、this
Java中的两个关键字——super、thisJava中的两个关键字——super、this ⼀、supersuper 是java中⽅的⼀个关键字，⽤它可以引⽤⽗类中的成员：super可⽤于访问⽗类中定义的属性super可⽤于调⽤⽗类中定义的成员⽅法super可⽤于在⼦类构造器中调⽤⽗类的构造器使⽤super关键字注意事项：1、当⼦类和⽗类都有同名的属性时，在⼦类中如果要使⽤⽗类的属性 super . 属性2、 super只能应⽤在成员⽅法和构造⽅法中，不能⽤在静态⽅法中（和this是⼀样的）3、如果在构造⽅法中使⽤必须放在第⼀⾏4、在构造⽅法中this()和super()不能同时出现super没有什么需要解释的地⽅，我们⽤代码来看看super具体的⼀些强⼤功能吧⽰例⼀、使⽤super调⽤基类的属性：public class Father { int num=20;}public class Child extends Father{ int num; public void print(){ num=10; super.num=30; System.out.println("num="+num); System.out.println("="+super.num); }}public class Test { public static void main(String[] args) { Child xm=new Child(); xm.print(); }}运⾏结果：⽰例⼆、使⽤super调⽤基类中的构造⽅法：public class Father { int num; public Father() { System.out.println("⽗类中的⽆参构造⽅法---"); } public Father(int num){ System.out.println("⽗类中的有参的构造⽅法----"+num); }}public class Child extends Father{ int num; public Child() { super(30); System.out.println("⼦类⽆参构造⽅法---"); } public Child(int num) { this.num = num; System.out.println("⼦类中的有参的构造⽅法---"+num); }}解释⼀下上⾯的这段代码：在Child类中的第⼀个构造函数⾥⾯，super(30);它会去调⽤⽗类中嗲有⼀个int型参数的构造⽅法。
java中 static,final,transient,volatile,Volatile关键字的作用
缓存行非64字节宽的处理器（自行调整补充字节长度，原理一样）
共享变量不会被频繁的写。追加字节会导致CPU读取性能下降，如果共享变量写的频率很低，那么被锁的几率也很小，就没必要避免相互锁定了
Volatile无法保证原子性
volatile是一种“轻量级的锁”，它能保证锁的可见性，但不能保证锁的原子性。
由于自增操作是不具备原子性的，它包括读取变量的原始值、进行加1操作、写入工作内存。那么就是说自增操作的三个子操作可能会分割开执行，就有可能导致下面这种情况出现：
假如某个时刻变量inc的值为10，线程1对变量进行自增操作，线程1先读取了变量inc的原始值，然后线程1被阻塞了；然后线程2对变量进行自增操作，线程2也去读取变量inc的原始值，由于线程1只是对变量inc进行读取操作，而没有对变量进行修改操作，所以不会导致线程2的工作内存中缓存变量inc的缓存行无效，所以线程2会直接去主存读取inc的值，发现inc的值时10，然后进行加1操作，并把11写入工作内存，最后写入主存。
如下面的例子
public class Test {
public volatile int inc = 0;
public void increase() {
inc++;
}
public static void main(String[] args) {
追加字节优化Volatile性能
在某些情况下，通过将共享变量追加到64字节可以优化其使用性能。
在JDK 7 的并发包里，有一个队列集合类LinkedTransferQueue，它在使用volatile变量时，用一种追加字节的方式来优化队列出队和入队的性能。队里定义了两个共享结点，头结点和尾结点，都由使用了volatile的内部类定义，通过将两个共享结点的字节数增加到64字节来优化效率，具体分析如下：
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默认错误处理try捕获异常catch处理异常throw抛出一个异常对象throws声明一个异常可能被抛出包相关import引入package包基本类型boolean布尔型byte字节型char字符型double双精度float浮点int整型long长整型short短整型null空TRUE真FALSE假变量引用super父类,超类this本类void无返回值保留字goto跳转const静态native本地详细说明private 关键字是访问控制修饰符，可以应用于类、方法或字段（在类中声明的变量）。
只能在声明 private（内部）类、方法或字段的类中引用这些类、方法或字段。
在类的外部protected 关键字是可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。
可以在声明 protected 类、方法或字段的类、同一个包中的其他任何类以及任何子类（无public 关键字是可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。
可能只会在其他任何类或包中引用 public 类、方法或字段。
所有类成员的默认访问范围都是abstract关键字可以修改类或方法。
abstract类可以扩展（增加子类），但不能直接实例化。
abstract方法不在声明它的类中实现，但必须在某个子类中重写。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
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.abstractabstract 关键字可以修改类或方法。
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){<statement>}-注释-boolean 变量只能以true 或false 作为值。
boolean 不能与数字类型相互转换。
包含boolean 操作数的表达式只能包含boolean 操作数。
Boolean 类是boolean 原始类型的包装对象类。
3.break用于提前退出for、while 或do 循环，或者在switch 语句中用来结束case 块。
-示例-for (i=0; i<max; i++){if (<loop finished early>){break;}}int type = <some value>;switch (type){case 1:<statement>break;case 2:<statement>break;default:<statement>}-注释-break 总是退出最深层的while、for、do 或switch 语句。
4.bytebyte 是Java 原始类型。
byte 可存储在[-128, 127] 范围以内的整数值。
-示例-byte b = 124;-注释-Byte 类是byte 原始类型的包装对象类。
它定义代表此类型的值的范围的MIN_VALUE 和MAX_VALUE 常量。
Java 中的所有整数值都是32 位的int 值，除非值后面有l 或L（如235L），这表示该值应解释为long。
5.case用来标记switch 语句中的每个分支。
-示例-int arg = <some value>;switch (arg){case 1:<statements>break;case 2:<statements>break;default:<statements>break;}-注释-case 块没有隐式结束点。
break 语句通常在每个case 块末尾使用，用于退出switch 语句。
如果没有break 语句，执行流将进入所有后面的case 和/或default 块。
6.catchcatch 关键字用来在try-catch 或try-catch-finally 语句中定义异常处理块。
-示例-try{<可能引发异常的块>}catch (<ng.Exception 或子类> e){<处理异常e 的代码>}try{<可能引发其他异常的块>}catch (FooException e){<处理FooException e 的代码>}catch (BarException e){<处理BarException e 的代码>}try{<可能引发异常的块>}catch (<ng.Exception 或子类> e){<处理异常e 的代码>}finally{<有异常或无异常情况下都执行的语句>}-注释-开始和结束标记{ 和} 是catch 子句语法的一部分，即使该子句只包含一个语句，也不能省略这两个标记。
每个try 块都必须至少有一个catch 或finally 子句。
如果某个特定异常类未被任何catch 子句处理，该异常将沿着调用栈递归地传播到下一个封闭try 块。
如果任何封闭try 块都未捕获到异常，Java 解释器将退出，并显示错误消息和堆栈跟踪信息。
7.charchar 是Java 原始类型。
char 变量可以存储一个Unicode 字符。
-示例-char delimiter = ';';-注释-可以使用下列char 常量：\b - 空格\f - 换页\n - 换行\r - 回车\t - 水平制表符\' - 单引号\" - 双引号\" - 反斜杠\xxx - 采用xxx 编码的Latin-1 字符。
\x 和\xx 均为合法形式，但可能引起混淆。
\uxxxx - 采用十六进制编码xxxx 的Unicode 字符。
Character 类包含一些可用来处理char 变量的static 方法，这些方法包括isDigit()、isLetter()、isWhitespace() 和toUpperCase()。
char 值没有符号。
8.classclass 关键字用来声明新的Java 类，该类是相关变量和/或方法的集合。
类是面向对象的程序设计方法的基本构造单位。
类通常代表某种实际实体，如几何形状或人。
类是对象的模板。
每个对象都是类的一个实例。
要使用类，通常使用new 操作符将类的对象实例化，然后调用类的方法来访问类的功能。
-示例-public class Rectangle{float width;float height;public Rectangle(float w, float h){width = w;height = h;}public float getWidth(){return width;}public float getHeight(){return height;}}9.continuecontinue 关键字用来跳转到for、while 或do 循环的下一个迭代。
-示例-for (i=0; i<max; i++){<statements>if (<done with this iteration>){continue;}<statements>}-注释-continue 总是跳到最深层while、for 或do 语句的下一个迭代。
10.defaultdefault 关键字用来标记switch 语句中的默认分支。
-示例-int arg = <some value>;switch (arg){case 1:<statements>break;case 2:<statements>break;default:<statements>break;}-注释-default 块没有隐式结束点。
break 语句通常在每个case 或default 块的末尾使用，以便在完成块时退出switch 语句。
如果没有default 语句，其参数与任何case 块都不匹配的switch 语句将不执行任何操作。
11.dodo 关键字用于指定一个在每次迭代结束时检查其条件的循环。
-示例-do{<statements>}while (!found);-注释-do 循环体至少执行一次。
条件表达式后面必须有分号。
12.doubledouble 是Java 原始类型。
double 变量可以存储双精度浮点值。
-示例-double ratio = .01;double diameter = 6.15;double height = 1.35E03; // 1.35 * 103 或1350.0double height = 1e-2; // 1.0 * 10-2 或0.01-注释-由于浮点数据类型是实际数值的近似值，因此，一般不要对浮点数值进行是否相等的比较。
Java 浮点数值可代表无穷大和NaN（非数值）。
Double 包装对象类用来定义常量MIN_VALUE、MAX_VALUE、NEGATIVE_INFINITY、POSITIVE_INFINITY 和NaN。
13.elseelse 关键字总是在if-else 语句中与if 关键字结合使用。
else 子句是可选的，如果if 条件为false，则执行该子句。
-示例-if (condition){<statements>}else{<statements>}14.extendsextends 关键字用在class 或interface 声明中，用于指示所声明的类或接口是其名称后跟有extends 关键字的类或接口的子类。