Day07-for循环的嵌套、跳转控制语句、方法

for循环的嵌套

/*
    (for 循环)
    “百钱买百鸡”是我国古代的著名数学题。题目这样描述:3 文
钱可以买1只公鸡,2 文钱可以买一只母鸡,1 文钱可以买3 只小鸡。用100文
钱买100 只鸡,那么各有公鸡、母鸡、小鸡多少只?

经典"穷举算法题"
    
    分析:
        1)定义公鸡,母鸡,小鸡分别是x,y,z只
        2)使用for循环,针对公鸡进行穷举  0,33  (3 文
钱可以买1只公鸡)
            获取到可能取到每一个公鸡的数量
                
        3) 继续针对母鸡进行穷举,(2 文钱可以买一只母鸡),for循环 0,50
            获取可能取到母鸡的数量
        4)
            公鸡和母鸡的数量确定,
            z = 100 - x - y ;
            
        5) 当前外层循环---针对公鸡进行穷举
                内层循环 ---针对母鸡进行穷举
                
                    z = 100 - x - y ;
                    
                必须满足的条件:
                    100文钱 要买公鸡,母鸡,小鸡
                    条件1 (3*x + 2*y + z/3 == 100) 
                            同时需要保证小鸡能被3整除  z % 3 == 0
                    输出所有的公鸡,母鸡,小鸡的数量---输出就是列表
                

*/

​
class ChickenTest{
    public static void main(String[] args){
        
        //定义公鸡,母鸡,小鸡分别是x,y,z只
        int z = 0 ;
        //使用for循环,针对公鸡进行穷举
        for(int x = 0 ; x <= 33 ; x ++){
            //继续针对母鸡进行穷举,(2 文钱可以买一只母鸡),for循环 0,50
            for(int y = 0 ; y <=50 ; y ++){
                
                
                //小鸡的数量
                z = 100 - x - y ;
                
                //满足的条件
                //100文钱 小鸡的数量是能被3整除
                if((3*x+2*y+z/3 == 100) && (z % 3 == 0)){
                    System.out.println("公鸡有:"+x+"只,母鸡有:"+y+"只,小鸡有:"+z+"只") ;
                }
            }
        }
    }
}

​

/*
    for循环的嵌套
    for(初始化语句1;条件表达式1;控制体语句1){
        循环体是for循环
        for(初始化语句2;条件表达式2;控制体语句2){
            循环体语句2;....
        }
    }
    
    
需求:
需要在控制台输出4行5列的*形
*****
*****
*****
*****
*/

​
class ForForDemo{
    public static void main(String[] args){
    for(int x = 0 ; x <4; x++){//外层控制行数 :4行  
            //循环体:就是5列*
            for(int y = 0;  y <5 ; y ++){ //内层控制列数:5列*
                 System.out.print("*") ;
            }
            System.out.println() ;
        }
        
    }
}

 

​

/*

  9行9列的*,列数在变化的*
*
**
***
****
*****
******
*******
********
*********

  需求:99乘法表
  1*1 = 1 
  1*2 = 2    2 * 2 = 4 
  1*3 = 3     2*  3 = 6    3....
                                    ...
                                                ...
...
*/

 

​
class ForForTest2{
    
    public static void main(String[] args){
        //9行9列的*,列数在变化的*
        for(int x = 0 ; x <9; x++){
            for(int y = 0 ; y <=x ; y++){
                System.out.print("*") ;
            }
            System.out.println() ;
        }
        System.out.println("-------------------------------") ;
        
        //99乘法表:为了保证有数据,从1开始
        for(int x = 1 ; x <= 9 ; x ++){//行数
            //列数也在变化
            for(int y = 1 ;y <=x ; y ++){
                //Java中的转义字符
                // \x :X任意字符   \t---"制表符"
                
                System.out.print(y+"*"+x+"="+(y*x)+"\t" ) ;
            }
            System.out.println() ;
        }
    }
}

​

/*
        请在控制台输出满足如下条件的五位数    (10000 99999)
        个位等于万位
        十位等于千位
        个位+十位+千位+万位=百位
        
        
        
*/

​
class Test2{
    
    public static void main(String[] args){
        
        System.out.println("满足条件的五位是:") ;
        //五位数,明确范围
        for(int x = 10000; x <=99999; x ++){
            //确定每个位上的数据本身
            int ge = x % 10 ;
            int shi = x /10 % 10;
            int bai = x /10 / 10 % 10 ;
            int qian = x/ 10/10/10 % 10;
            int wan = x /10/10/10/10 % 10 ;
            /*
                个位等于万位
                十位等于千位
                个位+十位+千位+万位=百位
            */
            if((ge==wan) && (shi==qian) && ((ge+shi+qian+wan)==bai)){
                System.out.println(x) ;
            }
            
        }
    }
} 

​

 

/*
我国最高山峰是珠穆朗玛峰:8848m,
我现在有一张足够大的纸张,厚度为:0.01m。
请问,我折叠多少次,就可以保证厚度不低于珠穆朗玛峰的高度?

分析:
        0)定义统计变量int count = 0 ;
        1)起始厚度 int start = 0.01 ;    1
         最终厚度:int end = 8848 ;        884800
         为了方便计算,都乘以100 ,取整
         
         不明确循环次数
        2)使用while(start < end){
            //统计变量++
            
            //折叠 起始厚度*=2 
            start *=2 ;
            
            //输出,方便看,第count次,它的厚度start是多少
        }
        
        
        3)输出count次
*/

​
class WhileTest{
    
    public static void main(String[] args){
        
        //定义统计变量
        int count = 0 ;
        //定义起始厚度
        int start = 1 ;
        int end  = 884800 ;
        
        //满足条件
        while(start < end){
            
            //count++
            count ++ ;
            
            //起始厚度是之前的2倍
            start *=2 ;
            System.out.println("第"+count+"次,起始厚度是"+start) ;
        }
        System.out.println("需要折叠"+count+"次") ;
    }
    
}

​

跳转控制语句

/*
    跳转控制语句:
            break 
            continue
            return 
    
        break;    中断,结束的意思
        
        break    
            应用场景:
                1)不能单独使用,报错
                2)只能在两个场景中使用
                        switch语句自带了break关键字
                        循环结构语句中
                                for/while循环都可以用到
                                
        break早期的时候,在for循环嵌套中使用,使用"标签语句"
                
                break 标签名称; 结束指定的循环
                
                标签名称:外层循环/内层循环
                wc:for(xxx;xx;xx){
                    nc:for(xx;xx;xx){
                        
                    }
                }
*/

​
class BreakDemo{
    
    public static void main(String[] args){
        
        //break ;//在 switch 或 loop 外部中断
        
        
        //写for循环
        for(int x = 0 ; x <10 ; x ++){
            if(x == 3){
                break ;//结束,中断
            }
            System.out.println(x) ;//0,1,2
        }
        
        System.out.println("--------------------------") ;
        
        //早期加入标签名称  (了解)
        wc:for(int x = 0 ; x < 4 ; x ++){//行数
            nc:for(int y = 0 ; y < 5 ; y ++){//列数
            /*
                if(x == 2){
                    break wc ; //结束外层循环了
                }
                */
                if(y == 2){
                    break nc ;
                }
                System.out.print("*") ;
            }
            System.out.println() ;
        }
    }
    
} 

​

/*
    contine:属于跳转控制语句中的一种
        一般都在循环语句中使用的;
        表示结束当前循环,立即进入下一次循环了...
        
    break:结束中断的意思
    
面试题:考点就是break/continue    
    看程序,写结果,补全代码
            for(int i =1 ; i <=10 ; i ++){
                
                if(i % 3 == 0 ){
                    //此处补全代码
                }
                
                System.out.println("我爱高圆圆") ;
            }
            
            
            1)需要在控制台输出 2次 "我爱高圆圆"   break ;
            2)需要在控制台输出 7次 "我爱高圆圆"  continue 
            3)需要在控制台输出 13次 "我爱高圆圆"
                                System.out.println("我爱高圆圆") ;
*/

​
class ContinueDemo{
    public static void main(String[] args){
        
        
        //for循环
        for(int x =1 ; x <= 10 ; x ++){
            
            //加入条件
            if(x ==3 ){
                //break ; //结束
                
                continue ;//结束当前循环,立即进入下一次循环了
            }
            System.out.println(x) ;// break ;1,2
                                //contine: 1,2,4,5,6,7,8,9,10
        }
        
    }
} 

​

/*
    return :返回结果   (结束方法去使用,但是很少单独使用)
    
    一般情况:return不会单独使用(很少单独使用)
    结合 Java中的有具体返回值类型的方法去使用
    
    
    
    实际开发中,
        只要看到return 关键字,肯定是当前方法中有具体返回值类型的时候,去使用!
    
    
    
    
*/

​
class ReturnDemo{
    public static void main(String[] args){
        
        System.out.println("程序开始了...") ;
        for(int x = 1 ; x <= 10 ; x ++){
            if(x == 3){
                
                System.out.println("条件成立了,进入if了") ;
                //break ;//当x=3的时候,成立,中断循环了结束了
                //continue ;//当x=3的时候,成立,立即进入下一次循环了
                return ; //结束方法去使用,很少单独使用;
                
            }
            System.out.println(x) ;
        }
        
        
        System.out.println("程序结束了,over...") ;
    }
} 

​

方法

有具体返回值类型的方法

/*
    什么是方法呢,
    在Java中,
    方法就是使用{}代码块将一些业务代码包裹起来,并为之起名字,称为"方法名"
    方法名,需要见名知意,满足"标识符的规则",
        以后直接在main中调用我们自己的业务方法即可!
        
    在Java中,如何定义一个有具体返回值类型的方法
    
    格式:固定写法
    
    定义方法
            权限修饰符 static  返回值类型 方法名(参数类型1 变量名1 ,参数类型2 变量名2.....){
                
                完成你的代码的业务逻辑:根据需求来完成操作
                
                return 结果;
            }
            
            详细解释:
                    权限修饰符:现在固定使用public  :访问权限足够大的
                    现在写方法:必须带上static  前面的写法:public static
                    
                    返回值类型:就是数据类型----研究的就是基本数据类型
                    方法名: 给{}代码块起名字, 见名知意,遵循"标识符规则",小驼峰命名法
                            add(),求和
                            sum() ,求和
                    参数列表:
                        参数类型 ----:数据类型,现在使用的就是基本数据类型 
                        变量名 ---- :给当前形式参数起名字,见名知意,"小驼峰命名法"
                        
                    return 结果: 根据你的业务方法,
                            返回值类型时什么类型,给你返回具体的结果
    
    
    调用方法:
        1)输出调用:不推荐
        2)赋值调用:推荐
        3)单独调用:用不了
    
    
需求:
        求两个数据之和(没有提示数据类型,都是int)
*/

 

​
class FunctionDemo{
    
    public static void main(String[] args){
        
        /*
            int a = 10 ;
            int b = 20 ;
            System.out.println(a+b) ;

        */
        
        
        //键盘录入或者直接现在给具体值:实际参数
        int a = 10 ;
        int b = 20 ; 
        
        //调用方法
        //单独调用:用不了,计算出来---但是没有结果出来
        //add(a,b) ;
        
        //输出调用:不建议:硬编码  
        //---直接输出结果,可能想通过获取的结果继续进行其他需求,用不了
        //System.out.println("两个数据的之和是:"+add(a,b)) ; //a=10,b=20 
        
        
        //有具体返回值类型的方法的调用---推荐使用 赋值调用
        //赋值调用:推荐
        int result = add(a,b) ;
        System.out.println("两个数据的结果是:"+result) ;
        
        
    }
    /*                                                            形式参数
        权限修饰符 static  返回值类型 方法名(参数类型1 变量名1 ,参数类型2 变量名2.....){
                
                完成你的代码的业务逻辑:根据需求来完成操作
                
                return 结果;
            }
            
        定义一个求两个数据之和的功能(方法)
        
        心中必须有两个明确
        1)明确返回值类型---数据类型:现在使用的就是基本数据类型
                int
        2)明确参数类型以及参数个数
            2个参数,分别都是int
                
            
    */
    public static int add(int x,int y ){//10,20 :实际参数将结果赋值形式参数x,y
        
        //赋值运算
        int result = x  + y ;
        return result ;//具体业务结果
        
        
        //return x+y ;
    }
    
}

​

/*
    定义有具体返回值类型的方法注意事项:
            1)方法和方法是平级关系,不能嵌套,只能在里面去调用
            2)定义方法的时候需要两个明确
                a)明确返回值类型
                b)明确参数类型以及参数个数(形式参数类型和几个参数)
                
            3)在定义方法的时候,形式参数必须携带数据类型,因为Java
            是一个强类型语言!
            
            4)在实际参数 main中,调用方法的时候,实际参数不需要携带数据类型,因为
            已经键盘录入,已经定义过了
            
            5)实际参数和形参参数,传参时,数据类型需要一一对应!
*/

class FunctionDemo2{
    
    public static void main(String[] args){
        
        
        //定义求和方法:两个数据求和
        /*public static int add(int a,int b){//非法的表达式开始(方法嵌套:错误))
            int c = a + b ;
            return c ;
        }
        */
        
        //以后键盘录入
        int a = 10 ; 
        int b = 20 ;
        //赋值调用 
        //int result = add(int a,int b) ; //不能在携带数据类型
        int result = add( a, b) ;
        System.out.println("result:"+result) ;
    }
    
    //方法和方法平级关系
    //定义求和方法:两个数据求和
    /*
        两个明确
            1)明确返回值类型: int
            2)明确参数类型以及参数格式
                    int类型,2个参数
    */
    public static  int add(int a,int b){ //形式参数不影响
    //public static  int add( a, b)//不行,Java语言不行,语法结构和格式非常严谨!
            int c = a + b ;
            return c ;
    }    
} 

/*
        没有提示,int类型
    1)键盘录入两个数据,比较两个数据是否相等,使用有具体返回值类型的方法来完成
    2)键盘录入两个数据,获取两个数据中较大的值,使用有具体返回值类型的方法来完成
    
    
    今天重点
            掌握
                    for循环嵌套的使用 ----经典算法题 "穷举法"
                    break/continue的区别:
                    
                    什么是方法以及有具体返回值类型的方法定义和调用(重点)
                            心中两个明确
                                1)明确返回值类型
                                2)明确参数类型以及参数个数
*/

//导包
import java.util.Scanner ;
class FunctionTest{
    
    public static void main(String[] args){
        
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;
        
        //提示并录入数据
        System.out.println("请您输入第一个数据:") ;
        int a = sc.nextInt() ;
        
        System.out.println("请您输入第二个数据:") ;
        int b = sc.nextInt() ;
        
        
        //调用方法
        //两个数据是否相等 
        boolean result = compare(a,b) ;
        System.out.println("result:"+result) ;
        
        System.out.println("-------------------------------") ;
        
        
        //提示并录入数据
        System.out.println("请您输入一个数据:") ;
        int m = sc.nextInt() ;
        
        System.out.println("请您在输一个个数据:") ;
        int n = sc.nextInt() ;
        
        //调用方法
        int max = getMax(m,n) ;
        System.out.println("两个数据中的最大值是:"+max) ;
    }
    /*
    
            定义一个功能:比较两个数据是否相等
            定义方法两个明确
                1)明确返回值类型
                        boolean 
                            
                2)明确参数类型以及参数个数
                        int类型,两个参数
                        
                权限修饰符 static 返回值类型 方法名(形式类型1 变量名1,.....){
                    
                    //业务逻辑
                    
                    return 结果;
                }
    */
    public static boolean compare(int a , int b){ //形式参数,完成方法的业务逻辑
            //三元
            //boolean  flag = (a==b)? true :false ;
            
            //优化
            
            boolean flag = a==b ; 
            
            return flag ;
        
    }
    
    /*
        键盘录入两个数据,获取两个数据中较大的值
    */
    /*
        定义这个方法
        //两个明确
        1)明确返回值类型
                int
        2)明确参数类型以及参数个数
                int 2个参数
    */
    public static int getMax(int a,int b){
        
        int max =0;  //结果变量
        if(a != b){
            
            //嵌套判断
            if(a > b){
                max = a ; 
            }else{
                max = b ; 
            }
        }else{
            System.out.println("两个数据一致") ;
            max = a ; 
        }
        return max ;
    }
    
} 

上一篇:throw 和 throws


下一篇:Python字符编码详解(转)