Java复习 2019.30

一、循环语句

while语句

1、格式：
	初始化语句；
	while(布尔表达式){
		循环体语句；
		初始化变量的自增；
	}
2、执行流程
	（1）执行初始化语句；
	（2）计算布尔表达式的值，结果只有两种，如果为false，循环就不执行了，直接结束
	（3）如果为true，执行循环体语句
	（4）执行初始化变量的自增
	（5）回到第(2)步
3、注意：
	（1）条件表达式结果一定是boolean类型
	（2）初始化变量的自增，一定不要忘记

public class Whi {
    public static void main(String[] args) {
        //		while循环
//		初始化语句；
//		while(布尔表达式){
//			循环体语句；
//			初始化变量的自增；
//		}
        int i = 0;//初始化语句
        while (i < 5){
            //初始化变量自增
              System.out.println(i);
//            i++
            i += 2;
          
        }
    }
}

死循环

1、死循环：循环能够一直的执行下去，不会停止
2、格式：
	两种
	（1）for语句的死循环
        for(;;){
            循环体语句；
        }
	（2）while语句的死循环（常用）
		while(true){
			循环体语句；
		}
3、死循环的作用
	（1）在格式上使用了死循环，将来可以结合跳转语句进行使用，能够结束死循环。
	（2）在服务器设计中，希望服务能够永远的给我们服务下去，所以在服务器设计中需要使用死循环。

        //for语句的死循环
        for (;;){
            System.out.println("for循环的死循环");
        }
//        System.out.println("hello"); 注意：死循环中如果没有跳转语句，那么在死循环的后面是无法跟任何代码的

//while语句的死循环
      while (true){
            System.out.println("while语句死循环");
        }

//死循环的简单使用
       Scanner sc = new Scanner(System.in);
        while (true){//结果正确结束循环
            System.out.println("请输入一个数字");
            int i = sc.nextInt();
            if (i == 5){//i等于5 结束循环
                System.out.println("录入正确");
                break;//结束
            }
        }

跳转语句

1、跳转语句：在循环的循环体语句中，结束循环，控制循环使用的语句
2、continue语句：
	解释：继续
		作用：结束本次循环，继续下次循环
3、break语句：
	解释：中断打断
	swtich语句中，break；作用：结束switch语句
	在循环中的break作用，结束break所在层次的循环。

public class Tiao {
    public static void main(String[] args) {
        //		continue语句
//		解释：继续
//		作用：结束本次循环，继续下次循环
        for (int i = 1;i <= 5;i++){
            if (i == 3){ // i == 3的时候结束本次循环 继续下一次
                continue;
            }
            System.out.println(i);
        }
        System.out.println("--------break-------");
        for (int i = 1;i <= 5;i++){
            if (i == 3){
                break;//在 i == 3 的时候直接结束循环
            }
            System.out.println(i);
        }
    }
}

练习：计算1+2+3+4+.....+100的和

package Lian;

public class He {
    public static void main(String[] args) {
        //计算1+2+3+4+5+....+100的和
        //这里定义一个变量，记录每次相加的和
        int sum = 0;
        //循环
        for (int i = 1;i <= 100; i++){
            //累加
            sum += i;
        }
        System.out.println(sum);
    }
}

while循环练习

使用while循环，统计1-100范围内，有多少个数字可以被7整除

package Lian;

public class Chu {
    public static void main(String[] args) {
        //使用while循环，统计1-100范围内，有多少个数字可以被7整除
        int i = 1;
        //统计能被7整除的个数
        int count = 0;
        while (i <= 100){
            if(i % 7 == 0) {
                System.out.println(i);
                count++;
            }
            //初始化变量的改变
            i++;
        }
        System.out.println("能被7整除的个数为：" + count);
    }
}

嵌套循环

1、在一次大的循环中，每次的循环内容（循环体语句）又是一个复杂的操作，就需要在大循环中，再去定义一个小循环，称为循环的嵌套（双重循环）
2、格式：
	for(初始化语句1;条件判断表达式1;初始化语句改变表达式1){  //外层循环
		for(初始化语句2;条件判断表达式2;初始化语句改变表达式2){ //内层循环
			循环体语句；
		}
	}
3、执行流程

public class Qian {
    public static void main(String[] args) {
        //嵌套循环
        for (int i = 0;i <= 3; i++){//外层循环，循环体语句是内层循环
            //嵌套循环：外层循环一次，内层循环要循环完
            for (int j = 0;j <= 3 ; j++){//内层循环
                System.out.println("i=" + i + "   j=" + j);
            }
        }
    }
}

练习：使用嵌套循环打印四行五列的星星矩阵

package Lian;

public class Qian {
    public static void main(String[] args) {
//		使用嵌套循环，打印四行五列的星星矩阵
//		外层循环控制行，内层循环控制列
//		*****
//		*****
//		*****
//		*****
        for (int i = 1;i <=4; i++){
            for (int j = 1;j <= 5;j++){
                System.out.print("*");//别加ln
            }
            System.out.println();
        }
    }
}

练习：使用嵌套循环打印五行五列的直角三角形

//	使用嵌套循环，打印5行五列的直角三角形
//	*            1       1列
//	**           2       2列
//	***          。。。
//	****
//	*****
        for (int i = 1;i <= 5;i++){
            for (int j = 1;j <=i;j++){
                System.out.print("*");
            }
            System.out.println();
        }

练习：打印九九乘法表

 //使用嵌套循环，打印九九乘法表
        for (int i = 1;i <= 9;i++){
            for (int j = 1;j <= i;j++){
                System.out.print(j + "*" + i + "=" + i * j + "\t"); // j * i = i*j的值 “\t” 空格
            }
            System.out.println();
        }

二、方法

1、方法定义的格式
	修饰符 返回值 方法名称（参数列表）{
		方法体；
		return 语句；
	}
2、说明：
	（1）修饰符：public static 
	（2）返回值类型：方法具有功能，有可能会有一些产出，需要将数据返回给调用者，调用者需要知道方法产生数据的类型的。
	（3）方法名称：只要是一个合法的标识符即可。   小驼峰命名法
	（4）参数列表:这段代码要完成功能，可能就需要一些资源，资源是外界的，在参数列表中，定义一些变量，告诉调用者，方法所需要的数据。
				将来调用者在调用方法的时候，就需要传入参数列表中声明的数据类型的数据。有了参数列表，方法就可以接受外界的数据，并进				 行使用或者处理。
	（5）方法体：一些对业务逻辑的处理。对数据的处理的操作
	（6）return语句：最终方法调用结束之后，可能会有数据的产出。返回给调用者，使用return语句进行返回，如果没有任何数据的产出，就可以只写一个return；或者不写。
		如果没有数据的产出。返回值类型就写一个void

public class Fang {
    //	方法的定义
    public static void main(String[] args) {

    }

    //	没有返回值，也没有参数列表，方法的定义
    public static void test() {// 就是执行一条hello这样的语句
        System.out.println("hello");
    }

    //	有返回值，有参数列表

    public static String sum(int a, int b, float f, String str) {
        String d = a + b + f + str;
        return d;
    }
}

方法的调用

1、格式：直接书写方法的名字即可
	方法名称（实际参数）;
2、方法调用的三种形式
	（1）直接调用：针对的是方法没有返回值，表示某些内容的执行
	（2）输出调用：方法具有返回值，但是这个返回值不需要后续进行处理，这时候就可以使用输出调用将方法返回的结果进行打印
	（3）赋值调用：针对的是方法具有返回值，将来需要使用这个方法返回的数据，定义一个变量去接收方法返回的数据。
3、方法调用的特点
	方法不调用就不执行

public class Fang {
    //	方法的定义
    public static void main(String[] args) {
//		方法的调用
//		直接调用
        test();
//		输出调用,将方法的结果进行打印，没有对方法产生的结果进行后续的使用或者处理
        System.out.println(sum(100, 200, 2.3f, "java"));
//		赋值调用,可以对方法产生的结果进行再次的处理或者使用
        String str = sum(777, 666, 2.3f, "java");
        str += "北京";
        System.out.println(str);
    }

    //	没有返回值，也没有参数列表，方法的定义
    public static void test() {// 就是执行一条hello这样的语句
        System.out.println("hello");
    }

    //	有返回值，有参数列表             方法的定义
    public static String sum(int a, int b, float f, String str) {
        String d = str + a + b + f;
        return d;
    }
}

方法的注意事项

 1、方法定义：
	（1）方法不能嵌套定义的
	（2）方法的定义，没有任何先后的区别
	（3）方法的定义都是平级的关系
	（4）方法是可以嵌套调用的，甚至可以自己调用自己（递归）
2、参数列表
	（1）形式参数：在定义方法的时候，在参数列表中进行的只是变量的声明（只是将变量定义出来，确不赋值），各个变量之间用逗号隔开
	（2）实际参数：在调用方法的时候，不能写上变量的类型，而是写具体的数据（值），各个实际参数之间，使用逗号隔开。本质上实际参数是完成				 对形式参数的赋值
3、return语句:
	（1）一旦执行了return语句，就意味方法的结束。
	（2）如果方法没有具体的返回内容，就可以写一个return；或者不写，这时候返回值类型必须是void
	（3）return后返回的数据，该数据的类型决定返回值的类型。返回值类型要和return后返回的数据的类型保持一致.

public class Fang {
	public static void main(String[] args) {
		System.out.println('h');
//		方法是谁先调用，谁先执行
		test_1();
//		test_2();

		int a = 123;
		int b = 345;
//		show(123,33);
		show(a, b);// 实际参数, 本质上相当于完成了对形式参数的赋值的过程

//		int i = 100;
//		int j ;
//		j = i;
//		System.out.println(j);
		for (int i = 1; i <= 5; i++) {
			if(i ==3) {
				break;
			}
		}
		System.out.println("hellojava");
	}

	public static int show(int a, int b) {// 形式参数，只有变量的定义，没有赋值 a = 123,b = 345

		return a + b;
	}

	public static void test_2() {
		System.out.println("test_2");
	}

	public static void test_1() {
		/*
		 * public static void test_2() { 方法不能嵌套定义，一般都是定义在主方法外面 }
		 */
		test_2();// 方法可以嵌套调用
		System.out.println("test_1");
	}

}

方法在内存中的理解

1、定义一个方法，键盘录入两个整数，获取两个整数的最大值
   package Lian;

import java.util.Scanner;

public class Max {
    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();

        int max = getmax(a,b);
        System.out.println(max);
    }
    public static int getmax(int a,int b){
        if (a > b){
            return a;
        }else{
            return b;
        }
    }

}

2、定义一个方法，从外界接收数据控制要打印星星矩阵的行数和列数
package Lian;

public class Ju {
    //2、定义一个方法，从外界接收数据控制要打印星星矩阵的行数和列数
    public static void main(String[] args) {

        printJu(20,20);

    }
    public static void printJu(int hang,int lie){
        for (int i = 1;i <= hang;i++){
            for (int j = 1;j <= lie;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

方法的重载

1、重载：overload，
2、方法的重载：
	在同一个类中，方法名相同，参数列表不同，与返回值类型无关。
3、解释：
	（1）在同一类中：不同无关类中，是不可能发生重载的
	（2）方法名称：一模一样
	（3）参数列表不同：参数的个数不同，参数的类型不同，参数类型的顺序不同。
	（4）与返回值类型无关的。方法是否是重载，与返回值类型没有关系的。
4、方法重载的好处
	（1）没有重载的时候，写一些相同逻辑的代码的时候需要记忆大量的方法名称，不方便
	（2）有重载之后，相同功能逻辑的代码，都使用的是一个方法的名称，不需要去记忆大量方法的名称了。
5、当前学习过的重载：
	println方法，可以打印任意数据类型的，println方法中重载了很多不同的数据类型

//	方法的重载
	public static void main(String[] args) {
//		getSum(1,2);
		int sum = getSum(1,3);
		System.out.println(sum);
	}
	
//	两个数的和 ---------------------------------1
	public static int getSum(int a,int b) {
		System.out.println("int");
		return a + b;
	}
	
//	public static double getSum(int a,int b) {//通过保证参数列表一致，让返回值类型不一致，发现编译报错，所以说明重载跟返回值没有关系的
//		System.out.println("int");
//		return a + b;
//	}
	
//	求三个数的和---------------------------------2
//	通过1,2，参数的个数不同，就是重载的一种体现
	public static int getSum(int a,int b,int c) {
		return a + b + c;
	}
	
//	求两个小数的和--------------------------------3
//	通过1.3，参数的类型不同，也是重载的一种体现
	public static double getSum(double a,double b) {
		System.out.println("double");
		return a + b;
	}
	
//=------------------------------------------4
	public static double getSum(int a,double d) {
		return a + d;
	}
//=------------------------------------------5
//	通过4,5发现，参数的类型的顺序不同，也是重载的一种体现
	public static double getSum(double d,int a) {
		return a + d;
	}
	
	/*
	 * public static double getSum(double dd,int aa) { return a + d; }重载跟参数列表的参数的名称是无关的，只跟类型有关
	 */
}