class OperatorDemo1{
public static void main(String[] args){
//定义两个变量
int a = 3 ;
int b = 4 ;
//测试基本的算术运算符
System.out.println("a+b="+(a+b)) ;
System.out.println("a-b="+(a-b)) ;
System.out.println("a*b="+(a*b)) ;
System.out.println("a/b="+(a/b)) ;
System.out.println("a/b="+(a*1.0/b)) ;//double类型：默认类型提升
System.out.println("a%b="+(a%b)) ;
}
}
扩展:++和--
使用方式:
两种场景:
1)单独使用
无论在数据前还是或者数据后:都是对当前变量的值进行自增1或者自减1
应用场景:循环语句中有一个控制体语句(步长语句)
2)参与运算使用
在数据前:
先将当前变量本身的值进行自增1或者自减1,然后在参与运算.
在数据后:
先运算,然后变量的本身的值进行自增1或者自减1;
class OperatorDemo2{
public static void main(String[] args){
//定义两个变量
int a = 5 ;
int b = 4 ;
//先输出a,b的值
System.out.println("a:"+a) ;//5
System.out.println("b:"+b) ;//4
System.out.println("----------------------------------") ;
//场景1:单独使用
//a)在数据前面
a = 5 ;
b = 4 ;
++a ;
--b ;
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
System.out.println("----------------------------------") ;
//b)在数据的后面
a = 5 ;
b = 4 ;
a ++ ;
b -- ;
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
System.out.println("----------------------------------") ;
//场景2:参与运算使用
//a)在数据的前面
//定义两个变量m,n
a = 5 ;
b = 4 ;
int m = ++ a; //将a变量先自增1,结果赋值m
int n = -- b ;//将b变量先自减1,结果赋值n
System.out.println("m:"+m) ;
System.out.println("n:"+n) ;
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
System.out.println("----------------------------------") ;
//b)在数据的后面
a = 5 ;
b = 4 ;
int x = a ++ ; //先将a值赋值x,x就是3,然后a进行自增1,变成4
int y = b -- ;//先将b的值赋值y,y就是4,然后将b的值进行自减1,变成3
System.out.println("x:"+x) ;
System.out.println("y:"+y) ;
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
}
}
2. 赋值运算符
2.1基本的赋值运算符: =
举例:
int a = 10 ;
表示将10赋值给int类型的变量a
注意事项:
=不能写成==,反之,==不能写成=
扩展的赋值运算符:
+=,-=,*=,/=,%=
class OperatorDemo3{
public static void main(String[] args){
//定义一个变量
int a = 10 ;
System.out.println("a:"+a) ;
}
}
2.2扩展的赋值运算符:
+=,-=,*=,/=,%=
使用+=举例:
int a = 100 ;
a += 200 ; //将符号左边的数据和右边的数据相加,然后在将结果赋值左边的变量a
类似于:a = a + 200 ;
class OperatorDemo4{
public static void main(String[] args){
//定义一个变量
int a = 10 ;
a += 20 ;//类似a = a + 20 ;
System.out.println("a的值是:"+a) ;
}
}
3.位运算符
针对多个数据进行操作(使用"补码"计算结果)
计算出来的结果是具体的数据值;
基本的位运算符:
位与&: 有0,则0
位或|: 有1,则1
位异或^:相同则为0,不同则为1
反码~: 按位取反,全部都0变1,1变0
class OperatorDemo5{
public static void main(String[] args){
//直接输出
System.out.println(3 & 4) ; //0
System.out.println(3 | 4) ; // 7
System.out.println(3 ^ 4) ; // 7
System.out.println(~ 3) ; //-4
}
}
4.三目运算符
三元运算符的格式:
(表达式)?执行语句1(具体的结果):执行语句2(具体的结果);
执行的流程:
1)先判断表达式的结果是否成立,如果结果为true,就执行成立的语句1;
否则不成立,则执行不成立的语句2;
需求:
1)定义两个变量,求两个变量中的最大值
2)定义三个变量,求三个变量中的最大值
3)定义两个变量,求两个变量是否相等 (boolean :true/false)
class OperatorDemo{
public static void main(String[] args){
//定义两个变量
int a = 30 ;
int b = 20 ;
//定义一个结果变量:max
//(表达式)?执行语句1:执行语句2;
int max = (a>b)?a:b;
//a大于b如果成立,那么就执行a的结果,否则就执行b的结果
System.out.println("两个数据中的最大值是:"+max) ;
System.out.println("------------------------------------") ;
//2)定义三个变量,求三个变量中的最大值 (采用方式1实现)
//方式1(分步实现): 可以使用中间变量的方式,先使用这个中间变量记录两个数据中的最大值,
//然后在使用这个中间变量和第三个变量进行比较;
//定义三个变量
int x = 100 ;
int y = 120 ;
int z = 60 ;
//定义一个中间变量:先记录x和y的最大值
int temp = (x > y)? x : y ;
//定义结果变量max2
int max2 = (temp>z)? temp : z ;
System.out.println("三个数据中的最大值是:"+max2) ;
System.out.println("------------------------------------") ;
//方式2:三元运算符的嵌套(不建议使用,如果没有带括号,层次不明显)
int max3 = ( x > y)?((x>z)?x:y):((y>z)?y:z) ; //带了括号,结构明显
//int max3 = x > y?x>z?x:y:y>z?y:z ;
System.out.println("三个数据中的最大值是:"+max3) ;
System.out.println("----------------------------------") ;
//定义两个变量,求两个变量是否相等
int m = 50 ;
int n = 55 ;
//定义boolean类型变量接收
boolean flag = (m==n)? true:false;
System.out.println("flag:"+flag) ;
//优化上面代码:==本身比较 :本身结果就是true/false
boolean flag2 = (m==n) ;
System.out.println("flag2:"+flag2) ;
}
}
5.键盘录入数据
使用步骤:
1)导包 用哪个一类,就需要导入到当前Java文件中(只要不是java.lang包下的类,都需要导入)
固定写法:
import java.util.Scanner;
书写位置:在class的上面
2)固定格式:创建文本扫描器对象
Scanner 对象名 = new Scanner(System.in) ;
3)提示并录入数据 (默认录入int类型)
System.out.println("请您输入数据:") ;
int 变量名= 对象名.nextInt() ; //录入一个int类型的数据
4)完成自己的业务操作:使用这个变量名(求两个数据是否相等/比较数据最大值等等...)
//导包
import java.util.Scanner ;
class ScannerDemo{
public static void main(String[] args){
//创建文本扫描器对象(键盘录入数据对象)
Scanner sc = new Scanner(System.in) ; //固定格式
//提示并录入数据
System.out.println("请您输入一个数据:") ;//默认int
int num = sc.nextInt() ; //前期先用int
//String num = sc.nextLine() ;//录入字符串类型
//直接输出
System.out.println("您输入的数据是:"+num) ;
}
}
6.选择结构语句
第一种:if语句(三种格式)
第二种:switch语句
if(表达式){
语句;
}
执行流程:
1)首先表达式是否成立,成立,则执行该语句
2)不成立,不会进入if里面;
应用场景:针对一种情况判断
if语句格式注意事项:
1)有{括号的地方不能有分号;
2)当前if(表达式){ //{}可以省略不写,但是开始学习建议!
语句 ;
}
import java.util.Scanner ;
class IfDemo{
public static void main(String[] args){
//创建键盘录入数据
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入一个数据x:") ;
int x = sc.nextInt() ;
if(x>=10){
System.out.println("x大于或者等于10") ;
}
if(x<10){
System.out.println("x小于10") ;
}
}
}
6.2 if选择结构语句格式2:
if(表达式){
语句1;
}else{
语句2;
}
执行流程:
1)先判断表达式是否成立,如果成立,执行执行语句1;
2)如果不成立,则执行语句2;
需求:键盘录入两个数据,比较两个数据是否相等
import java.util.Scanner ;
class IfDemo2{
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() ;
if(a==b){
System.out.println("这个两个数据相等") ;
}else{
System.out.println("这个两个数据不相等") ;
}
}
}
6.3 if语句格式3
针对多种情况进行判断
if(表达式1){
语句1 ;
}else if(表达式2){
语句2;
}else if(表达式3){
语句3;
...
...
...
}else{
语句n+1;
}
执行流程:
1)首先判断表达式1是否成立,如果成立,则执行语句1;
2)如果上面表达式1不成立,继续判断表达式2是否成立,如果成立,执行语句2
3)如果表达式2也不成立,继续判断表达式3是否成立,如果成立,执行语句3
...
...
4)如果上面的条件表达式都不成立,则执行最终语句n+1 ;
import java.util.Scanner ;
class IfDemo3{
public static void main(String[] args){
//创建键盘录入数据对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入学生成绩:") ;
int socre = sc.nextInt() ;
//测试程序
//1)考虑错误数据
//2)考虑边界数据
//3)考虑正确数据
if(socre>100 || socre<0){
System.out.println("您输入的数据不合法...") ;
}else if(socre>=90 && socre <=100){
System.out.println("该学生成绩优秀...") ;
}else if(socre >=80 && socre< 90){
System.out.println("该学生成绩良好...") ;
}else if(socre>=70 && socre<80){
System.out.println("该学生成绩较好...") ;
}else if(socre>=60 && socre<70){
System.out.println("该学生成绩及格...") ;
}else{
System.out.println("不及格") ;
}
}
}
6.4 switch语句的格式
switch(表达式){
case 值1:
语句1;
break ;
case 值2:
语句2;
break ;
...
...
...
default:
语句n+1 ;
break ;
}
执行流程:
1)switch中的表达式的结果值和case语句匹配,值1和结果匹配,就执行语句1,遇见break,switch结束;
2)值1和switch表达式结果不匹配,继续判断值2是否匹配,如果匹配,就执行语句2,switch语句结束
...
...
3)如果case语句后面值都不匹配,这个执行default语句,执行语句n+1,程序执行到末尾结束...
break:属于跳转控制语句中的一种
结束,中断意思! (不能单独使用,只能在switch和循环语句中使用)
import java.util.Scanner ;
class SwitchDemo{
public static void main(String[] args){
//break;
//创建键盘录入对象
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 ;
}
}
}
Switch语句的注意事项:
1)case语句后面只能是常量(Java是一个强类型语言: 语法,结构非常严谨)
2)case语句中beark 最好携带上,如果没有携带break语句,会造成"case穿透"
"case穿透": (要灵活使用,并不是说这个情况不好)
某个case语句中没有带break,此时当跟case的值匹配,这个时候继续就往下执行,不会在判断case!
3)default语句可以在switch语句中的任何位置,不会影响switch的执行流程
如果在语句中,default里面的break千万不能省略;省略会造成case穿透
如果在语句末尾,break可以省略不写,前期不建议
4)switch语句的结束条件是什么?
a)遇见break结束
b)程序默认执行到末尾
for(初始化语句;条件表达式;步长语句/控制体语句){
循环体语句;
}
执行流程:
1)初始化语句对变量进行赋值
2)判断条件表达式是否成立;
如果是成立,执行循环体语句;
3)继续执行控制体语句
4)继续回到2)里面判断
如果是成立,执行循环体语句;
继续回到3)
...
...
...
一直执行到条件不成立结束.
class ForDemo{
public static void main(String[] args){
//原始的做法:
//10个输出语句
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("-------------------------------------");
//问题:代码冗余度(重复度)很高
// 代码阅读起来不流畅...
//必须优化它
//引入for循环语句
for(int x = 1 ; x <=10 ; x ++ ){//x=1 ; 1 <=10 , x++---> 2<=10;x++-->3<=10,...../x++--->10 <=10--->x++-->11 <=10
System.out.println("helloworld") ; //打印"1次"/2/3...9/10
}
}
}
7.2 while循环语句
常用的格式
初始化语句;
while(条件表达式){
循环体语句;
控制体语句;
}
执行流程:
1)先初始化赋值
2)判断条件表达式是否成立,成立,则执行循环体语句-
3)执行控制体语句---继续判断条件是否成立,----循环,,,
...
...
4)执行到条件表达式不成立,while语句结束
class WhileDemo{
public static void main(String[] args){
//定义初始化语句
int x = 1 ;
while(x<=10){
System.out.println("helloworld") ;//1)2)....10)
//不要忘了控制体语句
x ++ ;
}
System.out.println("----------------------------------") ;
//求1-100之间的和
//定义最终结果变量
int sum = 0 ;
//初始化语句
int n = 1 ;
while(n<=100){
//循环体
sum += n ;
n ++ ;
}
System.out.println("1-100之间的和是:"+sum) ;
System.out.println("----------------------------------") ;
//求1-100之间的偶数和
int sum2 = 0;
int i = 1 ;
while(i<=100){
if(i % 2==0){
sum2 += i ;
}
i ++ ;
}
System.out.println("1-100之间的偶数和是:"+sum2) ;
System.out.println("----------------------------------") ;
//水仙花数:三位数,每各位的立方和是它本身
//定义初始化语句
int y = 100 ;
while(y<=999){
//定义每各为数据:个位,十位,百位
int ge = y % 10 ;
int shi = y /10 % 10;
int bai = y/10/10%10;
//满足条件:每各位的立方和是它本身
if(y==(ge*ge*ge+shi*shi*shi+bai*bai*bai)){
System.out.println("水仙花数是:"+y) ;
}
y++ ;
}
System.out.println("----------------------------------") ;
//统计水仙花数多少个
//水仙花数:三位数,每各位的立方和是它本身
//定义统计变量
int count = 0 ;
//定义初始化语句
int j = 100 ;
while(j<=999){
//定义每各为数据:个位,十位,百位
int ge = j % 10 ;
int shi = j /10 % 10;
int bai = j/10/10%10;
//满足条件:每各位的立方和是它本身
if(j==(ge*ge*ge+shi*shi*shi+bai*bai*bai)){
//统计变量++
count ++ ;
System.out.println("第"+count+"个的水仙花数是:"+j) ;
}
j++ ;
}
System.out.println("水仙花数共有:"+count+"个") ;
}
}
7.3 do-While循环语句
do-while循环语句的格式
初始化语句;
do{
循环体语句;
控制体语句;
}while(条件表达式) ;
执行的流程:
1)初始化语句赋值
2)执行循环体语句
3)执行控制体语句
4)条件表达式判断,如果条件成立,继续执行循环体...
...
条件表达式不成立,语句结束;
它和for,while循环语句最大的区别:当条件不成立的时候,循环体语句至少执行一次.
class DoWhileDemo{
public static void main(String[] args){
//在dos控制台输出5次"helloworld"
int x = 6 ;
do{
System.out.println("helloworld") ;
x ++ ;
}while(x<=5) ;
}
}
7.4 for循环的嵌套
for循环语句的嵌套:
格式
for(初始化语句;条件表达式;控制体语句){---外层循环
//循环体语句
for(初始化语句;条件表达式;控制体语句){--- 内层循环
循环体语句...
}
}
将一个for循环语句作为 "循环体"去执行;
例如:在控制台输出*形(四行五列的*)
*****
*****
*****
*****
99乘法表
class ForForDemo{
public static void main(String[] args){
//原始的做法:
System.out.println("*****") ;
System.out.println("*****") ;
System.out.println("*****") ;
System.out.println("*****") ;
System.out.println("-----------------------------") ;
//优化:冗余度很高,所以使用循环思想改进
//打印4行5列
for(int x = 0 ; x < 4 ; x ++){//行数
for(int y = 0 ; y < 5 ; y++){//列数
System.out.print("*") ;
}
System.out.println() ;
}
}
}
class ForForDemo2{
public static void main(String[] args){
//99乘法表
//为了表示有效数据:从1开始
for(int x = 1 ; x <= 9 ; x++){//控制行数
//内层循环:列数在变化
for(int y = 1; y <=x ; y++){
System.out.print( x+"*"+y+"="+(y*x)+"t") ;
//使用制表符号:
//转义字符"x"
//n :表示换行
//t :制表符,类似于tab键的效果,缩进空格
}
System.out.println() ;
}
}
}
8.跳转控制语句
break ;
continue ;
return ;
break:中断,结束
不能单独使用
1)只能在switch或者循环语句中使用; 单循环for循环中使用
2)在for循环嵌套中使用
break 标签语句 ;(现在很少见)
给外层循环,或者内层循环起名字--->标签语句;
class BreakDemo{
public static void main(String[] args){
//break ;//在 switch 或 loop 外部中断
for(int x = 1 ; x <=10 ; x++){
//判断
if(x==3){
break ;//结束,中断
}
System.out.println(x) ;//1,2
}
}
}
8.2 return
return: 返回具体的结果(结束方法)
但是一般return很少单独使用,需要在有具体返回值类型的方法中使用.
return 一般都是结合方法使用
格式:
return 结果值;
class ReturnDemo{
public static void main(String[] args){
//for循环
System.out.println("程序开始了....") ;
for(int x =1 ; x <= 10 ;x ++){
if(x == 3){
//break ; 只是结束了循环,程序依然需要继续往下执行!
return ; //方法结束
}
System.out.println(x) ;//1,2
}
System.out.println("程序结束了 Over....") ;
}
8.3 continue
continue:继续---->结束当前循环,立即进入下次循环 也不能单独使用
class ContinueDemo{
public static void main(String[] args){
//continue ;//continue 在 loop 外部,不能离开循环使用
//定义for循环
for(int x = 1 ; x <= 10 ; x ++){
//加一个条件
if(x % 3==0){
continue ;//结束循环,立即进入下次循环
}
System.out.println(x) ;//1,2,4,5,7,8,10
}
}
}
