Java基础知识 05（break,continue,return语句，方法调用，数组定义）

Java基础知识 05

控制跳转语句

循环嵌套：System.out.print( );       //打印不换行
		 System.out.println( );     //打印换行
1.break语句：中断（1）在选择结构switch语句中
				（2）在循环语句中
作用：推出单层循环，写在哪一层循环中，结束的就是哪一层循环。
2.continue语句：继续（1）在循环语句中
					（2）离开使用场景的存在是没有任何意义的
作用：跳出这一次循环，执行下一步操作。
3.return语句：退出一个方法，跳转到上层调用的方法。
作用：结束方法并返回。方法最后默认存在return。
	方法的返回值类型是void,这个return可以直接省略。

package demo.MyDemo;

public class test4 {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if(i%3==0){
                //break;
                //continue;
                System.out.println("Java学习");
            }
            System.out.println("Java学习");
        }
    }
}

方法调用

方法：完成特定功能的代码块
	就是封装一段功能，以实现代码的复用性。
定义方法的语句：（1）可以仿照main方法。
			  （2）方法定义在类中，方法和方法是平级关系，不能嵌套定义。
			  （3）语法：权限修饰符 状态修饰符 返回值类型 方法名 参数
			               public   static     void    send   ()     
                        {
                            //方法体，封装要实现的功能。
                        }
              （4）方法不调用不执行。
              （5）如何调用我们定义的方法呢？可以在main中调用我们的方法执行。
              （6）调用的语法：System.out.println("主方法调用")；
              //通过方法名直接调用      send();
  返回值类型：void表示这个方法，没有明确的返回数据。如果你的方法要返回数据，那么你就要明确表示你的方法，要返回什么样的类型的数据。如果你的方法一旦明确了返回值类型，那么就必须通过一个关键字return来带回与你明确了数据类型一致的值。

******定义方法：要明确两个方面：是否需要返回值？是否需要返回参数？需要返回几个参数？
（1）我们可以把要相加的两个数，作为参数传入进来。
（2）定义在方法的括号里的参数，我们叫做形式参数，简称形参。
（3）形参的作用：用来接收调用方法，所传入的数据。

案例程序分析1，输出****：

package demo2;

import java.util.Scanner;

public class test {
    public static void main(String[] args) {
        //调用方法来实现星星。
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个数");
        int lieshu = scanner.nextInt();
        System.out.println("请输入第二个数");
        int hangshu = scanner.nextInt();
        xingxing(lieshu,hangshu);
    }
    public static void xingxing(int lieshu,int hangshu){
        for (int i = 1; i <= hangshu; i++) {
            System.out.println();
            for (int j = 1; j <= lieshu; j++) {
                System.out.print("*");
            }
        }
    }
}

案例程序分析2：

package demo2;

public class test2 {
    public static void main(String[] args) {
        System.out.println("调用输出结果");
        //调用函数名为add的函数，
        add();
        int sum=add();
        //调用函数名为add2的函数
        add2();
        double sum2=add2();
    }
    //返回值类型int必须与调用结果的类型一致
    public static int add(){
        int a=10;
        int b=10;
        int sum=a+b;
        System.out.println(sum);
        return sum;
    }
    //返回值类型double必须与调用结果的类型一致
    public static double add2(){
        int a=10;
        int b=50;
        double sum=a+b+2.5;
        System.out.println(sum);
        return sum;
    }
}

案例程序分析3：

package demo2;

public class test4 {
    public static void main(String[] args) {
        //两个数相加的结果
        //三个数相加的结果
        //四个数相加的结果
        int sum1 = add(a:1,b:2);
        int sum2 = add1(a:1,b:2,c:3);
        int sum3 = add2(a:10,b:20,c:30,d:40);

        System.out.println(sum1);
        System.out.println(sum2);
        System.out.println(sum3);

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

******方法重载：允许一个类中出现多个同名方法,只要它们的形参个数或者形参类型不一样即可，在调用时，
			会根据传入的参数个数和参数类型，会自动匹配。

案例程序分析4，输出乘法口诀表：

package demo2;

import java.util.Scanner;

public class test3 {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数");
        int num = sc.nextInt();
        chengfa(num);
    }
    private static void chengfa(int num) {
        for (int i = 1; i <= num; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i+"*"+j+"="+i*j+"\t");
            }
            System.out.println();
        }
    }
}

数组定义

数组：就像一个容器，可以存储多个相同数据类型的元素。
	数组是存储多个变量（元素）的容器。
	这多个变量的数据类型要保持一致。
	数组可以存储基本数据类型也可以存储引用数据类型。
	基本数据类型：4类8种
	引用数据类型：数组，类，接口，枚举。
数组语法定义格式：int[] arr=new int[5];
				数据类型[] 数组名=new int[数组长度]；
		Java中的数组必须先初始化，然后才能使用。
		所谓的初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
初始化的分类：动态初始化：只给定长度，由系统给出初始值。
			静态初始化：给出初始化值，由系统决定长度。

案例程序分析5：

package demo3;

public class test1 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = new int[5];
        boolean[] arr1 = new boolean[5];
        char[] arr2 = new char[5];
        double[] arr3 = new double[5];

        int one = arr[0];
        System.out.println(one);//0
        boolean two = arr1[0];
        System.out.println(two);//false

        arr[0]=10;
        arr[1]=20;
        arr[2]=30;
        arr[3]=40;
        arr[4]=50;
        System.out.println(arr[0]);//10
        System.out.println(arr[1]);//20
        System.out.println(arr[2]);//30
        System.out.println(arr[3]);//40
        System.out.println(arr[4]);//50
        // byte short int long 整形数组默认值都是0
        // float double 数组 默认值是0.0
        //boolean 数组默认值是false
        // char 数组默认值是空格字符 "\u0000"
        System.out.println(arr1[0]);//false
        System.out.println(arr2[1]);//空格
        System.out.println(arr3[2]);//0.0
    }
}

​