java学习笔记—条件语句

Java 条件语句

if…else-三种格式：

1、if(布尔表达式) { //如果布尔表达式为true将执行的语句 }

如果布尔表达式的值为 true，则执行 if 语句中的代码块，否则执行 if 语句块后面的代码。

2、if(条件表达式){执行代码块；}else{执行代码块； }

3、if(条件表达式){执行代码块；}else if{执行代码块；}else{执行代码块；}

if…else if…else 语句

if 语句后面可以跟 else if…else 语句，这种语句可以检测到多种可能的情况。

使用 if，else if，else 语句的时候，需要注意下面几点：

• if 语句至多有 1 个 else 语句，else 语句在所有的 else if 语句之后。
• if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。
• 一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。

public class Test {	
	 public static void main(String[] args) {	     
	     int i =3;
	     if(i==1) {
	    	 System.out.println("一");
	     }else if(i==2) {
	    	 System.out.println("二");
	     }else {System.out.println("三");}
	     int m=90;
	     if(m==100) {
	    	 System.out.println("BWM一辆");
	     }else if(m > 80 && m <=99) {
	    	 System.out.println("手机一台");
	     }else if(m > 60 && m <=80) {
	    	 System.out.println("参考书一本");
	     }else {
	    	 System.out.println("什么都没有");
	     }
         
         int o = 4;
	     int p = 1;
	     if(o>2) { //o大于4，走if分支
	    	 if(p>2) {//判断p是不是大于2，如果是做这个分支
	    		 System.out.println(p+o);
	    		 System.out.println("atguigu"); 
	    	 }
	     }else {System.out.println("o is "+o); 
	    	 }
	     
	     if(false) {
	    	 //这里可以写任何代码段，包括if-else
	     }else {
	    	//这里可以写任何代码段，包括if-else
	     }

​

switch语句

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

语法

switch case 语句语法格式如下：

switch(expression){  
	  case value :       //语句    
		   break; //可选  
	  case value :       //语句       
			break; //可选    
						//你可以有任意数量的case语句   
		 default : //可选     
  //语句 }

switch语句有关规则
●switch(表达式)中 表达式的返回值必须是下述几种类型之一: byte, short, char,int，枚举，String;

​ ●case 子句中的值必须是常量，且所有case子句中的值应是不同的;

​ ●default 子句是可任选的，当没有匹配的case时，执行default

​ ●break语句用来在执行完–个case分支后使程序跳出switch语句块;如果没有
​ break，程序会顺序执行到switch结尾

break是必需写的，不然程序就行从case匹配到位置开一直往下执行到结尾

循环结构

●循环语句功能
➢在某些条件满足的情况下，反复执行特定代码的功能

●循环语句的四个组成部分
*初始化部分(init. statement)
*循环条件部分(test exp)
*循环体部分(body statement)
*迭代部分( alter. statement)

●循环语句分类
*for循环
*while循环
*do/while循环

for 循环语句

**格式：**for(初始化；布尔表达式：更新){

​ 代码块；}

实例:

int result = 0;
	     for(int b = 1;b<=100;b++) {
	    	 result +=b;/1+2+...+100
	     }
	     System.out.println("result="+result);//result=5050

//判断水仙花数
	     for(i=100;i<=999;i++) {
	     int q =i/100;//得到百位数
	     int w =(i-q*100)/10;//得到十位数
	     int e =(i-q*100-w*10);//得到个位
	     //System.out.println(i);
	     //System.out.println(q+" "+w+" "+e);
	     int res=q*q*q+w*w*w+e*e*e;
	     if(res==i) {
	    	 System.out.println(i);
	     }
	     }

Java 增强 for 循环

Java5 引入了一种主要用于数组的增强型 for 循环。

Java 增强 for 循环语法格式如下:

for(声明语句 : 表达式) { //代码句子 }

**声明语句：**声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

**表达式：**表达式是要访问的数组名，或者是返回值为数组的方法。

实例

Test.java 文件代码：

public class Test {   
	public static void main(String args[]){      
	int [] numbers = {10, 20, 30, 40, 50};      
    
    for(int x : numbers ){         
    System.out.print( x );         
    System.out.print(",");      
    }      
    System.out.print("\n");      
    String [] names ={"James", "Larry", "Tom", "Lacy"};      	for( String name : names ) {         
    System.out.print( name );         
    System.out.print(",");      
    }   
    } 
    }

以上实例编译运行结果如下：

10,20,30,40,50,
James,Larry,Tom,Lacy,

while循环

格式：【初始化】
while(布尔表达式){
语句；
更新语句；
}

		//求1到100之间所有偶数的和。
		 int k=0;
		 for(int i =1;i<=100;i++) {
			 if(i % 2==0) {
				 k +=i;
			 }
			}
		 System.out.println(k);
		 
		 int z=1;
		 int x=0;
		 while(z<101) {
			 if(z % 2==0) {
				 x +=z;								 
			 }
			 z++;
		 }System.out.println(x);

do…while 循环

对于 while 语句而言，不满足条件，则不能进入循环。而do…while 循环至少会执行一次。

public class Test {   
	public static void main(String args[]){      
		 int c = 5;       
			do{         
				System.out.print( c );         
				c++;         
				System.out.print("\n");      
			}while( c < 5 ); //运行结果为5
} }

break 关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块（终止当前所在循环）。

break 跳出最里层的循环，并且继续执行该循环下面的语句。

public class Test {   
	public static void main(String args[]) {      
	int [] numbers = {10, 20, 30, 40, 50};       
	
        for(int x : numbers ) {         // x 等于 30 时跳出循环         if( x == 30 ) {            
			break;         
        }         
	System.out.print( x );         
	System.out.print("\n");      }   } }

结果：

10
20

continue 关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在 for 循环中，continue 语句使程序立即跳转到更新语句。

在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

public class Test {   
	public static void main(String args[]) {
		for(int i = 1;i<6;i++) {
			if(i==3) {
				continue;//结束当前循环，直接进入下一次循环
				}
			System.out.println(i);
		}

结果：

1
2
4
5

嵌套循环

●将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环和内层循环。

●实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

●设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n=mn次。

         // 九九乘法表   
         //   1*1=1
	    //	  1*2=2 2*2=4
		//    1*3=3 2*3=6 3*3=9
		public class Test {   
		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();//换行
		}}}

结果

1*1=1 
2*1=2 2*2=4 
3*1=3 3*2=6 3*3=9 
4*1=4 4*2=8 4*3=12 4*4=16 
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81 

         //1-100之间的质数，只能被1和本身整除
		 //看能整除的次数，如果整除的次数为两次，则为质数
		public class Test {   
		public static void main(String args[]) {
		for(int i=1;i<=100;i++ ) {
			int k = 0;
			for(int j =1;j<=i;j++) {
				if(i%j==0) {
					k++;
				}
			}if(k==2) {
				System.out.println(i);
			}
		}}}