Java开发从入门到精通（一）：Java的进阶语法知识

Java大数据开发和安全开发

Java的方法
- 1.1 方法是什么
- - 1.1.1 方法的定义
  - 1.1.2 方法如何执行?
  - 1.1.3 方法定义时注意点
  - 1.1.4 使用方法的好处是?
- 1.2 方法的多种形式
- - 1.2.1 无参数无返回值
  - 1.2.2 有参数无返回值
- 1.3 方法使用时的常见问题
- 1.4 方法的设计案例
- - 1.4.1 计算1-n的和
  - 1.4.2 判断一个整数是奇数还是偶数
- 1.5 方法在计算机中的执行原理
- 1.6 Java的参数传递机制
- - 1.6.1 基本类型的参数传递
  - 1.6.2 引用类型的参数传递
  - 1.6.2 引用类型的参数传递案例
  - - 1.6.2.1 打印int类型的数组内容
    - 1.6.2.2 比较两个int类型的数组是否一样
- 1.7 方法重载
- - 1.7.1 方法重载的应用场景
  - 1.7.2 return关键字在方法中单独使用

Java的方法

1.1 方法是什么

方法是一种语法结构，它可以把一段代码封装成一个功能，以便重复调用，

1.1.1 方法的定义

方法的完整格式：
在这里插入图片描述

public class DefineDemo {
    public static void sum1(){
        // 1、李工。  存在两个人都需要求和的功能代码， 这样写冗余且不利于代码的简化  所以使用方法定义求和功能来调用
        int a = 10;
        int b = 20;
        int c = a + b;
        
        // 2、张工.
        int d = 30;
        int e = 20;
        int f = d + e;
    }
    
    public static void main(String[] args) {
        // 目标:掌握定义方法的完整格式，搞清楚使用方法的好处// 需求:假如现在很多程序员都要进行2个整数求和的操作。
        // 1、李工。
        int rs = sum(10, 20);
        System.out.println("和是:" + rs);

        // 2、张工.
        int rs2 = sum(30, 20);
        System.out.println("和是:" + rs2);
    }
	// 定义一个求个方法 在其他地方调用即可，简化了代码
    public static int sum(int a, int b) {
        int c = a + b;
        return c;
    }
}

1.1.2 方法如何执行?

方法定义后，必须调用才可以跑起来，调用格式：方法名(...)

  int rs = sum(10, 20);
  System.out.println("和是:" + rs);

1.1.3 方法定义时注意点

方法的修饰符:暂时都使用public static 修饰。
方法申明了具体的返回值类型，内部必须使用return返回对应类型的数据，
形参列表可以有多个，甚至可以没有;如果有多个形参，多个形参必须用"，”隔开，且不能给初始化值

1.1.4 使用方法的好处是?

在这里插入图片描述

1.2 方法的多种形式

方法定义时:需要按照方法解决的实际业务需求，来设计合理的方法形式解决问题。
1、方法是否需要接收数据处理?
2、方法是否需要返回数据?

1.2.1 无参数无返回值

public class DefineDemo1 {
    public static void main(String[] args) {
        // 目标:掌握按照方法解决的实际业务需求不同，设计出合理的方法形式来解决问题
        // 需求:打印3行Hello World.
        PrintHelloWorld();
        System.out.println("--------------------------");
        PrintHelloWorld();
        System.out.println("--------------------------");
    }
    //无参数 无返回值
    public static void PrintHelloWorld(){
        for (int i = 1; i <= 3; i++) {
            System.out.println("Hello World");
        }
    }
}

1.2.2 有参数无返回值

public class DefineDemo1 {
    public static void main(String[] args) {
        // 目标:掌握按照方法解决的实际业务需求不同，设计出合理的方法形式来解决问题
        // 需求:打印3行Hello World.
        PrintHelloWorld();
        System.out.println("--------------------------");
        PrintHelloWorld();
        System.out.println("--------------------------");

        //需要打印指定行数的Hello World
        PrintHelloWorld(10);
        PrintHelloWorld(5);
    }
    public static void PrintHelloWorld(int n){
        for (int i = 1; i <=n ; i++) {
            System.out.println("Hello World");
        }
    }
}

注意事项

如果方法不需要返回数据，返回值类型必须申明成void(无返回值申明)，此时方法内部不可以使用return返回数据.方法如果不需要接收数据，
则不需要定义形参，且调用方法时也不可以传数据给方法了
没有参数，且没有返回值类型(void)中明的方法，称为无参数、无返回值的方法，依次类推

1.3 方法使用时的常见问题

方法在类中的位置放前放后无所谓，但一个方法不能定义在另一个方法里面。
方法的返回值类型写void(无返回申明)时，方法内不能使用return返回数据，如果方法的返回值类型写了具体类型，方法内部则必须使用return返回对应类型的数据，
return语句的下面，不能编写代码，属于无效的代码，执行不到这儿。
方法不调用就不会执行，调用方法时，传给方法的数据，必须严格匹配方法的参数情况。
调用有返回值的方法，有3种方式:1、可以定义变量接收结果 2、或者直接输出调用，3、甚至直接调用;
调用无返回值的方法，只有1种方式:1、只能直接调用。

public class DefineDemo2 {
    public static void main(String[] args) {
        //- 调用有返回值的方法，有3种方式:1、可以定义变量接收结果  2、或者直接输出调用，3、甚至直接调用;
        // 可以定义变量接收结果
        int rs=sum(10,20);
        System.out.println(rs);
        // 直接输出调用
        System.out.println(sum(10,90));
        //直接调用
        sum(100,20);
        
        //调用无返回值的方法：直接调用
        PrintHelloWorld();

    }

    public static int sum(int a, int b) {
        int c = a + b;
        return c;
    }
    public static void PrintHelloWorld(){
        for (int i = 1; i <= 3; i++) {
            System.out.println("Hello World");
        }
    }
}

1.4 方法的设计案例

设计方法的技巧，主要关注三方面:

1、方法是否需要接收数据进行处理?
2、方法是否需要返回数据?
3、方法要处理的业务(编程能力)

1.4.1 计算1-n的和

1.方法是否需要接收数据进行处理?需要接收n具体的值，因此形参声明为:int n.
2.方法是否需要返回数据?需要返回1-n的求和结果，因此返回值类型声明为int.
3.方法内部的业务:完成求1-n的和并返回，

public class DefineTest1 {
    public static void main(String[] args) {
        int sum1 =sum(10);
        System.out.println(sum1);
        System.out.println("----------------------------");
        int sum2 =sum(100);
        System.out.println(sum2);
    }

    public static int sum(int n){
        int sum = 0;
        for (int i = 0; i <= n; i++) {
            sum +=i;
        }
        return sum;
    }
}

1.4.2 判断一个整数是奇数还是偶数

需要接收一个整数来判断，因此形参声明为:int number.1.方法是否需要接收数据进行处理?
2.方法是否需要返回数据? 方法内部判断完后直接输出结果即可，无需返回，因此返回值类型声明为:void方法内部的业务:通过if语句判断number是奇数还是偶数，并输出结果。

import java.util.Scanner;

public class DefineTest2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请随即输入一个整数：");
        int num = sc.nextInt();
        jiou(num);
    }

    public static void jiou(int n){
        if (n % 2 == 0){
            System.out.println("您输入的是一个偶数");
        }else {
            System.out.println("您输入的是一个奇数");
        }
    }
}

1.5 方法在计算机中的执行原理

方法被调用的时候，是进入到栈内存中运行
栈先进后出

1.methoddemo文件和mian sum方法被依次加载进方法区程序在运行方法区的代码时会先将main方法发到栈内存中执行main方法的具体代码，发现main代码中调用了sum方法，程序再将sum方法加载进栈内存中运行，sum方法运行时会在在栈内存中划分一块区域存储a，b变量然后计算结果，并将结果 30 返回给main函数

返回之后sum方法就算执行完毕，会被销毁

main方法继续往下执行输出结果30后也执行完全部代码完成了任务，也会被销毁

程序执行完毕，栈内资源得到释放

第二个程序：

1.6 Java的参数传递机制

1.6.1 基本类型的参数传递

Java的参数传递机制都是:值传递
所谓值传递:指的是在传输实参给方法的形参的时候，传输的是实参变量中存储的值的副本
实参:在方法内部定义的变量。
形参:定义方法时“(…)”中所声明的参数。

public class MethodDemo {
    public static void main(String[] args) {
        // 目标:理解方法的参数传递机制:值传递、
        int a = 10;  // a的副本传递给形参
        change(a);//change(10);
        System.out.println("main:" + a); // 10
    }

    public static void change(int a) {
        System.out.println("change1:" + a);// 10 
        a = 20;  //修改的是形参的值 对实参没有影响
        System.out.println("change2:" + a);// 20
        
    }
}

change1:10
change2:20
main:10

1.6.2 引用类型的参数传递

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

        int[] arrs = new int[]{10, 20, 30};
        change(arrs);
        System.out.println("main:" + arrs[1]);
    }

    public static void change(int[] arrs) {
        System.out.println("方法内1:" + arrs[1]);
        arrs[1] = 222;
        System.out.println("方法内2:" + arrs[1]);
    }
}

方法内1:20
方法内2:222
main:222

程序执行时加载class文件和里面的main方法和change方法到方法区，运行代码时先将main方法放到栈内存中，执行main的代码首选是声明了一个数组，数组的变量会保存在栈内存中，数组的值会被加载进堆内存中开辟新的内存区域用来存放数组的列表值，然后返回给arrs变量值在堆内存中的内存地址，main再往下执行发现调用了change方法，接着加载chage方法到栈内存中执行change方法的代码，发现change接受的参数是一个数组，但是数字的值是内存地址，直接指向了栈内存的数组列表，所以修改数组的值就是修改栈内存中的值，而且修改完所有引用这个数组列表的变量它的值都会变
在这里插入图片描述

在这里插入图片描述

1.6.2 引用类型的参数传递案例

1.6.2.1 打印int类型的数组内容

1.方法是否需要接收数据进行处理?需要接收一个int类型的数组，因此形参声明为:int[larr.
2.方法是否需要返回数据?方法内部直接输出数组内容即可，无需返回，因此返回值类型声明为:void
3.方法内部的业务:遍历数组，并输出相应的内容，

public class MethodDemo2 {
    public static void main(String[] args) {
        int[] arr1 = {11,12,13,14,15};
        print(arr1);
    }
    public static void print(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i==arr.length-1){
                System.out.print(arr[i]);
            }else {
                System.out.print(arr[i] + ",");
            }
		//三运表达式写法
		 System.out.print(i == arr.length-1 ? arr[i]:arr[i] +"," );

        }
        System.out.println("]");
    }
}

[11,12,13,14,15]

1.6.2.2 比较两个int类型的数组是否一样

1.方法是否需要接收数据进行处理?需要接收两个int类型的数组，因此，形参声明为:intl arr1，intl arr2
2.方法是否需要返回数据? 方法判断完后需要返回:true、false，因此，返回值类型声明为boolean类型
3.方法内部的业务:判断两个数组内容是否一样。

public class MethodDemo3 {
    public static void main(String[] args) {
        int[] arr1 = {11,12,13,14,15};
        int[] arr2 = {11,22,33,44,55};
        arravg(arr1,arr2);
    }
    public static boolean arravg(int[] arr1,int[] arr2){
        if (arr1==null && arr2==null){
            return true;
        }
        if (arr1 == null || arr2 ==null) {
            return false;
        }

        if (arr1.length != arr2.length){
            return false;
        }

        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] !=arr2[i]){
            return false;// 不相等
            }
        }
        return true;
    }
}

1.7 方法重载

一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了

public class MethodLoadDemo {
    public static void main(String[] args) {
        // 目标:认识方法重载，并掌握其应用场景。

    }
    public static void test (){

    }

    public static void test (int a){
    
    }
}

一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管(如:修饰符返回值类型是否一样都无所谓)。
形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。

1.7.1 方法重载的应用场景

开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。

案例导学：

开发武器系统，功能需求如下:

① 可以默认发一枚武器。
②可以指定地区发射一枚武器。
③可以指定地区发射多枚武器。

public class MethodLoadDemo1 {
    public static void main(String[] args) {
        fire();
        System.out.println("--------------------------");
        fire("美国");
        System.out.println("--------------------------");
        fire("美国",55555);
    }

    public static void fire(){
        System.out.println("默认给小日子发送一枚导弹");
    }

    public static void fire(String country){
        System.out.println("指定给" + country + "发送一枚导弹");
    }

    public static void fire(String country,int num){
        System.out.println("指定给" + country + "发送" + num +"个导弹");
    }
}

在这里插入图片描述

1.7.2 return关键字在方法中单独使用

1.在无返回值的方法中，如果要直接跳出并结束当前方法的执行，怎么解决?

return;跳出并立即结束所在方法的执行
break;跳出并结束当前所在循环的执行，
continue;结束当前所在循环的当次继续，进入下一次执行，

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


        System.out.println("开始");
        chu(10, 0);
        System.out.println("结束");
    }

    public static void chu(int a, int b) {
        if (b == 0) {
            System.err.println("您的数据有误 !!不执行 !!");
            return;//l直接跳出并结束当前chu方法的执行
        }
        int c = a / b;
        System.out.println("除法结果是:" + c);
    }
}