Java 中的方法类型

2025年7月28日 | 阅读 13 分钟

方法是一段代码块，或一组语句，或一组为执行特定任务或操作而分组的代码。它用于实现代码的重用性。我们编写一次方法，然后多次使用它。我们不需要一遍又一遍地编写代码。它还通过添加或删除代码块来提供代码的易于修改和可读性。只有在我们调用或调用方法时，它才会被执行。

阅读更多 Java 中的方法

Java 中的方法类型

Java 方法主要分为以下两类

预定义方法
用户定义方法

Java 方法还可以根据调用和功能进行分类。

按调用分类

实例方法
1. 访问器（Getter）方法
2. 修改器（Setter）方法
静态方法
抽象方法
Final 方法
Synchronized 方法
Native 方法

按功能分类

构造方法
递归方法
重载方法
重写方法
工厂方法

预定义方法

Java 类库中已经定义好的方法称为预定义方法。它也称为标准库方法或内置方法。我们可以在程序的任何地方直接调用这些方法来使用它们。

例如，String.length()、String.equals()、String.compareTo()、Math.sqrt()、Math.pow() 等都是预定义方法。

当我们在程序中调用任何预定义方法时，与相应方法相关的代码会在后台运行。

示例：预定义方法

public class Main {
  public static void main(String[] args) {
    // pow() is an in-built function defined in the Math class
    System.out.println("2 raised to the power of 5 is: " + Math.pow(2, 5));
  }
}

编译并运行

输出

2 raised to the power of 5 is: 32.0

用户定义方法

用户或程序员编写的方法称为用户定义方法。这些方法可以根据需要进行修改或定制。

如何调用或实例化用户定义方法？

在 Java 中，调用或实例化方法取决于该方法是静态的还是非静态的。

如果方法是静态的，我们可以直接使用类名或在同一类中调用它。请注意，我们需要创建一个对象来调用静态方法。

static void display() {
// code
} 
Empolyee.display(); // no need to create an object

如果方法是非静态的，我们必须创建一个类的对象，然后使用它来调用方法。

注意：如果我们尝试从静态上下文调用非静态方法而没有对象，我们将收到编译时错误，因为非静态方法属于实例，而不是类本身。

Empolyee emp = new Empolyee();
emp.display(); // method called using object reference

示例：用户定义方法

public class Main {
	// Static method
	static void greet() {
		System.out.println("Hello from the static method!");
	}
	// Non-static method
	void farewell() {
		System.out.println("Goodbye from a non-static method!");
	}
	public static void main(String args[]) {
		Main obj = new Main();
		obj.farewell(); //calling non-static method
		Main.greet(); //calling static method
	}
}

编译并运行

输出

Goodbye from a non-static method!
Hello from the static method!

按调用分类

实例方法

在其定义所在类的类的方法称为实例方法。它是一个非静态方法。在调用或实例化实例方法之前，有必要创建其类的对象。它可以访问该对象的实例变量。它可以使用 this 关键字引用当前对象。

示例：实例方法

class Demo {
	// Method declaration
	public void displayMessage() {
		System.out.println("This is an instance method.");
	}
}
public class Main {
	public static void main(String[] args) {
		// Create an object of the class Demo
		Demo obj = new Demo();
		obj.displayMessage();
	}
} 

编译并运行

输出

This is an instance method.

实例方法有两种类型：

访问器（Getter）方法
修改器（Setter）方法

访问器（Getter）方法

访问器方法，也称为 getter 方法，允许我们检索对象私有实例变量的值。这些方法提供对对象状态的只读访问。

通过使用访问器方法，我们可以确保对象的状态不会被外部代码意外或恶意修改。它们很容易识别，因为方法前缀是单词get。它们返回私有字段的值并用于访问其值。

public int getId() {    
return Id;    
}    

修改器（Setter）方法

修改器方法（也称为 setter 方法）允许我们修改对象私有实例变量的值。这些方法提供对对象状态的只写访问。

通过使用修改器方法，我们可以确保对象的状态仅通过受控接口进行修改。我们可以很容易地识别它，因为方法前缀是单词set。它不返回任何内容。它接受一个与其数据类型取决于字段的数据类型相同的参数。它用于设置私有字段的值。

public void setRoll(int roll) {  
this.roll = roll;  
} 

阅读更多 Java 中的访问器和修改器

示例：访问器和修改器方法

Person.java

public class Person {
	// instance variable
    private String name;   
    private int age;
    // Accessor methods (Getters)
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    // Mutator methods (Setters)
    public void setName(String newName) {
        name = newName;
    }
    public void setAge(int newAge) {
        age = newAge;
    }
}

Main.java

public class Main {
    public static void main(String[] args) {
        Person p = new Person();
        // Setting values
        p.setName("Peter");
        p.setAge(26);
        // Accessing values
        System.out.println("Name: " + p.getName()); 
        System.out.println("Age: " + p.getAge());   
    }
}

输出

Name: Peter
Age: 26

注意：两个类必须在同一包中，并执行 Main 类以获得输出。

静态方法

具有 static 关键字的方法称为静态方法。换句话说，它是属于类而不是类实例的方法。我们通过在方法名前放置 static 关键字来创建静态方法。

静态方法的主要优点是我们可以在不创建对象的情况下调用它。它通过类名调用。它可以访问静态数据成员并更改其值。它用于创建实例方法。静态方法最好的例子是main() 方法。

阅读更多 Java 中的静态方法

示例：静态方法

public class Main {
	// User-defined static method to convert Celsius to Fahrenheit
	public static double celsiusToFahrenheit(double celsius) {
		return (celsius * 9 / 5) + 32;
	}
	public static void main(String[] args) {
		double celsius = 25.0;
		// Calling the static method directly using the class name
		double fahrenheit = Main.celsiusToFahrenheit(celsius);
		System.out.println(celsius + " Celsius is equal to " + fahrenheit + " Fahrenheit.");
	}
}

编译并运行

输出

25.0 Celsius is equal to 77.0 Fahrenheit.

抽象方法

抽象方法是声明时没有方法体的方法。它强制子类实现自己的实现。它总是声明在抽象类中，所以类必须是抽象的。Java 提供 abstract 关键字来定义抽象类和方法。

阅读更多 Java 中的抽象方法

语法

如果一个类包含抽象方法，那么这个类本身必须声明为抽象的。

public abstract class Main {  
   // declare fields  
   // declare nonabstract methods  
   abstract void draw();  
}  

示例：抽象方法

abstract class Square {
	// Abstract method declaration
	public abstract int findSquare(int n);
}
public class Main extends Square {
F	// Implementing abstract method from abstract class Square
	public int findSquare(int n) {
		return n * n;
	}
	public static void main(String[] args) {
		Square obj = new Main();
		int result = obj.findSquare(5);
		System.out.println("The square of 5 is: " + result);
	}
}

编译并运行

输出

The square of 5 is: 25

Final 方法

声明为 final 的方法称为 final 方法。子类不能重写 final 方法。

final void paint() {  
}  

示例：Final 方法

class Bike {
	final void run() { // final method
		System.out.println("running");
	}
}
public class Main extends Bike {
	// We cannot override the final method
	/*void run() {
		System.out.println("running safely with 100kmph");
	}*/
	public static void main(String args[]) {
		Main obj = new Main();
		obj.run();
	}
}

编译并运行

输出

running

注意：如果我们从 Main 类中定义的 run() 方法中删除注释，然后尝试编译程序，则会收到编译时错误，因为 final 方法不能被重写。

重载 Final 方法

方法重载取决于参数列表及其类型，而不是返回类型或其他修饰符。在同一类中为 final 方法提供不同的一组参数仍然是有效的。例如，考虑以下代码片段。

class Main {
	// Final method
	public final void display(String message) {
		System.out.println("Message: " + message);
	}
	// Overloaded final method
	public final void display(String message, int count) {
		for (int i = 0; i < count; i++) {
			System.out.println("Message: " + message);
		}
	}
}    

在上面的代码中，Main 类有一个名为 display() 的 final 方法，它被重载为第二个版本，该版本接受一个额外的 int 参数。这表明 final 方法可以重载，只要方法签名不同。

注意：Java 允许重载 final 方法，但不允许重写。

Synchronized 方法

synchronized 关键字可以与方法和块一起使用。当一个方法或块被声明为 synchronized 时，会在指定对象上获取一个锁，并且其他线程在锁被释放之前无法访问 synchronized 代码。

当我们需要确保一次只有一个线程可以访问整个方法时，就会使用 synchronized 方法。当方法修改共享资源（如类变量或数据结构）时，它非常有用。

语法

// Synchronized method    
public synchronized void methodName() {    
   //code  
} 

示例：Synchronized 方法

public class Main {
	private int counter = 0;
	//synchronized method  
    public synchronized void increment() {    
        counter++;    
    }
	public static void main(String[] args) throws InterruptedException {
		Main obj = new Main();
		Thread thread1 = new Thread(() -> {
			for (int i = 0; i < 1000; i++) {
				obj.increment();
			}
		});
		Thread thread2 = new Thread(() -> {
			for (int i = 0; i < 1000; i++) {
				obj.increment();
			}
		});
		thread1.start();
		thread2.start();
		thread1.join();
		thread2.join();
		System.out.println("Counter: " + obj.counter);
	}
} 

编译并运行

输出

Counter: 2000

Native 方法

在 Java 中，native 方法是其实现是用 Java 以外的语言（通常是C 或 C++）编写的，并通过Java Native Interface (JNI) 在 JVM 外部执行的方法。这些方法通常用于与硬件交互、操作系统级功能或提高特定任务的性能。我们可以通过使用native 关键字来定义 native 方法。native 关键字只能应用于方法。

注意：Native 方法在 Java 中没有方法体，它们以分号结尾。

Java 提供了一种称为 Java Native Interface (JNI) 的机制，该机制允许在Java 虚拟机 (JVM) 上运行的 Java 代码与用其他语言编写的应用程序和库进行交互。

从 JVM 的角度来看，有两种类型的代码：Java 和native。Java Native Interface (JNI) 在两者之间建立了明确定义的、平台无关的接口。

编译 Native 方法

编写带有 native 方法的 Java 类。
使用 javah 命令（或 javac -h）进行编译。它会生成一个 C 头文件。
使用 JNI 约定用 C/C++ 实现方法。
将 C/C++ 代码编译成共享库（.dll、.so 等）。
使用 System.loadLibrary() 在 Java 中加载库。

示例：Native 方法

public class Main {
	// declaring native method
	public native int square(int i);
	public static void main(String[] args) {
	// loads the required native library at run time, which is written in the C language
		System.loadLibrary("Main"); //calls C implementation
		// calculates the square of a number
		System.out.println(new Main().square(6));
	}
}  

在 C 文件中实现 native 方法。

Main.c

#include <jni.h>  
#include "Main.h"  
JNIEXPORT jint JNICALL Java_Main_square(  
    JNIEnv *env, jobject obj, jint i) {  
  return i * i;  
}   

输出

请注意，只有在我们用另一种低级语言实现其 native 方法时，程序才会运行。在我们的例子中，我们在C 语言中定义了 native 方法的实现。

注意：应避免使用 native 关键字，因为它可能违背 Java 的“一次编写，随处运行”的理念。它通常仅在必要时少量使用。

按功能分类

构造方法

严格来说，构造函数不是方法，但从结构上看是。因为它们是 Java 中不同的结构。

我们不能像调用方法一样调用构造函数，例如，object.constructor() 是无效的。
它们是对象实例化生命周期的一部分，而不是一般行为逻辑。

构造函数是一个代码块，就像方法一样。但它是在创建类的实例时调用的。在调用构造函数时，对象内存会在内存中分配。它是一种特殊的类型的方法，用于初始化对象。

每次我们使用 new 关键字创建对象时，它都会调用一个默认构造函数。假设类中没有可用的构造函数；在这种情况下，Java 编译器默认提供一个默认构造函数。

阅读更多 Java 中的构造函数

示例：构造方法

class Bike {
	// creating a default constructor
	Bike() {
		System.out.println("Bike class");
	}
}
public class Main {
	// main method
	public static void main(String args[]) {
		// calling a default constructor
		Bike b = new Bike();
	}
} 

编译并运行

输出

Bike class

递归方法

递归方法会重复调用自身。它通过将问题分解为更小的子问题来解决问题。它是一个强大的概念，尤其适用于具有自然层次结构或重复结构的问题，例如阶乘或斐波那契数列。

递归方法有两个关键部分：基本情况和递归情况。

示例：递归方法

public class Main {
	public static int factorial(int n) {
		if (n <= 1) // Base case
			return 1;
		else
			return n * factorial(n - 1); // Recursive call
	}
	public static void main(String[] args) {
		int result = factorial(5);
		System.out.println("Factorial of 5 is: " + result); // Output: 120
	}
} 

编译并运行

输出

Factorial of 5 is: 120

重载方法

在 Java 中，重载方法是指同一个类中有多个方法共享相同的名称，但在其参数列表上有所不同，包括参数的数量、类型或顺序。这被称为方法重载，它是编译时多态性的一种形式。

阅读更多 Java 中的方法重载

示例：方法重载

class Sum {
	// Method to add two integers
	static int add(int a, int b) {
		return a + b;
	}
	// Method to add three integers
	static int add(int a, int b, int c) {  //overloaded method
		return a + b + c;
	}
}
public class Main {
	public static void main(String[] args) {
		// Calling the add method with two integers
		System.out.println(Sum.add(11, 11)); 
		// Calling the add method with three integers
		System.out.println(Sum.add(11, 11, 11)); 
	}
}

编译并运行

输出

22
33

重写方法

重写方法是子类中用于重新定义从其超类继承的方法的方法。它是运行时多态性的一种形式，允许对象根据其实际类型表现出不同的行为，即使以泛型方式引用。

阅读更多 Java 中的方法重写

示例：方法重写

class Animal {
	void sound() {
		System.out.println("Some generic animal sound");
	}
}
class Dog extends Animal {
	void sound() {
		System.out.println("Dog barks");
	}
}
class Cat extends Animal {
	void sound() {
		System.out.println("Cat meows");
	}
}
public class Main {
	public static void main(String[] args) {
		Animal a1 = new Dog(); // Upcasting
		Animal a2 = new Cat();
		a1.sound(); // Output: Dog barks
		a2.sound(); // Output: Cat meows
	}
} 

编译并运行

输出

Dog barks
Cat meows

工厂方法

工厂方法是一种创建型设计模式。它提供了一种灵活的方式来实例化对象，而无需指定它们的精确类。不是直接使用 new，而是将对象创建委托给一个方法（通常在超类或接口中），子类会重写该方法以生成特定类型。

示例：工厂方法

// Product interface
interface Notification {
	void notifyUser();
}
// Concrete Products
class EmailNotification implements Notification {
	public void notifyUser() {
		System.out.println("Sending an Email Notification");
	}
}
class SMSNotification implements Notification {
	public void notifyUser() {
		System.out.println("Sending an SMS Notification");
	}
}
// Creator
abstract class NotificationFactory {
	public abstract Notification createNotification();
}
// Concrete Creators
class EmailFactory extends NotificationFactory {
	public Notification createNotification() {
		return new EmailNotification();
	}
}
class SMSFactory extends NotificationFactory {
	public Notification createNotification() {
		return new SMSNotification();
	}
}
// Client code
public class Main {
	public static void main(String[] args) {
		NotificationFactory factory = new EmailFactory();
		Notification notification = factory.createNotification();
		notification.notifyUser(); 
	}
}

编译并运行

输出

Sending an Email Notification

Java 方法选择题

1. Java 中的方法重载是什么？

从一个方法调用另一个方法
在运行时重命名方法
具有多个同名但参数不同的方法
重写超类方法

答案：C

解释：在 Java 中，重载方法是指同一个类中有多个方法共享相同的名称，但在其参数列表上有所不同，包括参数的数量、类型或顺序。

2. 哪个关键字可以防止方法被重写？

static
final
private
protected

答案： B

解释： final 方法不能被子类重写，从而确保行为的一致性。

3. 静态方法尝试访问实例变量时会发生什么？

它正常访问
编译错误
运行时错误
如果变量是 final，则可用

答案： B

解释：静态方法属于类，不能直接访问实例变量。

4. 创建对象时自动调用哪个方法？

main()
start()
构造函数
execute()

答案：C

解释：构造函数用于初始化对象，并在实例化过程中被调用。

5. 以下哪种是从 main() 调用非静态方法的有效方式？

public class Demo {
    void greet() { System.out.println("Hello!"); }
    public static void main(String[] args) {
        // ?
    }
} 

greet();
Demo.greet();
new Demo().greet();
this.greet();

答案：C

解释：非静态方法需要一个对象才能被调用。

下一主题Java 中的 this 与 super

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中的方法类型