Day06

方法

含义：特定功能的代码块
好处：
1.减少代码冗余（减少重复性的代码）
2.程序可读性增强
3.减少bug出现
注意：
1.方法与方法是平级关系
2.方法不能在其他方法中声明（方法不能嵌套）
3.方法不被调用，就是个摆设

静态方法的语法结构：
public static 返回值类型方法名([参数列表]){

…代码块…
}

静态方法的分类：
1.无返回值无参数的方法
2.带参数的方法
3.带返回值的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IbxHv2TM-1644159242028)(D:\2113java_workspace\Day06\Day06下午\内存理解图.png)]

无返回值无参数的方法

语法结构：
public static void 方法名(){

…代码块…
}
注意：void – 无返回值

public static void main(String[] args){ 
   
	//调用静态方法方式1
	print();
	
	//调用静态方法方式2
	Test01.print();
	
}

public static void print(){ 
   
	for(int i = 0;i<3;i++){ 
   
		System.out.println("用良心做教育");
	}
}

public static void main(String[] args){ 
   
	run();
	play();
	run();
	run();
	play();
	run();
}

public static void run(){ 
   
	System.out.println("风骚的走位 -- 500行");
}

public static void play(){ 
   
	System.out.println("发技能 -- 1200行");
}

带参数的方法

语法结构：
public static void 方法名(参数列表){

…代码块…
}

注意：
1.方法小括号中声明的变量叫做形式参数/形参
2.调用方法时传入的数据叫做实际参数/实参
3.实参和形参的类型必须兼容
4.形参作用在本方法中
5.多个形参用逗号隔开

	public static void main(String[] args){ 
   
		
		print("用良心做教育");
		print("做真实的自己");
		
		printStar(3,"$");
		printStar(5,"%");
	}
	
	public static void printStar(int num,String str){ 
   
		for(int i = 0;i<num;i++){ 
   
			for(int j = 0;j<=i;j++){ 
   
				System.out.print(str);
			}
			System.out.println();
		}
	}
	
	
	public static void print(String str){ 
   
		for(int i = 0;i<3;i++){ 
   
			System.out.println(str);
		}
    }

带返回值的方法

注意：
1.方法功能的单一性（一个方法的功能不宜过多）
2.方法声明时规定返回值类型
3.return后的数据必须和方法声明时规定返回值类型兼容
4.返回的具体数据是返回给调用方法
5.返回值只能有一个（如果想返回多个数据就可以使用数组或者集合）
总结：
不需要外界传入数据和不需要返回数据给外界，就使用无参无返回值的方法
需要外界传入数据，就使用带参数的方法
需要返回数据给外界，就是用带返回值的方法

public static void main(String[] args){ 
   
		
		//调用方
		int max = getMax(10,20);
		//调用方
		max = getMax(max,30);
		
		System.out.println("最大值为：" + max);
	}
	
	//方法声明时规定返回值类型
	public static int getMax(int a,int b){ 
   
		int max = (a>b)?a:b;
		return max;//return后的数据必须和方法声明时规定返回值类型兼容
	}
	
	public static int xxx(){ 
   
		return 100;
	}

方法的重载

含义：方法和方法之间的关系
条件：
1.在同一个类
2.方法名一致
3.参数列表的个数或者是类型不一致
4.与返回值无关（一个方法有没有返回值或者说一个方法返回什么类型跟方法之间重载是没有关联的）
好处：
系统会根据传入的数据类型自动匹配到对应的方法中
应用场景：
在类中编写多个方法，发现多个方法的功能一致，所以方法名应该是一样的，就考虑使用重载

需求：
编写一个方法，传入两个int值，获取最大值 – getMax
编写一个方法，传入三个int值，获取最大值 – getMax
编写一个方法，传入两个double值，获取最大值 – getMax
编写一个方法，传入三个double值，获取最大值 – getMax

public static void main(String[] args){ 
   
	double max = getMax(10.1,20,30);
	System.out.println(max);
}

public static int getMax(int a,int b){ 
   
	return (a>b)?a:b;
}

public static int getMax(int a,int b,int c){ 
   
	int max = getMax(a,b);
	max = getMax(max,c);
	return max;
}

public static double getMax(double a,double b){ 
   
	return (a>b)?a:b;
}

public static double getMax(double a,double b,double c){ 
   
	double max = getMax(a,b);
	max = getMax(max,c);
	return max;
}

方法的递归

含义：方法调用方法自身
栈内存：调用方法，就在栈内存中开辟空间，
用于存储方法中的局部变量，方法执
行完毕Java中的垃圾回收器(gc)会立
刻回收方法在栈内存所占用的空间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-snVfxTGB-1644159242029)(D:\2113java_workspace\Day06\Day06下午\递归理解图.png)]

public static void main(String[] args){ 
   
		
		method();
	}
	
	//错误示范：递归用不好，就会造成死循环，最终导致栈内存溢出错误(StackOverflowError)
	//报错原因：死循环的调用method方法，就会在栈内存中开辟空间，导致栈内存装载满，就报错
	public static void method(){ 
   
		int i = 1000;
		method();
	}

注意：
1.找规律
2.找出口

	需求：设计一个方法，求n的阶乘
		5! = 1*2*3*4*5	5! = 4! * 5
		4! = 1*2*3*4	4! = 3! * 4
		3! = 1*2*3		3! = 2! * 3
		2! = 1*2		2! = 1! * 2
		1! = 1			1! = 1
		
		找规律	n! = (n-1)! * n
		找出口	1! = 1
		
	课后作业：不死神兔 -- 斐波那契数
	需求：有一对兔子，从出生后第三个月起每个月都生一对兔子，
		  小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，
		  问第N个月的兔子对数为多少？

public static void main(String[] args){ 
   
	
	int num = method(5);
	System.out.println(num);
}

//获取n的阶乘的方法
public static int method(int n){ 
   
	if(n == 1){ 
   
		return 1;
	}else{ 
   
		return method(n-1)*n;
	}
}

方法版本的万年历

import java.util.Scanner;
public class Test01{ 
   
	public static void main(String[] args){ 
   
		//输入年和月
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入年份：");//2021
		int year = scan.nextInt();
		System.out.println("请输入月份：");//12
		int month = scan.nextInt();
		
		//计算总天数
		int allDay = getAllDay(1900,year,1,month);
		
		//获取星期
		int week = getWeek(allDay);
		
		//获取当月天数
		int day = getDay(year,month);
		
		//打印日历
		printCalendar(year,month,day,week);
	}
	
	//获取总天数
	public static int getAllDay(int startYear,int endYear,int startMonth,int endMonth){ 
   
		return getAllDayOfYear(startYear,endYear) + getAllDayOfMonth(endYear,startMonth,endMonth) + 1;
	}
	
	//判断闰年/平年
	public static boolean isLeapYear(int year){ 
   
		if(year%4==0&&year%100!=0 || year%400==0){ 
   
			return true;//闰年
		}
		return false;//平年
	}
	
	//获取当月的天数
	public static int getDay(int year,int month){ 
   
		int day = 0;
		switch(month){ 
   
			case 1:case 3:case 5:case 7:case 8:case 10:case 12:
				day = 31;
			break;
			case 4:case 6:case 9:case 11:
				day = 30;
			break;
			case 2:
				if(isLeapYear(year)){ 
   //闰年
					day = 29;
				}else{ 
   //平年
					day = 28;
				}
			break;
		}
		return day;
	}
	
	//计算开始年到结束年的总天数
	public static int getAllDayOfYear(int startYear,int endYear){ 
   
		int allDayOfYear = 0;
		for(int i = startYear ;i<endYear;i++){ 
   
			if(isLeapYear(i)){ 
   
				allDayOfYear += 366;
			}else{ 
   
				allDayOfYear += 365;
			}
		}
		return allDayOfYear;
	}
	
	//计算开始月到结束月的总天数
	public static int getAllDayOfMonth(int year,int startMonth,int endMonth){ 
   
		int allDayOfMonth = 0;
		for(int i = startMonth;i<endMonth;i++){ 
   
			allDayOfMonth += getDay(year,i);
		}
		return allDayOfMonth;
	}
	
	//计算星期
	public static int getWeek(int allDay){ 
   
		int week = allDay%7;
		if(week == 0){ 
   //说明输入月的第一天是星期天
			week = 7;
		}
		return week;
	}
	
	//打印日历
	public static void printCalendar(int year,int month,int day,int week){ 
   
		//打印日历 -- 头部信息
		System.out.println("--- " + year + "年" + month + "月 ---");
		System.out.println("一\t二\t三\t四\t五\t六\t日");
		
		//打印日历 -- 空格
		int num = 0;
		for(int i = 1;i<week;i++){ 
   
			System.out.print("\t");
			num++;
		}
		
		//打印日历 -- 日期
		for(int i = 1;i<=day;i++){ 
   
			System.out.print(i + "\t");
			num++;
			if(num % 7 == 0){ 
   
				System.out.println();//换行
			}
		}
	}

}

作业

Work01.java

Work02.java

Work03.java

Work04.java

Day07 & 08

一维数组

含义：一组数据的容器
声明：
数据类型[] 数组名;

概念：
元素：数组中的数据
下标/索引：每个元素的编号/位置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-62IBSBQH-1644159242030)(D:\2113java_workspace\Day06\Day06下午\数组的概念图.png)]
注意：
1.数组是引用数据类型
2.数组一旦初始化完毕，长度不可改变（意味着数组没有添加和删除的功能)
3.数组的下标从0开始
4.一维数组在内存分配的空间是连续的

初始化：
1.静态初始化：数据由程序员指定，系统自动分配长度

2.动态初始化：

长度由程序员指定，系统自动分配数据
默认值：
整数类型：0
浮点类型：0.0
字符类型：’ ’
布尔类型：false
引用类型：null(空)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EKEY1cak-1644159242030)(D:\2113java_workspace\Day07\Day07上午\一维数组动态初始化理解图.png)]

静态初始化 vs 动态初始化
声明数组时，一开始就知道元素，就使用静态初始化
声明数组时，一开始就知道长度，就使用动态初始化

public static void main(String[] args){ 
   
	
	静态初始化1
	String[] names = new String[]{ 
   "椎名空","三上悠亚","北条麻衣","波多野结衣","京香Julia"};
	
	静态初始化2
	String[] names;
	names = new String[]{ 
   "椎名空","三上悠亚","北条麻衣","波多野结衣","京香Julia"};
	
	静态初始化3
	String[] names = { 
   "椎名空","三上悠亚","北条麻衣","波多野结衣","京香Julia"};
    
    动态初始化1：
	String[] names = new String[5];//5->5个元素
		
	动态初始化2：
	String[] names;
	names = new String[5];//5->5个元素
	
	通过下标设置元素
	names[2] = "李尧尧";
	
	通过下标获取元素
	String element = names[2];
	System.out.println(element);
	System.out.println(names[2]);
	
	获取长度
	int len = names.length;
	System.out.println("数组中元素的个数为：" + len);//5
	
	遍历数组 -- for循环
	for(int i = 0;i<names.length;i++){ 
   
		System.out.println(names[i]);
	}
	
	遍历数组 -- foreach/增强for循环
	for(String name : names){ 
   //依次取出names数组中的元素，并赋值给name
		System.out.println(name);
	}

	for vs foreach
		遍历时需要操作下标，就用for循环
		遍历时不需要操作下标，就用foreach循环
		
public static void main(String[] args){ 
   
		//声明5个长度的int数组，获取最大值
		int[] is = { 
   4,2,5,7,3};
		int max = is[0];//假设下标为0的元素是最大值
		for(int i = 1;i<is.length;i++){ 
   
			if(max < is[i]){ 
   
				max = is[i];
			}
		}
		System.out.println("最大值为：" + max);

数组的排序

分类：
冒泡排序
插入排序
选择排序
快速排序
…
冒泡排序口诀：
N个数字来排队
两两相比小靠前
外层循环N-1
内层循环N-1-i

public static void main(String[] args){ 
   
	int[] is = { 
   67,81,23,18,27};
	
	//冒泡排序
	for(int i = 0;i<is.length-1;i++){ 
   
		for(int j=0;j<is.length-1-i;j++){ 
   
			if(is[j] > is[j+1]){ 
   
				int temp = is[j];
				is[j] = is[j+1];
				is[j+1] = temp;
			}
		}
	}
	
	//打印
	for(int num : is){ 
   
		System.out.println(num);
	}
	
}

数组的查找

分类：
顺序查找
二分法查找
…

public static void main(String[] args){ 
   
	int[] is = { 
   67,81,23,18,27};
	int num = 81;
	for(int i = 0;i<is.length;i++){ 
   
		if(num == is[i]){ 
   
			System.out.println("查找到了");
			break;
		}
	}
}

import java.util.Arrays;
public class Test05{ 
   
public static void main(String[] args){ 
   
	int[] is = { 
   67,81,23,18,27};
	int num = 81;
	//排序 18 23 27 67 81
	Arrays.sort(is);
	
	int start = 0;
	int end = is.length-1;
	
	while(start <= end){ 
   
		int mid = (start + end)/2;
		
		if(num > is[mid]){ 
   
			start = mid+1;
		}else if(num < is[mid]){ 
   
			end = mid-1;
		}else{ 
   
			System.out.println("找到元素了");
			break;
		}
	}
	}
	}

数组的复制

数组的复制1

缺点：修改源数组，会导致新数组的数据也发生改变

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nOq3C4rA-1644159242031)(D:\2113java_workspace\Day07\Day07上午\数组的复制1.png)]

		//源数组
		String[] names = { 
   "麻生希","椎名空","北岛玲","朝桐光","苍井空"};
		
		//新数组
		String[] newNames = names;
		
		//修改源数组中的数据
		names[2] = "李尧尧";
		
		//遍历新数组
		for(String name : newNames){ 
   
			System.out.println(name);
		}

数组的复制2

规避缺点：修改源数组，不会导致新数组的数据也发生改变

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RRzZLLe3-1644159242031)(D:\2113java_workspace\Day07\Day07上午\数组的复制2.png)]

public class Test07{ 
   
	public static void main(String[] args){ 
   
		//源数组
		String[] names = { 
   "麻生希","椎名空","北岛玲","朝桐光","苍井空"};
		
		//新数组(长度和源数组一样)
		String[] newNames = new String[names.length];
		
		//将源数组中所有数据迁移到新数组中
		for(int i = 0;i<names.length;i++){ 
   
			newNames[i] = names[i];
		}
		
		//修改源数组中的数据
		names[2] = "李尧尧";
		
		//遍历新数组
		for(String name : newNames){ 
   
			System.out.println(name);
		}
		
	}
}

数组的扩容

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F0h0T9xT-1644159242032)(D:\2113java_workspace\Day07\Day07下午\数组的扩容.png)]

public class Test08{ 
   
	public static void main(String[] args){ 
   
		//源数组
		String[] names = { 
   "麻生希","椎名空","北岛玲","朝桐光","苍井空"};
		
		//新数组（新数组是源数组的长度的1.5倍）
		int capacity = names.length;
		int newCapacity = capacity + (capacity>>1);
		String[] newNames = new String[newCapacity];//null null null null null null null
		
		//数据的迁移 麻生希 椎名空 北岛玲 朝桐光 苍井空 null null
		for(int i = 0;i<names.length;i++){ 
   
			newNames[i] = names[i];
		}
		
		//将新数组对象的地址赋值给源数组的引用
		names = newNames;
		
		//遍历源数组
		for(String name : names){ 
   
			System.out.println(name);
		}
		
	}
}

数组的删除

数组的删除1

缺点：数组本来是容器，这种删除方式会让存储空间越来越小

public class Test09{ 
   

	public static void main(String[] args){ 
   
		//源数组
		String[] names = { 
   "麻生希","椎名空","北岛玲","朝桐光","苍井空"};
		
		//新数组
		String[] newNames = new String[names.length-1];
		
		//数据的迁移
		int index = 0;
		for(String name : names){ 
   
			if(!name.equals("椎名空")){ 
   
				newNames[index++] = name;
			}
		}
		
		//将新数组对象的地址赋值给源数组的引用
		names = newNames;
		
		//遍历源数组
		for(String name : names){ 
   
			System.out.println(name);
		}
		
	}
}

数组的删除2

规避缺点：这种删除方式不会改变数组的容量

public class Test10{ 
   

	public static void main(String[] args){ 
   
		
		//源数组
		String[] names = { 
   "麻生希","椎名空","北岛玲","朝桐光","苍井空"};
		
		//数据的迁移
		for(int i = 1;i<names.length-1;i++){ 
   
			names[i] = names[i+1];
		}
		names[names.length-1] = null;
		
		//遍历源数组
		for(String name : names){ 
   
			System.out.println(name);
		}
		
	}
}

数组作为参数和返回值

需求：编写一个方法，传入int类型的数组，返回最大值和最小值

public class Test11{ 
   

	public static void main(String[] args){ 
   
		
		int[] is = { 
   4,2,6,1,3,5};
		
		int[] maxAndMin = method(is);
		
		System.out.println("最大值为：" + maxAndMin[0]);
		System.out.println("最小值为：" + maxAndMin[1]);
	}
	
	public static int[] method(int[] is){ 
   
		int max = is[0];
		int min = is[0];
		for(int num : is){ 
   
			if(max < num){ 
   
				max = num;
			}
			if(min > num){ 
   
				min = num;
			}
		}
		return new int[]{ 
   max,min};
	}
}

可变参数

需求：编写一个方法，传入两个int值，求和
需求升级：编写一个方法，传入三个int值，求和
需求升级：编写一个方法，传入四个int值，求和
需求升级：编写一个方法，传入n 个int值，求和

public class Test12{ 
   

	public static void main(String[] args){ 
   
法一
		int sum = add(1,2,3,4,5);//传入的实参是作为数组的元素
		
		System.out.println(sum);
	}
	//可变参数：本质上就是数组
	public static int add(int... is){ 
   
		
		int sum = 0;
		for(int num : is){ 
   
			sum += num;
		}
		return sum;
	}
	
  法二：
 int sum = add(new int[]{ 
   1,2,3,4,5});//传入的实参是作为数组的元素
	System.out.println(sum);
	}
	//可变参数：本质上就是数组
	public static int add(int[] is){ 
   	
		int sum = 0;
		for(int num : is){ 
   
			sum += num;
		}
		return sum;
	}
	注意：可变参数后面不能添加其他参数
	public static void method(int i,String... ss){ 
       对
	}
	public static void method(String... ss,int i){ 
       错
	}
    一个方法中只能有一个可变参数

Arrays工具类

含义：java给我们提供的操作数组的工具类
API概念：Java类的使用说明书

import java.util.Arrays;
public class Test13{ 
   
public static void main(String[] args){ 
   
	int[] is = { 
   67,81,23,18,27};
	
	//排序 18 23 27 67 81
	Arrays.sort(is);

	//查找
	//注意：必须先排序再查找
	//返回值理解：如果有该元素，就返回下标，否则返回 -插入点-1
	int index = Arrays.binarySearch(is,79);
	System.out.println(index);
	
	//替换
	Arrays.fill(is,888);
	Arrays.fill(is,1,3,666);//(目标数组,开始下标-包含,结束下标-不包含,替换内容)
	
	//拷贝数组
	int[] copyOf =  Arrays.copyOf(is,is.length*2);
	
	//拷贝数组
	int[] copyOfRange = Arrays.copyOfRange(copyOf,1,5);//(目标数组,开始下标-包含,结束下标-不包含)
	
	//将数组转换为字符串
	String str = Arrays.toString(copyOfRange);
	System.out.println(str);
	
}
}

作业

Work01.java

Work02.java

Work03.java

Work04.java

Work05.java

Work06.java

Work07.java

Work08.java

Work09.java

Work10.java

Work01.java

二维数组

含义：包含多个一维数组
声明：数据类型[][] 数组名;
概念：
1.数组中的数据叫做元素
2.元素是有编号的，叫做下标/索引
3.下标从0开始
初始化：
静态初始化：数据由程序员指定，长度由系统自动分配

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nIDE9HYh-1644159242033)(D:\2113java_workspace\Day08\Day08上午\二维数组的静态初始化.png)]

动态初始化：长度由程序员指定，数据由系统自动分配
整数类型：0
浮点类型：0.0
字符类型：’ ’
布尔类型：false
引用类型：null

package com.qf.test01;

public class Test01 { 
   

	public static void main(String[] args) { 
   
		
静态初始化1：
String[][] names = new String[][]{ 
   { 
   "麻生希","椎名空","朝桐光"},{ 
   "钟燕","李尧尧","周世伟","邓荣华"}};
		
静态初始化2：
String[][] names;
names = new String[][]{ 
   { 
   "麻生希","椎名空","朝桐光"},{ 
   "钟燕","李尧尧","周世伟","邓荣华"}};
		
静态初始化3：
String[][] names = { 
   { 
   "麻生希","椎名空","朝桐光"},{ 
   "钟燕","李尧尧","周世伟","邓荣华"}};
        
动态初始化1：
String[][] names = new String[2][3];//2-两个一维数组 3-每个一维数组的元素个数
		
动态初始化2：
String[][] names;
names = new String[2][3];//2-两个一维数组 3-每个一维数组的元素个数
		
通过下标设置元素
names[0][2] = "黄小龙";
		
通过下标获取元素
String n = names[0][2];
System.out.println("通过下标获取元素：" + n);//黄小龙
		
获取长度
System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
System.out.println("获取二维数组中第一个一维数组元素的个数：" + names[0].length);//3
System.out.println("获取二维数组中第二个一维数组元素的个数：" + names[1].length);//4
		
遍历 -- for循环
		for (int i = 0; i < names.length; i++) { 
   
			for (int j = 0; j < names[i].length; j++) { 
   
				System.out.println(names[i][j]);
			}
		}
		
	
遍历 -- foreach
		for (String[] ss : names) { 
   
			for (String name : ss) { 
   
				System.out.println(name);
			}
		}
	}
}

需求：使用动态初始化定义二维数组，第一个一维数组元素个数为3，第二个一维数组元素个数为4
package com.qf.test01;

public class Test03 { 
   

	public static void main(String[] args) { 
   
		//创建长度为2的二维数组
		String[][] names = new String[2][];
		
		//创建长度为3的一维数组 
		String[] ss1 = { 
   "aaa","bbb","ccc"};
		//创建长度为4的一维数组 
		String[] ss2 = { 
   "xxx","yyy","zzz","mmm"};
		
		names[0] = ss1;//将一维数组赋值给二维数组下标为0的位置
		names[1] = ss2;//将一维数组赋值给二维数组下标为1的位置
		
		for (String[] ss : names) { 
   
			for (String name : ss) { 
   
				System.out.println(name);
			}
		}
	}
}

五子棋

Test01.java

Day09

初识面向对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CAVTI8eT-1644159242033)(D:\2113java_workspace\Day08\Day08下午\面向对象理解图.png)]

person类 Person.java

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n0M3msf2-1644159242034)(D:\2113java_workspace\Day08\Day08下午\类结构图.png)]

对象：

需求：
编写人类（属性：姓名、性别、年龄方法：吃饭饭、睡觉觉）
并创建一个对象，操作属性和方法

Test01.java

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6W2n7JTJ-1644159242034)(D:\2113java_workspace\Day08\Day08下午\面向对象内存图1.png)]

编写人类（属性：姓名、性别、年龄方法：吃饭饭、睡觉觉）
并创建两个对象，操作属性和方法

Test02.java

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w7tPmRzw-1644159242035)(D:\2113java_workspace\Day08\Day08下午\面向对象内存图2.png)]

构造方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2OqsI6nS-1644159242036)(D:\2113java_workspace\Day09\Day09上午\构造方法内存图.png)]

Person类 Person.java

特点：与类名相同且没有返回项的方法
注意：在没有有参构造的情况下，系统会默认实现无参构造（没有参数的构造方法）
作用：
1.与new一起是创建对象的意思
2.创建对象时可以初始化成员属性

无参构造

Test01.java

有参构造

Test02.java

private – 私有的

作用：
1.修饰属性：不能在类的外界使用
2.修饰方法：不能在类的外界使用

User类 User.java

对象 Test01.java

封装

理解：封装是个思想，不能让属性直接被外界调用，通过get/set方法让外界调用
原因：通过get/set方法让外界调用，我们可以操作属性，但是也可以做额外的功能，比如：记录get/set的时间
注意：
get-获取
set-设置
步骤：
1.私有化属性（目的：让属性不在外界直接使用）
2.添加get/set方法

this

知识点：this
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qBNqi8kC-1644159242036)(D:\2113java_workspace\Day09\Day09上午\this理解图.png)]

含义：本对象
- 理解：this在构造方法、成员方法中使用，表示调用该方法的对象
- 作用：
- ```
  1.调用本对象的成员属性
```
- ```
  2.调用本对象的成员方法
```
- 3.调用构造方法(调用构造方法一定是在构造方法中的第一句)

User类 User.java

对象（封装） Test01.java

对象（this） Test02.java

Static

知识点：static

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sM4zZTVS-1644159242036)(D:\2113java_workspace\Day09\Day09下午\静态属性内存图.png)]

含义：静态的

作用：

1.修饰属性：类属性，注意：直接使用类名调用

A类： A.java

对象： Test01.java

2.修饰方法

含义：静态方法
调用：直接用类名调用
应用场景：工具类

3.静态代码块

package com.qf.test02;

public class A { 
   
	
	String str1;
	static String str2;
	
	//类加载到方法区时调用
	//静态代码块可以初始化静态变量（不能初始化成员变量，因为在类加载到方法区时对象都没有创建何来的成员变量？）
	static{ 
   
		
		str2 = "bbb";//A.str2 = "bbb";
		System.out.println("静态代码块");
	}
	
	//创建对象时，优先于构造方法调用
	//代码块可以初始化成员变量和静态变量
	{ 
   
		str1 = "aaa";//this.str1 = "aaa";
		str2 = "bbb";//A.str2 = "bbb";
		System.out.println("代码块");
	}
	
	
	//创建对象时调用
	//构造方法可以初始化成员变量和静态变量
	public A(){ 
   
		
		str1 = "aaa";//this.str1 = "aaa";
		str2 = "bbb";//A.str2 = "bbb";
		System.out.println("A类的构造方法");
	}

}

package com.qf.test02;

public class Test01 { 
   
	
	public static void main(String[] args) { 
   
		A a1 = new A();
		A a2 = new A();
	}
}

类加载机制面试题

package com.qf.test05;

public class Test01 { 
   
	
	public static void main(String[] args) { 
   
		/** * 知识点：类加载机制面试题 */
		
		System.out.println(A.value1);//1
		System.out.println(A.value2);//0
	}
}

class A{ 
   
	//准备阶段1:系统分配空间
	// A a;
	// int value1;
	// int value2;
	//准备阶段2：系统赋默认值
	// A a = null;
	// int value1 = 0;
	// int value2 = 0;
	//初始化阶段：
	// A a = new A();
	// int value1 = 1;
	// int value2 = 0; 
	
    private static A a = new A();
    public static int value1;	
    public static int value2 = 0;

    private A(){ 
   
        value1++;
        value2++;
    }
}

package com.qf.test06;

public class Test01 { 
   
	
	public static void main(String[] args) { 
   
		/** * 知识点：类加载机制面试题 */
		
		System.out.println(B.value1);//1
		System.out.println(B.value2);//1
	}
}

class B{ 
   
	
	//准备阶段1：
	// int value1;
	// int value2;
	// B b;
	//准备阶段2：
	// int value1 = 0;
	// int value2 = 0;
	// B b = null;
	//初始化阶段：
	// int value1 = 1;
	// int value2 = 1;
	// B b = new B();
	
    public static int value1;
    public static int value2 = 0;
    private static B b = new B();

    private B(){ 
   
        value1++;
        value2++;
    }
    
}

作业

Elephant.java

Person.java

Refrigerator.java

Work01.java

Day10

继承

知识点：继承
- 含义：子类继承父类
  - 好处：解决代码的冗余
  - 应用场景：编写多个类，发现有相同的属性和方法时，就抽取到父类中

父类Person: Person.java

子类Chinese: Chinese.java

子类Japanese: Person.java

对象: Test01.java

深入继承

知识点：深入继承

1.创建子类对象，会调用父类构造方法吗？

会
2.创建子类对象，调用父类构造方法的目的是什么？
目的是在子类对象在堆中开辟的空间内存放父类成员变量
3.创建子类对象，会创建父类对象吗？
不会创建
4.创建子类对象，先调用父类构造方法还是子类构造方法？
先调用子类构造方法
5.创建子类对象，先完成父类构造方法还是子类构造方法？
先完成父类构造方法
6.子类是否可以继承父类私有化的属性和私有化的方法
可以继承
但不能直接调用，可以间接调用

父类：Father Father.java

子类：Son Son.java

对象： Test01.java

super

含义：表示父类，在子类中使用

作用：

1.调用父类非私有化的成员变量

2.调用父类非私有化的成员方法

3.调用父类非私有化的构造方法

父类：Father Father.java

子类：Son Son.java

对象 Test01.java

父类Person: Person.java

子类Chinese: Chinese.java

子类Japanese: Japanese.java

对象: Test01.java

重写

含义：在子类中重新写一遍父类的方法，可以扩展功能

应用场景：父类方法不满足子类需求时，在子类中重写即可

条件：

1.在子类中重写

2.访问修饰符不能被父类更严格

3.返回值类型、方法名、参数列表必须和父类重写的一模一样

经验：一般情况下，直接拷贝父类的方法，在子类中修改代码块即可

注解：既能向程序员解释代码，也能向程序解释代码
@Override – 注解，表示该方法是重写父类的

父类Person: Person.java

子类Chinese: Chinese.java

子类Japanese: Japanese.java

对象: Test01.java

访问修饰符

知识点：访问修饰符

含义：使用权限

作用：类上、方法上、属性

分类：

```
 1.private
```
```
 2.默认
```
```
 3.protected
```
4.public

父类A: A.java

子类B: B.java

对象: Test01.java

inese.java](D:\2113java_workspace\Day10\Day10下午\src\com\qf\test06\Chinese.java)

子类Japanese: Japanese.java

对象: Test01.java

重写

含义：在子类中重新写一遍父类的方法，可以扩展功能

应用场景：父类方法不满足子类需求时，在子类中重写即可

条件：

1.在子类中重写

2.访问修饰符不能被父类更严格

3.返回值类型、方法名、参数列表必须和父类重写的一模一样

经验：一般情况下，直接拷贝父类的方法，在子类中修改代码块即可

注解：既能向程序员解释代码，也能向程序解释代码
@Override – 注解，表示该方法是重写父类的

父类Person: Person.java

子类Chinese: Chinese.java

子类Japanese: Japanese.java

对象: Test01.java

访问修饰符

知识点：访问修饰符

含义：使用权限

作用：类上、方法上、属性

分类：

```
 1.private
```
```
 2.默认
```
```
 3.protected
```
4.public

父类A: A.java

子类B: B.java

对象: Test01.java

今天的文章Week02分享到此就结束了，感谢您的阅读，如果确实帮到您，您可以动动手指转发给其他人。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至举报，一经查实，本站将立刻删除。
如需转载请保留出处：https://bianchenghao.cn/33447.html

Week02

Day06

方法

无返回值无参数的方法

带参数的方法

带返回值的方法

方法的重载

方法的递归

方法版本的万年历

作业

Day07 & 08

一维数组

数组的排序

数组的查找

数组的复制

数组的复制1

数组的复制2

数组的扩容

数组的删除

数组的删除1

数组的删除2

数组作为参数和返回值

可变参数

Arrays工具类

作业

二维数组

五子棋

Day09

初识面向对象

构造方法

无参构造

有参构造

private – 私有的

封装

this

Static

类加载机制面试题

作业

Day10

继承

深入继承

super

重写

访问修饰符

重写

访问修饰符

相关推荐

发表回复