Java 的访问修饰符public,protected,private(封装、继承)
一、访问控制修饰符
Access level modifiers determine whether other classes can use a particular field or invoke a particular method.
访问级别修饰符决定其他类是否可以使用特定成员变量或调用特定成员方法方法。
Java 中有 4 个级别的访问控制：
- public: 在所有类中都是可见的
- protected: 仅在自己的包中、自己的子类中可见
- package-private（没有修饰符）: 仅在自己的包中可见
- private: 仅在自己的类中可见
| 修饰符 | Class | Package | Subclass | World |
|---|---|---|---|---|
| public | 🌼 | 🌼 | 🌼 | 🌼 |
| protected | 🌼 | 🌼 | 🌼 | ❌ |
| package-private | 🌼 | 🌼 | ❌ | ❌ |
| private | 🌼 | ❌ | ❌ | ❌ |
- 这四个访问控制修饰符可以修饰类的成员【eg：成员变量、成员方法、嵌套类（Nested Class）】
- 只有 public 和 package-private（没有修饰符）可以修饰顶级类（Top-level Class）【顶级类可以有多个，但被 public 修饰的顶级类只能有一个】
public class Person {
public class Fahter {
class Son {
protected class Grandson {
private class Dog {
}
}
}
}
}上面代码中的 Person 就是顶级类，Person 类（顶级类）只能被 public 修饰、或没有访问修饰符
访问修饰符不能修饰局部类（Local Class）、局部变量
二、封装（Encapsulation）
- 类中的成员变量私有化（private）
- 提供公共的（public）方法【Getter 和 Setter】让外界操纵成员变量
public class Person {
// 成员变量私有化
private String name;
private int age;
/* 提供公共的（public）方法（Getter 和 Setter）让外界操纵私有的属性 */
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
}public class Main {
public static void main(String[] args) {
Person p = new Person();
/* 通过公共的 Getter/Setter 方法操作成员变量 */
p.setName("张浩男");
p.setAge(11);
System.out.println(p.getName());
System.out.println(p.getAge());
}
}🌻 封装避免外界直接修改属性（而是通过 Setter 方法修改属性），把实现细节封装起来；Setter 可对数据进行验证，保证数据安全合理
三、继承（Inheritance）
(1) 引出继承
学生类：👨🎓
public class Student {
private String name;
private int age;
private double score;
private String gender;
}员工类：👨💻
public class Employee {
private String name;
private int age;
private String gender;
private double salary;
}
- 上面代码中的员工类和学生类都有 name、age 和 gender 属性，员工类和学生类唯一不同的属性是 salary 和 score
- 可以把 name、age 和 gender 等三个属性也抽取在一个类（Person）中，把 name、age 和 gender 作为 Person 类的属性。然后学生类和员工类继承 Person 类。这样学生类和员工类也拥有了 Person 类的 name、age 和 gender 等三个属性，而学生类和员工类中可编写它们独有的属性。
人类【包含 name、age 和 gender 三个属性（这三个属性是员工类和学生类也共有的）】
public class Person {
private String name;
private int age;
private String gender;
}学生类【独有的属性只有 score】
public class Student {
private double score;
}员工类【独有的属性只有 salary】
public class Student {
private double salary;
}- Person 类拥有 Student 类和 Employee 类共有的属性（name、age、gender）
- 可使用 extends 关键字把 Person 类和 Student 类、把 Person 类和 Employee 类产生关联（让 Student 类和 Employee 类中也拥有 Person 类中所拥有的属性）
(2) 继承介绍
The idea of inheritance（继承） is simple but powerful: When you want to create a new class and there is already a class that includes some of the code that you want, you can derive（产生、获得） your new class from the existing class. In doing this, you can reuse the fields and methods of the existing class without having to write them yourself.
继承思想简单，却强大：当你想要创建一个新的类的时候。如果有一个已存在的类，该类中包含你的新类中所需要的代码。你可以从已存在的类中产生你的新类。这样做的话，你就可以重复使用已存在的类中的成员变量和成员方法，而无需自己重新写。
A subclass（子类） inherits all the members (fields, methods, and nested classes) from its superclass（父类、超类）. Constructors are not members, so they are not inherited by subclasses, but the constructor of the superclass can be invoked from the subclass.
子类继承了父类（或超类）中的所有成员（成员变量、成员方法和嵌套类）。构造方法不是成员，所以构造方法不会被子类继承，但父类（或超类）的构造方法可以被子类调用。
继承可实现代码的复用。当多个类中存在相同的属性和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法。然后所有的子类不需要重新定义这些属性和方法，只需要通过 extends 关键字来继承父类即可。
public class Person {
private String name;
private int age;
private String gender;
}// Student 类继承 Person 类
public class Student extends Person {
private double score;
}// Employee 类继承 Person 类
public class Employee extends Person {
private double salary;
}- Person 可叫做超类、父类、基类
- Student 和 Employee 可叫做子类或派生类
(3) 继承细节
🌾 ① 子类继承了父类的成员变量和成员方法后，非私有的（public、protected、package-private）属性和方法可以在子类直接访问。私有的属性和方法子类不能够直接访问，可通过非私有的方法间接访问。父类 Father:
/**
* 父类
*/
public class Father {
public String name = "父类 name";
protected String age = "父类 age";
String money = "父类 money";
// 被 private 修饰的属性无法被子类直接访问到
private String hobby = "父类 hobby";
public String getHobbyByPublic() {
return hobby + "_ByPublic";
}
protected String getHobbyByProtected() {
return hobby + "_ByProtected";
}
String getHobbyByPackagePrivate() {
return hobby + "_ByPackagePrivate";
}
}子类 Son 继承 Father:
/**
* 子类
*/
public class Son extends Father {
public static void main(String[] args) {
Son son = new Son();
son.printFatherClassFields();
}
private void printFatherClassFields() {
// output: 父类 name
System.out.println(name);
// output: 父类 age
System.out.println(age);
// output: 父类 money
System.out.println(money);
// 无法访问到父类被 private 关键字修饰的属性
// System.out.println(hobby); // ERROR
// 可通过父类的非私有的方法间接访问到父类被 private 关键字修饰的属性
// output: 父类 hobby_ByPublic
System.out.println(getHobbyByPublic());
// output: 父类 hobby_ByProtected
System.out.println(getHobbyByProtected());
// output: 父类 hobby_ByPackagePrivate
System.out.println(getHobbyByPackagePrivate());
}
}
🌾 ② 实例化子类的时候，先调用父类的构造器完成父类的初始化，后调用子类的构造器完成子类的初始化 【“父子”，“父子”，先初始化“父”，后初始化“子”】
/**
* 父类
*/
public class Father {
public Father() { // 父类构造器
System.out.println("1.public Father() 构造器");
}
}/**
* 子类
*/
public class Son extends Father {
public Son() { // 子类构造器
System.out.println("2.public Son() 构造器");
}
public static void main(String[] args) {
new Son();
/*
output:
1.public Father() 构造器
2.public Son() 构造器
*/
}
}③ 创建子类对象的时候，不管使用子类的哪个构造器，默认情况下都会先去调用父类的无参构造器。如果父类没有提供无参构造器，则子类的构造器中必须用 super 关键字去指定使用父类的哪个构造器。否则，编译无法通过。
④ 子类可通过 super(参数列表) 显示调用父类的某个构造器
⑤ super 使用的时候必须放在构造器第一行，且 super 只能在构造器中使用
⑥ super() 和 this() 都只能放在构造器的第一行，所以这两个方法不能在一个构造器中同时存在
⑦ Java 中所有的类都有一个共同的父类 Object；Java 中所有的类都是 Object 类的子类；Object类是所有类的基类】
public class Father {
public static void main(String[] args) {
// output: class java.lang.Object
// Father 类继承 Object 类
System.out.println(Father.class.getSuperclass());
}
}⑧ 父类构造器的调用不仅限于直接父类，将会一直往上追溯，直到 Object 类
public class Grandpa {
public Grandpa() {
System.out.println("1. class Grandpa - 构造器");
}
}public class Father extends Grandpa{
public Father() {
System.out.println("2. class Father extends Grandpa - 构造器");
}
}public class Son extends Father {
public Son() {
System.out.println("3. class Son extends Father - 构造器");
}
}public class Grandson extends Son {
public Grandson() {
System.out.println("4. class Grandson extends Father - 构造器");
}
public static void main(String[] args) {
new Grandson();
}
}output: 1. class Grandpa - 构造器 2. class Father extends Grandpa - 构造器 3. class Son extends Father - 构造器 4. class Grandson extends Father - 构造器
⑨ Java 中是单继承机制（子类最多只能继承一个直接父类）
思考：如何让 A 类继承 B 类和 C 类 ?
A extends B；B extends C
public class C {
public String candy = "candy";
}public class B extends C {
public String boy = "boy";
}public class A extends B {
public static void main(String[] args) {
A a = new A();
a.test();
}
private void test() {
// boy
System.out.println(boy);
// candy
System.out.println(candy);
}
}
到此这篇关于Java 的访问修饰符public,protected,private(封装、继承)的文章就介绍到这了,更多相关Java 访问修饰符内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
这篇文章主要介绍了Spring依赖注入DI之三种依赖注入类型详解,通过 @Autowired 注解,字段注入的实现方式非常简单而直接,代码的可读性也很强,事实上,字段注入是三种注入方式中最常用、也是最容易使用的一种,需要的朋友可以参考下2023-09-09
Java虚拟机规范中定义了Java内存模型（Java Memory Model，JMM），用于屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的并发效果，JMM规范了Java虚拟机与计算机内存是如何协同工作的，以及在必须时如何同步的访问共享变量2021-06-06
并查集这种数据结构，可能出现的频率不是那么高，但是还会经常性的见到，其理解学习起来非常容易，通过本文，一定能够轻轻松松搞定并查集2021-06-06
mybatis plus实体类中字段映射mysql中的json格式方式
这篇文章主要介绍了mybatis plus实体类中字段映射mysql中的json格式方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2021-08-08
Java获取当前系统事件System.currentTimeMillis()方法
下面小编就为大家带来一篇Java获取当前系统事件System.currentTimeMillis()方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧2017-06-06
这篇文章主要介绍了javaagent的相关资料，文中示例代码非常详细，供大家参考和学习，感兴趣的朋友可以了解下2020-07-07
这篇文章主要介绍了Java线程安全与非线程安全解析，涉及非线程安全现象模拟以及线程安全的实现等相关内容，需要的朋友可以参考，一起交流学习。2017-10-10
这篇文章主要介绍了mybatis条件语句中带数组参数的处理方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2021-09-09
这篇文章主要介绍了Maven pom.xml文件获取当前时间戳方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2021-12-12
mybaits-plus lambdaQuery() 和 lambdaUpdate() 常见的使用方法
MyBatis-Plus是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生，这篇文章主要介绍了mybaits-plus lambdaQuery() 和 lambdaUpdate() 比较常见的使用方法,需要的朋友可以参考下2023-01-01
最新评论