Java考试复习资料 - 图文

Java考试复习资料

第一章Java 语言程序设计 1.java 命令行参数 2.Java程序书写规范：

? 包、类、变量、方法等命名：要体现各自的含义; ? 包名全部小写，io，awt;

? 类名第一个字母要大写: HelloWorldApp; ? 变量名第一个字母要小写: myName; ? 方法名第一个字母要小写: setName;

? 程序书写格式：保证良好的可读性，使程序一目了然。 ? 大括号{}要对齐，语句段要对齐 ? 在语句段之间适当空行

? 程序注释：帮助了解程序的功能。 ? 类注释 ? 变量注释 ? 方法注释 ? 语句注释 ? 语句段注释

? 建议：一个类一个.java文件

第二章 Java语言基础知识 标识符（identifier)：

需要命名的元素包括：类名、变量名、常量名、方法名…。标识符的长度不限，但第一个字符必须是这些字符之一： 大写字母(A-Z) 小写字母(a-z) 下划线 $符号

标识符的第二个字符及后继字符可以包括数字字符（0-9） ? 保留字

也称为关键（key）字，由小写的英文字母组成，赋予这些保留字专门的意义和用途，程序员不能再用作用户自 定义标识符。

abstract break byte boolean catch case class char continue default double do else extends false final float for finally

import implements int interface instanceof long length native new null package private protected public final return switch synchronized short static super try true this throw throws threadsafe transient void while if 保留字注意事项：

Java中，true、false和null都是小写的。区别于C++中大写的TRUE、FALSE和NULL。 不能更改或重复定义保留字，也不能将Java保留字用作用户自定义标示符 ? 变量

与C++不同，作为类里定义的变量，其默认初值都是确定的,但是在方法（函数）实现中定义的变量必须程序员

分区Java 的第1 页

与C++不同，作为类里定义的变量，其默认初值都是确定的,但是在方法（函数）实现中定义的变量必须程序员 自己初始化。

? 常量

常量是用某些特征含义的标识符表示某些不变化的数值。 C通过#define命令把一个标识符定义为常量; C++用const定义常量;

Java用 关 键 字 final来 定义;

? Java数据类型

? 数据类型转换

数据类型可以自动类型转换，int、long、float数据可以混合运算。转换从低级到高级： 低------------------------------------------------------------->高 byte,short,char—> int —> long—> float —> double int i = 10; byte b=(byte)i;

浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入

(int)25.7 =25； (int)-42.87f = -42；

? 2.3.1数组

分区Java 的第2 页

?

? （1）数组的声明与创建

声明（Declaration）

使用数组前必须对它进行声明。

不能直接使用，必须经过初始化分配内存后才能使用!

（2）数组元素的初始化

Java中创建数组的时，如果没有指定初始值，数组便被赋予默认值初始值。

?

（4）二维数组

下面语句使数组的3个元素分别又是三个整型数组，每个元素里有含有5个整数。 int[ ][ ] myArray = new int[3][5]； （5）数组类的方法

Arrays是Java类库提供的一个标准包，位于java.util，包含了很多静态成员方法。 【例2-6】Arrays类常用方法的使用

package chpt2;

//arrays里的方法使用

public static void main(String[] args) {

int[] a1=new int[]{1,3,5,7};

System.out.println(Arrays.equals(a, a1)); //判断a和a1是否相等,输出true

分区Java 的第3 页

import java.util.*; public class Ex2_6 {

/**

* @param args */

int[] a=new int[]{1,3,5,7};

} } 输出结果：

true false

int[] b=Arrays.copyOf(a, 6);

System.out.println(Arrays.equals(b, a1)); //输出false System.out.println(\

System.out.println(Arrays.toString(b)); //把数组转换成字符串输出 Arrays.fill(b, 2,5,1); //把第二个到第四个元素赋为1 System.out.println(Arrays.toString(b));

Arrays.sort(b); //对b进行排序 System.out.println(Arrays.toString(b));

System.out.println(Arrays.binarySearch(b, 3)); //使用二分查找法查找3的位置

========= [1, 3, 5, 7, 0, 0] [1, 3, 1, 1, 1, 0] [0, 1, 1, 1, 1, 3] 5

【例2-7】arraycopy()实现数组的复制

package chpt2;

public static void main(String[] args) { //13个元素

char[] copyTo = new char[7];

System.arraycopy(copyFrom, 2, copyTo, 0, 7); } class Ex2_7 { 输出结果：caffein

void java.lang.System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

2.4基本数据类型的封装类

char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e', ? Java中，除了引用类型外，基本数据类型也被封装为引用类型。

'i', 'n', 'a', 't', 'e', 'd' }; ? 在Java库中，8种基本数据类型都有一个相应的，预定的引用类型。

? 例如，其中存在一个相应于整数的java.lang.Interger,这些类类型称为对象封装(object wrappers)。

System.out.println(new String(copyTo));

}

（1）封装类的使用

分区Java 的第4 页

（2）生成封装类对象的方法

（3）从封装类数据转换为基本数据类型数据的方法

2.6.2循环结构 foreach语句

JDK1.5后，增添了一种新的foreach循环语句。

foreach语句是for语句的特殊简化版本，利用新的foreach语句，可遍历数组、集合。 格式如下：

foreach的语句格式：

for(元素类型t 元素变量x : 遍历对象obj){ 引用了x的java语句; }

第3章类与对象

分区Java 的第5 页

第3章类与对象 3.3数据成员及方法

3.3.2方法中参数传递的问题

? 参数的类型可以是基本数据类型，也可以是引用（类）类型。

? Java语言中，基本数据类型作为参数均采用传值（passing –by- value)的方式完成。

? 引用类型变量作为参数传递时，采用的是引用传递(passing-by-reference)的方式，在方法体中对形参的改动将会影响到实参。 3.3.3 toString()方法

String toString()是一个经常用到的方法，当需要把一个对象输出到屏幕，就要用到此方法。 实际上，Java的所有类都有一个默认的toString() 例3-3

System.out.println(ipad)语句就等价于System.out.println(ipad.toString()) public class Product { int ID; String name; String categories; double productPrice;

Product(int id, String nm, String categ,double price) {

ID =id; name=nm;

categories = categ; productPrice = price; }

Product(){}

public String toString(){

return (\ } }

如果直接调用默认的toString(),返回结果形式为： ? 对象类的名字@对象的地址 例如编译后运行结果如下： Product@19efb05

重写toString()方法的实现部分, “覆盖”掉从Object继承来的toString()，将对象的内容转换为字符串。 声明toString时需要注意以下事项：

toString()必须为public; 返回类型为String;

方法的名称必须为toString,且没有参数；

在方法体中不要使用输出方法System.out.println();

3.4.3 final修饰符

对于final修饰的引用,只是引用不能再指向其他对象,但其所指对象的属性还是可以被修改的. final在类之前

表示该类是最终类，不能再被继承。 final在方法之前

表示该方法是最终方法，该方法不能被任何派生的子类覆盖。 final在变量之前

表示变量的值在初始化之后就不能再改变；相当于定义了一个常量。

应该是引用不变，也就是引用指向指定的对象，不能再指向其它的对象。至于对象中的值还是可以改变的，因为final关心的是地址，而不是对象 当中的值。 3.4.4 方法重载

分区Java 的第6 页

3.4.6 对象的回收

与C++不同，Java额外提供了垃圾回收器( garbage collector)

对于不再使用的内存资源，垃圾回收器能自动将其释放，无需使用delete 无需再使用类似C++里的析构函数destructor。 3.4.8 类的访问控制

访问权限控制的等级，从最大权限到最小权限依次为: public protected

包访问权限（没有关键字） private.

公有(public) ：可以被其他任何对象访问(前提是对类成员所在的类有访问权限) 保护(protected) ：只可被同一类及其子类的实例对象访问 私有(private) ：只能被这个类本身访问，在类外不可见 包访问权限：默认访问权限，仅允许同一个包内的访问

需要注意的是类的访问控制只有public（公共类）及包（默认类）两种，没有私有。 3.5.1语言包java.lang

3、变量字符串类StringBuffer

StringBuffer类也是用来处理字符串。

String定义的常量字符串，一旦赋值或实例化后就不可更改，如果赋予新值将会重新开辟内存地址进行存储； 而StringBuffer类在实例化StringBuffer之后，可以改动其中的字符。 4、math类

Math类提供了用于几何学、三角学以及几种一般用途方法的浮点函数，来执行很多数学运算。Math类定义的所有变量和方法是静态的，是终结 类(final)。

第4章 异常处理(Exception) Java的异常处理

Java通过面向对象的方法来处理异常（Exception）。 Java把程序中可能出现的各类异常封装为类。 提供了自动检测出异常，并处理异常的机制。

Java尽可能地为各类异常提供解决方案，这些处理异常的代码块称为exception handler； Java把常规代码和异常处理代码分开。 try

{//常规代码段 ConnectDB; FetchData； GetResult; DisconnectDB; }

catch(FailedtoConnectDB) {dosomething} catch(FailedtoFetchData) { dosomething } catch(FailedtoGetResult) { dosomething }

分区Java 的第7 页

catch(FailedtoGetResult) catch(FailedtoDisconnectDB) { dosomething }

{ dosomething }

4.2 异常的分类

Java中，所有的异常都直接或间接地继承自Throwable类。

Java API的每个类包中都定义异常类，这些异常类分成两大类：

? Error类，是所有错误类的父类，处理致命性的，用户程序无法处理； ? Exception类，是所有异常类的父类，是Java程序中需要大量处理的。

Error：应用程序外部的异常情况，由Java虚拟机生成并抛出，包括 ? 硬件故障 ? 动态链接失败 ? 虚拟机错误等

Java程序不做处理。 Exception：

非检查型异常(Non-checked Exception) ? 继承自RuntimeException

? 也称为“运行时库”异常，例如数组越界，除零等；

? 由系统自动检测出异常，自动报错，提供默认的异常处理程序。 检查型异常(cheked exception)

? 即其他类型的异常，需要手动检查在什么位置引发的，何处能够捕获或处理以及如何处理; ? 程序中必须要作处理，或者捕获，或者声明抛弃。 4.3 异常的处理机制

无论是检查型异常还是非检查型异常，针对可能出现的异常，用户程序必须做出选择 （1）或者在异常出现的方法中处理该异常(try…catch…)。

（2）如果该方法中没有做出任何处理，就把异常抛给调用该方法的上一层方法，沿着被调用的顺序往前寻找，只要找到符合该异常种类的处理程 序，就交给这部分程序去处理。

分区Java 的第8 页

4.3.2 检查型异常处理

对于检查型异常，Java强迫程序必须进行处理。应该根据具体的情况选择在何处处理异常。 两种处理方法：

? 捕获异常(try, catch语句)

○ 使用try{}catch(){}块，捕获到所发生的异常，并进行相应的处理 ? 声明抛出异常(throws语句)

○ 不在当前方法内处理异常，而是把异常抛出到调用方法中由上层方法作处理。 语法格式

try {

statement(s)

可能产生异常的代码块 } catch (exceptiontype name) { statement(s)

捕获try代码块所产生的异常并做相应的处理,exceptiontype必须是一个从Throwable类派生出来的类的名称。 } finally { statement(s)

必须执行的代码 }

捕获异常的顺序会影响到异常的处理，在类层次结构中，一般的异常类型要放在后面，特殊的放在前面。

printStackTrace(), 它是从类Throwable中继承而来，调用此方法将会打印出“从方法调用处直到异常抛出处”的方法调用序列。

? 声明抛出异常——检查型异常处理方法2

? 如果在一个方法中生成了异常，但是该方法并不处理它产生的异常，而是沿着调用层次向上传递，交由调用它的方法来处理这些异常，这就是声明 抛出异常。 声明异常的方法

声明异常的方法是在产生异常的方法名后面加上关键字throws，后面接一个所有潜在异常类型的列表： void func() throws ExceptionA, ExceptionB, ExceptionC{

……

}

public class Ex4_6{

public static void main (String args[])throws NumberFormatException,IOException{ //在main里抛出异常

分区Java 的第9 页

}

public static void main (String args[])throws NumberFormatException,IOException{ //在main里抛出异常

Product ipad = new Product();

BufferedReader in =new BufferedReader(new InputStreamReader(System.in)); System.out.println(\请输入product ID:\ ipad.ID =Integer.parseInt(in.readLine()); System.out.println(\请输入product name:\

ipad.name =in.readLine();

System.out.println(\请输入product categoriese:\ ipad.categories=in.readLine(); }

? 4.4 自定义异常类

? 有些异常在jvm看来不是异常，需要自己手动引发异常，用new生成自己的异常对象，然后把它throw出来。 ? 注意是throw不是throws

生成异常对象通过throw语句来实现（注意：这里是throw而不是throws)： throw new ThrowableObject(); 或者

myException e = new myException(); throw e;

抛出的异常必须是Throwable或其子类的对象

? 【例4-7】使用try、throw、catch处理三种情形：无异常、除数为零、数组越界可能产生的异常。 package chpt4;

class Process{

void Proc( int sel ) {

System.out.println(\ if( sel==0 ) //没有异常 {

System.out.println(\ return; }

else if( sel==1 ) {

try{

int i=0;

int j=5/i; //除数为零

throw new ArithmeticException(); //显示地抛出异常ArithmeticException对象显 }

catch(ArithmeticException e) {

System.out.println( e.toString() ); } }

else if( sel==2 ) {

try{

int iArray[]=new int[4]; iArray[10]=5; //数组越界

throw new ArrayIndexOutOfBoundsException(); //显示地抛出异常ArrayIndexOutOfBoundsExceptionn对象 }

catch(ArrayIndexOutOfBoundsException e) {

System.out.println( e.toString() ); } }

分区Java 的第10 页

} } } ? public class Ex4_7{

public static void main( String args[] ) {

Process pp = new Process(); try {

pp.Proc( 0 ); //调用proc pp.Proc( 1 ); pp.Proc( 2 );

}catch( ArithmeticException e ){

System.out.println(\ }catch( ArrayIndexOutOfBoundsException e ){

System.out.println(\ }catch( Exception e ){

System.out.println(\ }finally{

System.out.println(\

} }

【例4-8】以电子商场例子为例，产品价格如果少于100元就不符合常规了，可以定义一个异常类来描述这种异常。 package chpt4; //Product.java import java.io.*; class Product { int ID; String name; String categories; double ProductPrice; int getID(){ return ID; }

String getName(){ return name; }

String getCategories(){ return categories; }

double getPrice(){ return ProductPrice; } }

class PriceException extends Exception {

public PriceException(){

System.out.println(\ } }

public class Ex4_8{

public static void main(String args[]) {

Product ipad = new Product(); ipad.ID =123; ipad.name = \ ipad.ProductPrice = 50; try{

if(ipad.ProductPrice<100) throw new PriceException(); }catch(PriceException e) {e.getMessage();}

} }

输出结果：the price is too low!!!

?

第5章 类的重用

有两种方法可以达到这一目的：

在现有类的基础上创建新类，在其中添加新代码，这种方法称为继承。

分区Java 的第11 页

? 在现有类的基础上创建新类，在其中添加新代码，这种方法称为继承。

? 在新类中使用其他类的对象。即新类由多种类的对象组成，这种方法称为组合。

? Java只支持类的单继承，每个子类只能有一个直接父类。 ? 子类对象与父类对象存在“IS A”(或“is kind of”)的关系

?

? 【例5-1】实现Product 、Computer和Laptop三个类的继承关系。 package chpt5.Ex5_1; //Product.java

public class Product { int ID; String name; String categories; double ProductPrice; int getID(){ return ID; }

String getName(){ return name; }

String getCategories(){ return categories; }

double getPrice(){ return ProductPrice; } }

? package chpt5.Ex5_1; public class Product_test{

public static void main(String args[]){

Computer apple = new Computer(); apple.ID = 123;

apple.name = \ apple.categories = \

System.out.println(apple.getName()); System.out.println(apple.getCategories()); Laptop mac = new Laptop(); mac.name = \ mac.weight = 20; mac.thickness = 1.3;

System.out.println(mac.getName());

System.out.println(mac.getProcessorName()); System.out.println(mac.getthickness());

} }

当子类中声明了与父类中相同的成员变量名，则从父类继承的变量将被隐藏。 class Parent {

分区Java 的第12 页

? class Parent { ? String name; ? }

? class Child extends Parent { ? String name; }

Super关键字

如何访问被隐藏的父类方法？可以用super来引用父类中的方法、变量及构造方法。

public void speedup(){

super.speedup(); //通过Super关键字调用父类的speedup()speed = speed +10;

System.out.println(\ed+\}

以上程序表示在子类里使用到父类的构造方法，super必须是子类构造方法的第一条语句。 5.2.5 继承关系下的构造方法

在子类的构造方法中，如果没有明确指明调用父类的构造方法，Java会自动插入对父类默认构造方法（无参的构造方法）的调用。 下面这个例子展示了继承的应用：

class Cat {

Cat() { //默认构造方法

System.out.println(\

}

class CartoonCat extends Cat {//默认构造方法

CartoonCat(){ System.out.println(\

}

class SuperStar extendsCartoonCat{ //默认构造方法

SuperStar() { System.out.println(\

}

public classOnShow{

public static void main(String[] args) { SuperStar garfield = new SuperStar(); }}

该程序的输出显示了自动调用：

Cat constructor

CartoonCat constructorSuperStar constructor

可以看出,即使没有为Cartoon()创建一个构造方法，编译器也会为我们自动合成一个默认构造方法，并发出对父类构造方法的调用。

? 5.3 终结类与终结方法final class & final method 终结类与终结方法

? 被final修饰符修饰的类和方法 ? 终结类不能被继承

? 终结方法不能被当前类的子类重写

? 终结类的特点

分区Java 的第13 页

?

不能有派生类 终结类存在的理由

? 从概念上说不应该有任何派生类 ? 从安全的角度上考虑

? 5.4 抽象类与抽象方法

? 抽象类：用abstract关键字来修饰一个类时，该类叫做抽象类 ? ? 抽象类不能创建对象； ? ? 它只能作为其它类的父类，这一点与final类正好相反。 抽象方法：用abstract来修饰一个方法时，该方法叫做抽象方法。 ? 抽象方法必须被重写；

? 抽象方法只有声明，不能有实现； ? 含有抽象方法的类必然是抽象类。 抽象类与抽象方法声明格式如下：

abstract class <类名>{

成员变量；

方法( ){方法体}; //一般方法 abstract 方法( ); //抽象方法定义

}

? 抽象方法仅有方法头，而没有方法体和操作实现 ? 具体实现在子类里完成

? 抽象类可以包含其他非抽象方法 需注意的问题

一个抽象类的子类如果不是抽象类，则它必须为父类中的所有抽象方法写出方法体，即重写父类中的所有抽象方法

? ? ? ?

5.5 重用方式之二——类的组合

组合的语法很简单，只要把已存在类的对象放到新类中即可。 可以使用“has a”语句来描述这种关系。

例如，考虑到车的组件有 车轮, 发动机等, 很自然的说“my car ‘has a’ engine/wheels”。所以，可简单的把engine对象和wheels对象放在 类Car中。

组合与继承的比较

? “包含 has-a”关系用组合来表达 ? “属于is-a”关系用继承来表达

? 在更多的时候，组合关系比继承更能使系统具有高度的灵活性，可维护行，并且提高系统的可重用性。

?

第6章 接口与多态 6.1 为什么需要接口

接口的引进是为了实现多重继承，但是比C++中多重继承简洁了许多。

分区Java 的第14 页

接口关系示意图

? 6.2 接口的声明及实现 ? ? “interface”（接口）可将其想象为一个“纯”抽象类。

? 这种抽象类中只包含常量和方法的定义，而没有方法的实现。

? 接口只提供一种形式，并不提供实施的细节，接口中的所有方法都是抽象的。

注意:Interface 没有构造方法,不能被直接实例化

? public interface driver{ ? int age = 30; //常量

? void driverCar(); //方法的定义 }

以上public接口中的变量age修饰符隐含为public static final; 方法drivercar()隐含修饰符为public abstract。

? 接口的实现

? 接口不能用new运算符直接产生对象，需要定义一个类来实现接口，由这个类来创建对象。 ? 使用implements关键字实现接口。

class Piano implements Instruments{

public void training( ) //实现instruments所有的方法，并为public

{……

}

public void play( ){……

分区Java 的第15 页

}

}

? 必须实现接口中的所有方法,并且这些方法必须定义为public。

? Java的设计以简单实用为导向，不允许一个类有多个父类。但允许一个类可以实现多个接口，通过这种机制就相当于实现多重继承，如上语法所 ? 述。

接口的扩展

接口可通过扩展的技术派生出新的接口 ? 原来的接口称为父接口(super interface) ? 派生出的接口称为子接口(sub interface)

? 子接口不仅可以保有父接口的成员，同时也可加入新成员。 ? 实现接口的类也必须实现此接口的父接口

publicperformance(}

)

{ ……

}

? 6.4 多态

? 多态是面向对象的第三大特征，它的实现实质上是由向上转型(Upcasting，也称为向上映射)和动态绑定(Dynamic Binding)机制完成的。 ? 子类的对象可以赋值给父类的对象，也就是子类对象可以向上转型为父类类型。 向上转型是安全的。

6.4.2 向上转型的应用

1）当一个子类对象(Garfield)转型为父类(mycat)以后，就被当成父类的对象，所能调用的方法会减少，只能调用父类定义的方法，而不能调用父 类没有，而子类有的方法。

2）如果在父类和子类中都提供了相同的方法，而此方法被转型后的对象使用，那么系统将会调用哪一个类中的方法？ 系统将会自动调用子类中的方法，

原因是Java提供了动态绑定机制，能识别出对象转型前的类型，从而自动调用该类的方法。

? 6.4.3 静态绑定和动态绑定

? 绑定: 将一个方法调用同一个方法主体连接到一起

? 静态绑定：也就是在编译时编译器就能准确地判断应该调用哪个方法。 动态绑定：程序在运行期间由JVM自动地判断应该调用那个方法。 以静态绑定方式实现

public class Hitgreenpig{

public static void main(String[] args) {

分区Java 的第16 页

}

? 以动态绑定方式实现

BlueBird one = new BlueBird();

one.chirp(); //通过对象调用方法，属于静态绑定one.shoot();

WhiteBird two = new WhiteBird();

two.chirp(); two.shoot();

RedBird three = new RedBird();

three.chirp();three.shoot();

}

public class Hitgreenpig {

public static void main(String[] args) {

AngryBird[] s = new AngryBird[5]; //生成父类对象数组int n;

for(int i = 0; i < s.length; i++) {

n = (int)(Math.random() * 3);//随机产生从0至2中一个数switch(n) {

case 0: s[i] = new BlueBird(); break;case 1: s[i] = new WhiteBird(); break;case 2: s[i] = new RedBird();break;} }

for(int i = 0; i < s.length; i++) s[i].shoot(); }}

说明

? 编译时无法知道s数组元素的具体类型，运行时才能确定类型，是动态绑定。 ? 在main的循环体中，随机生成一个指向BlueBird、WhiteBird或者RedBird的对象。

? 6.4.4多态的实现

? 利用向上转型，一个子类的对象可以转化为父类的对象，与动态绑定相结合，通过父类对象调用相应的子类方法，这就实现了多态。 Java的多态原理与C++的一样。不同的是在实现时更方便了许多，省略了virtual关键字，实际上已经自动实现的virtual方法。

? 6.4.5 何时需要多态 需要多态的情形：

情形1：如果需要在程序里添加更多的类 ； 情形2：如果准备为所有的类添加某些新功能 ； 6.5 内部类

6.5.1 内部类的概念

在另一个类或方法的定义中定义的类。 class OuterClass{

……

class InnerClass{

分区Java 的第17 页

}

? ? ? ? ?

class InnerClass{

……. }

6.5.2 静态内部类

如果不希望内部类与其外部类对象之间有联系，可以把内部类声明为static，它可以不依赖于外部类实例被实例化。 OuterClass.StaticInnerClass nestedObject =New OutClass.StaticInnerClass(); 静态内部类只能访问外部类的静态成员(包括静态变量和静态方法) 6.5.5 匿名的内部类(anonymous inner class) 匿名类可以访问所有外部类的方法变量 。

优点是代码简洁，但是可读性较差。一般用于GUI中实现事件处理。 匿名内部类：可在new关键字后声明内部类，并立即创建一个对象 【例6-8】匿名内部类实现接口Paper public class Ex6_8 {

public Paper pp() { //内部类定义开始 return new Paper() { private String line;

public String mark(){ return line; } }; //分号在这里是必须的，标记表达式的结束 }

分区Java 的第18 页

本文来源：https://www.bwwdw.com/article/7gz7.html