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

时间：2022-04-05 01:00:19


【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 面向对象的封装性就依赖访问修饰符来实现！

  1. 可读性：访问修饰符可以用来表明类、方法或变量的访问范围，使代码更易于理解和维护。

我对这种可读性的理解是对于访问范围进行了直接标明！

  1. 重用性：访问修饰符可以用来控制子类对于父类中属性和方法的访问，从而实现代码的重用。

我觉得更多的，访问修饰符对这方面提供了灵活的控制！我觉得子类继承父类最大的目的就是为了代码复用，访问修饰符提供了灵活的控制！

  1. 可维护性：访问修饰符可以用来限制对于某个类、方法或变量的访问，从而使得修改代码更加容易，不会影响其他部分的代码。

访问修饰符限制了可访问范围，代码修改带来的影响也是在一定范围内的！

  1. **安全性：**访问修饰符可以用来限制对于某个类、方法或变量的访问，从而提高程序的安全性，防止恶意操作或者不合理的访问。

限制的大多数目的就是为了安全！凡是容易造成安全问题的行为都应该得到限制！目标 => 策略 => 规则（限制）！

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

问题

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

3、访问修饰符有哪些

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

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

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

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 类无法访问

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

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(); // 私有方法报错
    }
}

私有方法报错

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

第三步：在不同包下创建 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(); // 私有方法报错
    }

}

错误提示

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

第四步：在不同包下创建 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(); // 报错
    }

}

错误提示

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

第五步：演示 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); // 报错
    }
}

错误提示

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

第三步：在不同包下创建 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); // 报错
    }

}

错误提示

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

第四步：在不同包下创建 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 表示任意类型。


标签：

相关文章