一文搞懂JAVA 修饰符

在Java中，修饰符（Modifier）是用来限制或者开放类、接口、方法和变量的访问权限；限制或者限制方法的继承或其他行为。Java中的修饰符分为以下几种：

• 访问控制修饰符：public，private，protected和默认（即不写）四种修饰符。
• 继承控制修饰符：final 和 abstract 两种修饰符。
• 静态修饰符：static 修饰符。
• 其他修饰符：synchronized 和 transient 等修饰符。

访问控制修饰符

public

public 是最常用的访问控制修饰符，它表示公开的、最高访问级别，可以在同名类或任意一个类中被访问到。例如：

public class Animal {
    public void eat(){
        System.out.println("Animal is eating...");
    }
}

public class Dog extends Animal {
    public void bark(){
        System.out.println("Dog is barking...");
    }
}

public class Test {
    public static void main(String[] args){
        Dog dog = new Dog();
        dog.eat();
        dog.bark();
    }
}

private

private 表示这个成员变量或方法只能在该类的内部可见，不能在外部被访问到。例如：

public class Animal {
    private String name;
    public Animal(String name){
        this.name = name;
    }
    private void printName(){
        System.out.println("Animal's name: " + name);
    }
}

public class Dog extends Animal {
    public Dog(String name){
        super(name);
    }
    public void printOwner(){
        System.out.println("My owner's name is: " + name);
    }
}

public class Test {
    public static void main(String[] args){
        Dog dog = new Dog("Lucy");
        dog.printName();// 编译错误，方法私有
        dog.printOwner();// 正常输出
    }
}

protected

protected 对该类和其子类可见，即同一个包内的其他类和该类的子类可以访问该成员。例如：

package com.demo;
public class Animal {
    protected String name;
    public Animal(String name){
        this.name = name;
    }
}

package com.demo;
public class Dog extends Animal {
    public Dog(String name){
        super(name);
        System.out.println(name); // animal's name
    }
}

package com.test;
import com.demo.Dog;
public class Test {
    public static void main(String[] args){
        Dog dog = new Dog("Lucy");
        dog.name;// 编译错误，不在同一个包内
    }
}

默认访问控制

如果一个类、方法或变量没有声明任何访问控制修饰符（即不加 public、private 或 protected 这些修饰符之一），则它具有默认访问控制，即在同一个包内可见。

继承控制修饰符

final

final 修饰的类不能被继承，修饰方法则不能被子类重写，修饰变量则表示该变量为常量。例如：

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

public class Dog extends Animal { // 编译错误，final类不能继承
}

public class Cat extends Animal {
    public void eat(){
        System.out.println("Cat is eating fish...");
    }
}

public class Test {
    public static void main(String[] args){
        Cat cat = new Cat();
        cat.eat();//吃鱼
    }
}

abstract

abstract 修饰类表示该类是一个抽象类，不能被实例化，只能被继承。abstract 修饰方法表示该方法是一个抽象方法，没有实现。例如：

public abstract class Animal {
    public void eat(){ // 普通方法
        System.out.println("Animal is eating...");
    }
    public abstract void bark(); // 抽象方法
}

public class Dog extends Animal {
    public void bark(){
        System.out.println("Dog is barking...");
    }
}

public class Test {
    public static void main(String[] args){
        Animal animal = new Animal();// 编译错误，抽象类无法实例化
        Dog dog = new Dog();
        dog.eat(); // 吃
        dog.bark(); // 叫
    }
}

静态修饰符

static 修饰的方法或者变量是属于该类本身，不属于具体的实例，可以被该类的所有实例访问。例如：

public class Dog {
    private static String name;
    public Dog(String name){
        Dog.name = name;
    }
    public static void printName(){
        System.out.println(name);
    }
}

public class Test {
    public static void main(String[] args){
        Dog dog1 = new Dog("Lucy");
        Dog dog2 = new Dog("Lily");
        dog1.printName();//Lily，因为最后一次赋值为Lily，name被静态修饰
        dog2.printName();//Lily
    }
}

其他修饰符

synchronized

synchronized 修饰方法表示该方法为同步方法，同一时间只能有一个线程访问该方法。例如：

public class Animal {
    public synchronized void eat(){ // 同步方法
        System.out.println("Animal is eating...");
    }
}

public class Test {
    public static void main(String[] args){
        Animal animal = new Animal();
        new Thread(() -> animal.eat()).start();
        new Thread(() -> animal.eat()).start();
    }
}

transient

transient 修饰的变量表示该变量不会被序列化，即不会保存到输出流中。例如：

public class Animal implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private transient int age;
}

public class Test {
    public static void main(String[] args) throws Exception {
        Animal animal = new Animal();
        animal.name = "Lucy";
        animal.age = 3;
        ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(new File("animal.txt")));
        oo.writeObject(animal);
        oo.close();
        ObjectInputStream oi = new ObjectInputStream(new FileInputStream(new File("animal.txt")));
        Animal newAnimal = (Animal) oi.readObject();
        oi.close();
        System.out.println(newAnimal.name);//Lucy
        System.out.println(newAnimal.age);//0，因为age属性被transient修饰了，不会被序列化
    }
}

总结

本文介绍了Java中修饰符的应用，涉及到访问控制修饰符、继承控制修饰符、静态修饰符和其他修饰符。看完本文，相信大家对Java中的修饰符会有更深刻的理解。