Java入门篇

LINK +

已于 2023-12-05 17:20:35 修改

阅读量2.1k

点赞数 53

文章标签： java

于 2023-12-05 16:59:51 首次发布

本文链接：https://blog.csdn.net/weixin_58423339/article/details/134811967

版权

1 java平台

1 Java的三大平台分类

JavaSE：

可以用于桌面应用开发。

目的：为了后面学习JavaEE打基础。

JavaME：

用于嵌入式设备和小型移动设备开发。

JavaEE：

企业级的服务器开发。

在这个领域Java是当之无愧的No1

2 Java的跨平台

虚拟机：

就可以理解为是一台虚拟的电脑。

我们自己编写的Java代码，是运行在虚拟机（JVM）中的。

我们自己编写的代码，不是运行在系统里面的。

针对于不同的操作系统，其虚拟机是不一样的。

3 JDK JRE和JVM

JVM：虚拟机，是代码真正运行的地方。

JRE：包含了JVM和核心类库。

JDK：包含了JRE和开发工具。

程序员：JDK

使用者：JRE

2. 常量变量

1 注释

注释就是给程序的解释说明。

1 注释的分类

单行注释 // 注释的内容

多行注释 / 注释的内容 /

（了解）文档注释 /** 注释的内容 */

2注释的注意事项

注释对程序的运行是没有任何影响的。

简单理解：注释是不参与程序的运行的。

注释的嵌套问题

不管是单行还是多行，在书写的时候都不要嵌套。

扩展：（了解）

因为注释是对程序的解释说明，是给程序员看的。对程序的执行没有任何影响。

所以，代码在编译之后，class文件里面是没有注释信息的，做了一个注释擦除。

2 关键字

关键字就是被Java赋予了特定含义的英文单词。

当我们在代码中，写了对应的单词之后，那么程序在执行时，就知道要做什么事情了。

1 关键字的特点

全部都是小写

在常用的代码编辑器中，关键字都有高亮的颜色显示。

2 class和public

class关键字

表示新建一个类。

class后面跟随的是这个类的名字，简称：类名。

类名后面跟随一对大括号，表示类的范围。

代码示例：

//表示新建了一个类
//类名：Demo
//类的范围：Demo后面的这对大括号决定。
public class Demo{
    
}

public关键字

当public写在class前面的时候，表示强制让文件名跟类名一定要保持一致。

如果没有一致，代码就会报错。

建议：

习惯：一个Java文件中，只写一个Java类。

这个是public关键字的第一个作用，第二个作用我们会在面向对象的时候继续学习。

3 字面量

在程序执行的过程中，其值不会发生改变的量。

由于翻译的原因，字面量跟我们预习资料中的常量是一回事。

而且，等以后你到了公司的时候，也会发现有人这么称呼。

1 分类：

整数类型

小数类型

字符串类型

字符类型

布尔类型

空类型

整数类型：

不带小数点的都是整数类型的字面量

小数类型：

只要带了小数点都是小数类型的字面量

举例：

123：不带小数点，整数类型

1.1 ：带小数点，小数类型

0：不带小数点，整数类型

10.0：带小数点：小数类型

字符串类型：

只要用双引号引起来的，不管里面的内容是什么，不管里面的内容有没有，都是字符串类型的。

字符类型：

一，需要用单引号引起来。二，里面有且只能有一个。

举例：

"abc"：用双引号引起来了，字符串类型

'a'：用单引号引起来了，内容一个，字符类型

" "（里面是一个空格）：用双引号引起来了，字符串类型

""（里面连空格都没有）：用双引号引起来了，字符串类型

“，”（里面是逗号）：用双引号引起来了，字符串类型

“123”：用双引号引起来了，字符串类型

'abc'：语法错误。因为字符里面只能有一个。

布尔类型：

只有两个值。true，false

true：真。false：假。

以后在实际开发中，我们会根据真假结果来执行不同的代码。

比如：用户登录。如果用户的用户名和密码输入正确了，那么比较结果就是true，此时会让用户登录成功。如果用户的用户名和密码输入错误了，那么比较结果就是false，此时会让用户继续输入。

空类型：

只有一个值：null

在后面的面向对象和数组的时候会再次学习。

代码练习：

输出Java中的6种字面量

public class HelloWorld{
	public static void main(String[] args){
		System.out.println(17);
		System.out.println(2.18);
		System.out.println("德玛西亚");
		System.out.println('男');
		System.out.println(true);
		System.out.println(false);
        //null简单理解：就表示什么东西都不存在。
        //不能直接输出使用的。
		System.out.println(null);
	}
}

4 变量

概念：

在程序的执行过程中，其值有可能发生改变的数据，就是变量

在实际开发中的使用场景：

突出了变量的变字。

场景一：

用户登录的时候，每一个用户的用户名和密码都有可能是不一样的。

在程序中，我们就可以定义两个变量，一个存储用户名，一个存储密码。

场景二：

微信余额

微信的余额，也是经常发生改变的。

我们可以定义一个变量，用来记录微信的余额。当余额发生改变的时候，就修改变量记录的值。

场景三：

银行卡余额

核心点：

经常发生变化的。

格式：

数据类型变量名 = 数据值；

数据类型：用于限定存储数据的类型。

如果是整数类型，那么表示该变量只能存整数

变量名：就是给小空间起的一个名字。

方便以后使用。

数据值：存在小空间里面的数据。

分号：表示语句的结束。

整体理解：

我们可以把变量理解为一个临时存储数据的小空间（小箱子）。

变量名，就是这个小空间的名字。

数据类型，限定了以后什么数据能存到这个小空间中。

数据值：真实存在小空间中的数据。

代码示例：

//1.定义一个变量，用来记录整数
int a = 123;
//2.定义一个变量，用来记录小数（浮点数）
double b = 11.1;

5 变量的使用

使用方式一：直接打印

代码示例：

//定义一个变量记录10
int a = 10;
//打印的是变量a里面记录的值
System.out.println(a);//10

扩展的对比：

//此时小括号中，打印的是字符串a
System.out.println("a");//a

同学们犯的错误：

昨天在写HelloWorld的时候，没有加双引号。此时报错。

原因：此时打印的不是字符串HelloWorld，而是变量HelloWorld里面的值。

在代码中，我们没有定义一个叫做HelloWorld的变量，所以报错。

System.out.println(HelloWorld);

使用方式二：参与计算

代码示例1：

int a = 10;
int b = 20;
//把变量a和变量b里面的值相加，再把结果打印出来
System.out.println(a + b);

代码示例2：

int a = 10;
int b = 20;
//把变量a和变量b里面的值相加，再把结果赋值给左边的变量c
int c = a + b;
//把变量c里面的值进行打印。
System.out.println(c);

使用方式三：修改变量的值

核心：变量只能记录一个值，修改之后，原来的值就会被覆盖

代码示例：

//定义一个新的变量，变量里面记录为10
int a = 10;
//此时变量a还没有被修改，所以打印的是最初的值10
System.out.println(a); //10
//修改已有的变量a，把里面的值修改为20.原来的值就被覆盖了
a = 20;
//此时变量里面记录的值已经被修改，打印修改之后的值20
System.out.println(a); //20

6 变量的注意事项

变量里面只能记录一个值。
当修改了变量里面的值时，原来的值就会被覆盖。

变量名不允许重复
代码示例：

int a = 10;
int a = 20;
System.out.println(a); //变量名重复了，所以报错

一条语句可以定义多个变量（了解）
建议：
以后在定义变量的时候，一行定义一个。
如果要定义多个变量，写在多行。
代码示例：

//表示在一行定义了4个变量，都是int类型的，以后能存整数
//但是这种写法，不方便阅读。
int a = 10,b = 20,c = 30,d = 40;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);

变量在使用之前一定要赋值
代码示例：

int a = 10;
//以等号为中间界，分为两部分。
//第一部分：等号的左边，定义变量
	int a
//第二部分：等号的右边，给左边的变量赋值
	= 10；

代码示例：
建议：
虽然变量的定义和赋值可以分开写。但是不建议。
建议，以后写代码的时候，定义变量直接给值。

7 变量的案例

根据情况计算车上乘客的数量

代码示例：

public class Test5{
	public static void main(String[] args){
		//一开始车上没人
		int count = 0;
		//到了第一站：上来一个人，没有人下去
		//先拿着count为0跟1进行相加
		//再把最终的结果赋值给count
		count = count + 1;	
		//到了第二站：上来两个人，下去一个人
		count = count + 2;
		count = count - 1;		
		//到了第三站：上来两个人，下去一个人
		count = count + 2;
		count = count - 1;		
		//到了第四站：下去一个人
		count = count - 1;
		//到了第五站：上来一个人
		count = count + 1;
		//到了终点站，count的值就是车上的乘客数量
		System.out.println(count);
	}
}

3. 数据类型运算符

1 Java中数据类型的分类

基本数据类型

引用数据类型

2 基本数据类型的四类八种

整数类型：byte、short、int、long

浮点类型：float、double

字符类型：char

布尔类型：boolean

扩展：

引用数据类型，在代码中除了上面的四类八种其他所有的都是引用数据类型。

基本数据类型需要记忆的

byte的取值范围：
-128 ~ 127

int的大概取值范围：
-21亿多 ~ 21亿多

整数和小数的取值范围的大小关系：
byte < short < int < long < float < double

扩展：

不同的数据类型，在内存中占用的字节数量是不一样的。

3 不同数据类型变量的定义

注意点：

定义long类型变量的时候，后面的数据值要加L后缀。建议大写。

定义float类型变量的时候，后面的数据值要加F后缀。建议大写。

代码示例：

//byte
byte b = 10;
System.out.println(b);//10

//short
short s = 100;
System.out.println(s);//100

//int
int i = 99;
System.out.println(i);//99

//long
//如果给long类型的变量赋值。
//后面的数据值要加L后缀。
//L可以是大写的，也可以是小写的。
//建议大写。
long n = 9999999999L;
System.out.println(n);

//float
float f = 11.1F;
System.out.println(f);

//double
double d = 10.2;
System.out.println(d);

//char
char c = '我';
System.out.println(c);

//boolean
boolean bb = true;
System.out.println(bb);

1.2 变量的练习

练习的目的：

以后在实际开发中，根据不同的数据来选择不同的数据类型

练习1：

定义变量记录老师的信息。

代码示例：

public class VariableDemo2{
    public static void main(String[] args){
        //老师的姓名
        String s = "德玛西亚";
        //老师的年龄
        int i = 18;
        //老师的性别
        char c = '男';
        //老师的身高
        double d = 180.1;
        //是否单身
        boolean b = true;
        //输出所有变量
        System.out.println(s);
        System.out.println(i);
        System.out.println(c);
        System.out.println(d);
        System.out.println(b);
    }
}

练习2：

定义变量记录电影的信息。

代码示例:

public class VariableDemo2{
    public static void main(String[] args){
        //定义变量记录电影的名字
        String name = "送初恋回家";
        //定义变量记录主演的名字
        String personName = "刘鑫等等";
        //定义变量记录年份
        int year = 2020;
        //定义变量记录分数
        double score = 9.0;
        
        //输出所有变量
        System.out.println(name);
        System.out.println(personName);
        System.out.println(year);
        System.out.println(score);
    }
}

练习3：

定义变量记录手机的信息。

代码示例：

public class VariableDemo2{
    public static void main(String[] args){
        //定义变量记录手机的价格
        double price = 5299.0;
        //定义变量记录手机的品牌
        String name = "华为";
        
        //输出所有变量
        System.out.println(price);
        System.out.println(name);
    }
}

2. 标识符

2.1 什么是标识符？

给类、方法、变量起的名字就是标识符。

简单理解：在代码中，凡是我们自己起的名字都是标识符，都要遵守我们下面讲解的规则。

2.2 标识符的硬性要求

必须要这么做，否则代码就会报错。

必须由数字、字母、下划线、美元$符组成

不能以数字开头

不能是关键字

区分大小写

2.3 标识符的软性建议

如果不这么做，代码不会报错，但是影响阅读，也显得代码很low

建议：不管是硬性要求还是软性建议，咱们都要遵守。

小驼峰命名法：

适用于：方法名、变量名

一个单词，全部小写。
比如：name，age，gender，address

多个单词，从第二个单词开始首字母大写。
比如：firstName

大驼峰命令法：

适用于：类名

一个单词，首字母大写。
比如：Demo，Test，Student

多个单词，每一个单词的首字母都要大写。
比如：HelloWorld

建议：

不管起什么名字，都要遵守四个字：见名知意。

如果英文单词记不住，不要使用拼音，用有道词典查一下。如果担心自己时间长了忘了，写注释。

3. 键盘录入

3.1 目的：

为了让我们变量记录的数据变得更加灵活。

3.2 实现步骤：

1.导包

简单理解：先要找到Scanner这个类在哪？

2.创建对象

简单理解：申请一下去我要开始用Scanner这个类了。

3.接收数据

只有等号右边才是真正的接收数据，接收到之后，把数据赋值给左边的变量

代码示例：

//1.导包 ，实际作用：先找到Scanner这个类在哪
//必须要写在第一行，类定义的外面
import java.util.Scanner;		

public class ScannerDemo1{
    public static void main(String[] args){
        //2.创建对象 ， 实际作用：申请一下我要开始用Scanner这个类了。
        Scanner sc = new Scanner(System.in);
        //加一个提示
        System.out.println("请输入一个整数");
        //3.把接收到的数据赋值给一个变量
        int number = sc.nextInt();  
        System.out.println(number);
    }
}

3.3 键盘录入的练习

核心：

如果我们需要多次键盘录入数据，那么第一步和第二步不需要多次书写。只要多次书写第三步即可

代码示例：

import java.util.Scanner;//找到Scanner这个类在哪	

public class ScannerDemo1{
	public static void main(String[] args){
		//申请一下，我准备要用Scanner这个类了。
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入第一个整数");
		int number1 = sc.nextInt();
		
		System.out.println("请输入第二个整数");
		int number2 = sc.nextInt();
		
		//求和
		int result = number1 + number2;
		
		System.out.println(result);
	}
}

4. idea

4.1 什么是idea？

是Java的集成开发工具，该工具把编写代码，编译，运行，调试等都集中在一起了。

特点：

自动保存、自动编译。

我们在使用的时候主要注重于两步：

编写代码

运行代码看结果

idea是收费的，我们暂时可以使用免费试用30天的版本。

4.2 下载和安装

下载：

可以不用下了，直接用day01资料中的即可。

安装：

傻瓜式安装直接点击下一步即可。

安装的注意点：

修改安装路径

要选择一下，在桌面创建一个64位的快捷方式

4.3 idea的结构

项目

模块

包

类

理解方式：

整个微信，可以理解为一个大的项目

下面有四个互相独立的功能：消息，联系人，朋友圈，我

这四个互相独立的功能，我们可以理解为4个模块。

以第一个消息模块为例，在这个模块里面，有文字，图片，动画等等，而这些东西都是需要用代码编写的。

为了方便管理，我们可以把所有的文字相关的代码，都放到同一个文件夹中。

为了方便管理，我们可以把所有图片相关的代码，都放到同一个文件夹中。

为了方便管理，我们可以把所有动画相关的代码，都放在同一个文件夹中。

然后在文件夹（包）中，就可以新建类，去编写代码了。

4.4 idea中类的相关操作

新建类：

细节：想要在哪个包中新建类，就右键点击谁，就可以了。

删除类：

想要删除哪个类，就右键点击谁就可以了，再选择delete即可。

修改类名：

我们不能直接在代码中修改，如果在代码中直接修改了，会导致类名跟文件夹不一致，从而报错。

如果想要修改可以有两种方式：

1.先选中要修改的文件名，按快捷键：shift + F6

2.右键点击要修改的文件名，选中rename

4.5 idea中模块的相关操作

新建模块：

点击File --- 再点击项目重构 ---- 再点击加号就可以新建模块了。

删除模块：

右键点击模块选择移除模块。

细节：此时并不是真正的删除，而是从idea界面中移除当前模块。在本地文件夹里面模块还是存在的。

导入模块：

前提：在本地中，需要有一个模块才能被导入到idea中。

点击File --- 再点击项目重构 ---- 再点击加号--- 点击import ---- 再选择对应的模块即可 ---- 选中模块里面的iml文件，再点击ok即可导入。

如果导入成功之后，在代码的右上角有JDK的选择，那么直接选择本地对应的版本即可。

如果没有JDK的选择，那么可以直接编写代码。

4.6 idea中项目的相关操作

关闭项目：

点击File --- 选择关闭项目即可

此时就可以回到idea最一开始的界面

新建项目：

在idea最一开始的界面中，我们可以点击newProject就可以新建项目了。

打开项目：

其实跟导入模块是类似的。

前提：在本地中需要有一个已经存在的项目。

在idea最一开始的界面中，我们可以点击open即可，在本地中选择要打开的项目就可以了。

4.7 扩展知识点：快捷键

我个人在编写代码时，常用的一些快捷键。

复制：ctrl + c

粘贴：ctrl + v

撤销：ctrl + z

向下生成一个空行：shift + 回车

格式化代码：ctrl + alt + L

向下复制一行：ctrl + d

移动代码：shift + alt + 上键/下键

温馨提示：

idea中的快捷键，有可能会跟其他软件冲突。

有可能冲突的软件：

QQ，网易云音乐，QQ音乐，有道词典，金山词霸。

如果我们按快捷键没有反应：

一定是跟其他软件冲突了。此时可以一个一个的去关闭。

讲解方式：

我在写代码的时候，用到一个，会讲一个。

5 算术运算符

5.1 分类：

+ - * / %

5.2 细节：

1.运算规则。跟小学数学是一模一样的

2.如果是整数跟整数进行计算，结果只能是整数。直接去掉小数部分，保留整数。

3.如果想要结果中有小数，需要有小数参与计算。

4.只要有小数参与计算，那么结果是有可能不精确的

5.%，叫做取余或者取模，进行的也是除法运算，只不过获取的是余数。

代码示例：

// %
//取余  取模
//跟除法一样，做的也是除法运算。
//除法 取的是商 取余取的是余数
System.out.println(10 / 3);//3
System.out.println(10 % 3);//1

%的使用场景：

1.我们可以利用%判断数字a是否可以被数字b整除。（掌握）

10 % 7 
看他的最终结果是不是0，如果结果为0，那么就表示10是7的倍数。
如果结果不是0，那么就表示10不是7的倍数。

2.我们可以利用%判断一个数字是奇数还是偶数。（掌握）

10 % 2
看他的最终结果是不是0，如果结果为0，表示10是偶数
如果结果是1，表示10是奇数。

3.我们还可以利用%去做游戏中的发牌（了解）

到了就业班还会再讲。

斗地主牌
1.我们可以把54张扑克牌都定义一个序号：1~54
2.拿着每一张牌的序号对3取模
如果结果为1，就把当前的牌发给第一个玩家。
如果结果为2，就把当前的牌发给第二个玩家。
如果结果为0，就把当前的牌发给第三个玩家。

5.3 练习

需求：

键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台

代码示例：

//对于任意的一个整数
//个位：数字 % 10
//十位：数字 / 10 % 10
//百位：数字 / 100 % 10
//千位：数字 / 1000 % 10
//万位：数字 / 10000 % 10
//...以此类推


//分析：
//1.键盘录入一个三位数，123
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int number = sc.nextInt();
System.out.println(number);
//2.将其拆分为个位、十位、百位后，打印在控制台

//number是什么？就是键盘录入的数字
//拿着键盘录入的数字跟10进行取余的计算。
//把得到的余数赋值给左边的变量
int ge = number % 10;

//拿着键盘录入的数字先跟10相除，得到整数部分
//拿着得到的整数部分，再跟10进行取余的计算。
//把得到的余数赋值给左边的变量
int shi = number / 10 % 10;

int bai = 456 / 100 % 10;
System.out.println(ge);
System.out.println(shi);
System.out.println(bai);

6. 隐式转换

概念

取值范围小的，变成取值范围大的。

细节：

隐式转换是不需要我们自己单独写代码实现的。是由虚拟机帮我们自动完成的。

触发时机：

在实际开发中，什么时候用到这个知识点。

1.取值范围小的跟取值范围大的进行计算的时候，小的会先提升为大的，然后再进行计算。

2.byte short char 这三种类型在参与计算的时候，先提升为int，再进行计算。

举例：

int a = 10;
double b = a;
//不会报错
//就是把一个取值范围小的，变成取值范围大的。
//把小的给大的不会报错，可以直接给。
//提升的时候，实际提升的不是变量a，而是变量a里面的数据10.

int a = 10;
long n = 100L;
??? result = a + n;
//问：result 是什么数据类型？long
//数据类型不一样，不能直接进行计算
//需要转成一样的才能进行计算。
//把变量a里面的数据10，提升为long类型的
//实际上，最终就是两个long类型的数据进行计算。
//最终的结果result就是long类型的

int a = 10；
long n = 100L;
double d = 20.1;
??? result = a + n + d;
//问：result 是什么数据类型？double
//数据类型不一样，不能直接进行计算
//需要转成一样的才能进行计算
//第一步：是a + n 类型不一样，变量a里面的数据先变成long，进行计算
//		 a + n 的结果是long类型的、
//第二步：long + double。需要继续提升，最终提升为double
//所以，最终的结果就是double类型。

byte b1 = 10；
byte b2 = 20；
??? result = b1 + b2;
//问：result 是什么数据类型？int
//取值范围比int小的类型，在计算的时候。先直接提升为int。再进行计算。
//b1和b2里面的数据，在进行计算的时候，先提升为int，再进行计算
//所以，结果为int。

7. 强制转换

核心：

把一个取值范围大的，交给取值范围小的。

在代码中，不能直接给，如果一定要这么干，就需要加入强制转换。

格式：

因为这个操作，不是虚拟机帮我们进行的，需要我们自己写代码实现。

简单理解：想要转成什么类型，就在前面的小括号中，写什么类型即可。

目标数据类型变量名 = （目标数据类型）待转换的数据。

细节：

强制转换，有可能导致数据发生改变。

举例：

double a = 12.3;
int i = (int)a;

byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2;
//第三行代码是报错的，因为等号的右边最终结果为int类型
//而把大的给小的，是不能直接给的，会报错。
//所以我们可以加入强制转换

//错误的。此时强转的是b1.
byte b3 = (byte)b1 + b2;

//错误的。此时强转的是b1和b2
//就算转完了，他们在再次相加计算的时候，还会变成int类型
byte b3 = (byte)b1 + (byte)b2;

//正确的。先计算小括号中的b1 + b2 ，得到一个int类型的结果
//然后再把int类型的结果转换成byte类型
byte b3 = (byte)(b1 + b2);

8. 字符串的加操作

规则1：

在+的过程中，如果有字符串参与计算，那么此时+就不是算术运算符了，而是字符串的拼接符。会把数据进行拼接，并产生一个新的字符串。

规则2：

如果有多个+连续存在，从左到右依次计算，如果没有字符串，就是普通的算术运算符。

如果有字符串参与，就是拼接。

规则3：

如果字符串跟变量进行拼接，是拿着变量里面的数据跟字符串进行拼接。

但是变量不能用双引号引起来。

规则4：

字符串只有相加操作，没有减，乘，除，取模操作

举例：

"123" + 123  结果："123123"

123 + 123 + "123" 结果："246123"

int age = 18;
sout("我的年龄是" + age + "岁");//我的年龄是18岁
//此时是三个字符串进行拼接
sout("我的年龄是" + "age" + "岁");//我的年龄是age岁

System.out.println(1 + 2 + "abc" + 2 + 1);//3abc21
//当连续+的时候，从左到右依次计算的，如果有字符串就是拼接
//如果没有字符串，就是相加。
//第一步：1 + 2 结果3
//第二步：3 + "abc" 结果"3abc"
//第三步："3abc" + 2 结果"3abc2"
//第四步："3abc2" + 1 结果"3abc21"

用法：

可以让我们的变量在展示的时候，更加有意义。

//分析：
//1.键盘录入一个三位数，123
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int number = sc.nextInt();
System.out.println(number);
//2.将其拆分为个位、十位、百位后，打印在控制台

//number是什么？就是键盘录入的数字
//拿着键盘录入的数字跟10进行取余的计算。
//把得到的余数赋值给左边的变量
int ge = number % 10;

//拿着键盘录入的数字先跟10相除，得到整数部分
//拿着得到的整数部分，再跟10进行取余的计算。
//把得到的余数赋值给左边的变量
int shi = number / 10 % 10;

int bai = number / 100 % 10;
System.out.println("个位是:" + ge);
System.out.println("十位是:" + shi);
System.out.println("百位是:" + bai);

9. 字符的加操作

ASCII码表：

在这张码表中，字符跟数字有一个一一对应的关系。

'a' --- 97

'A' --- 65

规则：

当字符加字符 或者 字符加数字的时候，此时字符会到ASCII码表中找对应的数字，然后再进行计算。

注意点：

当字符跟字符串参与计算的时候，做的是拼接操作。

代码示例：

char c = 'a';
int result = c + 0;//97
//先拿着字符a到码表中查，查到了数字97，再跟0进行计算，结果就是97.

char c = 'a';
System.out.println("ABC" + c);//ABCa

10. 自增自减运算符

基本用法：（掌握）

不管是写在前面，还是写在后面，只要单独写一行，结果就是一样的。

代码示例：

int a = 1;

//后++
a++;//把变量里面的值+1，执行完毕之后，变量里面的值就是2
System.out.println(a);//2

//先++
++a;//把变量里面的值+1，执行完毕之后，变量里面的值就是3
System.out.println(a);//3

//后--
a--;
System.out.println(a);//2

//先--
--a;
System.out.println(a);//1

扩展用法：（了解）

先和后，以后在实际开发中，我们基本上都是单独写成一行的。

如果实际参与了计算，一般在代码里面是不会写的。

运算规则：

先++：

先加后用

int a = 1;
int b = ++a;
// 先把变量a的值1，自增变成2.
// 再把2拿出来使用，赋值给变量b
所以，程序运行完毕之后，a为2，b为2

后++：

先用后加

int a = 1;
int b = a++;
// 先把变量a的值进行使用，赋值给变量b
// 然后变量a再进行自增
所以，程序运行完毕之后，a为2，b为1

面试题举例：

public class Test {
    public static void main(String[] args) {
        int x = 10;
        
        //后++，先用后加
        //先把x的值10拿出来用，赋值给y，然后x再进行自增变成11
        //当这行代码执行完毕之后，x = 11 y = 10
        int y = x++;
        
        //先++，先加后用
        //先把x的值进行自增，变成12，再把自增之后的值拿出来用。赋值给z
        //当这行代码执行完毕之后，x = 12 z = 12
        int z = ++x;
        
        //因为x自增了两次就是12
        System.out.println("x:" + x);//12
        System.out.println("y:" + y);//10
        System.out.println("z:" + z);//12
    }
}

应用场景一：

当过生日的时候，记录age的变量要自增。

变量在合适的时候需要自增一次。

应用场景二：

商城项目中的购物车，也需要用到自增，自减运算符。

应用场景三：

统计数量的时候。

在一开始，我们可以定义一个变量记录0

把所有参与统计的数据，一个一个进行对比，如果满足，变量就自增一次。

当所有参与统计的数据全部统计完毕，那么变量就表示最终的次数。

举例：

1 ~ 100 之间有多少个偶数？

代码中，我们可以从1开始去数到100。如果遇到一个偶数，那么统计的变量就需要自增一次。

当100个数全部统计完毕之后，变量的值就是最终的结果。

具体的代码我们会在后面学习完循环的时候写，现在知道一下应用场景即可。

11. 赋值运算符

分类：

符号	说明
=	把等号的右边赋值给左边。int a = 10;
+=	把左边和右边进行相加，结果赋值给左边，对右边没有任何影响。
-=	把左边和右边进行相减，结果赋值给左边，对右边没有任何影响。
*=	把左边和右边进行相乘，结果赋值给左边，对右边没有任何影响。
/=	把左边和右边进行相除，结果赋值给左边，对右边没有任何影响。
%=	把左边和右边进行相除，把余数赋值给左边，对右边没有任何影响。

代码示例：

//赋值运算符
//基本的赋值运算符 =

//其他赋值运算符
//+= -= *= /= %=
//以+=为例
int a = 10;
int b = 20;
//就表示把左右进行相加，把结果赋值给左边的，对右边没有任何影响
//相当于 a = a + b;
a += b;
System.out.println(a);//30
System.out.println(b);//20

扩展点：（了解）

+=、-=、*=、/=、%= 在底层隐藏了强制类型转换

代码示例：

byte b1 = 10;
byte b2 = 20;
b1 += b2;
//相当于：b1 = (byte)(b1 + b2)

12. 比较运算符

概念：

比较运算符，又叫做关系运算符，其实就是做了一个判断而已。

分类：

==：判断左右是否相等
!=：判断左右是否不相等
>:判断左边是否大于右边
>=：判断左边是否大于等于右边
<：判断左边是否小于右边
<=：判断左边是否小于等于右边

注意点：

关系运算符的结果只能是布尔类型的，要么是true，要么是false。在后面实际开发中，我们会根据两种情况来执行不同的代码。

用户登录，正确true，登录成功

错误false，登录失败

==千万不能写成一个=

练习：

需求：

您和您的约会对象在餐厅里面正在约会。
键盘录入两个整数，表示你和你约会对象衣服的时髦度。（手动录入0~10之间的整数，不能录其他）
如果你的时髦程度大于你对象的时髦程度，相亲就成功，输出true。
否则输出false。

代码示例：

//分析：
//1.键盘录入两个整数
Scanner sc = new Scanner(System.in);
System.out.println("请输入你衣服的时髦度");
int fashtion1 = sc.nextInt();
System.out.println("请输入约会对象衣服的时髦度");
int fashtion2 = sc.nextInt();
//2.比较一下即可
boolean result = fashtion1 > fashtion2;
System.out.println(result);

13 逻辑运算符

1 而且和或者

分类：

& 逻辑与，建议读作并且、而且。

表示需要同时满足左边和右边才可以。

| 逻辑或，建议读作或者。

表示两边的条件只要满足其中一个就可以了。

代码示例：

//& 而且
//规则：两边都为真，结果才是真。只要有一个为假，结果就是假
System.out.println(true & true);//true
System.out.println(false & true);//false
System.out.println(true & false);//false
System.out.println(false & false);//false

// |  或者
//规则：两边都为假，结果才是假，只要有一个为真，结果就是真
System.out.println(true | true);//true
System.out.println(false | true);//true
System.out.println(true | false);//true
System.out.println(false | false);//false

应用场景一：

用户在登录的时候，需要用户名和密码这两个同时输入正确了，那么才是可以的。

此时就是两个条件同时满足，用并且。

应用场景二：

丈母娘跟女婿提要求：需要有房子，或者有车子就可以穿走我的小棉袄。

此时就是两个条件中只要满足其中一个即可，用或者

1 异或

这个知识点不重要，后面几乎用不到，所以我们只要了解

运算规则：

相同为false，不同为true

代码示例：

System.out.println(true ^ true);//false
System.out.println(false ^ true);//true
System.out.println(true ^ false);//true
System.out.println(false ^ false);//false

1 非/取反

运算规则：

改变true和false的结果。

如果是true，取反之后变成false

如果是false，取反之后变成true

代码示例：

System.out.println(true);//true
System.out.println(!true);//false
System.out.println(!false);//true

建议：

最多只能用一次。用多了没有任何意义。

代码示例：

System.out.println(!!true);

14 短路逻辑运算符

分类：

&& 短路且、短路与

|| 短路或

特点：

只要左边能确定表达式最终的结果，那么右边不会参与计算。

&&：

左边为true，那么右边会参与计算。

左边为false，那么右边不会参与计算。

||：

左边为true，那么右边不会参与计算。

左边为false，那么右边会参与计算。

常用的逻辑运算符：

&& || !

练习：

需求：

数字6是一个真正伟大的数字，键盘录入两个整数。

如果其中一个为 6，最终结果输出true。

如果它们的和为 6的倍数。

最终结果输出true。

其他情况都是false。

代码示例：

//1.键盘录入两个整数
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int a = sc.nextInt();
System.out.println("请输入第二个整数");
int b = sc.nextInt();
//2.a==6 || b==6 || (a + b) % 6 == 0
//三个条件选一个
boolean result = (a == 6) || (b == 6) || ((a + b) % 6 == 0);
System.out.println(result);

15 三元运算符

三元运算符又叫三元表达式，还有其他名字：问号冒号表达式，三目运算符。

格式：

关系表达式？表达式1 ：表达式2 ；

注意点：

三元运算符的结果一定要被使用，可以赋值给一个变量，或者直接打印输出。

执行流程：

先执行关系表达式。

如果结果为真，执行表达式1，此时表达式1的结果就是整个三元运算符的结果。

如果结果为假，执行表达式2，此时表达式2的结果就是整个三元运算符的结果。

代码示例：

int a = 10;
int b = 20;
//利用三元表达式求a和b之间的较大值
int max = a > b ? a : b ;
System.out.println(max);


System.out.println(a > b ? a : b);

16 练习 - 两只老虎

需求：

动物园里有两只老虎，体重分别为通过键盘录入获得，请用程序实现判断两只老虎的体重是否相同。

代码示例：

//分析：
//1，键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请录入第一只老虎的体重");
int weight1 = sc.nextInt();
System.out.println("请录入第二只老虎的体重");
int weight2 = sc.nextInt();
//2.比较
// String result = 体重1 == 体重2 ? "相同"  : "不相同";
String result = weight1 == weight2 ? "相同" : "不相同";
System.out.println(result);

17 练习-求三个值的较大值

需求：

一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高。

代码示例：

//1.定义三个变量记录和尚的身高
int height1 = 150;
int height2 = 165;
int height3 = 210;
//2.求出任意两个数字的较大值
int temp = height1 > height2 ? height1 : height2;
//3.再拿着这个较大值跟第三个数进行比较，求出三个数字的最大值
int max = temp > height3 ? temp : height3;
System.out.println(max);

18 运算符的优先级

小括号优先于所有。

想要让谁先运行，就把谁给括起来就可以了。

5 流程控制语句

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。

1 流程控制语句分类

顺序结构

分支结构(if, switch)

循环结构(for, while, do…while)

2 顺序结构

顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

顺序结构执行流程图：

3 分支结构：if语句

if语句格式1

格式：
if (关系表达式) {
    语句体;	
}

执行流程：

①首先计算关系表达式的值

②如果关系表达式的值为true就执行语句体

③如果关系表达式的值为false就不执行语句体

④继续执行后面的语句内容

示例：

public class IfDemo {
	public static void main(String[] args) {
		System.out.println("开始");	
		//定义两个变量
		int a = 10;
		int b = 20;	
		//需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
		if(a == b) {
			System.out.println("a等于b");
		}		
		//需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
		int c = 10;
		if(a == c) {
			System.out.println("a等于c");
		}		
		System.out.println("结束");
	}
}

练习1：老丈人选女婿

需求：

键盘录入女婿的酒量，如果大于2斤，老丈人给出回应，否则没有任何回应

代码示例：

//分析：
//1.键盘录入女婿的酒量
Scanner sc = new Scanner(System.in);
System.out.println("请输入女婿的酒量");
int wine = sc.nextInt();//5
//2.对酒量进行一个判断即可
if(wine > 2) {
    System.out.println("不错哟，小伙子！");
}

练习2：考试奖励

需求：

键盘录入一个整数，表示小明的考试名次，如果名次为1，小红可以当小明的女朋有了。

代码示例：

//分析：
//1.键盘录入一个整数，表示小明的考试名次
Scanner sc = new Scanner(System.in);
System.out.println("请输入小明的名次");
int rank = sc.nextInt();
//2.对小明的考试成绩进行判断即可
if(rank == 1){
    System.out.println("小红成为了小明的女朋友");
}

第一种格式的细节：

如果我们要对一个布尔类型的变量进行判断，不要写==，直接把变量写在小括号中即可。

如果大括号中的语句体只有一条，那么大括号可以省略不写
如果大括号省略了，那么if只能控制距离他最近的那一条语句。
建议：自己不要去写，如果别人这么写了，你要能看懂即可。

练习3：无人汽车自动驾驶

代码示例：

无人汽车自动驾驶，每一次遇到红绿灯的时候都会进行判断，根据不同的情况执行不同的代码。
boolean isLightGreen = false;
boolean isLightYellow = false; 
boolean isLightRed = true; 

if (isLightGreen){
   System.out.println("gogogo！");
}

if (isLightYellow){
   System.out.println("slow！");
}

if (isLightRed){
   System.out.println("stop！");
}

if语句格式2

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

执行流程：

①首先计算关系表达式的值

②如果关系表达式的值为true就执行语句体1

③如果关系表达式的值为false就执行语句体2

④继续执行后面的语句内容

示例：

public class IfDemo02 {
	public static void main(String[] args) {
		System.out.println("开始");		
		//定义两个变量
		int a = 10;
		int b = 20;
		//需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，否则，在控制台输出：a的值不大于b
		if(a > b) {
			System.out.println("a的值大于b");
		} else {
			System.out.println("a的值不大于b");
		}		
		System.out.println("结束");
	}
}

练习1：吃饭

需求：

键盘录入一个整数，表示身上的钱。

如果大于等于100块，就是网红餐厅。

否则，就吃经济实惠的沙县小吃。

代码示例：

//分析：
//1.键盘录入一个整数。表示身上的钱。
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数表示身上的钱");
int money = sc.nextInt();
//2.对钱进行判断
if(money >= 100){
    System.out.println("吃网红餐厅");
}else{
    System.out.println("福建大酒店");
}

练习2：影院选座

需求：

在实际开发中，电影院选座也会使用到if判断。

假设某影院售卖了100张票，票的序号为1~100。

其中奇数票号坐左侧，偶数票号坐右侧。

键盘录入一个整数表示电影票的票号。

根据不同情况，给出不同的提示：

如果票号为奇数，那么打印坐左边。

如果票号为偶数，那么打印坐右边。

代码示例：

//分析：
//1.键盘录入票号
Scanner sc = new Scanner(System.in);
System.out.println("请输入票号");
int ticket = sc.nextInt();
if(ticket >= 1 && ticket <= 100){
    //合法
    //2.对票号进行判断
    if (ticket % 2 == 0) {
        //偶数
        System.out.println("坐右边");
    } else {
        //奇数
        System.out.println("坐左边");
    }
}else{
    //票号不合法
    System.out.println("票号不合法");
}

if语句格式3

格式：
if (关系表达式1) {
    语句体1;	
} else if (关系表达式2) {
    语句体2;	
} 
…
else {
    语句体n+1;
}

执行流程：

①首先计算关系表达式1的值

②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值

③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值

④…

⑤如果没有任何关系表达式为true，就执行语句体n+1。

练习1：考试奖励

需求：

小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，

假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。

分析：

①小明的考试成绩未知，可以使用键盘录入的方式获取值

②由于奖励种类较多，属于多种判断，采用if...else...if格式实现

③为每种判断设置对应的条件

④为每种判断设置对应的奖励

代码示例：

//95~100 自行车一辆
//90~94   游乐场玩一天
//80 ~ 89 变形金刚一个
//80 以下  胖揍一顿

//1.键盘录入一个值表示小明的分数
Scanner sc = new Scanner(System.in);
System.out.println("请输入小明的成绩");
int score = sc.nextInt();
//2.对分数的有效性进行判断
if(score >= 0 && score <= 100){
    //有效的分数
    //3.对小明的分数进行判断，不同情况执行不同的代码
    if(score >= 95 && score <= 100){
        System.out.println("送自行车一辆");
    }else if(score >= 90 && score <= 94){
        System.out.println("游乐场玩一天");
    }else if(score >= 80 && score <= 89){
        System.out.println("变形金刚一个");
    }else{
        System.out.println("胖揍一顿");
    }
}else{
    //无效的分数
    System.out.println("分数不合法");
}

练习2：商品的价格

在实际开发中，多种情况判断时，会用到if的第三种格式：

需求：

商场都会有VIP的会员制，根据不同的会员会有不同的折扣。

假设商品总价为1000。

键盘录入会员级别，并计算出实际支付的钱。

会员1级：打9折。

会员2级：打8折。

会员3级：打7折。

非会员：不打折，要打也是打骨折。

代码示例：

//1.定义变量记录商品的价格
int price = 1000;
//2.键盘录入是否为会员(0为会员 1 为非会员 其他数字也认为是非会员)
Scanner sc = new Scanner(System.in);
System.out.println("请输入是否为会员 0为会员 1 为非会员");
int type = sc.nextInt();
if(type == 0){
    //代码执行到这里表示是会员，输入会员级别
    System.out.println("请输入会员级别");
    int vip = sc.nextInt();
    System.out.println("当前会员级别为：" + vip + "级");
    //3.根据不同的会员级别计算商品的价格
    if(vip == 1){
        System.out.println("实际支付" + (price * 0.9));
    }else if(vip == 2){
        System.out.println("实际支付" + (price * 0.8));
    }else if(vip == 3){
        System.out.println("实际支付" + (price * 0.7));
    }else{
        //当输入会员级别不是1,2,3的时候会执行到这里
        System.out.println("没有当前的会员级别");
    }
}else{
    //非会员,商品不打折
    //商品的价格不会发生任何的变化
    System.out.println("当前不是会员");
    System.out.println("实际支付" + price);
}

练习3：自动驾驶

代码示例：

无人汽车自动驾驶，每一次遇到红绿灯的时候都会进行判断，根据不同的情况执行不同的代码。
boolean isLightGreen = false;
boolean isLightYellow = false; 
boolean isLightRed = true; 

//形成一个整体之后，如果第一个判断为真，下面的判断就不会执行了
//提高了代码的运行效率
if (isLightGreen){
   System.out.println("gogogo！");
}else if (isLightYellow){
   System.out.println("slow！");
}else if (isLightRed){
   System.out.println("stop！");
}

4 分支结构：switch语句

switch语句结构（掌握）

格式

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

执行流程：

- 首先计算出表达式的值

- 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。

- 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

switch语句练习-春夏秋冬

需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。

运行结果：

春：3、4、5
夏：6、7、8
秋：9、10、11
冬：1、2、12

示例代码：

public class Demo1 {
    public static void main(String[] args) {
        //键盘录入月份数据，使用变量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个月份：");
        int month = sc.nextInt();
        //case穿透
        switch(month) {
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("你输入的月份有误");
        }
    }
}

注意：如果switch中得case，没有对应break的话，则会出现case穿透的现象。

switch的扩展知识：

default的位置和省略情况
default可以放在任意位置，也可以省略

case穿透

switch在JDK12的新特性

int number = 10;
switch (number) {
    case 1 -> System.out.println("一");
    case 2 -> System.out.println("二");
    case 3 -> System.out.println("三");
    default -> System.out.println("其他");
}

switch和if第三种格式各自的使用场景

当我们需要对一个范围进行判断的时候，用if的第三种格式

当我们把有限个数据列举出来，选择其中一个执行的时候，用switch语句

比如：

小明的考试成绩，如果用switch，那么需要写100个case，太麻烦了，所以用if简单。

如果是星期，月份，客服电话中0~9的功能选择就可以用switch

练习1：休息日和工作日

需求：键盘录入星期数，输出工作日、休息日。

(1-5) 工作日，(6-7)休息日。

代码示例：

//分析：
//1.键盘录入星期数
Scanner sc = new Scanner(System.in);
System.out.println("请输入星期");
int week = sc.nextInt();//3
//2.利用switch进行匹配
----------------------------------------------------
利用case穿透简化代码
switch (week){
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
        System.out.println("工作日");
        break;
    case 6:
    case 7:
        System.out.println("休息日");
        break;
    default:
        System.out.println("没有这个星期");
        break;
}
----------------------------------------------------
同时匹配多个值
switch (week){
    case 1,2,3,4,5:
        System.out.println("工作日");
        break;
    case 6,7:
        System.out.println("休息日");
        break;
    default:
        System.out.println("没有这个星期");
        break;
}
----------------------------------------------------
利用JDK12简化代码书写
switch (week) {
    case 1, 2, 3, 4, 5 -> System.out.println("工作日");
    case 6, 7 -> System.out.println("休息日");
    default -> System.out.println("没有这个星期");
}

5 循环结构：for循环

for循环结构（掌握）

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

for循环格式：

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

格式解释：

- 初始化语句：用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样

- 条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去

- 循环体语句：用于表示循环反复执行的内容，简单说就是循环反复执行的事情

- 条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去

执行流程：
①执行初始化语句
②执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续

for循环书写技巧：

确定循环的开始条件

确定循环的结束条件

确定循环要重复执行的代码

代码示例：

//1.确定循环的开始条件
//2.确定循环的结束条件
//3.确定要重复执行的代码

//需求：打印5次HelloWorld
//开始条件：1
//结束条件：5
//重复代码：打印语句

for (int i = 1; i <= 5; i++) {
    System.out.println("HelloWorld");
}

for循环练习-输出数据

需求：在控制台输出1-5和5-1的数据

示例代码：

public class ForTest01 {
    public static void main(String[] args) {
		//需求：输出数据1-5
        for(int i=1; i<=5; i++) {
			System.out.println(i);
		}
		System.out.println("--------");
		//需求：输出数据5-1
		for(int i=5; i>=1; i--) {
			System.out.println(i);
		}
    }
}

for循环练习-求和

需求：求1-5之间的数据和，并把求和结果在控制台输出

示例代码：

public class ForTest02 {
    public static void main(String[] args) {
		//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
		int sum = 0;
		//从1开始到5结束的数据，使用循环结构完成
		for(int i=1; i<=5; i++) {
			//将反复进行的事情写入循环结构内部
             // 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中
			sum = sum + i;
			/*
				sum += i;	sum = sum + i;
				第一次：sum = sum + i = 0 + 1 = 1;
				第二次：sum = sum + i = 1 + 2 = 3;
				第三次：sum = sum + i = 3 + 3 = 6;
				第四次：sum = sum + i = 6 + 4 = 10;
				第五次：sum = sum + i = 10 + 5 = 15;
			*/
		}
		//当循环执行完毕时，将最终数据打印出来
		System.out.println("1-5之间的数据和是：" + sum);
    }
}

本题要点：

- 今后遇到的需求中，如果带有求和二字，请立即联想到求和变量

- 求和变量的定义位置，必须在循环外部，如果在循环内部则计算出的数据将是错误的

for循环练习-求偶数和

需求：求1-100之间的偶数和，并把求和结果在控制台输出 }

示例代码：

public class ForTest03 {
    public static void main(String[] args) {
		//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
		int sum = 0;
		//对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同
		for(int i=1; i<=100; i++) {
			//对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数
			if(i%2 == 0) {
                //sum += i；
				sum = sum + i;
			}
		}
		//当循环执行完毕时，将最终数据打印出来
		System.out.println("1-100之间的偶数和是：" + sum);
    }
}

for循环练习-统计次数

需求：

键盘录入两个数字，表示一个范围。

统计这个范围中。

既能被3整除，又能被5整除数字有多少个？

代码示例：

//1.键盘录入两个数字，表示一个范围。
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int number1 = sc.nextInt();
System.out.println("请输入第二个整数");
int number2 = sc.nextInt();
//2.比较number1和number2找到最大值和最小值
int max = number1 > number2 ? number1 : number2;
int min = number1 < number2 ? number1 : number2;
int count = 0;
//3.循环得到这个范围之内的每一个数字
//拿着每一个数字去跟3和5进行整除，如果满足规则，表示找到了一个
for (int i = min; i <= max; i++) {
    //i 依次表示min~max这个范围之内的每一个数字
    if(i % 3 == 0 && i % 5 == 0){
        count++;
    }
}
//当循环结束之后，就表示这个范围内所有的数字都找完了
System.out.println(count);

6. 循环高级

1无限循环

for、while、do...while都有无限循环的写法。

最为常用的是while格式的。

因为无限循环是不知道循环次数的，所以用while格式的

代码示例：

while(true){
    
}

1 跳转控制语句（掌握）

跳转控制语句（break）

- 跳出循环，结束循环

跳转控制语句（continue）

- 跳过本次循环，继续下次循环

注意： continue只能在循环中进行使用！

练习1：逢7过

需求：

朋友聚会的时候可能会玩一个游戏：逢7过

游戏规则：从任意一个数字开始报数，当你要报的数字是包含7或者是7的倍数时都要说过：过

需求：使用程序在控制台打印出1-100之间的满足逢七必过规则的数据

代码示例：

public class LoopDemo4 {
    public static void main(String[] args) {
        //目标：听懂并且自己独立写出来
        //核心：
        //不报数字的条件：
        //个位是7   十位是7  7的倍数
        //三个条件只要满足一个，就不报数字

        //游戏的规则
        //1 2 3 4 5 6 过 8 9 10 11 12 13 过 15 16 过 18 19 20 过...

        //循环的开始条件：1
        //结束条件：100
        for (int i = 1; i <= 100; i++) {
            //i依次表示这个范围之内的每一个数字
            if (i % 10 == 7 || i / 10 % 10 == 7 || i % 7 == 0) {
                System.out.println("过");
                continue;
            }
            System.out.println(i);
        }

    }
}

练习2：求平方根

需求：

键盘录入一个大于等于2的整数 x ，计算并返回 x 的平方根。

结果只保留整数部分，小数部分将被舍去。

代码示例：

public class LoopDemo5 {
    public static void main(String[] args) {
        //目标：听懂思路并且自己独立写出来

        //键盘录入10
        // 1 * 1 = 1 < 10
        // 2 * 2 = 4 < 10
        // 3 * 3 = 9 < 10
        // 4 * 4 = 16 > 10
        //说明：10的平方根在3~4之间。保留整数之后：3


        //键盘录入20
        //1 * 1 = 1 < 20
        // 2 * 2 = 4 < 20
        // 3 * 3 = 9 < 20
        // 4 * 4 = 16 < 20
        // 5 * 5 = 25 > 20
        //说明：20的平方根在4~5之间，保留整数之后：4

        //键盘录入40
        //1 * 1 = 1 < 40
        // 2 * 2 = 4 < 40
        // 3 * 3 = 9 < 40
        // 4 * 4 = 16 < 40
        // 5 * 5 = 25 < 40
        // 6 * 6 = 36 < 40
        // 7 * 7 = 49 > 40
        //说明：40的平方根在6~7之间，保留整数之后：6

        //思路：
        //从1开始循环，拿着循环得到的每一个数求平方。
        //拿着结果，跟键盘录入的数字比较。
        //如果平方之后的结果 == 录入的数字    表示当前数字就是我们题目的结果
        //如果平方之后的结果 <  录入的数字    循环继续
        //如果平方之后的结果 >  录入的数字    表示前一个数字就是我们题目的结果
        //循环的开始条件：1
        //循环的结束条件：键盘录入的数字

        //1.键盘录入数字
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int number = sc.nextInt();
        //2.循环找结果
        for (int i = 1; i <= number; i++) {
            //循环体
            if (i * i == number) {
                System.out.println(number + "的平方根为" + i);
                //如果已经找到了，那么后面就不需要再运行了，循环直接停止
                break;
            }else if(i * i > number){
                System.out.println(number + "的平方根为" + (i - 1));
                //如果已经找到了，那么后面就不需要再运行了，循环直接停止
                break;
            }
        }


    }
}

练习3：求质数

需求：

键盘录入一个正整数 x ，判断该整数是否为一个质数。

代码示例：

public class LoopDemo6 {
    public static void main(String[] args) {
        //目标：听懂思路并且自己独立写出来

        //质数：只能被1和本身整除的数。
        //7 是一个质数
        //13 是一个质数
        //8 不是一个质数
        //25 不是一个质数

        //1.键盘录入一个正整数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int number = sc.nextInt();
        //2.利用循环进行判断
        //思路一：从1开始到本身number结束，在这个范围之内，有多少个数字能被键盘录入的number整除
        //如果只有两个，那么表示number是一个质数。

        //思路二：从2开始到number-1结束，在这个范围之内，有多少个数字能被number整除
        //如果没有数字，那么表示number是一个质数。

        //思路二循环的开始条件：2
        //循环的结束条件：number-1
        int count = 0;
        for (int i = 2; i < number; i++) {
            //i依次表示，2~ number-1 这个范围之内的每一个数字
            //要求的是，在这个范围之内，有多少个数字能被number整除
            if(number % i == 0){
                count++;
            }
        }
        //当循环结束之后，表示我们已经找到了，在2 ~ number-1 这个范围之内，有多少个数字能被number整除
        if(count == 0){
            System.out.println(number + "是一个质数");
        }else{
            System.out.println(number + "不是一个质数");
        }
    }
}

6. Random

Random产生随机数（掌握）

概述：

- Random类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能

- - API后续课程详细讲解，现在可以简单理解为Java已经写好的代码

使用步骤：

1. 导入包
  import java.util.Random;
2. 创建对象
  Random r = new Random();
3. 产生随机数
  int num = r.nextInt(10);
  解释： 10代表的是一个范围，如果括号写10，产生的随机数就是0-9，括号写20，参数的随机数则是0-19
  扩展点：如果第三步没有指定范围，那么会在int的取值范围中获取一个随机数。

示例代码：

import java.util.Random;
public class RandomDemo {
	public static void main(String[] args) {
		//创建对象
		Random r = new Random();
		//用循环获取10个随机数
		for(int i=0; i<10; i++) {
			//获取随机数
			int number = r.nextInt(10);
			System.out.println("number:" + number);
		}
		//需求：获取一个1-100之间的随机数
		int x = r.nextInt(100) + 1;
		System.out.println(x);
	}
}

Random练习-猜数字小游戏

需求：
程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
当猜错的时候根据不同情况给出相应的提示
A. 如果猜的数字比真实数字大，提示你猜的数据大了
B. 如果猜的数字比真实数字小，提示你猜的数据小了
C. 如果猜的数字与真实数字相等，提示恭喜你猜中了

示例代码：

import java.util.Random;
import java.util.Scanner;

public class RandomTest {
	public static void main(String[] args) {
		//要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
		Random r = new Random();
		int number = r.nextInt(100) + 1;
		
		while(true) {
			//使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
			Scanner sc = new Scanner(System.in);
			
			System.out.println("请输入你要猜的数字：");
			int guessNumber = sc.nextInt();
			
			//比较输入的数字和系统产生的数据，需要使用分支语句。
             //这里使用if..else..if..格式，根据不同情况进行猜测结果显示
			if(guessNumber > number) {
				System.out.println("你猜的数字" + guessNumber + "大了");
			} else if(guessNumber < number) {
				System.out.println("你猜的数字" + guessNumber + "小了");
			} else {
				System.out.println("恭喜你猜中了");
				break;
			}
		}
		
	}
}

猜数字小游戏扩展1:（掌握）

生成随机数的代码不能写在循环里面。

否则，每猜一次，都会产生一个新的随机数。

猜数字小游戏扩展2:（了解）

很多游戏中，都会有保底机制。

假设，在猜数字小游戏中，三次猜不中就触发保底机制

代码示例：

import java.util.Random;
import java.util.Scanner;

public class RandomDemo2 {
    public static void main(String[] args) {
        //分析：
        //1.生成一个1-100之间的随机数字
        Random r = new Random();
        //扩展1：生成随机数的代码，不能写在循环里面，否则每一次都会生成一个新的随机数
        //扩展2：保底机制3次
        
        //定义变量记录猜的次数
        int count = 0;
        int number = r.nextInt(100) + 1;
        System.out.println(number);
        
        //2.使用键盘录入的方式去猜
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入你要猜的数字");
            int guessNumber = sc.nextInt();
            
            
            //每猜一次，count就++
            count++;
            //判断当前是第几次
            //如果达到了保底，直接提示猜中了
            if(count == 3){
                System.out.println("猜中了");
                break;
            }
           
            
            //3.拿着键盘输入的数字 跟 随机数比较判断
            if (guessNumber > number) {
                System.out.println("大了");
            } else if (guessNumber < number) {
                System.out.println("小了");
            } else {
                System.out.println("猜中了");
                break;
            }
        }

    }
}

7.数组

3.1什么是数组

数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。

3.2数组定义格式

3.2.1第一种（常用）

数据类型[] 数组名

示例：

int[] arr;        
double[] arr;      
char[] arr;

3.2.2第二种

数据类型数组名[]

示例：

int arr[];
double arr[];
char arr[];

3.3数组静态初始化

3.3.1什么是静态初始化

在创建数组时，直接将元素确定

3.3.2静态初始化格式

完整版格式

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
举例：
int[] arr = new int[]{1,2,3,4};

简化版格式

数据类型[] 数组名 = {元素1,元素2,...};
举例：
int[] arr = {1,2,3,4};

3.3.3静态初始化格式详解

等号左边：

- int:数组的数据类型

- []:代表这是一个数组

- arr:代表数组的名称

等号右边：

- new:为数组开辟内存空间

- int:数组的数据类型

- []:代表这是一个数组

- {}:表示数组里面存储的所有元素

3.4数组元素访问

3.4.1什么是索引

每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。

这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

3.4.2访问数组元素格式

数组名[索引];

3.4.3索引的作用：

利用索引可以获取数组中的元素

利用索引可以把数据存储到数组中

3.4.4示例代码

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];

        //输出数组名
        System.out.println(arr); //[I@880ec60

        //输出数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

练习1：数组的遍历

遍历：把数组里面所有的元素都一一获取出来

代码示例：

 //1.定义数组
        int[] arr = {1,2,3,4,5};
        //2.遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("---------------快速生成最终代码--------------------");
        //数组名.fori

练习2：累加求和

需求：

定义一个数组，存储1,2,3,4,5

遍历数组得到每一个元素，求数组里面所有的数据和

代码示例：

//1.定义数组
int[] arr = {1,2,3,4,5};

//2.定义一个累加变量sum
int sum = 0;

//3.遍历数组得到数组里面的每一个元素
for (int i = 0; i < arr.length; i++) {
    //i 依次表示数组中的每一个索引
    //arr[i] 依次表示数组中的每一个元素
    //System.out.println(arr[i]);
    sum = sum + arr[i];
}

//4.当循环结束之后，表示所有的数据都已经累加成功
System.out.println(sum);

练习3：统计个数

需求：

定义一个数组，存储1,2,3,4,5,6,7,8,9,10
遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字

代码示例：

//1.定义数组1,2,3,4,5,6,7,8,9,10
int[] arr = {1,2,3,4,5,6,7,8,9,10};
//2.定义统计变量
int count = 0;
//3.遍历数组得到每一个元素
for (int i = 0; i < arr.length; i++) {
    //3.判断当前元素是否满足
    if(arr[i] % 3 == 0){
        count++;
    }
}
//4.循环结束之后，就表示数组里面所有的元素都已经统计完毕
System.out.println(count);

练习4：变化数据

需求：

定义一个数组，存储1,2,3,4,5,6,7,8,9,10

遍历数组得到每一个元素。

要求：

1，如果是奇数，则将当前数字扩大两倍

2，如果是偶数，则将当前数字变成二分之一

代码示例：

public class ArrDemo7 {
    public static void main(String[] args) {
        /*
        定义一个数组，存储1,2,3,4,5,6,7,8,9,10
        遍历数组得到每一个元素。
        要求：
        1，如果是奇数，则将当前数字扩大两倍
        2，如果是偶数，则将当前数字变成二分之一
        */
        // 1  2  3  4  5  6  7   8  9   10
        // 2  1  6  2  10 3  14  4  18  5
        //1.定义数组
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        //2.遍历数组得到每一个元素
        for (int i = 0; i < arr.length; i++) {
            //3.判断每一个元素是奇数还是偶数
            if(arr[i] % 2 == 0){
                // 偶数，则将当前数字变成二分之一
                arr[i] = arr[i] / 2;
            }else{
                // 奇数，则将当前数字扩大两倍
                arr[i] = arr[i] * 2;
            }
        }
        //3.当循环结束之后，数组里面所有的数据都已经改变完毕
        //再遍历验证一下即可
        //一个循环只干一件事情。
        //如果想要遍历，再写一个循环即可
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

3.5数组动态初始化

3.5.1什么是动态初始化

数组动态初始化就是只给定数组的长度，由系统给出默认初始化值。

3.5.2动态初始化格式

数据类型[] 数组名 = new 数据类型[数组长度];

int[] arr = new int[3];

3.5.3动态初始化格式详解

等号左边：

- int:数组的数据类型

- []:代表这是一个数组

- arr:代表数组的名称

等号右边：

- new:为数组开辟内存空间

- int:数组的数据类型

- []:代表这是一个数组

- 5:代表数组的长度

3.6数组操作的两个常见小问题

3.6.1索引越界异常

出现原因

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr[3]);
    }
}

数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。
程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

解决方案
将错误的索引修改为正确的索引范围即可！

3.6.2空指针异常

出现原因

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];

        //把null赋值给数组
        arr = null;
        System.out.println(arr[0]);
    }
}

arr = null 这行代码，意味着变量arr将不会再保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

解决方案
给数组一个真正的堆内存空间引用即可！

3.7数组的练习

3.7.1数组最值

最大值获取：从数组的所有元素中找出最大值。

实现思路：

- 定义变量，保存数组0索引上的元素

- 遍历数组，获取出数组中的每个元素

- 将遍历到的元素和保存数组0索引上值的变量进行比较

- 如果数组元素的值大于了变量的值，变量记录住新的值

- 数组循环遍历结束，变量保存的就是数组中的最大值

代码实现：

//扩展1：max的值能不能写0？最好不要写0。
//      一般都会赋值数组中的某个元素

//扩展2：循环从0开始，或者循环从1开始，对结果有没有影响？
//       没有
//      如果循环从0开始，那么多了一次，自己跟自己比的过程。
//      对结果没有任何影响，只不过多循环了一次而已。


//1.定义数组存储元素
int[] arr = {33,5,22,44,55};
//2.定义一个变量max
int max = arr[0];
//3.遍历数组
for (int i = 1; i < arr.length; i++) {
    // i 索引  arr[i] 元素
    if(arr[i] > max){
        max = arr[i];
    }
}
//4.当循环结束之后，max记录的就是最大值
System.out.println(max);

3.7.2遍历数组统计个数

需求：生成10个1~100之间的随机数存入数组

1）求出所有数据的和

2）求所有数据的平均数

3）统计有多少个数据比平均值小

代码示例：

import java.util.Random;

public class ArrDemo13 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = new int[10];
        //2.生成10个随机数存入数组
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            //生成随机数
            int number = r.nextInt(100) + 1;
            //把生成的随机数存入数组
            arr[i] = number;
        }
        //3.求和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            //累加
            sum = sum + arr[i];
        }
        //4.平均数
        int avg = sum / arr.length;
        //5.统计
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] < avg){
                count++;
            }
        }
        //6.循环结束之后打印count
        System.out.println(count);
    }
}

练习数组

3.7.3交换数组中的数据

本题的前置练习1：

交换两个变量的值

int a = 10;
int b = 20;

//把a原本的值做了临时存储
int c = a;

//把b的值交给了a。
a = b;

//把c的值交给b
b = c;

System.out.println(a);
System.out.println(b);

本题的前置练习2：

把0索引的元素跟最后一个元素进行交换

int[] arr = {1,2,3,4,5};
//第一个和最后一个交换
// 5 2 3 4 1

int temp = arr[0];
arr[0] = arr[4];
arr[4] = temp;

for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

需求：

需求：定义一个数组，存入1,2,3,4,5。交换首尾索引对应的元素。

交换前：1,2,3,4,5

交换后：5,4,3,2,1

代码示例：

//1.定义数组
int[] arr = {1, 2, 3, 4, 5};
//2.循环交换数据
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
    //交换i和j指向的元素即可
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
//3.遍历数组
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

3.7.4打乱数组中的数据

需求：

定义一个数组，存入1~5。要求打乱数组中所有数据的顺序。

代码示例：

import java.util.Random;

public class ArrDemo18 {
    public static void main(String[] args) {
        //需求：定义一个数组，存入1~5。要求打乱数组中所有数据的顺序。

        //核心：
        //从0索引开始进行遍历
        //拿着遍历到的数据，跟数组中的随机索引处，进行位置交换


        //1.定义数组
        int[] arr = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
        //2.利用循环交换每一个索引上对应的元素
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            //生成一个新的随机索引
            int randomIndex = r.nextInt(arr.length);
            //拿着随机索引对应的元素 跟 i 对应的元素进行交换
            int temp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = temp;
        }
        //当循环结束之后，就表示数组里面的每一个元素，都跟随机索引进行了交换
        //当循环结束之后，此时就好比已经打乱了数组中的数据。
        //3.遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

8 方法概述

1 方法的概念

方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

注意：

- 方法必须先创建才可以使用，该过程成为方法定义

- 方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用

2. 方法的定义和调用

2.1 无参数方法定义和调用

定义格式：

public static void 方法名 (   ) {
	// 方法体;
}

范例：

public static void method (    ) {
	// 方法体;
}

调用格式：

方法名();

范例：

method();

注意：
方法必须先定义，后调用，否则程序将报错

2.2 方法调用过程图解

总结：每个方法在被调用执行的时候，都会进入栈内存，并且拥有自己独立的内存空间，方法内部代码调用完毕之后，会从栈内存中弹栈消失。

2.3 无参数方法的练习

需求：设计一个方法用于打印两个数中的较大数

思路：

- ①定义一个方法，用于打印两个数字中的较大数，例如getMax()

- ②方法中定义两个变量，用于保存两个数字

- ③使用分支语句分两种情况对两个数字的大小关系进行处理

- ④在main()方法中调用定义好的方法

代码：

public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法
        getMax();
    }

    //定义一个方法，用于打印两个数字中的较大数，例如getMax()
    public static void getMax() {
        //方法中定义两个变量，用于保存两个数字
        int a = 10;
        int b = 20;

        //使用分支语句分两种情况对两个数字的大小关系进行处理
        if(a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }
}

3. 带参数方法定义和调用

3.1 带参数方法定义和调用

定义格式：
参数：由数据类型和变量名组成 - 数据类型变量名
参数范例：int a

public static void 方法名 (参数1) {
	方法体;
}

public static void 方法名 (参数1, 参数2, 参数3...) {
	方法体;
}

范例：

public static void isEvenNumber(int number){
    ...
}
public static void getMax(int num1, int num2){
    ...
}

- 注意：

方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错

方法定义时，多个参数之间使用逗号( ，)分隔

调用格式：

方法名(参数)；

方法名(参数1,参数2);

范例：

isEvenNumber(10);

getMax(10,20);

- 方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错

3.2 形参和实参

形参：方法定义中的参数

等同于变量定义格式，例如：int number

实参：方法调用中的参数

等同于使用变量或常量，例如： 10 number

3.3 带参数方法练习

需求：设计一个方法用于打印两个数中的较大数，数据来自于方法参数 }

思路：

- ①定义一个方法，用于打印两个数字中的较大数，例如getMax()

- ②为方法定义两个参数，用于接收两个数字

- ③使用分支语句分两种情况对两个数字的大小关系进行处理

- ④在main()方法中调用定义好的方法（使用常量）

- ⑤在main()方法中调用定义好的方法（使用变量）

代码：

public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法（使用常量）
        getMax(10,20);
        //调用方法的时候，人家要几个，你就给几个，人家要什么类型的，你就给什么类型的
        //getMax(30);
        //getMax(10.0,20.0);

        //在main()方法中调用定义好的方法（使用变量）
        int a = 10;
        int b = 20;
        getMax(a, b);
    }

    //定义一个方法，用于打印两个数字中的较大数，例如getMax()
    //为方法定义两个参数，用于接收两个数字
    public static void getMax(int a, int b) {
        //使用分支语句分两种情况对两个数字的大小关系进行处理
        if(a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }
}

4. 带返回值方法的定义和调用

4.1 带返回值方法定义和调用

定义格式

public static 数据类型 方法名 ( 参数 ) { 
	return 数据 ;
}

范例

public static boolean isEvenNumber( int number ) {           
	return true ;
}
public static int getMax( int a, int b ) {
	return  100 ;
}

- 注意：

- - 方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错

调用格式

方法名 ( 参数 ) ;
数据类型 变量名 = 方法名 ( 参数 ) ;

范例

isEvenNumber ( 5 ) ;
boolean  flag =  isEvenNumber ( 5 );

- 注意：

- - 方法的返回值通常会使用变量接收，否则该返回值将无意义

4.2 带返回值方法练习1

需求：设计一个方法可以获取两个数的较大值，数据来自于参数

思路：

- ①定义一个方法，用于获取两个数字中的较大数

- ②使用分支语句分两种情况对两个数字的大小关系进行处理

- ③根据题设分别设置两种情况下对应的返回结果

- ④在main()方法中调用定义好的方法并使用变量保存

- ⑤在main()方法中调用定义好的方法并直接打印结果

代码：

public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法并使用变量保存
        int result = getMax(10,20);
        System.out.println(result);

        //在main()方法中调用定义好的方法并直接打印结果
        System.out.println(getMax(10,20));
    }

    //定义一个方法，用于获取两个数字中的较大数
    public static int getMax(int a, int b) {
        //使用分支语句分两种情况对两个数字的大小关系进行处理
        //根据题设分别设置两种情况下对应的返回结果
        if(a > b) {
            return a;
        } else {
            return b;
        }
    }
}

4.3 带返回值方法练习2

需求：

定义一个方法，求一家商场每个季度的营业额。根据方法结果再计算出全年营业额。

代码示例：

package com.itheima.demo;

public class MethodDemo9 {
    public static void main(String[] args) {
        /*需求：定义一个方法，求一家商场每个季度的营业额。
        根据方法结果再计算出全年营业额。*/
        int sum1 = getSum(10, 20, 30);
        int sum2 = getSum(10, 20, 30);
        int sum3 = getSum(10, 20, 30);
        int sum4 = getSum(10, 20, 30);

        int sum = sum1 + sum2 + sum3 + sum4;
        System.out.println(sum);

    }

    //心得：
    //1.我要干嘛？  决定了方法体   每个季度的营业额
    //2.我干这件事情，需要什么才能完成？ 决定了形参 需要三个月的营业额 a b c
    //3.我干完这件事情，看调用处是否需要使用方法的结果。   决定了返回值
    //如果需要使用，那么必须返回
    //如果不需要使用，可以返回也可以不返回
    public static int getSum(int month1,int month2,int month3){
        int sum = month1 + month2 + month3;
        //因为方法的调用处，需要继续使用这个结果
        //所以我们必须要把sum返回
        return sum;
    }
}

4.4 带返回值方法练习3

需求：

键盘录入两个圆的半径（整数），比较两个圆的面积。

代码示例：

import java.util.Scanner;

public class MethodDemo10 {
    public static void main(String[] args) {
        //需求：键盘录入两个圆的半径（整数），比较两个圆的面积。
        //键盘录入圆的半径
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入圆的半径");
        int radii1 = sc.nextInt();

        System.out.println("请输入第二个圆的半径");
        int radii2 = sc.nextInt();
        double area1 = getArea(radii1);
        double area2 = getArea(radii2);
        if(area1 > area2){
            System.out.println("第一个圆更大");
        }else{
            System.out.println("第二个圆更大");
        }
    }

    //心得：
    //1.我要干嘛？   求圆的面积
    //2.我干这件事情，需要什么才能完成？        半径
    //3.方法的调用处，是否需要继续使用方法的结果    要比较
    public static double getArea(int radii) {
        double area = 3.14 * radii * radii;
        return area;
    }
}

5. 方法的注意事项

5.1 方法的注意事项

方法不能嵌套定义

- 示例代码：

public class MethodDemo {
    public static void main(String[] args) {

    }

    public static void methodOne() {
		public static void methodTwo() {
       		// 这里会引发编译错误!!!
    	}
    }
}

void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

- 示例代码：

public class MethodDemo {
    public static void main(String[] args) {

    }
    public static void methodTwo() {
        //return 100; 编译错误，因为没有具体返回值类型
        return;	
        //System.out.println(100); return语句后面不能跟数据或代码
    }
}

5.2 方法的通用格式

格式：

public static 返回值类型 方法名(参数) {
   方法体; 
   return 数据 ;
}

解释：

- public static 修饰符，目前先记住这个格式
  返回值类型方法操作完毕之后返回的数据的数据类型
  如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
  方法名调用方法时候使用的标识
  参数由数据类型和变量名组成，多个参数之间用逗号隔开
  方法体完成功能的代码块
  return 如果方法操作完毕，有数据返回，用于把数据返回给调用者

定义方法时，要做到两个明确

- 明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型

- 明确参数：主要是明确参数的类型和数量

调用方法时的注意：

- void类型的方法，直接调用即可

- 非void类型的方法，推荐用变量接收调用

6. 方法重载

6.1 方法重载

方法重载概念
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载

- 多个方法在同一个类中

- 多个方法具有相同的方法名

- 多个方法的参数不相同，类型不同或者数量不同

注意：

- 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式

- 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

正确范例：

public class MethodDemo {
	public static void fn(int a) {
    	//方法体
    }
    public static int fn(double a) {
    	//方法体
    }
}

public class MethodDemo {
	public static float fn(int a) {
    	//方法体
    }
    public static int fn(int a , int b) {
    	//方法体
    }
}

错误范例：

public class MethodDemo {
	public static void fn(int a) {
    	//方法体
    }
    public static int fn(int a) { 	/*错误原因：重载与返回值无关*/
    	//方法体
    }
}

public class MethodDemo01 {
    public static void fn(int a) {
        //方法体
    }
} 
public class MethodDemo02 {
    public static int fn(double a) { /*错误原因：这是两个类的两个fn方法*/
        //方法体
    }
}

6.2 方法重载练习

需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）

思路：

- ①定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数

- ②定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数

- ③定义所有的重载方法，两个byte类型与两个short类型参数

- ④完成方法的调用，测试运行结果

代码：

public class MethodTest {
    public static void main(String[] args) {
        //调用方法
        System.out.println(compare(10, 20));
        System.out.println(compare((byte) 10, (byte) 20));
        System.out.println(compare((short) 10, (short) 20));
        System.out.println(compare(10L, 20L));
    }

    //int
    public static boolean compare(int a, int b) {
        System.out.println("int");
        return a == b;
    }

    //byte
    public static boolean compare(byte a, byte b) {
        System.out.println("byte");
        return a == b;
    }

    //short
    public static boolean compare(short a, short b) {
        System.out.println("short");
        return a == b;
    }

    //long
    public static boolean compare(long a, long b) {
        System.out.println("long");
        return a == b;
    }

}

7. 方法的参数传递

7.1 方法参数传递基本类型

测试代码：

public class ArgsDemo01 {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前：" + number);
        change(number);
        System.out.println("调用change方法后：" + number);
    }

    public static void change(int number) {
        number = 200;
    }
}

结论：

- 基本数据类型的参数，形式参数的改变，不影响实际参数

结论依据：

- 每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失

7.2 方法参数传递引用类型

测试代码：

public class ArgsDemo02 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30};
        System.out.println("调用change方法前：" + arr[1]);
        change(arr);
        System.out.println("调用change方法后：" + arr[1]);
    }

    public static void change(int[] arr) {
        arr[1] = 200;
    }
}

结论：

- 对于引用类型的参数，形式参数的改变，影响实际参数的值

结论依据：

- 引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果

7.3 数组遍历

需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]

思路：

- ①因为要求结果在一行上输出，所以这里需要在学习一个新的输出语句System.out.print(“内容”);
  System.out.println(“内容”); 输出内容并换行
  System.out.print(“内容”); 输出内容不换行
  System.out.println(); 起到换行的作用

- ②定义一个数组，用静态初始化完成数组元素初始化

- ③定义一个方法，用数组遍历通用格式对数组进行遍历

- ④用新的输出语句修改遍历操作

- ⑤调用遍历方法

代码：

public class Test1 {
    public static void main(String[] args) {
      /*  //先打印数据，再进行换行
        System.out.println("aaa");
        //只打印不换行
        System.out.print("bbb");
        System.out.print("ddd");
        //不打印任何内容，只换行
        System.out.println();
        System.out.print("cc");*/
        //设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
        int[] arr = {1,2,3,4,5};
        printArr(arr);
    }
    //1.我要遍历数组
    //2.需要什么？  数组
    //3.调用处是否需要使用方法的结果。
    public static void printArr(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length - 1){
                System.out.println(arr[i] + "]");
            }else{
                System.out.print(arr[i] + ", ");
            }
        }
    }
}

7.4 数组最大值

需求：设计一个方法用于获取数组中元素的最大值

思路：

- ①定义一个数组，用静态初始化完成数组元素初始化

- ②定义一个方法，用来获取数组中的最大值，最值的认知和讲解我们在数组中已经讲解过了

- ③调用获取最大值方法，用变量接收返回结果

- ④把结果输出在控制台

代码：

public class MethodTest02 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素初始化
        int[] arr = {12, 45, 98, 73, 60};

        //调用获取最大值方法，用变量接收返回结果
        int number = getMax(arr);

        //把结果输出在控制台
        System.out.println("number:" + number);
    }

    //定义一个方法，用来获取数组中的最大值
    /*
        两个明确：
            返回值类型：int
            参数：int[] arr
     */
    public static int getMax(int[] arr) {
        int max = arr[0];

        for(int x=1; x<arr.length; x++) {
            if(arr[x] > max) {
                max = arr[x];
            }
        }
        return max;
    }
}

7.5 判断是否存在

需求：

定义一个方法判断数组中的某一个数是否存在，将结果返回给调用处

代码示例：

public class Test3 {
  public static void main(String[] args) {
      //定义一个方法判断数组中的某一个数是否存在，将结果返回给调用处

      int[] arr = {1,2,3,4,5};
      boolean result = contains(arr, 3);
      System.out.println(result);
  }

  //1. 我要干嘛？判断数组中的某一个数是否存在
  //2. 需要什么？数组 数字
  //3. 调用处是否需要继续使用？返回
  //判断number在arr中是否存在
  public static boolean contains(int[] arr, int number) {//1 2 3 4 5    6
      //遍历arr得到每一个元素
      for (int i = 0; i < arr.length; i++) {
          //拿着每一个元素跟number比较
          if(arr[i] == number){
              //如果相等，表示存在
              return true;
          }
      }
      //当循环结束之后，如果还不能返回true，表示数组中所有数据都不相等
      //可以返回false
      return false;
  }
}

7.6 获取索引

需求：

定义一个方法获取数字，在数组中的索引位置，将结果返回给调用处，如果有重复的，只要获取第一个即可。

代码示例：

package com.itheima.demo;

public class Test4 {
    public static void main(String[] args) {
        //定义一个方法获取数字，在数组中的索引位置，将结果返回给调用处
        //如果有重复的，只要获取第一个即可

        int[] arr = {1,2,3,4,5};
        int index = contains(arr, 3);
        System.out.println(index);
    }

    //1. 我要干嘛？判断数组中的某一个数是否存在
    //2. 需要什么？数组 数字
    //3. 调用处是否需要继续使用？返回
    //获取number在arr中的位置
    public static int contains(int[] arr, int number) {
        //遍历arr得到每一个元素
        for (int i = 0; i < arr.length; i++) {
            //拿着每一个元素跟number比较
            if(arr[i] == number){
                //如果相等，表示找到了
                return i;
            }
        }
        //当循环结束之后，如果还不能返回索引，表示数组中不存在该数据
        //可以返回-1
        return -1;
    }
}

7.7 复制数组

需求：

定义一个方法copyOfRange(int[] arr,int from, int to)

功能：

将数组arr中从索引from（包含from）开始。

到索引to结束（不包含to）的元素复制到新数组中，

将新数组返回。

代码示例：

package com.itheima.test;

public class Test4 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int[] newArr = copyOfRange(arr, 3, 9);// [3索引~ 9索引)

        for (int i = 0; i < newArr.length; i++) {
            System.out.print(newArr[i] + " ");
        }
    }
    //如果方法要返回多个值，那么只能以数组的形式进行返回
    //把arr数组中，从from开始，到to之间的数据进行返回
    //{1,2,3,4,5,6,7,8,9,10}

    //技巧：(伪造索引)
    //在代码中，如果没有一个变量能表示当前的索引
    //就自己新建一个变量表示索引

    public static int[] copyOfRange(int[] arr, int from,int to){
        //1.新建一个新的数组
        int[] newArr = new int[to - from];

        int index = 0;
        //2.获取老数组中，from到to之间所有的元素
        for (int i = from; i < to; i++) {
            //System.out.println(arr[i]);
            //数组名[索引] = 数据值;
            //这是我想要的效果：在赋值的时候从newArr的0索引开始，依次往后赋值
            newArr[index] = arr[i];
            index++;
        }

        //当循环结束之后，表示新数组中已经存满元素了
        return newArr;
    }
}

9. 类和对象

1.1 类和对象的理解

客观存在的事物皆为对象，所以我们也常常说万物皆对象。

- 类的理解

- - 类是对现实生活中一类具有共同属性和行为的事物的抽象

- - 类是对象的数据类型，类是具有相同属性和行为的一组对象的集合

- - 简单理解：类就是对现实事物的一种描述

- 类的组成

- - 属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）

- - 行为：指事物能执行的操作，例如：手机事物（打电话，发短信）

类和对象的关系

- 类：类是对现实生活中一类具有共同属性和行为的事物的抽象

- 对象：是能够看得到摸的着的真实存在的实体

- 简单理解：类是对事物的一种描述，对象则为具体存在的事物

1.2 类的定义

类的组成是由属性和行为两部分组成

属性：在类中通过成员变量来体现（类中方法外的变量）

行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

类的定义步骤：

①定义类

②编写类的成员变量

③编写类的成员方法

public class 类名 {
	// 成员变量
	变量1的数据类型 变量1；
	变量2的数据类型 变量2;
	…
	// 成员方法
	方法1;
	方法2;	
}

示例代码：

/*
    手机类：
        类名：
        手机(Phone)

        成员变量：
        品牌(brand)
        价格(price)

        成员方法：
        打电话(call)
        发短信(sendMessage)
 */
public class Phone {
    //成员变量
    String brand;
    int price;

    //成员方法
    public void call() {
        System.out.println("打电话");
    }

    public void sendMessage() {
        System.out.println("发短信");
    }
}

1.3 对象的使用

创建对象的格式：

- 类名对象名 = new 类名();

调用成员的格式：

- 对象名.成员变量

- 对象名.成员方法();

示例代码

/*
    创建对象
        格式：类名 对象名 = new 类名();
        范例：Phone p = new Phone();

    使用对象
        1：使用成员变量
            格式：对象名.变量名
            范例：p.brand
        2：使用成员方法
            格式：对象名.方法名()
            范例：p.call()
 */
public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();

        //使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);

        p.brand = "小米";
        p.price = 2999;

        System.out.println(p.brand);
        System.out.println(p.price);

        //使用成员方法
        p.call();
        p.sendMessage();
    }
}

1.4 学生对象-练习

需求：首先定义一个学生类，然后定义一个学生测试类，在学生测试类中通过对象完成成员变量和成员方法的使用

分析：

- 成员变量：姓名，年龄…

- 成员方法：学习，做作业…

示例代码：

![1](C:\TeachRes\Java2019\JavaSe01\day07\4-笔记\笔记图片资源包\1.png)class Student {
    //成员变量
    String name;
    int age;

    //成员方法
    public void study() {
        System.out.println("好好学习，天天向上");
    }

    public void doHomework() {
        System.out.println("键盘敲烂，月薪过万");
    }
}
/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //使用对象
        System.out.println(s.name + "," + s.age);

        s.name = "林青霞";
        s.age = 30;

        System.out.println(s.name + "," + s.age);

        s.study();
        s.doHomework();
    }
}

2. 对象内存图

2.1 单个对象内存图

成员变量使用过程

成员方法调用过程

2.2 多个对象内存图

成员变量使用过程

成员方法调用过程

总结：
多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的一份

2.3 多个对象指向相同内存图

总结
当多个对象的引用指向同一个内存空间（变量所记录的地址值是一样的）
只要有任何一个对象修改了内存中的数据，随后，无论使用哪一个对象进行数据获取，都是修改后的数据。

3. 成员变量和局部变量

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

类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）

内存中位置不同：成员变量（堆内存）局部变量（栈内存）

生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，醉着方法的调用完毕而消失）

初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

4. 封装

4.1 private关键字

private是一个修饰符，可以用来修饰成员（成员变量，成员方法）

被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作

- 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰

- 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

示例代码：

/*
    学生类
 */
class Student {
    //成员变量
    String name;
    private int age;

    //提供get/set方法
    public void setAge(int a) {
        if(a<0 || a>120) {
            System.out.println("你给的年龄有误");
        } else {
            age = a;
        }
    }

    public int getAge() {
        return age;
    }

    //成员方法
    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        //给成员变量赋值
        s.name = "林青霞";
        s.setAge(30);
        //调用show方法
        s.show();
    }
}

4.2 private的使用

需求：定义标准的学生类，要求name和age使用private修饰，并提供set和get方法以及便于显示数据的show方法，测试类中创建对象并使用，最终控制台输出林青霞，30

示例代码：

/*
    学生类
 */
class Student {
    //成员变量
    private String name;
    private int age;

    //get/set方法
    public void setName(String n) {
        name = n;
    }

    public String getName() {
        return name;
    }

    public void setAge(int a) {
        age = a;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //使用set方法给成员变量赋值
        s.setName("林青霞");
        s.setAge(30);

        s.show();

        //使用get方法获取成员变量的值
        System.out.println(s.getName() + "---" + s.getAge());
        System.out.println(s.getName() + "," + s.getAge());

    }
}

4.3 this关键字

this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）

- 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量

- 方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

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

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

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

4.4 this内存原理

this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象

示例代码：

public class StudentDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("林青霞");
        Student s2 = new Student();
        s2.setName("张曼玉");
    }
}

图解：

4.5 封装思想

封装概述
是面向对象三大特征之一（封装，继承，多态）
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的

封装原则
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
成员变量private，提供对应的getXxx()/setXxx()方法

封装好处
通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性

5. 构造方法

5.1 构造方法概述

构造方法是一种特殊的方法

作用：创建对象 Student stu = new Student();

格式：
public class 类名{
修饰符类名( 参数 ) {
}
}

功能：主要是完成对象数据的初始化

示例代码：

class Student {
    private String name;
    private int age;

    //构造方法
    public Student() {
        System.out.println("无参构造方法");
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        s.show();
    }
}

5.2 构造方法的注意事项

构造方法的创建

如果没有定义构造方法，系统将给出一个默认的无参数构造方法
如果定义了构造方法，系统将不再提供默认的构造方法

构造方法的重载

如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法

推荐的使用方式

无论是否使用，都手工书写无参数构造方法

重要功能！

可以使用带参构造，为成员变量进行初始化

示例代码

/*
    学生类
 */
class Student {
    private String name;
    private int age;

    public Student() {}

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

    public Student(int age) {
        this.age = age;
    }

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

    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student();
        s1.show();

        //public Student(String name)
        Student s2 = new Student("林青霞");
        s2.show();

        //public Student(int age)
        Student s3 = new Student(30);
        s3.show();

        //public Student(String name,int age)
        Student s4 = new Student("林青霞",30);
        s4.show();
    }
}

5.3 标准类制作

①类名需要见名知意

②成员变量使用private修饰

③提供至少两个构造方法

无参构造方法

带全部参数的构造方法

④成员方法

提供每一个成员变量对应的setXxx()/getXxx()

如果还有其他行为，也需要写上

6.练习1-定义学生类

需求：

定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值，并通过show方法展示数据。

示例代码：

class Student {
    //成员变量
    private String name;
    private int age;

    //构造方法
    public Student() {
    }

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

    //成员方法
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    创建对象并为其成员变量赋值的两种方式
        1:无参构造方法创建对象后使用setXxx()赋值
        2:使用带参构造方法直接创建带有属性值的对象
*/
public class StudentDemo {
    public static void main(String[] args) {
        //无参构造方法创建对象后使用setXxx()赋值
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        s1.show();

        //使用带参构造方法直接创建带有属性值的对象
        Student s2 = new Student("林青霞",30);
        s2.show();
    }
}

7.练习2-创建对象并添加到数组

需求：

定义一个标准的javabean类
Student学生类
属性：name，age
在测试类中，创建两个学生对象并添加到数组中。

代码示例：

public class Test {
    public static void main(String[] args) {
        //需求：
        //定义一个标准的javabean类
        //Student学生类
        //属性：name，age
        //在测试类中，创建两个学生对象
        Student s1 = new Student();
        s1.setName("zhangsan");
        s1.setAge(23);

        Student s2 = new Student("lisi", 24);

        //创建一个长度为2的数组，用来存储学生对象
        Student[] arr = new Student[2];

        //把学生对象添加到数组当中
        arr[0] = s1;
        arr[1] = s2;

        //遍历数组，打印两个学生对象的所有信息
        for (int i = 0; i < arr.length; i++) {
            //i 索引   arr[i] 元素（学生对象）
            Student stu = arr[i];
            System.out.println(stu.getName() + ", " + stu.getAge());
        }

    }
}


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

    //空参构造
    //带全部参数的构造
    //针对于每一个私有化的成员变量都要提供对有的get和set方法
    public Student() {
    }

    public Student(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;
    }
}

8.练习3-修改年龄

需求：

定义javabean类，要求如下：

学生类（属性：姓名、年龄）

在测试类中，创建5个学生对象并添加到数组中

再遍历数组，如果学生的年龄小于18岁，那么就在原有基础上+2岁

最后遍历数组

代码示例：

public class Test {
    public static void main(String[] args) {
        //1.需求：
        //定义javabean类(Student)
        //属性：姓名，年龄
        //2.定义五个学生对象，
        Student s1 = new Student("zhangsan",23);
        Student s2 = new Student("lisi",15);
        Student s3 = new Student("wangwu",17);
        Student s4 = new Student("zhaoliu",21);
        Student s5 = new Student("qianqi",22);
        //3.添加到数组当中
        Student[] arr = new Student[5];
        arr[0] = s1;
        arr[1] = s2;
        arr[2] = s3;
        arr[3] = s4;
        arr[4] = s5;
        //4.如果学生的年龄小于18岁，那么就在原有的基础上+2岁。
        for (int i = 0; i < arr.length; i++) {
            //i 索引 arr[i] 元素(学生对象)
            Student stu = arr[i];
            int age = stu.getAge();
            if(age < 18){
                //如果小于18，我们就要在原有的基础上+2
                //age + 2;
                stu.setAge(age + 2);
            }
        }
        //5.遍历数组
        for (int i = 0; i < arr.length; i++) {
            Student stu = arr[i];
            System.out.println(stu.getName() +", " + stu.getAge());
        }
    }
}


package com.itheima.demo9;

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

    public Student() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

}

9.快速生成javabean的方式

记得一定要先手写，javabean类里面有很多细节需要我们注意的。

如果手写不出错了，可以用快捷键，使用方式如下：

1，先定义javabean中的属性

2，在javabean类的空白处，按快捷键：

alt + Insert 或者 alt + Fn + Insert

3，选择第一个，生成构造方法

4，选择get and set 生成get和set方法

如果快捷键练熟了，可以使用PTG插件。

链接外网，在setting里面搜索PTG，下载并安装即可

10.API

1.1API概述

什么是API
API (Application Programming Interface) ：应用程序编程接口

java中的API
指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。

1.2如何使用API帮助文档

打开帮助文档

找到索引选项卡中的输入框

在输入框中输入Random

看类在哪个包下

看类的描述

看构造方法

看成员方法

11.String类

2.1String类概述

String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以使用的时候不需要导包！

2.2String类的特点

字符串不可变，它们的值在创建后不能被更改

虽然 String 的值是不可变的，但是它们可以被共享

字符串效果上相当于字符数组( char[] )，但是底层原理是字节数组( byte[] )

2.3String类的构造方法

常用的构造方法

方法名	说明
public String()	创建一个空白字符串对象，不含有任何内容
public String(char[] chs)	根据字符数组的内容，来创建字符串对象
public String(byte[] bys)	根据字节数组的内容，来创建字符串对象
String s = “abc”;	直接赋值的方式创建字符串对象，内容就是abc

示例代码

public class StringDemo01 {
    public static void main(String[] args) {
        //public String()：创建一个空白字符串对象，不含有任何内容
        String s1 = new String();
        System.out.println("s1:" + s1);

        //public String(char[] chs)：根据字符数组的内容，来创建字符串对象
        char[] chs = {'a', 'b', 'c'};
        String s2 = new String(chs);
        System.out.println("s2:" + s2);

        //public String(byte[] bys)：根据字节数组的内容，来创建字符串对象
        byte[] bys = {97, 98, 99};
        String s3 = new String(bys);
        System.out.println("s3:" + s3);

        //String s = “abc”;	直接赋值的方式创建字符串对象，内容就是abc
        String s4 = "abc";
        System.out.println("s4:" + s4);
    }
}

2.4创建字符串对象两种方式的区别

通过构造方法创建
通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同

直接赋值方式创建
以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护

2.5字符串的比较

2.5.1==号的作用

比较基本数据类型：比较的是具体的值

比较引用数据类型：比较的是对象地址值

2.5.2equals方法的作用

方法介绍

public boolean equals(String s)     比较两个字符串内容是否相同、区分大小写

示例代码

public class StringDemo02 {
    public static void main(String[] args) {
        //构造方法的方式得到对象
        char[] chs = {'a', 'b', 'c'};
        String s1 = new String(chs);
        String s2 = new String(chs);

        //直接赋值的方式得到对象
        String s3 = "abc";
        String s4 = "abc";

        //比较字符串对象地址是否相同
        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
        System.out.println(s3 == s4);
        System.out.println("--------");

        //比较字符串内容是否相同
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));
        System.out.println(s3.equals(s4));
    }
}

2.6用户登录案例

2.6.1案例需求

已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示

2.6.2代码实现

/*
    思路：
        1:已知用户名和密码，定义两个字符串表示即可
        2:键盘录入要登录的用户名和密码，用 Scanner 实现
        3:拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。字符串的内容比较，用equals() 方法实现
        4:用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
 */
public class StringTest01 {
    public static void main(String[] args) {
        //已知用户名和密码，定义两个字符串表示即可
        String username = "itheima";
        String password = "czbk";

        //用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
        for(int i=0; i<3; i++) {

            //键盘录入要登录的用户名和密码，用 Scanner 实现
            Scanner sc = new Scanner(System.in);

            System.out.println("请输入用户名：");
            String name = sc.nextLine();

            System.out.println("请输入密码：");
            String pwd = sc.nextLine();

            //拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。字符串的内容比较，用equals() 方法实现
            if (name.equals(username) && pwd.equals(password)) {
                System.out.println("登录成功");
                break;
            } else {
                if(2-i == 0) {
                    System.out.println("你的账户被锁定，请与管理员联系");
                } else {
                    //2,1,0
                    //i,0,1,2
                    System.out.println("登录失败，你还有" + (2 - i) + "次机会");
                }
            }
        }
    }
}

2.7遍历字符串案例

2.7.1案例需求

键盘录入一个字符串，使用程序实现在控制台遍历该字符串

2.7.2代码实现

/*
    思路：
        1:键盘录入一个字符串，用 Scanner 实现
        2:遍历字符串，首先要能够获取到字符串中的每一个字符
            public char charAt(int index)：返回指定索引处的char值，字符串的索引也是从0开始的
        3:遍历字符串，其次要能够获取到字符串的长度
            public int length()：返回此字符串的长度
            数组的长度：数组名.length
            字符串的长度：字符串对象.length()
        4:遍历字符串的通用格式
 */
public class StringTest02 {
    public static void main(String[] args) {
        //键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        for(int i=0; i<line.length(); i++) {
            System.out.println(line.charAt(i));
        }
    }
}

2.8统计字符次数案例

2.8.1案例需求

键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)

2.8.2代码实现

/*
  思路：
        1:键盘录入一个字符串，用 Scanner 实现
        2:要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
        3:遍历字符串，得到每一个字符
        4:判断该字符属于哪种类型，然后对应类型的统计变量+1
            假如ch是一个字符，我要判断它属于大写字母，小写字母，还是数字，直接判断该字符是否在对应的范围即可
            大写字母：ch>='A' && ch<='Z'
            小写字母： ch>='a' && ch<='z'
            数字： ch>='0' && ch<='9'
        5:输出三种类型的字符个数
 */
public class StringTest03 {
    public static void main(String[] args) {
        //键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        //要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;

        //遍历字符串，得到每一个字符
        for(int i=0; i<line.length(); i++) {
            char ch = line.charAt(i);

            //判断该字符属于哪种类型，然后对应类型的统计变量+1
            if(ch>='A' && ch<='Z') {
                bigCount++;
            } else if(ch>='a' && ch<='z') {
                smallCount++;
            } else if(ch>='0' && ch<='9') {
                numberCount++;
            }
        }

        //输出三种类型的字符个数
        System.out.println("大写字母：" + bigCount + "个");
        System.out.println("小写字母：" + smallCount + "个");
        System.out.println("数字：" + numberCount + "个");
    }
}

2.9字符串拼接案例

2.9.1案例需求

定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，

并在控制台输出结果。例如，数组为 int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]

2.9.2代码实现

/*
    思路：
        1:定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        2:定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。
          返回值类型 String，参数列表 int[] arr
        3:在方法中遍历数组，按照要求进行拼接
        4:调用方法，用一个变量接收结果
        5:输出结果
 */
public class StringTest04 {
    public static void main(String[] args) {
        //定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1, 2, 3};

        //调用方法，用一个变量接收结果
        String s = arrayToString(arr);

        //输出结果
        System.out.println("s:" + s);
    }

    //定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回
    /*
        两个明确：
            返回值类型：String
            参数：int[] arr
     */
    public static String arrayToString(int[] arr) {
        //在方法中遍历数组，按照要求进行拼接
        String s = "";

        s += "[";

        for(int i=0; i<arr.length; i++) {
            if(i==arr.length-1) {
                s += arr[i];
            } else {
                s += arr[i];
                s += ", ";
            }
        }

        s += "]";

        return s;
    }
}

2.10字符串反转案例

2.10.1案例需求

定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果

例如，键盘录入 abc，输出结果 cba

2.10.2代码实现

/*
    思路：
        1:键盘录入一个字符串，用 Scanner 实现
        2:定义一个方法，实现字符串反转。返回值类型 String，参数 String s
        3:在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
        4:调用方法，用一个变量接收结果
        5:输出结果
 */
public class StringTest05 {
    public static void main(String[] args) {
        //键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        //调用方法，用一个变量接收结果
        String s = reverse(line);

        //输出结果
        System.out.println("s:" + s);
    }

    //定义一个方法，实现字符串反转
    /*
        两个明确：
            返回值类型：String
            参数：String s
     */
    public static String reverse(String s) {
        //在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
        String ss = "";

        for(int i=s.length()-1; i>=0; i--) {
            ss += s.charAt(i);
        }

        return ss;
    }
}

关于字符串的四个小扩展：（了解）

字符串存储的内存原理
String s = “abc”；直接赋值
特点：
此时字符串abc是存在字符串常量池中的。
先检查字符串常量池中有没有字符串abc，如果有，不会创建新的，而是直接复用。如果没有abc，才会创建一个新的。
所以，直接赋值的方式，代码简单，而且节约内存。

new出来的字符串
看到new关键字，一定是在堆里面开辟了一个小空间。
String s1 = new String（“abc”）；
String s2 = “abc”；
s1记录的是new出来的，在堆里面的地址值。
s2是直接赋值的，所以记录的是字符串常量池中的地址值。

==号比较的到底是什么？
如果比较的是基本数据类型：比的是具体的数值是否相等。
如果比较的是引用数据类型：比的是地址值是否相等。
结论：==只能用于比较基本数据类型。不能比较引用数据类型。

字符串拼接的时候，没有变量参与
String s = “a” + "b" + "c"；
此时没有变量参与，那么在编译的时候，就已经变成最终的结果了“abc”，这是字符串的常亮优化机制。

字符串拼接的时候，有变量参与
String s1 = “a”；
String s2 = s1 + “b”；
在底层，会创建一个StringBuilder对象，再利用append方法，把s1的内容和字符串a都拼接到StringBuilder容器当中，最后再调用toString方法变回一个字符串。在这个过程中，效率比较低，而且内存也有点浪费。

StringBuilder提高效率原理图
StringBuilder sb = new StringBuilder();
sb.append("a");
sb.append("b");
sb.append("c");
System.out.println(sb);
我们在代码中，只创建了一个StringBuilder容器对象，把所有的字符串都添加到同一个StringBuilder容器对象当中。而StringBuilder容器对象，里面的内容是可以发生改变的。从头到尾操作的都是同一个，所以效率较高。

12.ArrayList

集合和数组的优势对比：

长度可变

添加数据的时候不需要考虑索引，默认将数据添加到末尾

1.1ArrayList类概述

什么是集合
提供一种存储空间可变的存储模型，存储的数据容量可以发生改变

ArrayList集合的特点
底层是数组实现的，长度可以变化

泛型的使用
用于约束集合中存储元素的数据类型

1.2ArrayList类常用方法

1.2.1构造方法

方法名	说明
public ArrayList()	创建一个空的集合对象

1.2.2成员方法

方法名	说明
public boolean remove(Object o)	删除指定的元素，返回删除是否成功
public E remove(int index)	删除指定索引处的元素，返回被删除的元素
public E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
public E get(int index)	返回指定索引处的元素
public int size()	返回集合中的元素的个数
public boolean add(E e)	将指定的元素追加到此集合的末尾
public void add(int index,E element)	在此集合中的指定位置插入指定的元素

1.2.3示例代码

public class ArrayListDemo02 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> array = new ArrayList<String>();

        //添加元素
        array.add("hello");
        array.add("world");
        array.add("java");

        //public boolean remove(Object o)：删除指定的元素，返回删除是否成功
//        System.out.println(array.remove("world"));
//        System.out.println(array.remove("javaee"));

        //public E remove(int index)：删除指定索引处的元素，返回被删除的元素
//        System.out.println(array.remove(1));

        //IndexOutOfBoundsException
//        System.out.println(array.remove(3));

        //public E set(int index,E element)：修改指定索引处的元素，返回被修改的元素
//        System.out.println(array.set(1,"javaee"));

        //IndexOutOfBoundsException
//        System.out.println(array.set(3,"javaee"));

        //public E get(int index)：返回指定索引处的元素
//        System.out.println(array.get(0));
//        System.out.println(array.get(1));
//        System.out.println(array.get(2));
        //System.out.println(array.get(3)); //？？？？？？ 自己测试

        //public int size()：返回集合中的元素的个数
        System.out.println(array.size());

        //输出集合
        System.out.println("array:" + array);
    }
}

1.3ArrayList存储字符串并遍历

1.3.1案例需求

创建一个存储字符串的集合，存储3个字符串元素，使用程序实现在控制台遍历该集合

1.3.2代码实现

/*
    思路：
        1:创建集合对象
        2:往集合中添加字符串对象
        3:遍历集合，首先要能够获取到集合中的每一个元素，这个通过get(int index)方法实现
        4:遍历集合，其次要能够获取到集合的长度，这个通过size()方法实现
        5:遍历集合的通用格式
 */
public class ArrayListTest01 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> array = new ArrayList<String>();

        //往集合中添加字符串对象
        array.add("刘正风");
        array.add("左冷禅");
        array.add("风清扬");

        //遍历集合，其次要能够获取到集合的长度，这个通过size()方法实现
//        System.out.println(array.size());

        //遍历集合的通用格式
        for(int i=0; i<array.size(); i++) {
            String s = array.get(i);
            System.out.println(s);
        }
    }
}

1.4ArrayList存储学生对象并遍历

1.4.1案例需求

创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

1.4.2代码实现

/*
    思路：
        1:定义学生类
        2:创建集合对象
        3:创建学生对象
        4:添加学生对象到集合中
        5:遍历集合，采用通用遍历格式实现
 */
public class ArrayListTest02 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> array = new ArrayList<>();

        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("风清扬", 33);
        Student s3 = new Student("张曼玉", 18);

        //添加学生对象到集合中
        array.add(s1);
        array.add(s2);
        array.add(s3);

        //遍历集合，采用通用遍历格式实现
        for (int i = 0; i < array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

1.5ArrayList存储学生对象并遍历升级版

1.5.1案例需求

创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

学生的姓名和年龄来自于键盘录入

1.5.2代码实现

public class ArrayListTest {
    public static void main(String[] args) {
        //1.创建集合对象
        ArrayList<Student> list = new ArrayList<>();
        //2.键盘录入数据并添加到集合中
        Scanner sc = new Scanner(System.in);
        for (int i = 1; i <= 3; i++) {
            //创建学生对象
            Student s = new Student();
            //键盘录入学生信息
            System.out.println("请输入第" + i + "个学生的姓名");
            String name = sc.next();
            System.out.println("请输入第" + i + "个学生的年龄");
            int age = sc.nextInt();
            //把学生信息赋值给学生对象
            s.setName(name);
            s.setAge(age);
           //把学生对象添加到集合当中
            list.add(s);
        }
        //遍历
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println(stu.getName() + ", " + stu.getAge());
        }


    }
}

1.6 查找用户是否存在

需求：

1，main方法中定义一个集合，存入三个用户对象。

用户属性为：id，username，password

2，要求：定义一个方法，根据id查找对应的学生信息。

如果存在，返回true

如果不存在，返回false

代码示例：

package com.itheima.test4;

import java.util.ArrayList;

public class ArrayListTest {
    public static void main(String[] args) {
        //1.创建集合
        ArrayList<User> list = new ArrayList<>();
        //2.添加用户对象
        User u1 = new User("heima001","zhangsan","123456");
        User u2 = new User("heima002","lisi","1234");
        User u3 = new User("heima003","wangwu","12345");
        //3.添加元素
        list.add(u1);
        list.add(u2);
        list.add(u3);
        //3.根据id查找是否存在
        //调方法
        //如果调用本类中的方法,直接写方法名就可以。
        //如果我要调用其他类中的方法，需要用对象去调用。
        boolean flag = contains(list, "heima004");
        System.out.println(flag);
    }

    //1.我要干嘛？ 判断id在集合中是否存在
    //2.需要什么？ 集合  id
    //3.是否需要继续使用？需要
    //写在测试类中的方法，加static
    //写在javabean类中的方法，不加static
    public static boolean contains(ArrayList<User> list, String id){
        for (int i = 0; i < list.size(); i++) {
            User u = list.get(i);
            String uid = u.getId();
            if(uid.equals(id)){
                return true;
            }
        }
        //当集合里面所有的元素全部比较完毕了
        //如果此时还不存在，才能返回false
        return false;
    }
}

1.7 查找用户的索引

需求：

1，main方法中定义一个集合，存入三个用户对象。

用户属性为：id，username，password

2，要求：定义一个方法，根据id查找对应的学生信息。

如果存在，返回索引

如果不存在，返回-1

代码示例：

package com.itheima.test5;

import com.itheima.test4.User;

import java.util.ArrayList;

public class ArrayListTest {
    public static void main(String[] args) {
        //1.创建集合
        ArrayList<User> list = new ArrayList<>();
        //2.添加用户对象
        User u1 = new User("heima001","zhangsan","123456");
        User u2 = new User("heima002","lisi","1234");
        User u3 = new User("heima003","wangwu","12345");
        //3.添加元素
        list.add(u1);
        list.add(u2);
        list.add(u3);

        //4.查询索引
        int index = findIndex(list, "heima004");
        System.out.println(index);

    }

    //1.我要干嘛？查询索引
    //2.需要什么？集合  id
    //3.是否需要继续使用 需要返回值
    public static int findIndex(ArrayList<User> list, String id){
        for (int i = 0; i < list.size(); i++) {
            User u = list.get(i);
            String uid = u.getId();
            if(uid.equals(id)){
                return i;
            }
        }
        //如果循环结束还没有找到
        return -1;
    }
    public static boolean contains(ArrayList<User> list, String id){
        int index = findIndex(list, id);
        if(index >= 0){
            return true;
        }else{
            return false;
        }
       // return  findIndex(list, id) >= 0;
    }
}