一、基础知识
1．简述使用文本编辑器和 JDK 创建并运行 Java 应用程序的基本步骤。
答：①打开文本编辑器输入 Java 源程序；
②保存文件，文件名为源程序中 public 修饰类的类名，扩展名为.java；
③打开命令行工具；
④编译程序，在命令行输入：javac 源程序文件名；
⑤运行程序，在命令行输入：java 源程序中 public 修饰的类名。
2. 对比分析 Java 与其它高级语言的编译和运行过程，说明 Java 具有平*立性的原因？
答：因为 Java 程序编译之后的代码不是能被硬件系统直接运行的代码，而是一种“中间码”——字节码。 然后不同的硬件平台上安装有不同的 Java 虚拟机(JVM)，由 JVM 来把字节码再“翻译”成所对应的硬件平 台能够执行的代码。因此对于 Java 编程者来说，不需要考虑硬件平台是什么。所以 Java 可以跨平台。 而 C/C++不可以跨平台的原因就是编译后的代码在特定的硬件上可以直接执行，换个硬件平台这些代码就 不能被执行了。不过正是因为可以直接执行，所以 C/C++程序的执行效率要比 Java 程序高
3.简述 break 和 continue 语句在使用时的区别？
4. Java 对标识符命名有什么规定？
答：Java 对标识符的命名规定如下：
1) Java 语言的标识符必须由字母、下划线(“_”)或美元符号(“$”)开始，其余字符可以是上述三种符 号或数字(0-9)。Java 语言使用 Unicode 字符集，所以字母包括‘A’-‘Z’、‘a’-‘z’以及 Unicode 字符 集中序号大于 0xC0 的所有符号。
2) 保留字不能用于标识符如：abstract boolean 等等。
3) 标识符区分大小写。
5. 请列出 Java 主要的基本数据类型。
答：Java 主要的基本数据类型有：
布尔型 boolean、字节型 byte、字符型 char、短整型 short、整 型 int、长整型 long、浮点型(单精度型)float、双精度型 double。
二、类和对象 1
1.什么是类？什么是对象？类和对象有何联系？
答：在面向对象程序设计里，类是定义一个对象的属性和方法的蓝本。对象就是一组变量和相关方法的 集合，其中变量表明对象的状态，方法表明对象所具有的行为。类是对象的模板，对象是类的实例，可以 从一个类中创建许多对象。
2.方法的重载和方法的覆盖有什么不同？
答：方法重载，指的是在类中创建多个具有相同名称，但使用不同参数的方法，Java 虚拟机根据传递给 方法的参数个数和类型决定调用哪个重载方法。方法的覆盖指在子类中重新定义父类中已有的方法，对于 重写的方法，运行时系统根据调用该方法的实例的类型来决定选择哪个方法调用。
3.类变量和实例变量有何区别？
答：由 static 修饰的变量称为类变量，当系统在程序中第一次遇到一个类时，便会拷贝一份所有的类变 量在内存里。然后那些由此类产生的实例便可分享这些类变量。 实例变量指不是用 static 修饰的变量，可供实例方法使用。实例变量会复制于每一个从类产生的实例中。
4.Java 的成员变量修饰符有哪几种？其中哪种修饰符限定的范围最大？
答：成员变量的修饰符有 public、protected、private、static、final、transient、volatile 七种。Public 修饰 符的限定范围最大。
5.说明对象的基本概念和主要特征？
答：对象是对客观世界实体及其实体关系的抽象。特点：
（1）以数据为中心；
(2)实现了数据封装；
（3）模块 独立性好；
（4）对象是主动的；
（5）本质上具有并行性。
三、类和对象 2
1.抽象类和抽象方法有什么特点？
答：① 一个抽象类里可以没有抽象方法，但含有抽象方法的类必定为抽象类。
② 抽象类不能被实例化为对象，而只能作为其它类的超类，并且必须被继承。
③ 若某子类继承自一个抽象类，而该子类不是抽象类，则子类需用覆盖的方式来实例化超类中的所有抽象 方法。抽象方法可再与 public、protected 复合使用，但不能与 final、private 和 static 复合使用。
④ 抽象方法只有方法声明，不能有方法体。
2.接口和抽象类有什么区别？
答：从本质上讲，接口是一种特殊的抽象类，然而它们又有区别：
①接口只包含常量，而抽象类则不一定。
②接口中不能有非抽象的方法，但抽象类中可以有。
③一个类能实现多个接口，但只能有一个父类。
④接口并不属于继承结构，它实际与继承无关，无关的类可以实现同一个接口。
3.什么是包？为什么要使用包？
答：包（package）是类的容器。由于 Java 编译器为每个类生成一个字节码文件，且文件名与类名相同， 因此同名的类有可能发生冲突。为了解决这一问题，Java 提供包来管理类名空间。此外一旦创建了一个类， 并想重复地使用它，那么把它放在一个包中将是非常有效的。
4．简述在类的继承关系中，子类可以继承父类的哪些成员，不能继承的有哪些成员。
答：可继承：①父类中公开级的成员；②父类中保护级的成员；③如果子类和父类在同一个包中，则子 类继承父类中缺省的包访问级的成员。
不可继承：④父类中私有级的成员；⑤不在同一包的缺省成员和父类的同名成员。
多态
多态：相同类型的变量，调用相同的方法，执行的具体代码却不同的现象称为多态 继承与多态表现形式：变量隐藏 (属性的不同表现)方法重写(方法的不同表现) 上转型对象(实例的不同表 现) 方法的覆盖
规则：父类和子类方法同名；返回值类型形同；参数类型顺序相同；子类方法的权限不小于父类方法权限； 子类方法只能抛出父类方法声明抛出的异常或异常子类。（异常应比父类方法更具体）p119 继承关系图 注意：子类只有在能够访问到父类方法时才能对该方法进行重写
函数重载：函数名称相同，函数的参数个数不同或参数类型不同或参数顺序不同
四、异常
1.Error 类和 Exception 类有什么区别？
答：Error 类及 Exception 类是 Throwable 类的两个直接子类。Error 类描述的是内部系统错误，包括动态 链接失败、虚拟机错误等，Java 程序不做处理。Exception 类描述的是程序和外部环境引起的错误，这些错 误能通过程序捕获和处理，Exception 类是 Java 程序中需要大量处理的。
2.什么是异常？为什么要进行异常处理？
答：异常，是指由于程序运行时发生错误，从而导致程序错误结束。 在进行程序设计时，错误的产生是不可避免的，没有异常处理代码的程序，在运行时发生错误则可能非正 常结束，引起严重问题。因此，Java 给程序员提供了处理运行时错误的功能，称为异常处理。
3.简述异常处理的过程。
答：程序运行时出现错误时，创建异常对象，抛出异常对象，捕获该异常对象并进行处理。
4.写出下列关键字的意义和运用场合：①final；②finalize；③finally。
答：final, finally, finalize 的区别如下： final 用于声明属性、方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。 finally 是异常处理语句结构的一部分，表示总是执行。 finalize 是 Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提 供垃圾收集时的其他资源回收，例如关闭文件等。
五、常用类库
1.Vector 对象的大小与容量之间有什么区别？
答：一个 Vector 对象的大小是包含的 Object 引用的实际数量。而容量是指为 Object 引用分配的存储空间 的数量。
2.String 类和 StringBuffer 类的主要区别是什么？
答：String 类：用于比较两个字符串，查找和抽取串中的字符或子串，字符串与其他类型的转换等，String 类对象的内容一旦被初始化就不能再改变。StringBuffer 类：用于内容可以改变的字符串，可以将其他各种 类型的数据增加、插入到字符串中，也可以翻转字符串中原来的内容。
七、输入输出流
1．简述读写文本文件的基本步骤。
①导入输入/输出包；
②创建文件对象；
③创建读出/写入操作的对象；
④数据文件的读/写操作；
⑤关闭文 件。
1. 编写一个 Application，接受用户从键盘输入的 10 个整数，并输出这 10 个整数的最大值和最小值。
import java.io.* ;
public class abc
{
public static void main(String args[ ])
{ int i , n = 10 , max = 0 , min = 0 , temp = 0;
try {
BufferedReader br = new BufferedReader( new InputStreamReader(System.in));
max = min = Integer.parseInt(br.readLine( ));
} catch ( IOException e ) { } ;
for ( i = 2 ; i <= n ; i ++ ) {
try {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
temp = Integer.parseInt(br.readLine( ));
if (temp > max ) max=temp;
if (temp < min) min=temp;
} catch ( IOException e ) { } ;
}
System.out.println("max="+max+"\nmin="+min);
}
}
1. 编写一个 Application，从键盘输入整数 n，并计算从 1 到 n 的累加和。
import java.io.*;
public class Application1 {
public static void main(String[] args) {
String s = "";
int n, sum = 0;
System.out.println("计算从 1 到 n 的累加和。");
System.out.print("请输入 n 的值：");
// 从键盘读入字符串 s
try {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr); s = br.readLine();
}
catch(Exception e) { }
// 将字符串 s 转为整型数 n
n = Integer.parseInt(s);
// 计算 1 到 n 的累加和
for(int i=1; i<=n; i++) sum += i;
// 输出结果
System.out.println("你刚才的输入是：" + n);
System.out.println("1 到 n 的累加和是：" + sum);
}
}
2．import java.io.* ;
public class Reverse { public static void main(String args[ ])
{ int i , n =10 ;
int a[ ] = new int[10];
for ( i = 0 ; i < n ; i ++ )
try {
BufferedReader br = new BufferedReader( new InputStreamReader(System.in)); a[i] = Integer.parseInt(br.readLine( )); // 输入一个整数
} catch ( IOException e ) { } ;
for ( i = n－1 ; i >= 0 ; i ―― )
System.out.print(a[i]+" ");
System.out.println( );
}
}
从标准输入(即键盘)读入 10 个整数存入整型数组 a 中，然后逆序输出这 10 个整数。
import java.io.*;
public class Class1
{
public static void main(String args[ ]){
int i , Max , Min ;
int a[ ] = { 12,67,8,98,23,56,124,55,99,100 };
Max = Min = a[0];
for ( i = 1 ; i < a.length; i ++ ) {
if ( a[i]<Min ) Min = a[i];
if ( a[i]>Max ) Max = a[i];
}
System.out.println( Max+" "+Min );
System.out.println( );
}
}
编写一个完整的 Java Applet 程序使用复数类 Complex 验证两个复数 1+2i 和 3+4i 相加产生一个新 的复数 4+6i 。
复数类 Complex 必须满足如下要求：
(1) 复数类 Complex 的属性有： RealPart : int 型，代表复数的实数部分 ImaginPart : int 型，代表复数的虚数部分
(2) 复数类 Complex 的方法有： Complex( ) : 构造函数，将复数的实部和虚部都置 0 Complex( int r , int i ) : 构造函数，形参 r 为实部的初值，i 为虚部的初值。 Complex complexAdd(Complex a) : 将当前复数对象与形参复数对象相加，所得的结果仍是一个复数值， 返回给此方法的调用者。 String ToString( ) : 把当前复数对象的实部、虚部组合成 a+bi 的字符串形式，其中 a 和 b 分别为实部和 虚部的数据。
答：参考程序如下：
import java.applet.* ;
import java.awt.* ;
public class abc extends Applet
{
Complex a,b,c ;
public void init( )
{
a = new Complex(1,2);
b = new Complex(3,4); c = new Complex();
}
public void paint(Graphics g)
{
c=a.complexAdd(b);
g.drawString("第一个复数："+a.toString(),10,50);
g.drawString("第二个复数："+b.toString(),10,70);
g.drawString("两复数之和："+c.toString(),10,90);
}
}
class Complex
{
int RealPart ; // 复数的实部
int ImaginPart ; // 复数的虚部
Complex() { RealPart = 0 ; ImaginPart = 0 ; }
Complex(int r , int i)
{ RealPart = r ; ImaginPart = i ; }
Complex complexAdd(Complex a)
{
Complex temp = new Complex( ); // 临时复数对象
temp.RealPart=RealPart+a.RealPart;
temp.ImaginPart=ImaginPart+a.ImaginPart; return temp;
}
public String toString( )
{ return ( RealPart+" + "+ImaginPart+" i "); }
}
4． 编写一个学生类 Student ，要求：
(1) 学生类 Student 属性有： id : long 型，代表学号 name : String 类对象，代表姓名 age : int 型，代表年龄 sex : boolen 型，代表性别（其中：true 表示男，false 表示女） phone : String 类对象，代表联系电话
(2) 学生类 Student 的方法有：
Student(long i , String n , int a , boolean s , long p) : 有参构造函数，形参表中的参数分别初始化学号、姓名、 年龄、性别和联系电话。
int getAge() ( ) : 获取年龄作为方法的返回值。
boolean getSex( ) ( ) : 获取性别作为方法的返回值。
long getPhone ( ) : 获取联系电话作为方法的返回值。
public String toString( ) : 以 姓名：联系电话 的形式作为方法的返回值。
答：参考程序段如下：
class Student {
long id;
String name;
int age;
boolean sex;
long phone;
Student( long i , String n , int a , boolean s , long p ){
id = i; name = n; age = a; sex = s;
phone = p;
}
int getAge(){ return age; }
boolean getSex(){ return sex; }
long getPhone() { return phone; }
public String toString(){ return name+" : "+phone; }
}
1. 什么叫构造函数重载？
答：是指同一个类中存在着若干个具有不同参数列表的构造函数。
2. Java 语言有什么特点？
答：平台无关性、面向对象、安全稳定、支持多线程、简单易学
3. Java Applet 的基本工作原理是什么？
答：编译好的字节码文件保存在特定的 WWW 服务器上，当某一个浏览器向服务器请求下载嵌入了 Applet 的 HTML 文件时，该文件下载到客户端由浏览器解释 HTML 标记；当遇到 HTML 特殊的 Applet 标记时， 浏览器回自动根据 Applet 的名字和位置把字节码下载到本地，由浏览器本身拥有的 Java 解释器直接执行。
4. 什么叫多线程？Java 支持多线程有何意义？
答：多线程是指同时存在几个执行体，按几条不同的执行路线共同工作的情况。Java 支持多线程使得编程 人员可以方便地开发同时处理多任务的功能强大的程序，更好地解决现实世界的具体问题。
5. 什么是接口？如何定义接口？
答：接口是用来定义类间多重继承功能的结构。接口声明的语法：
[public] interface 接口名 [extends 父接口名列表]
{ //接口体
//常量域说明
[public] [static] [final] 域类型 域名 = 常量名；
//抽象方法声明
[public] [abstract] [native] 返回值 方法名（参数列表） [throw 异常列表]；
1．设计一个圆类，将圆的位置(圆心坐标和半径）作为属性（提供任意圆的设置），并能计算圆的面积。
public class MyCircle {
double x,y,r;
final double pi = 3.1415926;
MyCircle(double x, double y, double r)
{
this.x = x;
this.y = y;
this.r = r;
}
public double getArea()
{
return pi*r*r;
}
public static void main(String[] args) {
}
}
平台无关性与可移植性
程序的可移植性指的是程序不经修改而在不同硬件或软件平台上运行的特性，可移植性在一定程度上 决定了程序的可应用性。可移植性可分两个层次：源代码级可移植性和二进制可移植性。Java 不仅是源代 码级可移植的，甚至源代码经过编译之后形成的二进制代码——字节码，也同样是可移植的。
Java 采用了多种机制来保证可移植性，其中最主要的有两条：
第一，Java 既是编译型又是解释型的。Java 将源程序编译成字节码——二进制代码，这种字节码通过 Java 解释器来解释执行。任何一台机器，只要配备了 Java 解释器，就可以运行 Java 字节码，而不管这种字 节码是在何种平台上生成的。这不仅使开发的 Java 源代码是可移植的，甚至源代码经过编译之后形成的二 进制代码——字节码，也同样是可移植的。Java 源程序编译生成的字节码不是直接在操作系统平台上运行， 而是在一个称为 Java 虚拟机（JVM）的平台上运行。利用 JVM 把 Java 字节码跟具体的软硬件平台分隔开 来，就能保证在任何机器上编译的 Java 字节码文件都能在该机上运行。
第二，Java 采用的是基于国际标准——IEEE 标准的数据类型。Java 的数据类型在任何机器上都是一致 的，它不支持特定于具体的硬件环境的数据类型，它还规定同一种数据类型在所有各种实现中必须占据相 同的空间大小。此外，Java 的可移植性还体现在 Java 的运行环境上。Java 编译器是用 Java 语言本身所编写 的，而其他运行时环境则是用 ANSI C 编写的，整个运行时环境体现了一个定义良好的可移植性接口。最 后，Java 语言规范遵循 POSIX 标准，这也是使 Java 具有良好可移植性的重要原因。
强制类型转换
强制类型转换是指在一个表达式中出现的各种变量或常量的数据类型不同时，所进行的数据类型转换 （casting conversion）。Java 程序中的类型转换可分为显式类型转换和隐式类型转换两种形式。
（1）隐式类型转换。对于由双目运算中的算术运算符组成的表达式，一般要求运算符两边的两个操作 数的类型一致，如果两者的类型不一致，则系统会自动转换为较高（即取值范围较大）的类型，这便是隐 式数据类型转换。
根据操作数的类型，隐式转换的规则如下： (byte 或 short)与 int 型运算，转换为 int 型；
(byte 或 short 或 int)与 long 型运算，转换为 long 型；
(byte 或 short 或 int 或 long)与 float 型运算，转换为 float 型
(byte 或 short 或 int 或 long 或 float)与 double 型运算，转换为 double 型；
char 型或 int 型运算，转换为 int 型。
（2）显式类型转换。隐式类型转换只能由较低类型向较高类型转换，但是在实际工作中，有时也可能 需要由较高类型向较低类型转换。例如，我们在计算数值时为了保证其精度，为某些变量取了较高的数据 类型（如 double 型），但在输出时，往往只需要保留两、三位小数或者只输出整数，这时只能进行显式类 型转换。
显式类型转换需要人为地在表达式前面指明所需要转换的类型，系统将按这一要求把某种类型强 制性地转换为指定的类型，其一般形式如下： (<类型名>)<表达式>