成员方法定义

成员方法

基本介绍

成员方法是一个类中的行为，如人类可以跑步，说话等。

成员方法快速入门：

1.添加speak成员方法，输出 “我是一个好人”
2.cal01成员方法，可以计算从1+。。。+1000的结果 
3.cal02成员方法，该方法可以接收一个数n，计算1+。。。+n的结果 
4.添加getSum成员方法，可以计算两个数的和


import java.util.Scanner;

public class Method01 {
    public static void main(String[] args) {
        //方法的使用：先创建对象，再调用方法
        Person p1 = new Person();
        p1.speak();

        //调用cal01
        p1.cal01();

        //调用cal02
        p1.cal02();

        //调用getSum
        //p1.getSum(5,3);执行的结果8赋给sum
        int sum = p1.getSum(5, 3);
        System.out.println(sum);

        /**
         * 返回值：
         * 我是一个好人
         * 500500
         * 请输入n的值：
         * 88
         * 3916
         * 8
         */
    }
}

class Person{
    //属性
    public String name;
    public int age;

    //成员方法
    //1.添加speak成员方法，输出 “我是一个好人”
    //public 表示公共的
    //void  表示没有返回值
    //speak  表示方法名,()形参列表
    //{}  表示代码块，把我们功能写在代码块中
    //System.out.println("我是一个好人");  表示就是功能
    public void speak(){
        System.out.println("我是一个好人");
    }


    //2.cal01成员方法，可以计算从1+。。。+1000的结果
    public void cal01(){
        int sum=0;
        for (int i=1;i<=1000;i++){
            sum+=i;
        }
        System.out.println(sum);
    }


    //3.cal02成员方法，该方法可以接收一个数n，计算1+。。。+n的结果
    public void cal02(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入n的值：");
        int n = sc.nextInt();
        int sum = 0;
        for (int i=1;i<=n;i++){
            sum+=i;
        }
        System.out.println(sum);
    }

    //4.添加getSum成员方法，可以计算两个数的和
    public int getSum(int i,int j){
        return i+j;
    }
}

方法调用机制（非常重要必须掌握）

//分析下面代码调用机制
public class Method01 {
    public static void main(String[] args) {
    	Person p1 = new Person();
    	int returnRes = p1.getSum(10,20);
    	System.out.println("getSum方法的返回值="+returnRes);
    }
    
class Person(){
	public int getSum(int num1,int num2){
		int res = num1+num2;
		return res;
	}
}

方法调用的步骤：

1. 当程序执行到方法时，就会开辟一个独立的空间（就是栈空间）
2. 当方法执行完毕，或者执行到return语句时，就会返回（当一个方法执行完毕后，就会自动弹栈）
3. 返回到调用方法的地方
4. 返回后，继续执行方法后面的代码
5. 当MAIN方法（栈）执行完毕，整个程序退出

成员方法(重点)

需求：遍历一个数组，输出数组的各个元素值。

定义一个类MyTools，然后一个成员方法，调用方法实现，看看效果又如何

public class Method02 {
    public static void main(String[] args) {
        int[][] arr={{1,2,3},{43,5,6},{7,86,9}};
        for (int i=0;i<arr.length;i++){
           for (int j=0;j<arr[i].length;j++){
               System.out.print(arr[i][j]+"\t");
           }
            System.out.println();
        }

        System.out.println("===========================");

        //好处：可以多次直接调用，修改方便
        MyTools tools = new MyTools();
        tools.printArr(arr);
    }


}
class MyTools{
    //使用方法的好处：减少代码的冗余度
    public  void printArr(int[][] arr){
        for (int i=0;i<arr.length;i++){
            for (int j=0;j<arr[i].length;j++){
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

1.提高代码的复用性

2.可以将的细节封装起来，然后提供让用户来调用即可

成员方法的定义

语法格式：

访问修饰符   返回数据类型   方法名（形参列表）{//方法体
	语句;
	return  返回值;
}

1.形参列表：表示成员方法输入cal（int n）
2.返回数据类型：表示成员方法的输出，void表示没有返回值
3.方法主体：表示为了实现某一功能代码块
4.return语句不是必须的（可有可没有）

成员方法定义的注意事项

1.访问修饰符（作用是控制，方法的使用的范围）【public protected 默认 private】

2.返回数据类型

1. 一个方法最多有一个返回值【思考 ，如何返回多个结果，解决方案：返回数组或集合 】
2. 返回类型可以为任意数据类型，包含基本类型或引用类型（数组或对象）
3. 如果方法要求有返回数据类型，则方法体中最后执行语句必须为return值，而且要求返回值类型必须和return的值类型一致或兼容
4. 如果方法是void，则方法体中可以没有return语句，或者只写return;，注意不能写任何值
5. 方法名遵循驼峰命名法

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

        ReturnMultiResult result = new ReturnMultiResult();
        int[] sumAndSub = result.getSumAndSub(5, 3);
        System.out.println("两个数的和="+sumAndSub[0]);
        System.out.println("两个数的差="+sumAndSub[1]);

    }
}
class ReturnMultiResult{
    //1.由于一个方法最多只能一个返回值，如果返回是多个结果可以用数组或集合解决
    //2.返回类型可以是任意数据类型，这是返回是数组，所以在return返回必须也是一维数组类型
    //3.如果是void，则可以不定return语句，或只写return;
    //4.命名规则是驼峰命名法
    public int[] getSumAndSub(int num1,int num2){
        int[] arr = new int[2];
        arr[0] = num1 - num2;
        arr[1] = num1 + num2;
        return arr;
    }
}

在传入值时，可以int 传给 double byte 传给 int就是小的可以传给大的会自动类型提升,就是可以低精度传给高精度，高精度不可以传给低精度的

3.形参列表

1. 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开，比如getSum(int num1,int num2)
2. 参数类型可以为任意类型，包含基本类型或引用类型，比如print (int[][] arr)
3. 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数
4. 方法定义时的参数称为形式参数，简称为形参；方法调用时传入的参数称为实际参数，简称实参

4.方法体

里面写完成功能的具体的语句，可以为输入，输出，变量，运算，分支，循环，方法调用，但是里面不能再定义方法

在方法体中，不能再定义方法，因为方法是同级关系

5.方法调用细节说明（重点）

1. 同一个类中的方法调用：直接调用即可
2. 跨类中的方法调用，如A类调用B类的方法，需要创建B类的对象，再对象名.方法名调用
3. 跨类方法调用和方法的访问修饰符相关

public class Method04 {

    public static void main(String[] args) {
        SurveyMethod method = new SurveyMethod();
        //说明在不同的类中，调用其它类的方法时，需要创建该的对象，再对象名.方法名调用
        method.print01();
    }
}
/**
 * 1. 同一个类中的方法调用：直接调用即可
 * 2. 跨类中的方法调用，如A类调用B类的方法，需要创建B类的对象，再对象名.方法名调用
 * 3. 跨类方法调用和方法的访问修饰符相关
 */
class SurveyMethod {
    public void print01(){
        print02(10);//调用print02方法
        //说明在同一个类中，方法可以直接调用
    }

    public void print02(int num){
        System.out.println("num="+num);
    }
}

成员方法的练习题

1.编写一个类Exercise，有一个方法：判断一个数是奇数odd还是偶数，返回Boolean值,是偶数返回true,否则返回false

2.根据行，列打印对应行数和列数的字符

public class MethodExercise01 {
    public static void main(String[] args) {
        Exercise exercise = new Exercise();
        boolean judge = exercise.Judge(9);
        if (judge){
            System.out.println("是偶数");
        }else {
            System.out.println("是奇数");
        }

        exercise.Print(4,3,'%');
    }
}
//编写一个类Exercise，有一个方法：判断一个数是奇数odd还是偶数，返回Boolean值,是偶数返回true,否则返回false
class Exercise {
    /**
     * 思路：
     * 确定方法的返回值: boolean
     * 方法名：Judge判断
     * 确定方法的参数列表:  int num
     * 方法体：判断
     */

    public boolean Judge(int num){
//        if (num%2==0){
//            return true;
//        }
//        else {
//            return false;
//        }
        //代码优化
//        return num % 2 == 0 ? true : false;

        //代码优化
        return num % 2 == 0;
    }

    /**
     * 根据行，列打印对应行数和列数的字符
     * 比如：行：3，列：3，则打印相应效果是：
     *       ###
     *      ###
     *     ###
     *
     *
     *  思路：
     *  返回值：void
     *  方法名：Print
     *  参数列表： int row ,int col, char ch
     *  方法休：循环
     */

    public void Print(int row,int col,char ch){
        for (int i=1;i<=row;i++){
            for (int j=1;j<=col;j++){
                System.out.print(ch);
            }
            System.out.println();
        }
    }

}