本文主要是介绍java入门上部，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
java入门上部
人机交互
CMD
**CMD:**在windows中，利用命令行的方式操作计算机。可以打开文件，打开文件夹，创建文件夹等等
打开CMD
打开步骤：
1、Win + R, 出现运行窗口
2、在运行窗口输入 CMD, 应输入小写 cmd
3、 然后按 Enter(回车)， 在C:\Users\287557> 后输入CMD的常见命令
常见CMD命令
-
盘符名称 + 冒号
说明：盘符切换
举例：E:回车，表示切换到E盘
-
dir
说明：查看当前路径下的内容
- cd + 目录/文件夹名
说明：进入单级目录
举例：cd 作业
-
cd…
说明：回退到上一级目录
-
cd 文件夹1\文件夹2…
说明：进入多级目录
举例：cd 作业\操作系统
-
cd \
说明：回退到盘符目录。
-
cls
说明：清屏。
-
exit
说明:退出命令提示符窗口
配置环境变量
把qq的路径记录在电脑的环境变量
把软件的路径配置到环境变量中，可以在任意的目录下打开指定的软件
配置环境变量步骤：
此电脑——空白处右键——属性——收索高级系统设置——高级——环境变量——系统变量——path——编辑——添加路径
java基础语法
java入门
什么是java?
Java是一门面向对象编程语言，不仅吸收了 C++语言的各种优点，还摒弃了 C++里难以理解的多继承、指针等概念，因此 Java语言具有功能强大和简单易用两个特征。Java语言>>>作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。
Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立性与可移植性、多线程、动态性等特点。Java可以编写桌面应用程、Web应用程序、分布式系统和嵌入式系统应用程序等。
Java程序初体验
HelloWorld案例的编写
1、用记事本编写程序
2、编译（翻译）文件
3、运行程序
- 编译：javac是JDK提供的编译工具，我们可以通过这个工具，把当前路径下的==.java文件编译成.class==文件
- 运行：java提供一个工具，作用是运行代码，运行.class这个文件夹
BUG
- 中英文符号问题
- 单词拼写，大小写
环境变量
配置环境变量：
此电脑——空白处右键——属性——收索高级系统设置——高级——环境变量——系统变量——新建——变量名（N）：JAVA_HOME +变量值（V）：D:\JDK\jdk8（java.exe和javac.exe所在目录，去掉bin)——点击确定——Path——新建——%JAVA_HOME%\bin——点击确定
Notepad软件
常见的高级记事本：
Editplus、Notepad++、Sublime等
Java开发工具、用途、特性
Java SE
Java SE是java语言的（标准版），用于桌面应用的开发，是其它两个版本的基础。
**桌面应用：**用户只需打开程序，程序的界面会让用在最短的时间内找到他们需要的功能，同时主动带领用户完成他们的工作并得到最好的体验。
学习Java SE的目的是为今后从事的Java EE开发，打基础。
Java ME
Java ME是java语言的（小型版），用于嵌入式电子设备或者小型移动设备。
Java EE
Java EE是java语言的（企业版），用于Web方向的网站开发。
**网站开发：**浏览器+服务器。
Java能做什么？
1、**桌面应用开发：**开发各种各样的工具，如各种税务管理软件，IDEA、Clion、Pycharm、WebStorm（前端开发工具）、PhpStorm(Php开发工具)
2、**企业及应用开发：**微服务、springcloud、淘宝，京东，阿里云(企业级应用：开发服务器)
3、**移动应用的开发：**鸿蒙、android、医疗设备控制管理程序
4、**科学计算工具：**matlab
5、**大数据开发：**hadoop框架
6、**游戏开发：**我的世界MineCraft
Java的特性
- 面向对象：根据模板，把东西创建出来
- 安全性
- 多线程：通俗讲就是同时做多件事情
- 简单易用
- 开源：(1)不开源，例如下载一个QQ,仅仅下载的是QQ的安装包，腾讯公司不会把代码给你
(2)开源，当我们下载Java开发的工具的时候，Orck公司也会把代码给你，安装包和代码都要下载。一旦开源，世界上所有Java的开发者都可以维护Java.
- 跨平台：跨平台中的平台指的是操作系统，Windows、Mac（苹果电脑操作系统）、Linux。跨平台指Java程序可以在任意操作系统上运行
Write Once Run Anywhere 一次编译，到处运行
高级语言的编译运行方式
编程、编译、运行
- **编程：**java程序员写的.java代码，c程序员写的.c代码，python程序员写的.py代码
- **编译:**机器只认01机器语言，把.java、.c、.py的代码做转化让机器认识的过程
- **运行：**让机器执行编译后的指令
高级语言的编译运行方式
- 编译型
- 解释型
- 混合型，半编译，半解释
编译型
c\c++不跨平台
解释型
Python开源
混合型
-
java不是直接运行在系统中的，而是运行在虚拟机中的
-
java语言的跨平台是通过虚拟机实现的
-
针对于不同的操作系统，安装不同的虚拟机就可以了
JRE和JDK
JVM (Java Virtual Machine):Java 虚拟机，真正运行Java程序的地方
开发工具：
- javac编译工具
- java运行工具
- jdb调试工具
- jhat内存分析工具
…
**核心类库：**java已经写好的东西
JDK(Java Development kit):Java开发工具包，用于编写代码，由JVM、核心类库和开发工具组成。
JRE (Java Runtime Environment ): Java的运行环境，与JDK相似，JRE也是由JVM、核心类库、开发工具组成，但区别在于，组成 JRE的开发工具较 JDK少。例如，JRE的开发工具中不需要 javac编译工具，不需要 jdb调试工具，因为在 JRE中运行的是编译后的 .class文件。
Java基础概念
注释
-
**注释：**是在程序指定位置添加的说明性信息，简单理解，就是对代码进行解释说明的文字。
-
注释分类：
-
单行注释：
格式：//注释信息 -
多行注释：
格式：/*注释信息*/ -
文档注释：
格式：/**注释信息**/
-
-
注意：
-
注释的内容不参与编译，也不参与运行，仅仅是对代码的解释说明
-
不管是单行注释还是多行注释，在书写的时候都不要嵌套
-
关键字
**关键字：**被 Java 赋予特定涵义的英文单词
特点:
- 关键字的字母全部小写
- 常用的代码编辑器，针对关键字有特殊的颜色标记，非常的壮观
**关键字class:**用于（创建/定义）一个类，后面跟随类名，类是Java最基本的组成单元
关键字 return：
- 方法没有返回值：可以省略不写。如果书写，表示结束方法
- 方法有返回值：必须要写。表示结束方法和返回结果
字面量（常量）
**字面量:**数据在程序中的类型
| 字面量类型 | 说明 | 举例 |
|---|---|---|
| 整数类型（int) | 不带小数点的数字 | 666、-88 |
| 小数类型（double) | 带小数点的数字 | 13.14、-5.21 |
| 字符串类型（string) | 用双引号括起来的内容，内容可以为空 | “HelloWorld”、“黑马程序员”、" " |
| 字符类型（char) | 用单引号括起来的，内容只能有一个 | ‘A’、‘0’、‘我’、‘b’ |
| 布尔类型（boolean) | 布尔值，表示真假 | 只有两个值：true, false |
| 空类型 | 一个特殊的值，空值 | 值是：null |
**细节：**null不能直接打印
如果我们要打印null，那么只能用字符串的形式进行打印
扩展点：
‘\t’、‘\r’、‘\n’、…
1、\t 制表符：
在打印的时候，把前面字符串的长度补齐到8，或者8的倍数。最少补1个空格，最多补8个空格。
public class HelloWorld{public static void main (String[] args){System.out.println("abc" + '\t'); //字符串长度为3，'\t' 表示补5个空格System.out.println("abcd" + '\t'); //字符串长度为4，'\t' 表示补4个空格}
}
**作用：**打印时让数据对齐
public class HelloWorld{public static void main (String[] args){System.out.println("nameage"); System.out.println("tom23"); }
}打印效果：
nameage
tom23
public class HelloWorld{public static void main (String[] args){System.out.println("name" + '\t' + "age"); System.out.println("tom" + '\t' + "23"); }
}打印效果：
name age //name后补4个空格
tom 23 //tom后补5个空格
变量
**变量：**在程序的执行过程中，其值有可能发生改变的量（数据）
**变量的使用场景：**当某个数据经常发生改变时，我们也可以用变量存储。当数据变化时，只要修改变量里面记录的值即可。
变量的定义格式：
数据类型 变量名 = 数据值；"=":作用“赋值”
public class VariableDemo1{//主入口public static void main (String[] args){//定义变量//数据类型 变量名 = 数据值；int a = 12;//输出 a 的值System.out.println(a);}
}运行结果：12
变量的使用方式：
1、输出打印
2、参与计算
3、修改记录的值
public class VariableDemo2{//主入口public static void main (String[] args){//数据类型 变量名 = 数据值；//1、基本用法int a = 12;//输出 a 的值System.out.println(a);System.out.println(a);//2、变量参与计算int b = 15;int c = 20;System.out.println(b + c);//3、修改变量记录的值a = 21;System.out.println(a);System.out.println("---------------);//注意事项//在- 一条语句可以定义多个变量int d = 100,e = 200,f = 300;System.out.println(d);System.out.println(e);System.out.println(f);int g;//System.out.println(g);报错，变量使用前未赋值g = 600;System.out.println(g);}
}运行结果：
12
12
35
21
--------------------
100
200
300
注意事项：
- 只能存一个值
- 变量名不允许重复定义
- 一条语句可以定义多个变量
- 变量在使用之前一定要进行赋值
- 变量的作用域范围==(变量只能在所属的方法里面有效)==
变量练习：
public class VariableTest{//主函数入口public static void main(String[] args){//定义乘客数量变量,并初始化int counter = 0;//第一站，上一个乘客counter = counter + 1;//第二站，上两个乘客，下一位乘客counter = counter + 2 - 1;//第三站，上两个乘客，下一位乘客counter = counter + 2 - 1;//第四站，下一位乘客counter = counter - 1;//第五战，上一位乘客counter = counter + 1;//输出终点站乘客人数System.out.println(counter);}
}运行结果：
3
计算机的存储规则
**计算机中的3类数据：**文本数据、图片数据、声音数据
-
Text文本，文本数据
-
数字、字母、汉字
-
计算机的存储规则
-
数字：转二进制
-
字母：查询码表
-
汉字：查询码表
-
-
-
Image图片，图片数据
- 黑白图、灰度图、彩色图
- 通过每个像素点中的RGB三原色来存储
- 黑白图、灰度图、彩色图
-
Sound声音，声音数据
- 对声音的波形图进行采样再存储
在计算机中，任意数据都是以二进制的形式来存储的
不同进制在代码中的表现形式：
- 二进制：由 0 和 1 组成，代码中以0b开头
- 十进制；由 0 ~ 9 组成，前面不加任何后缀
- 八进制：由 0 ~ 7 组成，代码中以 0 开头
- 十六进制：由 0 ~ 9 还有 a ~ f 组成，代码中以 0x 开头
显示器的三个知识点：（图片存储）
- 分辨率：2K、4K
- 常见2K，1920*1080，在显示器上宽有1920个小格子，高有1080个小格子，一个小格子成为一个像素
- 常见4K，3840*2160，
- 像素
- 光学三原色
- 红、绿、蓝。也称之为TGB
- 写成十进制形式：（255，255，255）
- 写成十六进制形式：（FF,FF,FF)
数据类型
数据类型的分类：
-
基本数据类型
-
数据类型 关键字 取值范围 字节型 byte -128~127 短整型 short -32768~32768 长整型 long -9223372036854775808~9223372036854775807 整型 int(默认) -2147483648~2147483647 单精度浮点型 float -3.401298e-38~3.402823e+38 双精度浮点型 double(默认) -4.9000000e-324~1.797693e+308 字符型 char 0~65535 布尔型 boolean true, flase 注意:
-
1、在定义 long 类型的变量，在数据值后面需要加上一个 L 作为后缀
long n = 999999L;
2、在定义 float 类型的变量，在数据值后面需要加上一个 F 作为后缀
float f = 10.1F
3、double > float > long > int > short > byte
4、字符型
package just.test;public class Test3 {public static void main(String[] args) {char a = 'a';char b = ++a;char c = (char)99;System.out.println(b);System.out.println(c);}}运行结果：bc
<img src="D:/学习makedown/Java(2)插入的图片/基本数据类型.jpg" alt="基本数据类型" style="zoom:33%;" />
-
引用数据类型
只要是 new 出来的，都是 引用数据类型
例如：数组
练习：
1、练习：输出老师的信息
public class VariableTest2{//主入口public static void main(String[] args){//姓名string name = "黑马谢广坤";//年龄int age = 18;//性别char gender = '男';//身高double height = 180.1;//是否结婚,true表示结婚boolean flag = true;//输出变量的值System.out.println(name);System.out.println(age);System.out.println(gender);System.out.println(height);System.out.println(flag);}
}输出结果：
黑马谢广坤
18
男
180.1
true
标识符
**标识符：**就是给类、方法、变量等起的名字。做到，见名知意。
标识符命名规则—硬性要求
- 由 数字、字母、下划线(_) 和 美元符($) 组成
- 不能以数字开头
- 不能是关键字
- 区分大小写
标识符命名规则—软性要求
小驼峰命名法：方法、变量
-
规范1：标识符是一个单词 的时候，全部小写
-
范例1：name
-
规范2：标识符有多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写
-
范例2：firstName
大驼峰命名法：类名
- 规范1：标识符是一个单词 的时候，首字母大写**
- 范例1：Student
- 规范2：标识符有多个单词组成的时候，每个单词的首字母大写
- 范例2：GoodStudent
键盘录入
**键盘录入介绍：**Java帮我们写好一个类叫 Scanner,这个类就可以接收键盘输入的数字
Scanner使用步骤：
- 步骤一:导包 — Scanner 这个类在哪
import java.util.Scanner;导包的动作必须出现在类定义的上边
- 步骤二：创建对象 — 表示我要开始用 Scanner 这个类
Scanner sc = new Scanner(System.in);上面这个格式里面，只有 sc 是变量名，可以变，其他的都不允许变。
- 步骤三：接收数据 — 真正开始干活
int i = sc.nextInt();左面这个格式里面，只有i是变量名，可以变，其他的都不允许变
//导包，写在类定义的上面import java.util.Scanner;public class ScannerDemo1{public static void main(String[] args){//创建对象Scanner sc = new Scanner(System.in);System.out.println("请输入整数：");//接收数据//接收数据的代码sc.nextInt()，在键盘输入什么，sc.nextInt()就接受什么。再把接收到的结果，赋值给左边的变量,int i = sc.nextInt();//变量 i 记录了键盘录入的数据System.out.println("输出结果：");System.out.println(i);}}运行结果：请输入整数：1234输出结果：1234
**练习：**键盘输入数字并求和
需求：键盘录入两个整数，求出它们的和并打印出来。
//导包inport java.unit.Scanner;public class ScannerDemo2{public static void main(String[] args){//创建对象Scanner sc = new Scanner(System.in);//输入两个整数System.out.println("请输入第一个数字：");int number1 = sc.nextInt();System.out.println("请输入第二个数字：");int number2 = sc.nextInt();System.out.println("输出两整数之和：");System.out.println(number1 + number);}}运行结果：请输入第一个数字：12请输入第二个数字：21输出两整数之和：33IDEA
第一套体系
package Just.test;import java.util.Scanner;public class Test3 {public static void main(String[] args) {//键盘录入//第一套体系//nextInt(); 接收整数//nextDouble; 接受小数//next(); 接收字符串//遇到空格，制表符，回车就停止接收。这些符号后面的数据就不会接受了Scanner sc = new Scanner(System.in);System.out.println("请输入一个整数");int num1 = sc.nextInt();System.out.println(num1);System.out.println("请输入第二个整数");int num2 = sc.nextInt();System.out.println(num2);System.out.println();System.out.println("请输入一个字符串");String arr1 = sc.next();System.out.println(arr1);System.out.println("请输入第二个字符串");String arr2 = sc.next();System.out.println(arr2);System.out.println();}
}
====================================================
运行结果：
请输入一个整数
123 456
123
请输入第二个整数
456请输入一个字符串
asd fgjk
asd
请输入第二个字符串
fgjk
第二套体系
package Just.test;import java.util.Scanner;public class Test3 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);//第二套体系//nextLine(); 接收字符串//可以接收空格、制表符，遇到回车才停止接受数据System.out.println("请输入一个字符串");String line1 = sc.nextLine();System.out.println(line1);System.out.println("请输入第二个字符串");String line2 = sc.nextLine();System.out.println(line2);}
}
==========================================================================
运行结果：
请输入一个字符串
asd fghh
asd fghh
请输入第二个字符串
asdfgghh 12555
asdfgghh 12555
输出
sout
1、换行输出：
System.out.println();
2、非换行输出
System.out.print();
souf
非换行输出
System.out.printf("");
souf 输出的参数分为两部分：
(1) 第一部分参数：要输出的内容 + %s (占位)
(2) 第二部分参数：填充的数据
package Just.test;
package Just.test;public class Test2 {public static void main(String[] args) {//souf 两部分参数//第一部分参数：要输出的内容 + %s(占位）//第二部分参数：填充的数据System.out.printf("你好啊%s","张三");//第一部分：你好啊%s 第二部分填充数据：张三System.out.println();//换行System.out.printf("%s你好啊%s","张三","李四");//两个占位，需要对应两个 填充数据}
}
IDEA简介
IDEA概述：IDEA全称 IntelliJ IDEA, 是用于Java语言开发的集成环境，它是业界公认的目前用于 Java 程序开发最好的工具。
集成环境：把代码编写**，编译，执行，调试等多种功能综合到一起的开发工具
IDEA下载和安装
**下载：**https//www.jetbrains.com/idea/
**安装：**建议修改安装路径
IDEA项目结构介绍
1、project(项目)
2、module(模块)，各模块相互独立
3、package(包)，包就是文件夹，在模块里面建很多包，把功能相同的代码放在一个包中
- 第一个文件夹(包)——存放与文字相关的代码
- 第二个文件夹(包)——存放与图片相关的代码
- 第三个文件夹(包)——存放与动画相关的代码
- 第四个文件夹(包)——存放与==…==相关的代码
4、class(类)
总的结构：
project(项目)
module(模块)
package(包)
class(类)
IDEA使用步骤：
New Project——Empty Protect——Next——Project name（给项目取名字）——Project location(项目地址，后面一定要是 \ + 项目名称)——Finish——Modules——点击右上方" + "号——>New Module——Java——Next——Module name(模块名字)——Finish——Ok——展开模块——右键src——New—>———>Package——给“包”起名字（规则：公司域名反写+包的作用——右键包——New——Java Class——输入类名——
- 在给包命名时，一个" . ",代表一级包
快捷键
psvm + 回车
psvm + 回车 自动输入：public static void main(String[] args)
main + 回车
main + 回车 自动输入：public static void main(String[] args)
sout + 回车
sout + 回车 自动输入：System.out.println();
Ctrl + Alt + M
Ctrl + Alt + M 自动抽取方法
Ctrl + d
复制 + 换行
Ctrl + a
Ctrl + a 全选
alt + Fn + insert
alt + Fn + insert ——> Constructor(构造器)——> Select None——> 生成无参构造器
alt + Fn + insert ——> Constructor(构造器)——> 按住 Shift ，点击最下面的那个(Ctrl + a)——> Ok——> 生成有参构造器
alt + Fn + insert ——> Getter and Setter——> Ctrl + a ——>生成每一个私有化成员变量对应的 get 和 set 方法
Ctrl + 左键
Ctrl + 左键 跳转到所选择对象在代码中出现的其他位置
Ctrl + p
Ctrl + p 显示方法参数
Ctrl + b
先选中 ，然后 Ctrl + b 看源码
先选中，然后 Ctrl + b 位移
Ctrl + Alt + t
先选中，然后 Ctrl + Alt + t 选循环
Alt + 鼠标左键
Alt + 鼠标左键， 批量选择
Ctrl + Alt + v
左键选中类中调用的方法 Ctrl + Alt + v 自动生成左边内容
Alt + 回车
选中 Alt + 回车 自动导包
点击报错红线 Alt + 回车 提供解决方案
Ctrl + n
Ctrl + n 输入要搜索的对象，可以查看源码
Ctrl + r
Ctrl + r 更换变量的名字
IDEA的项目和模块操作
IDEA中类相关操作：
1、新建类：想把类新建在哪个包中，就右键那个包，然后 New —— Java.Class——写类名——回车
2、删除类：想删除哪个类，就右键那个类，然后 Delete…——Ok
3、修改类名：想修改哪个类，就右键那个类，然后选择 Refactor——Rename…，点击——弹出小窗，进行修改——点击 Refactor
IDEA中模块相关操作：
1、新建模块：File —— Porject Structure ——Modules ——中间点击 " + "——New Module——Java——Next——Module name(模块名字)——Finish——Yes——Ok.
在某模块时，建立新的模块时，此时模块并立，当新建的模块有类声明后，可以把新模块remove…， 然后单独打开
模块的内容根和模块文件位置一定是：\项目名称\模块名
2、删除模块：
3、修改模块：
4、导入块：
IDEA中项目相关操作：
打开 IntelliJ IDEA 时，默认打开上次操作的项目，
1、关闭项目：关闭某个项目，先选中要关闭的项目，然后点击 File ——Close Project——点击
2、新建项目：New Project——Empty Protect——Next——Project name（给项目取名字）——Project location(项目地址，后面一定要是 \ + 项目名称)——Finish——Yes
3、打开项目：
4、修改项目：
运算符
运算符与表达式
**运算符：**对字面量或者变量进行操作的符号
表达式: 用运算符把字面量或者变量连接起来，符合Java语法和式子就可以称为为表达式。不同运算符连接起来的表达式体现的是不同类型的表达式。
举例说明：
int a = 12;
int b = 15;
int c = a + b;
" + " : 是运算符，并且是算术运算符
“a + b” 是表达式，由于" + " 是算术运算符，所以这个表达式叫算术表达式
算术运算符
基本用法
算术运算符：
| 符号 | 作用 | 说明 |
|---|---|---|
| + | 加 | |
| - | 减 | |
| * | 乘 | |
| / | 除 | 取结果的 商 |
| % | 取余、取模 | 取结果的 余数 |
注意:
-
整数参与运算只能得到整数
-
当有小数参与运算时，计算结果可能不准确
-
取模的应用场景
- 1、可以用取模来判断，A 是否可以被 B 整除。 A % B
- 2、可以判断 A 是否为偶数。 A % 2，结果为 0 ，则 A 为偶数，结果为 1，则 B 为奇数
练习：
需求：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台
公式总结：
个位：数值 / 1 % 10
十位：数值 / 10 % 10
百位：数值 / 100 % 10
千位：数值 / 1000 % 10
…
package Just.test;import java.util.Scanner;public class Test1 {public static void main(String[] args) {//键盘录入一个三位数，获取其中的个位十位百位//1、键盘录入Scanner sc = new Scanner(System.in);System.out.println("请输入一个三位数");int number = sc.nextInt();//2、获取个位、十位、百位int unit = number % 10;int decade = number / 10 % 10;int hundred = number / 100 % 10;System.out.println("输出三位数的个位、十位、百位");System.out.println(unit);System.out.println(decade);System.out.println(hundred);}
}请输入一个三位数
289
输出三位数的个位、十位、百位
9
8
2
高级用法
" + " : 操作的三种情况
1、数字的 " + " 操作
-
数字进行运算时，数据类型不一样不能运算，需要转成一样的，才能运算
-
隐式转换(自动类型提升)
- 把一个取值范围小的数值，转成取值范围大的数据
- 取值范围 (由小到大）：byte——>short——>int——>long——>float——>double
- 隐式转换的两种提升原则：
- 取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算
- byte 、short 、char 三种类型的数据在运算的时候，都会直接先提升为 int ，然后再进行运算
-
强制转换：
-
如果把一个取值范围的数值，赋值给取值范围小的变量。是不允许直接赋值的，如果一定要这么做，就需要加入强制转换。
-
格式：目标数据类型 变量名 = （目标数据类型） 被强转的数据;
-
范例：
- 范例1
-
-
double a = 123;int b = (int)a;
- 范例2
package Just.arithmeticoperator;public class ArithmeticoperatorDemo3 {public static void main(String[] args) {byte b1 = 10;byte b2 = 12;//把 b1 + b2 的和转成 byte 类型byte result = (byte)(b1 + b2);System.out.println(result);}}运行结果：22
2、字符串的 " + " 操作
-
当 " + "操作中出现字符串时，这个 " + " 是字符串连接符，而不是算术运算符了。会将前后的数据进行拼接，并产生一个新的字符串。
-
范例：
“123” + 123 ——> “123123”
-
-
连续进行 " + " 操作时，从左到右逐个执行
-
范例：
1 + 99 + “年黑马” ——>100 + “年黑马” —— “100年黑马”
-
-
练习：
System.out.println(3.7 + "abc");//"3.7abc"System.out.println("abc" + true);//"abctrue"System.out.println('中' + "abc" + true);//"中abctrue"int age = 18;System.out.println("我的年龄是" + age + "岁" );//"我的年龄是18岁"System.out.println("我的年龄是" + "age" + "岁");//"我的年龄是age岁"System.out.println(1 + 2 + "abc" + 2 +1);//"3abc21"
3、字符的 “ + ” 操作
-
当 字符 + 字符 // 字符 + 数字 时，会把字符通过 ASCII 码表查询到对应的数字再进行计算。
-
练习：
System.out.println(1 + 'a'); // 1 + 97System.out.println('a' + "abc"); //"aabc"
自增自减运算符
基本用法
| 符号 | 作用 | 说明 |
|---|---|---|
| ++ | 加 | 变量的值加 1 |
| – | 减 | 变量的值减 1 |
注意事项：
++ 和 --即可以放在变量的前面，也可以放在变量的后面。
两种用法：
1、单独使用
++ 和 – 无论是放在变量的前面还是后面，单独写一行 结果是一样的。
2、参与计算
-
++
- 后 ++，先用后加
int a = 10;int b = a++;结果：a = 11;b = 10;
- 前 ++，先加后用
int a = 10;int b = ++a;结果：a = 11;b = 11;
-
–
- 后 --，先用后减
int a = 12;int b = a--;结果：a = 11;b = 12;
-
先 --，先减后用
int a = 12; int b = --a;结果： a = 11; b = 11;
赋值运算符
分类：
| 符号 | 作用 | 说明 |
|---|---|---|
| = | 赋值 | int a =10 ; 将10的值赋给a |
| += | 加后赋值 | a += b , 及 a = a + b; |
| -= | 减后赋值 | a -= b , 及 a = a - b; |
| *= | 乘后赋值 | a *= b , 及 a = a * b; |
| /= | 除后赋值 | a /= b , 及 a = a / b; |
| %= | 取余后赋值 | a %= b , 及 a = a % b; |
注意： +=、-=、*=、/= 和 %= ，底层都隐藏了一个强制类型的转换
关系(比较）运算符
关系 / 比较 运算符的分类：
| 符号 | 说明 |
|---|---|
| == | a == b ,判断 a 和 b 的值是否相等，成立为 true, 不成立为 false |
| ！= | a != b ,判断 a 和 b 的值是否不相等，成立为 true, 不成立为 false |
| > | a > b ,判断 a 是否大于 b, 成立 true, 不成立 flase |
| >= | a >= b ,判断 a 是否大于等于 b，成立 true, 不成立 flase |
| < | a < b , 判断 a 是否 小于 b , 成立 true, 不成立 flase |
| <= | a <= b , 判断 a 是否 小于等于 b , 成立 true, 不成立 flase |
注意事项：
- 关系运算符的结果都是boolean类型，要么是 true ,要么是 false。
- 千万不要把 " == " ,误写成 " = "
练习：约会
需求：
你和你的约会对象在餐厅里面正在约会。
键盘录入两个整数，表示你和你约会对象衣服的时髦度。（手动录入 0 ~ 10 之间的整数，不能录入其他）
如果你的时髦程度大于你对象的时髦程度，相亲成功，输出 true。
否则输出 false。
package Just.test;import java.util.Scanner;public class Test2 {public static void main(String[] args) {//键盘录入两个整数表示衣服的时髦度Scanner sc = new Scanner(System.in);System.out.println("请输入我们自己的衣服时髦度：");int myFashion = sc.nextInt();System.out.println("请输入相亲对象衣服的时髦度：");int girlFashion = sc.nextInt();//比较结果boolean result = myFashion > girlFashion;System.out.println(result);}
}运行结果：
请输入我们自己的衣服时髦度：
5
请输入相亲对象衣服的时髦度：
4
true
逻辑运算符
分类：
| 符号 | 作用 | 说明 |
|---|---|---|
| & | 逻辑与（且） | 并且，两边都为真，结果才是真 |
| | | 逻辑或 | 或者，两边都为假，结果才是假 |
| ^ | 逻辑异或 | 相同为 flase ,不同为 true |
| ! | 逻辑非 | 取反 |
package Just.logicoperator;public class LogicoperatorDemo1 {public static void main(String[] args) {// & 并且，两边都为真，结果才真System.out.println(true & true);//trueSystem.out.println(false & false);//flaseSystem.out.println(true & false);//flaseSystem.out.println(false & true);//flase// | 或，两边都为假，结果才是假System.out.println(true | true);//trueSystem.out.println(false | false);//flaseSystem.out.println(true | false);//trueSystem.out.println(false | true);//true// ^ 异或，相同为 false,不同为 trueSystem.out.println(true ^ true);//flaseSystem.out.println(false ^ false);//flaseSystem.out.println(true ^ false);//trueSystem.out.println(false ^ true);//true// !，逻辑非，取反System.out.println(!false);//trueSystem.out.println(!true);//flase}
}
短路逻辑运算符
分类：
| 符号 | 作用 | 说明 |
|---|---|---|
| && | 短路 与 | 结果和 & 相同，但是有短路效果 |
| || | 短路 或 | 结果和 | 相同，但是有短路效果 |
package Just.logicoperator;public class LogicoperatorDemo3 {public static void main(String[] args) {//&& 与System.out.println(true && true);//trueSystem.out.println(false && false);//falseSystem.out.println(true && false);//falseSystem.out.println(false && true);//falseSystem.out.println();// || 或System.out.println(true || true);//trueSystem.out.println(false || false);//falseSystem.out.println(true || false);//trueSystem.out.println(false || true);//trueSystem.out.println();//短路逻辑运算符具有短路效果，当左边的表达式能确定最终的结果，那么右边就不会参与运行int a = 10;int b = 10;boolean result = ++a < 5 && ++b < 5;System.out.println(result);//falseSystem.out.println(a);//11System.out.println(b);//10System.out.println();//a = 10;b = 10;boolean result1 = ++a < 5 & ++b < 5;System.out.println(result1);//falseSystem.out.println(a);//11System.out.println(b);//11}
}
注意事项：
- && : 左边为 false ,右边不管是真是假，整个表达式的结果一定是 false
- || : 左边为 true ,右边不管是真是假，整个表达式的结果一定是 true
- 最常用的逻辑运算符：&& , || , !
练习：数字6
需求：
数字6是一个真正伟大的数字，键盘录入两个整数。
如果其中一个为6，最终结果输出 true
如果他们的和为6的倍数。最终结果输出true
其他情况都是false
package Just.test;import java.util.Scanner;public class Test3 {public static void main(String[] args) {//键盘录入Scanner sc = new Scanner(System.in);System.out.println("输入第一个数：");int number1 = sc.nextInt();System.out.println("输入第二个数：");int number2 = sc.nextInt();int sum = number1 + number2;boolean result = number1==6 || number2==6 || sum % 6==0;System.out.println(result);}
}运行结果：
输入第一个数：
3
输入第二个数：
2
false
三元运算符
（三元运算符 / 三元表达式）格式
- 格式：关系表达式==？表达式1：==表达式2；
范例：求两个数的较大值
int max = a > b ? a : b ; //结果赋值给变量System.out.println(a > b ? a : b); //结果直接打印
package Just.ternaryoperator;public class TernaryoperatorDemo1 {public static void main(String[] args) {//定义两个变量int number1 = 12;int number2 = 15;//使用三元运算符获取两个整数中的较大值int max = number1 > number2 ? number1 : number2;System.out.println(max);}
}
**练习：**两只老虎
需求：动物园里有两只老虎，体重分别为通过键盘录入获得，
请用程序实现判断两只老虎的体重是否相同。
package Just.test;import java.util.Scanner;public class Test4 {public static void main(String[] args) {//键盘录入两只老虎的体重Scanner sc = new Scanner(System.in);System.out.println("请输入第一只老虎的体重：");int weight1 = sc.nextInt();System.out.println("请输入第二纸老虎的体重：");int weight2 = sc.nextInt();//输出结果String result = weight1 == weight2 ?"相同" : "不相同";System.out.println(result);}
}运行结果：
请输入第一只老虎的体重：
158
请输入第二纸老虎的体重：
149
不相同
**练习：**三个和尚
需求：一座寺庙里住着三个和尚，以知他们的身高
分别为150cm、210cm、165cm，
请用程序实现获取这三个和尚的最高身高
package Just.test;public class Test5 {public static void main(String[] args) {//三个和尚的身高int height1 = 150;int height2 = 210;int height3 = 165;//获取三个和尚最高身高int temp = height2 > height3 ? height2 : height3;int result = height1 > temp ? height1 : temp;//输出System.out.println("三个和尚的最高身高为：");System.out.println(result);}
}运行结果：
三个和尚的最高身高为：
210
运算符的优先级
注意： ( ) 优先于所有，写代码时，想让谁优先计算，直接用 ( ), 括起来。
原码、反码、补码
**源码：**十进制数据的二进制表现形式 ，最左边是符号位 ，0为正 ，1为负。
**反码：**正数的反码是其本身 ，负数的反码是符号位保持不变 ，其余位取反，0——>1 , 1——>0。
**补码：**正数的补码是其本身，负数的补码是在其反码的基础上 + 1。
bit ：比特位，二进制的基本单位；
1 字节 = 8 比特位
判断和循环
流程控制语句
顺序结构
顺寻结构语句是 Java 程序默认的执行流程，按照代码的先后顺序，从上到下依次执行
package Just.orderdemo;public class OrderDemo {public static void main(String[] args) {System.out.println("床前明月光");System.out.println("疑是地上霜");System.out.println("举头望明月");System.out.println("低头思故乡");}
}运行结果：
床前明月光
疑是地上霜
举头望明月
低头思故乡
分支结构
If
If 语句 ：表示判断
1、If 语句的第一种格式：
if (关系表达式){语句体；
}
执行流程：
- 首先计算关系表达式的值
- 如果关系表达式的值为 true ,就执行语句体
- 如果关系表达式的值为 false ,就不执行语句体
- 继续执行后面的其他语句
**练习：**老丈人选女婿
需求：键盘录入女婿酒量，如果大于2斤，老丈人给出回应，反之不回应
package Just.ifDemo;import java.util.Scanner;public class IfDemo1 {public static void main(String[] args) {//键盘录入女婿酒量Scanner sc = new Scanner(System.in);System.out.println("请输入女婿的酒量：");int wine = sc.nextInt();//对酒量进行判断if(wine > 2){System.out.println("小伙子，不错呦！！");}}
}运行结果：
请输入女婿的酒量：
3
小伙子，不错呦！！注意事项：
- 大括号的开头可以另起一行书写，但是建议写在第一行的末尾
- 在语句体中，如果只有一句代码，大括号可以省略不写。个人建议，大括号还是不要省略
- 如果对一个布尔类型的变量进行判断，不要用 == 号，直接把变量写在小括号里即可
**练习：**自动驾驶，红灯停，绿灯行，黄灯等
package Just.test;public class Test2 {public static void main(String[] args) {//定义灯的状态boolean isLightGreen = false;boolean isLightYellow = false;boolean isLightRed = true;//输出车的行为if(isLightGreen){System.out.println("GoGoGo!!!");}if(isLightYellow){System.out.println("Wait!!!");}if(isLightRed){System.out.println("Stop!!!");}}
}运行结果：
Stop!!!
2、If 语句的第二种格式
if (关系表达式){语句体1；
}else{语句体2；
}
执行流程：
- 首先计算关系表达式的值
- 如果关系表达式的值为 true 就执行语句体1
- 如果关系表达式的值为 false 就执行语句体2
- 继续执行后面的其他语句
**练习：**吃饭
需求：键盘录入一个整数，表示身上的钱。如果大于等于100块，就吃网红餐厅。否则，就吃经济实惠的沙县小吃。
package Just.test;import java.util.Scanner;public class Test3 {public static void main(String[] args) {//键盘录入身上的钱Scanner sc = new Scanner(System.in);System.out.println("请输入身上的钱：");int money = sc.nextInt();if(money > 100){System.out.println("吃网红餐厅");}else{System.out.println("吃沙县小吃");}}
}运行结果：
请输入身上的钱：
88
吃沙县小吃
**练习：**商品付款
在实际开发中，如果要根据两种不同的情况来执行不同的代码，就需要用到 if 的第二种格式。
需求：
假设，用户在超市实际购买商品总价为：600元。
键盘录入一个整数表示用户实际支付的钱。
如果付款大于等于600，表示付款成功。否则付款失败。
package Just.test;import java.util.Scanner;public class Test4 {public static void main(String[] args) {//键盘录入支付的钱Scanner sc = new Scanner(System.in);System.out.println("请输入顾客所实际支付的钱：");int pay = sc.nextInt();if(pay > 600){System.out.println("付款成功");}else{System.out.println("付款失败");}}
}运行结果：
请输入顾客所实际支付的钱：
666
付款成功
**练习：**影院选座
在实际开发中，电影院选座也会使用到 if 判断。
建设某影院售卖了100张票，票的序号为1~ 100。
其中奇数票号坐左侧，偶数票号坐右侧。
键盘录入一个整数表示电影票的票号。
根据不同情况，给出不同的提示：
如果票号是奇数，那么打印坐左边；
如果票号为偶数，那么打印坐右边。
package Just.test;import java.util.Scanner;public class Test5 {public static void main(String[] args) {//键盘录入票号Scanner sc = new Scanner(System.in);System.out.println("请输入票号：");int member = sc.nextInt();//判断票号的真假if(member > 0 && member <=100){//判断位置if(member % 2==0){System.out.println("坐右边");}else{System.out.println("坐左边");}}else{System.out.println("票号为假");}}
}运行结果：
请输入票号：
102
票号为假请输入票号：
66
坐右边
3、If 语句的第三种格式
if (关系表达式1){语句体1；
}else if(关系表达式2){语句体2；
}...else{语句体 n + 1;
}
执行流程：
- 首先计算关系表达式1的值
- 如果为 true 就执行语句体 1；如果为 false 就计算关系表达式 2的值
- 如果为 true 就执行语句体 2 ；如果为 false 就计算关系表达式3的值
- …
- 如果所有关系表达式结果都为 false ,就执行语句体 n + 1
总结：
从上往下依次进行判断
只要有一个判断为真，就执行对应的语句体
如果所有的判断都为假，就执行 else 的语句体
**练习：**小明的礼物
根据不同的分数送不同的礼物。
如果是 95 ~ 100分，送自行车一辆
如果是 90 ~ 94分，送游乐场玩一天
如果是 80 ~ 89分，送变形金刚一个
如果是 80 分及以下，揍一顿。
package Just.test;import java.util.Scanner;public class Test6 {public static void main(String[] args) {//键盘录入小明的成绩Scanner sc = new Scanner(System.in);System.out.println("输入小明的成绩为：");double score = sc.nextDouble();if(score > 0 && score <= 100){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("录入的成绩不合法");}}
}运行结果：
输入小明的成绩为：
88
送变形金刚一个输入小明的成绩为：
120
录入的成绩不合法
**练习：**商品的价格
在实际开发中，多种情况判断时，会用到 if 的第三种格式：
需求：
商场都会有 VIP 的会员制，根据不同的会员会有不同的折扣
建设商品的总价为1000
键盘录入会员级别，并计算实际支付的钱
会员 1 级：打9折
会员 2 级：打8折
会员 3 级：打7折
非会员：不打折
package Just.test;import java.util.Scanner;public class Test7 {public static void main(String[] args) {//定义变量记录总价int price = 1000;//键盘录入会员等级Scanner sc = new Scanner(System.in);System.out.println("输入会员的等级：");int grade = sc.nextInt();if(grade == 1){System.out.println("会员 1 级，打 9 折");System.out.println("需要支付： " + price * 0.9);}else if(grade == 2){System.out.println("会员 2 级，打 8 折");System.out.println("需要支付： " + price * 0.8);}else if(grade == 3){System.out.println("会员 3 级，打 7 折");System.out.println("需要支付： " + price * 0.7);}else{System.out.println("非会员，不打折");} }
}运行结果：
输入会员的等级：
3
会员 3 级，打 7 折
需要支付： 700.0输入会员的等级：
1
会员 1 级，打 9 折
需要支付： 900.0输入会员的等级：
5
非会员，不打折
需要支付： 1000
4、总结：
- if 的第一种格式，适用于一种情况的判断
- if 的第二种格式，适用于两种情况的判断
- if 的第三种格式，适用于多种情况的判断
switch
switch 语句格式：
switch(表达式){case 值1：语句体1；break;case 值2：语句体2；break;case 值3：语句体3；break;...default:语句体 n + 1;break;
}
执行过程：
- 首先计算表达式的值。
- 依次和 case 后面的值进行比较，如果有对应的值，就会执行相应的语句，在执行过程中，遇到 break 就会结束。
- 如果所有的 case 后面的值和表达式的值都不配，就会执行 default 里面的语句体，然后结束整个 switch 语句。
格式说明：
- 表达式 ：（将要匹配的值）取值为 byte、short、int、char。JDK5以后可以是枚举，JDK7以后可以是 String.
- case : 后面跟的是要和表达式进行比较的值（被匹配的值）
- break : 表示中断，结束的意思，用来结束 switch 语句。
- default : 表示所有情况都不匹配的时候，就执行该处的内容，和 if 语句的 else 相似。
- case : 后面的值只能是字面量，不能是变量
- case : 给出的值不允许重复。
package Just.switchdemo;import java.util.Scanner;public class SwitchDemo1 {public static void main(String[] args) {//键盘录入想吃的面Scanner sc = new Scanner(System.in);System.out.println("输入想吃的面：");String noodles = sc.next();//输入字符串型变量switch(noodles){case "兰州拉面":System.out.println("吃兰州拉面");break;case "武汉热干面":System.out.println("吃武汉热干面");break;case "北京杂酱面":System.out.println("吃北京杂酱面");break;case "陕西油泼面":System.out.println("吃陕西油泼面");break;default:System.out.println("吃方便面");break;}}
}运行结果：
输入想吃的面：
武汉热干面
吃武汉热干面
练习：运动计划
需求：键盘录入星期数，显示今天的减肥活动。
周一：跑步
周二：游泳
周三：慢走
周四：动感单车
周五: 拳击
周六：爬山
周日：好好吃一顿
package Just.test;import java.util.Scanner;public class Test9 {public static void main(String[] args) {//键盘录入星期Scanner sc = new Scanner(System.in);System.out.println("输入今天的星期数：");int number = sc.nextInt();switch (number){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;}}
}运行结果：
输入今天的星期数：
3
漫步输入今天的星期数：
8
没有这个星期数
switch 其他知识点
1、default 的位置和省略
- 位置：default 不一定是写在最下面的，我们可以写在任意位置。只不过习惯写在最下面
package Just.switchdemo;public class SwitchDemo2 {public static void main(String[] args) {int number = 10;switch (number){case 1:System.out.println("number 的值为 1");break;default:System.out.println("number 的值不是 1，10或者20");break;case 10:System.out.println("number 的值为 10");break;case 20:System.out.println("number 的值为 20");break;}}}运行的结果：number 的值为 10
- 省略：default 可以省略，语法不会有问题，但是不建议省略。
package Just.switchdemo;public class SwitchDemo2 {public static void main(String[] args) {int number = 1;switch (number){case 1:System.out.println("number 的值为 1");break;case 10:System.out.println("number 的值为 10");break;case 20:System.out.println("number 的值为 20");break;}}}运行结果：number 的值为 1
2、case 穿透
-
case 穿透：就是语句体中没有写 break 导致的
-
执行流程：
首先还是会拿着小括号中表达式的值跟下面每一个 case 进行匹配。
如果匹配上了，就会执行对应的语句体，如果此时发现了 break ,那么结束整个 switch 语句
如果没有发现 break ，那么程序会继续执行下一个 case 的语句体，一直遇到 break 或者大括号为止
-
使用场景：
如果多个 case 的语句体重复了，那么我们考虑用 case 穿透去简化代码。
package Just.switchdemo;public class SwitchDemo3 {public static void main(String[] args) {int number = 10;switch (number){case 1:System.out.println("number 的值为 1");break;case 10:System.out.println("number 的值为 10");//break;case 20:System.out.println("number 的值为 20");break;default:System.out.println("number 的值不是 1，10或者20");break;}}
}运行结果：
number 的值为 10
number 的值为 20
3、switch新特性
省略
4、switch 和 if 第三种格式各自的使用场景
- if 的第三种格式：一般用于对范围的判断
- switch 把有限个数据 一 一 列举出来，让我们任选其一
**练习：**休息日和工作日
需求：键盘录入星期数，输出工作日、休息日。
(1 - 5)工作日，(6 - 7)休息日
package Just.test;import java.util.Scanner;public class Test10 {public static void main(String[] args) {//键盘录入星期数Scanner sc = new Scanner(System.in);System.out.println("输入星期数：");int week = sc.nextInt();switch (week){case 1:case 2:case 3:case 4:case 5:System.out.println("工作日");break;case 6:case 7:System.out.println("休息日");break;}}
}运行结果：
输入星期数：
5
工作日
**练习：**用户选择
在实际开发中，如果我们需要在多种情况下选择其中一个，就可以使用 switch 语句。
当我们拨打了某些服务电话时，一般都会有按键选择。
假设现在我们拨打了一个机票预订电话。
电话中语音提示：
1、机票查询
2、机票预定
3、机票改签
4、退出服务
其他按键也是退出服务。请使用 switch 模拟该业务逻辑。
package Just.test;import java.util.Scanner;public class Test11 {public static void main(String[] args) {//键盘录入我们的选择Scanner sc = new Scanner(System.in);System.out.println("请输入所选择序号：");int chose = sc.nextInt();switch(chose){case 1:System.out.println("机票查询");break;case 2:System.out.println("机票预订");break;case 3:System.out.println("机票改签");break;case 4:System.out.println("退出服务");break;default:System.out.println("退出服务");break;}}
}运行结果：
请输入所选择序号：
2
机票预订请输入所选择序号：
8
退出服务
循环结构
for循环
格式：
for(初始化;条件判断;条件控制){循环体语句；
}
执行流程：
1、执行初始化语句
2、执行条件判断语句，看其结果是 true 还是 false
如果是 false ，循环结束
如果是 true ， 执行循环体语句
3、执行条件控制语句
4、回到 2 继续执行条件判断语句
注意：
- 初始化语句只执行一次
- 判断语句为 true ,循环继续
- 判断语句为 false ，循环结束
package Just.loopdemo;public class ForDemo1 {public static void main(String[] args) {for(int i = 0 ;i < 5 ;i++){System.out.println("HelloWorld");}}
}运行结果：
HelloWorld
HelloWorld
HelloWorld
HelloWorld
HelloWorld
package Just.test;public class Test12 {public static void main(String[] args) {for(int i = 1;i <= 5;i++){System.out.print(i);}System.out.println();for(int i = 1;i <= 5;i++){System.out.print(6 - i);}}
}运行结果：
12345
54321
**练习：**断线重连
在实际开发中，需要重复执行的代码，会选择循环实现
比如：玩游戏的时候，如果网不好那么会经常断线重连
那么断线重连这个业务逻辑就需要重复执行。
假设现在公司要求，断线重连的业务逻辑最多只写 5 次
请用代码实现：
备注：断线重连的业务逻辑可以用输出语句替代。
package Just.test;public class Test13 {public static void main(String[] args) {for(int i = 1;i <= 5;i++){System.out.println("第" + i +"次执行断线重连的业务逻辑");}}
}运行结果：
第1次执行断线重连的业务逻辑
第2次执行断线重连的业务逻辑
第3次执行断线重连的业务逻辑
第4次执行断线重连的业务逻辑
第5次执行断线重连的业务逻辑
**练习：**求和
需求：在实际开发中，如果要获取一个范围中的每一个数据时，也会用到循环。
比如：求 1 - 5 之间的和
package Just.test;public class Test14 {public static void main(String[] args) {int sum = 0;for(int i = 1;i <= 50;i++){sum = sum + i;// System.out.println(sum);}System.out.println("输出累加的和为：");System.out.println(sum);}
}运行结果：
输出累加的和为：
1275注意：
如果我们把变量定义在循环的里面，那么当前变量只能在本次循环中有效
当本次循环结束之后，变量就会从内存中消失
第二次循环开始的时候，又会重新定义一个新的变量。
**练习：**求和
需求：在实际开发中，如果要获取一个范围中的每一个数据时，会用到循环。
但是此时，大多数情况下，不会获取所有的数据，而是获取其中符合要求的数据。
此时就需要循环和其他语句结合使用了。
比如:求 1 - 100 之间的偶数和
package Just.test;public class Test15 {public static void main(String[] args) {int sum = 0;for(int i = 1;i <= 100;i++){if(i % 2 == 0){sum = sum + i;}}System.out.println("输出 1~100之间的偶数和");System.out.println(sum);}
}运行结果：
输出 1~100之间的偶数和
2550
**练习：**统计满足条件的数字
需求：键盘录入两个数字，表示一个范围
统计这个范围中。
既能被 3 整除，用能被 5 整除数字有多少个？
package Just.test;import java.util.Scanner;public class Test16 {public static void main(String[] args) {//键盘录入两个数字Scanner sc = new Scanner(System.in);System.out.println("请录入一个数字表示范围的开始：");int start = sc.nextInt();System.out.println("请录入一个数字表示范围的结束：");int end = sc.nextInt();//定义统计变量int number = 0;for(int i = start;i <=end;i++ ){if(i % 3 == 0 && i % 5 == 0 ){System.out.print(i + "、");number = number + 1;}}System.out.println();System.out.println("输出能被3和5同时整除的个数；");System.out.println(number);}
}运行结果：
请录入一个数字表示范围的开始：
20
请录入一个数字表示范围的结束：
60
30、45、60、
输出能被3和5同时整除的个数；
3
while
while 循环的执行流程
初始化语句；
while (条件判断语句){循环体语句；条件控制语句；
}
循环下面的其他语句
注意：
- 初始化语句只执行一次
- 判断语句为 true ,循环继续
- 判断语句为 false,循环结束
package Just.whiledemo;public class WhileDemo1 {public static void main(String[] args) {//打印换行变量int number = 0;int i = 1;while(i <= 100){System.out.print(i + "、 " );number++;//每行10个数字if(number % 10 == 0){System.out.println();}i++;}}
}运行结果：
1、 2、 3、 4、 5、 6、 7、 8、 9、 10、
11、 12、 13、 14、 15、 16、 17、 18、 19、 20、
21、 22、 23、 24、 25、 26、 27、 28、 29、 30、
31、 32、 33、 34、 35、 36、 37、 38、 39、 40、
41、 42、 43、 44、 45、 46、 47、 48、 49、 50、
51、 52、 53、 54、 55、 56、 57、 58、 59、 60、
61、 62、 63、 64、 65、 66、 67、 68、 69、 70、
71、 72、 73、 74、 75、 76、 77、 78、 79、 80、
81、 82、 83、 84、 85、 86、 87、 88、 89、 90、
91、 92、 93、 94、 95、 96、 97、 98、 99、 100、
for 和 while 的对比
***相同点：***运行规则都是一样的
for 和 while 的区别：
- for 循环中：知到循环次数或者循环的范围
- while 循环：不知道循环的次数和范围，只知道循环的结束条件
**练习：**打印折纸的次数
需求：世界最高峰是珠穆朗玛峰（8844.43米=8844430毫米），假如我有一张足够大的纸，它的厚度是0.1毫米。
请问，我折叠多少次，可以折成珠穆朗玛峰的高度？
package Just.test;public class Test17 {public static void main(String[] args) {//计数器 numberint number = 0;//纸张的初始厚度double i = 0.1;while(i <= 8844430){//折一次，纸张厚度为原来的两倍i = i * 2;//每折一次，计数器计数加一number = number + 1;}System.out.println("输出纸张折叠的次数: ");System.out.println(number);}
}运行结果：
输出纸张折叠的次数:
27
**练习：**回文数
需求：给你一个整数 x。
如果 x 是一个回文数，打印 true ，否则，返回 false
解释：回文数是指正序(从左到右) 和倒序(从右到左)读都是一样的整数。
例如，121是回文数，而123不是
package Just.test;public class Test18 {public static void main(String[] args) {//定义数字int x = 12345;int temp = x;//记录倒过来之后的结果int number = 0;while (x != 0){//从右往左获取每一个数字int unit = x % 10;//修改一下 x 记录的值x = x / 10;//把当前获取的数字拼接到最右边number = number * 10 + unit;}System.out.println("12345反过来为；");System.out.println(number);System.out.println("判断是否为回文数：");System.out.println(number == temp);}
}运行结果：
12345反过来为；
54321
判断是否为回文数：
false
**核心思路:**把数字倒过来跟原来的数字进行比较。
**练习：**求商和余数
需求：给定两个整数，被除数和除数(都是正数，且不超过 int 的范围)。
将两数相除，要求不使用乘法、除法和 % 运算符。
得到商和余数。
package Just.test;import java.util.Scanner;public class Test19 {public static void main(String[] args) {//键盘录入被除数和除数Scanner sc = new Scanner(System.in);System.out.println("键盘录入被除数：");int dividend = sc.nextInt();System.out.println("键盘录入除数：");int divisor = sc.nextInt();//记录商和余数int discuss = 0;int remainder = 0;while(dividend >=divisor){dividend = dividend - divisor;discuss = discuss + 1;}remainder = dividend;System.out.println("输出商为：");System.out.println(discuss);System.out.println("输出余数为：");System.out.println(remainder);}
}键盘录入被除数：
61
键盘录入除数：
15
输出商为：
4
输出余数为：
1
do…while
格式:
初始化语句；
do{循环体语句；条件控制语句；
}while(条件判断语句)
注意：
- 限制性后判断
循环高级综合练习
无限循环
**无限循环：**循环一直停不下来
1、for 循环的无限循环
for( ; ; ){System.out.println("学习")；
}
2、while 循环的无限循环
while(true){System.out.println("学习")；
}
3、do…while 循环的无限循环
do{System.out.println("学习")；
}while(true)
**注意：**最常用 while 无限循环
package Just.infiniteloopDemo;public class InfiniteloopDemo1 {public static void main(String[] args) {//for 格式的无限循环/*for(;;){System.out.println("学习");}*///while 格式的无限循环while(true){System.out.println("sb");}}
}
注意事项：
无限循环的下面不能再写其他代码了，因为循环永远停不下来，那么下面的代码永远都执行不到
跳转控制语句
1、continue 结束本次循环，继续下次循环
**练习：**小老虎吃包子
小老虎吃包子，第三个包子有虫子，跳过。
package Just.infiniteloopDemo;public class InfiniteloopDemo2 {public static void main(String[] args) {for(int i = 1;i <= 5;i++){if(i == 3){//结束本次循环，继续下次循环continue;}System.out.println("小老虎在吃第" + i + "个包子");}}
}运行结果：
小老虎在吃第1个包子
小老虎在吃第2个包子
小老虎在吃第4个包子
小老虎在吃第5个包子
2、break结束整个循环
**练习:**小老虎吃包子
小老虎吃包子，吃完第三个就饱了
package Just.infiniteloopDemo;public class InfiniteloopDemo3 {public static void main(String[] args) {for(int i = 1;i <= 5;i++){System.out.println("小老虎在吃第" + i + "个包子");if(i == 3){//结束整个循环break;}}}
}运行结果：
小老虎在吃第1个包子
小老虎在吃第2个包子
小老虎在吃第3个包子
3、return
**ruturn 😗*其实跟循环没有什么关系，跟方法有关的，表示 1 结束循环、2 返回结果
如果方法执行到了 return,那么整个方法全部结束，里面的循环也会随之结束了。
**练习：**判断是否存在
需求：定义一个方法判断数组中的某个数是否存在，将结果返回个调用处
import java.util.Scanner;public class Test7 {public static void main(String[] args) {//定义一个数组int[] arr = {12,34,56,78,90,58,39,42,93,63,81};//输入待判定的数Scanner sr = new Scanner(System.in);System.out.println("输入待判定的数:");int number = sr.nextInt();System.out.println(contains(number,arr));}//定义一个方法，判断数组中的数是否存在，将结果返回给调用处public static boolean contains(int number,int[] arr){for (int i = 0; i < arr.length; i++) {if(number == arr[i]) {return true;}}return false;}
}运行结果：
输入待判定的数:
90
true
练习
**练习1：**逢7过
朋友聚会的时候可能会玩一个游戏：逢7过
游戏规则:从任意一个数字开始报数，当你要报的数字是包含 7 或者是 7 的倍数时都要说： 过
需求：使用程序在控制台打印出 1 - 100 之间的满足逢 7 必过规则的数据
package Just.test;public class Test1 {public static void main(String[] args) {int number = 0;for(int i = 1;i <= 100;i++){number++;if(i % 7 ==0||i % 10 == 7||i / 10 ==7){System.out.print( "过、");if(number % 10 == 0){System.out.println();}continue;}System.out.print(i + "、");if(number % 10 == 0){System.out.println();}}}
}运行结果：
1、2、3、4、5、6、过、8、9、10、
11、12、13、过、15、16、过、18、19、20、
过、22、23、24、25、26、过、过、29、30、
31、32、33、34、过、36、过、38、39、40、
41、过、43、44、45、46、过、48、过、50、
51、52、53、54、55、过、过、58、59、60、
61、62、过、64、65、66、过、68、69、过、
过、过、过、过、过、过、过、过、过、80、
81、82、83、过、85、86、过、88、89、90、
过、92、93、94、95、96、过、过、99、100、
**练习2：**求平方根
需求：键盘录入一个大于等于 2 的整数 x ，计算并返回 x 的平方根。
结果只保留整数部分，小数部分将被舍去
import java.util.Scanner;public class Test2 {public static void main(String[] args) {//键盘录入一个大于2的数Scanner sc = new Scanner(System.in);System.out.println("键盘录入大于 2 的数是：");int number = sc.nextInt();for(int i = 1;i <= number;i++){if(i * i <= number&& (i +1)*(i + 1) > number){System.out.println("输出" + number + "平方根的整数部分：");System.out.println(i);}}}
}运行结果：
键盘录入大于 2 的数是：
20
输出20平方根的整数部分：
4
public class Test2 {public static void main(String[] args) {//键盘录入一个大于2的数Scanner sc = new Scanner(System.in);System.out.println("键盘录入大于 2 的数是：");int number = sc.nextInt();for(int i = 1;i <= number;i++){if(i * i == number){System.out.println("输出" + number + "平方根的整数部分：");System.out.println(i);break;}if(i * i > number){System.out.println("输出" + number + "平方根的整数部分：");System.out.println(i - 1);break;}}}
}运行结果：
键盘录入大于 2 的数是：
20
输出20平方根的整数部分：
4
练习3: 求质数
需求: 键盘录入一个正整数 x ，判断该整数是否为一个质数。
质数，只有 1 和 它本身两个因数的数。
package Just.test;import java.util.Scanner;public class Test3 {public static void main(String[] args) {//键盘录入一个数Scanner sc = new Scanner(System.in);System.out.println("输入一个整数: ");int number = sc.nextInt();//定义一个变量，表示标记，标记 number 是否为质数//true:是一个质数//false:不是一个质数//最初认为 number 是一个质数boolean flag = true;for(int i = 2;i < number;i++) {if(number % i == 0){flag = false;break;}}if(flag){System.out.println(number + "是一个质数");}else{System.out.println(number + "不是一个质数");}}
}运行结果：
输入一个整数:
31
31是一个质数运行结果：
输入一个整数:
25
25不是一个质数
优化后的代码：
思路：减少 for 循环的次数， a * b = c , 则 a 和 b 中必有一个数是 小于等于 c 平方根的
于是把 for循环中的 i < number 换成 i < number 的平方根，就可以减少 for循环的次数，从而提高效率，达到优化的目的。
**练习：**猜数字小游戏
需求：程序自动生成一个 1 ~ 100之间的随机数字，使用程序实现猜出这个数字是多少？
package Just.test;import java.util.Random;
import java.util.Scanner;public class Test4 {public static void main(String[] args) {//生成一个 1 ~ 100 之间的随机数Random r = new Random();int number = 1 + r.nextInt(100);//键盘录入你所猜的数Scanner sc = new Scanner(System.in);//无限循环，当未猜中时，一直循环下去，不断猜测while (true){System.out.println("请输入你要猜的数字：");int guessNumber = sc.nextInt();if(guessNumber > number){System.out.println("大了");}else if(guessNumber < number){System.out.println("小了");}else{System.out.println("中了");//猜中后，跳出循环break;}}}
}
注意事项：
1、生成随机数的代码是不能写在循环的里面，否则每一次都会产生一个新的随机数
2、抽奖机制：保底
加一个计数器，当抽奖未抽中而达到保底次数时，直接输出 “ 抽中 ” ，跳出循环。
public class Test4 {public static void main(String[] args) {.......int count = 0while (true){......count++;......if(count == n){System.out.println("中了");break;}/*if(guessNumber > number){System.out.println("大了");}else if(guessNumber < number){System.out.println("小了");}else{System.out.println("中了");//猜中后，跳出循环break;}*/}}
}
获取随机数
Java 已经帮我们写好一个类叫 Random , 这个类就可以生成一个随机数。
使用步骤：
1、导包
import java.util.Random;
导包的动作必须出现在类定义的上边
2、创建对象
Random r = new Random();
上面这个格式里面，只有 r 是变量名，可以变，其他的都不允许变。
3、生成随机数
int number = r.nextInt(随机数的范围)；
上面这个格式里面，number 是变量名，可以变
注意事项：随机数范围
在小括号中书写的是随机数的范围，这个范围是从零开始的，到这个数的 - 1 结束。
口诀：包头不包尾，包左不包右。
用来生成任意数到任意数之间的随机数：
- 让这个范围头尾都减去一个值，让这个数范围从 0 开始
- 尾巴 + 1
- 最终的结果，再加上第一步减去的值
例如：生成 7 ~ 15 之间的随机数
1、- 7，变成 0 ~ 8
2、尾巴 + 1 , 变成 0 ~ 9
3、加上 1、 减去的 7 ，变成 7 + （ 0 ~ 9）
编程实现：
Random r = new Random();
int number = 7 + r.nextInt(9);
System.out.println(number);
数组
这篇关于java入门上部的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
