1.安装JDK后，为了告诉计算机javac.exe和java.exe等执行文件的位置，需要配置的环境变量是___path__________。
2.Java提供了三种注释类型，分别是单行注释，多行注释和______文档注释_______。
3.char 类型用来表示在Unicode编码表中的字符，长度是____2_个字节。
4.&&是短路与运算符，如果左侧表达式的计算结果是false，右侧表达式将不再进行计算。
5.continue____语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
6.基本数据类型的类型转换中，要将double类型的常量3.14159赋给为整数类型变量n的语句是_______int n=(int)3.14159。
7.执行Person p = new Person();语句后，将在____堆内存_______中给Person对象分配空间，并在栈内存中给引用变量p分配空间，存放Person对象的引用。
8.使用static修饰的变量称为静态变量，静态变量可以有两种访问方式，分别是类名.静态变量名和________对象名.静态变量名_______________。
9.在一个类文件中的关键字package，import，class出现的可能顺序是_______package,import,class_______________________。
10.异常是由Java应用程序抛出和处理的非严重错误，比如所需文件没有找到、零作除数，数组下标越界等，可分为两类：Checked异常和____运行异常______________。
11.数组在内存中分配连续的空间，数组的长度固定，一经分配无法改变，可以使用_______length_____属性获取数组的长度。
12.DateFormat类可以实现字符串和日期类型之间的格式转换，其中将日期类型转换为指定的字符串格式的方法名是___format()_。
13.JDK1.5后提供了______enum______关键字，用以定义枚举类。枚举类是一种特殊的类，可以有自己的属性、方法和构造方法。
14.如果希望将自定义类Student的多个对象放入集合TreeSet，实现所有元素按照某个属性的自然顺序排列，则需要Student类实现_______Comparable___________接口。
15.迭代器Iterator为集合而生，专门实现集合遍历，该接口有三个方法，分别是hasNext() 、___next()、remove()。
16.Java IO体系中，______DataInputStream_____________是字节输入流，提供了可以存取所有Java基础类型数据（如：int，double 等）和String的方法,但没有提供存取对象的方法。
17._____对象序列化_______是指将Java对象转换成字节序列，从而可以保存到磁盘上，也可以在网络上传输，使得不同的计算机可以共享对象。
18.Java反射技术中，每个Method对象对应一个方法，获得Method对象后，可以调用其_______invoke___来调用对应方法。
19.处于运行状态的线程在某些情况下，如执行了sleep（睡眠）方法，或等待I/O设备等资源，将让出CPU并暂时停止自己的运行，进入_____阻塞____状态。
统一资源定位符URL是指向互联网“资源”的指针,由4部分组成：协议、存放资

1.一个Java源文件中可以定义多个类，但是至多只能有一个public类。( 对 )
2.Java的字节码文件的扩展名是class，是一种平台独立的非二进制文件。( 错 )
3.^ 是异或位运算符，运算规则是如果两个操作数相同，结果是0，否则结果是1。( 对 )
4.赋值运算符优先级别低于条件运算符，条件运算符优先级别低于算术运算符。对 )
5.switch选择语句是多分支选择语句，只能处理等值条件判断的情况，表达式可以是int类型、char类型，但不能是double,float类型。( 对 )
6.在多重循环中，外层循环变量变化一遍，内层循环变量要变化一次 。(错 )
7.程序调用自身的编程技巧称为递归。递归的特点是编程简单并且节省内存。(错 )
8.类可以看成一类对象的模板，对象可以看成该类的一个具体实例。( 对 )
9.使用public修饰的成员属性和方法可以被当前项目中所有包的所有类访问。( 对 )
10.将子类对象赋给父类引用变量，称为向下转型，将无法访问子类特有的方法。( 错 )
11.继承是多态的基础，没有继承就没有多态。( 对 )
12.内部类作为外部类成员，权限修饰符和其他成员一样，可声明为private、默认、protected或public。( 对 )
13.对于物理连接，比如数据库连接、输入流输出流、Socket连接等，垃圾回收机制无能为力，必须手动关闭才可以。( 对 )
14.数组和集合中的元素可以是任何数据类型，包括基本类型和引用类型。( 错 )
15.增强的for循环可以遍历数组和集合，语法简单 不需要知道数组的长度，不能实现与下标相关的操作。(对 )
16.LinkedHashMap是一种有序的HashMap，查询速度快，便于进行添加删除操作。( 对 )
17.Collection类是专门用来操作集合的工具类，提供一系列静态方法实现对各种集合的操作。( 错)
18.一个File对象可以代表一个文件或目录，它可以获取文件和目录属性，也可以访问文件内容。(错 )
19.进程是线程Thread内部的一个执行单元，它是程序中一个单一顺序控制流程。(错 )
20.Socket是传输层供给应用层的编程接口，是应用层与传输层之间的桥梁 。(对 )

）

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() 多线程中唤醒所有等待线程的功能

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

）
实现原理相同，功能相同，都是长度可变的数组结构，很多情况下可以互用（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分）

LinkedList采用链表存储方式。插入、删除元素时效率比较高

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

// 饿汉式的单例模式，在类加载时创建单例实例，而不是等到第一次请求实例时创建
// 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;
	}
}

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

2)实体类Student已经提供，和数据库表字段对应，有id,name,age,score,enterDate五个属性及相应的getter和setter方法，提供了各种参数的构造方法。
3)使用JDBC访问数据库四个连接参数分别为
a)driver:oracle.jdbc.driver.OracleDriver
b)url:jdbc:oracle:thin:@localhost:1521:orcl
c)username:bjsxt
d)password:bjsxt
4)方法的声明为public List findAll(){ }，在方法体中书写JDBC代码完成功能即可。

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分）		
}

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();
	}
}