零、考试说明
答题时长：90分钟
试卷共包含57道题目，其中单选题30道，多选题10道，判断题10道，简答题5道，程序题2道。
一、单选题（175-2-2题，1’）
1.定义一个类,必须使用的关键字是( )
A.public
B.class
C.interface
D.static
2.抽象方法:( )
A.可以有方法体
B.不可以出现在非抽象类中
C.有方法体的方法
D.抽象类中的方法都是抽象方法
3.下面关于switch语句错误的是:
A.在同一个switch语句中,case后的值可以相同
B.没有break语句,也能编译运行
C.default语句可有可无
D.switch语句中表达式的值可以是String类型
class Myclass{
static int member;
}
public class Test{
public static void main(String args[]){
Myclass A = new Myclass();
Myclass B = new Myclass();
Myclass.member = 1;
A.member = 2;
B.member = 3;
System.out.println("member = "+ Myclass.member);
}
}
A.member = 1
B.member = 2
C.member = 3
D.member = 0
5.对于类A,B,C,D和接口 IA,IB,IC 有以下的定义，
class A{}
class B extends A implements IA{}
class C extends B implements IB{}
class D extends B implements IC{}
interface IA{}
interface IB extends IA{}
interface IC extends IA{}
下列类型转换中，正确的是（）
A.IB ib = new D()
B.IC ic = new D()
C.IC ic = new C()
D.D d = new B()
JAVA程序设计（学堂在线-清华大学） 课后练习题 已更新完毕/CSDN@King_Arthur#
6.对于下面代码的运行结果描述,正确的是( )
public static void main(String[] args){
File f = new File("D:\\345.txt");
FileWriter fw;
try{
fw = new FileWriter(f);
String str = "chengliang\r\nrrrrrrttttttt";
fw.write(str);
}catch(IOException e){
e.printStackTrace();
}
}
A.D盘根目录下不会出现345.txt文件
B.D盘根目录下会出现345.txt文件,但是其中没有内容
C.会出现有345.txt文件,其中内容为str字符串的内容
D.345.txt文件中会出现乱码
7.在Java中,关于构造方法,下列说法错误的是( )
A.构造方法的名称必须与类名相同
B.构造方法可以带参数
C.构造方法不可以重载
D.构造方法绝对不能有返回值
8.下列哪些语句关于Java内存回收的说明是正确的? ( )
A.程序员必须创建一个线程来释放内存
B.内存回收程序负责释放无用内存
C.内存回收程序随机释放内存
D.内存回收程序可以在指定的时间释放内存对象
9.下面这段代码的输出为(忽略换行)
Object a = new Object();
Object b = new Object();
if(a.equals(b)){
System.out.println("YES");
}else{
System.out.println("NO");
}
b = a;
if(a.equals(b)){
System.out.println("YES");
}else{
System.out.println("NO");
}
A.YES NO
B.NO YES
C.YES YES
D.NO NO
10.Java语言的特点是:
(1) 面向对象(2) 安全性(3) 操作平台无关性(4) 多线程(5) 内存管理
A.(1)(3)(4)
B.(1)(2)(3)(4)
C.(1)(2)(3)(5)
D.(1)(2)(3)(4)(5)
11.在JAVA中,以下( )类的对象以键-值的方式存储对象
A.java.util.List
B.java.util.ArrayList
C.java.util.HashMap
D.java.util.LinkedList
12.下面关于继承的说法,正确的是( ) 。
A.超类的对象就是子类的对象
B.一个类可以有几个超类
C.一个类只能有一个子类
D.一个类只能有一个超类
13.面向对象的主要思想是:
将客观事物看作具有____和____的对象,通过抽象找出同一类对象的共同状态和行为,构成____。
A.状态,行为,类
B.属性,行为,方法
C.状态,行为,方法
D.属性,方法,类
14.线程通过( )方法可以使具有相同优先级线程获得处理器。
A.run
B.setPrority
C.yield
D.sleep
15.下列哪种操作不会抛出异常?
A.打开不存在的文件
B.用负数索引访问数组
C.浮点数除以0
D.浮点数乘以0
16.类Line的定义如下,其中的this代表的是:
class Line{
private int a,b;
public Line(int x,int y){
this.x = x;
this.y = y;
}
}
A.this指针
B.类名Line
C.父类的对象
D.Line类实例的当前对象引用
17.在Java中,存放字符串常量的对象属于( )类对象。
A.Character
B.String
C.StringBuffer
D.Vector
18.下面哪个不属于Java标准输入输出流
A.System.in
B.System.out
C.System.stream
D.System.err
19.在创建某类的对象时应该:
A.只要声明对象,就可以使用。
B.声明对象后,为对象分配内存空间初始化后,才能使用对象
C.对象是类的实例,只要存在类,就不用声明对象。
D.因为Java是单继承,所以一个类只能有一个对象。
20.Java语言间的继承关系是:
A.单继承
B.多继承
C.单继承和多继承
D.不能继承
21.Java application中的主类需包含main方法,以下哪项是main方法的正确形参?( )
A.String args
B.String []
C.Char arg
D.String args[]
22.关于对象成员占用内存的说法哪个正确?( )
A.同一个类的对象共用同一段内存
B.同一个类的对象使用不同的内存段,但静态成员共享相同的内存空间
C.对象的方法不占用内存
D.以上都不对
23.给定如下所示的Java代码,则运行时,会产生( )类型的异常
String s = null;
s.concat("abc");
A.ArithmeticException
B.NullPointerException
C.IOException
D.ClassNotFoundException
24.在以下哪种情况下不需要进行方法的覆盖
A.子类的方法和父类功能相同,但实现细节不同
B.在名字相同的方法中要做更多的事情
C.子类中要取消从父类继承的方法
D.以上都不是
25.在JAVA中,LinkedList类和ArrayList类同属于集合框架类,下列( )选项中的方法是LinkedList类有而ArrayList类没有的。
A.add(Object o)
B.add(int index,Object o)
C.remove(Object o)
D.removeLast()
26.A,B是两个定义好的接口,若接口C想要拓展这两个接口,以下做法正确的是
A.interface C extends A,B{}
B.interface implements A,B{}
C.class C extends A,B{}
D.class C implements A,B{}
27.已知MyInterface是一个接口,ClassA是实现了MyInterface的一个类,ClassB是ClassA的一个子类,则下列哪个语句是正确的
A.ClassB obj = new ClassA();
B.MyInterface obj = new ClassB()
C.ClassA obj = new MyInterface()
D.MyInterface obj = new MyInterface()
28.关于接口实现的语法,正确的是
A.可以用new运算符,直接产生接口对象
B.必须实现接口中的所有方法
C.来自接口的方法实现可以声明成private
D.接口的方法默认是protected修饰
29.关于接口哪个正确? ( )
A.实现一个接口只要实现接口的一个方法即可
B.接口可实现java的多重继承
C.接口间不能有继承关系
D.接口和抽象类是同一回事
30.编译一个定义了两个类和三个方法的 Java 源程序文件,总共会产生( )个字节码文件。
A.5 个字节码文件,以“.java”为扩展名
B.2 个字节码文件,以“.java”为扩展名
C.5 个字节码文件,以“.class”为扩展名
D.2 个字节码文件,以“.class”为扩展名
31.下面哪个关键字不是类及成员的访问控制符:
A.public
B.private
C.static
D.protected
32.下列javaDoc注释正确的是( )
A./*我爱北京天安门*/
B.//我爱北京天安门*/
C./**我爱北京天安门*/
D./*我爱北京天安门**/
33.以下关于继承的叙述正确的是( )。
A.在Java中一个类只能实现一个接口
B.在Java中一个类不能同时继承一个类和实现一个接口
C.在Java中接口只允许单一继承
D.在Java中类只允许单一继承
34.对于try{……}catch子句的排列方式,下列正确的一项是( )
A.子类异常在前,父类异常在后
B.父类异常在前,子类异常在后
C.只能有子类异常
D.父类异常与子类异常不能同时出现
35.给定如下Java 程序代码片段,编译运行这段代码,结果是( B )。
java.util.HashMap
map = new java.util.HashMap();
map.put("name",null);
map.put("name","Jack");
System.out.println(map.get("name"));
A.null
B.Jack
C.nullJack
D.运行时出现异常
36.面向对象的程序设计方法采用了什么样的抽象方法构建程序的类与对象:
A.过程抽象
B.数据抽象
C.过程抽象与数据抽象
D.没有采用任何的抽象方法
37.要获取以下MyClass类中member的值,采用的语句是:
public class Myclass{
public static int member=1;
public static int getmember(){
return member;
}
};
A.MyClass.member()
B.MyClass().member
C.MyClass.member或者MyClass.getmember()
D.MyClass().member或者MyClass().getmember()
38.下列不属于面向对象程序设计的基本特征的是:
A.抽象
B.封装
C.继承
D.静态
39.下列选项中,用于声明包名的关键字是:
A.import
B.package
C.interface
D.protected
40.()类是所有异常类的父类。
A.Runable
B.Error
C.Exception
D.AWTError
41.在JAVA中ArrayList类实现了可变大小的数组,便于遍历元素和随机访问元素,已知获得了ArrayList类的对象bookTypeList,则下列语句中能够实现判断列表中是否存在字符串“小说”的是( )。
A.bookTypeList.add("小说");
B.bookTypeList.get("小说");
C.bookTypeList.contains("小说");
D.bookTypeList.remove("小说");
42.执行下面代码结果( )
for(int i=0;;){
System.out.println("这是 "+i);
break;
}
A.语法错误,缺少表达式2和表达式3
B.死循环
C.程序什么都不输出
D.输出:这是0
43.下列选项中关于Java中封装的说法错误的是( )。
A.封装就是将属性私有化,提供共有的方法访问私有属性
B.属性的访问方法包括setter方法和getter方法
C.setter方法用于赋值,getter方法用于取值
D.包含属性的类都必须封装属性,否则无法通过编译
44.以下程序段的输出结果是:
int i = 0;
for(i=4; i>0; i--) {
if(i==1)
break;
System.out.print(i);
}
System.out.print(i);
A.4321
B.4322
C.321
D.432
45.以下程序的运行结果是:( )
public class Increment{
public static void main(String args[]) {
int a;
a = 6;
System.out.print(a);
System.out.print(a++);
System.out.print(a);
}
}
A.666
B.667
C.677
D.676
46.下列哪一项不是构造方法的特点:
A.构造方法名必须与类名相同
B.构造方法不具有任何返回类型
C.任何一个类都含有构造方法
D.构造方法可以通过对象调用
47.A和B是两个定义好的接口,若类C想要实现这两个接口,以下做法正确的是
A.class C extends A implents B{}
B.class C implements A,B{}
C.class C implements A extends B{}
D.class C extends A,B
48.下列声明二维数组的语句不合法的是()
A.char c[][] = new char[2][3];
B.char c[][]=new char[6][];
C.char[][] c= new char[3][3];
D.char [][] c = new char[][4];
49.某类的成员方法只能被自己调用,修饰该方法的是:
A.public
B.protected
C.private
D.无修饰符
50.对象的特征在类中表示为变量,称为类的( )。
A.对象
B.属性
C.方法
D.数据类型
51.线程通过( )方法可以休眠一段时间,然后恢复运行。
A.run
B.setPrority
C.yield
D.sleep
52.将类的成员的访问权限设置为默认的,则该成员能被( ) 。
A.同一包中的类访问
B.其他包中的类访问
C.所有的类访问
D.所有的类的子类访问
53.关于Object类,下面说法正确的是
A.equals方法可以比较两个对象是否相等
B.如果两个对象同一,那么它们一定相等
C.如果两个对象相等,那么它们一定同一
D.相等和同一意思一样
54.以下关于抽象类和接口的说法错误的是( )
A.抽象类在Java语言中表示的是一种继承关系,一个类只能使用一次继承。但是一个类却可以实现多个接口。
B.在抽象类中可以没有抽象方法
C.实现抽象类和接口的类必须实现其中的所有方法,除非它也是抽象类。接口中的方法都不能被实现
D.接口中的方法都必须加上public关键字。
55.下列值不为true的表达式有( )。
A."john" = = "john"
B."john".equals("john")
C."john" = "john"
D."john".equals(new String("john"))
56.以下( )不是合法的标识符
A.STRING
B.x3x;
C.void
D.de$f
57.在Java中,下面对于构造函数的描述错误的是( )
A.类不一定要显式定义构造函数
B.构造函数的没有返回类型
C.如果构造函数不带任何参数,那么构造函数的名称和类名可以不同
D.一个类可以定义多个构造函数
58.关于类的描叙正确的是( )
A.在类中定义的变量称为类的成员变量,在别的类中可以直接使用
B.局部变量的作用范围仅仅在定义它的方法内,或者是在定义它的控制流块中
C.使用别的类的方法仅仅需要引用方法的名字即可
D.一个类的方法可以没有方法名
59.当( )方法终止时,能使线程进入死亡状态。
A.run
B.setPrority//更改线程优先级
C.yield//暂停当前线程的执行,执行其他线程
D.sleep//线程休眠
60.下面关于接口的说法正确的是:
A.接口具有多重继承性,一个接口可以继承多个父接口
B.接口中定义的数据,都是变量
C.接口中定义的方法,可以在定义时提供实现
D.接口用abstract 修饰
61.对异常处理语句try-catch-finally,下面哪个说法是正确的:
A.如果有多个catch语句,对所有的catch语句都会执行一次
B.如果有多个catch语句,对每个符合条件的catch都会执行一次
C.多个catch的情况下,异常类的排列顺序应该是父类在前,子类在后
D.一般情况下,finally部分都会被执行一次
62.A类有a、b、c三个public变量成员,B类继承自A,并且增加了自己的public变量成员d,C继承自A,增加了自己的public变量成员e,则下列说法中错误的是
A.A类拥有c成员
B.B类拥有b成员
C.C类拥有d成员
D.B类拥有c成员
63.自定义异常类时,可以继承的类是( )
A.Error
B.Applet
C.Exception及其子类
D.AssertionError
64.在Java程序中,下面哪个是不合法的标志符()
A.2D
B.True
C._name
D.T1
65.为了区分重载多态中同名的不同方法,要求( )。
A.方法名不同
B.返回值类型不同
C.调用时用类名或对象名做前缀
D.形式参数个数或者类型不同
66.下面的代码段执行之后count的值是什么( )
int count = 1;
for (int i = 1; i <= 5; i++) {
count += i;
}
System.out.println(count);
A.5
B.1
C.15
D.16
67.关于Java中类的声明,下面哪个关键字是必须有的:
A.public
B.class
C.extends
D.implements
68.下面( )赋值语句不会出现编译警告或错误。
A.float f=1.3;
B.char c="a";
C.byte b=257;
D.int i=10;
69.( )表达式不可以作为循环条件
A.i++;
B.i>5;
C.bEqual = str.equals("q");
D.count = = i;
70.下面关于数组的说法中,错误的是( )
A.在类中声明一个整数数组作为成员变量,如果没有给它赋值,数值元素值为空
B.数组需要在内存中占用空间。
C.数组必须先声明,然后才能使用
D.数组本身是一个对象
71.如下哪个是Java中有效的关键字( )。
A.name
B.hello
C.false
D.good
72.变量命名规范说法正确的是( )
A.变量由字母、下划线、数字、$符号随意组成;
B.变量不能以数字作为开头;
C.A和a在java中是同一个变量;
D.不同类型的变量,可以起相同的名字;
73.下列代码输出结果是( )
int i = 10;
while ( i > 0 ){
i = i + 1;
if ( i = =10 ){
break;
}
}
A.while循环执行10次
B.死循环
C.循环一次都不执行
D.循环执行一次
74.有关类的说法,正确的是( ) 。
A.类具有封装性,所以类的数据是不能被访问的
B.类具有封装性,但可以通过类的公共接口访问类中的数据
C.声明一个类时,必须使用 public 修饰符
D.每个类中必须有 main 方法,否则程序无法运行
75.Java中,如果类C是类B的子类,类B是类A的子类,那么下面描述正确的是( )
A.C不仅继承了B中的成员,同样也继承了A中的成员
B.C只继承了B中的成员
C.C只继承了A中的成员
D.C不能继承A或B中的成员
76.关于面向对象的说法正确的是( )
A.类可以让我们用程序模拟现实世界中的实体
B.有多少个实体就要创建多少个类
C.对象的行为和属性被封装在类中,外界通过调用类的方法来获得,但是要知道类的内部是如何实现
D.现实世界中的某些实体不能用类来描述
77.在横线中哪种方法访问的是A类的balance
class B{
public int balance;
public int getBalance() {
return balance;
}
}
class A extends B{
public int balance;
public void use_B_balance() {
______
}
}
A.balance
B.getBalance()
C.super.balance
D.super.getBalance()
78.下面代码输出结果是( )。
int i=0,s=0;
do{
if (i%2 = = 0 ){
i++;
continue;
}
i++;
s = s + i;
}
while (i<7);
System.out.println(s);
A.16
B.12
C.28
D.21
79.下面关于抽象方法的说法中,正确的是
A.可以有方法体
B.可以出现在非抽象类中
C.没有方法体
D.抽象类中的方法都被称为抽象方法
80.下列输出结果是( )
int a = 0 ;
while ( a < 5 ) {
switch(a){
case 0:
case 3 : a = a + 2;
case 1 :
case 2 : a = a + 3;
default : a = a + 5;
}
}
System.out.print ( a ) ;
A.0
B.5
C.10
D.其他
81.以下关于java异常说法不正确的是( )。
A.Throwable 类是 Java 语言中Error类和Exception类的父类。
B.当异常对象是Exception类(或其子类)的实例时,能通过 Java 虚拟机或者 throw 语句抛出该异常对象,并能通过try…catch…finally处理。
C.如果只用一个catch块捕捉多个异常对象,则catch 子句中的参数类型应是所有异常对象的父类。
D.以上说法都不对。
82.如果一个程序中有多个catch语句,则程序会按如下哪种情况执行:
A.找到合适的异常类型后执行后面的catch语句
B.找到每个符合条件的catch都要执行一次
C.找到合适的异常类型处理后就不再执行后面的catch语句
D.对每个catch语句都执行一次
83.在异常处理中,将可能抛出异常的方法放在( )语句块中
A.throws
B.catch
C.try
D.finally
84.以下有关构造方法的说法,正确的是:( )
A.一个类的构造方法只能有一个
B.构造方法在类定义时被调用
C.构造方法只能由对象中的其它方法调用。
D.构造方法和类同名
85.下面说法不正确的是( )。
A.列表(List)、集合(Set)和映射(Map)都是java.util包中的接口。
B.List接口是可以包含重复元素的有序集合。
C.Set接口是不包含重复元素的集合。
D.Map接口将键映射到值,键可以重复,但每个键最多只能映射一个值。
86.有如下代码片段:
int num1 = 10;
int num2 = 20;
String word = new String("exam");
double answer = 25.5;
另外定义了下列方法头:
public int stuff(String s, int x, int y) 以下哪个是正确的方法调用:
A.num1 = stuff("hello", num1, num2);
B.answer = stuff(word, answer, num2);
C.num2 = stuff("hello",num1,answer);
D.num1 = stuff(num1,num2,answer);
87.下列有关 Java 中接口的说法正确的是( )。
A.接口中含有具体方法的实现代码
B.若一个类要实现一个接口,则用到 “implements” 关键字
C.若一个类要实现一个接口,则用到“ extends ”关键字
D.接口不允许继承
88.null
A.null1
B.null2
C.null3
D.null4
89.下面哪个条件运算的结果等价于简单的if-else语句:
if(a > b)
System.out.println(a);
else
System.out.println(b);
A.System.out.println((a>b):a?b);
B.System.out.println((a>b):b?a);
C.System.out.println((a>b)?b:a);
D.System.out.println((a>b)?a:b);
90.对于类A,B,C,D和接口 IA,IB,IC 有以下的定义，
class A{}
class B extends A implements IA{}
class C extends B implements IB{}
class D extends B implements IC{}
interface IA{}
interface IB extends IA{}
interface IC extends IA{}
A tmpA = new A()
B tmpB = new B()
C tmpC = new C()
D tmpD = new D()
则下列使用方法中正确的是()
A.tmpB = tmpA
B.tmpC =tmpD
C.tmpA = tmpC
D.tmpD = tmpB
91.下面的方法重载,正确的是( ) 。
A.
int fun(int a, float b）{ }
float fun(int a, float b) { }
B.
float fun(int a, float b) { }
float fun(int x, float y) { }
C.
float fun(float a) { }
float fun(float a, float b) { }
D.
float fun1(int a, float b) { }
float fun2(int a, float b) { }
92.为一个boolean类型变量赋值时,可以使用( )方式
A.boolean = 1;
B.boolean a = (9 >= 10);
C.boolean a="真";
D.boolean a = = false;
93.以下用于创建容器对象的类是( )
A.Frame
B.Checkbox
C.Button
D.TextField
94.程序员将可能发生异常的代码放在( )块中,无论如何都需要执行的代码在( )块中:
A.catch、try
B.try、finally
C.try、exception
D.try、final
95.下面哪个声明语句是正确的
A.abstract final class A;
B.abstract private move();
C.protected private number;
D.public abstract class B{}
96.关于异常,下列说法正确的是( )
A.异常是一种对象
B.一旦程序运行,异常将被创建
C.为了保证程序运行速度,要尽量避免异常控制
D.以上说法都不对
97.在Java接口中,下列选项中有效的方法声明是( )。
A.public void aMethod();
B.void aMethod(){};
C.protected void aMethod();
D.private void aMethod();
98.下列( )属于引用数据类型
A.double
B.char
C.用户自定义的Student类类型
D.int
99.考虑以下的方法头声明:
public void myMethod(int num, char letter)
下面哪个描述是正确的:
A.这个方法有个int型的参数,它的形式参数是letter
B.这个方法有个int型的参数,它的形式参数是num
C.这个方法有个char型的参数,它的实际参数是myMethod
D.这个方法是一个构造方法
100.下列哪一个import命令可以使我们在程序中创建数据库对象( )
A.import java.sql.*;
B.import java.util.*;
C.import java.io.*;
D.import java.net.*;
101.分析选项中关于Java中this关键字的说法正确的是( )
A.this关键字是在对象内部指代自身的引用
B.this关键字可以在类中的任何位置使用
C.this关键字和类关联,而不是和特定的对象关联
D.同一个类的不同对象共用一个this
102.若有定义:byte[] x={11,22,33,-66};
其中0≤k≤3,则对x数组元素错误的引用是( )
A.x[5-3]
B.x[4]
C.x[k]
D.x[0]
103.下列选项中关于Java中super关键字的说法正确的是( )。
A.super关键字是在子类对象内部指代其父类对象的引用
B.super关键字不仅可以指代子类的直接父类,还可以指代父类的父类
C.子类通过super关键字只能调用父类的方法,而不能调用父类的属性
D.子类通过super关键字只能调用父类的属性,而不能调用父类的方法
104.以下是接口I的定义:
interface I{
void setValue(int val);
int getValue();
}
以下哪段代码能够通过编译:
A.class A extends I{int value;public void setValue(int val){value=val;}public int getValue(){ return value;
B.class B implements I{int value; void setValue(int val){value=val;} public int getValue(){ return value;
C.interface C extends I {void add();}
D.interface D implements I{void add();}
105.下面说法正确的是
A.在写文件时,如果最后没有调用close方法则无法写入
B.写文件时在close方法之前,调用flush方法,可以写入
C.如果close方法之前没有调用flush方法,则无法写入
D.仅调用flush方法不能保证数据写入文件
106.关于接口声明的语法,以下说法正确的是
A.接口中的数据成员一定要有初值,且此值不能再更改,final关键词不可省略
B.接口中的方法必须是“抽象方法”,不能有方法体,可以省略public及abstract关键字
C.接口中的数据成员可以有变量,可以有常量。
D.只有接口中可以有抽象方法
107.如果想要文字量的的实际内容是 “I’m very interested in java Programming” (包含””),以下文字量声明正确的是:
A.string str = “I’m very interested in java Programming”
B.string str = \“I\’m very interested in java Programming\”
C.string str = “\“I\’m very interested in java Programming\””
D.string str = “I\’m very interested in java Programming”
108.给定java代码如下所示,在A处新增下列( )方法,是对cal方法的重载
public class Test{
public void cal(int x, int y, int z)
{
}
//A
}
A.public int cal(int x,int y,float z){return 0;}
B.public int cal(int x,int y,int z){return 0;}
C.public void cal2(int x, int y, int z){}
D.public viod cal(int z,int y,int x){}
109.给定如下代码,要在第三个构造方法的空白处填上一行代码使之能够调用第二个构造方法,这行代码应该是:
class Circle{
String name,radius;
int r;
public Circle(String n){
name = n;
}
public Circle(String n,int a){
name = n;
r = a;
}
public Circle(String n,String d,int a){
__________
radius = d;
}
}
A.Circle(n,a);
B.this(Circle(n,a));
C.this(n,a);
D.this(name,a);
110.在编写异常处理的Java程序中,每个catch语句块都应该与( )语句块对应,使得用该语句块来启动Java的异常处理机制。
A.if - else
B.switch
C.try
D.throw
111.下面关于抽象类和抽象方法的说法中,错误的是
A.抽象类可以包含非抽象方法
B.抽象类可以定义对象
C.抽象类可以包含抽象方法
D.抽象类不可以被实例化
112.不允许作为类及类成员的访问控制符的是( )。
A.public
B.private
C.static
D.protected
import java.io.*;
class Person{
public void print(){
System.out.print("Person ");
}
public void printMyGender(String s){
this.print();
System.out.print(s+" ");
}
}
class Gender{
String type="gender";
public void print(Person p){
p.printMyGender(type);
}
}
class Female extends Gender{
public Female(){
type="female";
}
}
class Male extends Gender{
public Male(){
type="male";
}
}
class Employee extends Person{
public void print(){
System.out.print("Employee ");
}
}
class Manager extends Employee{
public void print(){
System.out.print("Manager ");
}
}
public class Test{
public static void main(String[] args){
Manager man = new Manager();
Employee em = new Employee();
Gender gender1 = new Male();
Gender gender2 = new Female();
gender1.print(man);
gender2.print(em);
}
}
对于以上代码,其运行结果是
A.Person male Person female
B.Person gender Person gender
C.Manager male Employee female
D.Manager gender Employee gender
114.下面关于变量的说法,哪个是不正确的:
A.实例变量是类的成员变量
B.类变量用关键字static声明
C.类变量可以用<实例名>.<类变量名>访问
D.实例变量可以用<类名>.<实例变量名>访问
115.下面说法中错误的是
A.FileWriter中append参数为true时,可以实现在文件内容之后写追加操作
B.Java程序中每个字符占2字节
C.当使用PipedOutputStream类时,最后不需要调用输出流的close方法
D.BufferedWriter类的newLine方法是用于换行
116.下列类定义中哪些是合法的抽象类的定义?( )
A.abstract Animal{abstract void growl();
B.class abstract Animal{abstract void growl();}
C.abstract class Animal{abstract void growl();}
D.abstract class Animal{abstract void growl() {System.out.println(“growl”);};}
117.下面哪个流属于面向字符的输入流
A.BufferedWriter
B.FileInputStream
C.ObjectInputStream
D.InputStreamReader
118.下列选项中,用于引入其他包的关键字是:
A.import
B.package
C.infterface
D.protected
119.下列()不属于Java的基本数据类型
A.int
B.String
C.double
D.boolean
120.下列哪个选项是合法的标识符?( )
A.123
B._name
C.class
D.1first
121.在JAVA的异常处理模型中,能单独和finally语句一起使用的块是( A )。
A.try
B.catch
C.throw
D.throws
122.下面有关for循环的描述正确的是( )
A.for循环体语句中,可以包含多条语句,但要用大括号括起来
B.for循环只能用于循环次数已经确定的情况
C.在for循环中,不能使用break语句跳出循环
D.for循环是先执行循环体语句,后进行条件判断
123.下列说法正确的是( )
A.JAVA程序的main方法必须写在类里面
B.JAVA程序中可以有多个main方法
C.JAVA程序中类名必须与文件名一样
D.JAVA程序的main方法中如果只有一条语句,可以不用{}(大括号)括起来
124.下面关于面向对象概念的描述中,不正确的一项是:
A.在现实生活中,对象是指客观世界的实体
B.程序中的对象就是现实生活中的对象
C.在程序中,对象是通过一种抽象数据类型来描述的,这种抽象数据类型称为类
D.在程序中,对象是一组变量和相关方法的集合
125.JAVA所定义的版本中不包括:( )
A.JAVA2 EE
B.JAVA2 SE
C.JAVA2 ME
D.JAVA2 HE
126.null
A.null1
B.null2
C.null3
D.null4
127.下面关于多态性的说法,正确的是( ) 。
A.一个类中不能有同名的方法
B.子类中不能有和父类中同名的方法
C.子类中可以有和父类中同名且参数相同的方法
D.多态性就是方法的名字可以一样,但返回的类型必须不一样
128.当需要在文件中写入字符而不是字节时,在下面的类中最好选用( )类。
A.java.io.RandomAccessFile
B.java.io.PrintWriter
C.java.io.PrintStream
D.java.io.PrintOutputStream
129.Java程序运行时会自动检查数组的下标是否越界,如果越界,会抛出下面的哪一个异常?
A.SQLException
B.IOException
C.ArrayIndexOutOfBoundsException
D.SecurityManager
130.如果需要从文件中读取数据,可以在程序中创建哪一个对象
A.FileInputStream
B.FileOutputStream
C.DataOutputStream
D.FileWriter
131.定义一个类必须使用的关键字是( )
A.inface
B.class
C.interface
D.facebooK
132.与OutputStream流相对应的Java系统的“标准输出对象”是( )。
A.System.in
B.System.out
C.System.err
D.System.exit()
133.在Java语言中,下列关于类的继承的描述,正确的是( )。
A.一个类可以继承多个父类
B.一个类可以具有多个子类
C.子类可以使用父类的所有方法
D.子类一定比父类有更多的成员方法
134.A类继承自B类,那么A类中不可以使用
A.B类的保护方法
B.B类的公有属性
C.B类的私有属性
D.A类的私有属性
135.Java语言是( )
A.面向问题的解释型高级编程语言
B.面向机器的低级编程语言
C.面向过程的编译型高级编程语言
D.面向对象的解释型高级编程语言
136.假定类A有一个方法void method(),如果要求能够通过类名A直接调用method(),则其方法定义应该为
A.static void method()
B.public void method()
C.final void method()
D.abstract void method()
137.关于方法main()的说法哪个正确?( )
A.方法main()只能放在公共类中
B.main()的头定义可以根据情况任意更改
C.一个类中可以没有main()方法
D.所有对象的创建都必须放在main()方法中
138.关于下面程序片段, ( )的结论是正确的。
String a = "Java";
String b = "Java";
String x = "Ja";
String y = "va";
String c = x + y;
A.a 和b指向同一个实例对象,a 和c指向同一个实例对象
B.a 和 b 指向同一个实例对象,a 和 c 不指向同一个实例对象
C.a 和 b 不指向同一个实例对象,a 和 c 指向同一个实例对象
D.a 和 b 不指向同一个实例对象,a 和 c 不指向同一个实例对象
139.下面哪个代码片段是错误的:
A.
package mypackage;
public class Rectangle {//doing something...}
B.
import java.io. *;
package mypackage;
public class Rectangle {//doing something...}
C.
import java.io. *;
class Circle{//doing something...}
public class Rectangle {//doing something...}
D.
import java.io. *;
import java.awt. *;
public class Rectangle {//doing something...}
140.在Java中,一个类可同时定义许多同名的方法,这些方法的形式参数的个数、类型或顺序各不相同,传回的值也可以不相同。这种面向对象程序特性称为( )
A.隐藏
B.重写
C.重载
D.相同方法
141.下面关于方法的说法中不正确的是:( )
A.方法必须没有返回值
B.方法调用时要求形参和实参保持一致
C.方法允许重载
D.方法的参数可以为空
142.表达式(11+3*8)/4%3的值是( )
A.31
B.0
C.1
D.2
143.下列叙述那个是正确的( )。
A.java是面向对象的编程语言
B.abstract类中只有abstract方法
C.abstract类中可以有非abstract方法,但该方法不可以用final修饰
D.可以同是用final 和abstract修饰一个方法
144.在Java类的声明中,类体包含了哪些内容:
A.变量成员声明及初始化
B.方法声明
C.方法体
D.以上所有内容
145.下面的说法正确的是
A.abstract可以修饰字段、方法和类
B.抽象方法的body部分必须用大括号包住,但是需要为空
C.声明抽象方法,大括号可有可以没有
D.抽象方法没有方法体
146.关于Java的构造函数,下列说法哪个正确:
A.所有类都必须定义一个构造函数
B.构造函数必须有返回值
C.构造函数可以访问类的非静态成员
D.构造函数必须初始化类的所有数据成员
147.关于事件监听,正确的是( ) 。
A.一个事件监听器只能监听一个组件
B.一个事件监听器只能监听处理一种事件
C.一个组件可以注册多个事件监听器,一个事件监听器也可以注册到多个组件上
D.一个组件只能引发一种事件
148.构造函数何时被调用? ( )
A.创建对象时
B.类定义时
C.使用对象的方法时
D.使用对象的属性时
149.java语言中,下列哪一子句是异常处理的出口( )
A.try{…}子句
B.catch{…}子句
C.finally{…}子句
D.以上说法都不对
150.下面关于变量的说法,哪个是不正确的:
A.实例变量是类的成员变量
B.类变量用关键字static声明
C.类变量可以用<实例名>.<类变量名>访问
D.实例变量可以用<类名>.<实例变量名>访问
- (单选题)
关于下面的程序,哪个结论是正确的()
public class Test{
public static void main(String args[]){
int a[]=new int[5];
length = 10;
System.out.println(a.length);
}
}
A.程序可以正常运行,输出结果为10
B.程序可以正常运行,输出结果为5
C.程序可以正常运行,输出结果为15
D.程序无法运行
152.类与对象的关系是:
A.类是对象的抽象
B.对象是类的抽象
C.对象是类的子类
D.类是对象的具体实例
153.下面( )是合法的 Java 标识符。
A.#_pound
B._underscore
C.5Interstate
D.class
154.以下关于布局的说法,错误的是( )
A.BorderLayout是边框布局
B.null是空布局,空布局是指不允许在上面摆放组件。
C.FlowLayout是流布局,这种布局将其中的组件按照加入的先后顺序从左向右排列, 一行排满之后就转到下一行继续从左至右排列
D.GridLayout是网格布局,它以矩形网格形式对容器的组件进行布置。容器被分成大小相等的矩形,一个矩形中放置一个组件
155.Java类继承的层次结构为
A.树状结构
B.星状结构
C.网格结构
D.环形结构
156.以下程序片段,下列哪个选项插入到第2行将引起编译错误:
package mypackage;
class Myclass{
//do something
}
A.public class MainClass{}
B.package mypackage1;
C.class B{}
D.import java.util. *;
157.下列说法错误的是
A.读文件时,如果最后没有关闭输入流会引起程序错误
B.读文件时,可以用Reader类的read()方法判断是否读到文件结尾
C.Int read(char[] buf)方法是将读取的字符读入buf数组
D.读文件时不需要调用flush方法
158.给出下面代码,关于该程序以下哪个说法是正确的?( )
public class Person{
static int arr[] = new int[5];
public static void main(String a[]){
System.out.println(arr[0]);
}
}
A.编译时将产生错误
B.编译时正确,运行时将产生错误
C.输出零
D.输出空
159.下面说法中错误的是
A.FileReader类是Reader类的间接子类
B.InputStreamReader类是Reader类的子类
C.BufferedReader类可以读取一行
D.BufferedReader的readLine()函数,如果没有数据时会返回0
160.java中用来抛出异常的关键字是( )
A.try
B.catch
C.throw
D.finally
import java.io.*;
class Person{
public void print(){
System.out.print("Person ");
}
}
class Employee extends Person{
public void print(){
System.out.print("Employee ");
}
}
class Manager extends Employee{
public void print(){
System.out.print("Manager ");
}
}
public class Test{
public static void main(String[] args){
Manager man = new Manager();
Person person1 = new Manager();
Person person2=new Employee();
person1.print();
person2.print();
}
}
对于上述代码,其结果输出为
A.Manager Employee
B.Person Person
C.Manager Person
D.Person Manager
162.(1)汇编语言 (2)机器语言 (3)高级语言 (4)面向对象的高级语言
程序设计的发展历程按照发展顺序排序是:
A.(4)(3)(2)(1)
B.(1)(2)(3)(4)
C.(2)(1)(3)(4)
D.(4)(3)(1)(2)
163.以下( )代码,能够对数组正确初始化(或者是默认初始化)。
A.int[] a;
B.a = {1, 2, 3, 4, 5};
C.int[] a = new int[5]{1, 2, 3, 4, 5};
D.int[] a = new int[5];
164.关于接口和抽象类的说法,正确的是:
A.接口和抽象类都具有多重继承性,即一个可以继承多个
B.不相关的类可以实现同一个接口,而抽象类属于一个类的继承体系,且一般位于类体系的顶层
C.抽象类和接口都必须对数据成员进行初始化
D.抽象类和接口都可以在定义时提供实现方法体
165.score是一个整数数组,有五个元素,已经正确初始化并赋值,仔细阅读下面代码,程序运行结果是( )
temp = score[0];
for (int index = 1;index < 5;index++) {
if (score[index] < temp) {
temp = score[index];
}
}
A.求最大数
B.求最小数
C.找到数组最后一个元素
D.编译出错
166.下列说法哪个正确 ( )
A.不需要定义类,就能创建对象
B.对象中必须有属性和方法
C.属性可以是简单变量,也可以是一个对象
D.属性必须是简单变量
167.以下由do-while语句构成的循环执行的次数是( )
int k = 0;
do{
++k;
}while ( k < 1 );
A.一次也不执行
B.执行1次
C.无限次
D.有语法错,不能执行
相关题型：k<-1，不执行
168.另外的类要获取以下MyClass类中member的值,采用的语句是:
public class MyClass{
private static int member = 1;
public static int getMember(){
return member;
}
}
A.MyClass.member
B.new MyClass().member
C.MyClass.getMember()
D.MyClass().getMember()
169.关于下面程序, ( )的结论是正确的。
class J_SubClass extends J_Test{
public class J_Test {
J_Test(int i) {
System.out.println(i);
}
}
public static void main(String[] args) {
J_SubClass a = new J_SubClass();
}
}
A.不能通过编译,因为类 J_Test 没有定义无参数的构造方法
B.不能通过编译,因为类 J_SubClass 没有定义无参数的构造方法
C.不能通过编译,因为没有实现 J_SubClass(int i)的构造方法
D.可以成功通过编译
170.接口的所有成员方法都具有()修饰的特性。
A.private,final
B.public, abstact
C.static protected
D.static
171.下列不能作为switch表达式参数的数据类型是:
A.int
B.char
C.long
D.short
172.下面说法正确的是
A.FileWriter类是Writer类的子类
B.FileWriter类是OutputStreamReader类的子类
C.FileWriter类是FileOutputStream类的子类
D.Wirter类是OutputStreamWriter类的子类
Java输入输出流/知乎@知乎用户LPgEOK
173.用( )方法可以改变线程的优先级。
A.run
B.setPrority
C.yield
D.sleep
174.假设已经声明了一个类A的两个对象a1、a2,为了初始化a1和a2,下面语句正确的是:
A.a1, a2 = new A();
B.a1 ,a2 = new();
C.a1 = new(); a2 = new();
D.a1 = new A(); a2 = new A();
175.下面哪些是合法的抽象类定义
A.abstract A {abstract void method()}
B.class abstract B {abstract void method()}
C.abstract class C {abstract void method()}
D.abstract class D {abstract void method(){System.out.println(“d”)
二、多选题（16题，2’）
1.下面哪些是合法的标识符：
A.TwoUsers
B.this
C._endline
D.$persons
E.*point
2.对关键词continue和break的理解是正确的是：
A.执行break之后，程序的控制流跳转到循坏块的之后的语句继续执行
B.continue和break没有区别
C.执行break之后，程序的控制流程跳转到循坏块的迭代部分继续判断
D.执行到continue后，程序的控制流跳转到循环块的之后之后执行
E.执行到continue后，程序的控制流跳转到循环块的迭代部分继续判断
3.在Java的异常处理语句try-catch-final中，以下描述不正确的是：
A.当程序运行时抛出的异常是catch语句中异常的子类，异常也会被捕捉执行相应的catch语句
B.try后面是可能产生异常的代码，catch后面是捕获到某种异常对象时进行处理的代码，final后面是没有捕获到异常时要执行的代码
C.catch语句和final语句都可以缺省
D.try后面是可能产生异常的代码，catch后面是捕获到某种异常对象时进行处理的代码，final后面无论是否捕获到异常都必须执行的代码
E.catch语句用来处理程序运行时的非致命性错误，而final语句用来处理程序运行时的致命性错误
4.能否利用返回值对函数进行重载？
A.不行，Java系统无法区分仅返回值不同的函数，编译时会报错
B.不行，因为Java并未明确要求函数的返回值必须赋给变量
C.可以，因为返回值也是函数的重要组成部分
D.可以，但仅能用于返回值为简单变量的情况
E.可以，但要求一个函数有返回值，另一个函数没有返回值
5.如果一个程序段中有多个catch，则程序会按如下哪种情况执行？
A.对每个catch都执行一次
B.找到适合的例外类型后就不再执行后面的catch
C.按顺序找到和catch异常类型匹配的第一个catch块执行，如果final块是必须执行的
D.找到每个符合条件的catch都执行一次
E.找到适合的异常类型后继续执行后面的catch
6.下面关于继承的哪些叙述是正确的？
A.在java中一个类只能实现一个接口
B.在java中对类只允许单一继承
C.在java中一个类不能同时继承一个类和实现一个接口
D.java的单一继承使代码更可靠
E.java的类允许使用多继承，即一个类允许有多个父类
7.给定下列代码：
public class Parent{
public int addValue(int a,int b){
int s;
s = a + b;
return s;
}
}
class Child extends Parent{
}
下列的方法声明如果作为Child类的方法，哪些方法不是对Parent类中的addValue方法的重写。
A.public int addValue(int a,int C){//do something...}
B.public void addValue(){/*do something...*/}
C.public int addValue(int a,int b){/*do something...*/}
D.protected int addValue(int a,double b)
E.int addValue(int a,int b){/*do something...*/}
8.下列组件哪个是Swing顶层容器？
A.JPanel
B.JSplitPane
C.JDialog
D.JApplet
E.ContentPane
9.以下关于Object类的描述中，错误的是（）
A.Object类提供了wait，notify，notifyAll等函数用于线程间同步
B.Object类提供了clone，compare，delete，add，insert等函数用于对对象进行操作
C.Object类是其他一切类的直接或间接父类
D.Object类定义了一些每个类都应该具有的基本的成员变量和成员函数
E.Object类是所有自定义类的直接或间接父类，但不是系统类的父类
10.下面标识符哪些是Java中的保留字或关键字？
A.synchronized
B.switch
C.break
D.class
E.out
11.在创建对象时有几种方法为对象的成员变量赋初值（）
A.为成员变量赋指定的初值
B.利用构造函数为成员变量赋初值
C.不能为对象的成员变量赋初值
D.在创建对象之前先为对象的成员变量赋初值
E.缺省情况下成员变量会自动赋值或空值
12.关于接口的定义和实现，以下描述正确的是：
A.如果一个接口由多个类来实现，则这些类在实现该接口中的方法时应采用同一的代码
B.接口定义中的变量都必须写明final和static
C.接口定义中的方法都只有定义没有实现
D.接口定义中的成员变量变量只能是static和final的
E.如果一个类实现一个接口，则必须实现该接口中的所有方法
13.以下关于函数重载的描述中，正确的是
A.重载是指一个类的多个成员函数具有相同的名称，但有不同的参数
B.重载的函数必须具有不同的参数
C.“函数参数不同”指参数名称不同
D.“函数参数不同”指参数的类型不同
E.返回值不同的函数也可以重载
14.以下关于线程的运行，暂停，结束的描述中，错误的是
A.Thead类的sleep静态函数可以使线程休眠一段时间
B.线程的启动通过线程类（或者其子类）的start函数来实现
C.wait函数会使线程处于等待状态，作用与sleep函数相同
D.调用stop函数使线程停止
E.一个线程不需要特别的代码来中止它，当run函数中的代码都执行完了以后，线程就自然中止了
15.函数的定义中有哪些选项
A.所属于的类名
B.函数名称
C.返回值的类型
D.参数列表
E.函数中的局部变量列表
16.以下关于中断控制语句的描述，错误的是
A.return用于退出整个子程序
B.在一个函数中，不管有没有返回值。都需要return语句来退出函数
C.break用于强行退出当前循环，不执行循环中剩余的语句，直接进入下一次循环
D.break语句用于中断当前的程序块，如for循环块，if结构块等的执行
E.continue停止继续执行下面的语句，直接跳出循环起始位置
17.哪两种方法不能直接引起一个线程中断执行？
A wait() ;
B notify() ;
C sleep() ;
D notifyAll() ;
E stop() ;
三、判断题（20题，1’）
1.一个流就是一个从源流向目的地的数据序列
A.对
B.错
2.引用一个类的属性或调用其方法,必须以这个类的对象为前缀
A.对
B.错
3.多线程没有安全问题
A.对
B.错
4.构造函数的方法名可由编程人员任意命名
A.对
B.错
5.在Java中,高优先级的可运行线程可能会抢占低优先级线程
A.对
B.错
6.Java有垃圾回收机制,内存回收程序可在指定的时间释放内存对象
A.对
B.错
7.多线程安全问题的解决方案可以使用Lock提供的具体的锁对象操作
A.对
B.错
8.Java程序里既是面向对象的又是面向过程的语言
A.对
B.错
9.构造函数用于创建类的实例对象,构造函数名应与类名相同,返回类型为void
A.对
B.错
10.继承是一种由已有的类创建新类的机制
A.对
B.错
11.Java只支持单继承,也就是说子类只能有一个直接父类
A.对
B.错
12.抽象方法使用关键词abstract修饰
A.对
B.错
13.Java中的引用变量需要初始化,简单变量可以不进行初始化
A.对
B.错
14.子类可以继承父类的除私有成员以外的其它所有成员
A.对
B.错
15.类的私有属性和私有方法可以被其子类访问
A.对
B.错
16.Java程序里,创建新的类对象用关键字new,回收无用的类对象使用关键字free
A.对
B.错
17.Java的源代码中定义几个类,编译结果就生成几个以.class为后缀的字节码文件
A.对
B.错
18.构造函数的方法名可由编程人员任意命名
A.对
B.错
19.如果线程死亡,它便不能运行
A.对
B.错
20.抽象方法使用关键词abstract修饰
A.对
B.错
四、简答题（18题，5’）
1.什么是JDBC。
Java Database Connectivity (JDBC) 是一种 Java API，用于在 Java 应用程序中访问和处理数据库。它提供了一组标准的用于执行数据库操作的类和接口，可以让使用者使用 Java 语言连接到各种不同类型的数据库，并执行常见的数据库操作，如执行查询和更新。JDBC 还提供了一组标准的异常类，用于在发生数据库错误时报告错误。JDBC 的优点在于它是一种跨数据库的标准，因此你可以使用相同的代码连接到多种不同的数据库，并执行相同的操作。你只需要更改 JDBC 驱动程序即可。
2.Throw/throws有什么联系和区别?
throw 和 throws 在 Java 中是两个不同的语句，它们用于处理异常（exception）。
throw 语句用于抛出一个异常对象。它可以在方法内部使用，并且必须指定要抛出的异常类型。throws 语句用于声明一个方法可能会抛出的异常类型。它通常出现在方法的声明中，后面跟着一个或多个异常类型。
3.什么是相等?什么是同一?
在 Java 中，同一指的是两个对象是否指向同一个对象，也就是用 == 操作符比较的结果。
而相等指的是两个对象的值是否相等，也就是用 equals() 方法比较的结果。
4.什么是事件源,事件监听,事件对象?
在 Java 中，事件源是产生事件的对象。事件监听器是一种特殊的对象，它可以监听事件源上的事件，并在事件发生时执行特定的动作。事件对象是包含事件信息的对象，它是由事件源创建的，并在事件发生时传递给事件监听器。
5.什么是异常?简述Java的异常处理机制。
异常是指在程序运行期间发生的错误情况。异常可以由程序本身引起，也可以由系统引起。
在 Java 中，如果某个代码块可能会抛出异常，那么就可以使用 try 块来包含这个代码块。如果发生异常，那么就会抛出一个异常对象。然后，可以使用 catch 块来捕获这个异常对象。
6.什么是多态
多态是一种编程概念，它指的是在运行时执行不同的行为的能力。 在多态中，同一段代码可以被用来操作不同类型的对象，并且每个对象都可以实现同一个方法（或函数）的不同版本。在面向对象编程中，多态通常通过继承和接口实现。 在继承中，子类可以重写（或覆盖）父类的方法，从而实现多态。 在接口中，多态可以通过实现接口并定义所需的方法来实现。
7.简述Java链接数据库的步骤
在 Java 中连接数据库的步骤如下：
1.加载 JDBC 驱动程序
2.获取数据库连接
3.创建 SQL 查询
4.执行查询
5.处理结果
6.关闭连接
8.什么是抽象的定义以及抽象的好处
抽象是从众多的事物中抽取出共同的、本质性的特征，而舍弃其非本质的特征的过程。
抽象的好处在于，它使我们能够更容易地理解和掌握复杂的概念，并使我们能够将这些概念应用到新的情况中。通过抽象思考，我们可以更好地理解复杂的概念，并在解决问题时更具创造性。
9.简述程序、进程和线程之间的关系?什么是多线程程序?
程序是指一组按照特定顺序编写的指令，这些指令用于计算机执行某些特定任务。
进程是指程序在计算机中的执行过程。在程序运行时，系统为其分配资源，如内存和处理器时间，并将其加入到调度队列中。
线程是指进程中的一个执行流程。在单核处理器系统中，只能有一个线程被执行，而在多核处理器系统中，可以有多个线程同时被执行。
多线程程序是指在单个进程中包含多个线程的程序。多线程程序可以同时执行多个任务，提高程序的效率。
10.什么是面向对象,什么是面向过程。
面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，其中程序被构建为对象的集合，这些对象可以互相发送消息并与其他对象协同工作。在面向对象编程中，对象是程序的基本单位。对象包含数据（称为属性）和行为（称为方法）。对象之间的交互是通过发送消息来实现的。
面向过程编程（Procedural Programming）是一种编程范式，其中程序被构建为一系列的过程，这些过程是独立的单元，用于执行特定的任务。在面向过程编程中，过程是程序的基本单位，过程可以调用其他过程并使用变量来存储数据。
11.请论述java的内存回收机制。
Java使用垃圾回收器来自动管理内存。垃圾回收器的工作是找出那些不再被应用程序使用的对象并将它们从内存中删除。这样，就可以为新的对象释放出空间，以便在需要时使用。
Java中有几种不同类型的垃圾回收器，包括新生代回收器、老年代回收器和全堆回收器。新生代回收器主要负责管理新创建的对象，而老年代回收器则主要负责管理存活时间较长的对象。全堆回收器则负责管理整个堆中的所有对象。
Java中使用两种主要算法来实现垃圾回收：引用计数算法和标记-清除算法。引用计数算法会为每个对象建立一个引用计数器，统计对象被引用的次数。当对象的引用计数为0时，该对象就可以被回收。标记-清除算法则会找出所有不再被使用的对象，然后将它们标记为“可回收”，并在之后的某个时刻将它们清除出内存。
12.什么是封装的定义以及封装好处有哪些
封装是编程中常用的一种设计原则，也叫作"信息隐藏"或"数据隐藏"。它的基本思想是将一个对象的内部细节隐藏在对象内部，只提供给用户必要的接口，使得用户无需了解对象的内部实现细节就能使用对象。
封装的好处：
1.使得对象的内部实现可以随时更改，而不会影响用户程序。
2.提高了代码的可重用性，因为用户无需了解对象的内部实现细节就能使用对象。
3.增强了代码的安全性，因为用户无法访问对象的内部实现细节，也无法破坏对象的内部状态。
4.提高了代码的可读性和可维护性，因为用户只需了解对象的接口就能使用对象，而无需了解对象的内部实现细节。
5.可以更好地控制类的访问权限，可以将类的接口与内部实现进行分离，使得类的内部实现可以更加灵活地改变。
13.举例说明什么是方法重载,什么是方法重写。
方法重载是指在同一个类中定义多个同名方法，但是这些方法的参数列表不同。
举个例子，假设我们有一个名为"Calculator"的类，里面有两个名为"add"的方法，一个接受两个int类型的参数，另一个接受三个int类型的参数。这两个方法就是重载方法。
方法重写是指在子类中定义一个与父类中同名的方法，并且这个方法的实现和父类中的方法不同。
举个例子，假设我们有一个名为"Animal"的类，它有一个名为"move"的方法，这个方法接受一个int类型的参数，表示动物要移动的距离。然后我们有一个名为"Dog"的类，它是"Animal"的子类，并且它有一个同名的"move"方法，但是这个方法的实现是让狗跑的速度比较快。这个"move"方法就是重写方法。
14.简述对象锁的工作原理
对象锁是一种同步机制，可以在 Java 程序中使用。它的工作原理是，当一个线程要访问一个共享资源时，它会请求获取对象锁。如果该对象锁没有被另一个线程持有，那么该线程就可以获取锁并访问该共享资源。如果该对象锁被另一个线程持有，那么该线程就会被阻塞，直到锁被释放为止。
15.什么是死锁
死锁是指两个或两个以上的进程（或线程）在执行过程中，因争夺资源而造成的一种互相等待的现象。
典型的死锁情况如下：进程A和进程B同时运行，进程A需要资源X和资源Y，而进程B需要资源Y和资源X。如果进程A获得了资源X，而进程B获得了资源Y，那么进程A就会等待进程B释放资源Y，而进程B同样会等待进程A释放资源X。由于进程A和进程B都在等待对方释放资源，导致系统无法继续执行下去，产生死锁。
16.什么是抽象类和抽象方法?
在面向对象编程中，抽象类是一种不能被实例化的类，它只能被用作其他类的基类。抽象类通常包含一些抽象方法，这些方法是不包含任何实现的方法声明，它们只包含方法名和参数列表。
抽象方法必须在派生类中被实现，也就是说，派生类必须提供具体的实现来替换基类中的抽象方法。这有助于确保派生类具有所有基类中声明的方法的正确实现。
17.什么是接口?和抽象类有什么相同点和不同点?
接口是一种特殊的类型，它可以定义一组方法，但不能实现这些方法。它只能被类实现，而且类可以实现多个接口。一个类实现接口必须实现接口中所有的方法。
接口和抽象类都是用于定义抽象方法的特殊类型。
接口和抽象类的主要区别在于：
接口只能被类实现，而抽象类可以被继承。
类可以实现多个接口，但只能继承一个抽象类。
接口中的所有方法都是抽象的，而抽象类可以包含抽象方法和非抽象方法。
18.面向对象中抽象的定义以及抽象的好处
在面向对象编程中，抽象是一种用于创建模板的概念。抽象可以帮助你定义一组相关的对象，并为这些对象定义共同的行为和属性。
抽象有助于将复杂的系统分解成更小的、更易于管理的部分。
抽象还有助于维护代码的一致性，因为它规定了子类必须实现的方法和属性。这可以帮助你避免在不同的类中出现不一致的行为。
五、编程题（9题，10’）
1.按以下要求编写程序：
利用多线程编程思想，通过继承Thread类来实现多线程。
要求创建3个新线程，每个线程睡眠一段时间（0～6秒），然后结束。
public class ThreadSleepTester {
public static void main(String[] args) {
//TODO:创建并命名每个线程
TestThread thread1 = new TestThread("thread1");
TestThread thread2 = new TestThread("thread2");
TestThread thread3 = new TestThread("thread3");
System.out.println("Starting threads");
thread1.start();
thread2.start();
thread3.start();
System.out.println("Thread started, main ends\n");
}
}
class TestThread extends Thread {
private int sleepTime; // 休眠时间
public TestThread(String name) {
super(name);
sleepTime=(int)(Math.random()*6000); // Math.random()产生随机数
}
public void run() {
try {
System.out.println(getName() + "going to sleep for " + sleepTime);
Thread.sleep(sleepTime);
} catch (InterruptedException exception) {
}
System.out.println(getName() + "finished");
}
}
2.编程实现多线程的内存共享：
用三个线程模拟电影院的4个售票口，总共出售50张票。
public class sellTicketsTester {
public static void main(String[] args) {
sellTickets t = new sellTickets();
new Thread(t,"Thread1").start();
new Thread(t,"Thread2").start();
new Thread(t,"Thread3").start();
new Thread(t,"Thread4").start();
//TODO:四个线程（售票口）
}
}
class sellTickets implements Runnable{
private int tickets = 50; //TODO:50张电影票
public void run() {
while(tickets>0) {
System.out.println(Thread.currentThread().getName()+" is selling ticket "+tickets--);
}
}
}
3.根据以下要求编程实现功能：
在C盘根目录创建文本文件Hello.txt。(手动创建)
（1）向文件中写入文本：I love Java very much.
（2）把hello.txt中的文本读出来显示到屏幕上。
（3）使用try、catch方法处理I/O异常。
（4）利用BufferedWriter进行缓冲。
import java.io.*;
public class Test {
public static void main(String [] args) throws IOException{
//TODO:3.处理I/O异常
try {
FileReader fr = new FileReader("C:\\Hello.txt");
FileWriter fr2 = new FileWriter("C:\\Hello.txt");
BufferedReader fw = new BufferedReader(fr);
//TODO:4.利用BufferedWriter进行缓冲
BufferedWriter fw2 = new BufferedWriter(fr2);
//TODO:1.向文件中写入文本：I love Java very much.
String str = "I love Java very much.";
fw2.write(str);
fw2.close();
//TODO:2.把Hello.txt中的文本读出来显示到屏幕上
str = fw.readLine();
while(str!=null){
System.out.println(str);
str = fw.readLine();
}
fw.close();
}
catch (IOException ioe){
System.out.println("Error : " + ioe);
}
}
}
4.按以下要求编写程序：
（1） 定义包含5个元素的数组intArrayExc = {11,23,0,15,7}
（2） 捕获公式intArrayExc[i] / intArrayExc[i+1]可能抛出的异常
public class Test {
public static void main(String[] args) {
int[] intArrayExc = {11, 23, 0, 15, 7};
//TODO:1.定义数组
try {
for (int i = 0; i < intArrayExc.length - 1; i++) {
int result = intArrayExc[i] / intArrayExc[i + 1];
System.out.println(intArrayExc[i] +"/" + intArrayExc[i + 1] + "result is:" + result);
}
}catch (ArithmeticException e){
System.out.println(e); //TODO:2.异常处理：输出错误信息
}
System.out.println("main end");
}
}
5.利用GUI技术，实现以下界面：
（1）填加按钮button事件监听；
（2）当点击按钮后，用户名和密码文本框内容清空。
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class Clear extends JFrame implements ActionListener{
public Clear() {
//不设置布局管理器
setLayout(null);
//窗口尺寸
setBounds(400, 400,300,200);
//新建容器
Container co = getContentPane();
JLabel username=new JLabel("用户名");
JLabel password=new JLabel("密码");
JTextField username1=new JTextField();
JPasswordField password1=new JPasswordField();
//重置按钮
JButton cancel =new JButton("提交");
cancel.setBounds(110,100,60,40);
//用户名&密码 文字
username.setBounds(30,20,50,30);
password.setBounds(30,60,50,30);
//用户名&密码文本框
username1.setBounds(110,20,140,30);
password1.setBounds(110,60,140,30);
//添加到容器中
co.add(username);
co.add(password);
co.add(username1);
co.add(password1);
co.add(cancel);
//TODO:1.直接创建按钮的监听
cancel.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
//TODO:2.重置逻辑
username1.setText("");
password1.setText("");
}
});
//使控件可以显示
setVisible(true);
//使用Systemexit方法退出应用程序
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
public static void main(String[] args) {
new Clear();
}
//ActionListener监听事件中的一个重写方法
public void actionPerformed(ActionEvent e) {
}
}
6.参照以上类结构图编写代码：
设计Shape2D以及Shape3D接口，继承自父接口Shape
要求如下：
（1）Circle类实现Shape2D接口，Box类实现Shape3D接口。Shape接口中有个setColor（String color）方法，用来给图形设置颜色
（2）Shape2D接口中有一个计算面积的方法area()，还有一个计算周长的方法perimeter()
（3）Shape3D接口中有一个计算表面积的方法surfaceArea()，还有一个计算体积的方法volume()
（4） 设计接口ShowInfo,其中有showShapeInfo()方法，用来显示实现该接口类对象的详细信息
（5） 在测试类中创建Circle、Box类对象，并体现出多态思想
public interface Shape {
//TODO:(1)Shape接口中有个setColor（String color）方法，用来给图形设置颜色
public void setColor(String color);
}
public interface Shape2D extends Shape,ShowInfo {
//TODO:(2)Shape2D接口中有一个计算面积的方法area()，还有一个计算周长的方法perimeter()
public double area();
public double perimeter();
}
public interface Shape3D extends Shape,ShowInfo{
//TODO:(3)Shape3D接口中有一个计算表面积的方法surfaceArea()，还有一个计算体积的方法volume()
public double surfaceArea();
public double volume();
}
public interface ShowInfo {
//TODO:(4)设计接口ShowInfo,其中有showShapeInfo()方法，用来显示实现该接口类对象的详细信息
public abstract void showShapeInfo();
}
import java.text.DecimalFormat;
//TODO:(1)Circle类实现Shape2D接口
public class Circle implements Shape2D {
private int radius;
private String color;
public static final double PI=3.14;
public int getRadius() {
return radius;
}
public void setRadius(int radius) {
this.radius=radius;
}
public void setColor(String color) {
this.color=color;
}
public String getColor() {
return color;
}
public void showShapeInfo() {
System.out.println("这是一个圆，颜色是："+color+"面积为："+new DecimalFormat("0.00").format(area())+"周长为:"
+new DecimalFormat("0.00").format(perimeter()));
}
public double area() {
return PI*radius*radius;
}
public double perimeter() {
return 2*PI*radius;
}
}
import java.text.DecimalFormat;
public class Rectangle implements Shape2D{
private double length;
private double weight;
private String color;
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
public void setColor(String color) {
this.color=color;
}
public String getColor() {
return color;
}
public void showShapeInfo() {
if(weight!=length) {
System.out.println("这是一个长方形，颜色是："+color+"面积为："+new DecimalFormat("0.00").format(area())+"面积为:"
+new DecimalFormat("0.00").format(perimeter()));
}
else {
System.out.println("这是一个正方形，颜色是："+color+"面积为："+new DecimalFormat("0.00").format(area())+"面积为:"
+new DecimalFormat("0.00").format(perimeter()));
}
}
public double area() {
return length*weight;
}
public double perimeter() {
return 2*(length+weight);
}
}
import java.text.DecimalFormat;
//TODO:(1)Box类实现Shape3D接口
public class Box implements Shape3D{
private double high;
private double length;
private double weigth;
private String color;
public double getHigh() {
return high;
}
public void setHigh(double high) {
this.high = high;
}
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
public double getWeigth() {
return weigth;
}
public void setWeigth(double weigth) {
this.weigth = weigth;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void showShapeInfo() {
System.out.println("这是一个立体图形，颜色是："+color+"表面积为："+new DecimalFormat("0.00").format(surfaceArea())+"体积为:"
+new DecimalFormat("0.00").format(volume()));
}
public double surfaceArea() {
return 2*((high*length)+(high*weigth)+(length*weigth));
}
public double volume(){
return high*length*weigth;
}
}
import java.text.DecimalFormat;
public class Sphere implements Shape3D{
public static final double PI=3.14;
private double radius;
private String color;
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void showShapeInfo() {
System.out.println("这是一个球体，颜色是："+color+"表面积为："+new DecimalFormat("0.00").format(surfaceArea())+"面积为:"
+new DecimalFormat("0.00").format(volume()));
}
public double surfaceArea(){
return 4*PI*radius*radius;
}
public double volume() {
return (4.0/3.0)*(PI*radius*radius*radius);
}
}
public class Tester {
public static void main(String[] args) {
//TODO:(5)在测试类中创建Circle、Box类对象，并体现出多态思想
Circle aCircle = new Circle();
aCircle.showShapeInfo();
Box aBox = new Box();
aBox.showShapeInfo();
ShowInfo aShowInfo = new Circle();
aShowInfo.showShapeInfo();
aShowInfo = new Box();
aShowInfo.showShapeInfo();
}
}
7.设计一个
Birthday类，其成员变量至少有：year,month,day；
（1）创建构造方法，并进行构造方法间的调用：
Birthday(int year,int month,int day)
Birthday(int year,int month)
Birthday(int year)
Birthday( )
（2）创建详细信息输出函数printBirthday()，输出对象的信息：输出格式 年-月-日
（3）分别用各种构造方法初始化不同的对象，然后调用printBirthday方法输出对象的信息
class Birthday {
private int year;
private int month;
private int day;
//设计一个Birthday类，其成员变量至少有：year,month,day；
//TODO:（1）创建构造方法，并进行构造方法间的调用：
public Birthday(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public Birthday(int year, int month) {
this.year = year;
this.month = month;
}
public Birthday(int year) {
this.year = year;
}
public Birthday() {
}
//set、get方法
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
//为类配置setTime，getTime方法，不创建新的对象直接修改时间
public void setTime(int inityear, int initmonth, int initday) {
year = inityear;
month = initmonth;
day = initday;
}
public void getTime() {
this.year = year;
this.month = month;
this.day = day;
}
//TODO:（2）创建详细信息输出函数printBirthday()，输出对象的信息：输出格式 年-月-日
public void printBirthday() {
System.out.println(year + "-" + month + "-" + day);
}
}
public class Tester {
public static void main(String[] args) {
//TODO:（3）分别用各种构造方法初始化不同的对象，然后调用printBirthday方法输出对象的信息
Birthday brithday1 = new Birthday();
brithday1.printBirthday();
brithday1.getTime();
brithday1.setTime(2001,1,1);
brithday1.printBirthday();
System.out.println("------------------------------");
Birthday brithday2 = new Birthday(2004);
brithday2.printBirthday();
brithday2.getTime();
brithday2.setTime(2002,2,2);
brithday2.printBirthday();
System.out.println("------------------------------");
Birthday brithday3 = new Birthday(2006,6);
brithday3.printBirthday();
brithday3.getTime();
brithday3.setTime(2003,3,3);
brithday3.printBirthday();
System.out.println("------------------------------");
Birthday brithday4 = new Birthday(2008,8,8);
brithday4.printBirthday();
brithday4.getTime();
brithday4.setTime(2004,4,4);
brithday4.printBirthday();
System.out.println("------------------------------");
}
}
8.根据以下要求编写代码：
（1）将三个int型数字255/0/-1写入数据文件data.dat
（2）将data.dat中的三个整数读出并相加，结果输出到屏幕上。
import java.io.*;
public class Test {
public static void main (String[] args) {
//TODO:1.写入数据
String fileName = "data.dat";
int value0 = 255, value1 = 0, value2 = -1;
try {
DataOutputStream out = new DataOutputStream(
new FileOutputStream( fileName ) );
out.writeInt( value0 );
out.writeInt( value1 );
out.writeInt( value2 );
out.close();
}
catch (IOException iox){
System.out.println("Problem writing"+ fileName);
}
//TODO:2.求和并打印
int sum = 0;
try{
DataInputStream instr = new DataInputStream(new BufferedInputStream(new FileInputStream(fileName)));
sum += instr.readInt();
sum += instr.readInt();
sum += instr.readInt();
System.out.println( "The sum is:" + sum );
instr.close();
}
catch (IOException iox) {
System.out.println("Problem reading"+ fileName );
}
}
}
9.按以下要求编写程序
（1）创建Shape类，有属性表示颜色color，以及get,set方法。
（2）创建一个Rectangle类，继承Shape类。添加width和height两个成员变量。
（3）在Rectangle中添加两种方法分别计算矩形的周长和面积。
（4）创建编程利用Rectangle输出一个矩形的周长和面积。
package Shape;
public class Shape {
//TODO:（1）创建Shape类，有属性表示颜色color，以及get,set方法。
public String color;
final static double PI =3.14;
public String getColor() { return color; }
public void setColor(String color) { this.color = color; }
}
package Shape;
public class Rectangle extends Shape {
//TODO:（2）创建一个Rectangle类，继承Shape类。添加width和height两个成员变量。
private static float height;
private static float width;
//长方形方法，参数有长和宽
public Rectangle(float initHeight, float initWidth) {
length = initHeight;
width = initWidth;
}
//set，get方法
public double getHeight() { return height; }
public static void setHeight(float newHeight) { height = newHeight; }
public double getWidth() { return length; }
public static void setWidth(float newWidth) { width = newWidth; }
//TODO:（3）在Rectangle中添加两种方法分别计算矩形的周长和面积。
public static double perimeter() { return (2*height+2*width); }
public static double area() { return (height*width); }
//TODO:（4）创建编程利用Rectangle输出一个矩形的周长和面积。
public void printInfo() {
System.out.printf("长方形的周长:"+perimeter()+"\n长方形面积:"+area());
}
public static void main(String[] args) {
Rectangle R1 = new Rectangle(10,10);
R1.printInfo();
}
}
2907
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
