实例方法和静态方法：假设类A有如下定义，且a是A类的一个实例，则必定错误的选项是（C）。

题目

假设类A有如下定义，且a是A类的一个实例，则必定错误的选项是（C）。

class A {

int i;

static String s;

void method1() { }

static void method2() { }

}

A. System.out.println(a.i)；

B. a.method1();

C. A.method1();

D. A.method2() ;

解析：A、B、D正确，C错误

public class Main {
    public static void main(String[] args) {
        A a = new A(5, "s");  //创建类 A 的实例 a
        System.out.println(a.i);  //正常编译，因为 i 是 A 类的一个实例变量（非静态），并且可以通过 A类的一个实例（如 a）来访问。
        a.method1();  //正常编译，method1()是一个实例方法，它可以通过 A 类的一个实例（如 a）来调用。
        A.method1();  //代码报错，method1()是一个实例方法，它不能通过类名（如 A）直接调用。实例方法需要通过类的实例来调用。
        A.method2();  //method2()是一个静态方法（由 static关键字标识），它可以通过类名（如 A）直接调用，而不需要类的实例。
    }
}
​
class A {
    int i;
    static String s;
    //构造函数
    public A(int i, String s) {
        this.i = i;
        this.s = s;
    }
    //非静态方法（实例方法）
    void method1() {
    }
    //静态方法
    static void method2() {
    }
}
​

以下是一些关于Java类的实例方法（非静态方法）和静态方法的例子：

例子1：实例方法

public class Main {
    public static void main(String[] args) {
        // 创建Car的实例
        Car myCar = new Car("Toyota", 2023);
        // 调用实例方法
        myCar.startEngine(); // 输出：Car Toyota started.
        System.out.println("Year: " + myCar.getYear()); // 输出：Year: 2023
        // 尝试通过类名调用实例方法会编译错误
        Car.startEngine(); // 错误：不能这样调用非静态方法
    }
}
​
class Car {
    private String model;
    private int year;
    // 构造函数
    public Car(String model, int year) {
        this.model = model;
        this.year = year;
    }
    // 非静态方法（实例方法）
    public void startEngine() {
        System.out.println("Car " + model + " started.");
    }
    // 获取年份的实例方法
    public int getYear() {
        return year;
    }
}

例子2：静态方法

public class MathUtils {  
      
    // 静态方法，用于计算两个数的和  
    public static int add(int a, int b) {  
        return a + b;  
    }  
  
    public static void main(String[] args) {  
        // 调用静态方法  
        int sum = MathUtils.add(5, 3);  
        System.out.println("Sum: " + sum); // 输出：Sum: 8  
  
        // 尝试通过实例调用静态方法虽然可以工作，但通常不推荐这样做  
        // 因为静态方法与类的实例无关  
        // MathUtils mathUtils = new MathUtils(); // 实际上不需要创建MathUtils的实例  
        // int anotherSum = mathUtils.add(2, 2); // 这会工作，但不建议这样做  
  
        // 直接通过类名调用静态方法  
        int anotherSum = MathUtils.add(2, 2);  
        System.out.println("Another Sum: " + anotherSum); // 输出：Another Sum: 4  
    }  
}

总结

• 实例方法（非静态方法）：需要通过类的实例来调用。它们可以访问实例变量（非静态变量）和其他实例方法。

• 静态方法：可以通过类名直接调用，而不需要创建类的实例。它们只能访问静态变量和静态方法。由于静态方法与类的实例无关，因此它们不能访问实例变量（非静态变量）或实例方法（非静态方法），除非通过某个类的实例来引用。在Java中，main 方法就是一个静态方法，因为它是程序的入口点，不需要创建任何类的实例就可以直接调用。

__EOF__

本文作者：Josi
本文链接：https://www.cnblogs.com/joiny-/p/18259698.html
关于博主：编程小萌新一名，希望从今天开始慢慢提高，一步步走向技术的高峰！
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！