JAVA笔记

LFY1212

已于 2022-03-23 12:45:31 修改

阅读量116

点赞数

文章标签： eclipse java maven

于 2022-03-23 12:37:41 首次发布

本文链接：https://blog.csdn.net/LFY1212/article/details/123683004

版权

JAVA基础

一、java核心概念

JVM（Java Virtual Machine）:java虚拟机，内涵解释器，java可以跨平台就是因为自带解释器。

JRE（Java Running Environment）：java运行环境，运行java程序必须的环境，内含JVM。

JDK（Java Development Kit）：java开发工具包，开发必备，java编译器，内含JRE。运行不一定要有，只有开发才需要。（类似于吃饭不一定需要锅，但做饭一定需要锅。）

编译好的源文件（.java）需要用编译器生成字节码文件（.class），然后通过解释器执行。

二、java分类

1、javase

java标准语法，java基础环境，无论在什么java环境下均适用。

2、javaee

java企业级应用开发环境，较为臃肿。

3、javame

java移动环境，移动设备或嵌入式设备，小型环境，概念几乎消失。现在移动平台基本使用arm架构。
##三、java版本
早期sun公司发行版本为jdk1.0-jdk1.6，后oracle公司收购后发行版本为jdk1.7、jdk1.8，之后均为java6、java7、java8……

现如今java支持java7以后，早期sun公司版本不支持。

目前每六个月发布一次新版本，每年三月和九月。

从2019年9月版本之后均需要购买官方授权，最后一个企业稳定版为java8（现今多数公司使用版本java1.8.20）

openjdk是java7的先行版本，java7之后的openjdk为开源版本

四、java优势

1、通用优势

健壮性，安全性，面向对象

2、主要优势

JVM：使得java与平台无关，更容易，更安全，一处代码处处执行。

垃圾回收机制：不需要用指针去手动回收开辟的空间，JVM自带垃圾回收。

五、java命名规则

可以使用字母a-z(大小写均可)、数字、下划线、$

不能以数字开头，不能使用保留字及关键字对数字敏感

1>类名:用名词，首字母大写，驼峰式命名规则

2>变量名:首字母小写，驼峰式命名规则

3>常量名：全部大写，下划线连接

4>方法名:动词，首字母小写，驼峰式命名规则

六、类的编译规则

1．使用public修饰的类该类的名字必须与该类所在的源文件同名

2．java编译后生成的class文件名与源代码中类的名字相同与源代码文件名无关

3．在同一个源代码文件中可以编写多个类

4．在同一个源代码文件中多个类编译后生成各自与该源代码中与各个同名的class文件

5．在同一个源代码文件中多个类public只能修饰与源文件同名的那个类

6．在同一个源代码文件中不能出现同名的类

7．但是在内部类中可以出现多个public

七、包的命名规则

1．符合java命名规范只有字母数字_$不能以数字开头

2．公司域名倒写＋项目名＋模块名＋

3．包用来分装类（类似文件夹分装文件夹）

4．com.xxx（域名）.xxx（项目）.xxx（模块）

使用eclipse构建java项目

一、Test方法的使用

1、右键test/java，新建类，类名需要有test，包是main的包

2、编写时不需要main方法

3、需要修改poml.xml文件，添加以下代码

	<dependencies>
		<dependency>
			<groupId>org.junit.jupiter</groupId>
			<artifactId>junit-jupiter</artifactId>
			<version>5.8.2</version>
			<scope>test</scope>
		</dependency>
	</dependencies>

其中版本号需要自行查找，之后等待在线下载junit组件包

查找方式为打开网址https://mvnrepository.com/，搜索juint，点击api，即可查看最新版本，点击最新版本，可以找到如上代码

二、变量与常量

1、变量的声明、赋值与输出

	@Test
	public void test05() {
		int a = 10;			//变量的赋值：数据类型 变量名 赋值符号 变量值分号
		//变量就是在内存中凯尼一个空间，名就是空间的名字，查找用，值就是空间中所存放的东旭
		System.out.println(a);		//变量的输出	输出变量时不能加""，若增加，则只输出变量名
		//八种基本的数据类型
		byte z = 10;			//数值型-整数型-byte变量，占用1B空间
		short y = 10;			//数值型-整数型-short变量，占用2B空间
		int x = 10;				//数值型-整数型-int变量，占用4B空间
		long w = 10L;			//数值型-整数型-long变量，占用8B空间，变量赋值时需要加L
		double v = 10.0d;		//数值型-浮点型-double变量，占用8B空间，变量赋值时需要加d
		float u = 10.0f;		//数值型-浮点型-float变量，占用4B空间，变量赋值时需要加f
		char t = 't';			//字符型-char变量，占用2B空间，在java中采用unicode编码，所以占用2B
		boolean s = true;		//布尔型-boolean变量，占用1B空间，只有true或false
		boolean r = false;
	}

2、数据类型的修改

小转大自动转，大转小强制转

int a = 10; long b = a;   //	√
long a = 10; int b = a;   //	×

强制转换可以但会造成数据失真

long a = 1;
int b = (int) a;
System.out.print(b);

3、常量，不可修改

 final int a = 1;

此后a不可修改

三、字符串

1、字符串声明、赋值与读取

	@Test
	public void test01() {
		String a = "忽如一夜春风来，";
		String b = "千树万树梨花开。";
		System.out.println(a);			//	输出字符串时不能加""，若增加，则只输出变量名
		System.out.println(b);
	}

2、字符串拼接

1、使用拼接符+进行拼接
2、使用.concat()方法进行拼接

四、转义字符

	@Test
	public void test02() {
		System.out.print("aaaaa\"");			//	\"   输出"
		System.out.print("bbbbb\n");			//  \n   换行
		System.out.print("ccccc\r");			//  \r   回车
		System.out.print("ddddd\t");			//	\t   tab位
		System.out.print("eeeee\\" + "\n");		//	\\   转义输出\
	}

五、运算符

1、数学运算符

@Test
public void test05() {
	int a = 1;
	int b = 2;
	int c = a % b;					//	%	取模运算，只取余数
	double e = (a + 0.0f) / b;
	double f = (a + 0.0f) / 4;		//java中除法为地板除
	System.out.println(c);
	System.out.println(e);
	System.out.println(f);			//Java中浮点型计算能但不精确
}

@Test
public void test06() {
	int a = 10;
	System.out.println(a++);		//自增运算，此时输出a原值，因为先取a值输出才进行自增
	System.out.println(++a);		//自增运算，此时输出a++的值，因为先进行自增才取a值输出
	System.out.println(a);
	int b = a++;					//b输出a原值，因为先取了a值赋给b才进行a的自增运算，之后并没有第二次给b赋值
	// int b = a;
	// a = a + 1;
	System.out.println(b);
	System.out.println(a);
}

2、比较运算符

@Test
public void test13() {
	System.out.print("10 == 10 >>>" + (10 == 10) + "\t");		//	==	等于，比较对象是否相等
	System.out.println("10 == 20 >>>" + (10 == 20));
	System.out.print("10 != 10 >>>" + (10 != 10) + "\t");		//	!=	不等于，比较对象是否不等
	System.out.println("10 != 20 >>>" + (10 != 20));
	System.out.print("10 > 20 >>>" + (10 > 20) + "\t");			//	>	大于，返回x大于y的结果
	System.out.println("10 < 20 >>>" + (10 < 20));				//	<	小于，返回x小于y的结果
	System.out.print("10 <= 10 >>>" + (10 <= 10) + "\t");		//	<=	小于等于，返回x小于等于y的结果
	System.out.print("10 <= 11 >>>" + (10 <= 11) + "\t");
	System.out.println("10 <= 9 >>>" + (10 <= 9));
	System.out.print("10 >= 10 >>>" + (10 >= 10) + "\t");		//	>=	大于等于，返回x大于等于y的结果
	System.out.print("10 >= 11 >>>" + (10 >= 11) + "\t");
	System.out.println("10 >= 9 >>>" + (10 >= 9));
	//	输出值为True或False
}

3、逻辑运算符

（1）、

逻辑与&

短路与&&

	@Test
	public void test01() {
		int a = 10;
		int b = 20;
		int c = 30;
		// 逻辑与 &
		// （逻辑）短路与 &&
		System.out.println("a < b && a < c >>> " + (a < b && a < c));
		// &&符号两端表达式返回结果同时为true的时候则整体返回值为true
		System.out.println("a > b && a > c >>> " + (a > b && a > c));
		// &&符号两端表达式返回有一个为false则整体返回值为false 当第一个表达式返回结果为false的时候则第二个表达式不再计算 直接整体返回false
		System.out.println("a < b & a < c >>> " + (a < b & a < c));
		// &符号两端表达式返回结果同时为true的时候则整体返回值为true
		System.out.println("a > b & a > c >>> " + (a > b & a > c));
		// &符号两端表达式返回有一个为false则整体返回值为false，当第一个表达式返回结果为false的时候第二个表达式仍然需要计算
	}

（2）

逻辑或|

短路或||

@Test
	public void test02() {
		int a = 10;
		int b = 20;
		int c = 30;
		// 逻辑或 |
		// （逻辑）短路或 ||
		System.out.println("a < b || a < c >>> " + (a < b || a < c));
		// ||符号两端表达式返回结果有一个为true的时候则整体返回值为true 当第一个表达式返回结果为true的时候则第二个表达式不再计算 直接整体返回true
		System.out.println("a > b || a > c >>> " + (a > b || a > c));
		// ||符号两端表达式返回均为为false则整体返回值为false
		System.out.println("a < b | a < c >>> " + (a < b | a < c));
		// |符号两端表达式返回结果有一个为true的时候则整体返回值为true 当第一个表达式返回结果为true的时候第二个表达式仍然要做计算
		System.out.println("a > b | a > c >>> " + (a > b | a > c));
		// |符号两端表达式返回均为为false则整体返回值为false
	}

（3）

逻辑非！

@Test
	public void test03() {
		// 逻辑非 ！输出相反的结果
		System.out.println("!true => " + !true);
		System.out.println("!false => " + !false);
		System.out.println("!!true => " + !!true);
		System.out.println("!!false => " + !!false);
	}

4、位运算符

	@Test
	public void test04() {
		// &按位与运算
		System.out.println(5 & 3);
		// |按位或运算
		System.out.println(5 | 3);
		// ^按位异或运算		二进制，相同输出0，不同输出1
		// 原数据根据参考数据得到一个新数据，再次异或该参考数据会得到原数据   可以用来加密
		System.out.println(5 ^ 3);
		System.out.println(6 ^ 3);
		// ~按位取反  二进制中最高位为符号位，0正1负 
		System.out.println(~ 3);	
	}

5、左移与右移

@Test
	public void test05() {
		//右移相当于除以2的n次幂
		//无符号右移 >>> 也叫逻辑右移若该数为正，则最高位补0，负数同样补0   无符号右移一般正数运算时使用
		System.out.println(8 >>> 2);
		//右移 >> 若该数为正，则最高位补0，负数补1
		System.out.println(8 >> 2);
		System.out.println(-4 >> 2);
		System.out.println(4 >> 3);
		System.out.println(-4 >> 1);
		//左移相当于乘以2的n次幂		
		//最低位补0 
		System.out.println(2 << 2);
		System.out.println(-2 << 2);
	}

六、判断与循环

1、判断

（1）if语句

if(判断内容){判断内容为true时需要执行的内容}

@Test
	public void test01() {
		boolean rain = true;
		if (rain) {
			System.out.println("不上课");
		}
		System.out.println("结束");
	}

（2）if-else语句

if(判断内容){判断内容为true时需要执行的内容}
else{判断结果为false时需要执行的内容}

	@Test
	public void test02() {
		boolean rain = true;

		if (rain) {
			System.out.println("今天不上课");
		} else {
			System.out.println("上课");
		}
		System.out.println("结束");
	}

（3）if-else-if语句

if(判断的内容){判断内容为true时需要执行的内容}
else if(判断的内容){判断内容为true时需要执行的内容}
else if(判断的内容){判断内容为true时需要执行的内容}

	@Test
	public void test07() {
		Random random = new Random();
		int i = random.nextInt(7);
		System.out.println(i);
		if (i == 1) {
			System.out.println("今天是星期一");
		} else if (i == 2) {
			System.out.println("今天是星期二");
		} else if (i == 3) {
			System.out.println("今天是星期三");
		} else if (i == 4) {
			System.out.println("今天是星期四");
		} else if (i == 5) {
			System.out.println("今天是星期五");
		} else if (i == 6) {
			System.out.println("今天是星期六");
		} else if (i == 0) {
			System.out.println("今天是星期日");
		}
	}

（4）if语句的简写

判断 ? "判断结果为true时需要执行的内容":"判断结果为false时需要执行的内容"

@Test
	public void test04() {
		boolean rain = true;
		String weather = rain ? "不上课" : "上课";
		System.out.println("今天" + weather);
		System.out.println("结束");
	}

（5）switch-case语句

	@Test
	public void test08() {
		Random random = new Random();
		int i = random.nextInt(7);
		System.out.println(i);
		switch (i) {
		case 1:
			System.out.println("今天是星期一");
			break;
		case 2:
			System.out.println("今天是星期二");
			break;
		case 3:
			System.out.println("今天是星期三");
			break;
		case 4:
			System.out.println("今天是星期四");
			break;
		case 5:
			System.out.println("今天是星期五");
			break;
		case 6:
			System.out.println("今天是星期六");
			break;
		default:
			System.out.println("今天是星期日");
			break;
		}
	}

2、循环

（1）while循环

	@Test
	public void test01() {
		int i = 0;
		while (i < 10) {
			if (i % 2 == 0) {
				System.out.println(i);
			}
		}
		i++;
	}

continue为跳过但继续循环

	@Test
	public void test04() {
		int i = 0;
		while (i < 10) {
			if (i % 2 != 0) {
				i++;
				continue;
			}
			System.out.println(i++);
		}
	}

break为打断循环

	@Test
	public void test05() {
		int i = 1;
		while (i <= 5) {
			System.out.println("输出第" + i++ + "次");
			if (i == 3) {
				System.out.println("技能被打断");
				break;
			}
		}
	}

（2）for循环

	@Test
	public void test07() {
		for (int i = 0; i < 10; i++) {
			if (i == 5) {
				break;
			}
			System.out.println("第" + (i + 1) + "次");
		}
	}

（3）双层for循环

	@Test
	public void test12() {
		for (int i = 0; i < 9; i++) {
			for (int j = 0; j < i + 1; j++) {
				System.out.print((j + 1) + "*" + (i + 1) + "=" + (j + 1) * (i + 1) + "\t");
			}
			System.out.print("\n");
		}
	}

break在多层循环中可以用来打断指定循环

	@Test
	public void test10() {
		a1: for (int i = 0; i < 5; i++) {
			System.out.println("第" + (i + 1) + "次输出");
			a2: for (int j = 0; j < 5; j++) {
				if (i == 2 && j == 2) {
					System.out.println("被眩晕");
					break a1;
				}
				System.out.println("第" + (i + 1) + "次输出的第" + (j + 1) + "刀");
			}
		}
	}

七、数组

1、数组的声明、赋值与读取

相同类型的元素组成的集合称为数组

1>三种声明方法

（1）

//声明一个整数数组为a，并赋值给它三个值
int[] arr = { 10, 20, 30 };
//读取数组下标为0位置上元素的值
System.out.println(arr[0]);

（2）

//声明一个整数数组啊，并给他一个长度为6（这样声明时候必须带上长度）
int[] a = new int[6];
//给数组下标为2位置上的元素赋值
arr[2] = 20;
//读取数组下标为2位置上元素的值
System.out.println(arr[2]);

（3）

//{}中的为数组中元素的值   不是数组的长度
int[] arr = new int[] { 1, 2, 3 };
//读取数组下标为2位置上元素的值
System.out.println(arr[2]);

数组读取时，注意下标从0开始，而不是从1开始

读取的位置没有赋值时会读取到该数组数据类型的默认值

.length属性获取数组长度

2>读取

（1）利用for循环遍历数组输出

	@Test
	public void test05() {
		String[] a0 = new String[4];
		a0[0] = "北风卷地白草折";
		a0[1] = "胡天八月即飞雪";
		a0[2] = "忽如一夜春风来";
		a0[3] = "千树万树梨花开";
		for (int i = 0; i < a0.length; i++) {
			System.out.println(a0[i]);
		}
	}

（2）利用toString将数组转化成字符串输出

（3）利用for循环输出指定的元素

（4）增强for循环

	@Test
	public void test14() {
		String[] array = {"我", "爱", "你"};
		for (String string : array) {
			System.out.println(string);
		}
	}

2、数组的合并

（1）数组的简单合并

	@Test
	public void test02() {
		int[] arr0 = { 1, 3, 5, 7, 9 }; // 数组一
		int[] arr1 = { 0, 2, 4, 6, 8 }; // 数组二
		int z = arr0.length + arr1.length; // 新数组长度为两数组长度之和
		int[] arr2 = new int[z]; // 定义新数组
		for (int i = 0; i < arr0.length; i++) { // 将数组一的元素按下标赋值给新数组的同样下标
			arr2[i] = arr0[i];
		}
		for (int j = arr0.length; j < z; j++) { // 新数组的前几个下标（数组一长度）已占用，所以从后便开始
			arr2[j] = arr1[j - arr0.length]; // 新数组的后几个下标（j）等于数组二的（j-长度）下标，赋值
		}
		/**
		 * 第二遍for循环可以 
		 *	for(int j = 0;j < arr1.length;j++){ 
		 *		arr2[j + arr0.length] =arr1[j]; 
		 *	}
		 */
		System.out.println(Arrays.toString(arr2));
	}

（2）隔位组合数组

1>数组长度一致

	@Test
	public void test03() {
		int[] arr0 = { 0, 2, 4, 6, 8 };// 数组一
		int[] arr1 = { 1, 3, 5, 7, 9 };// 数组二
		int z = arr0.length + arr1.length;// 新数组长度为两数组长度之和
		int[] arr2 = new int[z];// 定义新数组
		for (int i = 0; i < arr0.length; i++) {
			arr2[2 * i] = arr0[i];
			arr2[2 * i + 1] = arr1[i];
		}
		System.out.println(Arrays.toString(arr2));
	}

3、数组排序

（1）数组排序时需要用到元素值的交互

三种交互方法

1>引入中间变量

		int a = 10 , b = 20;
		// 虽然多使用了变量但是容易理解	
		int c = a;
		a = b;
		b = c;

2>利用数学运算符

int a = 10 , b = 20;
		//借助数学公式 但不推荐 有数据失真的风险
		a = a + b;
		b = a - b;
		a = a - b;

3>利用位运算符

		int a = 10 , b = 20;
		//利用按位异或运算 虽然效率高但不好理解
		a = a ^ b;
		b = a ^ b;
		a = a ^ b;

（2）数组排序可能需要用到寻找数组最大最小值

获取最大值

	@Test
	public void test01() {
		// 需求: 获取数组中的最大值
		int[] arr = { 23, 32, 12, 21, 19, 91 };
		// 思路: 找一个和中间变量 将数组中的最后一个位置上的元素存储在该中间比哪里中 然后依次比较数组中所有元素的值
		// 获取数组中最后一个元素的值
		int max = arr[arr.length - 1];
		for (int i = 0; i < arr.length - 1; i++) {
			// 获取元素的值
			int j = arr[i];
			// 和中间变量比较 将最大值赋值给中间变量
			max = max > j ? max : j;
		}
		System.out.println("数组中最大值 >>> " + max);
	}

获取最小值

	@Test
	public void test02() {
		// 需求: 获取数组中的最小值
		int[] arr = { 23, 32, 12, 21, 19, 91 };
		// 思路: 找一个和中间变量 将数组中的最后一个位置上的元素存储在该中间比哪里中 然后依次比较数组中所有元素的值
		// 获取数组中最后一个元素的值
		int min = arr[arr.length - 1];
		for (int i = 0; i < arr.length - 1; i++) {
			// 获取元素的值
			int j = arr[i];
			// 和中间变量比较 将最小值赋值给中间变量
			min = min < j ? min : j;
		}
		System.out.println("数组中最值 >>> " + min);
	}

（3）数组的排序方法

冒泡排序、插入排序、选择排序、希尔排序、快速排序、Arrays.sort排序、归并排序、堆排序、计数排序、桶排序、基数排序等

1>Arrays.sort排序

	@Test
	public void test01() {
		int[] arr0 = { 23, 32, 12, 21, 19, 91 };
		// 调用java自带的指令排序
		System.out.println("排序前：" + Arrays.toString(arr0));
		Arrays.sort(arr0);
		System.out.println("排序后：" + Arrays.toString(arr0));
	}

2>插入排序

	@Test
	public void test02() {
		int[] arr0 = { 23, 32, 12, 21, 19, 91 };
		// 插入排序
		System.out.println("排序前：" + Arrays.toString(arr0));
		for (int i = 1; i < arr0.length; i++) {
			int a = arr0[i];
			int j;
			for (j = i; j > 0 && arr0[j - 1] > a; j--) {
				arr0[j] = arr0[j - 1];
			}
			arr0[j] = a;
		}
		System.out.println("排序后：" + Arrays.toString(arr0));
	}

3>冒泡排序

	@Test
	public void test03() {
		int[] arr0 = { 23, 32, 12, 21, 19, 91 };
		// 冒泡排序
		System.out.println("排序前：" + Arrays.toString(arr0));
		for (int i = 0; i < arr0.length - 1 ; i++) {
			for (int j = 1; j < arr0.length - i; j++) {
				if (arr0[j - 1] > arr0[j]) {
					int a = arr0[j];
					arr0[j] = arr0[j - 1];
					arr0[j - 1] = a;
				}
			}
		}
		System.out.println("排序后：" + Arrays.toString(arr0));
	}

4、数组的一些工具类

（1）Copyof拷贝数组

copyOf（原数组，新数组长度） = 数组的拷贝

生成新数组，按下标对应，多的丢掉少的默认值

	@Test
	public void test01() {
		// copyOf(原数组,新数组长度)  = 数组的拷贝
		String[] arr0 = {"我", "爱", "你"};
        System.out.println(Arrays.toString(arr0));
        String[] arr1 = Arrays.copyOf(arr0, 5);
        System.out.println(Arrays.toString(arr1));     
        String[] arr2 = Arrays.copyOf(arr0, 2);
        System.out.println(Arrays.toString(arr2));
	}

（2）数组的插入覆盖

将数组0的1下标开始截取，从2下标替换数组1，截取三个长度

不生成新数组

注意截取数组0长度时不能溢出，存的时候也不能溢出

	@Test
	public void test02() {
		int[] arr0 = {0, 1, 2, 3, 4};
        int[] arr1 = {5, 6, 7, 8, 9};
        System.arraycopy(arr0, 1, arr1, 2, 3);
        System.out.println(Arrays.toString(arr1));
	}

八、类和方法

1、方法的概念

方法，就是一段可以被重复利用的代码的封装方法定义五要素：修饰词，返回值类型，方法名，参数列表，方法体。

public static void fun() {
		// public static修饰词 void返回值类型 fun方法名 ()内为参数 {}方法体
	};

2、main方法

优先运行main方法是程序的入口

没有main方法就没有程序入口，就没有Java appliction

public class Demo01 {

	public static void main(String[] args) {
		// 优先运行main方法 是程序的入口
		// 无参方法的调用
		fun01();
		// 有参数方法的调用，方法需要一个参数的值，需要按照该方法参数的数据类型给其一个真实有效的值
		// 有一种特殊的实参，为引用类型
		// 实参的数据类型必须与形参的数据类型一直或者是形参的子类型
		fun02("橘子");
		// 按照参数位置进行传值
		fun03(1,"西瓜");
		//代码将两个整数相加 将相加结果返回 关键字return,将方法执行结果返回 方法的返回值类型与return后的数据类型有关
		long num = fun04(10, 15);
		System.out.println(num);
	}

	public static void fun() {
		// public static修饰词 void返回值类型 fun方法名 ()内为参数 {}方法体
	};

	/**
	 * 没有参数没有返回值
	 */
	public static void fun01() {
		System.out.println("北风卷地白草折");
	};

	/**
	 * 形式参数，定义方法的时候该参数只有一个形式，没有实际值，简称形参
	 * 
	 * @param food
	 */
	public static void fun02(String food) {
		System.out.println("吃" + food);
	}

	/**
	 * 吃了若干个xx食物
	 * 
	 * @param count 吃的食品数量
	 * @param food  吃的食品名称
	 */
	public static void fun03(int count, String food) {
		System.out.println("吃了" + count + "个" + food);
	};

	public static long fun04(int a, int b) {
		/**
		 * 代码将两个整数相加 将相加结果返回 关键字return,将方法执行结果返回 方法的返回值类型与return后的数据类型有关
		 */
		return a + b;
	};
}

3、方法重载

在同一个类中方法参数列表不同的同名方法这种表现形式我们成为方法重载

参数列表：参数的数量参数的数据类型

数据类型不同指的是同一参数位置的参数数据类型不同

public class Demo02 {
	public static void eat() {
		System.out.println("吃");
	}
	//与上一个方法名相同，但是参数数量不同
	public static void eat(String food) {
		System.out.println("吃" + food);
	}
	//与上一个方法名相同，但是参数数量不同
	public static void eat(int count,String food) {
		System.out.println("吃" +count + "个" + food);
	}
	//与上一个方法名相同，参数数量也相同，但是参数数据类型不同
	public static void eat(String food,int count) {
		System.out.println("吃" +count + "个" + food);
	}
}

4、变量的作用域

一个方法中无法读取另一个方法中声明的变量
声明在方法中的变量称为局部变量，仅在局部有效
声明在类中的变量称之为成员变量
当读取的变量在局部代码中没有被声明,则去找成员变量
当读取的变量在局部代码中已经被声明之后，则根据就近原则读取局部变量，不需要去找成员变量
Static修饰的成员变量（静态成员变量）是可以被该类的所有方法共享的
static修饰变量时只能修饰成员变量不能修饰局部变量
static修饰的方法称之为静态方法，静态方法只能访问静态成员变量
static修饰的方法称之为静态方法，反之称之为非静态方法或普通方法，也就是平时说的方法一般指的是非静态方法

public class Demo03 {
	static int a = 30;
	int b = 40;
	public static void main(String[] args) {
		//fun01();
		//fun02();
		//fun03();
		//fun04();
		fun05();
		fun06();
	}
	public static void fun01() {
		int x = 10;
		int y = 20;
		System.out.println("方法fun01 变量 x >>>" + x);
		System.out.println("方法fun01 变量 y >>>" + y);
	}
	public static void fun02() {
		int x= 20;
		System.out.println("方法fun01 变量 x >>>" + x);
		//一个方法中无法读取另一个方法中声明的变量
		//System.out.println("读取方法fun01 变量 y >>>" + y);
	}
	public static void fun03() {
		//当读取的变量在局部代码中没有被声明,则去找成员变量
		System.out.println(a);
	}
	public static void fun04() {
		//当读取的变量在局部代码中已经被声明之后，则根据就近原则读取局部变量，不需要去找成员变量
		int a =20;
		System.out.println(a);
	}
	public static void fun05() {
		a += 10;
		System.out.println("fun05执行后a=" + a);
	}
	public static void fun06() {
		a += 20;
		System.out.println("fun06执行后a=" + a);
	}
	public static void fun07() {
		System.out.println("静态成员变量a=" + a);
		//静态方法之只能访问静态成员变量
		//System.out.println("非静态成员变量b=" + b);
	}
	public void fun08() {
		//非静态方法既能访问静态成员变量也能访问非静态成员变量
		System.out.println("静态成员变量a=" + a);
		System.out.println("非静态成员变量b=" + b);
	}
}

5、方法的封装与调用

首先需要编写好一个方法，如之前的随机姓名生成，并给他一个返回值

public class ChineseNameGenerator {
	public static  String  generate(){
	return generateName;
	}
}

然后在新的类中打入随机姓名生成方法的类名.方法，进行导包便可使用

public class ChineseNameGeneratorTest {
	@Test
	public void generate() {
		for (int i = 0; i < 10; i++) {
			String name = ChineseNameGenerator.generate();
			System.out.println(name);
		}
	}
}