静态方法和非静态方法是面向对象编程中的两个重要概念，用于定义类中的行为和功能。它们在以下方面有所不同：

静态方法：
静态方法是属于类本身的方法，而不是类的实例。它们可以通过类名直接调用，而无需创建类的对象。静态方法具有以下特点：

  1. 静态方法在内存中只有一份副本，被所有该类的实例共享。
  2. 静态方法不能直接访问非静态成员（变量或方法），因为它们没有隶属于任何特定实例。
  3. 静态方法通常用于执行与类相关的操作，不依赖于对象的状态。
  4. 静态方法不能被子类重写，因为它们与类本身相关，而不是与实例相关。

非静态方法：
非静态方法是属于类的实例的方法。它们必须通过创建类的对象来调用。非静态方法具有以下特点：

  1. 非静态方法在每个类的实例中都有自己的副本，每个实例都可以独立地调用和修改它们。
  2. 非静态方法可以直接访问类的非静态成员和静态成员，包括变量和方法。
  3. 非静态方法通常用于执行与对象状态相关的操作，可以访问和修改对象的实例变量。
  4. 非静态方法可以被子类重写（覆盖），允许在子类中改变或扩展方法的行为。

在选择使用静态方法还是非静态方法时，需要考虑方法是否需要访问类的实例变量和方法，以及它们是否依赖于对象的状态。如果方法不需要访问实例变量并且与类本身相关，则可以将其定义为静态方法。如果方法需要访问实例变量并且与对象的状态相关，则应将其定义为非静态方法。

1.调用方式：

  • 静态方法可以直接通过类名调用，不需要创建类的实例。例如，假设有一个名为MathUtils的工具类，其中定义了一个静态方法add：
public class MathUtils {
    public static int add(int a, int b) {
        return a + b;
    }
}
  • 可以通过MathUtils.add(2, 3)来调用静态方法add，无需创建MathUtils的实例。
  • 实例方法需要通过类的实例（对象）来调用。例如，假设有一个名为Calculator的类，其中定义了一个实例方法multiply：
public class Calculator {
    public int multiply(int a, int b) {
        return a * b;
    }
}

需要先创建Calculator的实例，然后通过该实例来调用实例方法。例如：

Calculator calculator = new Calculator();
int result = calculator.multiply(2, 3);

2.内存分配：

  • 静态方法在类加载时就被分配内存，它属于类级别的方法，存储在方法区。当类被加载到内存中时，静态方法的字节码就会被加载到方法区，并且可以直接通过类名进行访问。
  • 实例方法在对象创建时才被分配内存，每个对象都有自己的实例方法。当创建一个类的实例时，会为该实例分配内存，并且实例方法的字节码也会被加载到内存中。

3.访问权限：

  • 静态方法可以直接访问类的静态成员（静态变量和静态方法），以及类的非静态成员（实例变量和实例方法），但不能直接访问非静态成员。这是因为静态方法在对象创建之前就已经存在，无法引用特定对象的非静态成员。
  • 实例方法可以直接访问类的静态成员和非静态成员。实例方法在对象创建后才能被调用，因此可以访问和操作对象的实例变量和其他实例方法。

现在，让我们通过示例代码来进一步理解静态方法和实例方法的区别。以下是示例代码：

public class MathUtils {
    private static int count;  // 静态变量

    public static int add(int a, int b) {
        return a + b;
    }

    public int multiply(int a, int b) {
        return a * b;
    }

    public static void incrementCount() {
        count++;
    }

    public void printCount() {
        System.out.println("Count: " + count);
    }
}

在上述示例代码中，我们创建了一个名为MathUtils的类，其中包含一个静态变量count、一个静态方法add、一个实例方法multiply、一个静态方法incrementCount和一个实例方法printCount。

现在，我们来演示如何调用静态方法和实例方法：

public class Main {
    public static void main(String[] args) {
        // 调用静态方法
        int sum = MathUtils.add(2, 3);
        System.out.println("Sum: " + sum);

        // 调用实例方法
        MathUtils mathUtils = new MathUtils();
        int product = mathUtils.multiply(2, 3);
        System.out.println("Product: " + product);

        // 访问静态变量
        MathUtils.incrementCount();
        mathUtils.printCount();
    }
}

在上述示例代码中，我们首先通过MathUtils.add(2, 3)调用静态方法add，并将返回值存储在sum变量中。然后，我们创建了一个MathUtils的实例mathUtils，并通过mathUtils.multiply(2, 3)调用实例方法multiply，将返回值存储在product变量中。最后，我们通过MathUtils.incrementCount()调用静态方法incrementCount来增加静态变量count的值，然后通过mathUtils.printCount()调用实例方法printCount来打印静态变量count的值。

4.关联对象：

  • 静态方法与任何特定的对象实例无关，因此无法直接访问实例变量或调用实例方法。静态方法通常用于执行与类相关的操作，而不依赖于特定的对象状态。
  • 实例方法与特定的对象实例相关联，可以直接访问和操作对象的实例变量和其他实例方法。实例方法通常用于执行与对象状态相关的操作。

5.继承和重写：

  • 静态方法可以被子类继承，但无法被子类重写。子类可以通过类名直接调用继承的静态方法，但无法在子类中重写该方法。
  • 实例方法可以被子类继承，并且子类可以重写父类的实例方法。子类重写的实例方法将覆盖父类的实现，可以根据子类的需要改变方法的行为。

示例代码，演示了继承和重写的概念：

public class Animal {
    public static void staticMethod() {
        System.out.println("Animal - 静态方法");
    }

    public void instanceMethod() {
        System.out.println("Animal - 实例方法");
    }
}

public class Dog extends Animal {
    public static void staticMethod() {
        System.out.println("Dog - 静态方法");
    }

    public void instanceMethod() {
        System.out.println("Dog - 实例方法");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();

        // 静态方法调用
        Animal.staticMethod();  // 输出: Animal - 静态方法
        Dog.staticMethod();     // 输出: Dog - 静态方法

        // 实例方法调用
        animal.instanceMethod();  // 输出: Animal - 实例方法
        dog.instanceMethod();     // 输出: Dog - 实例方法
    }
}

在上述示例代码中，我们定义了一个Animal类，其中包含一个静态方法staticMethod和一个实例方法instanceMethod。然后，我们创建了一个Dog类，它继承自Animal类，并重写了父类的静态方法和实例方法。

在Main类的main方法中，我们创建了一个Animal对象animal和一个Dog对象dog。然后，我们通过类名直接调用静态方法staticMethod，分别输出了父类和子类的静态方法调用结果。接下来，我们通过对象调用实例方法instanceMethod，同样输出了父类和子类的实例方法调用结果。

6.适用场景：

  • 静态方法适用于不依赖于对象状态的操作，例如数学计算、工具类方法等。
  • 实例方法适用于依赖于对象状态的操作，例如修改对象的属性、执行与对象相关的逻辑等。