java基础

最新推荐文章于 2025-06-03 09:20:46 发布

原创最新推荐文章于 2025-06-03 09:20:46 发布 · 290 阅读

0 ·

CC 4.0 BY-SA版权

java基础专栏收录该内容

1 篇文章

订阅专栏

本文详细介绍Java编程的基础知识，包括计算机基础概念、Java环境搭建、数据类型与运算符、控制结构、数组与方法等内容，深入浅出地讲解面向对象编程的封装、继承和多态特性。

第一章计算机基础

位(bit):一个数字0或者一个数字1，代表一位
字节(Byte):每逢8位是一个字节，这是数据存储的最小单位
命令指示符
- windows盘符切换c：/C：
- cd ** 加tab键自动补全
- cd 文件夹名称
- cd 文件夹1\文件夹2\文件夹3
- 直接回根路径cd \
- 查看当前内容dir
- 清屏cls
- 退出exit

第二章 Java语言开发语言环境搭建

JVM(Java Virtual Machine):java虚拟机，是运行所有java程序的假想计算机，是java程序的运行环境
跨平台：任何软件的运行，都必须要运行在操作系统之上，我们用java编写的软件可以运行在任何的操作系统上，这个特性称为java语言的跨平台特性，该特性是有JVM实现的，编写的程序是运行在JVM上，而JVM运行在操作系统上
JRE(Java Runtime Environment):是java程序的运行是环境，包含JVM和运行所需要的的核心类库
JDK(Java Development Kit):是Java程序开发工具包，包含JRE和开发人员使用的工具

第三章入门程序

程序开发步骤说明
java程序开发三步骤：编写、编译、运行
编写java源程序
javac xxx.java生成xxx.class
java xxx 执行java程序

// 第一行的第三个单词必须和所在的文件名称完全一样，大小写也要一样
// public class后面代表定义一个类的名称，类是java当中所有源代码的基本组织单位
public class HelloWorld {
	// 第二行的内容是万年不变的固定写法，代表main方法
	// 这一行代表程序执行的起点
	public static void main(String[] args){
		// 第三行代表打印输出语句（其实就是屏幕显示）
		// 希望显示什么东西，就在小括当中填写什么内容
		System.out.println("Hello,World!!");
	}
}

关键字的特点：
- 完全小写的字母
- 在增强版的记事本当中有特殊的颜色
标识符：是指在程序中，我们自己定义的内容，比如类的名字、方法的名字和变量的名字等等，都是标识符
- HelloWorld案例中，出现的标识符有类名字HelloWorld
命名规则：硬性要求
- 标识符可以包含字母、数字、$、和下划线_
- 标识符不能以数字开头
- 标识符不能是关键字
命名规范：软性建议
- 类名规范：首字母大小，后面每个单词首字母大写
- 变量名规范：首字母小写，后面每个单词首字母大写（小驼峰式）
- 方法名规范：同变量名

第四章常量

常量：是指在java程序运行期间固定不变的数据
常量的分类：
- 字符串常量：凡是用双引号引起来的部分，叫做字符串常量，例如：“abc”,“123”
- 整数常量：直接写上的数字
- 浮点数常量：直接写上的数字，有小数点
- 字符常量：凡是用单引号引起来的单个字符，就叫做字符常量，例如：‘a’,‘9’,‘中’
- 布尔常量：只有两种取值，true、false
- 空常量：null，代表没有任何数据

public class Demo01Const{
	public static void main(String[] args){
		//字符串常量
		System.out.println("ABC");
		System.out.println("");//字符串两个双引号中间的内容为空
		System.out.println("XYZ");
		//整数常量
		System.out.println(30);
		//浮点数常量
		System.out.println(3.14)
		//字符常量
		System.out.println('a');
		System.out.println('6');
		// System.out.println('');//两单引号中间必须有且仅有一个字符，没有不行
		//布尔常量
		System.out.println(true);
		System.out.println(false);
		//空常量 空常量不能直接用来打印输出
		// 错误写法 System.out.println(null)
	}
}

基本数据类型
- 整数型 byte short int long
- 浮点型 float doule
- 字符型 char
- 布尔型 boolean
引用数据类型
- 字符串
- 数组
- 类
- 接口
- Lambda
注意事项：

字符串不是基本类型，而是引用类型
浮点型可能只是一个近视值，并非精确的值
数据范围与字节数不一定相关
浮点数当中默认类型是double，如果一定要使用float类型，需要加上一个后缀F，如果是整数，默认是int类型，如果一定要使用long类型，需要加上后缀L，推荐使用大写字母后缀

变量：程序运行期间，内容可以发生改变的量

public class Demo02Variable {
	public static void main(String[] args){
		//创建一个变量
		//格式：数据类型 变量名称；
		int num1;
		//向变量当中存入一个数据
		//格式：变量名称 = 数据值
		num1 = 10;
		System.out.println(num1);//10
		//改变变量当中本来的数字，变成新的数字
		num1 = 20;
		System.out.println(num1);//20
		
		//使用一步到位的格式来定义变量
		//格式：数据类型 变量名称 = 数据值；
		int num2 = 25;
		System.out.println(num2);//20
		System.out.println("=======");
		byte num3 = 30;//注意：右侧数值的范围不能超过左侧数据类型的取值范围
		System.out.println(num3);//30
		//byte num4 = 400; //右侧超出了byte数据范围，错误；
		short num5 = 50;
		System.out.println(num5);//50
		float num7 = 2.5F;
		System.out.println(num7);//2.5
		char zifu = 'A';
		System.out.println(zifu);//A
		zifu = '中';
		System.out.println(zifu);//中
		boolean var1 = true;
		System.out.println(var1);//true
		//将一个变量的数据内容，赋值交给另一个变量
		//右侧的变量名称var赋值给var2进行存储
		boolean var2 = var1;
		System.out.println(var2);//false
		
	}
}

数据类型转换

自动类型转换

/*
当数据类型不一样时，将会发生数据类型转换
自动类型转换（隐式）
1.特点：代码不需要进行特殊处理，自动完成
2.规则：数据范围从小到大
强制类型转换（显式）
*/

public class Demo01DataType{
	public static void main(String[] args){
		System.out.println(1024);//这就是一个整数（byte，int，short，long），默认就是int类型
		System.out.println(3.14);//这就是一个浮点数，默认就是double类型
		//左边是long类型，右边是默认的int类型,左右不一样
		//一个等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储	
		//int-->long，符合了数据范围从小到大的要求
		//这一行代码发生了自动类型转换
		long num1 = 100;
		System.out.println(num1);//100
		//左边是double类型，右边是float类型，左右不一样
		//float-->double,符合从小到大的规则
		//也发生了自动类型转换
		double num2 = 2.5F;
		System.out.println(num2);//2.5
		//左边是float类型，右边long类型，左右不一样
		//long-->float,范围是float更大一些，符合从小到大原则
		//也发生了自动类型转换
		float num3 = 30L;
		System.out.println(num3);//30.0
	}
}

强制类型转换

/*
强制类型转换：1.特点：代码需要进行特殊的格式处理，不能自动完成
2.格式：范围小的类型 范围小的变量 = （范围小的类型）原本范围大的数据；
注意事项：1.强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出
2.byte/short/char这三种类型都可以发生数学运算
3.byte/short/char这三种类型在运算的时候，都会被首先提升为Int类型，然后再进行计算
4.boolean类型不能发生数据类型转换
*/


public class Demo02DataType{
	public static void main(String[] args){
		//左边是int类型，右边是long类型，不一样
		//long-->int,不是从小到大，不能发生自动类型转换
		//格式：范围小的类型 范围小的变量 = （范围小的类型）原本范围大的数据；
		int num = (int)100L;
		System.out.println(num);
		//long强制转换成为int类型
		int num2 = (int)6000000000L;
		System.out.println(num2);
		//double-->int 强制类型转换
		int num3 = (int)3.5;
		System.out.println(num3);//3,这并不是四舍五入，所有的小数位都会被舍弃掉
		
		char zifu = 'A';//这是一个字符型变量，里面是大写字母A
		System.out.println(zifu + 1);//66,也就是大写字母A被当成65进行处理	
		
		byte num4 = 40;//注意：右侧的数值大小不能超过左侧的类型范围
		byte num5 = 50;
		//byte + byte -->int + int --> int
		int result = num4 + num5;
		System.out.println(result);//90
		
		short num6 = 60;
		//byte + short --> int+int-->int
		//int强制转换成short:注意必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
		short result1 = (short) (num4 + num6);
		System.out.println(result1);
	}
}

ASCII码


/*
ASCII码表：American Standard Code for Information Interchange,美国信息交换标准代码
Unicode码表：万国码，也是数字和符号的对照关系，开头0-127部分和ASCII完全一样，但是从128开始包含更多的字符
48 - ’0‘
65 - ’A‘
97 - ’a‘
*/
public class Demo03DataTypeChar{
	public static void main(String[] args){
		char zifu1 = '1';
		System.out.println(zifu1 + 0);//49
		char zifu2 = 'A';//其实底层保存的是65数字
		char zifu3 = 'c';
		//左侧是int类型，右边是char类型
		//char-->int，确实是从小到大
		//发生了数据类型转化
		int num = zifu3;
		System.out.println(num);//99
		char zifu4 = '中';//正确写法
		System.out.println(zifu4 + 0);//20013
	}
}

算术运算符
进行特定操作的符号，例如：+
表达式：用运算符连起来的式子叫做表达式，例如：20+5，又例如：a+b
四则运算：
- 加
- 减
- 乘
- 除
- 取模


/*
首先计带到表达式的结果，然后再打印输出这个结果
对于一个整数的表达式来，除法用的是整除，整除除以整数，结果仍然是整数，只看商 不看余数
取模（取余数）:%
注意事项：1.一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种

*/
public class Demo04perator{
	public static void main(String[] args){
		System.out.println(20+30);
		//两变量之间也可以进行数学运算
		int a = 20;
		int b = 30;
		System.out.println(a - b);//-10
		//变量和常量之间可以混合运算
		System.out.println(a * 10);//200
		
		int x = 10;
		int y = 3;
		int result1 = x / y;
		System.out.println(result1);//3
		int result2 = x % y;
		System.out.println(result2);//余数，模，1
		//int + double --> double + double -->double
		double result3 = x + 2.5;
		System.out.println(result3);//12.5
	}
}

注意事项

/*
四则运算当中的加号“+”有常见的三种用法
1.对于数值来，那就是加法
2.对于字符char类型来，在计算之前，char会被提升成int类型，然后再计算
char类型字符，和int类型数字，之间的对照关系表，ASCII、Unicode
3.对于字符串String（首字母大写，并不是关键字）来，如加号代表字符串连操作
任何数据类型和字符串进行连的时候，都会变成字符串
*/

public class Demo05Plus{
	public static void main(String[] args){
		//字符串类型的变量基本使用;
		//数据类型 变量名称 = 数据值；
		String str1 = "Hello";
		System.out.println(str1);//Hello
		System.out.println("Hello" + "World");//HelloWorld
		//String + int -->
		String str2 = "java";
		System.out.println(str2 + 20);//java20
		//优先级问题
		System.out.println(str2 + 20 + 30);//java2030
		System.out.println(str2 + (20 + 30));//java50
	}
}

自增自减运算符
自增运算符：++
自减运算符：–
含义：让一个变量涨一个数字1，或者让一个变量降一个数字1

/*使用格式：写在变量之前，或者写在变量之后，例num++，num--,--num,++num
使用方式：
1.单独使用：不和其他任何操作混合，自己独立成为一个步骤
2.混合使用：和其他操作混合，例与赋值混合，或者与打印操作混合等
使用区别：
1.在单独使用的时候，前++和后++没有任何区别
2.在混合使用的时候，有重大区别
	a.如果是前++，那么变量立+1，然后拿着结果进行使用    【先加后用】
	b.如果是后++，那么首先使用变量本来的数值，然后再让变量+1 【先用后加】
注意事项：
只有变量才能使用自增、自减运算符，常量不可以发生改变，所以不能用
*/
public class Demo06Operator{
	public static void main(String[] args){
		int num1 = 10;
		System.out.println(num1);//10
		++num1;//单独使用 前++
		System.out.println(num1);//11
		num1++;//单独使用，后++
		System.out.println(num1);//12
		//与打印操作混合使用
		int num2 = 20;
		System.out.println(++num2);//混合使用，先++,变量立马上变成21，然后打印结果21
		System.out.println(num2);//21
		//混合使用：后++，首先使用变量本来30，然后再让变量+1得到31
		int num3 = 30;
		System.out.println(num3++);
		System.out.println(num3);
	}
}

赋值运算符
- +=
- -=
- *=
- /=
- %=
比较运算符
- ==、<、>、<=、>=、！=
- 比较运算符，是两个数据之间进行比较的运算，运算结果都是布尔值true或者false

/*
注意事项：
1.比较运算符的结果一定是boolean值，成立就是true，不成立就是false
2.如果进行多次判断，不能连写 数学当中的写法 例1<x<3 程序当中不允许这种写法
*/

public class Demo08OPerator{
	public static void main(String[] args){
		System.out.println(10 > 5);//true
		int num1 = 10;
		int num2 = 20;
		
		System.out.println(num1 <= num2);//true
	}
}

逻辑运算符
- 与 && 全都是true，才是true，否则就是false
- 或 || 至少一个是true，就是true，全都是false，才是false
- 非 ~ 本来是true，变成false，本来是false，变成true

注意事项：
1.逻辑运算符只能用于boolean值
2.与、或需要左右各有一个boolean值，但是取反只要唯一的一个boolean值即可
3.与、或两运算符，如果有多个条件，可以连
两个条件：条件a && 条件b
多个条件：条件a && 条件b && 条件c


public class Demo09Logic{
	public static void main(String[] args){
		System.out.println(true && false);//false
		System.out.println(true && true);//true
		
		System.out.println(true || false);//false
		System.out.println(true || true);//true
		
		System.out.println(!false);//true
		System.out.println(false);//false
	}
}

三元运算符

/*
一元运算符：只需要一个数据就可以进行操作的运算符，例如：取反、自增++、自减--
二元运算符：需要两数据才可以进行操作的运算符，例如：加法+，赋值
三元运算符：需要三个数据才可以进行操作的运算符
格式：数据类型 变量名称 = 条件判断 ？ 表达式a：表达式b;
流程：首先判断条件是否成立：
如果成立为true，那么将表达式a的值赋值给左侧的变量；
如果不成立为false，那么将表达式b的值赋值给左侧的变量；
二者选其一
注意事项：
1.必须同时保证表达式a和b都符合左侧数据类型要求
2.三元运算符的结果必须被使用
*/
public class Demo10Operator{
	public static void main(String[] args){
		int a = 10;
		int b = 20;
		//判断a>b是否成立，如果成立将a的值赋值给max，否则b赋值给max
		int max = a > b ? a : b;//最大值的变量
		System.out.println("最大值："+max);//20
	}
}

第四章判断语句

选择结构

单if语句

public class Demo02If{
	public static void main(String[] args){
		
		
		System.out.println("今天天气不错，正在压马路...突然发现一个快乐的地方：网吧");
		int age = 20;
		if(age >= 18){
			System.out.println("进入网吧，开始high!");
			System.out.println("妈妈让回家吃饭");
			System.out.println("结账走人");
		}
		System.out.println("继续玩");
		
	}
}

标准if-else语句

if(关系表达式){
    语句体1：
}else{
    语句体2：
}

// 标准的if-else语句
public class Demo03Ifelse{
	public static void main(String[] args){
		int num = 7;
		if (num%2==0){//如果除以2能够余数为0，说明是偶数
			System.out.println("偶数");
		}else{
			System.out.println("奇数");
		}
	}
}

if语句的第三种格式 if…else if…else

if(判断条件1){
    执行语句1；
}else if(判断语句2){
    执行语句2;
}...

//x和y的关系满足如下
//如果x >= 3, 那么y = 2x + 1;
//如果-1 <x < 3, 那么y = 2x;
//如果x <= -1, 那么y = 2x - 1;
public class Demo04IfElseExt{
	public static void main(String[] args){
		int x = 10;
		int y;
		if (x >= 3){
			y = 2*x + 1;
		}else if (-1 < x && x < 3){
			y = 2 * x + 1;
		}else{
			y = 2 * x - 1;
		}
		System.out.println(y);
	}
}

用if语句替换三元运算符

//题目：使用三元运算符和标准的if-else语句分别实现：取两数字当中的最大值
public class Demo06Max{
	public static void main(String[] args){
		int a = 10;
		int b = 20;
		//首先使用三元运算符
		//int max = a > b ? a:b;
		//System.out.println("最大值:"+ max);
		int max;
		if (a > b) {
			max = a;
		} else {
			max = b;
		}
		System.out.println("最大值:"+ max);
	}
}

选择语句 --swich
swich语句格式

swich(表达式){
    case常量值1:
    语句体1；
    break；
    case常量值2:
    语句体2；
    break；
}

执行流程
- 首先计算出表达式的值
- 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束
- 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后流程结束掉

public class Demo07Swich{
	public static void main(String[] args){
		int num = 10;
		switch (num) {
			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;
			case 7:
				System.out.println("星期日");
				break;
			default:
				System.out.println("数据不合理");
				break;//最后一个break语句可以省略，但是强烈建议不要省略
		}
	}
}

switch注意事项

多个case后面的数值不可以重复
switch后面小括当中只能是下列数据类型基本数据类型：byte/short/char/int
引用数据类型:String字符串、enum枚举
switch语句格式可以很灵活，前后顺序可以颠倒，而且break语句还可以忽略
匹配哪一个case就从哪个位置向下执行，直到遇到break或者整体结束为止

第四章循环语句

循环语句可以满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成四循环
for循环语句

for(初始化表达式1；布尔表达式2；布进表达式4){
    循环体3
}

执行流程
- 执行顺序：1234》234》234…2不满足为止
- 1负责完后循环变量初始化
- 2负责判断是否满足循环条件，不满足则跳出循环
- 3具体执行的语句
- 4循环后，循环条件所涉及变量的变化情况

public class Demo09For {
	public static void main(String[] args) {
		for (int i = 1; i <=100; i++) {
			System.out.println("我错啦" + i);
		}
		System.out.println("程序停止");
	}
}

while循环

/*
while循环有一个标准格式，还有一个扩格式

标准格式:
while (条件判断) {
	循环体
}
扩格式:
初始化语句:
while (条件判断) {
	循环体
	步进语句;
}

*/
public class Demo10While {
	public static void main(String[] args) {
		int i = 1;//1 初始化语句
		while (i <= 10) {
			System.out.println("我错啦" + i);//循环体
			i++;//步进语句
		}
		
	}
}

do…while循环

/*
do-while循环的标准格式
do {
	循环体
}while (条件判断);

扩格式：
初始化语句
do {
	循环体
	步进表达式
}while(布尔表达式)；

先执行一次再执行
*/
public class Demo11Dowhile {
	public static void main(String[] args) {
		int i = 1; //1
		do {
			System.out.println("原谅你啦" + i);
			i++;
		}while (i <= 10);
	}
}

求1到100的偶数和

/*
求出1-100的偶数和
*/
public class Demo12 {
	public static void main(String[] args) {
		int sum = 0;//用来累加的存钱罐
		for (int i = 1; i <= 100; i++) {
			if (i % 2 == 0) {
				sum += i;
			}
		}
		System.out.println("结果是:" + sum);
	}
}

三种循环的区别

如果条件判断从来没有满足过，那么for循环将会执行0次，但是do-while循环会执行至少一次
for循环的变量在小括内定义，只有循环内部才可以使用,while循环和do_while循环初始化语句本来就在外边，所以出来循环外边也可以使用

break关键字的用法有常见的两种：

可以用在switch语句当中，一旦执行，整个switch语句立刻结束
还可以用在循环语句当中，一旦执行，整个循环语句立刻结束，打断循环

注意：凡是次数确定的场景多用for.循环，否则多用while循环

public class Demo14Break {
	public static void main(String[] args) {
		for (int i = 1; i <= 10; i++) {
			if (i == 4) {
				break;
			}
			System.out.println("Hello" + i);
		}
	}
}

循环控制语句 continue：一旦执行，立刻跳出当前次循环剩余内容，马上开始下一次循环

public class Demo15Continue {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i == 4) {
                continue;
            }
            System.out.println(i + "层到了")
        }
    }
}

开发工具intellij IDEA
IDEA常用快捷键

快捷键	功能
Alt+Enter	导入包，自动修正代码
ctrl+Y	删除光标所在行
ctrl+D	复制光标所在行的内容，插入光标位置下面
ctrl+Alt+L	格式化代码
ctrl+/	单行注释，再取消注释
ctrl+shift+/	选中代码注释，多行注释，再取消注释
Alt+Insert	自动生成代码，toString,get,set等方法
Alt+Shift+上下箭头	移动当前代码行

第五章方法

方法的定义和调用

/*五行20个矩形
定义格式：
public static void 方法名称() {
    方法体
}
调用格式:
方法名称();

注意事项:
1.方法定义的先后顺序无所谓
2.方法定义必须是挨着的，不能在一个方法的内部定义另外一个方法
3. 方法定义之后，自己不会执行，如果希望执行，一定要进行方法的调用

*/
package cn.day01.demo02;

import java.sql.SQLOutput;

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

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

方法的定义格式

package cn.day01.demo02;
/*方法其实就是若干语句的功能集合
定义方法的完整格式：
返回值(产出的):就是从方法中出来的数据
定义方法的完整格式:
修饰符 返回值类型 方法名称（参数类型 参数名称，...） {
    方法体
    return 返回值;
}
修饰符，现阶段的固定写法 public static
返回值类型，也就是方法最终产生的数据结果是什么类型
方法名称:方法的名字，规则和变量一样，小驼峰
参数类型:进入方法的数据是什么类型
参数名称：进入方法的数据对应的变量名称
ps:参数如果有多个，使用逗号进行分割
方法体:方法需要做的事情，若干行代码
return:两个作用，第一停止当前方法，第二将后面的结果数据返回值还给调用处
返回值：也就是方法执行后最终产生的数据结果
注意：return后面的返回值必须和方法前面的返回值类型，保持对应

定义一个两个int数字相加的方法
三要素：
返回值类型：int
方法名称:sum
参数列表:int a; int b;

方法的三种调用格式:
1.单独调用：方法名称
2.打印调用:System.out.println(方法名称(参数))
3.赋值调用:数据类型 变量名称 = 方法名称(参数);
注意：此前学习的方法，返回值类型固定写为void，这个方法只能够单独调用，不能进行打印调用和赋值调用
* */
public class Demo02MethodDefine {
    public static void main(String[] args) {
        //单独调用
        sum(10, 20);
        //打印调用
        System.out.println(sum(10,20));

        //赋值调用
        int number = sum(15, 25);
        System.out.println("变量的值：" + number);
    }
    public static int sum(int a, int b) {
        int result = a + b;
        return result;
    }

有参数无参数方法

package cn.day01.demo02;
/*
有参数：小括号当中有内容，当一个方法需要一些数据条件，才能完成任务，就是有参数
例如两个数字相加，必须知道两个数字各自是多少
无参数：小括号当中留空，一个方法不需要任何数据条件，自己就能独立完成条件，就是元参数
例如定义一个方法，打印固定10次HelloWorld
*/

import java.sql.SQLOutput;

public class Demo03MethodParam {
    public static void main(String[] args) {
        method(10,20);
        method2();
    }
    //两个数字相乘
    //有参数
    public static void method(int a, int b) {
        int result = a + b;
        System.out.println("结果是:" + result);

    }
    //打印输出固定10次字符串
    public static void method2() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello,World!" + i);
        }
    }

}

package cn.day01.demo02;
/*
题目要求：定义一个方法，用来求出两个数字之和
题目变形：定义一个方法，用来打印两个数字之和
注意事项:
对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用
但是对于无返回值方法，只能使用单独调用，不能使用打印调用或者赋值调用
*/

public class Demo04MethodReturn {
    public static void main(String[] args) {
        //main方法，负责调用
        int num = getSum(10,20);
        System.out.println("返回值是：" + num);
        System.out.println("=====");
        printSum(100,200);
        System.out.println(getSum(2,3));//打印调用
        getSum(3,5);//单独调用
        //d对于void没有返回值的方法，。只能单独调用，不能打打印或者赋值调用
    }
    public static int getSum(int a, int b) {
        int result = a + b;
        return result;
    }
    public static void printSum(int a, int b) {
        int result = a + b;
        System.out.println("结果是:" + result);
    }
}

方法练习1

package cn.day01.demo02;
/*
题目要求：
定义一个方法:用来判断两个数字是否相同
三要素:
返回值类型:boolean
方法名称：isSame
参数列表:int a, int b
*/
public class Demo01MethodSame {
    public static void main(String[] args) {
        System.out.println(isSame(10,20));
    }
    public static boolean isSame(int a, int b) {
        // 4
//        boolean same;
      /*  if (a == b) {
            same = true;
        } else {
            same = false;
        }*/
        // 1 
//      boolean same = a == b ? true : false;
        // 2 
//        boolean same = a == b;
//        return same;
        // 3
        return a == b;
    }
}

方法练习2

package cn.day01.demo02;
/*
题目要求：
定义一个方法，用来求出1到100之间所有的数字和值
*/

public class Demo02MethodSum {
    public static void main(String[] args) {
        //打印调用
        System.out.println("结果是:" + getSum());
    }
    /*
    三要素
    返回值:有返回值，计算结果是int
    方法名称:getSum
    参数列表：数据范围已经确定，所以不需要参数
    */
    public static int getSum() {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += 1;
        }
        return sum;
    }
}

方法练习3

package cn.day01.demo02;
/*
题目要求:
定义一个方法，用来打印指定次数的Helloworld
*/
public class Demo03MethodPrint {
    public static void main(String[] args) {
        printCount(5);
    }
    /*
    三要素
    返回值类型，只是进行一大堆打印操作，没有计算，，也没有结果要dayin
    方法名称：printCount
    参数列表:到底要打印多少次，次数:int
    */
    public static void printCount(int num) {
        for (int i = 0; i < num; i++) {
            System.out.println("Hello,World!" + (i + 1));
        }
    }
}

使用方法的时候，注意事项

方法应该定义在类当中，但是不能再方法中再定义方法，不能嵌套
方法定义的前后顺序无所谓
方法定义之后不会执行，如果希望执行，一定要调用，单独调用、打印调用、赋值调用
如果方法有返回值，那么必须写上return返回值，不能没有
return后面的返回值数据，必须和方法的返回值类型，对应起来
对于一个void没有返回值的方法，不能写return后面的返回值，只能写returnz自己
对应方法当中最后一行的return可以省略不写
一个方法当中可以有多个return语句，但是必须保证同时只有一个被执行到，两个return不能连写

package cn.day01.demo02;

public class Demo04MethodNotice {
    public static int Method() {
        return 10;
    }
    public static void method2() {
//        return 10;错误的写法，方法没有返回值，return后面就不能写返回值
        return;//没有返回值，只是结束方法的执行而已
    }
    public static void method3() {
        System.out.println("AAA");
        return;//最后一行的return可以省略不写，有返回值必须要写
    }
    public static int getMax(int a, int b) {
        int max;
        if (a > b) {
            max = a;
        } else {
            max = b;
        }
        return max;
    }
}

方法重载：方法的重载（Overload）,多个方法的名称一样，但是参数不一样
好处:只需要记住唯一一个方法名称，就可以实现类型的多个功能
方法重载与下列因素相关

参数个数不同
参数类型不同
参数的多类型顺序不同

方法重载与下列因素无关

与参数的名称无关
与方法的返回值类型无关

package cn.day01.demo02;

public class Demo05MethodOverload {
    public static void main(String[] args) {
        System.out.println(sum(10,20));//两个参数的方法
        System.out.println(sum(10,20, 30));//三参数的方法
    }
    public static int sum(int a, int b) {
        return a + b;
    }
    public static int sum(int a, int b, int c) {
        return a + b + c;
    }
}

重载方法练习

//比较两个数值大小
package cn.day01.demo02;

public class Demo02MethodOverloadSame {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        System.out.println(isSame(a, b));
        System.out.println(isSame((short) a, (short) b));
        System.out.println(isSame(11,20));
        System.out.println(isSame(10L, 20L));
        
    }
    public static boolean isSame(byte a, byte b) {
        System.out.println("两个byte参数的方法执行");
        boolean same;
        if (a == b) {
            same = true;
        } else {
            same = false;
        }
        return same;
    }
    public static boolean isSame(short a, short b) {
        System.out.println("两个short参数的方法执行");
        boolean same = a == b ? true:false;
        return same;
    }
    public static boolean isSame(int a, int b) {
        System.out.println("两个int参数的方法执行");
        return a == b;
    }
    public static boolean isSame(long a, long b) {
        System.out.println("两个long参数的方法执行");
        if (a == b) {
            return true;
        } else {
            return false;
        }
    }
}

在调用输出语句的时候，println方法其实就是进行了多种数据类型的重载形式

package cn.day01.demo02;

public class Demo04OverloadPrint {
    public static void main(String[] args) {
        myPrint(100);
        myPrint(100);
    }
    public static void myPrint(byte num) {
        System.out.println(num);
    }
    public static void myPrint(short num) {
        System.out.println(num);
    }
    public static void myPrint(int num) {
        System.out.println(num);
    }public static void myPrint(long num) {
        System.out.println(num);
    }public static void myPrint(float num) {
        System.out.println(num);
    }public static void myPrint(double num) {
        System.out.println(num);
    }
    public static void myPrint(boolean is) {
        System.out.println(is);
    }
    public static void myPrint(String num) {
        System.out.println(num);
    }
}

第五章数组的概念
数组:数组是一种容器，可以同时存放多个数据值
特点：
- 数组是一种引用数据类型
- 数组当中的多个数据，类型必须统一
- 数组的长度在程序运行期间不可改变
数组的初始化方式：

动态初始化(指定长度)
- 在创建数组的时候，直接指定数据当中的数据元素个数
- 动态初始化数组的格式：
- 数据类型[] 数据名称 = new 数据类型[数据长度];
- 左侧数据类型:也就是数组当中保存的数据，全都是统一的数据类型
- 左侧的括号，代表我是一个数组
- 左侧数据名称，给数组取一个名字
- 右侧数据类型，必须和左侧数据类型保持一致
- 右侧中括号的长度，也就是数组中，到底可以保存多少个数据，是一个int数字
静态初始化(指定内容)
- 在创建数组的时候，不直接指定数据个数的多少，而是直接将具体的数据内容进行指定

静态初始化基本格式
- 数据类型[] 数组名称 = new 数据类型 [] {元素1，元素2，…}
注意事项：虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出长度
静态初始化标准格式可以拆分成两个步骤
使用建议：如果不确定数据当中的具体内容，使用动态初始化，否则，用静态初始化

//动态初始化数组
public class Demo01Array {
    public static void main(String[] args) {
        int[] arrayA = new int[300];
        double[] arrayB = new double[10];
        String[] arrayC = new String[5];
    }
}
//静态初始化
public class Demo01Array {
    public static void main(String[] args) {
        int[] arrayA = new int[] {5, 15, 25};
        String[] arrayB = new String[] {"Hello", "World", "Java"}
    }
}
//静态初始化省略格式
public class Demo01Array {
    public static void main(String[] args) {
        int[] arrayA;
        int[] arrayA = new int[] {10, 20, 30}
        String[] arrayB = {"Hello", "World", "Java"}
    }
}

数据元素获取
直接打印数组名称，得到的是数组对应的：内存地址哈希值
访问数组元素的格式：数组的名称[索引值]
索引值:就是一个int数字，代表数组当中元素的编号
索引值从0开始，一直到“数组的长度-1”为止

//静态初始化下访问数组元素
public class Demo04ArrayUse {
    public static void main(String[] args) {
        int[] array = {10, 20, 30};
        System.out.println(array[0]);
    }
}
//动态初始化数组访问
//使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值，规则如下
如果是整数类型，默认值0
如果是浮点类型，默认值0.0
如果是字符类型，默认值\u0000
如果是布尔类型，默认值false
如果是引用类型，默认值null
注意事项：静态初始化其实也有默认值，只不过系统马上将默认值替换成为了大括号当中的具体数值
public class Demo04ArrayUse {
    public static void main(String[] args) {
        int[] array = new int[3];
        System.out.println(array);//内存地址值
        System.out.println(array[0]);//0
        System.out.println(array[1]);//0
        System.out.println(array[2]);//0
        //将数据123数值赋值给array当中的一号元素
        array[1] = 123
        System.out.println(array[1]);//123
    }
}

Java内存划分

栈（Stack）:存放的都是方法中的局部变量，方法的运行一定要在栈当中
- 局部变量：方法的参数或者是方法{}内存的变量
- 作用域:一旦超出作用域，立刻从栈内存当中消失
堆（Heap）: 凡是new出来的东西，都在堆里面，堆内存里面的都系都有一个地址值：16进制
- 堆内存里面的数据都有默认值，规则
- 如果是整数，默认值0
- 如果是浮点数，默认值0.0
- 如果是字符默认’\u0000’
- 如果是布尔 false
- 如果是引用类型，null
方法区（Method Area）:存储.class相关信息，包含方法的信息
本地方法栈（Native Method Stack）:与操作系统相关
寄存器(pc Register):与CPU相关

数组越界异常：如果访问数组元素的时候，索引编号并不存在，那么将会发生数组索引越界异常：ArrayIndexOutOfBoundsException
空指针异常:数据必须进行new初始化才能使用其中的元素，如果只是赋值了一个null，没有进行new创建，那么将会发生控制住异常nullPointerException
获取数组的长度,格式:数组名称.length,将会得到一个int数字，代表数组的长度
数组一旦创建，程序运行期间，长度不可改变

public class Demo04ArrayUse {
    public static void main(String[] args) {
        int[] arrayA = {10, 20, 30};
        int len = arrayA.length;
        System.out.println(len);
        int[] arrayC = new int[3];
        System.out.println(arrayC.length);
        arrayC = new int[5];
        System.out.println(arrayC.length);
        
    }
}

练习求数组最值

//求数组最大值
public class Demo06ArrayMax {
    public static void main(String[] args) {
        int[] array = {5, 10, 15, 12, 35, 85};
        int max = array[0];
        for (int i =1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        System.out.println(max);
    }
}

数组元素反转

public class Demo07ArrayReverse {
    public static void main(String[] args) {
        int[] array = {10,20,30,40,50};
        for (int min = 0, max = array.length - 1; min < max; min++, max--) {
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

}

数组作为方法参数
- 当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值

public class demo01ArrayParam {
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 50};
        printArray(array);
    }
    //任何数据类型都可以作为方法的参数
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

数组作为方法的返回值

package cn.day01.demo02;
// 一个方法可以有0，1,2多个返回值，但是只能有0或者1个返回值，不能有多个返回值
//如果希望一个方法中产生多个结果数据进行返回，使用一个数组作为返回值即可
//数组作为方法的参数，传递进去的其实是数组的地址值
//数组作为方法的返回值，返回的其实也是数组的地址值
public class Demo02ArrayReturn {
    public static void main(String[] args) {
        int[] result = calculate(10, 20, 30);
        System.out.println(result[0]);
        System.out.println(result[1]);

    }
    public static int[] calculate(int a, int b, int c) {
        int sum = a + b + c;
        int avg = sum / 3;
        /*
        int[] array = new int[2];
        array[0] = sum;
        array[1] = avg;

         */
        int[] array = { sum, avg};
        return array;
    }
}

第五章面向对象

面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节
面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人来帮我做事儿

package cn.day01.demo02;
import java.util.Arrays;

public class Demo01PrintArray {
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 50};
        // 要求打印格式为: [10, 20, 30, 50]
        // 使用面向过程，每一个步骤细节都要亲力亲为
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {//如果是最后一个元素
                System.out.println(array[i] + "]");
            } else { //如果不是最后一个元素
                System.out.print(array[i] + ",");
            }
        }
        System.out.println("========");
        // 面向对象
        // 找一个JDK给我们提供好的Arrays类
        // 其中有一个toString方法，直接就能把数组变成想要的格式的字符串
        System.out.println(Arrays.toString(array));
    }
}

面向对象语言中，三大基本特征
- 封装
- 继承
- 多态
类：是一组相关属性和行为的集合，可以看成一类事物的模板，使用事物的属性特征和行为特征来描述该类书事物
属性：就是该事物的状态信息
行为：就是该事物能够做什么
对象：是一类事物的具体表现。对象是类的一个实例，必然具备该类事物的属性和行为
定义一个类，用来模拟学生事物，其中有两个组成部分
- 属性
  - 姓名
  - 年龄
- 行为
  - 吃饭
  - 睡觉
  - 学习
对应到java的类当中：
- String name;
- int age;
成员方法（行为）:
- public void eat() {}
- public void sleep() {}
- public void study() {}

public class Student {
    //成员变量
    String name;
    int age;
    public void eat() {
        System.out.println("");
    }
    public void sleep() {
        System.out.println("");
    }
    public void study() {
        System.out.println("");
    }
}

注意事项:
- 成员变量是直接定义在类当中的，在方法外边
- 成员方法不要写static关键字
通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用
导包：也就是指出需要使用的类，在什么位置：import 包名称.类名称
创建格式：类名称.对象名称 = new 类名称();
使用，分为两种情况
- 使用成员变量，对象名.成员变量名
- 使用成员方法，对象名.成员方法名(参数)
注意事项：如果成员变量没有进行赋值，那么将会有一个默认值、规则和数组一样
两个引用指向同一个对象

在这里插入图片描述

成员变量和局部变量的区别

package cn.day01.demo02;
/*局部变量和成员变量
1. 定义的位置不一样
局部变量，在方法的内部
成员变量，在方法的外部，直接写在类当中

2. 作用范围不一样
局部变量：只有方法当中才可以使用，出了方法就不能再用
成员变量：整个类全都可以通用

3. 默认值不一样
局部变量：没有默认值，如果要想使用，必须手动进行赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样

4. 内存的位置不一样
局部变量，位于栈内存成员变量，
成员变量，位于堆内存
5. 生命周期不一样
局部变量，随着方法进栈而诞生，随着方法出栈而消失
成员变量，随着对象创建而诞生，随着对象被垃圾回收而消失
*/
public class demo03 {
    String name; // 成员变量
    public void methodA() {
        int num = 20; // 局部变量
        System.out.println(num);
        System.out.println(name);
    }
    public void methodB(int param) {// 方法的参数就是局部变量
        // 参数在方法调用的时候，必然会被赋值的
        System.out.println(param);
        int age;
        // System.out.println(age); 局部变量无默认值
        //System.out.println(num); // 错误写法
        System.out.println(name);
    }
}

面向对象的三大特征

package cn.day01.demo02;
// ，面向对象三大特征：封装、继承、多态
//封装性在java当中的体现
/*1. 方法就是一种封装
2. 关键字private也是一种封装
封装就是将一些细节信息隐藏起来，对于外界不可见
*/

public class Demo02Method {
    public static void main(String[] args) {
        int[] array = {5, 10, 15, 25};
        int max = getMax(array);
        System.out.println(max);
    }
    public static int getMax(int[] array) {
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }
}

private关键字使用及作用

package cn.day01.demo02;
/*对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变*/

public class Student {
    private String name; //
    private int age;
    private  boolean male;
    public void setMale(boolean b) {
        male = b;
    }
    public boolean isMale() {
        return male;
    }

    public void setName(String str) {
        name = str;
    }
    public String getName() {
        return name;
    }
    public void setAge(int num) {
        age = num;
    }
    public int getAge() {
        return age;
    }
}

package cn.day01.demo02;

public class Demo04Student {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setName("鹿晗");
        stu.setAge(20);
        stu.setMale(true);

        System.out.println(stu.getName());
        System.out.println(stu.getAge());
        System.out.println(stu.isMale());
    }
}

this关键字

package cn.day01.demo02;
// 当方法的局部变量和类的成员变量重名的时候，根据“就近原则",优先使用局部变量
// 如果需要访问本类当中的成员变量，需要使用格式：this.成员变量名
// 通过谁调用的方法，谁就是this
public class Person {
    String name; // 成员变量
    public void sayHello(String name) {
        System.out.println(name + "，你好，我是" + this.name);
        System.out.println(this);
    }
}


package cn.day01.demo02;

public class Demo01Person {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "马云";
        person.sayHello("马化腾");
        System.out.println(person); // 地址值
    }
}

构造方法：是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法
格式：public 类名称（参数类型参数名称）{
方法体
}
注意事项：
- 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
- 构造方法不要写返回值类型，连void都不写
- 构造方法不能return一个返回值
- 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做 public Student() {}
- 一旦编写了至少一个构造方法，那么编译器将不再赠送
- 构造方法也是可以进行重载的重载：方法名称相同，参数列表不同

package cn.day01.demo02;

public class One {
    //成员变量
    private String name;
    private int age;
    public One() {
        System.out.println("构造方法执行啦！");
    }
    public One(String name, int age) {
        System.out.println("全参构造方法执行啦！");
        this.name = name;
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
}

package cn.day01.demo02;

public class Two {
    public static void main(String[] args) {
        One one = new One(); // 无参构造
        One two = new One("赵丽颖", 20); // 全参构造
        System.out.println("姓名:" + two.getName() + "，年龄:" + two.getAge());
    }
}

定义一个标准的类

package cn.day01.demo02;
// 一个标准的类通常要满足拥有下面四个组成部分
/*所有的成员变量都要使用private关键字修饰
2.为每一个成员变量编写一对儿Getter/Setter方法
3.编写一个无参数的构造方法
4.编写一个全参数的构造方法 85+

标准的类也叫java Bean
* */
public class StudentOne {
    private String name;
    private int age;

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

    public StudentOne() {
    }

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