Java方法详解 数组练习题

方法

什么是方法？

方法（method）是程序中最小的执行单元

小结：

@ 1 什么是方法？

方法是程序中最小的执行单元

@ 2 在实际开发中 什么时候用到方法？

重复的代码 、具有独立功能的代码可以抽取到方法中

@ 3 实际开发中 方法有什么好处？

 1 可以提高代码的复用性

 2 可以提高代码的可维护性

方法的格式

把一些代码打包在一起 用到的时候就调用

方法定义

把一些代码打包到一起 该过程称为方法定义

方法调用

方法定义后并不是直接运行的 需要手动调用才能执行 该过程称为方法调用

方法的定义格式

最简单的方法定义和调用

格式

public static void 方法名(){
    方法体 （ 就是打包起来的代码 ）;
}

范例

public static void playGame(){
     七个打印语句
}

代码：

package com.Test;

public class Demo01 {
    public static void main(String[] args) {
        //最简单的调用格式
        
        //调用方法
        playGame();
        
    }
    //定义一个方法
    public static void playGame(){
        System.out.println("选人物");
        System.out.println("开始");
        System.out.println("进攻");
        System.out.println("崩盘");
        System.out.println("失败");
        System.out.println("GG");
    }
}

练习

展示女朋友信息

需求：

定义一个方法 在方法内部打印女朋友的所有信息 

（⚠️不是所有女朋友信息 是一个女朋友的所有信息）

代码：

package com.Test;

public class Demo01 {
    public static void main(String[] args) {
        //利用最简单的格式完成当前练习

        playGame();
    }
    public static void playGame(){
        System.out.println("小花");
        System.out.println("18岁");
        System.out.println("身高168");
        System.out.println("体重100斤");
        System.out.println("喜欢吃海鲜");
        System.out.println("不喜欢吃香菜");
        System.out.println("喜欢喝鲜榨西瓜汁");
    }
}

看代码说结果 @ 1

目标 ：能说出方法调用执行过程 

package com.Test;

public class Demo01 {
    public static void main(String[] args) {
        System.out.println("a");
        System.out.println("b");
        metnod();
    }
      public static void metnod(){
          System.out.println("c");
          System.out.println("d");
      }
}

看到方法进入方法

执行完毕回到调用处

看代码说结果 @ 2

package com.Test;

public class Demo01 {
    public static void main(String[] args) {
        System.out.println("a");
        metnod1();
        System.out.println("b");
        
    }
      public static void metnod1(){
          method2();
          System.out.println("c");
      }
      public static void method2(){
          System.out.println("d");
          System.out.println("e");
      }
}

结果：

首先进入打印 a 然后进入method 1

从 1 有进入 2 打印 d e 然后在打印 c 最后是 b

 人肉计算器

需求 ：

定义一个方法 方法内部定义两个变量 

求出他们的和并进行打印

package com.Test;

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

        playGame();

      }
      public static void playGame(){
        int a = 19;
        int b = 100;
        int c = a + b;
          System.out.println(c);
      }
}

带参数的方法定义和调用

带参数的方法

单个参数​​​​​​​ ：方法名 （ 参数 ）;

范例 1 method（ 10 ）;

范例 2 method （ 变量 ）;

调用

多个参数 ：方法名（ 参数 1 ，参数 2 ，…… ）;

范例 1 getSum（ 10 ，20 ）;

范例 2 getSum（ 变量 1 ，变量 2 ）;

⚠️

方法调用时 参数的数量与类型必须与方法定义中小括号里面的变量一一对应

否则程序报错

package com.Test;

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

        getSum(10,20);

      }
      public static void getSum(int num1,int num2){
        int result = num1 + num2;
          System.out.println(result);
      }
}

形参和实参

形参：

全称形式参数 是指方法定义中的参数

实参：

全称实际参数 方法调用中的参数

代码演示：

package com.Test;

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

        getSum(10,20);  //(10,20) 实参
        
        int a = 10;
        int b = 20;
        getSum(a,b);  //(a,b) 实参

      }
      //(int num1, int num2) 形参
      public static void getSum(int num1,int num2){  
        int result = num1 + num2;
          System.out.println(result);
      }
}

练习

人肉计算机 1

需求：

定义一个方法 求长方形周长 将结果在方法中进行打印

代码：

package com.Test;

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

        getSum();
      }
      public static void getSum(){
         int a = 10;
         int wide = 4;
         int perimeter = ((a+wide)*2);
          System.out.println(perimeter);
      }
}

package com.Test;

public class Demo01 {
    public static void main(String[] args) {
        getLength(10,4);
      }
      public static void getLength(int len,int wide){
        int result = (len + wide)*2;
          System.out.println(result);

      }
}

扩展回顾键盘录入

package com.Test;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入长方形的长");
        int len = scanner.nextInt();
        System.out.println("请输入长方形的宽");
        int wide = scanner.nextInt();
        getLength(len,wide);
      }
      public static void getLength(int len,int wide){

        int result = (len + wide)*2;
           System.out.println("长方形的周长为"+result);

      }
}

人肉计算机 2 

需求：

定义一个方法 求圆的面积

将结果在方法中说明

​​​​​​​代码

package com.Test;

public class Demo01 {
    public static void main(String[] args) {
       getSum(3.14,3);
      }
      public static void getSum(double constant,double radius){
        double area = (constant*(radius*radius));
          System.out.println(area);

      }
}

代码

package com.Test;

public class Demo01 {
    public static void main(String[] args) {
       getSum(3);
      }
      public static void getSum(double radius){
        double area = (radius*radius*3.14);
          System.out.println(area);

      }
}

带返回值方法的定义和调用

格式

public static 返回值类型 方法名 (参数){
     方法体;
     return 返回值;
}

范例

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

小结

什么时候用到返回值方法？

在调用处要根据方法的结果 去编写另外一段代码

有返回值的定义格式

public static 返回值类型 方法名 (参数){
       方法体;
       return 返回值;
}

有返回值方法的调用格式

直接调用 赋值输出 输出调用

有返回值方法中参数的运行过程

练习

需求：

定义一个方法 求一家商场每个季度营业额 根据方法在计算出全年营业额

package com.Test;

public class Demo01 {
    public static void main(String[] args) {
        //掌握带返回值方法的定义和调用格式

        //直接调用
       // getSum(10,20,30);

        //赋值调用
        //int sum = getSum(10,20,30);
        //System.out.println(sum);

        //输出调用
        //System.out.println(getSum(10,20,30));

        //先计算第一季度的营业额
        int sum1 = getSum(10,20,30);
        //计算第二季度的营业额
        int sum2 = getSum(20,30,40);
        //计算第三季度的营业额
        int sum3 = getSum(20,30,40);
        //计算第四季度的营业额
        int sum4 = getSum(20,30,40);

        //全年
        int sum = sum1 + sum2 + sum3 +sum4;

        System.out.println(sum);
    }
    public static int getSum(int num1,int num2,int num3){
        int result = num1 +num2 +num3;
        return result;
    }
}

定义一个方法 比较两个长方形面积

package com.Test;

public class Demo01 {
    public static void main(String[] args) {
        //计算两个长方形面积并比较
        int area = (getSum(4,10));
        int area1 = (getSum(5,11));
        System.out.println(area);
        System.out.println(area1);
        if (area>area1){
            System.out.println(" 长方形面积area " + area + " 大于area1 "+area1);

        }else{
            System.out.println(" 长方形面积area1 " + area1 + " 大于area "+area);
        }


    }
    public static int getSum(int wide,int lo){
        int area = wide *  lo;
        int area1 = wide *  lo;
        return area;
    }
}

package com.exception.demo02;

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

        double area1 = getArea(5.3,1.7);
        double area2 = getArea(2.4,2.7);

        if (area1 > area2){
            System.out.println("第一个长方形更大");
        }else{
            System.out.println("第二个长方形更大");
        }

    }
    public  static double getArea(double len,double width){
        double area = len * width;
        return area;
    /*public static void compare(double len1,double width1, double len2,double width2) {
        double area1 = len1 + width1;
        double area2 = len2 + width2;

        if (area1 >area2){
            System.out.println("第一个长方形更大");
        }else{
            System.out.println("第二个长方形更大");
        }

     */

    }
}

方法的重载

在同一个类中 定义了多个同名的方法 这些同名的方法具有同种的功能

每个方法具有不同的参数类型或参数个数 这些同名的方法 就构成了重载关系

简单记

同一个类中 方法名相同 参数不同的方法 与返回值无关

参数不同 个数不同 类型不同 顺序不同

顺序不同可以构成重载 但是不建议

练习

@ 1  方法重载

需求：

使用方法重载的思想 设计比较两个整数是否相同的方法

要求：

兼容全整数类型 （byte ， short ， int ， long  ）

package com.exception.demo02;

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

        //调用
        //compare(10,20);

        //强转调用byte
        //compare((byte)10,(byte)20);

        byte sum1 = 10;
        byte sum2 = 20;
        compare(sum1,sum2);

    }
    //会把相同功能的方法起成一样的名字
    //定义方法的时候不需要这么多的单词
    //调用方法的时候不需要这么麻烦了

    public static void compare(byte sum1,byte sum2){
        System.out.println("byte");
        System.out.println(sum1 == sum2);
    }
    public static void compare(int a,int b){
        System.out.println("int");
        System.out.println(a  ==  b);
    }public static void compare(long sam1,long sam2){
        System.out.println("long");
        System.out.println(sam1 == sam2);
    }
    public static void compare(short run1,short run2){
        System.out.println("short");
        System.out.println(run1 == run2);
        return;
    }
}

@ 2  数组遍历

需求：

设计一个方法用于数组遍历

要求：

遍历结果是在一行上的    例如：[11 ，22 ，33 ，44 ，55 ]

package com.exception.demo02;

public class Demo15 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {11,22,33,44,55};


        //调用遍历数组
        printArr(arr);

        /*
        System.out.println("abc");  先打印abc 在进行换行
        System.out.print("abc");     只打印abc 不换行
        System.out.println("bcd");

        System.out.println();    不打印任何数据 只进行换行处理

         */
    }
    public static void printArr(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.println("]");
    }
}

@ 3  数组最大值

需求：

设计一个方法求数组的最大值 并将 最大值返回

package com.exception.demo02;

public class Demo14 {
    public static void main(String[] args) {
        int[] arr = {1,5,7,3,8,10};

        int max = getMax(arr);

        System.out.println(max);
    }
    public static int getMax(int[] arr){
        int max = arr[0];

        for (int i = 0; i < arr.length; i++) {
            if (arr[i]>max){
                max = arr[i];
            }
        }
        return max;
    }
}

@ 4 判断是否存在

定义一个方法判断数组中的某一个数是否存在 将结果返回给调用处

package com.exception.demo02;

public class Demo14 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {1,5,8,56,67,34,89,12};

        //判断一个数字在数组中是否存在了
        boolean flag = contains(arr,89);

        System.out.println(flag);
    }
    public static boolean contains(int[] arr,int number){
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]== number){
               return true;
            }

        }
        return false;
    }
}

@ 5  复制数组

需求：

定义一个方法 copyOfRange（int[] arr, int from, int to）

功能：

将数组 arr 从索引 from （包含 from ）开始

到索引 to 结束 （不包含 to ）的元素复制到新数组中

将新数组返回

package com.exception.demo02;

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

        int[] arr = {1,2,3,4,5,6,7,8,9};

        //调用方法拷贝数据
        int[] copyArr = copyOfRange(arr,3,7);

        for (int i = 0; i < copyArr.length; i++) {
            System.out.print(copyArr[i]+" ");
        }

    }
    public static int[] copyOfRange (int[] arr,int from,int to){
        //定义数组
        //动态初始化：不知道所有元素使用
        int[] newArr = new int[to - from];

        //把原始数组arr中的from到to上对应的元素 直接拷贝到newArr
        int index = 0;
        for (int i = from; i < to; i++) {
            //格式 数组名[索引] = 数据值
            newArr[index] = arr[i];
            index++;
        }
        return newArr;
    }
}

方法的内存

方法调用的基本内存原理

方法被调用之后就会进栈执行

栈 先进后出

Java内存分配

栈： 方法运行时使用的内存 方法进栈运行 运行完毕就出栈  //

堆： new 出来的 都在堆内存中开辟了一个小空间 //

方法区：存储可以运行的 class 文件

本地方法栈： JVM 在使用操作系统功能的时候使用 和我们开发无关

寄存器：给 CPU 使用 和我们开发无关 

基本数据类型和引用数据类型

基本数据类型

变量中存储的是真实数据

引用数据类型

变量中存储的是地址值

引用：使用了其他空间中的数据

从内存的角度去解释：

基本数据类型：

数据值存储在自己的空间中

特点：赋值给其他变量 也是赋的真实的值

引用数据类型：

数据值是存储在其他空间中 自己空间里面存储的是地址值

特点：赋值给其他变量 赋的地址值

方法传递基本数据类型的内存原理

传递基本类型时 传递的是真实的数据 形参的改变 不影响实际参数的值

传递引用数据类型时 传递的是地址值 形参的改变 影响实际参数的值

方法传递参数的结论

基本数据类型：

传递的是真实的数据

​​​​​​​引用数据类型：

传递的是地址值