尚硅谷Java入门视频教程第二章
第一章复习
课后习题
- JDK,JRE和JVM的关系是什么?
JDK = JRE + 开发工具集(例如Javac编译工具等)
JRE = JVM + Java SE标准类库 - 为什么要配置path环境变量?如何配置?
配置path环境变量原因:为了在各个路径下都可以调用java相关指令
配置方法:计算机->属性->高级系统设置->环境变量->新建系统变量->变量名(JAVA_HOME),值(jdk安装路径,bin的上一级)->确定->点击Path变量的值->新建->%JAVA_HOME%\bin->确定->确定->确定 - 常用的Windows命令行操作有哪些?
cd:切换路径、md:创建文件夹、rd:删除文件夹、del:删除文件等 - 创建如下类,使得运行可以产生如下输出:
新建java文件:ChairMan.java
public class ChairMan{
public static void main(String[] args){
System.out.println("姓名:主席");
System.out.println();
System.out.println("性别:男");
System.out.println("家庭住址:北京");
}
}
- 编译和运行上述代码的指令
-
先切换到文件所在目录
-
编译:编译是发生的错误一般为语法错误
javac ChairMan.java
出现错误:ChairMan.java:3: 错误: 编码GBK的不可映射字符
问题解决:编译时增加编码选项
javac -encoding utf-8 ChairMan.java
-
运行:运行时出错一般是运行时问题
java ChairMan
Java语言概述
-
基础知识:
- 软件:即一系列按照特定顺序组织的计算机数据和指令的集合。分为:系统软件和应用软件。
系统软件:windows、mac os、linux、android、ios…
应用软件:word、ppt…
人机交互方式:图形化界面 vs 命令行方式
应用程序 = 算法 + 数据结构 - 常用DOS命令:cd:切换路径、md:创建文件夹、rd:删除文件夹、del:删除文件等
- 计算机语言的发展迭代史
第一代:机器语言
第二代:汇编语言
第三代:高级语言-面向过程与面向对象 - Java语言版本迭代(重要时间节点)
1996年,发布JDK 1.0
1999年,Java分成J2SE、J2EE和J2ME,JSP/Servlet技术诞生
2004年,发布里程碑式版本:JDK 1.5,为突出此版本的重要性,更名为JDK 5.0
2014年,发布JDK 8.0,是继JDK 5.0以来变化最大的版本 - Java语言应用领域:
Java Web开发:后台开发
大数据开发
Android应用程序开发:客户端开发 - Java语言特点
面向对象:两个基本概念(类、对象),三大特性(封装、继承、多态)
健壮性:①去除了c语言中的指针,② 自动垃圾回收机制(仍然会出现内存溢出、内存泄露)
跨平台性:Write once , Run Anywhere——JVM
- 软件:即一系列按照特定顺序组织的计算机数据和指令的集合。分为:系统软件和应用软件。
-
开发环境搭建
- JDK,JRE和JVM的关系是什么?
JDK = JRE + 开发工具集(例如Javac编译工具等)
JRE = JVM + Java SE标准类库 - JDK下载、安装
下载:官网
安装:注意问题:安装软件的路径中不能包含中文、空格 - 为什么要配置path环境变量?如何配置?
配置path环境变量原因:为了在各个路径下都可以调用java相关指令
配置方法:计算机->属性->高级系统设置->环境变量->新建系统变量->变量名(JAVA_HOME),值(jdk安装路径,bin的上一级)->确定->点击Path变量的值->新建->%JAVA_HOME%\bin->确定->确定->确定
- JDK,JRE和JVM的关系是什么?
-
第一个Java程序
步骤:
将 Java 代码编写到扩展名为 .java 的文件中;
通过 javac 命令对该 java 文件进行编译javac ChairMan.java
;
通过 java 命令对生成的 class 文件进行运行java ChairMan
。
-
注释与API文档
- 注释:Comment
分类:
单行注释://
多行注释:/* */
文档注释 (java特有):/** */
特点:
对于单行和多行注释,被注释的文字,不会被JVM(java虚拟机)解释执行;
多行注释里面不允许有多行注释嵌套;
文档注释内容可以被JDK提供的工具 javadoc 所解析,生成一套以网页文件形式体现的该程序的说明文档。 - Java API文档
API (Application Programming Interface,应用程序编程接口)是 Java 提供的基本编程接口。习惯上将语言提供的类库都称为API。
API文档:针对于类库如何使用的说明书 - 良好的编程风格
- 注释:Comment
-
常用Java开发工具
- 文本编辑工具:
记事本、UltraEdit、 EditPlus、TextPad、 NotePad - Java集成开发环境(IDE):
JBuilder、NetBeans、Eclipse、MyEclipse、IntelliJ IDEA
- 文本编辑工具:
第2章:Java基本语法
2.1 关键字和保留字
- 关键字(keyword)的定义和特点
定义:被Java语言赋予了特殊含义,用做专门用途的字符串
特点:关键字中所有字母都为小写
官方地址: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html - Java保留字:
现有Java版本尚未使用,但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字,如goto 、const等
2.2 标识符(Identifier)
-
标识符:
Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
技巧:凡是自己可以起名字的地方都叫标识符。 -
定义合法标识符规则: 不遵守,编译失败
- 由26个英文字母大小写,0-9 ,_或 $ 组成;
- 数字不可以开头;
- 不可以使用关键字和保留字,但能包含关键字和保留字;
- Java中严格区分大小写,长度无限制;
- 标识符不能包含空格。
-
Java中的名称命名规范:不遵守,编译可以通过,但建议遵守
- 包名:多单词组成时所有字母都小写:xxxyyyzzz
- 类名、接口名:多单词组成时,所有单词的首字母大写:XxxYyyZzz(大坨峰)
- 变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写:xxxYyyZzz(小坨峰)
- 常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ
2.3 变量
2.3.1 变量基本概念
- 变量的概念:
内存中的一个存储区域
该区域的数据可以在同一类型范围内不断变化
变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值 - 变量的作用:用于在内存中保存数据
- 使用变量注意:
- Java中每个变量必须先声明,再赋值,后使用
编译错误① :使用前未定义
class VaribleTest{
public static void main(String[] args){
//编译错误:使用前myNumber未定义
System.out.println(myNumber);
//变量的声明
int myNumber;
//变量的赋值
myNumber = 1001;
//变量的使用
System.out.println(myNumber);
}
}
编译错误② :使用前仅声明,未赋值
class VaribleTest{
public static void main(String[] args){
//变量的声明
int myNumber;
//编译错误:使用myNumber前仅声明,未赋值
System.out.println(myNumber);
//变量的赋值
myNumber = 1001;
//变量的使用
System.out.println(myNumber);
}
}
- 使用变量名来访问这块区域的数据
- 变量的作用域:其定义所在的一对{ }内
- 变量只有在其作用域内才有效;出作用域,变量失效。
- 同一个作用域内,不能定义重名的变量
2.3.2 变量分类——按数据类型
对于每一种数据都定义了明确的具体数据类型(强类型语言),在内存中分配了不同大小的内存空间。
-
变量按照数据类型划分:
- 基本数据类型:
整型:byte \ short \ int \ long
浮点型:float \ double
字符型:char
布尔型:boolean - 引用数据类型:(后续补充)
类:class
接口:interface
数组:array
- 基本数据类型:
-
变量在类中声明的位置(后续补充)
成员变量 vs 局部变量
1. 整数类型:byte \ short \ int \ long
1. Java各整数类型有固定的表数范围和字段长度,不受具体OS的影响,以保证java程序的可移植性。
2. java的整型常量默认为 int 型,声明long型常量须后加‘l’或‘L’(输出结果中不带L/l)
3. java程序中变量通常声明为int型,除非不足以表示较大的数,才使用long
class VaribleTest1{
public static void main(String[] args){
//1. 整型:byte(1字节 = 8bit) \ short(2字节) \ int(4字节) \ long(8字节)
//① byte范围:-128 ~ 127
byte b1 = 12;
byte b2 = -128;
//b2 = 128;//编译不通过
System.out.println(b1);
System.out.println(b2);
// ② 声明long型变量,必须以"l"或"L"结尾
// ③ 通常,定义整型变量时,使用int型。
short s1 = 128;
int i1 = 1234;
long l1 = 3414234324L;
System.out.println(l1);
}
}
2. 浮点类型:float \ double
- 与整数类型类似,Java 浮点类型也有固定的表数范围和字段长度,不受具体操作系统的影响。
(float表示的数值范围比long还大——float有指数位) - 浮点型常量有两种表示形式:
十进制数形式:如:5.12 512.0f .512 (必须有小数点)
科学计数法形式:如:5.12e2 512E2 100E-2 - float:单精度,尾数可以精确到7位有效数字。很多情况下,精度很难满足需求。
double:双精度,精度是float的两倍。通常采用此类型。 - Java 的浮点型常量默认为double型,声明float型常量,须后加‘f’或‘F’。
class VaribleTest1{
public static void main(String[] args){
// 2. 浮点型:float(4字节) \ double(8字节)
// ① 浮点型,表示带小数点的数值
// ② float表示的数值范围比long还大
double d1 = 123.3;
System.out.println(d1+1);
// ③ 定义float类型变量时,变量要以“f”或“F”结尾
//float f1 = 12.3;//编译不通过
float f1 = 12.3F;
System.out.println(f1);
// ④ 通常,定义浮点型变量时,使用double型
}
}
3. 字符类型:char
- char 型数据用来表示通常意义上“字符”(2字节)
- Java中的所有字符都使用Unicode编码,故一个字符可以存储一个字母,一个汉字,或其他书面语的一个字符。
- 字符型变量的三种表现形式:
字符常量是用单引号(‘ ’)括起来的单个字符。例如:char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;
Java中还允许使用转义字符来将其后的字符转变为特殊字符型常量。例如:char c3 = ‘\n’; // '\n’表示换行符
直接使用 Unicode 值来表示字符型常量:‘\uXXXX’。其中,XXXX代表一个十六进制整数。如:\u000a 表示 \n。 - char类型是可以进行运算的。因为它都对应有Unicode码
class VaribleTest1{
public static void main(String[] args){
// 3. 字符型: char(1字符=2字节)
// ① 定义char型变量,通常使用一对'',内部只能写一个字符
char c1 = 'a';
//c1 = 'AB';//编译不通过
System.out.println(c1);
char c2 = '1';
char c3 = '中';
char c4 = 'ス';
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
//② 表示方式:1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
char c5 = '\n';//换行符
c5 = '\t';//制表符
System.out.print("hello" + c5);
System.out.println("world");
char c6 = '\u0043';
System.out.println(c6);
}
}
- 编码方式:字符与计算机内部的表示的对应方式
ASCII 码 -> Unicode 编码 -> UTF-8
class ReviewTest{
public static void main(String[] args){
char c1 = 'a';
char c2 = 97;//开发中非常少见,将其认为ASCII码,输出为ACSII码对应的字符
System.out.println(c2);//a
char c3 = 5;//ASCII码
char c4 = '5';//字符‘5’
int i1 = (int)c4;//将字符对应的ASCII妈转换为int型
System.out.println(i1);//53
}
}
4. 布尔类型:boolean
- boolean 类型用来判断逻辑条件,一般用于程序流程控制:
if条件控制语句;
while循环控制语句;
do-while循环控制语句;
for循环控制语句; - boolean类型数据只允许取值true和false,无null
不可以使用0或非 0 的整数替代false和true,这点和C语言不同。
Java虚拟机中没有任何供boolean值专用的字节码指令,Java语言表达所操作的boolean值,在编译之后都使用java虚拟机中的int数据类型来代替:true用1表示,false用0表示。———《java虚拟机规范 8版》
class VaribleTest1{
public static void main(String[] args){
//4.布尔型:boolean
//① 只能取两个值之一:true 、 false
//② 常常在条件判断、循环结构中使用
boolean bb1 = true;
System.out.println(bb1);
boolean isMarried = true;
if(isMarried){
System.out.println("你就不能参加\"单身\"party了!\\n 很遗憾");
//System.out.println("你就不能参加"单身"party了!\\n 很遗憾");//编译错误
}else{
System.out.println("你可以多谈谈女朋友!");
}
}
}
引用数据类型——String
- String不是基本数据类型,属于引用数据类型,翻译为:字符串
- 使用方式与基本数据类型一致。声明String类型变量时,使用一对"",例如:String str = “abcd”
- String可以和8种基本数据类型变量做运算,且运算只能是连接运算:+,运算的结果仍然是String类型
/*
String类型变量的使用
1. String属于引用数据类型,翻译为:字符串
2. 声明String类型变量时,使用一对""
3. String可以和8种基本数据类型变量做运算,且运算只能是连接运算:+
4. 运算的结果仍然是String类型
*/
class StringTest {
public static void main(String[] args) {
String s1 = "Hello World!";
System.out.println(s1);
String s2 = "a";
String s3 = "";
//char c = '';//编译不通过
//***********************
int number = 1001;
String numberStr = "学号:";
String info = numberStr + number;// +:连接运算
boolean b1 = true;
String info1 = info + b1;// +:连接运算
System.out.println(info1);
//***********************
//练习1
char c = 'a';//97 A:65
int num = 10;
String str = "hello";
System.out.println(c + num + str);//107hello
System.out.println(c + str + num);//ahello10
System.out.println(c + (num + str));//a10hello
System.out.println((c + num) + str);//107hello
System.out.println(str + num + c);//hello10a
//练习2
//* *
System.out.println("* *");//* *
System.out.println('*' + '\t' + '*');//93 //char+char+char ASCII码加法
System.out.println('*' + "\t" + '*');//* * //char+str+char 连接运算
System.out.println('*' + '\t' + "*");//51* //char+char+str ASCII码加法+连接运算
System.out.println('*' + ('\t' + "*"));//* * //char+(str+char)=char+str 连接运算
//***********************
//String str1 = 123;//编译不通过
String str1 = 123 + "";
System.out.println(str1);//"123"
//int num1 = str1;//编译不通过
//int num1 = (int)str1;//"123"//编译不通过
int num1 = Integer.parseInt(str1);
System.out.println(num1);//123
}
}
2.3.3 基本数据类型之间的运算规则
前提:这里讨论只是7种基本数据类型变量间的运算。不包含boolean类型的。
boolean类型不能与其它数据类型运算。
- 自动类型提升:
结论:当容量小的数据类型的变量与容量大的数据类型的变量做运算时,结果自动提升为容量大的数据类型。
byte 、char 、short --> int --> long --> float --> double
特别的:byte,short,char之间不会相互转换,他们三者在计算时首先转换为int类型。当byte、char、short三种类型的变量做运算时,结果为int型
说明:此时的容量大小指的是,表示数的范围的大和小。比如:float容量要大于long的容量
class VariableTest2 {
public static void main(String[] args) {
byte b1 = 2;
int i1 = 129;
//编译不通过
//byte b2 = b1 + i1;
int i2 = b1 + i1;
long l1 = b1 + i1;
System.out.println(i2);
float f = b1 + i1;
System.out.println(f);
short s1 = 123;
double d1 = s1;
System.out.println(d1);//123.0
//***************特别地*********************
char c1 = 'a';//97
int i3 = 10;
int i4 = c1 + i3;
System.out.println(i4);
short s2 = 10;
//char c2 = c1 + s2;//编译不通过
byte b2 = 10;
//char c3 = c1 + b2;//编译不通过
//short s3 = b2 + s2;//编译不通过
//short s4 = b1 + b2;//编译不通过
//****************************************
}
}
- 强制类型转换:自动类型提升运算的逆运算。
需要使用强转符:()
注意点:强制类型转换,可能导致精度损失。
class VariableTest3 {
public static void main(String[] args) {
double d1 = 12.9;
//精度损失举例1
int i1 = (int)d1;//截断操作
System.out.println(i1);//12
//没有精度损失
long l1 = 123L;
short s2 = (short)l1;
//精度损失举例2
int i2 = 128;
byte b = (byte)i2;
System.out.println(b);//-128
}
}
- 变量运算规则两个特殊情况:
① 使用long声明变量有时候不加L也可以通过编译,是因为java会默认将其转换为int类型,但当不加L且超过int的表示范围时,仍然会报错。
float类型必须加F,不加一定会报错。
② 整型常量,默认类型为int型;浮点型常量,默认类型为double型。因此在定义变量接受运算结果时,应采用int/double。
class VariableTest4 {
public static void main(String[] args) {
//1.编码情况1:
long l = 123213;
System.out.println(l);
//编译失败:过大的整数
//long l1 = 21332423235234123;
long l1 = 21332423235234123L;
//****************
//编译失败
//float f1 = 12.3;
float f1 = (float)12.3;
//2.编码情况2:
//整型常量,默认类型为int型
//浮点型常量,默认类型为double型
byte b = 12;
//byte b1 = b + 1;//编译失败
//float f1 = b + 12.3;//编译失败
}
}
2.3.4 变量之进制
- 所有数字在计算机底层都以二进制形式存在。 对于整数,有四种表示方式:
- 二进制(binary):0,1 ,满2进1.以0b或0B开头。
- 十进制(decimal):0-9 ,满10进1。
- 八进制(octal):0-7 ,满8进1. 以数字0开头表示。
- 十六进制(hex):0-9及A-F,满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。如:0x21AF +1= 0X21B0
- 二进制:
-
Java整数常量默认是int类型,当用二进制定义整数时,其第32位是符号位;当是long类型时,二进制默认占64位,第64位是符号位
-
二进制的整数有如下三种形式:
原码:直接将一个数值换成二进制数。最高位是符号位
负数的反码:是对原码按位取反,只是最高位(符号位)确定为1。
负数的补码:其反码加1。 -
计算机以二进制补码的形式保存所有的整数。
正数的原码、反码、补码都相同
负数的补码是其反码+1
特殊补码:
int型的128(0000 0000 0000 0000 0000 0000 1000 0000)强制转换为byte型时会变成-128(1000 0000)。
由于int型最高位符号位(0000 0000 0000 0000 0000 0000 1000 000)丢失,只保留了数值位,但转换为byte型后,保留的数值位的最高位变成了符号位(1000 0000),因此变为了-128。 -
为什么要使用原码、反码、补码表示形式呢?
计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂! 于是人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了。
-
2.4 运算符
运算符是一种特殊的符号,用以表示数据的运算、赋值和比较等。 包括算术运算符、赋值运算符、比较运算符(关系运算符)、逻辑运算符、位运算符、三元运算符。
2.4.1 算术运算符
注意点:
- (前)++ :先自增1,后运算
(后)++ :先运算,后自增1 - (前)-- :先自减1,后运算
(后)-- :先运算,后自减1 - 连接符: + :只能使用在String与其他数据类型之间使用。
/*
运算符之一:算术运算符
+ - + - * / % (前)++ (后)++ (前)-- (后)-- +
*/
class AriTest {
public static void main(String[] args){
//除号: /
int num1 = 12;
int num2 = 5;
int result1 = num1 / num2;
System.out.println(result1);//2
int result2 = num1 / num2 * num2;
System.out.println(result2);//10
double result3 = num1 / num2;
System.out.println(result3);//2.0
double result4 = num1 / num2 + 0.0;//2.0
double result5 = num1 / (num2 + 0.0);//2.4
double result6 = (double)num1 / num2;//2.4
double result7 = (double)(num1 / num2);//2.0
System.out.println(result4);
System.out.println(result5);
System.out.println(result6);
System.out.println(result7);
//%:取余运算
//结果的符号与被模数的符号相同
//开发中,尝使用%来判断能否被除尽的情况
int m1 = 12;
int n1 = 5;
System.out.println("m1 % n1 = " + m1 % n1);//2
int m2 = -12;
int n2 = 5;
System.out.println("m2 % n2 = " + m2 % n2);//-2
int m3 = 12;
int n3 = -5;
System.out.println("m3 % n3 = " + m3 % n3);//2
int m4 = -12;
int n4 = -5;
System.out.println("m4 % n4 = " + m4 % n4);//-2
//(前)++ :先自增1,后运算
//(后)++ :先运算,后自增1
int a1 = 10;
int b1 = ++a1;
System.out.println("a1 = " + a1 + ",b1 = " + b1);//11, 11
int a2 = 10;
int b2 = a2++;
System.out.println("a2 = " + a2 + ",b2 = " + b2);//11, 10
int a3 = 10;
++a3;//a3++;
int b3 = a3;
//注意点:
short s1 = 10;
//s1 = s1 + 1;//编译失败
//s1 = (short)(s1 + 1);//正确的
s1++;//自增1不会改变本身变量的数据类型
System.out.println(s1);
//问题:
byte bb1 =127;
bb1++;
System.out.println("bb1 = " + bb1);//-128
//(前)-- :先自减1,后运算
//(后)-- :先运算,后自减1
int a4 = 10;
int b4 = --a4;
System.out.println("a4 = " + a4 + ", b4 = " + b4);//9, 9
int a5 = 10;
int b5 = a5--;
System.out.println("a5 = " + a5 + ", b5 = " + b5);//9, 10
}
}
练习题:
随意给出一个三位数的整数,打印显示它的个位数,十位数,百位数的值。
class AriExer {
public static void main(String[] args) {
int num = 187;
int bai = num / 100;
int shi = num % 100 / 10;//int shi = num / 10 % 10;
int ge = num % 10;
System.out.println("百位为:" + bai);
System.out.println("十位为:" + shi);
System.out.println("个位为:" + ge);
}
}
2.4.2 赋值运算符
-
符号:=
当“=”两侧数据类型不一致时,可以使用自动类型转换或使用强制类型转换原则进行处理。
支持连续赋值。 -
扩展赋值运算符: +=, -=, *=, /=, %=
-
运算的结果不改变数据类型
-
开发中,如果希望变量实现+2的操作,有几种方法?(前提:int num = 10;)
方式一:num = num + 2;
方式二:num += 2; (推荐) -
开发中,如果希望变量实现+1的操作,有几种方法?(前提:int num = 10;)
方式一:num = num + 1;
方式二:num += 1;
方式三:num++; (推荐)
/*
运算符之二:赋值运算符
= += -= *= /= %=
*/
class SetValueTest {
public static void main(String[] args) {
//赋值符号:=
int i1 = 10;
int j1 = 10;
int i2,j2;
//连续赋值
i2 = j2 = 10;
int i3 = 10,j3 = 20;
//*********************
int num1 = 10;
num1 += 2;//num1 = num1 + 2;
System.out.println(num1);//12
int num2 = 12;
num2 %= 5;//num2 = num2 % 5;
System.out.println(num2);//2
short s1 = 10;
//s1 = s1 + 2;//编译失败
s1 += 2;//结论:不会改变变量本身的数据类型
System.out.println(s1);
//开发中,如果希望变量实现+2的操作,有几种方法?(前提:int num = 10;)
//方式一:num = num + 2;
//方式二:num += 2; (推荐)
//开发中,如果希望变量实现+1的操作,有几种方法?(前提:int num = 10;)
//方式一:num = num + 1;
//方式二:num += 1;
//方式三:num++; (推荐)
//练习1
int i = 1;
i *= 0.1;
System.out.println(i);//0
i++;
System.out.println(i);//1
//练习2
int m = 2;
int n = 3;
n *= m++; //n = n * m++;//先运算,后+1
System.out.println("m=" + m);//3
System.out.println("n=" + n);//6
//练习3
int n1 = 10;
n1 += (n1++) + (++n1);//n1 = n1 + (n1++) + (++n1);
System.out.println(n1);//32
}
}
4.2.3 比较运算符
- 比较运算符的结果是boolean类型
- 区分 == 和 =
- > \ < \ >= \ <= :只能使用在数值类型的数据之间
- ==:不仅可以使用在数值类型的数据之间,还可以使用在其他引用类型变量之间。
/*
运算符之三:比较运算符
== != > < >= <= instanceof
结论:
1.比较运算符的结果是boolean类型
2.区分 == 和 =
*/
class CompareTest {
public static void main(String[] args) {
int i = 10;
int j = 20;
System.out.println(i == j);//false
System.out.println(i = j);//20
boolean b1 = true;
boolean b2 = false;
System.out.println(b2 == b1);//false
System.out.println(b2 = b1);//true
}
}
4.2.4 逻辑运算符
- 逻辑运算符操作的都是boolean类型的变量,得到的结果也是boolean类型。
- 区分& 与 &&
相同点1:& 与 && 的运算结果相同
相同点2:当符号左边是true时,二者都会执行符号右边的运算
不同点:当符号左边是false时,&继续执行符号右边的运算。&&不再执行符号右边的运算。
开发中,推荐使用&& - 区分:| 与 ||
相同点1:| 与 || 的运算结果相同
相同点2:当符号左边是false时,二者都会执行符号右边的运算
不同点3:当符号左边是true时,|继续执行符号右边的运算,而||不再执行符号右边的运算
开发中,推荐使用||
/*
运算符之四:逻辑运算符
& && | || ! ^
说明:
1.逻辑运算符操作的都是boolean类型的变量
*/
class LogicTest {
public static void main(String[] args) {
//区分& 与 &&
//相同点1:& 与 && 的运算结果相同
//相同点2:当符号左边是true时,二者都会执行符号右边的运算
//不同点:当符号左边是false时,&继续执行符号右边的运算。&&不再执行符号右边的运算。
//开发中,推荐使用&&
boolean b1 = true;
b1 = false;
int num1 = 10;
if(b1 & (num1++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num1 = " + num1);
boolean b2 = true;
b2 = false;
int num2 = 10;
if(b2 && (num2++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num2 = " + num2);
// 区分:| 与 ||
//相同点1:| 与 || 的运算结果相同
//相同点2:当符号左边是false时,二者都会执行符号右边的运算
//不同点3:当符号左边是true时,|继续执行符号右边的运算,而||不再执行符号右边的运算
//开发中,推荐使用||
boolean b3 = false;
b3 = true;
int num3 = 10;
if(b3 | (num3++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num3 = " + num3);
boolean b4 = false;
b4 = true;
int num4 = 10;
if(b4 || (num4++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num4 = " + num4);
}
}
练习1:
练习2:
class Test {
public static void main (String [] args) {
boolean x = true;
boolean y = false;
short z = 42;
//if(y == true)
if((z++ == 42)&&(y = true))z++;//((先比较,后增1 -> T,z:43)&&(赋值语句:与= true -> T)) - > T -> z:44
if((x = false) || (++z == 45)) z++;//((F)||(先增1,再比较 -> z:45, T)) -> T -> z: 46
System.out.println("z = " + z);//46
}
}
2.4.5 位运算符
- 位运算符操作的都是整型的数据
- << :在一定范围内,每向左移1位,相当于 * 2
>> :在一定范围内,每向右移1位,相当于 / 2
面试题:最高效方式的计算2 * 8 ?
2 << 3 或 8 << 1 - 没有<<<
- 细节问题:
/*
运算符之五:位运算符 (了解)
结论:
1. 位运算符操作的都是整型的数据
2. << :在一定范围内,每向左移1位,相当于 * 2
>> :在一定范围内,每向右移1位,相当于 / 2
面试题:最高效方式的计算2 * 8 ? 2 << 3 或 8 << 1
*/
class BitTest {
public static void main(String[] args) {
int i = 21;
i = -21;
System.out.println("i << 2 :" + (i << 2));
System.out.println("i << 3 :" + (i << 3));
System.out.println("i << 27 :" + (i << 27));
int m = 12;
int n = 5;
System.out.println("m & n :" + (m & n));
System.out.println("m | n :" + (m | n));
System.out.println("m ^ n :" + (m ^ n));
//练习:交换两个变量的值
int num1 = 10;
int num2 = 20;
System.out.println("num1 = " + num1 + ",num2 = " + num2);
//方式一:定义临时变量的方式
//推荐的方式
int temp = num1;
num1 = num2;
num2 = temp;
//方式二:好处:不用定义临时变量
//弊端:① 相加操作可能超出存储范围 ② 有局限性:只能适用于数值类型
//num1 = num1 + num2;
//num2 = num1 - num2;
//num1 = num1 - num2;
//方式三:使用位运算符
//有局限性:只能适用于数值类型
//num1 = num1 ^ num2;
//num2 = num1 ^ num2;
//num1 = num1 ^ num2;
System.out.println("num1 = " + num1 + ",num2 = " + num2);
}
}
- 例题1:如何求一个0-255范围内的整数的十六进制值。如:60的十六进制形式为3C
/*
如何求一个0-255范围内的整数的十六进制值。如:60的十六进制形式为3C
*/
class BitTest2{
public static void main(String[] args) {
int i1 = 60;
int i2 = i1 & 15;//15的二进制只有最低四位为1111,因此按位相与后只保留i1的最低四位的值
String j = (i2>9)?(char)(i2-10+'A')+"":i2+"";//+""是将结果变成字符串,防止字符之间进行运算
int temp = i1 >>> 4;
i2 = temp & 15;
String k = (i2>9)?(char)(i2-10+'A')+"":i2+"";
System.out.println(k+""+j);
}
}
2.4.6 三元运算符
- 格式: (条件表达式)? 表达式1 : 表达式2
- 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假,决定执行表达式1,还是表达式2.
如果表达式为true,则执行表达式1。
如果表达式为false,则执行表达式2。
③ 表达式1 和表达式2要求是一致的(可以用同种类型接收 )。
④ 三元运算符可以嵌套使用 - 凡是可以使用三元运算符的地方,都可以改写为if-else
反之,不成立。 - 三元运算符与if-else的联系与区别:
1)三元运算符可简化if-else语句
2)三元运算符要求必须返回一个结果。
3)if后的代码块可有多个语句 - 如果程序既可以使用三元运算符,又可以使用if-else结构,那么优先选择三元运算符。原因:简洁、执行效率高。
- 说明
/*
运算符之六:三元运算符
1.结构:(条件表达式)? 表达式1 : 表达式2
2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假,决定执行表达式1,还是表达式2.
如果表达式为true,则执行表达式1。
如果表达式为false,则执行表达式2。
③ 表达式1 和表达式2要求是一致的。
④ 三元运算符可以嵌套使用
3.
凡是可以使用三元运算符的地方,都可以改写为if-else
反之,不成立。
4. 如果程序既可以使用三元运算符,又可以使用if-else结构,那么优先选择三元运算符。原因:简洁、执行效率高。
*/
class SanYuanTest {
public static void main(String[] args) {
//获取两个整数的较大值
int m = 12;
int n = 5;
int max = (m > n)? m : n;
System.out.println(max);
double num = (m > n)? 2 : 1.0;
//(m > n)? 2 : "n大";//编译错误
//**************************
n = 12;
String maxStr = (m > n)? "m大" : ((m == n)? "m和n相等" : "n大");
System.out.println(maxStr);
//*****************************
//获取三个数的最大值
int n1 = 12;
int n2 = 30;
int n3 = -43;
int max1 = (n1 > n2)? n1 : n2;
int max2 = (max1 > n3)? max1 : n3;
System.out.println("三个数中的最大值为:" + max2);
//不建议
//int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
//System.out.println("三个数中的最大值为:" + max3);
//该写成if-else:
if(m > n){
System.out.println(m);
}else{
System.out.println(n);
}
}
}
运算符优先级
- 运算符有不同的优先级,所谓优先级就是表达式运算中的运算顺序。如下表,上一行运算符总优先于下一行。
- 只有单目运算符、三元运算符、赋值运算符是从右向左运算的。
2.5 程序流程控制
- 流程控制语句是用来控制程序中各语句执行顺序的语句,可以把语句组合成能完成一定功能的小逻辑模块。
- 其流程控制方式采用结构化程序设计中规定的三种基本流程结构,即:
- 顺序结构
程序从上到下逐行地执行,中间没有任何判断和跳转。 - 分支结构
根据条件,选择性地执行某段代码。
有if…else和switch-case两种分支语句。 - 循环结构
根据循环条件,重复性的执行某段代码。
有while、do…while、for三种循环语句。
注:JDK1.5提供了foreach循环,方便的遍历集合、数组元素。
- 顺序结构
2.5.1 顺序结构
Java中定义成员变量时采用合法的前向引用。如:
2.5.2 分支语句1:if-else结构
- if-else的三种情况:
-
一分支执行,一分支不执行
-
两分支二选一
-
多选一
-
/*
分支结构中的if-else(条件判断结构)
一、三种结构
第一种:
if(条件表达式){
执行表达式
}
第二种:二选一
if(条件表达式){
执行表达式1
}else{
执行表达式2
}
第三种:n选一
if(条件表达式){
执行表达式1
}else if(条件表达式){
执行表达式2
}else if(条件表达式){
执行表达式3
}
...
else{
执行表达式n
}
*/
class IfTest {
public static void main(String[] args) {
//举例1
int heartBeats = 79;
if(heartBeats < 60 || heartBeats > 100){
System.out.println("需要做进一步检查");
}
System.out.println("检查结束");
//举例2
int age = 23;
if(age < 18){
System.out.println("你还未成年");
}else{
System.out.println("你已经成年了");
}
//举例3
if(age < 0){
System.out.println("您输入的数据非法");
}else if(age < 18){
System.out.println("青少年时期");
}else if(age < 35){
System.out.println("青壮年时期");
}else if(age < 60){
System.out.println("中年时期");
}else if(age < 120){
System.out.println("老年时期");
}else{
System.out.println("你是要成仙啊~~");
}
}
}
- Scanner的使用:
如何从键盘获取不同类型的变量:需要使用Scanner类
具体实现步骤:- 导包:import java.util.Scanner;
- Scanner的实例化:Scanner scan = new Scanner(System.in);
- 调用Scanner类的相关方法(next() / nextXxx()),来获取指定类型的变量
//1.导包:import java.util.Scanner;
import java.util.Scanner;
class ScannerTest{
public static void main(String[] args){
//2.Scanner的实例化
Scanner scan = new Scanner(System.in);
//3.调用Scanner类的相关方法
System.out.println("请输入你的姓名:");
String name = scan.next();
System.out.println(name);
System.out.println("请输入你的芳龄:");
int age = scan.nextInt();
System.out.println(age);
System.out.println("请输入你的体重:");
double weight = scan.nextDouble();
System.out.println(weight);
System.out.println("你是否相中我了呢?(true/false)");
boolean isLove = scan.nextBoolean();
System.out.println(isLove);
//对于char型的获取,Scanner没有提供相关的方法。只能获取一个字符串
System.out.println("请输入你的性别:(男/女)");
String gender = scan.next();//"男"
char genderChar = gender.charAt(0);//获取索引为0位置上的字符
System.out.println(genderChar);
}
}
注意:
需要根据相应的方法,来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时,会报异常:InputMisMatchException,导致程序终止。
- If-else练习题
1.岳小鹏参加Java考试,他和父亲岳不群达成承诺,如果:
成绩为100分时,奖励一辆BMW;
成绩为(80,99]时,奖励一台iphone xs max;
当成绩为[60,80]时,奖励一个 iPad;
其它时,什么奖励也没有。
请从键盘输入岳小鹏的期末成绩,并加以判断。
/*
说明:
1. else 结构是可选的。
2. 针对于条件表达式:
> 如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面,无所谓。
> 如果多个条件表达式之间有交集的关系,需要根据实际情况,考虑清楚应该将哪个结构声明在上面。
> 如果多个条件表达式之间有包含的关系,通常情况下,需要将范围小的声明在范围大的上面。否则,范围小的就没机会执行了。
*/
import java.util.Scanner;
class IfTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入岳小鹏期末成绩:(0-100)");
int score = scan.nextInt();
if(score == 100){
System.out.println("奖励一辆BMW");
}else if(score > 80 && score <= 99){
System.out.println("奖励一台iphone xs max");
}else if(score >= 60 && score <= 80){
System.out.println("奖励一个 iPad");
}else{
System.out.println("什么奖励也没有");
}
}
}
- 编写程序:由键盘输入三个整数分别存入变量num1、num2、num3,对它们进行排序(使用 if-else if-else),并且从小到大输出。
/*
说明:
1. if-else结构是可以相互嵌套的。
2. 如果if-else结构中的执行语句只有一行时,对应的一对{}可以省略的。但是,不建议大家省略。
*/
import java.util.Scanner;
class IfTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个整数:");
int num1 = scan.nextInt();
System.out.println("请输入第二个整数:");
int num2 = scan.nextInt();
System.out.println("请输入第三个整数:");
int num3 = scan.nextInt();
if(num1 >= num2){
if(num3 >= num1)
System.out.println(num2 + "<" + num1 + "<" + num3);
else if (num3 <= num2)
System.out.println(num3 + "<" + num2 + "<" + num1);
else
System.out.println(num2 + "<" + num3 + "<" + num1);
}else{
if(num3 >= num2)
System.out.println(num1 + "<" + num2 + "<" + num3);
else if (num3 <= num1)
System.out.println(num3 + "<" + num1 + "<" + num2);
else
System.out.println(num1 + "<" + num3 + "<" + num2);
}
}
}
- 练习:判断输出结果
①输出atguigu
②输出 x is 4
③ b ==false:b
b=false:c
java随机数生成
如何获取一个随机数:10-99
(int)(Math.random() * 90 + 10)//[0.0, 1.0) -> [0.0, 90.0) -> [10.0,100.0) -> [10, 99]
公式[a, b]:
(int)(Math.random * (b - a + 1) + a)
2.5.3 分支语句2:switch-case结构
- 格式
- 说明:
- 根据switch表达式中的值,依次匹配各个case中的常量。一旦匹配成功,则进入相应case结构中,调用其执行语句。
当调用完执行语句以后,则仍然继续向下执行其他case结构中的执行语句,直到遇到break关键字或此switch-case结构末尾结束为止。 - break,可以使用在switch-case结构中,表示一旦执行到此关键字,就跳出switch-case结构
- switch结构中的表达式,只能是如下的6种数据类型之一:
byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增) - case 之后只能声明常量,不能声明范围。
- break关键字是可选的。
- default:相当于if-else结构中的else.
default结构是可选的,而且位置是灵活的。
- 根据switch表达式中的值,依次匹配各个case中的常量。一旦匹配成功,则进入相应case结构中,调用其执行语句。
class SwitchCaseTest {
public static void main(String[] args) {
int number = 5;
switch(number){
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
case 3:
System.out.println("three");
break;
default:
System.out.println("other");
//break;
}
String season = "summer";
switch (season) {
case "spring":
System.out.println("春暖花开");
break;
case "summer":
System.out.println("夏日炎炎");
break;
case "autumn":
System.out.println("秋高气爽");
break;
case "winter":
System.out.println("冬雪皑皑");
break;
default:
System.out.println("季节输入有误");
break;
}
//**************如下的两种情况都编译不通过*********************
//情况一: switch表达式不可以为boolean类型
/*
boolean isHandsome = true;
switch(isHandsome){
case true:
System.out.println("我好帅啊~~~");
break;
case false:
System.out.println("我好丑啊~~~");
break;
default:
System.out.println("输入有误~~~");
}
*/
//情况二:case常量不可以为表达式
/*
int age = 10;
switch(age){
case age > 18:
System.out.println("成年了");
break;
default:
System.out.println("未成年");
}
*/
}
}
- 例题
- 对学生成绩大于60分的,输出“合格”。低于60分的,输出“不合格”。
说明:如果switch-case结构中的多个case的执行语句相同,则可以考虑进行合并。
class SwitchCaseTest1 {
public static void main(String[] args) {
/*
int score = 78;
switch(score){
case 0:
case 1:
case 2:
...
case 100:
}
*/
/*
int score = 78;
if(score >= 60){
}else{
}
*/
int score = 78;
switch(score / 10){
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("不及格");
break;
case 6:
case 7:
case 8:
case 9:
case 10:
System.out.println("及格");
break;
}
//更优的解决方案:
switch(score / 60){
case 0:
System.out.println("不及格");
break;
case 1:
System.out.println("及格");
break;
}
}
}
- 编写程序:从键盘上输入2019年的“month”和“day”,要求通过程序输出输入的日期为2019年的第几天。
/*
2 15: 31 + 15
5 7: 31 + 28 + 31 + 30 + 7
....
说明:break在switch-case中是可选的
*/
import java.util.Scanner;
class SwitchCaseTest2{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入2019年的month:");
int month = scan.nextInt();
System.out.println("请输入2019年的day:");
int day = scan.nextInt();
//定义一个变量来存储总天数
int sumDays = 0;
switch(month){
case 12:
sumDays = 30;
case 11:
sumDays += 31;
case 10:
sumDays += 30;
case 9:
sumDays += 31;
case 8:
sumDays += 31;
case 7:
sumDays += 30;
case 6:
sumDays += 31;
case 5:
sumDays += 30;
case 4:
sumDays += 31;
case 3:
sumDays += 28;
case 2:
sumDays += 31;
case 1:
sumDays += day;
}
System.out.println("2019年" + month + "月" + day + "日是当年的第" + sumDays + "天");
}
}
- 从键盘分别输入年、月、日,判断这一天是当年的第几天
注:判断一年是否是闰年的标准:
1)可以被4整除,但不可被100整除
或
2)可以被400整除
/*
说明:
1. 凡是可以使用switch-case的结构,都可以转换为if-else。反之,不成立。
2. 我们写分支结构时,当发现既可以使用switch-case,(同时,switch中表达式的取值情况不太多),又可以使用if-else时,我们优先选择使用switch-case。原因:switch-case执行效率稍高。
*/
import java.util.Scanner;
class SwitchCaseExer {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入year:");
int year = scan.nextInt();
System.out.println("请输入month:");
int month = scan.nextInt();
System.out.println("请输入day:");
int day = scan.nextInt();
//定义一个变量来保存总天数
int sumDays = 0;
switch(month){
case 12:
sumDays += 30;
case 11:
sumDays += 31;
case 10:
sumDays += 30;
case 9:
sumDays += 31;
case 8:
sumDays += 31;
case 7:
sumDays += 30;
case 6:
sumDays += 31;
case 5:
sumDays += 30;
case 4:
sumDays += 31;
case 3:
//sumDays += 28;
//判断year是否是闰年
if((year % 4 == 0 && year % 100 != 0 ) || year % 400 == 0){
sumDays += 29;
}else{
sumDays += 28;
}
case 2:
sumDays += 31;
case 1:
sumDays += day;
}
System.out.println(year + "年" + month + "月" + day + "日是当年的第" + sumDays + "天");
}
}
2.5.4 循环结构1:for循环
- 循环结构:在某些条件满足的情况下,反复执行特定代码的功能
- 循环语句分类:
for 循环
while 循环
do-while 循环 - 循环语句的四个组成部分:
- 初始化部分(init_statement)
- 循环条件部分(test_exp) :boolean类型
- 循环体部分(body_statement)
- 迭代部分(alter_statement)
- for循环
- 语法格式
for (①初始化部分; ②循环条件部分; ④迭代部分){
③循环体部分;
}
- 执行过程:
①-②-③-④-②-③-④-②-③-④-…-②
- 说明:
②循环条件部分为boolean类型表达式,当值为false时,退出循环
①初始化部分可以声明多个变量,但必须是同一个类型,用逗号分隔
④可以有多个变量更新,用逗号分隔
/*
For循环结构的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件
二、for循环的结构
for(①;②;④){
③
}
执行过程:① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
*/
class ForTest {
public static void main(String[] args) {
/*
System.out.println("Hello World!");
System.out.println("Hello World!");
System.out.println("Hello World!");
System.out.println("Hello World!");
System.out.println("Hello World!");
*/
for(int i = 1;i <= 5;i++){//i:1,2,3,4,5
System.out.println("Hello World!");
}
//i:在for循环内有效。出了for循环就失效了。
//System.out.println(i);
//练习:
int num = 1;
for(System.out.print('a');num <= 3;System.out.print('c'),num++){
System.out.print('b');
}
//输出结果:abcbcbc
System.out.println();
//例题:遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
//int sum;//编译错误,变量在使用之前必须先赋值
int sum = 0;//记录所有偶数的和
int count = 0;//记录偶数的个数
for(int i = 1;i <= 100;i++){
if(i % 2 == 0){
System.out.println(i);
sum += i;
count++;
}
//System.out.println("总和为:" + sum);
}
System.out.println("总和为:" + sum);
System.out.println("个数为:" + count);
}
}
- 例题
- 编写程序从1循环到150,并在每行打印一个值,另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”
class ForTest1 {
public static void main(String[] args) {
for(int i = 1;i <= 150;i++){
System.out.print(i + " ");
if(i % 3 == 0){
System.out.print("foo" + " ");
}
if(i % 5 == 0){
System.out.print("biz" + " ");
}
if(i % 7 == 0){
System.out.print("baz" + " ");
}
System.out.println();
}
}
}
- 题目:输入两个正整数m和n,求其最大公约数和最小公倍数。
比如:12和20的最大公约数是4,最小公倍数是60。
/*
说明:break关键字的使用:一旦在循环中执行到break,就跳出循环
*/
import java.util.Scanner;
class ForTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个正整数:");
int m = scan.nextInt();
System.out.println("请输入第二个正整数:");
int n = scan.nextInt();
//获取最大公约数(一定在1-较小数之间)
int min = (m <= n)? m : n;
for(int i = min;i >= 1;i--){
if(m % i == 0 && n % i == 0){
System.out.println("最大公约数为:" + i);
break;
}
}
//获取最小公倍数(一定在较大数-m*n之间)
int max = (m >= n)? m : n;
for(int i = max;i <= m*n;i++){
if(i % m == 0 && i % n == 0){
System.out.println("最小公倍数为:" + i);
break;
}
}
}
}
2.5.5 循环结构2:while循环
- 语法格式
①初始化部分
while(②循环条件部分){
③循环体部分; ④迭代部分;
}
- 执行过程:
①-②-③-④-②-③-④-②-③-④-…-② - 说明:
- 注意不要忘记声明④迭代部分。否则,循环将不能结束,变成死循环。
- for循环和while循环可以相互转换
区别:for循环和while循环的初始化条件部分的作用范围不同。
/*
说明:
1.写while循环千万小心不要丢了迭代条件。一旦丢了,就可能导致死循环!
2.我们写程序,要避免出现死循环。
3.for循环和while循环是可以相互转换的!
区别:for循环和while循环的初始化条件部分的作用范围不同。
算法:有限性。
*/
class WhileTest{
public static void main(String[] args) {
//遍历100以内的所有偶数
int i = 1;
while(i <= 100){
if(i % 2 == 0){
System.out.println(i);
}
i++;
}
//出了while循环以后,仍可以调用。
System.out.println(i);//101
}
}
2.5.6 循环结构3:do-while循环
- 语法格式
①初始化部分;
do{
③循环体部分
④迭代部分
}while(②循环条件部分);
- 执行过程:
①-③-④-②-③-④-②-③-④-…② - 说明:
do-while循环至少执行一次循环体。
/*
do-while循环的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件
二、do-while循环结构:
①
do{
③;
④;
}while(②);
执行过程:① - ③ - ④ - ② - ③ - ④ - ... - ②
说明:
1.do-while循环至少会执行一次循环体!
2.开发中,使用for和while更多一些。较少使用do-while
*/
class DoWhileTest {
public static void main(String[] args) {
//遍历100以内的偶数,并计算所有偶数的和及偶数的个数
int num = 1;
int sum = 0;//记录总和
int count = 0;//记录个数
do{
if(num % 2 == 0){
System.out.println(num);
sum += num;
count++;
}
num++;
}while(num <= 100);
System.out.println("总和为:" + sum);
System.out.println("个数为:" + count);
//*************体会do-while至少执行一次循环体***************
int number1 = 10;
while(number1 > 10){
System.out.println("hello:while");
number1--;
}
int number2 = 10;
do{
System.out.println("hello:do-while");
number2--;
}while(number2 > 10);
}
}
- 循环结构综合例题
从键盘读入个数不确定的整数,并判断读入的正数和负数的个数,输入为0时结束程序。
/*
说明:
1. 不在循环条件部分限制次数的结构:for(;;) 或 while(true)
2. 结束循环有几种方式?
方式一:循环条件部分返回false
方式二:在循环体中,执行break
*/
import java.util.Scanner;
class ForWhileTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int positiveNumber = 0;//记录正数的个数
int negativeNumber = 0;//记录负数的个数
for(;;){//while(true){
int number = scan.nextInt();
//判断number的正负情况
if(number > 0){
positiveNumber++;
}else if(number < 0){
negativeNumber++;
}else{
//一旦执行break,跳出循环
break;
}
}
System.out.println("输入的正数个数为:" + positiveNumber);
System.out.println("输入的负数个数为:" + negativeNumber);
}
}
2.5.7 嵌套循环(多重循环)
- 将一个循环放在另一个循环体内,就形成了嵌套循环。其中,for ,while ,do…while均可以作为外层循环或内层循环。
- 实质上,嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时,才会完全跳出内层循环,才可结束外层的当次循环,开始下一次的循环。
- 假设外层循环次数为m次,内层为n次,则内层循环体实际上需要执行m*n次。
外层循环控制行数,内层循环控制列数。 - 例题
- 打印如下的图形:菱形1
*
* *
* * *
* * * *
* * * * *
* * * *
* * *
* *
*
class ForForTest{
public static void main(String[] args){
for(int i = 1; i <= 5; i++){
for(int j = 1; j <= 5-i; j++){
System.out.print(" ");
}
for(int k = 1; k <= i; k++){
System.out.print("* ");
}
System.out.println();
}
for(int i = 1; i <= 4; i++){
for(int j = 1; j <= i; j++){
System.out.print(" ");
}
for(int k = 1; k <= 5 - i; k++){
System.out.print("* ");
}
System.out.println();
}
}
}
- 九九乘法表
/*
嵌套循环的应用1:
九九乘法表
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
。。。
9 * 1 = 9 。。。 9 * 9 = 81
*/
class NineNineTable {
public static void main(String[] args) {
for(int i = 1;i <= 9;i++){
for(int j = 1;j <= i;j++){
System.out.print(i + " * " + j + " = " + i*j + " ");
}
System.out.println();
}
}
}
- 输出100以内所有的质数
/*
100以内的所有质数的输出。
质数:素数,只能被1和它本身整除的自然数。-->从2开始,到这个数-1结束为止,都不能被这个数本身整除。
最小的质数是:2
*/
class PrimeNumber{
public static void main(String[] args){
int flag;//设置标志位,判断是否为质数
int count = 0;
for(int i = 2;i <= 100;i++){
flag = 0;
for(int j = 2;j < i;j++){
if(i % j == 0){
flag = 1;//若能被其他数整除,则不是质数,改变标志位
break;//主要出现能被其他数整除的情况,就不是质数,不用继续判断
}
}
if(flag == 0){
System.out.println(i);
count++;
}
}
System.out.println("100以内的所有质数共有" + count +"个。");
}
}
优化:内部循环只需要比较到根号i即可(<=Math.sqrt(i))
/*
100000以内的所有质数的输出。实现方式一
质数:素数,只能被1和它本身整除的自然数。-->从2开始,到这个数-1结束为止,都不能被这个数本身整除。
对PrimeNumberTest.java文件中质数输出问题的优化
*/
class PrimeNumber1 {
public static void main(String[] args) {
boolean isFlag = true;//标识i是否被j除尽,一旦除尽,修改其值
int count = 0;//记录质数的个数
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long start = System.currentTimeMillis();
for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
//优化二:对本身是质数的自然数是有效的。
//for(int j = 2;j < i;j++){
for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
if(i % j == 0){ //i被j除尽
isFlag = false;
break;//优化一:只对本身非质数的自然数是有效的。
}
}
//
if(isFlag == true){
//System.out.println(i);
count++;
}
//重置isFlag
isFlag = true;
}
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long end = System.currentTimeMillis();
System.out.println("质数的个数为:" + count);
System.out.println("所花费的时间为:" + (end - start));//17110 - 优化一:break:1546 - 优化二:13
}
}
2.5.8 特殊关键字的使用:break、continue
- break 语句
break语句用于终止某个语句块的执行
{ ……
break;
……
}
-
continue 语句
- continue只能使用在循环结构中
- continue语句用于跳过其所在循环语句块的一次执行,继续下一次循环
- continue语句出现在多层嵌套的循环语句体中时,可以通过标签指明要跳过的是哪一层循环
-
break/continue语句出现在多层嵌套的语句块中时,可以通过标签指明要终止的是哪一层语句块
label1: { ……
label2: { ……
label3: { ……
break label2;//continue label 2;
……
}
}
}
- break和continue关键字的使用异同
使用范围 | 循环中使用的作用(不同点) | 相同点 | |
---|---|---|---|
break | switch-case \ 循环结构中 | 结束当前循环 | 关键字后面不能声明执行语句 |
continue | 循环结构中 | 结束当次循环 | 关键字后面不能声明执行语句 |
class BreakContinueTest {
public static void main(String[] args) {
for(int i = 1;i <= 10;i++){
if(i % 4 == 0){
break;//123
//continue;//123567910
//System.out.println("今晚迪丽热巴要约我!!!");//编译错误
}
System.out.print(i);
}
System.out.println("\n");
//******************************
label:for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
//break;//默认跳出包裹此关键字最近的一层循环。
//continue;
//break label;//结束指定标识的一层循环结构//123
continue label;//结束指定标识的一层循环结构当次循环//123123123
}
System.out.print(j);
}
System.out.println();
}
}
}
- 求质数的另一种解法(用continue)
/*
100000以内的所有质数的输出。实现方式二
质数:素数,只能被1和它本身整除的自然数。-->从2开始,到这个数-1结束为止,都不能被这个数本身整除。
对PrimeNumberTest.java文件中质数输出问题的优化
*/
class PrimeNumberTest2 {
public static void main(String[] args) {
int count = 0;//记录质数的个数
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long start = System.currentTimeMillis();
label:for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
if(i % j == 0){ //i被j除尽
continue label;
}
}
//能执行到此步骤的,都是质数
count++;
}
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long end = System.currentTimeMillis();
System.out.println("质数的个数为:" + count);
System.out.println("所花费的时间为:" + (end - start));
}
}
项目一:家庭收支记账软件
主函数:
class FamilyAccount{
public static void main(String[] args){
boolean isFlag = true;
String details = "收支\t账户金额\t收支金额\t说 明\n";
int balance = 1000;//记录当前账户总金额
while(isFlag){
System.out.println("-----------------家庭收支软件-----------------");
System.out.println(" 1 收支明细");
System.out.println(" 2 登记收入");
System.out.println(" 3 登记支出");
System.out.println(" 4 退 出");
System.out.println();
System.out.print(" 请选择(1-4):");
char selection = Utility.readMenuSelection();
switch(selection){
case '1':
//System.out.println("1 收支明细");
System.out.println("-----------------当前收支明细记录-----------------");
System.out.println(details);
System.out.println("--------------------------------------------------\n");
break;
case '2':
//System.out.println("2 登记收入");
//读取收入信息
System.out.print("本次收入金额:");
int income = Utility.readNumber();
System.out.print("本次收入说明:");
String incomeInfo = Utility.readString();
//更新账户信息
balance += income;
details += "收入\t" + balance + "\t\t" + income + "\t\t" + incomeInfo + "\n";
System.out.println("---------------------登记完成----------------------\n");
break;
case '3':
//System.out.println("3 登记支出");
//读取支出信息
System.out.print("本次支出金额:");
int expendture = Utility.readNumber();
System.out.print("本次支出说明:");
String expendtureInfo = Utility.readString();
if(expendture > balance){
System.out.println("支出超过账户总金额,支出失败!");
}else{
//更新账户信息
balance -= expendture;
details += "支出\t" + balance + "\t\t" + expendture + "\t\t" + expendtureInfo + "\n";
}
System.out.println("---------------------登记完成----------------------\n");
break;
case '4':
//System.out.println("4 退 出");
System.out.print("确认是否退出(Y/N):");
char isExit = Utility.readConfirmSelection();
if(isExit == 'Y'){
isFlag = false;
}
break;
}
}
}
}
工具类:
import java.util.Scanner;
/**
Utility工具类:
将不同的功能封装为方法,就是可以直接通过调用方法使用它的功能,而无需考虑具体的功能实现细节。
*/
public class Utility {
private static Scanner scanner = new Scanner(System.in);
/**
用于界面菜单的选择。该方法读取键盘,如果用户键入’1’-’4’中的任意字符,则方法返回。返回值为用户键入字符。
*/
public static char readMenuSelection() {
char c;
for (; ; ) {
String str = readKeyBoard(1);
c = str.charAt(0);
if (c != '1' && c != '2' && c != '3' && c != '4') {
System.out.print("选择错误,请重新输入:");
} else break;
}
return c;
}
/**
用于收入和支出金额的输入。该方法从键盘读取一个不超过4位长度的整数,并将其作为方法的返回值。
*/
public static int readNumber() {
int n;
for (; ; ) {
String str = readKeyBoard(4);
try {
n = Integer.parseInt(str);
break;
} catch (NumberFormatException e) {
System.out.print("数字输入错误,请重新输入:");
}
}
return n;
}
/**
用于收入和支出说明的输入。该方法从键盘读取一个不超过8位长度的字符串,并将其作为方法的返回值。
*/
public static String readString() {
String str = readKeyBoard(8);
return str;
}
/**
用于确认选择的输入。该方法从键盘读取‘Y’或’N’,并将其作为方法的返回值。
*/
public static char readConfirmSelection() {
char c;
for (; ; ) {
String str = readKeyBoard(1).toUpperCase();
c = str.charAt(0);
if (c == 'Y' || c == 'N') {
break;
} else {
System.out.print("选择错误,请重新输入:");
}
}
return c;
}
private static String readKeyBoard(int limit) {
String line = "";
while (scanner.hasNext()) {
line = scanner.nextLine();
if (line.length() < 1 || line.length() > limit) {
System.out.print("输入长度(不大于" + limit + ")错误,请重新输入:");
continue;
}
break;
}
return line;
}
}