java期末考试复习重点 必考.docx

java期末考试复习重点 必考.docx

《java期末考试复习重点 必考.docx》由会员分享，可在线阅读，更多相关《java期末考试复习重点 必考.docx（18页珍藏版）》请在冰豆网上搜索。

java期末考试复习重点必考

…第一部分　知识点复习

第1章Java语言概述

1、Java虚拟机

是软件模拟的计算机，执行保存在.class文件中的字节码。

Java虚拟机的Java解析器（java.exe）负责将字节码文件解释成为特定的机器代码执行。

Java编译程序将java源程序（.java）翻译为JVM可执行的字节码（.class）

2、字节码

字节码其实就是二进制编码，也叫伪代码。

三个步骤：

类转载器——字节码校验器——java虚拟机

3、环境变量JAVA_HOME、PATH、CLASSPATH

JAVA_HOME：

该环境变量的值就是javas所在的目录。

PATH:

该环境变量指定一个路径列表，用于搜索可执行文件。

CLASSPATH：

该环境变量也指定一个路径列表，用于搜索

java编译器或者运行时需要用到的类。

例程：

JAVA_HOME=d\java\jdk;

PATH=d:

\java\jdk\bin;%path%;

CLASSPATH=.;d\java\jdk\jre\lib\rt.jar

4、javac、java、appletviewer

Javac:

编译器读取java源代码，并将其编译成字节代码，

如javac*.java;（*为类名）；

Java:

解析器可用来直接解释执行jaca字节代码，如java*；

Appletviewer：

可以测试小应用程序applet，读取包含小应用

程序的HTML文件在一个窗口运行它们，读取命令行中的

URL所指定的HTML文件，如appletviewer*html。

5、Application、Applet

Application应用程序是在计算机中单独运行，而Applet

小应用程序只能嵌入在Html网页中运行。

第2章数据类型及其运算

1、标识符定义

在Java中标识符是以字母、下划线（_）、美元符号（$）等其它货币符号（如£,¥）开始的一个字符序列，后面可以跟字母、下划线、美元符号、数字等字符。

合法：

Body，_test，￥hello

非法：

5Test,hello*/#,class

标识符是大小写敏感的，没有最大长度的限制，不能和关键字相同

2、关键字

所有的关键字都是小写的，如果大写就不是关键字了，java中无sizeof关键字，所有基本数据类型的长度和表示是确定的，不依赖执行环境，所以不需要此关键字。

3、三种注释

（1）单行注释：

//释内容

（2）多行注释：

/*注释文本

：

：

*/

（3）文档注释：

/***注释文本

*@Author

*

*/

4、变量及其分类

变量：

类型、变量名、和值。

分类：

局部变量、类成员变量（静态变量和实例变量

）、方法参数、异常处理参数

5、常量的定义

整形常量234，实型常量23.4，字符常量’a’，布尔常量true和false，以及字符串常量“helloworld！

”，finalintMAX_LOOP=5;

6、Java的数据类型分类

7、变量的类型转换（赋值相容）

8、掌握一维数组与二维数组的创建方法

第4章Java面向对象程序设计基础

1、对象、类、抽象、封装、继承、消息、多态概念的理解

答：

对象——是存在的具体实体，具有明确定义的状态和行为。

类——是具有相同属性和行为的一组对象的集合。

抽象——是去除一个事物中对当前目的不重要的细节，保留对当前目的具有决定意义的特征，形成数据抽象。

封装——把对象的属性和对这些属性的操作封装在一个单独的数据结构中，并尽可能隐藏对象的内部细节

继承——是一种有已有的类创建新类得机制。

消息——是指请求对象执行某一处理或回答某些信息的要求。

多态——用相同的名字来定义不同的方法。

（普通类中的多态为重载，重载是java实现多态性的方式之一）

2、类包括两个部分：

类声明和类体

答：

类声明的格式如下：

[修饰符]class类名[extends超类名][implements接口名列表]{

……

}

可能的选项有：

[public][abstract|final]class类名[extends超类名]

[implements接口名列表]{

……

}

public（公共）：

public修饰的类能被所有的类访问。

abstract（抽象）：

abstract修饰的类不能被实例化，它包含有未实现的方法。

final（最终）：

final修饰的类不能被继承，即不能有子类。

注意：

abstract和final不能同时作为一个类的修饰符。

3、类的修饰符、成员变量的修饰符、成员方法的修饰符分别有哪些？

答：

类的修饰符（3）：

public（其修饰的类能被所有的类访问）

abstract（其修饰的类不能被实例化，它包含有未实现的方法）

final（其修饰的类不能被继承，即不能有子类）

注意：

abstract和final不能同时作为一个类的修饰符。

成员变量的修饰符（8）：

默认访问修饰符：

其修饰的成员变量可以被同一包中的任何类访问。

public：

其修饰的成员变量可以被项目文件的任何方法访问，建议不要使用

protected：

其修饰的成员变量可以被子类访问。

private：

其修饰的成员变量只能在同一个类中使用。

static：

其修饰的成员变量称为类变量或静态变量。

不加static修饰的成为实例变量

final：

其修饰的成员变量又称为最终成员变量或常量。

注意：

abstract和final可以同时作为一个类的修饰符

transient：

用来声明一个暂时性变量

volatile：

声明一个多线程共享变量，使得各个线程对该变量的访问功能保持一致

成员方法的修饰符（9）：

default（默认）：

可以被同一包中的任何类访问。

public:

其修饰的方法可以由其他类访问。

protected：

其修饰的方法只有子类可以访问。

private：

只能由说明该方法的类访问。

static：

其修饰的方法成为静态方法或类方法。

无static修饰的方法为实例。

方法。

类方法是所有对象共享的方法。

final：

其修饰的方法为最终方法，不能由子类改变。

abstract：

其修饰的方法为抽象方法，无方法体。

synchronized：

其修饰的方法执行之前给方法设置同步机制，实现线程同步。

native：

其修饰的方法为本地方法，即方法实现与本地计算机系统有关。

4、变量与方法的调用格式分别是什么？

答：

成员变量:

在定义它的类内部来访问：

直接通过成员变量名来访问。

在定义它的类的外部来访问：

类变量的访问格式：

类名.类变量名

类对象变量的访问格式：

对象名.实例变量名

成员方法：

类方法（静态方法）：

类名.类静态方法名（实参列表）

对象方法（实例方法）：

类对象名.类非静态方法名（实参列表）

5、创建一个对象的3个步骤是什么？

答：

1.对象的声明格式为：

类的名字对象名字；例：

Peoplezhanfeizhu

2.为声明的对象分配内存使用new运算符和类的构造方法为声明的对象分配内存。

3.执行构造方法，进行初始化例：

zhanfeizhu=newPeople（“876“）；

以上三个步骤的简化形式：

Peoplezhanfeizhu=newPeople（“876“）；

6、构造方法的作用是什么？

答：

构造方法可以确保用户正确地构造类得对象，同时，构造方法也会对对象做初始化工作。

7、多态可分为重载与覆盖（重写）两种形式。

什么是重载？

什么是覆盖？

两者的区别是什么？

答：

方法重载：

指一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，或者参数个数不同，或者参数的类型不同或者是返回值不同

方法重写：

当子类中定义了一个方法，并且这个方法的名字、返回类型、参数个数以及类型与父类的某个方法完全相同时，父类的这个方法将被隐藏，这种情况被称为重写了父类的方法。

区别：

重写是继承后重新实现父类的方法，重载是在一个类里一系列参数不同名字相同的方法。

8、理解和掌握成员变量及方法的访问权限

在Java中，可以选择四种访问方式：

public、private、protected和default.

如果将一个成员变量或成员方法定义为public类型，则在同一类、子类、同一包中的类、不同的包中的类均可以访问该成员变量或成员方法。

//Demopub1.java

packagepub1;

publicclassDemopub1{//public修饰是必需的。

//公共类型的成员变量

publicinta;

//公共类型的成员方法

publicvoidmethod（）

{

System.out.println（）;

}

}

如果声明一个成员变量或成员方法的访问类型为protected，则该成员变量或成员方法只能够被该类内部、子类和相同包中的类访问.

【例4-11】不同包中公共类中protected修饰的方法的访问

//Demopro3.Java

packagepro3;

publicclassDemopro3

{

//公共类型的成员变量

publicinta;

//保护类型的成员方法

protectedvoidmethod（）

{

System.out.println（）;

}

}

如果一个变量或成员声明为私有类型，则该变量或方法只能在同一类中被访问。

如例4-12所示

【例4-12】私有类型变量的访问

//DemoPrivate.java

publicclassDemoPrivate{

publicinta;//公共类型的成员变量

privateintb;//私有类型的成员变量

publicintgetA（）{//公共类型的成员方法

returna;

}

privateintgetB（）{//私有类型的成员方法

returnb;

}

publicDemoPrivate（inta,intb）{//构造方法

this.a=a;

this.b=b;

}

9、final、this、super、null

1）final修饰成员变量

如果一个成员变量前面有final修饰，那么这个成员变量就变成了常量，一经赋值，就不允许在程序的其他地方修改。

定义方式如下：

finaltypevariableName；

例如

classConstTimeExpress{

finalintMaxHour=23;

finalintMaxMinute=59;

finalintMaxSecond=59;

}

2）final修饰方法

方法的final修饰符表明方法不能被子类覆盖。

带有final修饰符的方法称为最终方法。

Java的方法除非被说明为最终方法，否则方法是可以被覆盖的。

Java之所以这样规定，主要是因为Java的纯面向对象特性，它把覆盖当作面象对象的重要特性，给予了最大限度的实现。

把方法声明为最终方法有时可增加代码的安全性。

使用方式如下。

finalreturnTypemethodName（paramList）{

}

例如：

finalintgetLength（Strings）{

……

}

3）final类

final类不能被继承。

由于安全性的原因或者是面向对象的设计上的考虑，有时候希望一些类不能被继承，例如，Java中的String类，它对编译器和解释器的正常运行有很重要的作用，不能轻易改变它，因此把它修饰为final类，使它不能被继承，这就保证了String类型的唯一性。

同时，如果你认为一个类的定义已经很完美，不需要再生成它的子类，这时也应把它修饰为final类。

定义一个final类的格式如下：

finalclassfinalClassName{

……

}

关键字this是用来指向当前对象或类实例的。

例如：

publicclassMyDate{

privateintday,month,year;

publicvoidtomorrow（）{

this.day=this.day+1;

}

}

这里，this.day指的是当前对象的day字段。

或者在成员方法定义时，我们使用的形式参数与成员变量名称相同，这时我们要用到this。

例如：

classDemothis{

inta;//成员变量

publicDemo（inta）

{

this.a=a;

}

}

在Java语言规范中，null表示类或者变量是空，不代表任何对象或实例。

看下面的例子

SomeClassaSomeClass=null；

上面的语句中，只定义了类SomeClass的实例aSomeClass，但并没有为之创建任何对象。

第5章面向对象高级程序设计

1、子类是如何把父类的状态和行为转变为自身的状态和行为的？

答：

子类通过“成员变量的隐藏和方法的重写”可以把父类的状态和行为转变为自身的状态和行为。

（附加）例子：

下面这段程序就是这样的情况

classSuperClass{

inty;

voidsetY（）{

y=0;}

}

ClassSubClassextendsSuperClass{

inty;//在SubClass类里，父类的成员变量y被隐藏，

父类的方法被重写

voidsetY（）{

y=0;}

}//于是子类对象所使用的成员变量y为子类中定义的y，子类对象调用的方法为子类中所实现的方法，

该重写方法和父类中被重写的方法具有相同的名字，相同的参数，相同的返回类型

2、super的使用可分为哪3种情况？

试结合程序说明。

答：

（1）用来访问父类被隐藏的成员变量

（2）用来调用父类中被重写的方法

程序如下：

classsuperClass{

Inty;

superclass（）{

y=30;

System.out.println（“insuperClass:

y=”+y）;}

VoiddoPrint（）{

System.out.println（“InsuperClass.doPrint（）”）;}

}

ClasssubextendssuperClass{

Inty;

Sub（）{

super（）;

y=50;

System.out.println（“insub:

y=”+y）;}

VoiddoPrint（）{

Super.doPrint（）;

System.out.println（“insub.doPrint（）”）;

System.out.println（“super.y=”+super.y+“sub.y”+y）;}

}

运行结果如下：

insuperClass:

y=30insub:

y=50

InsuperClass.doPrint（）

insub.doPrint（）super.y=30sub.y=50

（3）用来调用父类的构造方法

程序如下：

classA{

publicintn;

publicA（）{}

publicA（intn）{

this.n=n;

}

intmethod（）{

returnn;

}

}

publicclassBextendsA{

publicB（）{

super（18）;

}

publicstaticvoidmain（Stringargs[]）{

Aa=newB（）;

intb=a.method（）;

System.out.println（"类A中的成员变量：

"+b）;

}

}

3、上转型对象的特点有哪些？

试结合程序说明。

答：

1．上转型对象不能操作子类新增的成员变量和子类新增的方法

2.上转型对象可以操作子类继承或重写的成员变量，也可以使用子类继承或重写的方法

3.如果子类重写了父类某个方法后，当对象的上转型对象调用这个方法时一定是调用了这个重写的

方法，因为在运行时知道，这个上转型对象的实体是子类创建的，只不过损失了一些功能而已

程序如下：

classMammal{

privateintn=40;

voidcrySpeak（Strings）{

System.out.println（s）;}}

PublicclassMonkeyextendsMammal{

voidcomputer（intaa,intbb）{

intcc=aa*bb;

System.out.println（cc）;}

voidcrySpeak（Strings）{

System.out.println（“**”+s+“**”）;}

Publicstaticvoidmain（Stringargs[]）{

Mammalmammal=newMonkey（）;

Mammal.crySpeak（“Ilovethisgame”）;

Monkeymonkey=（Monkey）mammal;

Mputer（10,10）;

}}

运行结果如下：

**Ilovethisgame**100

注意：

在main（）方法里，如果出现下面的两行代码，那是错误的：

mammal.n=1000;//因为子类本来没有继承n

puter（10,10）;//因为computer方法是子类新增的方法

4、什么是编译时多态？

什么是运行时多态？

答：

1）编译时多态性（由方法重载实现的静态多态性）

对于多个同名方法,如果在编译时能够确定执行同名方法中的哪一个,则称为编译时多态性.

2）运行时多态性（由方法重写实现的动态多态性）

如果在编译时不能确定,只能在运行时才能确定执行多个同名方法中的哪一个,则称为运行时多态性

（重写方法的调用原则如下：

java运行时系统根据调用该方法的实例，来决定调用那个方法；对子类的一个实例，如果子类重写了父类的方法，则运行时系统调用子类的方法；如果子类继承了父类的方法（未重写），则运行系统调用父类的方法）

5、方法重写时应遵循的原则是什么？

答：

1.改写后的方法不能比被重写的方法有更严格的访问权限

2.改写后的方法不能比重写的方法产生更多的异常

6、抽象类和接口这两者的异同是什么？

它们分别是如何定义的？

答：

ava语言中，用abstract关键字来修饰一个类时，这个类叫做抽象类。

一个abstract类只关心它的子类是否具有某种功能,并不关心该功能的具体实现,功能的具体行为由子类负责实现的。

例如：

publicabstractclassDrawing{

publicabstractvoiddrawDot（intx,inty）;

publicvoiddrawLine（intx1,inty1,intx2,inty2）{

…………

}

}

用abstract来修饰一个方法时，该方法叫做抽象方法。

与final类和方法相反，abstract类必须被继承，abstract方法必须被重写。

当一个类的定义完全表示抽象的概念时，它不应该被实例化为一个对象。

例如Java中的Number类就是一个抽象类，它只表示数字这一抽象概念，只有当它作为整数类Integer或实数类Float等的父类时才有意义。

定义一个抽象类的格式如下：

abstractclassabstractClass{

……

}

由于抽象类不能被实例化，因此下面的语句会产生编译错误：

newabstractClass（）；

抽象类中可以包含抽象方法，为所有子类定义一个统一的接口，对抽象方法只需声明，而不需实现，因此它没有方法体。

其格式如下：

abstracreturnTypeabstractMethod（[paramlist））；

1、接口声明

我们曾使用class关键字来声明类，接口通过使用关键自interface来声明.

完整的接口定义格式如下：

[public]interfaceinterfaceName[extendslistOfSuperInterface]{

……

}

其中public修饰符指明任意类均可以使用这个接口，缺省情况下，只有与该接口定义在同一个包中的类才可以访问这个接口。

extends子句与类声明中的extends子句基本相同，不同的是一个接口可以有多个父接口，用逗号隔开，而一个类只能有一个父类。

子接口继承父接口中所有的常量和方法。

通常接口名称以able或ible结尾，表明接口能完成一定的行为，例如Runnable、Serializable。

、接口的使用

一个类通过使用关键字implements声明自己使用（或实现）一个或多个接口。

如果使用多个接口,用逗号隔开接口名。

如

classCalculateextendsComputerimplementsSummary,Substractable{

……

}

类Calculate使用了Summary和Substractable接口,继承了Computer类。

如果一个类使用了某个接口,那么这个类必须实现该接口的所有方法,即为这些方法提供方法体。

需要注意的如下：

1）在类中实现接口的方法时,方法的名字,返回类型,参数个数及类型必须与接口中的完全一致。

2）接口中的方法被默认是public,所以类在实现接口方法时,一定要用public来修饰。

3）另外,如果接口的方法的返回类型如果不是void的,那么在类中实现该接口方法时,方法体至少要有一个return语句。

如果是void型,类体除了两个大括号外,也可以没有任何语句.

7、接口的使用需要注意的几个事项。

答：

1.在类实现接口的方法时，方法的名字、返回类型、参数个数、参数类型必须与接口中的完全一致

2.接口中的方法被默认是public，所以类在实现接口的方法时，一定要用public来修饰

3.另外，如果接口的方法的返回类型不是void的，那么在类中实现该接口方法时，方法体至少要有一个return语句。

如果是void型，类体除了两个大括号外，也可以没有任何语句。

8、理解内部类和匿名类的概念和作用。

内部类有如下特性：

一般用在定义它的类或语句块之内,在外部引用它时必须给出完整的名称。

名称不能与包含它的类名相同。

可以使用包含它的外部类的静态成员变量和实例成员变量,也可以使用它所在方法的局部变量。

可以定义为abstract。

可以声明为private或protected。

若被声明为static,就变成了顶层类,不能再使用局部变量。

若想在内部类中声明任何static成员,则该内部类必须声明为