day1内容
1.关键字
关键字:被Java语言特定含义的单词.
使用notepad++(editplus):高级记事本,针对关键字有特殊颜色标记.
组成关键字的单词:全部都是小写.
class,public, static, void,protected等
class:定义一个类(Java中的最基本的单元)
public:权限修饰符(公开的,公共的)
private(私有的,外界不能直接访问的)
protected:受保护的,权限修饰符
static:静态修饰符 (面向对象部分讲)
void:跟方法有关系(讲解Java中如何定义方法)
注意事项:
goto,const,这两个单词不是关键字,作为保留字使用!
2.标识符
标识符:给类,(接口),变量,(方法)起名字的字符序列。
1.给类命名时。(见名知意)
给类和接口的命名是一样
如果类的组成是一个单词:首字母大写
class Hello{}
//定义一个学生类 (见名知意)
如果类的组成式多个单词:每个单词首字母都大写(大驼峰命名法)
class StudentTest{} 针对学生的类测试类
2.给变量(方法)命名是一样的,
如果变量(方法)是一个单词的话:
该单词全部小写:
check() ,方法名
如果变量或者方法是多个单词的话:
第一个单词全部小写,从第二个单词开始首字母大写(小驼峰命名法)
定义方法名:检查用户名
checkUserName()
3.给常量的命名
如果是单个单词:
每个字母都大写
TYPE
如果是多个单词
每个单词字母大写,中间下划线隔开
TYPE_TEXT
一般情况:编写代码,要遵循基本规则(开始编码的时候,养成良好习惯!)
标识符的组成规则:
1)英文大小写字母
2)$和下划线_组成 面向对象:内部类 Outer$Inner(后面讲)
3)数字字符组成
注意事项:
1.不能以数字开头(数字字符组成,可以将数字变量的后面)
2.不能是Java中的关键字
3.Java是强类型语言,严格区分大小写的
3常量
常量:在程序的执行过程中,其值不发生改变的量!
分类:
1)字面值常量
a)字符串常量:使用双引号括起来的内容
举例: "我爱高圆圆","helloworld..."
b)字符常量:使用单引号括起来的单个内容
举例:'A','a','0'
'AB':写法有问题
c)整数常量: (整数:默认十进制(进制相关的))
100,1000
d)小数常量:
3.14,12.56
e)布尔常量:
true,false
f)空常量:
null
2)自定义常量。
public static final(终态的,无法更改的,属于状态修饰符) int xxx = xx ;
例如:
class ConstantDemo{
public static void main(String[] args){
//字面值常量
//字符串常量
System.out.println("输入数据") ;
//字符常量
System.out.println('A') ;
System.out.println('a') ;
System.out.println('0') ;
//整数常量
System.out.println(100) ;
System.out.println(10000) ;
//小数常量
System.out.println(3.1415926) ;
//布尔常量
System.out.println(true) ;
//空常量null
//针对引用类型的变量:变量值:默认 null
//Java研究的就是引用类型:数据传递问题!
String str = null ;
System.out.println(str) ;
}
}
day2内容
1变量
变量:程序执行过程中,值发生改变的量!
三要素:
1)数据类型
2)变量名
3)初始化值
针对Java语言数据类型的划分:
两大类:
1 基本数据类型
四类八种
整数类型
byte: 字节类型 占1个字节 记住byte类型的范围:-128~127(考点)
short:短整型 占2个字节
int(整数默认的类型):整数类型 占4个字节
long:长整型 占8个字节
应用场景:定义时间(系统时间换算成时间毫秒值)相关的变量(都是用long)
浮点类型:(小数默认的就是double类型)
单精度:float类型 占4个字节
双精度:double类型 占8个字节
字符类型:
char类型 占2个字节
布尔类型 占1个字节
boolean类型(true/false)
应用场景:用在逻辑判断中,布尔类型一般不参与运算!
2 引用数据类型(研究的这个类型) :面向对象部分讲解 数组,类(具体类,抽象类),接口
注意事项::如果定义long类型:在值的末尾加上一个标记(L/l,建议大L)
3 定义变量的注意事项:
1)要遵循的变量的三要素
数据类型 变量名 = 初始化值;
2)先定义,但是必须在使用之前对这个变量进行初始化,否则编译不通过!
3)Java是一种强类型,不能重复定义变量
4)同一行上可以定义多个变量,一般我们开发的时候,不建议这样使用(笔试题/面试题)
4 Java中存在强制类型转换:
语法格式:
目标数据类型 变量名 = (目标数据类型)(变量值) ;
注意事项:
强制类型不要随便使用,损失数据的精度!
适用范围:基本数据类型以及引用类型!
例1
class DataTypeDemo4{
public static void main(String[] args){
//定义两个变量
int a = 3 ;
byte b = 4 ;
//目标数据类型 变量名 = (目标数据类型)(变量值) ;
byte result = (byte) (a + b) ;-------(目标数据类型 变量名 = (目标数据类型)(变量值) )
System.out.println(result) ;
}
}
例2
class DataTypeDemo6{
public static void main(String[] args){
//定义三个变量
byte b, b1 = 3 ,b2 = 4;
//b = b1 + b2;//不兼容的类型: 从int转换到byte可能会有损失
//存在java的隐式类型转换:byte,short,char三者之间不转换,
//一旦参与运算,对应的类型都先默认提升int.
//使用小的类型来接收大的结果类型, 解决方案:强制类型转换
//b = (byte)(b1+b2) ;
//System.out.println(b) ;
b = 3 + 4 ;
System.out.println(b) ;
}
}
例3
求出 byte b = 130 ;
有问题吗?如果有,如何解决,结果是多少
class DataTypeDemo7{
public static void main(String[] args){
//-128~127
//byte b = 130 ;//从int转换到byte可能会有损失
//存在问题:超出了byte类型范围,结果:整数默认int,需要将int--->byte 强制类型转换
byte b = (byte)130;
System.out.println(b) ;//-126
}
}
130对应二进制数据是多少:0b10000010
整数默认int:4个字节
130整数的:原码
最高符号位:0 原码,反码,补码都一样
00000000 00000000 00000000 10000010
补码: 计算机底层计算需要用补码进行计算:byte b = (byte)130;
00000000 00000000 00000000 10000010
截取三个字节---->变成一个字节:byte类型
计算后的结果: 10000010 (补码)
最高符号位 数值位
1 0000010 补码
1 0000001 反码
负数的反码—>原码:最高符号不变,数值位按位取反,0变1,1变0
1 1111110 原码
结果:
-
64+32+16+8+4+2
-126
2运算
1.1扩展的算术运算符:
++或者–:
情况1:
单独使用:无论操作符++或者–在数据的前面还是数据的后面,都是对当前数据本身的值进行
自增1或者自减1;
情况2:
参与运算使用:
1)如果++或者–在数据的前面,是先对当前数据值进行自增1或者自减1,然后参与运算
2)如果++或者–在数据的后面,先运算,然后在对该数据值本身进行自增1或者自减1
例:
class OperatorDemo2{
public static void main(String[] args){
//定义两个变量
int a = 3 ;
int b = 4 ;
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
System.out.println("--------------------------") ;
//单独使用
//运算符在数据之前(++或者--在数据的前面)
//++a;
//--b ;
//++或者--在数据的后面
a++ ;
b--;
System.out.println("a:"+a) ;
System.out.println("b:"+b);
System.out.println("--------------------------") ;
//定义两个变量
int x = 3 ;
int y = 4 ;
System.out.println("x:"+x) ;
System.out.println("y:"+y) ;
System.out.println("--------------------------") ;
//++或者--参与运算使用
//1)在数据的前面
//int m = ++ x ;
//int n = -- y ;
//2)在数据的后面
int m = x ++ ; //m = x = 3 ; x ++= 3+1 = 4 ;
int n = y -- ;//n = y = 4 ; y -- = 4-1 = 3 ;
System.out.println("x:"+x) ;
System.out.println("y:"+y) ;
System.out.println("m:"+m) ;
System.out.println("n:"+n) ;
}
}
2.2赋值运算:
赋值运算符:
基本的赋值运算符:
=
将等号右边的值赋值给等号左边的变量;
int a = 10 ; 将整数10赋值给int类型的变量a
注意:= 不能写成==(比较运算符)
扩展的赋值运算符
+=,-=,*=,/=,%=…
举例:
+=
将等号左边的数据和右边的数据相加,在赋值给左边的变量
例2
class OperatorDemo{
public static void main(String[] args){
int a = 10 ;
int b ;
b = a = 20 ;//将整数20赋值给变量a,将a结果留下来再赋值给b
//b = a == 20 ; //将整数20和a的进行比较(不兼容的类型: boolean无法转换为int)
System.out.println("a:"+a+",b:"+b) ;
System.out.println("---------------------") ;
int x = 20 ;
x += 10 ; //相当于 x = x + 10 ;
System.out.println(x) ;
}
}
2.3关系运算符:
关系(比较)运算符
<,>,<=,>=,==,!
特点:使用比较符合连接的表达式无论是简单表达式还是复杂的表达式,结果都是boolean类型
注意:
== 比较的两个数据值是否相等,不要写成= (赋值运算符)
数学表达式: 3<=x<=5
Java语言: x>=3 && x<=5 并列关系
例
class OperatorDemo{
public static void main(String[] args){
//定义三个变量
int x = 3 ;
int y = 4 ;
int z = 5 ;
System.out.println(x>=y) ;
System.out.println(x!=z) ;
System.out.println(y==z) ; //不要写成=
System.out.println(x<=y) ; //x<y (使用逻辑运算符| ||) x = y
int m = 10 ;
int n = 20 ;
boolean flag = m==n;
//boolean flag = m =n; //(不要将==写成"=")
System.out.println(flag) ;
}
}
2.4逻辑运算符:
逻辑运算符的分类:
基本的逻辑运算符:
逻辑单与 & :有false,则false
逻辑单或 | :有true,则true
逻辑异或 ^ :相同则为false,不同则为true
逻辑非 ! :!true,则false;非false,则true;偶数个非是它本身的结身
开发中,经常使用的逻辑双与&&或者逻辑双或||
扩展的逻辑运算符
逻辑双与 &&
逻辑双或 ||
面试题:
逻辑双与&&和逻辑单与&的区别?
共同点:
都是并列关系,有false,则false
逻辑双与&&最大的不同点:
存在逻辑双与&&短路效果: (经常在笔试题中选择题!)
逻辑双与&&连接的表达式左边如果结果为false,右边的表达式不执行了;
逻辑双|| :逻辑双||连接的表达式左边为true,右边不执行了!(逻辑双||的短路效果)
例 :
class OperatorDemo{
public static void main(String[] args){
int a = 3 ;
int b = 4 ;
int c = 5 ;
//逻辑单与 &
System.out.println((a>b) & (a>c)) ; // flase & flase = false
System.out.println((a>b) & (a<c) ) ;//false & true = false
System.out.println((a<b) & (a>c) ) ; //true & false = false
System.out.println((a<b) & (a<c) ) ;//true & true = true
System.out.println("----------------------------") ;
//逻辑单或 |
System.out.println((a>b) | (a>c)) ; // flase | flase = false
System.out.println((a>b) | (a<c) ) ;//false | true = true
System.out.println((a<b) | (a>c) ) ; //true | false = true
System.out.println((a<b) | (a<c) ) ;//true | true = true
System.out.println("----------------------------") ;
//逻辑异或^
System.out.println((a>b) ^ (a>c)) ; // flase ^ flase = false
System.out.println((a>b) ^ (a<c) ) ;//false ^ true = true
System.out.println((a<b) ^ (a>c) ) ; //true ^ false = true
System.out.println((a<b) ^ (a<c) ) ;//true ^ true = false
System.out.println("----------------------------") ;
System.out.println(!(a>b)) ; //!false,则true
System.out.println(!!(a>b)) ;//false
}
}
在程序运算中:
class DataTypeDemo{
public static void main(String[] args){
//整数类型中的字节类型
//byte
byte b = 100 ;
System.out.println("b:"+b) ; //b:值
System.out.println("---------------------") ;
//short短整型
short s = 120 ;
System.out.println("s:"+s) ;
System.out.println("---------------------") ;
//int类型(整数默认)
int i = 10000 ;
System.out.println("i:"+i) ;
//int ii = 100000000000000; 过大的整数: 100000000000000
//整数过大,需要使用长整型定义
long ii = 100000000000000L ; //注意:如果定义long类型:在值的末尾加上一个标记(L/l,建议大L)
System.out.println("ii:"+ii) ;
System.out.println("---------------------") ;
//浮点类型(默认就是double类型)
//float
//float f = 12.56 ; //不兼容的类型: 从double转换到float可能会有损失
//注意:定义浮点类型,它默认double类型,在定义float类型变量,需要在变量值后面加F/f(建议大F)
float f = 12.56F;
System.out.println("f:"+f) ;
System.out.println("---------------------") ;
double d = 3.1415926;
System.out.println("d:"+d);
System.out.println("---------------------") ;
//GBK(中国的中文编码:一个中文对应两个字节)/
//GB2312(中国的中文编码表:一个中文对应两个字节)
//UTF-8编码格式(一个中文对应三个字节)
//char类型:字符类型
char ch = 'A';
char ch1 = 'a' ;
char ch2 = '0' ;
System.out.println("ch:"+ch+",ch1:"+ch1+",ch2:"+ch2) ;
char ch3 = '国' ;
System.out.println(ch3);
System.out.println("---------------------") ;
//布尔类型:用在逻辑判断(真或者假 true/false)
boolean flag = false ;
System.out.println(flag) ;
flag = true ;
System.out.println(flag) ;
//引用类型:面向对象部分说:现在不研究
}
}
day3内容
1 位运算符
位运算符中相关的移动符号:
<<:左移,将最高符号位舍弃掉,在右边补齐0
>>:右移符号: 如果最高符合为如果是0,在左边补齐0;最高符号位如果是1,左边补齐1
>>>:无符号右移:无论最高符号为是0还是1,始终在左边补齐0
3 << 2 :将3这个数据左移动两位
计算出3对应的二进制数据:0b11
00000000 00000000 00000000 00000011 原码(同时也是反码和补码,正数)
补码:
00000000 00000000 00000000 00000011
(00)000000 00000000 00000000 0000001100 (使用补码左移动两位)
000000 00000000 00000000 0000001100:补码--->反码---原码(正数)
=12
24 >> 2 (将24右移2位)
先算出24对应的二进制:0b11000
00000000 00000000 00000000 00011000(正数:原码,反码,补码都相同)
补码
00000000 00000000 00000000 00011000
(00)00000000 00000000 00000000 000110(00) (正数:补码--反码--->原码)
0000000000 00000000 00000000 000110
结果:6
24 >>> 2
-24的原,反,补
负数
(原码)
10000000 00000000 00000000 00011000
反码:
11111111 11111111 11111111 11100111
+1
-----------------------------------------------------
补码:
11111111 11111111 11111111 11101000
无符号右移
11111111 11111111 11111111 11101000
0011111111 11111111 11111111 111010(00)
- 6
=-6
结论
//左移符号有一个结论:
//将该符号左边的数据本身乘以2的移动次幂
//右移符号有一个结论:
//将该符号左边的数据本身除以2的移动次幂
2.三元运算符
三元运算符也称为(三目运算符)
三元运算符连接的是两个数值,用于对数据进行判断(大小,相等)
格式:
(表达式)? 执行true的结果:执行false的结果;
例1:
class OperatorDemo{
public static void main(String[] args){
//定义两个变量
//需求:求两个数据的最大值
int a = 100 ;(变量1)
int b = 200 ;(变量2)
//(表达式)? 执行true的结果:执行false的结果;
int max = (a >b)? a : b ;
System.out.println("两个数据的最大值是:"+max) ;
例2:
class OperatorDemo{
public static void main(String[] args){
//比较两个数据是否相等
//定义两个变量
int m = 10 ;
int n = 20 ;
//boolean flag = (m==n)? true :false ;
//==:比较运算符 :结果就是true或则false
//优化:改进
boolean flag = m == n ;
System.out.println("flag:"+flag) ;
例3:
//求三个数据的最大值
int x = 50 ;
int y = 30 ;
int z = 40 ;
//方式1:使用中间第三方变量进行操作 (开发中常使用:推荐方式)
//定义中间变量temp
int temp = (x > y)? x : y ;
//使用temp和z变量进行比较
int result = (temp > z)? temp : z ;
System.out.println("result:"+result) ;
System.out.println("-----------------------") ;
//方式2:直接三元运算符 一步走
int result2 = (x > y) ?((x>z)? x : z) :((y>z)? y : z) ;
//int result2 = x > y ?x>z? x : z :y>z? y : z ; // (可以运行但是不建议)去掉括号:阅读性差!
System.out.println("result2:"+result2) ;
3 键盘录入数据
在之前的学习中,定义变量是写死了,导致程序不灵活;
为了程序的灵活性,引入Scanner类(java.util.Scanner):文本扫描器
键盘录入格式:
1)导包 在Java中只要不是java.lang包下的类都需要导包
位置在class上面, 格式import java.util.Scanner; (用哪个类导哪个类)
2)固定格式:创建一个文件扫描器对象
Scanner 对象名 = new Scanner(System.in) ;
3)友情提示:"请您输入一个整数数据:"
4)接收数据:
int 变量名= 对象名.nextInt() ;
5)输出变量名即可!
例1:
导包
import java.util.Scanner ;
class ScannerDemo{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;(创建键盘录入对象)
//提示
System.out.println("请您输入一个数据:") (提示)
//接收数据:int类型数据
int a = sc.nextInt() (接收数据:int类型数据)
System.out.println("a:"+a) ;(输出变量名)
例2:
需求:键盘录入两个数据,求两个数据的最大值
import java.util.Scanner ;
class ScannerTest1{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示
System.out.println("请您录入第一个数据:") ;
int a = sc.nextInt() ;
System.out.println("请您录入第二个数据:") ;
int b = sc.nextInt() ;
//使用三元运算符进行比较
int max = (a>b) ? a : b ;
System.out.println("两个数据中的最大值是:"+max) ;
//需求:键盘录入两个数据,比较两个数据是否相等
System.out.println("输入第一个数据:") ;
int x = sc.nextInt() ;
System.out.println("输入第二个数据:") ;
int y = sc.nextInt() ;
//boolean类型
boolean flag = (x==y) ;
System.out.println("flag:"+flag) ;
}
}
需求:键盘录入三个数据,求三个数据的最大值
import java.util.Scanner ;
class ScannerTest2{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收数据
System.out.println("输入第一个数据:") ;
int num1 = sc.nextInt() ;
System.out.println("输入第二个数据:") ;
int num2 = sc.nextInt() ;
System.out.println("输入第三个数据:") ;
int num3 = sc.nextInt() ;
//使用中间第三方变量(推荐方式)
int temp = (num1 >num2)? num1: num2 ;
//使用temp变量和num3进行比较
int max = (temp > num3)? temp :num3;
System.out.println("三个数据中的最大值是:"+max) ;
System.out.println("-------------------------") ;
//直接使用三元运算符:一步走
int max2 = (num1>num2)? ((num1>num3)? num1:num3): ((num2 > num3)? num2 : num3) ;
System.out.println("三个数据中的最大值是:"+max2) ;
}
}
4流程控制语句
流程控制语句包括:顺序控制语句,选择控制语句,循环控制语句。
1:顺序结构语句
代码从上到下依次加载!
2:选择结构语句(if 结构语句,switch结构语句)
2.1 if结构语句
三种格式:
2.11 if(条件表达式){
语句;
}
2.12 if格式2使用居多
if(条件表达式){
语句1;
}else{
语句2;
}
2.13 if(条件表达式1){
语句1;
}else if(条件表达式2){
语句2;
.....
}else{
语句n+1;
}
使用If语句的注意事项:
1)有左大括号{的地方不能有分号,有分号的地方不能有左大括号{
2)if语句中如果是单个语句,{}可以省略,但是不建议!
3){}表示一个作用域,定义变量需要在{}这个作用域范围内使用
使用If语句的注意事项:
1)有左大括号{的地方不能有分号,有分号的地方不能有左大括号{
2)if语句中如果是单个语句,{}可以省略,但是不建议!
3){}表示一个作用域,定义变量需要在{}这个作用域范围内使用
例1
class IfDemo{
public static void main(String[] args){
//定义一个变量
int a = 10 ;
if(a >=10){
System.out.println("a大于等于10") ;
}
//错误写法
if(a <10);//if语句没有意义:if没有语句体,分号表示一个语句结束
//代码块:局部代码块 :限定变量的生命周期!
{
int x = 10 ;
System.out.println(x) ;
System.out.println("a大于等于10") ;
}
//System.out.println(x) ; //访问x变量超出了它的作用域范围
System.out.println("程序结束了...") ;
int m = 5 ; if(m>=5) //可以省略{},不建议
System.out.println("大于等于5") ;
}
}
if语句中第二种格式用法最多
if语句的格式2:
if(条件表达式){
语句1;
}else{
语句2;
}
执行流程:
1)判断条件表达式是否成立,如果成立,执行语句1
2)如果不成立,执行语句2;
应用场景:
针对两种情况进行判断!
三元运算符和if格式2的区别?
三元运算符连接的是两个数据的数据值(针对这个是数据值进行比较或者判断)
if格式2是一种流程控制语句:
范围要比三元运算符大,不仅仅可以判断两个数据数据值还可以操作具体语句
能够使用if格式2实现的不一定能够使用三元运算符;
但是如果能够三元运算符实现的一定能够使用if格式2
(在开发中,针对业务逻辑判断还是使用if格式2)
3.switch语句:
switch 选择结构语句
格式:
switch(表达式){
case 值1:
语句1;
break ;
case 值2:
语句2;
break ;
...
...
default:
语句n+1;
break ;
}
执行流程:
1)switch后面的表达式需要和case语句中的值进行匹配
如果值1匹配了,就执行语句1,遇见break 结束switch语句;
如果值1不匹配,就看值2是否匹配,如果匹配,执行语句2,遇见break结束;
…
如果上面都不匹配,执行default中的语句n+1,break结束语句;
break ; 属于跳转控制语句中一种: “结束,中断” ,
应用场景:是在switch以及loop(循环语句中使用)
switch后面表达式可以是什么样的数据类型?
一般情况:可以byte,short,char,int类型的
JDK5以后,是可以跟枚举 (enum)类型的 (引用类型)
JDK7以后,是可以跟String类型的(引用类型)
*switch语句使用的注意事项:
1)default语句是可以放在语句中的任何位置,不影响执行流程!
(建议default语句使用的时候放在语句末尾)
如果放在语句中,最好带上break,否则会造成case穿透!
2)switch语句的结束条件:
遇见break结束或者程序默认执行到末尾!
3)case语句后面的值只能是常量,不能变量(Java是一种强类型语言)
javascript:前端,简称js,弱类型语言 (switch语句的case后面既可以是常量也可以变量)
例1:
需求:
键盘录入一个数据,判断星期几
1,星期一
2,星期二
…
//导包
import java.util.Scanner;
class SwitchDemo{
public static void main(String[] args){
Scanner sc = new Scanner(System.in) ;
//提示并接收
System.out.println("请您输入一个数据(1-7):") ;
int week = sc.nextInt() ;
switch(week){
case 1 :
System.out.println("星期一") ;
break ;
case 2:
System.out.println("星期二") ;
break ;
case 3:
System.out.println("星期三") ;
break ;
case 4:
System.out.println("星期四") ;
break ;
case 5:
System.out.println("星期五") ;
break ;
case 6:
System.out.println("星期六") ;
break ;
case 7:
System.out.println("星期日") ;
break ;
default:
System.out.println("中国没有这个数据...") ;
break ;
}
}
}
例
import java.util.Scanner;
class SwitchDemo3{
public static void main(String[] args){
//录入一个整数类型,在录入字符串类型(String)
Scanner sc = new Scanner(System.in) ;
//接收整数
int a = sc.nextInt() ;
//录入字符串
//此时:创建一个新的键盘录入对象
Scanner sc2 = new Scanner(System.in) ;
String b = sc2.nextLine() ; //正式的录入字符串:nextLine()
System.out.println("a:"+a+",b:"+b);
}
}
day4内容
循环结构语句—for
for循环的格式
for(初始化语句;条件表达式;步长语句(控制体语句)){
循环体语句;
}
执行流程:
1)进入for循环,给变量进行初始化,执行初始化语句
2)判断条件表达式是否满足条件 (true的结果),然后执行循环体语句
3)执行循环体完毕之后,执行步长语句(对变量进行操作:++/–)
4)继续判断条件表达式是否成立,如果成立,再次执行循环体语句----->再次执行步长语句
…
…
…
5)当前条件表达式不成立,for语句结束!
求和思想:
求和思想:
需求:控制台输出1-10之间的和
分析:
0 + 1 = 1 ;
1 + 2 = 3 ;
3 + 3 = 6 ;
6 + 4 = 10 ;
10 + 5 = 15
.....
有两个加数:
第一个加数:是上一次前面数据的所有的和 (定义为一个变量) :默认从0开始
第二个加数:数据每次在变化: 1,2,3,4,5,6,...10 (定义变量:for循环中的变量)
求和思想的使用步骤:
1)定义一个最终结果变量: int sum = 0;
2)使用循环思想将的数据获取出来(第二个加数)
例:输出1-10之间的和
class ForDemo2{
public static void main(String[] args){
//原始的做法
System.out.println(1) ;
System.out.println(2) ;
System.out.println(3) ;
System.out.println(4) ;
System.out.println(5) ;
System.out.println(6) ;
System.out.println(7) ;
System.out.println(8) ;
System.out.println(9) ;
System.out.println(10) ;
System.out.println("-----------------------") ;
//代码重复度高:使用循环
for(int x = 1 ; x <= 10 ; x++ ){
System.out.println(x) ;
}
System.out.println("-----------------------") ;
//原始的做法:
//需求:控制台输出1-10之间的和
System.out.println(1+2+3+4+5+6+7+8+9+10) ;
//定义一个最终结果变量
int sum = 0 ;
for(int x = 1 ; x <= 10 ; x ++){//x =1 ,1 <=10 , x ++ --->x = 2 , 2 <=10 ,x++ ,--x =3 ,3 <=10
//sum = sum + x ;
sum += x ; //使用扩展的赋值运算符
//0 + 1 = 1 ;
//1 + 2 = 3 ;
//3+ 3 = 6 ;
//...
}
System.out.println("1-10之间的和是:"+sum) ;
}
}
循环结构语句—while
while循环
基本格式
while(条件表达式){
循环体语句;
步长语句;
}
扩展格式:(使用居多)
初始化语句 ;
while(条件表达式){
循环体语句;
步长语句;
}
执行流程:
1)先执行初始化语句,该变量进行初始化
2)判断条件表达式是否成立,如果成立,先执行循环体语句,----->执行步长语句
3)继续判断条件是否成立,如果还成立,继续在执行循环体语句----->执行步长语句
…
…
最终,条件表达式不成立,while循环结束!
例:
class WhileDemo{
public static void main(String[] args){
//for循环
for(int x = 1 ; x <= 5; x ++){
System.out.println("helloworld");
}
System.out.println("---------------------");
//while循环
int j = 1 ;
while(j<=5){
System.out.println("helloworld");
//步长语句
j++ ;
}
}
}
while循环和for循环的区别?
1)两种循环格式不一样
while循环---->
从内存角度考虑,while循环结束了,依然可以访问循环中的变量(消耗内存空间)
for循环----->
从内存角度考虑,for循环结束了,不能访问变量(变量生命周期随着for循环的结束而结束),比较省内存空间
2)从应用场景来说:
一般情况:如果明确循环次数或者明确循环的范围,优先考虑使用for循环
举例:给3次机会,模拟用户登录.. 可以使用for循环
如果不明确循环次数或者不明确的范围,使用while循环操作
举例:
猜数字游戏,(产生的随机和用户录入的数据进行比较)
---->这种情况:使用while循环操作
拓展:
猜数字小游戏
java.lang.Math类:数学运算的类
方法:获取随机数的方法:public static double random() 取值范围:[0.0,1.0)
键盘录入一个数据:整数类型(int) 和随机数据比较,
如果大了,提示"您录入的数据大了"
如果小了,提示"您录入的数据小了"
相等,提示"恭喜您,猜中了"
附加条件:统计 多少次猜中了
import java.util.Scanner;
class WhileTest{
public static void main(String[] args){
//获取一个随机数
//double d = Math.random() ;
//System.out.println(d) ;
//想求出:1-100之间的随机数
int number = (int)(Math.random()*100+1); //double
//System.out.println(number) ;
while(true){ //不知道录入多少次,使用while死循环
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收
System.out.println("请您输入一个数据:");
int guessNum = sc.nextInt() ;
//选择结构语句
if(guessNum > number){
System.out.println("您录入的数据大了...") ;
}else if(guessNum < number){
System.out.println("您录入的数据小了...") ;
}else{
System.out.println("恭喜您,猜中了...") ;
break ; //结束循环! (中断,结束)
}
}
}
}