Java教程
java学习笔记：
本文主要是介绍java学习笔记：，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
1.3三元运算符（三目运算符）：
格式：
（表达式）？执行语句1（具体结果的）：执行语句2（具体的结果）；
执行流程：
1）先判断表达式上的结果是否成立，如果结果为true,,就执行成立的语句1；否则不成立， 则执行不成立的语句2；
需求：
1）定义两个变量，求两个变量的最大值。
2）定义三个变量，求三个变量的最大值。
3）定义两个变量，求两个变量对否相等 (boolean ture/false)
案例：
1）定义两个变量，求两个变量的最大值。
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)；
}
}
2）定义三个变量，求三个变量的最大值。
class OperatorDemo{
• public static void main(String[] args){
• //定义两个变量
• int a = 30;
int b = 20;
int c = 123;
第一种方式：
//定义一个结果变量：max
//(表达式)？执行语句1：执行语句2；
int max =(a>b)?a:b;
int max2 =(c>max)?c:max;
第二种方式： 三元运算符的嵌套
(a>b)?(a>c)?a:c):(b>c)?b:c)
//a大于b如果成立,那么就执行a的结果，否则就执行b的结果；
System.out.println(“两个数据的最大值：”+max2；
}
}
3）定义两个变量，求两个变量对否相等 (boolean ture/false)
class OperatorDemo{
• public static void main(String[] args){
• //定义两个变量,求两个数是否相等
• int a = 30;
int b = 20;
//定义boolean类型结束
第一种方式：
boolean max =(a==b)?ture:false;
第二种方式：代码优化。
boolean max=(a==b);
//a大于b如果成立,那么就执行a的结果，否则就执行b的结果；
System.out.println(“两个数据的最大值：”+max)；
1.4键盘录入：
键盘录入步骤：
1）导包；import java.util.Scanner;
2)创建文本扫描器 ；Scanner 对象名 =new Scanner(System.in); 自己随意起（除关键字外以及特殊符号）
3）提示并录入数据（默认int类型）；
System.out.println("请输入数据")
Scanner 变量名=对象名.nextInt();
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) ;
•
•
•
}
}
案例1：
import java.util.Scanner ;
class ScannerTest{
public static void main(String[] args){
//创建键盘录入数据对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入第一个数据:") ;
int firstNum = sc.nextInt() ;
System.out.println("请您输入第二个数据:") ;
int secondNum = sc.nextInt() ;
//三元运算符
int max = (firstNum > secondNum)? firstNum:secondNum ;
System.out.println("两个数据中的最大值是:"+max) ;
}
}
案例3：
import java.util.Scanner ;
class ScannerTest2{
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() ;
System.out.println("请您输入第三个数据:") ;
int c = sc.nextInt() ;
//方式1:分步实现
//使用a和b比较,将结果交给第三方变量:记录最大值
int temp = (a>b)?a:b;
//使用temp和c进行比较,最终求最大值
int max = (temp >c)? temp:c ;
System.out.println("三个数据中的最大值是:"+max) ;
System.out.println("---------------------------------") ;
//方式2:一步走:使用三元运算符嵌套
int max2 = (a > b)?((ra>c)? a:c):((b>c)?b:c) ;
System.out.println("三个数据中的最大值是:"+max2) ;
System.out.println("------------------------------------------") ;
//3)键盘录入两个数据,比较两个数据是否相等 (boolean :true/false)
//提示并录入数据
System.out.println("请录入第一个数据:") ;
int firNum = sc.nextInt() ;
System.out.println("请录入第二个数据:") ;
int secNum = sc.nextInt() ;
//定义boolean类型接收
//boolean flag = (firNum==secNum)?true:false; //优化成下面代码
//== :本身就是进行比较true/false
boolean flag = firNum==secNum ;
System.out.println("flag:"+flag) ;
}
}
1.5流程控制语句：
流程控制语句分三类:
1.顺序结构语句 2.选择结构语句 3.循环结构语句
顺序结构语句:
当进入到类中之后,jvm调用main方法,代码由上而下依次加载 除非一种特例:当jvm退出了就不会进行执行了! 后期System类中有一个功能:exit(int status) 参数里面为0,表示正常终止jvm
a）顺序结构语句案例：
class ShunXuDemo{
//程序的入口
public static void main(String[] args){
//定义变量
int a = 10 ; //局部变量(在方法定义中的变量)
System.out.println("a:"+a) ;
System.out.println("程序开始了...") ;
System.out.println("我爱Java,爱高圆圆") ;
//让Jvm退出(正常终止正在运行的jvm),main方法就结束了
System.exit(0) ;
System.out.println("程序结束了...") ;
System.out.println("over...") ;
}
}
b）选择结构语句案例：
第一种：if语句：
格式：
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") ;
}
第二种：if语句：
格式：
开发中使用最多:针对两种情况进行判断!
if(表达式){
语句1;
}else{
语句2;
}
执行流程:
1)先判断表达式是否成立,如果成立,执行执行语句1;
• 2)如果不成立,则执行语句2;
•
需求:键盘录入两个数据,比较两个数据是否相等
•
//开发中 在业务中进行流程判断: if...else结构会经常用到
举例:登录 ----->String类型 :字符串数据 equals(String str):
比较两个字符串是否相等
案例：
第一：
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(表达式){
语句1;
}else{
语句2;
}
*/
if(a==b){
System.out.println("这个两个数据相等") ;
}else{
System.out.println("这个两个数据不相等") ;
}
System.out.println("-----------------------------------") ;
//定义一个变量
boolean flag ;
if(a == b){
flag = true ;
}else{
flag = false ;
}
System.out.println("flag:"+flag) ;
}
}
第二：import java.util.Scanner ;
class IfTest{
public static void main(String[] args){
//使用String字符串类: (目前先使用,后期在讲)
//已知存在用户名和密码
String username = "admin" ;
String password = "admin" ;
//创建键盘录入数据对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
//录入用户名
//键盘录入的对象名.nextLine()
//键盘录入的对象名.nextInt():整数int
System.out.println("请您输入用户名:") ;
String name = sc.nextLine() ;
System.out.println("请您输入密码:") ;
String pwd = sc.nextLine() ;
//录入的用户名和密码和已知存在的用户名和密码必须都一致
//if结构
//字符串数据 equals(String str):比较
两个字符串是否相等
if(name.equals(username) && pwd.equals(password)){
//成立: 两个都一致
//提示"登录成功"
System.out.println("恭喜您,登录成功...") ;
}else{
System.out.println("对不起,用户名或者密码输入错误!!!") ;
}
}
}
第三种：if语句：
格式：
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 IfDemo5{
public static void main(String[] args){
//创建键盘录入数据对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入学生成绩:") ;
int socre = sc.nextInt() ;
/*
if(表达式1){
语句1 ;
}else if(表达式2){
语句2;
}else if(表达式3){
语句3;
...
...
...
}else{
语句n+1;
}
90-100 优秀
80-90 良好
70-80 较好
60-70 及格
60以下 不及格
• */
• /*
• 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("不及格") ;
• }
• */
• //测试程序
• //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("不及格") ;
• }
}
}
第四种：switch语句：
格式：
switch(表达式){
case 值1:
语句1;
break ;
• case 值2:
• 语句2;
• break ;
• ...
• ...
• ...
• default:
• 语句n+1 ;
• break ;
• }
执行流程:很类似于if格式3
1)switch中的表达式的结果值和case语句匹配,值1和结果匹配,
就执行语句1,遇见break,switch结束;
2) 值1和switch表达式结果不匹配,继续判断值2是否匹配,如果匹配,就执行语句2,switch语句结束
...
...
3)如果case语句后面值都不匹配,这个执行default语句,执行语句n+1,程序执行到末尾结束...
break:属于跳转控制语句中的一种
结束,中断意思! (不能单独使用,只能在switch和循环语句中使用)
面试题:
switch跟的表达式可以是什么数据类型?
能够跟的基本类型:int,byte,short,char
Jdk版本不同的跟的类型不一样
JDK5以后,可以 跟枚举: enum : 枚举类(引用类型,里面的都常量!)
JDK5以后新特性
JDK7以后:可以跟String类型
Switch语句的注意事项:
1)case语句后面只能是常量(Java是一个强类型语言: 语法,结构非常严谨)
相对来说:前端:javascript :简称"js",Switch语句的case中不仅可以常量,也可以是变量
是一个弱类型语言(语法结构非常不严谨)
2)case语句中beark 最好携带上,如果没有携带break语句,会造成"case穿透"
"case穿透": (要灵活使用,并不是说这个情况不好)
某个case语句中没有带break,此时当跟case的值匹配,这个时候继续就往下执行,不会在判断case!
3)default语句可以在switch语句中的任何位置,不会影响switch的执行流程
如果在语句中,
default里面的break千万不能省略;省略,造成case穿透(考点)
如果在语句末尾,break可以省略不写,前期不建议
4)switch语句的结束条件是什么?
a)遇见break结束
b)程序默认执行到末尾
案例：
//看程序,写结果
/*
1)switch的执行流程
2)default语句可以在语句中的任何位置
3)case穿透现象
4)switch语句的结束条件
*/
class SwitchTest{
public static void main(String[] args){
int a = 3 ;
int b = 4 ;
switch(a){
default :
b++ ;
//case 4:
case 3: //匹配成功
b ++ ;
case 5
b++ ;
}
/*
1)a的和case进行匹配:case的值都不匹配,执行default语句,
b++,b=5,由于没有break语句,没有结束,就继续往下穿透,程序默认执行到末尾结束!
b=7
2)如果case语句的某个值匹配成功,default没有在语句没有末尾,
case语句中的语句体执行完毕,继续穿透到程序末尾结束 b=6
*/
System.out.println("b:"+b) ;
System.out.println("-------------------") ;
int x = 3 ;
int y = 4 ;
//最普通的一种情况
switch(x){
default:
y++; //5
break ; //结束
case 4:
y++ ;
case 5:
y++ ;
}
System.out.println("y:"+y) ;
}
}
案例：
第一：
需求:键盘录入一个数据(1-7),判断星期
*/
//导包
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(表达式){
case 值1:
语句1;
break ;
case 值2:
语句2;
break ;
...
...
...
default:
语句n+1 ;
break ;
}
*/
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 ;
}
}
}
第二：
/*
1.键盘录入一个数据,判断该月份的季节 (switch语句)
3,4,5月---->春季
6,7,8月---->夏季
9,10,11月--->秋季
12,1,2---->冬季
分析:
1)创建Scanner:键盘录入对象
2)录入数据: month 变量
3)使用switch语句 和case语句中 常量值进行匹配
*/
//导包
import java.util.Scanner ;
class SwitchTest2{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入一个数据: ") ;
int month = sc.nextInt() ;
//使用switch语句
/*
switch(month){
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 ;
case 8:
System.out.println("夏季") ;
break ;
case 9:
System.out.println("秋季") ;
break ;
case 10:
System.out.println("秋季") ;
break ;
case 11:
System.out.println("秋季") ;
break ;
case 1:
System.out.println("冬季") ;
break ;
case 2:
System.out.println("冬季") ;
break ;
case 12:
System.out.println("冬季") ;
break ;
default:
System.out.println("您输入的数据不合法") ;
break ;
}
*/
//问题:上面的代码冗余度(重复度)很高,优化
//灵活使用case穿透现象
switch(month){
case 3:
case 4:
case 5:
System.out.println("春季") ;
break ;
case 6:
case 7:
case 8:
System.out.println("夏季") ;
break ;
case 9:
case 10:
case 11:
System.out.println("秋季") ;
break ;
case 1:
case 2:
case 12:
System.out.println("冬季") ;
break ;
default:
System.out.println("您输入的数据不合法") ;
break ;
}
}
}
c）循环语句：
第一种：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 ++ ;
}
//说明：helloworld打印10次。
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+"个") ;
}
}
第二种：do-while
格式：
do-while循环语句的格式
初始化语句;
do{
循环体语句;
控制体语句;
}while(条件表达式) ;
执行流程：
1)初始化语句赋值
2)执行循环体语句
3)执行控制体语句
4)条件表达式判断,如果条件成立,继续执行循环体...
...
...
条件表达式不成立,语句结束;
开发中,do-while循环语句使用不多,jdk---提供的源码会涉及的
它和for,while循环语句最大的区别:
当条件不成立的时候,循环体语句至少执行一次!
开发中:优先使用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) ;
}
}
第三种：for
普通格式：
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") ;
//问题:代码冗余度(重复度)很高
// 代码阅读起来不流畅...
//必须优化它
//引入循环语句之for
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
}
}
}
嵌套格式：
for(初始化语句;条件表达式;控制体语句){---外层循环
//循环体语句
for(初始化语句;条件表达式;控制体语句){--- 内层循环
循环体语句...
}
}
案例：
class ForForDemo{
public static void main(String[] args){
//原始的做法:
System.out.println("*****") ;
System.out.println("*****") ;
System.out.println("*****") ;
System.out.println("*****") ;
System.out.println("-----------------------------") ;
//优化:冗余度很高,所以使用循环思想改进
//第一行 5个"*"
for(int x = 0 ; x < 5 ; x ++){
//System.out.println("*") ; //println():后期用到的打印功能, ln:换行
System.out.print("*") ;
}
//换行
System.out.println() ;
//第二行: 单独将5个 * 分别打印
for(int x = 0 ; x < 5 ; x ++){//0,1,2,3,4
System.out.print("*") ;
}
//换行
System.out.println() ;
//第三行:单独将5个 * 分别打印
for(int x = 0 ; x < 5 ; x ++){
System.out.print("*") ;
}
System.out.println() ;
//第四行:单独将5个 * 分别打印
for(int x = 0 ; x < 5 ; x ++){
System.out.print("*") ;
}
System.out.println() ;
System.out.println("-----------------------------------------") ;
//上面的代码依然重复度很高,
/*
for(int x = 0 ; x < 5 ; x ++){
System.out.print("*") ;
}
System.out.println() ; 出现了4次,继续循环改进!
*/
for(int x = 0 ; x <4 ; x++){//0,1,2,3 //控制行数
//循环体
for(int y = 0 ; y < 5 ; y ++){//每次打印5个"*" //控制列数
System.out.print("*") ;
}
System.out.println() ;
}
System.out.println("----------------------------------------") ;
//打印5行6列
for(int x = 0 ; x < 5 ; x ++){//行数
for(int y = 0 ; y < 6 ; y++){//列数
System.out.print("*") ;
}
System.out.println() ;
}
//7行8列的*
}
}
----------------------------------------------------------------------------------------
/*
输出*形,随着行数的增加,列数也在随之变化
*
**
***
****
*****
分析:
定义变量x: 代表行数
定义变量y: 代表列数
第一行,x=0 , y=0, 表示有1列
第二行,x=1 ,y=0,1 ,表示有2列
第三行,x =2 ,y=0,1,2 ,表示3列
第四行,x =3, y=0,1,2,3,表示4列
第五行,x =4 , y =0,1,2,3,4 ,表示5列
y的取值: y<=x :恰好取到行数x的值
类似于99乘法表的*
*
**
***
****
*****
******
*******
********
*********
99乘法表
1 *1 = 1
1 *2 = 2
...
...
...
...
*/
class ForForDemo2{
public static void main(String[] args){
//五行5列的*
for(int x = 0 ; x < 5 ; x ++){
for(int y = 0 ; y < 5 ; y ++){
System.out.print("*") ;
}
System.out.println() ;
}
//优化:分析:列数怎么变化:小于等于行数
System.out.println("------------------------------------------") ;
for(int x = 0 ; x < 5 ; x ++){//x =0,1,2,3,4
for(int y = 0 ; y <= x ; y ++){//y<=0 (1列), y<=2
System.out.print("*") ;
}
System.out.println() ;
}
System.out.println("------------------------------------------") ;
//输出:9行,列数也在随之变化
for(int x = 0 ; x < 9; x ++){
for(int y = 0 ; y <=x ; y ++){
System.out.print("*") ;
}
System.out.println() ;
}
System.out.println("------------------------------------------") ;
//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() ;
}
}
}
附件跳转控制语句
跳转控制语句:
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
}
System.out.println("--------------------------------------------") ;
//4行5列的*
wc:for(int x = 0 ; x < 4 ; x ++){//外层循环,行数 x=0,1,2,3
nc:for(int y = 0 ; y < 5 ; y ++){//内层循环,列数
//if(x == 2){
//break wc ; //结束外层循环
//}
if(y==2){
break nc ;//结束内层循环,控制列数
}
System.out.print("*") ;
}
System.out.println() ;
}
}
}
--------------------------------------------------------------------------------
class ContinueDemo{
public static void main(String[] args){
//continue ;//continue 在 loop 外部,不能离开循环使用
//定义for循环
for(int x = 1 ; x <= 10 ; x
++){
//加一个条件
/*
if(x == 3){
continue ;
}
/1,2,4,5,6,7,8,9,10
*/
if(x % 3==0){
continue ;//结束循环,立即进入下次循环
}
System.out.println(x) ;//1,2,4,5,7,8,10
}
}
}
这篇关于java学习笔记：的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
消息中间件底层原理资料详解11-27
-
RocketMQ底层原理资料详解：新手入门教程11-27
-
MQ底层原理资料详解：新手入门教程11-27
-
MQ项目开发资料入门教程11-27
-
RocketMQ源码资料详解：新手入门教程11-27
-
本地多文件上传简易教程11-27
-
消息中间件源码剖析教程11-26
-
JAVA语音识别项目资料的收集与应用11-26
-
Java语音识别项目资料：入门级教程与实战指南11-26
-
SpringAI：Java 开发的智能新利器11-26
-
Java云原生资料：新手入门教程与实战指南11-26
-
JAVA云原生资料入门教程11-26
-
Mybatis官方生成器资料详解与应用教程11-26
-
Mybatis一级缓存资料详解与实战教程11-26
-
Mybatis一级缓存资料详解：新手快速入门11-26
栏目导航
