【自学笔记】01Java基础-09Java关键字详解

介绍java（基于java11）中所有关键字，以及主要重要的关键字详解。

1 Java 11中的关键字：

1.1 类型声明与变量定义

• boolean：声明布尔类型变量，只有两个可能值 true 或 false。
• byte：声明一个8位有符号整数类型变量。
• short：声明一个16位有符号整数类型变量。
• int：声明一个32位有符号整数类型变量。
• long：声明一个64位有符号整数类型变量。
• float：声明一个单精度（32位）浮点数类型变量。
• double：声明一个双精度（64位）浮点数类型变量。
• char：声明一个16位Unicode字符类型变量。
• void：表示方法不返回任何值。

1.2 访问权限修饰符

• public：公共，修饰类，方法变量，允许任意对象访问。
• protected：保护，修饰方法与变量，只允许同一包内，或该类子类（即使在别的包）的对象访问。
• private：限制，修饰方法与变量，为当前类内部。
• default：默认，修饰类，方法变量，没有以上任一访问修饰符时，默认为default权限，不用在声明时特地写出来

1.3 类、成员修饰符

• static：静态，修饰方法或变量，会让方法或变量变成类级别，称为静态变量或类变量，可以直接类名访问，不需对象访问。

• final：不可变，可以应用于类（不能被继承）、方法（不能被重写）或变量（一旦赋值不能更改）。

• abstract：抽象，声明抽象类或抽象方法，抽象类不能实例化，抽象方法没有具体实现。

• strictfp：不常见，严格浮点指令集，保证跨平台时浮点运算的一致性。

1.4 流程控制与异常处理

• if：条件语句关键字，用于执行基于条件的选择性代码块。
• else：与 if 配合使用，表示当条件不满足时执行的代码块。
• switch：多分支选择结构关键字。
• case：配合 switch 使用，标识每个分支的入口条件。
• default：在 switch 结构中提供默认分支。
• while：循环结构，重复执行一段代码直到给定条件不再满足。
• do…while：先执行循环体再检查循环条件的循环结构。
• for：循环结构，通常用于已知循环次数的情况。
• break：跳出当前循环或 switch 语句。
• continue：结束当前迭代，继续下一次循环。
• try：开始异常处理块，包含可能抛出异常的代码。
• catch：捕获并处理在 try 块中抛出的异常。
• finally：无论是否发生异常，都会被执行的代码块。
• throw：显式抛出异常对象。
• throws：声明方法可能会抛出的异常类型列表。

1.5 类、接口与包相关

• class：声明类的关键字。
• interface：声明接口的关键字，接口定义了一组方法签名和常量。
• extends：类继承另一个类的关键字。
• implements：类实现接口的关键字。
• package：声明源文件所在的包名，用于组织代码和管理命名空间。
• import：导入其他包中的类或全部类。

1.6 其他重要关键字

• this：引用当前对象实例的引用关键字。
• super：在子类中引用父类的方法或字段。
• new：创建新对象实例的关键字。
• instanceof：操作符，检查对象是否属于某个类或其子类。
• synchronized：用于声明同步方法或同步代码块，以实现线程安全。
• volatile：声明变量在并发环境下具有可见性和有序性。
• transient：标记字段不会被序列化。
• native：声明一个方法由非Java语言实现，通常用于JNI调用本地方法。
• assert：断言关键字，用于测试布尔表达式的预期结果，主要用于开发阶段调试。

1.7 Java保留关键字但未使用的

• goto：Java中保留但未使用的关键字，曾经在某些其他编程语言中有跳转功能。
• const：同样是Java中预留的关键字，但目前并未赋予实际功能。

请注意，以上信息适用于Java 11及之前的大多数版本。

---

常用关键字详解

private关键字

private 属于访问权限修饰符（access modifier），用于控制类成员（变量和方法）的可见性及可访问范围。

1. 定义：

   • 当你在一个类中声明一个变量或方法时，如果使用了 private 关键字，那么这个成员就只能在这个类的内部被访问。

2. 作用：

   • 封装（Encapsulation）：private 关键字是实现封装的基础，它隐藏了类的内部细节，确保外部代码不能直接访问或修改类的私有数据成员，从而提高了代码的安全性和稳定性。
   • 数据保护：通过将字段（成员变量）设为 private，限制对这些字段的直接访问，强制其他类通过公共的 getter 和 setter 方法来读取或修改它们，从而可以对数据进行验证、转换或其他必要操作。

3. 访问权限：

   • private 成员只能在其所在的类内被访问，这意味着同一类中的静态方法、实例方法、构造器都可以访问该类的 private 成员。
   • 同一包内的其他类、子类以及所有外部类都不能直接访问 private 成员。
   • 若需要提供对外部的访问途径，通常会创建公共的（public）getter和setter方法（对于字段）或者公共的方法（对于行为）。

4. 示例：

   public class MyClass {
       private String secretMessage; // 私有变量
   
       public MyClass(String message) { // 公共构造器
           this.secretMessage = message;
       }
   
       public String getSecretMessage() { // 公开getter方法
           return secretMessage;
       }
   
       private void changeSecretMessage(String newMessage) { // 私有方法
           this.secretMessage = newMessage;
       }
   }
   
   public class AnotherClass {
       public static void main(String[] args) {
           MyClass obj = new MyClass("Hello, World!");
           // 直接访问private变量会编译错误
           System.out.println(obj.secretMessage);
           // 但是可以通过公开的getter方法访问
           System.out.println(obj.getSecretMessage());
       }
   }
   

5. 好处：

   • 提高安全性：由于外部无法直接访问和修改对象的私有状态，因此可以防止意外的修改导致的数据不一致或破坏对象的状态。
   • 提高可维护性：通过封装，可以在不影响外部调用者的情况下修改类的内部实现。
   • 增强代码的可理解性：通过清晰地标识出哪些部分是内部实现细节，有助于提高代码的可读性和设计意图的表达。

   ---

static关键字

1. 静态变量

• static修饰变量 时，这个变量成为类级别的变量，称为静态变量或类变量。
  • 静态变量存储在 Java 方法区（PermGen 或 Metaspace），而不是堆内存中每个对象实例的数据区域。
  • 所有该类的实例共享同一个静态变量，也就是说，无论创建了多少个对象，都只有一个静态变量的副本。
  • 静态变量可以通过类名直接访问，无需创建类的实例。

public class MyClass {
    public static int count; // 静态变量

    public MyClass() {
        count++; // 不需要通过 this.count 访问
    }
}

// 直接通过类名访问和修改静态变量
MyClass.count = 0;
System.out.println(MyClass.count); // 输出：0

2. 静态方法

• static 修饰的方法被称为静态方法或类方法，它们不属于任何特定的对象实例，而属于类本身。
  • 静态方法可以直接通过类名调用，不需要先创建类的实例。
  • 在静态方法内部不能访问非静态变量或方法，除非通过一个已经创建的实例来引用它们。

public class MyClass {
    private static void printHello() {
        System.out.println("Hello from the static method!");
    }

    public static void main(String[] args) {
        MyClass.printHello(); // 直接通过类名调用静态方法
    }
}

3. 静态代码块

• 静态初始化块是一组在类加载时会被执行一次的语句，且在任何实例创建之前运行。
  • 通常用于初始化静态变量和静态方法。

public class MyClass {
    public static String greeting;

    static { // 静态代码块
        greeting = "Hello, World!";
    }

    public static void main(String[] args) {
        System.out.println(MyClass.greeting); // 输出："Hello, World!"
    }
}

4. 好处：

• static 关键字的主要用途是提供一种机制，使某些成员能够在不依赖于类的具体实例的情况下被访问和使用。

• 静态成员非常适合用来描述那些与类本身而非其对象实例有关的状态或行为，比如工具类中的实用方法、全局配置变量等。

  ---

abstract关键字

当编程中遇到暂不明确实现的类或方法时，可以声明为抽象类/方法，在之后以继承的方式实现

1. 抽象类

• 当一个类被声明为 abstract 时，它就成为了一个抽象类。
• 抽象类不能被实例化，即不能通过 new 关键字创建其对象。
• 抽象类可以包含抽象方法（必须使用 abstract 关键字声明）以及非抽象方法（有具体实现的方法）。
• 抽象类的主要目的是作为其他类的基类，子类必须继承抽象类并实现其中的所有抽象方法，才能实例化子类。

public abstract class Animal {
    public abstract void makeSound(); // 抽象方法

    public void sleep() { // 非抽象方法，有具体实现
        System.out.println("Zzz...");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

2. 抽象方法

• 抽象方法没有具体的实现，只有方法签名（包括返回类型、方法名和参数列表）。
• 在抽象类中声明的全部抽象方法，其子类必须提供相应的实现，除非子类也是抽象的。
• 如果一个类包含了至少一个抽象方法，则该类必须声明为抽象类。

public abstract class Shape {
    public abstract double getArea(); // 抽象方法，计算形状的面积
}

• 使用场景：

• 定义通用行为：抽象类可以定义一些通用的行为，而将特定的实现留给子类去完成。

• 设计模板方法模式：在抽象类中定义算法骨架，具体的步骤由子类实现。

• 强制接口契约：通过抽象类和抽象方法来强制子类遵循一定的接口规则或契约。

  ---

super关键字

super 关键字主要用于访问和调用父类（超类）的成员变量、方法和构造函数。

• 访问父类成员变量：
  当子类中定义了一个与父类同名的成员变量时，会默认就近使用子类的变量，为了区分并明确访问父类中的变量，可以使用 super 关键字。

  class Parent {
      private int value;
  }
  
  class Child extends Parent {
      private int value;
  
      public void showParentValue() {
          System.out.println(super.value); // 访问父类Parent的value变量
      }
  }
  

• 调用父类的方法：
  同样的，子类可以通过 super 关键字调用父类中非私有（private）的实例方法。

  class Parent {
      public void displayMessage() {
          System.out.println("Hello from Parent");
      }
  }
  
  class Child extends Parent {
      @Override
      public void displayMessage() {
          super.displayMessage(); // 调用父类Parent的displayMessage方法
          System.out.println("Hello from Child");
      }
  }
  

• 调用父类的构造方法：
  在子类构造器的初始化列表或构造器的第一行代码中，必须且只能使用 super() 来调用父类的一个构造方法。

  class Parent {
      public Parent(String name) {
          System.out.println("Parent constructor called with: " + name);
      }
  }
  
  class Child extends Parent {
      public Child(String childName) {
          super(childName); // 调用父类Parent的带有String参数的构造方法
          // 其他子类初始化代码...
      }
  }
  

• 注意：

• super() 的调用必须是子类构造器的第一条语句，如果没有显示调用，则默认会有一个隐式的无参 super() 调用。

• 不能在一个静态上下文中使用 super 关键字，因为静态方法并不属于任何特定对象，因此无法通过 super 访问非静态成员。

• this 和 super 不能同时出现在同一个构造函数的初始化列表中。

  ---

final关键字

• final的作用

  • final 关键字是最终的意思，可以修饰（类、方法、变量）
  • 修饰类：表明该类是最终类，不能被继承。
  • 修饰方法：表明该方法是最终方法，不能被重写。
  • 修饰变量：表示该变量第一次赋值后，不能再次被赋值(有且仅能被赋值一次)。

• final修饰变量的注意

  • final修饰的变量是基本类型：那么变量存储的数据值不能发生改变。
  • final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的。

举个例子：

public class Example {
    public static final List<String> list = new ArrayList<>();

    public static void main(String[] args) {
        // 正确：向final修饰的list添加元素，修改的是list对象的内容
        list.add("Element1");
        list.add("Element2");

        // 错误：试图将list指向另一个ArrayList实例
        list = new ArrayList<>();  // 这行代码会导致编译错误

        System.out.println(list);  // 输出：[Element1, Element2]
    }
}

final修饰的引用类型变量list一旦被初始化为一个ArrayList实例后，就不能再指向其他的ArrayList实例了。由于list仍然指向原来的ArrayList对象，所以可以自由地向其中修改元素。

---

后续继续更新。。。。。