与成员方法

与成员方法 成员方法 基本介绍

在某些情况下，我们需要定义成员方法(简称方法)。比如人类:除了有一些属性外(年龄，姓名..)，我们人类还有一些行为比如：可以说话，跑步。。通过练习，还可以做算术题。这时就要用成员方法才能完成。现在要求完善对Person类的完善。

成员方法快速入门

• method01.java

1. ）添加speak 成员方法，输出 我是一个好人

2. ）添加cal01 成员方法，可以计算从1-1000的结果

3. ）添加cal02 成员方法，该方法可以接收一个数n，计算从1+..+n的结果

4. ）添加getSum成员方法，可以计算两个数的和

public class method01{
    public static void main(String[] args){
    Person p = new Person();
    p.speak();
    p.cal01();
    p.cal02(5);
    p.cal02(10);
    
    //调用getSum方法 同时num1 = 10 num2 = 20;
    //把getSum返回的值，赋给 变量returnRes
    int returnRes = p.getSum(10,20);
    System.out.println(returnRes);
    }
    
   
}
class Person{
    String name;
    int age;
    public void speak(){
        System.out.println("我是一个好人");
    }
    
    
    public void cal01(){
        int sum = 0;
        for(int i = 1;i <= 1000;i++){
            sum += i;
        }
        System.out.println("cal01的结果"+sum);
        
        
    }
    //添加cal02 成员方法，该方法可以接收一个数n，计算从1+..+n的结果
    //解读：
    //(int n)形参列表 表示当前有一个形参 n，可以接收用户输入
    public void cal02(int n){
                int sum = 0;
        for(int i = 1;i <= n;i++){
            sum += i;
        }
        System.out.println("cal02的结果"+sum);
    }
    //添加getSum成员方法，可以计算两个数的和
    //解读：
    //1.public 表示方法公开
    //2.int 表示方法执行后返回一个 int 值
    //3.getSum 方法名
    //4.(int num1,int num2) 形参列表，两个形参，可以接收用户传入的两个
    //5.return res; 表示把 res 的值， 返回
    public int getSum(int num1,int num2){
        int res = num1 + num2;
        return res;
    }
}

方法的调用机制原理：(重要!-示意图)

方法调用小结:

1. 当程序执行到方法时,就会开辟一个独立的空间(栈空间)

2. 当方法执行完毕，或者执行到return语句时，就会返回

3. 返回到调用方法的地方

4. 返回后继续执行方法后面的代码

5. 主方法(栈)执行完毕，整个程序退出

为什么需要成员方法？

需求：循环遍历一个数组，输出数组各个元素

int[][] map = {{0,0,1},{1,1,1},{1,1,3}};

解决方法1(传统方法)：

for(int i = 0;i < map.length;i++){
        for(int j = 0;j < map[i].length;j++){
            System.out.print(map[i][j]);
        }
        System.out.println();
    }

解决方法2：

public class method02{
    public static void main(String[] args){
    
    int[][] map = {{0,0,1},{1,1,1},{1,1,3}};
    
    myTools mytools = new myTools();
    mytools.printArr(map);
    
    
    }
}
class myTools{
    public void printArr(int[][] map){
    for(int i = 0;i < map.length;i++){
        for(int j = 0;j < map[i].length;j++){
            System.out.print(map[i][j]);
        }
        System.out.println();
    }
    }
}

好处：

1. 提高代码复用性

2. 可以将实现的细节封装起来，然后供给其他用户来调用即可。

成员方法的定义

public 返回数据类型 方法名(形参列表..){ 语句； return 返回值； }

1. 形参列表：表示成员方法输入cal(int n); getSum(int num1;int num2)

2. 数据类型(返回类型)：表示成员方法输出，void表示没有返回值。

3. 方法主体：表示为了实现某一功能的代码块。

4. return语句不是必须的。

5. 提示：结合前面的题示意图来理解。

注意事项和使用细节 访问修饰符

访问修饰符的作用：作用是控制，方法使用的范围。有四种，在后面 不写的话就是默认[四种分别是：public，protected，默认，private]具体在后面！

返回数据类型

1. 一个方法最多有一个返回值[思考，如何返回多个结果]

2. 返回的类型可以为任意类型，包含基本类型和引用类型(数组，对象)

3. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值；而且要求返回值类型必须和return的值类型一致或兼容。

4. 如果方法是void，则方法体中可以没有return语句，或者 只写return;

2.
public class method03{
    public static void main(String[] args){
    
    AA aa = new AA();
    int[] arr = aa.getSumAndSub(50,10);
    for(int i = 0;i < arr.length;i++){
        System.out.println(arr[i]);
    }
    }
}
class AA{
    public int[] getSumAndSub(int n1,int n2){
        int[] resArr = new int[2];
        resArr[0] = n1 + n2;
        resArr[1] = n1 - n2;
        return resArr;
    }
}

3.
public double f1(){
    double d1 = 1.1 * 3;
    int n = 100;
    return n;//低精度转高精度 可以通过
}
public int f2(){
    double d1 = 1.1 * 3;
    int n = 100;
    return d1;//高精度转低精度 不能    
}

4.
public void f3(){
    System.out.println("Hello");
    int n = 10;
    return;//可写可不写 因为返回值类型是void 所以也不能写返回值 return n;
}

方法名

遵循驼峰命名法，最好见名知义，表达出该功能的意思即可，比如 得到两个数的和getSum，开发中按照规范。 实际工作中，方法都是完成某个功能，所以都需要有实际含义，最好见名知义。

形参列表

1. 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开，比如getSum(int n1,int n2)

2. 参数类型可以为任意类型，包含基本类型或引用类型，比如 printArr(int[] [] map)

3. 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数！！！ 【getSum】

4. 方法定义时的参数成为形式参数，简称形参；方法调用时的传入参数成为实际参数，简称实参，实参和形参的类型要一致或兼容，个数，顺序必须一致！！！

方法体

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

方法调用细节说明

1. 同一个类中的方法调用：直接调用即可。比如 print(参数)；

2. 跨类中的方法A类调用方法B类方法：需要通过对象名调用.比如 对象名.方法名(参数)；

3. 特别说明：跨类的方法调用和方法的访问修饰符相关，先提一下，后面细说。

练习:

1.编写类aa,有一个方法:判断一个数是奇数还是偶数ood还是偶数,返回boolean

2.根据行,列,字符打印 对应行数和列数的字符,比如:行4,列4,字符#,打印对应效果

public class method04{
    public static void main(String[] args){
    AA a = new AA();
    boolean yn = a.odd(10);
        if(yn){
        System.out.println("偶数");
        }else{
        System.out.println("奇数 ");
        }
        
        a.print(10,20,'*');
        
    }
}
​
class AA{
    public boolean odd(int n1){
    return n1 % 2 == 0;
    }
​
    public void print(int num1,int num2,char c){
        for(int j = 1;j <= num2;j++){
            for(int i = 1;i <= num1;i++){
                System.out.print(c);
            }
        System.out.println();
        }
    }
}

疯狂敲代码ing

方法的传参机制

方法的传参机制对我们今后的编程非常重要,一定要搞得清清楚楚明明白白.

1. 基本数据类型传参，执行的是值拷贝，所以不会改变主方法(返回值以外)。

2. 引用数据类型传参，执行的是地址拷贝，地址内参数进行改变时(修改地址内)，主方法内也会改变(可以通过形参修改实参)。

案例2.

//B类中编写一个方法test100，可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化？
//B类中编写一个方法test200，可以接收一个Person(age,sal)对象，在方法中修改该对象属性，看看原来的对象是否发生变化？
public class method06{
	public static void main(String[] args){
		int[] arr = {100,200,300};
		System.out.println(arr[1]);//200
		B b = new B();
		b.arr(arr);
		System.out.println(arr[1]);//199
	}
}
class B{
	public void arr(int[] arrReceive){
		arrReceive[1] = 199;
	}
}

public class method07{
	public static void main(String[] args){
	test100 t = new test100();			//这里是一个test100的新空间
	t.name = "乔";
	t.age = 18;
	
	test200 t2 = new test200();			//这是test200一个新对象空间
	t2.ageAdd(t);						//把上面test100的对象地址传入了她t2类的ageAdd
	
	System.out.println(t.age);
	}
}
class test100{
	String name;
	int age;
}
class test200{
	public void ageAdd(test100 t){		//接收了上面传入的对象地址,此时t等于上面传来的地址
	t = new test100();					//t在这里创建了一个新test100对象,也就意味着地址指向了新对象，
	t.age = t.age + 1;					//新对象的地址执行代码，与之前的不会造成影响
	System.out.println(t.age);
	}
}