零基础学Java——小白的Java之路（3）

流程控制

条件
- if-else
- switch
循环
- while
- do-while
- for
跳转
- break
- continue
其他语句
- return

if语句

if(条件表达式1){
	语句块;
}
else if(条件表达式2){
	语句块2;
}
......
......
......
else{
	语句块3;
}

　　条件表达式的值为boolean值。可以有多个else if

　　条件表达式结果为true则执行其后{}的代码，否则判断下一个条件，如果所有条件都不成立则执行else。

　　if语句可以嵌套

if嵌套举例

//求三个数中的最大者
public class MaxOne{
	public static void main(String args[]){
		int a=5;
		int b=6;
		int c=7;
		if(a>b){
			if(a>c){
				System.out.println("最大的是："+a);
			}
			else{
				System.out.println("最大的是："+c);
			}
		}
		else if(b>c){
			System.out.println("最大的是："+b);
		}
		else{
			System.out.println("最大的是："+c);
		}
	}
}

示例代码　　

 1 //if条件语句
 2 import java.util.Scanner;
 3 
 4 public class IfTest{
 5     
 6     public static void main(String args[]){
 7         
 8         //语法
 9         /*
10         //单分支
11         
12         if(条件){
13             语句块;
14         }
15         
16         //双分支
17         
18         if(条件){
19             语句块1;
20         }
21         else{
22             语句块2;
23         }
24         
25         //多分支
26         
27         if(条件1){
28             语句块;
29         }
30         else if(条件2){
31             语句块2;
32         }
33         ......
34         ......
35         ......
36         else{
37             语句块3;
38         }
39         
40         */
41         
42         Scanner scan = new Scanner(System.in);
43         
44         System.out.print("请输入一个整数：");
45         
46         int x =scan.nextInt();
47         
48         System.out.println("你输入的是："+x);
49         
50         if(x>0){
51             
52             System.out.println(x+"是正数");
53             
54         }
55         else if(x<0){
56             
57             System.out.println(x+"是负数");
58             
59         }
60         else{
61             System.out.println(x+"是零");
62         }
63     }
64     
65 }

if条件语句

switch语句

switch(表达式){
				
	case 值1:
		语句块1;
		break;
	case 值2:
		语句块2;
		break;
	...
				
	default:
		语句块3;
				
}

　　switch 语句有如下规则：

switch 语句中的变量类型可以是： byte、short、 int 或者 char。从SE 7开始，switch 支持字符串类型。
当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
switch 语句可以包含一个 default 分支， default 在没有 case 语句的值和变量值相等的时候执行。

示例代码

 1 //switch 条件语句
 2 import java.util.Scanner;
 3 public class SWTest{
 4     
 5     public static void main(String args[]){
 6         
 7         /*
 8             语法
 9             switch(表达式){
10                 
11                 case 值1:
12                         语句块1;
13                         break;
14                 case 值2:
15                         语句块2;
16                         break;
17                 ...
18                 
19                 default:
20                         语句块3;
21                 
22             }
23             
24             default可以省略
25             执行：将表达式和值进行匹配，如果匹配上，开始往下执行，一直执行到break跳出switch，如果都不匹配，则执行default中的语句块
26         
27             注意表达式支持：int byte short char   jdk1.7后支持String
28         
29         
30         
31         */
32         Scanner scan = new Scanner(System.in);
33         System.out.print("请输入一个运算符：");
34         String ch = scan.nextLine();
35         
36         int a =2;
37         int b =3;
38         
39         switch(ch){
40             
41             case "+":
42                 System.out.println(a+"+"+b+"="+(a+b));
43                 break;
44                 
45             case "-":
46                 System.out.println(a+"-"+b+"="+(a-b));
47                 break;
48                 
49             case "*":
50                 System.out.println(a+"*"+b+"="+(a*b));
51                 break;
52                 
53             case "/":
54                 System.out.println(a+"/"+b+"="+(a/b));
55                 break;
56                 
57             default:
58                 System.out.println("请输入有效的运算符：+ - * /");
59         }
60         
61         
62     }
63 }

switch条件语句

while语句

while(condition){
				
	语句块;
			
}

判断控制表达式condition的值，当其是真时，while语句重复执行一个语句或语句块。

其中条件condition可以是任何布尔表达式。

只要条件表达式为真，循环体就被执行。当条件condition为假时，程序控制就传递到循环后面紧跟的语句行。

若只有单个语句需要重复，大括号可以省略。

示例代码

 1 //while循环
 2 public class WhileTest{
 3     
 4     public static void main(String args[]){
 5         
 6         /*
 7             while(条件){
 8                 
 9                 语句块:
10                 
11             }
12         
13             执行：1.判断条件，如果为false,结束循环
14                   2.条件如果为true,执行循环体中的语句，执行1
15         
16         
17         
18         */
19         
20         //计算1加到100
21         /*int i =1;
22         int sum =0;
23         
24         while(i<=100){
25             sum+=i;
26             
27             i++;
28         }
29         
30         System.out.println("结果为："+sum);
31         */
32         
33         //计算100以内偶数的和
34         int i =1;
35         int sum =0;
36         
37         while(i<=100){
38             
39             
40             if(i%2==0){
41                 sum+=i;
42             }
43             i++;    
44         }
45         System.out.println("结果为："+sum);
46         
47         
48     }
49 }

while循环语句

do-while语句

do{
				
	语句块;
			
}while(condition);

　　先执行循环体，然后再计算条件表达式condition 。如果表达式为真，则循环继续。否则，循环结束。对所有的Java循环都一样，条件condition必须是一个布尔表达式。

示例代码

 1 //do while循环
 2 public class Dowhile{
 3     public static void main(String args[]){
 4         int sum = 0;
 5         int i = 1;
 6         
 7         do{
 8             sum+=i;
 9             i++;
10         }
11         while(i<=100);
12         
13         System.out.println("sum="+sum);
14     }
15 }

do-while循环语句

for语句

for(语句块1;语句块2;语句块3){

       语句块4;     
  
}

　　执行顺序：

执行一次语句块 1；
执行语句块 2 ，若返回 true 则进入循环体；否则中断for循环。
执行完循环体后，进行语句块 3 的操作。
重复2，3

示例代码

 1 //for循环
 2 
 3 public class ForTest{
 4     
 5     public static void main(String args[]){
 6         
 7         int sum=0;
 8         for(int i=0;i<=100;i+=2){
 9             sum+=i;
10         }
11         
12         System.out.print("sum="+sum);
13     }
14 }

for循环语句

 1 //for的嵌套
 2 public class ForFor{
 3     public static void main(String args[]){
 4         
 5         /*for (int i =1;i<10;i++){
 6             
 7             for (int j =1;j<=i;j++){
 8                 
 9                 System.out.print(j+"*"+i+"="+j*i);
10                 System.out.print("\t");
11             }
12             
13             System.out.println();
14         }
15         */
16         
17         for (int i =1;i<10;i++){
18             
19             for (int j=1;j<=i;j++){
20                 
21                 System.out.print("*");
22                 System.out.print("\t");
23             }
24             
25             System.out.println();
26         }
27         
28     }
29 }

for的嵌套

其他语句

label:{语句块} ：用于给程序块取名字。

break ：语句在循环中用于立即从当前循环终止执行，结束当前循环的执行。

continue ：语句则是从其调用处跳至循环的开始处，结束本次循环，继续执行下一次循环，循环体中continue 语句之后的语句将不再执行。

示例代码

 1 //break continue return
 2 public class BreakContinue{
 3     
 4     public static void main(String args[]){
 5         
 6         for(int i=1;i<=10;i++){
 7             
 8             //System.out.println("i="+i);
 9             
10             if (i!=5){
11                 //break 结束循环，执行循环后的语句
12                 //break;
13                 
14                 //return 结束方法
15                 //return;
16                 
17                 //continue 结束当次循环，执行下一次循环
18                 continue;
19             }
20             System.out.println("i="+i);
21         }
22         
23         System.out.println("------end--------");
24     }
25 }

break及continue

一维数组

定义

数组类型数组名[]；或数组类型[] 数组名；
数组类型可为Java中的任何数据类型。
数组名，必须符合标识符定义规则。
“[]”指明该变量是一个数组类型的变量，可放到数组名后面，也可放到数组名前。
如：
```
int[] arr; 
int arr[];
```

初始化

使用new分配内存空间，并按照数组的类型，为每一个数组元素建立默任值。

int arr[ ];arr=new int[10]; 
int arr[]=new int[10];

也可以使用常量初始化：

int[] arr = {1,2,3,4};

[]中的10表示数组的长度，即这个数组最多存放元素的个数。定义初始化数组的时候必须确定数组的长度

引用

数组元素的引用格式为：数组名[下标]

int a[]=new int[10];
int b=a[0]+a[9];

数组下标范围从0到9。

数组下标的最小值为0，最大值为数组的长度-1。

如果下标超出了范围，程序运行时将报数组越界错误： java.lang.ArrayIndexOutOfBoundsException

示例代码

 1 //一维数组
 2 
 3 public class ArrayTest{
 4     
 5     public static void main(String args[]){
 6         
 7         //一维数组定义   必须要有一个[]
 8         //数据类型 [] 数组名称 或者 数据类型 数组名称[]
 9         
10         int arr[];  //或者  int[] arr;
11         
12         arr = new int[5];  //一维数组的初始化
13         
14         double[] brr = new double[5];
15         
16         int[] arr2 = {2,3,4,5,6,7};
17         
18         
19         /*boolean[] bl = new boolean[5];
20         
21         for(int i =0;i<bl.length;i++){
22             
23             System.out.println(bl[i]);
24         }
25         */
26         
27         //给数组赋值
28         for (int i =0;i<arr.length;i++){
29             arr[i]=10+i;
30         }
31         for (int i =0;i<arr.length;i++){
32             System.out.println(arr[i]);
33             
34         }
35         
36         
37 
38     
39     }
40 }

一维数组

二维数组

定义

二维数组可理解为数组的数组，即元素是数组的数组，定义格式为：

数组类型数组名[][]；

或数组类型[][] 数组名；

或数组类型[] 数组名[]；

如：

int[][] arr; 
int arr[][];

初始化

直接为每一维分配空间，例如：
```
 int a[][]=new int[3][2];
```

高维开始，分别为每一维分配空间，例如：

int a[ ][ ]=new int[3][]; 
a[0]=new int[2]; 
a[1]=new int[3]; 
a[2]=new int[4];

数组常量初始化，例如：
```
 int a[][]={{1},{2,3},{4,5,6}};
```

引用

引用格式为：

数组名[下标1][ 下标2]；

下标1，下标2分为二维数组的第一、二维下标，同一维数组一样，也可为整型常量和表达式，并且数组下标都从0开始。

int a[ ][ ]={{1,2,3},{4,5,6},{7,8,9}};
		System.out.println("数组a各元素的值为：");
		for(int i=0;i<4;i++){
			 for(int j=0;j<3;j++)
  				System.out.println(a[i][j]+"\t");
		}

操作数组的一些方法

System类中的静态方法arraycopy() 。

　　　System.arraycopy(src, srcPos, dest, destPos, length);

Arrays类中的方法。
- 排序方法sort（Object[] arrayname ）
- 二分查找方法 binarySearch(Object[] a,Object key)

　　　此两种方法可以用类名 + 点运算符调用。

int[] t={1,2,5,3};
Arrays.sort(t);
    for(int i=0;i<t.length;i++){
        System.out.print(t[i]);
    }
System.out.println();
int[] t2=new int[t.length];
    System.arraycopy(t, 0, t2, 0, t.length);
    for(int i=0;i<t2.length;i++){
        System.out.print(t2[i]);
    }

示例代码　　

 1 //二维数组
 2 public class ArrayTest2{
 3     
 4     public static void main(String args[]){
 5         
 6         int arr[][]=new int[3][];
 7         
 8         for (int k =0;k<arr.length;k++){
 9             
10             arr[k]=new int[5];
11             for (int i =0;i<arr[k].length;i++){
12                 
13                 arr[k][i]=(int)(Math.random()*100);
14             }
15         }
16         for (int k=0;k<arr.length;k++){
17             
18             for (int i =0;i<arr[k].length;i++){
19                 
20                 System.out.print(arr[k][i]+",");
21             }
22             System.out.println();
23         }
24         /*arr[0]=new int[5];
25         for (int i =0;i<arr[0].length;i++){
26             
27             arr[0][i]=(int)(Math.random()*100);
28         }
29         System.out.println(arr[0]);
30         
31         for (int i =0;i<arr.length;i++){
32             
33             System.out.println(arr[i]);
34         }
35         */
36         
37         /*int a[][]={{1,2,3},{4,5,6},{7,8,9}};
38         System.out.println("数组a各元素的值为：");
39         for(int i=0;i<3;i++){
40             for(int j=0;j<3;j++){
41                   System.out.println(a[i][j]+"\t");
42             }
43         }
44         */
45     }
46 }

二维数组

练习

计算1+2+3+….+20输出结果

 1 //计算1加到20的和
 2 
 3 public class HWD2T1{
 4     
 5     public static void main(String args[]){
 6         
 7         int sum =0;
 8         
 9         for (int i =0;i<=20;i++){
10             
11             sum+=i;
12         }
13         
14         System.out.println("sum="+sum);
15     }
16     
17 
18 }

第一题

计算1+3+5+7+9+……+99的值并输出

 1 //计算100以内所有奇数的和
 2 
 3 public class HWD2T2{
 4     
 5     public static void main(String args[]){
 6         
 7         int sum=0;
 8         
 9         for(int i=1;i<+100;i+=2){
10             
11             sum+=i;
12         }
13         
14         System.out.println("sum="+sum);
15     }
16 }

第二题

计算1+2!+3!+...+10!的值并输出

 1 //计算1到10的阶层的和
 2 
 3 public class HWD2T3{
 4     
 5     public static void main(String args[]){
 6         
 7         int a=1;
 8         
 9         int sum=0;
10         
11         for(int i =1;i<=10;i++){
12             
13             a*=i;
14             sum+=a;
15         }
16         
17         System.out.println("sum="+sum);
18     }
19 }

第三题

计算x+y的值（依次输入数字x、运算符号（如+、-、*、/）、运算数字y，由switch控制进行的运算并得到运算结果）。

 1 import java.util.Scanner;
 2 
 3 public class HWD2T4{
 4     
 5     public static void main(String args[]){
 6     
 7         Scanner scan = new Scanner(System.in);
 8     
 9         System.out.print("请输入一个数字：");
10     
11         double x = scan.nextDouble();
12     
13         System.out.print("请输入一个运算符：");
14     
15         String ch = scan.next();
16     
17         System.out.print("请再输入一个数字：");
18     
19         double y = scan.nextDouble();
20     
21         switch(ch){
22         
23             case "+":
24                 System.out.println(x+"+"+y+"="+(x+y));
25                 break;
26             
27             case "-":
28                 System.out.println(x+"-"+y+"="+(x-y));
29                 break;
30             
31             case "*":
32                 System.out.println(x+"*"+y+"="+(x*y));
33                 break;
34             
35             case "/":
36                 System.out.println(x+"/"+y+"="+(x/y));
37                 break;
38         }
39     }
40 }

第四题

定义一个长度为20的int类型的数组并赋值1到20，然后打印出数组的值。

 1 //定义一个长度为20的int类型的数组并赋值1到20，然后打印出数组的值
 2 public class HWD2T5{
 3     
 4     public static void main(String args[]){
 5         
 6         int[] arr = new int[20];
 7         
 8         for (int i=0;i<arr.length;i++){
 9             
10             arr[i]=1+i;
11         }
12         
13         for (int j=0;j<arr.length;j++){
14             
15             System.out.println(arr[j]);
16         }
17     }
18 }

第五题

屏幕输入一个年份，判断是否为闰年

 1 //输入一个年份，判断是否是闰年
 2 
 3 import java.util.Scanner;
 4 
 5 public class HWD2T6{
 6     
 7     public static void main(String args[]){
 8         
 9         Scanner scan = new Scanner(System.in);
10         
11         System.out.print("请输入一个年份：");
12         
13         int year = scan.nextInt();
14         
15         if (year%4==0&&year%100!=0||year%400==0){
16             
17             System.out.println("是闰年");
18         }
19         else{
20             
21             System.out.println("不是闰年");
22         }
23     }
24 }

第六题

附加题

编写程序，实现如下功能：

随机分配一个1～100之间的整数(Math.random()返回一个double类的数);
用户从键盘上输入自己的猜测
程序返回提示信息，提示信息分别是“猜大了”、“猜小了”和“猜对了”。
用户可根据提示信息再次输入猜测，直到提示信息是“猜对了”。

 1 //编写一个猜数字小程序
 2 
 3 import java.util.Scanner;
 4 
 5 public class HWD2EX1{
 6     
 7     public static void main(String args[]){
 8         
 9         Scanner scan =new Scanner(System.in);
10         
11         int rnum=(int)(Math.random()*100);
12         
13         boolean flag = true;
14         
15         while (flag==true){
16             
17             System.out.print("请输入你猜测的数字：");
18             
19             int i = scan.nextInt();
20             
21             if (i>rnum){
22                 
23                 System.out.println("猜大了");
24             }
25             else if (i<rnum){
26                 
27                 System.out.println("猜小了");
28             }
29             else{
30                 
31                 System.out.println("猜对了");
32                 
33                 flag = false;
34             }
35         }
36     }
37 }

附加题1

屏幕输入一个数，判断是否为素数

 1 //输入一个数判断是否是素数
 2 
 3 import java.util.Scanner;
 4 
 5 public class HWD2EX2{
 6     
 7     public static void main(String args[]){
 8         
 9         Scanner scan = new Scanner(System.in);
10         
11         System.out.print("请输入一个整数：");
12         
13         int num = scan.nextInt();
14         
15         boolean flag = true;
16         
17         if (num<2){
18             
19             System.out.println(num+"不是素数");
20         }
21         else{
22             
23             for (int i =2;i<num;i++){
24                 
25                 if(num%i==0){
26                     
27                     flag = false;
28                 }
29             }
30             if (flag==false){
31                 
32                 System.out.println(num+"不是素数");
33             }
34             else{
35                     
36                 System.out.println(num+"是素数");
37             }
38         }
39     }
40 }

附加题2

定义一个double数组并给数组元素赋值，查询输出这个double数组中的最小值

 1 //定义一个double数组并给数组赋值，查询输出这个数组的最小值
 2 
 3 public class HWD2EX3{
 4     
 5     public static void main(String args[]){
 6         
 7         double[] arr =new double[5];
 8         
 9         for (int i =0;i<arr.length;i++){
10             
11             arr[i]=Math.random()*100;
12         }
13         
14         double min = arr[0];
15         
16         for (int j =0;j<arr.length;j++){
17             
18             System.out.println(arr[j]);
19             
20             if(arr[j]<min){
21                 
22                 min = arr[j];
23             }
24         }
25         
26         System.out.println("该数组最小值是："+min);
27     }
28 }

附加题3

定义一个一维数组和二维数组，分别进行遍历。

 1 //定义一个一维数组和二维数组，分别进行遍历
 2 
 3 public class HWD2EX4{
 4     
 5     public static void main(String args[]){
 6         
 7         int[] arr1 = new int[5];
 8         
 9         for (int i =0;i<arr1.length;i++){
10             
11             arr1[i]=(int)(Math.random()*100);
12         }
13         
14         System.out.println("一维数组各属性分别为：");
15         
16         for (int i =0;i<arr1.length;i++){
17             
18             System.out.println(arr1[i]);
19         }
20         
21         int arr[][]=new int[5][3];
22         
23         for (int i =0;i<arr.length;i++){
24             
25             for (int j =0;j<arr[i].length;j++){
26                 
27                 arr[i][j]=(int)(Math.random()*100);
28             }
29         }
30         
31         System.out.println("二维数组各属性分别为：");
32         
33         for (int i =0;i<arr.length;i++){
34             
35             for (int j =0;j<arr[i].length;j++){
36                 
37                 System.out.println(arr[i][j]);
38             }
39         }
40     }
41 }

附加题4

显示从100到1000之间所有能被5和6整除的数

 1 //显示从100到1000之间所有能被5和6整除的数
 2 
 3 public class XT1{
 4     
 5     public static void main(String args[]){
 6         
 7         for (int i =100;i<=1000;i++){
 8             
 9             if(i%5==0&&i%6==0){
10                 
11                 System.out.println(i);
12             }
13         }
14     }
15 }

附加题5

从控制台输入10个整数并按相反顺序输出显示

 1 //从控制台输入10个整数并按相反顺序输出显示
 2 
 3 import java.util.Scanner;
 4 
 5 public class XT2{
 6     
 7     public static void main(String args[]){
 8         
 9         int[] arr = new int[10];
10         
11         Scanner scan = new Scanner(System.in);
12         
13         for (int i=0;i<arr.length;i++){
14             
15             System.out.print("请输入第"+(i+1)+"个数：");
16             
17             arr[i]=scan.nextInt();
18         }
19         
20         for (int i=arr.length-1;i>=0;i--){
21             
22             System.out.println(arr[i]);
23         }
24     }
25 }

附加题6

posted @ 2018-03-11 14:09 THEMIE 阅读(1060) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

THEMIE

零基础学Java——小白的Java之路（3）

公告