JAVA入门
打开CMD
- Win+R
- 输入cmd.
- 按下回车键
- Win+E 打开我的电脑
常见CMD命令
-
盘符名称+冒号
说明：盘符切换
举例：E：回车，表示切换到E盘
-
dir
说明：查看当前路径下的内容
-
cd 目录
说明：进入单级目录
举例：cd itheima
-
cd..
说明：回退到上一级目录
-
cd 目录1\目录2...
说明：进入多级目录
举例：cd itheima\JavaSE
-
cd\
说明：回退到盘符目录
-
cls
说明：清屏
-
exit
说明：退出命令提示符窗口
配置环境变量
为什么配置环境变量？
我们想要在任意的目录下都可以打开指定的软件。就可以把软件的路径配置到环境变量中。
打开我的电脑-属性-高级系统设置-高级-环境变量-系统变量path-编辑-新建-把软件的完整路径粘贴进去-上移-确定。
Java基础学习
基础语法
jdk
注意：针对不同操作系统，下载对应的安装包。
安装：傻瓜式安装，下一步即可
安装路径中不要包含中文和空格。
所有的开发工具最好安装目录统一。
bin：该路径下存放了各种工具命令。其中比较重要的有javac和java。
conf：该路径下存放了相关配置文件。
include：该路径下存放了一些平台特定的头文件。
jmods:该路径下存放了各种模块。
legal：该路径下存放了各模块的授权文档。
lib：该路径下存放了工具的一些补充JAR包。
Java程序初体验
编写步骤
用记事本写程序
public class HelloWorld{
public static void main(String[]args){
System.out.println("HelloWorld");
}
}
-
编译文件
如何理解编译？相当于翻译文件
-
运行程序
CMD中程序运行步骤：
- 切换盘符：要先找到我们刚刚书写的代码
- 编译：javac是JDK提供的编译工具，我们可以通过这个工具，把当前路径下的HelloWorld.java文件编译成class文件。
- 运行：java也是JDK提供的一个工具。作用就是用来运行代码的。运行当前路径下的HelloWorld.class这个文件。在运行的时候是不加后
案例常见问题
BUG的解决
- 具备识别BUG的能力 ———多看！
- 具备分析BUG的能力 ———多思考，多查阅资料
- 具备解决BUG的能力 ———多尝试，多总结
常见问题
- 中英文符号问题
- 单词拼写问题
环境变量
配置环境变量安全方式：
点击新建-变量名：JAVA_HOME，变量值：把路径粘贴进去，把bin给删掉。-确定-找到Path-新建-输入%JAVA_HOME%\bin-确定就可以了
步骤:
- 先配置JAVA_HOME.(路径不带bin)(E:develop\jdk)
- 再配置Path(%JAVA_HOME%\bin)
额外小拓展
部分win10的电脑有一个小bug.
当你重启后,配置的环境变量会失效.
解决方案:
- JAVA_HOME还是照样配置
- 在path当中,就不要引用JAVA_HOME了.
直接写完整路径.比如:E:develop\jdk\bin
Java 学习
Java能做什么?
Java的三大分类
JavaSE:java语言的(标准版),用于桌面应用的开发,是其他两个版本的基础.—-桌面应用开发.
学习java的目的:
为今后要从是的Java EE开发 ,打基础.
JavaME:Java语言的(小型版),用于嵌入式电子设备或者小型移动设备.
JavaEE:Java语言的(企业版),用于Web方向的网站开发.在这个领域,是当之无愧的NO.1.网站开发:浏览器+服务器
桌面应用开发
各种税务软件,IDEA,Clion,Pycharm
企业级应用开发
微服务,springcloud
移动应用开发
鸿蒙,Android,医疗设备
科学计算
matlab
大数据开发
Hadoop
游戏开发
我的世界 MineCraft
Java为什么这么火
主要从四个方面表现
用户量:使用人群
适用面:作用范围
与时俱进:更新速度
自身特点:面向对象/安全性/多线程/跨平台/简单易用/开源
Write Once Run Anywhere一次编译,到处运行
高级语言的编译运行方式
编程/编译/运行
编程:Java程序员写的.java代码,c程序员写的.c代码,python程序员写的.py代码
编译:机器只认识0011的机器语言,把.java.c.py的代码做转化让机器认识的过程
运行:让机器执行编译后的指令
语言类型
编译型:
解释性:
混合型:半编译,半解释
JRE和JDK
JVM(Java Virtual Machine):Java虚拟机,整整运行Java程序的地方
JRE(Java Runtime Environment):Java运行环境
JVM/核心类库/运行工具
JDK(Java Development Kit):Java开发工具包
JVM虚拟机:Java程序运行的地方
核心类库:Java已经写好的东西,我们可以直接用
开发工具:javac/java/jdb/jhat…
三者的包含关系
JDK包含了JRE
JRE包含了JVM
Java基础语法
注释
单行注释 格式://注释信息
多行注释 格式:/注释信息**/
文档注释 格式:/**注释信息*/
public class HelloWorld{
//叫做main方法,表示程序的主入口
public static void main(String[]args){
/*叫做输出语句(打印语句)
会把小括号里面的内容进行输出打印*/
System.out.println("HelloWorld");
}
}
注释的使用细节:
- 注释内容不会参与编译与运行,仅仅是对代码的解释说明
- 不管是单行注释还是多行注释,在书写的时候都不要嵌套
关键字
关键字:被Java赋予了特定涵义的英文单词
特点:
关键字的字母全部小写
常用的代码编辑器,针对关键字有特殊的颜色标记,非常直观.
class:用于(创建/定义)一个类;类是Java最基本的组成单元
字面量
告诉程序员:数据在程序中的书写格式
| 字面量类型 | 说明 | 举例 |
|---|---|---|
| 整数类型 | 不带小数点的数字 | 666,-88 |
| 小数类型 | 带小数点的数字 | 13.14,-5.21 |
| 字符串类型 | 用双引号括起来的内容 | “HelloWorld”,“张代伟” |
| 字符类型 | 用单引号括起来的内容 | ‘A’,‘O’,’我’ |
| 布尔类型 | 布尔值,表示真假 | 只有两个值:true,false |
| 空类型 | 一个特殊的值,空值 | 值是:null |
public class ValueDemo{
public static void main(String[]args){
//目标:需要大家掌握常见的数据在代码中如何书写的?
//整数
System.out.println(666);
System.out.println(-777);
//小数
System.out.println(1.93);
System.out.println(-3.71);
//字符串
System.out.println("刘顺国");
System.out.println("尼古拉斯阿淮");
//字符
System.out.println('A');
System.out.println('B');
//布尔
System.out.println(true);
System.out.println(false);
//空
//细节:null不能直接打印的.
//如果我们要打印null,那么只能用字符串的形式进行打印
System.out.println(null);
}
}
特殊字符字面量:
\t 制表符
在打印的时候,把前面字符串的长度补齐到8,或者8的整数倍.最少补1个空格,最多补8个空格.
变量
定义
变量:在程序执行的过程中,其值有可能发生改变的量(数据)
变量的使用场景:
当某个数据经常发生改变时,我们也可以用变量存储.当数据变化时,只要修改变量里面记录的值即可.
变量的定义格式:
数据类型 变量名 = 数据值;
public class VariableDemo{
public static void main(String[]args){
//定义变量
//数据类型 变量名 = 数据值;
//数据类型:限定了变量能存储数据的类型
//int(整数) double(小数)
//变量名:就是存储空间的名字
//作用:方便以后调用
//数据值:真正存在变量中的数
//等号:赋值. 把右边的数据赋值给左边的变量
//===================================
int a = 10;
System.out.println(a);//10
}
}
使用方式
注意事项:
- 只能存一个值
- 变量名不允许重复定义
- 一条语句可以定义多个变量
- 变量在使用之前一定要进行赋值
- 变量的作用域范围
public class VariableDemo{
public static void main(String[]args){
//1.基本用法
//定义变量,再进行输出
//===================================
int a = 10;
System.out.println(a);//10
System.out.println(a);//10
System.out.println(a);//10
//2.变量参与计算
int b = 20;
int c = 30;
System.out.println(b+c);
//修改变量记录的值
a = 50;
System.out.println(a);//50
//注意事项
//在一条语句中,可以定义多个变量
int d = 100,e = 200,f = 300;
System.out.println(d);
System.out.println(e);
System.out.println(f);
//变量在使用之前必须要赋值
//int g;
//g = 50;
//建议:以后在定义变量的时候,请直接赋值.
System.out.println(g);
}
}
变量的练习
package classVariableTest{
//主入口
public static void main(String[]args){
//一开始没有乘客
int count = 0;
//第一站:上去一位乘客
//在原有基础上 + 1
count = count+1;
//第二站:上去两位乘客.下来一位乘客
count = count+2-1;
//第三站:上来两位乘客,下来一位乘客
count= count+2-1;
//第四站:下来一位乘客
count=count-1;
//第五站:上去一位乘客
count= count+1;
//请问:到了终点站,车上一共几位乘客.
System.out.println(count);
}
}
计算机的存储规则
三类数据
-
Text文本数据:数字/字母/汉字
进制:在计算机中,任意数据都是以二进制的形式来存储的
不同进制在代码中的表现形式:
- 二进制:由0和1组成,代码中以0b开头.
- 十进制:由0-9组成,前面不加任何前缀.
- 八进制:由0-7组成,代码中以0开头.
- 十六进制:由0-9还有a-f组成,代码中以0x开头.
进制之间的转换
任意进制转换为十进制
公式:系数*基数的权次幂 相加
系数:就是每一位上的数字
基数:当前进制数
权:从右向左,依次为0 1 2 3 4 5 …..
十进制转其他进制
除基取余法
不断的除以基数(几进制,基数就是几)得到余数,直到商为0,再将余数倒着拼接起来即可.
-
Image图片数据
显示器的三要素:
分辨率
2K屏分辨率大致分为:
- 1920*1080
2. 19981080
3. 20481080
4. 2048*858
4K屏分辨率大致分为:
1. ==3840*2160== 2. 3996*2160 3. 4096*2160 4. 4096*1716 像素
黑白图:1是白,2是黑
灰度图:0是纯黑,255是纯白
三原色
彩色图:三原色:红黄蓝也称美学三原色.计算机中采用光学三原色:红绿蓝(RGB),写成十进制(0-255)或十六进制(0-FFFF).
- 1920*1080
-
Sound声音数据
数据类型
数据类型的分类
-
基本数据类型
注意事项:
long类型变量:需要加入L标识(大小写都可以)
float类型变量:需要加入F标识(大小写都可以)
public class VariableTest{ public static void main(String[]args){ //定义变量记录姓名 String name = "张代伟"; //定义变量记录年龄 int age = 18; //定义变量记录性别 char gender = '男'; //定义变量记录身高 double height = 180.1; //定义变量记录是否单身 //true 单身 false 不是单身 boolean flag = true; //输出变量的值 System.out.println(name); Systrm.out.println(age); System.out.println(gender); System.out.println(height); System.out.println(flag); } }public class VariableTest{ public static void main(String[]args){ //定义变量记录电影的名字 String name = "送初恋回家"; //定义变量记录主演的名字 String tostar = "刘鑫 张雨提 高媛"; //定义变量记录电影的年份 int year = 2020; //定义变量记录电影的评分 double grade = 9.0; //输出所有变量的值 System.out.println(name); System.out.println(tostar); System.out.println(year); System.out.printlan(grade); }public class VariableTest{ public static void main(String[]args){ //定义变量记录手机的价格 double price = 5299.0; //定义变量记录手机的品牌 String name = "华为"; //输出结果 System.out.println(name); System.out.println(price); } -
引用数据类型
标识符
标识符:就是给类,方法,变量等起的名字.
标识符命名规则—硬性要求
- 由数字、字母、下划线(_)和美元符($)组成
- 不能以数字开头
- 不能是关键字
- 区分大小写
标识符的命名规则—软性建议
命名要做到:见名知意
| 小驼峰命名法:适合变量和方法 | 大驼峰命名法:适合类名 |
|---|---|
| 规范1:标识符是一个单词的时候,全都小写. | 规范1:标识符是一个单词的时候,首字母大写. |
| 范例1:name | 范例1:Student |
| 规范2:标识符由多个单词组成的时候,第一个单词首字母小写,其他单词首字母大写. | 规范2:标识符由多个单词组成的时候,每个单词的首字母大写. |
| 范例2:firstName | 范例2:GoodStudent |
键盘录入
为什么要有键盘录入?
键盘录入介绍
Java帮我们写好一个类叫Scanner,这个类的功能就可以接收键盘输入的数字等数据.
使用步骤:
-
导包——Scanner这个类在哪
import java.util.Scanner;导包的动作必须出现在类定义的上边.
-
创建对象——表示我要开始用Scanner这个类了
Scanner sc = new Scanner(System.in)
上面这个格式里面,只有sc是变量名,可以改变,其他的都不允许变.
-
接受数据——真正开始干活了
int i = sc.nextInt();左面这个格式里面,只有i是变量名,可以变,其他的都不允许变.
//导包,找到Scanner这个类在哪
//书写要注意:要写在类定义的上面
import java.util.Scanner;
public class ScannerDemo{
public static void main(String[]args){
//2.创建对象,表示我现在准备要用Scanner这个类
Scanner scanner = new Scanner(System.in);
System.out.println("请输入整数:");
//3.接收数据
int i = scanner.nextInt();
System.out.println();
}
}
练习:键盘输入数字求和
需求:键盘录入两个整数,求出他们的和并打印出来
//导包
import java.util.Scanner;
public class ScannerTest{
public static void main(String[]args){
//2.创建对象
Scanner scanner = new Scanner(System.in);
System.out.println("请输入整数:");
//3.接收数据
int num1 = scanner.nextInt();
//再次接收第二个数据
int num2 = scanner.nextInt();
System.out.println(num1+num2);
}
}
IDEA
IDEA概述
全称IntelliJ IDEA,是用于Java语言开发的集成环境,它是业界公认的目前用于Java程序开发最好用的工具.
集成环境:把代码编写,编译,执行,调试等多种功能综合到一起的开发工具.
IDEA下载和安装
- 下载安装包:https://www.jetbrains.com/idea/
- 安装:傻瓜式安装,建议修改安装路径.
IDEA中的第一个代码
IDEA项目结构介绍:
- 项目(project)
- 模块(module)
- 包(package)
- 类(class)
大小排列:项目-模块-包-类
右键-open in-Exploer(在本地打开文件件)
IDEA的项目和模块操作
项目(project)
修改主体:(更换背景)
File-settings-Appearance & Bahavior-Appearance-Theme(主题)
修改字体:
File-settings-Editor-font-选择喜欢的字体(Consolas—程序员最喜欢的字体)
修改颜色:什么颜色都可以,但绝不能设置成红色,跟bug冲突.
File-settings-Editor-Color Scheme-Language Defaults-comments
键盘录入时自动导包:
File-settings-General-Auto Import-选择Add…+Optimize…两项确定即可
设置背景照片:
File-settings-Appearance-UI Options-Background Image…
IDEA中类的相关操作:
-
新建类
选中包-右键点击包-new-java class
-
修改类名
选中类-右键点击类-Refactor-Rename(快捷键:shift+f6)
-
删除类
选中类-右键点击类-delete
IDEA中项目的相关操作
-
关闭项目
File-Close Project
-
新建项目
New Project-Empty Project
-
打开项目
-
修改项目
模块(module)
IDEA中模块的相关操作
-
新建模块
File-Project Stucture- Module-+-New Module-java(根据需要选择需要的类型)
-
删除模块
-
修改模块
-
导入模块
运算符
运算符和表达式
运算符:对字面量或者变量进行操作的符号
表达式:
用运算符把字面量或者变量连接起来,符合Java语法的式子就可以称为表达式.
不同运算符连接的表达式体现的是不同类型的表达式.
算数运算符
public class ArithmeticoperatoeDemo{
public static void main(String[]args){
//+
System.out.println(1+2);
//-
System.out.println(5-2);
//*
System.out.println(2*5);
//如果在计算的时候有效数参与
//结论:
//在代码中,如果有小数参与计算,结果有可能不精确的.
//为什么呢?
//暂时只要知道这个结论就可以了.
//具体的原因,我们到了Java进阶的时候,会详细的讲解.
System.out.println(1.1+1.01);
System.out.println(1.1-1.01);
System.out.println(1.1*1.01);
//除法
//结论:
//1.整数参与计算,结果只能得到整数
//2.小数参与计算,结果有可能是不精确的,如果我们需要精确计算,需要用到后面的知识点.
System.out.println(10/2);//5
System.out.println(10/3);//3
System.out.println(10.0/3);//3.333333335
//取模,取余.实际上也是做除法运算,只不过得到的是余数而已.
System.out.println(10%2);//0
System.out.println(10%3);//1
//应用场景:
//1.可以用取模来判断:A是否可以被B整除
//A%B 10%3
//2.可以判断A是否为偶数
//A%2 如果结果为0,那么证明A是一个偶数.如果结果为1,那么证明A是一个奇数
//3.在以后,斗地主发牌
//三个玩家
//把每一张牌都定义一个序号
//拿着序号%3如果结果为1,就发给第一个玩家
//如果结果为2,就发给第二个玩家
//如果结果为0,就发给第三个玩家
}
}
练习:数值拆分
需求:键盘录入一个三位数,将其拆分为个位/十位/百位后,打印在控制台
运行结果
公式总结:
个位:数值%10
十位:数值/10%10
百位:数值/100%10
千位:数值/1000%10
public class Test{
public static void main(String[]args){
//键盘录入一个三位数,将其拆分为个位/十位/百位
//1.键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数");
int number = sc.nextInt();
//2.获取个位/十位/百位
//公式:
//个位:数值%10
//十位:数值/10%10
//百位:数值/100%10
//..........
int ge = number%10;
int shi = number/10%10;
int bai = numeber/100%10;
System.out.println(ge);
System.out.println(shi);
System.out.println(bai);
}
}
算术运算符的高级用法:
“+”操作的三种情况
-
数字相加:数字进行运算时,数据类型不一样不能运算,需要转成一样的,才能运算.
类型转换的分类:
隐式转换(自动类型提升):取值范围小的数值–>取值范围大的数值—->把一个取值范围小的数值,转成取值范围大的数据.
隐式转换的两种提升规则:
- 取值范围小的,和取值范围大的进行运算,小的会先提升为大的,再进行运算.
- byte short char 三种类型的数据在运算的时候,都会直接先提升为int,然后在进行运算.
隐式转换小结:
-
取值范围:
byte<short<int<long<float<double
-
什么时候转换?
数据类型不一样,不能进行计算,需要转成一样的才可以进行计算.
-
转换规则:
- 取值范围小的,和取值范围大的进行运算,小的会先提升为大的,再进行运算.
- byte short char 三种类型的数据在运算的时候,都会直接先提升为int,然后在进行运算.
练习:请问最终的运算结果是什么类型的?
byte b1 = 10;
byte b2 = 20;
int=数据类型 result = b1+ b2;
int i = 10;
long n =100L;
double d = 20.0;
double=数据类型 result = i+n+d;
byte b = 10;
short s = 20;
long n = 100L;
long数据类型 result = b+s+n;
强制转换:取值范围大的数值–>取值范围小的数值
如果把一个取值范围大的数值,赋值给取值范围小的变量.
是不允许直接赋值的.如果一定要这么做就需要加入强制转换
格式:目标数据类型 变量名 = (目标数据类型)被强转的数据;
练习:强制转换
byte b1 = 10;
byte b2 = 20;
byte result =(byte) (b1+b2);
-
字符串相加
当“+”操作中出现字符串时,这个“+”是字符串连接符,而不是运算符了.它会将前后的数据进行拼接,并产生一个新的字符串.例:”123”+123
连续进行“+”操作时,它是从左到右逐个执行.例:1+99+”“年达内”
-
字符相加
当字符+字符时,会把字符通过ASCII码表查询到对应的数字再进行计算.
当字符+数字时,会把字符通过ASCII码表查询到对应的数字再进行计算.
算术运算符小结:
自增自减运算符
基本用法:
| 符号 | 作用 | 说明 |
|---|---|---|
| ++ | 加 | 变量的值加1 |
| - - | 减 | 变量的值减1 |
注意事项:
++和- -既可以放在变量的前边,也可以放在变量的后边.
两种用法:
单独使用:++和 - -无论是放在变量的前边还是后边,单独写一行结果是一样的.
参与计算:
1.先用后加:a++
2.先加后用:++a
public class ArithmeticoperatoeDemo{
public static void main(String[]args){
int x = 10;
//++在后,先用后加.
//先把x变量中的值拿出来用,赋值给y,然后再进行自增.
//赋值给y的值是自增前的.
int y = x+1;//x=11,y=10
//++在前,先加后用
//先把x进行自增,然后把自增后的结果赋值给左边的变量
//先把x自增,编程12,然后再把自增之后的12赋值给z.
int z = ++x;//x=12,z=12
System.out.println();
System.out.println();
System.out.println();
}
}
赋值运算符
分类
| 符号 | 作用 | 说明 |
|---|---|---|
| = | 赋值 | int a =10,将10赋值给变量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 |
关系运算符
(关系运算符/比较运算符)的分类
| 符号 | 说明 |
|---|---|
| == | a==b,判断a和b的值是否相等,成立true,不成立为false |
| != | a!=b,判断a和b的值是否不相等,成立为true,不成立为false |
| > | a>b,判断a是否大于b,成立为true,不成立为false |
| >= | a>=b,判断a是否大于等于b,成立为true,不成立为false |
| < | a<b,判断a是否小于b,成立为true,不成立为false |
| <= | a<=b,判断a是否小于等于b,成立为true,不成立为false. |
注意事项:关系运算符的结果都是boolean类型,要么是true,要么是false.千万不要把“==”误写成“=”.
练习:约会
public class test{
public static void main(String[]args){
/*需求:您和您的相亲对象在餐厅里面正在约会.
键盘录入两个整数,表示你和你约会对象衣服的时髦度.(手动录入0-10之间的整数,不能录其他)
如果你的时髦程度大于你对象的时髦程度,相亲就成功,输出true.否则输出false.*/
//1.键盘录入两个整数表示衣服的时髦度
Scanner sc = new Scanner(System.in);
System.out.println("请输入我们自己的衣服时髦度");
int myfashion = sc.nextInt();
System.out.println("请输入相亲对象衣服的时髦度");
int girlfashion = sc.nextInt();
//2.把我衣服的时髦度跟女朋友的时髦度进行对比就可以了
boolean result = myfashion >girlfashion;
//打印结果
Sysstem.out.println(result);
}
}
逻辑运算符
在数学中,一个数据x,大于5,小于15,我们可以这样来进行表示:5<x<15.
在Java中,需要把上面的式子先进行拆解,在进行合并表达.
拆解为:x>5和x<15
合并后:x>5&x<15
分类:
| 符号 | 作用 | 说明 |
|---|---|---|
| & | 逻辑与(且) | 并且,两边都为真,结果才是真 |
| | | 逻辑或 | 或者,两边都为假,结果才是假 |
| ^ | 逻辑异或,用的很少 | 相同为false,不同为true |
| ! | 逻辑非 | 取反 |
public class LogicoperatorDemo{
public static void main(String[]args){
//1.& 并且
//两边都为真,结果才是真
System.out.println(true&true);
System.out.println(false&false);
System.out.println(true&false);
System.out.println(false&true);
//使用场景1:登录.用户名正确并且密码正确
//2.| 或者
//两边都为假,结果才是假
System.out.println(true|true);
System.out.println(false|false);
System.out.println(true|false);
System.out.println(false|true);
//使用场景2:满足其中一个条件时
//3.^ 异或
//相同为false,不同为true
//了解即可
System.out.println(true ^ true);
System.out.println(false ^ false);
System.out.println(true ^ false);
System.out.println(false ^ true);
//! 逻辑非 取反
//提示:
//取反的感叹号不要写多次,要么不写,要么只写一次
System.out.println(!false);//true
System.out.println(!true);//false
}
}
短路逻辑运算符
| 符号 | 作用 | 说明 |
|---|---|---|
| && | 短路与 | 结果和&相同,但是有短路效果 |
| || | 短路或 | 结果和|相同,但是有短路效果 |
public class LogicoperatorDemo{
public static void main(String[]args){
//1.&&
//运行结果跟单个&是一样的
//表示两边都为真,结果才是真
System.out.println(true&&true);
System.out.println(false&&false);
System.out.println(false&&true);
System.out.println(true&&false);
//2.||
//运行结果跟单个|是一样的
//表示两边为假,结果才是假
System.out.println(true||true);
System.out.println(false||false);
System.out.println(false||true);
System.out.println(true||false);
//3.短路逻辑运算符局有短路效果
//简单理解:当左边的表达式能确定最终的结果,那么右边就不会参与运行了
int a = 10;
int b = 10;
boolean result = ++a<5&&++b<5;
System.out.println(result);
System.out.println(a);
System.out.println(b);
}
注意事项:
- &or|,无论左边true orfalse,右边都要被执行
- &&or||,如果左边能确定整个表达式的结果,右边不执行.
- &&:左边为false,右边不管是真是假,整个表达式的结果一定是false.
- ||:左边为true,右边不管是真是假,整个表达式的结果一定是true.
这两种情况下,右边不执行,提高了效率.
以后最常用的逻辑运算符:&&,||,!.
练习:数字6
数字6是一个伟大的数字,键盘录入两个整数.
如果其中一个为6,最终结果输出true.
如果他们的和为6的倍数.最终结果输出true.
其他情况都是false.
public class test{
public static void main(String[]args){
/* 数字6是一个伟大的数字,键盘录入两个整数.
如果其中一个为6,最终结果输出true.
如果他们的和为6的倍数.最终结果输出true.
其他情况都是false.*/
//分析
//1.键盘录入两个整数
//变量a 变量b
//2.a==6 b==6 (a+b)%6==0
//如果满足其中一个,那么就可以输出true
//
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int num1 = sc.nextInt();
System.out.println("请输入一个整数");
int nim2 = sc.nextInt();
//可以短路逻辑运算符去连接三个判断
boolean result = num1==6||num2==6||(num1+num2)%6==0;
System.out.println(result);
}
三元运算符
需求:定义一个变量记录两个整数的较大值
作用:可以进行判断,根据判断的结果得到不同的内容
(三元运算符/三元表达式)格式
-
格式:关系表达式?表达式1:表达式2;
-
范例:求两个数的较大值.
a>b?a:b;
System.out.println(a>b?a:b);
public class test{ public static void main(String[]args){ //需求:使用三元运算符,获取两个数的较大值 //分析: //1.定义两个变量记录两个整数 int number1 = 10; int number2 = 20; //2.使用三元运算符获取两个整数的最大值 //格式:关系表达式?表达式1:表达式2; //整个三元运算符的结果必须要被使用 number1>number2?number1:number2; System.out.println(max); System.out.println(number1>number2?number1:number2); }
练习1:两只老虎
需求:动物园里有两只老虎,体重分别为通过键盘录入获得,请用程序实现判断两只老虎的体重是否相同.
public class test1{
public static void main(String[]args){
/*需求:动物园里有两只老虎,体重分别为通过键盘录入获得,请用程序实现判断两只老虎的体重是否相同.*/
//分析:
//1.键盘录入两只老虎的体重
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一只老虎的体重");
int weight1 = sc.nextInt();
System.out.println("请输入第二只老虎的体重");
int weight2 = sc.nextInt();
//2.比较
String result = boolean weight1>weight2?相同:不同;
System.out.println(result)
}
练习2:三元运算符练习2
需求:一座寺庙里住着三个和尚,已知他们的身高分别为150cm,210cm,165cm.请用程序实现获取这三个和尚的身高.
public class test2{
public static void main(String[]args){
/*需求:一座寺庙里住着三个和尚,已知他们的身高分别为150cm,210cm,165cm.请用程序实现获取这三个和尚的身高.*/
//1.定义三个变量记录三个和尚的身高
int height1 = 150;
int height2 = 210;
int height3 = 165;
//2.拿着第一个和尚和第二个和尚进行比较
//再拿着结果跟第三个和尚进行比较即可
int temp = height1>height2?height1:height2;
int max = temp>height3?temp:height3;
//ctrl+alt+L代码对齐快捷键
System.out.println(max);
}
运算符优先级
小括号()优先于所有
原码、反码、补码
原码
原码：十进制数据的二进制表现形式，最左边是符号位，0为正，1为负。
原码的弊端：
利用原码对正数进行计算的时候，如果是整数是完全不会有问题的。
但是如果是负数计算，结果就出错，实际运算的结果，跟我们预期的结果是相反的。
反码
反码：正数的补码反码是其本身，负数的反码是符号位保持不变，其余位取反。
反码：为了解决原码不能计算负数的问题而出现的。
计算规则：正数的反码不变，负数的反码在原码的基础上，符号位不变，数值取反，0变1,1变0.
反码的弊端：负数运算的时候，如果结果不跨0，是没有任何问题的，但是如果结果跨0，跟实际结果会有1的偏差。
补码
补码：正数的补码是其本身，负数的补码是在其反码的基础上+1.
补码出现的目的：
为了解决负数计算时跨0的问题而出现的。
补码的计算规则：
正数的补码不变，负数的补码在反码的基础上+1.
另外补码还能多记录一个特殊的值-128，改数据在1个字节下，没有源码和反码。
补码的注意点：
计算机中的存储和计算都是以补码的形式进行的。
基本数据类型
| 基本类型 | 字节数 | 二进制 |
|---|---|---|
| byte类型的10 | 1个字节 | 0000 1010 |
| short类型的10 | 2个字节 | 0000 0000 0000 1010 |
| int类型的10 | 4个字节 | 0000 0000 0000 0000 0000 0000 0000 1010 |
| long类型的10 | 8个字节 | 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1010 |
其他的运算符
| 运算符 | 含义 | 运算规则 |
|---|---|---|
| & | 逻辑与 | 0为false 1为true |
| | | 逻辑或 | 0为false 1为true |
| << | 左移 | 向左移动，低位补0,规则：移一位*2 |
| >> | 右移 | 向右移动，高位补0或1规则：移一位/2 |
| >>> | 无符号右移 | 向右移动，高位补0 |
public class Test{
public static voidmain(String[]args){
int a = 200;
int b = 10;
System.out.println(a|b);
0000 0000 0000 0000 0000 0000 1100 1000
0000 0000 0000 0000 0000 0000 0000 1010
=======================================
0000 0000 0000 0000 0000 0000 1100 1010
=======================================
202
}
}
流程控制语句
顺序结构
public class OrderDemo{
public static void main(String[]args){
System.out.println("好好学习Java");
System.out.println("早日掌握一门技术");
System.out.println("为国家崛起而奋斗");
System.out.println("赚大钱");
}
}
分支结构
if语句
第一种格式:
if(关系表达式){ if(酒量>2){System.out.println():}
语句体;
}
if的注意点:
1.大括号的开头可以另起一行书写,但是建议写在第一行的末尾;
2.在语句体中,如果只有一句代码,大括号可以省略不写;建议:大括号不要省略.
3.如果对一个布尔类型的变量进行判断,不要用==号;直接把变量写在小括号中即可
public class IfDemo{
public static void main(String[]args){
//需求:键盘录入女婿的酒量,如果大于2,老丈人给出回应,反之不回应.
//if格式
//if(关系表达式){
//语句体;
//}
//分析:
//1.键盘录入女婿的酒量
Scanner sc = new Scanner(System.in);
System.out.println("请输入女婿的酒量");
int wine = sc.nextInt();
//2.对酒量进行判断
if(wine>2){
System.out.println("小伙子,不错呦!");
}
}
}
public class Test{
public static void main(String[]args){
//小红:如果你这次考试全班第一,我就做你女朋友
//分析:
//1.定义变量记录小明的名次
int ranking =1;
//2.对小明的名次进行判断
if(ranking==1){
System.out.println("小红成为了小明的女朋友");
}
}
}
自动驾驶
public class Test{
public static void main(String[]args){
//汽车无人驾驶会涉及到大量的判断
//当汽车行驶的时候遇到了红绿灯,就会进行判断
//如果红灯亮,就停止
//如果黄灯亮,就减速
//如果绿灯亮,就行驶
//1.定义三个变量,表示灯的状态
//true 亮 false 关
boolean isLightGreen = false;
boolean isLightYellow = false;
boolean isLightRed = true;
//2.判断
//红灯亮,就停止
//黄灯亮,就减速
//绿灯亮,就行驶
if(isLightGreen){
System.out.println("GoGoGo!");
}
if(isLightYellow){
System.out.println("slow!");
}
if(isLightRed){
System.out.println("stop!");
}
}
第二种格式:
if(关系表达式){
语句体1;
}else{
语句体2;
}
执行流程:
1.首先计算关系表达式的值
2.如果关系表达式的值为true就执行语句体1
3.如果关系表达式的值为false就执行语句体2
4.继续执行后面的其他语句
练习:吃饭
public class Test{
public static void main(String[]args){
/*需求:键盘录入一个整数,表示身上的钱
如果大于100块,就是网红餐厅
否则,就吃经济实惠的沙县小吃
//分析
//1.键盘录入一个整数,表示身上的钱
Scanner scanner = new Scanner(System.in);
System.out.println("请录入身上的钱:");
int money = scanner.nextInt();
//2.对钱进行判断
if(money>=100){
System.out.println("吃网红餐厅!");
}else{
System.out.println("吃经济实惠的沙县小吃");
}
}
}
练习:商品付款
在实际开发中,如果要根据两种不同的情况来执行不同的代码,就需要用到if的第二种格式.
需求:
假设,用户在超市实际购买,商品总价为:600元.
键盘录入一个整数表示用户实际支付的钱.
如果付款大于等于600,表示付款成功.否则付款失败
public class Test{
public static void main(String[]args){
//分析:
//1.键盘录入一个整数表示用户实际支付的钱
Scanner cc = new Scanner(System.in);
System.out.println("请录入一个整数表示用户实际支付的钱");
int money = cc.nextInt();
//2.判断
if(money>=600){
System.out.println("付款成功");
}else{
System.out.println("付款失败");
}
}
}
在实际开发中,电影院选座也会使用到if判断.
假设某影院售卖了100张票,票的序号为1-100.
其中奇数票号坐左侧,偶数票号坐右侧.
键盘录入一个整数表示电影票的票号
根据不同的情况,给出不同的提示;
如果票号为奇数,那么打印坐在左边;
如果票号为偶数,那么打印坐在右边.
public class Test{
public static void main(String[]args){
//分析
//1.键盘录入一个整数表示电影票的票号
Scanner sc = new Scanner(System.in);
System.out,println("请录入一个票号");
int ticket = sc.nextInt();
//只有当ticket在0-100之间,才是真实有效的票
if(ticket>0&&ticket<=100){
//2.判断票号是奇数还是偶数
if(ticket%2==1){
System.out.println("坐左边");
}else{
System.out.println("坐右边");
}
}
}
第三种格式
在实际开发中,如果是多情况判断,会用到if的第三种形式.
格式:
if(关系表达式1){
语句体1;
}else if(关系表达式2){
语句体2;
}
..........
else{
语句体n+1;
}
执行流程:
1.首先计算关系表达式1的值;
2.如果为true就执行语句体1;如果为false就计算关系表达式2的值;
3.如果为true就执行语句体2;如果为false就计算关系表达式3的值;
4.........;
5.如果所有关系表达式结果结果都为false,就执行语句体n+1.
练习:小明的礼物;
public class Test{
public static void main(String[]args){
/*
根据不同的分数送不同的礼物
如果是95-100分,送自行车一辆
如果是90-94分,游乐场玩一天
如果是80-89分,送变形金刚一个
如果是80分,揍一顿*/
//分析:
//1.键盘录入小明的考试成绩
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个整数表示小明的成绩");
int score = sc.nextInt();
//对异常数据进行判断校验
//0-100合理数据
if(score>0&&score<=100){
//2.根据不同的考试成绩,给出不同的奖励;
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{
Syetem.out.println("成绩不合法");
}
}
练习:自动驾驶;
public class Test{
public static void main(String[]args){
boolean isLightGreen = false;
boolean isLightYellow = false;
boolean isLightRed = true;
if(isLightGreen){
Syetem.out.println("GoGoGo!!");
}else if(isLightYellow){
Syetem.out.println("Slow!!!!");
}else if(isLightRed){
Syetem.out.println("Stop!!!!");
}
}
switch
Switch语句格式
Switch(表达式){
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
case 值3:
语句体3;
break;
.....
default:
语句体n+1;
break;
}
执行流程:
1.首先计算表达式的值;
2.依次和case后面的值进行比较,如果有对应的值,就会执行相应的语句,在执行的过程中,遇到break就会结束;
如果所有的case后面的值和表达式的值都不匹配,就会执行default里面的语句体,然后结束整个Switch语句.
格式说明:
1.表达式:(将要匹配的值)取值为byte/short/int/char.JDK5以后可以是枚举,JDK7以后可以是String.
2.case:后面跟的是要和表达式进行比较的值(被匹配的值);
3.break:表示中断,结束的意思,用来结束Switch语句;
4.default:表示所有情况都不匹配的时候,就执行该处的内容,和if语句的else相似;
5.case后面的值只能是字面量,不能是变量;
6.case给出的值不允许重复.
Switch其他知识点
default的位置和省略
case穿透
Switch新特性
Switch和if第三种格式各自的使用场景
练习:吃面
public class Test{
public static void main(String[]args){
//兰州拉面,武汉热干面,北京炸酱面,陕西油泼面
//1.定义变量记录我心里想吃的面
String noodles = "兰州拉面";
//2.拿着这个面利用Switch跟四种面条匹配
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;
}
}
练习:运动计划;
需求:键盘录入星期数,显示今天的减肥活动;
周一:跑步;
周二:游泳;
周三:慢走;
周四:动感单车;
周五:拳击;
周六:爬山;
周日:好好吃一顿;
public class Test{
public static void main(String[]args){
//分析:
//1.键盘录入星期数
Scanner sc = new Scanner(System.in);
System.out.println("请录入星期");
int week = sc.nextInt();
//2.利用Switch对星期进行匹配;
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;
}
public class Test{
public static void main(String[]args){
//default的位置和省略;
//1.位置:default不一定是写在最下面的,我们可以写在任意位置,只不过习惯会写在最下面.
//2.省略:default可以省略,语法不会有问题,但是不建议省略.
int number = 100;
switch(number){
case 1:
System.out.println("number的值为1");
break;
case 20:
System.out.println("number的值为20");
break;
case 100:
System.out.println("number的值为100");
break;
default:
System.out.println("number的值不是1,20和100");
break;
}
}
public class Test{
public static void main(String[]args){
/*
case穿透
就是语句体中没有写break导致的
执行过程:
首先还是会拿着小括号中表达式的值跟下面每一个case进行匹配.
如果匹配上了,就会执行对应的语句体,如果此时发现了break,那么结束整个Switch语句.如果没有发现break,那么程序会继续执行下一个case的语句体,一直到遇到break或者右大括号为止.
使用场景:
如果多个case的语句体重复了,那么我们考虑用case穿透去简化代码.
*/
int number = 1;
switch(number){
case 1:
System.out.println("number的值为1");
// break;
case 20:
System.out.println("number的值为20");
//break;
case 100:
System.out.println("number的值为100");
//break;
//default:
// System.out.println("number的值不是1,20和100");
// break;
}
}
public class Test{
public static void main(String[]args){
/*
Switch新特性
JDK12
*/
//需求:
//1 2 3
/*int number = 1;
Switch(number){
case 1:
System.out.println("一");
break;
case 2:
System.out.println("二");
break;
case 3:
System.out.println("三");
break;
default:
System.out.println("没有这种选项");
break;
}*/
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:把有限个数据一一列举出来,让我们任选其一
*/
public class Test{
public static void main(String[]args){
/*需求:键盘录入星期数,输出工作日,休息日
(1-5)工作日,(6-7)星期日*/
//分析:
//1.键盘录入星期数
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个整数表示星期");
int week = sc.nextInt();
//2.利用Switch语句来进行选择
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;
}
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个整数表示星期");
int week = sc.nextInt();
//2.利用Switch语句来进行选择
Switch(week){
case 1,2,3,4,5->System.out.println("工作日");
case 6,7->System.out.println("休息日");
default->System.out.println("没有这个星期");
}
}
public class Test{
public static void main(String[]args){
/*在实际开发中,如果我们需要在多种情况下选择其中一个,就可以使用Switch语句.
当我们拨打了某些服务电话时,一般都会有按键选择.
假设现在我们拨打了一个机票预订电话
电话中语音提示:
1.机票查询
2.机票预订
3.机票改签
4.退出服务
其他按键也是退出服务,请使用Switch模拟该业务逻辑*/
//分析:
//1.键盘录入一个整数,表示我们的选择
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的选择");
int choose = sc.nextInt();
//2.根据选择执行不同的代码
switch(choose){
case 1->System.out.println("机票查询");
case 2->System.out.println("机票预订");
case 3->System.out.println("机票改签");
//case 4->System.out.println("退出服务");
default->System.out.priln("退出服务");
}
}
循环结构
什么是循环?
重复的做某件事情
具有明确的开始和停止标记
循环的分类:
for循环——重点
格式:
for(int i=1;i<=0;i++){
System.out.println("HelloWorld");
}
执行流程:
1.执行初始化语句
2.执行条件判断语句,看其结果是true还是false
如果是false,循环结束
如果是true,执行循环体语句
3.执行条件控制语句
4.回到2继续执行条件判断语句
public class ForDemo{
public static void main(String[]args){
//1.需求:打印5次HelloWorld
//分析:
//i 1~5
/*for(初始化语句;条件判断语句;条件控制语句){
循环体;
}*/
for(int i= 1;i<=5;i++){
System.out.println("HelloWorld");
}
}
public class Test{
public static void main(String[]args){
//需求1:打印1~5
//分析:
//开始条件:1
//结束条件:5
for(int i=1;i<=5;i++){
//第一次循环:i=1
//第二次循环:i=2
//i:1 2 3 4 5
System.out.println(i);
}
//需求2:打印5~1
//分析:
//开始条件:5
//结束条件:1
for(int i=5;i>.=1;i--){
System.out.println(i);
}
}
练习:断线重连
在实际开发中,需要重复执行的代码,会选择循环实现.
比如:如作图所示.玩游戏的时候,如果网不好那么会经常断线重连.
那么断线重连这个业务逻辑就需要重复执行.
假设现在公司要求,断线重连的业务逻辑最多只能写5次.
请用代码实现.
备注:断线重连的业务逻辑可以用输出语句替代.
public class Test{
public static void main(String[]args){
/*在实际开发中,需要重复执行的代码,会选择循环实现.
比如:如作图所示.玩游戏的时候,如果网不好那么会经常断线重连.
那么断线重连这个业务逻辑就需要重复执行.
假设现在公司要求,断线重连的业务逻辑最多只能写5次.
请用代码实现.
备注:断线重连的业务逻辑可以用输出语句替代.*/
//分析:
//1.因为我们需要重复执行某段代码,所以需要用循环解决
//循环的次数5次
//开始条件:1
//结束条件:5
for(int i=1;i<=5;i++){
System.out.println("第"+i+"次执行断线重连的业务逻辑");
}
}
练习:求和
需求:在实际开发中,如果要获取一个范围中的每一个数据时,也会用到循环.
比如:求1~5之间的和.
public class Test{
public static void main(String[]args){
/*需求:在实际开发中,如果要获取一个范围中的每一个数据时,也会用到循环.
比如:求1~5之间的和*/
//分析:
//1.循环1~5得到里面的每一个数字
//开始条件:1
//结束条件:5
//用来进行累加的
//int sum = 0;
for(int i=1;i<=5;i++){
//1.求和的变量不能定义在循环的里面,因为变量只在所属的大括号中有效.
//2.如果我们把变量定义在循环的里面,那么当前变量只能在本次循环中有效.
//当本次循环结束之后,变量就会从内存中消失.
//第二次循环开始的时候,又会重新定义一个新的变量.
//如果以后我们要写累加求和的变量,可以把变量定义在循环的外面.
int sum = 0;
System.out.println(i);
//可以把得到的每一个数字累加到变量sum当中
sum=sum+i;//sum +=i;
}
//当前循环结束之后,表示已经把1~5累加到变量sum当中了
System.out.println(sum);
}
练习:求和2
需求:在实际开发中,如果要获取一个范围中的每一个数据时,会用到循环;
但是此时,大多数情况下,不会获取所有的数据,而是获取其中符合要求的数据.
此时就需要循环和其他鱼护结合使用了.
比如:求1~100之间的偶数和.
public class Test{
public static void main(String[]args){
//分析:
//1.获取1~100之间的每个数
int sum = 0;
for(int i=1;i<=100;i++){
//2.累加求和(先判断,再求和)
if(i%2==0){
sum=sun+i;
}
//打印sum
System.out.println(sum);
}
}
练习:统计满足条件的数字;
需求:键盘录入两个数字,表示一个范围.统计这个范围中,既能被3整除,又能被5整除的数字有多少个?
public class Test{
public static void main(String[]args){
//分析:
//1.键盘录入两个数字
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个数字表示范围的开始");
int start = sc.nextInt();
System.out.println("请输入一个数字表示范围的结束");
int end= sc.nextInt();
//统计变量
//简单理解,统计符合要求的数字的个数
int count =0;
//2.利用循环获取这个范围中的每一个数字
//开始条件:start
//结束条件:end
for(int i=start;i<=end;i++){
//3.对每一个数字进行判断,统计有多少可满足要求的数字
if(i%3==0&&i%5==0){
//System.out.println(i);
count++;
}
}
System.out.println(count);
}
##### while循环—-重点 #####
格式:
初始化语句;
while(条件判断语句){
循环体语句;
条件控制语句;
}
初始化语句只执行一次;
判断语句为true,循环继续;
判断语句为false,循环结束
public class Test{
public static void main(String[]args){
//需求:利用while循环打印1~100
//分析:
//开始条件:1
//结束条件:100
int i= 1;
while(i<=100){
System.out.println(i);
i++;
}
}
for和while的对比
相同点:运行规则都是一样的.
区别:
- for循环中,控制循环的变量,因为归属for循环的语法结构中,在for循环结束后,就不能再次被访问到了.
- while循环中,控制循环的变量,对于while循环来说不归属其语法结构中,在while循环结束后,该变量还可以继续使用.
练习:打印折纸的次数
需求:世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米),假如我有一张足够大的纸,它的厚度是0.1毫米.请问我折叠多少次,可以折成珠穆朗玛峰的高度?
public class Test{
public static void main(String[]args){
//分析:折叠纸张:每一次折叠纸张的厚度都是原先的两倍
//double a = 0.1;
//a = a*2;或者a *=2;
//1.定义一个变量用来记录山峰的高度
double height = 8844430;
//2.定义一个变量用来记录纸张的初始厚度
double paper = 01.;
//3.定义一个变量用来统计次数
int count=0;
//4.循环折叠纸张,只要纸张的厚度小于山峰的高度,那么循环就继续
while(paper<height){
//折叠纸张
paper = paper*2;
//折叠一次,++一次;
count++;
}
//当循环结束之后,count记录的值就是折叠的次数
System.out.println(count);
}
练习:回文数;
需求:给你一个整数X;
如果x是一个回文整数,打印true,否则,则返回false.
解释:回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数
例如121是回文,而123不是
public class Test{
public static void main(String[]args){
//核心思路:把狮子倒过来跟原来的数字进行比较
//1.定义数字
int x = 12345;
//定义一个临时变量用于记录X原来的值,用于最后进行比较
int temp =x;
//记录倒过来之后的结果;
int num = 0;
//2.利用循环从右往左获取每一位数字
while(x!=0){
//从右往左获取每一位数字
int ge = x%10;
//修改一下x记录的值
x = x/10;
//把当前获取到的数字拼接到最右边
num = num*10+ge;
}
//3.打印num
System.out.println(num);
//4.比较
System.out.println(num==temp)
//1.定义数字;
int x =12;
//2.获取个位;
int ge = x%10;//2
//获取十位;
int shi = x/10%10;//1
//拼接
int result =ge*10+shi;
System.out.println(result);
}
练习:求商和余数
需求:给定两个整数,被除数和除数(都是正数,且不超过今天的范围).
将两数相除,要求不使用乘法/除法和%运算符.
得到商和余数.
public class Test{
public static void main(String[]args){
/*分析:
被除数/除数 = 商...余数
int a = 100;
int b = 10;
100-10=90
90-10=80
80-10=70
70-10=60
...
10-10=0(余数)
*/
//1.定义变量记录被除数
int dividend = 10;
//2.定义变量用来记录除数
int divisor = 3;
//3.定义一个变量用来统计相减了多少次
int count = 0;
//4.循环while
//在循环中,不断的用被除数-除数
//只要被除数是大于除数的,那么就一直循环
while(dividend>=divisor){
dividend = dividend-divisor;
//只要减一次,那么统计变量就自增一次
count++;
}
//当循环结束之后dividend变量记录的就是余数
System.out.println("余数为:"+dividend);
//当循环结束之后,count记录的值就是商
System.out.println("商为:"+count)
}
##### do…while—以后几乎不用 #####
格式:
初始化语句;
do{
循环体语句;
条件控制语句;
}while(条件判断语句);
循环高级
无限循环
无限循环:循环一直停不下来.
注意事项:无限循环的下面不能再写其它代码了,因为循环永远停不下来,那么下面的代码永远执行不到.
for(;;){
System.out.println("学习");
}
while(true){
System.out.println("学习");
}
do{
System.out.println("学习");
}while(true);
跳转控制语句
跳转控制语句:在循环的过程中,跳转到其他语句上执行.
public class Test{
public static void main(String[]args){
//1.跳过某一次循环
for(int i=1;i<=5;i++){
if(i==3){
//结束本次循环,继续下次循环.
continue;
}
System.out.println("小老虎在吃第"+i+"个包子");
}
}
public class SkiploppDemo{
public static void main(String[]args){
//2.结束整个循环
for(int i=1;i<=5;i++){
System.out.println("小老虎在吃第"+i+"个包子");//这样可以吃三个
if(i==3){
//结束整个循环
break;
}
// System.out.println("小老虎在吃第"+i+"个包子");这样只能吃两个
}
}
小结:
- continue:跳过本次循环,继续执行下次循环
- break:结束整个循环.
练习
案例1:逢7过
朋友聚会的时候可能会玩一个游戏:逢7过;
游戏规则:从任意一个数字开始,当你要报的数字是包含7或者是7的倍数时都要说过:过;
需求:使用程序在控制台打印出1!100之间的满足逢7必过规则的数据
public class LoopTest1{
public static void main(String[]args){
//分析:
//个位是7 十位是7 7的倍数
//1 2 3 4 5 6 过 8 9 10 11 12 13 过.......
//69 过 过过.....80
//1.得到1~100之间的每一个数字
//开始条件:1
//结束条件:100
for(int i=1;i<=100;i++){
//2.判断每一个数字,如果符合规则,就打印过.如果不符合规则就打印真实的数字
if(i%10==7 || i/10%10 || i/10/10%10){
System.out.println("过");
count;
}
System.out.println(i);
}
}
案例2:求平方根 win+R 输入calc计算器快捷键
需求:键盘录入一个大于等于2的整数x,计算并返回x的平方根.
结果只保留整数部分,小数部分将被舍去.
public class LoopTest1{
public static void main(String[]args){
//分析:
//平方根 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+"就是"+num+"的平方根");
//一旦找到了,循环就可以停止了.后面的数字就不需要再找了,提高代码的运行效率.
break;
}else if(i*i>num){
System.out.println((i-1)+"就是"+num+"的平方根的整数部分");
break;
}
}
}
案例3:求质数;
需求:键盘录入一个正整数X,判断该整数是否为一个质数.
public class LoopTest1{
public static void main(String[]args){
//质数:
//如果一个数只能被1和本身整除,那么这个数就是质数,否则这个数就叫做合数.
//例如7 = 1*7 质数
//例如8 = 1*8 2*4 合数
//分析:
//1.键盘录入一个正整数
//number
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个正整数");
int number = sc.nextInt();
//定义一个变量,表示标记
//标记number是否为一个质数
//true: 是一个质数
//false: 不是一个质数
//表示最初就认为number是一个质数
boolean flag = true;
//2.判断
//写一个循环,从2开始判断,一直判断到number-1为止
//看这个范围之内,有没有数字可以被number整除
for(int i = 2;i<=number-1;i++){
//i依次表示这个范围之内的每一个数字
//看number是否被1整除就可以了.
if(number%1==0){
System.out.println(number+"不是一个质数");
break;
}else{
System.out.println(number+"是一个质数");
}
//只有当这个循环结束了,表示这个范围之内所有的数字都判断完毕了
//此时才能断定number是一个质数
if(flag){
System.out.println(number+"是一个质数");
}else{
System.out.println(number+"不是一个质数");
}
}
}
暂作了解---后期补充
public class LoopTest{
public static void main(String[]args){
//100000
//2~99999
//循环的次数:将近10万次
//推荐一个简化的思路
//81
//1*81
//3*27
//9*9
//以81的平方根9,为中心
//而且假设a*b=81
//那么a和b中,其中有一个必定是小于等于9的
//另一个是大于等于9的
//假设,都是大于9---9.1*9.1>81
//假设,都是小于9---8.9*8.9<81
//其中一个数字一定是小于等于平方根
//另外一个数字一定是大于等于平方根
int number =100;
//如果这个范围之内,所有的数字都不能被number整除
//那么number就一定是一个质数
for(int i=2;i<=number的平方根;i++){
}
}
案例四:猜数字小游戏
需求:程序自动生成一个1~100之间的随机数字,使用程序实现猜出这个数字是多少?
获取随机数:
Java帮我们写好一个类叫Random,这个类就可以生成一个随机数
public class LoopTest{
public static void main(String[]args){
//先获取一个随机数
//范围0~10
//1.导包
//2.创建对象
Random r = new Random();
//3.生成随机数
//判断技巧:
//在小括号中,书写的是生成随机数的范围
//这个范围一定是从0开始的
//到这个数-(减)1结束
//口诀:包头不包尾,包左不包右
int number = r.next(10);//0~9
System.out.println(number)
}
