学习目录：

  1. 了解修饰符
  2. protected
  3. static (静态的) 和 abstract （抽象）

一. 修饰符

**1. 访问修饰符 **：
这些修饰符用于控制类、方法、属性等的访问权限。常见的访问修饰符包括：

  • public: 任何类都可以访问
  • private: 只能在当前类内部访问
  • protected: 同一包中的类或继承该类的子类可以访问
  • default（没有修饰符）：只能在同一包中的类中访问

**2. 非访问修饰符 **：
这些修饰符不控制访问权限，但用于提供其他功能。例如：

  • static: 用于声明静态成员，表示该成员属于类而不是类的实例。
  • final: 表示常量，或者在方法、类、变量上设置不可更改的限制。
  • abstract: 用于声明抽象类或抽象方法，表示该类不能直接实例化或该方法必须由子类实现。
修饰符 描述
final 属性和方法不能被重写或修改
static 属性和方法属于类，而不是某个对象
abstract 只能在抽象类中使用，且只能用于方法。该方法没有方法体，例如 abstract void run();。方法体由子类提供（继承）。你将在继承和抽象章节中学习更多关于继承和抽象的内容。
transient 在序列化包含这些属性和方法的对象时，这些属性和方法会被跳过
synchronized 方法只能被一个线程同时访问
volatile 属性的值不会被线程本地缓存，始终从“主内存”中读取

二. protected：同一包中的类或继承该类的子类可以访问

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class Person {
  // 受保护的实例变量
  protected String fname = "天气"; // 姓名
  protected String lname = "浩";  // 姓氏
  protected String email = "1233211234567@qq.com"; // 电子邮件
  protected int age = 24;  // 年龄
}

class Student extends Person { // extebds 表示类的继承关系
  // 私有的实例变量
  private int graduationYear = 2018; // 毕业年份

  public static void main(String[] args) {
    // 创建 Student 类的对象
    Student myObj = new Student();

    // 输出名字（继承自 Person 类）
    System.out.println("Name: " + myObj.fname + " " + myObj.lname);  // Name: 天气 浩

    // 输出电子邮件（继承自 Person 类）
    System.out.println("Email: " + myObj.email);  // Email: 1233211234567@qq.com

    // 输出年龄（继承自 Person 类）
    System.out.println("Age: " + myObj.age);  // Age: 24

    // 输出毕业年份（属于 Student 类）
    System.out.println("Graduation Year: " + myObj.graduationYear);  // Graduation Year: 2018
  }
}

extends 是一个关键字，用于表示类的继承关系。当一个类使用 extends 关键字时，它会继承另一个类的属性和方法。

三. static: 用于声明静态成员，表示该成员属于类而不是类的实例

static 和 public 方法之间的区别：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Main {
  // 静态方法
  static void myStaticMethod() {
    System.out.println("静态方法可以在不创建对象的情况下调用");
  }

  // 公共方法
  public void myPublicMethod() {
    System.out.println("公共方法必须通过创建对象来调用");
  }

  // 主方法
  public static void main(String[] args) {
    myStaticMethod(); // 调用静态方法

    Main myObj = new Main(); // 创建 Main 类的对象
    myObj.myPublicMethod(); // 通过对象调用公共方法
  }
}

四. 抽象（abstract）

一个方法属于一个类，并且没有方法体。方法体由子类提供：抽象（abstract）。

解释：

  • 抽象方法（abstract method）是没有具体实现的方法，只有方法的声明（包括方法名、参数等），没有方法体。
  • 该方法的具体实现由继承该抽象类的子类来提供。
  • 在 Java 中，抽象方法通常出现在抽象类（abstract class）中，子类必须重写这些抽象方法才能实例化该子类。

创建两个java文件： hello.java 文件 和 second.java 文件

1
2
3
4
5
6
7
8
9
10
11
12
13
abstract class hello {  
    public String fname = "John";  // 声明一个公共的字符串变量 fname，并赋初值 "John"
    public int age = 24;  // 声明一个公共的整型变量 age，并赋初值 24
    public abstract void study();  // 声明一个抽象方法 study()，没有方法体
}

// 子类（继承自 hello）:second 继承 hello 
class Student extends hello {  // 如果类名改了，这行代码的类目也要改
    public int graduationYear = 2018;  // 声明一个公共的整型变量 graduationYear，并赋初值 2018
    public void study() {  // 提供抽象方法 study() 的具体实现
        System.out.println("HI I LOVE YOU");  // 输出字符串 "HI I LOVE YOU"
    }
}

这个文件不能独立输出

下个文件进行调用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Second {  // 定义一个名为 Second 的类
    public static void main(String[] args) {  // 主方法，程序的入口点
        // 创建一个 Student 类的对象（Student 类继承了 Main 类的属性和方法）
        Student myObj = new Student();

        // 输出 myObj 对象的 fname 属性的值
        System.out.println("Name: " + myObj.fname);  // 打印出 myObj 对象的 fname 属性（学生的姓名）

        // 输出 myObj 对象的 age 属性的值
        System.out.println("Age: " + myObj.age);  // 打印出 myObj 对象的 age 属性（学生的年龄）

        // 输出 myObj 对象的 graduationYear 属性的值
        System.out.println("Graduation Year: " + myObj.graduationYear); 
        // 打印出 myObj 对象的 graduationYear 属性（学生的毕业年份）

        // 调用 myObj 对象的 study 方法（这是一个抽象方法）
        myObj.study();  // 调用继承自 Main 类的 study 方法，输出“Studying...”或者其他逻辑
    }
}

可能遇到的问题：

​ 有时候头文件名改了，System.out.println中的fname和age发生了报错，无法解析

解决方法：

  • 确保 Student 类继承了 Main 类： 如果 Student 类应该继承 Main 类，并且 fname 是 Main 类的属性，确保 Student 类声明了继承关系

  • 如果 Student 没有继承 Main 类，则 fname 需要在 Student 类中定义，或者 Second 类中的 myObj 需要引用正确的父类。

最终的输出结果：

1
2
3
4
Name: John
Age: 24
Graduation Year: 2018
HI I LOVE YOU