Java总结-2019.10

节点1：环境搭建，Java基础语法

1. 环境搭建

版本：
J2SE、J2EE、J2ME
下载并安装JDK
JDK(Java Develop Kit):开发工具包
JRE(Java Runtime Environment):运行时环境
配置环境变量
右键—>计算机—>选择“属性”—>点击“高级系统设置”—>打开“系统属性”窗口—>点击“环境变量”
（1） 新建“JAVA_HOME”环境变量，值设置为：JDK的安装目录
（2） 修改“Path”环境变量，添加“;%JAVA_HOME%\bin;”
（3） Classpath(可选)
验证是否安装成功：
打开“运行”—>输入cmd—>在命令提示符窗口，输入java –version,如果能够出现如下界面，则安装成功！

2. 第一个Java程序

创建文件名为HelloWorld.java的源文件：

//定义一个公共类，类名HelloWorld
public class HelloWorld{
	//类体-main方法
	public static void main(String[] args){
		//方法体
		System.out.print("Hello World!");
	}
}

运行Java程序：
（1） 打开“运行”，输入cmd，打开命令提示符窗口
（2） 切换目录
a) 切换盘符： e:
b) 切换目录： cd billfox（cd—change directory）
c) 编译程序： javac HelloWorld.java（编译源文件，获得class字节码文件）
d) 运行程序： java HelloWorld（运行字节码文件）

3. 开发工具的安装使用

安装版.exe
解压版

4. 使用Eclipse创建Java项目

包名：反域名制（com.taobao.projectName）
类名：所有单词首字母要大写！(UpperCamelCase驼峰命名法 StudentCount)
变量名,方法名，参数名：(lowerCamelCase驼峰命名法 studentCount)
常量：所有字母大写，每个单词之间用下划线隔开。 MAX_STOCK_COUNT

命名规范：由字母，数字，下划线和$组成，不能以数字开头。
比如：num1 num_1 $num

5. Java编程基础

1) 变量

语法：数据类型 变量名 [= 值];
例子：int count = 10;
float studentWeight;

标识符和关键字
标识符：是用来表示变量名、类名、方法名、数组名和文件名的有效字符序列。
关键字：是Java语言中被赋予特定含义的一些单词。

变量的作用域

public class Demo01 {
	public static void main(String[] args) {
		//变量的作用域
		int x = 10;
		
		{
			//代码块
			int y = 20;
			System.out.println(y);
			System.out.println(x);
		}
		
		System.out.println(y);//报错，超出了y的作用范围
		System.out.println(x);
	}
}

2) 数据类型( 四类8种)

（1） 整数型
a) 字节型byte 1个字节（8位） -27 ~27-1
b) 短整型short 2个字节（16位） -215 ~215-1
c) 整型int 4个字节（32位） -231 ~231-1
d) 长整型long 8个字节（64位） -263 ~263-1
（2） 浮点数类型
a) 单精度浮点 float 4个字节
b) 双精度浮点 double 8个字节
（3） 布尔型 boolean (true,false)
（4） 字符型 char

数据类型转换
（1） 自动类型转换（小 转 大）
byte–>short–>char–>int–>long–>float–>double
例子：
int num = 20;
float f1 = num;
（2） 强制类型转换（大 转 小）
例子：
float f2 = 2.5f;
int num2 = (int)f2;//有可能损失精度或者溢出
（3） 字符串型数据和整型数据相互转换 “10” 10
a) 字符串 转 数字 int num = Integer.parseInt(“10”);
b) 数字 转 字符串 String str = 10 + “”;

3) 输入输出

输出：
System.out.print(输出的内容); //不换行
System.out.println(输出的内容); //输出内容后换行
输入：
Scanner sc = new Scanner(System.in);//简易的文本扫描器
int I = sc.nextInt();//获取输入的整数
float f = sc.nextFloat();//获取输入的单精度浮点数
double d = sc.nextDouble();//获取输入的双精度浮点数
String s = sc.next();//获取输入的字符串

代码提示配置
参考https://www.cnblogs.com/zgqys1980/p/5067337.html
主动触发代码提示的快捷键：Alt + /
字体大小配置
Window->preferences->搜索”font”->选择”Colors and Fonts”->选择右侧列表中Basic下的Text Font,然后点击编辑（Edit）按钮，修改你想要的字体大小即可。

4) 常量

符号常量：final double PI = 3.1415926;
字面常量：10、2.5、’a’

5) 运算符

1. 算术运算符

+、-、*、/、%、++（前/后）、–（前/后）

注意：
/ 当两个运算数为整数时，为取整运算。
/ 当两个运算符不全为整数时，为除法运算。

c = a++;//先把a的值赋给c,然后a再自增
c = ++a;//先把a的值自增，然后把a赋给c

2. 关系运算符

、<、>=、<=、==、!=

由关系运算符构成的关系表达式，返回值为布尔值，即true/false.

3. 逻辑运算符

&&（短路与）、||（短路或）、!、&（非短路与）、|（非短路或）、^（异或）

逻辑运算符，用于连接关系表达式（boolean），最终的结果，也是布尔值（boolean）。

4. 位运算符

5. 赋值运算符

=、+=、-=、*=、/=、%=

a += 10；// 等价于 a = a + 10;

6. 条件运算符

表达式1?表达式2：表达式3;

“表达式1”是一个结果为布尔值的逻辑表达式。也就是返回值为true/false
运算规则：
如果表达式1返回true,则整个表达式的返回值为表达式2；否则返回表达式3；

7. 字符串运算符

其实就是对字符串进行拼接。

8. 运算符的优先级

. [] ()
算术运算符
关系运算符
逻辑运算符
条件运算符
赋值运算符

6) 流程控制语句

1. 顺序结构

2. 分支结构

1. 单分支if
2. 双分支if…else…
3. 多分支
   a) If…else if…else if…else
   b) Switch(表达式){case 值1：break; default:break;}
4. 分支结构嵌套

3. 循环结构

1. While
2. Do…while
3. For
4. Foreach增强for循环

4. 跳转语句

break;//结束循环
continue;//退出本次循环，进入下一次
return;//退出方法

7) 数组

1. 数组的定义

	（1）int[] scores;//声明
	     scores = new int[45];//初始化
	
	（2）int[] scores = new int[45];//声明数组的同时初始化
	
	（3）静态初始化
		int[] arr = new int[] {1,2,3,4,5,6};
		int[] arr =  {1,2,3,4,5,6};

2. 数组的赋值

		scores[0] = 10;
		scores[1] = 15;

3. 数组的常用操作

	数组遍历
	数组最值（最大值，最小值）
	数组排序（冒泡排序，选择排序）
	数组元素的删除，修改

4. Arrays

	排序 sort
	查询 binarySearch
	复制 copyOf
	转字符串 toString
	填充 fill

8) 方法

1. 方法的定义

[修饰符] 返回值类型 方法名([参数类型 参数名1，参数类型 参数2…]){
//方法体
}

例子：

public static void printStar(int line,int column) {
		
		for(int i = 0;i < line;i++) {
			//打印第i行： 
			//打印j个星号
			for(int j=0;j<column;j++) {
				System.out.print("*");
			}
			//打印换行
			System.out.println();
		}
}

2. 方法的分类

（1） 无返回值无参数

public class Demo02 {
	public static void main(String[] args) {
		welcome();
	}
	
	public static void welcome() {
		System.out.println("**************");
		System.out.println("***  欢迎光临   ***");
		System.out.println("**************");
	}
}

（2） 无返回值有参数

public class Demo03 {
	public static void main(String[] args) {
		welcome("Hello");
	}
	
	public static void welcome(String content) {
		System.out.println("**************");
		System.out.println("***  "+content+"  ***");
		System.out.println("**************");
	}
}

（3） 有返回值无参数

public class Demo04 {
	public static void main(String[] args) {
		int num = getNum();
		//System.out.println(num);
		
	}
	
	//有返回值
	public static int getNum() {
		//创建随机类
		Random rad = new Random();
		//int n = rad.nextInt(); //获得一个随机数
		int n = rad.nextInt(); //获得一个bound范围之内的随机数， 10   [0,10)   n>=0  n<10
		return n;
	}
}

（4） 有返回值有参数

public class Demo05 {
	public static void main(String[] args) {
		int sum = add(8, 5);
		System.out.println(sum);
	}
	
	//加法
	public static int add(int n1,int n2) {
		int result = n1 + n2;
		return result;
	}
}

节点2：Java面向对象编程

1. 面向对象编程思想

与面向过程编程思想的区别：
可以拿生活中的实例来理解面向过程与面向对象，例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用不同的方法来实现。

如果是面向对象的设计思想来解决问题。面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。

2. 类和对象的概念：

• 对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。（具体）
• 类：类是一个模板，它描述一类对象的行为和状态。（抽象）

3. 类的设计

1) 类的构成：

（1）成员变量
（2）成员方法
（3）构造方法
特点：
1.构造方法的方法名必须和类名一致。
2.没有返回值类型。
（4）类成员

1. 类变量（静态变量） 访问： 类名.类变量
2. 类方法（静态方法） 访问： 类名.类方法()
3. 静态代码块

/*
 * 类的设计
 * 1）成员变量
 * 2）成员方法
 * 3）构造方法
 * 
 * 4）类成员
 * 	 a.类变量
 * 	 b.类方法
 * 	 c.静态代码块
 * 
 * 
 * 类,其实一种用户自定义的数据类型。
 * 
 * 编码规范：驼峰命名法
 */
public class Student {
	
	//1.成员变量
	String name;
	String sex;
	int age;
	
	//2.成员方法
	public void study() {
		System.out.println(name+"在学Java,在"+school);//成员方法可以访问类变量，但类方法不能访问成员变量。
	}
	
	public void playGame() {
		System.out.println(name+"在玩王者荣耀");
	}
	
	//3.构造方法
	/*
	 * 特点：
	 * 1.构造方法的方法名要和类名一致。  
	 * 2.没有返回值类型。
	 * ---3.一般情况下，用public来修饰。
	 */
	public Student() {
		System.out.println("--构造方法执行--");
		count++;
	}
	
	
	
	//4.类变量(静态变量)
	static String school;
	static int count;//当前类的对象个数
	
	//5.类方法（静态方法）
	public static void count() {
		System.out.println("学校共有"+ count+"个学生 。");
	}
	
	//6.静态代码块
	static {
		//对类进行初始化
		count = 0;
		System.out.println("--学校构建完成。--");
	}
}

2) 参数的传递（值传递）

基本数据类型：变量值
引用数据类型：内存值

了解：InstanceOf:判断某个对象是否是某个类的对象。 S1 instanceof Student

3. 方法重载
   方法重载的特点：

1. 在同一个类中

2. 方法名相同

3. 参数的个数或者类型不同
   public class Actor {
   String name;

   //表演
   public void act() {
   System.out.println(“唱歌”);
   }

   public void act(String instrument) {
   System.out.println(“边弹” + instrument +“边唱”);
   }

   public void act(int n) {
   System.out.println(“循环唱” + n +“次”);
   }
   }

   方法重载，包括：

4. 成员方法重载

5. 构造方法重载。
   public class Actor {
   //成员变量
   String name;
   String sex;
   int age;

   //成员方法 重载
   public void act() {
   System.out.println(“唱歌”);
   }

   public void act(String instrument) {
   System.out.println(“边弹” + instrument +“边唱”);
   }

   public void act(int n) {
   System.out.println(“循环唱” + n +“次”);
   }

   //构造方法 重载
   public Actor() {
   }

   public Actor(String actorName) {
   name = actorName;
   }

   public Actor(String actorName,String actorSex) {
   name = actorName;
   sex = actorSex;
   }

   public Actor(String actorName,String actorSex,int actorAge) {
   name = actorName;
   sex = actorSex;
   age = actorAge;
   }
   }

   补充：可变参数
   //求整数的和(可变参数)
   public int add(int… nums) {
   int sum = 0;
   for (int i = 0; i < nums.length; i++) {
   sum = sum + nums[i];
   }
   return sum;
   }

4. this
   this指当前类的对象
   public Actor(String name,String sex,int age) {
   this.name = name;//当前要创建的对象的name属性 = name参数;
   this.sex = sex;
   this.age = age;
   }
   通过this关键字
   1.可以调用当前类的成员变量。
   2.可以调用当前类的成员方法。
   3.可以调用当前类的构造方法。
   public class Student {
   String name;
   String sex;

   public void study() {
   System.out.println(this.name+“在学习”);//1.通过this调用成员变量
   }

   public void race() {
   this.study();//2.通过this调用成员方法
   System.out.println(“参加比赛！”);
   }

   public Student() {

   }

   public Student(String name){
   this();//3.通过this调用无参构造
   this.name = name;
   }
   }

节点3：封装，继承，多态

1. 封装
   实现步骤：
   (1)属性私有化 (2)提供公共的getter,setter方法
   自动生成get,set方法：右键—>Source—>Generate Getters and Setters

public class Actor {
	//成员变量
	private String name;
	private String sex;
	private int age;
	
	//提供公共的get,set方法
	public void setName(String name) {
		this.name = name;
	}
	
	public String getName() {
		return this.name;
	}
	
	public void setSex(String sex) {
		if (sex.equals("男") || sex.equals("女")) {
			this.sex = sex;
		}else {
			System.out.println("您设置的性别有误！");
		}
	}
	
	public String getSex() {
		return this.sex;
	}
	
	public void setAge(int age) {
		if (age < 0 || age > 130) {
			System.out.println("您设置的年龄有误！");
		}else {
			this.age = age;
		}
		
	}
	
	public int getAge() {
		return this.age;
	}
	
	//成员方法 重载
	public void act() {
		System.out.println("唱歌");
	}
	
	public void act(String instrument) {
		System.out.println("边弹" + instrument +"边唱");
	}
	
	public void act(int n) {
		System.out.println("循环唱" + n +"次");
	}
	
	//构造方法  重载
	public Actor() {
	}
	
	public Actor(String name) {
		this.name = name;
	}
	
	public Actor(String name,String sex) {
		this.name = name;
		this.sex = sex;
	}
	
	public Actor(String name,String sex,int age) {
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
}

2. 继承

1. 继承的概念：
   可以基于已经存在的类构造一个新类。继承已经存在的类就可以复用这些类的方法和域。在此基础上，可以添加新的方法和域，从而扩充了类的功能。

   继承的关键字：extends

2. 继承的特点：

   1. 可以实现代码的复用—子类拥有父类非私有的属性和方法。
   2. 子类可以对父类进行扩展—子类可以拥有自己的属性和方法。
   3. 方法重写—子类可以用自己的方式去实现父类的方法。
   4. 单继承，可以多重继承
   5. 缺点：提高了代码的耦合度。

例子：
定义父类：

public class Animal {
	//父类定义子类共有的属性和行为
	String name;
	String sex;
	int age;
	String color;
	
	public void eat() {
		System.out.println(name + "吃东西");
	}
}

定义子类-Cat：

public class Cat extends Animal{
	//猫类特有的行为
	public void catchMouse() {
		System.out.println(name+ "抓老鼠...");
	}
}

定义子类-Dog：

public class Dog extends Animal {
	//狗类特有的行为
	public void guard() {
		System.out.println(name + "看家");
	}
	
}

3. 修饰符
   （1） 访问修饰符
   a) public:所有类都可以访问。 (当前类，同一个包中的不同类，不同包的类)
   b) protected：包的访问权限+不同包的子类 (当前类，同一个包中的不同类,不同包的子类)
   c) 缺省:包的访问权限。 (当前类，同一个包中的不同类)
   d) private:当前类 (当前类)
   （2） 非访问修饰符
   a) static
   i. 修饰成员变量，则成员变量变为类变量。static String school = “莱职”;
   ii. 修饰成员方法，则成员方法变为类方法。
   iii. 修饰代码块，则代码块变为静态代码块。特点：是在main方法之前运行，而且只运行一次。其实就是在类加载时运行。
   b) final
   i. 修饰变量，则变量变成不可改变的量，即常量。 final int num = 10;
   ii. 修饰方法，则方法变为不可重写的方法。
   iii. 修饰类，则类变为不可继承的类。
   c) abstract 抽象
4. 方法重写
   特点：
   1.要有继承，重写发生在两个类之间，子类去重写父类的同名的方法
   2.子类的方法名要和父类的方法名相同，而且参数（个数，类型）也要完全一致。
   3.子类对方法的修饰，只能扩大，不能缩小。

父类：

public class Animal {
	//域（成员变量）
	String name;
	String sex;
	int age;
	String color;
	
	//方法（成员方法）
	public void eat() {
		System.out.println(name + "吃东西");
	}
}

子类：

public class Cat extends Animal{
	//特有的行为（扩展）
	public void catchMouse() {
		System.out.println(name+ "抓老鼠...");
	}
	
	//子类可以重写从父类继承而来的方法
	public void eat() {
		System.out.println(name+"吃鱼");
	}
}

5. Super
   Super:指的是当前对象的父类

public class Dog extends Animal {
	//特有的行为（扩展）
	public void guard() {
		System.out.println(name + "看家");
	}
	
	//方法重写  --- 注解
	@Override
	public void eat() {
		super.eat();//调用超类（父类）的eat方法
		System.out.println(super.name+"啃骨头");//调用超类（父类）的name属性
	}
}

通过super关键字
1.可以调用父类的成员变量 super.property;
2.可以调用父类的成员方法 super.method();
3.可以调用父类的构造方法 super();

注意：子类默认会调用父类的无参构造，如果显式的调用了父类的有参构造，则不会再调用父类的无参构造。

3. 多态
   多态的三个必要条件：
   1．继承
   2．重写
   3．父类引用指向子类对象（上转型对象）

节点4：抽象类和接口

1. 抽象类

1. 定义抽象类：
   abstract class Person{
   //可以包含抽象方法
   }

class Student extends Person{
//子类继承抽象类，要去重写父类的抽象方法。
}

2. 特点：
   1.抽象类不一定包含抽象方法，但包含抽象方法的类，一定是抽象类。

2. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
   3.抽象类不能实例化。
   4.抽象类只能作为子类的超类（父类），被用来创建继承层级里子类的模板。
   5.Java中只有单继承。
3. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
4. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。
   抽象类存在的意义，就是被继承。
5. 接口

1. 语法 ：
   [可见度] interface 接口名称 [extends 其他的接口名] {
   // 声明变量
   // 抽象方法
   }

示例：

/*
 * 1.普通类
 *  只能包含非抽象方法。
 */
public class Student {
	//属性
	String name;
	String sex;
	int age;
	//方法
	public void study() {
		System.out.println("学习");
	}
}

/*
 * 2.抽象类
 *    可以包含抽象方法，非抽象方法，也可以不包含任何方法。
 */
public abstract class Animal {
	//属性
	String name;
	//方法
	public abstract void eat();
	
	public void bark() {
		System.out.println("叫。。。");
	}
}

/*
 * 3.接口
 * 	只能有抽象方法。
 */
public interface Work {
	//属性(默认用public static final修饰)
	int count = 0;//注意：接口中的静态常量，一定要赋初值。
	//方法（默认用public abstract修饰）
	void work();//抽象方法前的public abstract修饰符可以省略
	public abstract void earnMoney();
}

2. 接口的实现：

public class Teacher implements Work {

	@Override
	public void work() {
		System.out.println("上课");
	}

	@Override
	public void earnMoney() {
		System.out.println("拿课时费");
	}

}

3. 特点：
   抽象类是一种特殊的类。接口是一种特殊的抽象类。
   接口是一个抽象方法的集合。、
   Java中，对于类来说，只有单继承，但对于接口来说，可以多继承。
   定义接口的关键字：interface

4. 标记接口
   标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。
   标记接口作用：简单形象的说就是给某个对象打个标（盖个戳），使对象拥有某个或某些特权。
   示例：

package java.util; 
public interface EventListener {}

节点5：Object类和常用API

1. Object
   Object类是所有类的父类。

1. 常用方法：
   （1） hashcode() 返回哈希值
   （2） equals() 判断对象是否相等
   自动生成方式：在代码中，右键，选择”source”->”Genareate hashcode() and equals()”
   （3） getClass() 返回此Object的运行时类。
   （4） toString() 返回对象的字符串形式
   自动生成方式：在代码中，右键，选择”source”->”Genareate toString() ”

2. String（不可变性）

1. 创建字符串（构造方法）
   （1） String str0 = “Hello”;//字符串常量
   （2） String str1 = new String(“Hello”);//通过String构造方法
   （3） String str2 = new String(char[] cs);//通过字符数组构造字符串
   了解String的11种构造方法

2. 操作字符串（常用方法）
   （1） charAt(int index) 返回指定索引处的字符
   （2） indexOf(String s) 查找字符在字符串中第一次出现的位置
   （3） lastIndexOf(String) 查找字符在字符串中最后一次出现的位置
   （4） contains(String s) 判断是否包含字符序列
   （5） substring(int beginIndex)
   从beginIndex位置截取子字符串，一直扩展到字符串末尾
   （6） substring(int beginIndex,int endIndex) [begin,end)
   从beginIndex位置截取子字符串，一直到endIndex位置，不包括endIndex.
   （7） trim() 去除前后空格！
   （8） replace(char oldChar,char newChar) 替换
   （9） split(String s) 字符串分割
   （10） equals() 判断字符串内容是否相同
   （11） equalsIgnoreCase() 忽略大小写判断相等
   （12） matches(正则表达式)
   （13） length() 返回字符串的字符数（长度）
   （14） isEmpty() 判断字符串是否为空字符串
   （15） static valueOf(各种数据类型) 返回各种数据类型的字符串形式
   （16） toCharArray() 字符串 转 字符数组
   （17） getBytes() 字符串 转 字节
   （18） toLowerCase() 转小写
   （19） toUpperCase() 转大写
   （20） concat() 字符串拼接 +
   （21） format() 格式化字符串 %f %d %s

3. 正则表达式
   （1）匹配位置
   ^ 匹配字符串开始的位置。
   $ 匹配字符串结束的位置。
   （2）匹配字符
   .(点号) 匹配任意一个字符
   \ 将下一字符标记为特殊字符
   \s 匹配任意空白字符（空格，\f换页符\n换行符\r回车符\t制表符\v垂直制表符）
   \S 匹配任意非空白字符
   \d 匹配任意数字
   \D 匹配非数字
   \w 匹配任何字类字符。等价于[A-Za-z0-9_]
   \W 匹配任何非字类字符。等价于[^A-Za-z0-9_]
   （3）匹配字符范围
   x|y 匹配x或y.
   [xyz] 匹配包含的任一字符。
   [^xyz] 匹配未包含的任一字符。
   [a-z] 匹配字符范围。
   [^a-z] 匹配反向范围字符
   （4）匹配次数

   •    匹配前面的字符1-n次
     

   •    匹配前面的字符0-n次
     

   ? 匹配前面的字符0-1次
   {n} 匹配前面的字符正好n次
   {n,} 匹配前面的字符至少n次
   {n,m} 匹配前面的字符至少n次，至多m次。

   总结：正则表达式，可以用于匹配matches()，替换replace()和分割split()。

4. StringBuffer 、StringBuilder
   StringBuffer sBuffer = new StringBuffer(“Hello”);
   System.out.println(sBuffer);
   sBuffer.append(“World!”); //在末尾追加字符 //0123456789
   System.out.println(sBuffer); //HelloWorld!
   sBuffer.delete(3, 5); //删除多个字符（指定范围） [3,5)
   System.out.println(sBuffer); //HelWorld!
   sBuffer.deleteCharAt(0);//删除单个字符（指定位置）
   System.out.println(sBuffer);//elWorld!
   sBuffer.insert(2, “123456”);//在指定位置，插入内容
   System.out.println(sBuffer);//el123456World!
   sBuffer.reverse();//倒序
   System.out.println(sBuffer);
   sBuffer.setCharAt(0, ‘A’);//修改指定位置的字符
   System.out.println(sBuffer);
   StringBuffer中包含很多自己特有方法，也包含一些类似String类中的方法。比如（subString,indexOf,charAt）
   StringBuilder和StringBuffer的方法，基本完全相同。

总结：
　　String：适用于少量的字符串操作的情况
　　StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
　　StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

3. 日期时间类

1. Date
   Date date = new Date();//获取当前时间

2. SimpleDateFormat
   (1)Date转String
   SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日 hh时mm分ss秒 SSS E D”);
   String strDate = sdf.format(date);
   System.out.println(strDate);
   (2)String转Date
   String str = “2018年10月01日 10:30:30”;
   SimpleDateFormat sdf2 = new SimpleDateFormat(“yyyy年MM月dd日 hh:mm:ss”);
   Date date2 = sdf2.parse(str);//异常
   System.out.println(date2);

   获得系统时间的毫秒数
   long start = System.currentTimeMillis( );
   long end = date.getTime();

3. Calendar
   //获取Calendar对象
   Calendar c = Calendar.getInstance();
   System.out.println©;

   //修改Calendar的时间
   //c.set(2009, 6-1, 12);
   
   //获取日期的部分信息--年份
   System.out.println(c.get(Calendar.YEAR));
   System.out.println(c.get(Calendar.MONTH));
   System.out.println(c.get(Calendar.DAY_OF_MONTH));
   
   
   System.out.println(c.get(Calendar.DAY_OF_WEEK));
   
   System.out.println(c.get(Calendar.HOUR));
   System.out.println(c.get(Calendar.HOUR_OF_DAY));
   
   //单独设置属性值
   c.set(Calendar.YEAR, 2009);
   
   c.add(Calendar.YEAR, 5);
   c.add(Calendar.MONTH, 2);
   
   System.out.println(c.get(Calendar.YEAR));//2014
   System.out.println(c.get(Calendar.MONTH));//5
   
   //判断闰年
   GregorianCalendar gc = new GregorianCalendar();
   System.out.println(gc.isLeapYear(1900));
   

4. 包装类
   //包装类 （Byte,Short,Integer,Long Float,Double Character Boolean）
   //基本数据类型（byte,short,int,long float,double char boolean）

   //面向对象编程
   int num0 = 10;//数字
   Integer num1 = new Integer(20);//对象
   
   //Student student = new Student();
   
   //封箱（基本数据类型--->包装类）比如：int-->Integer
   Integer num2 = new Integer(num0);
   Integer num3 = Integer.valueOf(num0);
   
   //拆箱（包装类--->基本数据类型）比如：Integer-->int
   int num4 = num1.intValue();
   
   //自动封箱，拆箱
   Integer num6 = 10;
   int num5 = new Integer(10);
   
   //数值字符串   转成   基本数据类型   例子： "10"  -->  10
   String str = "10";
   System.out.println(str + 1);
   int num7 = Integer.parseInt(str);
   System.out.println(num7 + 1);
   
   String str2 = "2.5";
   System.out.println(str2 + 1);
   float f = Float.parseFloat(str2);
   System.out.println(f + 1);
   

5. 数学类
   //数学类
   System.out.println(Math.E);
   System.out.println(Math.PI);

   System.out.println(Math.abs(-10.25));//绝对值
   System.out.println(Math.sin(Math.PI/6));
   System.out.println(Math.cos(Math.PI/3));
   
   System.out.println(Math.ceil(2.5));//天花板
   System.out.println(Math.floor(2.5));//地板
   System.out.println(Math.round(2.26));//近似值
   
   System.out.println(Math.sqrt(9));//开平方根
   System.out.println(Math.cbrt(8));//开立方根
   System.out.println(Math.pow(3, 4));// 求幂
   
   System.out.println(Math.max(10, 8));//最大值
   System.out.println(Math.min(10, 8));//最小值
   
   System.out.println(Math.toDegrees(Math.PI/6));//弧度 转 角度
   System.out.println(Math.toRadians(30));//角度 转 弧度
   
   System.out.println(Math.random());//随机数   0<=x<1
   
   System.out.println(Math.multiplyExact(2, 3));//乘法
   System.out.println(Math.negateExact(10));//取反		
   

6. System和Runtime
   System.out.println(“Hello”);
   System.err.println(“Hello”);
   Scanner sc = new Scanner(System.in);
   //系统环境变量
   Map<String, String> map = System.getenv();
   for (String string : map.keySet()) {
   System.out.print(string+"😊;
   System.out.println(map.get(string));
   }
   System.out.println("===============");
   //系统属性
   Properties properties = System.getProperties();
   System.out.println(properties);
   System.out.println("------------------");

   Runtime runtime = Runtime.getRuntime();
   System.out.println("处理器的数量：" + runtime.availableProcessors());
   System.out.println("总内存数：" + runtime.totalMemory());
   
   //runtime.exec("C:\\Program Files (x86)\\Tencent\\TIM\\Bin\\QQScLauncher.exe");
   runtime.exec("notepad.exe");
   

节点6：泛型、集合应用技术

为什么要学习集合？
集合相比数组而言，集合的长度是可变的，但是数组是不可变的。

1. Collection-单列集合

1. List-列表（有序，可重复）
   数组：静态数组
   （1）ArrayList:动态数组（线程不同步，查询效率更高）

//int[] arr = new int[10];
//1.创建一个ArrayList(动态数组-可以自动扩展)
ArrayList list = new ArrayList();
//在没有指定泛型的时候，集合中可以添加任意类型的元素。
list.add(1);
list.add(2.5);
list.add('A');
list.add("Hello");
list.add(new Student());
list.add(6);
list.add(7);
list.add(8);
list.add(9);
list.add(10);
//集合是永远都填不满的，也就是可以自动扩展.
list.add(11);
list.add(12);
list.add(13);

System.out.println(list.toString());

//2.泛型（参数化类型）
ArrayList<String> iList = new ArrayList<String>();

//3.ArrayList的常用方法
//3.1添加元素到末尾
iList.add("tom");
iList.add("jack");
iList.add("rose");
iList.add("Kitty");
iList.add("Lufy");
//3.2在指定位置添加元素
iList.add(2, "Zoro");
System.out.println(iList);
//3.3删除指定位置的元素
iList.remove(0);
System.out.println(iList);
//3.4修改元素
iList.set(2, "Bluck");
System.out.println(iList);
//3.5获取元素
String s = iList.get(2);
System.out.println(s);

//3.6获取集合元素个数
System.out.println(iList.size());
//3.7判断集合是否为空
System.out.println(iList.isEmpty());
//3.8判断集合是否包含指定元素
System.out.println(iList.contains("Tomcat"));
//3.9查找元素在集合中的位置
int index = iList.indexOf("Lufy");
System.out.println("Lufy在集合的"+index+"号位置");
//3.10清空集合
iList.clear();
System.out.println(iList);
System.out.println("集合是否为空："+iList.isEmpty());
System.out.println("---ArrayList的遍历--方式一：");
//ArrayList的遍历--方式一
for (int i = 0; i < iList.size(); i++) {
	System.out.println(iList.get(i));
}
System.out.println("---ArrayList的遍历--方式二：");
//ArrayList的遍历--方式二
for (String string : iList) {
	System.out.println(string);
}
System.out.println("---ArrayList的遍历--方式三：");
//ArrayList的遍历--方式三（迭代器）
Iterator<String> iter = iList.iterator();//获取List的迭代器
while(iter.hasNext()) {//通过迭代器，判断是否有下一个元素
	String string = iter.next();//获取下一个元素
	System.out.println(string);
}

（2）Vector:（线程同步）[了解]
（3）LinkedList:链表（修改效率更高）
常用方法跟ArrayList基本相同。
不同之处：在性能方面。ArrayList适用于查询，LinkedList适用于增删改
2) Set-集合（无序，不可重复）
（1）HashSet:
//1.创建集合HashSet
HashSet hs = new HashSet();
System.out.print(“s1 equals s2:”);
System.out.println(s1.equals(s2));//true
//System.out.println(“String”.equals(“String”));
hs.add(1);
hs.add(2.5);
hs.add(‘A’);
hs.add(“String”);
hs.add(s1);
hs.add(s2);
hs.add(1);
hs.add(“String”);
//无序,不可重复
System.out.println(hs);

	//2.常用方法 和 泛型
	HashSet<String> sHashSet = new HashSet<String>();
	//2.1 添加
	sHashSet.add("tom");
	sHashSet.add("cat");
	sHashSet.add("rose");
	sHashSet.add("jack");
	System.out.println(sHashSet);
	//2.2删除
	sHashSet.remove("tom");
	System.out.println(sHashSet);
	//2.3判断是否包含某元素
	System.out.println(sHashSet.contains("jack"));
	//2.4获取集合的长度
	System.out.println(sHashSet.size());
	
	System.out.println("HashSet的遍历(迭代器):");
	//HashSet的遍历(迭代器)
	Iterator<String> iter = sHashSet.iterator();
	while(iter.hasNext()) {
		String string = iter.next();
		System.out.println(string);
	}

在HashSet类中，如果添加自定义类的对象，要求不可重复，需要在自定义类中重写hashCode()和equals()方法。
自动生成equals()方法的方式：右键SourceGenarate hashcode() and equals()…
2. Map-双列集合

1. HashMap（线程不安全）

创建HashMap双列集合///
		HashMap hm = new HashMap();//初始容量16  0.75
		hm.put(1, "张三");
		hm.put("102", 6);
		hm.put(2.5, 1);
		hm.put(101,new Student());
		
		//使用泛型//
		HashMap<Integer, Student> hmStudents = new HashMap<Integer, Student>();
		
		Student s1 = new Student();
		s1.setId(101);
		s1.setName("张三");
		Student s2 = new Student();
		s2.setId(102);
		s2.setName("李四");
		Student s3 = new Student();
		s3.setId(103);
		s3.setName("王五");
		Student s4 = new Student();
		s4.setId(104);
		s4.setName("赵六");
		/一、增删改查/
		//1.添加元素
		hmStudents.put(101, s1);
		hmStudents.put(102, s2);
		
		//4.获取元素
		Student s = hmStudents.get(103);
		System.out.println(s);

		//2.删除元素
		s = hmStudents.remove(102);
		System.out.println(s);
		
		//3.替换（修改）元素
		s = hmStudents.replace(101, s2);
		System.out.println(s);
		
		s = hmStudents.get(101);
		System.out.println(s);
		
		hmStudents.put(102, s1);
		hmStudents.put(103, s3);
		hmStudents.put(104, s4);
		//二、获取集合//
		//获取key的集合（第一列的集合）
		Set<Integer> set = hmStudents.keySet();
		System.out.println(set);
		//获取value的集合（第二列的集合）
		Collection<Student> cs = hmStudents.values();
		System.out.println(cs);
		//获取entry的集合（两个列的集合）
		Set<Entry<Integer, Student>> entries = hmStudents.entrySet();
		System.out.println(entries);
		//三、判断包含及其他
		//判断是否包含某个key
		boolean b = hmStudents.containsKey(102);
		System.out.println(b);
		//判断是否包含某个value
		boolean b2 = hmStudents.containsValue(s3);
		System.out.println(b2);
		//判断集合是否为空
		hmStudents.isEmpty();
		//清空集合
		//hmStudents.clear();
		
		/四、遍历（综合应用）///
		//HashMap的遍历
		System.out.println("遍历方法一：");
		Set<Integer> sIntegers = hmStudents.keySet();//获取第一列的集合
		Iterator<Integer> iterator = sIntegers.iterator();//获取第一列集合的迭代器
		while (iterator.hasNext()) {
			Integer key = (Integer) iterator.next();
			System.out.print(key+"=");//打印key
			Student stu = hmStudents.get(key);//根据key,获取value
			System.out.println(stu);
		}

2. Hashtable（线程安全，用法跟HashMap相同）

3. Collections-工具类
   排序 sort
   查询 binarySearch
   复制 copy
   随机排列 shuffle
   反转（逆序）reverse
   交换 swap
   填充 fill
   查找子列表 indexOfSubList()、lastIndexOfSubList()

节点7：异常和IO技术

1. 异常

1. 概念：
   异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。

2. 异常发生的原因：
   了解（物理错误，程序错误，用户错误）

3. 异常的分类：
   （1）检查性异常：（在编译时，不能被忽略，不可避免，必须处理）
   java.io.FileNotFoundException 文件未找到异常
   （2）运行时异常：（在编译时被忽略，是可能被程序员避免的异常，可以避免，可以不处理，发生时修改代码）
   java.lang.ArithmeticException 算术运算异常
   java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常

异常的类图

4. 异常处理：
   （1）积极处理-捕获处理
   try{
   //可能发生异常的代码
   }catch(发生异常的类型 异常对象名){
   //处理异常的代码
   }finally{
   //释放资源（无论是否发生异常，都会执行）
   }
   注意：异常的默认处理方式是，会终止程序。导致程序不能继续运行！！

异常对象的常用方法
void printStackTrace()
将此throwable和其追溯打印到标准错误流。
String
getMessage()
返回此throwable的详细消息字符串。

多个catch语句
（1）一个try语句块，可以跟多个catch语句，捕获多种异常。
（2）在catch语句中，异常类的父类Exception要放在后面。异常类的子类，放在前面。

（2）消极处理
抛出异常 throw:手动抛出异常
throw 异常对象；
声明抛出异常 throws:一般用于声明方法，可能会发生异常！
public static void divide() throws Exception{
…
}

自定义异常
了解：继承Exception
2. IO技术

1. File类
   概念：
   文件和目录路径名的抽象表示。

常用方法：
（1）创建：
1）文件 createNewFile()
2）目录 mkdir()：创建单级目录 mkdirs()：创建多级目录
（2）删除：delete()
（3）获取文件或文件夹属性
exists()：测试此抽象路径名表示的文件或目录是否存在。
getAbsolutePath()
getName()
getParent()
getPath()
isDirectory()
isFile()
isHidden()
lastModified()
list()
（4）文件或文件夹操作
renameTo(File dest)
2) 字节流
（1） 字节输出流（写）：OutputStream
实现类：

1. FileOutputStream
   构造方法：
   FileOutputStream(String name)
   FileOutputStream(File file)
   FileOutputStream(String name, boolean append):append为true,则表示追加文本
   FileOutputStream(File file, boolean append) append为true,则表示追加文本

注意：如果追加文本，需要换行。Window操作系统中要用”\r\n”
常用方法：

1. write(int b)写一个字节
2. write(byte[] b)写一个字节数组
3. write(byte[] b,int off,int len)写一个字节数组的一部分
4. close() 关闭流
5. BufferedOutputStream
   构造方法

常用方法

3. ObjectOutputStream
4. PrintStream
   构造方法

常用方法

（2） 字节输入流（读）：InputStream
实现类：

1. FileInputStream
   构造方法：
   FileInputStream(String name)
   通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
   FileInputStream(File file)
   通过打开与实际文件的连接创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
   常用方法：
   available()
   返回从此输入流中可以读取（或跳过）的剩余字节数的估计值，而不会被下一次调用此输入流的方法阻塞。
   read()
   从该输入流读取一个字节的数据。
   read(byte[] b)
   从该输入流读取最多 b.length个字节的数据为字节数组。
   read(byte[] b, int off, int len)
   从该输入流读取最多 len字节的数据为字节数组。
   close()
   关闭此文件输入流并释放与流相关联的任何系统资源。

2. BufferedInputStream
   构造方法

常用方法
3. ObjectInputStream

3. 字符流
   （1） 字符输出流（写）:Writer
   实现类：
   OutputStreamWriter:转换流（字符流字节流）

1. FileWriter

2. BufferedWriter

3. PrintWriter

（2） 字符输入流（读）:Reader
实现类：
InputStreamReader：转换流（字节流字符流）

1. FileReader

2. BufferedReader

节点8：JDBC

1. JDBC基本步骤

1. 什么是JDBC?
2. JDBC原理
3. JDBC核心类
   参考网址：https://www.cnblogs.com/qlqwjy/p/8227665.html

有：DriverManager、Connection、Statement，和ResultSet！
（1）DriverManger（驱动管理器）的作用有两个：
　　l 注册驱动： DriverManager.registerDriver(new Driver());
　　l 获取Connection： DriverManager.getConnection(String url,String user,String password)
（2）Connection对象表示连接，与数据库的通讯都是通过这个对象展开的：
l Connection最为重要的一个方法就是用来获取Statement对象；
（1） Statement createStatement()
（2） PreparedStatement prepareStatement(sql);
（3）Statement是用来向数据库发送SQL语句的，这样数据库就会执行发送过来的SQL语句
　　l void executeUpdate(String sql)：执行更新操作（insert、update、delete等）；
　　l ResultSet executeQuery(String sql)：执行查询操作，数据库在执行查询后会把查询结果，查询结果就是ResultSet；
（4）ResultSet对象表示查询结果集，只有在执行查询操作后才会有结果集的产生。结果集是一个二维的表格，有行有列。操作结果集要学习移动ResultSet内部的“行光标”，以及获取当前行上的每一列上的数据：
　　l boolean next()：使“行光标”移动到下一行，并返回移动后的行是否存在；
　　l XXX getXXX(int col)：获取当前行指定列上的值，参数就是列数，列数从1开始，而不是0。
2. JDBC-CRUD（Statement）
void executeUpdate(String sql)—执行增删改
ResultSet executeQuery(String sql)—执行查询
3. PreparedStatement
优点：（1）防止SQL注入。（2）效率更高。

【结论】：实际开发中，推荐使用PreparedStatement！！！
4. 自定义工具类

package com.ambow.dbwork;
import java.sql.*;
/*
    JDBC连接数据库的工具类---自定义工具类【了解，自己能写】
        //1. 获取数据库连接
        //2. 释放资源
 */
public class JDBCUtils {
    private static String DRIVERNAME = "com.mysql.jdbc.Driver";
    private static String URL = "jdbc:mysql://localhost:3306/db_book";
    private static String USER = "root";
    private static String PWD = "root";

    //1. 获取数据库连接
    public static Connection getConnection(){
        Connection conn = null;
        //1.加载驱动
        try {
            Class.forName(DRIVERNAME);
            //2.获取数据库连接
            conn = DriverManager.getConnection(URL, USER, PWD);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }
    //2. 释放资源
    public static void closeAll(Connection conn, Statement stmt, ResultSet rs){
        if (rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

5. 数据库连接池
   （1） c3p0
   参考网址：https://blog.csdn.net/HeiSeHuoEr/article/details/89537080
   （2） druid-阿里【推荐】
   参考网址：https://blog.csdn.net/Dear_UU/article/details/89370491

package com.ambow.jdbc;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

public class DruidUtils {
    //Druid德鲁伊,据说是魔兽世界中的一个角色,森林女神
    public static DruidDataSource dataSource;//数据库连接池

    //1.初始化Druid连接池
    static {
        //第二种方式:使用软编码通过配置文件初始化
        try {
            Properties properties = new Properties();
            //通过类加载器加载配置文件
            InputStream inputStream = DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");
            properties.load(inputStream);
            //创建连接池
            dataSource = (DruidDataSource) DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //2.获取连接
    public static Connection getConnection() {
        try {
            return dataSource.getConnection();//从连接池中获取连接
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    //3.释放资源
    public static void closeAll(Connection connection, Statement statement, ResultSet resultSet) {
        //释放resultSet
        try {
            if (resultSet != null) {
                resultSet.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        //释放Statement
        try {
            if (statement != null) {
                statement.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        //释放Connection
        try {
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

}

6. Apache DBUtils工具类/Spring JDBCTemplate
   参考网址：https://blog.csdn.net/HeiSeHuoEr/article/details/85157546

JDK8新特性：
lambda表达式
https://www.liaoxuefeng.com/article/001411306573093ce6ebcdd67624db98acedb2a905c8ea4000
全新的Stream API
https://www.liaoxuefeng.com/article/001411309538536a1455df20d284b81a7bfa2f91db0f223000
JDK11新特性解读
https://www.liaoxuefeng.com/article/0015419379727788f4e146b6fb1409dbaa7ad35db2560fc000

廖雪峰SQL教程
https://www.liaoxuefeng.com/wiki/001508284671805d39d23243d884b8b99f440bfae87b0f4000