Java基础知识

1. 常用DOC命令

d: 回车 盘符切换

dir (directory) 列出当前目录下的文件及文件夹

md (make directory) 创建目录

rd (remove directory) 删除目录

cd (change directory) 进入指定目录

cd… 退回到上级目录

cd\ 退回到根目录

del (delete) 删除文件 删除后缀名一样的文件 *.txt

exit 退出doc命令行

cls (clear screen) 清屏

2. 三目运算符

2.1. 格式

(比较表达式) ? 条件1 : 条件2;
若表达式为真，执行条件1；若为假，执行条件2；

获取两个整数中的最大值
int x = 3
int y = 4

class Demo{
	public static void main(String[] args){
		int x = 3;
		int y = 4;
		int z = (x > y) ? x : y;
		System.out.println(z);
	}
}

获取三个整数中的最大值
int x = 3
int y = 4
int z = 5

class Demo{
	public static void main(String[] args){
		int x = 3;
		int y = 4;
		int z = 5;
		int a = (x > y) ? x : y;
		int b = (a > z) ? a : z;
		System.out.println(b);
	}
}

3. 键盘录入数据

A:导包

	格式：import java.util.Scanner;
	位置：在class上面

B:创建录入对象

	格式：Scanne sc = new Scanner(System.in);

C:通过对象获取数据

	格式：int x = sc.nextInt();

3.1. 举例

import java.util.Scanner;

public class Demo{
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		System.out.println("请输入一个数据：");
		int x = in.nextInt();
		System.out.println("输入的这个数据：" + x);	
	}
}

4. switch case语句

4.1. 格式

switch(表达式){
		case 值1:
			语句体1;
			break;
		case 值2:
			语句体2;
			break;
		......
		default:
			语句体n+1;
			break;
}

4.2. 案例

根据键盘录入的数据，输出对应的星期；

import java.util.Scanner;

public class Demo{
	public static void main(String[] args){
		System.out.println("请输入今天的日期(一——七)：");
		Scanner sc = new Scanner(System.in);
		String day = sc.nextLine();
		
		switch (day){
			case "一":
				System.out.println("今天星期一");
				break;
			case "二":
				System.out.println("今天星期二");
				break;
			case "三":
				System.out.println("今天星期三");
				break;
			case "四":
				System.out.println("今天星期四");
				break;
			case "五":
				System.out.println("今天星期五");
				break;
			case "六":
				System.out.println("今天星期六");
				break;
			case "七":
				System.out.println("今天星期天");
				break;
			default:
				System.out.println("您输入的日期有误，请重新输入。");
				break;
		}
	}
}

模拟单项选择题

public class Demo{
	public static void main(String[] args){
		System.out.println("下面几个人你最爱谁？");
		System.out.println("1：张三");
		System.out.println("2：李四");
		System.out.println("3：王五");
		System.out.println("4：赵六");
		System.out.println("请输入你的答案(1-4)：");
		int people = sc.nextInt();
		switch(people){
			case 1:
				System.out.println("张三");
				break;
			case 2:
				System.out.println("李四");
				break;
			case 3:
				System.out.println("王五");
				break;
			case 4:
				System.out.println("赵六");
				break;
			default:
				System.out.println("那你输入的答案有误，请重新输入。");
				break;
		} 
	}
}

5. 循环体语句

5.1. for循环语句

5.1.1. 格式

	for(初始化语句;判断条件语句;控制条件语句){
		循环体语句;
	}

5.1.2. 执行流程

	A：执行初始化语句；
	B:执行判断条件语句，看其返回值是true还是false
		如果是true,就继续执行循环；
		如果是false，就结束循环；
	C：执行循环体语句；
	D：执行控制条件语句；
	E：回到B继续；

案例
1.求1到10的和

class ForDemo{
	public static void main(String[] args){
		int sum1 = 0;
		for(int i = 1;i <= 10;i++){
			sum1 = sum1 + i;
		}
		System.out.println("1到10的和:"+sum1);
	}
}

2.求1到100之前的偶数和

class ForDemo{
	public static void main(String[] args){
		int sum2 = 0;
		for(int i = 1;i <= 100;i++){
			if(i % 2 == 0){
				sum2 = sum2 + i;
			}
		}
		System.out.println("1到100之前的偶数和:"+sum2);
	}
}

3.求1到100之前的奇数和

class ForDemo{
	public static void main(String[] args){
		int sum3 = 0;
		for(int i = 1;i <= 100;i++){
			if(i % 2 == 1){
				sum3 = sum3 + i;
			}
		}
		System.out.println("1到100之前的奇数和:"+sum3);
	}
}

4.求5的阶乘

class ForDemo{
	public static void main(String[] args){
		int jiecheng = 1;
		for(int i = 1;i <= 5;i++){
			jiecheng = jiecheng * i;
		}
		System.out.println("5的阶乘是："+jiecheng);
	}
}

5.控制台输出所有的水仙花数,并且统计水仙花数的个数；
分析：水仙花数是指一个三位数，其各位数字的立等于该数本身；
例如：153就是一个水仙花数 153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3

class ForDemo{
	public static void main(String[] args){
		int count = 0;
		for(int i = 100;i < 1000;i++){
			int ge = i / 1 % 10;
			int shi = i / 10 % 10;
			int bai = i / 100 % 10;
			if(i == ge*ge*ge + shi*shi*shi + bai*bai*bai){
				count++;
				System.out.println("水仙花数字有："+ i);
			}
		}
		System.out.println("水仙花数的个数有"+count+"个");
	}
}

5.2. while循环语句

5.2.1. 基本格式

	while(判断条件语句){
				循环体语句;
			}

5.2.2. 扩展格式

	初始化语句;
	while(判断条件语句){
				循环体语句；
				控制条件语句；
			}

通过这个格式，我们可以看到其实和for循环差不多的。

	for(初始化语句;判断条件语句;循环条件语句){
				循环体语句;
	}

需求：用for循环与while循环比较控制台输出所有的水仙花数,并且统计水仙花数的个数；
分析：水仙花数是指一个三位数，其各位数字的立等于该数本身；
例如：153就是一个水仙花数 153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3

public class WhileDemo{
	public static void main(String[] args){
		//for循环格式
		int count = 0;
		for(int i = 100;i < 1000;i++){
			int a = i / 100;
			int b = (i % 100) / 10;
			int c = i % 10;
			if(i == a*a*a + b*b*b + c*c*c){
				count++;
				System.out.println("水仙花数字有："+ i);
			}
		}
		System.out.println("水仙花数的个数有"+count+"个");
		System.out.println("-------------");
		//--------------------------------------------------------
		//While循环格式
		int count = 0;
		int x = 100;
		while(x < 1000){
			int a = x / 100;
			int b = (x % 100) / 10;
			int c = x % 10;
			if(x == a*a*a + b*b*b + c*c*c){
				count++;
				System.out.println("水仙花数字有："+ x);
			}
			x++;
		}
		System.out.println("水仙花数字有："+ count +"个");
	}
}

5.3 do…while循环语句

基本格式

	do{
		循环体语句;
	}while(判断条件语句);

扩展格式

	do{
		循环体语句;
		控制条件语句;
	}while(判断条件语句);

5.4 循环的嵌套

1：输出一个四行五列的星星（*）图案；

public class ForForDemo{
	public static void main(String[] args){
		for(int i = 1;i <= 4;i++){
			for(int j = 1;j <= 5;j++){
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

2：输出如下图形：
*
**
***
****
*****

public class ForForDemo{
	public static void main(String[] args){
		for(int i = 1;i <= 5;i++){
			for(int j = 1;j <= i;j++){
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

3：打印九九乘法表。

public class ForForDemo{
	public static void main(String[] args){
		for(int i = 1;i <= 9;i++){
			for(int j = 1;j <= i;j++){
				System.out.print(j + " * " + i + " = " + (i * j) + "\t");
			}
			System.out.println();
		}
		System.out.println("---------------------");
	}
}

6. 数组

6.1. 一维数组

6.1.1. 数组的定义

数组是存储同一种数据类型多个元素的集合，也可以看做是一种容器。
数组既可以存储基本数据类型，又可以存储引用数据类型。

6.1.2. 定义格式

	A：数据类型[] 数组名;
	B：数据类型   数组名[];

6.1.3. 举例

	int[] a;  定义一个int类型的数组a变量；
	int a[];  定义一个int类型的a数组变量；

注意：效果可以认为是一样的，都是定义一个int类型的数组，推荐使用第一种；

public class ArrayDemo1{
	public static void main(String[] args){
		int[] arr1 = new int[4];
		/*
		左边：
			int:说明数组中的元素的数据类型是int类型；
			[]：说明这是一个数组；
			arr1：是数组的名称；
		右边：
			new：为数组分配内存空间；
			int：说明数组中的元素的数据类型是int类型；
			[]：是数组的名称；
			4：数组长度，就是数组中元素的个数；
		*/
		arr1[0] = 2;
		arr1[1] = 4;
		arr1[2] = 6;
		arr1[3] = 8;
		System.out.println(arr1);
		System.out.println(arr1[0]);
		System.out.println(arr1[1]);
		System.out.println(arr1[2]);
		System.out.println(arr1[3]);
	}
}

6.1.4. 如何对数组进行初始化呢？

6.1.4.1. 何为初始化？

	就是为数组开辟内存空间，并为每个数组元素赋予值。

6.1.4.2. 有几种初始化方式？

	a：动态初始化：只指定长度，由系统给定初始化值；
	b：静态初始化：给定初始化值，由系统决定长度；

6.1.4.2.1. 动态初始化格式：

	格式：数据类型[] 数组名 = new 数据类型[数组长度];
		举例：int[] arr = new int[3];

6.1.4.2.2. 静态初始化格式：

	格式：数据类型[] 数组名 = new int[]{元素1,元素2....};
	简化版格式：数据类型[] 数组名 = {元素1,元素2,....};
		举例：
			int[] arr = new int[]{1,2,3...};
			int[] arr = {1,2,3......};
		注意：不要动态和静态同时进行
		如下格式：int[] arr = new int[3]{1,2,3};	//错误。

6.1.5. 一维数组遍历：依次输出数组中的每一个元素

public class BianLi{
	public static void main(String[] args){
		//用遍历的方法进行打印
		int[] arr3 = {22,33,44,55,66,77,11,22,33,32,34};
		arrBianLi(arr3);
	}
	
	//定义一个遍历方法
	public static void arrBianLi(int[] arr){
		System.out.print("[");
		for(int i = 0;i < arr.length;i++){
			if(i == arr.length - 1){
				System.out.print(arr[i] + "]");
			}else{
				System.out.print(arr[i] + ",");
			}
		}
	}
}

6.1.6. 一维数组获取最值（最大值或者是最小值）

public class MaxMin{
	public static void main(String[] args){
		int[] arr1 = {2,4,1,7,9,6};
		
		//求该数组的最大值。
		int max = arr1[0];
		for(int i = 1;i < arr1.length;i++){
			if(arr1[i] > max){
				max = arr1[i];
			}
		}
		System.out.println("这个数组的最大值：" + max);
		
		//求该数组的最小值。
		int min = arr1[0];
		for(int i = 1;i < arr1.length;i++){
			if(arr1[i] < min){
				min = arr1[i];
			}
		}
		System.out.println("这个数组的最小值：" + min);
		
		int[] arr2 = {2,4,33,42,12,32,1,7,87};
		getMin(arr2);
		getMax(arr2);
	}
	
	//定义一个求数组最大值的方法
	public static void getMax(int[] arr){
		int max = arr[0];
		for(int i = 1;i < arr.length;i++){
			if(arr[i] > max){
				max = arr[i];
			}
		}
		System.out.println("这个数组的最大值：" + max);
	}
	
	//定义一个求数组最小值的方法
	public static void getMin(int[] arr){
		int min = arr[0];
		for(int i = 1;i < arr.length;i++){
			if(arr[i] < min){
				min = arr[i];
			}
		}
		System.out.println("这个数组的最小值：" + min);
	}
}

6.1.7. 一维数组元素查找（查找指定元素第一次在数组中出现的索引）

public class ArrayFind{
	public static void main(String[] args){
		int[] arr1 = {2,3,34,45,55,43,22};
		int index1 = getFind(arr1,55);
		System.out.println("您查找的索引值为：" + index1);
	}
	
	//定义一个元素查找的方法
	public static int getFind(int[] arr,int x){
		for(int i = 0;i < arr.length;i++){
			if(x == arr[i]){
				return i;
			}
		}
		return -1;
	}
}

6.1.8. 一维数组元素逆序（就是把数组中的元素倒过来）

public class NiXu{
	public static void main(String[] args){
		int[] arr1 = {1,23,3,24,56,7,78};
		System.out.print("逆序前：");
		arrBianLi(arr1);
		System.out.println();
		reverse(arr1);
		System.out.print("逆序后：");
		arrBianLi(arr1);
	}
	
	//定义一个逆序方法
	public static void reverse(int[] arr){
		for(int i = 0;i < arr.length / 2;i++){		//在这里去一半就可以，全部的话就会变回来。
			int temp = 0;
			temp = arr[i];
			arr[i] = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = temp;
		}
	}
	
	//定义一个遍历方法
	public static void arrBianLi(int[] arr){
		System.out.print("[");
		for(int i = 0;i < arr.length;i++){
			if(i == arr.length - 1){
				System.out.print(arr[i] + "]");
			}else{
				System.out.print(arr[i] + ",");
			}
		}
	}
}

6.2. 二维数组

6.2.1. 定义

就是元素为一位数组的一个数组

6.2.2. 格式1：

	数据类型[][] 数组名 = new 数据类型[m][n];
		m：表示这个二维数组有多少个一位数组。
		n：表示每一个一维数组的元素有多少个。
	注意：
		A：以下格式也可以表示二维数组：
			a：数据类型 数组名[][] = new 数据类型[m][n];
			b：数据类型[] 数组名[] = new 数据类型[m][n];
		B：注意下面定义的区别：
			int x;
			int y;
			int x,y;
		
			int[] x;
			int[] y[];
			int[] x,y[];

6.2.3. 格式2：

	数据类型[][] 数组名 = new 数据类型[m][];
		m：表示这个二维数组有多少个一位数组。
		一维数组没有给出，可以动态给。这一次是一个动态的一位数组。

6.2.4. 格式3：

	基本格式：
		数据类型[][] 数组名 = new 数据类型[][]{{元素1，元素2...},{元素1，元素2...},{元素1，元素2...}};
	简化版格式：
		数据类型[][] 数组名 ={{元素1，元素2...},{元素1，元素2...},{元素1，元素2...}};
		
	举例：
		int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
		int[][] arr = {{1,2,3},{4,5},{6}};

6.3. 二维数组与一位数组的比较

public class Array2Demo1{
	public static void main(String[] args){
		//-------------------------------------------------------------------
		//定义一个二维数组
		int[][] arr1 = new int[3][2];
		/*
			定义了一个二维数组
			这个二维数组有3个一维数组的元素
			每个一维数组有2个元素
		*/
		
		//输出二维数组的名称
		System.out.println(arr1);	//[[I@15db9742
		//输出二维数组的第一个元素的一位数组的名称
		System.out.println(arr1[0]);	//[I@6d06d69c
		System.out.println(arr1[1]);	//[I@7852e922
		System.out.println(arr1[2]);	//[I@7852e922
		//输出二维数组的元素
		System.out.println(arr1[0][0]);
		System.out.println(arr1[0][1]);
		System.out.println("----------------------------");
		
		//--------------------------------------------------------------------
		//定义一个二维数组
		int[][] arr2 = new int[3][];
		
		System.out.println(arr2);		//[[I@70dea4e
		System.out.println(arr2[0]);	//null
		System.out.println(arr2[1]);	//null
		System.out.println(arr2[2]);	//null
		//动态为每一个一维数组分配内存空间
		arr2[0] = new int[2];
		arr2[1] = new int[3];
		arr2[2] = new int[5];
		
		System.out.println(arr2[0]);	//[I@5c647e05
		System.out.println(arr2[1]);	//[I@33909752
		System.out.println(arr2[2]);	//[I@55f96302
		
		System.out.println(arr2[0][0]); //0
		System.out.println(arr2[0][1]); //0
	}
}

6.3.1. 二维数组的遍历

外循环控制的就是二维数组的长度，其实就是一位数组的个数
内循环控制的就是一位数组的长度。

public class Array2BianLi{
	public static void main(String[] args){
		//静态初始化一个二维数组
		int[][] arr1 = {{1,3,5},{2,4,6},{21,32},{23,43},{65,46,88,9}};
		BianLi(arr1);
		System.out.println("----------------------------------");
		
		//动态初始化一个二维数组
		int[][] arr2 = new int[2][5];
		arr2[0][0] = 1;
		arr2[0][1] = 2;
		arr2[0][2] = 3;
		arr2[1][0] = 7;
		arr2[1][1] = 8;
		arr2[1][2] = 9;
		BianLi(arr2);
		System.out.println("----------------------------------");
	}
	
	//定义一个遍历二维数组的方法
	public static void BianLi(int[][] arr){
		System.out.print("[");
		for(int i = 0;i < arr.length;i++){
			System.out.print("[");
			for(int n = 0;n < arr[i].length;n++){
				if(n != arr[i].length - 1){
					System.out.print(arr[i][n] + ",");
				}else{
					System.out.print(arr[i][n] + "]");
				}
			}
		}
		System.out.println("]");
	}
}

6.3.2. 例：公司年销售额求和

某公司按照季度和月份统计的数据如下：单位（万元）
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

public class GetSum{
	public static void main(String[] args){
		int[][] arr1 = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
		BianLi(arr1);
		int arr1Sum = getSum(arr1);
		System.out.println("公司年销售额为：" + arr1Sum);
	}
	
	//定义一个遍历二维数组的方法
	public static void BianLi(int[][] arr){
		System.out.print("[");
		for(int i = 0;i < arr.length;i++){
			System.out.print("[");
			for(int n = 0;n < arr[i].length;n++){
				if(n != arr[i].length - 1){
					System.out.print(arr[i][n] + ",");
				}else{
					System.out.print(arr[i][n] + "]");
				}
			}
		}
		System.out.println("]");
	}
	
	//定义一个二维数组求和的方法
	public static int getSum(int[][] arr){
		int sum = 0;
		for(int i = 0;i < arr.length;i++){
			for(int j = 0;j < arr[i].length;j++){
				sum += arr[i][j];
			}
		}
		return sum;
	}
}

7. 构造方法

7.1. 作用：给对象的数据进行初始化

7.2. 格式

	A：方法名与类名相同
	B：没有返回值类型，连void也没有
	C：没有具体的返回值

7.3. 注意事项

	A：如果我们没有给出构造方法，系统将自动提供一个无参构造方法
	B：如果我们给出了构造方法，系统将不会再提供默认的无参构造方法

7.4. 给成员变量赋值有两种方法

	A：setXxx();
	B：构造方法

7.5. 类的组成

成员变量，成员方法
我们又加入了新的成员：构造方法
以后再提类的组成：
		成员变量
		构造方法
		成员方法

7.6. 一个标准代码的最终版

	学生类：
		成员变量：
			name,age
		构造方法：
			无参，带两参
		成员方法：
			getXxx()/setXxx()
			show():输出该类的所有成员变量值

//创建一个学生类
class Student{
	private String name;
	private int age;
	
	//构造方法
	public Student(){}		//无参构造方法
	public Student(String name,int age){		//带参构造方法
		this.name = name;
		this.age = age;
	}
	
	//setXxx()/getXxx()方法
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
	
	//输出该类的所有成员变量值的show()方法
	public void show(String name,int age){
		System.out.println("姓名：" + name + "\n" + "年龄：" + age);
	}
}

//创建一个学生类的测试类
public class ConstructDemo{
	public static void main(String[] args){
		//创建一个学生对象
		Student stu1 = new Student();				//无参构造方法创建对象
		Student stu2 = new Student("李四",24);		//有参构造方法创建对象
		
		stu1.setName("张三");
		stu1.setAge(12);
		System.out.println("姓名：" + stu1.getName() + "\n" + "年龄：" + stu1.getAge());
		System.out.println("--------------------------");
		stu1.show(stu1.getName(),stu1.getAge());
		System.out.println("--------------------------");
		System.out.println("姓名：" + stu2.getName() + "\n" + "年龄：" + stu2.getAge());
		System.out.println("--------------------------");
		stu2.show("李四",24);
	}
}

8. static关键字

static的特点：可以修饰成员变量，还可以修饰成员方法

	A：随着类的加载而加载
			回想main方法
	B：优先于对象存在
	C: 被类的所有对象共享
		举例：咱们班的学生应该共用同一个班级编号
			这个特点也是告诉我们什么时候使用静态？
				如果某个成员变量是被所有对象共享的，那么他就应该定义成静态的
		举例：饮水机（使用静态）
			  水杯（不能使用静态修饰）
	D：可以通过类名调用
		其实他本身也是可以通过对象名调用
		推荐使用类名调用

静态修饰的内容一般我们称其为：与类相关的，类成员。

static关键字的注意事项：
	A：在静态方法中是没有this关键字的
		如何理解？
		静态是随着类的加载而加载，this是随着对象的创建而创建存在。
		静态比对象先存在
	B：静态方法只能访问静态的成员变量和静态的成员方法
	    静态方法：
			成员变量：只能访问静态变量
			静态方法：只能访问静态成员方法
		非静态方法：
				成员变量：可以使静态的，也可以是非静态的
				成员方法：可以是静态的成员方法，也可以是非静态的成员方法

简单记：静态只能访问静态

9. 猜数小游戏

分析：
	A：程序产生一个随机数（被猜的）
	B：键盘录入数据（你猜的）
	C：把你猜的和被猜的进行比较
		a：大了
		b：小了
		c：猜中了
	D：给出多次猜的机会，猜中就结束
		while()循环，猜中就break

import java.util.Scanner;

public class GuessDemo{
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		
		int number = (int)((Math.random() * 100) + 1);		//随机产生的0——100的一个数字
		while(true){
			System.out.println("请输入一个你猜出的数字（0-99之间）：");
			int guessNum = in.nextInt();
			
			if(guessNum < number){
				System.out.println("您输入的数字" + guessNum +"小了，请重新输入");
			}else if(guessNum > number){
				System.out.println("您输入的数字" + guessNum +"大了，请重新输入");
			}else{
				System.out.println("恭喜您猜对了！");
				break;
			}
		}
	}
}

10. 代码块

代码块：在java中，使用{}括代码称为构造代码块

根据其位置和声明的不同，可以分为：

局部代码块：局部位置，用于限定变量的生命周期,及早释放，提高内存利用率。

构造代码块：在类中的成员位置，用{}括起来的代码。每次调用构造方法执行之前，都会先执行构造代码块

	在构造方法执行之前执行。

	作用：可以把多个构造方法中相同的代码放到一起，对对象进行初始化。

静态代码块：在类中的成员位置，用{}括起来的代码，只不过用static修饰了。

	在构造代码块执行之前执行，并且只执行一次。
	
	作用：一般是对类进行初始化。

总结：

	静态代码块（只执行一次）—>构造代码块（每次调用构造方法都执行）—>构造方法

11. 继承

11.1. 继承概述

把多个类中相同的内容给提取出来定义到一个类中。

11.2. 如何实现类的继承

java提供了关键字extends

11.3. 继承的格式

class 子类名 extends 父类名{}

11.4. 继承的好处

A：提高了代码的复用性
B：提高了代码的维护性
C：让类与类之前产生关系，是多态的前提

类与类之前产生关系，其实也是继承的一个弊端：类的耦合性增强了

开发原则：低耦合，高内聚。
耦合：类与类的关系
内聚：就是自己完成某件事情的能力

11.5. 学生案例和老师案例的继承练习

学生：
	成员变量：姓名，年龄
	构造方法：无参，带参
	成员方法：getXxx()/setXxx()
老师:
	成员变量：姓名，年龄
	构造方法：无参，带参
	成员方法：getXxx()/setXxx()
	
人类：
	成员变量：姓名，年龄
	构造方法：无参，带参
	成员方法：getXxx()/setXxx()

public class ExtendsTest{
	public static void main(String[] args){
		//学生类的测试
		Student s1 = new Student();
		s1.setName("张三");
		s1.setAge(23);
		Student s2 = new Student("李四",24);
		System.out.println(s1.getName() + "的年龄是" + s1.getAge());
		System.out.println("----------------------");
		System.out.println(s2.getName() + "的年龄是" + s2.getAge());
		//老师类的测试
		Teacher t1 = new Teacher();
		t1.setName("王五");
		t1.setAge(25);
		Teacher t2 = new Teacher("赵六",26);
		System.out.println(t1.getName() + "的年龄是" + t1.getAge());
		System.out.println("----------------------");
		System.out.println(t2.getName() + "的年龄是" + t2.getAge());
	}
}

//定义一个人类
class Person{
	private String name;
	private int age;
	
	//无参构造方法
	public Person() {}
	//带参构造方法
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	//setXxx()/getXxx()方法
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
}

//定义一个学生类并继承人类
class Student extends Person{
	public Student() {};
	public Student(String name,int age){
		super(name,age);
	}
}
//定义一个老师类并继承人类
class Teacher extends Person{
	public Teacher() {};
	public Teacher(String name,int age){
		super(name,age);
	}
}

11.6. this和super的区别

11.6.1. 分别是什么

	this代表本类对应的应用
	super代表父类存储空间的标识（可以理解为父类的引用，可以操作父类成员）

11.6.2. 怎么用呢

	A：调用成员变量
		this.成员变量 调用本类的成员变量
		super.成员变量 调用父类的成员变量
	B：调用构造方法
		this(...)	调用本类的构造方法
		super(...)	调用父类的构造方法
	C：调用成员方法
		this.成员方法	调用本类的成员方法
		super.成员方法	调用父类的成员方法

11.7. 继承中构造方法的关系

	子类中所有的构造方法都会默认访问父类中空参数的构造方法

11.7.1. 为什么呢？

	因为子类会继承父类中的数据，可能还会使用父类中的数据。
	所以子类初始化之前，一定要先完成父类数据的初始化

注意：子类中的每一个构造方法的第一条语句默认是：super()；

11.7.2. 继承中构造方法的关系的演示

public class ExtendsDemo{
	public static void main(String[] args){
		Son s1 = new Son();		//无参构造方法
		System.out.println("---------------------------------");
		Son s2 = new Son("张三");	//带参构造方法
	}
}

class Father{
	int age;
	
	public Father(){
		System.out.println("Father的无参构造方法");		
	}
	public Father(String name){
		System.out.println("Father的带参构造方法");	
	}
}

class Son extends Father{
	public Son(){
		//super();
		System.out.println("Son的无参构造方法");	
	}
	public Son(String name){
		//super();
		System.out.println("Son的带参构造方法");	
	}
}

11.8. 继承中成员方法的关系：

11.8.1. 方法重写：

	子类中出现了和父类方法声明一模一样的方法。

11.8.2. 方法重载

	本类中出现了方法名一样，参数列表不同的方法，与返回值无关。

11.8.3. 方法重写的应用

	当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法；
	这样，既沿袭了父类的功能，又定义了子类特有的内容。

11.8.4. 方法重写的注意事项

	A：父类中的私有方法不能被重写
		  因为父类私有方法，子类根本无法被继承
	B：子类重写父类方法时，访问权限不能更低（可以更高）
		  最好保持一致
	C：父类静态方法，子类也必须通过静态方法进行重写
		  其实这算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中会讲解；
	子类重写父类方法的时候，声明最好一模一样；

12. final关键字

方法重写中，子类可以重写父类中的方法，如果父类不想让子类重写自己的方法，可以提供一个关键字：final

	final:最终的意思，常见的是他可以修饰类，方法，变量。

12.1. final修饰类，方法，变量的特点

	final修饰类：该类不能被继承。
	final修饰方法：该方法不能被重写。
	final修饰变量：该变量不能被重新赋值，因为这个变量其实就是常量。

12.2. 常量

	A：字面值常量："hello",10,true
	B：自定义常量：final int x = 10;

12.3. final修饰局部变量的特点

	基本类型：基本类型的值不能发生改变
	引用类型：引用类型的地址值不能发生改变。但是，该对象的堆内存里的值是可以改变的。

12.4. final修饰变量初始化时机

	A：被final修饰的变量只能赋值一次。
	B：在构造方法完毕之前（非静态的常量）

13. 多态

13.1. 定义

	同一个对象，在不同时刻体现出来的不同形态。

13.2. 举例

	从右往左念
	猫是猫：Cat c = new Cat();
	猫是动物：Animal a = new Cat();

13.3. 多态的前提

	A：要有继承关系
	B：要有方法重写
	C：要有父类引用指向子类对象
		  父 f = new 子();

13.4. 多态中的成员访问特点：

1. 成员变量

   编译看左边，运行看左边。
   

2. 构造方法

   创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
   

3. 成员方法

   编译看左边，运行看右边。
   由于方法存在方法重写，所以，运行看右边。
   

4. 静态方法

   编译看左边，运行看左边。
   	（静态和类相关，算不上重写，所以，访问还是左边的）
   

13.5. 多态的好处：

	A：提高代码的维护性（继承保证）
	B：提高代码的扩展性（多态保证）

提高代码扩展性代码演示

class DuoTaiDemo{
	public static void main(String[] args){
		Cat c1 = new Cat();
		AnimalTool.useAnimal(c1);
		System.out.println("----------");
		Dog d1 = new Dog();
		AnimalTool.useAnimal(d1);
	}
}

//创建一个动物工具类
class AnimalTool{
	private AnimalTool() {}		//将无参构造封装，不允许创建动物工具类对象
	//运用多态接收动物就可以
	public static void useAnimal(Animal a){
		a.eat();
		a.sleep();
	}
}

class Animal{
	public void eat(){
		System.out.println("吃饭");
	}
	public void sleep(){
		System.out.println("睡觉");
	}
}
class Cat extends Animal{
	public void eat(){
		System.out.println("猫吃鱼");
	}
	public void sleep(){
		System.out.println("猫躺着睡觉");
	}
}
class Dog extends Animal{
	public void eat(){
		System.out.println("狗吃肉");
	}
	public void sleep(){
		System.out.println("狗站着睡觉");
	}
}
class Pig extends Animal{
	public void eat(){
		System.out.println("猪吃白菜");
	}
	public void sleep(){
		System.out.println("猪侧着睡觉");
	}
}

13.6. 多态的弊端：

	因为编译看左边，运行看右边，所以多态不能使用子类特有的功能，只能使用父类定义过的功能。

13.6.1. 针对多态中的弊端如何使用子类的特有功能呢？

A：创建子类对象调用即可。（可以，但是大多时候不合理，而且太占内存了）
B：把父类的引用强制转换成子类的引用（向下转型）
	对象间的转型问题：
			向上转型：父类引用指向子类对象
				Fu f = new Zi();
			向下转型：父类引用转为子类对象
				Zi z = (Zi)f;	//要求该f必须是能够转换为Zi的。

13.7. 多态继承中的内存图解

注意：栈区中方法应该是先进后出。

13.8. 多态中对象的变化的内存图解

注意

 1. 栈区中方法应该是先进后出
 2. ClassCastException：类型转换异常；一般在多态的向下转型中容易出现。（出现此问题时编译没有错误）

14. 抽象类

14.1. 抽象类的概述

动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的。

我们把不是一个具体的功能定义为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。

14.2. 抽象类的特点

1. 抽象类和抽象方法必须用abstract关键字修饰
2. 抽象类中不一定有抽象方法，但是有抽象方法的类必须定义为抽象类
3. 抽象类不能实例
	因为它不是具体的
	抽象类中有构造方法，但是不能实例化。那构造方法的作用是什么呢？
		用于子类访问父类数据的初始化
4. 抽象类的子类
	a：如果不想重写抽象方法，该子类是一个抽象类
	b：重写所有的抽象方法，这个时候子类是一个具体的类

抽象类的实例化其实是靠具体的子类实现的。是多态的方式。
Animal a = new Cat();

14.3. 抽象类的成员特点

 1. 成员变量：既可以是变量，也可以是常量；
 2. 构造方法：有。
		用于子类访问数据的初始化；
 3. 成员方法：既可以是抽象的，也可以是非抽象的；
 4. 抽象类的成员方法特性：
		A：抽象方法：强制子类要求做的事；
		B：非抽象方法：子类继承的事情，提高代码的复用性。

一个类没有抽象方法，可以定义为抽象类，目的是不让创建对象。

14.4. 猫狗案例

具体事物：猫狗
共性：姓名，年龄，吃饭；

//定义一个抽象的方法类
abstract class Animal{
	private String name;
	private int age;
	
	//构造方法
	public Animal(){}
	public Animal(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
	
	//定义一个吃的抽象方法
	public abstract void eat();
} 

//定义一个具体的猫类，并且继承动物类
class Cat extends Animal{
	public Cat(){}
	public Cat(String name,int age){
		super(name,age);
	}
	
	public void eat(){
		System.out.println("猫吃鱼");
	}
}
//定义一个具体的狗类，并且继承动物类
class Dod extends Animal{
	public Dog(){}
	public Dog(String name,int age){
		super(name,age);
	}
	
	public void eat(){
		System.out.println("狗吃肉");
	}
}
public class AbstractDemo1{
	public static void main(String[] args){
		//方式一
		System.out.println("---------------------");
		Cat a1 = new Cat();
		a1.setName("Tom");
		a1.setAge(12);
		System.out.println("姓名：" + a1.getName() + "\t" + "年龄：" + a1.getAge());
		a1.eat();
		//方式二
		System.out.println("---------------------");
		Animal a = new Cat();
		a.setName("Jarry");
		a.setAge(13);
		System.out.println("姓名：" + a.getName() + "\t" + "年龄：" + a.getAge());
		a.eat();
	}
}

14.5. abstract不能和哪些关键字使用？

1. private：	冲突；因为abstract修饰的方法是要求被重写的，而加上private之后就不能够继承并且重写了，所以是冲突的。
2. final：		冲突；因为abstract修饰的方法是要求被重写的，而加上final之后就不能够重写了，所以是冲突的。
3. static：		无意义；因为static修饰的方法是可以通过类名访问的，而abstract修饰的方法是没有方法体的，所以无意义。

15. 接口

15.1. 接口的特点

A：接口用关键字interface表示
	interface 接口名 {}
B：类实现接口用implements表示
	class 类名 implements 接口名 {}
C：接口不能实例
	那么接口如何实例？
	按照多态的方式来实例
D：接口的子类：
	a：可以是抽象类。但是意义不大
	b：可以使具体类。要重写接口中的所有抽象方法。（推荐方案）
E：由此可见（InterfaceDemo2）：
	a：具体类多态（几乎没有）
	b：抽象类多态（常见）
	c：接口类多态（最常见）

15.1.1. 接口特点的演示案例

//定义一个动物培训的接口
interface AnimalTrain{
	public abstract void train();
}

//抽象类实现接口
abstract class Dog implements AnimalTrain{
	
}

//具体类实现接口
class Cat implements AnimalTrain{
	public void train(){
		System.out.println("猫跳高");
	}
}

//定义一个主方法类
class InterfaceDemo1{
	public static void main(String[] args){
		AnimalTrain at = new Cat();
		at.train();
	}
}

15.2. 接口成员特点

 1. 成员变量：只能是常量，而且是静态的
	默认修饰符：public static final
	建议：自己手动给出
	
 2. 构造方法：接口中没有构造方法

 3. 成员方法：只能是抽象方法，没有具体方法（注意与抽象类区别）
	默认修饰符：public abstract
	建议：自己手动给出

15.2.1. 接口成员特点演示案例

interface Inter{
	//接口中以下三种num都是一样的,前两中系统自动给出到第三种的那种完整格式
	public int num1 = 10;
	public final int num2 = 20;
	public static final int num3 = 30;
	
	//接口没有构造方法
	//public Inter(){}
	
	//接口中一下三种成员方法都是一样的，前两中系统自动给出到第三种的那种完整格式
	void show1();
	public void show2();
	public abstract void show3();
}

15.3. 类与类，类与接口，接口与接口之间的关系

 1. 类与类：
		继承关系，只能单继承，可以多层继承

 2. 类与接口：
		实现关系，可以单实现，也可以多实现
		并且还可以继承一个类的同时，实现多个接口

 3. 接口与接口：
		继承关系，可以单继承，也可以多继承

15.3.1. 演示案例

interface Father{
	public abstract void show1();
}

interface Mother{
	public abstract void show2();
}

//接口继承接口（单继承、多继承）
interface Sister extends Father,Mother{
	
}

//类单继承类的同时，实现接口（单实现、多实现）
class Son extends Object implements Father,Mother{
	public void show1(){
		System.out.println("show Father");
	}
	public void show2(){
		System.out.println("show Mother");
	}
}

class InterfaceDemo3{
	public static void main(String[] args){
		Father f = new Son();
		Mother m = new Son();
		
		f.show1();
		//f.show2();		//会报错，应创建Mother多态
		
		//m.show1();		//会报错，应创建Father多态
		m.show2();
		
	}
}

15.4. 抽象类与接口的区别

1. 成员区别：
	抽象类：
		成员变量：可以是变量，也可以是常量
		构造方法：有
		成员方法：可以是抽象，也可以是非抽象
	接口：
		成员变量：只可以是常量
		构造方法：无
		成员方法：只可以是抽象
2. 关系区别：
	类与类：
		继承：单继承
	类与接口：
		实现：单实现，多实现
	接口与接口：
		继承：单继承，多继承
3. 设计理念的区别
	抽象类：被继承体现的是：“is a”的关系。抽象类中定义的是该继承体系的共性功能
	接口：被实现体现的是：“like a”的关系。接口中定义的是该继承体系的扩展功能

15.4.1. 继承、抽象类实现的案例

//定义一个抽象的人类
abstract class Person{
	private String name;
	private int age;
	
	public abstract void eat();
	public void sleep(){
		System.out.println("睡觉");
	}
	
	public Person(){}
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
}
//定义一个老师类并且继承人类
class Teacher extends Person{
	public Teacher(){}
	public Teacher(String name,int age){
		super(name,age);
	}
	
	public void eat(){
		System.out.println("老师吃素");
	}
}
//定义一个抽烟的接口
interface Smoke{
	public abstract void smoke();
}
//定义一个抽烟的老师类继承老师实现抽烟接口
class TeacherSmoke extends Teacher implements Smoke{
	public TeacherSmoke(){}
	public TeacherSmoke(String name,int age){
		super(name,age);
	}
	public void smoke(){
		System.out.println("学生抽烟");
	}
}
//定义一个测试类
class InterfaceDemo{
	public static void main(String[] args){
		TeacherSmoke ts = new TeacherSmoke();
		ts.setName("张三");
		ts.setAge(23);
		System.out.println("姓名：" + ts.getName() + "---" + "年龄：" + ts.getAge());
		ts.eat();
		ts.sleep();
		
	}
}

16. 包

16.1. 包的定义

	package 包名;
	多级包用“.”分隔开即可

16.2. 注意事项

	A：package语句必须是程序的第一条可执行的代码
	B：package语句在一个Java文件中只能有一个
	C：如果没有package默认表示无名包

16.3. 带包编译的运行

	A：手动式
		a：编写一个带包的Java文件。
		b：通过javac命令编译该Java文件。
		c：手动创建包名。
		d：把b步骤的class文件放到c步骤的最底层包
		e：回到和包根目录在同一目录的地方，然后运行
				带包运行
	
	B：自动式
		a:编写一个带包的Java文件
		b：javac编译的时候带上-d即可
			javac -d . HelloWorld.java
		  c：回到和包根目录在同一目录的地方，然后运行
				带包运行

17. 修饰符

17.1. 修饰符

权限修饰符：private,默认的,protected,public
状态修饰符：static,final
抽象修饰符：abstract

17.2.权限修饰符

				本类	同一个包下（子类和无关类）	不同包下（子类）	不同包下（无关类）
private:		Y											
默认:			Y		Y								
protected:		Y		Y							Y
public:			Y		Y							Y					Y

17.3.修饰类的修饰符

权限修饰符：默认的,public
状态修饰符：final（目的：不允许继承）
抽象修饰符：abstract
	用的最多的是：public

17.4. 修饰成员变量的修饰符

权限修饰符：private,默认的,protected,public
状态修饰符：static,final
抽象修饰符：
	用的最多的是：private

17.4. 修饰构造方法的修饰符

权限修饰符：private,默认的,protected,public
状态修饰符：
抽象修饰符：
	用的最多的是：public

17.5. 修饰成员方法的修饰符

权限修饰符：private,默认的,protected,public
状态修饰符：static,final
抽象修饰符：abstract
	用的最多的是：public

17.6. 除此之外的组合规则

成员变量：public static final
成员方法：public static
		 public abstract
		 public final

18. 内部类

18.1. 内部类的概述

把类定义在其他类的内部，这个类就被称为内部类
	举例：把类A中定义了一个类B，类B就是内部类

18.2. 内部类的访问特点

A：内部类可以直接访问外部类的成员，包括私有。
B：外部类要访问内部类的成员，必须创建对象。

18.3. 内部类的位置

成员位置：在成员位置定义的类，被称为成员内部类
局部位置：在局部位置定义的类，被称为局部内部类

18.3.1. 成员内部类

1. 如何直接访问内部类的成员？

   外部类名.内部类名 对象名 = 外部类对象.内部类对象;
   	eg：Outer.Inner oi = new Outer().new Inter();
   

2. 如果成员内部类被静态修饰之后，不可以通过外部的对象访问

   外部类名.内部类名 对象名 = new 外部类名.内部类名();
   	eg：Outer.Inner oi = new Outer.inner();
   

class Outer{
	private int num1 = 10;
	private static int num2 = 100;
	
	//内部类可以用修饰符修饰是因为可以把内部类看作外部类的成员
	public static class Inner{
		public void show1(){
			//System.out.println(num1);		//静态内部类中不能访问非静态数据
			System.out.println(num2);
		}
		
		public static void show2(){
			//System.out.println(num1);		//静态内部类中不能访问非静态数据
			System.out.println(num2);
		}
	}
}

public class InnerClassDemo1{
	public static void main(String[] args){
		//创建有static修饰的成员内部类
		Outer.Inner oi1 = new Outer.Inner();
		oi1.show1();
		oi1.show2();
	}
}

成员内部类被静态修饰创建内部类对象案例：

class Outer{
	public static class Inner{
	}
}

Outer.Inner oi = new Outer.Inner();

3. 成员内部类的修饰符：

   private：为了保证数据的安全性
   static：为了方便访问数据
   	注意：静态内部类访问的外部类数据必须用静态修饰
   

   案例：一个人（人有身体，身体里边有心脏）

class Person{
	private class Heart{
		public void operator(){
				System.out.println("心脏搭桥");
		}
	}
									
	public void method(){
		if(你是一个外科医生){
			Heart h = new Heart();
			h.operator();
		}
	}
}

注意	A：外部类与内部类没有继承关系
		B：通过外部类名限定this对象
			Outer.this.num

18.3.2. 局部内部类

A：可以直接访问外部类成员
B：在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

18.4. 匿名内部类

	就是内部类的简化写法；

1. 前提：存在一个类或者接口
   这里的类可以是具体类也可以是抽象类

2. 格式：

   new 类名或者接口名(){
   		重写方法;
   }
   

3. 本质：

   是一个继承了该类或者实现了该接口的子类匿名对象。
   

18.4.1. 匿名对象的定义与方法的调用

interface Inner{
	public abstract void show();
}

class Outer{
	public void method(){
		Inner i = new Inner(){		//父类对象指向子类：多态
			public void show(){
				System.out.println("show");
			}
		}.show();	//调Inner对象的show方法
		
		i.show();	//也可以这样调用
	};
}

public class InnerClassDemo3{
	public static void main(String[] args){
		Outer o1 = new Outer();
		o1.method();
	}
}

19. StringBuffer类

19.1. StringBuffer的添加功能

1. public StringBuffer append(String str);
   

   可以把任意类型数据添加到字符串缓冲区里边，并返回字符串缓冲区本身

2. public StringBuffer insert(int offset,String str);
   

   可以指定位置把任意类型添加到字符串缓冲区里边，并返回字符串缓冲区本身

package stringBuffer_01;

public class StringBuffer01 {

	public static void main(String[] args) {
		StringBuffer sb1 = new StringBuffer();
		StringBuffer sb2 = sb1.append("hello");

		System.out.println("sb1:" + sb1); // hello
		System.out.println("sb2:" + sb2); // hello

		System.out.println(sb1 == sb2); // true

		// 上面代码等价于：
		StringBuffer sb = new StringBuffer();
		sb.append("hello");
		System.out.println("sb:" + sb);

		StringBuffer sb4 = new StringBuffer();
		sb4.append("hello").append(123);
		System.out.println("sb4:" + sb4);	//hello123
		sb4.insert(5, "world");
		System.out.println("sb4:" + sb4); 	//helloworld123
	}

}

19.2. StringBuffer的删除功能

1. public StringBuffer deleteCharAt(int index)
   

   删除指定位置的字符，并返回本身。

2. public StringBuffer delete(int start,int end);
   

   删除从指定位置开始到指定位置结束的内容，并返回本身。

package stringBuffer_01;

public class StringDemo03 {

	public static void main(String[] args) {
		StringBuffer stringBuffer = new StringBuffer();
		stringBuffer.append("hello").append("world").append("java");
		System.out.println(stringBuffer); // helloworldjava

		stringBuffer.deleteCharAt(2);
		System.out.println(stringBuffer); // heloworldjava

		stringBuffer.delete(0, 4);
		System.out.println(stringBuffer); // worldjava
	}

}

19.3. StringBuffer的替换功能

1. public StringBuffer replace(int start,int end,String str);
   

   从start开始到end结束用str替换

package stringBuffer_01;

public class StringBuffer02 {

	public static void main(String[] args) {
		StringBuffer stringBuffer = new StringBuffer();
		stringBuffer.append("hello").append("world").append("java");
		System.out.println(stringBuffer);// helloworldjava

		stringBuffer.replace(5, 10, "你好");
		System.out.println(stringBuffer);// hello你好java
	}

}

19.4. StringBuffer的反转功能

1. public StringBuffer reverse();
   

   将字符串的内容反转过来

package stringBuffer_01;

public class StringBuffer04 {

	public static void main(String[] args) {
		StringBuffer stringBuffer = new StringBuffer();
		stringBuffer.append("意如事万");
		System.out.println(stringBuffer);// 意如事万

		stringBuffer.reverse();
		System.out.println(stringBuffer);// 万事如意
	}

}

19.5. StringBuffer的截取功能

1. public String substring(int start);
   

   截取从指定位置到最后的字符串，并返回给一个新的字符串，原来的StringBuffer不变

2. public String substring(int start,int end);
   

   截取从指定位置到指定位置的字符串，并返回给一个新的字符串，原来的StringBuffer不变

package stringBuffer_01;

public class StringBuffer05 {

	public static void main(String[] args) {
		StringBuffer stringBuffer = new StringBuffer();
		stringBuffer.append("hello").append("world").append("java");
		System.out.println(stringBuffer);// helloworldjava

		String string1 = stringBuffer.substring(5);
		System.out.println(string1);// worldjava
		System.out.println(stringBuffer);// helloworldjava

		String string2 = stringBuffer.substring(5, 10);
		System.out.println(string2);// world
		System.out.println(stringBuffer);// helloworldjava

	}

}

19.6. StringBuffer与String的相互转换

19.6.1. String类型转换成StringBuffer

1. 通过构造方法

   StringBuffer stringBuffer = new StringBuffer(string);
   

2. 通过append()方法

   StringBuffer.append(string);
   

19.6.2. StringBuffer类型转换成String

1. 通过构造方法

   String string = new String(stringBuffer);
   

2. 通过toString()方法:任何引用类型调用toString()方法都可以转换成字符串类型

   String string = stringBuffer.toString();
   

package stringBuffer_01;

public class StringBuffer06 {

	public static void main(String[] args) {
		// String类型转换成StringBuffer
		String string1 = "helloworld";
		StringBuffer stringBuffer1 = new StringBuffer(string1);
		System.out.println(stringBuffer1);// helloworld

		StringBuffer stringBuffer2 = new StringBuffer();
		stringBuffer2.append(string1);
		System.out.println(stringBuffer2);// helloworld

		// StringBuffer类型转换成String
		StringBuffer stringBuffer3 = new StringBuffer("万事如意");
		String string2 = new String(stringBuffer3);
		System.out.println(string2);// 万事如意

		String string3 = stringBuffer3.toString();
		System.out.println(string2);// 万事如意
	}

}

19.7. 用StringBuffer做字符串的拼接

package stringBuffer_01;

public class StringBufferText {

	public static void main(String[] args) {
		int[] array = { 11, 33, 55, 77, 99 };
		String string = arrayToString(array);
		System.out.println(string);
	}

	public static String arrayToString(int[] arr) {
		StringBuffer stringBuffer = new StringBuffer("[");
		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
				stringBuffer.append(arr[i]);
				stringBuffer.append("]");
			} else {
				stringBuffer.append(arr[i]);
				stringBuffer.append(", ");
			}
		}
		String string = stringBuffer.toString();
		return string;
	}
}

19.8. 用StringBuffer做字符串的反转

package stringBuffer_01;

public class StringBufferText01 {

	public static void main(String[] args) {
		String string1 = "意如事万";
		String string2 = myReverse(string1);
		System.out.println(string2);
	}

	public static String myReverse(String str) {
		StringBuffer stringBuffer = new StringBuffer(str);
		stringBuffer.reverse();
		return stringBuffer.toString();
	}

}

20. 数组高级

20.1 排序

20.1.1. 冒泡排序

原理：要进行arr.length - 1大次，第一大次进行arr.length -1小次，以后一次递减一

20.1.1.1. 案例

package array_01;

public class AraryDemo01 {

	public static void main(String[] args) {
		int[] arr = { 11, 22, 33, 44, 55, 66 };
		printArray(arr);
		bubbleSort(arr);
		printArray(arr);
	}

	// 冒泡排序
	public static void bubbleSort(int[] arr) {
		int temp = 0;
		for (int i = 0; i < arr.length - 1; i++) {
			// 为了防止越界，x每次都要减一
			for (int x = 0; x < arr.length - i - 1; x++) {
				if (arr[x] > arr[x + 1]) {
					temp = arr[x];
					arr[x] = arr[x + 1];
					arr[x + 1] = temp;
				}
			}
		}
	}

	// 遍历功能
	public static void printArray(int[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if (i != arr.length - 1) {
				System.out.print(arr[i] + ", ");
			} else {
				System.out.println(arr[i] + "]");
			}
		}
	}

}

20.1.2. 选择排序

原理

第一次是从0索引和其他的比较；
第二次是从1索引和其他的比较；
最后一次是数组长度减二的元素和数组元素长度减一的元素比较

20.1.2.1. 案例

package array_01;

public class ArrayDemo2 {

	public static void main(String[] args) {
		int[] arr = { 66, 55, 44, 33, 22, 11 };
		printArray(arr);
		selectionSort(arr);
		printArray(arr);
	}

	// 选择排序
	public static void selectionSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int x = i + 1; x < arr.length; x++) {
				if (arr[i] > arr[x]) {
					int temp = arr[x];
					arr[x] = arr[i];
					arr[i] = temp;
				}
			}
		}
	}

	// 遍历功能
	public static void printArray(int[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if (i != arr.length - 1) {
				System.out.print(arr[i] + ", ");
			} else {
				System.out.println(arr[i] + "]");
			}
		}
	}

}

20.1.2.2. 把字符串中的字符进行排序案例

package array_01;

public class ArrayText01 {

	public static void main(String[] args) {
		String string = "dacgebf";
		char[] chs = string.toCharArray();
		printArray(chs);
		selectionSort(chs);
		printArray(chs);
		System.out.println(String.valueOf(chs));//将字符数组转换成字符串并输出
	}

	// 选择排序
	public static void selectionSort(char[] chs) {
		for (int i = 0; i < chs.length - 1; i++) {
			for (int x = i + 1; x < chs.length; x++) {
				if (chs[i] > chs[x]) {
					char temp = chs[x];
					chs[x] = chs[i];
					chs[i] = temp;
				}
			}
		}
	}

	// 遍历功能
	public static void printArray(char[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if (i != arr.length - 1) {
				System.out.print(arr[i] + ", ");
			} else {
				System.out.println(arr[i] + "]");
			}
		}
	}
}

20.2. 查找

20.2.1. 二分查找

原理

将要查找的数与数组的中间值比较，若是大了就找右边，若是小了就找左边

20.2.1.1. 案例

package array_01;

public class ArrayDemo03 {

	public static void main(String[] args) {
		int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
		System.out.println(binarySearch(array, 8));
	}

	public static int binarySearch(int[] arr, int value) {
		int min = 0;
		int max = arr.length - 1;
		int mid = (min + max) / 2;
		while (value != arr[mid]) {
			if (value > arr[mid]) {
				min = mid + 1;
			} else if (value < arr[mid]) {
				max = mid - 1;
			}

			// 加入判断
			if (min > max) {
				return -1;
			}
			mid = (min + max) / 2;
		}
		return mid;
	}

}

20.3. Arrays工具类

1. 把数组转换成字符串，形式参数可以是任何类型的数组

public static String toString(int[] a)

2. 对数组进行排序，形式参数可以是任何类型的数组

public static void sort(int[] a)

3. 对数组进行二分查找，形式参数可以是任何类型的数组

public static int binarySearch(int[] a,int key)

21. 正则表达式

21.1. 正则表达式定义

正则表达式：符合一定规则的字符串

21.2. 正则表达式规则

21.2.1. 字符

x			字符x。 举例：'a'表示字符a
\\			反斜线字符
\n			新行（换行）符 ('\u000A')
\r			回车符('\u000D')

21.2.2. 字符类

[abc]		a、b或c
[^abc]		任何字符，除了a、b或c
[a-zA-Z]	a到z或A-Z，两头的字母包括在内
[0-9]		0到9的字符都包括

21.2.3. 预定义字符类

.			任何字符	.字符本身用\.表示
\d			数字：[0-9]
\D			非数字：[^0-9]
\w			单词字符：[a-zA-Z_0-9]

21.2.4. 边界匹配器

^			行的开头
$			行的结尾
\b			单词边界

21.2.5. 数量词

X? 			X, 一次或一次也没有
X* 			X, 零次或多次
X+			X, 一次或多次
X{n}		X, 恰好n次
X{n,}		X, 至少n次
X{n,m}		X, 至少n次，但不超过m次

21.3. 正则表达式的判断功能

String类中的 public boolean matches(String regex)

21.3.1. 判断手机号码是否满足

package regex_01;

import java.util.Scanner;

public class RegexDemo02 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入你的手机号码：");
		String phone = sc.nextLine();
		String regex = "1[0-9]{10}";
		System.out.println(phone.matches(regex));
	}

}

21.4. 正则表达式的分割功能

String类中的 public String[] split(String regex)

21.4.1. 分割功能的案例

package regex_01;

public class RegexDemo03 {

	public static void main(String[] args) {
		// 定义一个字符
		String s1 = "aa,bb,cc";
		// 定义分割规则
		String regex = ",";
		// 分割
		String[] strArray1 = s1.split(regex);
		for (int i = 0; i < strArray1.length; i++) {
			System.out.print(strArray1[i] + "\t"); // aa bb cc
		}
		System.out.println();

		// 定义一个字符
		String s2 = "aa.bb.cc";
		// 直接分割
		String[] strArray2 = s2.split("\\.");
		for (int i = 0; i < strArray2.length; i++) {
			System.out.print(strArray2[i] + "\t"); // aa bb cc
		}
		System.out.println();

		// 定义一个字符
		String s3 = "aa          bb                          cc";
		// 直接分割
		String[] strArray3 = s3.split(" +");
		for (int i = 0; i < strArray3.length; i++) {
			System.out.print(strArray3[i] + "\t"); // aa bb cc
		}
		System.out.println();

		// 定义一个字符
		String s4 = "D:\\学习\\JavaSE WorkSpace\\num03_string\\src";
		// 直接分割
		String[] strArray4 = s4.split("\\\\");
		for (int i = 0; i < strArray4.length; i++) {
			System.out.print(strArray4[i] + "\t"); // D: 学习 JavaSE WorkSpace num03_string src
		}
		System.out.println();
	}

}

21.5. 正则表达式的替换功能

String类中的 public String replaceAll(String regex, String replacement)

22. Math类、Random类

22.1. Math：用于数学运算的类

22.1.1. 成员变量：

public static final double E
public static final double PI

22.1.2. 成员方法：

public static double abs(double a)					绝对值
public static double ceil(double a)					向上取整
public static double floor(double a)				向下取整
public static int max(int a,int b)					最大值
public static double pow(double a,double b)			a的b次幂
public static double random()						随机数
public static long round(double a)					四舍五入
public static double sqrt(double a)					正平方根

22.2. Random类：产生随机数的类

22.2.1. 构造方法

public Random()					没有给种子，用的是默认种子
public Random(long seed)		给出指定的种子

22.2.2. 成员方法

public int nextInt()			返回的是int范围内的随机数
public int nextInt(int n)		返回的是[0,n)范围内的随机数