一、顺序结构

代码从上到下依次执行

二、选择结构

也叫分支结构
选择结构会根据执行的结果选择不同的代码执行

两种形式:

if语句
switch语句

1. if语句
a. if语句的第一种形式

if(关系表达式){
语句体;
}
执行流程:
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体
如果是false就不执行语句体
1) if语句的注意事项:
if语句中的大括号是可以省略的,一旦省略,只控制到第一条语句结束(第一个分号结束)

b. if语句的第二种形式

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

c. 语句的第三种形式

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

else {
语句体n+1;
}

2. switch语句

a.
switch(表达式) {
case 常量值1:
语句体1;
break;
case 常量值2:
语句体2;
break;

default:
语句体n+1;
break;
}

Switch 表达式的取值:byte,short,int,char,
JDK7以后可以是String

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

c. 注意事项:

1.  case后面只能跟常量,不能跟变量
2.  多个case后面的常量值不能相同
3.  case的顺序没有要求,可以放到任意位置
4.  default也可以放到任意位置
5.  default可以省略
6.  break可以省略,如果省略,代码会继续向下执行,不管case是否匹配成功,一直再次遇到break,或者执行到了switch语句结束
7.  switch语句遇到break,或者switch语句结束

三、循环结构

让一段代码反复执行很多次
  1. for循环
    a. 语法格式:
    for(初始化语句;判断条件语句;控制条件语句) {
    循环体语句体;
    
    }
    b. 执行流程:
    A:执行初始化语句
    
    B:执行判断条件语句,看其结果是true还是false
    如果是false,循环结束。
    如果是true,继续执行。
    C:执行循环体语句
    D:执行控制条件语句
    E:回到B继续
2. while循环:
a. 语法格式:

初始化语句;
while(判断条件语句) {
循环体语句体;
控制条件语句;
}
练习:
//打印1-100
//求1-10之和
//求1-100 奇数和 偶数和

int i=1;
while(i<=100) {
System.out.println(i);
i++;
}
int sum = 0;
int j=1;
while(j<=10) {
sum += j;
j++;
}
System.out.println(sum);//55

    int singleSum = 0;
    int doubleSum = 0;
    int k=1;
    while(k<=100) {
        if(k%2 == 0) {
            doubleSum += k;
        }else {
            singleSum += k;
        }
        k++;
    }
    System.out.println(doubleSum);//2550
    System.out.println(singleSum);//2500

3. For和while的区别:

for循环适合针对一个范围判断进行操作
while循环适合判断次数不明确操作
教室高度:8848m,我现在有一张足够大的纸张, 厚度为:0.12m。请问,我折叠多少次,就可以保证厚度不低于教室的高度?
/**

  • 教室高度:8848m,我现在有一张足够大的纸张,
  • 厚度为:0.12m。请问,我折叠多少次,就可以保证厚度不低于教室的高度?
  • 不低于:>=
  • 循环次数不知道: while:
  • 变量:
  • 厚度
  • 次数
  • 循环条件: 什么时候折叠:
  • 厚度小于8848,没有等于,因为等于就已经符合条件了不需要在折叠
  • 循环体:
  • 折叠的操作” height*=2
  • 次数加1
    /
    public class WhileTest3 {
    public static void main(String[] args) {
    double height = 0.12;
    int count = 0;
    while(height<8848) {
    height
    =2;
    count++;
    }
    System.out.println(count);

    }
    }

4. do…while循环:
a. 格式:

初始化语句;
do {
循环体语句;
控制条件语句;
} while(判断条件语句);
b. 流程:

先执行初始化语句
在执行循环体语句
在执行条件控制语句
在做条件的判断,
    true, 继续执行循环体和条件控制
    false: 循环结束

特点:
循环体语句至少执行一次
c. 案例: 打印100句话:
public class DoWhileDemo {
public static void main(String[] args) {
int i=0;//初始化语句
do {
System.out.println(“沉迷学习,日渐消瘦”+i);//循环体
i++;//条件控制
}while(i<100);//条件判断
}
}

四、 循环综合案例

1. 贪吃蛇:

需求: 在键盘上输入一个数,如果是1,代表蛇吃食物,得分加10,并继续输入,
如果输入的是一个非1的数字,停止程序,输出得分
分析:
有键盘录入: 使用Scanner
几个变量: 存储输入的结果oper 分数score
并继续输入: 说明需要循环反复的执行,使用循环语句
循环的次数知道? 不知道,一般使用while循环
循环的条件: 输入的结果是1
循环体: 得分加10, 继续输入
条件控制语句: 继续输入
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println(“欢迎来到多易[www.51doit.com]贪吃蛇,蛇还有5秒到达战场,请做好准备!");
//分数
int score = 0;
System.out.println(“请输入您的操作(1/0)”);
int oper = sc.nextInt();
while(oper == 1) {
// 操作:得分加10, 继续输入
score += 10;
System.out.println(“请输入您的操作(1/0)”);
oper = sc.nextInt();//对oper重新赋值,(条件控制语句)
}
//代码如果能够执行到这里,说明循环已经结束了
System.out.println(“GAME OVER:您的分数为:”+score);//打印得分
}

2. 循环登录练习
需求:     1.控制台提示用户输入密码
        2.用户输入密码
        3.如果用户输入的密码不等于1234,回到步骤1
        4.如果用户输入的密码等于1234,提示登录成功

分析:
分析:
需要用到Scanner
循环: 执行多少次: 不确定: while
循环的条件: 用户输入的密码不等于1234
循环体: 提示用户输入密码,用户输入密码
public class CircleLoginDemo {
public static void main(String[] args) {
//1 Scanner
Scanner sc = new Scanner(System.in);
//2. 提示用户输入密码
System.out.println(“请输入密码”);
//3. 用户输入密码
int password = sc.nextInt();
//4. 循环
while(password != 1234) {
System.out.println(“请输入密码”);
password = sc.nextInt();//重新赋值
}

    System.out.println("登录成功");
}

}

案例一、上述代码将密码改写成字符串

字符串在比较内容的时候是不能使用  ==   !=  的, 
字符串在比较内容的时候,用的是equals    
用法:     字符串a.equals(字符串b);    如果内容相同 返回true, 否则返回false
在使用equals比较字符串内容的时候,要把已知存在的字符串放到前面
public class CircleLoginDemo2 {
    public static void main(String[] args) {
        //1 Scanner
        Scanner sc = new Scanner(System.in);
        //2. 提示用户输入密码
        System.out.println("请输入密码");
        //3. 用户输入密码
        String password = sc.nextLine();
        //4. 循环
        //abc1234是已知存在的,所以放到前面
        while(!"abc1234".equals(password)) { // password != "abc1234"
            System.out.println("请输入密码");
            password = sc.nextLine();//重新赋值
        }
        System.out.println("登录成功");
    }
}

案例二、上述代码使用do…while实现
public class CircleLoginDemo3 {
    public static void main(String[] args) {
        //1 Scanner
        Scanner sc = new Scanner(System.in);
        String password;//变量的声明,  局部变量不赋初值不能使用
        do {
            //2. 提示用户输入密码
            System.out.println("请输入密码");
            //3. 用户输入密码
            password = sc.nextLine();//赋值
        }while(!"abc1234".equals(password));
        System.out.println("登录成功");
    }
}



案例三、do you love me
需求:
问老婆一个问题:  你爱我么?
          如果回答的不是  爱,继续问
          如果回答的是爱, 循环结束
  分析:
    至少执行一次,可以使用do...while
    条件:
              不是爱    equals
    循环体:
            继续问
            继续获取答案
public class DoYouLoveMeDemo {
    public static void main(String[] args) {
        //1.
        Scanner sc = new Scanner(System.in);
        System.out.println("在一个月黑风高的夜晚,由于多看了旁边小姐姐一眼,被老婆大人赏了一个耳光,我满眼泛起委屈的泪花,含情脉脉的问她:");
        String answer;
        do {
            System.out.println("老婆,你爱我么?");
            answer = sc.nextLine();
        }while(!"爱".equals(answer));

        System.out.println("执子之手与子偕老,用我三生烟火换你一世迷离!!");
    }
}

五、 循环嵌套

在循环中继续使用循环:
案例: 请输出一个4行5列的星星(*)图案
/**

  • 循环的嵌套:
  • 循环中还有循环 两层嵌套
  • 外层循环控制行
  • 内存循环控制列
  • 列不换行
  • 内层循环结束后,在换行
    /
    public class CircleQTDemo {
    public static void main(String[] args) {
    //请输出一个4行5列的星星(*)图案
    for(int i=1;i<=4;i++) {
    for(int j=1;j<=5;j++) {
        System.out.print("*");
    }
    System.out.println();
    
    }
    }
    }

案例:99乘法表的打印:
思路: 行: 共9行:外层循环控制行,共9次
列: 第一行有1列,第二行有2列…以此类推,第i行有i列
内层循环控制列,1-i
内存循环打印乘法表达式,多列不换行,内层循环结束后换行

/**

  • \ 代表转义
  • tab: \t
  • 换行: \n
  • 回车: \r
    *
  • 使用while 循环如何打印99
    */
    public class NineNineXTableDemo {
    public static void main(String[] args) {
    //打印  "helloworld"
    System.out.println("\"helloworld\"");
    for(int i =1;i<=9;i++) {
        for(int j=1;j<=i;j++) {
            System.out.print(j+"x"+i+"="+j*i+"\t");
        }
        System.out.println();
    }
    
    }
    }

六、 跳转控制语句

break: 结束单层循环,在循环语句和switch语句中使用
continue:结束本次循环,在循环语句中使用
return: 结束整个方法,返回给生成调用者
public class JumpControlTest {
public static void main(String[] args) {
for(int x=1; x<=10; x++) {
if(x%3==0) {
//在此处填写代码
//break;
//continue;
System.out.println(“Java基础班”);
}
System.out.println(“Java基础班”);
}
// 我想在控制台输出2次:“Java基础班“ break;return
// 我想在控制台输出7次:“Java基础班“
// 我想在控制台输出13次:“Java基础班“
}
}

七、 方法:

1. 方法的定义

目的:解决代码重复编写的问题
格式:
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2…) {
函数体;
return 返回值;
}
a. 方法格式的解释说明:
• 修饰符 比较多,后面会详细介绍。目前public static
• 返回值类型 用于限定返回值的数据类型
• 方法名 一个名称,为了方便我们调用方法
• 参数类型 限定调用方法时传入参数的数据类型
• 参数名 是一个变量,接收调用方法时传入的参数
• 方法体 完成功能的代码
• return 结束方法以及返回方法指定类型的值
• 返回值 程序被return带回的结果,返回给调用者
b. 案例:

public class MethodDemo1 {
public static void main(String[] args) {
//1 [一万行]+张三
yiWanHang(“张三”);//调用

    //2[一万行]+李四
    yiWanHang("李四");

    //3[一万行]+王五
    yiWanHang("王五");

    int a = 10;
    int b = 20;
    printSum(10,50);//调用的时候必须给具体的值
}
//定义
public static void yiWanHang(String s) {
    System.out.println("一万行太短,只争朝夕"+s);
}
//需求:  定义一个方法,打印两个数的和
public static void printSum(int a,int b) {//定义的时候,用的是变量的声明方式
    System.out.println(a+b);
}

}

  1. 方法的调用
    方法名(符合参数类型和个数的具体值);
    练习:
    /**

    • 定义两个方法:
      1. 打印两个double类型的值的差
      1. 打印圆的面积和周长
    • 在main方法中调用:
    • 分别求 12.4 和 12.1 的差
    • 求半径是4的周长和面积
    • 定义一个方法,传入一个行数和列数, 输出对应的星形(x行n列的星星)
    • printStar(4,5);//打印4行4列的星星
      */
      public class MethodTest {

      public static void main(String[] args) {
      printCha(12.5,34);
      printAreaAndZHOfCircle(12);
      printStar(8,10);
      }

      public static void printCha(double a,double b) {
      System.out.println(a-b);
      }

      public static void printAreaAndZHOfCircle(double r) {
      System.out.println(“圆的周长为:”+23.14r);
      System.out.println(“圆的面积为:”+3.14rr);
      }

      public static void printStar(int x,int y) {
      for(int i=1;i<=x;i++) {
      for(int j=1;j<=y;j++) {

      System.out.print("*");
      

      }
      System.out.println();
      }
      }
      }

  2. 方法的返回值

无返回值的方法:
返回值类型 void
有返回值的方法
返回值类型 数据类型
必须return
return 后面的值要和返回值类型相一致
/**

    1. 定义一个方法,传入一个整数,并判断这个整数是不是偶数,如果是,返回true,
  • 如果不是返回false
    1. 定义一个方法:传入两个double值,返回这两个值得差
    2. 定义一个方法,传入三个float类型的值,返回三个数中的最大值
  • 在main方法中调用上面的方法
    */
    public class MethodTest2 {

    public static void main(String[] args) {
    boolean re = isDouble(13);
    System.out.println(re);
    System.out.println(getCha(12.3,34));//只有有返回值的方法可以直接打印
    System.out.println(getMax(12.4f,12,34));
    }

    public static boolean isDouble(int a) {
    /if(a%2==0) {
    return true;
    }else {
    return false;
    }
    /
    // return a%2==0?true:false;
    return a%2==0;
    }

    public static double getCha(double x,double y) {
    return x-y;
    }
    public static float getMax(float a,float b,float c) {
    if(a>b&a>c) {
    return a;
    }else if(b>c) {
    return b;
    }else {
    return c;
    }
    }

}

  1. 方法的重载
    a. 概念:一个类中可以存在多个名字相同的方法,但是必须保证参数的个数或类型不同,与返回值无关
    b. 案例:
    public class OverLoadDemo {
    public static void main(String[] args) {
    /System.out.println(getSum(3,4));
    System.out.println(getSum(34L,45L));
    /
    System.out.println(getSum(3,4L));//ambiguous: 模棱两可的
    System.out.println();//println也是一个重载的方法
    }

    public static long getSum(long a,int b) {
    System.out.println(1);
    return a+b;
    }

    public static long getSum(int a,long b) {
    System.out.println(2);
    return a+b;
    }

/*public static int getSum(int a,int b) {// 优先找类型一模一样的
    System.out.println("int");
    return a+b;
}

public static long getSum(long a,long b) {
    System.out.println("long");
    return a+b;
}*/


/*public static int getSum(int a,int b,int c) {
    return a+getSum(b,c);
}*/

}

本文原创–支持原创

联系我--strivedeer@163.com