Java面向对象——08修饰符、内部类

1.修饰符

1.访问修饰符

public:

• 任何类都可以访问被声明为public的类、方法、字段或构造函数。

public class MyClass {
    public int myField;
    public void myMethod() {
        // 方法体
    }
}

private:

• 只能在定义它的类内部访问，无法被其他类访问。

public class MyClass {
    private int myField;
    private void myMethod() {
        // 方法体
    }
}

protected:

• 可以在同一包中的其他类以及子类中访问。

public class MyClass {
    protected int myField;
    protected void myMethod() {
        // 方法体
    }
}

default（无修饰符）:

• 只有同一包中的其他类可以访问。

class MyClass {
    int myField; // 默认为default
    void myMethod() {
        // 方法体
    }
}

1.2其他修饰符

static:

• 用于声明静态成员，属于类本身，而不是类的实例。

public class MyClass {
    public static int staticField;
    public static void staticMethod() {
        // 方法体
    }
}

final:

• 用于表示常量、不可修改的类或方法。

public final class MyClass {
    public final int myField = 10;
    public final void myMethod() {
        // 方法体
    }
}

abstract:

• 用于声明抽象类或抽象方法，不能直接实例化抽象类，抽象方法必须在子类中实现。

public abstract class MyClass {
    public abstract void myMethod();
}

synchronized:

• 用于保证多线程环境下的同步访问。

public synchronized void myMethod() {
    // 方法体
}

transient:

• 防止序列化过程中字段被序列化。

private transient int myField;

2.内部类

2.1成员内部类

与外部类在同一层级，并且可以访问外部类的所有成员，包括私有成员。

public class OuterClass {
    private int outerField = 10;

    class InnerClass {
        void display() {
            System.out.println("Outer field: " + outerField);
        }
    }
}

2.2静态内部类

不能访问外部类的实例成员，但可以访问外部类的静态成员。

public class OuterClass {
    private static int staticOuterField = 20;

    static class StaticInnerClass {
        void display() {
            System.out.println("Static outer field: " + staticOuterField);
        }
    }
}

2.3局部内部类

定义在方法内部，只能在方法内使用。

public class OuterClass {
    void outerMethod() {
        class LocalInnerClass {
            void display() {
                System.out.println("Inside local inner class");
            }
        }
        LocalInnerClass local = new LocalInnerClass();
        local.display();
    }
}

2.4匿名内部类

public class OuterClass {
    void createAnonymousClass() {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("Inside anonymous class");
            }
        };
        new Thread(r).start();
    }
}