探索 Java 包（Package）与访问修饰符：合理组织代码结构，通过 public、protected、default、private 控制成员的可见性与可访问性。

好的，各位亲爱的码友们，欢迎来到今天的“Java 包与访问修饰符漫谈”专场！我是你们的老朋友，人称“bug克星”的码农老王。今天，咱们不聊高深莫测的算法，也不谈云里雾里的架构，就来聊聊Java世界里那些看似不起眼，却又至关重要的“小家伙”——包（Package）和访问修饰符。

准备好了吗？让我们一起揭开它们神秘的面纱，看看它们是如何影响我们的代码结构，以及如何像门卫一样，守护着我们的代码安全！😎

第一幕：包（Package）——代码的“小区”与“门牌号”

想象一下，如果所有的房子都挤在一个大平原上，没有任何规划，那将会是怎样一番景象？找个人像大海捞针，送个快递直接迷路，简直就是一场灾难！

Java的包，就扮演着“小区规划师”的角色。它就像一个个整齐划一的小区，将相关的类组织在一起，让我们的代码井然有序，易于管理。

1. 为什么要用包？

• 避免命名冲突： 想象一下，你写了一个Dog类，你的同事也写了一个Dog类，如果没有包，那编译器就要崩溃了：“到底要用哪个Dog？！” 包就像门牌号，com.example.myproject.Dog和com.mycompany.animal.Dog，有了它们，编译器就能轻松区分，避免了命名冲突。
• 提高代码可维护性： 将相关的类放在同一个包里，就像把同一栋楼的住户放在一起，方便管理和维护。你要修改某个功能，直接找到对应的包，事半功倍！
• 控制访问权限： 包不仅仅是代码的容器，它还影响着访问修饰符的作用范围，后面我们会详细讲解。

2. 如何创建和使用包？

创建包很简单，只需要在Java文件的开头加上package语句即可。例如：

package com.example.myproject;

public class MyClass {
    // 类的内容
}

这就像给你的房子挂上门牌号com.example.myproject。

使用包也很简单，有两种方式：

• 完整类名： 每次使用类的时候，都写上完整的包名。例如：

  com.example.myproject.MyClass myObject = new com.example.myproject.MyClass();

  这种方式比较繁琐，就像每次回家都要念一遍完整的家庭住址，累！

• import语句： 在文件的开头使用import语句，引入需要使用的类。例如：

  import com.example.myproject.MyClass;
  
  public class AnotherClass {
      public void doSomething() {
          MyClass myObject = new MyClass(); // 直接使用类名
      }
  }

  这种方式就像拿到小区的通行证，以后进出小区就方便多了！

3. 包的命名规范：

包的命名通常采用反向域名的方式，例如com.example.myproject。这样做的好处是可以保证包名的唯一性，避免与其他公司的项目发生冲突。

• 小写字母： 包名通常使用小写字母，提高可读性。
• 层次结构： 包名通常采用层次结构，例如com.example.myproject.model、com.example.myproject.service，方便组织代码。

总结一下，包就像代码的“小区”，它帮助我们组织代码，避免命名冲突，提高代码可维护性。使用package语句创建包，使用import语句引入包。记住，包的命名要规范，就像给房子挂上一个清晰的门牌号！🏠

第二幕：访问修饰符——代码的“门卫”与“保安”

有了包这个“小区”，接下来就要考虑安全问题了。谁可以进入我的房子？谁可以访问我的客厅？谁可以偷看我的日记？这就需要我们的“门卫”和“保安”——访问修饰符来出场了！

Java提供了四种访问修饰符，它们控制着类、方法、变量的可见性和可访问性。

1. public——“大门敞开，欢迎光临！”

public就像一个热情好客的主人，把大门敞开，欢迎所有人来参观。

• 类： public类可以被任何其他类访问。
• 方法和变量： public方法和变量可以被任何其他类访问。

示例：

package com.example.myproject;

public class PublicClass {
    public String publicVariable = "This is a public variable.";

    public void publicMethod() {
        System.out.println("This is a public method.");
    }
}

// 在另一个类中
package com.anotherproject;

import com.example.myproject.PublicClass;

public class AnotherClass {
    public void doSomething() {
        PublicClass publicObject = new PublicClass();
        System.out.println(publicObject.publicVariable); // 可以访问 public 变量
        publicObject.publicMethod(); // 可以调用 public 方法
    }
}

public是权限最高的访问修饰符，就像一个毫无防备的“裸奔者”，虽然方便，但也存在一定的安全风险。

2. protected——“亲朋好友，内部人员，请进！”

protected就像一个比较谨慎的主人，只允许亲朋好友和内部人员进入。

• 类： protected不能修饰类（只能修饰内部类，后面会讲到）。
• 方法和变量： protected方法和变量可以被以下类访问：
  • 同一个包中的所有类。
  • 不同包中的子类。

示例：

package com.example.myproject;

public class ProtectedClass {
    protected String protectedVariable = "This is a protected variable.";

    protected void protectedMethod() {
        System.out.println("This is a protected method.");
    }
}

// 同一个包中的类
package com.example.myproject;

public class SamePackageClass {
    public void doSomething() {
        ProtectedClass protectedObject = new ProtectedClass();
        System.out.println(protectedObject.protectedVariable); // 可以访问 protected 变量
        protectedObject.protectedMethod(); // 可以调用 protected 方法
    }
}

// 不同包中的子类
package com.anotherproject;

import com.example.myproject.ProtectedClass;

public class SubClass extends ProtectedClass {
    public void doSomething() {
        System.out.println(this.protectedVariable); // 可以访问 protected 变量
        this.protectedMethod(); // 可以调用 protected 方法
    }
}

protected提供了一定的封装性，允许子类继承和访问父类的成员，同时也限制了外部类的访问。

3. default（package-private）——“同一个小区的邻居，请进！”

default就像一个比较内向的主人，只允许同一个小区的邻居进入。

• 类： default类可以被同一个包中的所有类访问。
• 方法和变量： default方法和变量可以被同一个包中的所有类访问。

注意： default访问修饰符没有关键字，如果在声明类、方法、变量时没有指定任何访问修饰符，那么它就是default的。

示例：

package com.example.myproject;

class DefaultClass { // 没有指定访问修饰符，默认为 default
    String defaultVariable = "This is a default variable.";

    void defaultMethod() { // 没有指定访问修饰符，默认为 default
        System.out.println("This is a default method.");
    }
}

// 同一个包中的类
package com.example.myproject;

public class SamePackageClass {
    public void doSomething() {
        DefaultClass defaultObject = new DefaultClass();
        System.out.println(defaultObject.defaultVariable); // 可以访问 default 变量
        defaultObject.defaultMethod(); // 可以调用 default 方法
    }
}

// 不同包中的类
package com.anotherproject;

import com.example.myproject.DefaultClass; // 编译错误，无法访问 default 类

public class AnotherClass {
    public void doSomething() {
        DefaultClass defaultObject = new DefaultClass(); // 编译错误，无法访问 default 类
    }
}

default提供了比public更强的封装性，只允许同一个包中的类访问，适用于组织内部的代码。

4. private——“谢绝参观，禁止入内！”

private就像一个非常注重隐私的主人，谢绝一切参观，禁止任何人进入。

• 类： private不能修饰类（只能修饰内部类，后面会讲到）。
• 方法和变量： private方法和变量只能被声明它们的类访问。

示例：

package com.example.myproject;

public class PrivateClass {
    private String privateVariable = "This is a private variable.";

    private void privateMethod() {
        System.out.println("This is a private method.");
    }

    public void publicMethod() {
        System.out.println(this.privateVariable); // 可以访问 private 变量
        this.privateMethod(); // 可以调用 private 方法
    }
}

// 另一个类
package com.anotherproject;

import com.example.myproject.PrivateClass;

public class AnotherClass {
    public void doSomething() {
        PrivateClass privateObject = new PrivateClass();
        System.out.println(privateObject.privateVariable); // 编译错误，无法访问 private 变量
        privateObject.privateMethod(); // 编译错误，无法调用 private 方法
    }
}

private是权限最低的访问修饰符，提供了最强的封装性，保护了类的内部状态，防止外部类直接修改。

总结一下，访问修饰符就像代码的“门卫”和“保安”，它们控制着类、方法、变量的可见性和可访问性。public权限最高，private权限最低，protected和default介于两者之间。选择合适的访问修饰符，可以提高代码的封装性和安全性。🔒

第三幕：访问修饰符与继承——“子承父业，权限继承”

在Java的世界里，继承是一种非常重要的概念。子类可以继承父类的属性和方法，那么访问修饰符是如何影响继承的呢？

• public： 子类可以继承父类的所有public成员。
• protected： 子类可以继承父类的protected成员。
• default： 如果子类和父类在同一个包中，子类可以继承父类的default成员。
• private： 子类不能继承父类的private成员。

示例：

package com.example.myproject;

public class ParentClass {
    public String publicVariable = "This is a public variable.";
    protected String protectedVariable = "This is a protected variable.";
    String defaultVariable = "This is a default variable."; // default
    private String privateVariable = "This is a private variable.";

    public void publicMethod() {
        System.out.println("This is a public method.");
    }

    protected void protectedMethod() {
        System.out.println("This is a protected method.");
    }

    void defaultMethod() { // default
        System.out.println("This is a default method.");
    }

    private void privateMethod() {
        System.out.println("This is a private method.");
    }
}

// 同一个包中的子类
package com.example.myproject;

public class ChildClass extends ParentClass {
    public void doSomething() {
        System.out.println(this.publicVariable); // 可以访问 public 变量
        System.out.println(this.protectedVariable); // 可以访问 protected 变量
        System.out.println(this.defaultVariable); // 可以访问 default 变量
        // System.out.println(this.privateVariable); // 编译错误，无法访问 private 变量

        this.publicMethod(); // 可以调用 public 方法
        this.protectedMethod(); // 可以调用 protected 方法
        this.defaultMethod(); // 可以调用 default 方法
        // this.privateMethod(); // 编译错误，无法调用 private 方法
    }
}

// 不同包中的子类
package com.anotherproject;

import com.example.myproject.ParentClass;

public class AnotherChildClass extends ParentClass {
    public void doSomething() {
        System.out.println(this.publicVariable); // 可以访问 public 变量
        System.out.println(this.protectedVariable); // 可以访问 protected 变量
        // System.out.println(this.defaultVariable); // 编译错误，无法访问 default 变量

        this.publicMethod(); // 可以调用 public 方法
        this.protectedMethod(); // 可以调用 protected 方法
        // this.defaultMethod(); // 编译错误，无法调用 default 方法
    }
}

从上面的例子可以看出，子类可以继承父类的public和protected成员，以及同一个包中的default成员，但不能继承父类的private成员。

第四幕：内部类与访问修饰符——“房子里的房间，权限嵌套”

除了普通的类，Java还支持内部类，也就是在一个类里面定义的类。内部类可以访问外部类的成员，那么访问修饰符是如何影响内部类的呢？

• 内部类可以使用所有的访问修饰符：public、protected、default、private。
• 内部类的访问权限取决于它自身的访问修饰符，以及它所在的外部类的访问权限。

示例：

package com.example.myproject;

public class OuterClass {
    private String outerVariable = "This is a private variable in OuterClass.";

    public class PublicInnerClass {
        public void doSomething() {
            System.out.println(outerVariable); // 可以访问外部类的 private 变量
        }
    }

    protected class ProtectedInnerClass {
        public void doSomething() {
            System.out.println(outerVariable); // 可以访问外部类的 private 变量
        }
    }

    class DefaultInnerClass { // default
        public void doSomething() {
            System.out.println(outerVariable); // 可以访问外部类的 private 变量
        }
    }

    private class PrivateInnerClass {
        public void doSomething() {
            System.out.println(outerVariable); // 可以访问外部类的 private 变量
        }
    }

    public void accessInnerClasses() {
        PublicInnerClass publicInner = new PublicInnerClass();
        ProtectedInnerClass protectedInner = new ProtectedInnerClass();
        DefaultInnerClass defaultInner = new DefaultInnerClass();
        PrivateInnerClass privateInner = new PrivateInnerClass();

        publicInner.doSomething();
        protectedInner.doSomething();
        defaultInner.doSomething();
        privateInner.doSomething();
    }
}

// 另一个类
package com.anotherproject;

import com.example.myproject.OuterClass;

public class AnotherClass {
    public void doSomething() {
        OuterClass outer = new OuterClass();
        OuterClass.PublicInnerClass publicInner = outer.new PublicInnerClass(); // 可以访问 public 内部类
        // OuterClass.ProtectedInnerClass protectedInner = outer.new ProtectedInnerClass(); // 编译错误，无法访问 protected 内部类
        // OuterClass.DefaultInnerClass defaultInner = outer.new DefaultInnerClass(); // 编译错误，无法访问 default 内部类
        // OuterClass.PrivateInnerClass privateInner = outer.new PrivateInnerClass(); // 编译错误，无法访问 private 内部类
    }
}

从上面的例子可以看出，内部类可以访问外部类的所有成员，包括private成员。但是，外部类对内部类的访问权限取决于内部类自身的访问修饰符。

总结与建议——“合理规划，安全第一”

今天，我们一起漫谈了Java的包和访问修饰符，它们就像代码的“小区”、“门卫”和“保安”，帮助我们组织代码，控制访问权限，提高代码的封装性和安全性。

访问修饰符	作用范围	适用场景
public	所有类都可以访问	需要对外公开的API，例如公共方法、公共变量。
protected	同一个包中的类和不同包中的子类可以访问	允许子类继承和访问父类的成员，同时限制外部类的访问。
default	同一个包中的类可以访问	只允许同一个包中的类访问，适用于组织内部的代码。
private	只能被声明它们的类访问	保护类的内部状态，防止外部类直接修改，适用于封装性要求高的成员。

最后，给大家一些建议：

• 合理规划包结构： 将相关的类放在同一个包里，方便管理和维护。
• 选择合适的访问修饰符： 根据成员的用途和访问权限，选择合适的访问修饰符，提高代码的封装性和安全性。
• 优先使用private： 尽量将成员声明为private，只在必要的时候才放宽访问权限。
• 注意继承的影响： 了解访问修饰符对继承的影响，避免出现意外的访问权限问题。

希望今天的漫谈对大家有所帮助！记住，代码的安全就像房子的安全，需要我们精心呵护！🛡️

好了，今天的分享就到这里，感谢大家的聆听！下次再见！👋