在Java编程中,类与类之间的调用是实现代码复用和模块化设计的核心，掌握不同场景下的类调用方法，是提升代码质量和开发效率的关键，本文将从基础到进阶，系统介绍Java中一个类调用另一个类的多种方式及其应用场景。
基础调用：通过实例化对象访问成员
最常用的类调用方式是通过实例化对象访问目标类的成员变量和方法,这种调用适用于非静态成员，因为非静态成员属于对象实例，必须通过对象才能访问。
假设有一个Person类，包含成员变量name和age，以及方法sayHello()：
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void sayHello() {
System.out.println("Hello, I'm " + name + ", " + age + " years old.");
}
}
在另一个类Main中，可以通过new关键字实例化Person对象，然后调用其成员：
public class Main {
public static void main(String[] args) {
Person person = new Person("Alice", 25); // 实例化对象
person.sayHello(); // 调用方法
System.out.println("Name: " + person.name); // 访问变量（需为public）
}
}
需要注意的是,如果目标类的成员变量被private修饰，外部类无法直接访问，必须通过公共的getter/setter方法间接调用，这是封装性的核心体现。
静态成员调用：无需实例化的直接访问
当类的成员被static修饰时，该成员属于类本身，而非类的实例，调用静态成员无需创建对象，可以直接通过类名访问。
定义一个工具类MathUtils，包含静态方法add()：
public class MathUtils {
public static int add(int a, int b) {
return a + b;
}
}
在Main类中，直接通过类名调用静态方法：
public class Main {
public static void main(String[] args) {
int result = MathUtils.add(3, 5); // 直接通过类名调用
System.out.println("Result: " + result);
}
}
静态成员（变量或方法）属于类级别的共享资源，常用于工具类、常量定义等场景，但需注意，静态方法无法直接访问非静态成员，因为非静态成员依赖于对象实例，而静态方法在类加载时就已存在，此时可能还没有对象实例。
继承中的类调用：通过扩展实现复用
Java通过继承机制允许子类调用父类的成员（非私有成员），子类会自动继承父类的非私有成员变量和方法，并可以在此基础上进行扩展或重写。
假设有一个父类Animal，包含方法eat()：
public class Animal {
public void eat() {
System.out.println("Animal is eating.");
}
}
子类Dog继承Animal，并新增方法bark()：
public class Dog extends Animal {
public void bark() {
System.out.println("Dog is barking.");
}
}
在Main类中，通过子类对象调用父类和子类的方法：
public class Main {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat(); // 调用父类方法
dog.bark(); // 调用子类方法
}
}
如果子类需要调用父类的构造方法,可以使用super关键字，例如在子类构造方法中通过super(name)调用父类带参构造方法，子类可以通过@Override注解重写父类方法，实现多态特性。
接口调用：通过实现类定义行为
接口是Java中实现抽象和多态的重要工具,它定义了一组规范，但不提供具体实现，类通过实现接口，必须完成接口中所有方法的定义，然后通过实现类对象调用接口方法。
定义一个接口Flyable：
public interface Flyable {
void fly();
}
实现类Bird实现Flyable接口：
public class Bird implements Flyable {
@Override
public void fly() {
System.out.println("Bird is flying in the sky.");
}
}
在Main类中，通过接口类型引用实现类对象，并调用接口方法：
public class Main {
public static void main(String[] args) {
Flyable flyable = new Bird(); // 接口多态
flyable.fly(); // 调用实现类方法
}
}
接口调用体现了“面向接口编程”的思想，降低了类之间的耦合度，便于扩展和维护，新增一个Airplane类实现Flyable接口时，无需修改调用方的代码。
反射机制调用：动态访问类的成员
反射是Java高级特性,允许程序在运行时动态获取类的信息（如成员变量、方法、构造方法）并调用，反射常用于框架开发、动态代理等场景。
假设有一个Student类：
public class Student {
private String name;
public Student() {}
public void study(String subject) {
System.out.println("Studying " + subject);
}
}
通过反射调用Student类的成员：
import java.lang.reflect.Method;
public class Main {
public static void main(String[] args) throws Exception {
Class<?> clazz = Class.forName("Student"); // 获取Class对象
Object student = clazz.getDeclaredConstructor().newInstance(); // 实例化对象
Method studyMethod = clazz.getMethod("study", String.class); // 获取方法
studyMethod.invoke(student, "Java"); // 调用方法
// 访问私有字段（需设置可访问）
Field nameField = clazz.getDeclaredField("name");
nameField.setAccessible(true);
nameField.set(student, "Bob");
}
}
反射机制提供了极大的灵活性,但也破坏了封装性（可访问私有成员），且性能较低，需谨慎使用。
内部类调用：嵌套类的成员访问
内部类是定义在另一个类内部的类,分为成员内部类、静态内部类、局部内部类和匿名内部类，内部类可以直接访问外部类的私有成员，实现更紧密的逻辑封装。
外部类Outer和成员内部类Inner：
public class Outer {
private String outerField = "Outer field";
class Inner {
public void accessOuter() {
System.out.println(outerField); // 直接访问外部类私有成员
}
}
}
在Main类中，通过外部类对象实例化内部类对象：
public class Main {
public static void main(String[] args) {
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(); // 实例化内部类
inner.accessOuter();
}
}
静态内部类（用static修饰）无需依赖外部类实例即可创建，而局部内部类定义在方法或代码块中，匿名内部类常用于实现接口或继承类的临时场景。
Java中类的调用方式多样,从基础的实例化对象调用，到静态成员的直接访问，再到继承、接口、反射和内部类的进阶调用，每种方式适用于不同的场景，开发者需根据实际需求（如是否需要封装、是否需要动态性、是否需要多态等）选择合适的调用方式，合理运用这些调用机制，能够构建出结构清晰、可维护、可扩展的Java应用程序。
