public int addMe(int x. int y, int z){
1、class MyThread extends Thread {
public void run(){
System.out.printin("MyThread: run()");
}
public void start() {
System.out.println("MyThread: start()");
}
class MyRunnable implements Runnable {
public void run(){
System.out.println("MyRunnable: run()");
}
public void start() {
System.out.println("MyRunnable: start()");
}
}
public class Mylest {
public static void main(String args[]){
MyThread myThread = new MyThread();
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
my Thread.start();
thread.start();
}
}
A.打印MyThread: start() 后面跟 MyRunnable: run()
B.打印MyThread: run() 后面跟MyRunnable: start()
C.打印MyThread: start() 后面跟MyRunnable: start()
D.打印MyThread: run() 后面跟MyRunnable: run()
答案：A
2、// 文件名:SuperclassX.java
package packageX;
public class SuperclassX{
protected void superclassMethodX(){}
int superclassVarX;
}
//文件名:Subclass Y.java
1.package packagex packageY;
2.
3.public class SubclassY extends SuperclassX
4.{
5. SuperclassX objX = new SubclassY();
6. SubclassY objY=new SubclassY();
7. void subclasslMethodY()
8. {
9. objY.superclassMethodx();
10. int i;
11. i= objY.superclass VarX;
12. }
12. }
A.第5行编译错
B.第9行编译错
C.第11行意外
D.都不是
答案：D
3、程序段如下:
1.class MyClass
2.{
3.void myMethod(int i) {System.out.printn("int version");}
4.void myMethod(string s){System.out.println("String version"');}
5.public static void main(String args[])
6.{
7. MyClass obj= new MyClass();
8. char ch ='c';
9. obj.myMethod(ch);
10.}
11.}
A.第四行编译出错
B.第九行抛出例外
C.输出结果：int version
D.输出结果：String version
答案：C
4、publie class ThrowsDemo {
static void throwMethodO {
System.out.println("Inside throwMethod");
throw new lllegalAccessException("demo");
}
public static void main(String args[]){
try{
throwMethod();
}catch (lllegalAccessException e){
System.outprintln("Caught " + e);
}
}
}
A.编译错
B.运行错
C.编译成功，但是没有输出结果
D.以上都不是
答案：A
5、class X{
Y b=new Y();
x(){
System.out.print("X");
}
}
class Y{
Y() {
System.out.print("Y");
}
}
public class Z extends X{
Y y=new Y();
Z(){
System.out.print("Z");
}
public static void main(String[] args){
new Z();
}
}
A.Z
B.YZ
C.XYZ
D.YXYZ
答案：D
6、public class MyThread implements Runnable {
String myString= "Yes "；
public void run() {
this.myString ="No ";
}
public static void main(String[] args){
MyThread t =new MyThread();
new Thread(t).start();
for (int i=0,; i< 10; i++)
System out.print(t.myString);
}
A.打印yes yes yes yes yes yes
B.打印no no no no no no no no
C.打印yes no yes no ye no ye no
D.不确定
答案：D
1、下面( )是正确的接口。
A、interface A
{
Void print(){ };
}
B、abstract interface A
{
print();
}
C、{
Abstract vpid print(){};
}
D、interface A
{
void print();
}
答案：D
2、在异常处理中，如释放资源、关闭文件、关闭数据库等由（ ）来完成。
A.try子句
B.catch子句
C.finally子句
D.throw子句
答案：C
3、当方法遇到异常又不知如何处理时，下列哪种说法是正确的（ ）。
A.捕获异常
B.抛出异常
C.声明异常
D.嵌套异常
答案：C
4、关键字( )可以抛出异常？
A.transient
B.throws
C.throw
D.static
答案：C
5、下面是一个有错的程序:
1 package payroll;
2 class EmployeeNames {
3 public static String[] names={"a","b"};
4 public static String[] getNames(){
5 return names;
6 }
7 }
另一个文件
8 package client
9 import payroll.EmployeeNames;
10 public class TraderNames extends EmployeeNames{
11 public String[] traders ={"e","d"};
12 }
下面有四个改正项，哪个答案能改正程序?( )
A.8 package client;
B.2 protected class EmployeeNames{
C.1 package paryroll;
D.9 import payroll.EmployeeNames
答案：A
6、 String str = " Java"
StringBufer buffer = new StringBuffer(str);
if(str.equals(buffer)){
System.outprintln("Both are equal");
}else{
System.out.println("Both are not equal");
}
A.both are not equal
B.both are equal
C.编译错
D.运行错
答案：A
7、class Parent{
private void method1(){
System.out.println("Parent's method1()");
}
public void method2(){
System.out.println("Parent's method2()");
method1();
}
}
class Child extends Parent {
public void method1(){
System.out.println("Child's method1()");
}
public static void main(String args[]){
Parent p = new Child();
p.method2();
}
}
A.编译错
B.运行错
C.打印parent’s method2() parent’s method1()
D.打印 parent’s method2() child’s method1()
答案：C
8、下面程序段的编译和运行的结果是什么?
String s1 = new String(" Test");
String s2 = new String("Test");
if(s1==s2) System.out.println("Same");
if (s1 equals(s2)) System.out.println("Equals");
A.Same Equal
B.Equals
C.Same
D.编译错
答案：B
9、那一行的输出结果是 false?
1. public class MyClass
2. {
3. static String s1 = "I am unique!";
4. public static void main(String args[])
5. {
6. String s2 = "I am unique!";
7. String s3 = new String(s1);
8. System.out.println(s1==s2);
9. System.out.println(s1.equals(s2));
10. System.out.printn(s3 ==s1);
11. System.out.println(s3 .equals(s1));
12. System.out.println(TestClass.s4 ==s1):
13. }
14.}
15.
16.class TestClass
17.{
18. static String s4 = "I am unique!";
19.}
A.10 和12行
B.12行
C.8和１０行
D.都不是
答案：D
1、指出下列程序运行的结果()
public class Example{
String str=new string("good");
char [] ch={'a','b','c'};
public static void main(string args []){
Example ex=new Example();
ex.change(ex,str,ex,ch);
System.out.print(ex.str+"and");
System.out.print(ex.ch);
}
public void change(String str,char ch []){
str="test ok",
ch [0]='g'
}
}
A.good and abc
B.good and gbc
C.test ok and abc
D.test ok and gbc
答案：B
2、运行下列程序，会产生的结果是()
public class X extends Thread implements Runable{
public void run() {
System.out.println("this is run()");
}
public static void main(String args [])
}
Thread t=new Thread(new X());
t.start();
}
}
A.第一行会产生编译错误
B.第六行会产生编译错误
C.第六行会产生运行错误
D.程序会运行和启动
答案：A
3、对于catch子句的排列，下列哪种是正确的( )
A.父类在先，子类在后
B.子类在先，父类在后
C.有继承关系的异常不能在同一个try程序段内
D.先有子类，其他如何排列都无关
答案：A
4、J2SDK的下载，下列哪步可进入J2SE下载页面( )
B.点击左侧“Download”链接
C.点击页面中的“Java 2 Platform,Standard Edition”了；链接
D.点击页面中“J2SE 1.4.2”链接
答案：C
5、 Java中，数值类型值中可能出现的符号是( )
A.R
B.D
C.T
D.Y
答案：B
6、构造方法何时被调用( )
A.类定义时
B.创建对象时
C.调用对象方法时
D.使用对象的变量时
答案：B
7、下面的表达式中正确的是( )
A.String s=″你好″;int i=3;s+=i;
B.String s=″你好″;int i=3;if(i==s){s+=i};
C.String s=″你好″;int i=3;s=i+s;
D.String s=″你好″；int i=3;s=i+;
答案：A
8、哪个布局管理器使用的是组件的最佳尺寸( )
A.FlowLayout
B.BorderLayout
C.GridLayout
D.CardLayout
答案：A
9、在异常处理中，如释放资源、关闭文件、关闭数据库等由( )来完成。
A.try子句
B.catch子句
C.finally子句
D.throw子句
答案：C
10、要从文件″file.dat″文件中读出第10个字节到变量C中，下列哪个方法适合( )
A.FileInputStream in=new FileInputStream(″file.dat″);in.skip9.;int c=in.read();
B.FileInputStream in=new FileInputStream(″file.dat″);in.skip10.;int c=in.read();
C.FileInputStream in=new FileInputStream(″file.dat″);int c=in.read();
D.RandomAccssFile in=RandomAccssFile(″file.dat″);in.skip9.;int c=in.readByte();
答案：A
11、如果任何包中的子类都能访问超类中的成员，那么应使用哪个限定词( )
A.public
B.private
C.protected
D.transient
答案：C
12、运行下列程序的结果是()
abstract class MineBase{
abstract void amethod();
static int i;
}
public class Mine extends MineBase
{
public static void main(String args[ ]) {
int [] ar new int [5];
for(i=0;i System.out.println(ar );
}
}
A.打印5个0
B.编译出错，数组args[]必须初始化
C.编译出错，Mine应声明为abstract
D.出现IndexOutOfBoundes的例外
答案：C
13、下列运算结果默认为float的是( )
A.100/10
B.100*10
C.100F+10
D.100D-10
答案：A
14、 下列语句byte b=011;System.out.priftln(b);输出结果为( )
A.B
B.11
C.9
D.1
答案：C
15、在Java中，不属于整数类型变量的是( )
A.double
B.long
C.int
D.byte
答案：A
16、下面属于Java关键字的是( )
A.NULL
B.IF
C.do
D.goto
答案：C
17、下面哪个语句是正确的( )
A.Object o=new Button(″A″);
B.Button b=new Object(″B″);
C.Panel p=new Frame();
D.Frame f=new Panel();
答案：A
18、Java语言中，下列标识符错误的是( )
A.diss
B.—name
C.&count
D.—j
答案：C
19、Java变量中，以下不属于复合类型的数据类型是( )
A.类
B.字符型
C.数组型
D.接口
答案：B
20、Java中哪个类提供了随机访问文件的功能( )
A.RandomAccessFile类
B.RandomFile类
C.File类
D.AccessFile类
答案：A
1、java里面表示字符串的类有两种：String和（ ）。
A.Buffer
B.StringBuffer
C.DataBuffer
D.BufferString
答案：B
2、以下程序段的结果是: ( )
char a[]= {'a', 'b','c', 'd'};
char b[]= new char[4];
b=a;
for (inti= 3;i> 0; i--)
System.out.print((char)b);
A.abcd
B.dcba
C.abc
D.dcb
答案：D
3、以下程序段的结果是: ()
String str= "abcdefehijk";
String s= "bcde";
int index = 0;
index= str.indexOf(s, index);
str=str.substring(0, index)+ str.substring(index+4);
System.out.println(str);
A.abcdefghijk
B.afghijk
C.abcde
D.bcdefghijk
答案：B
一、 简答
1、 简述Java语言的主要特点。
答案：Java语言有下面一些特点：简单、面向对象、分布式、解释执行、健壮、安全、体系结构中立、可移植、高性能、多线程以及动态性。Java语言有下面一些特点：简单、面向对象、分布式、解释执行、健壮、安全、体系结构中立、可移植、高性能、多线程以及动态性。
2、 简述Java程序的可移植性。
答案：与平台无关的特性使Java程序可以方便地被移植到网络上的不同机器。同时，Java的类库中也实现了了与不同平台的接口，使这些类库可以移植。另外，Java编译器是由Java语言实现的，Java运行时系统由标准C实现，这使得Java系统本身也具有可移植性。 “Write once, run everywhere”也许是Java最诱人的特点。用Java开发成的系统其移植工作几乎为零，一般情况下只需对配置文件、批处理文件作相应修改即可实现平滑移植。
二、 判断
3、J2EE（Java 2 Platform Enterprise Edition）企业版是以企业为环境而开发应用程序的解决方案。（）
A.正确
B.错误
答案：对
4、J2ME（Java 2 Platform Micro Edition）——小型版是致力于消费产品和嵌入式设备的最佳解决方案。（）
A.正确
B.错误
答案：对
5、J2SE（Java 2 Platform Standard Edition）——标准版为桌面开发和低端商务应用提供了可行的解决方案。（）
A.正确
B.错误
答案：对
6、Java是区分大小写的语言，关键字的大小写不能搞错，如果把类class写成Class或者CLASS，都是错误的。（）
A.正确
B.错误
答案：对
7、Java源程序编写好之后，以文件的形式保存在硬盘或U盘上，源文件的名字可以随便取的，它不一定与程序的主类名一致。（）
A.正确
B.错误
答案：错
8、在JDK命令行开发工具中，用编译程序javac.Exe编译生成的文件是二进制可执行文件。（）
A.正确
B.错误
答案：错
9、Java程序可以分为Java Application和Java Applet两类，这两类程序的运行方式是相同的。（）
A.正确
B.错误
答案：错
10、操作系统Microsoft Wndows95／98/2000／XP/2003、Linux、UNIX、Mao OS等都是支持Java虚拟机的操作系统。（）
A.正确
B.错误
答案：对
11、 Javac是Java编译器，用来将Java源程序编译成Java字节码的程序。字节码文件名和源文件名相同，扩展名是．class。（）
A.正确
B.错误
答案：对
12、appletviewer 是Java小程序浏览器，可以执行HTML文件中的 Java小程序， Applet。它是个模拟浏览器，可以显示Applet的运行结果。（）
A.正确
B.错误
答案：对
一、简答
1、在JBuilder 9集成开发环境建立你的工程文件名myjava.jpx,把myfirstapp.java添加到myjava.jpx，并运行看结果。
答案：略
2、在你的D盘或E盘建立子文件夹myjava，用写字板编辑一个Java程序myfirstapp.java，保存在myjava目录下。程序实现在屏幕显示“你好，这是我的第一个Java程序。”分别用Java Application和Java Applet 2种形式实现。
答案：略
3、简述保留字。
答案：保留字（关键字）是Java语言本身使用的标识符，它有其特定的语法含义。所有的Java关键字将不能被当作一般的标识符使用。如：for、while、boolean等都是Java语言的保留字关键字。
4、简述标识符。
答案：在Java源程序代码中程序员需要标识和使用的各种元素如变量、函数、类和对象的名称就是标识符（identifier）。包括：包名称、类名、变量名、常量名、标号、方法名等。标识符要符合下面的规则。
一、 简答
1、简述Java的基本数据类型。
答案：基本数据类型包括: integer(整数)，floating (浮点数)， Boolean (布尔变量)，Character or String(字符或字符串)。
2、简述Java的表达式和运算符。
答案：表达式是由标示符、常量、变量和运算符组成，是程序的基本组成部分。 运算符指明对各种操作数所进行的运算，Java提供了丰富的运算符，Java语言的基本运算符分为算术运算符、逻辑运算符、关系运算符和位运算符4大类。同时也可以使用圆括号将一个表达式的几个部分组合到一起，并根据标准的代数规则建立优先地位。
3、简述Java的方法（method）。
答案：方法（method）是类的一个成员，它和面向过程程序设计中的函数有很多类似之处。由于它是类的一个重要组成部分。
二、 判断
4、若循环变量在for语句前面已经有定义并具有循环初值，则初始语句可以为空（分号不可省略）。（）
A.正确
B.错误
答案：对
5、do…while循环的执行过程是无条件执行循环体一次，在根据判断条件决定是否继续执行循环体。（）
A.正确
B.错误
答案：对
6、Java语言的任何类型，包括整型、浮点型、字符和布尔型都可以使用运算符“＝＝”来比较是否相等，用运算符“！＝”来判断是否不等。（）
A.正确
B.错误
答案：对
7、Java语言提供了三个专门的循环控制语句：for语句、while语句和do…while语句。（）
A.正确
B.错误
答案：对
8、Java语言提供了三个专门的循环控制语句：for语句、while语句和do…while语句。（）
A.正确
B.错误
答案：对
9、程序中的break语句是用于退出switch的，若无则程序将不再比较而是依次执行所有语句。（）
A.正确
B.错误
答案：对
一、 简答
1、编写一个程序，随机产生10个小写字母，并判断是元音字母、半元音字母还是复音字母。
答案：如图所示<img src="https://qitem.jxjypt.cn/course/upload/image/20220816/1660640116090035186.png" title="image.png" alt="image.png"/><img src="https://qitem.jxjypt.cn/course/upload/image/20220816/1660640131770021406.png" title="image.png" alt="image.png"/>
2、编写程序，找出50~100之间的所有素数。
答案：如图所示
3、什么是类？什么是对象？类和对象有何联系？
答案：在面向对象程序设计里，类是定义一个对象的属性和方法的蓝本。对象就是一组变量和相关方法的集合，其中变量表明对象的状态，方法表明对象所具有的行为。类是对象的模板，对象是类的实例，可以从一个类中创建许多对象。
4、方法的重载和方法的覆盖有什么不同？
答案：方法重载，指的是在类中创建多个具有相同名称，但使用不同参数的方法，Java虚拟机根据传递给方法的参数个数和类型决定调用哪个重载方法。方法的覆盖指在子类中重新定义父类中已有的方法，对于重写的方法，运行时系统根据调用该方法的实例的类型来决定选择哪个方法调用。
5、类变量和实例变量有何区别？
答案：由static修饰的变量称为类变量，当系统在程序中第一次遇到一个类时，便会拷贝一份所有的类变量在内存里。然后那些由此类产生的实例便可分享这些类变量。 实例变量指不是用static修饰的变量，可供实例方法使用。实例变量会复制于每一个从类产生的实例中。
6、抽象类和抽象方法有什么特点？
答案：① 一个抽象类里可以没有抽象方法，但含有抽象方法的类必定为抽象类。 ② 抽象类不能被实例化为对象，而只能作为其它类的超类，并且必须被继承。 ③ 若某子类继承自一个抽象类，而该子类不是抽象类，则子类需用覆盖的方式来实例化超类中的所有抽象方法。抽象方法可再与public、protected复合使用，但不能与final、private和static复合使用。 ④ 抽象方法只有方法声明，不能有方法体。
二、 判断
7、若循环变量在for语句前面已经有定义并具有循环初值，则初始语句可以为空（分号不可省略）。（）
A.正确
B.错误
答案：对
8、do…while循环的执行过程是无条件执行循环体一次，在根据判断条件决定是否继续执行循环体。（）
A.正确
B.错误
答案：对
9、标号提供了一种简单的break语句所不能实现的控制循环的方法，当在循环语句中遇到break后面有标号时，不管其它控制变量如何，都会终止标号的循环体。（）
A.正确
B.错误
答案：对
10、Java的类库是系统提供的已实现的标准类的集合，是Java编程的API，它可以帮助开发者方便、快捷地开发Java程序。（）
A.正确
B.错误
答案：对
11、Java的基础类库包java.Lang也要经过import语句引用。（）
A.正确
B.错误
答案：错
12、Java程序中使用 import java.io.*;表示要引入带*的类。（）
A.正确
B.错误
答案：错
13、Java.awt包是 Java语言用来构建图形用户界面（GUI）的类库，它包括了许多界面元素和资源，主要在 3个方面提供界面设计支持：低级绘图操作；图形界面组件和布局管理和界面用户交互控制和事件响应。（ ）
A.正确
B.错误
答案：对
14、Vector the Vecto =new Vector(100,100);这个语句创建了名称为the Vector的向量类对象，它的每个成员的容量为100，共有10个元素。（）
A.正确
B.错误
答案：错
1、编译并运行下面的程序，运行结果为()
publie class 11
{
public static void main (Sting[] args)
{
T1 a=new T1();
a.method(8);
a.method(1,2f);
}
void method(float i)
{
System.out.println( "foat: "+i);
}
void method(long i)
{
System.out.println(" long: "+i);
}
}
(2)定义类A和类B如下:
class A
{
int a=1;
double d=2.0;
void show()
{
System.out.println( "Class A:a= "+a+"td="+d);
}
}
dass B extends A
{
float a=3.0f;
String d="Java program.";
void show()
{
super.show();
System.out.println( "Class B: a= "+a+"\td="+d);
}
}
(1)若在应用程序的main方法中有以下语句:
A a=new A();
a.show();
则输出的结果如何?
(2)若在应用程序的main方法中定义类B的对象b:
A b=new B():
b.show();
则输出的结果如何？
答案：如图所示<img src="https://qitem.jxjypt.cn/course/upload/image/20220816/1660640324092057726.png" title="image.png" alt="image.png"/>
二、 填空
2、在子类中使用关键字_______做前缀可调用被子类覆盖的父类中的方法。
答案：super
3、Java中所有类都是_______类的子类。
答案：Object
4、通过_______运算符就能实现对对象成员变量的访问和对象方法的调用。
答案：圆点
5、类的构造方法的名称必须与_______名相同。
答案：类
6、类方法只能处理用关键字_______修饰的对象。
答案：static
一、简答
1、Java的成员变量修饰符有哪几种？其中哪种修饰符限定的范围最大？
答案：答：成员变量的修饰符有public、protected、private、static、final、transient、volatile七种。Public修饰符的限定范围最大。
2、写出下列关键字的意义和运用场合：①final；②finalize；③finally。
答案：答：final,finally,finalize的区别如下：final用于声明属性、方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。finally是异常处理语句结构的一部分，表示总是执行。finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。
3、作用域public,private,protected,以及不写时的区别
答案：如图所示
4、请定义一个名为Card的扑克牌类，该类有两个private访问权限的字符串变量face和suit：分别描述一张牌的牌面值（如：A、K、Q、J、10、9、…、3、2等）和花色（如：“黑桃”、“红桃”、“梅花”和“方块”）。定义Card类中的public访问权限的构造方法，为类中的变量赋值；定义protected访问权限的方法getFace()，得到扑克牌的牌面值;定义protected访问权限的方法getSuit()，得到扑克牌的花色;定义方法toString()，返回表示扑克牌的花色和牌面值字符串（如“红桃A”、“梅花10”）。
答案：<p>如图所示<img src="https://qitem.jxjypt.cn/course/upload/image/20220817/1660704626067060201.png"title="image.png"alt="image.png"/></p>
二、判断
5、内部类可以访问外层类的任何变量，包括私有的。（）
A.正确
B.错误
答案：对
6、匿名类可以有构造器,声明时候不能带参数。（）
A.正确
B.错误
答案：错
7、抽象方法可以是static的。（）
A.正确
B.错误
答案：错
8、构造器没有任何返回类型，哪怕是void也不行。（）
A.正确
B.错误
答案：对
9、只要类中显式地定义一个，那么Java不会再为你定义一个默认的构造器。（）
A.正确
B.错误
答案：对
10、构造方法可以被继承。（）
A.正确
B.错误
答案：错
11、方法的参数变量不能是final的（）
A.正确
B.错误
答案：错
12、一个Java类可以有多个父类，这称作多继承．（）
A.正确
B.错误
答案：错
1、abstract class Name {
private String name;
public abstract boolean isStupidName(String name){}
}
A.正确
B.错误
答案：B
2、abstract class Something {
private abstract String doSomething();
}
A.正确
B.错误
答案：B
3、public class Something{
public int addOne(final int x){
return ++x;
}
}
A.正确
B.错误
答案：B
4、public class Something {
public static void main(String[] args) {
Other o=new Other;
new Something().addOne(o);
}
public void addOne(final Other o){
0.i++;
}
}
class Other {
public int i;
}
A.正确
B.错误
答案：A
5、class Something {
int i;
public void doSomething() {
System.out.println("i= " + i);
}
}
A.正确
B.错误
答案：A
二、 填空
6、class FatherClass {
public FatherClass(){
System.out.println("FatherClass Create");
}
}
public class ChildClass extends FatherClass {
public childclass() {
System.out println("ChildClass Create");
}
public static void main(String[] args)
{
FatherClass fc = new FatherClass();
ChildClass cc =new ChildClass();
}
}
答案：FatherClass CreateFatherClass CreateChildClass Create
1、class Something {
final int i;
public void doSomething() {
System.out.println("i= " + i);
}
}
A.正确
B.错误
答案：B
2、interface Playable {
void play();
}
interface Bounceable {
void play();
}
interface Rollable extends Playable, Bounceable {
Ball ball = new Ball('PingPang");
}
class Ball implements Rollable {
private String name;
public String getName(){
return name;
}
public Ball(String name){
this name = name:
}
public void play() {
ball = new Ball("Football");
System.out.println(ball.getName());
}
}
A.正确
B.错误
答案：B
1、Error类和Exception类有什么区别？
答：Error类及Exception类是Throwable类的两个直接子类。Error类描述的是内部系统错误，包括动态链接失败、虚拟机错误等，Java程序不做处理。Exception类描述的是程序和外部环境引起的错误，这些错误能通过程序捕获和处理，Exception类是Java程序中需要大量处理的。
2、接口和抽象类有什么区别？
答：从本质上讲，接口是一种特殊的抽象类，然而它们又有区别： ①接口只包含常量，而抽象类则不一定。 ②接口中不能有非抽象的方法，但抽象类中可以有。 ③一个类能实现多个接口，但只能有一个父类。 ④接口并不属于继承结构，它实际与继承无关，无关的类可以实现同一个接口。
3、什么是包？为什么要使用包？
答：包（package）是类的容器。由于Java编译器为每个类生成一个字节码文件，且文件名与类名相同，因此同名的类有可能发生冲突。为了解决这一问题，Java提供包来管理类名空间。此外一旦创建了一个类，并想重复地使用它，那么把它放在一个包中将是非常有效的。
二、 改错
4、public class MyClass
{
public static void main(String ags[])
{
myMethod();
}
public void myMethod() throw MyException
{
throws(new MyException());
}
}
class MyException
{
public String toString()
{
return("用户自定义的异常");
}
}
答：这段程序有如下的错误： ① 用户自定义的异常MyException必须是系统类Exception的派生类。 ② 定义一个方法抛出异常需要使用关键字throws，而不是throw。 ③ 抛出异常的语句需要使用关键字throw，而不是throws。 ④ 因为方法main()调用可能会抛出异常的方法myMethod()，所以需要定义语句来处理myMethod()抛出给main()的异常。 ⑤ main()方法是静态的static方法，它只能调用、操作同样是static的静态方法或静态域，而不能调用属于具体对象而不是屑于整个类的方法myMehtod<)。为了让main()方法成功地调用myMethod()，必须把myMathod()也定义成static方法。
5、在空白处填上合适的语句。
public class ServerTimedOutException extends Exception
{
private int port;
public ServerTimedOutException(String message, int port)
{
super(message);
this.port= port;
}
public int getPort()
{
return port;
}
}
class Client
//在下行空白出填上声明抛弃ServerTimedOutException异常的语句
public void connectMe(String serverName)_______________________________
{
int success;
int portToConnect = 80;
success=open(serverName, portToConnect);
if(success ==-1)
{
//在下行空白处填上抛出ServerTimedOutException异常的语句
_____________________________________________________________
}
}
}
答： throws __ServerTimedOutException__________ throw new ServerTimedOutException
6、创建包需要使用的关键字是______，而且该语句应该是整个“.java”文件的______。
答案：Pakage、第一条语句
7、按异常处理不同可分为捕获异常、声明异常和（ ）三种。
答案：抛出异常
8、 Java语言中, 通常把可能发生异常的方法调用语句放到try块中，并用紧跟其后的（ ）块来捕获和处理异常。
答案：Catch
9、接口中的成员只有静态常量和（ ）。
答案：抽象方法
10、Throwable类是类库（ ）包中的一个类，它派生了两个子类：（ ）和（ ）。
答案：Java.lang、Error、Execption
1、什么是异常？为什么要进行异常处理？
答：异常，是指由于程序运行时发生错误，从而导致程序错误结束。 在进行程序设计时，错误的产生是不可避免的，没有异常处理代码的程序，在运行时发生错误则可能非正常结束，引起严重问题。因此，Java给程序员提供了处理运行时错误的功能，称为异常处理。
2、简述异常处理的过程。
答：程序运行时出现错误时，创建异常对象，抛出异常对象，捕获该异常对象并进行处理。
1、继承是的一个特点，继承支持()类概念。
答案：对象|层次
2、数据库的设计通常可以分为这样四个步骤：需求分析、() 、()和物理设计。
答案：概念设计|逻辑设计分析
3、在C+ +中，声明构造函数和析构函数时，()使用const或volatile关键词。
答案：不能
4、文件类()是java.io中的一个重要的非流类，里面封装了对文件系统进行操作的功能。
答案：File
5、Java语言通过接口支持（ ）继承，使类继承具有更灵活的扩展性。
答案：多重
6、抛出异常的程序代码可以是()，或者是JDK中的某个类，还可以是JVN。
答案：Java应用程序
7、按异常处理不同可分为运行异常、捕获异常、声明异常和()几种。
答案：抛出异常
8、变量类型有两大类：()和复合类型。
答案：基本类型
9、Java语言的各种数据类型之间提供两种转换，自动转换和()。
答案：强制转换
1、一个空数组与一个长度为0的数组有什么区别？
答： 一个空数组是指不包括任何Object引用的数组对象。而一个长度为0的数组是指有0个元素的数组对象。
2、Vector对象的大小与容量之间有什么区别？
答：一个Vector对象的大小是包含的Object引用的实际数量。而容量是指为Object引用分配的存储空间的数量。
3、String类和StringBuffer类的主要区别是什么？1. 指出下列程序运行的结果( )
答：String类：用于比较两个字符串，查找和抽取串中的字符或子串，字符串与其他类型的转换等，String类对象的内容一旦被初始化就不能再改变。StringBuffer类：用于内容可以改变的字符串，可以将其他各种类型的数据增加、插入到字符串中，也可以翻转字符串中原来的内容。
4、程序阅读题并写出运行结果
import java util.*；
public class TestVector{
public static void main(String[] args){
Vector vec=new Vector();
print(vec);
vec.addElement("C");
print(vec);
vec addElement("D");
print(vec);
for(int i=0;i<4;i++)
vec.addElement("E");
print(vec);
}
static void print(Vector vec)
{
System out.printn("vec-"+vec);
System.out.print("vec.size="+vec.size());
System out.println("\tvee.capacity="+vec,capacity());
System.out.printn("\n");
}
}
答：如图所示<img src="https://qitem.jxjypt.cn/course/upload/image/20220817/1660707077544053853.png" title="image.png" alt="image.png"/>
5、所谓缺省构造函数就是没有参数的构造函数。（）
A.正确
B.错误
答案：A
6、对象成员变量在对象创建时会获得一个缺省的初始值。（）
A.正确
B.错误
答案：A
7、Java数组随时可以改变大小。（）
A.正确
B.错误
答案：B
8、 InputStream和OutputStream读写的数据是８位的。（）
A.正确
B.错误
答案：A
9、Java是强类型语言。（）
A.正确
B.错误
答案：A
10、 Java没有指针，引用不能等同于指针。（）
A.正确
B.错误
答案：A
11、 protected的成员只能被继承类成员存取。（）
A.正确
B.错误
答案：B
12、任何的Applet都完全不能访问本地资源。（）
A.正确
B.错误
答案：B
13、Anonymous Inner Class (匿名内部类) 可以extends(继承)其它类。（）
A.正确
B.错误
答案：A
14、final类是为防止他人从你的类上派生新类，此类是不可继承的。（）
A.正确
B.错误
答案：A
15、super()和this()方法只能在构造函数里调用。（）
A.正确
B.错误
答案：A
16、接口的所有方法默认都是public,abstract和non-static的。（）
A.正确
B.错误
答案：A
17、接口可以声明成final。（）
A.正确
B.错误
答案：B
1、已知整数数组a有六个元素，其值分别为25、36、47、32、21、16，(11) 请设计一个程序求它的总和及平均值。
答： 一个空数组是指不包括任何Object引用的数组对象。而一个长度为0的数组是指有0个元素的数组对象。
2、编写一个程序，用选择法对数组a[]={20,10,50,40,30,70,60,80,90,100}进行从大到小的排序。
答：一个Vector对象的大小是包含的Object引用的实际数量。而容量是指为Object引用分配的存储空间的数量。
3、 编程将字符串"Mary was a"改为"Mary had a book."。
答：String类：用于比较两个字符串，查找和抽取串中的字符或子串，字符串与其他类型的转换等，String类对象的内容一旦被初始化就不能再改变。StringBuffer类：用于内容可以改变的字符串，可以将其他各种类型的数据增加、插入到字符串中，也可以翻转字符串中原来的内容。
二、 填空
4、设有数组定义：int b[]={10,20,30,40,50,60,70}; 则执行以下几个语句后的输出结果是
int s=0:
for( int i=0 ；i< b.length；i+ +)
if(i%2==1) s += b;
System.out.println(s)；
答案：120
1、编写一Java应用程序，在主线程中创建一个显示5个“Hello!”的线程并启动运行。
答案：<img src="https://qitem.jxjypt.cn/course/upload/image/20220812/1660289512432041709.png" title="image.png" alt="image.png"/>Hello
