Java面向对象设计

类与对象、封装、构造方法

• 类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。
  • 属性：就是该事物的状态信息。
  • 行为：就是该事物能够做什么。
• 对象：是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为。

类与对象的关系：
类是对一类事物的描述，是抽象的。对象是一类事物的实例，是具体的。类是对象的模板，对象是类的实体。

类的定义

public class ClassName{
    成员变量
    成员方法
}

成员变量定义的时候有其初始化的默认值：

在这里插入图片描述

封装

访问数据通过指定的方式
private：

1. private是一个权限修饰符，代表最小权限。
2. 可以修饰成员变量和成员方法。
3. 被private修饰后的成员变量和成员方法，只在本类中才能访问。

this：
this代表所在类的当前对象的引用（地址值），即对象自己的引用。

构造方法

1. 如果你不提供构造方法，系统会给出无参数构造方法。
2. 如果你提供了构造方法，系统将不再提供无参数构造方法。
3. 构造方法是可以重载的，既可以定义参数，也可以不定义参数。

标准代码--JavaBean

JavaBean是 Java语言编写类的一种标准规范。
符合 JavaBean 的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的 set 和 get 方法

常用API

API

应用程序编程接口

匿名对象

创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。
应用场景：

• 创建匿名对象类直接调用方法，没有变量名
• 一旦调用两个方法就是创建了两个对象，造成浪费
• 匿名对象可以作为方法的参数和返回值

static关键字

关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

• 类变量
• 静态方法
  注意事项：
  静态方法可以直接访问类变量和静态方法。
  静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。静态方法中，不能使用this关键字。
  静态方法只能访问静态成员

在这里插入图片描述
方法区中只有一块区域是用来保存静态区的
静态代码块：
给类变量进行赋值

Object类

java.lang.Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。
如果一个类没有特别指定父类，那么默认则继承自Object类

• 类
  java.lang.Object
• 构造方法
  Object（）
• 成员方法
  protected Object clone()
  创建并返回此对象的一个副本。
  boolean equals(Object obj)
  指示其他某个对象是否与此对象“相等”。
  protected void finalize()
  当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
  Class<?> getClass()
  返回此 Object 的运行时类。
  int hashCode()
  返回该对象的哈希码值。
  void notify()
  唤醒在此对象监视器上等待的单个线程。
  void notifyAll()
  唤醒在此对象监视器上等待的所有线程。
  String toString()
  返回该对象的字符串表示。
  void wait()
  在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
  void wait(long timeout)
  在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。
  void wait(long timeout, int nanos)
  在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待。

Objects类

java.util.Objects类
在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。
//内部调用equals方法
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}

Scanner类

一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器。
public final class Scanner
extends Object
implements Iterator<String>

• 类
  Java.util.Scanner
  Scanner 使用分隔符模式将其输入分解为标记，默认情况下该分隔符模式与空白匹配。然后可以使用不同的 next 方法将得到的标记转换为不同类型的值。
  实现迭代器Iterator接口，调用迭代器方法输出
  扫描器还可以使用不同于空白的分隔符。下面是从一个字符串读取若干项的例子：

     String input = "1 fish 2 fish red fish blue fish";
     Scanner s = new Scanner(input).useDelimiter("\\s*fish\\s*");
     System.out.println(s.nextInt());
     System.out.println(s.nextInt());
     System.out.println(s.next());
     System.out.println(s.next());
     s.close(); 

扫描器所使用的默认空白分隔符通过 Character.isWhitespace 来识别。不管以前是否更改，reset() 方法将把扫描器分隔符的值重置为默认空白分隔符。
**若没有外部同步，则 Scanner 的多线程使用是不安全的。 **
除非另行说明，否则将一个 null 参数传递到 Scanner 的任何一个方法中都将抛出NullPointerException。
默认情况下扫描器会将数字解释为十进制形式，除非已经使用 useRadix(int) 方法设置了不同的基数。不管以前是否更改，reset() 方法将把扫描器的基数重置为10 。

• 构造方法
  构造方法摘要
  Scanner(File source)
  构造一个新的 Scanner，它生成的值是从指定文件扫描的。
  Scanner(File source, String charsetName)
  构造一个新的 Scanner，它生成的值是从指定文件扫描的。
  Scanner(InputStream source)
  构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。
  Scanner(InputStream source, String charsetName)
  构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。
  Scanner(Readable source)
  构造一个新的 Scanner，它生成的值是从指定源扫描的。
  Scanner(ReadableByteChannel source)
  构造一个新的 Scanner，它生成的值是从指定信道扫描的。
  Scanner(ReadableByteChannel source, String charsetName)
  构造一个新的 Scanner，它生成的值是从指定信道扫描的。
  Scanner(String source)
  构造一个新的 Scanner，它生成的值是从指定字符串扫描的

• 成员方法
  void close()
  关闭此扫描器。
  Pattern delimiter()
  返回此 Scanner 当前正在用于匹配分隔符的 Pattern。
  String findInLine(Pattern pattern)
  试图在忽略分隔符的情况下查找下一个指定模式。
  String findInLine(String pattern)
  试图在忽略分隔符的情况下查找下一个从指定字符串构造的模式。
  String findWithinHorizon(Pattern pattern, int horizon)
  试图查找下一个指定模式。
  String findWithinHorizon(String pattern, int horizon)
  试图在忽略分隔符的情况下查找下一个从指定字符串构造的模式。
  boolean hasNext()
  如果此扫描器的输入中有另一个标记，则返回 true。
  boolean hasNext(Pattern pattern)
  如果下一个完整标记与指定模式匹配，则返回 true。
  boolean hasNext(String pattern)
  如果下一个标记与从指定字符串构造的模式匹配，则返回 true。
  boolean hasNextBigDecimal()
  如果通过使用 nextBigDecimal() 方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 BigDecimal，则返回 true。
  boolean hasNextBigInteger()
  如果通过使用 nextBigInteger() 方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 BigInteger 值，则返回 true。
  boolean hasNextBigInteger(int radix)
  如果通过使用 nextBigInteger() 方法，此扫描器输入信息中的下一个标记可以解释为指定基数中的一个 BigInteger 值，则返回 true。
  boolean hasNextBoolean()
  如果通过使用一个从字符串 "true|false" 创建的大小写敏感的模式，此扫描器输入信息中的下一个标记可以解释为一个布尔值，则返回 true。
  boolean hasNextByte()
  如果通过使用 nextByte() 方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个字节值，则返回 true。
  boolean hasNextByte(int radix)
  如果通过使用 nextByte() 方法，此扫描器输入信息中的下一个标记可以解释为指定基数中的一个字节值，则返回 true。
  boolean hasNextDouble()
  如果通过使用 nextDouble() 方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 double 值，则返回 true。
  boolean hasNextFloat()
  如果通过使用 nextFloat() 方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 float 值，则返回 true。
  boolean hasNextInt()
  如果通过使用 nextInt() 方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 int 值，则返回 true。
  boolean hasNextInt(int radix)
  如果通过使用 nextInt() 方法，此扫描器输入信息中的下一个标记可以解释为指定基数中的一个 int 值，则返回 true。
  boolean hasNextLine()
  如果在此扫描器的输入中存在另一行，则返回 true。
  boolean hasNextLong()
  如果通过使用 nextLong() 方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 long 值，则返回 true。
  boolean hasNextLong(int radix)
  如果通过使用 nextLong() 方法，此扫描器输入信息中的下一个标记可以解释为指定基数中的一个 long 值，则返回 true。
  boolean hasNextShort()
  如果通过使用 nextShort() 方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 short 值，则返回 true。
  boolean hasNextShort(int radix)
  如果通过使用 nextShort() 方法，此扫描器输入信息中的下一个标记可以解释为指定基数中的一个 short 值，则返回 true。
  IOException ioException()
  返回此 Scanner 的底层 Readable 最后抛出的 IOException。
  Locale locale()
  返回此扫描器的语言环境。
  MatchResult match()
  返回此扫描器所执行的最后扫描操作的匹配结果。
  String next()
  查找并返回来自此扫描器的下一个完整标记。
  String next(Pattern pattern)
  如果下一个标记与指定模式匹配，则返回下一个标记。
  String next(String pattern)
  如果下一个标记与从指定字符串构造的模式匹配，则返回下一个标记。
  BigDecimal nextBigDecimal()
  将输入信息的下一个标记扫描为一个 BigDecimal。
  BigInteger nextBigInteger()
  将输入信息的下一个标记扫描为一个 BigInteger。
  BigInteger nextBigInteger(int radix)
  将输入信息的下一个标记扫描为一个 BigInteger。
  boolean nextBoolean()
  扫描解释为一个布尔值的输入标记并返回该值。
  byte nextByte()
  将输入信息的下一个标记扫描为一个 byte。
  byte nextByte(int radix)
  将输入信息的下一个标记扫描为一个 byte。
  double nextDouble()
  将输入信息的下一个标记扫描为一个 double。
  float nextFloat()
  将输入信息的下一个标记扫描为一个 float。
  int nextInt()
  将输入信息的下一个标记扫描为一个 int。
  int nextInt(int radix)
  将输入信息的下一个标记扫描为一个 int。
  String nextLine()
  此扫描器执行当前行，并返回跳过的输入信息。
  long nextLong()
  将输入信息的下一个标记扫描为一个 long。
  long nextLong(int radix)
  将输入信息的下一个标记扫描为一个 long。
  short nextShort()
  将输入信息的下一个标记扫描为一个 short。
  short nextShort(int radix)
  将输入信息的下一个标记扫描为一个 short。
  int radix()
  返回此扫描器的默认基数。
  void remove()
  Iterator 的这种实现不支持移除操作。
  Scanner reset()
  重置此扫描器。
  Scanner skip(Pattern pattern)
  在忽略分隔符的情况下跳过与指定模式匹配的输入信息。
  Scanner skip(String pattern)
  跳过与从指定字符串构造的模式匹配的输入信息。
  String toString()
  返回此 Scanner 的字符串表示形式。
  Scanner useDelimiter(Pattern pattern)
  将此扫描器的分隔模式设置为指定模式。
  Scanner useDelimiter(String pattern)
  将此扫描器的分隔模式设置为从指定 String 构造的模式。
  Scanner useLocale(Locale locale)
  将此扫描器的语言环境设置为指定的语言环境。
  Scanner useRadix(int radix)
  将此扫描器的默认基数设置为指定基数。

Random类

此类的实例用于生成伪随机数流。
public class Random
extends Object
implements Serializable

• 类
  java.util.Random

• 构造方法
  Random()
  创建一个新的随机数生成器。
  Random(long seed)
  使用单个 long 种子创建一个新的随机数生成器。

• 成员方法
  protected int next(int bits)
  生成下一个伪随机数。
  boolean nextBoolean()
  返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 boolean 值。
  void nextBytes(byte[] bytes)
  生成随机字节并将其置于用户提供的 byte 数组中。
  double nextDouble()
  返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 double 值。
  float nextFloat()
  返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 float 值。
  double nextGaussian()
  返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的 double 值，其平均值是 0.0，标准差是 1.0。
  int nextInt()
  返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
  int nextInt(int n)
  返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。
  long nextLong()
  返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。
  void setSeed(long seed)
  使用单个 long 种子设置此随机数生成器的种子。

详细
空参数

public int nextInt() {
   return next(32);
 }

带有参数
返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。nextInt 的常规协定是，伪随机地生成并返回指定范围中的一个 int 值。所有可能的 n 个 int 值的生成概率（大致）相同。Random 类按如下方式实现 nextInt(int n) 方法：

public int nextInt(int n) {
     if (n<=0)
        throw new IllegalArgumentException("n must be positive");

     if ((n & -n) == n)  // i.e., n is a power of 2
         return (int)((n * (long)next(31)) >> 31);

     int bits, val;
     do {
         bits = next(31);
         val = bits % n;
     } while(bits - val + (n-1) < 0);
     return val;
  }

ArrayList类

java.lang.Object
继承者 java.util.AbstractCollection<E>
继承者 java.util.AbstractList<E>
继承者 java.util.ArrayList<E>
size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。add 操作以分摊的固定时间 运行，也就是说，添加 n 个元素需要 O(n) 时间。其他所有操作都以线性时间运行（大体上讲）。
每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。
此实现不是同步的
所有已实现的接口：
Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess

存储基本类型使用包装类型

在这里插入图片描述

• 类
  public class ArrayList<E>
  extends AbstractList<E>
  implements List<E>, RandomAccess, Cloneable, Serializable

• 构造方法
  ArrayList()
  构造一个初始容量为 10 的空列表。
  ArrayList(Collection<? extends E> c)
  构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
  ArrayList(int initialCapacity)
  构造一个具有指定初始容量的空列表。

• 成员方法
  boolean add(E e)
  将指定的元素添加到此列表的尾部。
  void add(int index, E element)
  将指定的元素插入此列表中的指定位置。
  boolean addAll(Collection<? extends E> c)
  按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。
  boolean addAll(int index, Collection<? extends E> c)
  从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。
  void clear()
  移除此列表中的所有元素。
  Object clone()
  返回此 ArrayList 实例的浅表副本。
  boolean contains(Object o)
  如果此列表中包含指定的元素，则返回 true。
  void ensureCapacity(int minCapacity)
  如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。
  E get(int index)
  返回此列表中指定位置上的元素。
  int indexOf(Object o)
  返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
  boolean isEmpty()
  如果此列表中没有元素，则返回 true
  int lastIndexOf(Object o)
  返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
  E remove(int index)
  移除此列表中指定位置上的元素。
  boolean remove(Object o)
  移除此列表中首次出现的指定元素（如果存在）。
  protected void removeRange(int fromIndex, int toIndex)
  移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
  E set(int index, E element)
  用指定的元素替代此列表中指定位置上的元素。
  int size()
  返回此列表中的元素数。
  Object[] toArray()
  按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
  <T> T[]
  toArray(T[] a)
  按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
  void trimToSize()
  将此 ArrayList 实例的容量调整为列表的当前大小。

String类

java.lang.Object
继承者 java.lang.String
所有已实现的接口：
Serializable, CharSequence, Comparable<String>

public final class String
extends Object
implements Serializable, Comparable<String>, CharSequence

字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。

String 类包括的方法可用于检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本并将所有字符全部转换为大写或小写。大小写映射基于 Character 类指定的 Unicode 标准版。

Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。字符串串联是通过 StringBuilder（或 StringBuffer）类及其 append 方法实现的。字符串转换是通过 toString 方法实现的，该方法由 Object 类定义，并可被 Java 中的所有类继承。有关字符串串联和转换的更多信息，请参阅 Gosling、Joy 和 Steele 合著的 The Java Language Specification。

• 类
  java.lang.String

• 构造方法
  String()
  初始化一个新创建的 String 对象，使其表示一个空字符序列。
  String(byte[] bytes)
  通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
  String(byte[] bytes, Charset charset)
  通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。
  String(byte[] ascii, int hibyte)
  已过时。 该方法无法将字节正确地转换为字符。从 JDK 1.1 开始，完成该转换的首选方法是使用带有 Charset、字符集名称，或使用平台默认字符集的 String 构造方法。
  String(byte[] bytes, int offset, int length)
  通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
  String(byte[] bytes, int offset, int length, Charset charset)
  通过使用指定的 charset 解码指定的 byte 子数组，构造一个新的 String。
  String(byte[] ascii, int hibyte, int offset, int count)
  已过时。 该方法无法将字节正确地转换为字符。从 JDK 1.1 开始，完成该转换的首选方法是使用带有 Charset、字符集名称，或使用平台默认字符集的 String 构造方法。
  String(byte[] bytes, int offset, int length, String charsetName)
  通过使用指定的字符集解码指定的 byte 子数组，构造一个新的 String。
  String(byte[] bytes, String charsetName)
  通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。
  String(char[] value)
  分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
  String(char[] value, int offset, int count)
  分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
  String(int[] codePoints, int offset, int count)
  分配一个新的 String，它包含 Unicode 代码点数组参数一个子数组的字符。
  String(String original)
  初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。
  String(StringBuffer buffer)
  分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。
  String(StringBuilder builder)
  分配一个新的字符串，它包含字符串生成器参数中当前包含的字符序列。

• 成员方法
  char charAt(int index)
  返回指定索引处的 char 值。
  int codePointAt(int index)
  返回指定索引处的字符（Unicode 代码点）。
  int codePointBefore(int index)
  返回指定索引之前的字符（Unicode 代码点）。
  int codePointCount(int beginIndex, int endIndex)
  返回此 String 的指定文本范围中的 Unicode 代码点数。
  int compareTo(String anotherString)
  按字典顺序比较两个字符串。
  int compareToIgnoreCase(String str)
  按字典顺序比较两个字符串，不考虑大小写。
  String concat(String str)
  将指定字符串连接到此字符串的结尾。
  boolean contains(CharSequence s)
  当且仅当此字符串包含指定的 char 值序列时，返回 true。
  boolean contentEquals(CharSequence cs)
  将此字符串与指定的 CharSequence 比较。
  boolean contentEquals(StringBuffer sb)
  将此字符串与指定的 StringBuffer 比较。
  static String copyValueOf(char[] data)
  返回指定数组中表示该字符序列的 String。
  static String copyValueOf(char[] data, int offset, int count)
  返回指定数组中表示该字符序列的 String。
  boolean endsWith(String suffix)
  测试此字符串是否以指定的后缀结束。
  boolean equals(Object anObject)
  将此字符串与指定的对象比较。
  boolean equalsIgnoreCase(String anotherString)
  将此 String 与另一个 String 比较，不考虑大小写。
  static String format(Locale l, String format, Object... args)
  使用指定的语言环境、格式字符串和参数返回一个格式化字符串。
  static String format(String format, Object... args)
  使用指定的格式字符串和参数返回一个格式化字符串。
  byte[] getBytes()
  使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
  byte[] getBytes(Charset charset)
  使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。
  void getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin)
  已过时。 该方法无法将字符正确转换为字节。从 JDK 1.1 起，完成该转换的首选方法是通过 getBytes() 方法，该方法使用平台的默认字符集。
  byte[] getBytes(String charsetName)
  使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
  void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
  将字符从此字符串复制到目标字符数组。
  int hashCode()
  返回此字符串的哈希码。
  int indexOf(int ch)
  返回指定字符在此字符串中第一次出现处的索引。
  int indexOf(int ch, int fromIndex)
  返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
  int indexOf(String str)
  返回指定子字符串在此字符串中第一次出现处的索引。
  int indexOf(String str, int fromIndex)
  返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
  String intern()
  返回字符串对象的规范化表示形式。
  boolean isEmpty()
  当且仅当 length() 为 0 时返回 true。
  int lastIndexOf(int ch)
  返回指定字符在此字符串中最后一次出现处的索引。
  int lastIndexOf(int ch, int fromIndex)
  返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
  int lastIndexOf(String str)
  返回指定子字符串在此字符串中最右边出现处的索引。
  int lastIndexOf(String str, int fromIndex)
  返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
  int length()
  返回此字符串的长度。
  boolean matches(String regex)
  告知此字符串是否匹配给定的正则表达式。
  int offsetByCodePoints(int index, int codePointOffset)
  返回此 String 中从给定的 index 处偏移 codePointOffset 个代码点的索引。
  boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
  测试两个字符串区域是否相等。
  boolean regionMatches(int toffset, String other, int ooffset, int len)
  测试两个字符串区域是否相等。
  String replace(char oldChar, char newChar)
  返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
  String replace(CharSequence target, CharSequence replacement)
  使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
  String replaceAll(String regex, String replacement)
  使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
  String replaceFirst(String regex, String replacement)
  使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
  String[] split(String regex)
  根据给定正则表达式的匹配拆分此字符串。
  String[] split(String regex, int limit)
  根据匹配给定的正则表达式来拆分此字符串。
  boolean startsWith(String prefix)
  测试此字符串是否以指定的前缀开始。
  boolean startsWith(String prefix, int toffset)
  测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
  CharSequence subSequence(int beginIndex, int endIndex)
  返回一个新的字符序列，它是此序列的一个子序列。
  String substring(int beginIndex)
  返回一个新的字符串，它是此字符串的一个子字符串。
  String substring(int beginIndex, int endIndex)
  返回一个新字符串，它是此字符串的一个子字符串。
  char[] toCharArray()
  将此字符串转换为一个新的字符数组。
  String toLowerCase()
  使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
  String toLowerCase(Locale locale)
  使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
  String toString()
  返回此对象本身（它已经是一个字符串！）。
  String toUpperCase()
  使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
  String toUpperCase(Locale locale)
  使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
  String trim()
  返回字符串的副本，忽略前导空白和尾部空白。
  static String valueOf(boolean b)
  返回 boolean 参数的字符串表示形式。
  static String valueOf(char c)
  返回 char 参数的字符串表示形式。
  static String valueOf(char[] data)
  返回 char 数组参数的字符串表示形式。
  static String valueOf(char[] data, int offset, int count)
  返回 char 数组参数的特定子数组的字符串表示形式。
  static String valueOf(double d)
  返回 double 参数的字符串表示形式。
  static String valueOf(float f)
  返回 float 参数的字符串表示形式。
  static String valueOf(int i)
  返回 int 参数的字符串表示形式。
  static String valueOf(long l)
  返回 long 参数的字符串表示形式。
  static String valueOf(Object obj)
  返回 Object 参数的字符串表示形式。

Arrays类

public class Arrays
extends Object

• 类
  java.util.Arrays
• 构造方法
  默认构造方法
• 成员方法
  static <T> List<T>
  asList(T... a)
  返回一个受指定数组支持的固定大小的列表。
  static int binarySearch(byte[] a, byte key)
  使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。
  static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key)
  使用二分搜索法来搜索指定的 byte 型数组的范围，以获得指定的值。
  static int binarySearch(char[] a, char key)
  使用二分搜索法来搜索指定的 char 型数组，以获得指定的值。
  static int binarySearch(char[] a, int fromIndex, int toIndex, char key)
  使用二分搜索法来搜索指定的 char 型数组的范围，以获得指定的值。
  static int binarySearch(double[] a, double key)
  使用二分搜索法来搜索指定的 double 型数组，以获得指定的值。
  static int binarySearch(double[] a, int fromIndex, int toIndex, double key)
  使用二分搜索法来搜索指定的 double 型数组的范围，以获得指定的值。
  static int binarySearch(float[] a, float key)
  使用二分搜索法来搜索指定的 float 型数组，以获得指定的值。
  static int binarySearch(float[] a, int fromIndex, int toIndex, float key)
  使用二分搜索法来搜索指定的 float 型数组的范围，以获得指定的值。
  static int binarySearch(int[] a, int key)
  使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。
  static int binarySearch(int[] a, int fromIndex, int toIndex, int key)
  使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值。
  static int binarySearch(long[] a, int fromIndex, int toIndex, long key)
  使用二分搜索法来搜索指定的 long 型数组的范围，以获得指定的值。
  static int binarySearch(long[] a, long key)
  使用二分搜索法来搜索指定的 long 型数组，以获得指定的值。
  static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
  使用二分搜索法来搜索指定数组的范围，以获得指定对象。
  static int binarySearch(Object[] a, Object key)
  使用二分搜索法来搜索指定数组，以获得指定对象。
  static int binarySearch(short[] a, int fromIndex, int toIndex, short key)
  使用二分搜索法来搜索指定的 short 型数组的范围，以获得指定的值。
  static int binarySearch(short[] a, short key)
  使用二分搜索法来搜索指定的 short 型数组，以获得指定的值。
  static <T> int
  binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)
  使用二分搜索法来搜索指定数组的范围，以获得指定对象。
  static <T> int
  binarySearch(T[] a, T key, Comparator<? super T> c)
  使用二分搜索法来搜索指定数组，以获得指定对象。
  static boolean[] copyOf(boolean[] original, int newLength)
  复制指定的数组，截取或用 false 填充（如有必要），以使副本具有指定的长度。
  static byte[] copyOf(byte[] original, int newLength)
  复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
  static char[] copyOf(char[] original, int newLength)
  复制指定的数组，截取或用 null 字符填充（如有必要），以使副本具有指定的长度。
  static double[] copyOf(double[] original, int newLength)
  复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
  static float[] copyOf(float[] original, int newLength)
  复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
  static int[] copyOf(int[] original, int newLength)
  复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
  static long[] copyOf(long[] original, int newLength)
  复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
  static short[] copyOf(short[] original, int newLength)
  复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
  static <T> T[]
  copyOf(T[] original, int newLength)
  复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。
  static <T,U> T[]
  copyOf(U[] original, int newLength, Class<? extends T[]> newType)
  复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。
  static boolean[] copyOfRange(boolean[] original, int from, int to)
  将指定数组的指定范围复制到一个新数组。
  static byte[] copyOfRange(byte[] original, int from, int to)
  将指定数组的指定范围复制到一个新数组。
  static char[] copyOfRange(char[] original, int from, int to)
  将指定数组的指定范围复制到一个新数组。
  static double[] copyOfRange(double[] original, int from, int to)
  将指定数组的指定范围复制到一个新数组。
  static float[] copyOfRange(float[] original, int from, int to)
  将指定数组的指定范围复制到一个新数组。
  static int[] copyOfRange(int[] original, int from, int to)
  将指定数组的指定范围复制到一个新数组。
  static long[] copyOfRange(long[] original, int from, int to)
  将指定数组的指定范围复制到一个新数组。
  static short[] copyOfRange(short[] original, int from, int to)
  将指定数组的指定范围复制到一个新数组。
  static <T> T[]
  copyOfRange(T[] original, int from, int to)
  将指定数组的指定范围复制到一个新数组。
  static <T,U> T[]
  copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)
  将指定数组的指定范围复制到一个新数组。
  static boolean deepEquals(Object[] a1, Object[] a2)
  如果两个指定数组彼此是深层相等 的，则返回 true。
  static int deepHashCode(Object[] a)
  基于指定数组的“深层内容”返回哈希码。
  static String deepToString(Object[] a)
  返回指定数组“深层内容”的字符串表示形式。
  static boolean equals(boolean[] a, boolean[] a2)
  如果两个指定的 boolean 型数组彼此相等，则返回 true。
  static boolean equals(byte[] a, byte[] a2)
  如果两个指定的 byte 型数组彼此相等，则返回 true。
  static boolean equals(char[] a, char[] a2)
  如果两个指定的 char 型数组彼此相等，则返回 true。
  static boolean equals(double[] a, double[] a2)
  如果两个指定的 double 型数组彼此相等，则返回 true。
  static boolean equals(float[] a, float[] a2)
  如果两个指定的 float 型数组彼此相等，则返回 true。
  static boolean equals(int[] a, int[] a2)
  如果两个指定的 int 型数组彼此相等，则返回 true。
  static boolean equals(long[] a, long[] a2)
  如果两个指定的 long 型数组彼此相等，则返回 true。
  static boolean equals(Object[] a, Object[] a2)
  如果两个指定的 Objects 数组彼此相等，则返回 true。
  static boolean equals(short[] a, short[] a2)
  如果两个指定的 short 型数组彼此相等，则返回 true。
  static void fill(boolean[] a, boolean val)
  将指定的 boolean 值分配给指定 boolean 型数组的每个元素。
  static void fill(boolean[] a, int fromIndex, int toIndex, boolean val)
  将指定的 boolean 值分配给指定 boolean 型数组指定范围中的每个元素。
  static void fill(byte[] a, byte val)
  将指定的 byte 值分配给指定 byte 节型数组的每个元素。
  static void fill(byte[] a, int fromIndex, int toIndex, byte val)
  将指定的 byte 值分配给指定 byte 型数组指定范围中的每个元素。
  static void fill(char[] a, char val)
  将指定的 char 值分配给指定 char 型数组的每个元素。
  static void fill(char[] a, int fromIndex, int toIndex, char val)
  将指定的 char 值分配给指定 char 型数组指定范围中的每个元素。
  static void fill(double[] a, double val)
  将指定的 double 值分配给指定 double 型数组的每个元素。
  static void fill(double[] a, int fromIndex, int toIndex, double val)
  将指定的 double 值分配给指定 double 型数组指定范围中的每个元素。
  static void fill(float[] a, float val)
  将指定的 float 值分配给指定 float 型数组的每个元素。
  static void fill(float[] a, int fromIndex, int toIndex, float val)
  将指定的 float 值分配给指定 float 型数组指定范围中的每个元素。
  static void fill(int[] a, int val)
  将指定的 int 值分配给指定 int 型数组的每个元素。
  static void fill(int[] a, int fromIndex, int toIndex, int val)
  将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。
  static void fill(long[] a, int fromIndex, int toIndex, long val)
  将指定的 long 值分配给指定 long 型数组指定范围中的每个元素。
  static void fill(long[] a, long val)
  将指定的 long 值分配给指定 long 型数组的每个元素。
  static void fill(Object[] a, int fromIndex, int toIndex, Object val)
  将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。
  static void fill(Object[] a, Object val)
  将指定的 Object 引用分配给指定 Object 数组的每个元素。
  static void fill(short[] a, int fromIndex, int toIndex, short val)
  将指定的 short 值分配给指定 short 型数组指定范围中的每个元素。
  static void fill(short[] a, short val)
  将指定的 short 值分配给指定 short 型数组的每个元素。
  static int hashCode(boolean[] a)
  基于指定数组的内容返回哈希码。
  static int hashCode(byte[] a)
  基于指定数组的内容返回哈希码。
  static int hashCode(char[] a)
  基于指定数组的内容返回哈希码。
  static int hashCode(double[] a)
  基于指定数组的内容返回哈希码。
  static int hashCode(float[] a)
  基于指定数组的内容返回哈希码。
  static int hashCode(int[] a)
  基于指定数组的内容返回哈希码。
  static int hashCode(long[] a)
  基于指定数组的内容返回哈希码。
  static int hashCode(Object[] a)
  基于指定数组的内容返回哈希码。
  static int hashCode(short[] a)
  基于指定数组的内容返回哈希码。
  static void sort(byte[] a)
  对指定的 byte 型数组按数字升序进行排序。
  static void sort(byte[] a, int fromIndex, int toIndex)
  对指定 byte 型数组的指定范围按数字升序进行排序。
  static void sort(char[] a)
  对指定的 char 型数组按数字升序进行排序。
  static void sort(char[] a, int fromIndex, int toIndex)
  对指定 char 型数组的指定范围按数字升序进行排序。
  static void sort(double[] a)
  对指定的 double 型数组按数字升序进行排序。
  static void sort(double[] a, int fromIndex, int toIndex)
  对指定 double 型数组的指定范围按数字升序进行排序。
  static void sort(float[] a)
  对指定的 float 型数组按数字升序进行排序。
  static void sort(float[] a, int fromIndex, int toIndex)
  对指定 float 型数组的指定范围按数字升序进行排序。
  static void sort(int[] a)
  对指定的 int 型数组按数字升序进行排序。
  static void sort(int[] a, int fromIndex, int toIndex)
  对指定 int 型数组的指定范围按数字升序进行排序。
  static void sort(long[] a)
  对指定的 long 型数组按数字升序进行排序。
  static void sort(long[] a, int fromIndex, int toIndex)
  对指定 long 型数组的指定范围按数字升序进行排序。
  static void sort(Object[] a)
  根据元素的自然顺序对指定对象数组按升序进行排序。
  static void sort(Object[] a, int fromIndex, int toIndex)
  根据元素的自然顺序对指定对象数组的指定范围按升序进行排序。
  static void sort(short[] a)
  对指定的 short 型数组按数字升序进行排序。
  static void sort(short[] a, int fromIndex, int toIndex)
  对指定 short 型数组的指定范围按数字升序进行排序。
  static <T> void
  sort(T[] a, Comparator<? super T> c)
  根据指定比较器产生的顺序对指定对象数组进行排序。
  static <T> void
  sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
  根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。
  static String toString(boolean[] a)
  返回指定数组内容的字符串表示形式。
  static String toString(byte[] a)
  返回指定数组内容的字符串表示形式。
  static String toString(char[] a)
  返回指定数组内容的字符串表示形式。
  static String toString(double[] a)
  返回指定数组内容的字符串表示形式。
  static String toString(float[] a)
  返回指定数组内容的字符串表示形式。
  static String toString(int[] a)
  返回指定数组内容的字符串表示形式。
  static String toString(long[] a)
  返回指定数组内容的字符串表示形式。
  static String toString(Object[] a)
  返回指定数组内容的字符串表示形式。
  static String toString(short[] a)
  返回指定数组内容的字符串表示形式。

Math类

java.lang.Object
继承者 java.lang.Math
public final class Math
extends Object

• 类
  java.lang.Math

• 构造函数
  静态变量
  static double E
  比任何其他值都更接近 e（即自然对数的底数）的 double 值。
  static double PI
  比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。

• 成员方法
  static double abs(double a)
  返回 double 值的绝对值。
  static float abs(float a)
  返回 float 值的绝对值。
  static int abs(int a)
  返回 int 值的绝对值。
  static long abs(long a)
  返回 long 值的绝对值。
  static double acos(double a)
  返回一个值的反余弦；返回的角度范围在 0.0 到 pi 之间。
  static double asin(double a)
  返回一个值的反正弦；返回的角度范围在 -pi/2 到 pi/2 之间。
  static double atan(double a)
  返回一个值的反正切；返回的角度范围在 -pi/2 到 pi/2 之间。
  static double atan2(double y, double x)
  将矩形坐标 (x, y) 转换成极坐标 (r, theta)，返回所得角 theta。
  static double cbrt(double a)
  返回 double 值的立方根。
  static double ceil(double a)
  返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。
  static double copySign(double magnitude, double sign)
  返回带有第二个浮点参数符号的第一个浮点参数。
  static float copySign(float magnitude, float sign)
  返回带有第二个浮点参数符号的第一个浮点参数。
  static double cos(double a)
  返回角的三角余弦。
  static double cosh(double x)
  返回 double 值的双曲线余弦。
  static double exp(double a)
  返回欧拉数 e 的 double 次幂的值。
  static double expm1(double x)
  返回 ex -1。
  static double floor(double a)
  返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。
  static int getExponent(double d)
  返回 double 表示形式中使用的无偏指数。
  static int getExponent(float f)
  返回 float 表示形式中使用的无偏指数。
  static double hypot(double x, double y)
  返回 sqrt(x2 +y2)，没有中间溢出或下溢。
  static double IEEEremainder(double f1, double f2)
  按照 IEEE 754 标准的规定，对两个参数进行余数运算。
  static double log(double a)
  返回 double 值的自然对数（底数是 e）。
  static double log10(double a)
  返回 double 值的底数为 10 的对数。
  static double log1p(double x)
  返回参数与 1 之和的自然对数。
  static double max(double a, double b)
  返回两个 double 值中较大的一个。
  static float max(float a, float b)
  返回两个 float 值中较大的一个。
  static int max(int a, int b)
  返回两个 int 值中较大的一个。
  static long max(long a, long b)
  返回两个 long 值中较大的一个。
  static double min(double a, double b)
  返回两个 double 值中较小的一个。
  static float min(float a, float b)
  返回两个 float 值中较小的一个。
  static int min(int a, int b)
  返回两个 int 值中较小的一个。
  static long min(long a, long b)
  返回两个 long 值中较小的一个。
  static double nextAfter(double start, double direction)
  返回第一个参数和第二个参数之间与第一个参数相邻的浮点数。
  static float nextAfter(float start, double direction)
  返回第一个参数和第二个参数之间与第一个参数相邻的浮点数。
  static double nextUp(double d)
  返回 d 和正无穷大之间与 d 相邻的浮点值。
  static float nextUp(float f)
  返回 f 和正无穷大之间与 f 相邻的浮点值。
  static double pow(double a, double b)
  返回第一个参数的第二个参数次幂的值。
  static double random()
  返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
  static double rint(double a)
  返回最接近参数并等于某一整数的 double 值。
  static long round(double a)
  返回最接近参数的 long。
  static int round(float a)
  返回最接近参数的 int。
  static double scalb(double d, int scaleFactor)
  返回 d × 2scaleFactor，其舍入方式如同将一个正确舍入的浮点值乘以 double 值集合中的一个值。
  static float scalb(float f, int scaleFactor)
  返回 f × 2scaleFactor，其舍入方式如同将一个正确舍入的浮点值乘以 float 值集合中的一个值。
  static double signum(double d)
  返回参数的符号函数；如果参数为 0，则返回 0；如果参数大于 0，则返回 1.0；如果参数小于 0，则返回 -1.0。
  static float signum(float f)
  返回参数的符号函数；如果参数为 0，则返回 0；如果参数大于 0，则返回 1.0；如果参数小于 0，则返回 -1.0。
  static double sin(double a)
  返回角的三角正弦。
  static double sinh(double x)
  返回 double 值的双曲线正弦。
  static double sqrt(double a)
  返回正确舍入的 double 值的正平方根。
  static double tan(double a)
  返回角的三角正切。
  static double tanh(double x)
  返回 double 值的双曲线余弦。
  static double toDegrees(double angrad)
  将用弧度表示的角转换为近似相等的用角度表示的角。
  static double toRadians(double angdeg)
  将用角度表示的角转换为近似相等的用弧度表示的角。
  static double ulp(double d)
  返回参数的 ulp 大小。
  static float ulp(float f)
  返回参数的 ulp 大小。

Date类

java.lang.Object
继承者 java.util.Date
public class Date
extends Object
implements Serializable, Cloneable, Comparable<Date>

• 类
  java.util.Date
• 构造方法
  Date()
  分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
  Date(long date)
  分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
• 成员方法
  after(Date when)
  测试此日期是否在指定日期之后。
  boolean before(Date when)
  测试此日期是否在指定日期之前。
  Object clone()
  返回此对象的副本。
  int compareTo(Date anotherDate)
  比较两个日期的顺序。
  boolean equals(Object obj)
  比较两个日期的相等性。
  long getTime()
  返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
  hashCode()
  返回此对象的哈希码值。
  toString()
  把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。

DateFormat类

java.text.DateFormat
由于DateFormat为抽象类，不能直接使用，所以需要常用的子类java.text.SimpleDateFormat

在这里插入图片描述

public String format(Date date)：将Date对象格式化为字符串。
public Date parse(String source)：将字符串解析为Date对象。

继承

is-a关系

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。
优点：

1. 提高代码的复用性。
2. 类与类之间产生了关系，是多态的前提。

成员变量：
访问重名变量使用super关键字
封装提供getter setter方法
成员方法：
访问重名父类方法需要使用SUPER关键字
调用本类重名方法为重写（Override）
方法重写 ：子类中出现与父类一模一样的方法时 （返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。
注意事项：

1. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
2. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。

父类空间优于子类对象的产生
super ：代表父类的存储空间标识(可以理解为父亲的引用)。
this ：代表当前对象的引用(谁调用就代表谁)。

子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。 super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

继承的特点
1、Java中支持单继承
2、Java支持多层继承
3、子类和父类是一种相对的概念

Calendar类

java.lang.Object
继承者 java.util.Calendar
public abstract class Calendar
extends Object
implements Serializable, Cloneable, Comparable<Calendar>

java.util.Calendar日历类

在这里插入图片描述

public int get(int field)：返回给定日历字段的值。
public void set(int field, int value)：将给定的日历字段设置为给定值。
public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。

System类

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：
public static long currentTimeMillis()：返回以毫秒为单位的当前时间。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

StringBuilder类

StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。
public StringBuilder()：构造一个空的StringBuilder容器。
public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去。

public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
public String toString()：将当前StringBuilder对象转换为String对象。

一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。

StringBuffer类

线程安全的可变字符序列。
一个类似于 String 的字符串缓冲区，但不能修改。

抽象类

我们把没有方法主体的方法称为抽象方法。
Java语法规定，包含抽象方法的类就是抽象类。
抽象方法 ： 没有方法体的方法。
抽象类：包含抽象方法的类。
继承抽象类的子类必须重写父类所有的抽象方法
此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象

接口

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。

抽象方法：使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。
默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。
静态方法：使用 static 修饰，供接口直接调用。
私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。

非抽象子类实现接口：

1. 必须重写接口中所有抽象方法。
2. 继承了接口的默认方法，即可以直接调用，也可以重写。
   抽象方法：
   子类必须全部实现
   默认方法：
   可以继承可以重写，但是只能通过实现类的对象来调用
   静态方法：
   静态和.class文件相关，只能使用接口名进行调用，不可以通过实现类的类名或者实现类的对象进行调用
   私有方法：
   只有默认方法可以调用
   私有静态方法：
   默认方法和静态方法可以调用

接口的多实现

接口中有多个抽象方法的时候，实现类必须重写所有的抽象方法，如果抽象方法存在重名，只需要重写一次
接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。
接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

优先级的问题
当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。

接口的多继承

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次。

子接口重写默认方法时，default关键字可以保留。子类重写默认方法时，default关键字不可以保留。

接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
接口中，没有构造方法，不能创建对象。
接口中，没有静态代码块。

多态

指同一行为，具有多个不同的表现形式
1、继承或者实现
2、方法的重写
3、父类应用指向子类对象
当使用多态调用方法的时候，首先检查父类中是否有该方法，如果没有，则编译错误，如果有执行的是子类重写后的方法

多态具有良好的扩展性：

应用类型转换

向上转型：
多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转型。
向下转型：
父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
多态带来的麻烦：
需要调用子类中的特有的方法必须使用向下转型
instanceof给引用变量做类型的校验，适用于在向下转型的时候先做一次判断，防止ClassCastException异常

final关键字

final： 不可改变。可以用于修饰类、方法和变量。
类：被修饰的类，不能被继承。
方法：被修饰的方法，不能被重写。
变量：被修饰的变量，不能被重新赋值。

修饰变量：
局部变量-基本类型：
基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。
局部变量-引用类型：
引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改

成员变量：

• 显示初始化
• 构造方法初始化

权限修饰符

public：公共的。
protected：受保护的
default：默认的
private：私有的

在这里插入图片描述

内部类

将一个类A定义在另一个类B中，里面那个类A就称为内部类，B称为外部类

成员内部类

定义在类中方法外的类

• 内部类可以直接访问外部类的成员，包括私有成员。
• 外部类要访问内部类的成员，必须要建立内部类的对象。
  内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号
  创建内部类对象格式：
  外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

匿名内部类

是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。
开发中，最常用到的内部类就是匿名内部类了。

包装类

在这里插入图片描述
装箱：从基本类型转换为对应的包装类对象。
拆箱：从包装类对象转换为对应的基本类型。
从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。

Collection集合

集合：集合是java中提供的一种容器，可以用来存储多个数据。
数组的长度是固定的。集合的长度是可变的。
数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。

• 单列集合java.util.Collection
• 双列集合java.util.Map

• 单列集合java.util.Collection

•   java.util.List：元素有序、元素可重复
  

•       java.util.ArrayList
        java.util.LinkedList
  

•   java.util.Set：元素无序，而且不可重复
        java.util.HashSet
        java.util.TreeSet
  

Collection常用功能：
public boolean add(E e)： 把给定的对象添加到当前集合中 。
public void clear() :清空集合中所有的元素。
public boolean remove(E e): 把给定的对象在当前集合中删除。
public boolean contains(E e): 判断当前集合中是否包含给定的对象。
public boolean isEmpty(): 判断当前集合是否为空。
public int size(): 返回集合中元素的个数。
public Object[] toArray(): 把集合中的元素，存储到数组中。

Iterator迭代器

迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

public E next():返回迭代的下一个元素。
public boolean hasNext():如果仍有元素可以迭代，则返回 true。
tips:：在进行集合元素取出时，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会发生java.util.NoSuchElementException没有集合元素的错误。

原理：
在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历。

增强for循环

增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
仅仅作为遍历操作

可变参数

修饰符 返回值类型 方法名(参数类型... 形参名){ }
同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。
不可变参数只能存在一个，且要卸载一个方法参数列表中的末尾

泛型

一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。
集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。
泛型是数据类型的一部分，我们将类名与泛型合并一起看做数据类型。

泛型E
自定义的泛型类
修饰符 class 类名<代表泛型的变量> { }
含有泛型的方法
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }
含有泛型的接口
修饰符 interface接口名<代表泛型的变量> { }

泛型通配符
当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

受限泛型
泛型的上限：
格式： 类型名称 <? extends 类 > 对象名称
意义： 只能接收该类型及其子类
泛型的下限：

格式： 类型名称 <? super 类 > 对象名称
意义： 只能接收该类型及其父类型

List集合

public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
public E get(int index) :返回集合中指定位置的元素。
public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

ArrayList集合
LinkdedList集合
public void addFirst(E e) :将指定元素插入此列表的开头。
public void addLast(E e) :将指定元素添加到此列表的结尾。
public E getFirst() :返回此列表的第一个元素。
public E getLast() :返回此列表的最后一个元素。
public E removeFirst() :移除并返回此列表的第一个元素。
public E removeLast() :移除并返回此列表的最后一个元素。
public E pop() :从此列表所表示的堆栈处弹出一个元素。
public void push(E e) :将元素推入此列表所表示的堆栈。
public boolean isEmpty() ：如果列表不包含元素，则返回true。

Set接口

HashSet集合
哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的
LinkedHashSet集合

Collections类

java.util.Collections

public static <T> boolean addAll(Collection<T> c, T... elements) :往集合中添加一些元素。
public static void shuffle(List<?> list) 打乱顺序 :打乱集合顺序。
public static <T> void sort(List<T> list) :将集合中元素按照默认规则排序。
public static <T> void sort(List<T> list，Comparator<? super T> ) :将集合中元素按照指定规则排序。

比较形式

Java提供两种比较形式：
java.lang.Comparable;
java.util.Comparator;

• Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
• Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

方法内部调用new Comparator（）
两个对象比较的结果有三种：大于，等于，小于。
如果要按照升序排序， 则o1 小于o2，返回（负数），相等返回0，01大于02返回（正数） 如果要按照降序排序 则o1 小于o2，返回（正数），相等返回0，01大于02返回（负数）
直接在函数中写匿名内部类

Map集合

public V put(K key, V value) : 把指定的键与指定的值添加到Map集合中。
public V remove(Object key) : 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
public Set<K> keySet() : 获取Map集合中所有的键，存储到Set集合中。
public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。

public K getKey() ：获取Entry对象中的键。
public V getValue() ：获取Entry对象中的值。

HashMap集合

数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

LinkedHashMap集合

ashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

JDK9对集合添加的优化

使用与创建少量的元素：
1:.of()方法只是Map，List，Set这三个接口的静态方法，其父类接口和子类实现并没有这类方法，比如HashSet，ArrayList等待；
2:返回的集合是不可变的；