day05总结

05.01 循环结构循环嵌套输出4行5列的星星)(掌握)

案例演示
	需求：请输出一个10行10列的星星(*)图案。
	如图：
		*****
		*****
		*****
		*****
	注意：
		System.out.println("*");和System.out.print("*");的区别：print不换行。
B:结论：
	外循环控制行数，内循环控制列数
案例：
public class MyDemo3 {
    public static void main(String[] args) {
        for (int i = 0; i <10; i++) {
            for (int j = 0; j < 10; j++) {
                //打印不换行 print("*");
                System.out.print("*");
            }
            //只是换行，不输出然后内容
            System.out.println();
        }

    }
}
    

05.02 循环结构循环嵌套输出正三角形(掌握)

案例演示
	需求：请输出下列的形状
	*
	**
	***
	****
	*****
案例：
public class MyDemo3 {
    public static void main(String[] args) {
        /*
        *
        *  A:案例演示
	需求：请输出下列的形状
                    *
                    **
                    ***
                    ****
                    *****   */
        for (int i = 1; i <=5; i++) {
            for (int j = 1; j <=i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}    

05.03 循环结构九九乘法表(掌握)

案例演示
	需求：在控制台输出九九乘法表。
代码优化
	注意：
	'\x' 	x表示任意，这种做法叫转义字符。
	
	'\t'	tab键的位置(空格)
	'\n'	换行
public class MyDemo {
    public static void main(String[] args) {
        //输出九九乘法表
        /*
         *   1*1=1
         *   1*2=2 2*2=4
         *   1*3=3 2*3=6 3*3=9
         *   1*4=4 2*4=8 3*4=12 4*4=16
         * */
        //ctrl+alt+L 排版代码
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                //\t 是一个转义字符 空一个table位置
                System.out.print(j + "*" + i + "=" + (j * i) + "\t");
            }
            // System.out.println();
            //  \n 是一个转意字符，换行符
            System.out.print("\n");
        }
    }
}    

05.04 控制跳转语句

05.04.1 break语句

break的使用场景
	(1):在选择结构switch语句中
	(2):在循环语句中
	注意：离开使用场景的存在是没有意义的
作用
	a:退出单层循环   写在哪一层，中断的就是哪一层的循环。
	b:退出多层循环(几乎不使用)   在内层循环结束外层循环
		要想实现这个效果，就必须知道一个东西;带标签的语句；
		格式：标签名：语句
案例:
public class MyDemo2 {
    public static void main(String[] args) {
        //控制循环的两个关键字
        //比如 1---10
        for (int i = 1; i <=10; i++) {
            System.out.println(i);
        }
        System.out.println("====================");
        //原计划是循环10次，但是中途到5的时候，我要中断循环
        for (int i = 1; i <=10; i++) {
            System.out.println(i);
            if(i==5){
               break; //中断循环，结束循环
            }
        }

        // break 这个关键字，用在switch语句和循环语句中，离开这两种场景，没有意义。
        //break 用来接收switch语句，或者说结束循环。
        int j=1;
        while (true){
            System.out.println("呵呵");
            if(j>10){
              break; //中断循环
            }
            j++;
        }
        System.out.println("下面的代码");
    }
}
案例，内层循环中断外层循环：
public class MyDemo4 {
    public static void main(String[] args) {
        //我想在内层循环，去结束外层循环
        //我们可以给每层循环，起个别名，通过别名来结束某个循环
        wc:for (int i = 0; i < 10; i++) {
            nc:for (int j = 0; j < 10; j++) {
                if (j == 2) {
                    //break nc;
                    break wc; //根据循环的别名来结束循环
                }
                System.out.print("*");
            }
            System.out.println();
        }
    }
}    

05.04.2 continue语句

continue的使用场景
	(1):在循环语句中
	(2):离开使用场景的存在是没有意义的
作用
	a:跳出一次循环，执行下一步操作
练习题
	for(int x=1; x<=10; x++) {
		if(x%3==0) {
			//在此处填写代码
		}
		System.out.println(“Java基础班”);
	}
	
	我想在控制台输出2次:“Java基础班“
	我想在控制台输出7次:“Java基础班“
	我想在控制台输出13次:“Java基础班“
案例：
public class MyDemo {
    public static void main(String[] args) {
        //输出偶数
        //continue 跳出一次循环，继续下一次循环。也是使用在循环语句中，离开循环场景没有任意
        for (int i = 1; i <= 10; i++) {
            if(i%2==1){
                continue;
            }
            System.out.println(i);
        }

        System.out.println("======================");
        //输出1--10 不要 5和6
        for (int i = 1; i <= 10; i++) {
            if (i==5||i==6) {
                continue; //跳过一次循环，继续下一次循环
            }
            System.out.println(i);
        }

    }
}
练习题：
public class MyDemo4 {
    public static void main(String[] args) {
       /* 1.我想在控制台输出2次:“Java基础班“
        我想在控制台输出7次:“Java基础班“
        我想在控制台输出13次:“Java基础班“*/
        for (int x = 1; x <= 10; x++) {
            if (x % 3 == 0) {
                //在此处填写代码
               // 1. 我想在控制台输出2次:“Java基础班“
                
                //break;
                //2. 我想在控制台输出7次:“Java基础班“
                
               // continue;
                //3.我想在控制台输出13次:“Java基础班“
                
                System.out.println("Java基础班");
            }
            System.out.println("Java基础班");
        }
    }
}    

05.05 方法

为什么要有方法：为了提高代码的复用性；
什么是方法
	方法就是完成特定功能的代码块
	在很多语言中都有函数的定义，但是在咱们JAVA语言中，我们将其称之为方法。
方法的格式
	修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2 ....){
		方法体;
		return 返回值;
	}
方法的格式详细说明
	(1): 修饰符 			比较多,后面会详细介绍。目前使用  public static
	(2): 返回值类型 		用于限定返回值的数据类型
	(3): 方法名			就是一个名称，它的存在是为了方便我们调用方法
	(4): 参数类型 			限定调用方法时传入参数的数据类型
	(5): 参数名 	  是一个变量，接收调用方法时传入的参数
					这个参数其实有一个专业的名词,被称之为形式参数,它的作用是用来接收实际参数的.
	(6): 方法体 			完成功能的代码
	(7): return 			结束方法以及返回方法指定类型的值 
	(8): 返回值 			就是功能的结果，由return带回，带回给调用者
案例：    
public class MyDemo {
    //main方法，是由JVM来自动调用
    public static void main(String[] args) {
        //方法：就是封装一段功能逻辑，以实现代码的复用性。
        //定义方法的语法：
        //1.你从第一天开始学Java接触过一个方法，你可以仿照他 这个main方法，就是你第一天接触的。
        //2.方法定义在类中，方法跟方法是平级关系，不能嵌套定义
        //3.语法:权限修饰符 状态修饰符 返回值类型 方法名(参数){ 方法体}
        //4.方法不调用不执行。
        //5.如何调用我们定义的方法呢？我可以在main调用我的方法执行
        //6.调用的语法
        System.out.println("主方法调用了");
        //通过方法名直接调用
        send();
        System.out.println("=================");
        send();
        System.out.println("=================");
        send();
        System.out.println("=================");
        send();
    }
    //语法:权限修饰符 状态修饰符 返回值类型 方法名(参数){ 方法体}
    public static void send(){
       //{} 方法体，封装你要实现的功能逻辑，比如发射炮弹
        System.out.println("发射子弹1");
        System.out.println("发射子弹2");
        System.out.println("发射子弹3");
        System.out.println("发射子弹4");
        System.out.println("发射子弹5");
        System.out.println("发射子弹6");
        System.out.println("发射子弹7");
        System.out.println("发射子弹8");
    }
} 
求和方法的调用：
public class MyDemo2 {
    public static void main(String[] args) {
        //我要设计一个方法，来计算两个数的和
        System.out.println("主方法调用了");
        //调用add方法
        add();
        //我要在main下面的代码中要使用add方法执行完后，计算的这个结果40

        int r=add2();
        System.out.println(r);
        System.out.println(100+r);
        //方法有返回值，你调用完之后，返回的这个结果，你收不收。这不是必须的，你可以不收
        //如果你要接收，那么这个方法返回什么类型，就用什么类型来接收
        add2();

        int sum=add2();
        //当然大类型接收小类型，也可以
        long l=add2();

        double v = add3();
        System.out.println(v);

    }

    //返回值类型：void 表示这个方法，没有明确的返回的数据
    //如果你的方法，要返回数据。那么你就要明确，你的方法，要返回什么样的类型的数据
    //如果你的方法，一旦明确了返回值类型，那么就必须，通过一个关键字return 来带回与你明确了数据类型一致的值

---------------------------------------------------------------------------------
    public static int add2() {
        System.out.println("add2 方法调用了");
        int a = 20;
        int b = 20;
        int sum = a + b;
        System.out.println("sum=" + sum);
        //返回给调用者
        return sum;
    }
------------------------------------------------------------------------------------
    public static double add3() {
        System.out.println("add3 方法调用了");
        int a = 20;
        int b = 20;
        double sum = a + b+3.2;
        System.out.println("sum=" + sum);
        //返回给调用者
        return sum;
    }
--------------------------------------------------------------------------------------
    public static void add() {
        int a = 20;
        int b = 20;
        int sum = a + b;
        System.out.println("sum=" + sum);
    }
}    

05.05.1 return的作用

return 			结束方法以及返回方法指定类型的值
    
public class MyDemo3 {
    public static void main(String[] args) {

        int add = add();
        System.out.println(add);



        return; //结束方法
    }
    public static int add(){

        //return 结束方法，并返回
        return 100;
    }

    public static void add2() {

        //return 结束方法
        //方法最后默认存在  return
        //你的方法的返回值类型是void 这个return可以省略不写

        return; //结束方法
    }

}    

05.05.2 如何写一个方法 方法的调用

需求：求两个数据之和的案例
如何写一个方法
	两个明确
		(1):返回值类型 	明确功能结果的数据类型
		(2):参数列表 		你要传递几个参数，以及每一个参数的数据类型
方法调用(有明确返回值的调用)
	a:单独调用,一般来说没有意义，所以不推荐。
	b:赋值调用,推荐方案。
	c:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。

public class MyDemo4 {
    public static void main(String[] args) {
        int sum = add();
        System.out.println(sum);
        int sum2 = add2(50, 50);
        System.out.println(sum2);
        //如果我们在调用一个方法时，这个方法需要参数，那我们就需要传入相应的参数
        //参数类型和参数个数，跟人家方法需要的参数要对应。
        //我们把调用方法时，传入的参数，叫做实际参数，简称实参
        int sum3 = add2(60, 40);
        System.out.println(sum3);
        int i=200;
        int j=300;
        int sum4 = add2(i, j);
        System.out.println(sum4);
        //如果一个方法有返回值，我们可以输出调用
        int aaa=add2(2, 3);
        System.out.println(aaa);
        System.out.println(add2(2, 3));
        //如果方法没有返回值，不能输出调用
       // System.out.println(add0());//报错

        //以后我们要定义一个方法，要考虑 方法要不要返回值。返回值类型是什么？方法要不要参数。要几个参数。参数类型是什么？

    }
-----------------------------------------------------------------------------------
    //这个两个数相加的方法，设计的不好，这两个数给死了
    public static int add() {
        int a = 20;
        int b = 30;
        return a + b;
    }
-----------------------------------------------------------------------------------
    public static void add0() {
        int a = 20;
        int b = 30;
        return;
    }
------------------------------------------------------------------------------
    //这么来设计。我们可以把要相加的两个数，作为参数传入进来
    //定义在方法的括号里面的参数，我们叫做形式参数，简称形参
    //语法。(数据类型 参数名,数据类型 参数名,.....)
    //形参的作用：就是用来接收调用方法时，所传入的数据
    public static int add2(int a, int b) {
        int sum = a + b;
        return sum;
    }

}        

05.05.3 方法的注意事项

方法不调用不执行
方法与方法是平级关系，不能嵌套定义
方法定义的时候参数之间用逗号隔开
方法调用的时候不用在传递数据类型
如果方法有明确的返回值，一定要由return带回一个值

05.05.4 方法的重载

案例演示
	求和案例
		2个整数
		3个整数
		4个整数
方法重载概述
	在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同，与返回值无关。
	参数列表不同：
		A:参数个数不同
		B:参数类型不同
            
public class MyDemo {
    public static void main(String[] args) {
        //求两个数，相加的结果

        //求三个数，相加的结果
        //求四个数,相加的结果
        int sum1 = add(1, 2);   优先与int类型匹配，因为整数是int类型。
        int sum2 = add(1, 2, 3);
        int sum3 = add(1, 2, 3, 4);
        System.out.println(sum1);
        System.out.println(sum2);
        System.out.println(sum3);

        //方法重载：允许一个类中，可以出现多个同名方法，只要他们的形参个数或形参类型不一样即可。不拿返回值类来区分
        //在调用时。会根据传入的参数个数和参数类型，会自动匹配
        System.out.println("=====================");
        add(20,30.3);

    }
    public static int add(int a, int b) {
        System.out.println("两个整型的方法调用了");
        return a + b;
    }

   /*
   不拿返回值类型来区分
   public static double add(int a, int b) {
        return a + b;
    }*/
    public static double add(int a, double b) {
        System.out.println("一个整形一个浮点型的方法调用了");
        return a + b;
    }

    public static int add(int a, int b,int c) {
        return a + b+c;
    }

    public static int add(int a, int b, int c,int d) {
        return a + b + c+d;
    }
}