Java访问修饰符

在Java中，访问修饰符是用来定义类、变量、方法和构造器的可访问性的。这些修饰符决定了其他类或程序的成分能否访问某个类的字段和方法。Java提供了四种主要的访问级别：private，default (无修饰符)，protected，和 public。

1. private：最严格的访问级别，私有成员只能在类本身内部被访问。
2. protected：受保护成员可以被同包的类或所有子类访问。
3. public：公共成员可以被任何其他类访问。
4. 默认（无修饰符，也称为包私有）：成员可以被同一包内的任何类访问。

下面通过具体的例子来展示每种访问修饰符的用法和影响：

1. private

private 修饰符是访问级别最严格的修饰符，被其修饰的成员只能被同一个类的方法访问。

public class Car {
    private int year;
    private void display() {
        System.out.println("Year: " + year);
    }
    
    public void setYear(int year) {
        this.year = year;
    }
    
    public void show() {
        display(); // 同类中访问private方法
    }
}

class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.setYear(2022);
        // myCar.display(); // 错误: display() 在 Car 中是 private 访问控制
        myCar.show(); // 正确
    }
}

2. 默认访问修饰符（无修饰符，package-private）

如果不设置任何访问修饰符（默认访问级别），则成员被视为包私有，即只能被同一个包的类访问。

package com.example.vehicle;

class Bicycle {
    void displayModel() {
        System.out.println("This is a bicycle.");
    }
}

public class Main {
    public static void main(String[] args) {
        Bicycle bike = new Bicycle();
        bike.displayModel(); // 正确，因为 Main 和 Bicycle 在同一个包中
    }
}

package com.example.user;

import com.example.vehicle.Bicycle;

class Test {
    void testBike() {
        Bicycle bike = new Bicycle();
        // bike.displayModel(); // 错误: displayModel() 在 Bicycle 中不可访问
    }
}

3. protected

protected 修饰符允许同一包内的其他类以及所有子类访问。

package com.example.vehicle;

public class Vehicle {
    protected String brand = "Ford";        // Vehicle 品牌
    protected void honk() {                 // 车辆按喇叭
        System.out.println("Tuut, tuut!");
    }
}

package com.example.vehicle;

class Car extends Vehicle {
    private void display() {
        honk(); // 可以访问父类的 protected 方法
        System.out.println("Brand: " + brand); // 可以访问父类的 protected 字段
    }
}

package com.example.test;

import com.example.vehicle.Vehicle;

public class TestVehicle extends Vehicle {
    public void test() {
        System.out.println("Brand: " + brand); // 正确
        honk(); // 正确
    }
}

如果外包中的类并没有继承，则无法访问protected和private变量和方法

package com.example.test;

import com.example.vehicle.Vehicle;

public class TestVehicle {
    public void test() {
        Vehicle myVehicle = new Vehicle();
        System.out.println("Brand: " + myVehicle.brand);  // 错误：无法访问'brand'
        myVehicle.honk();  // 错误：无法访问'honk()'
    }
}

但是可以访问public static

package com.example.vehicle;

public class Vehicle {
    public static String brand = "Ford";  // 公共字段
    public static void honk() {           // 公共方法
        System.out.println("Tuut, tuut!");
    }
}

package com.example.test;

import com.example.vehicle.Vehicle;

public class TestVehicle {
    public void test() {
        System.out.println("Brand: " + Vehicle.brand);  // 正确：可以访问公共字段
        Vehicle.honk();  // 正确：可以调用公共方法
    }
}

4. public

public 修饰符设置了最少的访问限制，被其修饰的成员可以被任何其他类访问。

package com.example.vehicle;

public class Vehicle {
    public void display() {
        System.out.println("This is a vehicle.");
    }
}

package com.example.main;

import com.example.vehicle.Vehicle;

public class Main {
    public static void main(String[] args) {
        Vehicle myVehicle = new Vehicle();
        myVehicle.display(); // 正确
    }
}

每种修饰符都有其特定的用途，通过合理使用它们，可以使代码更加安全、清晰和易于维护。