java中有哪些方法，分别有哪些作用

java中有哪些方法，分别有哪些作用，这个问题我相信不少初学者疑惑挺大的，日常的课上只有Java在各个领域的应用和原则描述，没有对方法进行总结

1. 静态方法（Static Method）

静态方法是属于类而不是类的实例的方法。静态方法可以通过类名直接调用，而不需要创建类的对象。

特点

• 修饰符：使用 static 关键字修饰。

• 调用方式：可以通过类名直接调用，也可以通过对象调用（不推荐）。

• 访问权限：可以是 public、protected 或 private。

• 限制：不能访问类的非静态属性和非静态方法，因为静态方法属于类，而非类的实例。

示例

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

public class Main {
    public static void main(String[] args) {
        int result = MathUtils.add(5, 3); // 通过类名调用静态方法
        System.out.println(result); // 输出：8
    }
}

使用场景

• 工具类：如 Math 类中的 Math.abs()、Math.random() 等。

• 常量类：提供一些静态常量和静态方法。

• 单例模式：通过静态方法提供单例实例。

2. 私有方法（Private Method）

私有方法是只能在类内部被访问的方法。私有方法不能被外部类或子类直接调用。

特点

• 修饰符：使用 private 关键字修饰。

• 访问权限：只能在定义它的类内部访问。

• 用途：通常用于封装类的内部实现细节，避免外部直接调用。

示例

public class Calculator {
    private int calculateSum(int a, int b) {
        return a + b;
    }

    public void printSum(int a, int b) {
        int sum = calculateSum(a, b); // 在类内部调用私有方法
        System.out.println("Sum: " + sum);
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        calc.printSum(5, 3); // 输出：Sum: 8
        // calc.calculateSum(5, 3); // 错误：无法访问私有方法
    }
}

使用场景

• 封装内部逻辑：隐藏实现细节，只暴露公共接口。

• 辅助方法：用于实现类的内部功能，如递归辅助方法、验证逻辑等。

3. 构造方法（Constructor）

构造方法是用于创建类的实例时初始化对象的方法。构造方法的名称必须与类名相同，且没有返回值类型。

特点

• 名称：必须与类名相同。

• 返回值：没有返回值类型（包括 void）。

• 调用：通过 new 关键字调用。

• 重载：可以有多个构造方法，只要参数列表不同。

示例

public class Person {
    private String name;
    private int age;

    // 无参构造方法
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }

    // 带参数的构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person(); // 调用无参构造方法
        person1.display(); // 输出：Name: Unknown, Age: 0

        Person person2 = new Person("Alice", 25); // 调用带参数的构造方法
        person2.display(); // 输出：Name: Alice, Age: 25
    }
}

使用场景

• 对象初始化：在创建对象时初始化对象的属性。

• 重载构造方法：提供不同的初始化方式。

4. 抽象方法（Abstract Method）

抽象方法是没有具体实现的方法，必须在抽象类或接口中定义。抽象方法要求子类必须实现该方法。

特点

• 修饰符：使用 abstract 关键字修饰。

• 实现：没有方法体，以分号结尾。

• 使用：必须在抽象类或接口中定义。

示例

abstract class Animal {
    public abstract void speak(); // 抽象方法
}

class Dog extends Animal {
    @Override
    public void speak() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    public void speak() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.speak(); // 输出：Dog barks

        Animal myCat = new Cat();
        myCat.speak(); // 输出：Cat meows
    }
}

使用场景

• 定义通用接口：在抽象类或接口中定义通用方法，由子类实现具体逻辑。

• 强制子类实现：确保子类必须实现某些方法。

5. 最终方法（Final Method）

最终方法是不能被子类重写的方法。使用 final 关键字修饰。

特点

• 修饰符：使用 final 关键字修饰。

• 重写限制：不能被子类重写。

示例

class Animal {
    public final void eat() {
        System.out.println("Animal eats");
    }
}

class Dog extends Animal {
    // 错误：不能重写 final 方法
    // public void eat() {
    //     System.out.println("Dog eats");
    // }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat(); // 输出：Animal eats
    }
}

使用场景

• 防止方法被重写：确保某些方法的实现逻辑不能被修改。

• 性能优化：JVM 可以对 final 方法进行优化。

6. 同步方法（Synchronized Method）

同步方法是用于实现线程安全的方法。同步方法可以防止多个线程同时访问共享资源。

特点

• 修饰符：使用 synchronized 关键字修饰。

• 锁机制：同步方法会自动获取对象锁（非静态同步方法）或类锁（静态同步方法）。

示例

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + counter.getCount()); // 输出：Final count: 2000
    }
}

使用场景

• 线程安全：确保多线程环境下的数据一致性。

• 资源保护：防止多个线程同时访问共享资源。

7. 默认方法（Default Method）

默认方法是接口中可以有具体实现的方法。默认方法使用 default 关键字修饰。

特点

• 修饰符：使用 default 关键字修饰。

• 实现：可以有方法体。

• 使用：在接口中定义默认方法，实现类可以选择性地覆盖该方法。

示例

interface Animal {
    default void speak() {
        System.out.println("Animal speaks");
    }
}

class Dog implements Animal {
    @Override
    public void speak() {
        System.out.println("Dog barks");
    }
}

class Cat implements Animal {
    // 没有覆盖默认方法
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.speak(); // 输出：Dog barks

        Animal myCat = new Cat();
        myCat.speak(); // 输出：Animal speaks
    }
}

使用场景

• 向后兼容：在接口中添加新方法，而不需要修改