Java程序的三种基本结构

顺序结构 (按照顺序从上往下依次执行)

public class Order (){
	public void main (string[] args){
		short a = 1;//以a为理由向内存申请一份2个字节的空间,并存1
		float b = 2.0;//以b为理由向内存申请一份4个字节的空间,并存2.0
		int c = 3;//以c为理由向内存申请一份4个字节的空间,并存3
		double d = 4.0//以d为理由向内存申请一份8个字节的空间,并存4.0
		System.out.println(a);//输出a的值
		System.out.println(b);//输出b的值
		System.out.println(c);//输出c的值
		System.out.println(d);//输出d的值	
	}
}

代码执行结果为
1
2.0
3
4.0
代码从上向下依次执行

选择分支结构(基于顺序结构,选择执行某些代码)

使用if语句实现程序的选择分支

• 语法
  - ｉｆ (判断条件){
  　　-条件为真时执行的代码块
  }ｅｌｓｅ｛
  　　　　－条件为假是执行的代码块
  ｝
  
  
  

－ｉｆ（判断条件１）｛
　　条件１为真是执行代码块否则判断条件２
｝ｅｌｓｅ　ｉｆ（判断条件２）｛
　条件２为真是执行代码块否则判断条件３
｝ｅｌｓｅ　ｉｆ（判断条件３）｛
　条件３为真时执行代码块
｝ｅｌｓｅ｛
　　条件１，２，３全部为假是执行的代码块
｝

代码举例

public class SelectBranch{
	public void main(String[] arg){
		int a = 1, b = 2,c = 3,d = 4;
		if(a>b){
			System.out.println(c);//如果a>b条件成立,则输出 c 
		}else{
			System.out.println(c);//如果a>b条件成立,则输出 d
		}
	}
} 

代码执行结果为 4,因为a>b条件不成立,执行else里的代码块

public class SelectBranch{
	public void main(String[] arg){
		int a = 1, b = 2,c = 3,d = 4;
		if(a>b){
			System.out.println("a>b条件成立");//如果a>b条件成立,则输出  
		}else if(c>d){
			System.out.println("c>d条件成立");//如果a>b条件成立,则输出 
		}else{
			System.out.println("a>b,c>d条件都不成立");//如果a>b,c>d条件都不成立,则输出 
		}
	}
} 

代码执行结果为
a>b,c>d条件都不成立

使用if语句实现程序的选择执行

适合于条件范围判断,也能做条件等值判断

switch case 语句

• 语法
  -switch(表达式){
  case 常量1 : 代码块1 break;
  case 常量2 : 代码块2 break;
  case 常量3 : 代码块3 break;
  …
  default: 代码块 break ; / / 此break可以省略
  }
• 说明
• 表达式的结果类型只能是整型数据，字符型数据，枚举型数据，也可以是字符串类型，但必须注意ｊｒｅ版本
• ｊｒｅ版本１．７及以上ｓｗｉｔｃｈ的表达式可以是字符串类型
• ｊｒｅ版本１．６以下ｓｗｉｔｃｈ不能使用字符串类型
• 注意虽然使用ｊｒｅ版本是１．７以上，但是编译等级设置为１．６及以下任然不可以使用字符串
• 常量：整型，字符型，枚举型，字符串类型
• 代码块：　符合常量时执行的代码，可以是多行代码，但不一定使用大括号
• ｂｒｅａｋ：是终止的意思，如果执行到ｂｒｅａｋ语句，那么终止当前的ｓｗｉｔｃｈ结构，执行后面的语句
  如果没有ｂｒｅａｋ语句那么找到符合的常量的时候执行对应的代码块，但执行完代码块后后续常量对应的代码块一并执行，直到碰到ｂｒｅａｋ语句退出ｓｗｉｔｃｈ结构
• ｄｅｆａｕｌｔ：如果没有任何一个常量符合，则执行ｄｅｆａｕｌｔ后面的代码块
  ｄｅｆａｕｌｔ可以放在ｓｗｉｔｃｈ的任何位置，但是不能放在ｃａｓｅ中
  ｄｅｆａｕｌｔ和ｃａｓｅ是平级关系，但一般ｄｅｆａｕｌｔ放在ｓｗｉｔｃｈ的最后，并且可以不写ｂｒｅａｋ．

public class SelectBranch{
	public void main(String[] arg){
		int a = 10;
		int b = 20;
		switch(b - a){
			case 30 : System.out,println("b - a = 30") break;
			case 20 : System.out,println("b - a = 20") break;
			case 10 : System.out,println("b - a = 10") break;
			default : System.out,println("默认值") ;
		}
	｝
｝

代码执行结果
输出 b - a = 10,
因为有break,不执行default后面的代码

switch适合做等值判断

三元运算符

• 语法
  类型名 变量名 = (条件表达式) ? 表达式1 : 表达式二;
• 说明
  条件表达式的结果为boolean类型
  条件表达式为真值把表达式一的结果赋值给变量名
  条件表达式为假值把表达式二的结果赋值给变量名
  表达式一和表达二的结果类型必须相同,且要和变量的类型相同
  三元运算符的本质就是一个ｉｆ－ｅｌｓｅ

public class SelectBranch{
	public void main(String[] arg){
	int a = 10,b = 20;
	int c = (b>a)? b - a:b + a;//如果b > a,将b - a的值赋值给c,否则将b + a的值赋值给c 
	System.out.println(c);
	}
}

相当于

public class SelectBranch{
	public void main(String[] arg){
	int a = 10,b = 20,c=0;
	if(b > a){
		c = b - a;
	}else{
		c = b + a;
	}
	System.out.println(c);
	}
}

代码执行结果
10

程序的选择分支结构

循环结构(基于顺序结构,重复执行某些代码)

• 循环的分类
• while 循环
• do–while 循环
• for 循环(普通for循环和增强for循环)

while循环

• 语法
  while(条件){
  循环代码体
  }
• 说明
  • 条件可以是逻辑表达式,也可以是关系表达式,但表达式的结果必须是boolean类型
  • 循环体代码完成某以功能的若干代码,一定是有规律的

public class Loop{
	public void main(String[] arg){
		int a = 1;
		while(i <= 100){
			System.out.print(i++);//当a < 100时循环打印1~100
		}
	}
}

代码执行结果为 123456~100

do-while

• 语法
  do{
  }while(条件)
• 循环至少执行一次,然后才判断条件

public class Loop{
	public void main(String[] arg){
		int a = 1;
		do{
			System.out.print(i++);//当a < 100时循环打印1~100,先执行一次输出再判断条件
		}while(i <= 100)
	}
}

代码执行结果 123456789~~~100

for循环

• 语法
  ｆｏｒ（数据初始化；条件；循环变量的增量或减量）｛
  循环体代码块
  ｝
• 说明
  • 数据初始化:可以定义多个变量,中间用逗号隔开,但类型必须是同一种类型,且在第一此循环是执行一次
  • 条件表达式:可以是关系表达式也可以是逻辑表达式 ,结果是boolean类型,且表达式有且只有一个,条件为真值进入循环,条件为假值则退出循环
  • 循环变量的增量或减量,当循环条件为真值,执行循环体然后执行循环变量的增量或减量,然后判断条件是否为真,如果为真则继续执行循环体,然后还是执行循环变量的增量或减量如此往复直到循环条件为假则退出循环

public class Loop{
	public void main(String[] arg){
		for(int a = 1;a <= 100 a++){
			System.out.print(i++);//当a < 100时循环打印1~100
		}
	}
}

代码执行结果.123456789~~100

增强for循环

• 语法
  ｆｏｒ（数据类型 变量名：数组名或集合名）｛
  　　循环体代码
  ｝
• 说明
  从数组或集合中取出取出一个数据赋值给变量名然后在循环体代码中使用此变量名中的数据（变量名的作用域仅在此循环体范围内），执行完一次循环体后再次从数组或集合中取出第二个数据赋值给变量名，然后在循环体中使用变量名中的数据，如此往复，直到把数组或集合中的数据都取出，循环执行完毕

public class Loop{
	public void main(String[] arg){
		int [] a0 = new int[10]; //声明数组的同时申请了内存空间,有初值0
		int [] a1 = {1,2,3,4,5,6.7.8.9.0};//声明数组的同时申请了内存空间,并赋值
		int [] a2 = new int [] {1,2,3,4,5,6,7,8,,9,0};//[]里不能写数字,声明数组的同时申请了内存空间,并赋值
		for(int b : a0){
			System.out.print(b);//变量b的作用范围只在此方法体内,循环打印a0[10]数组里的内容
		}
		for(int b : a1){
			System.out.print(b);//变量b的作用范围只在此方法体内,循环打印a1[]数组里的内容
		}
		for(int b : a2){
			System.out.print(b);//变量b的作用范围只在此方法体内,循环打印a1[]数组里的内容
		}
	}
}

代码执行结果
0000000000 1234567890 1234567890

循环嵌套

• 说明
  循环里面套循环,外层循环执行一次,内层循环执行多次,冒泡排序法就是一个简单的循环嵌套的例子

package cn.tedu.lianx.Demo1;

import java.util.Scanner;

public class MaoPao {
	public static void main(String[] args) {		
		Scanner input = new Scanner(System.in);
		System.out.println("请输入数组长度");
		int len = input.nextInt();//自定义一个数组长度
		int [] a = new int [len];
		for(int i=0;i<len;i++){//循环输入若干值
			System.out.println("请输入第"+(i+1)+"个数字");
			a[i] = input.nextInt();
		}
		for(int i=0;i<a.length;i++){//冒泡排序的过程
			for(int j=0;j<a.length-i-1;j++){
				if(a[j]>a[j+1]){
					int k;
					k = a[j];
					a[j]=a[j+1];
					a[j+1]=k;
				}
			}
		}
		System.out.println("----------------------运行结果---------------------------");//结果展示
		for(int i : a){//增强for循环的实际应用
			System.out.print(i+"\t");
		}
		input.close();
	}

}

• 代码执行结果
  
  扫描或搜索java泡腾片关注公众号获取更多内容