java方法练习

学习目标：

• 掌握 Java 方法知识

---

1.

/*
1. 编写程序，声明一个method方法，
在方法中打印一个10x8 的*型矩形， 在main方法中调用该方法。

2. 修改上一个程序，在method方法中，
除打印一个10x8的*型矩形外，再计算该矩形的面积，并将其作为方法返回值。
在main方法中调用该方法， 接收返回的面积值并打印。

3. 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个 mxn的*型矩形，并计算该矩形的面积，
将其作为方法返回值。在main方法 中调用该方法，接收返回的面积值并打印。
 */
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args) {
//              method();
       /* int area = method1();
        System.out.println("面积为："+area);*/
           int area = method2(8,9);
           System.out.println("面积为："+area);
    }

   /* public static void method(){
        for (int i=0;i<10;i++)
        {
            for (int j=0;j<8;j++)
            {
                System.out.print("*");
            }
            System.out.println();
        }*/

        /*public static int method1(){
            for (int i=0;i<10;i++)
            {
                for (int j=0;j<8;j++)
                {
                    System.out.print("*");
                }
                System.out.println();
            }
            return 10*8;
        }*/

           public static int method2(int m , int n){
               for(int i=0;i<m;i++)
               {
                   for(int j=0;j<n;j++)
                   {
                       System.out.print("*");
                   }
                   System.out.println();
               }
               return m*n;
           }
}

思路：
1）声明一个method方法，10*8的矩阵，利用for循环，一个是行数一个是列数，嵌套起来，每一列打印完要转行，这样就是一个由符号组成的矩形了。在main方法中直接调用它，method();即可。
2）method1方法和method类似，增加了一个计算矩形面积，因为需要返回值，所以在声明时标注返回值的类型为int类型，在main方法调用时，定义一个int变量 area(和方法定义一致)，然后打印输出面积。
3）method2的方法核心不变，这里调用时需要两个参数m和n，一个是行数，一个是列数，打印好矩形后，返回面积也就是m乘n，在main方法中声明int area = method2(8,9); m=8，n=9。

2.

/*
编写程序，定义三个重载方法并调用。方法名为mOL。
三个方法分别接收一个int参数、两个int参数、一个字符串参数。
分别 执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
在主类的main ()方法中分别用参数区别调用三个方法。
 */
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args) {
         int aquare = mOL(5);
         int multiply = mOL(2,3);
         String output = mOL("重载方法");
         //方法的调用
    }

    public static int mOL(int a){//一个int型参数
        System.out.println(a+"的平方运算："+a*a);
        return a*a;//返回平方结果
    }

    public static int mOL(int m , int n){//两个int型参数
        System.out.println(m+"和"+n+"的相乘结果："+m*n);
        return m*n;//返回相乘结果
    }

    public static String mOL(String str){//一个字符串参数
        System.out.println("字符串为："+str);
        return str;//返回字符串
    }
}

3.

/*
定义三个重载方法max()，第一个方法求两个int值中的最大值，
第二个方法求两个double值中的最大值，
第三个方法求三个double值中的最大值，并分别调用三个方法。
 */
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args) {
           int a =max(2,3);
           System.out.println("最大值1："+a);
           double b =max(2.5,3.6);
           System.out.println("最大值2："+b);
           double c =max(1.3,2.1,3.2);
           System.out.println("最大值3："+c);
    }
    public static int max(int a,int b){//两个int型参数
             return (a>b)?a:b;
    }
    public static double max(double a , double b){//两个double型参数
             return (a>b)?a:b;
    }
    public static double max(double a ,double b,double c){//三个double型参数
             return (max(a,b)>c)?max(a,b):c;
    }
}

思路：
1）方法定义时，因为题目条件比较简单，可以直接使用return返回表达式的值，省去实现比较数的大小的代码，在main中进行调用和打印输出比较结果。

4.

/*
统计高于平均分的分数有多少个。
- 定义数组[95, 92, 75, 56, 98, 71, 80, 58, 91, 91]。
- 定义getAvg方法，获取一个数组中的平均数
  打印效果：高于平均分80的个数有5个
 */
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args) {
        int[] a = {95,92,75,56,98,71,80,58,91,91};//定义数组
        getAvg(a);//调用getAvg方法
    }

    public  static  void getAvg(int a[]){
        if(a != null && a.length>0){//考虑到数组为空且无元素的情况
            int sum=0;
            int a1;
            for(int i=0;i<a.length;i++) {
                sum+=a[i];//遍历得到总分
            }
            a1=sum/a.length;//除以数组个数得到平均分
            System.out.print("高于平均分"+a1);
            int count=0;
            for(int i=0;i<a.length;i++) {
                if(a[i]>sum) {//遍历找到高于平均分的分数有几个
                    count++;
                }
            }
            System.out.println("的个数有"+count+"个");
        }else{//打印输出两种情况
            System.out.println("数组为空或数组里面没有元素！");
        }

    }
}

问题：没有考虑到数组为空或者没有元素的情况，使用带参数的方法定义和调用时，没有想清楚参数是哪一个和哪种类型，以及得到总分后，求平均分可以使用length方法获取数组的个数，不必再次使用遍历。
解决：
1）首先是确定方法定义和调用的参数，为了获取一组数组的平均数，应该是需要访问整个数组，所以参数是定义的数组，int a[ ]
2）方法定义时，要考虑特殊情况，如果这个数组为空且无元素，那么就直接打印输出提示错误，符合条件了，再接着之后的操作。
3）先得到平均分，定义一个sum，遍历将所有分数加起来之后，除以数组个数，得到平均分；之后要找到高于平均分的分数个数有几个，定义一个count，数组遍历如果高于平均分，则count++，最终打印输出，得到’'高于平均分80的个数有5个"的效果。
4）在main方法中直接方法调用getAvg(a);

5.

/*
定义equals方法，比较数组内容是否完全一致。
代码实现，效果如图所示：
数组1：{1,2,3,6,7,8}和数组2：{1,2,3,6,7,8}是完全一致的
提示：长度一致，内容一致，定义为内容完全一致。
 */
public class HelloWorld {
    public static void main(String[] args) {
        int[] a ={1,2,3,6,7,8};
        int[] b ={1,2,3,6,7,8};
        equals(a,b);
    }

    public static void equals (int a[],int b[]){
        if((a!=null&&a.length>0) && (b!=null&&b.length>0)){
           //考虑数组为空且无元素的情况
            if(a.length==b.length){
                boolean fl =false;
                for(int i=0;i<a.length;i++){
                    if(a[i]!=b[i]){
                       fl=true;
                    }
                    }
                if(fl==true){
                    System.out.println("数组内容不一致!");
                }else{
                    System.out.println("数组1：{1,2,3,6,7,8}和数组2：{1,2,3,6,7,8}是完全一致的");
                }
            }else {
                System.out.println("数组长度不一致！");
            }
        }else{
            System.out.println("数组为空且无元素！");
        }
    }
}

思路：
为了直接在方法调用时，直接根据判断给出不同结果，equals方法就不用返回值，定义两个数组a和b，先判断数组是否为空且有无元素，之后判断长度，再判断内容；在遍历时用boolean fl，如果a和b中的元素有不一致的，就将fl赋值为true，判断true就输出数组内容不一致，没有出现不一致的元素，就默认false输出结果两个数组完全一致。

第二种 只考虑长度和内容，在main方法中输出是否一致，需要是返回值类型，把equals方法定义为boolean型，如果长度不一致，返回false，遍历判断两个数组元素是否一致，不一致返回false，其余情况返回true。

public class HelloWorld {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,3,2,1};
        int[] arr2 = {1,2,3,4,3,2,1};
        System.out.println(" 是否一致:" +equals(arr ,arr2) );//调用输出

    }
    //  比较
    public static boolean equals(int[] arr1, int[] arr2) {
        // 长度不同,返回false
        if (arr1.length != arr2.length) {
            return false;
        }// arr1[i] 和 arr2[i]比较
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        return true;
    }
}