java 8 教程（基础篇）

java 8 教程（基础篇）

注意：Java 教程是为 JDK 8编写的。本页中描述的示例和实践没有利用后期版本中引入的改进，并且可能使用不再可用的技术。有关 Java SE 9和后续版本中更新的语言特性的摘要，请参阅 Java 语言更改。有关所有 JDK 版本的新特性、增强功能以及已删除或已弃用选项的信息，请参阅 JDK 发布说明。
本文是对官方教程的简单总结，省略了许多示例，阅读中如有疑惑请参阅文章末尾的参考链接查看官方教程。

入门指南

Java技术现象

• 关于 Java

  • 既是一种编程语言，也是一种平台。

  • 编程语言

    • 标签：简单，面向对象，分布式，多线程，动态，体系结构中立，可移植，高性能，健壮，安全
    • .java -> .class
    • 一次编写，到处运行

  • java 平台

    • Java 虚拟机
    • Java 应用程序编程接口

• Java 可以做什么

  • 开发工具

    • javac，java，javadoc

  • 应用程序接口

  • 部署技术

    • Java Web Start，Java Plug-In

  • 用户界面工具箱

    • JavaFX，Swing，2D toolkits

  • 集成库

    • IDL，JDBC，JNDI，RMI，RMI-IIOP

“Hello World!”应用程序

• 用于NetBeans IDE
• 用于微软操作系统
• 适用于Solaris OS、Linux和Mac OS X

深入“Hello World！”

• 代码注释

  • // text
  • /* text */
  • /** documentation */

• 类定义

  • class name { }

• main 方法

  • public static void main(String[] args)

常见问题

基本概念与特性

面向对象编程概念

• 对象

  • 包含相关状态和行为的软件包。软件对象通常用于对日常生活中发现的真实世界对象建模。
  • 好处：模块性，信息隐藏，代码重用，可插性，调试简单

• 类

  • 创建对象的蓝图或原型。

• 继承

  • 一种机制

• 接口

  • 类与外部世界之间的契约。当一个类实现一个接口时，它承诺提供该接口发布的行为。

• 包

  • 以逻辑方式组织类和接口的名称空间。将代码放入包中可以使大型软件项目更容易管理。

语言基础

• 变量

  • 实例变量(非静态字段)

  • 类变量(静态字段)

  • 局部变量

  • 参数

  • 命名规则

    • 变量名区分大小写。变量名可以是任何合法的标识符——一个无限长的 Unicode 字母和数字序列，以字母、美元符号“$”或下划线“_”开头。但是，按照惯例，变量名总是以字母开头，而不是“$”或“_”。此外，按照惯例，美元符号根本就不用。您可能会发现在某些情况下，自动生成的名称将包含美元符号，但您的变量名称应始终避免使用它。对于下划线字符也存在类似的约定;虽然从技术上讲，变量名以“_”开头是合法的，但这种做法是不鼓励的。不允许留白。
    • 后面的字符可以是字母、数字、美元符号或下划线。惯例(和常识)也适用于这条规则。在为变量选择名称时，使用完整的单词而不是隐晦的缩写。这样做将使您的代码更容易阅读和理解。在许多情况下，它还会使你的代码自文档化;例如，命名为 cadence、speed 和 gear 的字段比缩写版本(如s、c和g)要直观得多。还要记住，您选择的名称不能是关键字或保留字。
    • 如果您选择的名称只包含一个单词，请将该单词全部拼写为小写字母。如果包含多个单词，则后面每个单词的首字母大写。名称 gearRatio 和 currentGear 是这种约定的主要例子。如果变量存储的是一个常量值，比如 static final int NUM_GEARS = 6，则惯例略有变化，每个字母都大写，后面的单词用下划线分隔。按照惯例，下划线字符永远不会在其他地方使用。

  • 基本数据类型

    • byte

      • 字节数据类型是一个8位有符号二补整数。最小值为-128，最大值为127(包括)。在大型数组中，字节数据类型对于节省内存非常有用，因为节省内存实际上很重要。它们也可以用来代替 int，它们的限制有助于澄清你的代码;变量的范围是有限的这一事实可以作为一种文档形式。

    • short

      • 短数据类型是一个16位有符号二补整数。最小值为-32,768，最大值为32,767(含)。与使用byte一样，同样的原则也适用:在大型数组中，在节省内存非常重要的情况下，可以使用 short 来节省内存。

    • int

      • 默认情况下，int 数据类型是32位有符号的二补型整数，最小值为-2³¹，最大值为2³¹-1。在 Java SE 8及更高版本中，可以使用 int 数据类型表示无符号32位整数，该整数的最小值为0，最大值为2³²-1。使用 Integer 类将int 数据类型用作无符号整数。有关更多信息，请参阅数字类一节。像 compareUnsigned, divideUnsigned 等静态方法已经添加到Integer类中，以支持无符号整数的算术操作。

    • long

      • 长数据类型是一个64位的二进制补码整数。signed long的最小值为-2⁶³，最大值为2⁶³-1。在Java SE 8及更高版本中，可以使用 long 数据类型表示无符号64位 long，其最小值为0，最大值为2⁶⁴-1。当需要的值范围大于 int提供的值范围时，请使用此数据类型。Long 类还包含类似 compareUnsigned, divideUnsigned 等方法来支持unsigned Long 的算术运算。

    • float

      • 浮点数据类型是一个单精度32位 IEEE 754浮点数。它的值范围超出了本文的讨论范围，但在 Java 语言规范的浮点类型、格式和值一节中指定。与字节和 short 的建议一样，如果需要在大型浮点数数组中节省内存，则使用float(而不是double)。这种数据类型永远不应该用于精确的值，比如货币。为此，您将需要使用java.math.BigDecimal 类。数字和字符串涵盖BigDecimal 和其他有用的类

    • double

      • 双数据类型是双精度64位 IEEE 754浮点数。它的值范围超出了本文的讨论范围，但在 Java 语言规范的浮点类型、格式和值一节中指定。对于十进制值，此数据类型通常是默认选择。如上所述，这种数据类型永远不应该用于精确的值，比如货币。

    • boolean

      • 布尔数据类型只有两个可能的值: true 和 false。将此数据类型用于跟踪 true/false 条件的简单标记。这种数据类型表示一个比特信息，但它的“大小”并不是精确定义的。

    • char

      • char 数据类型是一个16位 Unicode 字符。它的最小值为’\u0000’(或0)，最大值为’\uffff’(或65,535包括在内)。

    • 除了上面列出的8种基本数据类型之外，Java 编程语言还通过 Java .lang. String 类提供了对字符串的特殊支持。用双引号括住你的字符串会自动创建一个新的 String 对象;例如，String s = "this is a String ";字符串对象是不可变的，这意味着一旦创建，它们的值就不能更改。String类在技术上不是基本数据类型，但考虑到语言给予它的特殊支持，您可能倾向于认为它是基本数据类型。

    • 默认值

      • 声明字段时并不总是需要赋值。已声明但未初始化的字段将被编译器设置为合理的默认值。一般来说，这个默认值将为零或 null，这取决于数据类型。然而，依赖这些默认值通常被认为是糟糕的编程风格。
      • byte：0，short：0，int：0，long：0L，float：0.0f，double：0.0d，char：‘\u0000’，String(或任何对象)：null，boolean：false
      • 局部变量略有不同;编译器从不为未初始化的局部变量赋值。如果不能在声明局部变量的地方初始化它，请确保在尝试使用它之前为它赋值。访问未初始化的局部变量将导致编译时错误。

    • 字面量

      • 基本类型是内置在语言中的特殊数据类型;它们不是从类中创建的对象。字面量是一个固定值的源代码表示;字面量直接在代码中表示，不需要计算。

      • 整数字面值

        • 如果一个整型字面值以字母L或L结尾，则它的类型为long;否则为 int 类型。建议使用大写字母“L”，因为小写字母“L”和数字“1”很难区分。
        • 整型 byte、short、int 和 long 的值可以从 int 字面值中创建。可以从长字面值创建超过 int 范围的 long 类型值。整数字面量可以用以下数字系统表示:
        • 十进制:以10为基数，由数字0到9组成;这是你每天使用的数字系统
          十六进制:以16为进制，由数字0 ~ 9和字母 A ~ F 组成
          二进制:基数2，其数字由数字0和1组成(可以在 Java SE 7及更高版本中创建二进制文字)
        • 对于通用编程，十进制可能是您将使用的唯一数字系统。但是，如果需要使用另一种数字系统，前缀0x表示十六进制，0b 表示二进制:

      • 浮点字面值

        • 浮点字面值如果以字母F或f结尾，则为 float 类型;否则它的类型是 double，并且可以选择以字母 D 或 d 结尾。
        • 浮点类型(浮点和双精度)也可以用 E 或 e (用于科学计数法)、F 或 f (32位浮点字面值)和 D 或 d (64位双精度字面值;这是默认值，按惯例省略)。

      • 字符与字符串字符值

        • char 和 String 类型的文字可以包含任何 Unicode (UTF-16)字符。如果您的编辑器和文件系统允许，您可以直接在代码中使用这些字符。如果不是，你可以使用“Unicode转义”，如“\u0108”(大写C带回旋)，或“S\u00ED Se\ u00f1”(西班牙语为Sí Señor)。对于字符字面值总是使用“单引号”，对于字符串字面值总是使用“双引号”。Unicode 转义序列可以在程序的其他地方使用(例如在字段名中)，而不仅仅是在 char 或 String 字面量中使用。
        • Java 编程语言还支持一些针对 char 和 String 字面值的特殊转义序列:\b(退格)、\t(制表符)、\n(换行)、\f(换行)、\r(回车)、"(双引号)、'(单引号)和\(反斜杠)。
        • 还有一个特殊的空文字，可以用作任何引用类型的值。null 可以赋给任何变量，但基本类型的变量除外。对于空值，除了测试它是否存在之外，几乎没有什么可以做的。因此，在程序中经常使用null作为标记，表示某些对象不可用。

      • 类字面量

        • 由取类型名并附加".class"构成;例如，String.class。这引用了表示类型本身的对象(类型为Class)。

    • 在数字字符中使用下划线字符

      • 在 Java SE 7及更高版本中，任何数量的下划线字符(_)都可以出现在数值文字中数字之间的任何位置。例如，该特性使您能够将数字字面值中的数字组分开，这可以提高代码的可读性。
      • 您只能在数字之间放置下划线

  • 数组

    • 声明一个变量引用一个数组

      • int[] anArray;

    • 创建、初始化和访问数组

      • anArray = new int[10];
      • anArray = { }

    • 复制数组

      • System 类的 arraycopy 方法

    • 数组操作

      • java.util.Arrays 类

• 运算符

  • 优先级

  • 赋值

    • =

  • 算数

    • +, -, *, /, %

  • 一元运算符

    • +, -, ++, --, !

  • 相等

    • ==

  • 关系

    • !=, >, >=, <, <=

  • 条件

    • &&,||（短路）
    • 三元运算 ？：

  • 类型比较

    • instanceof

  • 位与位移

    • <<, >>
    • >>>
    • &, |, ~, ^

• 表达式,语句和块

  • 表达式是由变量、操作符和方法调用组成的构造，这些变量、操作符和方法调用是根据语言的语法构造的，计算结果为单个值。
  • 语句大致相当于自然语言中的句子。一条语句形成了一个完整的执行单元。通过用分号(;)结束表达式。
  • 块是一组介于平衡花括号之间的零条或多条语句，可以在任何允许使用一条语句的地方使用。

• 控制流程语句

  • if-then 和 if-then-else 语句

  • switch 语句

  • while 和 do-while 语句

  • for 语句

  • 分支语句

    • break 语句

      • 有标记
      • 无标记

    • continue 语句

    • return 语句

类与对象

• 类

  • 声明类

    • 修饰符，类名，父类，实现接口列表，类体

  • 声明成员变量

    • 分类

      • 类中的成员变量：字段
      • 方法或代码块中的变量：局部变量
      • 方法声明中的变量：参数

    • 访问修饰符

      • public,private

    • 类型

    • 变量名

  • 定义方法

    • 修饰符，返回类型，方法名，参数列表，异常列表，方法体

    • 方法签名：方法名和参数类型

    • 方法命名

    • 重载方法

    • 构造方法

    • 给方法或构造方法传递信息

      • 参数类型
      • 任意数量的参数
      • 参数名
      • 传递基本数据类型参数（值传递）
      • 传递引用数据类型参数（值传递）

• 对象

  • 创建对象

    • 声明，实例化，初始化

    • 声明一个变量来引用一个对象

    • 实例化一个类

      • new 运算符
      • 构造函数

  • 使用对象

    • 引用一个对象的字段
    • 调用对象的方法
    • 垃圾收集器

• 深入类

  • 方法的返回值

    • 返回时机

      • 完成方法中所有的语句
      • 执行到了 return 语句
      • 抛出一个异常

    • 返回一个类或接口

      • 返回对象的类型必须是返回类型或该类型的子类
      • 协变返回类型：返回类型允许与子类沿同一方向变化
      • 接口可用作返回类型，那么返回的对象必须实现该接口

  • this 关键字

    • 实例方法或构造函数中
    • this 与字段的使用
    • this 与构造函数的使用

  • 访问控制

    • 访问层级

      • 顶级

        • public, 包私有（没有指定修饰符）

      • 成员级

        • public，private，protected，包私有

  • 类成员

    • 类变量

      • static
      • 通过类名引用

    • 类方法

    • 常量

      • static final
      • 编译时常量

  • 初始化字段

    • 静态初始化块

    • 初始化块

      • 构造函数间共享

    • 使用 final 方法初始化实例变量（用于子类希望重用初始化方法）

• 嵌套类

  • 使用嵌套类的原因

    • 是一种对只在一个地方使用的类进行逻辑分组的方法
    • 增加了封闭性
    • 可以产生更可读和更易于维护的代码

  • 内部类（非静态）

    • 不可以定义静态成员，可以定义常量

    • 内部类的实例对象存在于外部类的实例中

      • OuterClass.InnerClass innerObject = outObject.new InnerClass();

    • 举例

      • 使用内部类来实现 helper 类
      • 要处理用户界面事件，您必须知道如何使用内部类，因为事件处理机制广泛使用了他们。

    • 修饰符

      • 与外部类成员使用相同的修饰符

    • 本地类

      • 在块中定义，一般是在方法中

      • 声明

      • 访问外围类的成员

        • 只可以访问声明为 final 的本地变量
        • 从 java8 开始，本地类可以访问封闭块中为 final 或有效 final 的局部变量和参数（一个变量或参数的值在初始化后从未改变过称为有效 final）

    • 匿名类

      • 和本地类类似，除了没有名字

      • 声明

        • 一个表达式

      • 语法

        • 类似于构造函数的调用，只不过代码块中包含一个类的定义
        • new 运算符，要实现的接口名或要继承的类，包含构造函数参数的括号（如果是接口的话，是空参），类定义体

      • 访问外围作用域中的本地变量

        • 访问外围类中的成员
        • 不能访问外围作用域中没有声明为 final 或有效 final 的本地变量
        • 与本地类的约束一样不可以声明静态初始化器或成员接口
        • 不可以声明构造函数

      • 声明与访问匿名类的成员

    • Lambda 表达式

      • 函数作为方法参数或者说代码作为数据

      • 理想用例

        • 创建搜索匹配某一特性成员的方法

        • 创建更通用的搜索方法

        • 在本地类中指定搜索条件

        • 在匿名类中中指定搜索条件

        • 在 Lambda 表达式中指定搜索条件

        • 使用 Lambda 表达式的标准函数接口

          • 函数接口：只包含一个抽象方法
          • java.util.function

        • 在应用中使用 Lambda 表达式

        • 更广泛的使用泛型

        • 使用接受 Lambda 表达式作为参数的聚合操作

          • stream(),filter(),map(),forEach()

      • GUI 程序中的 Lambda 表达式

      • 语法

        • 用逗号分隔的形式参数列表，用括号括起来（参数数据类型可省略，如果只有一个参数，可以省略括号）

        • 箭头符号：->

        • 主体

          • 单个表达式或语句块
          • 返回计算的值或使用 return 语句

      • 访问外围作用域中本地变量

        • 词法范围：不会从超类型继承任何名称，也不会引入新的作用域级别
        • 只能访问包含块的 final 或 有效 final 类型的局部变量和参数

      • 目标类型

        • 方法所期望的数据类型

        • 只能在 Java 编译器可以确定目标类型的情况下使用lambda 表达式

        • 方法参数

          • Java编译器用另外两个语言特性确定目标类型
          • 重载解析
          • 类型参数推断

      • 序列化

        • 不推荐

      • 方法引用

        • 分类

          • 引用静态方法

            • ContainingClass::staticMethodName

          • 引用特定对象的实例方法

            • containingObject::instanceMethodName

          • 引用特定类型的任意对象的实例方法

            • ContainingType::methodName

          • 引用构造函数

            • ClassName::new

  • 静态嵌套类

    • 在行为上是一个顶级类

  • 影子

    • 如果特定作用域中的类型声明与封闭作用域中的另一个声明同名，则该声明将隐藏封闭作用域的声明
    • x, this.x, Shadow.this.x

  • 序列化

    • 不同编译器对内部类的序列化结果可能不同

  • 使用时机

    • 本地类

      • 如果需要创建一个类的多个实例、访问其构造函数或引入一个新的命名类型(例如，因为稍后需要调用其他方法)，请使用它。

    • 匿名类

      • 如果需要声明字段或其他方法，可以使用它。

    • Lambda 表达式

      • 如果您正在封装想要传递给其他代码的单个行为单元，请使用它。例如，如果您希望在流程完成或流程遇到错误时对集合的每个元素执行某个操作，则可以使用lambda表达式。
      • 如果您需要一个功能接口的简单实例，并且前面的条件都不适用(例如，您不需要构造函数、命名类型、字段或其他方法)，请使用它。

    • 嵌套类

      • 如果您的需求与局部类类似，您希望使该类型更广泛地可用，并且您不需要访问局部变量或方法参数，请使用它。
      • 如果需要访问封闭实例的非公共字段和方法，请使用非静态嵌套类(或内部类)。如果不需要这种访问，请使用静态嵌套类。

• 枚举类型

  • 所有枚举都隐式地扩展 java.lang.Enum，因此枚举不能扩展其他任何东西。
  • 枚举类型的构造函数必须是包私有或私有访问。它自动创建在枚举体开头定义的常量。您不能自己调用枚举构造函数。
  • 枚举常量列表必须以分号结束。

注解

• 元数据的一种形式，提供关于程序的数据，而这些数据不是程序本身的一部分。注释对它们所注释的代码的操作没有直接影响。

• 应用

  • 编译器信息
  • 编译时和部署时处理
  • 运行时处理

• 基础

  • 注释的格式

  • java8 支持重复注释

  • 注释可以使用的地方

    • 声明:类、字段、方法和其他程序元素的声明。在声明上使用时，根据约定，每个注释通常出现在自己的行上。

    • 从 java8 开始，注释也可以应用于类型的使用

      • new @Interned MyObject();
      • myString = (@NonNull String) str;
      • class UnmodifiableList implements
        @Readonly List<@Readonly T> { … }
      • void monitorTemperature() throws
        @Critical TemperatureException { … }

• 声明一个注解类型

  • @interface
  • 可以定义可选的默认值

• 预定义注解类型

  • @Deprecated

  • @Override

  • @SuppressWarnings

  • @SafeVarargs

  • @FunctionalInterface

  • 适用于其他注解的注解

    • @Retention
    • @Documented
    • @Target
    • @Inherited
    • @Repeatable

• 类型注解可插拔类型系统

  • 注解可以应用于任何类型的使用。这意味着注解可以在使用类型的任何地方使用。
  • 例：类实例创建表达式(new)、类型转换、实现子句和抛出子句。
  • 为了支持改进的Java程序分析，以确保更强的类型检查。Java SE 8发行版没有提供类型检查框架，但是它允许您编写(或下载)类型检查框架，该框架实现为一个或多个与Java编译器一起使用的可插拔模块。

• 重复注解

  • 出于兼容性考虑，重复注释存储在Java编译器自动生成的容器注释中。为了让编译器做到这一点，在代码中需要两个声明。
  • 声明一个可重复注解类型
  • 声明包含注解类型，包含注解类型的值元素必须具有数组类型。数组类型的组件类型必须是可重复的注解类型。

• 检索注解

  • Reflection API

• 设计考虑

  • 基数性

    • 现在可以使用注解0次(一次)，或者(如果注解的类型被标记为@Repeatable)多次。

  • 位置

    • 还可以通过使用 @Target 元注释来限制注释类型的使用位置。

接口

• 一种引用类型，类似于类，只能包含常量、方法签名、默认方法、静态方法和嵌套类型。方法体只存在于默认方法和静态方法中。接口不能被实例化——它们只能由类实现或由其他接口扩展

• 接口作为 api

• 定义接口

  • public，interface，extends

  • 接口体

    • 抽象方法，默认方法，静态方法，常量声明
    • 接口中的所有抽象方法、默认方法和静态方法都是隐式公共方法，因此可以省略 public 修饰符。常量声明同理。

• 实现接口

  • 在类声明中包含 implements 子句。
  • implements 关键字后面跟着一个由该类实现的接口列表，以逗号分隔。
  • 按照惯例，implements 子句跟在 extends 子句后面(如果有的话)。

• 以类型的方式使用接口

  • 定义一个新接口时，就是在定义一个新的引用数据类型。可以在任何可以使用任何其他数据类型名称的地方使用接口名称。

• 默认方法

  • 默认方法使您能够向库的接口添加新功能，并确保与为这些接口的旧版本编写的代码的二进制兼容性。

  • 扩展包含默认方法的接口

    • 完全不要提及默认方法，这将使您的扩展接口继承默认方法。
    • 重新声明默认方法，使其抽象。
    • 重新定义默认方法，该方法将覆盖它。

  • 静态方法

    • 这让你更容易在你的库中组织帮助方法;您可以在同一个接口中保留特定于某个接口的静态方法，而不是在一个单独的类中。

  • 将默认方法集成到现有库中

    • 以 Comparator 接口为例

继承

• 定义

  • 从另一个类派生的类称为子类(也称为派生类、扩展类或子类)。派生子类的类称为超类(也称为基类或父类)。

• 除了 Object，它没有超类，每个类都有且只有一个直接超类(单继承)。在没有任何其他显式超类的情况下，每个类都隐式地是Object 的子类。

• 子类从父类继承所有成员(字段、方法和嵌套类)。构造函数不是成员，因此不能由子类继承，但是父类的构造函数可以从子类调用。

• Java 平台类层次结构

• 在子类中可以做什么

  • 子类继承父类的所有 public 和 protected 成员，无论子类在哪个包中。如果子类与其父类在同一个包中，它还继承父类的包私有成员。你可以按原样使用继承的成员，替换它们，隐藏它们，或者用新成员补充它们:
  • 可以编写调用父类构造函数的子类构造函数，可以隐式调用，也可以使用关键字 super。

• 超类的私有成员

• 转换对象

• 状态、实现和类型的多重继承

  • Java 编程语言不允许扩展多个类的一个原因是为了避免状态的多重继承问题，即从多个类继承字段的能力。因为接口不包含字段，所以不必担心状态的多重继承所导致的问题。
  • Java 编程语言支持类型的多重继承，即类实现多个接口的能力。一个对象可以有多种类型:它自己的类的类型和类实现的所有接口的类型。

• 覆盖和隐藏方法

  • 实例方法

  • 静态方法

  • 被调用的被重写实例方法的版本是子类中的版本。

  • 被调用的隐藏静态方法的版本取决于它是从父类还是子类调用的。

  • 接口方法

    • 实例方法优先于接口默认方法。
    • 已经被其他候选对象覆盖的方法将被忽略。
    • 接口中的静态方法不会被继承。
    • 可以使用 super 关键字调用任何默认实现

  • 覆盖方法的访问说明符可以允许比被覆盖方法更多的访问，但不能更少。

  • 重载

• 多态性

  • 类的子类可以定义它们自己独特的行为，同时还可以共享父类的一些相同功能。
  • Java 虚拟机(JVM)为每个变量中引用的对象调用适当的方法。它不调用由变量类型定义的方法。这种行为被称为虚拟方法调用，它展示了 Java 语言中重要的多态性特性的一个方面。

• 隐藏字段

  • 在类中，与超类中的字段具有相同名称的字段将隐藏超类的字段，即使它们的类型不同。
  • 在子类中，父类中的字段不能通过其简单名称引用。相反，必须通过 super 访问该字段

• super 关键字

  • 访问超类成员

  • 子类的构造函数

    • 如果构造函数没有显式调用超类构造函数，Java编译器会自动插入对超类的无参数构造函数的调用。如果超类没有无参数构造函数，则会得到编译时错误。
    • 构造函数链接

• Object 类

  • protected Object clone() throws CloneNotSupportedException

    • Cloneable 接口
    • 如果一个对象包含一个外部对象的引用，你可能需要重写clone() 来获得正确的行为。

  • public boolean equals(Object obj)

    • Object 中测试的是引用是否相等
    • 如果重写 equals()，也必须重写 hashCode()。

  • protected void finalize() throws Throwable

    • Object 的实现为空
    • 可以由系统自动调用，但是何时调用，甚至是否调用都是不确定的。因此，不要依赖这种方法来为你做清理工作。

  • public final Class getClass()

    • 不可以能重写 getClass()。

  • public int hashCode()

  • public String toString()

  • 线程同步相关

    • public final void notify()
      public final void notifyAll()
      public final void wait()
      public final void wait(long timeout)
      public final void wait(long timeout, int nanos)

• 编写 Final 类和方法

  • 从构造函数调用的方法通常应该声明为final。如果构造函数调用非final方法，子类可能会以令人惊讶或不希望的结果重新定义该方法。
  • 声明为 final 的类不能被子类化。

• 抽象类和方法

  • 声明为抽象的类，它可以包含也可以不包含抽象方法。抽象类不能被实例化，但可以被子类化。
  • 当抽象类被子类化时，子类通常为其父类中的所有抽象方法提供实现。然而，如果不是这样，那么子类也必须声明为抽象的。
  • 与接口相比
  • 静态成员

数字与字符串

• 数字

  • Number 类

    • 所有数字包装类都是 Number 类的子类

    • 使用 Number 对象的情况

      • 作为期望对象的方法的参数
      • 使用类定义的常量，如 MIN_VALUE 和 MAX_VALUE，它们提供数据类型的上界和下界。
      • 使用类方法将值与其他基本类型进行转换，将值与字符串进行转换，并在数字系统(十进制、八进制、十六进制、二进制)之间进行转换。

    • Number 子类需要实现的方法

      • 类型转换：xxxValue()
      • 比较：compareTo()
      • 判等：equals()

  • 数字打印输出格式化

    • printf 和 format 方法

      • PrintStream 类
      • java.util.Formatter

    • DecimalFormat 类

      • 控制前导和后导零、前缀和后缀、分组(千位)分隔符和小数分隔符的显示。

  • Math 类

    • 静态导入

      • import static java.lang.Math.*;

    • 常量

      • PI，E

    • 基本方法

      • 绝对值

      • 四舍五入

      • 上界，下界

      • 最小，最大

      • 指数，对数

      • 三角函数

      • 随机数

        • 当你需要生成单个随机数时，Math.random很有效。如果需要生成一系列随机数，则应该创建java.util.Random的实例，并调用该对象上的方法来生成数字。

• Character 类

  • 不可变

  • 方法

    • 判断字母，数字，空格，大写，小写
    • 转大写，小写

  • 转义字符

• 字符串

  • 创建 String

    • “ ”，字符数组
    • 不可变

  • 字符串长度

  • 字符串连接

    • concat()，+
    • Java编程语言不允许字面值字符串在源文件中跨行

  • 创建格式字符串

    • String.format()

  • 数字和字符串之间的转换

    • 字符串转数字

      • valueOf()
      • parseXXXX()

    • 数字转字符串

      • toString()

  • 操作字符串中的字符

    • 获取

      • charAt()

      • substring()

      • 其他方法

        • split(),subSequence(),trim(),toLowerCase()

    • 搜索

      • indexOf(),contains()

    • 替换

      • replace()

  • 比较与部分比较

    • endsWith，startsWith，compareTo，compareToIgnoreCase，equals，equalsIgnoreCase，regionMatches，matches

  • StringBuilder 类

    • 与String对象类似，只是它们可以被修改。在内部，这些对象被视为包含字符序列的变长数组。在任