Java学习第五天笔记

Java学习第五天笔记

流程控制语句之循环语句
	for循环
	while循环	
		while语句
		do...while语句
控制跳转语句
	break
	continue
	return
方法(函数)

04.01_Java语言基础(循环结构概述和for语句的格式及其使用)(掌握)

案例：在控制台输出10次"helloworld";
A:什么是循环结构
	循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，
	需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环
B:循环结构的分类
	for循环
	while循环
C:循环结构for语句的格式：
	for(初始化表达式语句;判断条件语句;控制条件语句) {
		循环体语句;
	}
D:执行流程：
	a:执行初始化表达式语句
	b:执行判断条件语句,看其返回值是true还是false
		如果是true，就继续执行
		如果是false，就结束循环
	c:执行循环体语句;
	d:执行控制条件语句
	e:回到B继续。	
E: 注意事项:
	初始化表达式语句只执行一次

把刚才的需求使用for循环进行改进。

04.02_Java语言基础(循环结构for语句的练习之获取数据)(掌握)

A:案例演示
	需求：请在控制台输出数据1-10
	需求：请在控制台输出数据10-1
B:注意事项
	a:判断条件语句无论简单还是复杂结果是boolean类型。
	b:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
	c:一般来说：有左大括号就没有分号，有分号就没有左大括号

04.03_Java语言基础(循环结构for语句的练习之求和思想)(掌握)

A:案例演示:	需求：求出1-10之间数据之和
B:学生练
	需求：求出1-100之间偶数和
	需求：求出1-100之间奇数和

04.04_Java语言基础(循环结构for语句的练习之水仙花)(掌握)

A:案例演示
	需求：在控制台输出所有的”水仙花数”

	所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
	举例：153就是一个水仙花数。
	153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153

04.05_Java语言基础(循环结构for语句的练习之统计思想)(掌握)

A:案例演示:    需求：统计”水仙花数”共有多少个

04.06_Java语言基础(循环结构while语句的格式和基本使用)(掌握)

A:循环结构while语句的格式：
	while循环的基本格式：
		while(判断条件语句) {
			循环体语句;
		}
	完整格式：
	    初始化条件语句;
	    while(判断条件语句) {
			 循环体语句;
			 控制条件语句;
	   }
B:执行流程：
	a:执行初始化条件语句;
	b:执行判断条件语句,看其返回值是true还是false
		如果是true，就继续执行
		如果是false，就结束循环
	c:执行循环体语句;
	d:执行控制条件语句
	e:回到b继续。
C:案例演示
	需求：在控制台输出10次"helloworld"
	需求：请在控制台输出数据1-10

04.07_Java语言基础(循环结构while语句的练习)(掌握)

A:求和思想:	求1-100之和
B:统计思想:	统计”水仙花数”共有多少个

04.08_Java语言基础(循环结构do…while语句的格式和基本使用)(掌握)

A:循环结构do...while语句的格式：
	do {
		循环体语句;
	}while(判断条件语句);
	
	完整格式；
		初始化条件语句;
		do {
			循环体语句;
			控制条件语句;
		}while(判断条件语句);
B:执行流程：
	a:执行初始化条件语句;
	b:执行循环体语句;
	c:执行控制条件语句;
	d:执行判断条件语句,看其返回值是true还是false
		如果是true，就继续执行
		如果是false，就结束循环
	e:回到b继续。
C:案例演示
	需求：在控制台输出10次"helloworld"
	需求：请在控制台输出数据1-10

04.09_Java语言基础(循环结构三种循环语句的区别)(掌握)

三种循环语句的区别:
	(1):do...while循环至少执行一次循环体。
		而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
	(2):A： 如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用for循环。
			因为变量及早的从内存中消失，可以提高内存的使用效率。
		B:建议优先考虑for循环，然后是while循环 ，最后是do...while循环

04.10_Java语言基础(循环结构注意事项之死循环)(掌握)

A:一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
B:两种最简单的死循环格式
	while(true){...}
	for(;;){...}

04.11_Java语言基础(循环结构循环嵌套输出4行5列的星星)(掌握)

A:案例演示
	需求：请输出一个4行5列的星星(*)图案。
	如图：
		*****
		*****
		*****
		*****
	注意：
		System.out.println("*");和System.out.print("*");的区别
B:结论：
	外循环控制行数，内循环控制列数

04.12_Java语言基础(循环结构循环嵌套输出正三角形)(掌握)

A:案例演示
	需求：请输出下列的形状
	*
	**
	***
	****
	*****

04.13_Java语言基础(循环结构九九乘法表)(掌握)

A:案例演示
	需求：在控制台输出九九乘法表。
B:代码优化
	注意：
	'\x' 	x表示任意，这种做法叫转义字符。
	
	'\t'	tab键的位置
	'\n'	换行

04.14_Java语言基础(控制跳转语句break语句)(掌握)

A:什么是控制跳转语句
	前面我们已经说过了，Java中的goto是保留字，目前不能使用。虽然没有goto语句可以增强程序的安全性，但是也带来很多不便，
	比如说，我想在某个循环执行到某一步的时候就结束，现在就做不了这件事情。
	为了弥补这个缺陷，Java就提供了break，continue和return来实现控制语句的跳转和中断。
B:控制跳转语句的分类
	break 中断
	continue 继续
	return 返回 
C:break的使用场景
	(1):在选择结构switch语句中
	(2):在循环语句中
	注意：离开使用场景的存在是没有意义的
D:作用
	a:退出单层循环
	b:退出多层循环(几乎不使用)
		要想实现这个效果，就必须知道一个东西;带标签的语句；
		格式：标签名：语句

04.15_Java语言基础(控制跳转语句continue语句)(掌握)

A:continue的使用场景
	(1):在循环语句中
	(2):离开使用场景的存在是没有意义的
B:作用
	a:跳出一次循环，执行下一步操作
C:练习题
	for(int x=1; x<=10; x++) {
		if(x%3==0) {
			//在此处填写代码
		}
		System.out.println(“Java基础班”);
	}
	
	我想在控制台输出2次:“Java基础班“
	我想在控制台输出7次:“Java基础班“
	我想在控制台输出13次:“Java基础班“	

04.16_Java语言基础(控制跳转语句return语句)(掌握)

A:return的作用
	return 就是退出一个方法。
	跳转到上层调用的方法。这个在方法的使用那里会在详细的讲解。
B:案例演示
	return: 		结束当前方法
	break:		结束单层循环
	continue:		结束当前循环，执行下一次循环

04.17_Java语言基础(方法概述和格式说明)(理解)

A:为什么要有方法
	假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹(植物大战僵尸)。
	发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很臃肿，可读性也非常差。
	为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，
	这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，
	程序在需要发射炮弹时调用该方法即可。
B:什么是方法
	方法就是完成特定功能的代码块
	在很多语言中都有函数的定义，但是在咱们JAVA语言中，我们将其称之为方法。
C:方法的格式
	修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2 ....){
		方法体;
		return 返回值;
	}
D:方法的格式详细说明
	(1): 修饰符 			比较多,后面会详细介绍。目前使用  public static
	(2): 返回值类型 		用于限定返回值的数据类型
	(3): 方法名			就是一个名称，它的存在是为了方便我们调用方法
	(4): 参数类型 			限定调用方法时传入参数的数据类型
	(5): 参数名 			是一个变量，接收调用方法时传入的参数
							        这个参数其实有一个专业的名词,被称之为形式参数,它的作用是用来接收实际参数的.
	(6): 方法体 			完成功能的代码
	(7): return 			结束方法以及返回方法指定类型的值 
	(8): 返回值 			就是功能的结果，由return带回，带回给调用者

04.18_Java语言基础(方法之求和案例及其调用)(掌握)

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

04.19_Java语言基础(方法的调用图解)

A:画图演示:把刚才的的推荐调用方式画图解释

04.20_Java语言基础(方法的练习)(掌握)

A:案例演示:	需求：获取两个数中的较大值	
B:案例演示:	需求：比较两个数是否相等
使用键盘录入改进

04.21_Java语言基础(方法的注意事项)(理解)

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

04.22_Java语言基础(方法之输出星形及其调用)(掌握)

A:案例演示
	需求：根据键盘录入的行数和列数，在控制台输出星形
B:方法调用：(没有明确返回值的调用)
	单独调用
	输出调用(错误)
	赋值调用(错误)

04.23_Java语言基础(方法的练习)(掌握)

A:案例演示:	需求：根据键盘录入的数据输出对应的乘法表

04.24_Java语言基础(方法重载概述和基本使用)(掌握)

A:案例演示
	求和案例
		2个整数
		3个整数
		4个整数
B:方法重载概述
	在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同，与返回值无关。
	参数列表不同：
		A:参数个数不同
		B:参数类型不同

总结：

1.方法 封装一段逻辑功能 实现方法复用性，方法与方法是平级关系，不能嵌套定义。方法不调用不执行。调用方法通过方法名直接调用，方法名（）。语法：权限修饰符 状态修饰符 返回值类型 方法名（参数）{方法体}

2.循环语句 for与嵌套

public class MyDemo2 {
    public static void main(String[] args) {
      /* A:
        案例演示
        需求：请输出一个4行5列的星星( *)图案。
        如图：

      *****
      *****
      *****
      *****
      *
      *
      *
      *
      * */
      //循环嵌套
        //外层循环：控制行数
        //内层循环：控制列数
        //for循环加嵌套
        for (int i = 0; i <10; i++) {
            for (int j = 0; j < 10; j++) {
                //打印不换行 print("*");
                System.out.print("*");
            }
            //只是换行，不输出然后内容
            System.out.println();
        }

    }
}

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

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");
        }
    }
}

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();
        }
    }
}

 */
public class MyDemo {
    public static void main(String[] args) {
        //输出偶数
        //continue 跳出一次循环，继续下一次循环。也是使用在循环语句中，离开循环场景没有任意
        for (int i = 1; i <= 10; i++) {
            //对2取余值为1
            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基础班");
        }
    }
}

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;
    }

}

public class MyDemo5 {
    public static void main(String[] args) {
       /* A:
        案例演示:
        需求：根据键盘录入的数据输出对应的乘法表*/
       //定义方法：要明确两个东西 返回值 参数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入整数");//键盘录入
        int num = sc.nextInt();
        show(num);//方法调用
    }

    public static void show(int num) {
        for (int i = 1; i <=num; i++) {
            for (int j = 1; j <=i; j++) {
                System.out.print(j+"*"+i+"="+(j*i)+"\t");
            }
            System.out.println();
        }
    }
}

方法重载

public class MyDemo {
    public static void main(String[] args) {
        //求两个数，相加的结果

        //求三个数，相加的结果
        //求四个数,相加的结果
        int sum1 = add(1, 2);
        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;
    }
}