Java（一）认识Java到循环

一、Java入门

1.1 人机交互

1.1 什么是cmd？

就是在windows操作系统中，利用命令行的方式去操作计算机。

我们可以利用cmd命令去操作计算机，比如：打开文件，打开文件夹，创建文件夹等。

1.2 如何打开CMD窗口？

1. 按下快捷键：win + R。

   此时会出现运行窗口。

2. 在运行窗口中输出cmd

3. 输出回车。

解惑：

cmd默认操作C盘下的users文件夹下的XXX文件夹。（XXX就是计算机名）

1.3 常用CMD命令

扩展：

在很多资料中都说成是DOS命令，其实是不对的。真正的DOS命令是1981年微软和IBM出品的MS-DOS操作系统中的命令才叫做DOS命令。

而在Windows中，win98之前的操作系统是以非图形化的DOS为基础的，可以叫做DOS命令。到了2000年以后，windows逐渐的以图形化界面为主了，这个时候就不能叫DOS命令了，他只是模拟了DOS环境而已，很多的原本的DOS命令已经无法使用了，所以这个时候叫做CMD命令会更准确一些。

常见的CMD命令如下：

操作	说明
盘符名称:	盘符切换，如E:回车，表示切换到E盘。
dir	查看当前路径下的内容
cd 目录	进入单级目录，例如cd Desktop
cd ..	回退到上一级目录
cd 目录1\目录2...	进入多级目录，例如cd Desktop\test
cd \	回退到盘符目录
cls	清屏
exit	退出命令提示符窗口

1.4 CMD练习

目标：

利用cmd命令打开自己电脑上的QQ。

步骤：

1,确定自己电脑上的QQ安装在哪里
2,启动cmd
3,进入到启动程序QQ.exe所在的路径。
4,输出qq.exe加回车表示启动qq。

注意：

在windows操作系统当中，文件名或者文件夹名是忽略大小写的。

1.5 环境变量

path环境变量

系统除了在当前目录下查找指定文件，还会在path中指定的路径中查找该文件。

作用：

如果我想要在CMD的任意目录下，都可以启动某一个软件，那么就可以把这个软件的路径配置到环境变量中的PATH里面。

在启动软件的时候，操作系统会先在当前路径下找，如果在当前录课没有再到环境变量的路径中去找。如果都找不到就提示无法启动。

步骤：

第一步：右键点击我的电脑并选择属性。

（如果无法出现第二步界面，可以打开我的电脑之后右键点击空白处）

第二步：点击高级系统设置。

第三步：选择高级，再点击下面的环境变量。

第四步：找系统变量里面的PATH

第五步：点击新建，把软件的完整路径，配置到PATH当中，再点击确定即可。

第六步：（可做可不做）点击上移，把当前配置的路径移动到最上面。

移动的好处：在CMD中打开软件时，会先找当前路径，再找环境变量，在环境变量中是从上往下依次查找的，如果路径放在最上面查找的速度比较快。

1.2 Java概述

Java是什么？

语言：人与人交流沟通的表达方式

计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言

Java是一门非常火的计算机语言。（也叫做编程语言）

我们想要让计算机做一些事情，那么就可以通过Java语言告诉计算机就可以了

Java语言的发展

三个版本：

• Java5.0：这是Java的第一个大版本更新。

• Java8.0：这个是目前绝大数公司正在使用的版本。因为这个版本最为稳定。

• Java15.0：这个是我们课程中学习的版本。

解惑：

我们学的跟工作中使用的版本不太一样啊。会不会影响以后工作呢？

向下兼容。新的版本只是在原有的基础上添加了一些新的功能而已。

举例：

用8版本开发的代码，用11版本能运行吗？必须可以的。

用11版本开发的代码，用8版本能运行吗？不一定。

如果11版本开发的代码，没有用到9~11的新特性，那么用8是可以运行的。

如果11版本开发的代码，用到了9~11的新特性，那么用8就无法运行了。

2.8 Java的三大平台

JavaSE、JavaME、JavaEE

2.8.1 JavaSE

是其他两个版本的基础。

2.8.2 JavaME

Java语言的小型版，用于嵌入式消费类电子设备或者小型移动设备的开发。

其中最为主要的还是小型移动设备的开发（手机）。渐渐的没落了，已经被安卓和IOS给替代了。

但是，安卓也是可以用Java来开发的。

2.8.3 JavaEE

用于Web方向的网站开发。（主要从事后台服务器的开发）

在服务器领域，Java是当之无愧的龙头老大。

2.9 Java的主要特性

• 面向对象

• 安全性

• 多线程

• 简单易用

• 开源

• 跨平台

2.9.1 Java语言跨平台的原理

• 操作系统本身其实是不认识Java语言的。

• 但是针对于不同的操作系统，Java提供了不同的虚拟机。

虚拟机会把Java语言翻译成操作系统能看得懂的语言。

2.10 JRE和JDK

JVM（Java Virtual Machine），Java虚拟机

JRE（Java Runtime Environment），Java运行环境，包含了JVM和Java的核心类库（Java API）

JDK（Java Development Kit）称为Java开发工具，包含了JRE和开发工具

总结：我们只需安装JDK即可，它包含了java的运行环境和虚拟机。

JVM

允许跨平台的是java程序，而不是JVM虚拟机。

JDK的安装目录

bin				存放各种工具命令(javac,java)
conf			配置文件
include			平台特定的头文件
jmods			各种模块
legal			模块的授权文档
lib				补充JAR包

名词解释

JDK（Java开发工具包）包括JVM、核心类库和开发工具

• JVM：虚拟机

• 核心类库：Java已经写好的东西

• 开发工具：javac,java,jdb,jhat……

JRE（Java运行环境）包括JVM、核心类库和运行工具

JDK包含JRE，JRE包含JVM

1.2.1 下载和安装

下载

通过官方网站获取JDK

http://www.oracle.com

注意1：针对不同的操作系统，需要下载对应版本的JDK。

注意2：

如果你的电脑是windows32位的，建议重装系统，重装成64位的操作系统。

因为Java从9版本开始，就已经不提供32位版本的安装包了。

如果自己不愿意下载，到今天day01资料文件中，也有对应的安装包。

安装

傻瓜式安装，下一步即可。默认的安装路径是在C:\Program Files下。

建议：

• 安装路径不要有中文，不要有空格等一些特殊的符号。

• 以后跟开发相关的所有软件建议都安装在同一个文件夹中，方便管理。

JDK的安装目录介绍

目录名称	说明
bin	该路径下存放了JDK的各种工具命令。javac和java就放在这个目录。
conf	该路径下存放了JDK的相关配置文件。
include	该路径下存放了一些平台特定的头文件。
jmods	该路径下存放了JDK的各种模块。
legal	该路径下存放了JDK各模块的授权文档。
lib	该路径下存放了JDK工具的一些补充JAR包。

1.3 Java程序的运行-HelloWorld小案例

HelloWorld案例是指在计算机屏幕上输出“HelloWorld”这行文字。各种计算机语言都习惯使用该案例作为第一个演示案例。

javac是JDK提供的编译工具

1.这里使用javac.exe进行编译，生成HelloWorld.class文件。

javac Helloworld.java

2.使用java.exe运行上一步生成的.class文件，但.class后缀要缺省。

java HelloWorld

3.输出结果

高级语言的编译运行方式

编译型：全部转换成01代码，整体运行

解释型：转换一行01代码，运行一行

混合型（Java）：先编译成.class文件，再运行（在虚拟机中运行）

2.3.1 Java程序开发运行流程

开发Java程序，需要三个步骤：编写程序，编译程序，运行程序。

2.3.2 HelloWorld案例的编写

1. 新建文本文档文件，修改名称为HelloWorld.java。

注意：后缀名为java的才是java文件。

1. 用记事本打开HelloWorld.java文件，输写程序内容。

注意：代码要跟我编写的完全保持一致。

public class HelloWorld {
	public static void main(String[] args) {
		System.out.println("HelloWorld");
	}
}

1. 保存

注意：未保存的文件在左上角会有*符号标记

1. 编译文件。编译后会产生一个class文件。

   java文件：程序员自己编写的代码。

   class文件：交给计算机执行的文件。

2. 运行代码

   注意：运行的是编译之后的class文件。

用到两个命令：

javac + 文件名 + 后缀名 （就是编译java文件）

java + 文件名（运行编译之后的class文件）

2.4 HelloWorld案例常见问题

2.4.1 BUG

在电脑系统或程序中，隐藏着的一些未被发现的缺陷或问题统称为bug（漏洞）。

2.4.2 BUG的解决

1. 具备识别BUG的能力：多看

2. 具备分析BUG的能力：多思考，多查资料

3. 具备解决BUG的能力：多尝试，多总结

2.4.3 HelloWorld常见问题

1、非法字符问题。Java中的符号都是英文格式的。

2、大小写问题。Java语言对大小写敏感（区分大小写）。

3、在系统中显示文件的扩展名，避免出现HelloWorld.java.txt文件。

4、编译命令后的java文件名需要带文件后缀.java

5、运行命令后的class文件名（类名）不带文件后缀.class

...

常见错误代码1

publicclass HelloWorld{
    public static void main(String[] args){
        System.out.println("HelloWorld");
    }
}

问题：

public和class之间缺少一个空格。

技巧：一般来讲在单词之间的空格是不能省略的。

如果是单词和符号之间的空格是可以省略的。

常见错误代码2

public class HelloWorld{
    public static void main(String[] args){
        system.out.println("HelloWorld");
    }
}

问题：

system首字母必须大写。

技巧：

Java代码中，是严格区分大小写的。

所以该大写的地方一定要大写，该小写的地方一定要小写。多多练习。

常见错误代码3

public class HelloWorld{
    public static void main(String[] args){
        System.out.println(HelloWorld);
    }
}

问题：

第三行代码中的HelloWorld必须用双引号引起来，否则就会出现问题。

常见错误代码4

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("HelloWorld")；
    }
}

问题：

在以后代码当中，所有的标点符号必须是英文状态下的。

技巧：

可以在输入法中进行对应的设置。

1.4 环境变量

2.5.1 为什么配置环境变量

开发Java程序，需要使用JDK提供的开发工具（比如javac.exe、java.exe等命令），而这些工具在JDK的安装目录的bin目录下，如果不配置环境变量，那么这些命令只可以在bin目录下使用，而我们想要在任意目录下都能使用，所以就要配置环境变量。

注意：现在最新从官网上下载的JDK安装时会自动配置javac、java命令的路径到Path环境变量中去 ，所以javac、java可以直接使用。

2.5.2配置方式

以前下载的老版本的JDK是没有自动配置的，而且自动配置的也只包含了4个工具而已，所以我们需要删掉已经配置完毕的，再次重新配置Path环境变量。

①JAVA_HOME：告诉操作系统JDK安装在了哪个位置（未来其他技术要通过这个找JDK）

②Path：告诉操作系统JDK提供的javac(编译)、java(执行)命令安装到了哪个位置

2.5.3win10的bug

当电脑重启之后，环境变量失效了。表示操作系统不支持自定义的环境变量。

步骤：

• 还是要配置JAVA_HOME给以后的相关软件去使用

• 我们可以把java和javac的完整路径配置到PATH当中。

  E:\develop\JDK\bin

二、Java基础语法

2.1 注释

注释是对代码的解释和说明文字。

Java中的注释分为三种：

• 单行注释：

// 这是单行注释文字

• 多行注释：

/*
这是多行注释文字
这是多行注释文字
这是多行注释文字
*/
注意：多行注释不能嵌套使用。

• 文档注释（暂时用不到）：

/**
这是多行注释文字
这是多行注释文字
这是多行注释文字
*/

使用的技巧

如果我们要对代码进行解释，那么就可以使用注释。

当注释的内容比较少，一行就写完了，可以用单行注释。

如果注释的内容比较多，需要写在多行，那么可以使用多行注释。

注意点

注释的内容不会参与编译和运行的，仅仅是对代码的解释说明而已。

所以，不管在注释当中写什么内容，都不会影响代码运行的结果。

2.2 关键字

概念

被Java赋予了特定含义的英文单词。

当我们在代码中写了关键字之后，程序在运行的时候，就知道要做什么事情了。

注意：关键字很多，不用刻意去记。

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

第一个关键字class

表示定义一个类。创建一个类。

类：Java项目最基本的组成单元，一个完整的Java项目有可能会有成千上万个类来组成的。

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

在类名后面会有一对大括号，表示这个类的内容。

举例：

public class HelloWorld{
    
   
}

解释：class表示定义类。

类名：HelloWorld

HelloWorld后面的大括号表示这个类的范围。

2.3 字面量

作用：告诉程序员，数据在程序中的书写格式。

字面量类型	说明	程序中的写法
整数	不带小数的数字	666，-88
小数	带小数的数字	13.14，-5.21
字符	必须使用单引号，有且仅能一个字符	‘A’，‘0’， ‘你’
字符串	必须使用双引号，内容可有可无	“HelloWorld”，“宝贝”
布尔值	布尔值，表示真假，只有两个值：true，false	true 、false
空值	一个特殊的值，空值	值是：null

public class Demo {
    public static void main(String[] args) {
        System.out.println(10); // 输出一个整数
        System.out.println(5.5); // 输出一个小数
        System.out.println('a'); // 输出一个字符
        System.out.println(true); // 输出boolean值true
        System.out.println("666"); // 输出字符串
    }
}

区分技巧

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

2. 只要带了小数点，那么就是小数类型的字面量。

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

4. 字符类型的字面量必须用单引号引起来，不管内容是什么，但是个数有且只能有一个。

5. 字符类型的字面量只有两个值，true、false。

6. 空类型的字面量只有一个值，null。

2.4 变量

4.1 什么是变量？

变量就在程序中临时存储数据的容器。但是这个容器中只能存一个值。

4.2 变量的定义格式

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

4.2.1 格式详解

数据类型：限定了变量当中能存储什么类型的数据。

如果要存10，那么数据类型就需要写整数类型。

如果要存10.0，那么数据类型就需要写小数类型。

变量名：其实就是这个容器的名字。

当以后想要使用变量里面的数据时，直接使用变量名就可以了。

数据值：真正存储在容器中的数据。

分号：表示语句的结束，就跟以前写作文时候的句号是一样的。

4.2.2 常用的数据类型

整数：int

小数（浮点数）：double

其他数据类型稍后讲解

举例：

public class VariableDemo{
	public static void main(String[] args){
		//定义一个整数类型的变量
		//数据类型 变量名 = 数据值;
		int a = 16;
		System.out.println(a);//16
		
		//定义一个小数类型的变量
		double b = 10.1;
		System.out.println(b);//10.1
	}
}

4.2.3 变量的注意事项

• 变量名不能重复

• 在一条语句中，可以定义多个变量。但是这种方式影响代码的阅读，所以了解一下即可。

• 变量在使用之前必须要赋值。

案例：

public class VariableDemo2{
	public static void main(String[] args){
		//1.变量名不允许重复
		//int a = 10;
		//int a = 20;
		//System.out.println(a);
		
		//2.一条语句可以定义多个变量
		//了解。
		//int a = 10, b = 20, c = 20,d = 20;
		//System.out.println(a);//?
		//System.out.println(b);//?
		
		
		//3.变量在使用之前必须要赋值
		int a = 30;
		System.out.println(a);
	}
}

4.3 变量的练习

题目：

说出公交车到终点站之后，车上一共有多少乘客？

一开始没有乘客。

第一站：上去一位乘客，没有下来乘客。

第二站：上去两位乘客，下来一位乘客。

第三站：上去两位乘客，下来一位乘客。

第四站：没有上去乘客，下来一位乘客。

第五站：上去一位乘客，没有下来乘客。

问：到了终点站之后，车上一共多少乘客？

代码

public class VariableTest1{
	//主入口
	public static void main(String[] args){
		//一开始没有乘客。
		int count = 0;
		//第一站：上去一位乘客
		//在原有的基础上 + 1
		count = count + 1;
		//System.out.println(count);
		//第二站：上去两位乘客，下来一位乘客
		count = count + 2 - 1; 
		//第三站：上去两位乘客，下来一位乘客
		count = count + 2 - 1;
		//第四站：下来一位乘客
		count = count - 1;
		//第五站：上去一位乘客
		count = count + 1;
		//请问：到了终点站，车上一共几位乘客。
		System.out.println(count);//3
	}
}

2.5 数据类型

5.1 Java语言数据类型的分类

• 基本数据类型

• 引用数据类型（面向对象的时候再深入学习）

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

字面量（数据在程序中的书写形式）

• 整数类型

• 小数类型

• 字符串类型 双引号

• 字符类型 单引号而且内容只有一个

• 布尔类型

• 空类型 值是null（不能直接打印）

/t制表符

在打印的时候，把前面字符串的长度补齐到8，或者8的整数倍。最多补1个空格，最多补8个空格。

基本数据类型

• 整数

  byte 范围（-128~+127）

  short

  int（默认）

  long 若要定义long类型的变量，要在数据值的后面加一个L后缀

• 浮点数

  float 定义float类型变量时要加F后缀

  double（默认）

• 字符

  char

• 布尔

  boolean

取值范围关系：double > float > long > int > short > byte

String类型是字符串类型

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

• 由数字、字母、下划线和美元符（$）组成

• 不能以数字开头

• 不能是关键字

• 区分大小写

数据类型	关键字	内存占用	取值范围
整数	byte	1	负的2的7次方 ~ 2的7次方-1(-128~127)
	short	2	负的2的15次方 ~ 2的15次方-1(-32768~32767)
	int	4	负的2的31次方 ~ 2的31次方-1
	long	8	负的2的63次方 ~ 2的63次方-1
浮点数	float	4	1.401298e-45 ~ 3.402823e+38
	double	8	4.9000000e-324 ~ 1.797693e+308
字符	char	2	0-65535
布尔	boolean	1	true，false

说明

e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方。

在java中整数默认是int类型，浮点数默认是double类型。

需要记忆以下几点

byte类型的取值范围：

-128 ~ 127

int类型的大概取值范围：

-21亿多 ~ 21亿多

整数类型和小数类型的取值范围大小关系：

double > float > long > int > short > byte

最为常用的数据类型选择：

• 在定义变量的时候，要根据实际的情况来选择不同类型的变量。

  比如：人的年龄，可以选择byte类型。

  比如：地球的年龄，可以选择long类型。

• 如果整数类型中，不太确定范围，那么默认使用int类型。

• 如果小数类型中，不太确定范围，那么默认使用double类型。

• 如果要定义字符类型的变量，那么使用char

• 如果要定义布尔类型的变量，那么使用boolean

5.3 定义8种基本数据类型变量

public class VariableDemo3{
    public static void main(String[] args){
        //1.定义byte类型的变量
        //数据类型 变量名 = 数据值;
        byte a = 10;
        System.out.println(a);

        //2.定义short类型的变量
        short b = 20;
        System.out.println(b);

        //3.定义int类型的变量
        int c = 30;
        System.out.println(c);

        //4.定义long类型的变量
        long d = 123456789123456789L;
        System.out.println(d);

        //5.定义float类型的变量
        float e = 10.1F;
        System.out.println(e);

        //6.定义double类型的变量
        double f = 20.3;
        System.out.println(f);

        //7.定义char类型的变量
        char g = 'a';
        System.out.println(g);

        //8.定义boolean类型的变量
        boolean h = true;
        System.out.println(h);

    }
}

注意点

• 如果要定义 一个整数类型的变量，不知道选择哪种数据类型了，默认使用int。

• 如果要定义 一个小数类型的变量，不知道选择哪种数据类型了，默认使用double。

• 如果要定义一个long类型的变量，那么在数据值的后面需要加上L后缀。（大小写都可以，建议大写。）

• 如果要定义一个float类型的变量，那么在数据值的后面需要加上F后缀。（大小写都可以）

5.4 练习1

题目：定义5个变量记录老师的信息并打印

代码示例：

public class VariableTest1{
	public static void main(String[] args){
		//1.定义字符串类型的变量记录老师的姓名
		String name = "黑马谢广坤";
		//2.定义整数类型的变量记录老师的年龄
		int age = 18;
		//3.定义字符类型的变量记录老师的性别
		char gender = '男';
		//4.定义小数类型的变量记录老师的身高
		double height = 180.1;
		//5.定义布尔类型的变量记录老师的婚姻状况
		boolean flag = true;
		
		//输出5个变量的值
		System.out.println(name);
		System.out.println(age);
		System.out.println(gender);
		System.out.println(height);
		System.out.println(flag);
		
	}
}

5.5 练习2

题目：将（电影名称，主演，年份，评分）四个信息选择不同类型的变量，随后打印出来。

代码示例：

public class VariableTest2{
	public static void main(String[] args){
		//1.定义字符串变量记录电影的名称
		String movie = "送初恋回家";
		//2.定义三个变量记录主演的名字
		String name1 = "刘鑫";
		String name2 = "张雨提";
		String name3 = "高媛";
		//3. 定义整数类型的变量记录年龄的年份
		int year = 2020;
		//4.定义小数类型的变量记录电影的评分
		double score = 9.0;
		
		//打印变量的信息
		System.out.println(movie);
		System.out.println(name1);
		System.out.println(name2);
		System.out.println(name3);
		System.out.println(year);
		System.out.println(score);
		
	}
}

5.6 练习3

题目：选择其中一部手机，将（手机价格，手机品牌）两个信息选择不同类型的变量，随后打印出来。

代码示例：

public class VariableTest3{
	public static void main(String[] args){
		//1.定义小数类型的变量记录手机的价格
		double price = 5299.0;
		
		//2.定义字符串类型的变量记录手机的品牌
		String brand = "华为";
		
		//输出变量记录的值
		System.out.println(price);
		System.out.println(brand);
	}
}

2.6 标识符

业内大多数程序员都在遵守阿里巴巴的命名规则。

在day02的资料文件夹中有。

6.1 硬性要求

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

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

• 数字不能开头

• 不能是关键字

• 区分大小写的。

6.2 软件建议

如果不这么做，代码不会报错，但是会让代码显得比较low。

6.2.1 小驼峰命名法

适用于变量名和方法名

• 标识符是一个单词的时候，全部小写，比如：name

• 标识符由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写，比如：firstName、maxAge

6.2.2 大驼峰命名法

适用于类名

• 标识符是一个单词的时候，首字母大写。例如：Demo、Test。

• 标识符由多个单词组成的时候，每个单词的首字母大写。比如：HelloWorld

不管起什么名字，都要做到见名知意。

阿里巴巴命名规范细节

1. 尽量不要用拼音。但是一些国际通用的拼音可视为英文单词。

   正确：alibaba、hangzhou、nanjing

   错误：jiage、dazhe

2. 平时在给变量名、方法名、类名起名字的时候，不要使用下划线或美元符号。

   错误：_name

   正确：name

2.7 键盘录入

键盘录入的实际功能Java已经帮我们写好了，不需要我们自己再实现了，而Java写好的功能都放在了Scanner这个类中，所以，我们只要直接使用Scanner这个类就可以了。

使用步骤：

第一步：

导包：其实就是表示先找到Scanner这个类在哪。

第二步：

创建对象：其实就表示申明一下，我准备开始用Scanner这个类了。

第三步：

接收数据：也是真正干活的代码。

代码示例：

//导包，其实就是先找到Scanner这个类在哪
import java.util.Scanner;
public class ScannerDemo1{
	public static void main(String[] args){
		//2.创建对象，其实就是申明一下，我准备开始用Scanner这个类了。
		Scanner sc = new Scanner(System.in);
		//3.接收数据
		//当程序运行之后，我们在键盘输入的数据就会被变量i给接收了
		System.out.println("请输入一个数字");
		int i = sc.nextInt();
		System.out.println(i);
	}
}

2.8 IDEA

8.1 IDEA概述

IDEA全称IntelliJ IDEA，是用于Java语言开发的集成环境，它是业界公认的目前用于Java程序开发最好的工具。

集成环境：

把代码编写，编译，执行，调试等多种功能综合到一起的开发工具。

8.2 IDEA的下载和安装

8.2.1 下载

可以到官方网站自行下载，网址请点击这里

8.2.2 安装

• 下载后，双击安装包

• 点击next，准备安装

• 点击Browse修改安装路径

  修改完毕点击next

• 勾选64-bit launcher，表示在桌面新建一个64位的快捷方式

  其他的不要勾选

  点击next

• 点击Install，准备安装

• 等进度条读取完毕之后，会有最终界面提示

  点击finish即可。

• 第一次启动会询问，是否导入一些设置

  选择第二个不导入，保持默认设置，再点击OK

• 选择背景主题

  左边是黑色背景，右边是白色背景

  这个可以根据自己的喜好来选择

  选择完毕点击右下角的next

• 在本界面让我们购买idea

  因为我们是学习阶段，所以可以使用免费使用30天

  点击第一排第二个，Evaluate for free

• 点击蓝色的Evaluate，就可以开始免费试用30天了

• 当看到这个界面，就表示idea已经成功安装完毕

  可以点击右上角关闭

8.3 IDEA中层级结构介绍

8.3.1 结构分类

project（项目）

module（模块）

package（包）

class（类）

8.3.2 结构介绍

project（项目、工程）

淘宝、京东等网站都属于一个个项目，IDEA中就是一个个的Project。

module（模块）

在一个项目中，可以存放多个模块，不同的模块可以存放项目中不同的业务功能代码。在黑马程序员的官方网站中，至少包含了以下模块：

• 论坛模块

• 报名、咨询模块

为了更好的管理代码，我们会把代码分别放在两个模块中存放。

package（包）

一个模块中又有很多的业务，以黑马程序员官方网站的论坛模块为例，至少包含了以下不同的业务。

• 发帖

• 评论

为了把这些业务区分的更加清楚，就会用包来管理这些不同的业务。

class（类）

就是真正写代码的地方。

8.3.3 小结

• 层级关系

  project - module - package - class

• 包含数量

  project中可以创建多个module ​ module中可以创建多个package ​ package中可以创建多个class

  这些结构的划分，是为了方便管理类文件的。

8.4 IDEA中的第一个代码

8.4.1 操作步骤

• 创建Project项目

• 创建Module模块

• 创建class类

• 在类中编写代码

• 完成编译运行

8.4.2 分步图解

• 双击启动图标

• 首先要新建一个项目

  点击creat new project

• 我们要从0开始写代码，所以新建一个空的什么都没有的项目。

  点击左下方的Empty Project

  再点击右下角的next

• 输入项目的名称

  输入项目的存放路径

• 点击ok，IDEA会帮助我们在本地创建一个项目文件夹

• 点击Module，准备新建一个模块

• 点击+

  再点击New Module

• 我们要编写Java代码，所以要新建一个Java模块。

  点击Java

  再点击右下角的next

• 输入模块的名称

  再点击右下角的Next

• 成功新建一个模块之后，中间就会出现刚刚新建的模块

  点击右下角的OK

• 回到主界面

  展开刚刚新建的模块

  右键点击src，选择New，选择Java Class

• 输入类名

  再按回车

• 由于字体比较小

  所以，我们要设置一下字体

  点击File，选择Setting

• 搜索一下font

  在右边可以输入Size的数值来调节代码字体的大小。

  设置完毕后点击右下角的OK

• 编写代码

• 运行代码

  右键空白处，点击Run

• 最下面会弹出控制台。

  所有输出语句中的内容，都会在控制台上展示。

8.5 IDEA中类的相关操作

8.5.1 类的相关操作

• 新建类文件

• 删除类文件

• 修改类文件

8.5.2 新建类文件

• 所有的Java代码都会写在src文件夹当中。

  所以，右键点击src，选择new，点击Java Class

• 输入类名，再按回车

• 新建完毕

8.5.3 修改类名

• 右键点击想要修改的文件

  点击Refactor

  再点击Rename

• 输入想要修改的名字

  输入完毕点击下面的Refactor

• 文件名和类名均已修改成功

8.5.4 删除类文件

• 想要删除哪个文件，就右键点击该文件

  选择Delete即可

• 在弹出的界面中点击OK，确定删除

小贴士：

此时删除是不走回收站的，直接从硬盘中删掉了。

8.6 IDEA中模块的相关操作

8.6.1 模块的相关操作

• 新建模块

• 删除模块

• 修改模块

• 导入模块

8.6.2 新建模块

• 点击File，选择Project Structure

• 选择Module

• 点击+

  选择New Module

• 要创建一个Java模块，所以选择第一个Java

  点击右下角的Next

• 输入模块的名称

  点击右下角的Finish

• 成功新建完毕之后，在中间空白区域就出现了刚刚新建的模块

  点击右下角的OK

• 在主界面中，也会出现刚刚新建的模块

8.6.3 删除模块

• 右键点击模块

  选择Remove Module

• 选择Remove，表示确定删除

• 此时发现，在IDEA列表页面，删除的模块已经不在了。

小贴士：

此时删除仅仅是从IDEA列表中的删除，在本地硬盘中还是存在的。

8.6.4 修改模块

• 右键点击模块名

  选择Refactor

  再选择Rename

• 选择第三个修改模块名和本地文件夹名

  点击OK

• 输入要修改的新的模块名

  输入完毕点击Refactor

• 回到主界面，就发现模块名和文件夹名都已经修改完毕

8.6.5 导入模块

• 点击File，选择Project Structure

• 选择Module

  点击+

  选择Import Module

• 从本地硬盘中选择要导入的模块

  再点击OK

• 不断点击Next

• 如果中间出现提示框，则点击Overwrite

  然后继续点击右下角的Next

• 一直点到finish为止

• 成功导入后，在中间位置就会出现导入的模块信息

• 在主界面中也会出现导入的模块信息

• 展开模块点击模块中的Java文件，会发现代码报错。

  是因为导入模块跟JDK没有关联导致。

• 可以点击右上角的Setup SDK

  再选择已经安装的JDK版本即可

• 导入完毕之后，代码就恢复正常不会报错了

8.7 IDEA中项目的相关操作

8.7.1 项目的相关操作

• 关闭项目

• 打开项目

• 修改项目

• 新建项目

8.7.2 关闭项目

• 点击File，选择Close Project即可

• 刚刚操作的项目就已经关闭了

  左侧是项目列表，如果要再次打开该项目，直接点击即可。

  右侧有create new project，可以再建一个新的项目

• 鼠标放在项目上，后面会出现一个叉。

  如果点击了这里的叉，会在IDEA的列表中删除。不会删除本地硬盘上的项目。

8.7.3 打开项目

• 在本界面还可以打开本地已经存在的项目

  点击Open or Import

• 选择要打开的项目

  点击OK

• 项目就被打开了

8.7.4 修改项目

• 点击File，选择Project Structure

• 在这个界面，默认是Module

  所以，要先点击Project

  在右侧页面中，输入新的项目名称

  修改JDK版本和编译版本都变成JDK14

  再点击OK

• 此时发现，项目名称已经修改完毕

• 但是本地文件夹的名字还没有修改

• 需要先关闭当前项目

• 点击项目后面的叉，从列表中移除项目

• 到本地硬盘中手动修改文件夹的名称

• 点击Open or Import重新打开项目

• 选择修改之后的项目

  点击OK

• 此时会发现，项目名称和本地硬盘文件夹的名称都已经修改完毕了

8.7.5 新建项目

• 点击File

  选择New

  点击Project

• 同样还是创建一个什么都没有的空项目

• 输入项目的名称

  点击右下角的finish

• IDEA循环是否需要帮我们在本地创建一个新的文件夹

  点击OK

• 询问是在本窗口打开还是在一个新的窗口打开。

  可以点击New Window，在一个新的窗口打开。

• 此时就出现了两个窗口，在一个新的窗口打开了新的项目

IDEA的快捷键

选中文件按Delete

选中文件按Shift+Delete可以永久删除

格式化代码快捷键：Ctrl+Alt+L

快捷键：Ctrl+Alt+v自动生成代码左边

三、运算符和表达式

3.1 基本概念

运算符

就是对常量或者变量进行操作的符号。

比如： + - * /

表达式

用运算符把常量或者变量连接起来的，符合Java语法的式子就是表达式。

比如：a + b 这个整体就是表达式。

而其中+是算术运算符的一种，所以这个表达式也称之为算术表达式。

3.2 算术运算符

分类：

+ - * / %

运算特点：

+ - * :跟小学数学中一模一样没有任何区别.

/：
1.整数相除结果只能得到整除，如果结果想要是小数，必须要有小数参数。
2.小数直接参与运算，得到的结果有可能是不精确的。
案例：
System.out.println( 10 / 3);//3
System.out.println(10.0 / 3);//3.3333333333333335

%：取模、取余。
   他做的也是除法运算，只不过获取的是余数而已。
案例：
System.out.println(10 % 2);//0
System.out.println(10 % 3);//1
应用场景：
//可以利用取模来判断一个数是奇数还是偶数
System.out.println(15 % 2);//1  奇数

练习：数值拆分

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

代码示例：

//1.键盘录入一个三位数
//导包 --- 创建对象 --- 接收数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数");
int number = sc.nextInt();//123

//2.获取这个三位数的个位、十位、百位并打印出来
//公式：
//针对于任意的一个数而言
//个位： 数字 % 10
int ones = number % 10;
//十位： 数字 / 10 % 10
int tens = number / 10 % 10;
//百位： 数字 / 100 % 10
int hundreds = number / 100  % 10;

//输出结果
System.out.println(ones);
System.out.println(tens);
System.out.println(hundreds);

公式：

获取任意一个数上每一位数。

个位：数字 % 10

十位：数字 / 10 % 10

百位：数字 / 100 % 10

千位：数字 / 1000 % 10

。。。以此类推。。。

3.3 隐式转换

概念

也叫自动类型提升

就是把一个取值范围小的数据或者变量，赋值给另一个取值范围大的变量。此时不需要我们额外写代码单独实现，是程序自动帮我们完成的.

简单记忆

就是小的给大的，可以直接给.

两种提升规则

• 取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算.

• byte、short、char三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算.

取值范围从小到大的关系

byte short int long float double

3.4 隐式转换的练习

请看下面案例是否有误，如果有问题，请说出原因，如果没有问题，请说出运算过程和运算结果

案例一

double d = 10;
System.out.println(d);//10.0

解释：

10是整数，整数默认是int类型的。

而在取值范围的顺序中：byte short int long float double

在赋值的时候把一个int类型的赋值给了一个double类型的，把一个小的赋值给一个大的是可以直接给的.

案例二

byte b = 100;
int i = b;//可以成功赋值

解释：

因为byte的取值范围是小的，int的取值范围是大的，在底层进行了隐式转换，不需要我们额外写代码单独实现，是可以直接赋值。

案例三

int i = 10;
long n = 20L;
??? result = i + n;
问变量result是什么类型的？

解释：

变量i是int类型的，变量n是long类型的。

而在取值范围的顺序中：byte short int long float double

变量i里面的值会自动提升为long类型的，最终的结果其实就是两个long相加，那么最终的result是long类型的。

案例四

int i = 10;
long n = 100L;
double d = 20.0;
??? result = i + n + d;
问变量result是什么类型的？

解释：

变量i是int类型的，变量n是long类型，变量d是double类型。

而在取值范围的顺序中：byte short int long float double

所以变量i和变量n里面的值在参与运算的时候，都会进行类型提升，变成double。

最终其实就是三个double进行相加，那么最终的结果就是double类型的。

案例五

byte b1 = 10;
byte b2 = 20;
??? result = b1 + b2;//int
问变量result是什么类型的？

解释：

因为b1和b2都是byte类型的，所以在参与计算的时候，变量b1和变量b2里面的值都会自动提升为int类型的。最终其实就是两个int类型的相加，最终结果也是int类型的。

案例六

byte b = 10;
short s = 20;
long n = 100L;
??? result = b + s + n;
问变量result是什么类型的？long

解释：

变量b是byte类型的，变量s是short类型的，变量n是long类型的。

byte，short，char类型的变量在参与运算的时候，变量里面的值会直接先提升为int。

第一步：变量b和变量s里面的值会先提升为int参与运算。

int + int + long

第二步：而long类型的取值范围是大于int的取值范围的。

所以变量b和变量s里面的值会再次提升为long。

long + long + long

所以最终结果是long类型的。

3.5 强制转换

概念

如果要把一个取值范围大的数据或者变量赋值给另一个取值范围小的变量。是不允许直接操作。

如果一定要这么干，就需要加入强制转换。

书写格式

目标数据类型 变量名 = （目标数据类型）被强转的数据；

简单理解：

要转成什么类型的，那么就在小括号中写什么类型就可以了。

案例：

public class OperatorDemo2 {
    public static void main(String[] args) {
        double a = 12.3;
        int b = (int) a;
        System.out.println(b);//12
    }
}

注意点：

强制转换有可能会导致数据发生错误。（数据的精度丢失）

3.6 字符串的+操作

核心技巧

• 当+操作中出现字符串时，此时就是字符串的连接符，会将前后的数据进行拼接，并产生一个新的字符串。

• 当连续进行+操作时，从左到右逐个执行的。

3.7 字符串相加的练习

案例1：

1 + "abc" + 1

结果："1abc1"

解释：

第一步： 1 + "abc"。在这个过程中，有字符串参与的，所以做的是拼接操作，产生一个新的字符串"1abc"

第二步： "1abc" + 1。这个过程中，有字符串参与的，所以做的也是拼接操作，产生一个新的字符串"1abc1"

案例2：

1 + 2 + "abc" + 2 + 1

结果：“3abc21”

解释：

第一步：1 + 2 。在这个过程中，没有字符串参与的，所以做的是加法运算，结果为3。

第二步：3 + "abc"。在这个过程中，有字符串参与的，所以做的是拼接操作，产生一个新的字符串"3abc"。

第三步："3abc" + 2。在这个过程中，有字符串参与的，所以做的是拼接操作，产生一个新的字符串"3abc2"。

第四步："3abc2" + 1。在这个过程中，有字符串参与的，所以做的是拼接操作，产生一个新的字符串“3abc21”

案例3：

String name = "黑默丁格";
System.out.println("我的名字是" + name);

结果： 我的名字是黑默丁格

解释：当字符串跟变量相加的时候，实际上是跟变量里面的值进行拼接。

3.8 字符的+操作

规则

当+操作中出现了字符，会拿着字符到计算机内置的ASCII码表中去查对应的数字，然后再进行计算。

案例

char c = 'a';
int result = c + 0;
System.out.println(result);//97

ASCII码表中：

'a' ----- 97

'A' ----- 65

3.9 算术运算符的总结

分类：

+ - * / %  这些操作跟小学数学几乎是一模一样的。

注意点：

• / 和 % 的区别：他们两个都是做除法运算，/取结果的商。% 取结果的余数。

• 整数操作只能得到整数，如果想要得到小数，必须有浮点数参与运算。

算术运算符的高级用法：

是以+为例进行的讲解，其余减法，乘法，除法的运算规则也是一样的。

特例：字符串只有+操作，没有其他操作。

3.10 自增自减运算符

分类

++  自增运算符
--  自减运算符

++：就是把变量里面的值+1

--：就是把变量里面的值-1

使用方式

• 放在变量的前面，我们叫做先++。 比如：++a

• 放在变量的后面，我们叫做后++。 比如：a++

注意点

不管是先++，还是后++。单独写在一行的时候，运算结果是一模一样的。

案例

int a = 10;
int b = a++;//先用后加,b=10

int a = 10;
int b = ++a;//先加后用,b=11

public class Test{
	public static void main(String[] args){
		int x = 10;
		int y = x++;//把10赋给y,再加1
		int z = ++x;//先把x(11)加1再赋给z
		System.out.println("x:"+x);	//12
		System.out.println("y:"+y);	//10
        System.out.println("Z:"+z);	//12
	}
}

自增自减运算符的应用场景

某些情况下，变量需要进行加1或者减1的时候使用。

比如：过生日多一岁，就用到了自增运算符。

比如：购物商场中，选择商品数量，也用到了自增或者自减运算符。

比如：统计很多数据中，有多少个数据满足要求，也用到了自增运算符。

3.11 赋值运算符

符号：=

运算过程：就是把等号右边的结果赋值给左边的变量

案例

public class OperatorDemo6 {
    public static void main(String[] args) {
        //1.最为简单的赋值运算符用法
        int a = 10;//就是把10赋值给变量a
        System.out.println(a);

        //2.如果等号右边需要进行计算。
        int b = 20;
        int c = a + b;//先计算等号右边的，把计算的结果赋值给左边的变量
        System.out.println(c);

        //3.特殊的用法
        a = a + 10;//先计算等号右边的，把计算的结果赋值给左边的变量
        System.out.println(a);//20
    }
}

3.12 扩展赋值运算符

分类

+=，-=，*=，/=，%=

运算规则

就是把左边跟右边进行运算，把最终的结果赋值给左边，对右边没有任何影响。

案例

public class OperatorDemo7 {
    public static void main(String[] args) {
        //扩展赋值运算符
        int a = 10;
        int b = 20;
        a += b;//把左边和右边相加，再把最终的结果赋值给左边，对右边没有任何影响
        // 相当于 a = a + b;
        System.out.println(a);//30
        System.out.println(b);//20
    }
}

注意点

扩展的赋值运算符中隐层还包含了一个强制转换。

以+=为例。

a += b ;实际上相当于 a = (byte)(a + b);

案例

short s = 1;
s += 1;				
//并不完全等同于s = s + 1,而是等同于s = (short) (s + 1);
System.out.println(s);	//2
//+=,-=,*=,/=,%=都隐藏了一个强制类型转换

public class OperatorDemo8 {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        //a += b;
        a = (byte)(a + b);
        System.out.println(a);//30
    }
}

3.13 关系运算符

分类

符号	解释
==	就是判断左边跟右边是否相等，如果成立就是true，如果不成立就是false
!=	就是判断左边跟右边是否不相等，如果成立就是true，如果不成立就是false
>	就是判断左边是否大于右边，如果成立就是true，如果不成立就是false
>=	就是判断左边是否大于等于右边，如果成立就是true，如果不成立就是false
<	就是判断左边是否小于右边，如果成立就是true，如果不成立就是false
<=	就是判断左边是否小于等于右边，如果成立就是true，如果不成立就是false

注意点

• 关系运算符最终的结果一定是布尔类型的。要么是true，要么是false

• 在写==的时候，千万不要写成=

3.14 逻辑运算符

将5<x<15拆分成x>5&x<15

• &（逻辑与）

• |（逻辑或）

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

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

• ^（逻辑异或） 相同为false，不同为true

• !（逻辑非）

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

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

& 和 | 的使用

&：逻辑与（而且）

两边都为真，结果才是真，只要有一个为假，那么结果就是假。

|：逻辑或（或者）

两边都为假，结果才是假，只要有一个为真，那么结果就是真。

代码示例：

// &  //两边都是真，结果才是真。
System.out.println(true & true);//true
System.out.println(false & false);//false
System.out.println(true & false);//false
System.out.println(false & true);//false

System.out.println("===================================");

// | 或  //两边都是假，结果才是假，如果有一个为真，那么结果就是真。
System.out.println(true | true);//true
System.out.println(false | false);//false
System.out.println(true | false);//true
System.out.println(false | true);//true

使用场景

根据固定的场景，来选择使用&还是使用|

• 用户登录。

  用户名输入正确 & 密码输入正确

  因为只有用户名和密码同时都正确了，那么才能成功登录，只要有一个失败了都不行。

  使用技巧：

  当我们需要同时满足左边和右边两种情况时，可以使用且

• 丈母娘选女婿

  丈母娘：女婿啊，你要么买个房子，要么买辆车。就可以把我的小棉袄穿走了。

  买个房子 | 买辆车

  两个条件中，只要满足其中一个，就可以穿走小棉袄了。

  使用技巧：

  当两种条件只要满足其中一个的时候，可以使用或

^（异或）的使用

在以后用的不多，了解一下即可。

计算规则：如果两边相同，结果为false，如果两边不同，结果为true

代码示例：

//^   //左右不相同，结果才是true，左右相同结果就是false
System.out.println(true ^ true);//false
System.out.println(false ^ false);//false
System.out.println(true ^ false);//true
System.out.println(false ^ true);//true

!（取反）的使用

是取反，也叫做非。

计算规则：false取反就是true，true取反就是false

温馨提示：取反最多只用一个。

代码示例：

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

System.out.println(!!false);//注意点：取反最多只用一个。

3.15 短路逻辑运算符

分类： && ||

&&

运算结果跟&是一模一样的，只不过具有短路效果。

||

运算结果跟|是一模一样的。只不过具有短路效果。

逻辑核心

当左边不能确定整个表达式的结果，右边才会执行。

当左边能确定整个表达式的结果，那么右边就不会执行了。从而提高了代码的运行效率。

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

//||
System.out.println(true || true);//true
System.out.println(false || false);//false
System.out.println(true || false);//true
System.out.println(false || true);//true
int a = 10;
int b = 10;
boolean result = ++a<5 && ++b<5;
System.out.println(result);//false
System.out.println(a);//11
System.out.println(b);//10
int a = 10;
int b = 10;
boolean result = ++a<5 & ++b<5;
System.out.println(result);//false
System.out.println(a);//11
System.out.println(b);//11

举例

• 用户登录案例

  用户名正确 & 密码正确

  如果使用一个&，不管用户名是否正确都会去验证密码。

思考：

如果用户名输入正确了，那么我们再判断密码是否正确，是符合业务逻辑的。

但是如果用户名输入错误了，那么现在还有必要去比较密码吗？没有不要了。

如果使用一个&，那么左边和右边不管什么情况下，都会执行。

用户名正确 && 密码正确

如果用户名输入正确了，那么才会验证密码是否输入正确。

如果用户名输入错误了，那么就不会再去验证密码是否正确，最终的结果直接为false。从而提高了程序运行的效率。

• 丈母娘选女婿

  有房 | 有车

  首先先看看有没有房，发现有，然后再去看看有没有车。

思考：

既然都有房子，干嘛还要去看车呢？多此一举。

有房 || 有车

首先先看看有没有房，如果有，那么右边就不执行了。最终的结果直接为true。

如果没有房子，才会去看右边有没有车。

总结

&& 和 & 、||和|的运行结果都是一模一样的。

但是短路逻辑运算符可以提高程序的运行效率。

建议

最为常用： && || ！

3.16 三元运算符

三元运算符又叫做：三元表达式或者问号冒号表达式

格式

关系表达式 ? 表达式1 : 表达式2;

计算规则

• 计算关系表达式的值

• 如果关系表达式的值为真，那么执行表达式1

• 如果关系表达式的值为假，那么执行表达式2

注意点

三元运算符的最终结果一定要被使用，要么赋值给一个变量，要么直接打印出来

案例

public class OperatorDemo12 {
    public static void main(String[] args) {
        //题目：求两个数的较大值
        int a = 10;
        int b = 20;

        //格式：关系表达式 ？ 表达式1 ： 表达式2 ；
        //注意点：
        //三元运算符的最终结果一定要被使用。
        //要么赋值给一个变量，要么直接输出。
       int max =  a > b ? a : b ;
        System.out.println(max);


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

3.17 练习

练习1-两只老虎

题目

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

代码示例

//1.获取两只老虎的体重
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一只老虎的体重");
int weight1 = sc.nextInt();
System.out.println("请输入第二只老虎的体重");
int weight2 = sc.nextInt();

//2.利用三元运算符求出最终结果
String result = weight1 == weight2 ? "相同" : "不相同";
System.out.println(result);

练习2-求三个数的最大值

题目

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

代码示例

//1.定义三个变量记录和尚的身高
int height1 = 150;
int height2 = 210;
int height3 = 165;

//2.利用三元运算符求出两个数中的较大值。
int temp = height1 > height2 ? height1 : height2;

//3.求出最终的结果
int max = temp > height3 ? temp : height3;

System.out.println(max);

四、判断和循环

4.1 流程控制语句

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

4.1.1 流程控制语句分类

• 顺序结构

• 判断和选择结构(if, switch)

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

4.1.2 顺序结构

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

顺序结构执行流程图：

4.2 if语句

4.2.1 if

格式：
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("小红成为了小明的女朋友");
}

注意

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

2. 如果大括号中的语句体只有一条，那么大括号可以省略不写；如果大括号省略了，那么if只能控制距离他最近的那一条语句。

3. 建议：自己不要去写，如果别人这么写了，你要能看懂即可。

4.2.2 if-else

格式：
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("票号不合法");
}

4.2.3 else-if-else

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

执行流程：

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

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

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

④…

⑤如果没有任何关系表达式为true，就执行语句体n+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("分数不合法");
}

4.3 switch语句

4.3.1 格式

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

4.3.2 执行流程

• 首先计算出表达式的值

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

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

switch

执行流程：

• 首先计算表达式的值

• 依次和case后面的值进行比对，如果由对应的值就会执行相应的语句，在执行过程中，遇到break就会结束。

• 如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后结束整个switch语句

注意：

• 表达式：取值为byte、short、int、char、String类型

• case：后面跟的是和表达式进行比较的值

• break：结束整个switch语句

• case后面只能是字面量不能是变量，不能重复

switch (day){
    case 1:
        System.out.println("跑步");
    case 2:
        System.out.println("游泳");
    case 3:
        System.out.println("慢走");
    case 4: 
        System.out.println("动感单车");
    case 5:
        System.out.println("拳击");
    case 6: 
        System.out.println("爬山");
    case 7: 
        System.out.println("好好吃一段");
    default:
        System.out.println("没有这一天");
}

default的省略和位置

省略：可以缺省，但是不建议

位置：最好放在最后面

case穿透

case中缺省了break

如果有多个case语句重复了，可以用case穿透来简化代码

switch (n){
    case 1:
        System.out.println("一");
    case 2:
        System.out.println("二");
    case 3:
        System.out.println("三");
    default:
        System.out.println("没有该选项");
}

switch新特性(JDK12)

switch (n){
        case 1 -> System.out.println("一");
        case 2 -> System.out.println("二");
        case 3 -> System.out.println("三");
        default -> System.out.println("四");
}

另：switch语句的结果可以作为右值赋给变量

if语句通常应用于某个范围当中，而switch语句通常应用于有限个值并可以列举

switch (week){
    case 1,2,3,4,5 -> System.out.println("工作日");
    case 6,7 -> System.out.println("休息日");
    default -> System.out.println("没有这一天");
}

练习：运动计划

题目

键盘录入星期数，显示今天的减肥活动。

周一：跑步

周二：游泳

周三：慢走

周四：动感单车

周五：拳击

周六：爬山

周日：好好吃一顿

代码

package a01switch选择语句;

import java.util.Scanner;

public class SwitchDemo2 {
    public static void main(String[] args) {
        //1.键盘录入一个整数表示星期
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数表示星期");
        int week = sc.nextInt();

        //2.书写一个switch语句去跟week进行匹配
        switch (week){
            case 1:
                System.out.println("跑步");
                break;
            case 2:
                System.out.println("游泳");
                break;
            case 3:
                System.out.println("慢走");
                break;
            case 4:
                System.out.println("动感单车");
                break;
            case 5:
                System.out.println("拳击");
                break;
            case 6:
                System.out.println("爬山");
                break;
            case 7:
                System.out.println("好好吃一顿");
                break;
            default:
                System.out.println("输入错误，没有这个星期");
                break;
        }
    }
}

4.3.3 switch的扩展知识

• default的位置和省略情况

  default可以放在任意位置，也可以省略

• case穿透

  不写break会引发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-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;
}
----------------------------------------------------
利用JDK12简化代码书写
switch (week) {
    case 1, 2, 3, 4, 5 -> System.out.println("工作日");
    case 6, 7 -> System.out.println("休息日");
    default -> System.out.println("没有这个星期");
}

4.4 循环结构

4.4.1 for循环

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

格式

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

格式解释

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

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

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

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

执行流程

①执行初始化语句

②执行条件判断语句，看其结果是true还是false

如果是false，循环结束

如果是true，继续执行

③执行循环体语句

④执行条件控制语句

⑤回到②继续

for循环书写技巧

• 确定循环的开始条件

• 确定循环的结束条件

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

代码示例

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

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

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

练习1 输出数据

题目

在控制台输出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);
		}
    }
}

练习2 求和

题目

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

本题要点：

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

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

练习3-求偶数和

题目

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

练习4-统计次数

题目

键盘录入两个数字,表示一个范围
统计这个范围中:既能被3整除,又能被5整除数字有多少个?

代码

4.4.2 while循环

格式

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

练习1：打印5次HelloWorld

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

练习2：珠穆朗玛峰

//1.定义一个变量表示珠穆朗玛峰的高度
int height = 8844430;
//2.定义一个变量表示纸张的厚度
double paper = 0.1;

//定义一个计数器（变量），用来统计折叠的次数
int count = 0;

//3.循环折叠纸张
//只有纸张的厚度 < 穆朗玛峰的高度 循环才继续，否则循环就停止
//坑：只有判断为真，循环才会继续
while(paper < height){
    //折叠纸张
    paper = paper * 2;
    count++;
}

//4.打印一下纸张的厚度
System.out.println(count);//27

4.4.3 do...while循环

这里了解即可，几乎用不到

格式

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

特点

先执行，再判断

4.4.4 三种循环的区别

for和while循环，是先判断，再执行。

do...while是先执行，再判断。

当知道循环次数或者循环范围的时候，用for循环。

当不知道循环次数，也不知道循环范围，但是知道循环的结束条件时，用while循环。

4.4.5 无限循环

概念

又叫死循环，循环一直停不下来。

for格式

for(;;){
    System.out.println("循环执行一直在打印内容");
}

解释：

初始化语句可以空着不写，表示循环之前不定义任何的控制变量。

条件判断语句可以空着不写，如果不写，默认表示true，循环一直进行。

条件控制语句可以空着不写，表示每次循环体执行完毕后，控制变量不做任何变化。

while格式

while(true){
    System.out.println("循环执行一直在打印内容");
}

解释：

小括号里面就不能省略了，true一定要写出来，否则代码会报错。

do...while格式

do{
    System.out.println("循环执行一直在打印内容");
}while(true);

解释：

小括号里面就不能省略了，true一定要写出来，否则代码会报错。

注意事项

• 最为常用的格式：while

• 无限循环下面不能再写其他代码了，因为永远执行不到。

4.5 条件控制语句

break

不能单独存在的。可以用在switch和循环中，表示结束，跳出的意思。

代码示例：

//1.吃1~5号包子
for (int i = 1; i <= 5; i++) {
    System.out.println("在吃第" + i + "个包子");
    //2.吃完第三个的时候就不吃了
    if(i == 3){
        break;//结束整个循环。
    }
}

continue

不能单独存在的。只能存在于循环当中。

表示：跳过本次循环，继续执行下次循环。

代码示例：

//1.吃1~5号包子
for (int i = 1; i <= 5; i++) {
    //2.第3个包子有虫子就跳过，继续吃下面的包子
    if(i == 3){
        //跳过本次循环（本次循环中，下面的代码就不执行了），继续执行下次循环。
        continue;
    }
    System.out.println("在吃第" + i + "个包子");
}

4.6 循环练习

练习一：逢七过

题目

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

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

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

举例

1 2 3 4 5 6 过 8 9 10 11 12 13 过 15 16 过 18 ...

代码

/*朋友聚会的时候可能会玩一个游戏：逢7过
        游戏规则：从任意一个数字开始报数，当你要报的数字是包含7或者是7的倍数时都要说过：过
        题目：使用程序在控制台打印出1-100之间的满足逢七必过规则的数据*/
//分析：
//个位7  十位7   7倍数
//1 2 3 4 5 6 过 8 9 10 11 12 13 过 15 16 过 18 19 20 过....
//69 过 过 过 过 过 过... 80
//1.得到1~100之间的每一个数字
//开始：1
//结束：100
for (int i = 1; i <= 100; i++) {
    //2.判断每一个数字，如果符合规则，就打印过，如果不符合规则就打印真实的数字
    if(i % 10 == 7 || i / 10 % 10 == 7  ||  i % 7 == 0){
        System.out.println("过");
        continue;
    }
    System.out.println(i);
}

练习二：平方根

题目

键盘录入一个大于等于2的整数x,计算并返回 x 的 平方根 。结果只保留整数部分,小数部分将被舍去

代码

/*题目：键盘录入一个大于等于2的整数 x ，计算并返回 x 的 平方根 。
        结果只保留整数部分 ，小数部分将被舍去 。*/


//分析：
//平方根   16的平方根4
//         4的平方根2


// 10
// 1 * 1 = 1 < 10
// 2 * 2 = 4 < 10
// 3 * 3 = 9 < 10
// 4 * 4 = 16 > 10
//推断：10的平方根是在3~4之间。


// 20
// 1 * 1 = 1 < 20
// 2 * 2 = 4 < 20
// 3 * 3 = 9 < 20
// 4 * 4 = 16 < 20
// 5 * 5 = 25 > 20
//推断：20的平方根是在4~5之间。


//在代码当中
//从1开始循环，拿着数字的平方跟原来的数字进行比较
//如果小于的，那么继续往后判断
//如果相等，那么当前数字就是平方根
//如果大于的，那么前一个数字就是平方跟的整数部分


//1.键盘录入一个整数
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int number = sc.nextInt();
//2.从1开始循环判断
//开始：1 结束: number
for (int i = 1; i <= number; i++) {
    //用i * i 再跟number进行比较
    if(i * i == number){
        System.out.println(i + "就是" + number + "的平方根");
        //一旦找到了，循环就可以停止了，后面的数字就不需要再找了，提高代码的运行效率。
        break;
    }else if(i * i > number){
        System.out.println((i - 1) + "就是" + number + "平方根的整数部分");
        break;
    }
}

练习三：判断是否为质数

题目

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

代码

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

//质数：
//如果一个整数只能被1和本身整除，那么这个数就是质数。否则这个数叫做合数
//7 = 1 * 7 质数
//8 = 1 * 8  2 * 4 合数


//分析：
//1.键盘录入一个正整数
//number
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个正整数");
int number = sc.nextInt();//9

//定义一个变量，表示标记
//标记着number是否为一个质数
//true： 是一个质数
//false : 不是一个质数

//表示最初就认为number是一个质数
boolean flag = true;


//2.判断
//写一个循环，从2开始判断，一直判断到number-1为止
//看这个范围之内，有没有数字可以被number整除
for (int i = 2; i < number; i++) {
    //i 依次表示这个范围之内的每一个数字
    //看number是否能被i整除就可以了
    if(number % i == 0){// 9 % 2 = 1
        flag = false;
        //System.out.println(number + "不是一个质数");
        break;
    }/*else{
                System.out.println(number + "是一个质数");
            }*/
}

//只有当这个循环结束了，表示这个范围之内所有的数字都判断完毕了
//此时才能断定number是一个质数
if(flag){
    System.out.println(number + "是一个质数");
}else{
    System.out.println(number + "不是一个质数");
}

练习四：猜数字小游戏

题目

程序自动生成一个1-100之间的随机数,在代码中使用键盘录入去猜出这个数字是多少？
使用循环猜，一直猜中为止

思路分析

1. 生成一个1-100之间的随机数
2. 使用键盘录入去猜出这个数字是多少
3. 把反复猜的代码写在循环中

代码

//1.生成一个1-100之间的随机数
Random r = new Random();
int number = r.nextInt(100) + 1;// 0 ~ 99 + 1 --- 1 ~ 100
System.out.println(number);
​
//2.使用键盘录入去猜出这个数字是多少？
Scanner sc = new Scanner(System.in);
while(true){
    System.out.println("请输入一个整数");
    int guessNumber = sc.nextInt();
    //3.比较
    if(guessNumber > number){
        System.out.println("您猜的数字大了");
    }else if(guessNumber < number){
        System.out.println("您猜的数字小了");
    }else{
        System.out.println("恭喜你，猜中了");
        break;
    }
}

4.7 补充-Random

使用步骤

1. 导包

import java.util.Random;
// 导包的动作必须出现在类定义的上边

1. 创建对象

Random r = new Random ();
// 上面这个格式里面，只有r是变量名，可以变，其他的都不允许变

1. 生成随机数

int number = r.nextInt(随机数的范围);
// 上面这个格式里面，只有number是变量名，可以变，其他的都不允许变
// 随机数范围的特点：从0开始，不包含指定值。比如：参数为10，生成的范围[0,10)

代码示例1

//1.导包
import java.util.Random;
​
public class RandomDemo1 {
    public static void main(String[] args) {
        //2.创建对象
        Random r = new Random();
        //3.生成随机数
        int number = r.nextInt(100);//包左不包右，包头不包尾
        //0 ~ 99
        System.out.println(number);
​
    }
}

若为r.nextInt(10)，则表明要生成的数的范围在0-9之间

如何生成任意区间的随机数呢？例如，我们要生成7-15之间的任意数，可以

int number = r. nextInt(9) + 7;

代码示例2

//1.生成一个1-100之间的随机数
Random r = new Random();
int number = r.nextInt(100) + 1;// 0 ~ 99 + 1 --- 1 ~ 100
System.out.println(number);

//2.使用键盘录入去猜出这个数字是多少？
Scanner sc = new Scanner(System.in);
while(true){
    System.out.println("请输入一个整数");
    int guessNumber = sc.nextInt();
    //3.比较
    if(guessNumber > number){
        System.out.println("您猜的数字大了");
    }else if(guessNumber < number){
        System.out.println("您猜的数字小了");
    }else{
        System.out.println("恭喜你，猜中了");
        break;
    }
}