2.程序流程控制+Random类+数组

小鱿鱼G

已于 2022-03-09 22:16:23 修改

阅读量179

点赞数

文章标签： java

于 2021-05-03 11:56:28 首次发布

本文链接：https://blog.csdn.net/weixin_53280964/article/details/116372161

版权

1.顺序结构

开始→步骤A→步骤B→步骤C→结束

流程图

// 顺序结构
public class Demo015Sequence {
	public static void main(String[] args) {
		System.out.println("今天天气不错");
		System.out.println("挺风和日丽的");
		System.out.println("我们下午没课");
		System.out.println("这的确挺爽的");
	}

}

2.判断语句（选择结构/语句）

2.1 判断语句——if语句

2.1.1 单if语句

格式

if(关系表达式) {
      语句体;
}

执行流程

首先判断关系表达式看其结果是ture还是false
如果是ture就执行语句体
如果是false就执行语句体

流程图

public class Demo021f {
	public static void main(String[] args) {
		System.out.println("今天天气不错，正在压马路...突然发现一个网吧");
		int age = 18;
		if ( age>= 18) {
			System.out.println("进了网吧开始嗨");
			System.out.println("遇到一群猪队友，开始骂街");
			System.out.println("感觉不爽，结账走人");
		}
		System.out.println("回家吃饭");
	}

}

2.1.2. 标准if...else语句

格式

if(关系表达式) {
     语句体1;
}else {
     语句体2;
}

执行流程

首先判断关系表达式看其结果是ture还是false
如果是ture就执行语句体1
如果是false就执行语句体2

流程图

public class Domo03IfElse {
	public static void main(String[] args) {
		//判断给定的数据是奇数还是偶数
		//定义变量
		int a = 1;
		if(a % 2 == 0) {
			System.out.println("a是偶数");
		}else {
			System.out.println("a是奇数");
		}
		System.out.println("结束");
	}

}

2.1.3. 扩展if...else if...else语句

格式

if(判断条件1) {
   执行语句1;
} else if (判断条件2) {
   执行语句2;
}
...
} else if (判断条件n) {
   执行语句n;
} else {
   执行语句n+1;
}

执行流程

首先判断关系表达式1看其结果是ture还是false
如果是ture就执行语句体1
如果是false就继续判断关系表达式2看其结果是ture还是false
如果是ture就执行语句体2
如果是false就继续判断关系表达式...看其结果是ture还是false
...

流程图

public class Demo04IfElse {
	public static void main(String[] args) {
		//x和y的关系满足如下：
		//如果x > = 3，那么 y = 2x + 1；
		//如果-1 < x < 3，那么 y = 2x；
		//如果x < =-1，那么 y = 2x - 1；
		//根据给定的x的值，计算出y的值并输出
		//定义变量
		int x = 5;
		int y;
		if (x >= 3) {
			y = 2* x + 1;
		}else if (x> -1&&x<3) {
			y = 2* x;
		}else {
			y = 2* x - 1;
		}
		System.out.println("y的值是： "+y);
	}

}

2.1.4 案例：指定考试成绩，判断成绩的等级

要求：

90-100 优秀
80-89 好
70-79 良
60-69 及格
60以下不及格

public class Zuoye01 {
	public static void main(String[] args) {
		int score = 100;
		if (score<0 || score>100) {
			System.out.println("你的成绩是错误的");
		}else if (score>=90 -1&& score<= 100) {
			System.out.println("你的成绩属于优秀");
		}else if (score>=80 -1&& score< 90) {
			System.out.println("你的成绩属于好");
		}else if (score>=70 -1&& score< 80) {
			System.out.println("你的成绩属于良");
		}else if (score>=60 -1&& score< 70) {
			System.out.println("你的成绩属于及格");
		}else {
			System.out.println("你的成绩属于不及格");
		}
	}

}

2.1.5 案例：使用三元运算符和标准的if...else语句分别实现：取两个数字当中的最大值

public class ZuoYe02Max {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		// 首先使用三元运算符
		//int max = a > b ? a : b;
		// if语句
		int max ;
		if (a > b) {
			max = a;
		} else {
			max = b;
		}
		System.out.println("最大值是： "+max);
	}

}

2.2 选择语句——switch语句

2.2.1 格式

switch(表达式) {
  case 常量值1：
     语句体1;
     break;
  case 常量值2：
     语句体2;
     break;
...
  default:
     语句体n+1;
     break;
}

2.2.2 执行流程

首先计算出表达式的值
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行过程中，遇到break就结束
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束

2.2.3 流程图

public class Demo05Switch {
	public static void main(String[] args) {
		int num = 1;
		switch (num) {
		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;
		}
	}

}

2.2.4注意事项

多个case后面的数值不能重复
switch后面小括号当中只能是以下数据类型：☝基本数据类型：byte/short/char/int ☝引用数据类型： String字符串，enum枚举
switch语句格式可以很灵活，前后顺序可以颠倒，而且break语句可以省略

3.循环结构

3.1循环结构的基本组成

初始化语句：在循环开始最初执行，而且只做唯一一次
条件判断：如果成立，则循环继续；如果不成立，则循环退出
循环体：重复要做的事情内容，若干行语句
步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次

3.2循环语句1——for

3.2.1语句格式

for(初始化表达式①;布尔表达式②;步进表达式④) {
        循环体③
}

3.2.2执行流程

执行顺序：①②③④＞②③④＞②③④...②不满足为止
①负责完成循环变量初始化
②负责判断是否满足循环条件，不满足则跳出循环
③具体执行的语句
④循环后，循环条件所涉及变量的变化情况

3.2.3流程图

3.3循环语句2——while

3.3.1 标准格式

#标准格式
while (条件判断) {
     循环体
}

3.3.2 扩展格式

#扩展格式
初始化语句;
   while  (条件判断②) {
     循环体③;
     步进语句④;
}

3.3.3 执行流程

执行顺序：①②③④＞②③④＞②③④...②不满足为止
①负责完成循环变量初始化
②负责判断是否满足循环条件，不满足则跳出循环
③具体执行的语句
④循环后，循环条件所涉及变量的变化情况

3.4循环语句3——do...while

3.4.1循环格式

初始化表达式①
     do{
     循环体②
     步进表达式③
}while(布尔表达式④);

3.4.2执行流程

执行顺序：①②③④＞②③④＞②③④...②不满足为止
①负责完成循环变量初始化
②负责判断是否满足循环条件，不满足则跳出循环
③具体执行的语句
④循环后，循环条件所涉及变量的变化情况

3.4.3流程图

3.5案例：求1-100之间的偶数和

public class Demo01Anli {
	public static void main(String[] args) {
		int sum = 0;
		for (int i = 1;i<=100;i++) {
			if(i%2==0) {
				sum+=i;
			}
		}
		System.out.println("结果是："+sum);
	}

}

3.6三种循环的区别

如果条件判断从来没有满足过，那么 for循环和while 循环将会执行0次，但是do-while循环会执行至少一次。
for循环的变量在小括号当中定义，只有在循环内部才可以使用。while 循环和while循环初始化语句本来就在外边，所以在循环之外还可以继续使用。

4.条件控制语句

4.1break语句

4.1.1常见的用法

可以用在switch语句当中，一旦执行，整个switch语句立刻结束
可以用在循环语句当中，一旦执行，整个循环语句立刻结束。打断循环

public class Demo01Anli {
	public static void main(String[] args) {
		for (int i = 1;i<=10;i++) {
			if(i==4) {
				break;
			}
			System.out.println("hello"+ i);
		}
	}

}

4.1.2关于循环的选择

凡是次数确定的场景多用for循环，否则多用while 循环

4.2continue语句

另一种循环控制语句是continue关键字。

一旦执行，立即跳过当前次循环剩余内容，马上开始下次循环

public class Demo01Anli {
	public static void main(String[] args) {
		for (int i = 1;i<=10;i++) {
			if(i==4) {
				continue;
			}
			System.out.println(i+"层到了");
		}
	}

}

5.死循环

5.1概述

永远停不下来的循环

5.2标准格式

while (true) {
    循环体
}

6.循环嵌套

6.1概述

指一个循环的循环体是另一个循环。总循环次数=外循环次数*内循环次数

6.2格式

for(初始化表达式①；循环条件②;步进表达式⑦) {
    for(初始化表达式③；循环条件④;步进表达式⑥) {
        执行语句⑤;
}

6.3执行流程

执行顺序：①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥
外循环一次，内循环多次
比如跳绳：一共五组，每组跳10个。5组就是外循环，10个是内循环

6.4练习：使用循环嵌套，打印5*8矩形

	public static void main(String[] args) {
		//打印5行*号，每行8个
		//外循环5次，内循环8次
			for (int j = 0;j<=5;j++) {
				for (int k = 0;k<=8;k++) {
					//不换行打印*
					System.out.print("*");	
				}
				//内循环打印8个*后，需要一次换行
				System.out.println();
			}
	}

7.数组

7.1概念

一种容器，可以同时存放多个数据值

7.2.特点

数组是一种引用数据类型
数组当中的多个数据，类型必须统一
数组的长度在程序运行期间不可改变

7.3.数组的初始化

在内存中创建一个数组，并且向其中赋予一些默认值

7.3.1动态初始化（指定长度）

在创建数组的时候，直接指定数组当中的数据元素个数

7.3.2格式

数据类型[] 数组名称 = new 数据类型[数组长度];

解析：

左侧数据类型：数组当中保存的数据，全部是统一的数据类型
左侧的中括号：代表我是一个数组
左侧数组名称：给数组取一个名字
右侧的 new ：代表创建数组的动作
右侧数据类型：必须和左边的数据类型保持一致
右侧中括号的长度：数组中，可以保存多少个数据，是一个int数字

7.3.3静态初始化（指定内容）

在创建数组的时候，不直接指定数组当中的数据元素个数多少，而是直接将具体的数据内容进行指定

7.3.4基本格式

数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，...};

7.3.5省略格式

数据类型[] 数组名称 =  {元素1，元素2，...};

7.3.6注意事项

虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出长度
静态初始化标准格式可以拆分成两个步骤

int[] arrayA;
arrayA = new int[] {11,21,31};

动态初始化也可以拆分成两个步骤

int[] arrayB;
arrayB = new int[3];

静态初始化一旦使用省略格式，就不能拆分成两个步骤
如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化

7.4访问数组元素进行获取

直接打印数据名称，得到的是数组对应的内存地址哈希值

7.4.1访问数据元素的格式

数据名称[索引值]

索引值：一个int数字，代表数组当中元素的编号

【注意】索引值从0开始，一直到“数组长度-1”为止

7.5访问数组元素进行赋值

使用动态初始化数组时，其中的元素将会自动拥有一个默认值，规则如下：

如果是整数类型，那么默认为0
如果是浮点类型，那么默认为0.0
如果是字符类型，那么默认为‘\u0000'
如果是布尔类型，那么默认为false
如果是引用类型，那么默认为null

【注意事项】：静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成了大括号中的具体数值

8.Java中的内存划分

8.1.分类

Java的内存需要划分为5个部分：

8.1.1栈（Stack）

存放的都是方法中的局部变量。方法的运行一定在栈当中

局部变量：方法的参数，或者是方法（）内部的变量
作用域：一旦超出作用域，立刻从栈内存中消失

8.1.2堆（Heap）

凡是new出来的东西，都在堆当中。堆内存里面的东西都有一个地址值：16进制。堆内存里面的数据，都有默认值，规则：

如果是整数类型，那么默认为0
如果是浮点类型，那么默认为0.0
如果是字符类型，那么默认为‘\u0000'
如果是布尔类型，那么默认为false
如果是引用类型，那么默认为null

8.1.3方法区（Method Area)

存储.class相关信息，包含方法的信息

8.1.4本地方法栈（Native Method Stack)

与操作系统相关

8.1.5寄存器（pc Register)

与CPU相关

8.2一个数组的内存图

8.3两个数组的内存图

8.4两个引用指向同一个数组的内存图

9.常见的问题

9.1数组索引越界异常

索引值从0开始，一直到“数组长度-1”为止

如果访问数组元素的时候，索引编号并不存在，那么将会发生数组索引越界异常（ArrayIndexOfBoundsException）

原因：索引编号出错

解决：修改成为正确的索引编号

9.2空指针异常

所有的引用类型变量，都可以赋值为一个null值，但是代表其中什么都没有

数组必须new初始化才能使用其中的元素，如果只是赋值了一个null，没有进行new的创建，那么将会发生空指针异常（NullPointerException）

原因：忘了new

解决：补上new

10.获取数组的长度

10.1格式

数组名称.length

得到一个int数字，代表数组的长度

10.2注意

数组一旦创建，程序运行期间，长度不可改变

int [ ] arrayC = new int[3];
System.out.println(arrayC.length);//3
arrayC = new int[5];
System.out.println(arrayC.length);//5

案例一：数组的遍历输出

/*
 遍历数组：对数组当中的每一个元素进行逐一处理。默认处理方式就是打印输出
 */
public class Array {
	public static void mian(String[] args) {
		int[] array = {15,25,30,40,50 };
		// 首先使用原始方式
		System.out.println(array[0]);
		System.out.println(array[1]);
		System.out.println(array[2]);
		System.out.println(array[3]);
		System.out.println(array[4]);
		//使用循环,次数是数组的长度
		for (int i = 0;i < 5;i++) {
			System.out.println(array[i]);
		}
		int len = array.length;//长度
		for (int i = 0;i < len;i++) {
			System.out.println(array[i]);
		}
	}

}

案例二：求出数组中的最值

public class ArrayMax {
	public static void mian(String[] args) {
		int[] array = {5,15,30,10000};
		int max = array[0];
		for(int i = 0;i < array.length;i++) {
			//如果当前元素比max更大，则换人
			if (array[i] > max) {
				max = array[i];
			}
		}
		System.out.println("最大值："+ max);
		int min = array[0];
		for(int i = 0;i < array.length;i++) {
			//如果当前元素比max更小，则换人
			if (array[i] < min) {
				min = array[i];
			}
		}
		System.out.println("最小值："+ min);
	}

}

案例三：数组元素反转

数组元素反转，其实就是对称位置的元素交换
通常遍历数组用的是一个索引：int i = 0;现在表示对称位置需要两个索引：int min = 0;int max = array.length-1;
如何交换两个变量的值：

int a =10;
int b =20;
int temp = a;
a=b;
b=temp;

4.什么时候停止交换

min==max
min>max

public class ArrayRevese {
	public static void mian(String[] args) {
		int[] array = {5,15,30,4o,50};
		//遍历打印数字原来的样子
		for(int i = 0;i < array.length;i++) {
	        System.out.println(array[i]);
		}
		/*
        初始化语句：int min = 0, max = array.length-1
        条件判断：min < max
        步进表达式：min++ ,max--
        循环体：用第三个变量倒手
        */
		for(int min = 0, max = array.length-1;min < max;min++ ,max--) {
			int temp = array[min];
            array[min]=array[max];
            array[max]=temp;
		}
		//再次打印遍历输出数组后的样子
        for(int i = 0;i < array.length;i++) {
	        System.out.println(array[i]);
	}

}

11.数组作为方法参数——传递地址

数组可以作为方法的参数，当调用方法的时候，向方法的小括号进行传参，传递进去的是数组的地址值

public static void mian(String[] args) {
		int[] array = {5,15,30,40,50};
		 printArray(array);
}
public static void printArray(int[] array) {
         for(int i = 0;i < array.length;i++) {
	        System.out.println(array[i]);
		}
}

12.数组作为方法返回值——返回地址

一个方法可以有0,1，多个参数，但只能有0或1个返回值。

一个方法中产生多个数据进行返回时，使用一个数组作为返回值类型

数组作为方法的参数，传递的是数组的地址值

数组作为方法的返回值，返回的是数组的地址值

public static void mian(String[] args) {
       int[] result = calculate(10,20,30);
       System.out.println("总和："+result[0]);
        System.out.println("平均值："+result[1]);
}
public static int[] calculate(inta,int b, int c) {
         int sum = a+b+c;
         int avg = sum/3;
          int[] array = {sum,avg}
          return array;
	       
		
}

小鱿鱼G

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
2.程序流程控制+Random类+数组

1.顺序结构开始→步骤A→步骤B→步骤C→结束流程图// 顺序结构public class Demo015Sequence { public static void main(String[] args) { System.out.println("今天天气不错"); System.out.println("挺风和日丽的"); System.out.println("我们下午没课"); System.out.println("这的确挺爽的"); }}2.判断语
复制链接

扫一扫