java第三天/10.1

一、java 三大流程控制

1.顺序控制
依次执行我们的代码。
2.条件控制
int a = 0;
a. 目的 ： 对程序执行，一些不可预知的流程，进行一个预先判断.
b. 条件:
条件具有真假的特性。而且只可能为真，或者为假。
c. java条件控制有四种手段:
(1)if语句
结构:
if(条件){
//实现我们的逻辑
}
public class IfDemo{
public static void main(String[] args){
int a=5;
int b=10;
if(a==b){
System.out.println(b);
}
System.out.println(a);
}
}
(2)if…else语句
结构:

if(条件){
//实现我们的逻辑
}else{
//实现我们的逻辑
}
else后面之间跟我们的{//代码}
public class IfDemo{
public static void main(String[] args){
int a=5;
int b=10;
if(a==b){
System.out.println(b);
}else{
System.out.println(a);
}
}
}
3)if(条件)…else if(条件)…(接N个)…else

注意: a.else if(条件): 条件的约束，和我们前面说的if(条件)，俩者是等价的.
b.else if 可以有多个
c.else 可以省略掉的, 但是即使没有匹配所有条件，我们依然建议必须有else，来保证 语句的完整和可读性.
d.如果满足条件只需要执行一行代码，{}也是可以省略的，但是不建议这么做.
public class IfDemo{
public static void main(String[] args){
int score = 59;
if(score>=90){
System.out.println(“iphone X”);
}else if(score>70 && score < 90){
System.out.println(“ihpone 8”);
}else if(score>=60 && score <=70){
System.out.println(“xiao mi”);
}
}
}
注意：/*
条件:
a. 可以是一个表达式(
1.第一类表达式: 常量表达式 – 2*2,6-5
2.第二类表达式: 包含变量的表达式 – score > 90
)
b. boolean类型
表达式需要最终输出boolean类型
c. 尖括号:
可以省略,当我们在条件成立的时候，仅需要执行一行代码的时候，可以省略掉尖括号
虽然可以省略掉，但是按照规范性和可读性，我们始终都需要{}
建议: 虽然条件判断语句可以彼此嵌套，而且也没有嵌套层数的限制，但是过多的嵌套很影响可读性。
所以要避免过多的嵌套，一般最多建议嵌套3层。
*/
(4)switch case

结构:

switch(判断值){
case 值1:
break;
case 值2:
break;
…….
case 值n:
break;
default:
}
/*
注意:
1.switch 后面的 () 一定不能省略
2.switch 后面跟的是整形或者是字符型
实际上，对于char型来说，在这里也是先转换成ascII码，然后进行比较的
3.case 值, 只能是字面常量(1,2, ‘A’,’c’); 常量表达式( 2 * 3, ‘a’+3)
4.break; 跳出我们匹配到的条件。 break 可以省略的。
break可以跳出我们的switch代码块，如果省略掉switch. 那么代码将会在第一个匹配成功的条件，
一直向下继续执行我们的switch语句，直到遇到break为止.
5.default: 可以省略，而且default 可以放到任何的位置
default作用: 当匹配不到任何条件的时候，执行的内容.
*/
public class SwitchDemo{
public static void main(String[] args){
int turn = 10;
switch(turn){
default:
System.out.println(“100”);
break;
case 1:
case 2:
case 3:
System.out.println(“800”);
break;
case 4:
case 5:
System.out.println(“500”);
break;
default:
System.out.println(“100”);
break;
}
}
}
条件控制语句来说：
彼此可以嵌套使用的.

课堂练习:
定义一个变量，保存年龄。 并且当年龄大于60岁，我们输出老年. 当年龄在 40 到 60 之间，我们输出中年. 当年龄在
18 - 40之间，我们输出少年. 如果小于18岁，输出未成年.
public class Text{
public static void main(String[] args){
int age=20;
if(age>=60){
System.out.println(“老年”);
}else if(age>40 && score < 60){
System.out.println(“中年”);
}else if(age>=18 &&age<=40){
System.out.println(“少年”);
else{
System.out.println(“未成年”);
}
}
}
3.循环控制
a. while 循环
结构:
while(循环条件){
//循环实现的代码
}
/*
循环条件: 可以是一个变量，也可以是一个字面的常量; 可以是我们的表达式(常量表达式，包含变量的表达式)
类型: boolean

特点: 先判断后执行
*/

public class WhileDemo{
public static void main(String[] args){
int maxNum = 30;
int minNum = 11;
while(minNum<=maxNum){
System.out.println(minNum);
}
}
}
b. do .. while循环
结构:

do{
//实现的代码
}while(循环的条件);
//特点: 先执行后判断；不管条件是否成立，都会至少先执行一次do 中的代码
public class DoWhile{
public static void main(String[] args){
int maxNum = 30;
int minNum = 11;
do{
System.out.println(minNum);
minNum++;
}while(minNum<=maxNum);
}
}
c. for 循环
使用率最高的;

结构:
for(循环变量初始化 ;循环条件判断; 循环变量的改变){
//循环需要实现的逻辑
}
/*
首先for循环有三个部分组成:
a. 循环变量初始化
b. 循环条件判断
c. 循环变量的改变
这三个部分都可以省略，但是; 不可以省略
循环变量: 我们可以定义多个,对于循环变量的改变，我们也可以同时改变多组变量
执行流程:
a.循环变量初始化，这个在整个的循环过程中，只会执行一次
b.进行循环条件的判断，如果满足条件，则执行，否则结束循环
c.当循环条件满足之后，并且执行了我们循环中定义的代码，最后就会进行循环变量的改变。
*/
public class ForDemo{
public static void main(String[] args){
int minNum = 1;
final int MAX_NUM = 50;
int sum = 0;
for(int i=1;i<=MAX_NUM;i++){
if(i%2 == 0){
//1到50所有偶数之和
sum+=i;
}
System.out.println(sum);
}
}
}
/*
int i = 0;
for(;i<=MAX_NUM;){
if(i%2==1){
1到50之间所有奇数之和
sum+=i;
}
i++;
}
*/
for(int i = 0,num =0;i<100;i+=4,num++){
System.out.println(“i:”+i);
System.out.println(“num:”+num);
}
d. foreach 循环(不是一个常规的java提供的循环的方式，他只是java提供的一种语法糖)
foreach: 对一种循环方式的命名，常规循环的简化方式.
语法糖： 针对基本的语法，提供了一种简化的实现方式.

补充知识点:
俩个关键字: 应用到循环控制中，continue的含义是跳出当次的循环，break的含义是跳出整个循环

continue:
在循环的代码体中，如果遇到continue, 则会跳出当次循环，循环体内continue之后的代码都不会执行，并且循环变量进行一次改变操作，
之后再次进行条件判断，如果满足条件，则进入循环，否则直接结束循环; 跳出的仅是continue外层直接包裹的循环.

break:
在循环的代码体中，如果遇到break,则会跳出本循环代码块，break后的代码不会执行。并且整个循环的过程结束。
break后退出的循环也是直接包围break的循环。

循环的嵌套:
System.out.println(“*”); //输出，会默认换行
System.out.print(“*”); //输出，不会换行

/*
嵌套的层数没有限制，编译不会出错。但是建议最多嵌套2层
*/
public class StarOutPut{
public static void main(String[] args){
for(int j = 1;j<=5;j++){
for(int i =1;i<=j;i++){

System.out.print(“*”);
}
System.out.println(“”);
}
//—————————————-
System.out.println();
for(int j = 1;j<=5;j++){
for(int i =1;i<=(6-j);i++){

System.out.print(“*”);
}
System.out.println(“”);
}
}

二、数组初始

1、阶段性关键字总结:

public,class,static,void,int,boolean,char,byte,long,short,double,float,final.

new:
用来创建一个对象。

2、定义:

数组保存元素的类型 [] 数组变量的名称 = new 数组保存元素的类型[元素的数量];

数组元素的访问: index(数组保存元素的索引) , 从0开始(length-1)

数组来说，如果初始化一个数组，但是并没有保存任何的值，那么数组中会存放一些默认的值:
byte,short,int,long: 0
float，double:0.0
boolean: false
char: ”

数组对象中有一个变量length,能够让我们拿到数组的长度.
3、注意:
java.lang.ArrayIndexOutOfBoundsException:
数组越界的异常.
数组特性:
a. 长度一旦制定，长度就无法改变
b. 定义的时候指定的类型，那么数组始终只能保存该类型的元素

4、课堂练习:
定义一个保存5个整形的数组，依次赋值为 1–5.
最终再依次打印出数组保存的每个元素(要求打印的时候按照倒序)
public class Array{
publc static void main(String[] args){
int []arr=new int[5];
for(i=0;i<5;i++){
arr[i]=i+1;
}
for(int i=arr.length-1;i>=0;i–){
System.out.println(arr[i]);
}
}
}