首页  思维导图  详情

JavaNotes

2021-05-17 23:00:37   2  举报





AI智能生成

大三小白的Java笔记嗷~

java

作者其他创作

大纲/内容

JavaNotes

基础知识

数据类型

基本数据类型

整型

byte

1 byte = 8 bits

byte为基本数据单位

-128(-2^7)~127(2^8-1)

short

2个字节存储

-32768(-2^15)~32767(2^15-1)

int

4个字节存储

-2147483648 (-2^31)~247483647(2^31-1)

long

8个字节存储

-9223372036854775808 (-2^63)~9223372036854775807(2^63-1)

字符型

char

英文1个字节，中文2个字节

浮点型

float

1.4E-45~3.4028235E38

double

4.9E-324~1.7976931348623157E308

布尔型

boolean

true

false

注意，true和false不能用1和0来表示

引用数据类型

Java类库中的类以及自定义的一些类，如String、Math

变量

类变量

独立于方法之外的变量，用 static 修饰。

实例变量

独立于方法之外的变量，不用static修饰

局部变量

类方法中的变量

例子代码

数组

泛型数组列表

声明数组列表

var staff = new ArrayList<E>();

ArrayList<E> staff = new ArrayList<>();

add方法可以将元素添加到数组列表中

staff.add(new E(\"...\

size方法返回数组列表中包含的实际元素个数

staff.size()

等价于数组a的a.length

trimToSize方法

这个方法将存储块的大小调整为保存当前元素数量所需要的存储空间

垃圾回收器将回收多余的存储空间

a = b

在Java中这条赋值语句的操作结果是让a和b引用同一个数组列表

访问数组列表

访问或改变数组列表的元素：get和set方法

使用toArray方法将数组元素拷贝到一个数组中

使用remove方法删除指定索引位置的元素

运算符

算术运算符

取余运算符

自增运算符

i++

先用后加

++i

先加后用

自减运算符

原理与自增运算符相同

赋值运算符

sum += 1 和 sum = sum + 1是相同的

同上

(%)=

<<=

左移位赋值运算符

c <<= 2等价于 c = c << 2

>>=

右移位运算符

c >>= 2 等价于 c = c >> 2

按位与赋值运算符

按位异或赋值操作符

按位或赋值运算符

逻辑运算符

逻辑或运算符

逻辑与运算符

逻辑非运算符

用来反转操作数的逻辑状态

关系运算符

位运算符

如果相应位都是0，则结果为0，否则为1

如果相对应位都是1，则结果为1，否则为0

如果相对应位都是0，则结果为0，否则为1

按位取反运算符翻转操作数的每一位，即0变成1，1变成0。

按位左移运算符。左操作数按位左移右操作数指定的位数。

按位右移运算符。左操作数按位右移右操作数指定的位数。

>>>

按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充

条件运算符

？：

判断语句？x : y

true: 采用x赋值

false：采用y赋值

instanceof

用来在运行时指出对象是否是特定类的一个实例。

用法：result = object instanceof class

循环/判断/选择

if/else、if/else if/.../(else)

while、do/while

for/for each

switch/case/default/break

面向对象编程

封装

继承

用关键字extends来表示继承

子类与父类是“is-a”的关系

Java中，所有的继承都是公共继承，而没有C++中的私有继承和保护继承

超类（superclass）和子类（subclass）是Java程序员最常用的两个术语

子类比超类拥有的功能更多

在设计类的时候，应该将最一般的方法放在超类中，而将更特殊的方法放在子类中

覆盖方法

@Override

super关键字

调用超类的方法

调用超类构造器

动态绑定

在运行时能自动地选择适当的方法

重要特性：无须对现有的代码进行修改就可以对程序进行扩展

在继承层次中，从某个特定的类到其祖先的路径被称为该类的继承链

Java不支持多重继承，但提供了类似多重继承的功能——接口

is-a规则的另一种表述是替换规则

在Java中，子类引用的数组可以转换成超类引用的数组，而不需要使用强制类型转换

再覆盖一个方法的时候，子类方法不能低于超类方法的可见性

final类和方法

阻止继承

强制类型转换的唯一原因

要在暂时忽视对象的实际类型之后使用对象的全部功能

在将超类强制转换为子类之前，应该使用instance of进行检查

当强制类型转换失败时，Java不会生成null对象，而是抛出一个异常

静态绑定

如果是private方法，static方法，final方法或者构造器，那么编译器将可以准确地知道应该调用哪个方法

抽象

abstract类

abstract方法

多态

一个对象变量可以指示多种实际类型的现象

在Java中，对象变量是多态的

Overload/Override

接口

包

借助包可以方便地组织直接的代码并将自己的代码与别人提供的代码库分开管理

使用包的主要原因是确保类名的唯一性

要用一个因特网域名以逆序的形式作为包名，然后对于不同的工程使用不同的子包

从编译器的角度来看，嵌套的包之间没有任何关系

类的导入

使用完全限定名

使用import语句

只能使用星号（*）导入一个包，而不能使用import java.*或import java.*.*导入以java为前缀的所有包

静态导入

有一种import语句允许导入静态方法和静态字段，而不只是类

无名包

如果没有在源文件中放置package语句，这个源文件中的类就属于无名包

类之间的关系

依赖（uses-a）

聚合（has-a）

继承（is-a）

对象包装器与自动装箱

包装器

所有的基本类型都有一个与之对应的类，这些类称为包装器

Integer

Long

Float

Double

Short

Byte

Charater

Boolean

Number

包装器类是final的，因此不能派生它们的子类

自动装箱

调用list.add(3)将自动地变换成list.add(Integer.valueOf(3));的这种变换称为自动装箱

装箱和拆箱时编译器要做的工作，而不是虚拟机

同一性

==运算符可以应用于包装器对象，不过检测的是对象是否有相同的内存位置

在比较两个包装器对象时调用equals方法

intValue()

toString()

parseInt()

valueOf()

关键字

访问修饰符

public

对外部完全可见

protected

对本包和所有子类可见

（default）

对本包可见

private

仅对本类可见

基本数据类型关键字

循环与判断相关的关键字

void

空类型修饰符

final

被其指定的类或变量或方法均无法被继承（或修改）

abstract

this

指示隐式参数

super

super.父类变量、super.父类方法

var（not keyword）

可以用此关键字来声明变量，然后可以通过从变量的初始值推断出它的类型，不可以用于数值类型，如int，long，double等

extends

子类继承父类的关键字

implements

类实现接口的关键字

import

导包关键字

package

new

new一个对象

return

static

静态字段修饰符（其实用类字段比较贴切）

interface

enum

continue

break

const

可用final取代，目前未被使用

goto

没有用到

throw

throws

assert

断言

常用的类

java.lang

String

compareTo()

equals()

equalsIgnoreCase()

length()

toCharArray()

toUpperCase()/toLowerCase()

indexOf()

substring()

join()

repeat()

trim()

一定不要使用“==”运算符检测两个字符串是否相等！

Math

pow()

PI、E

log()

sin()...

System

System.out.println()

System.out.print()

System.out.printf()

java.util

Scanner

next()

nextLine()

nextInt()

nextDouble()

Arrays

sort()

foreach

copyOf()

length

binarySearch()

fill()

ArrayList

Date

java.time

LocalDate

of()

getYear()/getMonthValue()/getDayOfMonth()

plusDays()

minusDays()

枚举类

enum关键字放在类名前面，表示这是一个枚举类

所有的枚举类都是Enum类的子类

最有用的一个继承方法是toString方法

返回枚举常量名

toString的逆方法是静态方法valueOf

ordinal方法返回enum声明中枚举常量的位置，位置从0开始计数

方法

静态方法

不在对象上执行的方法

可以提供类名来调用这个方法

可以使用对象调用静态方法

两种情况可以使用静态方法

方法不需要访问对象状态，因为它需要的所有参数都通过显式参数提供

方法只需要访问类的静态字段

工厂方法

静态方法的另一种常见用途

main方法

静态的main方法将执行并构造程序所需要的对象

方法的名字和参数列表称为方法的签名

参数数量可变的方法

printf方法

省略号... 是Java代码的一部分，它表明这个方法可以接任意数量的对象（fmt参数之外）。

对于printf的实现者来说，Object..参数类型与Object[]完全一样

甚至可以将main方法声明以下形式：

public static void main(String... args)

文档注释

javadoc

javadoc实用工具从以下几项中抽取信息

模块

公共类与接口

公共类和受保护的字段

公共的和受保护的构造器及方法

几种注释

类注释

必须放在import之后，类定义之前

方法注释

@param

@renturn

@throws

字段注释

只需要对公共字段（通常指静态常量）建立文档

通用注释

@author

@version

@see

@link

包注释

需要在每一个包目录中添加一个单独的文件

提供一个名为package-info.java的Java文件

提供一个名为package.html的HTML文件

类中

方法参数

按值传递

两种类型：基本数据类型、对象引用

对象构造

重载

如果多个方法有相同的名字、不同的参数，便出现了重载

重载解析：编译器必须挑选出具体调用哪个方法。它用各个方法首部中的参数类型与特定方法调用中所使用的值类型进行匹配，，来选出正确的方法。如果编译器找不到匹配的参数，就会产生编译时错误，因为根本不存在匹配，或者没有一个比其他更好的

默认字段初始化

如果在构造器中没有显式地为字段设置初值，那么就会被自动赋为默认值：数值为0、布尔型为false、对象引用为null。

显式字段初始化

初始化块

对象初始化块

静态初始化块

构造器

如果写一个类时没有编写构造器，就会为你提供一个无参数构造器。

这个构造器将所有的实例字段设置为默认值。

如果类中提供了至少一个构造器，但是没有提供无参数的构造器，那么构造对象时如果部提供参数就是hi不合法的。

仅当类没有任何其他构造器的时候，你才会得到一个默认的无参数构造器

对象析构

Java会完成自动的垃圾回收，不需要人工回收内存，所以Java不支持析构器。

类路径

类路径必须与包名匹配

在一个JAR文件中，可以包含多个压缩形式的类文件和子目录。

为了使类能够被多个程序共享，需要做到下面几点

把类文件放一个目录中

将JAR文件放在一个目录中

设置类路径（class path）

设置类路径

最好使用-classpath或-cp选项指定类路径

java -classpath c:\\classdir;.;c:\\archive.jar MyProg

类设计技巧

一定要保证数据私有（private）

一定要对数据进行初始化

不要在类中使用过多的基本类型

不是所有的字段都需要单独的字段访问器（getter）和字段更改器（setter）

分解有过多职责的类

类名和方法名要能够体现它们的职责

优先使用不可变的类

内部类

为什么需要使用内部类

内部类可以对同一个包中的其他类隐藏

内部类方法可以访问定义这个类的作用域中的数据，包括原本私有的数据

内部类原先对于简洁地使用回调非常重要，不过如今lambda表达式在这方面可以做得更好

使用内部类访问对象状态

一个内部类可以访问自身的数据字段，也可以访问创建它的外围类对象的数据字段

内部类的对象总有一个隐式引用，指向创建它的外部类对象

只有内部类可以是私有的，而常规类可以有包可见性或公共可见性

内部类的特殊语法规则

可以采用以下语法更加明确地编写内部类对象的构造器

outerObject.new InnerClass(construction parameters)

在外围类的作用域之外，可以这样引用内部类

OuterClass.InnerClass

内部类中声明的所有静态字段都必须是final，并初始化为一个编译时常量

内部类不能有static方法

也可以允许有静态方法，但只能访问外围类的静态字段和方法

内部类是否必要、有用和安全

内部类是一个编译器现象，与虚拟机无关。编译器将会把内部类转换为常规的类文件，用$分隔外部类名与内部类名

javap -private innerClass.outerClass\\$innerClass

查看内部类的实际工作

内部类可以访问外围类的私有数据

局部内部类

声明局部内部类不能有访问说明符

局部类的作用域被限定在声明这个局部类的块中

由外部方法访问变量

匿名内部类

new SuperType(construction parameters) { inner class methods and data }

SuperType可以是接口也可以是类

静态内部类

使用内部类只是为了把一个类隐藏在另外一个类的内部，并不需要内部类有外围类对象的一个引用

可以将内部类声明为static 这样就不会生成上述引用

只要内部类不需要访问外围类对象，就应该使用静态内部类

与常规内部类不同，静态内部类可以有静态字段和方法

在接口中声明的内部类自动是static和public

Object

只有基本类型不是对象

equals方法

自反性

对称性

传递性

一致性

hashcode方法

散列码

toString方法

最好自定义一个toString方法

接口不是类，而是对希望符合这个接口的类的一组需求

接口中的所有方法都自动是public方法

在接口中声明方法时，不必提供关键字public

Java8之前，接口中绝对不会实现方法

Java8之后，可以在接口中提供简单方法

这些方法不能引用实例字段

接口没有实例

为了让类实现一个接口，通常需要完成下面两个步骤

将类声明为实现给定的接口

对接口中的所有方法提供定义

要将类声明为实现某个接口，需要使用关键字implements

接口的属性

接口不是类，不能使用new运算符实例化一个接口

尽管不能构造接口的对象，却能声明接口的变量

接口变量必须引用实现了这个接口的类对象

可以使用instanceof检查一个对象是否实现了某个特定的接口

与建立类的继承层次一样，也可以扩展接口

虽然在接口中不能包含实例字段，但时可以包含常量

与接口中的方法都自动被设置为public一样，接口中的字段总是public static final

有些接口只定义产量，而没有定义方法

这样使用接口更像是退化，所以我们建议最好不要这样使用

尽管每个类只能有一个超类，但却能实现多个接口

可以用逗号将想要实现的各个接口分隔开

接口与抽象类

使用抽象类表示通用属性存在一个严重的问题

每个类只能扩展一个类

但是，每个类可以实现多个接口

Java设计者选择了不支持多重继承，其主要原因是多重继承会让语言变得非常复杂或者效率会降低

接口中的方法

静态和私有方法

在Java8中，允许在接口中增加静态方法

只是这有违于将接口作为抽象规范的初衷

通常的做法都是将静态方法放在伴随类中

在Java9中，接口中的方法可以是private

private方法可以是静态方法或实例方法

由于私有方法只能在接口中使用，所以它们的用法很有限，只能作为接口中其他方法的辅助方法

默认方法

必须用default修饰符标记这样一个方法

一个重要用法是“接口演化”

解决默认方法冲突

超类优先

接口冲突

覆盖

“类优先”规则可以确保与Java7的兼容性

千万不要让一个默认方法重新定义Object类中的某个方法

接口与回调

Comparator接口

对象克隆

Cloneable接口

这个接口指示一个类提供了一个安全的clone方法

clone方法

clone方法是Object的一个protected方法

异常

处理错误

异常分类

Throwable

Error

Exception

IOException

RuntimeException

错误的强制类型转换

数组访问越界

访问null指针

非派生于RuntimeException的异常

试图超越文件末尾继续读取数据

试图打开一个不存在的文件

试图根据给定的字符串查找Class对象，而这个字符串表示的类并不存在

非检查型异常

派生于Error类或RuntimeException类的所有异常

检查型异常

声明所有检查型异常

会抛出异常的情况

调用了一个抛出检查型异常的方法

检测到一个错误，并且利用throw语句抛出一个检查型异常

程序出现错误

Java虚拟机或运行时库出现内部错误

如果出现前两种情况，则必须告诉调用这个方法的程序员有可能抛出异常

一个方法必须声明所有可能抛出的检查型异常，而非检查型异常要么在你的控制之外(Error)，要么是由从一开始就应该避免的情况所导致的（RuntimeException）.

如果子类中覆盖了超类的一个方法，子类方法中声明的检查型异常不能比超类方法中声明的异常更通用

如果超类方法没有抛出任何检查型异常，子类也不能抛出任何检查型异常

如何抛出异常

找到一个合适的异常类

创建这个类的一个对象

将对象抛出

一旦方法抛出了异常，这个方法就不会返回到调用者

创建异常类

定义一个派生于Exception的类，或者派生于Exception的某个子类，如IOException

习惯做法

自定义的这个类应该包含两个构造器，一个是默认的构造器，另一个是包含详细描述信息的构造器

捕获异常

try/catch语句

try/catch/catch...

捕获多个异常

finally子句

不管是否有异常被捕获，finally子句中的代码都会执行

执行finally子句的情况

代码没有抛出异常

代码抛出一个异常，并在一个catch子句中捕获

try语句可以只有finally子句，而没有catch子句

不要把控制流的语句（return，throw，break，continue）放在finally子句中

try-with-Resources语句

堆栈轨迹元素

StackFrame

StackTraceElement

使用异常的技巧

异常处理不能代替简单的测试

不要过分地细化异常

充分利用异常层次结构

不要压制异常

在检测错误时，“苛刻”要比放任更好

不要羞于传递异常

早抛出，晚捕获

断言的概念

断言机制允许在测试期间向代码中插入一些检查，而在生产代码中自动删除这些检查

Java语言引入了关键字assert，有两种形式

assert condition

assert condition : expression

\"表达式\"(expression)部分的唯一目的是产生一个消息字符串

启用和禁用断言

在默认情况下，断言是禁用的

启用断言使用：java -enableassertions MyApp 或 java -ea MyApp

不必重新编译程序来启用或禁用断言

启用或禁用断言是类加载器（class loader）的功能

禁用断言时，类加载器会去除断言代码

也可以用选项 -disableassertions或 -da在某个特定类和包中禁用断言

使用断言完成参数检查

在Java语言中，给出了3种处理系统错误的机制

抛出异常

日志

使用断言

何时应该选择断言

断言失败时致命的，不可恢复的错误

断言检查只是在开发和测试阶段打开

不应该使用断言向程序的其他部分通知发生了可恢复性的错误

前置条件

使用断言提供假设文档

断言是一种测试和调试阶段使用的战术性工具

与之不同，日志是一种在程序整个生命周期都可以使用的战略性工具

基本日志

全局日志记录器

Logger.getGlobal().info(\"File\" -> Open menu item selected);

取消所有日志

Logger.getGlobal().setLevel(Level.OFF);

高级日志

调用getLogger方法创建或获取日志记录器

未被任何变量引用的日志记录器可能会被垃圾回收。

7个日志级别

SEVERE

WARNING

INFO

CONFIG

FINE

FINER

FINEST

在默认情况下，实际上只记录前3个级别

还可以使用Level.ALL开启所有级别的日志记录，或者使用Level.OFF关闭所有级别的日志记录

默认的日志处理器会抑制低于INFO级别的消息

修改日志管理器配置

默认情况下，配置文件位于：conf/logging.properties

日志记录器并不将消息发送到控制台，那是处理器的任务

日志管理器在虚拟机启动时初始化，也就是在main方法执行前

本地化

处理器

过滤器

格式化器

日志技巧

lambda表达式

为什么引入lambda表达式

lambda表达式是一个可传递的代码块，可以在以后执行一次或多次

lambda表达式的语法

第一个lambda表达式

lambda表达式就是一个代码块，以及必须传入代码的变量规范

表达式形式

参数，箭头(->)以及一个表达式

即使lambda表达式没有参数，仍然要提供空括号，就像无参数方法一样

如果推导出一个lambda表达式的参数类型，则可以忽略其类型

lambda表达式的返回类型总是会由上下文推导得出

如果一个lambda表达式只在某系分支返回一个值，而另外一些分支不返回值，这是不合法的

函数式接口

对于只有一个抽象方法的接口，需要这种接口的对象时，就可以提供一个lambda表达式

这种接口称为函数式接口

最好把lambda表达式当作是一个函数，而不是一个对象，另外要接受lambda表达式可以传递到函数式接口

方法引用

方法引用也不是一个对象

只有当lambda表达式的体只调用一个方法而不做其他操作时，才能把lambda表达式重写为方法引用

可以在方法引用中使用this参数

构造器引用

变量作用域

lambda表达式有三部分

一个代码块

参数

自由变量的值，这是指非参数而且不在代码中定义的变量

关于关于代码块以及自由变量值有一个术语：闭包。Java中，lambda表达式就是闭包

如果在lambda表达式中引用一个变量，而这个变量可能在外部改变，这也是不合法的。

lambda表达式可以捕获外围作用域中的变量的值

在lambda表达式中，引用值不会改变的变量

lambda表达式中捕获的变量必须实际上是事实最终变量

lambda表达式的体与嵌套块有相同的作用域

在一个lambda表达式中使用this关键字时，是指创建这个lambda表达式的方法的this参数

处理lambda表达式

使用lambda表达式的重点是延迟执行

之所以希望以后再执行代码，原因有

在一个单独的线程中运行代码

多次运行代码

在算法的适当位置运行代码

发生某种情况时执行代码

只在必要时才运行代码

反射

反射库提供了一个丰富且精巧的工具集，可以用来编写能够动态操纵Java代码的程序。

能够分析类能力的程序称为反射。

反射机制可以用来

在运行时分析类的能力。

在运行时检查对象，例如，编写一个适用于所有类的toString方法。

实现泛型数组操作代码。

利用Method对象。这个对象很像C++中的函数指针。

Class类

forName(String className)

getConstructor(Class.. parameterTypes)

虚拟机为每个类型管理一个唯一的Class对象

声明异常

异常两种类型

非检查型

检查型

如果一个方法包含一条可能抛出检查型异常的语句，则在方法名上增加一个throws子句

资源

图像和声音文件

包含消息字符串和按钮标签的文本文件

URL getResource(String name)

InputStream getResourceAsStream(String name)

利用反射分析类的能力

检查类的结构

getName()

getType()

getModifiers()

getMethods()

getConstructor()

isPublic()

JAR文件

创建JAR文件

jar cvf jarFileName file1 file2 ...

jar options file1 file2

清单文件

每个JAR文件还包含一个清单文件，用于描述归档文件的特殊特性

MANIFEST.MF

要想编辑清单文件，需要将希望添加到清单文件中的行放到文本文件中

然后运行：jar cfm jarFileName manifestFileName . . .

要想更新一个已有的JAR文件的清单，则需要将增加的部分放置到一个文本文件中

然后执行以下命令：jar ufm MyArchive.jar manifest-additions.mf

可执行JAR文件

java -jar MyProgram.jar

多版本JAR文件

多版本JAR文件的唯一目的是支持你的某个特定版本的程序或库能够在多个不同的JDK版本上运行。

服务加载器和代理

服务加载器

代理

栈、堆、队列

泛型程序设计

为什么要使用泛型程序设计

类型参数的好处

在Java中增加泛型类之前，泛型程序设计是用继承实现的

类型参数表达形式（示例）

var files = new ArrayList<String>();

ArrayList<String> files = new ArrayList();

ArrayList<String> passwords = new ArrayList<>() { public String get(int n) {return super.get(n).replaceAll(\".\

它们会让你的程序更易读，也更安全

谁想成为泛型程序员

大多数Java程序员都会使用类似ArrayList<String>这样的类型，就好像它们是Java内置的类型一样（就像String[] 数组）。

当然，数组列表比数组更好，因为数组列表可以自动扩展

应用程序员很可能不会编写太多的泛型代码

JDK开发人员已经做出了很大的努力，为所有的集合类型提供了类型参数。

定义简单的泛型类

public class Pair<T> { code to do something}

可以用具体的类型替换类型变量来实例化泛型类型

Pair<String>

泛型类相当于普通类的工厂

Java的泛型类类似于C++的模板类。唯一明显的不同是Java没有特殊的template关键字

两种机制有着本质的区别

泛型方法

示例

示例中的方法是在普通类中定义的，而不是在泛型类中。这是一个泛型方法

类型变量放在修饰符（这里的修饰符就是public static）的后面，并在返回类型的前面

泛型方法可以在普通类中定义，也可以在泛型类中定义

调用实例

类型变量的限定

泛型代码和虚拟机

类型擦除

虚拟机没有泛型类型对象

所有对象都属于普通类

无论何时定义一个泛型类型，都会自动提供一个相应的原始类型（raw type）

这个类型的名字就是去掉类型参数后的泛型类型名

转换泛型表达式

编写一个泛型方法调用时，如果擦除了返回类型，编译器会插入强制类型转换

转换泛型方法

类型擦除也会出现在泛型方法中

泛型方法：public static <T extends Comparable> T min(T[] a)

类型擦除后

public static Comparable min(Comparable[] a)

桥方法

对于Java泛型的转换，需要记住以下几个事实

虚拟机中没有泛型，只有普通的类和方法

所有的类型参数都会替换为它们的限定类型

会合成桥方法来保持多态

为保持类型安全性，必要时会插入强制类型转换

调用遗留代码

设计Java泛型时，主要目标是允许泛型代码和遗留代码之间能够互操作

@SupressWarnings(\"unchecked\")

这个注解会关闭对方法中所有代码的检查

限制与局限性

不能用基本类型实例化类型参数

其原因在于类型擦除

运行时类型查询只适用于原始类型

虚拟机中的对象总有一个特定的非泛型类型

不能创建参数化类型的数组

Varargs警告

@SafeVarargs

只能声明为static、final或（Java9中）private的构造器和方法

不能实例化类型变量

最好的解决办法是让调用者提供一个构造器表达式

不能构造泛型数组

泛型类的静态上下文中类型变量无效

不能再静态字段或方法中引用类型变量

禁止使用带有类型变量的静态字段和方法

不能抛出或捕获泛型类的实例

实际上，泛型类扩展Throwable甚至都是不合法的

在异常规范中使用类型变量是允许的

可以取消对检查型异常的检查

Java异常处理的一个基本原则是，必须为所有检查型异常提供一个处理器

不过可以利用泛型取消这个机制

通过使用泛型类，擦除和@SupressWarnings注解，我们就能消除Java类型系统的部分基本限制

注意擦除后的冲突

当泛型类型被擦除后，不允许创建引发冲突的条件

补救的办法是重新命名引发冲突的方法

倘若两个接口类型是同一接口的不同参数化，一个类或类型变量就不能同时作为这两个接口类型的子类

泛型类型的继承规则

无论S和T有什么关系，通常，Pair<S>于Pair<T>都没有任何关系

总是可以将参数化类型转换为一个原始类型

转换成原始类型会产生类型错误

通配符类型

通配符概念

在通配符类型中，允许类型参数发生变化

Pair<? extends Employee>

现在已经有办法区分安全的访问器方法和不安全的更改器方法了

通配符的超类型限定

? super Manager

可以为方法提供参数，但不能使用返回值

如果你是一名库程序员，你一定要熟悉通配符

无限定通配符

Pair<?>

Pair<?>与Pair本质的不同在于

可以用任意Object对象调用原始Pair类的setFirst方法

通配符捕获

通配符不是类型变量

因此，不能在编写代码的时候使用“?”作为一种类型

swapHelper方法的参数T捕获通配符

通配符捕获机制是不可避免的

通配符只有在非常限定的情况下才是合法的

编译器必须能够保证单个确定的类型

反射和泛型

泛型Class类

Class类是泛型的

String.class实际上是一个Class<String>类的对象

Class<T>的以下方法就使用了类型参数

T newInstance()

T cast(Object obj)

T[] getEnumConstants()

Class<? super T> getSuperclass()

Constructor<T> getConstructor(Class... parameterTypes)

Constructor<T> getDeclaredConstructor(Class... parameterTypes)

使用Class<T>参数进行类型匹配

虚拟机中的泛型类型信息

可以使用反射API来确定

这个泛型方法有一个名为T的类型参数

这个类型参数有一个子类型限定，其自身又是一个泛型类型

这个限定类型有一个通配符参数

这个通配符参数有一个超类型限定

这个泛型方法有一个泛型数组参数

你可以重新构造实现者声明的泛型类和方法的所有有关内容

你不会知道对于特定的对象或方法调用会如何解析类型参数

类型字面量

CDI和Guice等注入框架就使用类型字面量来控制泛型类型的注入