【Java 类】001-访问修饰符、命名规范

清疚 2023-09-24 21:58 45阅读 0赞

## 【Java 类】001-访问修饰符、命名规范 ##

#### 文章目录 ####

*  【Java 类】001-访问修饰符、命名规范
 *  一、访问修饰符概述
 *   *  1、是什么
     *  2、作用
     *   *  作用
         *  问题
     *  3、访问修饰符有哪些
     *  4、作用对象
 *  二、访问修饰符使用演示
 *   *  1、类访问修饰符演示
     *   *  第一步：创建 \`Dog\` 类：public
         *  第二步：同包下创建 \`Cat\` 类：default
         *  第三步：在 \`domain\` 包下创建 \`Pig\` 类：default
         *  第四步：创建 \`Main\` 类
         *  第五步：查看提示 \`Pig\` 类无法访问
     *  2、方法访问修饰符访问
     *   *  第一步：创建 \`Dog\` 类
         *  第二步：在同包下创建 \`Main\` 类
         *  第三步：在不同包下创建 \`Main\` 方法
         *  第四步：在不同包下创建 \`DogSon\` 类
         *  第五步：演示 \`private\` 方法本类可访问
     *  3、属性访问修饰符演示
     *   *  第一步：创建 \`Dog\` 类
         *  第二步：在同包下创建 \`Main\` 类
         *  第三步：在不同包下创建 \`Main\` 类
         *  第四步：在不同包下创建 \`DogSon\` 类
         *  第五步：演示 \`private\` 属性本类而可访问
         *  扩展：Java 中为什么子类的 \`main\` 方法中通过父类对象的实例访问 \`protected\` 方法报错？
         *  扩展：Java 中为何同类下的 \`main\` 方法可以直接通过当前类对象访问 \`private\` 属性？
 *  三、包命名规范
 *  四、类命名规范
 *  五、变量命名规范
 *  六、常量命名规范
 *  七、方法命名规范
 *  八、泛型命名规范

## 一、访问修饰符概述 ##

### 1、是什么 ###

Java访问修饰符是一种**关键字**，用来控制**类、方法和变量**的**访问权限**。

### 2、作用 ###

#### 作用 ####

1.  **封装性：访问修饰符可以用来限制其他类**对于某个**类、方法或变量**的访问，从而保护类的**数据安全性**，实现类的**封装**。
    
    > Java 面向对象的封装性就依赖访问修饰符来实现！
2.  **可读性：访问修饰符可以用来表明类、方法或变量的访问范围**，使代码更易于**理解和维护**。
    
    > 我对这种可读性的理解是对于访问范围进行了**直接标明**！
3.  **重用性：访问修饰符可以用来控制子类对于父类中属性和方法的访问**，从而实现代码的**重用**。
    
    > 我觉得更多的，访问修饰符对这方面提供了灵活的控制！我觉得子类继承父类最大的目的就是为了代码复用，访问修饰符提供了灵活的控制！
4.  **可维护性：访问修饰符可以用来限制**对于某个类、方法或变量的访问，从而使得**修改代码**更加容易，**不会影响其他部分的代码**。
    
    > 访问修饰符限制了可访问范围，代码修改带来的影响也是在一定范围内的！
5.  \*\*安全性：\*\*访问修饰符可以用来限制对于某个类、方法或变量的访问，从而提高程序的安全性，防止恶意操作或者不合理的访问。
    
    > 限制的大多数目的就是为了安全！凡是容易造成安全问题的行为都应该得到限制！**目标 => 策略 => 规则（限制）！**

总之，Java访问修饰符可以用来控制程序中各个部分的访问范围，从而实现类的**封装**，增强程序的**可读性、重用性、可维护性和安全性**。

#### 问题 ####

访问修饰符并不是只有优点，也会带来一些问题！如带来了程序设计的复杂性，垂直和水平方向的访问限制设置提高了对**软件开发人员**的要求，如果访问修饰符使用不当，会导致代码的可读性大大降低，提高了系统的复杂性！**访问修饰符设置得当的时候，往往带来很多好处，但如果设置不当便适得其反！**

### 3、访问修饰符有哪些 ###

Java中有四种访问修饰符，它们分别是：

1.  **public（公共的）**：被声明为 `public` 的类、方法和变量可以被**任何**其他类访问。
2.  **protected（受保护的）**：被声明为 `protected` 的方法和变量只能被**同一包内**的其他类访问，或者是其他包中的**子类**访问。
3.  **default（默认的）**：如果没有指定任何访问修饰符，则默认为 `default` ，被声明为default的方法和变量只能被**同一包内**的其他类访问。
4.  **private（私有的）**：被声明为 `private` 的方法和变量只能被**同一类内部**的其他方法访问，不能被其他类访问。

![img][]

### 4、作用对象 ###

Java访问修饰符可以用于以下三个对象：

1.  **类**：Java 中的类可以使用 `public` 和 `默认` 的访问修饰符。如果使用 `public` 访问修饰符，这个类将被**其他任何类**所访问。如果使用 `默认` 的访问修饰符，则只能在**同一包内**的其他类中访问这个类。
2.  **方法**：Java 中的方法可以使用 `public`、`protected`、`private`和 `默认` 的访问修饰符。如果使用 `public` 访问修饰符，这个方法将被**其他任何类**所访问。如果使用 `protected` 访问修饰符，这个方法将被**同一包中**的其他类和其他包中的**子类**所访问。如果使用 `private` 访问修饰符，这个方法只能在**同一类中**访问。如果使用 `默认` 的访问修饰符，则只能在**同一包中**的其他类中访问这个方法。
3.  **变量**：Java 中的变量可以使用 `public`、`protected`、`private`和 `默认` 的访问修饰符。如果使用 `public` 访问修饰符，这个变量将被**其他任何类**所访问。如果使用 `protected` 访问修饰符，这个变量将被**同一包中**的其他类和其他包中的**子类**所访问。如果使用 `private` 访问修饰符，这个变量只能在**同一类**中访问。如果使用 `默认` 的访问修饰符，则只能在**同一包中**的其他类中访问这个变量。

在实际开发中，访问修饰符的选择应该根据具体的需求和业务逻辑，合理地使用访问修饰符，避免过度使用访问修饰符，降低代码的可读性和灵活性。同时，需要保持代码的简洁和清晰，避免过度的复杂性和实现细节的暴露。

## 二、访问修饰符使用演示 ##

### 1、类访问修饰符演示 ###

#### 第一步：创建 `Dog` 类：public ####

package main;
    
    /**
     * @author zibo
     * @date 2023/3/5 12:05
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    public class Dog {
        }

#### 第二步：同包下创建 `Cat` 类：default ####

package main;
    
    /**
     * @author zibo
     * @date 2023/3/5 12:07
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    class Cat {
        }

#### 第三步：在 `domain` 包下创建 `Pig` 类：default ####

package domain;
    
    /**
     * @author zibo
     * @date 2023/3/5 12:11
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    class Pig {
        }

#### 第四步：创建 `Main` 类 ####

package main;
    
    import domain.Pig;
    
    /**
     * @author zibo
     * @date 2023/3/5 12:06
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    public class Main {
        
        public static void main(String[] args) {
        
            // public 修饰的类，可以在任何地方被访问
            Dog dog = new Dog();
            // default 修饰的类，只能在同一个包中被访问
            Cat cat = new Cat();
            // default 修饰的类，只能在同一个包中被访问
            new Pig();
        }
    }

#### 第五步：查看提示 `Pig` 类无法访问 ####

![image-20230305121457649][]

### 2、方法访问修饰符访问 ###

#### 第一步：创建 `Dog` 类 ####

package main;
    
    /**
     * @author zibo
     * @date 2023/3/5 12:16
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    public class Dog {
        
    
        /**
         * public 方法：可以被任何类访问
         */
        public void publicMethod() {
        
            System.out.println("publicMethod");
        }
    
        /**
         * protected 方法：可以被同一个包下的类访问，也可以被不同包下的子类访问
         */
        protected void protectedMethod() {
        
            System.out.println("protectedMethod");
        }
    
        /**
         * default 方法：可以被同一个包下的类访问
         */
        void defaultMethod() {
        
            System.out.println("defaultMethod");
        }
    
        /**
         * private 方法：只能被本类访问
         */
        private void privateMethod() {
        
            System.out.println("privateMethod");
        }
    
    }

#### 第二步：在同包下创建 `Main` 类 ####

package main;
    
    /**
     * @author zibo
     * @date 2023/3/5 12:06
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    public class Main {
        
        public static void main(String[] args) {
        
            Dog dog = new Dog();
            dog.publicMethod();
            dog.protectedMethod();
            dog.defaultMethod();
            dog.privateMethod(); // 私有方法报错
        }
    }

**私有方法报错**

![image-20230305122004535][]

#### 第三步：在不同包下创建 `Main` 方法 ####

package test;
    
    import main.Dog;
    
    /**
     * @author zibo
     * @date 2023/3/5 12:18
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    public class Main {
        
    
        public static void main(String[] args) {
        
            Dog dog = new Dog();
            dog.publicMethod();
            dog.protectedMethod(); // 不同包下的非子类访问报错
            dog.defaultMethod(); // 不同包下的类访问报错
            dog.privateMethod(); // 私有方法报错
        }
    
    }

**错误提示**

![image-20230305122131688][]

#### 第四步：在不同包下创建 `DogSon` 类 ####

package test;
    
    import main.Dog;
    
    /**
     * @author zibo
     * @date 2023/3/5 12:22
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    public class DogSon extends Dog {
        
    
        /**
         * 子类访问父类的 public 方法
         */
        public void testPublicMethod() {
        
            publicMethod();
        }
    
        /**
         * 子类可以访问父类的 protected 方法
         */
        public void testProtectedMethod() {
        
            protectedMethod();
        }
        
        /**
         * 子类不能访问父类的 default 方法
         */
        public void testDefaultMethod() {
        
            defaultMethod(); // 报错
        }
        
        /**
         * 子类不能访问父类的 private 方法
         */
        public void testPrivateMethod() {
        
            privateMethod(); // 报错
        }
    
    }

**错误提示**

![image-20230305122532742][]

#### 第五步：演示 `private` 方法本类可访问 ####

package main;
    
    /**
     * @author zibo
     * @date 2023/3/5 12:30
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    public class Dog {
        
    
        /**
         * private 方法：只能被本类访问
         */
        private void privateMethod() {
        
            System.out.println("privateMethod");
        }
    
        public static void main(String[] args) {
        
            Dog dog = new Dog();
            dog.privateMethod();
        }
    
    }

### 3、属性访问修饰符演示 ###

#### 第一步：创建 `Dog` 类 ####

package main;
    
    /**
     * @author zibo
     * @date 2023/3/5 12:31
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    public class Dog {
        
    
        /**
         * public 变量：可以被任何类访问
         */
        public String publicVariable = "publicVariable";
    
        /**
         * protected 变量：可以被同一个包下的类访问，也可以被不同包下的子类访问
         */
        protected String protectedVariable = "protectedVariable";
    
        /**
         * default 变量：可以被同一个包下的类访问
         */
        String defaultVariable = "defaultVariable";
    
        /**
         * private 变量：只能被本类访问
         */
        private String privateVariable = "privateVariable";
    
    }

#### 第二步：在同包下创建 `Main` 类 ####

package main;
    
    /**
     * @author zibo
     * @date 2023/3/5 12:35
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    public class Main {
        
        public static void main(String[] args) {
        
            Dog dog = new Dog();
            System.out.println(dog.publicVariable);
            System.out.println(dog.protectedVariable);
            System.out.println(dog.defaultVariable);
            System.out.println(dog.privateVariable); // 报错
        }
    }

**错误提示**

![image-20230305125446283][]

#### 第三步：在不同包下创建 `Main` 类 ####

package test;
    
    import main.Dog;
    
    /**
     * @author zibo
     * @date 2023/3/5 12:18
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    public class Main {
        
    
        public static void main(String[] args) {
        
            Dog dog = new Dog();
            System.out.println(dog.publicVariable);
            System.out.println(dog.protectedVariable); // 报错
            System.out.println(dog.defaultVariable); // 报错
            System.out.println(dog.privateVariable); // 报错
        }
    
    }

**错误提示**

![image-20230305125637188][]

#### 第四步：在不同包下创建 `DogSon` 类 ####

package test;
    
    import main.Dog;
    
    /**
     * @author zibo
     * @date 2023/3/5 12:22
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    public class DogSon extends Dog {
        
    
        /**
         * 子类访问父类的 public 属性
         */
        public void testPublicProperty() {
        
            System.out.println(publicVariable);
        }
    
        /**
         * 子类可以访问父类的 protected 属性
         */
        public void testProtectedProperty() {
        
            System.out.println(protectedVariable);
        }
    
        /**
         * 子类访问父类的 default 属性
         */
        public void testDefaultProperty() {
        
            System.out.println(defaultVariable); // 报错
        }
    
        /**
         * 子类不能访问父类的 private 属性
         */
        public void testPrivateProperty() {
        
            System.out.println(privateVariable); // 报错
        }
    
        public void myPrint(String[] args) {
        
            System.out.println(protectedVariable); // 这种可以！
            Dog dog = new Dog();
            System.out.println(dog.publicVariable);
            System.out.println(dog.protectedVariable); // 报错：注意这种方式是不行的
            System.out.println(dog.defaultVariable); // 报错
            System.out.println(dog.privateVariable); // 报错
        }
    
    }

#### 第五步：演示 `private` 属性本类而可访问 ####

package main;
    
    /**
     * @author zibo
     * @date 2023/3/5 13:07
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    public class Dog {
        
    
        /**
         * private 变量：只能被本类访问
         */
        private String privateVariable = "privateVariable";
    
        public static void main(String[] args) {
        
            Dog dog = new Dog();
            System.out.println(dog.privateVariable); // 这里可以访问，和 protected 在非同包子类不同
        }
    
    }

#### 扩展：Java 中为什么子类的 `main` 方法中通过父类对象的实例访问 `protected` 方法报错？ ####

在 Java 中，`protected` 修饰符用于限制只有**同包**下其他类和其**子类**可以访问该成员变量或方法。因此，如果你在子类的 `main` 方法中通过**父类对象**的实例访问 `protected` 方法，会出现**编译错误**。**这是因为子类虽然继承了父类的 protected 方法，但是并不能通过父类对象的实例来直接访问该方法。**

要访问父类的 `protected` 方法，可以在子类中创建一个方法来调用该方法。例如，可以在子类中创建一个**公共方法**，该方法通过 `super` 关键字调用父类的 `protected` 方法，然后从 `main` 方法中调用该公共方法。以下是示例代码：

public class Parent {
        
        protected void myMethod() {
        
            System.out.println("This is a protected method");
        }
    }
    
    public class Child extends Parent {
        
        public void callProtectedMethod() {
        
            super.myMethod();
        }
    
        public static void main(String[] args) {
        
            Child child = new Child();
            child.callProtectedMethod();
        }
    }

在上面的示例中，`Child` 类继承了 `Parent` 类的 `protected` 方法 `myMethod()`，并创建了一个公共方法 `callProtectedMethod()`，该方法通过super关键字调用了父类的 `myMethod()` 方法。然后在 `main` 方法中，创建 `Child` 类的对象 `child`，并通过调用 `callProtectedMethod()` 方法来访问父类的 `protected` 方法。

#### 扩展：Java 中为何同类下的 `main` 方法可以直接通过当前类对象访问 `private` 属性？ ####

这是因为 Java 中的**访问控制是基于类而不是基于对象的**。私有属性被声明为 `private` 后，只有该类的其他方法可以访问它，而其他类的对象无法直接访问该属性。但是，由于 `main` 方法和其他方法都属于同一个类，因此它们都可以直接访问该类的私有属性。

package main;
    
    /**
     * @author zibo
     * @date 2023/3/5 13:22
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    public class Dog {
        
        
        private static String privateStaticVariable = "privateStaticVariable";
        private String privateVariable = "privateVariable";
        public String publicVariable = "publicVariable";
    
        /**
         * 普通方法访问 private 变量
         */
        public void myPrint() {
        
            System.out.println(privateStaticVariable);
            System.out.println(privateVariable);
            System.out.println(publicVariable);
            System.out.println(new Dog().privateVariable);
        }
    
        /**
         * 静态方法访问 private 变量
         */
        public static void myStaticPrint() {
        
            System.out.println(privateStaticVariable);
            System.out.println(privateVariable); // 报错，静态方法不能访问非静态变量
            System.out.println(publicVariable); // 报错，静态方法不能访问非静态变量
            // 私有方法，只能在本类中访问，静态方法中不能访问非静态变量
            // 所以不能访问，但是可以通过对象访问，另外静态方法是可以直接访问本类的静态属性的
            System.out.println(new Dog().privateVariable); // 正常，私有普通属性是属于对象的，所以可通过对象访问
            System.out.println(new Dog().publicVariable); // 正常，私有普通属性是属于对象的，所以可通过对象访问
        }
    
    }

## 三、包命名规范 ##

1.  包名应该全部**小写**。
2.  包名应该基于**逆域名命名**，例如，一个公司的域名为 `example.com`，则该公司编写的 Java 代码的根包名应该是 `com.example`。
3.  包名应该**简短而有意义**，能够反映出包中包含的类的**功能**。
4.  如果一个包名由多个单词组成，单词之间都应该都点 `.` 隔开，例如：`com.example.myapp`。
5.  不要在包名中使用**下划线**或**其他特殊字符**，因为这可能会导致一些问题。

## 四、类命名规范 ##

1.  类名应该以**大写字母开头**，采用驼峰式命名规则，例如：`MyClass`，而不是`myClass` 或 `MYCLASS`。
2.  类名应该是**名词**，而不是动词。
3.  类名应该简明扼要地描述类的**职责和功能**，同时尽量**避免使用缩写**。
4.  如果一个类名由多个单词组成，**每个单词的首字母都应该大写**，例如：`MyFirstClass`。
5.  **接口**名也应该采用相同的规范，以便于与类名进行区分，例如：`MyInterface`。
6.  **抽象类**的命名应该以 `Abstract` 开头，例如：`AbstractClass`。
7.  **子类**：如果一个类是某个类的**子类**，应该在**父类名后面加上一个单词**来描述它的特定功能，例如：`MySubClass`。
8.  **接口实现类**：应该在类名后面加上 `Impl`，例如：`MyClassImpl`。
9.  异常类：为了和普通类做出区别，一般以 “`Exceptiont`” 作为后缀。
10. **测试类**：为了和普通类做出区别，一般以“`Test`”作为后缀。
11. **枚举类**：为了和普通类做出区别，一般以“`Enum`”作为后缀，**枚举类中的值遵循常量的命名规范。**

## 五、变量命名规范 ##

1.  通常是**见名知意**的名词。
2.  首字母**小写**。
3.  多个单词时，采用**驼峰**命名法。
4.  **不建议**使用**中文**缩写来命名。
5.  **不建议**使用**下划线**作为连接。

## 六、常量命名规范 ##

1.  通常是**见名知意**的名词。
2.  **全部大写**字母。
3.  多个单词之间使用“`_`”进行分隔。
4.  **不建议**使用**中文**缩写来命名。

## 七、方法命名规范 ##

1.  通常是**见名知意**的名词。
2.  首字母**小写**。
3.  多个单词时，采用**驼峰**命名法。
4.  不建议使用**中文**缩写来命名。
5.  不建议使用**下划线**作为连接。
6.  **有返回值**的方法一般加“`get`”前缀。
7.  **设置**的方法一般加对应的**动词**作为前缀（如：`set`、`insert`、`update`、`delete`）。
8.  **查询**的方法一般加“`select`”或“`find`”或“`query`”作为前缀。
9.  带有**条件**的方法一般在命名中使用“`by`”或“`with`”等字符。
10. **判断**的方法一般以“`is`”作为前缀。
11. **测试**方法一般以“`test`”作为前缀。

## 八、泛型命名规范 ##

1.  E 表示 Element，通常用在集合中。
2.  T 表示 Type（类型），通常指类。
3.  K 表示 Key（键），通常用于 Map 中。
4.  V 表示 Value（值），通常用于 Map 中，与 K 成对出现。
5.  N 表示 Number，通常表示数值类型。
6.  ? 表示不确定的 Java 类型。
7.  X 表示异常。
8.  U,S 表示任意类型。

[img]: https://img-blog.csdnimg.cn/img_convert/ac56c5780488985e0d1c9307d8503393.png
[image-20230305121457649]: https://img-blog.csdnimg.cn/img_convert/92f0a5f0b73526d13fd71b1d0d565abe.png
[image-20230305122004535]: https://img-blog.csdnimg.cn/img_convert/ce0493f174a9848adb3ee548c1ddd7b4.png
[image-20230305122131688]: https://img-blog.csdnimg.cn/img_convert/909b11a75e99caa006cbf5e3ca24af86.png
[image-20230305122532742]: https://img-blog.csdnimg.cn/img_convert/05073157b521139eb27450c8939f9635.png
[image-20230305125446283]: https://img-blog.csdnimg.cn/img_convert/b9c6223abe0ea2bb6d22c770067dd1e9.png
[image-20230305125637188]: https://img-blog.csdnimg.cn/img_convert/ab3a9bc5ee527769e7e8d62811baabef.png