Java基础语法

流程控制语句

if…else if…else if…else

多分支语法格式:

 if(条件判断){
 
 } else if(条件判断){
 
 } else if(条件判断){
 
 }  else {
     
 }

适合与多条件的判断,但是 if else过多,会导致程序的阅读性下降

优势 : 高效的优势,只要有一个if的条件判断结果是true,整体的语句结构就结束了

public static void main(String[] args) {
    int i = 99;
    //if else if的多分支
    if(i < 100) {
        System.out.println("第一个if的条件是true");
    }else if(i > 100){
        System.out.println("第二个if的条件是true");
    }else if (i == 100) {
        System.out.println("第三个if的条件是true");
    }else {
        System.out.println("所有的条件都是false");
    }
}

多分支语句的练习

需求 : 请你输入你的考试成绩,对成绩进行等级划分

90-100 : 优

80-89 : 良

70-79 : 中

60-69 : 差

<60 : 不及格

switch选择语句

程序也是进行选择的, switch语句中包含的关键字比较多

switch case default break

switch语句的格式 :

 switch (变量){
     case 常量1 :
         要执行的语句1;
         break;
     case 常量2 :
         要执行的语句2;
         break;
     case 常量3 :
         要执行的语句3;
         break;
     default:
         要执行的语句;
         break;
 }

语句流程详细解释
- switch中的变量,和case后面的常量,进行比较 (是否相同)
- 如果和常量1相等,执行 : 语句1, 执行break,整体switch结束
- 如果和常量2相等,执行 : 语句2, 执行break,整体switch结束
- switch中的变量,和任何一个case后面的常量都不相等,执行default后面的语句, 执行break,整体switch结束

switch语句中的变量的数据类型有限制

byte short int char (JDK1.0-1.4)
添加数据类型 enum 枚举 (JDK1.5)
添加数据类型字符串 (JDK1.7)
使用的是JDK1.8 (支持的类型 byte short int char 枚举字符串)

public static void main(String[] args) {
		int i = 5;
		switch (i) {
		case 1:
			System.out.println("case1");
			break;
			
		case 2:
			System.out.println("case2");
			break;
			
		case 3:
			System.out.println("case3");
			break;

		default:
			System.out.println("所有case都不相等");
			break;
		}
	}

选择语句的练习

需求 : 根据输入的月份,判断是哪个季节

春季 : 3,4,5 夏季 : 6,7,8 秋季 : 9 ,10 ,11 冬季 12 , 1, 2

采用if和switch分别完成

		if(month < 1 || month > 12) {
			System.out.println("输入的月份不存在");
		}
		//季节判断  春季 : 3,4,5
		else if(month >=3  && month <=5) {
			System.out.println("春季");
		}
		//季节判断  夏季 : 6,7,8 
		else if (month >= 6 && month <=8 ) {
			System.out.println("夏季");
		}
		//季节判断  秋季 : 9 ,10 ,11
		else if (month >= 9 && month <= 11) {
			System.out.println("秋季");
		}
		//季节判断  冬季 12 , 1, 2
		else {
			System.out.println("冬季");
		}

case穿透特性

在switch的语句中,不写break,出现case的穿透性

 switch (变量){
     case 常量1 :
         要执行的语句1;
        // break;
     case 常量2 :
         要执行的语句2;
        // break;
     case 常量3 :
         要执行的语句3;
        // break;
     default:
         要执行的语句;
       //  break;
 }

在这里插入图片描述

case穿透特性实现季节判断

public static void main(String[] args) {
    //键盘输入,接收月份
    Scanner sc = new Scanner(System.in);
    int month = sc.nextInt(); // 4
    //利用case穿透特性
    switch(month) {
        case 3:
        case 4:
        case 5:
            System.out.println("春季");
            break;
        case 6:
        case 7:
        case 8:
            System.out.println("夏季");
            break;
        case 9:
        case 10:
        case 11:
            System.out.println("秋季");
            break;

        case 1:
        case 2:
        case 12:   
            System.out.println("冬季");
            break;
            
        default:
            System.out.println("月份不存在");
    }
}

循环语句

循环 : 程序中的语句(代码)多次的反复的执行

使用的频率非常的高

输出10次 “HelloWorld”

System.out.println("HelloWorld"); 语句复制10次,不行

while循环

语法格式 :

while(布尔类型的表达式){
  //while的循环体
}

while循环的执行流程
1. 执行布尔表达式,如果是true
2. 执行循环体中的程序
3. 再次执行布尔表达式,如果还是true
4. 再次执行循环体中的程序
5. 再次执行布尔表达式,如果是false
6. while循环就结束了
结论: 只要while中的布尔表达式结果是true,就执行循环体,直到布尔类型为false,循环结束

public static void main(String[] args) {
		int i = 1;
		while(i < 10) {
			System.out.println("while的循环体 "+i);
			//变量i 发生变化 ++
			i++;
		}
		//打印10次HelloWorld
		//j变化到10的时候,循环结束
		int j = 0;
		while(j < 10) {
			System.out.println("HelloWorld");
			j++;
		}
	}

while循环练习

输出10以内的所有偶数

public static void main(String[] args) {
    //定义变量,默认值是0, 变化到10
    int i = 0; 
    while(i <= 10) {
        //判断是不是偶数
        if(i % 2 == 0) {
            System.out.println(i + "是偶数");
        }
        i++;
    }
}

public static void main(String[] args) {
	//定义变量,默认值是0, 变化到10
	int i = 0;
	//变量i在循环的时候,每次+2行不?  不需要判断了
	while(i <= 10) {
		System.out.println(i + "是偶数");
		//i=i+2;
		i+=2;
	}
}

for循环

语法格式 :

for (初始化变量 ; 条件 ; 增量){
    //for的循环主体
}

循环的三个部分解释
- 初始化变量 : 定义变量数据类型变量名 = 值
- 条件 : 条件必须是布尔类型结果 true 或者 false
- 增量 : 循环变量的变化
- 条件 : 控制循环是否执行,条件是true,循环,条件是false结束循环
```
public static void main(String[] args) {
    for(int i = 0 ; i < 5 ; i++) {
        System.out.println("这里是for循环的循环体  "+i);
    }
}
```
for循环的执行流程
1. 执行初始化的变量. (只会执行一次)
2. 执行条件的判断 (判断条件是false,循环直接结束), 判断条件是true
3. 进入到for的循环体执行
4. 执行变量的自增
5. 执行条件的判断 (判断条件是false,循环直接结束), 判断条件是true
6. 执行循环体
7. 执行变量的自增
8. 执行条件的判断 (判断条件是false,循环直接结束)

for循环实现练习

for循环实现0-10之间的偶数

public static void main(String[] args) {
    //利用for循环中的变量
    for(int i = 0 ; i <= 10 ;i+=2) {
    	System.out.println(i +"是偶数");
    }
}

for实现求和计算 1 + 2 + 3 +…+ 100 = 5050 (高斯算法)

public static void main(String[] args) {
    //定义变量int类型,保存求和后的结果
    int sum = 0;
    //进行1-100之间的循环
    for(int i = 1 ; i <= 100 ;i++) {
        //求和计算, sum变量保存求和后的结果
        sum = sum + i; 
    }
    System.out.println(sum);
}

do…while

格式 :

 do{
 	//循环主体
 }while(条件判断);

循环执行流程
- 判断while中的循环条件
- 如果条件是true,执行循环体
- 如果条件是false,结束循环
注意
: do … while 无条件先执行一次循环体

break和continue

break : 终止作用就是终止循环, 在循环中遇到break,循环就结束,只能在循环中或者switch出现

public static void main(String[] args) {
    int i = 0;
    while(true) {
    i++;
    //判断变量的值,如果=10,执行break终止循环
    if(i == 10) {
    	break;
    	}
    }

    for( ; ;) {
    	break;
    }
}

continue : 终止本次循环,开始下一次循环

public static void main(String[] args) {
    for(int i = 0 ; i <=10 ;i++) {
    //判断,如果变量是偶数,执行下一次循环
    	if(i % 2 == 0) {
   	 		continue;
   		 }
   		 System.out.println(i);
    }
}

嵌套循环

引出 : 上体育课迟到20分钟,处罚

操场跑圈 : 跑5圈, 再跑5圈, 再跑5圈, 再跑5圈

跑了4组,每组跑了5圈, 一共跑了多少圈 20 组数*每组圈数

理解 : 第一组5圈… 我的第一次循环 5圈我的第二次循环 5圈 (围绕操场循环了5次)

一次大的循环,包含5次小的循环 : 程序嵌套循环, 总的循环次数 = 大循环次数*小循环次数

嵌套for

两个for循环在一起,形成嵌套形式, 双循环

一个for是另一个for的循环体

格式 :

 for(初始化变量 ; 条件 ; 增量){  //外循环
     for(初始化变量 ; 条件 ; 增量){ //内循环
     }
 }
//内循环是外键循环的循环体

public static void main(String[] args) {
    //外循环,循环5次
    for(int i = 0 ; i < 5 ;i++) {
        //内循环,循环3次
        for(int j = 0; j < 3 ; j++) {
            System.out.println("内循环");
        }
        System.out.println("外循环");
    }
}

在这里插入图片描述

嵌套for循环练习

外循环一次,内循环多次
结论 : 外循环控制行数 ,内循环控制每行的个数

public static void main(String[] args) {
		//外循环5次
		for(int i = 0 ; i < 5 ;i++) {
			//内循环5次
			for(int j = 0 ; j < 5 ;j++) {
				//内循环输出星号
				System.out.print("*");
			}
			//外循环输出空的换行
			System.out.println();
		}
	}

尖向下的直角三角形

public static void main(String[] args) {
		// 有几个行 5行 外循环5次
		for(int i = 0 ; i < 5; i++) {
			/*
			 *  每个行有几个星号 第一行是5个,逐行递减
			 *  变量j 0 1 2 3 4 
			 *  
			 *  外循环第一行的时候,内循环5个
			 *  外循环第二行的时候,内循环4个
			 *  j变化 : 每次执行内循环的时候,变量j的初始化都+1
			 *  
			 *  外循环的i 变量  0 1 2 3 4
			 */
			for(int j = i ; j < 5 ;j++) {
				System.out.print("*");
			}
			System.out.println();
		}
	}

尖向上的直角三角形

public static void main(String[] args) {
		// 有几个行 5行 外循环5次
		for(int i = 0 ; i < 5 ;i++) {
			/*
			 * 内循环 : 循环次数不固定  每行递增效果
			 * 第一行 : 内循环1次
			 * 第二行 : 内循环2次
			 * 内循环的变量 j
			 * 
			 *   第一行 : 内循环1次  j<1
			 *   第二行 : 内循环1次  j<2
			 *   内 : 变量j每次都从0开始,但是条件在改变
			 */
			for(int j = 0 ; j <= i ;j++) {
				System.out.print("*");
			}
			System.out.println();
		}
	}

乘法表

public static void main(String[] args) {
		//i  1-9
		for(int i = 1 ; i <= 9 ;i++) {
			// 第一次循环1 ,第二次循环 1 2  
			for(int j = 1; j<=i ;j++) {
				/*
				 *  替换为乘法计算即可
				 */
				System.out.print(j+"*"+i+"="+j*i+"\t");
			}
			System.out.println();
		}
	}

数组(Array)

概述 : 数组是一种容器,容器就是存储数据的,数组可以同时存储多个数据的容器.

比如 : 班级里面有100个同学,100个名字,定义变量的方式 ,需要定义出100个变量,存储名字

更好的解决办法 : 100个名字全部存储在一个容器中,方便管理这些个数据

凡是数据多了,存储在数组容器中.

Java数组 : 只能存储同一个数据类型的数据

数组的定义

定义数组的格式1:
- 数据类型,定义的数组容器存储的数据的类型 int 这个数组就只能存储整数
- [] 就表示数组
- 数组的名字, 理解为就是一个变量的名字 (标识符,驼峰命名)
- new 创建数组容器的关键字
- 数据类型,定义的数组容器存储的数据的类型 int 这个数组就只能存储整数
- 整数值, 表示的是数组的长度, 就是容量,也就数组能存储多少个数据
```
 数据类型[] 数组的名字 = new 数据类型[整数值];
 int[] arr = new int[3];
```
JVM内存划分

在这里插入图片描述

数组内存

在这里插入图片描述

栈内存和堆内存区别
- 栈内存,使用完毕就释放,效率高
- 堆内存,等待JVM垃圾回收,效率低
- 栈内存中的变量,必须赋值,否则不能使用
- 堆内存的数据,必须有默认值
- 栈内存,方法运行的时候计算
- 堆内存,负责存储对象和数组

数组的访问

操作数组中的数据了, 存储到数组中的任何数据,都称为数组的元素(Element)

数组元素的访问,依靠数组的索引 (index) (下标)

数组的索引
- 每个数组都有自己的索引
- 索引是从0开始的
- 索引是数组的特性,天生就有, 本质上就是数组中每个元素的编号
数组访问的语法:
- 数组名[索引]

public static void main(String[] args) {
		//定义存储int类型的数组,数组的长度是3
		int[] arr = new int[3];
		
		//输出,数组0索引上的元素
		System.out.println(arr[0]);
		
		//输出,数组1索引上的元素
		System.out.println(arr[1]);
				
		//输出,数组2索引上的元素
		System.out.println(arr[2]);
		
		//数组0索引上的元素,赋值
		arr[0] = 5;
		System.out.println(arr[0]);
	}

数组的长度

Java中的数组是定长的, 数组的长度,也就是存储元素的个数,一旦创建完毕,不可改变

定长也是数组的一个弊端

对于数组 : JVM赋予数组一个属性 (属性 : 属于这个事务的特性)

属性的名字 length, 表示数组的长度 (int类型)

使用方法 : 数组名.length

 public static void main(String[] args) {
		//定义数组,存储的类型是int类型,长度5
		 int[] arr = new int[5];
		 //使用数组的长度属性 length
		 //int l = arr.length;
		 System.out.println(arr.length);		 
	}

数组长度length属性, 数组的最大索引,是长度-1 arr.length-1

数组的定义

定义格式2 : 定义数组的同时直接存储元素

{}可以直接写入数组的元素值

数据类型[] 数组的名字 = new 数据类型[]{元素1,元素2,元素3};

public static void main(String[] args) {
    int[] arr = new int[] {1,2,3,4,5,6,7};
    System.out.println(arr);

    //输出5, 在4索引的位置
    System.out.println(arr[4]);

    //数组的长度length属性
    System.out.println(arr.length);
}

定义格式3:

数据类型[] 数组的名字 = {元素1,元素2,元素3};

	public static void main(String[] args) {
		int[] arr = {1,2,3,4,5,6,7,8,9,0};
		System.out.println(arr[7]);
		System.out.println(arr.length);
	}

原文链接：https://blog.csdn.net/zxy467243465/article/details/107500101

Java基础语法

流程控制语句

if…else if…else if…else

多分支语句的练习

switch选择语句

选择语句的练习

case穿透特性

case穿透特性实现季节判断

循环语句

while循环

while循环练习

for循环

for循环实现练习

do…while

break和continue

嵌套循环

嵌套for

嵌套for循环练习

数组(Array)

数组的定义

数组内存

数组的访问

数组的长度

数组的定义

你可能也喜欢