javaSE试题(一)

来源：品趣旅游知识分享网

一、填空题（共20个题目，总计20分）

二、选择题（共25个题目，总计25分）

A.
final Person person = new Person(“欧欧”);
B. = “美美”;
C. person = new Person(“亚亚”);
D. 没有错误
13) 以下关于异常的代码的执行结果是（ C ）。（选择一项）
public class Test {
public static void main(String args[]) {
try {
System.out.println(“try”);
return;
} catch(Exception e){
System.out.println(“catch”);
}finally {
System.out.println(“finally”);
}
}
}

A. try
catch
finally
B. catch
finally
C. try
finally
D. try

以下关于String类的代码的执行结果是（ B ）。（选择一项）
public class Test2 {
public static void main(String args[]) {
String s1 = new String(“bjsxt”);
String s2 = new String(“bjsxt”);
if (s1 == s2)
System.out.println(“s1 == s2”);
if (s1.equals(s2))
System.out.println(“s1.equals(s2)”);
}
}

A. s1 == s2
B. s1.equals(s2)
C. s1 == s2
s1.equals(s2)
D. 以上都不对
以下关于StringBuffer类的代码的执行结果是（D ）。（选择一项）
public class TestStringBuffer {
public static void main(String args[]) {
StringBuffer a = new StringBuffer(“A”);
StringBuffer b = new StringBuffer(“B”);
mb_operate(a, b);
System.out.println(a + “.” + b);
}
static void mb_operate(StringBuffer x, StringBuffer y) {
x.append(y);
y = x;
}
}

A. A.B
B. A.A
C. AB.AB
D. AB.B
以下选项中能够正确创建一个数组的是（ AD）。（选择二项）

A. float []f[] = new float[6][6];
B. float f[][] = new float[][];
C. float [6][]f = new float[6][6];
D. float [][]f = new float[6][];
以下选项中关于int和Integer的说法错误的是（ BD）。（选择二项）

A. int是基本数据类型，Integer是int的包装类，是引用数据类型
B. int的默认值是0，Integer的默认值也是0
C. Integer可以封装了属性和方法提供更多的功能
D. Integer i=5;该语句在JDK1.5之后可以正确执行，使用了自动拆箱功能
以下选项中关于Java集合的说法错误的是（ AC ）。（选择二项）

A. List接口和Set接口是Collections接口有两个子接口
B. List接口中存放的元素具有有序，不唯一的特点
C. Set接口中存放的元素具有无序，不唯一的特点
D. Map接口存放的是映射信息，每个元素都是一个键值对
以下代码的执行结果是（ B ）。（选择一项）
Set s=new HashSet();
s.add(“abc”);
s.add(“abc”);
s.add(“abc”);
s.add(“abcd”);
System.out.println(s.size());

A. 1
B. 2
C. 3
D. 4
下面集合类中属于非线程安全，且结构采用了哈希表的是（C ）。（选择一项）

A. Vector
B. ArrayList
C. HashMap
D. Hashtable
以下选项中关于如下代码的说法正确的是（ A D ）。（选择二项）
public class TestBuffered {
public static void main(String[] args) throws IOException {
BufferedReader br =
new BufferedReader(new FileReader(“d:/bjsxt1.txt”));
BufferedWriter bw =
new BufferedWriter(new FileWriter(“d:/bjsxt2.txt”));
String str = br.readLine();
while(str !=null){
bw.write(str);
bw.newLine();
str = br.readLine();
}
br.close();
bw.close();
}
}

A. 该类使用字符流实现了文件复制，将d:/bjsxt1.txt复制为d:/bjsxt2.txt
B. FileReader和FileWriter是处理流，直接从文件读写数据//节点流
C. BufferedReader和BufferedWriter是节点流，提供缓冲区功能，提高读写效率
D. readLine()可以读取一行数据，返回值是字符串类型，简化了操作
InputStreamReader是转换流，可以将字节流转换成字符流，是字符流与字节流之间的桥梁。它的实现使用的设计模式是（ C ）。（选择一项）

A. 工厂模式
B. 装饰模式
C. 适配器模式
D. 代理模式
以下选项中可以填写到横线处，让代码正确编译和运行的是（ A ）。（选择一项）
public class Test implements Runnable {
public static void main(String[] args) {
___________________________________
t.start();
System.out.println(“main”);
}
public void run() {
System.out.println(“thread1!”);
}
}

A. Thread t = new Thread(new Test());
B. Test t = new Test();
C. Thread t = new Test();
D. Thread t = new Thread();
在多个线程访问同一个资源时，可以使用（ A ）关键字来实现线程同步，保证对资源安全访问。（选择一项）

A. synchronized
B. transient
C. static
D. yield
以下说法中关于UDP协议的说法正确的是（ AD ）。（选择二项）

A. 发送不管对方是否准备好，接收方收到也不确认
B. 面向连接
C. 占用系统资源多、效率低
D. 非常简单的协议，可以广播发送

三、判断题（共20个题目，总计10分）

四、简答题（共5个题目，总计25分）

1.方法重载和方法重写（覆盖）的区别。（4分

）

2.写出java.lang.Object类的六个常用方法的声明并说明其作用。（6分）

1)public boolean equals(java.lang.Object) 比较内容
2)public native int hashCode() 哈希码
3)public java.lang.String toString() 变成字符串
4)public final native java.lang.Class getClass() 获取类结构信息
5)protected void finalize() throws java.lang.Throwable 垃圾回收前执行的方法
6)protected native Object clone() throws java.lang.CloneNotSupportedException 克隆
7)public final void wait() throws java.lang.InterruptedException 多线程中等待功能
8)public final native void notify() 多线程中唤醒功能
9)public final native void notifyAll() 多线程中唤醒所有等待线程的功能

3.接口和抽象类的联系和区别。（5分）

相同点（1分）
抽象类和接口均包含抽象方法，类必须实现所有的抽象方法，否则是抽象类
抽象类和接口都不能实例化，他们位于继承树的顶端，被其他类继承和实现
两者的区别主要体现在两方面：语法方面和设计理念方面
语法方面的区别是比较低层次的，非本质的，主要表现在：（2分）
接口中只能定义全局静态常量，不能定义变量。抽象类中可以定义常量和变量。
接口中所有的方法都是全局抽象方法。抽象类中可以有0个、1个或多个，甚至全部都是抽象方法。
抽象类中可以有构造方法，但不能用来实例化，而在子类实例化时执行，完成属于抽象类的初始化操作。接口中不能定义构造方法。
一个类只能有一个直接父类（可以是抽象类），但可以充实实现多个接口。一个类使用extends来继承抽象类，使用implements来实现接口。
二者的主要区别在设计理念上，决定了某些情况下使用抽象类还是接口。（2分）
抽象类体现了一种继承关系，目的是复用代码，抽象类定义了各个子类的相同代码，可认为父类是一个实现了部分功能的“中间产品”，而子类是“最终产品”。父类和子类间须存在“is-a”关系，即父类和子类在概念本质上是相同的。
接口并不要求实现类和接口在概念本质上一致，仅仅是实现了接口定义的约定或能力而已。接口定义了“做什么”，实现类负责完成“怎么做”，体现了功能（规范）和实现分离的原则。接口和实现之间可以认为是一种“has-a的关系”

4.Vector和ArrayList、ArrayList和LinkedList的区别和联系。（6分

）
实现原理相同，功能相同，都是长度可变的数组结构，很多情况下可以互用（1分）
两者的主要区别如下
1.Vector是早期JDK接口，ArrayList是替代Vector的新接口（0.5分）
2.Vector线程安全，ArrayList重速度轻安全，线程非安全（1分）
3.长度需增长时，Vector默认增长一倍，ArrayList增长50%（0.5分）
ArrayList和LinkedList的区别和联系
ArrayList和LinkedList都是List的实现类，元素具有有序，不唯一特点。（1分）
ArrayList实现了长度可变的数组，在内存中分配连续空间。遍历元素和随机访问元素的效率比较高；（1分）

5.面向对象设计原则有哪些。（4分）

面向对象设计原则是面向对象设计的基石，面向对象设计质量的依据和保障，设计模式是面向对象设计原则的经典应用
1.单一职责原则SRP
2.开闭原则OCP
3.里氏替代原则LSP
4.依赖注入原则DIP
5.接口分离原则ISP
6.迪米特原则LOD
7.组合/聚合复用原则CARP
开闭原则具有理想主义的色彩，它是面向对象设计的终极目标。其他设计原则都可以看作是开闭原则的实现手段或方法。

五、编码题（共3个题目，总计20分）

1.写出饿汉式单例模式、懒汉式单例模式、多线程情况下懒汉式双重判断单例模式的示例代码。（7分）

// 饿汉式的单例模式，在类加载时创建单例实例，而不是等到第一次请求实例时创建
// 1、私有 的无参数构造方法Singleton()，避免外部创建实例
// 2、私有静态属性instance * 3、公有静态方法getInstance()
public class Singleton {
	private static Singleton instance = new Singleton();	
	private Singleton(){	}
	public static Singleton getInstance(){	
		return instance;
	}
}
/**
 //懒汉式的单例模式，类加载时不创建单例实例，在第一次请求实例的时候创建
*/
public class Singleton {	
	private static Singleton instance;	
	private Singleton(){	}	
	public static Singleton getInstance(){
		if(instance==null){ //只创建一次对象
			instance = new Singleton();
		}			
		return instance;
	}
}
//多线程情况下懒汉式的单例模式，避免创建多个对象
 // 需要使用synchronized关键字和进行两次null判断
public class Singleton {	
	private static Singleton instance;	
	private Singleton(){	}
	public static Singleton getInstance(){
		if(instance ==null){//避免每次加锁，只有第一次没有创建对象时才加锁
			synchronized(Singleton.class){//加锁，只允许一个线程进入
				if(instance==null){ //只创建一次对象
					instance = new Singleton();
				}			
			}
		}
		return instance;
	}
}

2.写出使用JDBC访问数据库表t_student中所有数据，并将结果集内容封装成List返回的代码。（6分）

1)数据库表已经创建，表名称及字段信息如下

public List<Student> findAll() {
	String driver="oracle.jdbc.driver.OracleDriver";
	String url="jdbc:oracle:thin:@localhost:1521:orcl";
	String uname="bjsxt";
	String password="bjsxt";
	Connection conn = null;
	Statement stmt = null;
	ResultSet rs = null;
	List<Student> stuList = new ArrayList<Student>();
	try {
		//加载驱动（1分）
		Class.forName(driver);
		//获取连接（1分）
		conn = DriverManager.getConnection(url, uname,password);
		//建立会话//(0.5分)
		stmt = conn.createStatement();
		//发送SQL命令得到结果(0.5分)
		rs = stmt.executeQuery("select * from t_student");
		//处理结果
		while(rs.next()){
			//取出结果集中各列数据（1分）
			int id = rs.getInt("id");
			String name = rs.getString("name");
			int age = rs.getInt("age");
					double score = rs.getDouble("score");
			Date enterDate = rs.getDate("enterDate");
			//封装成Student对象（0.5分）
			Student stu=new Student(id name age, score,enterDate);
			//加入集合（0.5分
			stuList.add(stu);				
		}
	} catch (SQLException e) {
		e.printStackTrace();
	} catch (ClassNotFoundException e) {
		e.printStackTrace();
	}finally{
		//关闭资源(依次关闭rs，stmt，conn)（1分）
		super.closeAll(rs,stmt,conn);
	}		
	return stuList;//（1分）		
}

3.使用TCP网络编程完成用户登录功能：客户端输入用户名和密码，向服务器发出登录请求；服务器接收数据并进行判断，如果用户名和密码均是bjsxt，则登录成功，否则登录失败，返回相应响应信息；客户端接收响应信息并输出登录结果。（7分）

1)用户User类已提供构造方法 public User(String username,String password)。
2)客户端采用ObjectOutputStream发送封装了用户名和密码的User对象。
3)服务器端和客户端的类名和方法声明如下所示。

public class LoginServer {
	public static void main(String[] args) throws Exception {
		// 1.创建一个ServerSocket，指定等待端口（1分）
		ServerSocket serverSocket = new ServerSocket(8888);
		// 2.使用ServerSocket接收用户请求（处于监听状态）（1分）
		Socket socket =  serverSocket.accept();
		// 3.创建输入流和输出流（0.5分）
		ObjectInputStream ois = 
new ObjectInputStream(socket.getInputStream());
		DataOutputStream dos = 
new DataOutputStream(socket.getOutputStream());
		// 4.接收用户数据并输出（0.5分）
		User user = (User) ois.readObject();
		System.out.println("我是服务器，收到的信息是：" + user);
		// 5.发送反馈信息（0.5分）
		boolean flag = false;
		if ("bjsxt".equals(user.getUsername())
				&& "bjsxt".equals(user.getPassword())) {
			flag = true;
		}
		dos.writeBoolean(flag);
		// 6.关闭流和socket（0.5分）
		ois.close();		dos.close();		socket.close();
	}
}
public class LoginClient {
	public static void main(String[] args) throws Exception {
		// 1.创建Socket，用来发送请求（0.5分）
		Socket socket = 
new Socket(InetAddress.getByName("127.0.0.1"), 8888);
		// 2.创建输入流和输出流（0.5分）
		DataInputStream dis =
				new DataInputStream(socket.getInputStream());
		ObjectOutputStream oos =  
			new ObjectOutputStream(socket.getOutputStream());
		// 3.发送数据（1分）
		Scanner input = new Scanner(System.in);
		System.out.println("请输入用户名");
		String username = input.nextLine();
		System.out.println("请输入密码");
		String password = input.nextLine();
		User user = new User(username, password);
		oos.writeObject(user);
		// 4.接收反馈信息并输出（0.5分）
		boolean flag = dis.readBoolean();
		if (flag) {
			System.out.println("登录成功");
		} else {
			System.out.println("登录失败");
		}
		// 5.关闭流和socket（0.5分）
		dis.close();		oos.close();		socket.close();
	}
}

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文