Java学习（java基础）-韩顺平老师

一、简单介绍

1、jdk、jre

2、Java代码规范

a、类、方法的注释，要以javadoc的方式来写

/**
*@author：楠小弟
*@version：1.0
*/
public class Hello{
	public static void main(String[]args){
		System.out.println("hello,world!!!");
	}
}

b、非javaDoc的注释

是给代码的维护者看的，着重告诉读者为什么这样写，如何修改等。
public class Hello{
	public static void main(String[]args){
		//此句为了测试是否能正常输出
		System.out.println("hello,world!!!");
	}
}

c、使用 tab操作：实现向右缩进，shift+tab向左缩进

d、运算符两边各加一个空格

e、源文件使用utf-8编码

f、行宽度不要超过80字符：一行不要写太长

3、DOS命令（了解）

a、DOS介绍

DOS：Disk Operating System磁盘操作系统

b、常用的dos命令

①查看当前目录：

dir  查看当前目录
dir d:\abc\hello 查看d盘hello的目录

②切换到其他盘：

cd /D c: 切换到c盘，/D为命令

③切换到当前盘的其他目录

cd d:\abc\hello  绝对路径切换
cd ..\..\abc\hello 相对路径切换

④切换到上一级

cd ..

⑤切换到根目录

cd \

⑥查看指定目录下的所有子目录

tree

⑦清屏：cls

⑧退出：exit

⑨其他相关命令

创建目录：md
删除目录：rd
拷贝文件：copy
删除文件：del
输入内容到文件：echo
type
剪切：move

4、复习：Java编写步骤

1、编写Java的源代码
2、javac 编译，得到对应的 .class 字节码文件
3、java 运行，本质就是把 .class加载到jvm 运行。

二、变量

1、变（变化）量（值）

a、为什么需要变量？

变量 是程序的基本组成单位。

b、概念：

变量相当于内存中一个数据存储空间的表示。
可以把变量看作是一个房间的门牌号，通过门牌号可以找到房间，
而通过变量名可以访问到变量（值）。

使用步骤：1》声明变量  2》赋值。

2、数据类型

-Java数据类型分为两大类：基本类型，引用类型。

• 基本数据类型有8种
  • byte,short,int,long,float,double,char,boolean
• 引用类型：类，接口，数组

a、整型类型

b、浮点类型

• 注意：使用double类型接收两数之间的乘除时，确保被除数为double或后面加”.0“.

3、JavaAPI

• 是Java提供的基本编程接口。

4、字符类型（char）

5、编码的昔日今朝

6、布尔类型

7、自动类型转换

• 介绍
  
• 注意细节
  
• byte,short 和 char之间不会相互自动转换

当把具体的数赋值给byte时：
①先判断该数是否在byte范围内，若是就可以。

• byte，short，char 他们三者可以计算，在计算时首先转换为int类型

byte b=1；
byte b1=2；
short s=1；
short s1=b+b1+s；//错
byte b2=b+b1+s；//错
int i=b+b1+s；//正确

8、强制类型转换

9、基本数据类型和String类型的转换

三、运算符

1、运算符介绍

2、算术运算符

算术运算符是对数值类型的变量进行运算的，在java程序中使用的非常多。

• 注意：【取模，取余：“%” 有个公式】

a % b = a - a / b * b;
eg:
10 % 3= 10 - 10 / 3 * 3;//结果为：1
-10 % 3= -10 - （-10） / 3 * 3;//结果为：-1

判断符号：
	除数为负，结果为负。

3、关系运算符

4、逻辑运算符

• 短路与和逻辑与
  
• 短路或和逻辑或
  
• 取反和异或
  
• 练习题：
  

5、赋值运算符

6、三元运算符

7、运算符优先级

四、标识符

1、规则

2、规范

3、关键字

4、 保留字

五、进制

1、介绍

2、图示

3、进制之间的转换

a、其他进制转十进制

• 二进制转十进制
  
• 八进制转十进制
  
• 十六进制转十进制
  

b、十进制转其他进制

• 十进制转二进制
  
• 十进制转八进制
  
• 十进制转十六进制
  

c、二进制转其他进制

• 二进制转八进制
  
• 二进制转十六进制
  

d、八进制转二进制

e、十六进制转二进制

4、位运算

a二进制在运算中的说明

b、原码、补码、反码

c、位运算符《one》

d、位运算符《two》

5、本章练习

• 注意 取模 的使用方式
  
  
  

六、控制结构

1、顺序控制

2、分支控制

a、单分支

b、双分支

c、多分支

d、嵌套分支

e、switch分支

f、switch和if的比较

3、循环控制

a、for循环

b、while循环

c、do…while循环

d、多重循环

e、练习

• a、打印等腰三角形

//获取键盘输入。注意：别忘记导包：java.util.Scanner
		Scanner inp=new Scanner(System.in);
		System.out.println("阁下想打印多少行？");
		int rowNum=inp.nextInt();//接收要打印的行数
		//开始打印想要的行数
		for(int i=1;i<=rowNum;i++){
			for(int k=1;k<=(rowNum-i);k++){//打印空格
				System.out.print(" ");
			}
			for(int j=1;j<=(2*i-1);j++){//打印*
				System.out.print("*");
			}
			System.out.println();//每次循环换行
		}

• 结果如下
  
• 2、打印空心等腰三角形

//2、打印空心等腰三角形
		System.out.println("阁下想打印多少行？");
	    rowNum=inp.nextInt();//接收要打印的行数
		//开始打印想要的行数
		for(int i=1;i<=rowNum;i++){
			for(int k=1;k<=(rowNum-i);k++){//打印空格
				System.out.print(" ");
			}
			for(int j=1;j<=(2*i-1);j++){//打印*
				if(j==1 || j==(2*i-1) || i==rowNum){
					System.out.print("*");
				}else{
					System.out.print(" ");
				}
				
			}
			System.out.println();//每次循环换行
		}

• 结果如下
  
• 3、打印菱形

//3、打印菱形
		
		for(int i=1;i<=rowNum;i++){
			for(int k=1;k<=(rowNum-i);k++){//打印空格
				System.out.print(" ");
			}
			for(int j=1;j<=(2*i-1);j++){//打印*
				System.out.print("*");
			}
			System.out.println();//每次循环换行
		}
		
		//菱形下半部分
		for(int i=rowNum-1;i>=1;i--){
			for(int k=1;k<=(rowNum-i);k++){//打印空格
				System.out.print(" ");
			}
			for(int j=1;j<=(2*i-1);j++){//打印*
				System.out.print("*");
			}
			System.out.println();//每次循环换行
		}

• 结果如下
  
• 4、打印空心菱形

System.out.println("阁下想打印多少行？");
	    rowNum=inp.nextInt();//接收要打印的行数
		//开始打印想要的行数
		for(int i=1;i<=rowNum;i++){
			for(int k=1;k<=(rowNum-i);k++){//打印空格
				System.out.print(" ");
			}
			for(int j=1;j<=(2*i-1);j++){//打印*
				if(j==1 || j==(2*i-1)){
					System.out.print("*");
				}else{
					System.out.print(" ");
				}
				
			}
			System.out.println();//每次循环换行
		}
		for(int i=rowNum-1;i>=1;i--){
			for(int k=1;k<=(rowNum-i);k++){//打印空格
				System.out.print(" ");
			}
			for(int j=1;j<=(2*i-1);j++){//打印*
				if(j==1 || j==(2*i-1) || i==rowNum){
					System.out.print("*");
				}else{
					System.out.print(" ");
				}
				
			}
			System.out.println();//每次循环换行
		}

• 结果如下
  

f、跳转终止语句：break

• 练习
  

//1)1-100以内的数求和，求出当和第一次大于20的当前数【for+break】
		int sum=0;//接收和
		liu:for(int i=1;i<=100;i++){
			sum+=i;
			if(sum>=20){
				System.out.println("累加到20的当前数："+i);
				break liu;
			}
		}
		//)实现登录验证，有3次机会，如果用户名为"丁真”，密码"666"提示登录成功，
		//否则提示还有几次机会，请使用for+break完成
		String name="";
		String pwd="";
		for(int i=1;i<=3;i++){
			System.out.print("请输入用户名：");
			name=inp.next();
			System.out.print("\n请输入密码：");
			pwd=inp.next();
			//判断
			if(name.equals("丁真") && "666".equals(pwd)){
				System.out.println("恭喜【"+name+"】登陆成功！！");
				break;
			}
			//判断是否已经是第三次输错了
			if(i==3){
				System.out.println("当前用户已被锁定，请稍后再试！！");
			}else{
				System.out.println("用户名或密码输入有误！还有【"+(3-i)+"】次机会");
			}
			
		}

g、跳转控制语句continue

h、跳转控制语句 return

i、练习

七、数组、排序、查找

1、数组的使用

a、数组的动态初始化

b、数组的静态初始化

c、数组的注意事项

d、数组练习

//1、第一题
		char []ch=new char[26];		
		for(int i=0;i<ch.length;i++){//循环26次
			ch[i]=(char)('A'+i);//'A'+i 是int，需要强转
		}
		System.out.println("=======打印如下=====");
		for(int i=0;i<ch.length;i++){
			System.out.print(ch[i]+"  ");
		}

//第二题
		int [] arr={4,-1,9,10,23};
		int max=arr[0];//假定第一个元素为最大值
		int maxIndex=0;//索引
		for(int i=1;i<arr.length;i++){//从下标1开始遍历
			if(arr[i]>max){//如果max 小于 当前元素时
				max=arr[i];//把当前元素 赋值给 max
				maxIndex=i;//记录当前元素下标
			}
		}
		System.out.println("最大值为:"+max+"最大值的下标为："+maxIndex);

e、数组的赋值机制

2、数组的拷贝

3、数组的翻转

4、数组的扩容

//1、对数组进行扩容
//对数组 int arr[]={1,2,3};实现扩容操作
		int arr[]={1,2,3};//初始数组
		int newArr[];//新数组用来扩容使用
		char ch=' ';//用来接收用户的选择
		int num=0;//用来输入的整数
		//使用while循环进行连续增加
		do{//当用户不想弄了时结束
			System.out.println("数组的数据为：");
			for(int i=0;i<arr.length;i++){
				System.out.print(arr[i]+" ");
			}
			System.out.println("\n是否进行扩容？y/n");
			ch=inp.next().charAt(0);
			//判断
			if(ch=='y'){//进行扩容时
				System.out.println("请输入要添加的整数：");
				num=inp.nextInt();
				newArr=new int[arr.length+1];//新数组比旧数组大一个
				//把旧数组的数据弄到新数组上
				for(int i=0;i<arr.length;i++){
					newArr[i]=arr[i];
				}
				//把用户输入的值赋给新数组
				newArr[newArr.length-1]=num;
				//把新数组赋给旧数组
				arr=newArr;
			}else{//退出循环
				System.out.println("拜拜了你呢！！");
				break;
			}
		}while(true);

//2、对数组进行缩减
//练习：给定一个数组，int[] arr={1,2,3,4,5,6,7};
		//用户可以随意除去数组中任意一个元素，对数组进行缩减
		//当数组只剩下一个时，提示不能再缩减，退出程序。
		int[] arr={1,2,3,4,5,6,7};//初始数组
		int[] newArr;//声明新数组，进行数组的缩减
		char ch=' ';//用户的选择
		int num=0;//用户缩减的元素
		
		do{
			System.out.print("数组的元素如下：");
			//遍历数组
			for(int i=0;i<arr.length;i++){
				System.out.print(arr[i]+" ");
			}
			System.out.println("\n是否进行对数组缩减？y/n");
			ch=inp.next().charAt(0);
			//判断用户的选择
			if(ch=='y'){//确定缩减
				int index=0;//用户要缩减元素的下标
				boolean flag=false;//用户要缩减的元素是否存在
				//判断数组的长度是否大于一
				if(arr.length<=1){
					System.out.println("数组元素只剩下一个，不能再删减！");;
					break;
				}
				//初始化新数组
				newArr=new int[arr.length-1];
				//询问用户想缩减哪个元素
				System.out.println("要除去哪个元素？");
				num=inp.nextInt();
				//判断用户输入的元素的下标
				for(int i=0;i<arr.length;i++){
					if(arr[i]==num){
						index=i;
						flag=true;
						break;//找到后结束循环
					}
				}
				//判断用户输入的元素是否存在
				if(flag){//在数组中能找到
					int j=0;//用来给新数组当下标
					//除去此元素
					for(int i=0;i<arr.length;i++){
						if(arr[i]==arr[index]){
							continue;//此元素出现时跳过
						}
						//把旧数组数据赋给新数组
						newArr[j]=arr[i];
						j++;//下标加1
					}
					//把新数组重新赋给旧数组
					arr=newArr;
				}else{//不存在
					System.out.println("输入的元素不存在！！！");
				}
				
			}else{//不缩减，程序结束
				System.out.print("拜拜了你呢！！");
				break;
			}
		}while(true);
	

5、数组的排序

a、冒泡排序

//冒泡排序
		int[]arr={12,5,23,96,20,45,3};//初始数组
		int temp=0;//它用来保存临时变量
		for(int i=0;i<arr.length-1;i++){//循环6次：arr.length-1
			System.out.println("\n====第"+(i+1)+"轮=====");
			//当确定好最后一个最大时，就无需再和其判断
			for(int j=0;j<arr.length-1-i;j++){
				//当前面的元素大于后面的元素时，互换位置
				if(arr[j]>arr[j+1]){
					temp=arr[j];//临时变量获得前面元素
					arr[j]=arr[j+1];//前面元素位置被后面元素替代
					arr[j+1]=temp;//后面元素位置被前面元素替代
				}
				
			}
			//打印每轮的结果
			for(int j=0;j<arr.length;j++){
				System.out.print(arr[j]+"\t");
			}
			//判断数组是否是正序的
			if(temp<0){
				System.out.println("此数组不需要重新搞，");
				break;
			}
			
		}

6、数组的查找

7、二维数组

a、二维数组的使用

• 动态初始化~1
  
• 动态初始化~2
  
• 动态创建的二维数组
  
• 静态初始化
  

b、二维数组的遍历

• 答案
  
  ###c、二维数组的应用案例

i、杨辉三角

• 编码
  

//杨辉三角
		int[][]arr=new int[10][];//初始化一个为10的二维数组
		for(int i=0;i<arr.length;i++){//层数
			//动态初始化一维数组
			arr[i]=new int[i+1];
			//为一维数组赋值
			for(int j=0;j<arr[i].length;j++){
				//首和尾都是 1
				if(j==0 || j==arr[i].length-1){
					arr[i][j]=1;
				}else{
					//根据规律获得的公式
					arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
				}
				//输出数据
				System.out.print(arr[i][j]+" ");
			}
			//每层结束换行
			System.out.println();
		}

c、二维数组的使用细节

d、数组练习

i、练习一：【二维数组】课堂练习

ii、练习二：【一维数组】在升序的数组中插入元素，且依然是升序

int[]arr={10,12,45,90};//初始数组
		int[]newArr=new int[arr.length+1];//用来扩容
		int index=-1;//用来确定要插入的位置
		int num=23;//要插入的整数
		boolean flag=false;//限制条件
		//查找下标以及把数据拷贝到newArr数组
		for(int i=0,j=0;i<arr.length;i++){
			//当要插入的数 第一次遇到大于自己的 就是要插入的位置
			if(num<=arr[i] &&  !flag){//当flag为默认时执行
				index=i;//获得当前下标
				flag=true;//限制条件为true：下次在遇到大于的数时跳过
				j++;//把当前位置空下来留给要插入的数据
			}
			newArr[j]=arr[i];//赋值
			j++;//用来给新数组赋值的下标
		}
		//判断
		if(index<0){//小于0说明要插的数很大，放在最后一个
			newArr[newArr.length-1]=num;
		}else{//正常赋值
			newArr[index]=num;
		}
		//把新数组重新赋给旧数组
		arr=newArr;
		System.out.println("插入之后如下：");
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}

八、面向对象编程（基础）

1、类与对象

a、 对象在内存存在的形式

b、对象的声明方式

c、类和对象的内存分配机制

i、练习

2、成员方法

a、属性

b、如何访问属性

c、成员方法

public class Liu{
	public static void main(String[]args){
		Person p=new Person();
		p.name="jack";
		p.age=22;
		p.sex="男";
		//speak方法
		p.speak();
		//cal01方法，计算1+n的结果
		p.cal01(100);
		//getSum方法，计算两数之和
		int num=p.getSum(25,45);
		System.out.println("两数之和为："+num);
	}

}

class Person{
	String name;//姓名
	int age;//年龄
	String sex;//性别

	//speak方法
	public void speak(){
		System.out.println(name+" 是一个好人");
	}
	//cal01方法，计算1+2+...+100的结果
	public void cal01(int num){
		int sum=0;
		for(int i=0;i<num;i++){
			sum+=num;
		}
		System.out.println("1+加到"+num+"的结果为："+sum);
	}
	
	//getSum方法，计算两数之和
	public int getSum(int num,int num1){
		return (num+num1);
	}
}

d、方法调用机制

e、为什么需要成员方法

f、成员方法的定义

g、注意事项和注意细节

i、细节一

ii、细节二

iii、细节三

h、练习

• 第一个的编码
  
• 第二个编码
  
• 代码

public class Liu{
	public static void main(String[]args){
		AA a=new AA();
		if(a.isOod(-3)){
			System.out.println("是个奇数");
		}else{
			System.out.println("是个偶数");
		}
		
		a.printChar(4,4,'#');
	}
	
}

class AA{
	//判断一个数是否是奇数
	public boolean isOod(int num){
		return num%2!=0;
	}
	
	//根据行数、列数以及字符打印效果
	public void printChar(int row,int col,char c){
		for(int i=0;i<row;i++){
			for(int j=0;j<col;j++){
				System.out.print(c+" ");
			}
			System.out.println();
		}
	}
}

3、成员方法传参机制

a、基本类型的传参机制

b、引用类型的传参机制

c、练习：拷贝对象（克隆）

4、方法递归调用

a、递归能解决什么问题

b、递归小例子

c、递归的重要规则

d、递归练习题

i、斐波那契

• 前两个为1，从第三个开始，前两个数之和等于后面那个数字
  
• 注意：需要保证输入的是正整数
  

ii、猴子吃桃

iii、老鼠出迷宫

• 参考 韩顺平Java：221-224集

iiii、汉诺塔

• 参考 韩顺平Java：225集

iiiii、八皇后

• 参考 韩顺平Java：226集

5、overload（方法重载）

a、基本介绍

b、方法重载的注意事项

c、方法重载的练习

6、可变参数

a、介绍

b、注意事项

c、练习

public class Three{
	public static void main(String[]args){
		HspMethods me=new HspMethods();
		String n1=me.showScore("男小弟",76.5,56.9);
		String n2=me.showScore("毛小妹",76.5,56.9,45.5);
		String n3=me.showScore("崔家与",76.5,56.9,78.2,56,86);
		System.out.println(n1+"\n"+n2+"\n"+n3);
	}
}

class HspMethods{
	public String showScore(String name,double ... cjs){
		double sum=0;
		for(int i=0;i<cjs.length;i++){
			sum+=cjs[i];
		}
		return (name+"有"+cjs.length+"门课，其总成绩为："+sum);
	}
	
}

7、作用域

a、介绍

b、注意事项

8、构造器

a、介绍

c、快速入门

d、注意事项

e、练习题

public class Three{
	public static void main(String[]args){
		Person p=new Person();
		Person p1=new Person("tom",22);
		System.out.println("无参的：【name="+p.name+"--age="+p.age+"】");
		System.out.println("有参的：【name="+p1.name+"--age="+p1.age+"】");
	}
}

class Person{
	String name;
	int age;
	//将age属性初始值为18
	Person(){
		age=18;
	}
	public Person(String pName,int pAge){
		name=pName;
		age=pAge;
	}
	
}

9、this

a、介绍

b、注意事项

10、本章作业

public class Three{
	public static void main(String[]args){
		System.out.println("===========one============");
		//声明数组
		double[]d={23.1,45.2,23.2,65,6};
		//创建对象
		A01 a=new A01();
		//调用方法
		double dd=a.maxs(d);
		System.out.println("最大值为："+dd);
		
		System.out.println("===========two============");
		String[] strs={"love","tom","lisa","vol"};
		A02 a2=new A02();
		int index=a2.find("lisa",strs);
		System.out.println("目标下标为："+index);
		
			
		System.out.println("===========three============");
		Book book=new Book();
		book.name="小王子黄金版";
		book.price=152;
		book.updatePrice(book);
		System.out.println("此书的最终价格为："+book.price);
	}
	
	
}
class A01{
	//求最大值的方法
	public double maxs(double[] d){
		double max=0;
		for(int i=0;i<d.length;i++){
			if(max<d[i]){
				max=d[i];
			}
		}
		return max;
	}
}

//2、找下标
class A02{
	public int find(String str,String[] strs){
		int index=-1;
		for(int i=0;i<strs.length;i++){
			if(str.equals(strs[i])){
				index=i;
				break;
			}
		}
		return index;
	}
}
//3、实现更改某书的价格
class Book{
	String name;
	double price;
	public void updatePrice(Book b){
		if(b.price>150)price=150;
		else if(price>100) price=100;
	}
}

九、面向对象编程（中级）

1、idea的使用

a、快捷键

b、自定义模板

2、包

a、包的作用

b、包的本质

c、包的命名

d、常用的包

e、如何导(引入)包

f、注意细节

3、访问修饰符

a、基本介绍

b、注意事项

4、封装（重）

a、介绍

b、封装的好处

c、封装的实现步骤

d、快速入门案例一

package com.liu;

/**
 * @author 刘sir
 */
public class Test {
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("南校地");
        p.setAge(222);
        p.setSalary(5000);
        System.out.println(p.info());
    }
}

class Person {
    public String name;
    private int age;
    private double salary;

    public String getName() {
        return name;
    }

    /**
     * 在此设置姓名的字段在 2-6个字符之间
     */
    public void setName(String name) {
        if (name.length() >= 2 && name.length() <= 6) {
            this.name = name;
        } else {
            System.out.println("姓名太长，给定默认值");
            this.name = "某某人";
        }
    }

    public int getAge() {
        return age;
    }

    /**
     * 年龄在1-120之间
     *
     * @param age
     */
    public void setAge(int age) {
        if (age >= 1 && age <= 120) {
            this.age = age;
        } else {
            System.out.println("年龄过大。默认18");
            this.age = 18;
        }
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    //方法展示
    public String info() {
        return "姓名：" + getName() + " 年龄：" + getAge() + " 薪资：" + getSalary();
    }
}

d1、快速入门案例二

package com.liu;

/**
 * @author 刘sir
 */
public class Test {
    public static void main(String[] args) {
        Person p = new Person("tom",22,6000);
        System.out.println(p.info());
    }
}

class Person {
    public String name;
    private int age;
    private double salary;


    public Person() {
    }

    public Person(String name, int age, double salary) {
        this.setName(name);
        this.setSalary(salary);
        this.setAge(age);
    }

    public String getName() {
        return name;
    }

    /**
     * 在此设置姓名的字段在 2-6个字符之间
     */
    public void setName(String name) {
        if (name.length() >= 2 && name.length() <= 6) {
            this.name = name;
        } else {
            System.out.println("姓名太长，给定默认值");
            this.name = "某某人";
        }
    }

    public int getAge() {
        return age;
    }

    /**
     * 年龄在1-120之间
     *
     * @param age
     */
    public void setAge(int age) {
        if (age >= 1 && age <= 120) {
            this.age = age;
        } else {
            System.out.println("年龄过大。默认18");
            this.age = 18;
        }
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    //方法展示
    public String info() {
        return "姓名：" + getName() + " 年龄：" + getAge() + " 薪资：" + getSalary();
    }
}

e、封装小练习

package com.liu;
/**
 * @author 刘sir
 */
public class Test {
    public static void main(String[] args) {
        Account ac=new Account("那空间",22,"123456");
        System.out.println(ac.info());
    }

}
class Account{
    private String name;
    private double balance;
    private String pwd;

    public Account() {
    }

    public Account(String name, double balance, String pwd) {
       this.setBalance(balance);
       this.setName(name);
       this.setPwd(pwd);
    }

    public String getPwd() {
        return pwd;
    }

    /**
     * 密码必须是6位
     * @param pwd
     */
    public void setPwd(String pwd) {
        if(pwd.length()==6){
            this.pwd = pwd;
        }else{
            System.out.println("密码必须是6位,已设置默认密码");
            this.pwd="000000";
        }
    }

    public String getName() {
        return name;
    }

    /**
     * 长度为2位3位或4位
     * @param name
     */
    public void setName(String name) {
        if(name.length()>=2 && name.length()<=4){
            this.name = name;
        }else{
            System.out.println("姓名长度在2-4之间，已设置默认值");
            this.name="某某人";
        }
    }

    public double getBalance() {
        return balance;
    }

    /**
     * 余额必须大于20
     * @param balance
     */
    public void setBalance(double balance) {
        if(balance>20){
            this.balance = balance;
        }else{
            System.out.println("余额必须大于20");
            this.balance=20;
        }
    }

    //信息输出
    public String info(){
        return "姓名："+getName()+" 余额："+getBalance()+" 密码："+getPwd();
    }
}

5、继承（重）

a、介绍

b、示意图

c、继承给编程带来的便利

d、继承的细节问题

e、继承的本质分析

f、继承练习

6、多态（重）

a、介绍

b、多态的具体体现

c、多态的向上转型

d、多态的向下转型

e、注意细节

f、练习

g、Java的动态绑定机制

h、多态的应用

i、多态数组

• Person类

package com.two;

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    public String say(){
        return "姓名："+name+" 年龄："+age;
    }
}

• Studentlei

package com.two;

public class Student extends Person{
    private double score;

    public Student(String name, int age, double score) {
        super(name, age);
        this.score = score;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String say() {
        return "学生-"+super.say()+" 成绩："+ score;
    }
    public void study(){
        System.out.println(getName()+"-同学，正在学习~~~");
    }
}

• Teacher类

package com.two;

public class Teacher extends Person{
    private double salary;

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public Teacher(String name, int age, double salary) {
        super(name, age);
        this.salary = salary;
    }

    @Override
    public String say() {
        return "老师-"+super.say()+" 薪水："+salary;
    }
    public void teach(){
        System.out.println(getName()+"-老师正在教课`~~~");
    }
}

• 测试类

package com.two;

public class PloyArray {
    public static void main(String[] args) {
        Person[]p=new Person[5];
        p[0]=new Person("淘米",20);
        p[1]=new Student("小明",20,86.5);
        p[2]=new Student("小红",20,90.5);
        p[3]=new Teacher("赵sir",35,5000);
        p[4]=new Teacher("李sir",30,5500);
        for (int i = 0; i < p.length; i++) {
            System.out.println(p[i].say());
            if(p[i] instanceof Teacher){
                ((Teacher) p[i]).teach();
            }else if(p[i] instanceof Student){
                ((Student) p[i]).study();
            }

        }
    }
}

• 测试结果
  

ii、多态参数

7、Super

a、介绍

b、super使用细节

c、super和this的比较

8、overwrite（重写）

a、介绍

b、注意事项

c、重写和重载的比较

d、练习

package com.extendsT;

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }
    public String say(){
        return "姓名="+name+" 年龄="+age;
    }
}
class Student extends Person{
    private String id;
    private double score;

    public Student(String name, int age, String id, double score) {
        super(name, age);
        this.id = id;
        this.score = score;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }
    @Override
    public String say(){

        return super.say()+" id="+id+" score="+score;
    }
}
class Test{
    public static void main(String[] args) {
        Person p=new Person("那地方",21);
        System.out.println(p.say());
        Student s=new Student("看到",21,"1001",98);
        System.out.println(s.say());
    }
}

9、Object类详解

a、equals方法

i、如何重写equals方法

public class Test {
    public static void main(String[] args) {
        Person p=new Person("tom",20,'女');
        Person p1=new Person("tom",20,'女');
        System.out.println(p.equals(p1));
    }
}

class Person {
    private String name;
    private int age;
    private char gender;

    /**
     * 有参构造
     *
     * @param name
     * @param age
     * @param gender
     */
    public Person(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    /**
     * setter和getter方法
     *
     * @return
     */
    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;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    @Override
    public boolean equals(Object obj) {
        //当是同一个对象时
        if (this == obj) {
            return true;
        }
        //判断类型
        if (obj instanceof Person) {
            Person p = (Person) obj;
            return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
        }
        //类型不同
        return false;
    }
}

ii、小练习

b、hashCode方法

c、toString方法

d、finalize方法

public class Test {
    public static void main(String[] args) {
        Car bm = new Car("BM");
        bm=null;
        System.gc();//回收命令
        System.out.println("程序结束~~~");
    }
}
class Car{
    private String name;

    public Car(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("销毁汽车："+name);
        System.out.println("释放了某些资源！！！");
    }
}

10、断点调试

a、介绍

b、断点调试的快捷键

c、应用案例

i、案例1

ii、案例2

iii、案例3

iiii、案例4

11、练习

a、零钱通项目（p335-p341）

i、开发流程

• 普通版方式代码实现

public class LingMoneyOs {
    public static void main(String[] args) {
        //键盘输入
        Scanner inp = new Scanner(System.in);
        //循环判断条件
        boolean loop = true;
        //用来接收用户的选择
        String str = "";
        //收支记录
        String allNote = "\n----------零钱通明细----------";
        //收益或支出的金钱
        double money;
        //总金额
        double allMoney = 0;
        //时间格式转换
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //消费的项目
        String note;

        do {
            System.out.println("----------零钱通菜单----------");
            System.out.println("\t\t1 零钱通明细");
            System.out.println("\t\t2 收益入账");
            System.out.println("\t\t3 消费");
            System.out.println("\t\t4 退     出");
            System.out.print("请选择（1-4）：");
            str = inp.next();
            //使用switch来进行判断
            switch (str) {
                case "1":
                    System.out.println(allNote);
                    break;
                case "2":
                    System.out.print("收益金额：");
                    money = inp.nextDouble();
                    //校验金额是否合法
                    if (money <= 0) {
                        System.out.println("**收益入账金额应大于0！**");
                        break;
                    }
                    //总金额改变
                    allMoney += money;
                    //添加记录
                    allNote += "\n收益入账\t+" + money + "\t" + sdf.format(new Date()) + "\t余额：" + allMoney;
                    System.out.println("\n~~~~~~~添加欧克~~~~~~~");
                    break;
                case "3":
                    System.out.print("消费金额：");
                    money = inp.nextDouble();
                    System.out.print("消费说明：");
                    note = inp.next();
                    //判断消费的金额是否大于自己拥有的
                    if (money > allMoney || money <= 0) {
                        System.out.println("**消费金额应在0-" + allMoney + " 之间**");
                        break;
                    }
                    //跟新总钱数
                    allMoney -= money;
                    //添加记录
                    allNote += "\n" + note + "\t-" + money + "\t" + sdf.format(new Date()) + "\t余额：" + allMoney;
                    System.out.println("\n~~~~~~~添加欧克~~~~~~~");
                    break;
                case "4":
                    //用来接收用户的选择
                    char isTui;
                    while (true) {
                        System.out.print("确定要退出吗？y/n：");
                        isTui = inp.next().charAt(0);
                        if ('y' == isTui || 'n' == isTui) {
                            break;
                        }
                    }
                    //判断
                    if ('y' == isTui) {
                        loop = false;
                    } else if ('n' == isTui) {
                        loop = true;
                    }
                    break;
                default:
                    System.out.println("输入有误，请重新选择！！");
            }
        } while (loop);
        System.out.println("-----感谢你使用零钱通系统，期待你的下次光临！-----");

    }
}

• oop版方式实现

/**
 * @author nan
 * 使用oop方式
 */
public class LingMoneyOsOop {
    Scanner inp=new Scanner(System.in);
    //循环判断条件
    boolean loop = true;
    //用来接收用户的选择
    String str = "";
    //收支记录
    String allNote = "\n----------零钱通明细----------";
    //收益或支出的金钱
    double money;
    //总金额
    double allMoney = 0;
    //时间格式转换
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //消费的项目
    String note;

    /**
     * 菜单
     */
    public void showMenu(){
        do {
            System.out.println("----------零钱通菜单----------");
            System.out.println("\t\t1 零钱通明细");
            System.out.println("\t\t2 收益入账");
            System.out.println("\t\t3 消费");
            System.out.println("\t\t4 退     出");
            System.out.print("请选择（1-4）：");
            str = inp.next();
            //使用switch来进行判断
            switch (str) {
                case "1":
                    this.info();
                    break;
                case "2":
                   this.getMoney();
                    break;
                case "3":
                    this.giveMoney();
                    break;
                case "4":
                   this.goOut();
                    break;
                default:
                    System.out.println("输入有误，请重新选择！！");
            }
        } while (loop);
        System.out.println("-----感谢你使用零钱通系统，期待你的下次光临！-----");

    }

    /**
     * 零钱通明细
     */
    public void info(){
        System.out.println(allNote);
    }

    /**
     * 收益入账
     */
    public void getMoney(){
        System.out.print("收益金额：");
        money = inp.nextDouble();
        //校验金额是否合法
        if (money <= 0) {
            System.out.println("**收益入账金额应大于0！**");
            return;
        }
        //总金额改变
        allMoney += money;
        //添加记录
        allNote += "\n收益入账\t+" + money + "\t" + sdf.format(new Date()) + "\t余额：" + allMoney;

    }

    /**
     * 消费
     */
    public void giveMoney(){
        System.out.print("消费金额：");
        money = inp.nextDouble();
        System.out.print("消费说明：");
        note = inp.next();
        //判断消费的金额是否大于自己拥有的
        if (money > allMoney || money <= 0) {
            System.out.println("**消费金额应在0-" + allMoney + " 之间**");
            return;
        }
        //跟新总钱数
        allMoney -= money;
        //添加记录
        allNote += "\n" + note + "\t-" + money + "\t" + sdf.format(new Date()) + "\t余额：" + allMoney;

    }

    /**
     * 退出
     */
    public void goOut(){
        //用来接收用户的选择
        char isTui;
        while (true) {
            System.out.print("确定要退出吗？y/n：");
            isTui = inp.next().charAt(0);
            if ('y' == isTui || 'n' == isTui) {
                break;
            }
        }
        //判断
        if ('y' == isTui) {
            loop = false;
        } else if ('n' == isTui) {
            loop = true;
        }
    }
}
class Test{
    public static void main(String[] args) {
        new LingMoneyOsOop().showMenu();
    }
}

b、课后练习（p342-p348）

12、房屋租聘系统

a、系统演示如下

b、结构图

c、房屋租聘代码

• 老韩的代码
  老韩代码-房屋租凭
• 个人写的代码
  个人代码-房屋租聘

Java基础第一部分结束

学习路上肯定会有很多艰难险阻，
但这并不可怕，
让我们时时牢记h自己的初心是什么？
虽然现在自己的技术非常小白，
但这不能代表一直就是这样，
老韩的座右铭挺好的：我亦无他，惟手熟尔--《卖油翁》
加油吧，伙计，
也许现在你麻木了，但不要放弃，重新挑起自己的热爱，
昨日已经过去，无法回去；
明日尚未来到，无法预测；
今日正在逝去，把握当下。
今日的光景，是过去的结果，
未来想要更多机会，乃在乎现在的选择，
既然自己想要丰富自己，就从现在当下开始吧，
把握不住当下，也就把握不住未来；
今天如何选择，明日就会有不一样的结果，
今日种的因，明日就要吃其结的果....
勇于逃离自我辖制，自己有很大潜力，
勇敢去闯吧，不要被恐惧吓住，
不论什么事，就大胆尝试(不是犯罪的事)，
无论结果如何，至少不留遗憾了。

十、面向对象（高级篇）

1、类变量和类方法

a、类变量介绍

b、类变量注意事项

c、类方法介绍

d、类方法使用场景

e、类方法注意事项

2、理解main方法语法

a、深入理解main方法

b、注意事项

c、在idea中使用args传参

3、代码块

a、介绍

b、注意事项

c、小练习

4、单例设计模式

a、什么是设计模式

什么是单例模式

c、单例模式-饿汉式

d、单例模式-懒汉式

e、懒汉式 VS 饿汉式

5、final关键字

a、介绍

b、使用细节

6、抽象类

a、抛砖引玉

b、介绍

c、细节

d、小练习

e、抽象模板模式

7、接口

a、介绍

b、应用场景

c、注意细节

d、接口VS继承

e、接口的多态性

8、内部类

a、内部类的分类

i、局部内部类

ii、匿名内部类

!、匿名内部类的使用

!!、匿名内部类的最佳实践

!!!、小练习

iii、成员内部类

iiii、静态内部类

!、介绍：

!!、练习

十一、枚举和注解

0、介绍

1、枚举的实现方式

a、自定义类实现枚举

b、enum关键字实现枚举

i、注意事项

ii、小练习

c、enum常用方法

d、小练习

public class Test05 {
    public static void main(String[] args) {
        Week[] values = Week.values();
        System.out.println("==所有星期的信息如下==");
        for (Week w:values){
            //这里使用getName()获取，也可使用重写toString方法返回name
            System.out.println(w.getName());
        }
    }
}
enum Week{
        MONDAY("星期一"),TUESDAY("星期二"),WEDNESDAY("星期三"),THURSDAY("星期四"),
    FRIDAY("星期五"),SATURDAY("星期六"),SUNDAY("星期日");
    private String name;

    Week(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

e、enum实现接口问题

3、JDK内置的基本注解类型

a、注解的理解

b、基本注解类型1：@override

c、基本注解类型2：@deprecated

d、基本注解类型3：@suppresswarnings

4、元注解：对注解进行注解

a、介绍

b、Retention

c、target

e、Documented

f、Inherited

十二、异常处理

1、异常的概念

2、异常的体系图（！！！）

3、常见的异常

a、NullPointerException空指针异常

b、ArithmeticException数学运算异常

c、ArrayIndexOutOfBoundsException数组下标越界异常

d、ClassCastException类型转换异常

e、NUmberFormatException数字格式不正确异常

f、编译时异常

4、异常处理概念

a、try…catch异常处理

b、try…catch注意细节

5、异常处理分类

a、throw异常处理

b、注意事项

6、自定义异常

a、基本概念

b、步骤

7、throw和throws的对比

十三、常用类

1、包装类

a、包装类和基本数据的转换

b、包装类和String之间的转换

c、Integer类和Character类的常用方法

d、Integer面试题

2、String

a、String的理解

b、创建String对象的两种方式以及区别

c、小练习

d、String的特性

i、几道面试题

e、String的常见方法

3、StringBuffer

a、基本介绍

b、String VS StringBuffer

c、StringBuffer构造器

d、String和String Buffer相互转换

e、StringBuffer类常见方法

f、StringBuffer小练习

4、StringBuilder

a、基本介绍

b、常用方法

c、String、StringBuffer和StringBulider的比较

• 小测试
  

d、总结

5、Math

a、基本介绍

b、常见方法应用案例

6、Date、Calendar、LocalDate…

a、Date第一代日期类

b、Calendar第二代日期类

i、应用实例

c、LocalDate第三代日期

i、区别

ii、常用方法

7、System

a、常见方法

8、Arrays

a、Arrays类常见方法应用案例

/**
定制排序
*/
public class Test01 {
    public static void main(String[] args) {
        int[] arr={-1,-8,3,9,1,7};
        //调用自排序方法
        selfCompare(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                int a= (int) o1;
                int b= (int) o2;
                return b-a;
            }
        });
        //输出排序好的数组
        for (int a :arr) {
            System.out.println(a);
        }
    }
    /**
     * 自排序数组
     * @param arr
     * @param c
     */
    public static void selfCompare(int[]arr, Comparator c){
        int temp;
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (c.compare(arr[j],arr[j+1])>0){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
}

b、小练习

public class Test01 {
    public static void main(String[] args) {
        Book[] books = new Book[4];
        books[0] = new Book("红楼梦", 100);
        books[1] = new Book("金瓶梅新", 90);
        books[2] = new Book("青年文摘20年版", 10);
        books[3] = new Book("java从入门到大神", 300);

        //进行排序
        //按price排序
        Arrays.sort(books, new Comparator<Book>() {
            @Override
            public int compare(Book o1, Book o2) {
                Book b1=o1;
                Book b2=o2;
                double result= b2.getPrice()- b1.getPrice();
                if(result>0) {
                    return -1;
                }else if(result <0){
                    return 1;
                }else {
                    //两数相等时
                    return 0;
                }
            }
        });
        //按书名长度
        Arrays.sort(books, new Comparator<Book>() {
            @Override
            public int compare(Book o1, Book o2) {
                Book b1=o1;
                Book b2=o2;
                return b1.getName().length()-b2.getName().length();
            }
        });
        //打印最后结果
        for (Book b:books){
            System.out.println(b);
        }
    }


}
class Book {
    private String name;
    private double price;

    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

9、BigInteger、BigDecimal

a、介绍

b、BigInteger常见方法

c、BigDecimal

10、本章练习

a、练习

public class Test03 {
    public static void main(String[] args) {
        //测试数据
        String str = "abcdef";
        System.out.println("====测试前数据=====");
        System.out.println(str);
        try {
            str = reverse(str, 10, 4);
        } catch (Exception e) {
            System.out.println(e.getMessage());
            return;
        }
        System.out.println("====交换后====");
        System.out.println(str);

    }
    public static String reverse(String str, int start, int end) {
        //做个验证环节，防止一些因操作带来异常
        if (!(str != null && start >= 0 && end >= 0 && str.length() > 0 && start < str.length() && end < str.length())) {
            throw new RuntimeException("请检查输入的参数，貌似又不恰当的地方....");
        }
        //把字符串转换为char数组
        char[] chars = str.toCharArray();
        //辅助变量
        char temp;
        for (int i = start, j = end; i < j; i++, j--) {
            temp = chars[i];
            chars[i] = chars[j];
            chars[j] = temp;
        }
        //使用chars重新构建一个String
        return new String(chars);
    }
}

public class Test04 {
    public static void main(String[] args) {
      
        String name="tom";
        String pwd="123456";
        String email="[email protected]";
        try {
            userRegister(name,pwd,email);
            System.out.println("注册OK啦！");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
    /**
     * 用户注册方法
     *
     * @param name  姓名
     * @param pwd   密码
     * @param email 邮箱
     */
    public static void userRegister(String name, String pwd, String email) {
        // 第一步：判断参数是否为空
        if (!(name != null && pwd != null && email != null)) {
            throw new RuntimeException("本次注册的各个信息不能为空！！");
        }
        //第二步：判断姓名
        if (!(name.length() >= 0 && name.length() <= 4)) {
            throw new RuntimeException("姓名长度应在【2，4】，你输入的姓名不符合【" + name.length() + "】");
        }
        //第三步：判断密码
        if (!(pwd.length() == 6 && isNum(pwd))) {
            throw new RuntimeException("密码必须是6位且都是数字！！");
        }

        //第四步：判断邮箱
        int e = email.lastIndexOf("@");
        int e1 = email.lastIndexOf(".");
        if (!(e > 0 && e1 > e)) {
            throw new RuntimeException("邮箱中必须存在@和.且@在.前面！！");
        }
    }
    /**
     * 判断密码中是否都是数字
     * @param pwd
     * @return true：都为数字；反之false
     */
    public static boolean isNum(String pwd) {
        //把字符串转换为char数组
        char[] chars = pwd.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if ((chars[i] < '0' || chars[i] > '9')) {
                return false;
            }
        }
        return true;
    }
}

public class Test06 {
    public static void main(String[] args) {
        String str="abcABHHJ123楠小弟";
        numsOfWord(str);
    }
    public static void numsOfWord(String str){
        if(str==null){
            System.out.println("不能为空！！");
            return;
        }
        char[] chars = str.toCharArray();
        //大写字母个数
        int dn=0;
        //小写字母个数
        int xn=0;
        //数字个数
        int nn=0;
        //其他数字
        int other=0;
        for (int i = 0; i < chars.length; i++) {
            if(chars[i]>='A'&&chars[i]<='Z'){
                dn++;
            }else if(chars[i]>='a'&&chars[i]<='z'){
                xn++;
            }else if(chars[i]>='0'&&chars[i]<='9'){
                nn++;
            }else{
                other++;
            }
        }
        System.out.println("大写字母有："+dn);
        System.out.println("小写字母有："+xn);
        System.out.println("其他字符有："+other);
        System.out.println("数字有："+nn);

    }
}

十四、集合

1、集合框架体系

2、Collection

介绍

i、常用方法

ii、iterator迭代器

iii、增强for循环

a、List

• 三种遍历方式
  

i、ArrayList

ii、LinkedList

iii、Vector

b、Set

i、HashSet

ii、LinkedHashSet

iii、TreeSet

3、Map

a、HashMap

b、Hashtable

c、LinkedHashMap

d、TreeMap

e、Properties

4、Collections

5、总结

6、练习

十五、泛型

1、泛型语法

a、介绍

b、语法

c、注意

d、练习

--参考答案
public class Test01 {
    public static void main(String[] args) {
        List<Employee> list=new ArrayList<>();
        //添加数据
        list.add(new Employee("tom",55000,new MyDate(2000,4,22)));
        list.add(new Employee("lisa",45000,new MyDate(1998,8,21)));
        list.add(new Employee("lisa",45000,new MyDate(1998,8,10)));
        System.out.println("=====排序前====");
        System.out.println(list);
        //进行排序
        list.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee e1, Employee e2) {
                //先判断是否属于这个类型
                if(!(e1 instanceof Employee && e2 instanceof Employee)){
                    System.out.println("类型不正确！！");
                    return 0;
                }
                //这里开始比对姓名
                int i = e1.getName().compareTo(e2.getName());
                if(i!=0){
                    return i;
                }
                //姓名相同：这里开始比较生日,MyDate类实现Comparable类
               return e1.getBirthday().compareTo(e2.getBirthday());
            }
        });
        System.out.println("=====排序后======");
        System.out.println(list);
    }
}
class Employee{
    private String name;
    private double price;
    private MyDate birthday;

    public Employee(String name, double price, MyDate birthday) {
        this.name = name;
        this.price = price;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "\nEmployee{" +
                "name='" + name + '\'' +
                ", price=" + price +
                ", birthday=" + birthday +
                '}';
    }
}
class MyDate implements Comparable<MyDate>{
    private int year;
    private int month;
    private int day;

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }


    @Override
    public int compareTo(MyDate o) {
        //当年不一样是
        int y = year - o.getYear();
        if(y!=0){
            return y;
        }
        //当年相同时，判断月
        int mo = month - o.getMonth();
        if(mo!=0){
            return mo;
        }
        //当年月都相同时,比较日
       return day - o.getDay();
    }
}

2、自定义泛型

a、泛型类

b、泛型接口

c、泛型方法

3、泛型继承和通配符

4、JUnit单元测试

a、介绍

5、练习

十六、坦克大战（包含线程、IO流）

0、为什么选择坦克大战

1、坦克大战用到的知识

a、坐标系

i、介绍

ii、像素

b、java绘图技术

i、介绍

public class PannelTest extends JFrame {
    private MyPanel mp = null;

    public static void main(String[] args) {
        new PannelTest();
    }

    public PannelTest() {
        mp = new MyPanel();
        //添加画板
        this.add(mp);
        //设置窗口大小
        this.setSize(400, 400);
        //设置title
        this.setTitle("画一个圆");
        //设置点击❌号结束运行
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //设置窗体可显示
        this.setVisible(true);
    }
}
class MyPanel extends Panel {
    @Override
    public void paint(Graphics g) {
        super.paint(g);
        //画出一个圆形
        g.drawOval(10, 10, 50, 50);
    }
}

• 结果
  

ii、绘图原理

iiii、Graphics类

c、画出坦克

i、介绍

d、事件处理机制

public class TestLister extends JFrame {
    MyPanel my = null;

    public static void main(String[] args) {
        new TestLister();

    }

    public TestLister() {
        my = new MyPanel();
        //添加画板
        this.add(my);

        //设置窗体大小
        this.setSize(400, 400);
        //设置点击叉号关闭
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //设置不可最大化
        this.setResizable(false);
        //设置窗体可显示
        this.setVisible(true);
        //添加画板监听器
        this.addKeyListener(my);
    }


}

class MyPanel extends Panel implements KeyListener {
    int x = 10, y = 10;

    @Override
    public void paint(Graphics g) {
        super.paint(g);
        //画一个圆形
        g.fillOval(x, y, 30, 30);
    }

    /**
     * 监听键盘输出字符
     *
     * @param e
     */
    @Override
    public void keyTyped(KeyEvent e) {

    }

    /**
     * 监听键盘按下的按键
     *
     * @param e
     */
    @Override
    public void keyPressed(KeyEvent e) {
        System.out.println("按下了：" + e.getKeyChar());
        //按下 上下左右键时开始添加事件
        if(e.getKeyCode()==KeyEvent.VK_DOWN){
            y++;
        }else if(e.getKeyCode()==KeyEvent.VK_UP){
            y--;
        }else if(e.getKeyCode()==KeyEvent.VK_LEFT){
            x--;
        }else if(e.getKeyCode()==KeyEvent.VK_RIGHT){
            x++;
        }
        //重绘画板
        this.repaint();
    }

    /**
     * 监听松开键盘
     *
     * @param e
     */
    @Override
    public void keyReleased(KeyEvent e) {

    }
}

i、基本说明

ii、深入理解事件处理机制

iii、事件类型

iiii、事件监听

2、线程（基础部分）

a、线程介绍

• 获取电脑的cpu个数

  @Test
    public void test01(){
        Runtime runtime = Runtime.getRuntime();
        //获取cpu个数
        int i = runtime.availableProcessors();
        System.out.println("此电脑拥有cpu有"+i+" 个");

    }

b、线程使用

i、继承Thread

ii、实现Runnable

c、线程终止

d、线程常用方法

i、常用方法和注意细节

ii、小练习

public class TestExce {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Hello());

        for (int i = 1; i <= 10; i++) {
            System.out.println("hi"+i);
            if(i==5){
                t.start();
                t.join();
                System.out.println("子线程结束.....");
            }
            Thread.sleep(1000);
        }
        System.out.println("主线程结束...");
    }
}

class Hello implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i <=10 ; i++) {
            System.out.println("hello"+i);
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

iii、用户线程和守护线程

e、线程的生命周期

f、Synchronized

i、介绍

i、解决卖票问题

public class TestExce {
    public static void main(String[] args) throws InterruptedException {
        Ticket t = new Ticket();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
    }
}

class Ticket implements Runnable{
    private boolean loop=true;
    private int num=100;
//下面代码块为方法同步
    private synchronized void sell(){
    //代码块同步
    // synchronized(同步的类){
	//下面的方法，填其中
	//}
        if (num<=0){
            System.out.println("票已卖完！！");
            loop=false;
            return;
        }
        System.out.println(Thread.currentThread().getName()+" 卖了一张票，剩余："+(--num));

        //休眠一段时间
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        while (loop){
           sell();
        }
    }
}

g、互斥锁

i、介绍

h、死锁

I、释放锁

i、下面操作会释放锁

ii、下面操作不会释放锁

j、练习题

public class ThreadTest {
    public static void main(String[] args) {
        A a = new A();
        B b = new B(a);
        a.start();
        b.start();
    }
}
class A extends Thread {
    private boolean flag=true;

    @Override
    public void run() {
        while (flag){
            System.out.println((int) (Math.random()*100)+1);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

class B extends Thread{
    private A a;
    private Scanner inp=new Scanner(System.in);
    public B(A a){
        this.a=a;
    }

    @Override
    public void run() {
        while (true){
            System.out.println("请输入Q来结束");
            if(inp.next().equalsIgnoreCase("Q")){
                //以通知方式结束a进程
                a.setFlag(false);
                System.out.println("B线程已退出");
                break;
            }
        }
    }
}

public class ThreadTest02 {
    public static void main(String[] args) {
        Card card = new Card();
        User u1 = new User(" 小虎", card);
        User u2 = new User(" 小白", card);
        u1.start();
        u2.start();
    }
}

/**
 * 模拟银行卡
 */
class Card {
    private static int money = 10000;

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        Card.money = money;
    }
}

/**
 * 模拟用户
 */
class User extends Thread {
    private String name;
    public Card card;

    public User(String name, Card card) {
        this.name = name;
        this.card = card;
    }

    @Override
    public void run() {
        while (true) {
            //同步代码块：同步的是card对象
            synchronized (card) {
                if (card.getMoney() < 1000) {
                    System.out.println("余额不足。目前剩余：" + card.getMoney());
                    break;
                }
                card.setMoney(card.getMoney() - 1000);
                System.out.println(name + "取走1000，当前剩余：" + card.getMoney());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3、坦克发射子弹

a、我方子弹发射分析思路

b、敌方子弹发射思路

c、让敌方坦克自由移动

d、增加功能：双方开始发子弹，击落效果

4、IO流

a、文件

i、概念

ii、常用操作

b、IO流原理及流的分类

• 区别
  

c、节点流和处理流

d、输入流

i、InputStream

1、FileInputStream && FIleOutputStream

• 文件的拷贝
  

2、BufferedInputStream

3、ObjectInputStream && ObjectOutputStream

ii、Reader

1、FileReader && FileWriter

• FileReader介绍
  
  注意：字符输入流是按字符来读取的不是按字节
• FileWriter介绍
  
• 应用案例
  
  

2、BufferedReader

• 注意
  

3、转换流InputStreamReader

e、标准输入输出流

f、打印流

g、Properties类

i、介绍

ii、应用案例

• 读取
  

• 添加
  

• 修改
  

h、练习时刻

5、最终版坦克

a、防止坦克重叠问题

6、个人坦克大战源码

个人代码中未实现的功能：
1、没有解决坦克重叠问题
2、没添加音乐
3、没有菜单
4、不能暂停....

• jar包，在安装有jdk的电脑上可直接运行
  坦克大战jar包
• 个人坦克大战源代码
  坦克大战源码

十七、网络编程

1、网络相关概念

a、ip地址

b、域名

c、网络协议

d、TCP和UDP

e、inetAddress

i、方法

####ii、应用案例

2、Socket

a、介绍

b、TCP网络通信编程

i、netstat指令

ii、TCP网络不为人知的秘密

c、TCP应用案例

i、案例一

• 服务端
  
• 客户端

ii、案例二：使用字节流进行发信息

iii、案例三：使用字符流接收数据

iiii、案例四：向服务端发送图片（上传图片）

• 服务端

 ServerSocket serverSocket=new ServerSocket(9999);
        System.out.println("在段口9999进行监听......");
        //获取客户
        Socket socket = serverSocket.accept();

        //获取客户端发来的图片
        InputStream is = socket.getInputStream();
        BufferedInputStream bis=new BufferedInputStream(is);
        //把文件保存到指定路径
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("src\\t.gif"));
        //使用包装方法把文件全部读取后返回byte数组
        byte[] bytes = StreamUtilsTools.streamToByteArray(bis);
        //开始保存数据
        bos.write(bytes);
        bos.close();
        System.out.println("从客户端获取到了图片");

        //给客户端发送数据
        OutputStream os = socket.getOutputStream();
        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(os,"utf8"));
        bw.write("收到图片！");
        bw.newLine();//结束标识
        bw.flush();

        //关闭
        bw.close();
        bis.close();
        socket.close();
        serverSocket.close();

• 客户端

  Socket socket=new Socket("127.0.0.1",9999);
        //发送图片数据
        BufferedOutputStream bos=new BufferedOutputStream(socket.getOutputStream());
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream("e:\\1.gif"));
        //获取文件
        byte[] bytes = StreamUtilsTools.streamToByteArray(bis);
        //发送文件
        bos.write(bytes);
        bis.close();
        //结束标识
        socket.shutdownOutput();

        //接收从服务器发来的信息
        InputStream is = socket.getInputStream();
        String s = StreamUtilsTools.streamToString(is);
        System.out.println("从服务器接收的信息："+s);

        //关闭
        bos.close();
        socket.close();

• 工具类

   /**
     * 功能：将输入流转换为byte数组，即可以把文件的内容读入到byte中
     * @param is
     * @return
     * @throws IOException
     */
    public static byte[]streamToByteArray(InputStream is) throws IOException {
        //创建输出流对象
        ByteArrayOutputStream bos=new ByteArrayOutputStream();
        int len;
        //字节数组
        byte[]buff=new byte[1024];
        //循环读取
        while ((len=is.read(buff))!=-1){
            //把读取的数据写入bos中
            bos.write(buff,0,len);
        }
        bos.close();
        return bos.toByteArray();
    }

    /**
     * 功能：将InputStream转换为String
     * @param is
     * @return
     * @throws IOException
     */
    public static String streamToString(InputStream is) throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(is,"utf8"));
        StringBuilder sb=new StringBuilder();
        String len;
        while ((len=br.readLine())!=null){
            sb.append(len+"\r\n");
        }
        return sb.toString();
    }

d、UDP网络通信编程

i、介绍

ii、基本流程

e、UDP应用案例

i、案例一

f、本章练习题

i、tcp练习题

ii、udp练习

iii、tcp练习：文件下载

3、多用户即时通讯系统

a、开发流程

b、需求分析

c、登录动能

i、分析

• 注意：多线程中使用ConcurrentHashMap集合来管理线程
  

d、拉取在线用户列表

e、私聊功能

f、群聊功能

g、发文件

h、推送新闻

i、无异常退出

j、拓展功能

k、个人通信系统源码

• 个人编写的源码

十八、反射

1、反射机制

a、引入反射

b、反射原理

c、反射机制可以做的事情

d、反射相关的类

e、反射的优缺点

f、反射优化

2、Class类

a、基本介绍

b、常用方法

c、获取Class对象的几种方式

d、哪些类型有Class对象

3、类加载

a、基本说明

b、类加载过程图

c、类加载的5个阶段

i、加载阶段

ii、连接阶段

• 1、验证
  

• 2、准备
  
  

• 3、解析
  

• 初始化
  

4、反射获取类的结构信息

a、第一组：java.lang.Class类

b、第二组：java.lang.reflect.Field类

c、第三组：java.lang.reflect.Method类

d、第四组：java.lang.reflect.Constructor类

5、反射相关类

a、通过反射创建对象

b、通过反射访问类中的成员

i、访问属性

ii、访问方法

6、本章作业

a、练习一

b、练习二

public class HomeWork02 {
    public static void main(String[] args) throws Exception {
        Class<?> aClass = Class.forName("java.io.File");
        //获取file类的所有构造器
        Constructor<?>[] allCon = aClass.getDeclaredConstructors();
        for (Constructor<?> constructor : allCon) {
            System.out.println("构造器："+constructor);
        }

        System.out.println("==================================");
        //通过构造器创建
        Constructor<?> con = aClass.getConstructor(String.class);
        //实例化对象
        Object o1 = con.newInstance("e:\\nanxiaodi.txt");
        //获取创建文件方法
        Method me = aClass.getMethod("createNewFile");
        Object invoke = me.invoke(o1);
        System.out.println("创建欧克？"+invoke);
    }
}