Java程序设计教程及实验指导（个人笔记）

第一章Java语言概述

一、实验操作
1、调试的例题
①　打印HelloWorld程序
②　下载并安装JDK，设置环境变量
③　下载Eclipse
2、完成的习题编程
①　HelloWorld程序；
②　使用Scanner类的输入方法来输入数据，将输入的数据显示在屏幕上；

二、遇到的问题及解决方法
1、Eclipse敲代码时无代码提示
解决：工具栏=》Window→Preference→Java→Editor→Content Assist→Auto Active→Auto active triggers for Java:点加上所有的小写字母和大写字母；

2、Eclipse开发工具内字体过小
解决：工具栏=》Window→Preference→General→Appearance→Colors and Fonts→Java Editor Text Font→Edit…→选择自己想要的字体和大小

三、小结
学习了Java最基础的打印与输出，掌握了怎么安装JDK以及环境配置，以及最基础的PrintIn、Print方法输出、Scanner类输入，暂无问题。

第二章Java编程基础

一、实验操作
1.调试的例题
①　定义数据类型并进行简单四则运算
②　了解Java命名规范，程序注释（3种）
③　了解运算符和表达式，三元运算符（a>b?0:1）
④　了解自动类型转换和强制类型转换
⑤　break和continue语句；一维数组的定义与使用；
⑥　了解二维数组（杨辉三角）
⑦　Arrays类的用法：
1)Boolean Arrays.equals(array1,array2):比较两个数组是否相等；
2)Void Arrays.sort(array)：对数组array进行升序排列；
3)String Arrays.toString(array)：将数组array转换成一个字符串；
4)Void Arrays.fill(array,val):将数组array中的所有元素赋值为val；
2.完成的习题编程
课本P323实验题：过程如下：

// 使用循环语句输出如下图案（-）代表空格
	// ---*
	// --***
	// -*****
	// *******
	private static void getAsterisk() {
		System.out.println("图案为：");
		int space = 3;// 定义空格循环数
		for (int i = 0; i < 4; i++) { // 外层共有4行
			for (int j2 = space; j2 > 0; j2--) {// 每行打印的空格数量
				System.out.print(" ");
			}
			space--; // 每一层的空格循环数减一
			// j<(2*i)+1 使每层循环总数为奇数：1 3 5 7
			for (int j = 0; j < (2 * i) + 1; j++) {// 每行打印星号的数量
				System.out.print("*");
			}
			System.out.println();// 空格和星号打印完后换行
		}
		System.out.println();
	}

(2)

/**
	 * 计算分数序列前20项目之和： 2/1+3/2+5/3+.... ;scoreSum 分数求和；知道前一个值，可以推出后一个值（迭代关系式）
	 */
	private static void scoreSum() {
		// 关系：前一个的分子和分母的和等于后一项分子；前一项的分子是后一项的分母（交换）
		// 分子：每一项都等于前一个分子+分母
		// 分母：每一项都等于前一项的分子（交换）
		double z = 2.0;// 第一个分子
		double m = 1.0;// 第一个分母
		double sum = 0.0;
		for (int i = 0; i < 20; i++) {
			sum += z / m;// 分式的值;先写出第一个的，后面将分子分母的变化描述出来
			double tempM = m;// 预先储存分母
			m = z;// 分母的变化归规律
			z += tempM;// 分子的变化规律
//			System.out.println(z + "分子" + m + "分母");
		}
		System.out.println("前20项之和为：" + sum);
	}

(3)

/**
	 * 某比赛10个评委打分，编写程序输入评委打分，求选手的平均分，要求去掉最高分和最低分在进行平均分。尽量减少时间和空间复杂度
	 */
	private static double getAverage() {
		@SuppressWarnings("resource") // 用于抑制编译器产生警告信息
		Scanner scanner = new Scanner(System.in);
		double[] numberList = new double[10];
		double temp = 0.0, sumAvg = 0.0;
		for (int i = 1; i <= 10; i++) {
			System.out.println("请第" + i + "位评委打分：");
			numberList[i - 1] = scanner.nextDouble();
		}
		System.out.println(Arrays.toString(numberList));
		for (int i = 0; i < numberList.length - 1; i++) {
			int numberTemp = i;
			for (int j = i + 1; j < numberList.length; j++) {
				if (numberList[numberTemp] > numberList[j]) {
					temp = numberList[numberTemp];
					numberList[numberTemp] = numberList[j];
					numberList[j] = temp;
				}
			}
		}
		System.out.println("目前升序为：" + Arrays.toString(numberList));
		numberList[0] = 0.0;
		numberList[numberList.length - 1] = 0.0;
		for (int i = 0; i < numberList.length; i++) {
			sumAvg += numberList[i] / (numberList.length - 2);
		}
//		System.out.println(Arrays.toString(numberList) + "最大" + Max + "最小" + Min + "平均分为：" + sumAvg);
		return sumAvg;
	}

（4）

	/**
	 * 随机0~100的10个整数，至于一维数组中，使用选择排序法对其递增排序 选择排序：每一个值都和其他的值相比较，互换其位置，产生新的升序或者降序排列的数组
	 */

	private static void selectSort() {
		int integerList[] = new int[10];
		int temp;
		for (int i = 0; i < integerList.length; i++) {
			integerList[i] = new Random().nextInt(100);
		}
		System.out.println("随机产生的数组为：" + Arrays.toString(integerList));
		for (int i = 0; i < integerList.length - 1; i++) {// 除了最后一个不用比较
			int Max = i;
			for (int j = i + 1; j < integerList.length; j++) {
				if (integerList[Max] > integerList[j]) {// 判断当前下标值，是否大于数组里每一个，大于则互换位置，将小的置换去前面
					temp = integerList[Max];// 临时存储
					integerList[Max] = integerList[j];// 置换位置
					integerList[j] = temp;
				}
			}
		}
		System.out.println("随机产生的数组递增排列为：" + Arrays.toString(integerList));
	}

（5）

	/**
	 * 九九乘法表：减少空间和时间复杂度
	 */
	private static void getMultiplicationTablesJinjie() {
		for (int i = 1; i <= 9; i++) {// 控制总层数
			for (int j = 1; j <= i; j++) {// 计算二者相乘
//				System.out.print(i + "*" + j + "=" + (i * j) + "\t");
				System.out.print(j + "*" + i + "=" + (i * j) + "\t");
			}
			System.out.println();
		}
	}

二、遇到的问题及解决方法
1、Eclipse敲代码运行无影响但是总有黄色提示
解决：@SuppressWarnings(“resource”) //(“all”) 用于抑制编译器产生警告信息

2、某一段时间内思路混乱，逻辑错误
解决：跳过该题或者停止思考，等静一段时间再去从头理一遍逻辑。

三、小结
运用迭代算法不流畅、不熟悉，需要多理解题目，将逻辑关系式列出的同时，要习惯反着理解。迭代算法：能从旧的值推导出新的值或者关系式，将关系式用变量表达出来，在循环中描述值得变化。

第三章Java类与对象

一、实验操作
1.调试的例题
①　面向对象的三要素
1)类
2)对象
3)继承
②　面向对象的特征
1)封装性：将类的属性和行为结合成一个独立的单位，尽可能隐藏类内部的细节；
2)继承性：子类继承父类的属性和行为（父子关系），父类不可调用子类的属性；
3)多态性：分为编译时的多态和运行时的多态；
a.编译时的多态是指类实现一个相同的方法，可以通过方法重载来完成同一个方法实现不同的业务逻辑；
b.运行时的多态是通过方法覆盖实现的，子类的方法覆盖父类的方法；
③　类的定义
1)Public:公有的（公共的，随意调用）
2)Protected：受保护的（只能项目里面调用）
3)Private：私有的（只能自己的类里面调用，多用于属性的构造）
④　Java的内存分为：堆和栈；
⑤　方法重载：相同的方法实现不同的功能；
1)方法名相同
2)形参的个数和类型可以不同
⑥　构造方法：特殊的成员方法，对对象进行初始化
1)特点
a.构造方法是在生成对象时被自动调用，程序员不能在程序中直接调用；
b.构造方法具有和类相同的名称；
c.构造方法不能声明返回值的类型；
d.构造方法中除了初始化对象属性语句外，不应该有其他语句；
2)快捷创建方式：
a.在要插入的地方右键选择Source→Generate Constructor→uing Fields命令选择所要构造的属性。
⑦　静态成员：static关键字修饰的成员；
⑧　使用静态属性无需创建类对象，虽然可以通过对象名称.属性名，但是建议通过类名.静态属性来访问；
⑨　用final声明静态的变量；
1)Public static final double E = 2.7515135351；
⑩　静态方法的特点
1)在创建对象之前就可以使用“类名.静态方法”来调用类方法；
2)静态方法中没有this引用，所以不能用this来调用对象属性和调用方法；
3)静态方法可以访问静态属性和其他方法；
4)静态方法使用“类名.静态方法”方式在类外来调用；
⑪　主类中的man方法是一个静态方法，有一个String类型的数组；
⑫　Java中Math类的方法：
1.abs(x)返回x这个数的绝对值：
Math.abs(11.3); //11.3
Math.abs(-11.3); //11.3

2.copySign(x,y) 返回第一个参数的值，第二参数的符号。
Math.copySign(1.25, -11.3); //-1.25
Math.copySign(-11.3, 1.25); //11.3

3.signum(x) 如果x大于0则返回1.0，小于0则返回-1.0，如果等于0则返回0.0
Math.signum(10.3); //1.0
Math.signum(-10.3); //-1.0
Math.signum(0); //0.0

4.exp(x) 返回e的x次幂。
Math.exp(2)

5.expm1(x) 返回e的x次幂 - 1。
Math.expm1(2)

6.hypot(x,y) 返回x²+y²的二次方根。
Math.hypot(x, y); //√(x²+y²)
Math.hypot(3, 4); // 5

7.Math.sqrt(b);返回b的平方根
⑬　包实际上与文件夹对应，作用为：
1)解决类命名冲突问题；
2)把类分门别类的组织到相应的包中，方便管理、维护和保护；
⑭　JDK常用的包：
1)Java.lang：这是java语言的核心包，系统将自动引入这个包进入用户程序；
2)Java.util：实用包，提供各种实用功能的类，包括日期类、集合类、随机数类等；
3)Javax.swing：轻量级的窗口工具包；
4)Java.io：输入/输出包，其中提供了输入/输出类的接口；
5)Java.net：网络函数包，提供了实现网络应用程序的类；
⑮　字符串类常用的方法
1)Length（）：返回字符串长度
2)ToCharArray（）：将字符串转换为一个新的字符数组；
3)charAt(int index):返回指定索引的字符；
4)Trim():返回字符串的副本，去除前导空白和尾部空白；
5)Substring（int begin,int end）：截取从指定索引处的字符开始到结尾时的索引；
6)indexOf(String str)：返回指定字符串在字符串中第一次出现的索引；
7)indexOf(String str，int index)：返回指定字符串在指定的索引开始，第一次出现处的索引；
8)Split（）：根据给定的正则表达式拆分字符串；返回数组；
9)ToLowerCase（）：将字符串中的所有字母转换成小写；
10)ToUpperCase（）：将字符串中所有的字符转换为大写；
11)Equals（）：将指定字符串与字符串相比较；返回bool；
12)ReplaceAll（String regex,String replacement）：使用给定的replacement替换字符串中所有匹配给定的正则表达式的子字符串；
⑯　StringBuilder类(new 对象，.的方式调用)
1)Append（String str）:将指定的字符串追加到字符串之后；
2)Insert（int offset,int str）:将指定字符串插入字符串中指定位置；
3)Reverse（）：反转字符串；
4)SetCharAt（int pos，int ch）：将指定字符设置在指定的位置（替换）；
5)Replace（int stat，int end,String str）:使用指定的字符串替代字符串部分内容；

2.完成的习题编程
课本P330实验题：过程如下：
(1)定义–个图书类,其属性有书名、编号、定价和静态属性当前图书对象数。类中有无参构造方法和带2个参数(书名、书价)的构造方法，获取、设置书名和定价的方法，以1重写的toString()方法。书的编号采用自动编号，第1本书的编号为1,第2本书的编号为2,以此类推。并编写程序进行测试。

package page03;

public class BookObject {
	private String bookName;
	private int bookNo;
	private double bookPrice;
	private static int bookObjectNum = 0;

	public void setbookName(String name) {
		bookName = name;
	}

	public String getbookName() {
		return bookName;
	}

	public void setbookPrice(double price) {
		bookPrice = price;
	}

	public double getbookPrice() {
		return bookPrice;
	}

	public void BookObject(String bookname, double price) {
		this.bookNo = ++bookObjectNum;
		this.bookName = bookname;
		this.bookPrice = price;
	}

	public String toString() {
		return "编号为：" + bookNo + "\t书名为：" + bookName + "\t定价为：" + bookPrice + "\n图书对象数为：" + bookObjectNum;
	}

}


		// 调用图书类 p330 （1）
		System.out.println("调用图书类");
		printXX("张三", 12.5);
		printXX("李四", 5.5);
		printXX("王五", 9.5);

二、遇到的问题及解决方法
1、Eclipse敲代码运行无影响但是总有黄色提示
解决：@SuppressWarnings(“resource”) //(“all”) 用于抑制编译器产生警告信息

2、某一段时间内思路混乱，逻辑错误
解决：跳过该题或者停止思考，等静一段时间再去从头理一遍逻辑。

三、小结
学习了；类的定义和对象的生成和使用，构造方法的特点和使用，this引用和static成员的使用以及字符串类的使用。
掌握了：对象的生成使用以及用this调用成员方法，使用static修饰静态成员，以及字符串的使用。

第四章 继承与多态性

一、实验操作
1.调试的例题
①super关键字的使用；
②定义抽象类及抽象方法；
③利用接口实现运行时多态性；

(1)要点：
(2)Java继承具有以下特点
①继承关系是传递的，子承父业。
②继承简化了人们对事物的认识和描述，能清晰体现相关类间的层次结构关系。
③继承提供了软件重用功能。
④避免相同的代码出现多次复用。
(3)继承的使用
①[访问修饰符] class 类A（子类） extends 类B（父类）{//成员定义}
②例子： public class Student extends Preson{ private String school;}
(4)Super()方法：在继承类（子类）中用作调用父类的构造方法，可以在子类的构造方法中用Super()来一同构建构造方法；
①可以在子类中用super.方法名，调用父类的方法；
(5)方法重写（@Override）：子类不能重写父类的static（静态方法）
(6)方法重载和方法重写的区别
①方法重写是方法的返回类型、方法名、和方法参数完全相同；
②方法重载是方法的方法名相同但是参数的个数或者参数类型不一样；
(7)Final关键字
①使用final来声明常量，常量不能修改且定义的时候要赋初始值；
②使用final声明的方法不可以被子类重写；
③当某个类中不允许它的子类来重写某个方法，那么这个类中的该方法用final来声明：public final void XXX（）{}；
④使用final声明的类，不能继承，也就是不可以有子类
⑤优点
1)把方法锁定，防止任何继承类修改它的意义和实现；
2)编译器在遇到用final声明的方法时，会转入内嵌机制，提高运行效率；
(8)抽象类和抽象方法（关键字：abstract，必须继承，由子类重写父类的抽象方法）
①声明抽象方法：[访问修饰符] abstract <返回值类型> <方法名> (参数列表){}
1)例如：public abstract void Function1212（String aa）{}
②声明抽象类：abstract class 类名（）{//类体}
1)例如：abstract class User（）{}

③抽象方法不能是静态的（static）
④含有抽象方法的类一定是抽象类
⑤抽象类的两种用途
1)抽象类是用来被继承的；
2)抽象类虽然不能实例化对象（new 对象），但是能定义抽象类的引用并指向具体子类的对象，通过抽象类的引用调用子类对象的重写方法实现多态；
(9)多态性：一个程序中同名的不同方法共存的情况，分为编译时的多态和运行时的多态；
①编译时的多态：是通过方法的重载来实现的；
②运行时的多态：是通过方法重写来实现的（子类重写父类的方法来实现——需要继承）
1)作用：使程序的可维护性极好；
③实现多态的过程
1)在抽象类中定义抽象方法
2)在抽象类的子类中重写抽象方法
3)让抽象类的对象引用指向具体子类对象（执行类）
4)通过抽象类的对象引用调用抽象方法，会绑定到具体子类中重写的抽象方法上。
a.例子：class ShapeUser{//Shape 是定义的抽象类
Public void ShowShape(Shape shape){//传入的实参只能是Shape类的具体子类对象
Shape.draw();//指向Shape类的子类的重写方法
}
}

(10)Object类：是所有类的父类，当一个类没有指定继承父类的时候，默认继承Object类；
(11)Java接口（interface）
①定义
1)Java接口是一种特殊的抽象类，只包含常量和抽象方法，没有变量和具体方法；
2)Java接口的方法只能是抽象的（abstract）和公开的（public）
3)Java接口不含有构造方法

②Java接口类的用途
1)通过接口实现不相关类的相同行为，而无需考虑这些类之间的关系
2)通过接口指明多个类需要实现的方法
3)通过接口了解对象的交互界面，而无需了解对象所对应的类

③Java接口的定义：
1)[public] interface 接口名[extends 父接口列表]{…//接口体}
a.例如：interface Collection {//方法默认是public、abstract
Void add（Object obj）;
}

④Java接口的实现
1)注意事项：
a.在类的声明中，用implements子句表示类实现了那个接口；
b.一个类中可以实现多个接口，在implements子句中用逗号分开；
c.类必须实现接口定义中的所有方法；
例子：class FIFOQueue implements Collection{
Void add(Object obj){
//具体的实现方法
}
}

⑤Java接口类型的使用
1)Java接口是抽象的，不允许是实例化对象，但是允许定义接口类型的引用变量，利用该引用变量引用实现了这个接口的类的对象；
2)使用方法：
a.作为一种引用类型来使用；
b.接口类型的引用变量可以指向任意一个实现了该接口的子类的实例；
c.通过这些引用变量可以访问类所实现的接口中的方法；

⑥Java接口（接口的多态）的灵活性在于：规定了一个类必须做什么，但是不管你如何去做
1)例如规定这个类必须开门，凡是不管你怎么开门，开什么门；

(12)注解
①@Override:能实现编译时检查，可以为子类的重写方法添加该注释，以声明该方法用于覆盖父类中的方法，如果该方法没有覆盖父类中的方法，那么在编译时会报错；
②@SuppressWarning：阻止编译器发出某些警告，可以有以下参数：
1)Deprecation:过时的类或方法警告；
2)Unchecked：执行了未检查的转换时警告；
3)Fallthrough：当Switch程序块直接通往下一种情况而没有break语句时的警告；
4)Path：在类路径、源文件路径等路径中有不存在的路径时的警告；
5)Serial：在可序列化的类上缺少serialVersionUID定义时的警告；
6)Finally：任何finally子句不能完成时的警告；
7)All：关于以上所有情况的警告；
③@Deprecated：标记某个过时的类或者方法，当编程人员使用这些方法时，将会在编译时显示提示信息；

二、遇到的问题及解决方法
解决：跳过该题或者停止思考，等静一段时间再去从头理一遍逻辑。

三、小结
学习了java继承的基本概念以及关键词extends的使用，抽象类使用以及关键词abstract，java接口的运行及应用。

第五章 异常处理

一、实验操作
1.调试的例题
①finally语句块示例；
②异常抛出示例；
③异常处理的嵌套示例；

要点：
(1)常见的异常类
①RuntimeException：运行异常的基类；
②ArithmeticException：算数错误，如除以0；
③IllegalArgumentException：方法收到非法参数；
④ArrayIndexOutOfBoundsException：数组下标越界；
⑤NullPointerException：试图访问null对象；
⑥SecurityException：视图违反安全性；
⑦FileNoFoundException：不能找到文件；
⑧EOFException：文件结束；
⑨IllegalAccessException：对类的访问被拒绝；
⑩NoSuchMethodException：请求的方法不存在；
⑪InterruptedException：线程中断；

(2)异常处理机制：通过try——catch——finally
①Try语句块：用try{…}选定捕获异常的范围，执行的过程中可能会生成异常对象并抛出给catch语句
②Catch：一个try语句可以有多个catch语句用于处理异常事件，在catch语句中给用户一个较好的反馈或者打印出错误信息；
1)提供了getMessage（）方法用来得到有关异常事件的信息
2)PrintStackTrace（）用来跟踪异常发生时的堆栈内容。
③Finally语句块：是可选的，经常用于释放对象占用的资源；

(3)异常的抛出
①throws语句
1)例如：public void someMethod(…) throws ExceptionOne,ExceptionTwo{
…//方法体
}

②Throw语句
1)抛出异常首先要生成异常对象，抛出的异常必须是Throwable类或其子类的实例；
a.例如：
Throw new IllegalAccessException(“非法访问异常”)

(4)异常的转发
①让最合适处理该异常的方法去处理这个异常。
在catch语句块中重新抛出所捕获的异常即可；

(5)异常处理的注意事项
①避免过大的try语句块，不要把不会出现异常的代码放到try中；
②捕获异常是应该细化异常的类型，不要不管什么类型的异常都写成Exception；
③Catch语句块尽量保持一个块捕获一类异常，不要忽略捕获的异常，要么处理，要么转发，要么抛出新的异常；
④不要把自己能处理的异常抛给别人；

2.完成的习题编程

二、遇到的问题及解决方法
1、一些代码的关键字会混淆
解决：多次手写代码

三、小结
异常处理能处理就处理不能处理就抛出，让调用者处理，最终没有处理的异常会使用JVM终止程序的运行，try语句块不能单独存在，可以和catch，finally共同组成try-catch-finally，try-catch，try-finally3中结构。

第六章 Java常用类

一、实验操作

1. 调试的例题
   ①使用BigInteger类的示例；
   ②定时器任务，输出“定时任务被执行”；

要点：
(1)日期和时间操作类
①System类（java.lang.Ststem）:
1)System.currentTimeMillis()方法
a.声明：
a)Public static long currentTimeMillis():返回当前的计算机时间，时间点的表达格式为当前计算机时间和GMT（格林尼治）
b)例如：long time = System.currentTimeMillis();//得到一个长整型的数字；

2)System.nanoTime()方法
a.声明：
a)Public static long nanoTime():返回尽量准确的可用系统计时器的当前值，以纳秒（豪微秒）为单位，这个方法依靠操作系统，
3)相同点：这两个方法主要是用于计算程序运行所需要的时间：
a.例如： long startTime = System.nanoTome() //获取开始时间;
doSomeThing();//测试代码
long endTime = System.nanoTome();//获取结束时间
则运行时间为：（startTime-endTime）+“ns”//ns为单位

(2)Date类：使用Date类的默认构造方法创建对象就代表当前的时间。
①如：Date time = new Date（）；
System.out.println(time)//为中国标准时间需要转换，CTS中国标准时间;

(3)Calendar类：是一个抽象类，处理日期和时间
①Calendar c = new Calendar.getInstance();

②Set方法：可以使用Calendar对象代表特定的时间，通过设定对象中的年、月、日参数来完成。
1)Set方法的声明如下：
a.Public final void set(int year,int month,int date)
（）c.set（2020，（7-1），19）
其中月份为实际的月份值减1

③Get方法：可以获得Calendar对象中对应的信息；
1)声明：
Public int get(int field)
其中参数field代表需要获得的字段的值，字段说明和set()方法一样，但是获得的月份为实际月份值减一，星期值：周日为1，周一为2以此类推；

④add方法：
1)声明
Public abstract void add(int filed,int amount)
在Calendar对象中的某个字段上减少或者增加一定的数值，增加时amount为正，减少时amount为负；
⑤after方法
1)声明
Public boolean after(Object When)
判断当前日期在不在传入参数日期之后，在的话返回true，不在就是false；
Public boolean before(Object When)
判断当前日期在不在传入参数日期之前，在的话返回true，不在就是false；

⑥getTime方法：将Calendar对象装换为Date对象，两者表达相同的时间点。
1)声明：public final Date getTime()
2)类似：public final void setTime():将Date对象装换为Calendar对象;

DateFormat类和SimpleDateFormat类：Java.text.DateFormat是日期和时间格式化子类的抽象类，该类主要实现Date对象和字符串之间的相互转换；

(1)DateFormat类和SimpleDateFormat类：Java.text.DateFormat是日期和时间格式化子类的抽象类，该类主要实现Date对象和字符串之间的相互转换；
①Public final String format(Date time)用法：
DateFormat.getDateInstance().Format(time);//2019年2月15日
DateFormat.getTimeInstance().Format(time);//下午 3 : 26 : 24
DateFormat.getDateTimeInstance().Format(time);//2019年2月15日 下午3 :26 :24

②Public Date parse(String source)用法：
SimpleDateFormat format = (SimpleDateFormat )DateFormat.getInstance();
Format.applyPattern(‘yyyy年MM月dd日 HH时 mm分 ss秒’);
Format.applyPattern(‘yyyy-MM-dd HH: mm: ss秒’);

(4)Math类：java.lang.Math类是标准的数学类，封装了数学函数和常量。
①Math.E e常量；
②Math.PI π常量；
③Math.Pow(2,3) :2的3次方；
④Math.round(5.6) :5.6四舍五入；
⑤Math.Random():产生一个0~1.0的随机数；
⑥Math.Random()*100:产生一个0~100的随机整数；
(5)Random 类
①定义
1)public Random()
2)Public Random(long seed)
②使用：
1)Boolean nextBoolean():返回下一个boolean随机数；
2)Void nextBytes(byte vals[]):用随机产生的值填充vals
3)Double nextDouble():返回下一个double随机数（在[0.0,1.0]区间均匀分布的double）；
4)Double nextGaussian():返回下一个高斯随机数（正态分布的double值）；
5)Int nextInt():返回下一个int随机数；
6)Int nextInt(int n):返回下一个【0，n）区间内的随机数；
7)Long nextLong():返回下一个long随机数；
8)Void setSeed(long newSeed):将由newSeed指定的值作为种子值（也就是随机数产生器的初值）；
③例子：
1)Random r = new Random();
Int n = r.nextInt(n);

(6)BigInteger类和BigDecimal类：
①BigInteger支持任意精度的整数，也就是用任意精度大小的整数值，在运算过程中不会丢失任何信息。
1)Public BigInteger(String val):构造方法，将字符串转换为BigInteger；
2)Public BigInteger add(BigInteger val):加法；
3)Public BigInteger subtract(BigInteger val):减法；
4)Public BigInteger multiply(BigInteger val):乘法；
5)Public BigInteger divide(BigInteger val):除法；
6)Public int compareTo(BigInteger val):与指定的val比较，小于返回-1，大于返回1，等于返回0；

②BigDecimal类：支持任意精度的小数，并对他们进行计算；
1)Public BigDecimal (String val):构造方法，用字符串构造BigDecimal；
2)Public BigDecimal (double val):构造方法，用double构造BigDecimal；
3)加、减、乘法类似BigInteger；

(7)正则表达式：
①正则表达式语法：
1)元字符：( , [ , { , \ , ^ , - , $ , | , } , ] , ) , ? , *, + , .
注意：在元字符前加入反斜线（\）可以强制将元字符处理成普通字符
②字符模式：
1)基本：[bcr]at 会匹配bat、cat、rat；
2)否定：^{元字符，[}a-z] 匹配小写a~z范围以外的；
3)范围：-元字符，[1-5]和[a-h] [a-zA-Z]是匹配a_{z小写或者A}Z大写中的任意一个;
4)并集：[0-4[6-8]]:匹配0 1 2 3 4 5 6 7 8这几个数字；
5)交集：[0-9&&[345]] 匹配0-9中和345相同的部分，公共部分；
6)差集：[0-9&&[^345]] 匹配0~9中除了345的部分；
③例子：
1)[abc]：a、b或c；
2)[^abc]：除了a、b、c以外的字符；
3)[a-zA-z]：a_z或者AZ（范围）；
4)[a-d][m-p]；a_d或mp（并集）
5)Java|Hello：Java 或 Hello；
6)[a-z&&[def]]：d、e、f（交集）；
7)[a-z&&[^bc]]：a~z中除了b、c以外的字符；
8)[a-z&&[^m-p]]：a_{z并且不包括m}p（差集）
(8)正则表达式预定义字符：
①. ：任何字符；
②\d：数组字符[0~9]；
③\D：非数字字符[^0~9]；
④\s：空白字符（[\t\n\x0B\f\r]）
⑤\S：非空白字符 [^\s];
⑥\w：单词字符 ([a-zA-Z_0-9]);
⑦\W：非单词字符（[^\w]）；

(9)正则表达式量词：允许指定匹配出现的次数；
①? ：0次货1次；
②*：0次或者多次；
③+：一次或者多次；
④{n}：精确为n次；
⑤{n,}：至少为n次；
⑥{n,m}：精确为n~m次；

(10)正则表达式边界匹配字符：
①^：行首；
②$：行尾；
③\b：单词边界；
④\B：非单词边界；

(11)Pattern类和Matcher类
①引入java.util.regex.Pattern：用来创建一个正则表达式；
②引入java.util.regex.Matcher类：用正则表达式匹配一个字符串；
③方法：
1)Public static Pettern compile(String regex)：编译模式，参数regex表示输入的正则表达式；
2)Public static Pettern compile(String regex,int flag)：编译模式，参数regex为正则表达式，flag表示模式类型，如Pattern.CASE_INSENSITIVE表示不区分大小写；
3)Public String[] split(CharScquence input):分割字符串input；

(12)Matcher类
①方法
1)Public Boolean matches()：对整个字符串进行模式匹配；
2)Public Boolean find()：从start处开始匹配；
3)Public String replaceAll(String replacement):用给定的replacement 全部替代匹配的部分；

(13)String类对正则表达式的支持：
①方法：
1)Public Boolean matches(String regex)：字符串模式匹配；
2)Public String[] split(String regex)：分割字符串input；
3)Public String replaceAll(String regex,String replacement)：用给定的replacement替代匹配的部分；

(14)定时器任务:Timer类和TimerTask类
①实现一个定时器任务分两步：
1)扩展TimerTask类并重写run方法，把完成定时器任务的代码放到run中；
2)创建一个Timer对象，然后调用它的scheddule（）方法来安排任务；
3)Timer类
a.方法
a)Public Timer()：构造方法。相关的线程不作为守护线程运行；
b)Public Timer(boolean isDaemon)：构造方法。可以指定其相关的线程作为守护线程运行；
c)Public void cancel()：终止此计时器，丢弃所有当前已安排的任务；
d)Public void schedule(TimerTask task,Data data)：在指定的时间执行指定的任务。如果此时间已过，则立即执行该任务；
e)Public void schedule(TimerTask task,long delay，long period)：指定的任务从指定的延迟后开始以固定周期重复执行（单位为毫秒）；

4)Arrays类
a.Arrays.sort（）：会根据数组元素的大小对数组元素进行排序；

三、遇到的问题及解决方法
1.一些代码的关键字会混淆
解决：多次手写代码
2.知识点以及语法不牢固
解决方法：查阅书记和上网查资料

三、小结
学习了时间和日期操作类的使用，Mach类的使用，使用Random类获取随机数，使用正则表达式匹配查找和替换字符。

第七章 泛型与集合

一、实验操作
1.调试的例题
①向ArrayList对象中添加元素并遍历输出
②使用LinkedList类实现先进先出和后进后出功能
③为存放到HashSet集合的对象所属类重写hashCode()和equals()方法
④验证TreeSet对用户自定义类的对象是自然排序的

要点：
1)泛型：
a)优点：
i.类型安全：类型错误可以再编译时被捕获，而不是在运行时抛出异常；
ii.消除强制类型转换：使代码的可读性更好；

2)泛型类和泛型接口：
a)Class 类型<泛型类型1,泛型类型2，…> { … }
b)Interface 接口<泛型类型1，泛型类型2，…>{ … }
c)例子：
i.Java.util.Map接口的定义摘录：
Public interface Map<K,V>{
Public void put(K key,V value);
Public void get(K key)
}
d)注意：Map接口有两个参数类型，键值对；
i.例如：Map<String,String> map = new HashMap<String,String>();
ii.Map<String,String> map = new HashMap< >();
iii.Map.put(“key”,”blarg”); String s = map.get(“key”);

3)泛型擦除：使用泛型时没有指定泛型类型，则表示擦除泛型，class将安照Object类型进行接收；
注意：在开发中建议不要擦除泛型；

4)泛型通配符：
a)例如：
i.Public static void print（Point<?> P）{
System.out.println（P.getX()）；
System.out.println（P.getY()）；
}
”?”表示可以接收任何泛型，但是使用泛型通配符是，该类型对象只有可读属，没有可写属性，p.getX()可用，p.setX()不可用，与原生的相比，泛型通配符是类型安全的；

5)泛型接口的实现方式：
a)Interface IDemo{
Void print(T param)
}；
i.不指定具体泛型类型；
1.Class DemoImpl implements IDemo{

}
ii.指定具体泛型类型；
Class DemoImpl implements IDemo{
Public void print(String param){
System.out.println(“param”+param);
}
}

6)泛型方法
a)Class Demo{
Public T fun(T param){
Return param;
}
}

7)Java集合分类
a)List：提供的是一个有序的集合且它允许有重读元素；
b)Set：提供一个无序的集合，且不允许包含重复的值；
c)Map：提供一个键值对的 元素集合，Key值唯一；
d)Set和List都继承Collection接口；
e)Map提供了ketSet（）和values()两个方法；

8)Collection类和Iterator接口
a)Collection类：是最基本的集合接口，声明了适用于java集合（只包括Set、List和Queue）的通用方法。
i.方法：
1.Boolean add（E e）：将对象添加到集合；
2.Boolean remove（Object o）：如果集合中有与o相匹配的对象，则删除对象o；
3.Int size（）；返回当前集合中的元素；
4.Boolean isEmpty（）：判断集合中是否有元素；
5.Boolean contains（Object o）：查找集合中是否含有对象o；
6.Iterator iterator（）：返回一个迭代器，用于访问集合中的各个元素；
7.Boolean containsAll（Collection<?> c）：查找集合中是否含有集合c的所有元素； 8.Boolean addAll（Collection<?Extends E> c）:将集合c的所有元素添加到集合； 9.Void clear（）：删除集合中的所有元素； 10.Boolean removeAll（Collection<?> c）：从集合中删除集合c的所有元素；
11.Boolean retainAll（Collection<?> c）：从集合中删除集合c中不包含的元素；
12.Coolection转换为Object数组：Object【】 toArray（）：返回包含集合中的所有元素的array；
ii.Iterator接口
1.Boolean hasNext（）：判断是否存在另一个可访问元素；
2.Object next（）：返回要访问的下一个元素。
3.Void remove（）：删除上次访问的对象；

9)ArrayList类
a)ArrayList类：最常用的List接口的实现类，而List是Cillection接口的子接口；
10)HashSet类
a)HashSet类：中存放的元素是无序的，由于是用来散列函数，因此存取速度非常快，在地址空间很大的情况下，它的存取速度可以达到O(1)级，具有很好的存取和查找性能；
11)Map类
a)Public void clear（）：清空Map集合；
b)Public boolean containsKey（Object key）：若此Map集合包含指定键的映射关系，则返回true；
c)Public boolean containsValue（Object value）：若此Map集合包含指定值的映射关系，则返回true；
d)Public V get（）：返回指定键所映射的值；
e)Public boolean isEmpty（）：如果Map集合为空则返回true；
f)Public Set keySet（）：返回此集合中包含的所有key集合；
g)Public V put（K key,V value）:加入键值对元素，若已经存在则用新值替换旧值；
h)Public int size（）：返回Map集合中的元素个数；
i)Public V remove（Object key）：删除key所对应的键值对元素；

二、遇到的问题及解决方法
1、一些代码的关键字会混淆
解决：多次手写代码

三、小结
学习了泛型技术及其使用，list接口、set接口、map接口的使用，还有集合工具collections类。

第八章 多线程

一、实验操作
1.调试的例题
使用eclipse新建项目，新建一个测试类，检查JDK环境变量是否完整，进程和线程是现代操作系统中两个必不可少的运行模型
2、完成的习题编程
(1)继承Thread类的创建线程示例
(2)线程的优先级示例
(3)多线程售票数据的访问冲突问题示例
(4)把一组任务交给线程池执行
要点：
1.Java线程创建两种方法：直接继承Thread类创建线程和通过实现Runnable接口创建；
2.启动线程要使用start（）方法；
3.多线程之间需要协调工作可以使用wait（）方法等；

二、遇到的问题及解决方法
1.遇到的问题： 无
2.解决方法： 无

三、小结
学习了Java多线程的两种创建方法，线程的生命周期以及状态变化，线程操作的相关方法和多线程的互斥和同步
掌握了Java线程创建两种方法：直接继承Thread类创建线程和通过实现Runnable接口创建，线程的生命周期等

第九章 Java I/O流

一、实验操作
1.调试的例题
使用eclipse新建项目，新建一个测试类，检查JDK环境变量是否完整，程序在运行时通常要和外部进行交互，从外部读取数据或向外部设备发送数据。

2、完成的习题编程
1)创建一个新文件
2)用filewriter写入一个字符串，filereader读出写入内容；
a.如下：

package com.IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

public class IO {

	public static void main(String[] args) {
		// File ="D:\WeChat Files\WeChat
		// Files\wxid_fj25menpkofd22\FileStorage\File\2022-10\JavaIO.txt"
//		isFile();

//		Filecz();

		// 文件流类
		flieLiu();

	}

	// 文件创建以及判断是否存在
	public static void isFile() {
		String FilePath = "D:\\WeChat Files\\WeChat Files\\wxid_fj25menpkofd22\\FileStorage\\File\\2022-10\\JavaIO.txt";
		File file = new File(FilePath);
		if (file.exists()) {
			file.delete();
		} else {
			try {
				file.createNewFile();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	// 文件操作
	public static void Filecz() {
		System.out.println(
				"列出D:\\\\WeChat Files\\\\WeChat Files\\\\wxid_fj25menpkofd22\\\\FileStorage\\\\File\\\\2022-10   下面的内容");
		System.out.println("flie.list()方法");
		String path = "D:\\WeChat Files\\WeChat Files\\wxid_fj25menpkofd22\\FileStorage\\File\\2022-10";
		File file2 = new File(path);
		String[] lists = file2.list();
		for (String i : lists) {
			System.out.println(i);
		}

		System.out.println("======================================================");
		System.out.println("flie.listFiles()方法");
		System.out.println("======================================================");
		File[] fileliu = file2.listFiles();
		for (File item : fileliu) {
			System.out.println(item.getName() + "\t" + (file2.isFile() ? "文件" : "不是文件类型"));
		}
	}

	public static void flieLiu() {
		// 写入字符串/读出字符串
		String FilePath = "D:\\WeChat Files\\WeChat Files\\wxid_fj25menpkofd22\\FileStorage\\File\\2022-10\\JavaIO.txt";
		File file = new File(FilePath);
		if (file.exists()) {
			try (FileOutputStream outputsrteam = new FileOutputStream(file, true)) {
				Scanner as = new Scanner(System.in);
				System.out.println("请输入两个字节");
				String first = as.nextLine();
				String firs2 = as.nextLine();
				outputsrteam.write(first.getBytes());
				outputsrteam.write(firs2.getBytes());
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

			// 读出
			System.out.println("文件读出：");
			try (FileInputStream in = new FileInputStream(file)) {
				int length = in.available();// 获取文件流的字节数
				byte[] buf = new byte[length];
				in.read(buf);// 读取内容到字节数组中
				System.out.println("结果为：");
				System.out.println(new String(buf));
			} catch (IOException e) {
				e.printStackTrace();
			}

		} else {
			System.out.println("该文件不存在！正在重新创建");
			try {
				file.createNewFile();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static void zifuIOInAndOut() {
		String FilePath = "D:\\WeChat Files\\WeChat Files\\wxid_fj25menpkofd22\\FileStorage\\File\\2022-10\\JavaZIFIO.txt";
		File file = new File(FilePath);
		if (file.exists()) {
			System.out.println("使用FileWritwe和FileReader读写");
			try (FileWriter fileWriter = new FileWriter(file, true)) {
				Scanner as = new Scanner(System.in);
				System.out.println("请输入两个字符：");
				String first = as.nextLine();
				String firs2 = as.nextLine();
				fileWriter.write(first);
				fileWriter.write(firs2);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

			// 读出
			System.out.println("文件读出：");
			int length = 0;
			char[] buf = new char[1024];
			try (FileReader in = new FileReader(file)) {
				// 获取文件流的字节数
				in.read(buf);// 读取内容到字节数组中
				System.out.println("结果为：");
				System.out.println(new String(buf));
			} catch (IOException e) {
				e.printStackTrace();
			}

		} else {
			System.out.println("该文件不存在！正在重新创建");
			try {
				file.createNewFile();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

3)丛文本文件读出10个整数，然后升序排序输出
4)DataInputStream类的使用
要点：
1.File类是文件操作的辅助类，但它不能进行文件内容访问
2.RandomAccessFile类支持文件随机读写
3.InputStreamReader类和OouputStreamWriter类是字节流到字符流的转换类；
4.DataInputStream类和DataOutStream类提供了Java数据类型的读和写；

二、遇到的问题及解决方法
1.遇到的问题： 无；
2.解决方法： 无；

三、小结
学习了Java流的分类及字节流和字符流；使用file类进行文件属性操作；字节流和字符流的转换。
掌握了File类是文件操作的辅助类，但它不能进行文件内容访问，RandomAccessFile类支持文件随机读写，InputStreamReader类和OouputStreamWriter类是字节流到字符流的转换类，DataInputStream类和DataOutStream类提供了Java数据类型的读和写等

第十章 图形用户界面

一、实验操作
1.调试的例题
检查JDK环境变量是否完整，使用eclipse新建项目，新建一个测试类，Java图形用户界面用于实现用户与程序互交。

2、完成的习题编程
(1)swing的窗体示例
(2)flowlayout流式布局管理器
(3)鼠标事件示例

要点：
1、Swing组件：
①顶层容器：顶层容器属于窗体组件，可以独立显示，图形界面就是建立在顶层容器基础上的。JFrame：普通的窗体(运行时称为窗口)；JDialog：对话框
②中间容器：中间容器也称为面板，可充当基本组件的容器。JPanel：一般面板容器组件；JScrollPane：带滚动条，可水平或垂直滚动的面板；JSplitPane：分割面板；JTabbedPane：选项卡面板
③基本组件：基本组件是直接实现人机交互的组件，必须依附于中间容器。JLabel：标签；Jbutton：按钮；JcheckBox：复选框；JRadioButton：单选按钮；JTextField：文本框；JpasswordField：密码框；JTextArea：文本区；JComboBox：组合框；JList：列表框；JProgressBar：进度条；JSlider：滑块；JTable：表格
2、窗体类JFrame：是最常用的顶层容器，称为窗体类
JFrame()：创建一个无标题窗体类；
JFrame(String title)：创建一个有标题的窗体；
setLocation(int x, int y)：设置窗体显示的位置；
setSize(int width, int height)：设置窗体大小；
setVisible(boolean flag)：设置窗体是否可见；
setDefaultCloseOPeration(int value)：设置单击窗体右上角的“关闭”按钮后，程序会做出怎样的处理：JFrame.DO_NOTHING_ON_CLOSE：什么也不做，JFrame.HIDE_ON_CLOSE：隐藏当前窗体，JFrame.DISPOSE_ON_CLOSE：隐藏当前窗体，并释放窗体占用的其他资源，JFrame.EXIT_ON_CLOSE：结束窗体所属的应用程序
3、面板类JPanel：是最常用的中间容器，称为面板类。面板本身不能独立显示，必须依附于顶层容器才可以显示，面板中可添加基本组件或其他中间容器
JPanel()：创建一个空的面板；
JPanel(LayoutManager layou)：创建带有指定布局管理器的面板；
add(Component comp)：将组件添加到面板中；
setLayout(LayoutManager lm)：设置面板的布局管理器；
4、布局管理器：Java语言使用布局管理器对象来管理容器中的组件的排列方式。例如水平排列、网格排列等。布局管理器包括以下几种类型：FlowLayout(流式布局管理器)、BorderLayout(边界布局管理器)、GridLayout(网格布局管理器)、GridBagLayout(网格包布局管理器)和CardLayout(卡片布局管理器)
5、流式布局管理器：流式布局管理器(FlowLayout)也称为顺序布局管理器，是最基本的布局管理器，其布局规则是：将组件逐个从左到右顺序排列，一行放满后转到下一行继续排列。
FlowLayout()：初始化流式为居中对齐，默认水平和垂直间距是5像素；
FlowLayout(int align, int hgap, int vgap)：以指定的对齐方式及指定的水平间距hgap和垂直间距vgap初始化流式布局管理器；
align的值有FlowLayout.LEFT、FlowLayout.RIGHT、FlowLayout.CENTER、FlowLayout.LEADING和FlowLayout.TRAILING
6、边界布局管理器：边界布局管理器(BorderLayout)按照地图方位把容器分为东、南、西、北、中5个区域。窗体缩放时，南、北区的高度保持不变，东、西区的宽度保持不变。当使用边界布局将一个组件添加到容器中时，要使用一下5个常量之一：BorderLayout.NORTH、BorderLayout.SOUTH、BorderLayout.EAST、BorderLayout.WEST、BorderLayout.CENTER，默认为BorderLayout.CENTER，内容面板的默认布局管理器是BorderLayout
BorderLayout()：创建一个组件之间没有间距的边界布局管理器；
BorderLayout(int hgap, int vgap)：用指定的水平间距、垂直间距创建一个边界布局管理器；
7、网格布局管理器：网格布局管理器(GridLayout)以矩形网格形式对容器的组件进行布局，适用于较多组件构成的用户界面，其基本规则是：将窗口分为几行几列的网格，按照自左至右、自上而下的分式依次放入组件
GridLayout()：创建具有默认值的网格布局管理器，即每个组件占据一个网格；
GridLayout(int rows, int cols)：创建具有指定行数和列数的网格布局管理器；
GridLayout(int rows, int cols, int hgap, int vgap)：创建具有指定行和列且设定间隔的网格布局管理器；
8、事件处理：①界面组件布局：生成图形用户界面；②界面组件的事件处理：为用户提供相应的响应
9、事件处理机制：java事件处理涉及3种对象：事件对象、事件源对象和事件监听器对象。一般事件源对象可以注册多个事件监听器，一个事件监听器对象也可以被注册到多个事件源。只有注册了事件监听器的事件源才可以进行事件响应。为事件源注册事件监听器后，可使用该事件源中的add×××Listener(aListener)方法。依据事件类型不同，注册方法名中间的×××也不同
10、事件类：
ActionEvent：按下按钮，双击列表项或选中一个菜单项或在文本中按Enter键时，就会触发此事件；
AdjustmentEvent：操纵滚动条时会触发此事件；
ComponentEvent：当一个组件移动、隐藏、调整大小或成为可见时会触发此事件；ItemEvent：单击复选框、单选按钮、列表项时触发此事件；
FocusEvent：组件获得或失去键盘焦点时会触发此事件；
KeyEvent：键盘有键按下时会触发此事件；
MouseEvent：拖动、移动、单击、按下或释放鼠标键或在鼠标指针进入或退出一个组件时，会触发此事件；
ContainerEvent：将组件添加至容器或从中删除时会触发此事件；
TextEvent：文本框或文本域中的文本改变时会触发此事件；
WindowEvent：当一个窗口激活、关闭、失效、恢复、最小化、打开或退出时会触发此事件
11、事件监听器接口：事件监听器通过实现java.awt.event包中定义的一个或多个接口来创建。在发生事件时，事件源将调用事件监听器的相应方法。如：ActionListener：actionPerformed();
12、事件适配器类：事件适配器类实现了事件监听器接口的所有方法（方法体为空，不做任何实际工作）
13、Swing常用基本组件：
标签(JLabel)是容纳文本的组件；
按钮(JButton)是用来捕捉用户操作最为简便的分式；
文本框(JTextField)是常用的单行文本组件；
密码框(JPasswordField)作为文本框的子类，允许编辑一个单行文本，但不显示原始字符，常用“*”代替密码的显示；
文本区(JTextArea)是可以输入多行文本的组件；
单选按钮(JRadioButon)可被选择或取消选择，并可为用户显示其状态；setSelected设置按钮是否被选中；
复选框(JCheckBox)用于多选项的用户输入，用户可以通过单击复选框来选定或取消选定某选项；
组合框(JComboBox)如果有很多选项，可以使用组合框；
列表(JList)多个选项列表的形式展示，允许用户选择一个或多个选项；

二、遇到的问题及解决方法
1.遇到的问题： 无；
2.解决方法：无 ；

三、小结
学习了swing容器和布局管理器的使用方法以及Java的图形用户界面事件处理机制；
掌握了swing容器组件JFrame和JPanle，布局管理器BorderLayout FlowLayout GridLayout，按钮JButton 文本框JTextField 密码框JPasswordField；

第十一章 网络编程

一、实验操作
1.调试的例题
检查JDK环境变量是否完整，使用eclipse新建项目，新建一个测试类，Java提供的Java.net包包括一系列的网络类支持Java程序直接发送与接受tcp数据。
2、完成的习题编程
①　使用URL的openstream方法与web服务器建立；
②　获取本机的主机名和IP地址；
③　基于socket的控制台网上聊天程序；
要点：
1.Java.net中提供URL类，可以通过它读取指定的www资源
2.InetAddress类用于对IP地址进行封装
3.基于TCP协议实现网络通讯类有socket类和serversocket类
二、遇到的问题及解决方法
暂无

三、小结
1)学习了使用URL类读取www网络资源，IP地址封装类InetAddress的使用，基于TCP协议的网络通信，基于udp协议的数据通信。
2)掌握了Java.net中提供URL类，可以通过它读取指定的www资源，InetAddress类用于对IP地址进行封装和基于TCP协议实现网络通讯类有socket类和serversocket类

第十二章 数据库编程JDBC

一、实验操作
1、调试的例题
在数据库javadatabaseconnection中创建数据表staff(id,name,sex)，请编写对数据库进行操作的DAO和VO，并进行测试。
2、完成的习题编程
1)在数据库factory中创建数据表student(id,name,sex)，请编写对数据库进行操作的DAO并进行测试：
2)创建包，分类存放相关的类或接口，com.inters，com.beans、com.javamysqlconn、com.dao、utils
a.如下：

3)编写接口类，定义接口方法类型以及参数列表；
4)编写实现类ISStudent，用于实现接口增、删、改、查的方法；
5)封装JDBC
a.如下：

package com.utils;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class utils {
	private static String url;
	private static Connection conn;
	private static PreparedStatement ps = null;
	private static ResultSet rs = null;

	public static Connection jdbcConnection() {
		try {
			Class.forName("com.mysql.jdbc.Driver");
			url = "jdbc:mysql://localhost:3306/javadatabaseconnection";
			conn = DriverManager.getConnection(url, "root", "123456");
			if (conn != null) {
				System.out.println("数据库连接成功！");
			} else {
				System.out.println("数据库连接失败！");
			}

		} catch (ClassNotFoundException | SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return conn;
	}

	// JDBC表的修改
	public static int jdbcTableModification(String sql) {
		int result = 0;
		try {
			jdbcConnection();
			ps = conn.prepareStatement(sql);
			result = ps.executeUpdate();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				psClose();
				connClose();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return result;
	}

	// JDBC表的查询
	public static ResultSet jdbcTableFind(String sql) {
		try {
			jdbcConnection();
			ps = conn.prepareStatement(sql);
			rs = ps.executeQuery();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return rs;
	}

	// 关闭数据库连接
	public static void connClose() {
		try {
			conn.close();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	// 关闭数据通道连接
	public static void psClose() {
		try {
			ps.close();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

6)在实现类JavaBaseDataConnection中调用接口并完成查询、修改、删除的功能；
a.如下：

package com.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

import com.inters.IStudent;
import com.utils.utils;

import beans.Student;

public class ISStudentDao implements IStudent {

	Connection conn = null;
	PreparedStatement ps = null;
	ResultSet rs = null;
	ArrayList<Student> list;

	@Override
	public int InsertStudent(int id, String name, String sex) {
		// TODO Auto-generated method stub
		int result = 0;
		try {
			String sql = "insert into Student values('" + id + "','" + name + "','" + sex + "')";
			result = utils.jdbcTableModification(sql);
		} catch (Exception e) {
			System.out.println(e);
			// TODO: handle exception
		}
		return result;
	}

	@Override
	public ArrayList<Student> QuerybyName(String name) {
		// TODO Auto-generated method stub
		try {
			String sql = "select * from student Where name like '%" + name + "%'";
			rs = utils.jdbcTableFind(sql);
			list = new ArrayList<Student>();
			while (rs.next()) {
				Student st = new Student();
				st.setId(rs.getInt(1));
				st.setName(rs.getString(2));
				st.setSex(rs.getString(3));
				list.add(st);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			try {
				utils.psClose();
				utils.connClose();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return list;
	}

	@Override
	public ArrayList<Student> QueryAllTbale() {
		// TODO Auto-generated method stub
		try {
			String sql = "select * from student";
			rs = utils.jdbcTableFind(sql);
			list = new ArrayList<Student>();
			while (rs.next()) {
				Student st = new Student();
				st.setId(rs.getInt(1));
				st.setName(rs.getString(2));
				st.setSex(rs.getString(3));
				list.add(st);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			try {
				utils.psClose();
				utils.connClose();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return list;
	}

	@Override
	public int DelectTableById(int id) {
		// TODO Auto-generated method stub
		int result = 0;
		try {
			String sql = "delete from student where id = " + id;
			result = utils.jdbcTableModification(sql);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}

	@Override
	public int UpdateStudById(int id, String name, String sex) {
		// TODO Auto-generated method stub
		int result = 0;
		try {
			String sql = "UPDATE student SET name = '" + name + "',sex = '" + sex + "' WHERE id = '" + id + "'";
			result = utils.jdbcTableModification(sql);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}

}

二、遇到的问题及解决方法
暂无

三、小结
1、JDBC：JDBC是Java database connectivity的缩写。JDBC是Sun提供的一套数据库编程接口API函数，由Java语言编写的类、界面组成。用JDBC写的程序能够自动地将SQL语句传送给相应的数据库管理系统。JDBC为程序开发提供了标准的接口，并为数据库厂商及第三方中间件厂商实现与数据库的连接提供了标准接口
2、DriverManager：DriverManager类是JDBC的管理层，作用于用户和驱动程序之间。它跟踪可用的驱动程序，并在数据库和相应驱动程序之间建立连接。在使用此类之前，必须先加载数据库驱动程序
加载方式：Class.forName(JDBC数据库驱动程序)，
如加载MySql的JDBC驱动：Class.forName(com.mysql.jdbc.Driver);
不同的数据库其JDBC驱动程序是不同的，如下：
Mysql数据库驱动：com.mysql.jdbc.Driver
SQL Server2005数据库驱动：com.microsoft.sqlserver.jdbc.SQLServerDriver
Oracel数据库驱动：com.microsoft.sqlserver.jdbc.SQLServerDriver
3、Connection接口：数据库驱动程序加载之后，可以调用DriverManager.getConnection()方法得到数据库的连接。在DriverManager类中定义了三个重载的getConnection()方法，分别如下：
static Connection getConnection(String url);
static Connection getConnection(String url,Properties info);
static Connection getConnection(String url,String user,String password);
方法中的参数含义：
url：表示数据库资源的地址
info：是一个java.util.Properties类的实例
user：是建立数据库连接所需用户名
password：是建立数据库所需的密码
常用的数据库连接字符串如下：
Mysql数据库：jdbc:mysql://主机名:3306/数据库名
SQL Server2005数据库：jdbc:sqlserver://主机名:1433:databaseName=数据库名
Oracle数据库：jdbc:oracle:thin:@主机名:1521:数据库名
4、Statement接口：Statement接口对象用于将普通的SQL语句发送到数据库中。建立了到数据库的连接后，就可以创建Statement对象。Statement接口对象可以通过调用Connection接口的createStatement()方法创建。示例代码如下：
Connection con=DriverManager.getConnection(url,”user”,”password”);
Statement stmt=con.createStatement();
常用执行SQL语句的方法：
①executeUpdate()方法用于更新数据，如执行INSERT、UPDATE和DELETE语句及SQL DDL（数据定义）语句，这些语句都不返回记录集，而是返回一个整数，表示受影响的行数。其方法原型：int executeUpdate(String sql);
②executeQuery()方法用于执行SELECT语句，此方法返回一个结果集，其类型为ResutSet。ResultSet是一个数据库游标，通过他可访问数据库中的记录。executeQuery()方法原型：ResultSet executeQuery(String sql);
5、PreparedStatement接口：PreparedStatement接口继承Statement接口，所以它具有Statement的所有方法，同时添加了一些自己的方法。PreparedStatement与Statement有以下两点不同：
PreparedStatement接口对象包含已编译的SQL语句；
PreparedStatement接口对象中的SQL语句可包含一个或多个IN参数，也可用“？”作为占位符。该接口对象的setString(n,参数)方法可以将第n个?用传进的参数代替。这样做增加了程序的可维护性，也增加了程序的安全性
PreparedStatemen对象可以通过调用Connection接口对象的preparedStatement()方法得到。代码示例如下：
Connection con=DriverManager.getConnection(url,”user”,”password”);
PreparedStatement pstmt=con.preparedStatement(String sql)；
6、创建PreparedStatement对象与创建Statement对象不同点:
①在创建PreparedStatement对象时需要SQL命令字符串作为preparedStatement()方法的参数
②在调用PreparedStatement对象的executeQuery()或executeUpdate()方法执行查询时，不再需要参数
③使用PreparedStatement对象的SQL命令字符串中可用“?”作为占位符

三、小结
学习了使用Java——JDBC链接数据库，并对数据库进行编写和操作。
掌握了Java——JDBC的链接以及封装数据，创建接口，创建接口实现类和对数据库的操作。