选择结构
一、选择结构
①简单if选择结构
主要解决只有一种结果的问题,如果(条件),那么(结果),条件不管它是什么,算出来的结果一定是true/false。
若条件为真,则输出代码块,反之。
语法:if(条件){
//代码块
}
例如:
public class Test{
public static void main(String [] args){
int scores = 90;
if(scores > 85){
System.out.print("奖励一个Mp3"); //90>85成立,会输出代码块
}
}
}
②if-else结构
主要解决只有两种可能结果的问题
语法: if(条件){
//条件成立时语句
}else{
//条件不成立时语句
}
例如:
public class Test{
public static void main(String [] args){
int scores =80;
if(scores>90){
System.out.print("奖励一个Mp3");
}else{
System.out.print("惩罚进行编码!"); //80>90不成立,则输出else括号里的代码块
}
}
}
③多重if选择结构
主要解决有多种可能结果的问题,永远只执行其中一个分支。
语法: if(条件1){
//条件1成立时语句
}else if(条件2){
//条件2成立时语句
}else if(条件3){
//条件3成立时语句
}else{
//条件1,2,3都不成立时语句
}
注意:else块最多有一个或没有,else块必须要放在else if块之后!!
例如:
public class Test{
public static void main(String [] args){
int scores =85;
if(scores>98){
System.out.print("奖励一个Mp3");
}else if(scores>80){
System.out.print("奖励本子一个");
}else if(scores>60){
System.out.print("惩罚进行编码");
}else{
System.out.print("惩罚写检讨书");
}
}
}
因为85>98不成立,条件一不满足,但85>80成立,输出条件二下的代码块,即输出“奖励本子一个”,以下的代码不再执行,结束运行。
④嵌套if选择结构
在一个if-else结构中再嵌套一个if-else结构。
语法: if(条件一){
if(条件二){
//代码块1
}else{
//代码块2
}
}else{
//代码块3
}
注意:只有当满足外层if选择结构的条件时,才会判断内层if的条件!!
例如:
public class Test{
public static void main(String [] args){
int scores =98;
char sex ='女';
if(scores>90){
if(sex.equals('女')){
System.out.print("奖励少女心本子一个");
}else{
System.out.print("奖励英雄钢笔一支");
}
}else{
System.out.print("进行惩罚!!");
}
}
}
因为98>90,满足外层if的条件,则可以进入内层if,并且内层if的条件也满足,则可以输出"奖励少女心本子一个"
⑤switch选择结构
适用范围:在多分支结构下且是等值条件判断的情况下用switch更简便.
语法:
switch(值:int,char){
case 值1:
语句块1;
break;//中断,跳出switch
case 值2:
语句块2;
break;//中断,跳出switch
case 值3:
语句块3;
break;//中断,跳出switch
default:
其它语句;
break;//可省
}
注意:switch(“你好”){ } jdk6.0以下是错误,所以要使用String类型必须以Jdk1.7为前提。
1.switch里面的break和default是可以省略的,但会影响结果,switch中的case也可以打乱顺序;
2.当switch匹配到一个case分支,执行完相应语句之后没有遇到break,那么后面的语句要依次执行,遇到break就出来,没遇到就一直执行到最后出来;
3.case的值不可以重复;
4.多个case块可以执行同一语句。
例如:
import java.util.*;
Scanner input = new Scanner(System.in);
String str = input.next();
switch(str){
case "1":
case "2": //多个case块执行同一语句
System.out.print("敲代码");
break;
case "3":
case "4":
System.out.print("玩游戏");
break;
default:
System.out.print("睡觉");
break;
}
因为是从键盘输入的,所以当输入1和2时则会匹配相应的case块,然后输出case块里面的内容,又因为有break,则刹车跳出当前结构,以此类推;当输入的值既不是1和2也不是3和4,则会输出default里面的内容,default为“默认”,也可以省略 。
二、“==”和“equals”的区别:
”==“:判断值,还要比较栈里面保存的堆地址
“equals”:比较内容
equals的语法:变量名1.equals(变量名2)
变量名1和变量名2可以颠倒顺序。
三、逻辑运算符
运算符 | 汉语名称 | 表达式 | 说明 |
---|---|---|---|
&& | 短路与、并且 | 条件1&&条件2 | 两个条件必须同时为真,则结果才为真;两个条件有一个为假,则结果为假 |
|| | 短路或、或者 | 条件1||条件2 | 两个条件有一个为真,则结果为真;两个条件同时为假,则结果为假 |
! | 非 | !条件 | 条件为真,结果为假;条件为假,结果为真 |
短路:遇上&&,只要前面出现一个false,后面统统不执行
遇上||,只要前面出现一个true,后面也统统不执行
&:非短路逻辑与
| : 非短路的逻辑或
非短路:不管前面是什么样的结果后面统统会执行
例如:
int scores =90;
int num=103;
if(scores>90&&scores>100){
System.out.print("好好学习");
}else if(scores>90||scores>100){
System.out.print("天天向上");
}
因为if括号里面的是两个条件用“&&”表示的,所以两件必须同时满足,但是90>90不成立,所以不执行下面的代码块;那么进入else if,该两个条件是用“||”表示的,所以满足其中一个条件即可,103>100成立满足其中一个条件,那么输出“天天向上”。
循坏结构
一、循坏结构
1.什么是循坏?
循环就是重复做(相同)的或(相似)的事情;例如在操场上进行800米的赛跑,汽车的轮子等等。
2.循坏的三要素:
①循环条件判断 ( 跑多少圈停下来 )
②循环变量初始化 ( 记分牌要初始化 )
③循环体内要改变循环变量 ( 每跑一圈加1 )
3.循环的分类
a.确定次数的循环
b.不确定次数的循环
4.怎么写循坏?
第一步:打框架
while(){
}
第二步:找出三要素,放入对应位置
循环变量初始化; //通常以第一件事做参考
while(循环条件判断){ //通常以最后一件事做参考
//循环体
循环体内改变循环变量; //通常以相邻两件事之差做参考
}
第三步:写循环体
①如果是重复做相同的事情,只需把其中一件直接当循环体
②如果是重复做相似的事情,那么首先把其中一件事当循环体,然后
找出规律,把不同的部份用变量(循环变量)代替
例如:
int i =1; //初始化
while(i<=100){ //循坏条件判断
System.out.println("第"+i+"遍:好好学习,天天向上"); //循坏体
i++; //迭代体
}
二、三大循坏结构
1.while循坏结构(当型循坏)
语法:
//循环变量初始化;
while(循环条件判断){
//循环体
//循环体内改变循环变量;
}
//例子
int i =1;
while(i<=100){
System.out.println("天天向上");
i++;
}
执行顺序:先判断循坏条件是否满足,若第一次判断循坏条件就不满足,则会直接跳出循坏,循坏操作一次都不会执行。若满足则执行循坏操作,然后进行迭代部分,再次判断循坏条件,决定继续执行或退出循坏。
特点:先判断,后执行
2.do-while循坏(直到型循坏)
语法:
//循环变量初始化;
do{
//循环体
//循环体内改变循环变量;
}while(循环条件判断);
//例子
int i =1;
do{
System.out.println("我希望你快乐");
i++;
}while(i<=10);
注意:在do-while循坏中,while括号后面是分号,并不是大括号!!!
执行顺序:先执行一遍循坏体,再去判断循坏条件,若满足条件则循坏继续执行,否则退出循坏。
特点:先执行,后判断
3.while循坏和do-while循坏最大的区别:
do-while循坏结构不管在什么情况都至少执行一次;而while循坏若第一次不满足条件,则会退出循坏,什么也不会执行。
4.for循坏
语法:
for(循环变量初始化;循环条件判断;循环体内改循环变量){
//循环体
}
//例子
import java.util.*;
Scanner input =new Scanner(System.in);
int scores =0;
for(int i = 0;i<5;i++){
System.out.println("请输入第"+(i+1)+"门课的成绩:");
scores =input.nextInt();
}
注意:for后面的括号中的三个表达式必须用分号隔开,并且这三个表达式可以省略;
但是当省略表达式时,则需要在for语句前给循坏变量赋值。
执行顺序:先执行初始部分,再进行循坏条件判断,若满足判断结果,则执行循坏体;若不满足则退出循坏。再执行迭代部分,改变循坏变量值,然后再次进行循坏条件判断,直到退出for循坏结构。
注意:初始部分仅仅执行了一次!!
适用范围:对于循坏次数确定的情况下,使用for循坏结构。
死循环
1.定义:永远不会退出的循坏称为死循环
2.三种循坏的死循环表示:
①for( ; ; ){}
②while(true){}
③do{}while(true);
continue与break:
break:用在switch中,用来跳出switch;
用在循环中:结束(当前)循环,跳到当前循环之后执行
continue:结束本次循环,直接进入下一次循环
//例子
int sum =0;
for(int i = 0;i<10;i++){
if(i%2==0){
continue;
}
sum=sum+i; //进行累加
}
System.out.println("它们的和为:"+sum);
首先进入for循环结构,如果满足条件再进入if选择结构,如果i对2取余等于0,则说明i不是所需要的数,不进行累加,直接进入下一次循环。
//例子
for(int i =o;i<10;i++){
if(i%2!=0){
break;
}
System.out.println(i);
}
首先进入for循环结构,如果满足条件再进入if选择结构,如果i对2取余不等于0,则终止循坏。
数组
一、什么是数组?
数组就是在内存空间划出一串连续的空间,也是一种引用数据类型,存同种类型的大量数据。
二、数组的基本要素
①标识符(数组名称)
②数组元素
一些数组元素的初始值:
数据类型 | 初始值 |
---|---|
int | 0 |
double | 0.0 |
char | ‘\u0000’ |
boolean | false |
String |
③数组下标
注意:每个元素都有固定对应的一个下标,并且下标是从0开始的,最大下标数则为数组长度-1
因此数组下标的范围则为(0~数组长度-1)
数组长度:数组可容纳元素的最大数量
④元素类型
三、使用数组的步骤
1.声明数组
语法:数据类型 [ ] 数组名;
或者 数据类型 数组名 [ ];
例如:int [ ] scores;
或者int [ ] scores; //数组名遵循变量名的命名规则
2.分配空间
语法:数组名 =new 数据类型[数组长度];
注意:数组长度是固定的!!!
例如:scores =new int [31]; //存储30个学员成绩
3.赋值
①语法:数组名[下标值];
例如:scores[0] =89;
scores[1] =90;
scores[2] =80;
②语法:数据类型 [ ]数组名 ={值1,值2,值3,…,值n};
例如:int [ ]scores ={60,70,80,90,100};//创建一个长度为5的数组scores
或者int [ ]scores =new int [ ]{60,70,80,90,100};
4.对数据进行处理
四、数组的基本语法:
数据类型[ ] 数组名 = new 数据类型[长度];
数据类型[ ] 数组名 = new 数据类型[ ]{值};
数据类型 数组名[ ] = new 数据类型[ ]{值};
五、数组越界
定义:如果数组已经满但是继续向数组中存储数据的话,程序就会报错,称为数组越界
运行程序发现编译报错,控制台打出了“java.lang.ArrayIndexOutOfBoundsException”,意思就是数组下标超过范围,定义了一个数组长度为2,而却赋了三个值,超过长度定会报错!!
数组常见错误:①数组下标从零开始
②数组访问越界
六、数组应用
1.数组排序
语法:Arrays.sort(数组名);
说明:Arrays是Java中提供的一个类,而sort()是该类的一个方法。
例如 :
import java.util.Arrays;//排序包
int [] num =new int []{80,98,60,77,90}
Arrays.sort(num);
System.out.println("按升序排列:");
for(int i =0;i<num.length;i++){
System.out.println(num[i]+" ");
}
System.out.print("\n降序输出为:");
for (int j =num.length-1; j >=0; j--) {
System.out.print(num[j]+"\t");
}
2.数组求最大小值
Scanner input =new Scanner(System.in);
int [] money=new int[]{60,70,80,90,100};
//求最小值
int min =0;
min=money[0];
for (int i = 0; i < money.length; i++) {
if(money[i]<min){
min=money[i];
}
}
//求最大值
int max =0;
max=money[0];
for (int i = 0; i < money.length; i++) {
if(money[i]>max){
max=money[i];
}
}
System.out.println("最小值是:"+min);
System.out.println("最大值是:"+max);
3.插入元素(难点)
(我也不怎么会,不好意思!)
循坏进阶
一、二重循环结构
1.定义:一个循坏体内又包含另一个完整的循坏结构
2.语法://while与while嵌套
while(循坏条件1){
//循坏操作1;
while(循坏条件2){
//循坏操作2;
}
}
//for与for循坏嵌套
for(循坏条件1){
//循坏操作1;
for(循坏条件2){
//循坏操作2;
}
}
//while与for循坏嵌套
while(循坏条件1){
//循坏操作1;
for(循坏条件2){
//循坏操作2;
}
}
//do-while与do-while循坏嵌套
do{
//循坏操作1
do{
//循坏操作2
}while(循坏条件2);
}while(循坏条件1);
二、应用(打印图形)
注意:外层循坏控制行数!!!
//打印等腰三角形
Scanner input =new Scanner(System.in);
System.out.println("请输入等腰三角形的行数:");
int hang =input.nextInt();
for (int i = 1; i <=hang; i++) { //外层循坏控制行数
for (int j = 1; j <=hang-i; j++) {
System.out.print(" "); //控制空格
}
for (int j2 = 1; j2 <=2*i-1; j2++) {
System.out.print("*"); //控制星星数
}
System.out.print("\n"); //换行
打印九九乘法表
三、continue和break
注意:continue和break在二重循坏中的用法与在循坏中的用法一致!!!而且只会影响内层循坏的执行,对外层循坏没有影响,continue语句是跳出本次循坏,进入下一次循坏,而break是跳出本层循坏