一、三元运算符
三元运算符
,也称为三目运算符
或问号冒号运算符
。即有三个表达式参与的运算表达式。既然是个运算符,那么运算完必须有运算结果。
1、三元运算符格式
条件表达式 ? 表达式1 :表达式2
2、运算原则
条件表达式
运算结果必须为boolean类型的值。- 当
条件表达式
的值是true时,表达式1
结果就是三元运算符的结果。 - 当
条件表达式
的值是false时,表达式2
结果就是三元运算符的结果。
表达式1&表达式2
返回数据的语句。
3、举例
class OperateDemo
{
public static void main(String[] args)
{
int x = 3 ;
int y ;
y = x < 10 ? 100 : 200;
System.out.println("y="+y);
}
}
注意:表达式1
&表达式2
当需要存储于变量时,需要类型相同。三元运算符的结果直接使用时,不要求类型一致。
System.out.println((target == 12)?true:0);
使用三元运算符求两个数的最大值:
class OperateDemo
{
public static void main(String[] args)
{
int a = 3 ;
int b = 5 ;
int max ;
max = a < b ? b : a;
System.out.println("max="+max);
}
}
思考:如何使用三元运算如何求三个数的最大值(最小值)。
// 三个数字作比较
int x = 14, y = 65, z = 37;
int max1;// O(1)
max1 = x > y? x : y;
max1 = max1 > z? max1 : z;
System.out.println("较大值:"+max1);
二、流程控制&顺序结构
程序流程
即就是 代码的执行顺序。 分为循环
和判断
两个方面。
class Demo
{
public static void main(String[] args)
{
int a = 3 ;
int b = 5 ;
int sum ;
sum = a + b;
System.out.println("sum="+sum);
}
}
上述代码当在dos命令行中写入java Demo 回车之后,首先会启动JVM,JVM就会去加载当前Demo这个class文件,并执行其中的main方法。当程序执行main方法的时候会从第一行开始往下执行,直到整个代码全部执行完成。在此过程中程序按照书写的顺序,不会跳过任何一行代码。像这样的执行流程就是常见的顺序执行结构。
三、判断结构(if)
if
是Java中的关键字,当程序在执行过程遇到if
关键字,JVM
就知道此处需要进行判断,根据判断结果需要处理相应的代码。
1、第一种格式
if(条件表达式)
{
执行语句;
}
格式说明:if关键字后面是一对小括号,小括号后面是没有分号的,小括号中的表达式运算完的结果必须是boolean类型的值。
if流程控制执行顺序:JVM在执行代码时,遇到if关键字,首先会运算if括号中的表达式,当if中表达式的值为true时,就会执行if后面大括号中的语句。当if中表达式的值为false时,就会跳过if后面大括号中的语句,继续执行大括号下面的其他语句。
class IfDemo
{
public static void main(String[] args)
{
int y = 4;
if( y > 4)
{
System.out.println("y大于4");
}
System.out.println("over");
}
}
2、第二种格式
if(条件表达式)
{
执行语句;
}
else
{
执行语句;
}
执行说明:当if条件表达式为true时,执行if后面大括号中的语句,当if条件表达式为false时,执行else后面大括号中的语句。if-else格式组合成一条判断结构语句。要么执行if后面的语句,要么执行else后面的语句。切记,else后面的语句要能够执行,if中的条件表达式结果必须是false。
class IfDemo
{
public static void main(String[] args)
{
int y = 4;
if( y > 4)
{
System.out.println("y大于4");
}
else
{
System.out.println("y小于等于4");
}
System.out.println("over");
}
}
3、三元运算符的变形
通过三元运算可以简化if-else
的操作
int a = 4 , b = 5;
int max;
if( a > b)
{
max = a;
}
else
{
max = b;
}
//可以使用三元运算简化:
max = a > b ? a : b;
三元运算符是简写的if-else格式,简写是有弊端:不是所有的if-else都能简化,三元运算符运算完必须有结果,而if-else不一定运算完一定有运算结果。
4、if判断第三种格式:
if(条件表达式)
{
执行语句;
}
else if (条件表达式)
{
执行语句;
}
……
else
{
执行语句;
}
代码演示:
class IfDemo
{
public static void main(String[] args)
{
int a = 3;
if( a > 1)
{
System.out.println("a");
}
else if( a > 2)
{
System.out.println("b");
}
else if( a > 3)
{
System.out.println("c");
}
else
{
System.out.println("d");
}
}
}
// a
- 思路
- 怎么获取数值,并且保存这个值为变量,并且后续操作该变量。
- 输入的数值和星期联系起来,进行判断!
- 使用输出语句打印出结果。
- 步骤
- 定义变量,记录数据。
- 通过判断结构语句if对该变量进行判断。
- 根据不同的条件,通过输出语句显示不同的结果。
class IfTest
{
public static void main(String[] args)
{
//1,定义变量。记录数据。
int week = 9;
//2,通过判断结构语句if对该变量进行判断。
if(week == 1)
//3,根据不同的条件,通过输出语句显示不同的结果。
System.out.println(week+"对应的是星期一");
else if(week == 2)
System.out.println(week+"对应的是星期二");
else if(week == 3)
System.out.println(week+"对应的是星期三");
else if(week == 4)
System.out.println(week+"对应的是星期四");
else if(week == 5)
System.out.println(week+"对应的是星期五");
else if(week == 6)
System.out.println(week+"对应的是星期六");
else if(week == 7)
System.out.println(week+"对应的是星期日");
else
System.out.println(week+"没有对应的星期");
}
}
四、多分支结构(switch)
1、switch语句格式
switch(表达式){
case 取值1:
执行语句;
break;
case 取值2:
执行语句;
break;
...
default:
执行语句;
break;
}
程序执行时,遇到switch
关键字,首先会计算表达式的值,然后根据计算的值和case后面的值做比较,当case后面的值和switch表达式的值相同时,就执行case身后的所有语句,若case身后没有和switch表达式匹配的值,程序就会执行default后面的语句。
2、代码演示
class SwitchDemo{
public static void main(String[] args) {
int x = 5;
switch (x) {
case 5:
System.out.println("a");
break;
case 3:
System.out.println("b");
break;
default:
System.out.println("c");
break;
}
System.out.println("Hello world!");
}
}
3、switch语句特点
switch
语句选择的类型只有四种:byte,short,int , char。(java5之前)。还支持 enum(jdk5), String(jdk7);
case
之间与default
没有顺序。先执行第一个case
,没有匹配的case
执行default
。
结束switch语句的两种情况:遇到break,执行到switch语句结束。
如果匹配的case或者default没有对应的break,那么程序会继续向下执行,运行可以执行的语句,直到遇到break或者switch结尾结束。
4、switch练习
修改上述根据用户的给定的数值,显示该数值对应的星期。 如2----星期二
class SwitchTest
{
public static void main(String[] args)
{
int week = 9;
switch(week)
{
case 1:
System.out.println(week+"对应的是星期一");
break;
case 2:
System.out.println(week+"对应的是星期二");
break;
case 3:
System.out.println(week+"对应的是星期三");
break;
case 4:
System.out.println(week+"对应的是星期四");
break;
case 5:
System.out.println(week+"对应的是星期五");
break;
case 6:
System.out.println(week+"对应的是星期六");
break;
case 7:
System.out.println(week+"对应的是星期日");
break;
default:
System.out.println(week+"没有对应的星期");
break;
}
}
}
switch 根据月份判断季度
public static void main(String[] args) {
String moon = "小月";
switch(moon){
case "一月":
case "二月":
case "三月":
System.out.println("春");
break;
case "四月":
case "五月":
case "六月":
System.out.println("夏");
break;
case "七月":
case "八月":
case "九月":
System.out.println("秋");
break;
case "十月":
case "十一月":
case "十二月":
System.out.println("冬");
break;
default:
System.out.println("查询季度失败~~");
break;
}
}
使用switch结构将学生成绩划分为A(90 – 100),B(80 – 89),C(70 – 79),D(60 – 69),E(60分以下) 五个等级。
class SwitchDemo01{
public static void main(String[] args) {
int res = 76;
switch(res/10){
case 10:
case 9:
System.out.println("成绩为:A");
break;
case 8:
System.out.println("成绩为:B");
break;
case 7:
System.out.println("成绩为:C");
break;
case 6:
System.out.println("成绩为:D");
break;
default:
System.out.println("成绩为:E");
break;
}
}
}
5、if 和 switch 的区别
if 可以用于判断数值,也可以判断区间,只要运算结果是boolean类型,都可以进行判断。
switch用于对固定的几个值,进行判断。判断的值的类型有限。
五、循环结构(while & do-while)
1、循环结构
根据程序的需求,可以将某些代码重复执行的操作。JAVA中的循环结构有如下三种:
while
:事先不需要知道循环执行多少次;do-while
:同上,只是 至少执行一次(先做,后判断);for
:需要知道循环次数。
2、while循环
while(条件表达式)
{
执行的语句;
}
while执行的顺序:
当程序遇到while关键字时,JVM首先会运算while后面的条件表达式,当条件表达式为true时,就会执行while后面大括号中的语句,当把大括号中的所有语句执行完后,会又回到while的条件表达式处再次判断,若还为true,就会继续执行大括号中的语句,若为false就跳过大括号中的所有语句,继续往下执行。
3、while代码举例
class WhileDemo
{
public static void main(String[] args)
{
int i = 1;
while( i < 10 )//这个程序是个死循环
{
System.out.println("i"+i);
}
System.out.println("over");
}
}
/*上述循环是个无限循环(也称为死循环),主要原因是i变量一直为1,每次判断i<10都成立,导致选好条件结束不了。程序永远卡在循环这个地方执行*/
public static void main(String[] args)
{
int i = 1;
while( i < 10 )
{
System.out.println("i"+i);
i++; // 让i不断的更新,最后使循环可以结束
}
System.out.println("over");
}
4、while练习
需求
运算1-10的和。
思路:
计算:1+2+3+4+…+10
每次加的和
不确定。需要变量
记录和的值。
每次和值需要加的下一个数是确定的吗?不确定,需要变量。
求和是+下一个数,再重复说明需要执行多次,用循环。
下一个数,是有规律的—自增。
步骤:
1.定义变量,一个记录和
,一个记录下一个数
。
2.需要循环结构。
3.循坏中需要进行和+
下一个数的运算,并让下一个数自增。
// 1.定义变量,一个记录和,一个记录下一个数
int i = 1;
int sum = 0;
// 2.需要循环结构
while(i<=10){
// 3.循环中需要进行和 + 下一个数的运算,并让下一个数自增。
sum = sum + i;
i++;
}
System.out.println("sum ="+sum);
5、while循环注意事项
1.while循环的括号中的表达式计算结果必须为boolean类型的值。
2.while循环的括号中不能直接写false常量。
3.while循环的括号后面不能写分号,循环控制语句的代码用大括号括起来。
4.while循坏控制的条件变量一定要更新,保证循环能够正常结束。
6、do-while循坏
do
{
执行语句;
}while(条件表达式);
执行顺序:
先执行do后面的语句,当执行完之后再进入条件表达式进行判断,若条件表达式结果为true继续执行do后面的语句,若条件表达式结果为false,则结束循环。
do-while 特点是无论条件是否满足,循环体至少被执行一次。
7、while和do-while对比
以下两个程序的执行结果:
int x = 3;
while(x<3){
System.out.println("x="+x);
x++;
}
System.out.println("========================");
int y = 3;
do{
System.out.println("y="+y);
y++;
}while (y<3);
六、循坏结构(for)
1、for循坏格式
for(初始化表达式(1);循环条件表达式(2);循环后的操作表达式(3))
{
执行语句;(4)
}
执行顺序:
for里面的3个表达式运行的顺序,初始化表达式只读一次,判断循环条件,为真就执行循坏体,然后再执行循环后的操作表达式,接着继续判断循坏条件,重复这个过程,直到条件不满足为止。编号表示:1》》》2》》》4》》》3·········2(当判断结果false时)
。
2、for循环代码举例
class forDemo{
public static void main(String[] args) {
for (int x = 1; x < 3; x++){
System.out.println("x="+x);
}
}
}
3、for和while的区别
for (int x = 1; x < 3; x++){
System.out.println("x="+x);
}
System.out.println("===================");
int y = 1;
while ( y < 3 ){
System.out.println("y="+y);
y++;
}
System.out.println("y.....="+(y++));
while与for可以互换,区别在于for为了循坏而定义的变量再for循环结束就在内存中释放。而while循坏使用的变量在循环结束后还可以继续使用。
4、无限循环
最简单无线循环格式:
while(true){} ,for( ; ; ){} ,无限循环存在的原因是并不知道循环多少次,而是根据某些条件来控制循环。
5、for循环练习
需求
获取1-100之间6的倍数的个数。
思路
1.个数是未知的,所以定义变量。
2.6的倍数怎么表示?只要是对6能整除,也就是没有余数。
3.需要对1-100之间所有的数都要进行判断是不是6的倍数。如果是,需要对个数变量进行自增。
4.怎么完成1-100之间呢?使用循环。
步骤
1.定义变量,记录个数。记录1-100变化的数。
2.定义循环,遍历1-100.
3.在循环中对1-100的数字进行判断。
4.满足条件,个数变量是自增。
class ForTest{
public static void main(String[] args) {
// 1.定义变量,记录个数。
int count = 0;
for(int x = 1; x <= 100; x++){
// 对数值进行判断,是否是6的倍数。
if(x % 6 ==0){
count++;
}
}
System.out.println("count="+count);
}
}
七、嵌套循环
循环嵌套:其实就是在循环中还有循环。简称 大圈套小圈.
1、代码演示
class ForForDemo{
public static void main(String[] args) {
for (int i = 0; i < 3; i++) { //行
for (int j = 0; j < 4; j++) { //每一行的个数
System.out.println("y="+j);
}
}
}
}
通过结果发现:在循环嵌套中,外循环执行一次,内循环要从头向尾执行完。
2、循环嵌套联系
需求
在屏幕上显示以下图形
*****
****
***
**
*
思路
1.图形是由5行的组成。
2.每一行有多个星。
3.多行,循环就可以完成。每一行,里面有多个星。循环内,还需要循环负责每一行的星的个数。
4.外循环控制行数,内循环控制每一行的个数。
class ForForTest{
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
System.out.print("&");
}
System.out.println();
}
/*
&&&&&
&&&&&
&&&&&
&&&&&
&&&&&
*/
for (int i = 0; i < 6; i++) {
for (int j = 0; j < i; j++) {
System.out.print("*");
}
System.out.println();
}
/*
*
**
***
****
*****
*/
}
}
空心菱形
/**
*空心菱形
*/
class Demo03{
public static void main(String[] args) {
/**
* 上半部分 等腰三角 空心
* 下半部分 倒等腰三角 空心
*/
for (int i = 6; i >=1 ; i--) {
for (int j = 1; j <= 11 ; j++) {
if(i==j || j==12-i){
System.out.print("*");
}else{
System.out.print(" ");
}
}
System.out.println();
}
for (int i = 2; i <= 6; i++) {
for (int j = 1; j <= 11; j++) {
if(i==j || j==12-i){
System.out.print("*");
}else{
System.out.print(" ");
}
}
System.out.println();
}
}
}
/*
*
* *
* *
* *
* *
* *
* *
* *
* *
* *
*
*/
八、流程控制( continue ,break)
1、break语句、continue语句
break:终止该层循环;
continue:跳过该次循环
注意:
1.若这两个语句离开应用范围,存在是没有意义的。
2.这个两个语句单独存在后面都不能有语句,因为执行不到。
3.continue
语句是跳过本次循环,继续下次循环。
4.标签
的出现,可以让这两个语句作用于指定的循环。
2、break语句 和 continue语句举例
// break是终止循环,即在程序中遇到break,那么break所属的循环将结束。
for (int x = 0; x < 3; x++){
if (x==1)
break;
System.out.println("x1="+x);
}
// continue是结束本次循环,继续下次循环。循环是不会结束的。
for (int x = 0; x < 10; x++){
if(x % 2 ==0)
continue;
System.out.println("x2="+x);
}
/*
x1=0
x2=1
x2=3
x2=5
x2=7
x2=9
*/
3、使用循环标签
在多层嵌套循环
中,终止 / 跳过
标签标记的那层循环的执行;break <标签>
或 continue <标签>
;
outer:for (int x = 0; x < 3; x++){
inner:for (int y = 0; y < 4; y++){
System.out.println("x1="+x);
break outer;
}
}
System.out.println("=========================================");
outer:for (int x = 0; x < 3; x++){
inner:for (int y = 0;y < 4; y++){
System.out.println("x2="+x);
continue outer;
}
}