一、for和for-each

1.1for和for-each概念

for 循环是一种常用的循环结构，它可以通过一个变量（通常是 i）来控制循环的次数和范围。for 循环的语法格式如下：

for (初始化; 布尔表达式; 更新) {
  //代码语句
}

for-each 循环是 Java 1.5 的新特性之一，它可以方便地遍历数组或集合中的元素，而不需要使用下标或迭代器。for-each 循环的语法格式如下：

for (元素类型t 元素变量x : 遍历对象obj) {
  //引用了x的java语句;
}

for 和 for-each 循环的效率和适用性取决于遍历对象的数据结构。一般来说，对于数组或 ArrayList 这样基于数组的数据结构，使用 for 循环更快，因为它可以直接通过下标访问元素，而不需要额外的对象创建和类型转换。对于 LinkedList 这样基于链表的数据结构，使用 for-each 循环更快，因为它可以直接获取元素的值，而不需要每次都调用 get 方法进行遍历。

1.2for-each优缺点

二、枚举

 枚举是一种特殊的类，它用来表示一组有限的常量，比如季节、颜色、方向等。枚举可以提高代码的可读性和安全性，避免使用硬编码的字符串或整数来表示常量。枚举类使用 enum 关键字来定义，各个常量使用逗号 , 来分割。

Java的enum类型
-所有的enum类型都是Enum的子类，也继承了相应方法

1. ordinal()返回枚举值所在的索引位置, 从0开始

   // 定义一个枚举类型 Season，表示四个季节
   enum Season {
     SPRING, SUMMER, AUTUMN, WINTER;
   }
   
   // 在主方法中，使用 values() 方法获取所有的枚举值，并打印出它们的 ordinal 值
   public class Main {
     public static void main(String[] args) {
       // 获取所有的枚举值
       Season[] seasons = Season.values();
       // 遍历枚举值
       for (Season s : seasons) {
         // 打印出每个枚举值的 ordinal 值
         System.out.println(s + " 的 ordinal 值是 " + s.ordinal());
       }
     }
   }
   

2. compareTo()比较两个枚举值的索引位置大小

   public class Test {
       public static void main(String[] args) {
           // 定义两个枚举值
           Season s1 = Season.SPRING;
           Season s2 = Season.WINTER;
           // 使用compareTo()方法比较它们的索引位置大小
           int result = s1.compareTo(s2);
           // 输出结果
           System.out.println(result); // -3
       }
   }
   
   // 定义一个枚举类Season
   enum Season {
       SPRING, SUMMER, AUTUMN, WINTER
   }
   

3. toString()返回枚举值的字符串表示

   public class Test {
       public static void main(String[] args) {
           // 定义三个枚举值
           Color c1 = Color.RED;
           Color c2 = Color.GREEN;
           Color c3 = Color.BLUE;
           // 使用toString()方法获取它们的字符串表示
           System.out.println(c1.toString()); // 红色
           System.out.println(c2.toString()); // 绿色
           System.out.println(c3.toString()); // 蓝色
       }
   }
   
   // 定义一个枚举类Color，并重写toString()方法
   enum Color {
       RED, GREEN, BLUE;
   
       @Override
       public String toString() {
           switch (this) {
               case RED:
                   return "红色";
               case GREEN:
                   return "绿色";
               case BLUE:
                   return "蓝色";
               default:
                   return "未知颜色";
           }
       }
   }
   

4. valueOf()将字符串初始化为枚举对象

   public class Test {
       public static void main(String[] args) {
           // 定义一个字符串
           String s = "GREEN";
           // 使用valueOf()方法将字符串转换为枚举值
           Color c = Color.valueOf(s);
           // 输出结果
           System.out.println(c); // GREEN
       }
   }
   
   // 定义一个枚举类Color
   enum Color {
       RED, GREEN, BLUE
   }
   

5. values()返回所有的枚举值

   public class Test {
       public static void main(String[] args) {
           // 使用values()方法返回一个包含所有枚举值的数组
           Season[] seasons = Season.values();
           // 输出数组的长度和内容
           System.out.println(seasons.length); // 4
           for (Season season : seasons) {
               System.out.println(season); // SPRING, SUMMER, AUTUMN, WINTER
           }
       }
   }
   
   // 定义一个枚举类Season
   enum Season {
       SPRING, SUMMER, AUTUMN, WINTER
   }
   

三、不定项参数

Java不定项参数是一种可以接受不确定个数的同类型参数的方法，它可以用于简化方法的重载和数组的传递。不定项参数的语法是在参数类型后面加上三个点（…），表示该参数可以接受零到多个值，编译器会将这些值封装成一个数组传递给方法。

//定义一个不定项参数的方法，用于求和
public static int sum (int... nums) {
    int total = 0;
    for (int num : nums) {
        total += num;
    }
    return total;
}

//调用不定项参数的方法，可以传入任意个数的int值
System.out.println (sum ()); //输出0
System.out.println (sum (1)); //输出1
System.out.println (sum (1, 2, 3)); //输出6
System.out.println (sum (new int [] {4, 5, 6})); //输出15，也可以直接传入一个数组

四、静态导入 

静态导入是Java 5中引入的一种新特性，它可以让你在不使用类名的情况下，直接访问类中的静态成员变量和方法。静态导入的语法是：

import static package.ClassName.fieldName|methodName;

或者

import static package.ClassName.*;

第一种语法可以导入指定类中的某个静态成员变量或方法，第二种语法可以导入指定类中的所有静态成员变量和方法。例如，如果你想使用Math类中的PI常量和sqrt方法，你可以使用静态导入：

import static java.lang.Math.PI;
import static java.lang.Math.sqrt;

 五、自动装箱和拆箱

自动装箱和拆箱是Java中的一种特性，它可以让基本数据类型和对应的包装类之间自动地相互转换。例如，int类型可以自动转换为Integer对象，Integer对象可以自动转换为int值。这样可以方便地在面向对象和基本类型之间进行切换，简化代码的编写。

​

​

六、多异常并列

多异常并列是Java 7中引入的一种特性，它可以让你在一个catch块中捕获多个不同类型的异常，并用同样的方式来处理它们。这样可以避免重复的代码和逻辑，简化异常处理的过程。

多异常并列使用时要注意以下几点：

• 一个catch块中只能有一个异常对象，不能写成catch (ExceptionType1 e1 | ExceptionType2 e2 | … e3)这样的形式。
• 多个异常类型之间不能有继承关系，否则会造成编译错误。例如，不能写成catch (IOException | FileNotFoundException e)，因为FileNotFoundException是IOException的子类。
• 如果有多个catch块，那么多异常并列的catch块应该放在最前面，否则会被其他catch块覆盖。例如，不能写成catch (Exception e) {…} catch (NumberFormatException | ArithmeticException e) {…}，因为Exception是所有异常的父类。

public class Test {
    public static void main(String[] args) {
        try {
            int a = Integer.parseInt("abc"); //可能抛出NumberFormatException
            int b = 10 / 0; //可能抛出ArithmeticException
        } catch (NumberFormatException | ArithmeticException e) {
            //这个catch块可以捕获两种异常，并统一处理
            System.out.println("发生了数学错误：" + e.getMessage());
        } catch (Exception e) {
            //这个catch块可以捕获其他类型的异常，并单独处理
            System.out.println("发生了其他错误：" + e.getMessage());
        }
    }
}

 上面的代码中，第一个catch块使用了多异常并列的语法，可以同时捕获NumberFormatException和ArithmeticException，并输出它们的信息。第二个catch块可以捕获其他类型的异常，并输出它们的信息。这样就可以避免重复的代码和逻辑，简化异常处理的过程。

如果你把两个catch块的顺序颠倒，那么就会造成编译错误，因为第一个catch块会捕获所有类型的异常，包括NumberFormatException和ArithmeticException，那么第二个catch块就永远不会被执行。这就违反了多态和重载的规则，所以编译器会提示错误。

七、整数类型用二进制表示

7.1二进制

​ 7.2下划线

​

 八、接口

8.1接口的默认方法

接口的默认方法是Java 8中引入的一种新特性，它可以让接口中定义一些带有具体实现的方法，而不需要实现类去实现这些方法。这样可以方便地为接口添加新的功能，而不影响已有的实现类。接口的默认方法的语法是在方法名前面加上default关键字，

public interface MyInterface {
    // 普通的抽象方法
    void abstractMethod();
    // 默认方法
    default void defaultMethod() {
        System.out.println("这是一个默认方法");
    }
}

 接口的默认方法有以下几个作用：

• 兼容性：接口的默认方法可以让接口在不破坏现有代码的情况下，向后兼容地添加新的方法。这样就不需要修改所有实现了该接口的类，而只需要在需要的地方重写或调用默认方法即可。
• 多继承：接口的默认方法可以让一个类实现多个接口，而不用担心接口之间有相同的方法签名。如果一个类实现了多个接口，且这些接口有相同的默认方法，那么这个类必须重写这个默认方法，或者使用super关键字来指定调用哪个接口的默认方法。
• 扩展性：接口的默认方法可以让接口提供一些通用的功能，而不需要在每个实现类中重复编写相同的代码。例如，List接口中就提供了一个sort方法，它可以对列表进行排序，而不需要每个列表类都实现自己的排序算法。

​ 8.2接口的静态方法

接口的静态方法是Java 8中引入的一种新特性，它可以让接口中定义一些带有具体实现的静态方法，而不需要实现类去调用这些方法。这样可以方便地为接口提供一些与接口相关的工具方法，或者一些通用的逻辑。接口的静态方法的语法是在方法名前面加上static关键字，例如：

public interface MyInterface {
    // 普通的抽象方法
    void abstractMethod();
    // 静态方法
    static void staticMethod() {
        System.out.println("这是一个静态方法");
    }
}

接口的静态方法有以下几个特点：

• 接口的静态方法只能通过接口名来调用，不能通过实现类或者实现类的对象来调用。例如，MyInterface.staticMethod(); 可以调用静态方法，但是 MyClass.staticMethod(); 或者 new MyClass().staticMethod(); 都会报错。
• 接口的静态方法不能被实现类继承或者重写，也不能被子接口继承或者重写。如果实现类或者子接口中定义了与接口中静态方法相同签名的方法，那么这个方法和接口中的静态方法没有任何关系，只是一个普通的方法。
• 接口的静态方法可以访问接口中定义的常量，但是不能访问接口中定义的抽象方法和默认方法。如果需要在静态方法中调用抽象方法或者默认方法，可以通过传入一个实现类的对象作为参数来实现。

​ 8.3接口的私有方法

接口的私有方法是Java 9中引入的一种新特性，它可以让接口中定义一些带有具体实现的私有方法，而不需要实现类去实现或调用这些方法。这样可以方便地为接口提供一些与接口相关的工具方法，或者一些通用的逻辑。接口的私有方法的语法是在方法名前面加上private关键字，例如：

public interface MyInterface {
    // 普通的抽象方法
    void abstractMethod();
    // 私有方法
    private void privateMethod() {
        System.out.println("这是一个私有方法");
    }
}

接口的私有方法有以下几个作用：

• 封装性：接口的私有方法可以让接口中的一些细节或者辅助功能被隐藏起来，而不暴露给外部。这样可以保护接口的内部逻辑，避免被误用或者滥用。
• 复用性：接口的私有方法可以让接口中的一些重复或者相似的代码被抽取出来，而不需要在每个默认方法或者静态方法中重复编写。这样可以提高代码的复用性和可维护性。
• 灵活性：接口的私有方法可以让接口中的默认方法或者静态方法更加灵活和简洁，而不需要包含过多的代码或者逻辑。这样可以提高代码的可读性和可扩展性。

​ 8.4接口与抽象类

​ 九、try-with-resources

try-with-resources是Java 7中引入的一种特性，它可以让你在一个try语句中声明一个或多个需要关闭的资源，比如文件，流，套接字等。try-with-resources语句可以确保在语句结束后，每个资源都会被自动关闭，无论是否发生异常。这样可以避免手动关闭资源的麻烦，也可以避免资源泄漏的风险。

try-with-resources语句的语法是：

try (ResourceType resource = new ResourceType(...)) {
    // 使用资源的代码
} catch (ExceptionType e) {
    // 处理异常的代码
}

其中，ResourceType是要关闭的资源的类型，它必须实现AutoCloseable接口，这个接口只有一个方法close()，用于释放资源。resource是要关闭的资源的对象，它必须在try语句中声明和初始化。你可以在一个try语句中声明多个资源，只要用分号隔开即可。例如：

try (BufferedReader br = new BufferedReader(new FileReader("input.txt"));
     PrintWriter pw = new PrintWriter(new FileWriter("output.txt"))) {
    // 读写文件的代码
} catch (IOException e) {
    // 处理异常的代码
}

这样，无论读写文件的代码是否正常执行，br和pw都会被自动关闭。

十、ResourceBundle

ResourceBundle是Java中的一个类，它可以用于实现国际化（i18n）的功能，也就是让程序能够根据不同的语言和地区显示不同的信息。ResourceBundle可以从不同的文件中加载语言和地区相关的数据，比如属性文件（.properties）或者Java类文件（.java）。ResourceBundle可以根据用户的Locale（语言和地区）自动选择合适的文件，也可以手动指定要加载的文件。ResourceBundle可以通过键值对的方式存储和获取数据，也可以通过下标的方式存储和获取数据。ResourceBundle有两个常用的子类：PropertyResourceBundle和ListResourceBundle，分别对应属性文件和Java类文件。 

10.1多语言支持

在Java程序中实现多语言支持的一种常用方法是使用ResourceBundle类，它可以从不同的文件中加载语言和地区相关的数据，比如属性文件（.properties）或者Java类文件（.java）。ResourceBundle类可以根据用户的Locale（语言和地区）自动选择合适的文件，也可以手动指定要加载的文件。ResourceBundle类可以通过键值对的方式存储和获取数据，也可以通过下标的方式存储和获取数据。

要使用ResourceBundle类，你需要按照以下步骤进行：

• 第一步，创建一个或多个资源文件，每个资源文件都有一个基名和一个本地信息的附加部分，比如messages_zh_CN.properties表示基名为messages，本地信息为zh_CN（简体中文）的属性文件。每个资源文件中都定义了一些键值对，用来存储不同语言的文本信息。例如：

username=用户名
password=密码

• 第二步，创建一个ResourceBundle对象，使用getBundle方法来加载资源文件，并传入基名和Locale对象。例如：

Locale locale = Locale.getDefault(); // 获取默认的语言和地区
ResourceBundle bundle = ResourceBundle.getBundle("messages", locale); // 加载资源文件

• 第三步，使用ResourceBundle对象的getString方法来获取指定键对应的值，并显示在程序中。例如：

String username = bundle.getString("username"); // 获取用户名对应的文本
String password = bundle.getString("password"); // 获取密码对应的文本
System.out.println(username + ": " + password); // 输出文本

十一、var类型

var类型是Java 10中引入的一种特性，它可以让你在声明局部变量时不需要显式地指定变量的类型，而是让编译器根据变量的初始值来推断变量的类型。var类型可以简化代码的编写，避免重复的类型名称，也可以用于处理匿名类型或者复杂的表达式。不过，var类型也有一些限制和注意事项，比如只能用于局部变量，不能用于类的成员变量，必须在声明时赋初始值，不能赋null值，不能用于多个变量的声明等等。

十二、Switch