JAVA基础--方法

方法的定义（函数）

注意：Java都是值传递

语法：

修饰符 返回值类型 方法名(参数类型 参数名)
{
    ...
    方法体
    ...
    return 返回值;
}

例子：定义一个求两数最大值的方法

public class Demo01 {
    public static void main(String[] args)
    {
        int max=Max(10,20);//最大值赋予给max
        System.out.println(max);//输出20
    }
    //求最大值的方法
    //public和static都是修饰符
    public static int Max(int num1,int num2)
    {
        int res = 0;
        if(num1==num2)
        {
            System.out.println("num1==num2");
            return 0;//return也可用于终止方法
        }
        if(num1>num2)
        {
            res = num1;
        }
        else
        {
            res = num2;
        }
        return res;//返回res
    }
}

有static和没有static的区别

有static:静态方法

在main中可以直接使用定义的方法

public class Demo04 {
    public static void main(String[] args) {
        int num = 10;
        printNum(num);//直接使用，打印10
    }
    public static void printNum(int x){
        System.out.println(x);
    }
}

注意：如果是定义在另外一个类中的方法，则通过类名.方法名的方式调用即可

无static：非静态方法

需要实例化这个类，new一个对象

public class Demo04 {
    public static void main(String[] args) {
        int num = 10;
      //对象类型 对象名 = 对象值
        Demo04 demo04 = new Demo04();
        demo04.printNum(num);//打印10 使用类名进行调用
    }
    public  void printNum(int x){
        System.out.println(x);
    }
}

Demo04 demo04 = new Demo04();
demo04.printNum(num);
//注意：以上两步可以合成一步，如下
new Demo04().printNum(num);

两个方法的相互调用

//均为非静态或静态方法时可以嵌套调用
//若其中两个方法一个是静态一个非静态，则无法嵌套调用
public void A(){
   B();
}
public void B(){

}
或
public static void A(){
   B();
}
public static void B(){

}   

原因：静态方法是和类一起加载出来的，而非静态方法是在实例化(new)之后才存在的

方法的重载

一个类里面有两个名字相同的方法，但形参不同

方法重载的规矩：

• 方法名称必须相同
• 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)
• 方法的返回类型可以相同也可以不同
• 仅仅返回类型不同不足以成为方法的重载

实现理论

方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去匹配对应的方法，如果匹配失败则编译器会报错

public class Demo01 {
    public static void main(String[] args)
    {
        //int max=Max(10,20);//调用第一个Max方法，输出20
        double max=Max(10.0,20.0);////调用第二个Max方法，输出20.0
        System.out.println(max);
    }
    //求最大值的方法
    public static int Max(int num1,int num2)
    {
        int res = 0;
        if(num1==num2)
        {
            System.out.println("num1==num2");
            return 0;//return也可用于终止方法
        }
        if(num1>num2)
        {
            res = num1;
        }
        else
        {
            res = num2;
        }
        return res;//返回res
    }
    //方法的重载
    public static double Max(double num1,double num2)
    {
        double res = 0;
        if(num1==num2)
        {
            System.out.println("num1==num2");
            return 0;//return也可用于终止方法
        }
        if(num1>num2)
        {
            res = num1;
        }
        else
        {
            res = num2;
        }
        return res;//返回res
    }
}

可变参数

• JDK1.5开始，Java支持传递同类的可变参数给一个方法
• 在方法声明中，在指定参数类型后加一个省略号(...)
• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明

例子：求数组中的最大值

public class Demo02 {
    public static void main(String[] args) {
        //调用可变参数的方法1
        printMax(34,3,3,2,56.5);//输出56.5
        //调用可变参数的方法2
        printMax(new double[]{1,2,3,4,5});//输出5.0
    }
    //方法，注意：可变参数必须是最后一个参数！！！
    public static void printMax(double...numbers){
        if(numbers.length==0){
            System.out.println("No argument passed!");
            return;
        }
        //把numbers[0]的值赋值给result，用于比较
        double result = numbers[0];
        //排序
        for(int i = 1;i < numbers.length; i++){
            if(numbers[i]>result){
                result = numbers[i];
            }
        }
        System.out.println("The max value is "+ result);//输出最大值
    }
}

值传递 & 引用传递

• 值传递

//值传递
public class Demo05 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);//输出1
        Demo05.change(a);
        System.out.println(a);//还是输出1
    }
    //返回值为空
    public static void change(int a){
        a = 10;
    }
}

• 引用传递：传递的是对象（本质上还是值传递）

//引用传递
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//输出null
        Demo05.change(person);//引用传递
        System.out.println(person.name);//输出张三
    }
    //返回值为空
    public static void change(Person person){
        //person是一个对象，指向 Person person = new Person();
        //是一个具体的人，可以改变属性
       person.name = "张三";//修改的是Person类中的name属性
    }
}
//定义了一个Person类，有一个属性：name
//注意：有public的类只能有一个，没有public的类可以有无数个
class Person{
    String name;//初始值为null
}