Java之方法

类的成员之二：方法

方法的概念

方法（method）：代表一个独立的可复用的功能

目的/好处：

（1）复用

（2）简化代码

方法的语法

1、方法的声明格式：

【修饰符】 class 类名{
    【修饰符】 返回值类型  方法名(【形参列表】){
        方法体：实现功能的代码
    }
}

说明：

（1）【修饰符】

（2）返回值类型：

①void：表示无返回值

②非void：所有的Java数据类型都可以

（3）方法名：能很好的体现方法的功能

命名的规范：①见名知意②从第二个单词开始首字母大写

（4）【形参列表】：

在完成这个方法的功能时，需要一些数据，这些数据要由“调用者”来决定，那我们就可以设计形参。

语法格式：

()：无参，空参

(数据类型 形参名)：一个形参

(数据类型1 形参名1, ......, 数据类型n 形参名n)：n个形参

（5）方法体：实现方法的功能，最好一个方法就完成一个独立的功能。

2、方法的调用格式：

//本类同级别方法调用：直接调用
【变量 = 】 方法名(【实参列表】);

//在其他类的方法中调用
【变量 = 】 对象名.方法名(【实参列表】);

（1）是否传实参

看被调用的方法是否有形参

（2）是否接收返回值

看被调用的方法是否是void，如果是void，就不需要也不能接收，如果不是void，就可以接收。

3、方法的声明与调用的代码示例

（1）无参无返回值方法

//本类
class Circle{
    double radius;
    void printInfo(){
        System.out.println("半径：" + radius);
    }
    void test(){
        printInfo();//本类中调用无参无返回值方法
    }
}

//其他类
class Circle{
    double radius;
    void printInfo(){
        System.out.println("半径：" + radius);
    }

}
class TestCircle{
    public static void main(String[] args){
        Circle c1 = new Circle();
        c1.printInfo(); //其他类中调用无参无返回值方法
    }
}

（2）无参有返回值方法

//本类
class Circle{
    double radius;
    
    double getArea(){
        return 3.14 * radius * radius();
    }
    
    void printInfo(){
      //  System.out.println("半径：" + radius + "，面积：" + getArea());//本类中调用无参有返回值
           double area = getArea();//本类中调用无参有返回值
        System.out.println("半径：" + radius + "，面积：" + area);
    }
}

//其他类
class Circle{
    double radius;
    
    double getArea(){
        return 3.14 * radius * radius();
    }
}
class TestCircle{
    public static void main(String[] args){
        Circle c1 = new Circle();
        double area = c1.getArea();
        System.out.println("面积：" + area);
        //或
        System.out.println("面积：" + c1.getArea());
    }
}

（3）有参无返回值方法

//本类
class GraphicTools{
    void printRectange(int line, int column, char sign){
        for(int i=1; i<=line; i++){
            for(int j=1; j<=column; j++){
                Sytem.out.print(sign);
            }
            System.out.println();
        }
    }
    
    void test(){
        printRectange(5,10,'%');//本类中调用有参无返回值方法
    }
}

//其他类
class GraphicTools{
    void printRectange(int line, int column, char sign){
        for(int i=1; i<=line; i++){
            for(int j=1; j<=column; j++){
                Sytem.out.print(sign);
            }
            System.out.println();
        }
    }
}
class Test{
    public static void main(String[] args){
        GraphicTools tools = new GraphicTools();
        tools.printRectange(5,10,'%');
    }
}

（4）有参有返回值方法

//本类
class MyMath{
    int sum(int a,int b){
        return a+b;
    }
    void print(){
        int x = 4;
        int y = 7;
        System.out.println(x + "+" + y + "=" + sum(x,y);//本类中调用有参有返回值的方法
    }
}

//其他类
class MyMath{
    int sum(int a,int b){
        return a+b;
    }
}
class Test{
    public static void main(String[] args){
        MyMath my = new MyMath();
        int x = 4;
        int y = 7;
        
        System.out.println(x + "+" + y + "=" + my.sum(x,y));
    }
}

4、方法声明与调用的原则

（1）方法必须先声明后调用

如果调用方法时，如果方法名写错或调用一个不存在的方法，编译会报错

（2）方法声明的位置必须在类中方法外

正确示例：

类{
    方法1(){
        
    }
    方法2(){
        
    }
}

错误示例：

类{
    方法1(){
        方法2(){  //错误
        
           }
    }
}

（3）方法的调用的位置有要求

正确示例：

类{
    方法1(){
        调用方法
    }
}

错误示例：

类{
    方法1(){
        
    }
    
    调用方法  //错误位置
}

（4）方法的调用格式要与方法的声明格式对应

①是否要加“对象.”：看是否在本类中，还是其他类中

②是否要接收返回值：看被调用方法是否是void

③是否要传实参：看被调用方法是有形参列表

方法的重载Overload

概念：在同一个类中，出现了两个或多个的方法，它们的方法名称相同，形参列表不同，这样的形式称为方法的重载。和返回值类型无关。

示例代码：

//求两个整数的最大值
public int max(int a,int b){
    return a>b?a:b;
}
    
    //求三个整数的最大值
public int max(int a, int b, int c){
    return max(max(a,b),c);
}
    
    //求两个小数的最大值
public double max(double a, double b){
    return a>b?a:b;
}

方法的参数传递机制

Java中方法的参数传递机制：值传递

（1）形参是基本数据类型时，实参给形参传递数据值，是copy的形式，形参对值的修改不影响实参。 （2）形参是引用数据类型时，实参给形参传递地址值，形参对对象的属性的修改，会影响实参对象的属性值，因为此时形参和实参就是指向同一个对象。 示例代码：

class Test{
    public static void swap(int a, int b){
        int temp = a;
        a = b;
        b = temp;
    }

    public static void main（String[] args){
        int x = 1;
        int y = 2;
        swap(x,y);//调用完之后，x与y的值不变
    }
}

示例代码：

class Test{
    public static void change(MyData my){
        my.num *= 2;
    }
    
    public static void main(String[] args){
        MyData m = new MyData();
        m.num = 1;
        
        change(m);//调用完之后，m对象的num属性值就变为2
    }
}

class MyData{
    int num;
}

// 陷阱 

class Test{
    public static void change(MyData my){
        my = new MyData();//形参指向了新对象
        my.num *= 2;
    }
    
    public static void main(String[] args){
        MyData m = new MyData();
        m.num = 1;
        
        change(m);//调用完之后，m对象的num属性值仍然为1
    }
}

class MyData{
    int num;
}