Java 期末复习 习题集
兑生 2024-07-04 15:05:03 阅读 75
文章目录
😭 血泪教训❌ 代码补全题❌ 阅读程序写结果
💝 阅读程序✅ 数据类型✅ equals✅ 类✅ 静态变量和成员变量✅ 多态✅ 继承✅ 数组✅ 字符串✅ HashTable✅ 文件读写✅ IO流
💝 程序补全✅ 对象操作✅ 文件读写✅ 内部类 ⭐✅ 匿名内部类 ⭐
🐒博士练习题💖 单选题💖 填空题（期末不考此题型）💖 判断题💖 程序阅读题1. 读代码写结果2. 读代码写结果3. 读代码写结果4. 读代码写结果5. 读代码写结果
📖 试卷一一、选择题二、判断题
📖 试卷二一、选择题二、判断题
📖 试卷三一、选择题二、判断题
📖 试卷四一、选择题二、判断题
📖 试卷五一、选择题
📚不进🧠二、面向对象编程📙 面向对象特征📙 静态变量和成员变量📙 访问权限修饰符
三、继承📙 子类继承父类方法重写注意事项📙 final 关键字
四、多态📙 多态成员访问特点📙 重写和重载📙 抽象类的特点📙 抽象类的成员特点
五、接口和内部类📙 接口特点📙 接口成员特点📙 抽象类和接口的区别📙 内部类📙 匿名内部类
六、设计模式📙 单例设计模式 ⭐✨ 枚举实现✨ 饿汉式单例✨ 懒汉式单例
📙 简单工厂模式📙 工厂方法模式📙 抽象工厂模式📙 适配器模式
七、GUI编程📙 布局管理器📙 流布局管理器📙 事件响应的三大要素📙 事件响应的步骤📙 AWT概述📙 Swing概述📙 文本控件
八、集合📙 泛型通配符📙 Map 接口概述
九、异常处理📙 异常体系📙 编译型异常 和 运行时异常📙 throws 和 throw📙 finally
十、文件与IO流📙 IO 流基本类十一、多线程📙 线程的生命周期📙 线程状态转换图
十二、网络编程📙 网络模型📙 网络通信三要素📙 UDP 和 TCP📙 Socket 套接字📙 UDP 传输📙 TCP 传输
十三、类加载器与反射📙 类加载流程📙 类加载器📙 反射📙 反射获取构造方法📙 反射获取成员变量📙 反射获取成员方法📙 动态代理
十四、数据库编程📙 SQL 语句📙 JDBC📙 获取数据库连接📙 PrepareStatement
😭 血泪教训
<code>真题如下
❌ 代码补全题
几乎都是实验原题
内部类模拟用户登录三个售票窗口抢100张票LinkedList模拟栈
❌ 阅读程序写结果
父子类调用输出顺序（简单）字符串
public class Test
{
public static void main(String[] args)
{
String a = "helloworld";
String b = "hello";
String c = "world";
System.out.println(a == b + c);
System.out.println(a.equals(b + c));
System.out.println(a == "hello" + "world");
System.out.println(a.equals("hello" + "world"));
System.out.println(a == "helloworld");
System.out.println(a.equals("helloworld"));
}
}
💝 阅读程序
✅ 数据类型
<code>public class Test
{
public static void main(String[] args)
{
int test = 0;
System.out.println(test);// 0
System.out.println('a');// a
System.out.println('a' + 1);// 98
System.out.println("hello" + 'a' + 1);// helloa1
System.out.println('a' + 1 + "hello");// 98hello
System.out.println("5+5=" + 5 + 5);// 5+5=55
System.out.println(5 + 5 + "=5+5");// 10=5+5code>
final double PI = 3.14;
byte b = 024;// 0 开头表示八进制，2*8 + 4 = 20
short c = 0x17af;// 0x 开头表示十六进制
int d = 10000;
long e = -145L;
float f = -8.29F;
double g = 1.6E-4;
char h = 'h';
boolean i = false;
System.out.println("b=" + b);// b=20
System.out.println("c=" + c);// c=6063
System.out.println("d=" + d);// d=10000
System.out.println("e=" + e);// e=-145
System.out.println("f=" + f);// f=-8.29
System.out.println("g=" + g);// g=1.6E-4
System.out.println("h=" + h);// h=h
System.out.println("i=" + i);// i=false
}
}
byte b = (byte) 130;// byte 的范围为 -128 ~ 127
System.out.println(b);// -126
✅ equals
阅读下面的程序代码，并回答问题
String s1 = new String("abcde");code>
String s2 = new String("abcde");
boolean b1= s1.equals(s2);
boolean b2 = s1== s2;
System.out.print(b1+" "+b2);
程序段执行后，在命令行的输出结果如何？
true false解释输出问题1 的结果的原因？
equals方法比较两个字符串的内容是否相等
（String 重写了equals() 和 hashCode()方法，正常情况 equals() 和 “==” 一个效果）运算符“==”判断两个对象是否指向同一个引用，即是否为同一个对象。
✅ 类
写出下面的程序编译运行后的结果
public class Test
{
public static void main(String args[])
{
new Student("Tom", 'm', 90, 88);
new Student("Jack", 'm', 66, 89);
new Student("Mary", 'f', 76, 86);
System.out.println("name\tsex\tchinese\tenglish");
Student.print();
}
}
class Student
{
protected String name;
protected char sex;
protected int chinese;
protected int english;
protected Student next;
static Student list;
Student(String name, char sex, int chinese, int english)
{
this.name = name;
this.sex = sex;
this.chinese = chinese;
this.english = english;
this.next = list;
list = this;
}
static void print()
{
Student friend = list;
if (friend == null)
System.out.println("The list is empty.");
else
{
do
{
System.out.println(friend.toString());
friend = friend.next;
} while (friend != null);
}
}
public String toString()
{
return new String(name + "\t" + sex + "\t" + chinese + "\t" + english);
}
}
参考答案
✅ 静态变量和成员变量
<code>class Person
{
// 姓名
String name;
// 年龄
int age;
// 国籍（注意国籍是静态的）
// String country;
static String country;
public Person()
{
}
public Person(String name, int age)
{
this.name = name;
this.age = age;
}
public Person(String name, int age, String country)
{
this.name = name;
this.age = age;
this.country = country;
}
public void show()
{
System.out.println("姓名：" + name + ",年龄：" + age + ",国籍：" + country);
}
}
public class PersonDemo
{
public static void main(String[] args)
{
// 创建对象1
Person p1 = new Person("邓丽君", 16, "中国");
p1.show();
// 创建对象2
Person p2 = new Person("杨幂", 22);
p2.show();
// 创建对象3
Person p3 = new Person("凤姐", 20);
p3.show();
p3.country = "美国";
p3.show();
p1.show();
p2.show();
}
}
运行结果
姓名：邓丽君,年龄：16,国籍：中国
姓名：杨幂,年龄：22,国籍：中国
姓名：凤姐,年龄：20,国籍：中国
姓名：凤姐,年龄：20,国籍：美国
姓名：邓丽君,年龄：16,国籍：美国
姓名：杨幂,年龄：22,国籍：美国
✅ 多态
读程序，写出正确的运行结果。
// AbstractClassDemo.java源代码如下：
abstract class Shape { //定义抽象类Shape和抽象方法display
abstract void display();
}
class Circle extends Shape {
void display() { //实现抽象类的方法
System.out.println("Circle");
}
}
class Rectangle extends Shape {
void display() { //实现抽象类的方法
System.out.println("Rectangle");
}
}
class Triangle extends Shape {
void display() { //实现抽象类的方法
System.out.println("Triangle");
}
}
public class AbstractClassDemo {
public static void main(String args[]) {
(new Circle()).display(); //定义无名对象来调用对应的display方法
(new Rectangle()).display();
(new Triangle()).display();
}
}
参考答案
Circle；
Rectangle；
Triangle。
读程序，写出正确的运行结果。
public class Test
{
public static void main(String[] args)
{
A a = new B();
a.show();
B b = new C();
b.show();
}
}
class A
{
public void show()
{
show2();
}
public void show2()
{
System.out.println("我");
}
}
class B extends A
{
/*
public void show() {
show2();
}
*/
public void show2()
{
System.out.println("爱");
}
}
class C extends B
{
public void show()
{
super.show();
}
public void show2()
{
System.out.println("你");
}
}
参考答案
爱
你
✅ 继承
读程序，写出正确的运行结果。
public class Father {
int a = 100;
public void miner() {
a--;// 只对当前类的成员变量 a 生效，并不影响子类的 a
}
public static void main(String[] args) {
Father x = new Father();
Son y = new Son();
System.out.println(y.a);
System.out.println(y.getA());
y.miner();//调用的是父类的方法
System.out.println(y.a);
System.out.println(y.getA());
}
}
class Son extends Father {
int a = 0;
public void plus() {
a++;
}
public int getA() {
return super.a;
}
}
参考答案
0
100
0
99
✅ 数组
应用程序的main方法中有以下语句，则输出的结果是什么？
int b[][]={ { 1, 1, 1}, { 2,2}, { 3}};
int sum=0;
for(int i=0; i<b.length; i++) {
for(int j=0; j<b[i].length; j++) {
sum+=b[i][j];
}
}
System.out.println("sum="+sum);
参考答案：sum=10
👩🏫 思路：
1
+
1
+
1
+
2
+
2
+
3
=
10
1+1+1+2+2+3=10
1+1+1+2+2+3=10
✅ 字符串
应用程序的main方法中有以下语句，则输出的结果是什么？
String s = "xxxxxxxxxxxxxxx#123#456#zzzzz";code>
int n = s.indexOf("#");// n 是第一个"#"的下标
int k = s.indexOf("#", n+1);// k 是第二个"#"的下标
String s2 = s.substring(n+1, k);
System.out.println(s2);
参考答案：123
✅ HashTable
应用程序的main方法中有以下语句，则输出的结果是什么？
Hashtable hashtable=new Hashtable();
hashtable.put("100","aaa");
hashtable.put("200","bbb");
hashtable.put("300","ccc");
System.out.println(hashtable.get("300").toString()
+ hashtable.get("200").toString()
+ hashtable.get("100").toString());
参考答案：cccbbbaaa
✅ 文件读写
下面的程序创建了一个文件输出流对象，用来向文件test.txt中输出数据，假设程序当前目录下不存在文件test.txt，编译下面的程序Test.java后，将该程序运行3次，则文件test.txt 的内容是什么？
import java.io.*;
public class Test {
public static void main(String args[]) {
try {
String s = "ABCDE";
byte b[] = s.getBytes();
FileOutputStream file = new FileOutputStream("test.txt", true);
file.write(b);
file.close();
} catch (IOException e) {
System.out.println(e.toString());
}
}
}
参考答案：ABCDE
✅ IO流
读下列代码，说出这段程序的功能。
import java.io.*;
public class Test {
public static void main(String[] argv) {
try {
BufferedReader is =
new BufferedReader(new InputStreamReader(System.in));
String inputLine;
While((inputLine = is.readLine()) != null) {
System.out.println(inputLine);
}
is.close();
} catch (IOException e) {
System.out.println("IOException: " + e);
}
}
}
参考答案
读取键盘输入，显示到屏幕上，直到键盘输入为空为止。
💝 程序补全
✅ 对象操作
public class Leaf {
private int i = 0; //此属性值用于检验
Leaf increment() { //定义方法increment()，返回值是Leaf类的对象
i++;
return (1); //将当前对象的地址作为返回值返回
}
void print() {
System.out.println(" i = " + i);
}
public static void main(String args[]) {
Leaf x = (2); //创建Leaf类的对象x
x.increment().increment().increment().print();
} //多次调用方法increment()，返回的都是x的地址，i 值表示调用次数
}
参考答案
(1) this；
(2) new Leaf()；
(3) 3
✅ 文件读写
class FileStream
{
public static void main(String args[])
{
try
{
File inFile = new File("file1.txt"); //指定源文件
File outFile = new File("file2.txt"); //指定目标文件
FileInputStream fis = （1）;
FileOutputStream fos = new FileOutputStream(outFile);// 类名可参考此代码
int c;
//逐字节从源文件中输入，再输出到fos流
while((c = fis.read()) != -1)（ 2）;
fis.close();
fos.close();
}
catch(Exception e)
{
System.out.println("FileStreamsTest: " + e);
}
}
}
参考答案
(1) new FileInputStream(inFile);
(2) fos.write(c);
✅ 内部类 ⭐
<code>class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num);// 局部变量
System.out.println(this.num);// 内部类的成员变量
System.out.println(Outer.this.num);// 外部类的成员变量
}
}
}
class OuterInnerDemo{
public static void main(String[] args){
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
✅ 匿名内部类 ⭐
<code>/*
要求在控制台输出”HelloWorld”
分析：Outer.method()是静态方法的调用格式，说明Outer类中有一个静态方法method()
Outer.method().show()说明Outer.method()方法返回了一个实现了Inner接口中show()
方法的对象
*/
interface Inner
{
void show();
}
static class Outer
{ // 补齐代码
public static Inner method()
{
return new Inner()
{
public void show()
{
System.out.println("HelloWorld");
}
};
}
}
public static void main(String[] args)
{
Outer.method().show();
}
🐒博士练习题
💖 单选题
💖 填空题（期末不考此题型）
💖 判断题
💖 程序阅读题
1. 读代码写结果
<code>class A
{
int m = 5;
void zengA(int x)
{
m = m + x;
}
int jianA(int y)
{
return m - y;
}
}
class B extends A
{
int m = 3;
int jianA(int z)
{
return super.jianA(z) + m;
}
}
public class Test
{
public static void main(String[] args)
{
A a1 = new A();
A a2 = new A();
B b = new B();
A t = (A) b;
A a3, a4;
a3 = b;
a4 = a1;
a1.zengA(5);
a3.zengA(6);
b.m = 4;
System.out.println(a1.m); // 【代码 1】
System.out.println(a2.m); // 【代码 2】
System.out.println(a3.m); // 【代码 3】
System.out.println(a4.m); // 【代码 4】
System.out.println(a3.jianA(1)); // 【代码 5】11-1+4 = 14
}
}
2. 读代码写结果
<code>abstract class A
{
public abstract double f(double x, double y);
}
class B extends A
{
double m;
public double f(double a, double b)
{
return a * b + m;
}
}
public class E
{
public static void main(String args[])
{
B b = new B();
A a = b;
b.m = 2.0;
System.out.println(a.f(2.0, 3.0)); // 【代码 1】 2 * 3 + 2 = 8.0
}
}
3. 读代码写结果
<code>class A
{
static int m = 5;
void zengA(int x)
{
m = m + x;
}
}
public class E
{
public static void main(String args[])
{
A a1 = new A();
A a2 = new A();
a2.zengA(5);
System.out.println(a1.m); // 【代码 1】
System.out.println(a2.m); // 【代码 2】
}
}
4. 读代码写结果
<code>class A
{
int x = 100;
double y = 200.3;
A(int x)
{
x = x;
}
A(double y)
{
this.y = y;
}
double B()
{
return x + y;
}
}
public class Test
{
public static void main(String[] args)
{
A a1 = new A(-80);// 构造方法：细节 x=x，相当于啥也没干
System.out.println(a1.B()); // 【代码 1】100+200.3 = 300.3
A a2 = new A(60.5);
System.out.println(a2.B()); // 【代码 2】
}
}
5. 读代码写结果
{
public double f(double x, double y);
}
class B implements A
{
double m;
public double f(double a, double b)
{
return a * b + m;
}
}
public class E
{
public static void main(String args[])
{
B b = new B();
A a = b;
b.m = 2.0;
System.out.println(a.f(2.0, 3.0));// 2 * 3 + 2 = 8
}
}
📖 试卷一
一、选择题
<code>🔔 加粗项 即为 答案
Java源程序经编译生成的字节码文件的扩展名为（），字节码文件由解释器执行。
A）class
B）java
C）exe
D）html
下面哪一个函数是线程的入口函数？
A）private void run()
B）public void run()
C）public void start()
D）public void begin()
关于组合框（combo box），以下陈述中哪个为真？
A）组合框允许选择多个元素。
B）组合框的缺省是可编辑的。
C) 组合框只允许选择一个元素。
D）组合框用JComboBox类表示，它是由JList类派生过来的。
何时线程进入runnable 阶段？
A）当调用get() 方法时
B）当调用setTime() 方法时
C）当调用showStatus() 方法时
D）当调用start()方法时
下列不属于WindowListener接口的是（ ）
A）windowOpened()
B）windowClosed()
C）windowActivated()
D）mouseDragged()
System类属于（ ）包。
A）java.util
B）java.io
C）java.awt
D）java.lang
代码模板产生了一个异常ArrayStoreException。产生这个错误可能的原因是什么？
A）程序试图在数组中存贮错的数据类型
B）程序试图在数组单元0存贮数据
C）程序试图在串中访问不存在的字符位置
D）程序试图访问数组下标外的数组元素
在Java中，要想使本身. 子类或包中的方法可以访问该类，应该用（）关键字。
A）不需要任何关键字
B）private
C）final
D）protected
如何强制垃圾回收一个对象？
A）不能强制回收
B）调用System.gc()
C）调用System.gc(),并传入对象引用
D）调用Runtim.gc()
有关网络通信的类都集中在哪一个包中？
A）.Java.network.;
B）Java.socket.;
C）Java.net.*;
D）.Java.message.*;
既能作为类的修饰符, 也能作为类成员的修饰符的是( )。
A) public
B) extends
C) Float
D）static
下面哪一个是非法的标识符？
A）2variable
B）Variable2
C）_what
D） _3_
哪个不是FilterInputStream的子类?
A）DataInputStream
B）BufferedInputStream
C）PushbackInputStream
D）FileInputStream
在窗体上，单击一个按钮，会产生什么事件？
A）ClickEvent
B）ActionEvent
C）MouseEvent
D）ButtonEvent
预测以下代码的输出：
A) 将有一个编译错误，因为名字和id没有初始化。
B) 将印出”Name:Alisha ID:C001” 。
C) 将引发一个异常，因为没有创建学生。（<code>new Student() 少了后面的小括号）
D) 将有一个编译错误，因为学生引用没有初始化。
class Student{
String name;
String id;
void display(){
System.out.println(“Name:”+name+” ID :”+id);
}
public static void main(String args[]){
Student student=new student;
student.name="Alisha";code>
student.id=”C001”;
student.display();
}
}
下面的语句的作用是：（ ）。
Vector MyVector = new Vector(100,50);
A) 创建一个数组类对象MyVector，有100个元素的空间，每个元素的初值为50。
B) 创建一个向量类对象MyVector，有100个元素的空间，每个元素的初值为50。
C) 创建一个数组类对象MyVector，有100个元素的空间，若空间使用完时，以50
个元素空间单位递增。
D) 创建一个向量类对象MyVector，有100个元素的空间，若空间使用完时，以50个元素空间单位递增。
二、判断题
🔔 错的打叉：❌
Java虚拟机是实现跨平台的基础。Java支持多继承。❌sleep()方法是使线程停止一段时间的方法。实现一个接口，则在类中一定要实现接口中的所有方法。一个Java类可以有多个父类，这称作多继承。❌只要类中显式地定义一个构造方法，那么Java默认的构造方法不再存在。构造方法没有任何返回类型，哪怕是void也不行。抽象类不能实例化。一个异常处理中 finally语句块只能有一个或者可以没有。程序中抛出异常时(throw …)，只能抛出自己定义的异常对象。❌用Javac编译Java源文件后得到代码是二进制的。String类在java.lang包中。final类是为防止他人从你的类上派生新类，此类是不可继承的。所有的文件输入/输出流都继承于InputStream类/OutputStream类。❌
📖 试卷二
一、选择题
下面哪些是java语言中的关键字？
A）sizeof
B）abstract
C）NULL
D）Native
当试图访问超出数组下标的数组元素时会引发下列哪种异常：
A）ArithmeticException
B）NullPointerException
C）ArrayIndexOutOfBoundsException
D）NumberFormatException
Java在调用Thread.sleep(100)方法的时候会抛出什么异常？
A）InterruptedException
B）IllegalAccessException
C）SleepException
D）RuntimeException
关于被私有保护访问控制符private修饰的成员变量,以下说法正确的是()
A) 可以被三种类所引用:该类自身,与它在同一个包中的其他类,在其他包该类的子类
B) 可以被两种类访问和引用:该类本身,该类的所有子类
C) 只能被该类自身所访问和修改
D) 只能被同一个包中的类访问
在服务器端，ServerSocket使用什么方法监听来自客户的通信？
A）Get()
B）Accept()
C） GetClient()
D）AcceptClient()
必须将组件放在一定的（ ）中才能显示出来。
A) 容器
B) 组件
C) 浏览器
D) 窗口
判断下面陈述中那句话是正确的？
A）try语句可以单独存在，不需要其他的附加语句。
B）try语句不能单独存在，后面必须要和catch或final语句配合使用。
C）在try语句后面的catch语句只能有一句。
D）final语句的作用是用来完成一些做不了的工作。
用abstract定义的类( )
A) 可以被实例化
B) 不能派生子类
C) 不能被继承
D) 只能被继承
Java语言中，负责并发管理的机制是（ ）
Ａ) 垃圾回收
Ｂ) 虚拟机
C) 代码安全
D) 多线程
线程生命周期中正确的状态是（ ）
A) 新建. 就绪. 运行. 堵塞和死亡
B) 新建. 运行和死亡
C) 新建. 运行. 阻塞和死亡
D) 就绪. 运行. 堵塞和死亡
以下类中哪一个是所有异常类的基类？
A）Exception
B）Throwable
C）Error
D) RuntimeException
下面哪一个不是Java关键字？
A）true
B）sizeof
C）super
D）void
题目：下面的哪些叙述为真（存在争议）
A）equals()方法判定引用值是否指向同一对象。（equals()可能会被重写）
B）== 操作符判定两个分立的对象的内容和类型是否一致。
C）equals()方法只有在两个对象的内容一致时返回true。
D) 类File重写方法equals()在两个分立的对象的内容和类型一致时返回true
下面那个方法不是InputStream类中的方法?
A）int read(byte[])
B）void flush()
C）void close()
D） int available() 返回输入流中的可读字节数
有关线程的哪些叙述是对的。
A) 一旦一个线程被创建，它就立即开始运行。
B) 用start()方法可以使一个线程成为可运行的，但是它不一定立即开始运行。
C) 当一个线程因为抢先机制而停止运行，它被放在可运行队列的前面。
D) 一个线程可能因为不同的原因停止（cease）并进入就绪状态。
一个可以独立运行的Application Java应用程序( )
A) 可以有一个或多个main方法
B) 最多只能有两个main方法
C) 可以有一个或零个main方法
D) 只能有一个main方法
在线程通信过程中，Java可以使用什么关键字来避免出来冲突？
A）Lock
B）Synchronized
C）Synclock
D）belock
就线程优先级而言，检查以下陈述的有效性。
陈述A：线程从创建它的线程中继承它的优先级。
陈述B：被继承的优先级不可被改变。❌
A) A为TRUE ，B为FALSE
B) A为FALSE，B为TRUE
C) A和B都为TRUE
D) A和B都为FALSE
为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为( )。
A）static void method( )
B）public void method( )
C）final void method( )
D）abstract void method( )
下面那个选项是正确的包含50个字符串数组的声明？B
A）String obj[50]; ❌ 声明不允许有数组长度
B）String[] obj; ✅
C）Object obj[50]; Object 是 String的父类，理论上也行
D）Char obj[50]
二、判断题
🔔 错的打叉：❌
Java是一种面向过程的程序设计语言。❌
构造方法可以被继承。❌
application是从其中的main()方法开始运行的。
Java中类的构造函数只能有一个。❌
用final修饰的类必须被继承。❌
所有的文件输入/输出流都继承于InputStream类/OutputStream类。❌
int x=9; if(x>8 and x<10) System.out.println(“true”); 以上语句运行结果显示true 。
接口的所有方法默认都是public,abstract和non-static的。
只要类中显式地定义一个构造方法，那么Java默认的构造方法不再存在
Java数组随时可以改变大小。❌
抽象类不能实例化。
程序中抛出异常时(throw …)，只能抛出自己定义的异常对象。❌
<code>super()和this()方法只能在构造函数里调用。
📖 试卷三
一、选择题
下列关于栈的叙述正确的是
A) 栈是非线性结构
B) 栈是一种树状结构
C) 栈具有先进先出的特征
D) 栈具有后进先出的特征
下列不是InputStream子类的是
A) 文件输入流FileInputStream
B) 对象输入流ObjectInputStream
C) 字符输入流CharInputStream（不存在此类）
D) 压缩文件输入流ZipInputStream
下列方法中可以用来创建一个新线程的是
A) 实现java.lang.Runnable接口并重写start()方法
B) 实现java.lang.Runnable接口并重写run()方法（只是创建了一个任务）
C) 继承java.lang.Thread类并重写run()方法
D) 继承java.lang.Thread类并重写start()方法
Java语言具有许多优点和特点，下列选项中，哪个反映了Java程序并行机制的特点
A) 安全性
B) 多线性
C) 跨平台
D) 可移植
哪种循环在条件表达式被计算之前至少执行循环体语句一次
A）do-while循环
B）for循环
C) while循环
D) 以上都不是
数组的哪个实例变量可以确定数组的长度
A) size
B) length
C) max_value
D) Length()
异常包含下列那些内容
A) 程序中的语法错误
B) 程序的编译错误
C) 程序执行过程中遇到的事先没有预料到的情况
D) 程序事先定义好的可能出现的意外情况
Character流与Byte流的区别是
A) 每次读入的字节数不同
B) 前者带有缓冲，后者没有
C) 前者是块读写，后者是字节读写
D) 二者没有区别，可以互换使用
监听事件和处理事件
A) 都由Listener完成
B) 都由相应事件Listener处登记过的构件完成
C) 由Listener和构件分别完成
D) 由Listener和窗口分别完成
下列哪个属于容器的构件
A) JFrame
B) JButton
C) Pnel
D) JApplet
为实现多线程之间的通信，需要使用下列那种流才合适？
A) Filter stream
B) File stream
C) Random access stream
D) Piped stream
下面关于Applet的说法正确的是
A）Applet也需要main方法
B）Applet继承自java.awt.Applet或javax.swing.JApplet
C）Applet能访问本地文件
D）Applet程序不需要编译
查找随机文件的记录时，应使用的方法是
A）readInt()
B）readBytes(int n)
C）seek(long l)
D）readDouble()
下列叙述中，正确的是
A）Reader是一个读取字符文件的接口
B）Reader是一个读取数据文件的抽象类
C）Reader是一个读取字符文件的抽象类
D）Reader是一个读取字节文件的一般类
编译 Java Applet 源程序文件产生的字节码文件的扩展名为
A）java
B）class
C）html
D）exe
下列叙述中，错误的是
A) 父类不能替代子类
B) 子类能够替代父类
C) 子类继承父类
D) 父类包含子类
在switch(expression)语句中，expression的数据类型不能是
A）double
B）char
C）byte
D）short
main 方法是 Java Application 程序执行的入口点，关于 main 方法的方法头以下哪项是合法的
A）public static void main （ ）
B）public static void main （ String args[] ）
C）public static int main （ String [] arg ）
D）public void main （ String arg[] ）
在某个类中定义一个方法：void GetSort(int x),以下关于能否做为这个方法的重载错误的是
A）void GetSort(float x){x*=x;}
B）int GetSort(double y){return(int)(s*y);}
C）double GetSort(int x,int y){return x+Y}
D) 都不能
假设有String a=“A”;char b=’A’;int c=65，下面选项中_____是正确
A）if(a == b) {System.out.print(“Equal”)}
B）if(c == b) {System.out.print(“Equal”)}
C）if(a == c) {System.out.print(“Equal”)}
D）if(c = b) {System.out.print(“Equal”)}
下列代码中，将引起编译错误的行是
A) 第2行
B) 第3行 (0.0 默认为double 类型，不能强制转换为 float 类型，正确写法应为 0.0f)
C) 第4行
D) 第6行
1）public class Exercise{
2） public static void main(String args[]){
3） float f=0.0;
4） f+=1.0;
5） }
6）}
下列代码中，将引起一个编译错误的行是
A) 第3行
B) 第5行
C) 第6行
D) 第10行 （找不到此构造方法）
1)public class Test{
2) int m,n;
3) public Test(){ }
4) public Test(int a){ m=a;}
5) public static void main(String args[]){
6) Test t1,t2;
7) int j,k;
8) j=0;k=0;
9) t1=new Test();
10) t2=new Test(j,k);
11) }
12) }
二、判断题
🔔 错误的打 ❌
Java 和 c++都是面向对象的程序设计语言。
字符串 “‘a’” 的长度是5。❌
同一个类中定义多个参数列表不同的同名方法,叫做方法的重载。
一个类的定义包括定义类头和定义类体两个部分。
一个程序里可以有多个父类，也可以有多个主类。❌
子类的对象能直接向其父类对象赋值。
抽象方法只能存在于抽象类中。
在父类中声明为 final 的方法，也可以在其子类中被重新定义(覆盖)。❌
接口中所有方法均为抽象方法。
False 是合法的 Java 标识符。
子类的类成员变量不能与其父类的类成员变量同名。❌
static 变量不能是 private 变量。❌
保留字 this 代表当前对象。
类的构造函数名必须和类名相同。
一个子类可以重新定义从父类那里继承来的同名方法，允许它们有不同的返回值。❌
📖 试卷四
一、选择题
下列哪项是Java调试器，如果编译器返回程序代码的错误，可以用它对程序进行调试
A）java.exe
B）javadoc.exe
C）jdb.exe（java debug）
D）javaprof.exe
下列的哪个选项可以正确用以表示八进制值8
A）0x8
B）0x10
C）08
D）010 （0开头：表示是八进制）
下列的哪个赋值语句是不正确的
A）float f = 11.1;
B）double d = 5.3E12;
C）float d = 3.14f ;
D）double f=11.1E10f;
下列的哪个赋值语句是正确的
A）char a=12;
B）int a=12.0;
C）int a=12.0f;
D）int a=（int）12.0;
下列于继承的哪项叙述是正确的
A) 在java中允许多重继承
B) 在java中一个类只能实现一个接口
C) 在java中一个类不能同时继承一个类和实现一个接口
D) java的单一继承使代码更可靠
下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问
A）private
B) 无修饰符
C）public
D）protected
判断下面陈述中那句话是正确的
A）try语句可以单独存在，不需要其他的附加语句
B）try语句不能单独存在，后面必须要和catch或final语句配合使用
C) 在try语句后面的catch语句只能有一句
D）final语句的作用是用来完成一些做不了的工作
下列关于内部类的说法不正确的是
A) 内部类的类名只能在定义它的类或程序段中或在表达式内部匿名使用
B) 内部类可以使用它所在类的静态成员变量和实例成员变量
C) 内部类不可以用abstract修饰符定义为抽象类（<code>可以的）
D) 内部类可作为其他类的成员，而且可访问它所在类的成员
下列常见的系统定义的异常中，哪个是输入. 输出异常
A）ClassNotFoundException
B）IOException（I：input；O：output）
C）FileNotFoundException
D）UnknownHostException
下列哪个不是nio（not blocking io）包的新特点
A) 内存映射技术
B) 文件锁定
C) 字符及编码
D) 阻塞I/O（这个是 BIO，B：blocking 阻塞）
下列哪个选项是正确计算42度（角度）的余弦值
A）double d=Math.cos（42）
B）double d=Math.cosine（42）
C）double d=Math.cos（Math.toRadians（42））
D）double d=Math.cos（Math.toDegrees（42））
下列InputStream类中哪个方法可以用于关闭流
A）skip（）
B）close（）
C）mark（）
D）reset（）
下列方法中哪个是执行线程的方法
A）run（）
B）start（）
C）sleep（）
D）suspend（）
下列关于Frame类的说法不正确的
A) Frame是Window类的直接子类
B) Frame对象显示的效果是一个窗口
C) Frame被默认初始化为可见
D) Frame的默认布局管理器为BorderLayout
下列Java常见事件类中哪个是鼠标事件类
A）InputEvent
B）KeyEvent
C）MouseEvent
D）WindowEvent
下列哪个是面向大型企业级用容器管理专用构件的应用平台
A）J2EE
B）J2ME
C）J2SE
D）J2DE
能从循环语句的循环体中跳出的语句是
A）for 语句
B）break 语句
C）while 语句
D）continue语句
何时线程进入runnable 阶段？
A）当调用get() 方法时
B）当调用setTime() 方法时
C）当调用showStatus() 方法时
D）当调用start()方法时
给出下列代码，则数组初始化中哪项是不正确的
byte[ ] array1,array2[ ];
byte array3[ ][ ];
byte[ ][ ] array4;
A）array2 = array1
B）array2=array3
C）array2=array4
D）array3=array4
📚 array1 是一维数组，array2是二维数组（byte[] array2[]）
下面哪个是合法的布尔值？
A） “false”
B) false
C） 0
D） f
顺序执行下列程序语句后，则b的值是
String a=“Hello”;
String b=a.substring（0,3）;
A）Hello
B）hello
C）Hel
D）null
二、判断题
🔔 错误的打 ❌
Java中的的字符使用的是 16 位的Unicode 编码。
类是同种对象的集合和抽象。
Java 仅支持类间的单重继承。
接口是由常量和抽象方法组成的特殊类。
构造函数的方法名可由编程人员任意命名。❌
使用静态属性必须以类名做前缀。❌（同一个类中不用前缀）
类的私有属性和私有方法可以被其子类访问。❌
abstract 是抽象修饰符，可以用来修饰类及其属性和方法。❌（<code>不能修饰属性）
Java 支持多线程机制。
一个 Java 源程序中允许有多个公共类。❌ （只能有一个公共类）
Java 程序可以划分为两大类: Application 和 Applet
for 语句中的循环体不能是空的。❌
子类不能继承父类的构造函数。
重载的方法可以通过它们的返回值类型的不同来区分。❌
数组一定占用连续的内存空间。（其实不一定，不过理论上是连续的）
📖 试卷五
一、选择题
一、 单选题
当某一线程正处于休眠状态，而另一个线程用 Thread 类中的 interrupt() 方法中断它时，抛出的异常类型是（ ）。
A) IOException
B) RuntimeException
C) InterruptedException
D) ClassNotFoundException
下面的程序段的功能是( )。
File file1=new File("d:\\xxx\\yyy\\zzz");
file1.mkdirs();
A)在当前目录下生成子目录：\xxx\yyy\zzz
B)生成目录： e:\xxx\yyy\zzz
C)在当前目录下生成文件xxx.yyy.zzz
D)以上说法都不对
关于下面的程序Test.java说法正确的是( )。
A)3
B)102
C) 12
D)程序有编译错误
public class Test {
String x = "1";
int y;
public static void main(String args[]) {
int z = 2;
// 非 staic 的 x，y 不能在static的main方法里直接使用
System.out.println(x + y + z);
}
}
应用程序的main方法中有以下语句，则执行后输出的结果是 ( )。
A) 125
B) 5
C) 98
D) 168
int[] x = { 125,21,5,168,98};
int min = x[0];
for (int i=1; i<x.length; i++){
if(x[i] < min)
min = x[i];
}
System.out.println(min);
以下关于java异常说法不正确的是（ ）。
A) Throwable 类是 Java 语言中Error类和Exception类的父类。
B) 当异常对象是Exception类（或其子类）的实例时，能通过 Java 虚拟机或者 throw 语句抛出该异常对象，并能通过try…catch…finally处理。
C) 如果只用一个catch块捕捉多个异常对象，则catch 子句中的参数类型应是所有异常对象的父类。
D) 以上说法都正确。
下面说法不正确的是( )？
A)列表(List). 集合(Set)和映射(Map)都是java.util包中的接口。
B)List接口是可以包含重复元素的有序集合。
C)Set接口是不包含重复元素的集合。
D)Map接口将键映射到值，键可以重复，但每个键最多只能映射一个值。
📚不进🧠
二、面向对象编程
📙 面向对象特征
封装(encapsulation)：解决了数据的安全性问题继承(inheritance)：解决了代码的重用问题多态(polymorphism)：解决了程序的拓展问题
📙 静态变量和成员变量
📙 访问权限修饰符
默认也叫<code>缺省
三、继承
📙 子类继承父类方法重写注意事项
📙 final 关键字
四、多态
📙 多态成员访问特点
📙 重写和重载
📙 抽象类的特点
📙 抽象类的成员特点
五、接口和内部类
📙 接口特点
📙 接口成员特点
🔔 题外话：其实接口的成员方法不一定是抽象方法，但在考试里最好选择保守的。
👨🏫 参考文章
{
public abstract void print();
default void dprint()// 并非抽象方法
{
System.out.println("接口中的默认方法");
}
}
📙 抽象类和接口的区别
🔔 题外话： jdk8 之后，接口也可以有非抽象方法 👨🏫 参考文章
📙 内部类
📙 匿名内部类
六、设计模式
📙 单例设计模式 ⭐
✨ 枚举实现
<code>// 定义一个名为Singleton的枚举类型
public enum Singleton {
// 第一行定义枚举实例
// 这里定义了一个名为INSTANCE的枚举常量，它代表了Singleton2的唯一实例
INSTANCE;
// 私有成员变量，用于存储数据
private Object data;
// 公共方法，用于获取存储的数据
public Object getData() {
return data;
}
// 公共方法，用于设置存储的数据
public void setData(Object data) {
this.data = data;
}
// 静态方法，用于获取Singleton的唯一实例
// 这个方法是通过调用枚举常量INSTANCE来实现的
public static Singleton getInstance() {
return INSTANCE;
}
}
✨ 饿汉式单例
class Singleton {
// 1. 私有构造方法
// 这个构造方法被声明为私有，意味着不能在类的外部创建Singleton的实例。
// 这是实现单例模式的关键，防止外部代码通过new关键字创建多个实例。
private Singleton() {
}
// 2. 在本类中创建私有静态的全局对象
// 这里创建了一个静态的Singleton实例，它在类加载时就立即被创建。
// 这种方式是“饿汉式”单例模式的实现，因为实例在类加载时就已经被创建了。
// 由于是静态的，所以这个实例在整个程序运行期间都存在。
private static Singleton instance = new Singleton();
// 3. 提供一个全局访问点,供外部获取单例对象
// 这个方法是静态的，因此可以通过类名直接调用，不需要创建Singleton类的实例。
// 它返回了之前创建的静态实例。
public static Singleton getInstance() {
return instance;
}
}
✨ 懒汉式单例
public class LazySingleton {
// 使用volatile关键字确保instance变量在多线程中的可见性
private static volatile LazySingleton instance = null;
private LazySingleton() {
// 防止通过反射机制创建多个实例
if (instance != null) {
throw new IllegalStateException("Already initialized.");
}
}
public static LazySingleton getInstance() {
// 第一次检查，如果instance不为null，则直接返回
if (instance == null) {
// 同步块，确保只有一个线程可以创建实例
synchronized (LazySingleton.class) {
// 第二次检查，防止多个线程同时进入同步块
if (instance == null) {
instance = new LazySingleton();
}
}
}
return instance;
}
}
📙 简单工厂模式
🍻 <code>Client.java
// 产品接口
interface Product {
void operation();
}
// 具体产品A
class ConcreteProductA implements Product {
public void operation() {
System.out.println("ConcreteProductA operation.");
}
}
// 具体产品B
class ConcreteProductB implements Product {
public void operation() {
System.out.println("ConcreteProductB operation.");
}
}
// 简单工厂类
class SimpleFactory {
// 根据传入的类型创建产品实例
public static Product createProduct(String type) {
if ("A".equals(type)) {
return new ConcreteProductA();
} else if ("B".equals(type)) {
return new ConcreteProductB();
} else {
throw new IllegalArgumentException("Invalid product type.");
}
}
}
// 客户端类
public class Client {
public static void main(String[] args) {
// 创建简单工厂实例
SimpleFactory factory = new SimpleFactory();
// 创建产品A
Product productA = factory.createProduct("A");
productA.operation();
// 创建产品B
Product productB = factory.createProduct("B");
productB.operation();
}
}
运行结果
📙 工厂方法模式
🍻 <code>Client.java
//产品接口
interface Product
{
// 定义产品类必须实现的操作
void operation();
}
//具体产品A
class ConcreteProductA implements Product
{
// 实现产品接口定义的操作
public void operation()
{
System.out.println("ConcreteProductA operation.");
}
}
//具体产品B
class ConcreteProductB implements Product
{
// 实现产品接口定义的操作
public void operation()
{
System.out.println("ConcreteProductB operation.");
}
}
//工厂接口
interface Factory
{
// 定义创建产品的方法
Product createProduct();
}
//具体工厂A，用于创建ConcreteProductA实例
class ConcreteFactoryA implements Factory
{
// 实现工厂接口，创建ConcreteProductA实例
public Product createProduct()
{
return new ConcreteProductA();
}
}
//具体工厂B，用于创建ConcreteProductB实例
class ConcreteFactoryB implements Factory
{
// 实现工厂接口，创建ConcreteProductB实例
public Product createProduct()
{
return new ConcreteProductB();
}
}
//客户端代码
public class Client
{
public static void main(String[] args)
{
// 创建具体工厂A的实例
Factory factoryA = new ConcreteFactoryA();
// 使用工厂A创建产品A
Product productA = factoryA.createProduct();
productA.operation(); // 输出: ConcreteProductA operation.
// 创建具体工厂B的实例
Factory factoryB = new ConcreteFactoryB();
// 使用工厂B创建产品B
Product productB = factoryB.createProduct();
productB.operation(); // 输出: ConcreteProductB operation.
}
}
运行结果
📙 抽象工厂模式
🍻 <code>Client.java
// 抽象产品A接口
interface AbstractProductA {
void operationA();
}
// 抽象产品B接口
interface AbstractProductB {
void operationB();
}
// 具体产品A1类
class ConcreteProductA1 implements AbstractProductA {
public void operationA() {
System.out.println("ConcreteProductA1 operationA.");
}
}
// 具体产品A2类
class ConcreteProductA2 implements AbstractProductA {
public void operationA() {
System.out.println("ConcreteProductA2 operationA.");
}
}
// 具体产品B1类
class ConcreteProductB1 implements AbstractProductB {
public void operationB() {
System.out.println("ConcreteProductB1 operationB.");
}
}
// 具体产品B2类
class ConcreteProductB2 implements AbstractProductB {
public void operationB() {
System.out.println("ConcreteProductB2 operationB.");
}
}
// 抽象工厂接口
interface AbstractFactory {
AbstractProductA createProductA();
AbstractProductB createProductB();
}
// 具体工厂1类
class ConcreteFactory1 implements AbstractFactory {
public AbstractProductA createProductA() {
return new ConcreteProductA1();
}
public AbstractProductB createProductB() {
return new ConcreteProductB1();
}
}
// 具体工厂2类
class ConcreteFactory2 implements AbstractFactory {
public AbstractProductA createProductA() {
return new ConcreteProductA2();
}
public AbstractProductB createProductB() {
return new ConcreteProductB2();
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
// 创建具体工厂1的实例
AbstractFactory factory1 = new ConcreteFactory1();
// 使用工厂1创建产品A和产品B
AbstractProductA productA1 = factory1.createProductA();
AbstractProductB productB1 = factory1.createProductB();
productA1.operationA(); // 输出: ConcreteProductA1 operationA.
productB1.operationB(); // 输出: ConcreteProductB1 operationB.
// 创建具体工厂2的实例
AbstractFactory factory2 = new ConcreteFactory2();
// 使用工厂2创建产品A和产品B
AbstractProductA productA2 = factory2.createProductA();
AbstractProductB productB2 = factory2.createProductB();
productA2.operationA(); // 输出: ConcreteProductA2 operationA.
productB2.operationB(); // 输出: ConcreteProductB2 operationB.
}
}
运行结果
📙 适配器模式
🍻 <code>Client.java
// 目标接口，客户端期望的接口
interface Target {
// 客户端期望的方法
void request();
}
// 适配者类，拥有客户端不兼容的接口
class Adaptee {
// 适配者类的现有方法
public void specificRequest() {
System.out.println("Adaptee's specificRequest.");
}
}
// 适配器类，实现了目标接口，并通过委托适配者类的方法来实现目标接口的方法
class Adapter implements Target {
// 持有适配者类的引用
private Adaptee adaptee;
// 构造函数，传入适配者类的实例
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
// 实现目标接口的方法，通过调用适配者类的方法来实现
@Override
public void request() {
// 委托给适配者类的方法
adaptee.specificRequest();
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
// 创建适配者类的实例
Adaptee adaptee = new Adaptee();
// 创建适配器类的实例，传入适配者类的实例
Target adapter = new Adapter(adaptee);
// 调用适配器类的方法，实际上调用了适配者类的方法
adapter.request(); // 输出: Adaptee's specificRequest.
}
}
运行结果
七、GUI编程
📙 布局管理器
📙 流布局管理器
📙 事件响应的三大要素
📙 事件响应的步骤
📙 AWT概述
📙 Swing概述
📙 文本控件
八、集合
📙 泛型通配符
📙 Map 接口概述
九、异常处理
📙 异常体系
📙 编译型异常 和 运行时异常
📙 throws 和 throw
📙 finally
十、文件与IO流
📙 IO 流基本类
十一、多线程
📙 线程的生命周期
📙 线程状态转换图
十二、网络编程
📙 网络模型
📙 网络通信三要素
📙 UDP 和 TCP
📙 Socket 套接字
📙 UDP 传输
📙 TCP 传输
十三、类加载器与反射
📙 类加载流程
📙 类加载器
📙 反射
📙 反射获取构造方法
📙 反射获取成员变量
📙 反射获取成员方法
📙 动态代理
十四、数据库编程
📙 SQL 语句
📙 JDBC
📙 获取数据库连接
📙 PrepareStatement
声明
本文内容仅代表作者观点，或转载于其他网站，本站不以此文作为商业用途
如有涉及侵权，请联系本站进行删除
转载本站原创文章，请注明来源及作者。