关于java:基础2

在计算机程序运行的过程中，总是会呈现各种各样的谬误。

有一些谬误是用户造成的，比方，心愿用户输出一个 int 类型的年龄，然而用户的输出是abc：

// 假如用户输出了 abc：String s = "abc";
int n = Integer.parseInt(s); // NumberFormatException!

程序想要读写某个文件的内容，然而用户曾经把它删除了：

// 用户删除了该文件：String t = readFile("C:\\abc.txt"); // FileNotFoundException!

Java 内置了一套异样解决机制，总是应用异样来示意谬误。

异样是一种class，因而它自身带有类型信息。异样能够在任何中央抛出，但只须要在下层捕捉，这样就和办法调用拆散了：

try {String s = processFile(“C:\\test.txt”);
    // ok:
} catch (FileNotFoundException e) {// file not found:} catch (SecurityException e) {// no read permission:} catch (IOException e) {// io error:} catch (Exception e) {// other error:}

因为 Java 的异样是class，它的继承关系如下：

                     ┌───────────┐
                     │  Object   │
                     └───────────┘
                           ▲
                           │
                     ┌───────────┐
                     │ Throwable │
                     └───────────┘
                           ▲
                 ┌─────────┴─────────┐
                 │                   │
           ┌───────────┐       ┌───────────┐
           │   Error   │       │ Exception │
           └───────────┘       └───────────┘
                 ▲                   ▲
         ┌───────┘              ┌────┴──────────┐
         │                      │               │
┌─────────────────┐    ┌─────────────────┐┌───────────┐
│OutOfMemoryError │... │RuntimeException ││IOException│...
└─────────────────┘    └─────────────────┘└───────────┘
                                ▲
                    ┌───────────┴─────────────┐
                    │                         │
         ┌─────────────────────┐ ┌─────────────────────────┐
         │NullPointerException │ │IllegalArgumentException │...
         └─────────────────────┘ └─────────────────────────┘

从继承关系可知：Throwable是异样体系的根，它继承自 Object。Throwable 有两个体系：Error和 Exception，Error 示意重大的谬误，程序对此个别无能为力，例如：

OutOfMemoryError：内存耗尽
NoClassDefFoundError：无奈加载某个 Class
StackOverflowError：栈溢出

而 Exception 则是运行时的谬误，它能够被捕捉并解决。

某些异样是利用程序逻辑解决的一部分，应该捕捉并解决。例如：

NumberFormatException：数值类型的格局谬误
FileNotFoundException：未找到文件
SocketException：读取网络失败

还有一些异样是程序逻辑编写不对造成的，应该修复程序自身。例如：

NullPointerException：对某个 null 的对象调用办法或字段
IndexOutOfBoundsException：数组索引越界

Exception又分为两大类：

RuntimeException以及它的子类；
非 RuntimeException（包含IOException、ReflectiveOperationException 等等）

Java 规定：

必须捕捉的异样，包含 Exception 及其子类，但不包含 RuntimeException 及其子类，这种类型的异样称为 Checked Exception。
不须要捕捉的异样，包含 Error 及其子类，RuntimeException及其子类。

捕捉异样应用 try...catch 语句，把可能产生异样的代码放到 try {...} 中，而后应用 catch 捕捉对应的 Exception 及其子类

public class Main {public static void main(String[] args) {byte[] bs = toGBK("中文");
        System.out.println(Arrays.toString(bs));
    }

    static byte[] toGBK(String s) {
        try {// 用指定编码转换 String 为 byte[]:
            return s.getBytes("GBK");
        } catch (UnsupportedEncodingException e) {
            // 如果零碎不反对 GBK 编码，会捕捉到 UnsupportedEncodingException:
            System.out.println(e); // 打印异样信息
            return s.getBytes(); // 尝试应用用默认编码}
    }
}

如果咱们不捕捉UnsupportedEncodingException，会呈现编译失败的问题

编译器会报错，错误信息相似：unreported exception UnsupportedEncodingException; must be caught or declared to be thrown，并且精确地指出须要捕捉的语句是 return s.getBytes("GBK");。意思是说，像UnsupportedEncodingException 这样的 Checked Exception，必须被捕捉。

这是因为 String.getBytes(String) 办法定义是：

public byte[] getBytes(String charsetName) throws UnsupportedEncodingException {...}

在办法定义的时候，应用 throws Xxx 示意该办法可能抛出的异样类型。调用方在调用的时候，必须强制捕捉这些异样，否则编译器会报错。

Java 应用异样来示意谬误，并通过 try ... catch 捕捉异样；

Java 的异样是 class，并且从Throwable 继承；

Error是无需捕捉的严重错误，Exception是应该捕捉的可解决的谬误；

RuntimeException无需强制捕捉，非 RuntimeException（Checked Exception）需强制捕捉，或者用throws 申明；

不举荐捕捉了异样但不进行任何解决。

在 Java 中，但凡可能抛出异样的语句，都能够用 try ... catch 捕捉。把可能产生异样的语句放在 try {...} 中，而后应用 catch 捕捉对应的 Exception 及其子类。

能够应用多个 catch 语句，每个 catch 别离捕捉对应的 Exception 及其子类。JVM 在捕捉到异样后，会从上到下匹配 catch 语句，匹配到某个 catch 后，执行 catch 代码块，而后_不再_持续匹配。

简略地说就是：多个 catch 语句只有一个能被执行。例如：

public static void main(String[] args) {
    try {process1();
        process2();
        process3();} catch (IOException e) {System.out.println(e);
    } catch (NumberFormatException e) {System.out.println(e);
    }
}

存在多个 catch 的时候，catch的程序十分重要：子类必须写在后面。例如：

public static void main(String[] args) {
    try {process1();
        process2();
        process3();} catch (IOException e) {System.out.println("IO error");
    } catch (UnsupportedEncodingException e) { // 永远捕捉不到
        System.out.println("Bad encoding");
    }
}

对于下面的代码，UnsupportedEncodingException异样是永远捕捉不到的，因为它是 IOException 的子类。当抛出 UnsupportedEncodingException 异样时，会被 catch (IOException e) {...} 捕捉并执行。

finally语句块保障有无谬误都会执行。上述代码能够改写如下：

public static void main(String[] args) {
    try {process1();
        process2();
        process3();} catch (UnsupportedEncodingException e) {System.out.println("Bad encoding");
    } catch (IOException e) {System.out.println("IO error");
    } finally {System.out.println("END");
    }
}

当某个办法抛出了异样时，如果以后办法没有捕捉异样，异样就会被抛到下层调用办法，直到遇到某个 try ... catch 被捕捉为止：

public class Main {public static void main(String[] args) {
        try {process1();
        } catch (Exception e) {e.printStackTrace();
        }
    }

    static void process1() {process2();
    }

    static void process2() {Integer.parseInt(null); // 会抛出 NumberFormatException
    }
}

通过 printStackTrace() 能够打印出办法的调用栈，相似：

java.lang.NumberFormatException: null
    at java.base/java.lang.Integer.parseInt(Integer.java:614)
    at java.base/java.lang.Integer.parseInt(Integer.java:770)
    at Main.process2(Main.java:16)
    at Main.process1(Main.java:12)
    at Main.main(Main.java:5)

printStackTrace()对于调试谬误十分有用，上述信息示意：NumberFormatException是在 java.lang.Integer.parseInt 办法中被抛出的，从下往上看，调用档次顺次是：

main()调用process1()；
process1()调用process2()；
process2()调用Integer.parseInt(String)；
Integer.parseInt(String)调用Integer.parseInt(String, int)。

查看 Integer.java 源码可知，抛出异样的办法代码如下：

public static int parseInt(String s, int radix) throws NumberFormatException {if (s == null) {throw new NumberFormatException("null");
    }
    ...
}

并且，每层调用均给出了源代码的行号，可间接定位。

当产生谬误时，例如，用户输出了非法的字符，咱们就能够抛出异样。

如何抛出异样？参考 Integer.parseInt() 办法，抛出异样分两步：

创立某个 Exception 的实例；
用 throw 语句抛出。

上面是一个例子：

void process2(String s) {if (s==null) {NullPointerException e = new NullPointerException();
        throw e;
    }
}

实际上，绝大部分抛出异样的代码都会合并写成一行：

void process2(String s) {if (s==null) {throw new NullPointerException();
    }
}

如果一个办法捕捉了某个异样后，又在 catch 子句中抛出新的异样，就相当于把抛出的异样类型“转换”了：

void process1(String s) {
    try {process2();
    } catch (NullPointerException e) {throw new IllegalArgumentException();
    }
}

void process2(String s) {if (s==null) {throw new NullPointerException();
    }
}

Java 规范库定义的罕用异样包含：

Exception
│
├─ RuntimeException
│  │
│  ├─ NullPointerException
│  │
│  ├─ IndexOutOfBoundsException
│  │
│  ├─ SecurityException
│  │
│  └─ IllegalArgumentException
│     │
│     └─ NumberFormatException
│
├─ IOException
│  │
│  ├─ UnsupportedCharsetException
│  │
│  ├─ FileNotFoundException
│  │
│  └─ SocketException
│
├─ ParseException
│
├─ GeneralSecurityException
│
├─ SQLException
│
└─ TimeoutException

当咱们在代码中须要抛出异样时，尽量应用 JDK 已定义的异样类型。例如，参数查看不非法，应该抛出IllegalArgumentException：

static void process1(int age) {if (age <= 0) {throw new IllegalArgumentException();
    }
}

在一个大型项目中，能够自定义新的异样类型，然而，放弃一个正当的异样继承体系是十分重要的。

一个常见的做法是自定义一个 BaseException 作为“根异样”，而后，派生出各种业务类型的异样。

BaseException须要从一个适宜的 Exception 派生，通常倡议从 RuntimeException 派生：

public class BaseException extends RuntimeException {}

其余业务类型的异样就能够从 BaseException 派生：

public class UserNotFoundException extends BaseException {
}

public class LoginFailedException extends BaseException {
}

...

自定义的 BaseException 应该提供多个构造方法：

public class BaseException extends RuntimeException {public BaseException() {super();
    }

    public BaseException(String message, Throwable cause) {super(message, cause);
    }

    public BaseException(String message) {super(message);
    }

    public BaseException(Throwable cause) {super(cause);
    }
}

上述构造方法实际上都是原样照抄RuntimeException。这样，抛出异样的时候，就能够抉择适合的构造方法。通过 IDE 能够依据父类疾速生成子类的构造方法。

抛出异样时，尽量复用 JDK 已定义的异样类型；

自定义异样体系时，举荐从 RuntimeException 派生“根异样”，再派生出业务异样；

自定义异样时，应该提供多种构造方法。

在所有的 RuntimeException 异样中，Java 程序员最相熟的恐怕就是 NullPointerException 了。

NullPointerException即空指针异样，俗称 NPE。如果一个对象为null，调用其办法或拜访其字段就会产生NullPointerException，这个异样通常是由 JVM 抛出的，例如：

public class Main {public static void main(String[] args) {
        String s = null;
        System.out.println(s.toLowerCase());
    }
}

指针这个概念实际上源自 C 语言，Java 语言中并无指针。咱们定义的变量实际上是援用，Null Pointer 更确切地说是 Null Reference，不过两者区别不大。

如果遇到 NullPointerException，咱们应该如何解决？首先，必须明确，NullPointerException 是一种代码逻辑谬误，遇到 NullPointerException，遵循原则是早裸露，早修复，严禁应用catch 来暗藏这种编码谬误：

// 谬误示例: 捕捉 NullPointerException
try {transferMoney(from, to, amount);
} catch (NullPointerException e) {}

好的编码习惯能够极大地升高 NullPointerException 的产生，例如：

成员变量在定义时初始化：

public class Person {private String name = "";}

应用空字符串 "" 而不是默认的 null 可防止很多 NullPointerException，编写业务逻辑时，用空字符串"" 示意未填写比 null 平安得多。

返回空字符串""、空数组而不是null：

public String[] readLinesFromFile(String file) {if (getFileSize(file) == 0) {
        // 返回空数组而不是 null:
        return new String[0];
    }
    ...
}

这样能够使得调用方无需查看后果是否为null。

断言（Assertion）是一种调试程序的形式。在 Java 中，应用 assert 关键字来实现断言。

咱们先看一个例子：

public static void main(String[] args) {double x = Math.abs(-123.45);
    assert x >= 0;
    System.out.println(x);
}

语句 assert x >= 0; 即为断言，断言条件 x >= 0 预期为true。如果计算结果为false，则断言失败，抛出AssertionError。

应用 assert 语句时，还能够增加一个可选的断言音讯：

assert x >= 0 : "x must >= 0";

这样，断言失败的时候，AssertionError会带上音讯x must >= 0，更加便于调试。

Java 断言的特点是：断言失败时会抛出AssertionError，导致程序完结退出。因而，断言不能用于可复原的程序谬误，只应该用于开发和测试阶段。

对于可复原的程序谬误，不应该应用断言。例如：

void sort(int[] arr) {assert arr != null;}

应该抛出异样并在下层捕捉：

void sort(int[] arr) {if (x == null) {throw new IllegalArgumentException("array cannot be null");
    }
}

断言是一种调试形式，断言失败会抛出AssertionError，只能在开发和测试阶段启用断言；

对可复原的谬误不能应用断言，而应该抛出异样；

断言很少被应用，更好的办法是编写单元测试。

在编写程序的过程中，发现程序运行后果与预期不符，怎么办？当然是用 System.out.println() 打印出执行过程中的某些变量，察看每一步的后果与代码逻辑是否合乎，而后有针对性地批改代码。

代码改好了怎么办？当然是删除没有用的 System.out.println() 语句了。

如果改代码又改出问题怎么办？再加上System.out.println()。

重复这么搞几次，很快大家就发现应用 System.out.println() 十分麻烦。

怎么办？

解决办法是应用日志。

那什么是日志？日志就是 Logging，它的目标是为了取代System.out.println()。

输入日志，而不是用System.out.println()，有以下几个益处：

能够设置输入款式，防止本人每次都写"ERROR:" + var；
能够设置输入级别，禁止某些级别输入。例如，只输入谬误日志；
能够被重定向到文件，这样能够在程序运行完结后查看日志；
能够按包名管制日志级别，只输入某些包打的日志；
能够……

因为 Java 规范库内置了日志包java.util.logging，咱们能够间接用。先看一个简略的例子：

public class Hello {public static void main(String[] args) {Logger logger = Logger.getGlobal();
        logger.info("start process...");
        logger.warning("memory is running out...");
        logger.fine("ignored.");
        logger.severe("process will be terminated...");
    }
}

运行上述代码，失去相似如下的输入：

Mar 02, 2019 6:32:13 PM Hello main
INFO: start process...
Mar 02, 2019 6:32:13 PM Hello main
WARNING: memory is running out...
Mar 02, 2019 6:32:13 PM Hello main
SEVERE: process will be terminated...

比照可见，应用日志最大的益处是，它主动打印了工夫、调用类、调用办法等很多有用的信息。

再仔细观察发现，4 条日志，只打印了 3 条，logger.fine()没有打印。这是因为，日志的输入能够设定级别。JDK 的 Logging 定义了 7 个日志级别，从重大到一般：

SEVERE
WARNING
INFO
CONFIG
FINE
FINER
FINEST

因为默认级别是 INFO，因而，INFO 级别以下的日志，不会被打印进去。应用日志级别的益处在于，调整级别，就能够屏蔽掉很多调试相干的日志输入。

和 Java 规范库提供的日志不同，Commons Logging 是一个第三方日志库，它是由 Apache 创立的日志模块。

Commons Logging 的特色是，它能够挂接不同的日志零碎，并通过配置文件指定挂接的日志零碎。默认状况下，Commons Loggin 主动搜寻并应用 Log4j（Log4j 是另一个风行的日志零碎），如果没有找到 Log4j，再应用 JDK Logging。

什么是反射？

反射就是 Reflection，Java 的反射是指程序在运行期能够拿到一个对象的所有信息。

失常状况下，如果咱们要调用一个对象的办法，或者拜访一个对象的字段，通常会传入对象实例：

// Main.java
import com.itranswarp.learnjava.Person;

public class Main {String getFullName(Person p) {return p.getFirstName() + " " + p.getLastName();}
}

然而，如果不能取得 Person 类，只有一个 Object 实例，比方这样：

String getFullName(Object obj) {return ???}

怎么办？有童鞋会说：强制转型啊！

String getFullName(Object obj) {Person p = (Person) obj;
    return p.getFirstName() + " " + p.getLastName();
}

强制转型的时候，你会发现一个问题：编译下面的代码，依然须要援用 Person 类。不然，去掉 import 语句，你看能不能编译通过？

所以，反射是为了解决在运行期，对某个实例无所不知的状况下，如何调用其办法。

JVM 为每个加载的 class 及interface创立了对应的 Class 实例来保留 class 及interface的所有信息；
获取一个 class 对应的 Class 实例后，就能够获取该 class 的所有信息；
通过 Class 实例获取 class 信息的办法称为反射（Reflection）；
JVM 总是动静加载class，能够在运行期依据条件来管制加载 class。

Java 的反射 API 提供的 Field 类封装了字段的所有信息：
通过 Class 实例的办法能够获取 Field 实例：getField()，getFields()，getDeclaredField()，getDeclaredFields()；
通过 Field 实例能够获取字段信息：getName()，getType()，getModifiers()；
通过 Field 实例能够读取或设置某个对象的字段，如果存在拜访限度，要首先调用 setAccessible(true) 来拜访非 public 字段。
通过反射读写字段是一种非常规办法，它会毁坏对象的封装。

当咱们获取到一个 Method 对象时，就能够对它进行调用。咱们以上面的代码为例：

String s = "Hello world";
String r = s.substring(6); // "world"

如果用反射来调用 substring 办法，须要以下代码：

 // String 对象:
String s = "Hello world";
// 获取 String substring(int)办法，参数为 int:
Method m = String.class.getMethod("substring", int.class);
// 在 s 对象上调用该办法并获取后果:
String r = (String) m.invoke(s, 6);
// 打印调用后果:
System.out.println(r);

Java 的反射 API 提供的 Method 对象封装了办法的所有信息：
通过 Class 实例的办法能够获取 Method 实例：getMethod()，getMethods()，getDeclaredMethod()，getDeclaredMethods()；
通过 Method 实例能够获取办法信息：getName()，getReturnType()，getParameterTypes()，getModifiers()；
通过 Method 实例能够调用某个对象的办法：Object invoke(Object instance, Object... parameters)；
通过设置 setAccessible(true) 来拜访非 public 办法；
通过反射调用办法时，依然遵循多态准则。

咱们通常应用 new 操作符创立新的实例：

Person p = new Person();

如果通过反射来创立新的实例，能够调用 Class 提供的 newInstance()办法：

Person p = Person.class.newInstance();

Constructor对象封装了构造方法的所有信息；

通过 Class 实例的办法能够获取 Constructor 实例：getConstructor()，getConstructors()，getDeclaredConstructor()，getDeclaredConstructors()；

通过 Constructor 实例能够创立一个实例对象：newInstance(Object... parameters)；通过设置 setAccessible(true) 来拜访非 public 构造方法。

注解是放在 Java 源码的类、办法、字段、参数前的一种非凡“正文”：

// this is a component:
@Resource("hello")
public class Hello {
    @Inject
    int n;

    @PostConstruct
    public void hello(@Param String name) {System.out.println(name);
    }

    @Override
    public String toString() {return "Hello";}
}

正文会被编译器间接疏忽，注解则能够被编译器打包进入 class 文件，因而，注解是一种用作标注的“元数据”。

从 JVM 的角度看，注解自身对代码逻辑没有任何影响，如何应用注解齐全由工具决定。

Java 的注解能够分为三类：

第一类是由编译器应用的注解，例如：

@Override：让编译器查看该办法是否正确地实现了覆写；
@SuppressWarnings：通知编译器疏忽此处代码产生的正告。

这类注解不会被编译进入 .class 文件，它们在编译后就被编译器扔掉了。

第二类是由工具解决 .class 文件应用的注解，比方有些工具会在加载 class 的时候，对 class 做动静批改，实现一些非凡的性能。这类注解会被编译进入 .class 文件，但加载完结后并不会存在于内存中。这类注解只被一些底层库应用，个别咱们不用本人解决。

第三类是在程序运行期可能读取的注解，它们在加载后始终存在于 JVM 中，这也是最罕用的注解。例如，一个配置了 @PostConstruct 的办法会在调用构造方法后主动被调用（这是 Java 代码读取该注解实现的性能，JVM 并不会辨认该注解）。

定义一个注解时，还能够定义配置参数。配置参数能够包含：

所有根本类型；
String；
枚举类型；
根本类型、String、Class 以及枚举的数组。

因为配置参数必须是常量，所以，上述限度保障了注解在定义时就曾经确定了每个参数的值。

注解的配置参数能够有默认值，短少某个配置参数时将应用默认值。

此外，大部分注解会有一个名为 value 的配置参数，对此参数赋值，能够只写常量，相当于省略了 value 参数。

如果只写注解，相当于全副应用默认值。

举个栗子，对以下代码：

public class Hello {@Check(min=0, max=100, value=55)
    public int n;

    @Check(value=99)
    public int p;

    @Check(99) // @Check(value=99)
    public int x;

    @Check
    public int y;
}

@Check就是一个注解。第一个 @Check(min=0, max=100, value=55) 明确定义了三个参数，第二个 @Check(value=99) 只定义了一个 value 参数，它实际上和 @Check(99) 是齐全一样的。最初一个 @Check 示意所有参数都应用默认值。

注解（Annotation）是 Java 语言用于工具解决的标注：

注解能够配置参数，没有指定配置的参数应用默认值；

如果参数名称是value，且只有一个参数，那么能够省略参数名称。

Java 语言应用 @interface 语法来定义注解（Annotation），它的格局如下：

public @interface Report {int type() default 0;
    String level() default "info";
    String value() default "";}

注解的参数相似无参数办法，能够用 default 设定一个默认值（强烈推荐）。最罕用的参数该当命名为value。

有一些注解能够润饰其余注解，这些注解就称为元注解（meta annotation）。Java 规范库曾经定义了一些元注解，咱们只须要应用元注解，通常不须要本人去编写元注解。

最罕用的元注解是 @Target。应用@Target 能够定义 Annotation 可能被利用于源码的哪些地位：

类或接口：ElementType.TYPE；
字段：ElementType.FIELD；
办法：ElementType.METHOD；
构造方法：ElementType.CONSTRUCTOR；
办法参数：ElementType.PARAMETER。

例如，定义注解 @Report 可用在办法上，咱们必须增加一个@Target(ElementType.METHOD)：

@Target(ElementType.METHOD)
public @interface Report {int type() default 0;
    String level() default "info";
    String value() default "";}

定义注解 @Report 可用在办法或字段上，能够把 @Target 注解参数变为数组{ElementType.METHOD, ElementType.FIELD}：

@Target({
    ElementType.METHOD,
    ElementType.FIELD
})
public @interface Report {...}

实际上 @Target 定义的 value 是ElementType[]数组，只有一个元素时，能够省略数组的写法。

另一个重要的元注解 @Retention 定义了 Annotation 的生命周期：

仅编译期：RetentionPolicy.SOURCE；
仅 class 文件：RetentionPolicy.CLASS；
运行期：RetentionPolicy.RUNTIME。

如果 @Retention 不存在，则该 Annotation 默认为 CLASS。因为通常咱们自定义的Annotation 都是 RUNTIME，所以，务必要加上@Retention(RetentionPolicy.RUNTIME) 这个元注解：

@Retention(RetentionPolicy.RUNTIME)
public @interface Report {int type() default 0;
    String level() default "info";
    String value() default "";}

应用 @Repeatable 这个元注解能够定义 Annotation 是否可反复。这个注解利用不是特地宽泛。

应用 @Inherited 定义子类是否可继承父类定义的 Annotation。@Inherited 仅针对 @Target(ElementType.TYPE) 类型的 annotation 无效，并且仅针对 class 的继承，对 interface 的继承有效：

@Inherited
@Target(ElementType.TYPE)
public @interface Report {int type() default 0;
    String level() default "info";
    String value() default "";}

在应用的时候，如果一个类用到了@Report：

@Report(type=1)
public class Person {}

则它的子类默认也定义了该注解：

public class Student extends Person {}

咱们总结一下定义 Annotation 的步骤：

第一步，用 @interface 定义注解：

public @interface Report {}

第二步，增加参数、默认值：

public @interface Report {int type() default 0;
    String level() default "info";
    String value() default "";}

把最罕用的参数定义为value()，举荐所有参数都尽量设置默认值。

第三步，用元注解配置注解：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Report {int type() default 0;
    String level() default "info";
    String value() default "";}

其中，必须设置 @Target 和@Retention，@Retention个别设置为 RUNTIME，因为咱们自定义的注解通常要求在运行期读取。个别状况下，不用写@Inherited 和@Repeatable。

Java 应用 @interface 定义注解：

可定义多个参数和默认值，外围参数应用 value 名称；

必须设置 @Target 来指定 Annotation 能够利用的范畴；

该当设置 @Retention(RetentionPolicy.RUNTIME) 便于运行期读取该Annotation。

能够在运行期通过反射读取 RUNTIME 类型的注解，留神千万不要漏写@Retention(RetentionPolicy.RUNTIME)，否则运行期无奈读取到该注解。

能够通过程序处理注解来实现相应的性能：

对 JavaBean 的属性值按规定进行查看；
JUnit 会主动运行 @Test 标记的测试方法。

注解如何应用，齐全由程序本人决定。例如，JUnit 是一个测试框架，它会主动运行所有标记为 @Test 的办法。

咱们来看一个 @Range 注解，咱们心愿用它来定义一个 String 字段的规定：字段长度满足 @Range 的参数定义：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Range {int min() default 0;
    int max() default 255;}

在某个 JavaBean 中，咱们能够应用该注解：

public class Person {@Range(min=1, max=20)
    public String name;

    @Range(max=10)
    public String city;
}

然而，定义了注解，自身对程序逻辑没有任何影响。咱们必须本人编写代码来应用注解。这里，咱们编写一个 Person 实例的查看办法，它能够查看 Person 实例的 String 字段长度是否满足 @Range 的定义：

void check(Person person) throws IllegalArgumentException, ReflectiveOperationException {
    // 遍历所有 Field:
    for (Field field : person.getClass().getFields()) {
        // 获取 Field 定义的 @Range:
        Range range = field.getAnnotation(Range.class);
        // 如果 @Range 存在:
        if (range != null) {
            // 获取 Field 的值:
            Object value = field.get(person);
            // 如果值是 String:
            if (value instanceof String) {String s = (String) value;
                // 判断值是否满足 @Range 的 min/max:
                if (s.length() < range.min() || s.length() > range.max()) {throw new IllegalArgumentException("Invalid field:" + field.getName());
                }
            }
        }
    }
}

这样一来，咱们通过 @Range 注解，配合 check() 办法，就能够实现 Person 实例的查看。留神查看逻辑齐全是咱们本人编写的，JVM 不会主动给注解增加任何额定的逻辑。

泛型是一种“代码模板”，能够用一套代码套用各种类型。

在解说什么是泛型之前，咱们先察看 Java 规范库提供的ArrayList，它能够看作“可变长度”的数组，因为用起来比数组更不便。

实际上 ArrayList 外部就是一个 Object[] 数组，配合存储一个以后调配的长度，就能够充当“可变数组”：

public class ArrayList {private Object[] array;
    private int size;
    public void add(Object e) {...}
    public void remove(int index) {...}
    public Object get(int index) {...}
}

如果用上述 ArrayList 存储 String 类型，会有这么几个毛病：

须要强制转型；
不不便，易出错。

例如，代码必须这么写：

ArrayList list = new ArrayList();
list.add("Hello");
// 获取到 Object，必须强制转型为 String:
String first = (String) list.get(0);

很容易呈现 ClassCastException，因为容易“误转型”：

list.add(new Integer(123));
// ERROR: ClassCastException:
String second = (String) list.get(1);

要解决上述问题，咱们能够为 String 独自编写一种ArrayList：

public class StringArrayList {private String[] array;
    private int size;
    public void add(String e) {...}
    public void remove(int index) {...}
    public String get(int index) {...}
}

这样一来，存入的必须是String，取出的也肯定是String，不须要强制转型，因为编译器会强制查看放入的类型：

StringArrayList list = new StringArrayList();
list.add("Hello");
String first = list.get(0);
// 编译谬误: 不容许放入非 String 类型:
list.add(new Integer(123));

问题临时解决。

然而，新的问题是，如果要存储 Integer，还须要为Integer 独自编写一种ArrayList：

public class IntegerArrayList {private Integer[] array;
    private int size;
    public void add(Integer e) {...}
    public void remove(int index) {...}
    public Integer get(int index) {...}
}

实际上，还须要为其余所有 class 独自编写一种ArrayList：

LongArrayList
DoubleArrayList
PersonArrayList
…

这是不可能的，JDK 的 class 就有上千个，而且它还不晓得其他人编写的 class。

为了解决新的问题，咱们必须把 ArrayList 变成一种模板：ArrayList<T>，代码如下：

public class ArrayList<T> {private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

T能够是任何 class。这样一来，咱们就实现了：编写一次模版，能够创立任意类型的ArrayList：

// 创立能够存储 String 的 ArrayList:
ArrayList<String> strList = new ArrayList<String>();
// 创立能够存储 Float 的 ArrayList:
ArrayList<Float> floatList = new ArrayList<Float>();
// 创立能够存储 Person 的 ArrayList:
ArrayList<Person> personList = new ArrayList<Person>();

因而，泛型就是定义一种模板，例如ArrayList<T>，而后在代码中为用到的类创立对应的ArrayList< 类型 >：

ArrayList<String> strList = new ArrayList<String>();

由编译器针对类型作查看：

strList.add("hello"); // OK
String s = strList.get(0); // OK
strList.add(new Integer(123)); // compile error!
Integer n = strList.get(0); // compile error!

这样一来，既实现了编写一次，万能匹配，又通过编译器保障了类型平安：这就是泛型。

在 Java 规范库中的 ArrayList<T> 实现了 List<T> 接口，它能够向上转型为List<T>：

public class ArrayList<T> implements List<T> {...}

List<String> list = new ArrayList<String>();

即类型 ArrayList<T> 能够向上转型为List<T>。

要_特地留神_：不能把 ArrayList<Integer> 向上转型为 ArrayList<Number> 或List<Number>。

这是为什么呢？假如 ArrayList<Integer> 能够向上转型为ArrayList<Number>，察看一下代码：

// 创立 ArrayList<Integer> 类型：ArrayList<Integer> integerList = new ArrayList<Integer>();
// 增加一个 Integer：integerList.add(new Integer(123));
//“向上转型”为 ArrayList<Number>：ArrayList<Number> numberList = integerList;
// 增加一个 Float，因为 Float 也是 Number：numberList.add(new Float(12.34));
// 从 ArrayList<Integer> 获取索引为 1 的元素（即增加的 Float）：Integer n = integerList.get(1); // ClassCastException!

咱们把一个 ArrayList<Integer> 转型为 ArrayList<Number> 类型后，这个 ArrayList<Number> 就能够承受 Float 类型，因为 Float 是Number的子类。然而，ArrayList<Number>实际上和 ArrayList<Integer> 是同一个对象，也就是 ArrayList<Integer> 类型，它不可能承受 Float 类型，所以在获取 Integer 的时候将产生ClassCastException。

实际上，编译器为了防止这种谬误，基本就不容许把 ArrayList<Integer> 转型为ArrayList<Number>。

ArrayList<Integer> 和 ArrayList<Number> 两者齐全没有继承关系。

泛型就是编写模板代码来适应任意类型；

泛型的益处是应用时不用对类型进行强制转换，它通过编译器对类型进行查看；

留神泛型的继承关系：能够把 ArrayList<Integer> 向上转型为 List<Integer>（T 不能变！），但不能把 ArrayList<Integer> 向上转型为 ArrayList<Number>（T 不能变成父类）。

应用 ArrayList 时，如果不定义泛型类型时，泛型类型实际上就是Object：

// 编译器正告:
List list = new ArrayList();
list.add("Hello");
list.add("World");
String first = (String) list.get(0);
String second = (String) list.get(1);

此时，只能把 <T> 当作 Object 应用，没有施展泛型的劣势。

当咱们定义泛型类型 <String> 后，List<T>的泛型接口变为强类型List<String>：

// 无编译器正告:
List<String> list = new ArrayList<String>();
list.add("Hello");
list.add("World");
// 无强制转型:
String first = list.get(0);
String second = list.get(1);

当咱们定义泛型类型 <Number> 后，List<T>的泛型接口变为强类型List<Number>：

List<Number> list = new ArrayList<Number>();
list.add(new Integer(123));
list.add(new Double(12.34));
Number first = list.get(0);
Number second = list.get(1);

编译器如果能主动推断出泛型类型，就能够省略前面的泛型类型。例如，对于上面的代码：

List<Number> list = new ArrayList<Number>();

编译器看到泛型类型 List<Number> 就能够主动推断出前面的 ArrayList<T> 的泛型类型必须是ArrayList<Number>，因而，能够把代码简写为：

// 能够省略前面的 Number，编译器能够主动推断泛型类型：List<Number> list = new ArrayList<>();

除了 ArrayList<T> 应用了泛型，还能够在接口中应用泛型。例如，Arrays.sort(Object[])能够对任意数组进行排序，但待排序的元素必须实现 Comparable<T> 这个泛型接口：

public interface Comparable<T> {
    /**
     * 返回正数: 以后实例比参数 o 小
     * 返回 0: 以后实例与参数 o 相等
     * 返回负数: 以后实例比参数 o 大
     */
    int compareTo(T o);
}

应用泛型时，把泛型参数 <T> 替换为须要的 class 类型，例如：ArrayList<String>，ArrayList<Number>等；

能够省略编译器能主动推断出的类型，例如：List<String> list = new ArrayList<>();；

不指定泛型参数类型时，编译器会给出正告，且只能将 <T> 视为 Object 类型；

能够在接口中定义泛型类型，实现此接口的类必须实现正确的泛型类型。

编写泛型类比一般类要简单。通常来说，泛型类个别用在汇合类中，例如ArrayList<T>，咱们很少须要编写泛型类。

如果咱们的确须要编写一个泛型类，那么，应该如何编写它？

能够依照以下步骤来编写一个泛型类。

首先，依照某种类型，例如：String，来编写类：

public class Pair {
    private String first;
    private String last;
    public Pair(String first, String last) {
        this.first = first;
        this.last = last;
    }
    public String getFirst() {return first;}
    public String getLast() {return last;}
}

最初，把特定类型 String 替换为T，并申明<T>：

public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {return first;}
    public T getLast() {return last;}
}

纯熟后即可间接从 T 开始编写。

编写泛型类时，要特地留神，泛型类型 <T> 不能用于静态方法。

泛型还能够定义多种类型。例如，咱们心愿 Pair 不总是存储两个类型一样的对象，就能够应用类型<T, K>：

public class Pair<T, K> {
    private T first;
    private K last;
    public Pair(T first, K last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() { ...}
    public K getLast() { ...}
}

应用的时候，须要指出两种类型：

Pair<String, Integer> p = new Pair<>("test", 123);

Java 规范库的 Map<K, V> 就是应用两种泛型类型的例子。它对 Key 应用一种类型，对 Value 应用另一种类型。

编写泛型时，须要定义泛型类型<T>；

静态方法不能引用泛型类型<T>，必须定义其余类型（例如<K>）来实现动态泛型办法；

泛型能够同时定义多种类型，例如Map<K, V>。

Java 的泛型是由编译器在编译时履行的，编译器外部永远把所有类型 T 视为 Object 解决，然而，在须要转型的时候，编译器会依据 T 的类型主动为咱们履行平安地强制转型。

理解了 Java 泛型的实现形式——擦拭法，咱们就晓得了 Java 泛型的局限：

局限一：<T>不能是根本类型，例如 int，因为理论类型是Object，Object 类型无奈持有根本类型：

Pair<int> p = new Pair<>(1, 2); // compile error!

局限二：无奈获得带泛型的Class。

Java 的泛型是采纳擦拭法实现的；

擦拭法决定了泛型<T>：

不能是根本类型，例如：int；
不能获取带泛型类型的Class，例如：Pair<String>.class；
不能判断带泛型类型的类型，例如：x instanceof Pair<String>；
不能实例化 T 类型，例如：new T()。

泛型办法要避免反复定义方法，例如：public boolean equals(T obj)；

子类能够获取父类的泛型类型<T>。

汇合类型是 Java 规范库中被应用最多的类型。

什么是汇合（Collection）？汇合就是“由若干个确定的元素所形成的整体”。例如，5 只小兔形成的汇合。

在数学中，咱们常常遇到汇合的概念。例如：

无限汇合：
- 一个班所有的同学形成的汇合；
- 一个网站所有的商品形成的汇合；
- …
有限汇合：
- 整体自然数汇合：1，2，3，……
- 有理数汇合；
- 实数汇合；
- …

为什么要在计算机中引入汇合呢？这是为了便于解决一组相似的数据，例如：

计算所有同学的总成绩和均匀问题；
列举所有的商品名称和价格；
……

在 Java 中，如果一个 Java 对象能够在外部持有若干其余 Java 对象，并对外提供拜访接口，咱们把这种 Java 对象称为汇合。很显然，Java 的数组能够看作是一种汇合：

String[] ss = new String[10]; // 能够持有 10 个 String 对象
ss[0] = "Hello"; // 能够放入 String 对象
String first = ss[0]; // 能够获取 String 对象

既然 Java 提供了数组这种数据类型，能够充当汇合，那么，咱们为什么还须要其余汇合类？这是因为数组有如下限度：

数组初始化后大小不可变；
数组只能按索引程序存取。

因而，咱们须要各种不同类型的汇合类来解决不同的数据，例如：

可变大小的程序链表；
保障无反复元素的汇合；
…

Java 规范库自带的 java.util 包提供了汇合类：Collection，它是除 Map 外所有其余汇合类的根接口。Java 的 java.util 包次要提供了以下三种类型的汇合：

List：一种有序列表的汇合，例如，按索引排列的 Student 的List；
Set：一种保障没有反复元素的汇合，例如，所有无反复名称的 Student 的Set；
Map：一种通过键值（key-value）查找的映射表汇合，例如，依据 Student 的name查找对应 Student 的Map。

Java 汇合的设计有几个特点：一是实现了接口和实现类相拆散，例如，有序表的接口是 List，具体的实现类有ArrayList，LinkedList 等，二是反对泛型，咱们能够限度在一个汇合中只能放入同一种数据类型的元素，例如：

List<String> list = new ArrayList<>(); // 只能放入 String 类型

最初，Java 拜访汇合总是通过对立的形式——迭代器（Iterator）来实现，它最显著的益处在于无需晓得汇合外部元素是按什么形式存储的。

因为 Java 的汇合设计十分长远，两头经验过大规模改良，咱们要留神到有一小部分汇合类是遗留类，不应该持续应用：

Hashtable：一种线程平安的 Map 实现；
Vector：一种线程平安的 List 实现；
Stack：基于 Vector 实现的 LIFO 的栈。

还有一小部分接口是遗留接口，也不应该持续应用：

Enumeration<E>：已被 Iterator<E> 取代。

Java 的汇合类定义在 java.util 包中，反对泛型，次要提供了 3 种汇合类，包含 List，Set 和Map。Java 汇合应用对立的 Iterator 遍历，尽量不要应用遗留接口。

在汇合类中，List是最根底的一种汇合：它是一种有序列表。

List的行为和数组简直完全相同：List外部依照放入元素的先后顺序寄存，每个元素都能够通过索引确定本人的地位，List的索引和数组一样，从 0 开始。

数组和 List 相似，也是有序构造，如果咱们应用数组，在增加和删除元素的时候，会十分不不便。例如，从一个已有的数组 {'A', 'B', 'C', 'D', 'E'} 中删除索引为 2 的元素：

┌───┬───┬───┬───┬───┬───┐
│ A │ B │ C │ D │ E │   │
└───┴───┴───┴───┴───┴───┘
              │   │
          ┌───┘   │
          │   ┌───┘
          │   │
          ▼   ▼
┌───┬───┬───┬───┬───┬───┐
│ A │ B │ D │ E │   │   │
└───┴───┴───┴───┴───┴───┘

这个“删除”操作实际上是把 'C' 前面的元素顺次往前挪一个地位，而“增加”操作实际上是把指定地位当前的元素都顺次向后挪一个地位，腾出来的地位给新加的元素。这两种操作，用数组实现十分麻烦。

因而，在理论利用中，须要增删元素的有序列表，咱们应用最多的是 ArrayList。实际上，ArrayList 在外部应用了数组来存储所有元素。例如，一个 ArrayList 领有 5 个元素，理论数组大小为6（即有一个空位）：

size=5
┌───┬───┬───┬───┬───┬───┐
│ A │ B │ C │ D │ E │   │
└───┴───┴───┴───┴───┴───┘

当增加一个元素并指定索引到 ArrayList 时，ArrayList主动挪动须要挪动的元素：

size=5
┌───┬───┬───┬───┬───┬───┐
│ A │ B │   │ C │ D │ E │
└───┴───┴───┴───┴───┴───┘

而后，往外部指定索引的数组地位增加一个元素，而后把 size 加1：

size=6
┌───┬───┬───┬───┬───┬───┐
│ A │ B │ F │ C │ D │ E │
└───┴───┴───┴───┴───┴───┘

持续增加元素，然而数组已满，没有闲暇地位的时候，ArrayList先创立一个更大的新数组，而后把旧数组的所有元素复制到新数组，紧接着用新数组取代旧数组：

size=6
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ A │ B │ F │ C │ D │ E │   │   │   │   │   │   │
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘

当初，新数组就有了空位，能够持续增加一个元素到数组开端，同时 size 加1：

size=7
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ A │ B │ F │ C │ D │ E │ G │   │   │   │   │   │
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘

可见，ArrayList把增加和删除的操作封装起来，让咱们操作 List 相似于操作数组，却不必关怀外部元素如何挪动。

咱们考查 List<E> 接口，能够看到几个次要的接口办法：

在开端增加一个元素：boolean add(E e)
在指定索引增加一个元素：boolean add(int index, E e)
删除指定索引的元素：int remove(int index)
删除某个元素：int remove(Object e)
获取指定索引的元素：E get(int index)
获取链表大小（蕴含元素的个数）：int size()

然而，实现 List 接口并非只能通过数组（即 ArrayList 的实现形式）来实现，另一种 LinkedList 通过“链表”也实现了 List 接口。在 LinkedList 中，它的外部每个元素都指向下一个元素：

        ┌───┬───┐   ┌───┬───┐   ┌───┬───┐   ┌───┬───┐
HEAD ──>│ A │ ●─┼──>│ B │ ●─┼──>│ C │ ●─┼──>│ D │   │
        └───┴───┘   └───┴───┘   └───┴───┘   └───┴───┘

通常状况下，咱们总是优先应用ArrayList。

异样解决

Java 的异样

捕捉异样

小结

捕捉异样

多 catch 语句

抛出异样

异样的流传

抛出异样

自定义异样

小结

NullPointerException

解决 NullPointerException

应用断言

小结

应用 JDK Logging

应用 Commons Logging

反射

Class 类

拜访字段

调用办法

调用构造方法

注解

应用注解

注解的作用

小结

定义注解

元注解

元注解

@Target

@Retention

@Repeatable

@Inherited

如何定义 Annotation

小结

解决注解

泛型

什么是泛型

向上转型

小结

应用泛型

泛型接口

小结

编写泛型

静态方法

多个泛型类型

小结

擦拭法

小结

汇合

汇合简介

Collection

小结

应用 List

站内搜索