导图社区 Java基础

发布时间：2021-06-05

Java基础

Java基础知识点，内容包括：计算机基础知识、JAVA语言概述、Java中的常量及进制、运算符、键盘录入数据、流程控制语句等相关知识点。整理了好长一段时间，发布的第一个作品，希望大家喜欢！

编辑于2021-06-05 16:08:37

java基础
Java总结
Java详细
Java全体系

andrew

Java基础

社区模板帮助中心，点此进入>>

andrew

相似推荐
大纲

Java基础全体系

异常处理

面向对象

反射

网络编程

IO流

常用类

泛型

异常处理

多线程

集合

新特性

枚举类与注解

常用类

BigInteger与BigDecimal

BigInteger

Integer类作为int的包装类，能存储的最大整型值为231-1，Long类也是有限的，最大为263-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。

java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger 提供

所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。

构造器

BigInteger(String val)：根据字符串构建BigInteger对象

常用方法

public BigInteger abs()：返回此 BigInteger 的绝对值的 BigInteger。

BigInteger add(BigInteger val) ：返回其值为 (this + val) 的 BigInteger

BigInteger subtract(BigInteger val) ：返回其值为 (this - val) 的 BigInteger

BigInteger multiply(BigInteger val) ：返回其值为 (this * val) 的 BigInteger

BigInteger divide(BigInteger val) ：返回其值为 (this / val) 的 BigInteger。整数相除只保留整数部分。

BigInteger remainder(BigInteger val) ：返回其值为 (this % val)的BigInteger。

BigInteger[] divideAndRemainder(BigInteger val)：返回包含 (this / val) 后跟(this % val) 的两个 BigInteger 的数组。

BigInteger pow(int exponent) ：返回其值为 (thisexponent) 的 BigInteger。

BigDecimal

一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。

BigDecimal类支持不可变的、任意精度的有符号十进制定点数。

构造器

public BigDecimal(double val)

public BigDecimal(String val)

常用方法

public BigDecimal add(BigDecimal augend)

public BigDecimal subtract(BigDecimal subtrahend)

public BigDecimal multiply(BigDecimal multiplicand)

public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

Math类

java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般为double型。

abs 绝对值

pow(double a,doble b) a的b次幂

exp e为底指数

max(double a,double b)

min(double a,double b)

random() 返回0.0到1.0的随机数

long round(double a) double型数据a转换为long型（四舍五入）

acos,asin,atan,cos,sin,tan 三角函数

sqrt 平方根

log 自然对数

toDegrees(double angrad) 弧度—>角度

toRadians(double angdeg) 角度—>弧度

System类

System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。

由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。

成员变量

System类内部包含in、out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。

成员方法

native long currentTimeMillis()：该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。

void exit(int status)：该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。

void gc()：该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。

String getProperty(String key)：该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见的属性名以及属性的作用如下表所示：

字符串相关的类

String

String的特性

String类：代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。

String是一个final类，代表不可变的字符序列。

字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改。

String对象的字符内容是存储在一个字符数组value[]中的。

常用方法

int length()：返回字符串的长度： return value.length

char charAt(int index)：返回某索引处的字符return value[index]

boolean isEmpty()：判断是否是空字符串：return value.length == 0

String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写

String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写

String trim()：返回字符串的副本，忽略前导空白和尾部空白

boolean equals(Object obj)：比较字符串的内容是否相同

boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写

String concat(String str)：将指定字符串连接到此字符串的结尾。等价于用“+”

int compareTo(String anotherString)：比较两个字符串的大小

String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从

beginIndex开始截取到最后的一个子字符串。

String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。

boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束

boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始

boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始

boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true

int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引

int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始

int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引

int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索

注：indexOf和lastIndexOf方法如果未找到都是返回-1

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 替换此字符串匹配给定的正则表达式的第一个子字符串。

boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。

String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。

String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

String与基本数据类型转换

字符串-> 基本数据类型、包装类

Integer包装类的public static int parseInt(String s)：可以将由“数字”字符组成的字符串转换为整型。

类似地,使用java.lang包中的Byte、Short、Long、Float、Double类调相应的类方法可以将由“数字”字符组成的字符串，转化为相应的基本数据类型。

基本数据类型、包装类->字符串

调用String类的public String valueOf(int n)可将int型转换为字符串

相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(double d)、valueOf(boolean b)可由参数的相应类型到字符串的转换

字符数组->字符串

String 类的构造器：String(char[]) 和 String(char[]，int offset，int length) 分别用字符数组中的全部字符和部分字符创建字符串对象。

字符串->字符数组

public char[] toCharArray()：将字符串中的全部字符存放在一个字符数组中的方法。

public void getChars(int srcBegin, int srcEnd, char[] dst,int dstBegin)：提供了将指定索引范围内的字符串存放到数组中的方法。

字节数组->字符串

String(byte[])：通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。

String(byte[]，int offset，int length) ：用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象。

字符串->字节数组

public byte[] getBytes() ：使用平台的默认字符集将此 String 编码为byte 序列，并将结果存储到一个新的 byte 数组中。

public byte[] getBytes(String charsetName) ：使用指定的字符集将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。

StringBuffer

java.lang.StringBuffer代表可变的字符序列，JDK1.0中声明，可以对字符串内容进行增删，此时不会产生新的对象。

很多方法与String相同。

作为参数传递时，方法内部可以改变值。

StringBuffer类不同于String，其对象必须使用构造器生成。有三个构造器：

StringBuffer()：初始容量为16的字符串缓冲区

StringBuffer(int size)：构造指定容量的字符串缓冲区

StringBuffer(String str)：将内容初始化为指定字符串内容

常用方法

StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接

StringBuffer delete(int start,int end)：删除指定位置的内容

StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str

StringBuffer insert(int offset, xxx)：在指定位置插入xxx StringBuffer reverse() ：把当前字符序列逆转

当append和insert时，如果原来value数组长度不够，可扩容。

如上这些方法支持方法链操作。

方法链的原理：

public int indexOf(String str)

public String substring(int start,int end)

public int length()

public char charAt(int n )

public void setCharAt(int n ,char ch)

StringBuilder

StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且提供相关功能的方法也一样

面试题：对比String、StringBuffer、StringBuilder

String(JDK1.0)：不可变字符序列

StringBuffer(JDK1.0)：可变字符序列、效率低、线程安全

StringBuilder(JDK 5.0)：可变字符序列、效率高、线程不安全

注意：作为参数传递的话，方法内部String不会改变其值，StringBuffer和StringBuilder 会改变其值。

时间日期API

JDK8之前

java.lang.System类

System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。

此方法适于计算时间差。

计算世界时间的主要标准有：

UTC(Coordinated Universal Time)

GMT(Greenwich Mean Time)

CST(Central Standard Time)

java.util.Date类

表示特定的瞬间，精确到毫秒

构造器：

Date()：使用无参构造器创建的对象可以获取本地当前时间。

Date(long date)

常用方法

getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

toString():把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)，zzz是时间标准。

其它很多方法都过时了。

3. java.text.SimpleDateFormat类

Date类的API不易于国际化，大部分被废弃了，java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类。

它允许进行格式化：日期->文本、解析：文本->日期

格式化：

SimpleDateFormat() ：默认的模式和语言环境创建对象

public SimpleDateFormat(String pattern)：该构造方法可以用参数pattern指定的格式创建一个对象，该对象调用：public String format(Date date)：方法格式化时间对象date

解析：

public Date parse(String source)：从给定字符串的开始解析文本，以生成一个日期。

java.util.Calendar(日历)类

Calendar是一个抽象基类，主用用于完成日期字段之间相互操作的功能。

获取Calendar实例的方法

使用Calendar.getInstance()方法

调用它的子类GregorianCalendar的构造器。

一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。比如YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY、MINUTE、SECOND

public void set(int field,int value)

public void add(int field,int amount)

public final Date getTime()

public final void setTime(Date date)

注意:

获取月份时：一月是0，二月是1，以此类推，12月是11

获取星期时：周日是1，周二是2 ，。。。。周六是7

JDK8之后

新日期时间API出现的背景

如果我们可以跟别人说：“我们在1502643933071见面，别晚了！”那么就再简单不过了。但是我们希望时间与昼夜和四季有关，于是事情就变复杂了。JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar并不比Date好多少。它们面临的问题是：

可变性：像日期和时间这样的类应该是不可变的。

偏移性：Date中的年份是从1900开始的，而月份都从0开始。

格式化：格式化只对Date有用，Calendar则不行。

此外，它们也不是线程安全的；不能处理闰秒等。

总结：对日期和时间的操作一直是Java程序员最痛苦的地方之一。

第三次引入的API是成功的，并且Java 8中引入的java.time API 已经纠正了

过去的缺陷，将来很长一段时间内它都会为我们服务。

Java 8 吸收了 Joda-Time 的精华，以一个新的开始为 Java 创建优秀的 API。新的 java.time 中包含了所有关于本地日期（LocalDate）、本地时间

（LocalTime）、本地日期时间（LocalDateTime）、时区（ZonedDateTime）

和持续时间（Duration）的类。历史悠久的 Date 类新增了 toInstant() 方法，用于把 Date 转换成新的表示形式。这些新增的本地化时间日期 API 大大简化了日期时间和本地化的管理。

新时间日期API

java.time – 包含值对象的基础包

java.time.chrono – 提供对不同的日历系统的访问

java.time.format – 格式化和解析时间和日期

java.time.temporal – 包括底层框架和扩展特性

java.time.zone – 包含时区支持的类

说明：大多数开发者只会用到基础包和format包，也可能会用到temporal包。因此，尽管有68个新的公开类型，大多数开发者，大概将只会用到其中的三分之一。

LocalDate、LocalTime、LocalDateTime 类是其中较重要的几个类，它们的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。

LocalDate代表IOS格式（yyyy-MM-dd）的日期,可以存储生日、纪念日等日期。

LocalTime表示一个时间，而不是日期。

LocalDateTime是用来表示日期和时间的，这是一个最常用的类之一。

注：ISO-8601日历系统是国际标准化组织制定的现代公民的日期和时间的表示法，也就是公历。

瞬时：Instant

Instant：时间线上的一个瞬时点。这可能被用来记录应用程序中的事件时间戳。

在处理时间和日期的时候，我们通常会想到年,月,日,时,分,秒。然而，这只是时间的一个模型，是面向人类的。第二种通用模型是面向机器的，或者说是连续的。在此模型中，时间线中的一个点表示为一个很大的数，这有利于计算机处理。在UNIX中，这个数从1970年开始，以秒为的单位；同样的，在Java中，也是从1970年开始，但以毫秒为单位。

java.time包通过值类型Instant提供机器视图，不提供处理人类意义上的时间单位。Instant表示时间线上的一点，而不需要任何上下文信息，例如，时区。概念上讲，它只是简单的表示自1970年1月1日0时0分0秒（UTC）开始的秒数。因为java.time包是基于纳秒计算的，所以Instant的精度可以达到纳秒级。

(1 ns = 10-9 s) 1秒 = 1000毫秒 =10^6微秒=10^9纳秒

时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。

格式化与解析日期或时间

java.time.format.DateTimeFormatter 类：该类提供了三种格式化方法：

预定义的标准格式。如：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME

本地化相关的格式。如：ofLocalizedDateTime(FormatStyle.LONG)

自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)

其他API

ZoneId：该类中包含了所有的时区信息，一个时区的ID，如 Europe/Paris

ZonedDateTime：一个在ISO-8601日历系统时区的日期时间，如 2007-12- 03T10:15:30+01:00 Europe/Paris。

其中每个时区都对应着ID，地区ID都为“{区域}/{城市}”的格式，例如：Asia/Shanghai等

Clock：使用时区提供对当前即时、日期和时间的访问的时钟。

持续时间：Duration，用于计算两个“时间”间隔

日期间隔：Period，用于计算两个“日期”间隔

TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下一个工作日”等操作。

TemporalAdjusters : 该类通过静态方法 (firstDayOfXxx()/lastDayOfXxx()/nextXxx())提供了大量的常用 TemporalAdjuster 的实现。

与传统日期处理的转换

Java比较器

在Java中经常会涉及到对象数组的排序问题，那么就涉及到对象之间的比较问题。

Java实现对象排序的方式有两种：

自然排序：java.lang.Comparable

定制排序：java.util.Comparator

方式一：自然排序：java.lang.Comparable

Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。

实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。如果当前对象this大于形参对象obj，则返回正整数，如果当前对象this小于形参对象obj，则返回负整数，如果当前对象this等于形参对象obj，则返回零。

实现Comparable接口的对象列表（和数组）可以通过 Collections.sort 或 Arrays.sort进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

对于类 C 的每一个 e1 和 e2 来说，当且仅当 e1.compareTo(e2) == 0 与 e1.equals(e2) 具有相同的 boolean 值时，类 C 的自然排序才叫做与 equals 一致。建议（虽然不是必需的）最好使自然排序与 equals 一致。

Comparable 的典型实现：(默认都是从小到大排列的)

String：按照字符串中字符的Unicode值进行比较

Character：按照字符的Unicode值来进行比较

数值类型对应的包装类以及BigInteger、BigDecimal：按照它们对应的数值大小进行比较

Boolean：true 对应的包装类实例大于 false 对应的包装类实例

Date、Time等：后面的日期时间比前面的日期时间大

方式二：定制排序：java.util.Comparator

当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排序，强行对多个对象进行整体排序的比较。

重写compare(Object o1,Object o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示 o1小于o2。

可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。

还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。

面向对象

类

方法

构造器

属性

接口

特性

面向过程与面向对象

面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。

面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

面向对象的三大特征

封装 (Encapsulation)

继承 (Inheritance)

多态 (Polymorphism)

面向对象的思想概述

面向对象分析方法分析问题的思路和步骤：

根据问题需要，选择问题所针对的现实世界中的实体。

从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。

把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。

将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

类(Class)和对象(Object)是面向对象的核心概念。

类是对一类事物的描述，是抽象的、概念上的定义

对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。

面向对象程序设计的重点是类的设计

类的设计，其实就是类的成员的设计

类和对象

Java类及类的成员

属性：对应类中的成员变量

行为：对应类中的成员方法

类的语法格式

修饰符 class 类名 { 属性声明; 方法声明; } 说明：修饰符public：类可以被任意访问类的正文要用{ }括起来

类的成员

属性

语法格式

修饰符数据类型属性名 = 初始化值 ;

说明1: 修饰符

常用的权限修饰符有：private、缺省、protected、public

其他修饰符：static、final (暂不考虑)

说明2：数据类型

任何基本数据类型(如int、Boolean) 或任何引用数据类型。

说明3：属性名

属于标识符，符合命名规则和规范即可。

变量的分类

局部变量(除形参外，必须显示初始化)

形参（方法、构造器中定义的变量）

方法局部变量（在方法中定义）

代码块局部变量（在代码块中定义）

在方法体内部声明的变量称为局部变量

成员变量

实例变量（不以static修饰）

类变量（以static修饰）

在方法体外，类体内声明的变量称为成员变量

对象属性的默认初始化赋值

属性赋值过程

默认初始化

显式初始化

构造器中初始化

通过“对象.属性“或“对象.方法”的方式赋值

方法

什么是方法(method、函数):

方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。

将功能封装为方法的目的是，可以实现代码重用，简化代码

Java里的方法不能独立存在，所有的方法必须定义在类里。

方法的声明格式

修饰符返回值类型方法名（参数类型形参1, 参数类型形参2, …）｛方法体程序代码 return 返回值; ｝

注意

方法被调用一次，就会执行一次

没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法。

定义方法时，方法的结果应该返回给调用者，交由调用者处理。

方法中只能调用方法或属性，不可以在方法内部定义方法。

方法的重载

概念

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

特点

与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型或参数顺序)。调用时，根据方法参数列表的不同来区别。

可变个数的形参

public void method(Object...params)

说明

声明格式：方法名(参数的类型名 ...参数名)

可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个

可变个数形参的方法与同名的方法之间，彼此构成重载

可变参数方法的使用与方法参数部分使用数组是一致的

方法的参数部分有可变形参，需要放在形参声明的最后

在一个方法的形参位置，最多只能声明一个可变个数形参

方法参数的值传递机制

方法，必须由其所在类或对象调用才有意义。若方法含有参数：

形参：方法声明时的参数

实参：方法调用时实际传给形参的参数值

Java的实参值如何传入方法呢？

Java里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参

形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

构造器

构造器的特征

它具有与类相同的名称

它不声明返回值类型。（与声明为void不同）

不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

构造器的作用：创建对象；给对象进行初始化

语法格式

修饰符类名(参数列表){ 初始化语句; }

根据参数不同，构造器可以分为如下两类：

隐式无参构造器（系统默认提供）

显式定义一个或多个构造器（无参、有参）

注意：

Java语言中，每个类都至少有一个构造器

默认构造器的修饰符与所属类的修饰符一致

一旦显式定义了构造器，则系统不再提供默认构造器

一个类可以创建多个重载的构造器

父类的构造器不可被子类继承

JavaBean

JavaBean是一种Java语言写成的可重用组件

特点

类是公共的

有一个无参的公共的构造器

有属性，且有对应的get、set方法

用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

this关键字

this是什么？

在Java中，this关键字比较难理解，它的作用和其词义很接近。

它在方法内部使用，即这个方法所属对象的引用；

它在构造器内部使用，表示该构造器正在初始化的对象。

this可以调用类的属性、方法和构造器

什么时候使用this关键字呢？

当在方法内需要用到调用该方法的对象时，就用this。具体的：我们可以用this来区分属性和局部变量。

在任意方法或构造器内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性。不过，通常我们都习惯省略this。

当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量

使用this访问属性和方法时，如果在本类中未找到，会从父类中查找

this可以作为一个类中构造器相互调用的特殊格式

注意

可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！

明确：构造器中不能通过"this(形参列表)"的方式调用自身构造器

如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了 "this(形参列表)"

"this(形参列表)"必须声明在类的构造器的首行！

在类的一个构造器中，最多只能声明一个"this(形参列表)"

final关键字

在Java中声明类、变量和方法时，可使用关键字final来修饰,表示“最终的”。

final标记的类不能被继承。（提高安全性，提高程序的可读性。）

String类、System类、StringBuffer类

final标记的方法不能被子类重写。

比如：Object类中的getClass()。

final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次。

final标记的成员变量必须在声明时或在每个构造器中或代码块中显式赋值，然后才能使用。

关键字：package、import

package

package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。它的格式为：package 顶层包名.子包名 ;

包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；

包通常用小写单词标识。通常使用所在公司域名的倒置：com.atguigu.xxx

包的作用

包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式

包可以包含类和子包，划分项目层次，便于管理

解决类命名冲突的问题

控制访问权限

import

为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。import语句告诉编译器到哪里去寻找类。

注意

在源文件中使用import显式的导入指定包下的类或接口

声明在包的声明和类的声明之间。

如果需要导入多个类或接口，那么就并列显式多个import语句即可

举例：可以使用java.util.*的方式，一次性导入util包下所有的类或接口。

如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。

如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。

如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。

import static组合的使用：调用指定类或接口下的静态的属性或方法

代码块

代码块(或初始化块)的作用：

对Java类或对象进行初始化

代码块(或初始化块)的分类：

一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块(static block)

没有使用static修饰的，为非静态代码块。

static代码块通常用于初始化static的属性

静态代码块

可以有输出语句。

可以对类的属性、类的声明进行初始化操作。

不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。

若有多个静态的代码块，那么按照从上到下的顺序依次执行。

静态代码块的执行要先于非静态代码块。

静态代码块随着类的加载而加载，且只执行一次。

非静态代码块

可以有输出语句。

可以对类的属性、类的声明进行初始化操作。

除了调用非静态的结构外，还可以调用静态的变量或方法。

若有多个非静态的代码块，那么按照从上到下的顺序依次执行。

每次创建对象的时候，都会执行一次。且先于构造器执行。

内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。

在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。

Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。

Inner class的名字不能与包含它的外部类类名相同；

分类：

成员内部类（static成员内部类和非static成员内部类）

如何使用局部内部类

只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类

但是它的对象可以通过外部方法的返回值返回使用，返回值类型只能是局部内部类的父类或父接口类型

局部内部类的特点

内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号，以及数字编号。

只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类。

局部内部类可以使用外部类的成员，包括私有的。

局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。

局部内部类和局部变量地位类似，不能使用public,protected,缺省,private

局部内部类不能使用static修饰，因此也不能包含静态成员

局部内部类（不谈修饰符）、匿名内部类

成员内部类作为类的成员的角色：

和外部类不同，Inner class还可以声明为private或protected；

可以调用外部类的结构

Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量

成员内部类作为类的角色：

可以在内部定义属性、方法、构造器等结构

可以声明为abstract类，因此可以被其它的内部类继承

可以声明为final的

编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）

【注意】

非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员

内部类中才可声明static成员。

外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式

成员内部类可以直接使用外部类的所有成员，包括私有的数据

当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的

匿名内部类

匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

格式：

new 父类构造器（实参列表）|实现接口(){ //匿名内部类的类体部分 }

匿名内部类的特点

匿名内部类必须继承父类或实现接口

匿名内部类只能有一个对象

匿名内部类对象只能使用多态形式引用

对象的创建和使用

创建对象语法：类名对象名 = new 类名();

使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）

类的访问机制：

在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。（例外：static方法访问非static，编译不通过。）

在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。

内存解析

堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在 Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。

通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、 char 、 short 、 int 、 float 、 long 、 double）、对象引用（reference类型，它不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放。

方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

三大特征

封装

为什么需要封装?

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

高内聚：类的内部数据操作细节自己完成，不允许外部干涉；

低耦合：仅对外暴露少量的方法用于使用。

信息封装

Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：

隐藏一个类中不需要对外提供的实现细节；

使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；

便于修改，增强代码的可维护性；

访问权限修饰符

classs的访问权限修饰符只能使用public和default(缺省)

继承

为什么要有继承？

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

此处的多个类称为子类(派生类)，单独的这个类称为父类(基类或超类)。可以理解为:“子类 is a 父类”

类继承语法规则:

class Subclass extends SuperClass{ }

作用：

继承的出现减少了代码冗余，提高了代码的复用性。

继承的出现，更有利于功能的扩展。

继承的出现让类与类之间产生了关系，提供了多态的前提。

注意

不要仅为了获取其他类中某个功能而去继承

子类继承了父类，就继承了父类的方法和属性。

在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。

在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”

关于继承的规则：

子类不能直接访问父类中私有的(private)的成员变量和方法。

Java只支持单继承和多层继承，不允许多重继承

一个子类只能有一个父类

一个父类可以派生出多个子类

方法重写

定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

要求：

子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表

子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型

子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限

子类不能重写父类中声明为private权限的方法

子类方法抛出的异常不能大于父类被重写方法的异常

注意：

子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。

super关键字

在Java类中使用super来调用父类中的指定操作：

super可用于访问父类中定义的属性

super可用于调用父类中定义的成员方法

super可用于在子类构造器中调用父类的构造器

注意：

尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员

super的追溯不仅限于直接父类

super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

调用父类的构造器

子类中所有的构造器默认都会访问父类中空参数的构造器

当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器。同时，只能”二选一”，且必须放在构造器的首行

如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错

this和super的区别

子类对象实例化过程

多态

Object类的使用

Object类是所有Java类的根父类

如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类

多态性，是面向对象中最重要的概念，在Java中的体现：

对象的多态性：父类的引用指向子类的对象

可以直接应用在抽象类和接口上

Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。

若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)

“看左边”：看的是父类的引用（父类中不具备子类特有的方法）

“看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）

对象的多态

在Java中,子类的对象可以替代父类的对象使用

一个变量只能有一种确定的数据类型

一个引用类型变量可能指向(引用)多种不同类型的对象

子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。

一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法

虚拟方法调用

子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

重载与重写

从编译和运行的角度看：

重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。

所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；

而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。

instanceof操作符

x instanceof A：检验x是否为类A的对象，返回值为boolean型。

要求x所属的类与类A必须是子类和父类的关系，否则编译错误。

如果x属于类A的子类B，x instanceof A值也为true。

对象类型转换

基本数据类型的Casting：

自动类型转换：小的数据类型可以自动转换成大的数据类型

强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型

对Java对象的强制类型转换称为造型

从子类到父类的类型转换可以自动进行

从父类到子类的类型转换必须通过造型(强制类型转换)实现

无继承关系的引用类型间的转换是非法的

在造型前可以使用instanceof操作符测试一个对象的类型

子类继承父类

若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中。

对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量

==操作符与equals方法

基本类型比较值:只要两个变量的值相等，即为true。

引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才返回true。

用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本数据类型除外)，否则编译出错

equals()：所有类都继承了Object，也就获得了equals()方法。还可以重写。

只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象。

格式:obj1.equals(obj2)

特例：当用equals() 方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象；

原因：在这些类中重写了Object类的equals()方法。

当自定义使用equals()时，可以重写。用于比较两个对象的“内容”是否都相等

重写equals()方法的原则

对称性：如果x.equals(y)返回是“ true ”，那么y.equals(x) 也应该返回是“true”。

自反性：x.equals(x)必须返回是“true”。

传递性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。

一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。

任何情况下，x.equals(null)，永远返回是“false”；

x.equals(和x不同类型的对象)永远返回是“false”。

toString方法

toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。

在进行String与其它类型数据的连接操作时，自动调用toString()方法

可以根据需要在用户自定义类型中重写toString()方法如String类重写了toString()方法，返回字符串的值。

基本类型数据转换为String类型时，调用了对应包装类的toString()方法

包装类(Wrapper)的使用

针对八种基本数据类型定义相应的引用类型—包装类（封装类）

有了类的特点，就可以调用类中的方法，Java才是真正的面向对象

基本数据类型包装成类的实例----装箱

获得包装类对象中包装的基本类型变量----拆箱

字符串转换成基本数据类型

基本数据类型转换成字符串

static关键字

类属性、类方法的设计思想

类属性作为该类各个对象之间共享的变量。在设计类时,分析哪些属性不因对象的不同而改变，将这些属性设置为类属性。相应的方法设置为类方法。

如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用。

使用范围：

属性

方法

代码块

内部类

被修饰后成员的特点：

随着类的加载而加载

优先于对象存在

修饰的成员，被所有对象所共享

访问权限允许时，可不创建对象，直接被类调用

类方法

没有对象的实例时，可以用类名.方法名()的形式访问由static修饰的类方法

在static方法内部只能访问类的static修饰的属性或方法，不能访问类的非static的结构

因为不需要实例就可以访问static方法，因此static方法内部不能有this。(也不能有super ? YES!)

static修饰的方法不能被重写

抽象类与抽象方法

用abstract关键字来修饰一个类，这个类叫做抽象类。

用abstract来修饰一个方法，该方法叫做抽象方法。

抽象方法：只有方法的声明，没有方法的实现。以分号结束

含有抽象方法的类必须被声明为抽象类。

抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。

不能用abstract修饰变量、代码块、构造器

不能用abstract修饰私有方法、静态方法、final的方法、final的类。

接口

接口就是规范，定义的是一组规则

继承是一个"是不是"的关系，而接口实现则是 "能不能" 的关系。

接口(interface)是抽象方法和常量值定义的集合。

接口的特点：

用interface来定义。

接口中的所有成员变量都默认是由public static final修饰的。

接口中的所有抽象方法都默认是由public abstract修饰的。

接口中没有构造器。

接口采用多继承机制。

定义Java类的语法格式：先写extends，后写implements

class SubClass extends SuperClass implements InterfaceA{ }

一个类可以实现多个接口，接口也可以继承其它接口

实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类

接口的主要用途就是被实现类实现。（面向接口编程）

与继承关系类似，接口与实现类之间存在多态性

接口和类是并列关系，或者可以理解为一种特殊的类。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义 (JDK7.0及之前)，而没有变量和方法的实现。

接口与抽象类

Java 8中关于接口的改进

Java 8中，你可以为接口添加静态方法和默认方法。从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。

静态方法：使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。

默认方法：默认方法使用 default 关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。比如：java 8 API中对Collection、List、Comparator等接口提供了丰富的默认方法。

接口的默认方法

若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现：接口冲突。

解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突。

若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非抽象方法，则不会出现冲突问题。因为此时遵守：类优先原则。接口中具有相同名称和参数的默认方法会被忽略。

泛型

自定义泛型

泛型声明

interface List<T>

class GenTest<K,V>

T只能是类，不能用基本数据类型填充。但可以使用包装类填充

泛型实例化

List<String> strList = new ArrayList<String>(); Iterator<Customer> iterator = customers.iterator();

注意事项

泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：<E1,E2,E3>

泛型类的构造器如下：public GenericClass(){}。而下面是错误的：public GenericClass<E>(){}

实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。

泛型不同的引用不能相互赋值。

尽管在编译时ArrayList<String>和ArrayList<Integer>是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。

泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。经验：泛型要使用一路都用。要不用，一路都不要用。

如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。

jdk1.7，泛型的简化操作：ArrayList<Fruit> flist = new ArrayList<>();

泛型的指定中不能使用基本数据类型，可以使用包装类替换。

在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。

异常类不能是泛型的

不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity];

参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。

父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

子类不保留父类的泛型：按需实现

没有类型擦除

具体类型

子类保留父类的泛型：泛型子类

全部保留

部分保留

结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型

泛型方法

[访问权限]<泛型>返回类型方法名([泛型标识参数名称])抛出的异常

通配符？

List<?>是List<String>、List<Object>等各种泛型List的父类。

List<?>不能写入数据

注意事项

不能用于泛型方法声明的返回值中

不能用于泛型类的声明中

不能用于创建对象上

有限制的通配符

上限extends

<? extends Number>

<? extends Comparable>

下限super

<? super Number>

异常处理

用户自定义异常类

一般地，用户自定义异常类都是RuntimeException的子类。

自定义异常类通常需要编写几个重载的构造器。

自定义异常需要提供serialVersionUID

自定义的异常通过throw抛出。

自定义异常最重要的是异常类的名字，当异常出现时，可以根据名字判断异常类型。

异常处理机制

在编写程序时，经常要在可能出现错误的地方加上检测的代码，如进行x/y运算时，要检测分母为0，数据为空，输入的不是数据而是字符等。过多的if-else分支会导致程序的代码加长、臃肿，可读性差。因此采用异常处理机制。

Java异常处理

Java采用的异常处理机制，是将异常处理的程序代码集中在一起，

与正常的程序代码分开，使得程序简洁、优雅，并易于维护。

try-catch-finally

Java提供的是异常处理的抓抛模型。

Java程序的执行过程中如出现异常，会生成一个异常类对象，该异常对象将被提交给Java运行时系统，这个过程称为抛出 (throw)异常。

异常对象的生成

由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，如果在当前代码中没有找到相应的处理程序，就会在后台自动创建一个对应异常类的实例对象并抛出——自动抛出

由开发人员手动创建：Exception exception = new ClassCastException();——创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样

异常的抛出机制

如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。这一过程称为捕获(catch)异常。

如果一个异常回到main()方法，并且main()也不处理，则程序运行终止。

程序员通常只能处理Exception，而对Error无能为力。

异常处理是通过try-catch-finally语句实现的

try

捕获异常的第一步是用try{…}语句块选定捕获异常的范围，将可能出现异常的代码放在try语句块中。

catch(Exceptiontype e)

在catch语句块中是对异常对象进行处理的代码。每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。

如果明确知道产生的是何种异常，可以用该异常类作为catch的参数；也可以用其父类作为catch的参数。

比如：可以用ArithmeticException类作为参数的地方，就可以用RuntimeException类作为参数，或者用所有异常的父类Exception类作为参数。但不能是与ArithmeticException类无关的异常，如NullPointerException（catch中的语句将不会执行）。

finally

捕获异常的最后一步是通过finally语句为异常处理提供一个统一的出口，使得在控制流转到程序的其它部分以前，能够对程序的状态作统一的管理。

不论在try代码块中是否发生了异常事件，catch语句是否执行，catch语句是否有异常，catch语句中是否有return， finally块中的语句都会被执行。

finally语句和catch语句是任选的

捕获异常的有关信息

与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。

getMessage()获取异常信息，返回字符串

printStackTrace()获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

不捕获异常时的情况

前面使用的异常都是RuntimeException类或是它的子类，这些类的异常的特点是：即使没有使用try和catch捕获，Java自己也能捕获，并且编译通过( 但运行时会发生异常使得程序运行终止 )。

如果抛出的异常是IOException等类型的非运行时异常，则必须捕获，否则编译错误。也就是说，我们必须处理编译时异常，将异常进行捕捉，转化为运行时异常

throws+异常类型

声明抛出异常是Java中处理异常的第二种方式

如果一个方法(中的语句执行时)可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。

在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。

重写方法声明抛出异常的原则

重写方法不能抛出比被重写方法范围更大的异常类型。在多态的情况下，对methodA()方法的调用-异常的捕获按父类声明的异常处理。

异常概述与异常体系结构

异常：在Java语言中，将程序执行中发生的不正常情况称为“异常”。(开发过程中的语法错误和逻辑错误不是异常)

Java程序在执行过程中所发生的异常事件可分为两类：

Error：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError和OOM。一般不编写针对性的代码进行处理。

Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理

空指针访问

试图读取不存在的文件

网络连接中断

数组角标越界

解决方法

遇到错误终止程序运行

编写程序时，考虑错误的检测、错误信息的提示和错误的处理

捕获错误最理想的是在编译期间，但有的错误只有在运行时才发生

除数为零

数组下表越界

分类

编译时异常

运行时异常

是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该积极避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常。

对于这类异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响。

编译时异常

是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。编译器要求Java程序必须捕获或声明所有编译时异常。

对于这类异常，如果程序不处理，可能会带来意想不到的结果。

常见异常

java.lang.RuntimeException

ArrayIndexOutOfBoundsException

ClassCastException

NullPointerException

ArithmeticException

NumberFormatException

InputMismatchException

java.io.IOExeption

FileNotFoundException

EOFException

java.lang.ClassNotFoundException

java.lang.InterruptedException

java.io.FileNotFoundException

java.sql.SQLException

手动抛出异常

Java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要使用人工创建并抛出。

首先要生成异常类对象，然后通过throw语句实现抛出操作(提交给Java运行环境)。

可以抛出的异常必须是Throwable或其子类的实例。

多线程

线程的通信

wait() 与 notify() 和 notifyAll()

wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。

notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待

notifyAll ()：唤醒正在排队等待资源的所有线程结束等待

概要

这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常。

因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。

wait() 方法

在当前线程中调用方法：对象名.wait()

使当前线程进入等待（某对象）状态，直到另一线程对该对象发出 notify(或notifyAll) 为止。

调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

调用此方法后，当前线程将释放对象监控权，然后进入等待

在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。

notify()/notifyAll()

在当前线程中调用方法：对象名.notify()

功能：唤醒等待该对象监控权的一个/所有线程。

调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

线程的同步

问题的提出

多个线程执行的不确定性引起执行结果的不稳定

多个线程对账本的共享，会造成操作的不完整性，会破坏数据

问题的原因

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

解决办法

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

同步机制

Synchronized的使用方法

同步代码块

同步方法

同步锁

同步锁机制：对于并发工作，你需要某种方式来防止两个任务访问相同的资源（其实就是共享资源竞争）。防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了。

synchronized的锁是什么

任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）

同步方法的锁：静态方法（类名.class）、非静态方法（this）

同步代码块：自己指定，很多时候也是指定为this或类名.class

释放锁的操作

当前线程的同步方法、同步代码块执行结束。

当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。

当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。

当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁

不会释放锁的操作

线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行

线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。

应尽量避免使用suspend()和resume()来控制线程

注意事项

必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全

一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块（指定需谨慎）

线程的死锁问题

死锁

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

解决方法

专门的算法、原则

尽量减少同步资源的定义

尽量避免嵌套同步

Lock(锁)

从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

synchronized 与 Lock 的对比

Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放

Lock只有代码块锁，synchronized有代码块锁和方法锁

使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有

更好的扩展性（提供更多的子类）

优先使用顺序

Lock->同步代码块（已经进入了方法体，分配了相应资源）->同步方法(在方法体之外)

同步的范围

如何找问题，即代码是否存在线程安全

明确哪些代码是多线程运行的代码

明确多个线程是否有共享数据

明确多线程运行代码中是否有多条语句操作共享数据

如何解决

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。即所有操作共享数据的这些语句都要放在同步范围中

切记

范围太小：没锁住所有有安全问题的代码

范围太大：没发挥多线程的功能。

线程的生命周期

JDK中用Thread.State类定义了线程的几种状态

新建

当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态

就绪

处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源

运行

当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能

阻塞

在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中

止自己的执行，进入阻塞状态

死亡

线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

线程状态转换图

线程的分类

守护线程

用户线程

区别和联系

守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。

Java垃圾回收就是一个典型的守护线程

若JVM中都是守护线程，当前JVM将退出

它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开

基本概念

程序

是为完成特定任务、用某种语言编写的一组指令的集合

一段静态的代码

进程

是程序的一次执行过程，或是正在运行的一个程序

是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期

进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

线程

进程可进一步细化为线程，是一个程序内部的一条执行路径

若一个进程同一时间并行执行多个线程，就是支持多线程的

线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小

一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

并行与并发

多个CPU同时执行多个任务。比如：多个人同时做不同的事

一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事

多线程程序的优点

提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

提高计算机系统CPU的利用率

改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

何时需要多线程

程序需要同时执行两个或多个任务。

程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等

需要一些后台运行的程序时

线程的创建和使用

API中创建线程的两种方式

继承Thread类

定义子类继承Thread类。

子类中重写Thread类中的run方法。

创建Thread子类对象，即创建了线程对象。

调用线程对象start方法：启动线程，调用run方法。

注意事项

子主题

如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。

run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU

调度决定。

想要启动多线程，必须调用start方法。

一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。

Thread类

特性

通过该Thread对象的start()方法来启动这个线程，而非直接调用run()

每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体

构造器

Thread()：创建新的Thread对象

Thread(String threadname)：创建线程并指定线程实例名

Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法

Thread(Runnable target, String name)：创建新的Thread对象

Thread类的相关方法

void start()

run()

String getName()

void setName()

static Thread currentThread()

static void yield()

join()

static void sleep(long millis)

stop()

boolean isAlive()

实现Runnable接口

定义子类，实现Runnable接口。

子类中重写Runnable接口中的run方法。

通过Thread类含参构造器创建线程对象。

将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。

调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

继承方式和实现方式的区别和联系

区别

继承Thread：线程代码存放Thread子类run方法中。

实现Runnable：线程代码存在接口的子类的run方法。

实现方式的好处

避免了单继承的局限性

多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

JDK5.0新增线程创建方式

新增方式一：实现Callable接口

与使用Runnable相比， Callable功能更强大些

相比run()方法，可以有返回值

方法可以抛出异常

支持泛型的返回值

需要借助FutureTask类，比如获取返回结果

Future接口

可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。

FutrueTask是Futrue接口的唯一的实现类

FutureTask 同时实现了Runnable, Future接口。它既可以作为

Runnable被线程执行，又可以作为Future得到Callable的返回值

新增方式二：使用线程池

好处

提高响应速度（减少了创建新线程的时间）

降低资源消耗（重复利用线程池中线程，不需要每次都创建）

便于线程管理

corePoolSize：核心池的大小

maximumPoolSize：最大线程数

keepAliveTime：线程没有任务时最多保持多长时间后会终止

背景

经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

线程池相关API

线程池接口

ExecutorService

提供的方法

void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable

<T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般又来执行Callable

void shutdown() ：关闭连接池

常见子类

ThreadPoolExecutor

工具类、工厂类

Executors

提供的方法

Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池

Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池

Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池

Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运

行命令或者定期地执行。

线程的调度

调度策略

时间片

抢占式

高优先级的线程抢占CPU

Java的调度方法

同优先级线程组成先进先出队列（先到先服务），使用时间片策略

对高优先级，使用优先调度的抢占式策略

线程的优先级

线程的优先级等级

MAX_PRIORITY：10

MIN _PRIORITY：1

NORM_PRIORITY：5

涉及的方法

getPriority() ：返回线程优先值

setPriority(int newPriority) ：改变线程的优先级

说明

线程创建时继承父线程的优先级

低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

集合

Map接口

特点

key-value映射

key使用Set来存放，不允许重复

方法

添加、删除、修改

Object put(Object key, Object value)

void putAll(Map m)

Object remove(Object key)

void clear()

查询

Object get(Object key)

boolean containsKey(Object key)

boolean containsValue(Object value)

int size()

boolean isEmpty()

boolean equals(Object obj)

元视图

Set keySet()

Collection values()

Set entrySet()

实现类

HashMap

特点

允许null键和null值

存储结构

jdk7

数组+链表

jdk8

数组+链表+红黑树

重要常量

DEFAULT_INITIAL_CAPACITY

默认容量

MAXIMUM_CAPACITY

最大容量

DEFAULT_LOAD_FACTOR

默认加载因子

TREEIFY_THRESHOLD

树化阈值

UNTREEIFY_THRESHOLD

反树化阈值

MIN_TREEIFY_CAPACITY

最小树化容量

table

存储元素的数组

entrySet

存储元素的集

modCount

HashMap修改的次数

threshold

扩容的临界值

loadFactor

加载因子

子类

LinkedHashMap

存储结构

在HashMap的基础上使用双向链表存储元素顺序

特点

有序迭代顺序和Key-Value插入顺序一致

TreeMap

特点

有序

存储结构

红黑树

排序(同TreeSet)

自然排序

所有元素的Key必须实现Comparable接口，并且所有的Key都是同一个类的对象

定制排序

创建TreeMap时，传入一个Comparator对象

HashTable

特点

线程安全

不允许使用null做为Key和Value

不保证顺序

子类

Properties

特点

主要用于处理属性文件

方法

getProperty(String key)

setProperty(String key,String value)

Collections工具类

一个操作Set、List和Map等集合的工具类

方法

排序

reverse(List)

shuffle(List)

sort(List)

sort(List,Comparator)

swap(List, int , int)

查找、替换

Object max(Collection)

Object max(Collection,Comparator)

Object min(Collection)

Object min(Collection,Comparator)

int frequency(Collection, Object)

void copy(List dest, List src)

boolean replaceAll(List list, Object oldVal, Object newVal)

同步控制

synchronizedCollection(Collection<T> c)

synchronizedList(List<T>list)

synchronizedMap(Map<K,V>m)

synchronizedSet(Set<T>s)

synchronizedSortedMap(SortedMap<K,V>m)

synchronizedSortedSet(SortedSet<T>s)

Collection接口

迭代器

Iterator

方法

hasNext()

next()

remove()

注意：在遍历过程中不能修改集合对象但是可以调用迭代器的remove()方法

使用foreach循环遍历集合本质时使用迭代器

基础方法

添加

add(Object ob)

addAll(Collection coll)

获取有效元素个数

int size()

清空集合

void clear()

是否为空集合

boolean isEmpty()

是否包含某个元素

boolean contains(Object obj)

boolean containsAll(Collection c)

删除

boolean remove(Object obj)

boolean removeAll(Collection coll)

取交集

boolean retainAll(Collection c)

集合相等

boolean equals(Object obj)

转成对象数组

Object[]toArray()

获取hash值

hashCode()

遍历

iterator()

子接口

List

特点

元素有序

可重复

实现类

ArrayList

本质：变长数组

jdk1.7：饿汉式，直接创建一个初始容量为10的数组

jdk1.8：懒汉式，一开始创建一个长度为0的数组，当添加元素是再创建一个容量为10的数组

方法

Arrays.asList()返回固定长度的List集合

LinkedList

本质：双向链表

方法

void addFirst(Object obj)

void addLast(Object obj)

Object getFirst()

Object getLast()

Object removeFirst()

Object rmoveLast()

Vector

类似于ArrayList，主要区别是线程安全

方法

void addElement(Object obj)

void insertElementAt(Object obj, int index)

void setElementAt(Object obj, int index)

void removeElement(Object obj)

void removeAllElements()

通用方法

void add(int index, Object obj)

boolean addAll(int index, Collection coll)

Object get(int index)

int indexOf(Object obj)

int lastIndexOf(Object obj)

Object remove(int index)

Object set(int index, Object obj)

List subList(int fromIndex, int toIndex)

Set

特点

不可重复

实现类

HashSet

特点

线程不安全

元素可以为null

顺序不一定

通过hashCode和equals()方法比较对象是否相等

子类

LinkedHashSet

结构

双向链表

子接口

SortedSet

实现类

TreeSet

结构

红黑树

特点

有序，查询快

方法

Comparator comparator()

Object first()

Object last()

Object lower(Object o)

Object higher(Object o)

SortedSet subSet(fromElement,toElement)

SortedSet headSet(toElement)

SortedSet tailSet(fromElement)

排序方式

自然排序

通过调用集合元素的compareTo(Object obj)方法来比较

定制排序

通过Comparator接口来实现。需要重写compare(T o1,T o2)方法

TreeSet中的对象必须实现Comparable接口，实现Comparable的类必须实现compareTo(Object obj)方法，两个对象即通过compareTo(Object obj)方法的返回值来比较大小

集合概述

Java 集合可分为 Collection 和 Map 两种体系

Collection接口：单列数据，定义了存取一组对象的方法的集合

List：元素有序、可重复的集合

Set：元素无序、不可重复的集合

 Map接口：双列数据，保存具有映射关系“key-value对”的集合

Queue

SortedSet

Collections

TreeMap

SortedMap

Comparable

Set

Comparator

HashSet

Collections

Collection

Map

Properties

LinkedHashMap

HashMap

List

HashTable

LinkedList

Comparator

Comparable

ArrayList

Vector

Iterator

ListIterator

新特性

JDK更新

集合的流式操作

并发

Arrays

Number和Math

IO/NIO的改进

Reflection获取形参名

String:join()

Files

新编译工具

JVM中Metaspace取代PermGen空间

接口增强

新的时间和日期API

重复注解

类型注解

通用目标类型推断

lambda表达式

为什么使用Lambda表达式

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

语法

Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ，该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分：

左侧：指定了 Lambda 表达式需要的参数列表

右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即Lambda 表达式要执行的功能。

语法格式一：无参，无返回值

语法格式二：Lambda 需要一个参数，但是没有返回值。

语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略

语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值

语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略

类型推断

上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断”。

函数式(Functional)接口

什么是函数式(Functional)接口

只包含一个抽象方法的接口，称为函数式接口。

你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常(即：非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明）。

我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

在java.util.function包下定义了Java 8 的丰富的函数式接口

如何理解函数式接口

Java从诞生日起就是一直倡导“一切皆对象”，在Java里面面向对象(OOP) 编程是一切。但是随着python、scala等语言的兴起和新技术的挑战，Java不得不做出调整以便支持更加广泛的技术要求，也即java不但可以支持OOP还可以支持OOF（面向函数编程）

在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中，Lambda表达式的类型是函数。但是在Java8中，有所不同。在 Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型——函数式接口。

简单的说，在Java8中，Lambda表达式就是一个函数式接口的实例。这就是 Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。

所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。

函数式接口举例

自定义函数式接口

函数式接口中使用泛型

作为参数传递 Lambda 表达式

作为参数传递 Lambda 表达式：为了将 Lambda 表达式作为参数传递，接收Lambda表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口的类型。

Java 内置四大核心函数式接口

其他接口

方法引用和构造器引用和数组引用

方法引用(Method References)

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！

方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。

要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！

格式：使用操作符“::” 将类(或对象) 与方法名分隔开来。

如下三种主要使用情况：

对象::实例方法名

类::静态方法名

类::实例方法名

举例

注意：当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数(或无参数)时：ClassName::methodName

构造器引用

格式：ClassName::new

与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法，要求构造器参数列表要与接口中抽象方法的参数列表一致！且方法的返回值即为构造器对应类的对象。

举例

数组引用

格式： type[] :: new

Stream API

Stream API说明

Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API。

Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用 Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

为什么要使用Stream API

实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongDB，Radis等，而这些NoSQL的数据就需要 Java层面去处理。

Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算。

什么是 Stream

Stream到底是什么呢？

是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。 “集合讲的是数据，Stream讲的是计算！”

注意：

①Stream 自己不会存储元素。

②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream 的操作三个步骤

1- 创建 Stream

一个数据源（如：集合、数组），获取一个流

2- 中间操作

一个中间操作链，对数据源的数据进行处理

3- 终止操作(终端操作)

一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

图例

创建Stream的方式

通过集合

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：

default Stream<E> stream() : 返回一个顺序流

default Stream<E> parallelStream() : 返回一个并行流

通过数组

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

static <T> Stream<T> stream(T[] array): 返回一个流

重载形式，能够处理对应基本类型的数组：

public static IntStream stream(int[] array)

public static LongStream stream(long[] array)

public static DoubleStream stream(double[] array)

通过Stream的of()

可以调用Stream类静态方法of()，通过显示值创建一个流。它可以接受任意数量的参数

public static<T> Stream<T> of(T... values) : 返回一个流

创建无限流

可以使用静态方法Stream.iterate()和Stream.generate()创建无限流

迭代

public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)

生成

public static<T> Stream<T> generate(Supplier<T> s)

Stream的中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

筛选与切片

映射

排序

Stream 的终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。

流进行了终止操作后，不能再次使用。

匹配与查找

规约

备注：map 和 reduce 的连接通常称为 map-reduce 模式，因 Google用它来进行网络搜索而出名。

收集

Collector 接口中方法的实现决定了如何对流执行收集的操作(如收集到 List、Set、 Map)。

另外， Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，

具体方法与实例如下表：

Optional类

到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类， Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。

Optional<T> 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。

Optional类的Javadoc描述如下：这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

Optional提供很多有用的方法，这样我们就不用显式进行空值检测。

创建Optional类对象的方法：

Optional.of(T t) : 创建一个 Optional 实例，t必须非空；

Optional.empty() : 创建一个空的 Optional 实例

Optional.ofNullable(T t)：t可以为null

判断Optional容器中是否包含对象：

boolean isPresent() : 判断是否包含对象

void ifPresent(Consumer<? super T> consumer) ：如果有值，就执行Consumer 接口的实现代码，并且该值会作为参数传给它。

获取Optional容器的对象：

T get(): 如果调用对象包含值，返回该值，否则抛异常

T orElse(T other) ：如果有值则将其返回，否则返回指定的other对象。

T orElseGet(Supplier<? extends T> other) ：如果有值则将其返回，否则返回由

Supplier接口实现提供的对象。

T orElseThrow(Supplier<? extends X> exceptionSupplier) ：如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。

枚举类与注解

注解

注解(Annotation)概述

从 JDK 5.0 开始, Java 增加了对元数据(MetaData) 的支持, 也就是Annotation(注解)

Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用 Annotation, 程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署。

Annotation可以像修饰符一样被使用, 可用于修饰包,类, 构造器, 方法, 成员变量, 参数, 局部变量的声明, 这些信息被保存在 Annotation 的 “name=value” 对中。

在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/Android中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗代码和XML配置等。

未来的开发模式都是基于注解的，JPA是基于注解的，Spring2.5以上都是基于注解的，Hibernate3.x以后也是基于注解的，现在的 Struts2有一部分也是基于注解的了，注解是一种趋势，一定程度上可以说：框架 = 注解 + 反射 + 设计模式。

常见的Annotation示例

使用Annotation时要在其前面增加@符号, 并把该Annotation当成一个修饰符使用。用于修饰它支持的程序元素

生成文档的注解

@author 标明开发该类模块的作者，多个作者之间使用,分割

@see 参考转向，也就是相关主题

@version 标明该类模块的版本

@param 对方法中某参数的说明，如果没有参数就不能写

@return 对方法返回值的说明，如果方法的返回值类型是void就不能写

@since 从哪个版本开始增加的

@exception 对方法可能抛出的异常进行说明，如果方法没有用throws显式抛出的异常就不能写

其中

@param @return 和 @exception 这三个标记都是只用于方法的。 @param的格式要求：@param 形参名形参类型形参说明 @return 的格式要求：@return 返回值类型返回值说明 @exception的格式要求：@exception 异常类型异常说明 @param和@exception可以并列多个

在编译时进行格式检查(JDK内置的三个基本注解)

@Override: 限定重写父类方法, 该注解只能用于方法

@Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择

@SuppressWarnings: 抑制编译器警告

跟踪代码依赖性，实现替代配置文件功能

自定义Annotation

定义新的Annotation类型使用 @interface 关键字

自定义注解自动继承了java.lang.annotation.Annotation接口

Annotation的成员变量在Annotation定义中以无参数方法的形式来声明。其方法名和返回值定义了该成员的名字和类型。我们称为配置参数。类型只能是八种基本数据类型、String类型、Class类型、enum类型、Annotation类型、以上所有类型的数组。

可以在定义Annotation的成员变量时为其指定初始值, 指定成员变量的初始值可使用default关键字

如果只有一个参数成员，建议使用参数名为value

如果定义的注解含有配置参数，那么使用时必须指定参数值，除非它有默认值。格式是“参数名 = 参数值”，如果只有一个参数成员，且名称为value，可以省略“value=”

没有成员定义的Annotation称为标记; 包含成员变量的Annotation称为元数据Annotation

注意：自定义注解必须配上注解的信息处理流程才有意义。

JDK中的元注解

JDK的元Annotation用于修饰其他Annotation 定义

JDK5.0提供了4个标准的meta-annotation类型，分别是：

Retention

@Retention: 只能用于修饰一个 Annotation 定义, 用于指定该 Annotation 的生命周期, @Rentention 包含一个 RetentionPolicy 类型的成员变量, 使用 @Rentention 时必须为该 value 成员变量指定值:

RetentionPolicy.SOURCE:在源文件中有效（即源文件保留），编译器直接丢弃这种策略的注释

RetentionPolicy.CLASS:在class文件中有效（即class保留），当运行 Java 程序时, JVM不会保留注解。这是默认值

RetentionPolicy.RUNTIME:在运行时有效（即运行时保留），当运行 Java 程序时, JVM 会保留注释。程序可以通过反射获取该注释。

Target

@Target: 用于修饰 Annotation 定义, 用于指定被修饰的 Annotation 能用于修饰哪些程序元素。 @Target也包含一个名为 value 的成员变量。

Documented

@Documented: 用于指定被该元Annotation修饰的Annotation类将被javadoc工具提取成文档。默认情况下，javadoc是不包括注解的。

定义为Documented的注解必须设置Retention值为RUNTIME。

Inherited

@Inherited: 被它修饰的 Annotation 将具有继承性。如果某个类使用了被@Inherited 修饰的 Annotation, 则其子类将自动具有该注解。

比如：如果把标有@Inherited注解的自定义的注解标注在类级别上，子类则可以继承父类类级别的注解

实际应用中，使用较少

利用反射获取注解信息（在反射部分涉及）

JDK 5.0 在 java.lang.reflect 包下新增了 AnnotatedElement 接口, 该接口代表程序中可以接受注解的程序元素

当一个Annotation 类型被定义为运行时Annotation 后, 该注解才是运行时可见, 当 class 文件被载入时保存在 class 文件中的 Annotation 才会被虚拟机读取

程序可以调用 AnnotatedElement对象的如下方法来访问 Annotation 信息

JDK 8中注解的新特性

Java 8对注解处理提供了两点改进：可重复的注解及可用于类型的注解。此外，反射也得到了加强，在Java8中能够得到方法参数的名称。这会简化标注在方法参数上的注解。

类型注解：

JDK1.8之后，关于元注解@Target的参数类型ElementType枚举值多了两个：

在Java 8之前，注解只能是在声明的地方所使用，Java8开始，注解可以应用在任何地方。

TYPE_PARAMETER,TYPE_USE。

ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中（如：泛型声明）。

ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。

枚举类

枚举类的使用

如何自定义枚举类

当需要定义一组常量时，强烈建议使用枚举类

如何使用关键字enum定义枚举类

Enum类的主要方法

实现接口的枚举类

枚举类的实现

JDK1.5之前需要自定义枚举类

JDK 1.5 新增的 enum 关键字用于定义枚举类

若枚举只有一个对象, 则可以作为一种单例模式的实现方式。

枚举类的属性

枚举类对象的属性不应允许被改动, 所以应该使用 private final 修饰

枚举类的使用 private final 修饰的属性应该在构造器中为其赋值

若枚举类显式的定义了带参数的构造器, 则在列出枚举值时也必须对应的传入参数

自定义枚举类

私有化类的构造器，保证不能在类的外部创建其对象

在类的内部创建枚举类的实例。声明为：public static final

对象如果有实例变量，应该声明为private final，并在构造器中初始化

使用说明

使用 enum 定义的枚举类默认继承了 java.lang.Enum类，因此不能再继承其他类

枚举类的构造器只能使用 private 权限修饰符

枚举类的所有实例必须在枚举类中显式列出(以, 分隔; 结尾)。列出的实例系统会自动添加 public static final 修饰

必须在枚举类的第一行声明枚举类对象

JDK1.5中可以在switch表达式中使用Enum定义的枚举类的对象作为表达式, case 子句可以直接使用枚举值的名字, 无需添加枚举类作为限定。

主要方法

valueOf

toString

equals

hashCode

getDeclaringClass

name

ordinal

compareTo

clone

实现接口的枚举类

和普通 Java 类一样，枚举类可以实现一个或多个接口

若每个枚举值在调用实现的接口方法呈现相同的行为方式，则只要统一实现该方法即可。

若需要每个枚举值在调用实现的接口方法呈现出不同的行为方式,则可以让每个枚举值分别来实现该方法

反射

Class类

子主题

常用方法

static Class forName()

Object newInstance()

getName()

Class getSuperClass()

Class[]getInterfaces()

ClassLoader getClassLoader()

Class getSupterclass()

Constructor[] getConstructors()

Field[] getDeclaredFields()

Method getMethod(String name, Class...paramTypes)

获取Class类的实例

Class clazz = Class.forName("java.lang.String")

Class clazz = String.class

Class clazz = "".getClass()

this.getClass().getClassLoader().loadClass("全类名")

拥有Class对象的类型

class

interface

enum

annotation

primitive type

void

类的加载

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口（即引用地址）。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。

链接：将Java类的二进制代码合并到JVM的运行状态之中的过程。

验证：确保加载的类信息符合JVM规范，例如：以cafe开头，没有安全方面的问题

准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。

解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

初始化：

执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。

当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。

虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步。

类的初始化

类的主动引用（一定会发生类的初始化）

当虚拟机启动，先初始化main方法所在的类

new一个类的对象

调用类的静态成员（除了final常量）和静态方法

使用java.lang.reflect包的方法对类进行反射调用

当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类

类的被动引用（不会发生类的初始化）

当访问一个静态域时，只有真正声明这个域的类才会被初始化

当通过子类引用父类的静态变量，不会导致子类初始化

通过数组定义类引用，不会触发此类的初始化

引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

Class对象的作用

创建类的对象

网络编程

小结

位于网络中的计算机具有唯一的IP地址，这样不同的主机可以互相区分。

客户端－服务器是一种最常见的网络应用程序模型。服务器是一个为其客户端提供某种特定服务的硬件或软件。客户机是一个用户应用程序，用于访问某台服务器提供的服务。端口号是对一个服务的访问场所，它用于区分同一物理计算机上的多个服务。套接字用于连接客户端和服务器，客户端和服务器之间的每个通信会话使用一个不同的套接字。TCP协议用于实现面向连接的会话。

Java 中有关网络方面的功能都定义在 java.net 程序包中。Java 用 InetAddress 对象表示 IP地址，该对象里有两个字段：主机名(String) 和 IP 地址(int)。

类 Socket 和 ServerSocket 实现了基于TCP协议的客户端－服务器程序。Socket是客户端和服务器之间的一个连接，连接创建的细节被隐藏了。这个连接提供了一个安全的数据传输通道，这是因为 TCP 协议可以解决数据在传送过程中的丢失、损坏、重复、乱序以及网络拥挤等问题，它保证数据可靠的传送。

类 URL 和 URLConnection 提供了最高级网络应用。URL 的网络资源的位置来同一表示 Internet 上各种网络资源。通过URL对象可以创建当前应用程序和 URL 表示的网络资源之间的连接，这样当前程序就可以读取网络资源数据，或者把自己的数据传送到网络上去。

URL编程

URL类

URL(Uniform Resource Locator)：统一资源定位符，它表示 Internet 上某一资源的地址。

它是一种具体的URI，即URL可以用来标识一个资源，而且还指明了如何locate这个资源。

通过 URL 我们可以访问 Internet 上的各种网络资源，比如最常见的 www，ftp站点。浏览器通过解析给定的 URL 可以在网络上查找相应的文件或其他资源。

URL的基本结构由5部分组成：

<传输协议>://<主机名>:<端口号>/<文件名>#片段名?参数列表

例如 : http://192.168.1.100:8080/helloworld/index.jsp#a?username=shkstart&password=123

#片段名：即锚点，例如看小说，直接定位到章节

参数列表格式：参数名=参数值&参数名=参数值....

为了表示URL，java.net 中实现了类 URL。我们可以通过下面的构造器来初始化一个 URL 对象：

public URL (String spec)：通过一个表示URL地址的字符串可以构造一个URL对象。例如：URL url = new URL ("http://www. atguigu.com/");

public URL(URL context, String spec)：通过基 URL 和相对 URL 构造一个 URL 对象。

URL类的构造器都声明抛出非运行时异常，必须要对这一异常进行处理，通常是用 try-catch 语句进行捕获。

一个URL对象生成后，其属性是不能被改变的，但可以通过它给定的方法来获取这些属性：

public String getProtocol( )

获取该URL的协议名

public String getHost( )

获取该URL的主机名

public String getPort( )

获取该URL的端口号

public String getPath( )

获取该URL的文件路径

public String getFile( )

获取该URL的文件名

public String getQuery()

获取该URL的查询名

针对HTTP协议的URLConnection类

URL的方法 openStream()：能从网络上读取数据

若希望输出数据，例如向服务器端的 CGI （公共网关接口-Common Gateway Interface-的简称，是用户浏览器和服务器端的应用程序进行连接的接口）程序发送一些数据，则必须先与URL建立连接，然后才能对其进行读写，此时需要使用 URLConnection 。

URLConnection：表示到URL所引用的远程对象的连接。当与一个URL建立连接时，首先要在一个 URL 对象上通过方法 openConnection() 生成对应的 URLConnection 对象。如果连接过程失败，将产生IOException.

URL netchinaren = new URL ("http://www.atguigu.com/index.shtml");

URLConnectonn u = netchinaren.openConnection( );

通过URLConnection对象获取的输入流和输出流，即可以与现有的CGI程序进行交互。

public Object getContent( ) throws IOException

public int getContentLength( )

public String getContentType( )

public long getDate( )

public long getLastModified( )

public InputStream getInputStream( )throws IOException

public OutputSteram getOutputStream( )throws IOException

URI、URL和URN的区别

URI，是uniform resource identifier，统一资源标识符，用来唯一的标识一个资源。而URL是uniform resource locator，统一资源定位符，它是一种具体的URI，即URL可以用来标识一个资源，而且还指明了如何locate这个资源。而URN，uniform resource name，统一资源命名，是通过名字来标识资源，比如mailto:java-net@java.sun.com。也就是说，URI是以一种抽象的，高层次概念定义统一资源标识，而URL和URN则是具体的资源标识的方式。URL 和URN都是一种URI。

在Java的URI中，一个URI实例可以代表绝对的，也可以是相对的，只要它符合URI的语法规则。而URL类则不仅符合语义，还包含了定位该资源的信息，因此它不能是相对的。

UDP网络编程

UDP网络通信

类 DatagramSocket 和 DatagramPacket 实现了基于 UDP 协议网络程序。

UDP数据报通过数据报套接字 DatagramSocket 发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。

DatagramPacket 对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。

UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接。如同发快递包裹一样。

DatagramSocket 类的常用方法

public DatagramSocket(int port)创建数据报套接字并将其绑定到本地主机上的指定端口。套接字将被绑定到通配符地址，IP 地址由内核来选择。

public void close()关闭此数据报套接字。

public void send(DatagramPacket p)从此套接字发送数据报包。DatagramPacket 包含的信息指示：将要发送的数据、其长度、远程主机的 IP 地址和远程主机的端口号。

public void receive(DatagramPacket p)从此套接字接收数据报包。当此方法返回时，DatagramPacket 的缓冲区填充了接收的数据。数据报包也包含发送方的 IP 地址和发送方机器上的端口号。此方法在接收到数据报前一直阻塞。数据报包对象的 length 字段包含所接收信息的长度。如果信息比包的长度长，该信息将被截短。

public InetAddress getLocalAddress()获取套接字绑定的本地地址。

public int getLocalPort()返回此套接字绑定的本地主机上的端口号。

public InetAddress getInetAddress()返回此套接字连接的地址。如果套接字未连接，则返回null。

public int getPort()返回此套接字的端口。如果套接字未连接，则返回 -1。

DatagramPacket类的常用方法

public DatagramPacket(byte[] buf,int length)构造 DatagramPacket，用来接收长度为length 的数据包。 length 参数必须小于等于 buf.length。

public DatagramPacket(byte[] buf,int length,InetAddress address,int port)构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。length 参数必须小于等于buf.length。

public InetAddress getAddress()返回某台机器的 IP 地址，此数据报将要发往该机器或者是从该机器接收到的。

public int getPort()返回某台远程主机的端口号，此数据报将要发往该主机或者是从该主机接收到的。

public byte[] getData()返回数据缓冲区。接收到的或将要发送的数据从缓冲区中的偏移量 offset 处开始，持续length 长度。

public int getLength()返回将要发送或接收到的数据的长度。

流程：

DatagramSocket与DatagramPacket

建立发送端，接收端

建立数据包

调用Socket的发送、接收方法

关闭Socket

网络编程概述

Java是 Internet 上的语言，它从语言级上提供了对网络应用程序的支持，程序员能够很容易开发常见的网络应用程序。

Java提供的网络类库，可以实现无痛的网络连接，联网的底层细节被隐藏在Java 的本机安装系统里，由 JVM 进行控制。并且 Java 实现了一个跨平台的网络库，程序员面对的是一个统一的网络编程环境。

网络基础

计算机网络

把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大、功能强的网络系统，从而使众多的计算机可以方便地互相传递信息、共享硬件、软件、数据信息等资源。

网络编程的目的：

直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯。

网络编程中有两个主要的问题

如何准确地定位网络上一台或多台主机；定位主机上的特定的应用

找到主机后如何可靠高效地进行数据传输

网络通信要素概述

如何实现网络中的主机互相通信

通信双方地址

IP地址

InetAddress

唯一的标识 Internet 上的计算机（通信实体）

本地回环地址(hostAddress)：127.0.0.1 主机名(hostName)：localhost

IP地址分类方式1：IPV4 和 IPV6

IPV4：4个字节组成，4个0-255。大概42亿，30亿都在北美，亚洲4亿。2011年初已经用尽。以点分十进制表示，如192.168.0.1

IPV6：128位（16个字节），写成8个无符号整数，每个整数用四个十六进制位表示，数之间用冒号（：）分开，如：3ffe:3201:1401:1280:c8ff:fe4d:db39:1984

IP地址分类方式2：公网地址(万维网使用)和私有地址(局域网使用)。192.168. 开头的就是私有址址，范围即为192.168.0.0--192.168.255.255，专门为组织机构内部使用

特点：不易记忆

InetAddress类

Internet上的主机有两种方式表示地址：

域名(hostName)：www.atguigu.com

IP 地址(hostAddress)：202.108.35.210

InetAddress类主要表示IP地址，两个子类：Inet4Address、Inet6Address。

InetAddress 类对象含有一个 Internet主机地址的域名和 IP 地址：www.atguigu.com 和 202.108.35.210。

域名容易记忆，当在连接网络时输入一个主机的域名后，域名服务器(DNS)负责将域名转化成IP地址，这样才能和主机建立连接。 -------域名解析

构造与常用方法

InetAddress类没有提供公共的构造器，而是提供了如下几个静态方法来获取InetAddress实例

public static InetAddress getLocalHost()

public static InetAddress getByName(String host)

InetAddress提供了如下几个常用的方法

public String getHostAddress()：返回 IP 地址字符串（以文本表现形式）。

public String getHostName()：获取此 IP 地址的主机名

public boolean isReachable(int timeout)：测试是否可以达到该地址

端口号

端口号标识正在计算机上运行的进程（程序）

不同的进程有不同的端口号

被规定为一个 16 位的整数 0~65535。

端口分类：

公认端口：0~1023。被预先定义的服务通信占用（如：HTTP占用端口80，FTP占用端口21，Telnet占用端口23）

注册端口：1024~49151。分配给用户进程或应用程序。（如：Tomcat占用端口8080，MySQL占用端口3306，Oracle占用端口1521等）。

动态/私有端口：49152~65535。

端口号与IP地址的组合得出一个网络套接字：Socket。

网络通信协议

计算机网络中实现通信必须有一些约定，即通信协议，对速率、传输代码、代码结构、传输控制步骤、出错控制等制定标准。

问题：网络协议太复杂

计算机网络通信涉及内容很多，比如指定源地址和目标地址，加密解密，压缩解压缩，差错控制，流量控制，路由控制，如何实现如此复杂的网络协议呢？

通信协议分层的思想

在制定协议时，把复杂成份分解成一些简单的成份，再将它们复合起来。最常用的复合方式是层次方式，即同层间可以通信、上一层可以调用下一层，而与再下一层不发生关系。各层互不影响，利于系统的开发和扩展。

TCP/IP协议簇

传输层协议中有两个非常重要的协议：

传输控制协议TCP(Transmission Control Protocol)

用户数据报协议UDP(User Datagram Protocol)。

TCP/IP 以其两个主要协议：传输控制协议(TCP)和网络互联协议(IP)而得名，实际上是一组协议，包括多个具有不同功能且互为关联的协议。

IP(Internet Protocol)协议是网络层的主要协议，支持网间互连的数据通信。

TCP/IP协议模型从更实用的角度出发，形成了高效的四层体系结构，即物理链路层、IP层、传输层和应用层。

TCP 和 UDP

TCP协议：

使用TCP协议前，须先建立TCP连接，形成传输数据通道

传输前，采用“三次握手”方式，点对点通信，是可靠的

TCP协议进行通信的两个应用进程：客户端、服务端。

在连接中可进行大数据量的传输

传输完毕，需释放已建立的连接，效率低

三次握手

四次握手

UDP协议：

将数据、源、目的封装成数据包，不需要建立连接

每个数据报的大小限制在64K内

发送不管对方是否准备好，接收方收到也不确认，故是不可靠的

可以广播发送

发送数据结束时无需释放资源，开销小，速度快

Socket

利用套接字(Socket)开发网络应用程序早已被广泛的采用，以至于成为事实上的标准。

网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字。

通信的两端都要有Socket，是两台机器间通信的端点。

网络通信其实就是Socket间的通信。

Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。

一般主动发起通信的应用程序属客户端，等待通信请求的为服务端。

Socket分类：

流套接字（stream socket）：使用TCP提供可依赖的字节流服务

数据报套接字（datagram socket）：使用UDP提供“尽力而为”的数据报服务

Socket类的常用构造器：

public Socket(InetAddress address,int port)创建一个流套接字并将其连接到指定IP 地址的指定端口号。

public Socket(String host,int port)创建一个流套接字并将其连接到指定主机上的指定端口号。

Socket类的常用方法：

public InputStream getInputStream()返回此套接字的输入流。可以用于接收网络消息

public OutputStream getOutputStream()返回此套接字的输出流。可以用于发送网络消息

public InetAddress getInetAddress()此套接字连接到的远程 IP 地址；如果套接字是未连接的，则返回 null。

public InetAddress getLocalAddress()获取套接字绑定的本地地址。即本端的IP地址

public int getPort()此套接字连接到的远程端口号；如果尚未连接套接字，则返回 0。

public int getLocalPort()返回此套接字绑定到的本地端口。如果尚未绑定套接字，则返回 -1。即本端的端口号。

public void close()关闭此套接字。套接字被关闭后，便不可在以后的网络连接中使用（即无法重新连接或重新绑定）。需要创建新的套接字对象。关闭此套接字也将会关闭该套接字的 InputStream 和 OutputStream。

public void shutdownInput()如果在套接字上调用 shutdownInput() 后从套接字输入流读取内容，则流将返回EOF（文件结束符）。即不能在从此套接字的输入流中接收任何数据。

public void shutdownOutput()禁用此套接字的输出流。对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接终止序列。如果在套接字上调用 shutdownOutput() 后写入套接字输出流，则该流将抛出 IOException。即不能通过此套接字的输出流发送任何数据。

一定的规则

OSI参考模型

TCP/IP参考模型

网络通信协议

TCP网络编程

基于Socket的TCP编程

Java语言的基于套接字编程分为服务端编程和客户端编程，其通信模型如图所示：

客户端Socket的工作过程包含以下四个基本的步骤：

创建 Socket：根据指定服务端的 IP 地址或端口号构造 Socket 类对象。若服务器端响应，则建立客户端到服务器的通信线路。若连接失败，会出现异常。

打开连接到Socket 的输入/出流：使用 getInputStream()方法获得输入流，使用 getOutputStream()方法获得输出流，进行数据传输

按照一定的协议对Socket 进行读/写操作：通过输入流读取服务器放入线路的信息（但不能读取自己放入线路的信息），通过输出流将信息写入线程。

关闭 Socket：断开客户端到服务器的连接，释放线路

客户端创建Socket对象

客户端程序可以使用Socket类创建对象，创建的同时会自动向服务器方发起连接。Socket的构造器是：

Socket(String host,int port)throws UnknownHostException,IOException：向服务器(域名是host。端口号为port)发起TCP连接，若成功，则创建Socket对象，否则抛出异常。

Socket(InetAddress address,int port)throws IOException：根据InetAddress对象所表示的 IP地址以及端口号port发起连接。

客户端建立socketAtClient对象的过程就是向服务器发出套接字连接请求

服务器程序的工作过程包含以下四个基本的步骤：

调用 ServerSocket(int port) ：创建一个服务器端套接字，并绑定到指定端口上。用于监听客户端的请求。

调用 accept()：监听连接请求，如果客户端请求连接，则接受连接，返回通信套接字对象。

调用该Socket类对象的 getOutputStream() 和 getInputStream ()：获取输出流和输入流，开始网络数据的发送和接收。

关闭ServerSocket和Socket对象：客户端访问结束，关闭通信套接字。

服务器建立 ServerSocket 对象

ServerSocket 对象负责等待客户端请求建立套接字连接，类似邮局某个窗口中的业务员。也就是说，服务器必须事先建立一个等待客户请求建立套接字连接的ServerSocket对象。

所谓“接收”客户的套接字请求，就是accept()方法会返回一个 Socket 对象

IO流

Java NIO

定义

Java NIO (New IO，Non-Blocking IO)是从Java 1.4版本开始引入的一套新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的(IO是面向流的)、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。

Java API中提供了两套NIO

一套是针对标准输入输出

另一套就是网络编程NIO。

java.nio.channels.Channel

FileChannel

处理本地文件

SocketChannel

TCP网络编程的客户端的Channel

ServerSocketChannel

TCP网络编程的服务端的Channel

DatagramChannel

UDP网络编程中发送端和接收端的Channel

Path、Paths和Files核心API

背景

早期的Java只提供了一个File类来访问文件系统，但File类的功能比较有限，所提供的方法性能也不高。而且，大多数方法在出错时仅返回失败，并不会提供异常信息。

NIO. 2为了弥补这种不足，引入了Path接口，代表一个平台无关的平台路径，描述了目录结构中文件的位置。Path可以看成是File类的升级版本，实际引用的资源也可以不存在。

过去的IO操作

import java.io.File; File file = new File("index.html");

现在的IO操作

import java.nio.file.Path; import java.nio.file.Paths; Path path = Paths.get("index.html");

同时，NIO.2在java.nio.file包下还提供了Files、Paths工具类，Files包含了大量静态的工具方法来操作文件；Paths则包含了两个返回Path的静态工厂方法。

Paths 类提供的静态 get() 方法用来获取 Path 对象：

static Path get(String first, String … more) : 用于将多个字符串串连成路径

static Path get(URI uri): 返回指定uri对应的Path路径

Path常用方法

String toString() ：返回调用 Path 对象的字符串表示形式

boolean startsWith(String path) : 判断是否以 path 路径开始

boolean endsWith(String path) : 判断是否以 path 路径结束

boolean isAbsolute() : 判断是否是绝对路径

Path getParent() ：返回Path对象包含整个路径，不包含 Path 对象指定的文件路径

Path getRoot() ：返回调用 Path 对象的根路径

Path getFileName() : 返回与调用 Path 对象关联的文件名

int getNameCount() : 返回Path 根目录后面元素的数量

Path getName(int idx) : 返回指定索引位置 idx 的路径名称

Path toAbsolutePath() : 作为绝对路径返回调用 Path 对象

Path resolve(Path p) :合并两个路径，返回合并后的路径对应的Path对象

File toFile(): 将Path转化为File类的对象

Files常用方法

Path copy(Path src, Path dest, CopyOption … how) : 文件的复制

Path createDirectory(Path path, FileAttribute<?> … attr) : 创建一个目录

Path createFile(Path path, FileAttribute<?> … arr) : 创建一个文件

void delete(Path path) : 删除一个文件/目录，如果不存在，执行报错

void deleteIfExists(Path path) : Path对应的文件/目录如果存在，执行删除

Path move(Path src, Path dest, CopyOption…how) : 将 src 移动到 dest 位置

long size(Path path) : 返回 path 指定文件的大小

用于判断

boolean exists(Path path, LinkOption … opts) : 判断文件是否存在

boolean isDirectory(Path path, LinkOption … opts) : 判断是否是目录

boolean isRegularFile(Path path, LinkOption … opts) : 判断是否是文件

boolean isHidden(Path path) : 判断是否是隐藏文件

boolean isReadable(Path path) : 判断文件是否可读

boolean isWritable(Path path) : 判断文件是否可写

boolean notExists(Path path, LinkOption … opts) : 判断文件是否不存在

用于操作文件内容

SeekableByteChannel newByteChannel(Path path, OpenOption…how) : 获取与指定文件的连接，how 指定打开方式。

DirectoryStream<Path> newDirectoryStream(Path path) : 打开 path 指定的目录

InputStream newInputStream(Path path, OpenOption…how):获取 InputStream 对象

OutputStream newOutputStream(Path path, OpenOption…how) : 获取 OutputStream 对象

处理流

缓冲流

为了提高数据读写的速度，Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组，缺省使用8192个字节(8Kb)的缓冲区。

缓冲流要“套接”在相应的节点流之上，根据数据操作单位可以把缓冲流分为：

BufferedInputStream 和 BufferedOutputStream

BufferedReader 和 BufferedWriter

当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区

当使用BufferedInputStream读取字节文件时，BufferedInputStream会一次性从文件中读取8192个(8Kb)，存在缓冲区中，直到缓冲区装满了，才重新从文件中读取下一个8192个字节数组。

向流中写入字节时，不会直接写到文件，先写到缓冲区中直到缓冲区写满， BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。使用方法 flush()可以强制将缓冲区的内容全部写入输出流

关闭流的顺序和打开流的顺序相反。只要关闭最外层流即可，关闭最外层流也会相应关闭内层节点流

flush()方法的使用：手动将buffer中内容写入文件

如果是带缓冲区的流对象的close()方法，不但会关闭流，还会在关闭流之前刷新缓冲区，关闭后不能再写出

转换流

转换流提供了在字节流和字符流之间的转换

API

InputStreamReader：将InputStream转换为Reader

实现将字节的输入流按指定字符集转换为字符的输入流

需要和InputStream“套接”。

构造器

public InputStreamReader(InputStream in)

public InputSreamReader(InputStream in,String charsetName)

OutputStreamWriter：将Writer转换为OutputStream

实现将字符的输出流按指定字符集转换为字节的输出流。

需要和OutputStream“套接”。

构造器

public OutputStreamWriter(OutputStream out)

public OutputSreamWriter(OutputStream out,String charsetName)

字节流中的数据都是字符时，转成字符流操作更高效。

很多时候我们使用转换流来处理文件乱码问题。实现编码和解码的功能。

补充：字符编码

常见编码表

ASCII

ISO8859-1:拉丁码表

GB2312:两个字节中文

GBK:升级版中文

Unicode:国际标准码

UTF-8:变长编码

ANSI编码指的是平台的默认编码

标准输入、输出流

System.in和System.out分别代表了系统标准的输入和输出设备

默认输入设备是：键盘，输出设备是：显示器

System.in的类型是InputStream

System.out的类型是PrintStream，其是OutputStream的子类 FilterOutputStream 的子类

重定向：通过System类的setIn，setOut方法对默认设备进行改变。

public static void setIn(InputStream in)

public static void setOut(PrintStream out)

打印流

实现将基本数据类型的数据格式转化为字符串输出

打印流：PrintStream和PrintWriter

提供了一系列重载的print()和println()方法，用于多种数据类型的输出

PrintStream和PrintWriter的输出不会抛出IOException异常

PrintStream和PrintWriter有自动flush功能

PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。

System.out返回的是PrintStream的实例

数据流

为了方便地操作Java语言的基本数据类型和String的数据，可以使用数据流。

数据流有两个类：(用于读取和写出基本数据类型、String类的数据）

DataInputStream 和 DataOutputStream

分别“套接”在 InputStream 和 OutputStream 子类的流上

DataInputStream中的方法

long readLong()

String readUTF()

int readInt()

void readFully(byte[] b)

byte readByte()

float readFloat()

short readShort()

boolean readBoolean()

double readDouble()

char writeChar()

DataOutputStream的方法

long writeLong()

String writeUTF()

int writeInt()

void writeFully(byte[] b)

byte writeByte()

float writeFloat()

short writeShort()

boolean writeBoolean()

double writeDouble()

char writeChar()

对象流

ObjectInputStream和ObjectOutputSteam

用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。

序列化：用ObjectOutputStream类保存基本类型数据或对象的机制

反序列化：用ObjectInputStream类读取基本类型数据或对象的机制

ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

对象的序列化

什么是对象的序列化

对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原来的Java对象

序列化的好处

序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原

序列化是 RMI（Remote Method Invoke – 远程方法调用）过程的参数和返回值都必须实现的机制，而 RMI 是 JavaEE 的基础。因此序列化机制是 JavaEE 平台的基础

如何实现对象的序列化

如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。否则，会抛出NotSerializableException异常

Serializable

Externalizable

凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：private static final long serialVersionUID;

serialVersionUID用来表明类的不同版本间的兼容性。简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。

如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID 可能发生变化。故建议，显式声明。

简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的 serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)

使用对象流序列化对象

若某个类实现了 Serializable 接口，该类的对象就是可序列化的：

创建一个 ObjectOutputStream

调用 ObjectOutputStream 对象的 writeObject(对象) 方法输出可序列化对象

注意写出一次，操作flush()一次

反序列化

创建一个 ObjectInputStream

调用 readObject() 方法读取流中的对象

强调：如果某个类的属性不是基本数据类型或 String 类型，而是另一个引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的 Field 的类也不能序列化

随机存取文件流

RandomAccessFile 类

RandomAccessFile 声明在java.io包下，但直接继承于java.lang.Object类。并且它实现了DataInput、DataOutput这两个接口，也就意味着这个类既可以读也可以写。

RandomAccessFile 类支持 “随机访问” 的方式，程序可以直接跳到文件的任意地方来读、写文件

支持只访问文件的部分内容

可以向已存在的文件后追加内容

RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置。

RandomAccessFile 类对象可以自由移动记录指针：

long getFilePointer()：获取文件记录指针的当前位置

void seek(long pos)：将文件记录指针定位到 pos 位置

构造器

public RandomAccessFile(File file, String mode)

public RandomAccessFile(String name, String mode)

创建 RandomAccessFile 类实例需要指定一个 mode 参数，该参数指定 RandomAccessFile 的访问模式：

r: 以只读方式打开

rw：打开以便读取和写入

rwd:打开以便读取和写入；同步文件内容的更新

rws:打开以便读取和写入；同步文件内容和元数据的更新

如果模式为只读r。则不会创建文件，而是会去读取一个已经存在的文件，如果读取的文件不存在则会出现异常。如果模式为rw读写。如果文件不存在则会去创建文件，如果存在则不会创建。

节点流（或文件流）

在写入一个文件时，如果使用构造器FileOutputStream(file)，则目录下有同名文件将被覆盖。

注意事项

定义文件路径时，注意：可以用“/”或者“\\”。

在写入一个文件时，如果使用构造器FileOutputStream(file)，则目录下有同名文件将被覆盖。

如果使用构造器FileOutputStream(file,true)，则目录下的同名文件不会被覆盖，在文件内容末尾追加内容。

在读取文件时，必须保证该文件已存在，否则报异常。

字节流操作字节，比如：.mp3，.avi，.rmvb，mp4，.jpg，.doc，.ppt

字符流操作字符，只能操作普通文本文件。最常见的文本文件：.txt，.java，.c，.cpp 等语言的源代码。尤其注意.doc,excel,ppt这些不是文本文件。

OutputStream & Writer

OutputStream

void write(int b)

void write(byte[]b)

void write(byte[]b, int off, int len)

void flush()

void close()

Writer

void write(int b)

void write(char[] cbuf)

void write(char[]cbuf, int off, int len)

void flush()

void close()

File类的使用

java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关

File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。

想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。

File对象可以作为参数传递给流的构造器

常用构造器

public File(String pathname)

以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。

绝对路径：是一个固定的路径,从盘符开始

相对路径：是相对于某个位置开始

public File(String parent,String child)

以parent为父路径，child为子路径创建File对象。

public File(File parent,String child)

根据一个父File对象和子文件路径创建File对象

路径分隔符

路径分隔符与操作系统有关

public static final String separator。根据操作系统，动态的提供分隔符

常用方法

File类的获取功能

public String getAbsolutePath()

public String getPath()

public String getName()

public String getParent()

public long length()

public long lastModified()

public String[] list()

public File[] listFiles()

File类的重命名功能

public boolean renameTo(File dest)

File类的判断功能

public boolean isDirectory()

public boolean isFIle()

public boolean exists()

public boolean canRead()

public boolean canWrite()

public boolean isHidden()

File类的创建功能

public boolean createNewFile()

public boolean mkdir()

File类的删除功能

public boolean delete()

IO流原理及流的分类

Java IO原理

I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。

Java程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行。

java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

流的分类

按操作数据单位不同分为：字节流(8 bit)，字符流(16 bit)

按数据流的流向不同分为：输入流，输出流

按流的角色的不同分为：节点流，处理流

Java的IO流共涉及40多个类，实际上非常规则，都是从4个抽象基类派生的。

由这四个类派生出来的子类名称都是以其父类名作为子类名后缀

IO流体系

节点流和处理流

节点流

直接从数据源或目的地读写数据

处理流

不直接连接到数据源或目的地，而是“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。

InputStream & Reader

InputStream

int read()

int read(byte[] b)

int read(byte[]b, int off, int len)

public void close() throw IOException

Reader

int read()

int read(char[] cbuf)

int read(char[]cbuf, int off, int len)

public void close() throws IOException

InputStream 和 Reader 是所有输入流的基类

程序中打开的文件 IO资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以应该显式关闭文件 IO 资源

FileInputStream 从文件系统中的某个文件中获得输入字节。FileInputStream用于读取非文本数据之类的原始字节流。要读取字符流，需要使用 FileReader