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 类不能有子类。
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 if ( break; } } int type = switch (type){ case 1: break; case 2: break; default: } -注释- break 总是退出最深层的while、for、do 或switch 语句。 4.byte byte 是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 = switch (arg){ case 1: break; case 2: break; default: break; } -注释- case 块没有隐式结束点。break 语句通常在每个case 块末尾使用，用于退出switch 语句。 如果没有break 语句，执行流将进入所有后面的case 和/或default 块。 6.catch catch 关键字用来在try-catch 或try-catch-finally 语句中定义异常处理块。 -示例- try{ <可能引发异常的块> } catch ( <处理异常e 的代码> } try{ <可能引发其他异常的块> } catch (FooException e){ <处理FooException e 的代码> } catch (BarException e){ <处理BarException e 的代码> } try{ <可能引发异常的块> } catch ( <处理异常e 的代码> } finally{ <有异常或无异常情况下都执行的语句> } -注释- 开始和结束标记{ 和} 是catch 子句语法的一部分，即使该子句只包含一个语句，也不能省略这两个标记。 每个try 块都必须至少有一个catch 或finally 子句。 如果某个特定异常类未被任何catch 子句处理，该异常将沿着调用栈递归地传播到下一个封闭try 块。如果任何封闭try 块都未捕获到异常，Java 解释器将退出，并显示错误消息和堆栈跟踪信息。 7.char char 是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.class class 关键字用来声明新的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.continue continue 关键字用来跳转到for、while 或do 循环的下一个迭代。 -示例- for (i=0; i if ( continue; } } -注释- continue 总是跳到最深层while、for 或do 语句的下一个迭代。 10.default default 关键字用来标记switch 语句中的默认分支。 -示例- int arg = switch (arg){ case 1: break; case 2: break; default: break; } -注释- default 块没有隐式结束点。break 语句通常在每个case 或default 块的末尾使用，以便在完成块时退出switch 语句。 如果没有default 语句，其参数与任何case 块都不匹配的switch 语句将不执行任何 操作。 11.do do 关键字用于指定一个在每次迭代结束时检查其条件的循环。 -示例- do{ } while (!found); -注释- do 循环体至少执行一次。 条件表达式后面必须有分号。 12.double double 是Java 原始类型。 double 变量可以存储双精度浮点值。 -示例- double ratio = .01; double diameter = 6.15; double height = 1.35E03; // 1.35 * 103 或1350.0 double height = 1e-2; // 1.0 * 10-2 或0.01 -注释- 由于浮点数据类型是实际数值的近似值，因此，一般不要对浮点数值进行是否相等的比较。 Java 浮点数值可代表无穷大和NaN（非数值）。Double 包装对象类用来定义常量MIN_VALUE、MAX_VALUE、NEGATIVE_INFINITY、POSITIVE_INFINITY 和NaN。 13.else else 关键字总是在if-else 语句中与if 关键字结合使用。else 子句是可选的，如果if 条件为false，则执行该子句。 -示例- if (condition){ } else{ } 14.extends extends 关键字用在class 或interface 声明中，用于指示所声明的类或接口是其名称后跟有extends 关键字的类或接口的子类。 -示例- public class Rectangle extends Polygon{ } -注释- 在上例中，Rectangle 类继承Polygon 类的所有public 和protected 变量和方法。 Rectangle 类可以重写Polygon 类的任何非final 方法。 一个类只能扩展一个其他类。 15.false false 关键字代表boolean 变量的两个合法值之一。 -示例- boolean isComplete = false; 16.final final 关键字可以应用于类，以指示不能扩展该类（不能有子类）。 final 关键字可以应用于方法，以指示不能重写任何子类中的方法。 -示例- public final class MyFinalClass{ } public class MyClass{ public final String myFinalMethod() { } } -注释- 一个类不能同时是abstract 又是final。abstract 意味着必须扩展类，final 意味着不能扩展类。 一个方法不能同时是abstract 又是final。abstract 意味着必须重写方法，final 意味着不能重写方法。 17.finally finally 关键字用来定义始终在try-catch-finally 语句中执行的块。 finally 块通常包含清理代码，用在部分执行try 块后恢复正常运行。 -示例- try{ <可能引发异常的块> } catch ( <处理异常e 的代码> } finally{ <有异常或无异常情况下都执行的语句> } -注释- 开始和结束标记{ 和} 是finally 子句语法的一部分，即使该子句只包含一个语句，也不能省略这两个标记。 每个try 块都必须至少有一个catch 或finally 子句。 如果执行try 块的任何部分，不论是否出现异常，也不论try 或catch 块是否包含return、continue 或break 语句，都一定会执行finally 块中的代码。 如果不出现异常，控件将跳过try 块，进入finally 块。 如果在执行try 块期间出现异常，并且相应的catch 块包含break、continue 或return 语句，控件将首先穿过finally 块，之后再执行break、continue 或return。 18.float float 是Java 原始类型。 float 变量可以存储单精度浮点值。 -示例- float ratio = .01; float diameter = 6.15; float height = 1.35E03; // 1.35 * 103 或1350.0 float height = 1e-2; // 1.0 * 10-2 或0.01 -注释- 使用此关键字时应遵循下列规则： Java 中的浮点文字始终默认为双精度。要指定单精度文字值，应在数值后加上f 或F，如0.01f。 由于浮点数据类型是实际数值的近似值，因此，一般不要对浮点数值进行是否相等的比较。 Java 浮点数值可代表无穷大和NaN（非数值）。Float 包装对象类用来定义常量MIN_VALUE、MAX_VALUE、NEGATIVE_INFINITY、POSITIVE_INFINITY 和NaN。 19.for for 关键字用于指定一个在每次迭代结束前检查其条件的循环。 -示例- int i; for (i=0; i } -注释- for 语句的形式为for(initialize; condition; increment) 控件流进入for 语句时，将执行一次initialize 语句。 每次执行循环体之前将计算condition 的结果。如果condition 为true，则执行循环体。 每次执行循环体之后，在计算下一个迭代的condition 之前，将执行increment 语句。 20.if if 关键字指示有条件地执行代码块。条件的计算结果必须是布尔值。 -示例- if (condition){ } if (condition){ } else{ } -注释- if 语句可以有可选的else 子句，该子句包含条件为false 时将执行的代码。 包含boolean 操作数的表达式只能包含boolean 操作数。 21.implements implements 关键字在class 声明中使用，以指示所声明的类提供了在implements 关键字后面的名称所指定的接口中所声明的所有方法的实现。 -示例- public class Truck implements IVehicle{ } -注释- 在上例中，Truck 类必须提供在IVehicle 接口中所声明的所有方法的实现。 否则，Truck 类将是独立的；它可以声明其他方法和变量，并扩展另一个类。 一个类可以实现多个接口。 22.import import 关键字使一个包中的一个或所有类在当前Java 源文件中可见。可以不使用完全限定的类名来引用导入的类。 -示例- import java.io.File; import https://www.doczj.com/doc/4e1098524.html,.*; -注释- 当多个包包含同名的类时，许多Java 程序员只使用特定的import 语句（没有“*”）来避免不确定性。 23.instanceof instanceof 关键字用来确定对象所属的类。 -示例- if (node instanceof TreeNode){ } -注释- 在上例中，如果node 是TreeNode 类的实例，或者是TreeNode 的子类的实例，则instanceof 表达式的值将为true。 24.int int 是Java 原始类型。 int 变量可以存储32 位的整数值。 -示例- int number = 5; int octalNumber = 0377; int hexNumber = 0xff; -注释- Integer 类是int 原始类型的包装对象类。它定义代表此类型的值的范围的MIN_VALUE 和MAX_VALUE 常量。 Java 中的所有整数值都是32 位的int 值，除非值后面有l 或L（如235L），这表示该值应解释为long。 25.interface interface 关键字用来声明新的Java 接口，接口是方法的集合。 接口是Java 语言的一项强大功能。任何类都可声明它实现一个或多个接口，这意味着它实现了在这些接口中所定义的所有方法。 -示例- public interface IPolygon{ public float getArea(); public int getNumberOfSides(); public int getCircumference(); } -注释- 实现了接口的任何类都必须提供在该接口中的所有方法的实现。 一个类可以实现多个接口。 26.long long 是Java 原始类型。 long 变量可以存储64 位的带符号整数。 -示例- long number = 5; long anotherNumber = 34590L; long octalNumber = 0377; long hexNumber = 0xffl; -注释- Long 类是long 原始类型的包装对象类。它定义代表此类型的值的范围的MIN_VALUE 和MAX_VALUE 常量。 Java 中的所有整数值都是32 位的int 值，除非值后面有l 或L（如235L），这表示该值应解释为long。 27.native native 关键字可以应用于方法，以指示该方法是用Java 以外的语言实现的。 -示例- native String getProcessorType(); -注释- Native 方法不在此文档的讨论范围内。 28.new new 关键字用于创建类的新实例。 -示例- String sName = new String(); Float fVal = new Float(0.15); -注释- new 关键字后面的参数必须是类名，并且类名的后面必须是一组构造方法参数（必须带括号）。 参数集合必须与类的构造方法的签名匹配。 = 左侧的变量的类型必须与要实例化的类或接口具有赋值兼容关系。 29.null null 是Java 的保留字，表示无值。 -示例- Integer i; i = null; String s; if (s != null){ } -注释- 将null 赋给非原始变量相当于释放该变量先前所引用的对象。 不能将null 赋给原始类型（byte、short、int、long、char、float、double、boolean）变量。 30.package package 关键字指定在Java 源文件中声明的类所驻留的Java 包。 -示例- package com.mycompany; public class MyClass{ } -注释- package 语句（如果出现）必须是Java 源文件中的第一个非-注释-性文本。 在上面的-示例-中，MyClass 类的完全限定类名是com.mycompany.MyClass。 如果Java 源文件不包含package 语句，在该文件中定义的类将位于“默认包”中。请注意，不能从非默认包中的类引用默认包中的类。 31.private private 关键字是访问控制修饰符，可以应用于类、方法或字段（在类中声明的变量）。 -示例- public class MyPublicClass{ private class MyPrivateClass{ } private int i; private String myMethod(){ } } -注释- 只能在声明private（内部）类、方法或字段的类中引用这些类、方法或字段。在类的外部或者对于子类而言，它们是不可见的。 所有类成员的默认访问范围都是package 访问，也就是说，除非存在特定的访问控制修饰符，否则，可以从同一个包中的任何类访问类成员。 32.protected protected 关键字是可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。 -示例- public class MyPublicClass{ protected class MyPrivateClass{ } protected int i; protected String myMethod(){ } } -注释- 可以在声明protected 类、方法或字段的类、同一个包中的其他任何类以及任何子类（无论子类是在哪个包中声明的）中引用这些类、方法或字段。 所有类成员的默认访问范围都是package 访问，也就是说，除非存在特定的访问控制修饰符，否则，可以从同一个包中的任何类访问类成员。 33.public public 关键字是可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。 -示例- public class MyPublicClass{ public class MyPrivateClass{ } public int i; public String myMethod(){ } } -注释- 可能只会在其他任何类或包中引用public 类、方法或字段。 所有类成员的默认访问范围都是package 访问，也就是说，除非存在特定的访问控制修饰符，否则，可以从同一个包中的任何类访问类成员。 34.return return 关键字会导致方法返回到调用它的方法，从而传递与返回方法的返回类型匹配的值。 -示例- public void myVoidMethod(){ return; } public String myStringMethod(){ String s = "my response"; return s; } public int myIntMethod(){ int i = 5; return(i); } -注释- 如果方法具有非void 的返回类型，return 语句必须具有相同或兼容类型的参数。 返回值两侧的括号是可选的。 35.short short 是Java 原始类型。 short 变量可以存储16 位带符号的整数。 -示例- short number = 5; short octalNumber = 0077; short hexNumber = 0xff; -注释- Short 类是short 原始类型的包装对象类。它定义代表此类型的值的范围的MIN_VALUE 和MAX_VALUE 常量。 Java 中的所有整数值都是32 位的int 值，除非值后面有l 或L（如235L），这表示该值应解释为long。 36.static static 关键字可以应用于内部类（在另一个类中定义的类）、方法或字段（类的成员变量）。 -示例- public class MyPublicClass{ public final static int MAX_OBJECTS = 100; static int _numObjects = 0; static class MyStaticClass{ } static int getNumObjects(){ } } -注释- 通常，static 关键字意味着应用它的实体在声明该实体的类的任何特定实例外部可用。 static（内部）类可以被其他类实例化和引用（即使它是顶级类）。在上面的-示例-中，另一个类中的代码可以实例化MyStaticClass 类，方法是用包含它的类名来限定其名称，如MyClass.MyStaticClass。 static 字段（类的成员变量）在类的所有实例中只存在一次。 可以从类的外部调用static 方法，而不用首先实例化该类。这样的引用始终包括类名作为方法调用的限定符。在上面的示例中，MyClass 类外部的代码以MyClass.getNumObjects() 的形式调用getNumObjects() static 方法。 模式： public final static 通常用于声明可以在类的外部使用的类常量。在引用这样的类常量时需要用类名加以限定。在上面的-示例-中，另一个类可以用MyClass.MAX_OBJECTS 形式来引用MAX_OBJECTS 常量。 37.super super 关键字用于引用使用该关键字的类的超类。 -示例- public class MyClass{ public MyClass(String arg){ super(arg); } public String myStringMethod(){ return super.otherStringMethod(); } } -注释- 作为独立语句出现的super 表示调用超类的构造方法。 super. 38.switch switch 语句用于基于某个表达式选择执行多个代码块中的某一个。 -示例- int arg = switch (arg){ case 1: break; case 2: break; default: break; } char arg = switch (arg){ case 'y': case 'Y': break; case 'n': case 'N': break; default: break; } -注释- switch 条件的计算结果必须等于byte、char、short 或int。 case 块没有隐式结束点。break 语句通常在每个case 块末尾使用，用于退出switch 语句。 如果没有break 语句，执行流将进入所有后面的case 和/或default 块。 39.synchronized synchronized 关键字可以应用于方法或语句块，并为一次只应由一个线程执行的关键代码段提供保护。 -示例- public class MyClass{ public synchronized static String mySyncStaticMethod(){ } public synchronized String mySyncMethod(){ } } public class MyOtherClass{ Object someObj; public String myMethod(){ synchronized (someObj){ } } } -注释- synchronized 关键字可防止代码的关键代码段一次被多个线程执行。 如果应用于静态方法（如上例中的MySyncStaticMethod），那么，当该方法一次由一个线程执行时，整个类将被锁定。 如果应用于实例方法（如上例中的MySyncMethod），那么，当该方法一次由一个线程访问时，该实例将被锁定。 如果应用于对象或数组，当关联的代码块一次由一个线程执行时，对象或数组将被锁定。 40.this this 关键字用于引用当前实例。 -示例- public class MyClass{ int number; public MyClass(int number){ this.number = number; } } -注释- 当引用可能不明确时，可以使用this 关键字来引用当前的实例。 在上面的-示例-中，构造方法参数number 与类的成员变量同名。this.number 明确表示MyClass 的该实例的number 成员变量。 41.throw throw 关键字用于引发异常。 -示例- import java.io.IOException; public class MyClass{ public method readFile(String filename) throws IOException{ if (error){ throw new IOException("error reading file"); } } } -注释- throw 语句将https://www.doczj.com/doc/4e1098524.html,ng.Throwable 作为参数。Throwable 在调用栈中向上传播，直到被适当的catch 块捕获。 引发非RuntimeException 异常的任何方法还必须在方法声明中使用throws 修饰符来声明它引发的异常。 42.throws throws 关键字可以应用于方法，以便指出方法引发了特定类型的异常。 -示例- import java.io.IOException; public class MyClass{ public method readFile(String filename) throws IOException{ if (error){ throw new IOException("error reading file"); } } } -注释- throws 关键字将逗号分隔的https://www.doczj.com/doc/4e1098524.html,ng.Throwables 列表作为参数。 引发非RuntimeException 异常的任何方法还必须在方法声明中使用throws 修饰符来声明它引发的异常。 要在try-catch 块中包含带throws 子句的方法的调用，必须提供该方法的调用者。 43.transient transient 关键字可以应用于类的成员变量，以便指出该成员变量不应在包含它的类实例已序列化时被序列化。 -示例- public class MyClass{ private transient String password; } 44.try try 关键字用于包含可能引发异常的语句块。 -示例- try{ <可能引发异常的块> } catch ( <处理异常e 的代码> } try{ <可能引发其他异常的块> } catch (FooException e){ <处理FooException e 的代码> } catch (BarException e){ <处理BarException e 的代码> } try{ <可能引发异常的块> } catch ( <处理异常e 的代码> } finally{ <有异常或无异常情况下都执行的语句> } -注释- 每个try 块都必须至少有一个catch 或finally 子句。 如果某个特定异常类未被任何catch 子句处理，该异常将沿着调用栈递归地传播到下一个封闭try 块。如果任何封闭try 块都未捕获到异常，Java 解释器将退出，并显示错误消息和堆栈跟踪信息。 45.true true 关键字表示boolean 变量的两个合法值中的一个。 -示例- boolean isComplete = true; 46.void void 关键字表示null 类型。 -示例- public class MyClass{ public void doSomething(){ return; } } -注释- void 可以用作方法的返回类型，以指示该方法不返回值。 47.volatile volatile 关键字用于表示可以被多个线程异步修改的成员变量。 注意：volatile 关键字在许多Java 虚拟机中都没有实现。 -示例- public class MyClass{ volatile int sharedValue; } -注释- volatile 的目标用途是为了确保所有线程所看到的指定变量的值都是相同的。 48.while while 关键字用于指定一个只要条件为真就会重复的循环。 -示例- while (!found){ 正确识别java语言的关键字（keyword）和保留字（reserved word）是十分重要的。Java的关键字对java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等。保留字是为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 true try void volatile while 保留字 const，goto 注意点 识别java语言的关键字，不要和其他语言如c/c++的关键字混淆。 const和goto是java的保留字。 所有的关键字都是小写 friendly，sizeof不是java的关键字 } 1, which of the following are keywords or reserved words in java? a) if b)then c)goto d)while e)case f)sizeof 2, which of the following are java key words? a)double b)Switch c)then d)instanceof 3, which of these are key words in java? a) default b)NULL c)String d)throws e)long f)true 答案来了1，acde 2，ad 3，adef 作对了吗^_^ 解释来了1，then和sizeof都不是java的关键字，熟悉c或者c＋＋，写惯了asp的高手就要小心喽。 2，所有的关键字都是小写的，所以Switch不是关键字。instanceof看上去像方法名，但其实是关键字； 3，大写的NULL不是java语言的关键字。String是java语言的一个封装类的类名，也不是关键字。 再来点系统的： 正确识别java语言的关键字（keyword）和保留字（reserved word）是十分重要的。Java 的关键字对java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等。保留字是为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有三个版本：JAVA SE 标准版\JAVA ME移动版\JAVA EE企业版 java常用命令：java, javac, appletview java程序文件名：.java, .class java的两类程序：applet, application; 特点，区别，这两类程序如何运行 java的主方法，主类，共有类；其特征 java的数据类型，注意与C++的不同，如字符型，引用型，初值 java与C++的不同之处，期中已总结 java标记符的命名规则 1）标识符有大小写字母、下划线、数字和$符号组成。 2）开头可以是大小写字母，下划线，和$符号（不能用数字开头） 3）标识符长度没有限制 4）标识符不能使关键字和保留字 面向对象的四大特征 抽象、封装、继承、多态 封装，类、对象，类与对象的关系，创建对象，对象实例变量 构造函数，默认构造函数，派生类的构造函数，构造函数的作用，初始化的顺序，构造方法的重载 构造函数：创建对象的同时将调用这个对象的构造函数完成对象的初始化工作。把若干个赋初值语句组合成一个方法在创建对象时一次性同时执行，这个方法就是构造函数。是与类同名的方法，创建对象的语句用new算符开辟了新建对象的内存空间之后，将调用构造函数初始化这个新建对象。 构造函数是类的特殊方法： 构造函数的方法名与类名相同。 构造函数没有返回类型。 构造函数的主要作用是完成对类对象的初始化工作。 构造函数一般不能由编程人员显式地直接调用。 在创建一个类的新对象的同时，系统会自动调用该类的构造函数为新对象初始化。 类的修饰符：public类VS 默认; abstract类; final类; 1）类的访问控制符只有一个：public，即公共的。公共类表明它可以被所有其他类访问和引用。 若一个类没有访问控制符，说明它有默认访问控制特性，规定该类智能被同一个包中的类访问引用（包访问控制）。 2）abstract类：用abstract修饰符修饰的类被称为抽象类，抽象类是没有具体对象的概念类，抽象类是它所有子类的公共属性集合，用抽象类可以充分利用这些公共属性来提高开发和维护效率。 3）final类：被final修饰符修饰限定的，说明这个类不能再有子类。所以abstract与final 不能同时修饰一个类。 域和方法的定义 1)域：定义一个类时，需要定义一组称之为“域”或“属性”的变量，保存类或对象的数据。 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将按照它们在类中出现的先 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) { 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的开发和平台之间的约定，程序员只要按照约定使用关键字，java的开发平台就能认识他，并正确处理，展示出程序员想要的效果。 下面列出java关键字的含义： 1.abstract :表明类或类中的方法是抽象的； 2.assert: 声明断言； 3.boolean:基本数据类型之一，布尔类型； 4.break:提前跳出一个块； 5.byte:基本数据类型之一，字节类型； 6.case：在switch语句中，表明其中的一个分支； 7.catch :用于处理例外情况的，用来捕捉异常； 8.char :基本数据类型之一，字符类型； 9.class :类； 10.continue :回到一个块的开始处； 11.default :用在switch语句中，表明一个默认的分支； 12.do :用在“do while循坏语句中”； 13.double: 基本数据类型之一，双精度浮点型； 14.else :在条件语句之后，与if形成对应； 15.extends :用来表明一个类是另一个类的子类； 16.final :用来表明一个类不能派生出子类，或类中的方法不能被覆盖，或声明一个变量时常量 17.finally :用于处理异常情况，表示这一块无论如何都被执行； 18.float :基本数据类型之一，单精度浮点数据类型 19.for :一种循坏结构的引导词； 20.if :条件语句的引导词； 21.Implements:表明一个类实现了给定的接口； 22.import: 表明要访问指定的类或包； 23.instanceof: 用来测试一个对象是否是一个指定类的实例； 24.int: 基本数据类型之一，整形； 25.interface:接口； 26.long: 基本数据类型之一，长整形； 27.native:用来声明一个方法是由与机器相关的语言（如C/C++/FORTRAN）实现的； 28.new:用来申请新对象； 29.package:包； 30.private: 一种访问方式：私有模式； 31.protected:一种访问方式：保护模式； 32.public: 一种访问方式，公共模式； 33.return:从方法中返回值； 34.short :基本数据类型之一，短整数类型； 35.static: 表明域或方法是静态的，即该域或方法是属于类的； 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， // 不能被所在包外的代码存取 //以下定义了三个使用不同修饰符和不同参数的构造方法。 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 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） 面向对象的思想特点 A:是一种更符合我们思想习惯的思想 B:可以将复杂的事情简单化 C:将我们从执行者变成了指挥者 面向对象： 我们怎么才能更符合面向对象思想呢? A:有哪些类呢? B:每个类有哪些东西呢? C:类与类直接的关系是什么呢? 开发，设计，特征 面向对象开发 就是不断的创建对象，使用对象，指挥对象做事情。 面向对象设计 其实就是在管理和维护对象之间的关系。 面向对象特征 封装(encapsulation) 继承(inheritance) 多态(polymorphism) 继承：把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，这多个类就具备了这些内容。这个关系叫继承。 继承的好处： A:提高了代码的复用性 B:提高了代码的维护性 C:让类与类产生了一个关系，是多态的前提 继承的弊端： A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。 原则：低耦合，高内聚。 耦合：类与类的关系 内聚：自己完成某件事情的能力 B:打破了封装性 Java中继承的特点 A:Java中类只支持单继承 B:Java中可以多层(重)继承(继承体系) 继承的注意事项： A:子类不能继承父类的私有成员 B:子类不能继承父类的构造方法，但是可以通过super去访问 C:不要为了部分功能而去继承 多态：同一个对象在不同时刻体现出来的不同状态。 多态前提： A:有继承或者实现关系。 B:有方法重写。 C:有父类或者父接口引用指向子类对象。 多态中的成员访问特点 A:成员变量 编译看左边，运行看左边 B:构造方法 子类的构造都会默认访问父类构造 C:成员方法 编译看左边，运行看右边 D:静态方法 编译看左边，运行看左边 多态的好处 提高了程序的维护性(由继承保证) 提高了程序的扩展性(由多态保证) 多态的弊端 不能访问子类特有功能 静态的特点： A:随着类的加载而加载 B:优先与对象存在 C:被类的所有对象共享 这其实也是我们判断该不该使用静态的依据。 D:可以通过类名调用 静态变量和成员变量的区别 A:所属不同 静态变量：属于类，类变量 成员变量：属于对象，对象变量，实例变量 B:内存位置不同 静态变量：方法区的静态区 成员变量：堆内存 C:生命周期不同 静态变量：静态变量是随着类的加载而加载，随着类的消失而消失 成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失D:调用不同 静态变量：可以通过对象名调用，也可以通过类名调用 成员变量：只能通过对象名调用 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期末知识点整理总结 计科2班苏锐师编号47 学号201330551464 第一章 Java语言概述 1. Java语言发展历史和现状及前景 2. Java语言的特点： 简单、面向对象、分布式、健壮性、结构中立、 安全性、可移植、解释的、高性能、多线程、多态性 3. Java虚拟机概念（JVM），Java程序的执行过程 4. Java应用程序分类：Application和Applet 5. Java程序的开发环境：JDK，IDE 第二章 Java数据类型及其运算 1. 标识符与保留字 1.2 标识符命名语法规则与Java推荐的标识符命名规则 1.3 Java中的关键字 2. 数据类型byte, short, int long, char, float, double, boolean 注意点：Java中所有数据类型是确定的，与平台无关，没有sizeof操作，其中特别注意char 类型是2字节Unicode编码，与C++ 不同；知道基本类型都有对应的默认值。 整型数的十进制、八进制、十六进制值的表示。 实型数的十进制、十六进制与科学计数法表示，注意实型常量默认类型为double型。 3. 运算符与表达式算术运算符： + - * / % ++ -- 关系运算符：> >= < <= == != 逻辑运算符：&& || ！& | 注意短路计算与非短路计算的差别 位运算符： >> << >>> & | ^ ~ 要认识异或(^)与按位取反(~)运算符 赋值运算符： += -= *= /= %= &= |= ^= <<= >>= >>>= 要注意赋值运算符中包含了强制转换： 若： int k = 1; k += 44.232D; 则相当于： k = (int) ( k + 44.232D); 条件运算符：exp ？stat1 ：stat2 要注意stat1与stat2要求类型相兼容且不能为void类型。运算符的优先级：算术运算 > 关系运算> 逻辑运算 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:按钮 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 跳转 CoreJava部分 1简述下java基本数据类型及所占位数，java基本数据类型：4类8种 整数类型：byte(1byte),short(2byte),int(4byte),long(8byte) 浮点类型：float(4byte),double(8byte) 字符类型：char(2byte) 逻辑类型：boolean(false/true1byte) 2说出5个启动时异常 ------RunTimeException ------NullPointerException ------ArrayIndexOutOfBoundsException ------ClassCastException ------NumberFormatException 3HashMap和HashTable的区别： 1HashMap允许空键值对，HashTable不允许 2HashMap不是线程安全的，HashTable是 3HashMap直接实现Map接口，HashTable继承Dictionary类 4.ArrayList,Vector,LinkedList存储性能和区别 它们都实现了List接口 ArrayList和Vector都是基于数组实现的 LinkedList基于双向循环链表（查找效率低，添加删除容易） ArrayList不是线程安全的而Vector是线程安全的，所有速度上ArrayList高于Vector 5.Collection和Collections的区别 Collection是集合类的上级接口，继承与他的接口主要有Set和List Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全等操作。 6List、Map、Set三个接口，存取元素时，各有什么特点？ List以特定次序来持有元素，可有重复元素。 Set无法持有重复元素，内部排序 Map保存key-value值，value可多值。 7final,finally,finalize的区别 Final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承Finally是异常处理语句结构的一部分，表示总是执行 Finalize是Object类的一个方法，在垃圾收集时的其他资源回收，例如关闭文件等。8Overload和Override的区别。Overload的方法是否可以改变返回值的类型？ 方法的重写Override和重载Overload是Java多态的不同表现。 重写Overriding是父类与子类之间多态的一种表现，方法名，参数列表返回值类型都得与父类的方法一致。 重载Overloading是一种类中多态的一种表现。重载的方法是可以改变返回值类型的。9用一句话总结一下冒泡排序 依次比较相邻的两个数，将小数放在前面，大数放在后面。 10实现线程安全的两种方式 1）synchronized方法：通过在方法声明加入synchronized关键字来声明synchronized方法 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/4e1098524.html,返回的是父类的成员变量的值null System.out.println(name); C语言Java关键字对比表 JAVA关键字C语言关键字相同关键字java特有C语言特有abstract auto break abstract auto assert break case assert const boolean case char boolean extern break char continue byte goto byte const default catch register case continue do class signed catch default double extends sizeof char do else final struct class double enum finally typedef continue else float implements unsigned default enum for import union do extern if instanceof double float int interface else for long native enum goto return new extends if short package final int static private finally long switch protected float register void public for return volatile strictfp if short while super implements signed synchronized import sizeof this instanceof static throw int struct throws interface switch transient long typedef try native unsigned new union package void private volatile protected while public return strictfp short static super switch synchronized this throw throws transient try void volatile while Java常用API的运用，效率及技巧 1. Java面向对象基本概念 2. System 3. String, StringBuffer 4. 数值，字符，布尔对象与简单类型的操作 5. Class, ClassLoader 6. Java IO系统 7. Java集合类 8. ResourceBundle, Properties 9. Exceptions 10. JDBC类库 11. 常用设计模式 1. Java面向对象基本概念 Java基本上是面向对象的程序设计语言，除了一些简单类型(primitive)的变量以外，一切都是对象，程序是对象的组合，每个对象都有自己的空间，并且每个对象都有一种类型，同一类所有对象都能接受相同的消息。下面只对Java中对象的结构作简单的说明： 类（class）: class是定义类的关键字，类中包含类变量，方法，内部类，内部接口等。由class可以生成类的实例，即一个个对象。如果一个类的成员被定义 成static的，则这个成员不专属于任何对象，而是属于这个类，所有的对象共享这 个成员。 抽象类(abstract class): 抽象类不能直接生成一个实例，抽象类中必需有方法是abstract的，抽象类的意思就是它实现了一部分的方法，而定义为abstract的方法 则需要在它的字类中去实现。 接口(interface): 接口可以理解为纯抽象的类，它的每个方法都是未实现的，它可以有成员变量，但必须是static的。一个类如果从这个接口继承（implements） 则它必须实现这个接口的所有方法。 继承类用关键字：extends，继承接口用关键字：implements。一个类只能从一个类继承下来，但可以从多个接口继承（类似于C++的多重继承）。字类可以覆盖父类的方法(method)，但不能覆盖父类的成员变量(field)。如果父类的方法为final或static的则不能被覆盖。类的初始化顺序是，如果有父类，则先初始化父类的field，然后执行父类的构造函数，如果子类没有显式的去调父类的构造函数则缺省的会去调父类的无参数构造函数。然后是子类的field 与构造函数的初始化。 public interface SuperInterface { public staitc String SOME_FLAG = “1”; public void someMethod(); } public Class SuperClass { { System.out.println(“init SuperClass field”);} public SuperClass() {System.out.println(“init SuperClass Constructor”); } public void runMethod() { System.out.println(“run SuperClass runMethod()”); } }java关键字
java期末考试知识点总结
java中常用关键字总结
java选择题
Java关键字final使用总结
java关键字和java命名规范
java中的关键字的含义及介绍
java常用词汇
JAVA关键字大全(方便版)
常用java技巧总结
Java关键字大全
Java期末知识点整理总结
JAVA编程关键字和常用单词
java关键字
JAVA重点知识总结
java中super关键字的三种用法
C语言与java关键字对比表
何小伟-高手总结java常用API
相关主题
文本预览