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循环的执行流程
执行布尔表达式,如果是true
执行循环体中的程序
再次执行布尔表达式,如果还是true
再次执行循环体中的程序
再次执行布尔表达式,如果是false
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循环的执行流程
执行初始化的变量. (只会执行一次)
执行条件的判断 (判断条件是false,循环直接结束), 判断条件是true
进入到for的循环体执行
执行变量的自增
执行条件的判断 (判断条件是false,循环直接结束), 判断条件是true
执行循环体
执行变量的自增
执行条件的判断 (判断条件是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);
}
