1 java平台

1 java平台 1 Java的三大平台分类

：

可以用于桌面应用开发。

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

：

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

：

企业级的服务器开发。

在这个领域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和 class关键字

表示新建一个类。

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

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

代码示例：

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

关键字

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

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

建议：

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

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

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

同学们犯的错误：

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

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

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

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进行相加//再把最终的结果赋值给countcount = 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、

字符类型：char

布尔类型：

扩展：

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

基本数据类型需要记忆的

扩展：

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

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

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

小驼峰命名法：

适用于：方法名、变量名

大驼峰命令法：

适用于：类名

建议：

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

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

3. 键盘录入 3.1 目的：

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

3.2 实现步骤：

1.导包

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

2.创建对象

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

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中类的相关操作 新建类：

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

删除类：

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

修改类名：

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

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

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

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

4.5 idea中模块的相关操作 新建模块：

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

删除模块：

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

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

导入模块：

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

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

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

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

4.6 idea中项目的相关操作 关闭项目：

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

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

新建项目：

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

打开项目：

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

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

在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 = 10int y = x++;//先++，先加后用//先把x的值进行自增，变成12，再把自增之后的值拿出来用。赋值给z//当这行代码执行完毕之后，x = 12 z = 12int z = ++x;//因为x自增了两次就是12System.out.println("x:" + x);//12System.out.println("y:" + y);//10System.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, )

循环结构(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等于bif(a == b) {System.out.println("a等于b");}		//需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于cint 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的值不大于bif(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 (表达式) {case 1:语句体1;break;case 2:语句体2;break;...default:语句体n+1;break;
}

语句练习-春夏秋冬

春：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("你输入的月份有误");}}
}

的扩展知识：

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

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

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

比如：

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

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

练习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循环结构（掌握）

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

for循环书写技巧：

代码示例：

//1.确定循环的开始条件
//2.确定循环的结束条件
//3.确定要重复执行的代码//需求：打印5次HelloWorld
//开始条件：1
//结束条件：5
//重复代码：打印语句for (int i = 1; i <= 5; i++) {System.out.println("HelloWorld");
}

for循环练习-输出数据

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

for循环练习-求和

public class ForTest02 {public static void main(String[] args) {//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0int 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循环练习-求偶数和

public class ForTest03 {public static void main(String[] args) {//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0int 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 跳转控制语句（掌握） 练习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//结束条件：100for (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-1int 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. 产生随机数（掌握） 导入包

java.util.;创建对象

r = new ();产生随机数

int num = r.(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);}
}

练习-猜数字小游戏

import java.util.Random;
import java.util.Scanner;public class RandomTest {public static void main(String[] args) {//要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100Random 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静态初始化格式详解 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动态初始化格式详解 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的索引。

程序运行后，将会抛出 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

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将不会再保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

3.7数组的练习 3.7.1数组最值

//扩展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.循环结束之后打印countSystem.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 1int 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 方法的概念

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

2. 方法的定义和调用

2.1 无参数方法定义和调用

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

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

方法名();

method();

2.2 方法调用过程图解

2.3 无参数方法的练习

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 带参数方法定义和调用

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

实参：方法调用中的参数

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

3.3 带参数方法练习

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

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

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

4.2 带返回值方法练习1

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() {// 这里会引发编译错误!!!}}
}

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

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 方法重载练习

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));}//intpublic static boolean compare(int a, int b) {System.out.println("int");return a == b;}//bytepublic static boolean compare(byte a, byte b) {System.out.println("byte");return a == b;}//shortpublic static boolean compare(short a, short b) {System.out.println("short");return a == b;}//longpublic 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 数组遍历

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 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，表示数组中所有数据都不相等//可以返回falsereturn 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;}}//当循环结束之后，如果还不能返回索引，表示数组中不存在该数据//可以返回-1return -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 类的定义

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

类的定义步骤：

①定义类

②编写类的成员变量

③编写类的成员方法

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 类名();范例：Phone p = new Phone();使用对象1：使用成员变量格式：对象名.变量名范例：p.brand2：使用成员方法格式：对象名.方法名()范例：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 关键字

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

/*学生类*/
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 的使用

/*学生类*/
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关键字

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内存原理

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

4.5 封装思想 封装概述

是面向对象三大特征之一（封装，继承，多态）

是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的 封装原则

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

成员变量，提供对应的()/()方法 封装好处

通过方法来控制成员变量的操作，提高了代码的安全性

把代码用方法进行封装，提高了代码的复用性 5. 构造方法 5.1 构造方法概述

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

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 标准类制作

①类名需要见名知意

②成员变量使用修饰

③提供至少两个构造方法

④成员方法

6.练习1-定义学生类

需求：

定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过赋值，有参创建的对象直接赋值，并通过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-创建对象并添加到数组

需求：

定义一个标准的类

学生类

属性：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-修改年龄

需求：

定义类，要求如下：

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

在测试类中，创建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.快速生成的方式

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

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

1，先定义中的属性

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

alt + 或者 alt + Fn +

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

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

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

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

10.API 1.1API概述 1.2如何使用API帮助文档

11.类 2.类概述

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

2.类的特点 2.类的构造方法

方法名

说明

()

创建一个空白字符串对象，不含有任何内容

(char[] chs)

根据字符数组的内容，来创建字符串对象

(byte[] bys)

根据字节数组的内容，来创建字符串对象

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”;	直接赋值的方式创建字符串对象，内容就是abcString s4 = "abc";System.out.println("s4:" + s4);}
}

2.4创建字符串对象两种方式的区别 2.5字符串的比较 2.5.1==号的作用 2.5.方法的作用

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,2System.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

/*思路：1:键盘录入一个字符串，用 Scanner 实现2:要统计三种类型的字符个数，需定义三个统计变量，初始值都为03:遍历字符串，得到每一个字符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();//要统计三种类型的字符个数，需定义三个统计变量，初始值都为0int bigCount = 0;int smallCount = 0;int numberCount = 0;//遍历字符串，得到每一个字符for(int i=0; i='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 + "个");}
}

/*思路：1:定义一个 int 类型的数组，用静态初始化完成数组元素的初始化2:定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。返回值类型 String，参数列表 int[] arr3:在方法中遍历数组，按照要求进行拼接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

/*思路：1:键盘录入一个字符串，用 Scanner 实现2:定义一个方法，实现字符串反转。返回值类型 String，参数 String s3:在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回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;}
}

public class ArrayListDemo02 {public static void main(String[] args) {//创建集合ArrayList array = new ArrayList();//添加元素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:创建集合对象2:往集合中添加字符串对象3:遍历集合，首先要能够获取到集合中的每一个元素，这个通过get(int index)方法实现4:遍历集合，其次要能够获取到集合的长度，这个通过size()方法实现5:遍历集合的通用格式*/
public class ArrayListTest01 {public static void main(String[] args) {//创建集合对象ArrayList array = new ArrayList();//往集合中添加字符串对象array.add("刘正风");array.add("左冷禅");array.add("风清扬");//遍历集合，其次要能够获取到集合的长度，这个通过size()方法实现
//        System.out.println(array.size());//遍历集合的通用格式for(int i=0; i

/*思路：1:定义学生类2:创建集合对象3:创建学生对象4:添加学生对象到集合中5:遍历集合，采用通用遍历格式实现*/
public class ArrayListTest02 {public static void main(String[] args) {//创建集合对象ArrayList 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());}}
}

public class ArrayListTest {public static void main(String[] args) {//1.创建集合对象ArrayList 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());}}
}

package com.itheima.test4;import java.util.ArrayList;public class ArrayListTest {public static void main(String[] args) {//1.创建集合ArrayList 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类中的方法，不加staticpublic static boolean contains(ArrayList 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;}}//当集合里面所有的元素全部比较完毕了//如果此时还不存在，才能返回falsereturn false;}
}

package com.itheima.test5;import com.itheima.test4.User;import java.util.ArrayList;public class ArrayListTest {public static void main(String[] args) {//1.创建集合ArrayList 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 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 list, String id){int index = findIndex(list, id);if(index >= 0){return true;}else{return false;}// return  findIndex(list, id) >= 0;}
}