Java程序编程（十）

面向对象设计7大原则

第二章 Java语言基础与流程控制

TowCase-1 1

1、向控制台输出字符串

 System.out.print("Welcome java!");

2、数据类型

（1）基本数据类型

A、整型：int

二进制

八进制

十六进制

十进制

长整型：long 数值后加L

B、单字符型：char 可以表示汉字数值用单引号

C、float和double可能存在精度丢失

单精度浮点：float

双精度浮点：double

D、布尔型：boolean

         //一、数据类型
         //1、基本数据类型
         int a = 0b1101; //二进制
         int b = 0123;   //八进制
         int c = 0xAB;   //十六进制
         int d = 123;    //十进制
         
         //向控制台输出
         System.out.println(a);
         System.out.println(b);
         System.out.println(c);
         System.out.println(d);
         
         long number = 1000l;//后加L表示长整型
         System.out.println(number);
         
         //单字符型：可以表示汉字
         char c1 = 'A',c2 = '男'; //单引号
         System.out.println(c1+" "+c2);
         
         //float和double可能存在精度丢失
         float num1 = 1.555555f;//单精度浮点
         double num2 = 1.555555f;//双精度浮点
         System.out.println(num1);
         System.out.println(num2);
         
         //布尔型
         boolean b1 = true,b2 = 10>20;
         System.out.println(b1);
         System.out.println(b2);

（2）对象数据类型：String

 //2、对象数据类型
         String name = "tom";
         String name2 = new String("jack");
         System.out.println(name);
         System.out.println(name2);

3、类型转换

         //3、类型转换 
         //(1)byte<short<int<long<....
         int a1 = 100;

(1)byte<short<int<long<....

         //(1)byte<short<int<long<....
         int a1 = 100;

(2)自动转换：左边类型大 = 右边类型小

         //(2)自动转换：左边类型大 = 右边类型小
         float f1 = a1 + 200;
         double d1 = f1+1.5;

(3)强制转换：左边类型小 = （目标类型）右边类型大

         //(3)强制转换：左边类型小 = （目标类型）右边类型大
         int a2 = (int)(f1+1.5);
         char c3 = (char)a2;
         char c4 = (char)65.5;

4、变量

（1）定义变量

变量的值是可以变化的

         //二、变量
         //（1）定义变量
         int studentId = 1;
         String studentName = "zhangsan";
         studentId = 2;//变量的值是可以变化的
         System.out.println("studentId");

（2）定义常量：固定不变的量，常量名全部大写，多个单词用下划线隔开

A、定义常量关键字：final

常量值不能被修改

B、变量必须赋值后才能使用

		//（2）定义常量：固定不变的量，常量名全部大写，多个单词用下划线隔开
		//A、定义常量关键字：final
		final float PI = 3.14f;
		final String SCHOOL_NAME = "南方IT";
		//PI = 3.1415f;//错误的，常量值不能被修改
		System.out.println(PI);
		System.out.println(SCHOOL_NAME);
		
		//B、变量必须赋值后才能使用
		//int a;
		//System.out.println(a);

5、变量的作用域:

		//3、变量的作用域:
		if(true) {
			int  x = 100;
			System.out.println(x);
		}

6、扫描仪：Scanner

TowCase-2 1

步骤

（1）导入

（2）定义一个扫描仪

（3）输入一个人的学号、姓名、身高

A、接受整数

B、接受字符串

C、接受单精度

（4）输出

（5）关闭扫描仪

import java.util.Scanner;//导入

public class BBB {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//System.out：输出流对象
		//System.in：输入流对象
		//定义一个扫描仪
		Scanner input = new Scanner(System.in);
		
		//输入一个人的学号、姓名、身高
		System.out.println("请输入学号:");
		int studenId = input.nextInt();//接受整数
		
		//*input.nextLine();
		System.out.println("请输入姓名:");
		String studenName = input.next();//接受字符串 //*nextLine();
		
		System.out.println("请输入身高:");
		float studenHeight = input.nextFloat();//接受单精度
		
		//输出
		System.out.println("学号:"+ studenId);
		System.out.println("姓名:"+ studenName);
		System.out.println("身高:"+ studenHeight);
		
		input.close();//关闭扫描仪
	}

}

7、运算符

（1）单目运算符

（2）双目运算符

（3）三目运算符

（4）运算符优先级，从高到低

（5）转义字符

/*
 * 运算符：根据需要的操作数个数不同，还分成：
 * 单目运算符:  ++、--、!
 * 双目运算符:  大多数都是双目
 * 三目运算符:  ?:
 * 
 * 运算符优先级，从高到低
 * 		()、前缀++、前缀--、!
 * 		*、/、%
 *  	+、-
 *  	关系运算
 *  	&&、 ||
 *  	?:
 *  	赋值运算
 *  	后缀++、后缀--
 *  
 *  转义字符：\n、\t、\"、\'、\\
 */

TwoCase-3 2 SecDemo

（1）赋值运算符: =、 +=、-=、*=、\=、%=

		//赋值运算符: =、 +=、-=、*=、\=、%=
		
		int a = 10 ;
		a += 100;    // a = a + 100
		System.out.println(a); // 110
		
		
		a *= 2 + 1;
		System.out.println(a); // 330

（2）算术运算符：+、-、*、/、%、++、--

A、+ : 加法、字符串连接

B、/：除数

除数不能为整数0

Infinity 正无穷大

-Infinity 负无穷大

非数字

C、%：求余数，取模运算 (商为整数，剩下部分就是余数)

D、 ++、--：后缀、前缀

后缀优先级最低，最后算

前缀优先级很高，要先算

		// 算术运算符：+、-、*、/、%、++、--
		
		// + : 加法、字符串连接
		int a = 10 + 20;
		String b = "10" + 20;
		
		System.out.println(a);  // 30
		System.out.println(b);  // 1020
		
		/// /：除数
		// int c = 10 / 0;  // 除数不能为整数0
		// System.out.println(c);
		
		float c = 10 / 0.0f;
		System.out.println(c); // Infinity 正无穷大
		
		float d = -10 / 0.0f;
		System.out.println(d); // -Infinity 负无穷大
		float e = 0 / 0.0f;
		System.out.println(e); // NaN (not a number) : 非数字
		
		// %： 求余数，取模运算 (商为整数，剩下部分就是余数)
		int num1 = 10 % 3;
		float num2 = 12.5f % 3.5f;
		System.out.println(num1);  // 1
		System.out.println(num2);  // 2.0
		// 判断m能否被n整除:    m % n == 0
		
		// ++、--：后缀、前缀
		int x = 10;
		x++; // 后缀     x = x + 1
		++x; // 前缀
		System.out.println(x);  //x = 12
		
		int y = x++;  // 后缀优先级最低，最后算
		System.out.println("x=" + x);  // 13
		System.out.println("y=" + y);  // 12
		
		int z = ++x;  // 前缀优先级很高，要先算
		System.out.println("x=" + x);  // 14
		System.out.println("z=" + z);  // 14

（3）关系运算符: >、>=、<、<=、==、!=

浮点型可能会产生精度丢失，所以一般等于的比较不用于浮点型数据

		// 关系运算符: >、>=、<、<=、==、!=
		boolean b1 = 10 > 20;
		System.out.println(b1); // false
		
		boolean b2 = 10 <= 20;
		System.out.println(b2); // true
		
		boolean b3 = 10 == 20;
		System.out.println(b3); // false
		
		// 浮点型可能会产生精度丢失，所以一般等于的比较不用于浮点型数据
		boolean b4 = 0.1 + 0.2 == 0.3;
		System.out.println(b4); // false
		System.out.println(0.1 + 0.2);
		System.out.println(0.3);

（4）逻辑运算符： &&、||、!

短路运算

与运算第一个式子不成立，后面式子不计算

或运算第一个式子成立，后面式子不计算

		// 逻辑运算符： &&、||、!
		
		// 短路运算:
		// 与运算第一个式子不成立，后面式子不计算
		System.out.println(10 > 100 && 10 > 0); // false
		
		// 或运算第一个式子成立，后面式子不计算
		System.out.println(10 < 100 || 10 > 500); // true
		System.out.println(!(10 < 20));

（5）条件运算符

（1）表达式1?表达式2:表达式3

当表达式1成立时，将表达式2作为结果；当表达式1不成立时，将表达式3作为结果。相当于if...else结构

（2）<< ：左移位数 << ：右移位数

		// 条件运算符:  
		
		// 表达式1?表达式2:表达式3
		// 当表达式1成立时，将表达式2作为结果
		// 当表达式1不成立时，将表达式3作为结果
		// 相当于if...else结构
		
		int max = 10 > 20 ? 10 : 20;
		System.out.println("最大值:\n" + max);
		
		// System.out.println(5<<3);  // 左移3位
		// 00000101
		
	}
}

8、if有3种形式

输入两个数，判断两个的关系

（1）if第一种形式

嵌套结构

（2）if...else:第二种形式

（3）if...else if结构：第三种形式

		import java.util.Scanner;//导入
		
		// if有3种形式
		// 输入两个数，判断两个的关系
		Scanner scanner = new Scanner(System.in);
		
		System.out.println("输入第一个数:");
		int number1 = scanner.nextInt();
		
		System.out.println("输入第二个数:");
		int number2 = scanner.nextInt();
		scanner.close();
		
		// if第一种形式
		if (number1 < number2) {
			System.out.println("number1 < number2");
		}
		
		if (number1 == number2) {
			System.out.println("number1 == number2");
		}
		
		if (number1 > number2) {
			System.out.println("number1 > number2");
		}
		
		// 嵌套结构
		/*if (number1 >= 0) {
			if (number1 <= 100) {
				System.out.println("number1在0~100之间");
			}
		}*/
		
		
		// if...else:第二种形式
		if (number1 < number2) {
			System.out.println("number1 < number2");
		} else {
			if (number1 == number2) {
				System.out.println("number1 == number2");
			} else {
				System.out.println("number1 > number2");
			}
		}
		
		// if...else if结构：第三种形式
		if (number1 < number2) {
			System.out.println("number1 < number2");
		} else if (number1 == number2) {
			System.out.println("number1 == number2");
		} else {
			System.out.println("number1 > number2");
		}

9、switch:开关语句

		import java.util.Scanner;//导入
		
		/* switch:开关语句
			switch (判断对象) {
				case 可能等于的值:处理语句;break;
				default:当所有case不满足时要做的事情;break;
			}
			判断对象:必须是整型、char型或String型的变量或表达式
			break:可以根据需要省略
		*/
		
		
		Scanner scanner = new Scanner(System.in);
		
		System.out.println("输入抽奖号码:");
		int number = scanner.nextInt();
		
		scanner.close();
		
		switch (number) {
		case 888:
			System.out.println("一等奖");
			break;
		case 999:
			System.out.println("二等奖");
			break;	
		case 666:
			System.out.println("三等奖");
			break;	
		default:
			System.out.println("很遗憾,没有中奖");
			break;
		}

10、循环结构:for、while、do...while

计算1+2+3+....+ 10的和

（1）当型循环：当条件成立，一直执行操作

（2）直到型循环：做什么操作，直到条件不成立

（3）break：结束循环

（4）continue：跳过本次循环后面的语句，去执行下一次循环（5）二重循环结构

		// 循环结构:for、while、do...while
		
		// 计算1+2+3+....+ 10的和
		int sum = 0;
		for (int i = 1; i <= 10 ; i++) {
			sum += i;
		}
		System.out.println(sum);
		
		sum = 0;
		int i = 1;
		while (i <= 10) {  // 当型循环：当条件成立，一直执行操作
			sum += i;
			i++;
		}
		System.out.println(sum);
		
		sum = 0;
		i = 1;
		do {     	// 直到型循环：做什么操作，直到条件不成立
			sum += i;
			i++;
		} while (i <= 10);
		System.out.println(sum);
		
		
		// 学会循环过程的跟踪
		/*
		for (int i = 1; i < 100; i += 5) {
			if (i > 25) {
				break;  // 结束循环
			} else {
				i *= 2;
			}
			System.out.println(i);
		}*/
		
		for (int j = 0; j < 10; j++) {
			if (j >= 5 && j <= 8) {
				continue;// 跳过本次循环后面的语句，去执行下一次循环
			}
			System.out.println(j);
		}

		// 二重循环结构：
		for (int j = 1; j < 10 ; j++) {
			for (int k = 1; k <= j ; k++) {
				System.out.print(j + "*" + k + "=" + (j * k) + "\t");//不能用println()
			}
			System.out.println(); // 换行 代码要放在for的外面
		}

11、一维数组

TwoCase-4 3 SecDemo2

（1）一维数组的定义

A 两种方法

比较常用

B 数组要经过初始化才能被使用

a 第一种方法

b 第二种方法长度根据数据个数确定，不能直接指定长度

c 第三种方法

C 输出

a 数组长度

b 数组第一个数

c 数组最后一个数

d 下标越界

		// 一维数组的定义
		//两种方法
		// int[] arr; 	// 这种比较常用
		// int arr2[]; // 这种也是正确的
		
		// 数组要经过初始化才能被使用
		//第一种方法
		int[] arr = {1,2,3,4,5};
		
		//第二种方法 长度根据数据个数确定，不能直接指定长度
		int[] arr3 = new int[] {1,2,3,4,5}; 
		
		//第三种方法
		//指定常数
		int len = 10;
		int arr2[] = new int[len];//等于int arr2[] = new int[10];
		
		//输出
		System.out.println("数组长度:" + arr.length);
		System.out.println("第一个数:" + arr[0]);
		System.out.println("最后一个数:" + arr[arr.length - 1]);
		
		// System.out.println(arr[5]); // 下标越界 错误

12、排序

1、用数组输入5个人的年龄

（1）定义数组

（2）定义数组

（3）定义一个扫描仪

（4）for遍历 i+1 是定位到指定下标数组的值接受整型

（5）关闭扫描器

2、选择排序：每个数都要跟它后面所有元素比较一次

（1）升序 for遍历行（i）列（j）j表示后面所有元素下标

（2）进行比较

（3）交换位置

// 冒泡排序:从最后一个元素开始比较

（1）升序 for遍历行（i）列（j）i表示第几轮比较

（2）相邻元素比较

3、遍历输出 i是下标

4、java中的foreach循环 i是迭代变量，用于保存遍历到的元素

		// 用数组 输入5个人的年龄
		//定义数组
		int[] ages = new int[5];
		
		//定义一个扫描仪
		Scanner scanner = new Scanner(System.in);
		
		// for遍历
		for (int i = 0; i < ages.length; i++) {
			
			//输入
			System.out.print("输入第" + (i + 1) + "个人的年龄:");
			
			//接受整型
			ages[i] = scanner.nextInt(); 
		}
		
		// 关闭扫描器
		scanner.close(); 
		
		
		// 选择排序：每个数都要跟它后面所有元素比较一次
		// 升序
		//for遍历
		/*for (int i = 0; i < ages.length; i++) {
		 * 
			// j表示后面所有元素下标
			for (int j = i + 1; j < ages.length; j++) {
				// 进行比较
				if (ages[i] > ages[j]) {
					// 交换位置
					int temp = ages[i];
					ages[i] = ages[j];
					ages[j] = temp;
				}
			}
		}*/
		
		// 冒泡排序:从最后一个元素开始比较
		// i表示第几轮比较
		// 升序
		for (int i = 1; i < ages.length; i++) {
			for (int j = ages.length - 1; j >= i; j--) {
				// 相邻元素比较
				if (ages[j] < ages[j - 1]) {
					int temp = ages[j];
					ages[j] = ages[j - 1];
					ages[j - 1] = temp;
				}
			}
		}
		
		
		// 遍历输出
		for (int i = 0; i < ages.length; i++) {   // i是下标
			System.out.println("第" + (i + 1) + "个人的年龄:" +  ages[i]);
		}
		// java中的foreach循环
		int count = 1;
		for (int i : ages) {  // i是迭代变量，用于保存遍历到的元素
			System.out.println("第" + count + "个:" + i);
			count++;
		}

13、升序降序

（1）定义数组

（2）升序排序并行排序，效率更高 // 如果要降序，需要把数组定义成对象类型

二分查找：查找前数组一定要排好顺序

（1）定义下标返回出现位置的下标，没有出现，返回负数

（2）判断

（3）遍历输出

（4）转字符串输出

		// 数组工具类Arrays
		int[] arr = { 100, 20, 33, 23, 33 };
		
		// 升序排序
		// Arrays.sort(arr);
		Arrays.parallelSort(arr);  // 并行排序，效率更高
		
		// 如果要降序，需要把数组定义成对象类型
		// Arrays.sort(arr, Collections.reverseOrder());
		
		// 二分查找：查找前数组一定要排好顺序
		// 返回出现位置的下标，没有出现，返回负数
		int idx = Arrays.binarySearch(arr, 33);
		
		//判断
		if (idx < 0) {
			System.out.println("没有找到");
		} else {
			System.out.println("找到,下标位置:" + idx);
		}
		
		//遍历输出
		for (int i : arr) {
			System.out.println(i);
		}
		// 转字符串输出
		System.out.println(Arrays.toString(arr));

14、二维数组

（1）定义数组存储2个班级，每个班5个同学的成绩、

1、第一种写法

2、第二种写法

3、第三种写法混合写法

（2）获取行数和列数

（3）访问元素，通过行下标和列下标

（4）遍历所有值

// foreach遍历二维 is表示遍历到的行(每一行是一个一维数组) 遍历行中元素输出所有值

		// 二维数组
		// 存储2个班级，每个班5个同学的成绩
		//int[][] arr;
		//int arr2[][];
		
		//第一种写法
		int[][] arr = {
				{22,3,4,5,7},
				{23,4,5,76,8}
		};  // 2行5列的二维数组 （相当于2个一维数组）
		
		//第二种写法
		int[][] arr2 = new int[2][5]; // 2行5列的二维数组
		
		//第三种写法  混合写法
		int[][] arr3 = new int[][] { 
			{ 22, 3, 4, 5,10 }, 
			{ 23, 4, 5, 76, 8 } 
		}; 
		
		
		// 获取行数和列数
		System.out.println("行数:" + arr3.length);//一共多少行
		System.out.println("列数:" + arr3[0].length);//一行几列
		System.out.println("列数:" + arr3[1].length);//二行几列
		
		// 访问元素，通过行下标和列下标
		System.out.println(arr3[1][3]);//2行4列
		
		// 遍历  所有值
		for (int i = 0; i < arr3.length; i++) {//行
			for (int j = 0; j < arr3[i].length; j++) {//列
				System.out.print(arr3[i][j] + " ");//输出所有值
			}
			System.out.println();//换行
		}
		
		System.out.println("----------------------------");
		
		// foreach遍历二维
		for (int[] is : arr3) {  // is表示遍历到的行(每一行是一个一维数组)
			for (int i : is) {  // 遍历行中元素
				System.out.print(i + " ");//输出所有值
			}
			System.out.println();//换行
		}

15、不规则的二维数组

列数后面再确定

		// 不规则的二维数组
		int[][] arr = {
				{1,2,3},
				{23,43,54,4,3,3},
				{12,4,3,3}
		};
		
		int[][] arr2 = new int[3][]; // 列数后面再确定
		
		arr2[0] = new int[3]; // 第一行有3列
		arr2[1] = new int[6]; // 第二行有6列
		arr2[2] = new int[4]; // 第三行有4列

16、 ==: 对于基本类型的数据来说，比较的是值是否相等

在JVM中对String类型有特殊的处理

在JVM中有一个字符串池的存在，用于管理程序中的字符串对象

字符串的比较建议用equals方法

在JVM还有一个Integer常量池，把-128~127之间的整数放入池中

		// ==: 对于基本类型的数据来说，比较的是值是否相等
		int a = 10, b = 10;
		System.out.println(a == b);  // true
		
		// 在JVM中对String类型有特殊的处理
		// 在JVM中有一个字符串池的存在，用于管理程序中的字符串对象
		String s1 = "abc",s2 = "abc";
		System.out.println(s1 == s2); // true （地址相同）
		
		String s3 = new String("abc");
		System.out.println(s1 == s3); // false  （地址不相同）
		
		// 字符串的比较建议用equals方法
		// equals:比较的是值是否相等
		System.out.println(s1.equals(s3)); // true
		
		
		// 在JVM还有一个Integer常量池，把-128~127之间的整数放入池中
		// 管理
		Integer m = 10,n = 10;
		System.out.println(m == n);   // true
		
		Integer m1 = 1000,n1 = 1000;
		System.out.println(m1 == n1);   // false

17、包装器类型：对每种基础类型提供了一个

对应的类类型,这个对应的类类型就叫做包装类

基础类型和包装器类型的区别:

1、声明方式不同

定义变量

Integer 过时，不建议使用

包装器类型属于对象数据类型。存储数据的结构与基本类型不同。

默认初值不同，int默认为0，包装器类型默认为null

基本类型没有包含任何方法属性成员,包装器类中有这种类型相关的属性和方法

使用场景不同：在集合中表示元素的类型，必须使用包装器类型。

		// 包装器类型：对每种基础类型提供了一个
		// 对应的类类型,这个对应的类类型就叫做包装类
		/*	基础类型		包装类(类类型)
		 *  int			Integer
		 *  float		Float
		 *  double		Double
		 *  ....
		 */
		// 基础类型和包装器类型的区别:
		// 1、声明方式不同
		int number1 = 100;
		
		Integer number2 = new Integer(100); // 过时，不建议使用
		Integer number3 = 100;
		
		
		// 2、包装器类型属于对象数据类型。存储数据的结构与基本类型不同。
		// 3、默认初值不同，int默认为0，包装器类型默认为null
		// 4、基本类型没有包含任何方法属性成员,包装器类中有这种类型相关的属性和方法
		// 5、使用场景不同：在集合中表示元素的类型，必须使用包装器类型。

18、转类型

（1） int的数据范围

（2）int/float/double/char转String

方法1

方法2

（3） String转其它类型

方法1 转int

方法2 转int

转 float

转 Double

（4）String 跟数组的转换

字符串转char类型数组

根据char类型数组构造出一个字符串

		//  int的数据范围
		// System.out.println(Integer.MAX_VALUE);
		// System.out.println(Integer.MIN_VALUE);
		
		// int/float/double/char转String
		int number = 123; 
		
		String string = Integer.toString(number);// 方法1
		System.out.println(string);
		
		String string2 = String.valueOf(number); // 方法2
		System.out.println(string2);
	
		// String转其它类型
		String str = "123";
		
		int a = Integer.parseInt(str);  // 方法1 转int
		System.out.println(a); 
		
		// Float.parseFloat(str) 转 float
		// Double.parseDouble(str) 转 Double
		
		int b = Integer.valueOf(str);  // 方法2 转int
		System.out.println(b);
		
		// String 跟 数组的转换
		String str1 = "hello";
		char[] cs = {'h','e','l','l','o'};
		
		char[] cs2 = str1.toCharArray();  // 字符串转char类型数组
		String str2 = new String(cs);  // 根据char类型数组构造出一个字符串

第三章 Java面向对象程序设计

1、字段属性构造函数方法

ThreeCase-1 4 OopDemo1

（1）字段: 保存数据的变量

字段访问修饰符:public 、默认（无关键字，在本包中可以用）、 private 、 protected(受保护，继承链中使用)

（2）属性: 用于字段对外公开，提供对外访问接口

get访问器 set访问器

boolean型的get访问器默认以is开头

（3）构造函数：默认系统提供一个无参构造,如果自行添加了构造，系统将不会再提供无参构造

构造函数名跟类名相同

调用父类无参构造函数(暂时可以不写)

（4）方法：实例方法和静态方法

1、实例方法：属于每一个对象的方法，调用方式: 对象名.实例方法名(参数)

（1）void表示无返回值，其它类型都是有返回

（2）return 进行值的返回。执行到return，方法就执行完

（3）多个方法名字一样，但参数（个数或类型）不同，叫方法重载！多个参数逗号分隔，每个都要类型

（5）创建对象：new（把对象从无到有创建出来，分配存储空间）同时，调用了构造函数进行初始化

1、调用了无参构造函数

2、赋值：set访问器

3、取值:get访问器

4、实例方法的调用

5、接收返回值

package com.nf.oop; // package定义了类所在的包（路径）

public class Student {

	// 字段: 保存数据的变量
	// 字段访问修饰符:public 、默认（无关键字，在本包中可以用）、 private 、 protected(受保护，继承链中使用)
    int stuId;  // 学号
	String stuName;  // 姓名
	int stuAge; // 年龄
	boolean finished;  // 是否毕业 (boolean型字段尽量不以is开头)
	
	// 属性: 用于字段对外公开，提供对外访问接口
	public int getStuId() {  // get访问器
		return stuId;
	}
	public void setStuId(int stuId) { // set访问器
		this.stuId = stuId;
	}
	public String getStuName() {
		return stuName;
	}
	public void setStuName(String stuName) {
		this.stuName = stuName;
	}
	public int getStuAge() {
		return this.stuAge;
	}
	public void setStuAge(int stuAge) {
		this.stuAge = stuAge;
	}
	
	// boolean型的get访问器默认以is开头
	public boolean isFinished() {
		return finished;
	}
	public void setFinished(boolean finished) {
		this.finished = finished;
	}
	
	
	// 构造函数：默认系统提供一个无参构造,如果自行添加了构造，系统将不会再提供无参构造
	// 构造函数名跟类名相同
	public Student() {
		super();
	}
	public Student(int stuId, String stuName) {
		super();  // 调用父类无参构造函数(暂时可以不写)
		this.stuId = stuId;
		this.stuName = stuName;
	}
	
	public Student(int stuId, String stuName, int stuAge, boolean finished) {
		super();
		this.stuId = stuId;
		this.stuName = stuName;
		this.stuAge = stuAge;
		this.finished = finished;
	}
	
	// 方法：实例方法和静态方法
	// 实例方法：属于每一个对象的方法，调用方式: 对象名.实例方法名(参数)
	// void表示无返回值，其它类型都是有返回
	public void study() {
		System.out.println("在学习……");
	}
	
	public int getScore(String subjectString) {
		return 100;  // return 进行值的返回。执行到return，方法就执行完
	}
	
	// 多个方法名字一样，但参数（个数或类型）不同，叫方法重载！
	public int calc(int a,int b,int c) {  // 多个参数逗号分隔，每个都要类型
		return a + b + c;
	}
	
	public int calc(int a,int b) {  // 方法名可以重复
		return a + b;
	}
	
	public float calc(float a,float b) {  // 方法名可以重复
		return a + b;
	}
	
	
		public static void main(String[] args) {
		// 创建对象：new（把对象从无到有创建出来，分配存储空间）
		// 同时，调用了构造函数进行初始化
		Student s1 = new Student(); // 调用了无参构造函数
		
		// Student s2 = new Student(1001,"李四");// 调用了有参构造函数
		Student s3 = new Student(1002,"王五",12,false);
		
		// 赋值：set访问器
		s1.setStuId(1000);
		s1.setStuName("张三");
		s1.setStuAge(18);
		s1.setFinished(false);
		
		// 取值:get访问器
		System.out.println(s1.getStuId());
		System.out.println(s1.getStuName());
		System.out.println(s1.getStuAge());
		System.out.println(s1.isFinished());
		
		// 取值:get访问器
		System.out.println(s3.getStuId());
		System.out.println(s3.getStuName());
		System.out.println(s3.getStuAge());
		System.out.println(s3.isFinished());
		
		// 实例方法的调用:
		s1.study();
		s3.study();
		
		int score = s1.getScore("java"); // 接收返回值
		System.out.println(score);
		
	}
}

2、静态

（1）static：静态的，用static可以修饰字段、属性/方法

1、非静态的字段：属于每个对象的，数据不共享，叫局部变量

（1）创建对象

（2）赋值

（3）输出

2、静态的字段: 每个对象共享的,叫类变量(类名.静态成员名)

（1）静态方法:不能使用this来访问对象的非静态成员

（2）最特殊的静态方法: 叫“静态块”或"初始化代码块"

在什么时候被执行了？？？在类第一次加载时自动调用（不能手动调用）

静态块一般可用于初始化静态字段（类变量）

（3）多个静态块，从上到下的执行顺序

（4）静态的成员通过类名调用

（5）静态方法调用

public class Teacher {
	// static：静态的，用static可以修饰字段、属性/方法
	// 非静态的字段：属于每个对象的，数据不共享，叫局部变量
	int teaId;
	
	// 静态的字段: 每个对象共享的,叫类变量(类名.静态成员名)
	static String school;
	
	// 静态方法:不能使用this来访问对象的非静态成员
	public static void working() {
		System.out.println("test...........");
	}
	
	// 最特殊的静态方法: 叫“静态块”或"初始化代码块"
	// 在什么时候被执行了？？？在类第一次加载时自动调用（不能手动调用）
	static { // 一般可用于初始化静态字段（类变量）
		school = "南方IT";
		System.out.println("static...............");
	}
	
	// 多个静态块，从上到下的执行顺序
	static {
		System.out.println("second static...............");
	}
	
	public Teacher() {
		super();
		System.out.println("construtor...........");
	}
	
	// 每个类都可以加个main函数，用于测试本类的代码
	public static void main(String[] args) {
		//创建对象
		Teacher t1 = new Teacher();
		t1.teaId = 1;//赋值
		
		Teacher t2 = new Teacher();
		t2.teaId = 2;//赋值
		
		//输出
		System.out.println(t1.teaId + "   " + t2.teaId);
		
		// 静态的成员通过类名调用
		// Teacher.school = "南方IT";
		System.out.println(t1.school + "  " + t2.school);
		
		Teacher.working();// 静态方法调用
		
	}
}

3、方法重载、静态方法

ThreeCase-1 5 OopDemo2

文档注释

1 字段 // 工号// 姓名

静态字段静态的常量 // 公司名

2 属性 get访问器 set访问器静态的没有属性

3 构造函数

4 实例方法方法重载：方法名一样，参数不同

静态方法

特殊的静态方法：静态块/初始化块(初始化静态字段)

计算两个数的和

5 main入口

1 定义数组

2 定义一个扫描仪

3 for遍历

（1）创建对象

（2）输出下标

（3）输入

（4）接受

//文档注释
/**
 * 员工类
 * @author 小明
 * @version 1.0
 */

public class Employee {
	
	//1 字段
	private int empId;  // 工号
	private String empName; // 姓名
	
	//静态字段
	// static：静态的
	// static final:静态的常量
	public static String COMPANY_NAME;  // 公司名
		
	//2 属性 get访问器 set访问器  静态的没有属性
	public int getEmpId() {
		return this.empId;
	}
	public void setEmpId(int empId) {
		this.empId = empId;
	}
	public String getEmpName() {
		return empName;
	}
	public void setEmpName(String empName) {
		this.empName = empName;
	}
	
	
	//3 构造函数
	public Employee(int empId, String empName) {//有参
		super();
		this.empId = empId;
		this.empName = empName;
	}
	
	public Employee() {//无参
		super();
	}
	
	//4  实例方法
	// 方法重载：方法名一样，参数不同
	
	/**
	 * 自我介绍的方法
	 */
	public void introduce() {//无参
		System.out.println("大家好，我是:" + this.empName);
	}
	/**
	 * 自我介绍方法2
	 * @param other  别人的姓名
	 */
	public void introduce(String other) {//有参
		System.out.println("你好，" + other + ",我是:" + this.empName);
	}
	
	public String toString() {
		return "[" + this.empId + "," + this.empName +"]";
	}
	
	// 静态方法
	public static void meeting() {
		System.out.println("开会啦.............");
	}
	
	// 特殊的静态方法：静态块/初始化块(初始化静态字段)
	static {
		COMPANY_NAME = "nf";
		System.out.println("test..............");
	}
	
	/**
	 * 计算两个数的和
	 * @param a 第一个数
	 * @param b 第二个数
	 * @return 两个数之和
	 */
	public int add(int a,int b) {
		return a + b;
	}
	
	//5 main入口
	public static void main(String[] args) {
		//1 定义数组
		Employee[] emps = new Employee[3];
		
		
		/*Employee[] emps2 = {
			new Employee(1, "张三"),
			new Employee(2, "lisi"),
			new Employee(3, "wangwu")	
		};*/
		
		//2 定义一个扫描仪
		Scanner scanner = new Scanner(System.in);
		
		//3 for遍历
		for (int i = 0; i < emps.length; i++) {
			//（1） 创建对象
			emps[i] = new Employee();
			
			//（2）输出下标
			System .out.println("第" + (i + 1) + "个:");
			
			//（3）输入
			System.out.println("请输入工号:");
			
			//（4）接受
			emps[i].setEmpId(scanner.nextInt());
			
			//输入
			System.out.println("请输入姓名:");
			//接受
			emps[i].setEmpName(scanner.next());
		}
		
		//关闭扫描仪
		scanner.close();
		
		//3 foreach遍历 所有信息
		for (Employee employee : emps) {
			
			//输出被调用的方法
			System.out.println(employee.toString());
		}
		
		//定义变量 赋值
		int x = 10;
		test(x);  // 传递基本类型的数据：传递的是数据的副本（拷贝一份）
		System.out.println(x); // 10
		
		//创建对象
		MyTest my = new MyTest();
		my.a = 10;
		test2(my);  // 传递对象类型的数据：传递的是引用（指向数据的地址）
		System.out.println(my.a); // 1000
	
		//定义数组
		int[] arr = {10,2,3,3,12,2,4,56,6};
		test3(arr); // 数组也是对象类型（数组名是数组首地址）
		//arr和myArray地址相同，是同一个数组对象
		for (int i : arr) {
			System.out.print(i);
		}	
		
}

	//静态方法
	public static void test(int a) {
		a = 1000;
	}
	
	public static void test2(MyTest myTest) {
		myTest.a = 1000;
	}
	
	public static void test3(int[] myArray) {
		Arrays.parallelSort(myArray);
	}
	

}        
 
 

//新建一个类
package com.nf.entities;
public class MyTest {         
     int a;
}

第四章类的封装、继承与多态

4、继承

一个类没有显式继承，它的父类是java.lang.Object类

类名首字母要大写

字段命名要用骆驼命名法

（1）父类

1 字段

2 属性

3 方法

（2）Student类继承了Person类

1 字段

2 属性

3 main入口

（1）创建子类对象

（2）输出

（3）调用方法

（3）

（4）

创建子类对象

FourCase-1 6 OopDemo4

// 一个类没有显式继承，它的父类是java.lang.Object类
public class Worker {

}
===============================================================================

//类名首字母要大写
//（1）父类
public class Person {

	//1 字段 命名要用骆驼命名法
	private String name;//名字
	private String gender;//性别
	private int age;//年龄
	
	//2 属性
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	//3 方法
	public void working() {
		System.out.println("在工作中……");
	}
	
}
===============================================================================

/**
 * Student类 继承了Person类
 */
public class Student extends Person{
	
	//1 字段 子类可以有自己的成员
	private int stuId;	// 学号
	private String subjectName;// 专业
	
	//2 属性
	public int getStuId() {
		return stuId;
	}
	public void setStuId(int stuId) {
		this.stuId = stuId;
	}
	public String getSubjectName() {
		return subjectName;
	}
	public void setSubjectName(String subjectName) {
		this.subjectName = subjectName;
	}
	
	//3 main入口
	public static void main(String[] args) {
		
		//（1） 创建子类对象
		Student student = new Student();
		student.setStuId(1);
		student.setName("张三");
		student.setAge(10);
		student.setGender("男");
		student.setSubjectName("软件");
		
		//（2）输出
		System.out.println(student.getStuId());
		System.out.println(student.getName());
		System.out.println(student.getAge());
		System.out.println(student.getGender());
		System.out.println(student.getSubjectName());
		
		//（3）调用方法
		student.working();
	}	
}
===============================================================================

/**
 * Teacher类继承了Person类
 */
public class Teacher extends Person {
	private int tid; // 工号

	//属性
	public int getTid() {
		return tid;
	}

	public void setTid(int tid) {
		this.tid = tid;
	}
	public static void main(String[] args) {
		
		// 创建子类对象
		SoftTeacher softTeacher = new SoftTeacher();
		softTeacher.setTid(1);
		softTeacher.setName("小明");
		
		//输出
		System.out.println(softTeacher.getTid());
		System.out.println(softTeacher.getName());
	}	
	
}
===============================================================================
===============================================================================

（1）父类

1 字段

2 构造函数

3 默认有一个无参构造

4 方法

（2）Tiger继承了Animal

1 字段

2 构造函数

3 默认会调用父类无参构造调用父类无参构造函数

4 方法调用父类中的cry()方法

6 main入口

（1）创建子类对象

（2）输出

（3）调用方法

//父类
public class Animal {
	
	//1 字段
	private String typeName; // 类别
	private int age;  // 年龄

	//2 构造函数
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getTypeName() {
		return typeName;
	}
	public void setTypeName(String typeName) {
		this.typeName = typeName;
	}
	
	//3 默认有一个无参构造
	public Animal() {
		super();
		System.out.println("父类无参构造");
	}
	
	public Animal(String typeName) {
		super();
		this.typeName = typeName;
	}
	public Animal(String typeName, int age) {
		super();
		this.typeName = typeName;
		this.age = age;
	}
	
	//4 方法
	public void cry() {
		System.out.println("叫~~~~");
	}
}

===============================================================================

/**
 * Tiger继承了Animal
 * @author 86188
 *
 */
public class Tiger extends Animal{

	//1 字段
	private String locationAdd;  // 生活的地区
	
	//2 属性
	public String getLocationAdd() {
		return locationAdd;
	}
	public void setLocationAdd(String locationAdd) {
		this.locationAdd = locationAdd;
	}
	
	
	//3 默认会调用父类无参构造
	public Tiger() {
		super();  // 调用父类无参构造函数
		System.out.println("子类构造函数");
	}
	
	//4 带参
	public Tiger(String typeName,int age,String locationAdd) {
		super(typeName,age); // 调用父类带参构造
		this.locationAdd = locationAdd;
	}
	
	//5 方法
	public void crying() {
		super.cry(); // 调用父类中的cry()方法
		System.out.println(".......end");
	}

	//6 main入口
	public static void main(String[] args) {
		//（1） 创建子类对象
		Tiger tiger = new Tiger("食肉动物",5,"华南");
		
		//（2）输出
		System.out.println(tiger.getTypeName());
		System.out.println(tiger.getAge());
		System.out.println(tiger.getLocationAdd());
		
		//（3）调用方法
		tiger.crying();
	}
	
}

5、instanceof：类型的实例

（1）父类

1 字段

2 输出信息

（2）班主任类继承了老师类

1 字段

2 输出信息

（3）专业类继承了老师类

1 字段

2 输出信息

（4）方法把老师所有信息输出来

1 判断 instanceof：类型的实例

（5）main入口

1 创建子类对象

2 调用方法

FourCase-2 7 OopDemo5

/**
 * 老师类
 * @author 86188
 *
 */
//（1）父类 
public class Teacher {
	
	//1 字段
	protected int tid; // 工号
	protected String tname; // 姓名
	
	/**
	 *2 输出信息
	 */
	public void showInfo() {
		System.out.println("工号:" + this.tid);
		System.out.println("姓名:" + this.tname);
	}
}

//（2） 班主任类 继承了 老师类
public class MasterTeacher extends Teacher {

	//1 字段
	protected String className; //班级
	
	/**
	 *2 输出信息
	 */
	public void show() {
		super.showInfo();//调用父类方法
		System.out.println("班级:" + this.className);
	}
	
}

//（3） 专业类 继承了 老师类
public class SubjectTeacher extends Teacher {

	//1 字段
	protected String subject; // 教的专业
	
	/**
	 * 2 输出信息
	 */
	public void show() {
		super.showInfo();//调用父类方法
		System.out.println("专业:" + this.subject);
	}
	
}

public class School {

	//（4）方法 把老师所有信息输出来
	public static void getTeacherInfo(Teacher teacher) {
		//1 判断
		//instanceof：类型的实例
		if (teacher instanceof SubjectTeacher) {
			SubjectTeacher st = (SubjectTeacher)teacher;
			st.show();
		}
		if (teacher instanceof MasterTeacher) {
			MasterTeacher st = (MasterTeacher)teacher;
			st.show();
		}
	}
	
	（5）main入口
	public static void main(String[] args) {
	
		//1 创建子类对象
		SubjectTeacher teacher = new SubjectTeacher();
		teacher.tid = 1;
		teacher.tname = "zhagnsan";	
		teacher.subject = "软件";
		//创建子类对象
		MasterTeacher teacher2 = new MasterTeacher();
		teacher2.tid = 2;
		teacher2.tname = "lisi";	
		teacher2.className = "186";
		
		//2 调用方法
		getTeacherInfo(teacher);
		getTeacherInfo(teacher2);
	}
	
}

6、方法重写

FourCase-3 8 OopDemo6

（1）父类

1 字段

2 方法：赚钱

（2） Daughter 继承 Father

1 方法

@Override // 注解：表示方法重写

（3） Son 继承 Father

1 赚钱的方法方法重写（overide）：子类中可以对父类的方法进行修改，重新实现它的逻辑

@Override // 注解：表示方法重写

（4）main入口

1 向上转型父类指向子类

2 调用方法

//（1）父类
public class Father {
	
	//1 字段
	protected double money;
	
	//2 方法：赚钱
	public void addMoney() {
		System.out.println("开了一间公司");
	}
	
}

/**
 *（2） Daughter 继承 Father
 * @author 86188
 *
 */
public class Daughter extends Father {
	
	//1 方法
	@Override // 注解：表示方法重写
	public void addMoney() {
		//super.addMoney();
		System.out.println("开花店");
	}
}

/**
 *（3） Son 继承 Father
 * @author 86188
 *
 */
public class Son extends Father {

	// 赚钱的方法:
	//1 方法重写（overide）：子类中可以对父类的方法进行修改，重新实现它的逻辑
	@Override  // 注解：表示方法重写
	public void addMoney() {
		//super.addMoney();
		System.out.println("买彩票中奖");
	}
	
}

//测试
public class Test {

	（4）main入口
	public static void main(String[] args) {
		//1 向上转型 父类指向子类
		Father father = new Son();
		Father father2 = new Daughter();
		
		//2 调用方法
		father.addMoney();
		father2.addMoney();

	}

}

第五章接口与抽象类

FiveCase-1 9 OopDemo7

1、抽象类抽象方法

（1）形状类:抽象类

默认带一个无参构造函数

1 抽象方法

（2）三角形类 Triangle 继承 Shape

1 字段三边

2 构造函数

3 方法重写

（3）圆形类 Circle 继承 Shape

1 字段常量

2 构造函数

3 方法重写

（4）main入口

1 抽象类不能直接实例化，可以指向子类对象

2 输出

// （1）形状类:抽象类
public abstract class Shape {
	
	// 默认带一个无参构造函数
	
	// 1 抽象方法
	public abstract double getLenth();  	// 计算周长 
	public abstract double getArea(); 		// 计算面积
}

//（2） 三角形类 Triangle 继承 Shape
public  class Triangle extends Shape{

	//1 字段 三边
	private int a;
	private int b;
	private int c;
	
	//2 构造函数
	public Triangle(int a, int b, int c) {
		super();
		this.a = a;
		this.b = b;
		this.c = c;
	}

	//3 方法重写
	@Override
	public double getLenth() {
		return this.a + this.b + this.c;
	}

	//方法重写
	@Override
	public double getArea() {
		double p = getLenth() / 2.0; // 周长的一半
		double s = Math.sqrt(p * (p - this.a) * (p - this.b) * (p - this.c));
		return s;
	}

}

//（3） 圆形类 Circle 继承 Shape
public class Circle extends Shape {

	//1 字段 常量
	private int r; // 半径
	private final double PI = 3.14; // 常量
	
	//2 构造函数
	public Circle(int r) {
		super();
		this.r = r;
	}

	//3 方法重写
	@Override
	public double getLenth() {
		return 2 * this.PI * this.r;
	}

	//方法重写
	@Override
	public double getArea() {
		return this.PI * this.r * this.r;
	}

}

public class Test {

	//（4）main入口
	public static void main(String[] args) {
		
		// Shape a = new Shape(); // 抽象类不能直接实例化
		//1 抽象类不能直接实例化， 可以指向子类对象
		Shape shape = new Triangle(3, 4, 5); // 可以指向子类对象
		Shape shape2 = new Circle(5);
		
		//2 输出
		System.out.println("周长: " + shape.getLenth());
		System.out.println("周长: " + shape2.getLenth());
		
		System.out.println("面积: " + shape.getArea());
		System.out.println("面积: " + shape2.getArea());

	}

}

2、接口

（1）表示“工作”的接口 Workable.java文件

1 字段默认的修饰符:public static final 常量

2 默认是public abstract (公开的抽象的方法)

3 default方法：从jdk8开始引入（默认是public的）

（2）老师类:实现工作接口Workable

1 重写接口中的方法

2 接口中的default方法，可以重写，也可以不重写

（3）学生类:实现工作接口Workable

1 重写接口中的方法

（4）main入口

1 创建对象

2 输出接口类的常量

3 调用使用接口类的方法

FiveCase-2 10 OopDemo8 demo4

（1）表示“工作”的接口 Workable.java文件

// （1）表示“工作”的接口 Workable.java文件
public interface Workable {
	
	// 成员默认都是public的
	
	//1 字段 默认的修饰符:public static final
	String COMPANY_NAME = "南方IT"; // 常量
	
	//2 默认是public abstract (公开的抽象的方法)
    void work(); // 表示“工作”的方法（体现接口是一种编程规范）
    
    //3 default方法：从jdk8开始引入 （默认是public的）
    default void signIn() {
    	System.out.println("上班打卡……");
    }
        
}

（2）老师类:实现工作接口Workable

// （2）老师类:实现工作接口Workable
public class Teacher implements Workable {

	@Override  //1 重写接口中的方法
	public void work() {
		System.out.println("老师开始朝九晚九的工作了……");
	}
	
	@Override  //2 接口中的default方法，可以重写，也可以不重写
	public void signIn() {
		System.out.println("老师上班打卡");
	}
	
}

（3）学生类:实现工作接口Workable

//（3）学生类:实现工作接口Workable
public class Student implements Workable{

	// 重写接口中的方法
	@Override
	public void work() {
		System.out.println("开始上课了");	
	}
	
}

public class Test {
	//（4）main入口
	public static void main(String[] args) {
		
		//1 创建对象
		Teacher teacher = new Teacher();
		Student student = new Student();
		
		//2 输出接口类的常量
		System.out.println(Workable.COMPANY_NAME);
		System.out.println(Workable.COMPANY_NAME);

		//3 调用使用接口类的方法
		teacher.work();
		student.work();
		
		teacher.signIn();
		student.signIn();

	}

}

FiveCase-3 11 OopDemo9 demo2

3、接口可以继承接口

//接口
public interface A {
	void a();//抽象方法
}

// 接口可以继承接口:子接口拥有父接口的成员
public interface B extends A{
	void b();//抽象方法
}

public class C implements B{

	//重写抽象方法
	@Override
	public void a() {
		
	}

	@Override
	public void b() {
		
	}

}

FiveCase-3 11 OopDemo9 demo3

4、实现排序接口

// 实现排序接口
public class Student implements Comparable<Student> {
	
	//1 字段
	private int sid;
	private String sname;
	private int age;
	
	//2 属性
	public int getSid() {
		return sid;
	}
	public void setSid(int sid) {
		this.sid = sid;
	}
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	//3 构造函数
	public Student(int sid, String sname, int age) {
		super();
		this.sid = sid;
		this.sname = sname;
		this.age = age;
	}
	
	//4 重写父类toString
	@Override
	public String toString() {
		return "学号:" + this.sid
				+ " 姓名:" + this.sname
				+ " 年龄:" + this.age;
	}
	
	//5 重写排序接口中的compareTo
	@Override  
	public int compareTo(Student o) {
		// 用当前对象this和对象o比较，确定两者先后顺序
		// return this.sid - o.sid;  // 按照学号排序，升序
		// return o.sid - this.sid; // 按照学号排序，降序
		return this.sname.compareTo(o.sname);  // 按照姓名排序，升序
	}
	
}

public class Test {

	public static void main(String[] args) {
		//1 定义数组存本类数据
		Student[] students = {
				new Student(1, "b", 10),
				new Student(3, "c", 30),
				new Student(4, "a", 20),
				new Student(5, "f", 15),
				new Student(2, "e", 18)
		};
		//2 如果要对对象数组进行排序，那么该类要实现排序接口！
		Arrays.parallelSort(students);
		
		//3 输出结果 （类名 命名 ：数组名）
		for (Student student : students) {
			System.out.println(student.toString());
		}

	}

}

FiveCase-3 11 OopDemo9 demo4

5、排序比较器类

public class Student {
	
	//1 字段
	private int sid;
	private String sname;
	private int age;
	
	//2 属性
	public int getSid() {
		return sid;
	}
	public void setSid(int sid) {
		this.sid = sid;
	}
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	//3 构造函数
	public Student(int sid, String sname, int age) {
		super();
		this.sid = sid;
		this.sname = sname;
		this.age = age;
	}
	
	//4 重写父类toString方法
	@Override
	public String toString() {
		return "学号:" + this.sid
				+ " 姓名:" + this.sname
				+ " 年龄:" + this.age;
	}
}

// 编号排序比较器类
public class SortById implements Comparator<Student> {

	// 重写排序接口中的compareTo
	@Override
	public int compare(Student o1, Student o2) {
		// 对象o1和o2进行比较
		return o1.getSid() - o2.getSid(); // 按照学号比较
	}

}

// 姓名排序比较器类
public class SortByName implements Comparator<Student>{
	// 重写排序接口中的compareTo
	@Override
	public int compare(Student o1, Student o2) {
		
		 // 按照姓名比较
		return o1.getSname().compareTo(o2.getSname());
	}

}

public class Test {

	//main入口
	public static void main(String[] args) {
		//1 定义数组存数据
		Student[] students = {
				new Student(1, "b", 10),
				new Student(3, "c", 30),
				new Student(4, "a", 20),
				new Student(5, "f", 15),
				new Student(2, "e", 18)
		};
		//2 排序，
		
		//（1）把排序比较器对象传进去
		// Arrays.sort(students,new SortById());
		// Arrays.sort(students,new SortByName());
		
		//（2） 如果不想写排序比较器类，也是可以的
		Arrays.sort(students, new Comparator<Student>() {
			
			// 重写排序接口中的compareTo
			@Override
			public int compare(Student o1, Student o2) {	
				return o1.getAge() - o2.getAge();// 年龄排序
			}
		});
		
		//3 输出
		for (Student student : students) {
			System.out.println(student.toString());
		}
		
		
	}
	
}

FiveCase-3 11 OopDemo9 demo5

6、重写克隆方法

//Dog 继承 Cloneable
public class Dog implements Cloneable{
	//1 字段
	private String name;
	private int age;

	
	//2 属性
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}


	public int getAge() {
		return age;
	}


	public void setAge(int age) {
		this.age = age;
	}

	//3 构造函数
	public Dog(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	//4 重写Object类中的Clone()克隆方法
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
	
}

public class Test {

	public static void main(String[] args) {
		
		//1 创建对象
		Dog dog1 = new Dog("小明", 1);
		
		//2 dog1 和 dog2 是同一个对象
		Dog dog2 = dog1;  
		
		//3 调用set访问器
		dog2.setAge(2);
		
		//4 输出
		System.out.println(dog1.getAge()); //2
		System.out.println(dog2.getAge()); //2
		
		//5 异常处理
		try {
			//（1）克隆对象
			Dog dog3 = (Dog)dog1.clone(); // dog3 和dog1 不是同一个对象
			//（2）调用set访问器
			dog3.setAge(3);
			//（3）输出
			System.out.println(dog1.getAge()); //2
			System.out.println(dog3.getAge()); //3
			
			
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		
	}
	
}

第六章异常处理

SixCase12 ExceptionDemo demo1

1、异常处理

public class Student {

	// 构造函数也可以进行异常声明
	public Student() throws Exception {
		
	}
	
	// 在方法中，如果有抛出异常，那么可以针对方法进行异常声明
	public int getScore()  { // 声明方法抛出了RuntimeException类型的异常
		int score = -10;
		if (score < 0 || score > 100) {
			// 手动抛出异常
			// throw 异常对象;
			// 抛出非检查型异常：可以不声明
			throw new RuntimeException("成绩范围不能小于0或大于100");
		}
		return score;
	}
	
	public int getAge() throws Exception {
		int age = 100;
		if (age < 18 || age > 30) {
			// 抛出的是检查型异常：程序必须进行处理(要么try...catch，要么对外声明)
			throw new Exception("年龄范围不正确!");
		}
		return age;
	}
	// 声明的类型可以写父类型。也可以声明多类型
	public int getAge1() throws NumberFormatException,IllegalArgumentException {
		int age = 100;
		if (age < 18 ) {
			// 抛出的是检查型异常：程序必须进行处理(要么try...catch，要么对外声明)
			throw new NumberFormatException("年龄范围不正确!");
		}
		if (age > 30) {
			throw new IllegalArgumentException("年龄不能大于30");
		}
		return age;
	}
	
	
}

import java.util.InputMismatchException;
import java.util.Scanner;

public class Test1 {

	public static void main(String[] args) {
		test2();
	}
	static void test1() {
		try {
			int a = 10, b = 10;
			int c = a / b;
			System.out.println(c);
		} catch (Exception e) {
			// 输出消息
			e.printStackTrace(); // 打印异常栈跟踪信息
			// System.out.println(e.getMessage()); // 输出异常信息
		} finally { // 无论是否有异常，都执行的操作
			System.out.println(" ..... end");
		}
		
	}
	static void test2() {
		Scanner scanner = new Scanner(System.in);
		try {
			System.out.println("输入第一个数:");
			int a = scanner.nextInt();
			System.out.println("输入第二个数:");
			int b = scanner.nextInt();
			
			int c = a / b;
			System.out.println("商:" + c);
			
			int[] arr = {1,3};
			System.out.println(arr[2]);
			
		} catch (InputMismatchException e) { // 写具体类型的异常，可以针对这个类型异常进行专门处理
			System.err.println("输入数字格式错误！");
		} catch (ArithmeticException e) {
			System.err.println("除数不能为0！");
		} catch (Exception e) { // 异常父类型一定写在最后
			System.err.println("通用的处理办法.....");
		} finally {
			scanner.close();
			
		}
	}
}

// 测试类：用户界面
public class Test2 {

	public static void main(String[] args) {
		

			//System.out.println(s1.getScore());
			try {
				Student s1 = new Student();
				System.out.println(s1.getAge());
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			try {
				new Student().getAge1();
			} catch (NumberFormatException e) {
				// TODO: handle exception
			} catch (IllegalArgumentException e) {
				// TODO: handle exception
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}

}

SixCase12 ExceptionDemo demo2

2、自定义异常类

public class Car {

	private int oil; // 剩余的油量
	
	public Car(int oil) {
		super();
		this.oil = oil;
	}

	// 车在跑
	public void run() throws CarException{
		if (this.oil <= 1) {
			throw new CarException("油量过低",10,"珠海大桥");
		}
		this.oil -= 1;
	}
	
}

// 自定义异常类：要从Exception或RuntimeException派生出来
// 如果从Exception派生，就是检查型异常；
// 如果从RuntimeException派生，就是非检查型异常；
public class CarException extends Exception {

	private static final long serialVersionUID = 1L;
	// 添加自带的属性
	private int hour;  // 发生在几点
	private String address;  // 发生的地点
	
	public CarException() {
		super();
		
	}
	public CarException(String message) {
		super(message);
		
	}
	public CarException(String message,int hour,String address) {
		super(message);
		this.hour = hour;
		this.address = address;
		
	}
	
	// 可以重写父类的方法
	@Override
	public String getMessage() {
		return "异常消息:" + super.getMessage() 
				+ " 时间:" + this.hour
				+ " 地点:" + this.address;
	}
}

public class Test {

	public static void main(String[] args) {
		Car car = new Car(10);
		while (true) {
			try {
				car.run();
			} catch (CarException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				break;
			}
		}

	}

}

第七章常用类库

1、概述什么是Java类库

java类库就是由一堆java类打包在一起组成的库，封装一些类方便你使用，比如Map,List这种。

2、字符串

1）String

1. Sting表示字符串类型，属性属于引用类型，不属于基本类型。
2. 在JAVA中使用双引号括起来的都是字符串。例如：“ADC”，“王五”；
3. 在JAVA中规定，用双引号快起来的字符串，是不可变的，也就是说“adc”自出生到死亡，不可变。不能变成“adcd”，也不能变成“ab”。
4. 在JDK当中双引号快起来的字符串，例如：“abc”都是直接存储在“方法区”的“字符串常量池”当中。
5. 为什么sun公司把字符串存在一个“字符串常量池”当中呢。因为字符串在实际开发使用太频繁，为了执行效率所以把字符串存在“字符串常量池”。

java中常用的String方法

1 length（）字符串的长度

String a = "Hello Word!";
System.out.println(a.length);

输出的结果是字符串长度10。

2 charAt（）截取一个字符

String a = "Hello Word";
System.out.println(a.charAt(1));

输出的结果是字符串a的下标为1的字符e。

3 getchars（）截取多个字符并由其他字符串接收

String a = "Hello Word";
char[] b = new char[10];
a.getChars(0, 5, b, 0);
System.out.println(b);

输出的结果为Hello，其中第一个参数0是要截取的字符串的初始下标（int sourceStart），第二个参数5是要截取的字符串的结束后的下一个下标（int sourceEnd）也就是实际截取到的下标是int sourceEnd-1，第三个参数是接收的字符串（char target[]），最后一个参数是接收的字符串开始接收的位置。

4 getBytes()将字符串变成一个byte数组

String a = "Hello Word";
byte b[] = a.getBytes();
System.out.println(new String(b));

输出的结果为Hello Word的byte数组。

5 toCharArray()将字符串变成一个字符数组

String a = "Hello Word";
char[]b = a.toCharArray();
System.out.println(b);

输出的结果为Hello Word字符数组。

**6 equals()和equalsIgnoreCase()比较两个字符串是否相等，前者区分大小写，后者不区分**

String a = "Hello Word";
String b = "hello word";
System.out.println(a.equals(b));System.out.println(a.equalsIgnoreCase(b));

输出的结果为第一条为false，第二条为true。

7 startsWith()和endsWith()判断字符串是不是以特定的字符开头或结束

String a = "Hello Word";
System.out.println(a.startsWith("ee"));  
System.out.println(a.endsWith("rd"));

输出的结果第一条为false，第二条为true。

8 toUpperCase()和toLowerCase()将字符串转换为大写或小写

String a = "Hello Word";
System.out.println(a.toUpperCase());
System.out.println(a.toLowerCase());

输出的结果第一条为“HELLO WORD”，第二条为“hello word”。

9 concat() 连接两个字符串

String a = "Hello Word";
String b = "你好";
System.out.println(b.concat(a));

输出的结果为“你好Hello Word”。

10 trim()去掉起始和结束的空格

String a = "    Hello Word   ";
System.out.println(a.trim());

输出的结果为“Hello Word”。

11 substring（）截取字符串

String a = "Hello Word";
System.out.println(a.substring(0, 5));
System.out.println(a.substring(6));

输出的结果第一条为“Hello”,第一个参数0（beginIndex）是开始截取的位置，第二个参数5（endIndex）是截取结束的位置，输出的结果第二条是“Word”，参数6（beginIndex）是开始截取的位置。

12 indexOf()和lastIndexOf()前者是查找字符或字符串第一次出现的地方，后者是查找字符或字符串最后一次出现的地方

String a = "Hello Word";
System.out.println(a.indexOf("o"));
System.out.println(a.lastIndexOf("o"));

输出的结果第一条是4，是o第一次出现的下标，第二条是7，是o最后一次出现的下标。

13 compareTo()和compareToIgnoreCase(）按字典顺序比较两个字符串的大小，前者区分大小写，后者不区分

String a = "Hello Word";
String b = "hello word";
System.out.println(a.compareTo(b));
System.out.println(a.compareToIgnoreCase(b));

输出的结果第一条为-32，第二条为0，两个字符串在字典顺序中大小相同，返回0。

14 replace() 替换

String a = "Hello Word";
String b = "你好";
System.out.println(a.replace(a, b));
System.out.println(a.replace(a, "HELLO WORD"));System.out.println(b.replace("你", "大家"));

输出的结果第一条为“你好”，第二条为“HELLO WORD”，第三条为“大家好”。

2）StringBuffer类

StringBuffer 是使用缓冲区的，本身也是操作字符串的，但是与String类不同，String 类的内容一旦声明之后则不可改变，改变的只是其内存地址的指向，而StringBuffer中的内容是可以改变的。

对于StringBuffer而言，本身是一个具体的操作类，所以不能像 String那样采用直接赋值的方式进行对象的实例化，必须通过构造方法完成。

3）String、StringBuffer的区别

1 StringBuffer不是不变类，在修改字符串内容时，不会创建新的对象，因此，它比String类更适合修改字符串。

2 StringBuffer类没有提供同String一样的toCharArray方法

3 StringBuffer类的replace方法同String类的replace方法不同,它的replace方法有三个参数,第一个参数指定被替换子串的起始位置，第二个参数指定被替换子串的终止位置，第三个参数指定新子串

3、随机数操作

4、

5、

6、正则表达式

https://blog.csdn.net/zpz2411232428/article/details/83549502

一、校验数字的表达式
1 数字：^[0-9]*$
2 n位的数字：^\d{n}$
3 至少n位的数字：^\d{n,}$
4 m-n位的数字：^\d{m,n}$
5 零和非零开头的数字：^(0|[1-9][0-9]*)$
6 非零开头的最多带两位小数的数字：^([1-9][0-9]*)+(.[0-9]{1,2})?$
7 带1-2位小数的正数或负数：^(\-)?\d+(\.\d{1,2})?$
8 正数、负数、和小数：^(\-|\+)?\d+(\.\d+)?$
9 有两位小数的正实数：^[0-9]+(.[0-9]{2})?$
10 有1~3位小数的正实数：^[0-9]+(.[0-9]{1,3})?$
11 非零的正整数：^[1-9]\d*$ 或 ^([1-9][0-9]*){1,3}$ 或 ^\+?[1-9][0-9]*$
12 非零的负整数：^\-[1-9][]0-9"*$ 或 ^-[1-9]\d*$
13 非负整数：^\d+$ 或 ^[1-9]\d*|0$
14 非正整数：^-[1-9]\d*|0$ 或 ^((-\d+)|(0+))$
15 非负浮点数：^\d+(\.\d+)?$ 或 ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$
16 非正浮点数：^((-\d+(\.\d+)?)|(0+(\.0+)?))$ 或 ^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$
17 正浮点数：^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ 或 ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
18 负浮点数：^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ 或 ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$
19 浮点数：^(-?\d+)(\.\d+)?$ 或 ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$
 
二、校验字符的表达式
1 汉字：^[\u4e00-\u9fa5]{0,}$
2 英文和数字：^[A-Za-z0-9]+$ 或 ^[A-Za-z0-9]{4,40}$
3 长度为3-20的所有字符：^.{3,20}$
4 由26个英文字母组成的字符串：^[A-Za-z]+$
5 由26个大写英文字母组成的字符串：^[A-Z]+$
6 由26个小写英文字母组成的字符串：^[a-z]+$
7 由数字和26个英文字母组成的字符串：^[A-Za-z0-9]+$
8 由数字、26个英文字母或者下划线组成的字符串：^\w+$ 或 ^\w{3,20}$
9 中文、英文、数字包括下划线：^[\u4E00-\u9FA5A-Za-z0-9_]+$
10 中文、英文、数字但不包括下划线等符号：^[\u4E00-\u9FA5A-Za-z0-9]+$ 或 ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$
11 可以输入含有^%&',;=?$\"等字符：[^%&',;=?$\x22]+
12 禁止输入含有~的字符：[^~\x22]+

三、特殊需求表达式
1 Email地址：^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
2 域名：[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
3 InternetURL：[a-zA-z]+://[^\s]* 或 ^https://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$
4 手机号码：^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
5 电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX)：^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$ 
6 国内电话号码(0511-4405222、021-87888822)：\d{3}-\d{8}|\d{4}-\d{7}
7 身份证号：
		15或18位身份证：^\d{15}|\d{18}$
		15位身份证：^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$
		18位身份证：^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{4}$
8 短身份证号码(数字、字母x结尾)：^([0-9]){7,18}(x|X)?$ 或 ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$
9 帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
10 密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：^[a-zA-Z]\w{5,17}$
11 强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在8-10之间)：^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$ 
12 日期格式：^\d{4}-\d{1,2}-\d{1,2}
13 一年的12个月(01～09和1～12)：^(0?[1-9]|1[0-2])$
14 一个月的31天(01～09和1～31)：^((0?[1-9])|((1|2)[0-9])|30|31)$ 
15 钱的输入格式：
16 1.有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：^[1-9][0-9]*$ 
17 2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：^(0|[1-9][0-9]*)$ 
18 3.一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：^(0|-?[1-9][0-9]*)$ 
19 4.这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分：^[0-9]+(.[0-9]+)?$ 
20 5.必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：^[0-9]+(.[0-9]{2})?$ 
21 6.这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：^[0-9]+(.[0-9]{1,2})?$ 
22 7.这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$ 
23 8.1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须：^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$ 
24 备注：这就是最终结果了,别忘了"+"可以用"*"替代如果你觉得空字符串也可以接受的话(奇怪,为什么?)最后,别忘了在用函数时去掉去掉那个反斜杠,一般的错误都在这里
25 xml文件：^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$
26 中文字符的正则表达式：[\u4e00-\u9fa5]
27 双字节字符：[^\x00-\xff] (包括汉字在内，可以用来计算字符串的长度(一个双字节字符长度计2，ASCII字符计1))
28 空白行的正则表达式：\n\s*\r (可以用来删除空白行)
29 HTML标记的正则表达式：<(\S*?)[^>]*>.*?|<.*? /> (网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力)
30 首尾空白字符的正则表达式：^\s*|\s*$或(^\s*)|(\s*$) (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式)

1
整数或者小数：^[0-9]+\.{0,1}[0-9]{0,2}$
2
只能输入数字："^[0-9]*$"。
3
只能输入n位的数字："^\d{n}$"。
4
只能输入至少n位的数字："^\d{n,}$"。
5
只能输入m~n位的数字：。"^\d{m,n}$"
6
只能输入零和非零开头的数字："^(0|[1-9][0-9]*)$"。
7
只能输入有两位小数的正实数："^[0-9]+(.[0-9]{2})?$"。
8
只能输入有1~3位小数的正实数："^[0-9]+(.[0-9]{1,3})?$"。
9
只能输入非零的正整数："^\+?[1-9][0-9]*$"。
10
只能输入非零的负整数："^\-[1-9][]0-9"*$。
11
只能输入长度为3的字符："^.{3}$"。
12
只能输入由26个英文字母组成的字符串："^[A-Za-z]+$"。
13
只能输入由26个大写英文字母组成的字符串："^[A-Z]+$"。
14
只能输入由26个小写英文字母组成的字符串："^[a-z]+$"。
15
只能输入由数字和26个英文字母组成的字符串："^[A-Za-z0-9]+$"。
16
只能输入由数字、26个英文字母或者下划线组成的字符串："^\w+$"。
17
验证用户密码："^[a-zA-Z]\w{5,17}$"正确格式为：以字母开头，长度在6~18之间，只能包含字符、数字和下划线。
18
验证是否含有^%&',;=?$\"等字符："[^%&',;=?$\x22]+"。
19
只能输入汉字："^[\u4e00-\u9fa5]{0,}$"
20
验证Email地址："^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$"。
21
验证InternetURL："^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$"。
22
验证电话号码："^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$"正确格式为："XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX"。
23
验证身份证号（15位或18位数字）："^\d{15}|\d{18}$"。
24
验证一年的12个月："^(0?[1-9]|1[0-2])$"正确格式为："01"～"09"和"1"～"12"。
25
验证一个月的31天："^((0?[1-9])|((1|2)[0-9])|30|31)$"正确格式为；"01"～"09"和"1"～"31"。
26
匹配中文字符的正则表达式： [\u4e00-\u9fa5]
27
年月日的正则表达式： (\\d{4})-(0[1-9]|10|11|12)-(\\d{2})
28
手机号码的正则表达式： \\d{11}
29
座机区号和号码的正则表达式：(\\d{3})-(\\d{6,8})    6到8位
30
匹配汉字的正则表达式：张[\u4e00-\u9fa5]{1,2}
31
匹配标点符号的正则表达式：（,或.或空格或!）[,. !]
32
匹配c#或c++的正则表达式： c#|c\\+\\+
33
以hello开头的正则表达式：^hello
34
查找所有hello或hi的正则表达式：hello|hi
35
加?表示非贪婪匹配：<td>.+?</td>
36
由任意的字母、数字、下划线6到8位的的正则表达式：\\w{6,16}
37

1）正则表达式是什么？

在计算机科学中，是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。

正则表达式是对字符串操作的一种逻辑公式，用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

2）正则表达式的特点：

灵活性、逻辑性和功能性非常的强；

可以迅速地用极简单的方式达到字符串的复杂控制。
对于刚接触的人来说，比较晦涩难懂。

https://blog.csdn.net/lclc_smart/article/details/84217861

https://www.cnblogs.com/dsh20134584/p/7398151.html

3）常用的元字符代码符号

.  通配符  表示任意一个字符。例如：t.g匹配tag、tig等
\s 空白符号 表示空格字符(空格键，tab，换行，换页，回车)
\S 表示非空格字符([^\s]) 
\d 表示一个数字([0-9])
\D 表示一个非数字([^0-9])
\w 表示一个单词 由任意的字母、数字、下划线"_"所组成([a-zA-Z_0-9])
\W 表示一个非单词 不是由任意的字母、数字、下划线"_"所组成([^\w]) [^a-zA-Z_0-9]
\b 表示一个单词的边界 
\B 表示一个非单词的边界
\G 表示前一个匹配的结束
^  “否”符号 表示一行开始
$  表示一行的结尾
[] 方括号符号 表示匹配方括号内的一个字符 
() 圆括号符号 1）把一个子规则括起来   2）分组

4）表示次数的元字符代码符号

* 重复零次或更多次。例如：a*匹配零个或者多个a
+ 重复一次或更多次。例如： a+匹配一个或者多个a
？ 重复一次或零次。例如： a?匹配一个或者零个a
{n}  重复n次。例如： a{4}匹配4个a
{n,} 重复n次或更多次。例如： a{4,}匹配至少4个a
{n,m} 重复n到m次。例如： a{4,10}匹配4至10个a

5）其他元字符代码符号

匹配非ASCII字符，比如中文，那就用\u####的十六进制表示 
x 字符 x
\\ 反斜线字符
\0n 带有八进制值 0 的字符 n (0 <= n <= 7)
\0nn 带有八进制值 0 的字符 nn (0 <= n <= 7)
\0mnn 带有八进制值 0 的字符 mnn（0 <= m <= 3、0 <= n <= 7）
\xhh 带有十六进制值 0x 的字符 hh
\uhhhh 带有十六进制值 0x 的字符 hhhh
\t 制表符 ('\u0009')
\n 新行（换行）符 ('\u000A')
\r 回车符 ('\u000D')
\f 换页符 ('\u000C')
\a 报警 (bell) 符 ('\u0007')
\e 转义符 ('\u001B')
\cx 对应于 x 的控制符 
|  “或”符号 不能使用方括号，必须使用圆括号t（a|e|i|o|oo）n,得tan,Ten......
- 连字符 表示一个范围
\ 转义字符
? 数量限定符号 在连字符后面加?

6）正则表达式的类库

1、Pattern：一个Pattern是一个正则表达式经编译后的表现模式。

方法

2、Matcher：一个Matcher对象是一个状态机器，它依据Pattern对象做为匹配模式对字符串展开匹配检查。

https://www.runoob.com/java/java-regular-expressions.html

索引方法

1	public int start()
返回以前匹配的初始索引。
2	public int start(int group)
 返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引
3	public int end()
返回最后匹配字符之后的偏移量。
4	public int end(int group)
返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。

查找方法

1	public boolean lookingAt()
 尝试将从区域开头开始的输入序列与该模式匹配。
2	public boolean find()
尝试查找与该模式匹配的输入序列的下一个子序列。
3	public boolean find(int start）
重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。
4	public boolean matches()
尝试将整个区域与模式匹配。

替换方法

1	public Matcher appendReplacement(StringBuffer sb, String replacement)
实现非终端添加和替换步骤。
2	public StringBuffer appendTail(StringBuffer sb)
实现终端添加和替换步骤。
3	public String replaceAll(String replacement)
 替换模式与给定替换字符串相匹配的输入序列的每个子序列。
4	public String replaceFirst(String replacement)
 替换模式与给定替换字符串匹配的输入序列的第一个子序列。
5	public static String quoteReplacement(String s)
返回指定字符串的字面替换字符串。这个方法返回一个字符串

第八章集合类型

一、课前预习

1.简述集合与数组的区别。

2.简述在Java集合框架里分别都有哪些接口以及哪些常用的实现类。

3.简述 Set、List、Map这三种集合类型的区别。

4.简述Set、List、Map集合分别都有哪些常用的方法?

5.简述Collections 算法类有哪些常用的方法?

6.简述如何使用迭代器循环遍历集合。

7.简述定义集合时指定了泛型的好处是什么?

二、概述

三、泛型

四、对象集合

1、数组（Array）

2、集（set）

3、顺序列表（List）

4、映像（Map）

5、迭代器（Iterator）

五、对象集合

1、类型框架主要接口

1）Collection

2、Collection接口

3、List接口

4、Set接口

5、

6、

7、

8、

9、

10、

第九章输入输出流

一、课前预习

1.简述File类有哪些常用的方法及它们

2.简述字节流与字符流的区别。

3.简述都有哪些类属于字节流，又有哪些类属于字符流?

4.简述字节流和字符流都有哪些常用的方法?

5.简述什么是对象的序列化和反序列化?

6.简述进行对象序列化的步骤。

二、概述

本章主要内容:

(1)．File类的相关操作

(2)．字节流的基本操作

(3)．字符流的基本操作

(4)．对象序列化

三、操作文件的类--File

1、File类的基本介绍

1）构造函数

File(String path) 文件(相对路径),移植性较好: File f1 = new File(“mydir\myfile.txt”); 目录(绝对路径): File f2 = new File(“d:\mydir\dir1”);

File(String parent, String child )

文件路径以及文件名： File f3 = new File(“d:\d1” , “a.java”);

File(File dir, String name)

文件对象与文件名：File f4 = new File(f2 , “myfile.txt”);

2）主要方法常用方法

canRead()、canWrite()、delete()、equals(object)、exists() getAbsolutePath() 和 length()

1.判断目标是否存在：public boolean exists()

2.判断是否是文件public boolean isFile();

3.判断是否是目录public boolean isDirectory();

4.获取文件名称public String getName() 仅返回文件名

5.获取整个路径public String getPath() 返回整个路径字符串

6.获取文件长度/返回文件的大小 public long length()

7.获取文件读属性 public boolean canRead()

8.获取文件写属性public boolean canWrite()

9.列出目录中的文件 public String[] list()

10.创建新文件 public boolean createNewFile() throws IOException

11.删除文件 public boolean delete()

12.列出指定目录的全部内容,只是列出了名称 public String[] list()

13、列出指定目录的全部内容,会列出路径 public File[] listFiles()

14、创建一个目录 public boolean mkdir()

15、为已有的文件重新命名 public boolean renameTo (File dest)

2、使用File类操作文件

1）创建一个新文件

2）删除一个指定文件

===============================================

1、字符串

1）String类

public class TestString {

	public static void main(String[] args) {
		// 创建字符串
		String s1 = "hello";
		String s2 = new String("hello");
		String s3 = "hello";
		
		//System.out.println(s1.charAt(0));//首字母
		System.out.println(s1 == s3); // true  (比较的是地址是否相等)
		System.out.println(s1 == s2); // false
		System.out.println(s1 == s2.intern()); // true (将s2纳入常量池来管理)
		System.out.println(s1.equals(s2)); // true（比较值是否相等）equals是比较对应的字符是否相同
		
		// 当定义一个字符串对象后，再针对它做任何修改的操作，这个对象是不会改变内容，
		// 会得到一个新的字符串对象 （字符串不可变）
		String s4 = "hello";
		for (int i = 0; i < 10000; i++) {
			s4 += "a";
		}
		// 那么，针对String类型的字符串对象，不要进行频繁的修改操作，因为可能出现很多字符串对象，浪费存储空间
		
	}
}

2）StringBuilder类

public class TestString {	
	
	public static void main(String[] args) {

		// 可变字符串类：
		// StringBuilder：线程不安全的，一般用在单线程环境中
		// StringBuffer：线程安全，可以用在多线程环境中
		StringBuffer sb = new StringBuffer("hello"); // 定义字符串对象
		System.out.println(sb.capacity()); // 容量 21
		System.out.println(sb.length());  // 长度 5
		for (int i = 0; i < 10000; i++) {
			sb.append("a"); // 进行修改操作时，不会生成新的字符串对象
		}
		System.out.println(sb);
	}

}

posted @ 2024-02-29 08:11 一只菜喵程序媛阅读(19) 评论(0) 收藏举报

刷新页面返回顶部

一只菜喵程序媛

用0和1编织世界，用代码敲出浪漫

Java程序编程（十）

面向对象设计7大原则

第二章 Java语言基础与流程控制

TowCase-1 1

1、向控制台输出字符串

2、数据类型

（1）基本数据类型

A、整型：int

二进制

八进制

十六进制

十进制

长整型：long 数值后加L

B、单字符型：char 可以表示汉字 数值用单引号

C、float和double可能存在精度丢失

单精度浮点：float

双精度浮点：double

D、布尔型：boolean

（2）对象数据类型 ：String

3、类型转换

(1)byte<short<int<long<....

(2)自动转换：左边类型大 = 右边类型小

(3)强制转换：左边类型小 = （目标类型）右边类型大

4、变量

（1）定义变量

变量的值是可以变化的

（2）定义常量：固定不变的量，常量名全部大写，多个单词用下划线隔开

A、定义常量关键字：final

常量值不能被修改

B、变量必须赋值后才能使用

5、变量的作用域:

6、扫描仪：Scanner

TowCase-2 1

步骤

（1）导入

（2）定义一个扫描仪

（3）输入一个人的学号、姓名、身高

A、接受整数

B、接受字符串

C、接受单精度

（4）输出

（5）关闭扫描仪

7、运算符

（1）单目运算符

（2）双目运算符

（3）三目运算符

（4）运算符优先级，从高到低

（5）转义字符

TwoCase-3 2 SecDemo

（1）赋值运算符: =、 +=、-=、*=、\=、%=

（2）算术运算符：+、-、*、/、%、++、--

A、+ : 加法、字符串连接

B、/：除数

除数不能为整数0

Infinity 正无穷大

-Infinity 负无穷大

非数字

C、%： 求余数，取模运算 (商为整数，剩下部分就是余数)

D、 ++、--：后缀、前缀

后缀优先级最低，最后算

前缀优先级很高，要先算

（3）关系运算符: >、>=、<、<=、==、!=

浮点型可能会产生精度丢失，所以一般等于的比较不用于浮点型数据

（4）逻辑运算符： &&、||、!

短路运算

与运算第一个式子不成立，后面式子不计算

或运算第一个式子成立，后面式子不计算

（5） 条件运算符

（1）表达式1?表达式2:表达式3

当表达式1成立时，将表达式2作为结果；当表达式1不成立时，将表达式3作为结果。相当于if...else结构

（2）<< ：左移位数 << ：右移位数

8、if有3种形式

输入两个数，判断两个的关系

（1）if第一种形式

嵌套结构

（2）if...else:第二种形式

（3）if...else if结构：第三种形式

9、switch:开关语句

B、单字符型：char 可以表示汉字数值用单引号

（2）对象数据类型：String

C、%：求余数，取模运算 (商为整数，剩下部分就是余数)

（5）条件运算符

（3）break：结束循环

（4）continue：跳过本次循环后面的语句，去执行下一次循环（5）二重循环结构

b 第二种方法长度根据数据个数确定，不能直接指定长度

1、用数组输入5个人的年龄

（4）for遍历 i+1 是定位到指定下标数组的值接受整型

（2）相邻元素比较

（2）升序排序并行排序，效率更高 // 如果要降序，需要把数组定义成对象类型

（1）定义下标返回出现位置的下标，没有出现，返回负数

（1）定义数组存储2个班级，每个班5个同学的成绩、

1、第一种写法

3、第三种写法混合写法

（4）遍历所有值

// foreach遍历二维 is表示遍历到的行(每一行是一个一维数组) 遍历行中元素输出所有值