Java期末考试大纲

---

一、题型

1. 选择
2. 判断
3. 编程（30分）
4. 问答/理解题（30-40分）
5. 程序填空题

---

二、重点

第1章 初次接触Java

1. JDK和JRE的关系。
   弄懂 JRE、JDK、JVM 之间的区别与联系

---

第2章 Java语言基础

1. $$数据类型\{\begin{array}{l}\text{Primitive type / 基本类型 / 简单类型（8种）}\{\begin{array}{l}\text{整数类型：byte(8位), short(16位), int(32位), long(64位)}\\ \text{浮点类型：float(32位), double(64位)}\\ \text{字符类型：char(16位)}\\ \text{布尔类型：boolean}\end{array}\\ \text{Reference type / 复合类型 / 引用类型}\{\begin{array}{l}\text{class(类)}\\ \text{interface(接口)}\\ \text{数组}\end{array}\end{array}$$
2. 类型转换
3. 逻辑表达式（布尔值，不能是int等）
4. switch(expression)中的expression新版本类型都可以
5. break lab; 跳出多重循环

---

第4章 面向对象（上）

1. 对象互发消息：
   （1）引用必须引用了特定的对象，否则会在运行时抛出NullPointerException异常
   （2）对象必须定义了相应的属性或方法，否则编译不会通过
   （3）被访问的属性或方法具有可访问的权限
2. 区别对象和对象引用，区别Java和C++
   Java作业三
3. 创建数组（数组是对象）
   Java创建数组
4. 创建对象初始化顺序：
   （1）系统会对数据成员进行默认初始化
   （2）执行数据成员定义处的初始化语句
   （3）调用构造方法为数据成员指定初值

class IntClass {
	int value; // 自动初始化，默认值为0
	// int value = 5; // 在定义时指定初始化语句

	public IntClass() {}

	// 定义构造方法将属性value初始化
	public IntClass(int val) {
		value = val;
	}
}

public class IntClassConstructor {
	public static IntClass getInstance() {
		// 调用构造方法，从而省略了s，value代码
		IntClass s = new IntClass(8);
		// s.value = 8;
		return s;
	}

	public static void main(String args[]) {
		IntClass a = new IntClass();
		System.out.println(a.value);
		a = getInstance();
		System.out.println(a.value);
	}
}

输出：
0
8

5. 垃圾回收机制
6. 数据成员又叫字段
7. final修饰常量
8. 包package组织情况

---

第5章 面向对象（中）

1. 对象三大特征：封装、继承、多态。
   Java面向对象的三大特征
   封装：（1）数据、操作（2）信息隐藏、安全性问题。
2. 最小编程单元：类。
3. 类的组合：一个类中放了本类/另一类的对象引用作为数据成员
4. 高内聚、低耦合
5. 子类继承父类的真正含义并不是将父类的属性和方法复制到子类当中，而是在生成子类对象的时候，将父类和子类的非静态的属性复制到子类对象当中（方法不复制）
6. Object类似所有类的共同祖先，即使定义类时美有写extends Object
7. 被final修饰的类称为最终类，它不能有子类
8. 被final修饰的方法不能在子类中覆盖
9. 子类方法覆盖父类方法，子类的访问修饰符权限应等于或大于父类
10. 同名的static方法和非static方法不能互相覆盖
11. 抽象类中如果存在抽象方法，则具体子类必须对抽象方法进行覆盖

---

第6章 面向对象（下）

1. this三种用法：
   （1）this.域变量、this.成员方法
   （2）this(参数)——引用重载的构造方法
   （3）this指代当前对象
2. super两种用法：
   （1）super.域变量、super.成员方法(参数)
   （2）super(参数)——构造方法的继承调用
   若子类的域变量名或成员方法名与父类的域变量名或成员方法名相同时，要调用父类的同名方法或使用父类的同名域变量，则可用关键字super来指代。
3. 初始化顺序：
   （1）在调用任何一个构造方法之前，先进行类字段初始化
   （2）在调用子类构造方法之前，先调用父类构造方法
4. 抽象类、抽象方法（abstract）【等价于C++中纯虚函数】
5. 接口 interface 是功能方法说明的集合，其中定义的数据成员全是 final static（静态常量）（即使没有任何修饰，其效果完全等效
6. 接口没有构造方法，所有成员方法都是抽象方法。注意，方法前不能修饰为final
7. 抽象类与接口比较：
   （1）共同点：二者都有抽象方法，都不能实例化。都有自己的声明，并能引用具体子类或实现类对象。
   （2）不同点

	抽象类	接口
属性	可以有域变量	不能有域变量，只能是静态常量
成员方法	可以有具体方法，而且具体方法可以调用抽象方法	如果有方法，则全部是抽象方法
实现策略	必须有子类继承	必须有实现类实现
拓展性	弱	强

8. 抽象类声明可以引用所有具体子类对象
9. 父类声明可引用所有具体子类对象
10. 子类声明不能引用平行级别的其他类对象，也不能引用父类对象
11. 父类声明所引用的子类对象可以经过显式的转化（造型cast）赋值给子类声明，但子类声明所引用的子类对象赋值给父类声明则不需要显式的转化
12. 对象用.equals()比较的是引用，用==比较的是引用
13. String用equals()比较的是值，用==比较的是引用地址
14. 数值用==比较的是值
15. 使用instanceof比较引用类型：
    运算符的格式：a instanceof A，其中a为对象的引用，A为类。
    如果a为A的实例或A子类的实例，则返回true；
    如果a为A父类的实例，则返回false；
    如果a对象的类和A没有任何关系，则编译不会通过。
16. 内部类、匿名内部类
17. 外部类无法直接访问内部类中的成员

---

第7章 异常

1. 异常声明
2. 异常捕获
3. 自定义异常 throw new 异常类
4. $$异常处理\{\begin{array}{l}声明抛出处理\{\begin{array}{l}隐式声明抛出\\ 显式声明抛出\end{array}\\ \\ 程序捕获处理\{\begin{array}{l}非嵌套捕获\\ 嵌套捕获\end{array}\end{array}$$

---

第8章 Java常用类库与工具

1. String的equals是值比较，严格区别大小写，可用equalsIgnoreCase忽略大小写比较
2. String的特点是一旦赋值，便不能改其指向的字符对象。如果更改，则会指向一个新的字符对象
3. 编译器自动优化：

String s = "Hello";
String t = "Hello"; // s和t指向同一个字符对象

String s = "Hello";
String t = new String("Hello"); // s和t指向内存中不同的字符对象

5. StringBuffer是一个具有对象引用传递特点的字符串对象（拼接字符串等操作后不会创建一个新的String对象，而是对自身进行改变）

7. String内部实现基于常量字符数组，内容不可变
8. StringBuffer（线程安全）、StringBuilder（非线程安全）基于普通字符数组，数组大小可扩容，内容可变
9. 性能：StringBuilder > StringBuffer > String

---

第9章 线程

1. 两种创建线程的方式
   Java产生线程
2. 多线程访问共享资源 --> 安全性问题 --> 同步机制（synchronized原子性）–> 上锁、死锁

---

第10章 集合类

1. 两大集合框架：Collection、Map
2. $$Collection接口\{\begin{array}{l}List接口：规定集合类元素具有可控制的顺序\\ Set接口：规定集合类元素不能重复\\ Queue接口：支持队列插入、取出等操作\end{array}$$
3. $$遍历接口\{\begin{array}{l}枚举接口Enumeration：hasMoreElements()、nextElement()\\ 迭代器接口Iterator：hasNext()、next()、remove()\\ 迭代器接口ListIterator：hasNext()、next()、hasPrevious()、previous()、remove()、nextIndex()、previousIndex()、add()\end{array}$$
4. $$Map接口\{\begin{array}{l}keySet()：获取映射中关键字集合的一个Set引用\\ values()：返回映射中值集合的一个Collection引用\\ entrySet()：返回一个Set\end{array}$$
5. Map的实现类：Hashtable、HashMap、TreeMap
6. Map遍历：

Set keys = map.keySet();
if(keys!=null){
	Iterator iterator = keys.iterator();
	while(iterator.hasNext()){
		Object key = iterator.next();
		Object value = map.get(key);
		...;
	}
}

Set entries = map.entrySet();
if(entries!=null){
	Iterator iterator = entries.iterator();
	while(iterator.hasNext()){
		Map.Entry entry = iterator.next();
		Object key = entry.getKey();
		Object value = entry.getValue();
		...;
	}
}

7. 排序接口Comparator
   Java书p167习题8

---

第14章 I/O 输入/输出

1. 标准输入：对象是键盘，Java对应类是System.in
   标准输出：对象是屏幕，Java对应类是System.out
   标准错误输出：对象也是屏幕，Java对应类是System.err
2. $$字节流\{\begin{array}{l}InputStream\{\begin{array}{l}\text{int read(byte b[ ])：读多个字节到数组中，返回读到的字节数目，如果读完则返回-1}\\ \text{int read(byte b[ ], int off, int len)：从输入流中读取长度为len的数据，写入数组b中从索引off开始的位置，并返回读取的字节数，如果读完则返回-1}\end{array}\\ \\ OutputStream\{\begin{array}{l}\text{write(byte b[ ])：将字节数组中的数据输出到流中}\\ \text{write(byte b[ ], int off, int len)：将数组b从off指定的位置开始，长度为len的数据输出到流中}\\ \text{flush()：刷空输出流，并将缓冲区中的数据强制送出}\end{array}\end{array}$$
3. ByteArrayInputStream构造方法：public ByteArrayInputStream(byte[] buf)——将字节数组作为字节流的数据源

public class ByteArrayStream {
	public static void main(String[] args) {
		byte[] b = "hello".getBytes(); // String->byte[]
		ByteArrayInputStream bais = new ByteArrayInputStream(b);
		int n = 0;
		while((n=bais.read())!=-1) {
			System.out.print((char)n); // hello
		}
	}
}

4. ByteArrayOutputStream构造方法：public ByteArrayOutputStream()——构造一个字节数组输出流，用于将多少字节写入到流中，最后可以整体转换为一个字节数组

public class ByteArrayStream {
	public static void main(String[] args) {
		byte[] b = "hello".getBytes(); // String->byte[]
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		baos.write(b,0,b.length); // 把b中length长度的字节数组写到输出流上
		System.out.println(new String(baos.toByteArray()));
	}
}

5. FileInputStream构造方法：FileInputStream(String name)——以文件路径名字构造一个文件输入流，打开一个与实际文件的连接，用于从该流中读取文件字节流
6. FileOutputStream构造方法：FileOutputStream(String name)——以文件路径名字构造一个文件输出流，打开一个与实际文件的连接，用于文件的写字节流操作
7. PipedInputStream和PipedOutputStream：通常用于将一个程序的输出连接到另一个程序的输入。
   输出流作为管道的发送端，输入流作为管道的接收端。
   使用前需要调用connect方法将输出流和输入流连接起来。
   通常一个线程执行管道输出流的写操作，另一个线程执行管道输入流的读操作。

public class PipedStream{
	public static void main(String[] args) throws IOEception {
		PipedInputStream in = new PipedInputStream();
		PipedOutputStream out = new PipedOutputStream();
		in.connect(out);
		new Thread(new Input(in)).start();
		new Thread(new Output(out)).start();
	}
}

class Input implements Runnable {
	private PipedInputStream in;
	public Input(PipedInputStream in) {
		this.in = in;
	}
	
	public void run() {
		byte[] buf = new byte[1024];
		int len;
		try {
			len = in.read(buf);
			String s = new String(buf, 0, len);
			System.out.println("in "+s);
			in.close();
		} catch(IOException e) {
			e.printStackTrace();
		}
	}
}

class Output implements Runnable {
	private PipedOutputStream out;
	public Output(PipedOutputStream out) {
		this.out = out;
	}

	public void run() {
		try {
			out.write("hello".getBytes());
		} catch(IOException e) {
			e.printStackTrace();
		}
	}
}

8. 字节流 --> 字符流：InputStreamReader(InputStream in)

InputStreamReader ins = new InputStreamReader(System.in);

9. 字符流 --> 字节流：OutputStreamWriter(OutputStream out)或PrintWriter(OutputStream out)

OutputStreamWriter outs = new OutputStreamWriter(new FileOutputStream("test.txt"));

PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out), true);
out.println("Hello"); // 输出字符串“Hello”

10. 过滤流BufferedReader的使用：用于缓存字符流，可以一行一行的读（只要是Reader的之类都可以作为BufferedReader的参数）

BufferedReader keyin = new BufferedReader(new InputStreamReader(System.in));

String c1;
int i = 0;
int[] e = new int[10];
while(i<10) {
	try {
		c1 = keyin.readline();
		e[i] = Integer.parseInt(c1);
		i++;
	} catch(NumberFormatException ee) {
		System.out.println("请输入正确的数字！");
	}
}

11. 过滤流DataInputStream和DataOutputStream，可从字节流中写入、读取Java基本数据类型，不依赖于机器的具体数据类型，方便存储和恢复数据

DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("test.txt")));
dos.writeInt(3); // 写入整型
dos.writeDouble(3.14); // 写入浮点型
dos.writeUTF("hello"); // 写入字符串
dos.close();

DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream("test.txt")));
System.out.println(dis.readInt()); // 读取整型，输出3
System.out.println(dis.readDouble()); // 读取浮点型，输出3.14
System.out.println(dis.readUTF()); // 读取字符串，输出hello
dis.close();

12. 对象的串行化（Serialization）又称序列化，是将内存中的动态对象表达成为可以传输的串形式，而与之相反的过程则成为反串行化或反序列化。
13. 对象串行化实现了Serialization接口的对象转换成一个字节序列，并能够在以后将这个字节序列完全恢复为原来的对象。
14. 对象串行化的目的是为了便于网络传输和介质存储。
15. 对象串行化和反串行化的实质是要解决对象在内存和物理存储之间如何进行映射，或者对象如何从一台计算机的内存映射到另一台计算机的内存上的问题。

---

第15章 Java网络通信

1. OSI七层协议

层	功能
物理层	比特流传输
数据链路层	两个相邻结点间的点到点的帧传输
网络层	为分组交换网上的不同主机提供通信服务，包括路由、地址解析等
传输层	为两主机间的进程通信提供可靠服务
会话层	提供网络中两主机之间会话的建立、维持和终止等
表示层	提供网络传输的标准格式
应用层	直接为用户的应用进程提供服务

2. TCP/IP四层协议：应用层、运输层、网络层、网络接口层
3. 网络应用定位：
   （1）IP地址：标识计算机等网络设备的网络地址。由四个8位二进制数组成。
   例如：192.127.32.123
   （2）域名：网络地址的助记符。
   如：www.baidu.com
   （3）服务类型：应用层提供的网络服务。
   例如：http
   （4）端口号：网络服务的标识号。
   例如：80
4. 统一资源定位器URL（Uniform Resource Locator）：protocol://resourceName
   （1）协议名（protocol）：指明获取资源所使用的传输协议，如http
   （2）资源名（resourceName）：指明资源的完整地址，包括域名、端口号、文件名或文件内部的一个引用
   例如：http://news.hzau.edu.cn/2015/1114/43886.shtml
5. 可以通过URL的方法openStream()读取指定的WWW资源
6. 可以通过URL的方法openConnection()连接WWW网络资源
7. 127.0.0.1是TCP/IP协议中默认的本机地址
8. 网络通信两类传输协议：TCP和UDP
9. TCP是一种面向连接的保证可靠传输的协议，TCP三次握手确立连接
10. Socket通讯的一般过程：
    （1）创建Socket
    （2）打开连接到Socket的输入/输出流
    （3）按照一定的协议对Socket进行读/写操作：先启动服务端，再启动客户端，客户端向服务端发送字符串，之后处于阻塞等待状态；服务器收到客户端发送的字符串后显示，并处于向客户端发送字符的状态。当任何一端输入字符串“bye”后，退出程序，通讯中断
    （4）关闭Socket（先关闭流）
11. 获取连接到套接字的输入流/输出流

// 由Socket对象得到输入流，并构造相应的BufferedReader对象
BufferedReader is = new BufferedReader(new InputStreamReader(socket.getInputStream()));

// 由Socket对象得到输出流，并构造PrintWriter对象
PrintWriter os = new PrintWriter(socket.getOutputStream());

// 由系统标准输入设备构造BufferedReader对象
BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));

12. 数据报是一种完备的、独立的数据实体，该实体携带有能从源计算机经网络正确路由到目的计算机的信息。不同数据报之间的通信信息相互独立，一个数据报之前和之后发出的数据报没有逻辑联系
13. DatagramSocket：用于在程序之间建立传送数据报的通信连接
    DatagramPacket：用来表示一个数据报

---

第16章 JDBC

1. JDBC（Java DataBase Connectivity）是Java面向对象应用程序访问数据库的接口API规范，它的出现使Java应用程序对各种关系数据库的访问方法得到统一
2. JDBC的驱动类型：
   （1）100%纯JDBC驱动
   （2）JDBC调用客户端
   （3）JDBC/ODBC桥
3. 使用JDBC操作数据库通常包含以下步骤：
   （1）载入JDBC driver
   （2）得到数据库的Connection对象，在客户端与数据库之间建立连接
   （3）根据连接对象得到Statement进行查询或数据更新
   （4）如果执行查询则返回的记录集ResultSet进行遍历操作；如果执行更新则根据成功与否的返回结构进行数据库事务操作
   （5）操作结束后，依次对ResultSet、Statement、Connection执行关闭操作
4. JDBC异常处理统一由SQLException来捕获处理
5. Java反射机制（运行时获取自身信息）
   假设Student是一个类，stu是Student类的实例对象的一个引用
   （1）Class c1 = Student.class();
   （2）Class c2 = stu.getClass();
   （3）Class c3 = Class.forName("hzau.info.Student");
   （4）Student stu = c1.newInstance(); // 运行时创建实例对象
   （5）Method m = c1.getDeclaredMethod("方法名",可变参数列表(参数类型.class)); // 运行时获取类方法
   （6）m.invoke(对象, 参数列表); // 运行时调用对象方法