【Java开发指南 | 第十九篇】Java方法

读者可订阅专栏：Java开发指南 |【CSDN@秋说】

Java方法

方法的定义

在Java中，方法是一段代码块，用于执行特定的任务或操作。方法包含了一系列语句，可以被其他代码多次调用。方法通常用于组织代码，提高代码的重用性和可读性。

方法的语法

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

修饰符（Modifiers）：

• 修饰符是可选的，用于控制方法的访问权限和其他特性。常见的修饰符包括：
  • public：表示该方法可以被任何类访问。
  • private：表示该方法只能被同一个类内部的其他方法访问。
  • protected：表示该方法可以被同一包内的类及其子类访问。
  • static：表示该方法属于类而不是实例，可以通过类名直接调用。
  • final：表示该方法不能被子类重写。
  • abstract：表示该方法没有实现，必须在子类中被实现。
  • 等等…

返回值类型（Return Type）：

• 返回值类型指定了方法执行后的返回结果的数据类型。如果方法不返回任何值，则返回类型为 void。
• 如果方法有返回值，则必须在方法体中使用 return 语句返回相应的值。
• 如果方法声明了返回值类型但是没有在方法体中使用 return 返回值，则编译器会报错。

方法名（Method Name）：

• 方法名是用来标识方法的名称，其他代码可以通过方法名来调用该方法。
• 方法名应该符合Java的命名规范，通常采用驼峰命名法。

参数类型（Parameter Types）：

• 方法可以接受零个或多个参数，参数类型指定了每个参数的数据类型。
• 参数列表是包含在圆括号内的，多个参数之间使用逗号分隔。

方法体（Method Body）：

• 方法体是方法的实际实现，包含了一系列语句，用于执行特定的任务或操作。
• 方法体位于花括号 {} 内，其中的语句会按顺序执行。

方法的类型

1、静态方法（Static Method）：使用 static 关键字修饰的方法，可以直接通过类名调用，无需实例化对象。

public class Ice{
	public static void a()
	{
		System.out.println("ice");
	}
	
	
	public static void main(String[] args)
	{
		//调用静态方法，无需实例化对象
		Ice.a();
	}
}

2、实例方法（Instance Method）：没有使用 static 关键字修饰的方法，必须通过类的实例对象调用。

public class Ice{
	public void a()
	{
		System.out.println("ice");
	}
	
	
	public static void main(String[] args)
	{
		//创建实例对象
		Ice b = new Ice();
		//调用实例方法，需要使用实例对象
		b.a();
	}
}

方法的调用

当方法返回一个值的时候，方法调用通常被当做一个值。

public class Ice{
	public static int a()
	{
		return 1;
	}//方法返回一个值
	
	
	public static void main(String[] args)
	{
		int b = Ice.a();
		System.out.println(b);
	}
}

如果方法返回值是void，方法调用一定是一条语句。

public class Ice{
	public static void a()
	{
		System.out.println("ice ice");
	}//方法返回void
	
	
	public static void main(String[] args)
	{
		Ice b = new Ice();
		b.a();
	}
}

方法的重载

先看该例：

public class Ice{
	public static int max(int num1,int num2)
	{
		if(num1>num2)
			return num1;
		else
			return num2;
	}
	
	
	public static void main(String[] args)
	{
		int b=Ice.max(5, 1);
		System.out.println(b);
	}
}

上面代码使用的max方法仅仅适用于int型数据。但如果我们想得到两个浮点类型数据的最大值呢？

解决方法是创建另一个有相同名字但参数不同的方法（一个类的两个方法拥有相同的名字，但是有不同的参数列表），如下面代码所示：

public class Ice {
    public static int max(int num1, int num2) {
        if (num1 > num2)
            return num1;
        else
            return num2;
    }
    
    // 方法重载，接受 double 类型的参数
    public static double max(double num1, double num2) {
        if (num1 > num2)
            return num1;
        else
            return num2;
    }

    public static void main(String[] args) {
        int b1 = Ice.max(5, 1); // 调用第一个 max 方法
        System.out.println(b1);

        double b2 = Ice.max(3.5, 4.2); // 调用第二个 max 方法
        System.out.println(b2);
    }
}

如果我们调用max方法时传递的是int型参数，则int型参数的max方法就会被调用；如果传递的是double型参数，则double类型的max方法体会被调用，这就是方法重载。

构造方法

构造方法是一种特殊类型的方法，用于在创建对象时进行初始化操作。它与类同名，没有返回类型（甚至不是 void），并且在创建对象时由 Java 虚拟机自动调用。

语法结构：

public class ClassName {//类名

        // 构造方法定义
    public ClassName(/* 参数列表 */) {
        // 构造方法体
    }



    // 其他成员方法和属性
}

构造方法的语法结构包括：

• 访问修饰符：通常为 public，用于控制该构造方法的访问权限。
• 方法名：与类名相同。
• 参数列表：可以有零个或多个参数，用于在创建对象时传递初始化信息。
• 构造方法体：包含在大括号 {} 内的代码块，用于执行初始化操作。

示例如下：

public class Ice{
	//属性
	private String size;
	private int year;
	
	//构造方法，用于初始化 Ice 对象的属性
	public Ice(String size,int year)
	{
		this.size=size;
		this.year=year;
	}
	
	//方法
	public void a()
	{
		System.out.println("size:"+size);
		System.out.println("year:"+year);
	}
	
	public static void main(String[] args)
	{
		//创建对象并初始化
		Ice aa=new Ice("mideum",7);
		aa.a();
	}
}

方法之可变参数

JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。

方法的可变参数的声明如下所示：

typeName... parameterName
参数类型...参数名

public class Ice
{
    //输出数组中最大值
	public static void max(double...numbers)
	{
		double max1=numbers[0];
		for(int i=1;i<numbers.length;i++)
		{
			if(numbers[i]>max1)
				max1=numbers[i];
		}
		System.out.println(max1);
	}
	
	//调用
	public static void main(String[] args)
	{
		max(12,32,21,6.3);
		max(new double[]{1,1.2,2.2});
	}
}

由于max方法的参数类型是double，若代码改为float[]，则将产生类型不匹配的错误：

**注意：**在Java中，一个方法只能有一个可变参数，并且这个可变参数必须是方法参数列表中的最后一个参数。

示例：

//正常工作的代码示例
public class Ice
{
	public static void max(int a,double...numbers)
	{
		double max1=numbers[0];
		for(int i=1;i<numbers.length;i++)
		{
			if(numbers[i]>max1)
				max1=numbers[i];
		}
		if(a>max1)
		//第一个数与后面最大的一个进行比较
			System.out.println(a);
		else
			System.out.println(max1);
	}
	
	public static void main(String[] args)
	{
		max(122,32,21,6.3);//122>32，输出122
		max(12,32,21,6.3);//12<32，输出32.0
	}
}

倘若我将代码变为：

public static void max(int a,double...numbers)

则产生如下报错

这是因为在调用方法时，可变参数可以接受任意数量的参数，包括零个参数，因此它会"吞噬"掉方法参数列表中的所有参数，导致后续参数无法被准确定位。