《JAVA基础》

admin管理员组

文章数量:1534197

第一章 Java技术概括

1. java的版本

1) JAVA SE(Standard Edition)

包含JAVA的基本系统、可以构建图形用户界面程序

2) JAVA ME(Mobile/Micro Edition)

在JAVA SE的基础上，做了精简，然后增加了手机相关的库构成

3) JAVA EE(Enterprise Edition)

在JAVA SE基础上，增加了servlet,jsp等几十种企业级构成

2. Java的安装

1) 安装JDK与Eclipse

\1. JDK安装路径：Oracle Java Technologies | Oraclejavase/archive-139210.html

\2. Java 归档文件下载 - Java SE 8u211 及更高版本 (oracle)

\3. Eclipse安装路径：www.eclipse

2) 配置环境

\1. 配置JDK环境变量：高级设置 —— 环境变量 —— path （系统变量） ——

(1) 新建 —C:\Program Files\Java\jdk1.8.0_331\bin——

(2) 新建JAVA_HOME——C:\Program Files\Java\jdk1.8.0_331\bin—— 变量: JAVA_HOME 变量值：C:\Program Files\Java\jdk1.8.0_331

l Path —— C:\Program Files\Java\jdk1.8.0_331\bin：在任何目录下都能运行

l JAVA_HOME —— C:\Program Files\Java\jdk1.8.0_331\bin：java运行的程序很多，让运行程序可以找到java的位置

3) 检查安装是否成功

(1) Cmd —— 输入：java -version

① cmd：文本编辑器 and 命令行

② java -version：查看安装版本

4) 命令行代码

(1) Type Helloworld.class :type 用于显示命令的类型信息

(2) Dir Helloworld（directory） ：dir命令基本上会列出目录中的文件及子目录的名称

(3) Javac Helloworld.java：编译代码，转成计算机可以识别的语言

(4) Java Heilloworld：运行代码

(5) Java Helloworld copy con Helloworld.java ：把控制台上的目录保存到 Hellorld.java

(6) Echo %JAVA_HOME% ：输出环境变量

3. JAVA的特点

1) 平台无关性

一个应用可以在不同的操作系统上运行

2) 完全面向对象和简单性

所有设计都必须类实现，JAVA程序就是多个类的集合

放弃C++的复杂语法

3) 可靠性

严密的语法规则

4) 安全性

反编译采用域管理方式的安全模型，

5) 多线程

每个线程都有时独立的，并发执行

6) 分布式应用

服务器可以多人访问

第二章基本程序逻辑与编码规范

1. 命名规则

(1) 一般是动宾结构：doSometing

(2) 驼峰命名法：

① 方法名：第二个单词开始首字母大写

② 类名：所有单词首字母大写

(3) Boolean类型：

① isxxx（）(更好的方案)

② getxxx()

2. 注释

1) 传统注释

\1. 单行注释：//

\2. 多行注释：/.../

2) 文档注释：/**...*/

(1) 生成文档：右键-Export-doc-index.html

3. 编码规范

(1) 代码处理

① 特例处理

② 普通处理

(2) JAVA程序员一般跟线程打交道（栈）

① 看懂语法

② 良好的编程习惯（跟国际接轨）

③ 算法

(3) 代码真善美

① 变量定义区、业务处理区、结果输出区

(4) 程序员学习方法

① String等类观察源码先看实例属性

4. 编码格式

(1) 概念：通过编码格式将二进制码变为代码

(2) 字典

① Gbk简体中文

② Big5繁体中文

③ Iso-88xx英文

(3) 乱码：编码集不相同

(4) 统一unicodem码/万国码 65537

① Utf-8（通用字典）

② 代码/路径尽量使用英文

③ ASCII是所有编码集128位

(5) 更改编码集

① Preferences——General——workspace——Other——utf-8

(6) 提高编码速度

① Preferences-java------Editor——.二十六个字母大小写

(5)

5. 基本程序逻辑

(1) 测试驱动的开发（TDD：Test-Driven-Development）

(2) 基本思路就是通过测试来推动整个开发的进行

(3) 调试视图：inspect（若干个窗口的有效组合，更容易让我们从事某项工作）

① 复位：Window —— perspective ——resect perspective

② 断点：程序走着停下来的地方

(4) 模块化开发

① 将程序按照功能划分为若干的小程序模块，每个模块完成确定的功能，并在模块之间建立必要的联系

(5) 日志文件（TODD）

① Show view —— Progress

6. 基本编程思想

耦合性、内聚性、复用性，可读性、扩展性

7. Scanner

(1) 概念：用于扫描输入文本的新的实用程序

(2) 作用：其可以扫描某个区域，变量需要手动输入时，可以使用

(3) 例子：

① Scanner = new Scanner(System.in)

② Begin = scanner.nextInt()

③ Scanner.nextLine：输入至回车结束

④ Scanner.next：空格结束

(4) 解释：

① 将scanner中读取二进制数据，数据读到后，安装整数的方式

② System.in代表是标准输入设备，

③ Println：printLine输入后换行

(5) 注意事项

① float height = scanner.nextFloat();

② String sex = scanner.nextLine();

③ //nextFloat遇到空格或是回车时，数据就会被读走，回车被留下

④ //nextLine是以回车结束，调用后，缓存区内还有剩下的回车符

第三章 基本编码热身

1. 术语

(1) Demo（演示）

(2) Prj（project）项目

(3) 打开工作区：Default location-Workspace 工作区（项目默认创建位置）

(4) 新建工作区：switch Workspace-other

(5) 大纲：outline（c说明是构造方法，s是静态属性）

2. Eclipse常见问题

(1) 打开工程

① Import——General-Existing——搜索projects

(2) 查看原码

① Ctrl + 鼠标滑动

(3) 工程打叉

① Jdk版本不相同

② 右键——properties ——Java Build Path —— Add Library——JRE System Library ——Alternate JRE-jdk —— Installed JRE——Add- Stand VM-Directory - jdk1.8.0

(4) 控制台打开

① Window - Show View – Console

(5) 导入doc

① tools - generate - out directory

第四章 面向对象编程技术

1. 类型的发展

(1) 基本类型（面向过程的语言，处处皆是函数）

① 基本类型的概念

l 实数、整数、字符、布尔值

(1) byte（-128）, Float,double（隐含类型，不建议使用精度丢失）

l 使用int类型（分）1.30元——>130分

l 使用decimal类型(BigDecimal)

(2) long,short（-32768），Int（隐含类型）

(3) Boolean

(4) Char(16bits)(C语言8bits)

② 基本类型的注意事项

l JAVA不提倡使用，缺点：无法表示没有，身上没有方法代码

③ 基本类型的格式修饰符

l o：octal（八）、d：decimal（十）、x：hex（十六）、ld：long decimal

④ 基本类型的转换：

l 分为自动转换和强制转换

(1) ·自动转换：（byte、short、char）——int——long——float——double

l 通过运算，转为精度高的类型

l 注意事项：先转为基本类型，然后再将类型装箱

(2) 强制转换：double——float——long——int——（byte、short、char）

l 通过大范围转换小范围（精度丢失）

l int num = scanner.nextInt();

l byte byteData = (byte)num;

l 强制转换超出类型范围时，从负数开始

l 结果为小数时，分母必须是精度类型

(3) 基本类型转String

l String.Value（）

(4) String转基本类型

l Object.parse (num)、Integer.parseInt(1)

(5) Int转char数组

l Int先转为String类型，借助toCharArray

l Char[] c = String.valueOf(num).toCharArray()

(6) Char数组转int

l Char先转为String类型，借组Integer.parseInt()

l String s = String.valueOf(c)

l Int N = Integer.parseInt（c）

⑤ 运算符：按位与（&）、按位或（|）、按位异或（^）、按位取反（~）

l 按位与：转换二进制、进行运算（都得）

l 按位或：转换二进制、进行运算（或者）

l 按位异或：转换二进制、进行运算（相同0，不同1）

l 按位取反：转换原码——反码——补码——进行运算（相反,0正1负）

(1) 原码：计算机中最简单的一种形式，是以二进制表示

(2) 反码：原码和补码的过渡码

(3) 补码：用来解决负数在计算机种表示的问题

(4)

(5)

(6) <<左移：

l 原码——补码——左移——补码——原码：低位补零

(7) >>右移:

l 原码——补码——右移——补码——原码：高位补零（负数补1）

(8) <<<>>>无符号左移右移：正数同>>，负数默认int 32位

l 原码——补码——右移

(2) 数组

① 数组的概念

l 存储固定大小的同类型元素

② 数组的创建

l Int[] a = new int[3]

l Int b = new int[]{1,2,3}

l Int[] c = {1,2,3}

③ Syntax sugar

④ 数组的排序

l 使用Array.sort（）

l 在此之前还得实现Comparable<>接口

(3) 结构体

Struct book{

double bookWeight;

String bookName;

Float bookPrince;

}b;

Book b;

B.bookName = “书”;

(4) 复杂类型（class 类型 = 包含了方法的超级结构体）

Class Cat{

//属性，特征

Double weight;

String name;

Int age;

//方法，行为

Void run(){}

Void sound(){}

}

2. 类和对象

1) 类、对象的概念

(1) 类的概念：具备某些共同特性的实体集合，是一种抽象的数据类型

(2) 对象的概念：对象是类的一个具体的个体，他是实际存在的

(3) 比较：类是对象的集合，对象是类的实例

2) 对应关系

(1) 声明结构体 --- 结构体变量

(2) 声明类 --- 对象

(3) 比较：

① 现实中：模具 --- 实物（制作模具是重要且复杂，同时也是抽象的）

② 程序中：类 ---- 对象

3) 类的构建

(1) 属性（property）{成员]

(2) 方法（method）[动作]

(3) 类的构建粒度

① 满足程序设计即可，为涉及的属性和方法不可加入类的设计，不同应用领域会有不同的抽象视角。

(4) 可执行类：类带main方法，是程序的起点

4) 类的封装

(1) 概念：

① 将数据和对数据的操作组合起来构成类。对象是一个不可分割的独立单位

(2) 功能：

① 实现信息隐藏，类纪要提供与外部联系的方法，又要尽可能地隐藏实现细节

3. 面向对象三大特性

(1) 封装

① 隐藏内部实现，稳定外部接口

(2) 继承

① 子类继承父类成员，实现代码复用

(3) 多态

① 不同子类对同一消息做出不同的反映

第五章JAVA对象内存理解与静态属性理解

1. 面向过程、对象的引入

(1) 面向过程：着重过程的步骤解决问题（proceure oriented）

① 优点：流程化任务清晰明确、效率高

② 缺点：维护困难，计算机思考，重用率低

③ 评判代码质量

l 时间复杂度：循环的次数

l 空间复杂度：数组开辟的大小

(2) 面向对象：通过对功能的划分解决问题(object oriented)

① 优点：结构清晰，人类思考，易拓展，易维护，低耦合

l 低耦合：元素与元素之间不会过分的依赖

② 缺点：性能低，开销大（私有属性需要增加读或写的行为）

③ 评判代码质量

l 高内聚

l 低耦合

l 可复用性

l 可维护性

l 可扩展性

2. 面向对象的来历

(1) 面向过程的系统，无法写出极度复杂的系统，面向过程只能写出小程序

3. 面向对象

1) 面向对象的概念

(1) 是程序开发领域的重要思想，思想模拟人类的客观世界的逻辑

2) 面向对象的引入

(1) 操作系统OS是系统资源的大管家，其负责给应用程序分配软硬件资源，任何一个应用程序在操作系统中表示为一个进程（process），进程是一个逻辑单位，真正干活的是线程（thread）.

3) 栈、堆的概念与理解

栈、堆的概念

(1) 一个应用程序启动之后，必须获得内存才能执行，应用程序获得内存之后，分为两种使用方法，一种方式叫做堆（heap），一种方式叫做栈（stack），操作系统只允许以进程为单位其申请内存，然后进程申请内存之后，再给予内部分配。

l 理解：操作系统：学校，进程：班级（虚的），线程：学生

学校只允许以班级为单位申请资金，然后班级内部分配

栈、堆的运行

(1) 一个进程申请到了内存之后，给每个线程分配了各自的存储空间（stack），剩余的空间为所有线程所共用，这个空间，就叫做堆（heap），stack是一个狭小的空间，尽量不要存太多的数据，而堆是浩瀚无垠的空间，可以存储大量的数据。

l 理解：班级申请到资金后，给每个学生（栈）分配资金，剩下的钱当班费（堆），钱不够再向学校申请，保存到班费里

栈、堆的注意事项

(1) 一个进程至少要有一个线程，一个程序至少有一个堆和一个栈

(2) 一个线程一个栈，一个进程一个堆，一个进程能访问多个线程

(3) 线程理论上只能访问自己，访问对象要放在栈空间，栈太小了，所以要放在堆里

(4) 没有学过JAVA多线程开发时，所写的程序都是单进程单线程程序

(5) 目前唯一个线程是JVM帮你创建的，这个线程叫main线程

(6) 生命周期：堆>栈>对象

4. 创建对象 Car car= new Car();

1) Car

(1) 类加载（class loading）：从左向右运行，识别到Car是个类之后，将代码一个bit一个bit加载到内存中，在代码区运行

2) car

(1) 创建引用变量（指针）：32位或64位，该变量只能指向Car类的对象

① 基础数据类型（值传递）

(2) 引用数据类型（引用传递）

3) New Car

(1) 创建对象：new在堆中申请内存空间，创建了裸对象（裸对象：属性值都没有）

l 对象：属性（结构体的衍生），又称XX类的实例

属性

属性的概念

(1) 用来描述某个对象的特征，通常用变量的形式进行定义

变量的分类

(1) 成员变量

① 概念：类体中，方法体之外的变量

② 格式：类型 变量名 [=初始值]

③ 分类：类变量和实例变量，

l 类变量：用static修饰，通过类名访问

l 实例变量：创建对象后可访问的变量，在堆中（属于对象）

④ 注意事项：

l 默认初始化值

l 默认访问修饰符

(2) 局部变量

① 概念：方法体内的变量

② 存放在栈中

③ 注意事项：

l 显式初始化值

l 不指定访问修饰符

(3) 变量的作用域

① 静态变量：与类同命

② 实例变量：与实例对象同命

③ 局部变量：与方法同命

This

This的引入

(1) 类的属性与局部变量出现同名的现象

(2) 构造方法体内调用构造方法出现同名现象

This的概念

(1) 代表对象中的成员或方法（是系统自带的）

This的用法

(1) This.属性

(2) This.方法

(3) This（）：调用构造方法

(4) 语法糖只有一个this是调用当前的对象

This的注意事项

(1) This（）必须是构造方法的方法体的第一行

① 子类会优先初始化父类对象，避免对象本身还未构建，找不到对应的对象

(2) This（）不能多次调用，避免构建出两个对象

(3) This不能调用静态，因为静态区域打开时，实例还未创建

Super

Super的引入

(1) 由于子类不能继承父类的构造方法，要调用父类的构造方法，可以使用super

Super的概念

(1) 引用变量，用于引用父类的对象

Super的用法

(1) Super.属性

(2) Super.方法

(3) Super（）：调用父类构造方法

Super的注意事项

(1) Super（）必须是子类构造方法的方法体的第一行

① 子类初始化对象时，要保证父类先初始化对象

(2) Super（）不能多次调用，避免构造出两个对象

4) Car()

(1) 裸对象的概念：裸对象所有属性均为空白，无发生表示生活中的实物，在JAVA中，我们通过构造方法完成裸对象的初始化

5. 构造方法：

1) 构造方法的引入

(1) 当一个婴儿诞生后，就要给这个婴儿起名字，就用到了构造方法

2) 构造方法的概念

(1) 构造方法是个特殊的方法，与类同名，无返回类型的方法，即使是void也不可以

3) 构造方法的分类

(1) 有参构造方法

(2) 无参构造方法

4) 构造方法的作用

(1) 有参：类中的属性初始化

(2) 无参：设置访问权限private

5) 构造方法的生成

(1) 右键 – Source == Generate Constructor using Fields

6) 构造方法的注意事项

(1) 对象创建后，生成默认构造方法并调用

① 类中没有构造方法时，系统自动生成无参构造方法

② 类中已有构造方法时，系统自动删除无参构造方法

(2) 构造方法加上void编译器会认为时普通方法

① 构造方法时在类对象实例化时调用

② 普通方法是在类实例化后调用

7) 构造方法的扩展

(1) 扩展引入：一个类可以拥有多个构造方法，提升了这个类的易用性

(2) 层叠构造方法（cascading constructor）：互依赖基础构造方法的，即提供方法的多样性，提高了易用性，又减少程序的负担。

8) 构造方法的拷贝

(1) 通过形参传入对象，构造方法内拷贝

String name;

int age;

/** 对象的拷贝 */

public User(User user) {



this.name = user.name;

this.age = user.age;

}

new Car()：

(1) New Car + car() = new Car Car() = new Car()

(2) 每个对象都有一套属于自己的独立的属性拷贝，但方法是公用的

枚举

(1) 概念：用一种新的类型定义eunm

(2) 引入：有具体的值，以防用户输入信息错误

(3) 语法：

① ·枚举是一组描述性的名称

② 枚举定义了一组有限的方法，不能包含方法

③ 对可能的值进行约束

④ 枚举允许名称表示整数值

(4) 例子

public enum Penguin {

雪纳瑞**,拉布拉多**

}

private Penguin strain;

public class Dog {

public Penguin getStrain() {

return strain;

}

6. Static关键字

(1) Static的引入：静态属性属于类，只要类被加载，静态属性的空间（静态数据区）就开启，静态方法就能被调用，

① 静态数据区：各个类的静态属性的杂居区域

(1) Static的概念

① 是一个访问修饰符，用于修饰类的成员方法，类的成员，不需要依赖对象进行访问

(2) Static的作用：

① 静态属性都只有一份拷贝，为所有实例共享,实现累加

② 没有静态属性，就会分开计算

(3) Static的调用：

① 静态东西不能调用实例的东西（对象被调用时，实例未出现）

② 静态方法不能访问实例属性、实例方法

(4) static的用法

① 类名.属性（直接访问，推荐使用）

② 引用变量.属性（栈-对象-UML类图-静态数据区）

7. New关键字

(1) New的概念

① 创建一个新的对象，可以理解为创建的意思

(2) New的作用：

① 实例属性属于对象，每个对象都有一份拷贝，为所有的实例共享

(3) New的调用：

① 实例方法必须通过引用变量来调用，也就是对象存在才行

(4) New的访问：

① 实例方法可以访问静态属性和静态方法

(5) New的注意事项：

① 实例没有被使用就会被销毁（垃圾回收机制）

第六章包装类技术的理解

1. 包

1) 包的引入

(1) 一个好的类名，大家都爱使用，那么相同类名的情况下，将很难区分类的主人，所以我们必须给类起义个范围限定（归属），JAVA中是通过包的机制类解决

2) 包的概念

(1) 包是一种封装类、子包和接口的机制，可用于组织一组相关的类和接口

3) 包的命名

命名规则

(1) 同一个包中不能出先雷同的类名

命名方法

(1) 是通过磁盘目录来表示，一般使用单位的域名倒装来作为包名

命名划分

(1) 功能划分（小型）

① Common：公共的，公开的

② Util：工具包

③ Ui/view：视图

④ Controller：控制层

⑤ Service：业务层

⑥ Dao：持久层

⑦ .imp实现包

⑧ Entity/vo/bean/do/pojo/model：模型/对象包

(2) 模块划分

① 多个功能划分

命名规范

(1) 包名全部小写，不能出现下划线，中划线等特殊字符

① Com.abc.mju.cs（层层递进的文件夹）

② Com.abc.fz.cs（com是公用）

4) 包的作用

(1) 把功能相似或相关的类或接口组织在同一个包中

(2) 采用树形目录的存储方方式，避免名字冲突

(3) 限定访问权限，拥有包访问权限的类才可访问包中的类

5) 包的发行机制

(1) JAVA发行类库，是通过.class打包的方式，虽然class文件体积很小，但也有高效率的发布方式，便是打包，后缀名.jar

(2) 打包文件的格式是.zip ，为了和传统压缩文件区分，JAVA把后缀改成了.jar（java archive）java归档

(3) 磁盘拷贝文件，拷贝小文件很消耗磁盘，磁盘机制，小文件拷贝剩下的空间就无法使用，发布文件慢

6) 包的调用

(1) 调用的方法

① 使用import关键字（import唯一性）

② 类名加包名前缀

l david.Student stu = new David.Student()（全类名）

(2) 调用的顺序

① 未指定的包名，将在本包中有优先查找

(3) 快速调用包

① 快捷键：Ctrl + Shift + O（快速调用）

② 右键 + Copy Qualified Name（复制包名）

(4) 调用包的优先级

① 本地导入 > 同包类

(5) 调用的注意事项

① 同包类无需导入使用，异包类需要显式导入

② 不能导入不同包相同类，使用次数多的类优先导入

7) 包的注意事项

(1) 命名规则注意事项：

① 重复命名：Package already exists（类型已经存在））

② Java的库不是域名倒装（Java.lang）

(2) 默认包注意事项：

① 为避免编写的类，在后续系统中出现使用上的问题，请不要书写无包类/默认包类（default package）

(1) 默认包的使用：

① The use of the default package is discouraged.（不推荐使用默认包）

② 无包类就是直接在src下的文件夹

l Src：源代码

l Bin：字节码 （编译后的位置）

2. 包装类（wrapper class）

1) 包装类的引入

(1) Java是个完全面向对象的语言，几乎所有的方法都可以通过对象，基本数据类型却不是面向对象的

2) 包装类的出现

(1) Java中不能定义基本类型对象，为了将基本类型视为对象进行处理为了弥补了基本类型的语意缺失

3) 包装类的概念

(1) java中的一种重要的引用数据类型，基本类型都有与之对应的包装类，也是组成java程序的基本要素，因为所有的java程序都是基于类，所以出现新概念：抛弃数据类型

4) 包装类的作用

(1) 将基本类型包转起来的类，让基本类型具有对象的特性，Integer默认值不是0而是null

(2) 指代了很多针对基本类型的服务代码（静态代码）比如int类型有困难，请先找，Integer类

(3) 可以作为泛型的参数，基本类型不行

5) Lang包（核心包）

(1) java.lang.*： 包中的所有的类在任何JAVA程序中都有编译器默认导入，编译器提供syntax sugar（语法糖）除了lang包其他慎用，因为编译性能会下降。

6) 包装类与基本类型的内存空间

(1) 占用对象内存空间主要看实例属性，Integer 和int占用内存空间基本相等，Integer只有一个实例属性：value

3. 装箱与拆箱

装、拆箱的概念

(1) 装箱：基本类型转换成包装类（保存在value变量中，i——>value:5）

(2) 拆箱：包装转换成基本类型（将对象中的数据属性取出value：5——>i）

装、拆箱的操作

(1) 手动

① 装箱操作(inbox)：Integer i = new Integer(5)

② 拆箱操作(outbox)：int a = i.intValue()

(2) 自动

① 装箱操作(inbox)：Integer i =300；（syntax sugar）

② 拆箱操作(outbox)：int a =300

装、拆箱的发展

(1) JDK的发展：

① 1.1（1.0）——1.2 ,——1.3 ,——1.4 ,——1.5

② 1.5版本才出现自动装、拆箱(J2EE = Java 2 EE = JAVA EE = JEE)

(2) JDK降级

① 右键 —— Properites —— Java Compiler —— Compiler compliance level(编译器兼容的级别):1.5

② Type mismatch:cannot convert from int to Integer

l （类型不匹配：不能把整形转成Integer）

第七章系统常用类

(1) Object类

① Equals

② toString

(2) Systeml类

① 文件路径

② system.getProperty

③ Path.separator（路径分隔符）：系统不一致时，有正反斜杆之分

(3) 数据类型类

① 字符串和数字的转换

(4) Math类

① Math.ceil() 方法可对一个数进行上舍入，返回值大于或等于给定的参数，

(5) Random类

(6) Date类

① 时间与字符串的转换

(7) BigDecimal类

① 加减乘除

② Add（）:BigDecimal对象中的值相加，然后返回这个对象

③ Subtract（）：BigDecimal对象中的值相减，然后返回这个对象

④ Multiply（）：BigDecimal对象中的值相乘，然后返回这个对象

⑤ Divide（）：BigDecimal对象中的值相除，然后返回这个对象

(8) Class类

第八章String类

1. String的引入

(1) 例子：”aaa” + 1 = =aaa.concat(new Integer(1).toString())（syntax sugar）

2. String的创建

(1) String str = new String(“aba”) 和 String s2 = new String(new char[]{‘k’,’k’})

(2) String str = “aba”(Syntactic sugar)

① 创建字符串数组：String（char value[]）

② 源码：this.value = Array.copyOf(value,value.lenth)

3. String的应用

String的判断

(1) 查找使用：int[] ——> Arrays

(2) S2.startwith()：判断是否以...开始造句

(3) S2.endwith()：判断是否以…结尾造句

(4) S2.isEmpty()：判断是否是空串

String的查找

(1) S2.charAt()：返回特定索引字符上的值（输入字符的下标）

(2) S2.indexOf()：

① 查找第一个字串字符

② 从第n个下标开始查找，返回位置

③ 判断子串是否存在（返回数字）

(3) S2.contains()：判断字串是否存在（返回boolean）又称装饰方法

(4) S2.lastIndexOf()：最后开始查找

String的比较

(1) S2.equals()：内容比较

(2) S2.toUpperCase()：全部转大写（验证码）

(3) S2.equalsIgnoreCase():忽略大小写

(4) S2pareTo()：比较大小

String的相加

(1) S2.concart()：字符串相加，等价 （ + ” “）

(2) String.valueOf(123)：数值转字符串（低成本版）

① S2 + 123 ，等价 （ s2.concat(new Integer(123).toString())）（高成本版）

String的返回

(1) S2.length：返回长度（字符数组的数量）

(2) S2.trim()：删除左右空格

(3) S2.substring()：返回字串,下标从n到m

String的转换

(1) S2.toCharArray()[3]：字符串转字符数组

(2) Long,parseLong：字符串转长整型

(3) S2.replace( n, m )；字符n替代字符m

(4) 注：未存盘*Test.java，存盘Test.java

String的替换

(1) Str.replace(“a”,””)：有返回值，替换字母

String的切割

(1) Split（“[ ， | 。]“）：逗号或者句号

4. String的指向

(1) String s1 = new String(“a”) and String s2 = new Sting(“a”) and String s3 = “a”;

① S1 == s2 ，结果false

② S1 == s3，结果false

l 1和s2是否指向的同一个对象

③ S2.- （s2），结果true

l S1和s2指向对象的内容是否相等

5. String不变性

1) Immutable概念

(1) 字符串创建后，值不会别修改，对字符串修改将创建新字符串

2) Immutable问题

(1) 如果一个对象身上的引用计数为0，这个对象将不能再被引用，这个对象将成为堆中的垃圾对象。由于字符串的不变性，字符串操作产生大量的垃圾对象，内存波动大的问题（扫了又多）

3) 引用计数

(1) 在JAVA系统中，对象在堆中，我们通过栈中的引用变量指向和操作一个对象身上可能有多个引用变量指向，这些引用变量指向的统计数量我们称为”引用计数”

4) JAVA垃圾回收器

(1) 在内存出现紧张的情况下，就会开始自动垃圾对象清理工作，其会对堆中的一个一个对象询问过去，如果发现这个对象的引用计数为0，那么就会自动释放这个对象。

5) 内存泄漏

(1) 创建对象后，占用内存空间，但对象永远无法释放

6. StringBuffer

(1) StringBuffer优点

① 不会产生中间结果，做大量的字符串操作，提高效率

(2) StringBuffer创建

① StringBuffer sb = new StringBuffer()

(3) StringBuffer比较和用法

① “aaa” + “bbb” == a.concat(“bbb”) (Syntactic sugar)

l 字符串的不变性：Aaa Bbb Aaabbb

② sb.append(“aa”).append(“bb”)（链式编程：返回自己）

l 字符串不产生中间结果：Aaa Bbb

(4) Sb.append(sections[i]).reverse();

① sb添加后还是sb，在翻转还是sb，return this就是添加toString

(5) StringBuffer输出方式：s1.toString();

(6) StringBuffer的删除：sb.delete(2，3)

(7) StringBuffer的插入：insert（）

(8)

7. String的分类

(1) StringBuffer：线程安全，速度慢

(2) StringBuilder：线程不安全，速度块

第九章 方法的重载、继承和重写

1. Overload（重载）

1) Overload引入

(1) 为了保护优秀的方法名资源，以便能够重用，java提供了方法名的重载（overload）

2) Overload概念

(1) 类中定义了许多方法名相同，而他们的参数数量不同或数量相同而类型和次序不同，是多态体现之一

3) Overload规则

(1) 具体规则

① 参数数量不同，立即构成重载

② 参数数量相同，相同位置上的参数，只要有一组数据类型不同，则构成重载

(2) 判断条件

① 参数名不做为是否重载的判断条件

② 返回值不同，也不作为是是否重载的判断条件

③ 访问修饰符也不作为重载是否成功的判断条件

4) Overload优点

(1) 优秀的方法名的得到了保护

(2) 系统根据录入的类型，自动匹配

5) Overload编译原理

(1) Int add(int a,int b) 编译最终方法名：add_int_int

(2) 构造方法未找到对应的数据类型，会自动升级

6) Overload注意事项

(1) 重载失败：Duplicate method（重复方法）构成重名

7) 不定参数

(1) 全称

① Vary arguments（不定参数）

(2) 不定参数的作用：

① 为了方便参数数量不确定的情况，以提高方法签名的高度兼容性，最终会被理解为数组

(3) 不定参数的注意事项

① 一个方法中的不定参数只能有1个，而且是最后一个参数

l Void calc(double num,int …b)

2. Inheritance（继承）

1) Inheritance专业术语

(1) Animal

① 父类（parent class）

② 基类（base class）

③ 超类（super class）

(2) Mouse

① 子类（child class）

② 派生类（Derivied class）

2) Inheritance的引入

(1) 子类继承父类将获得所有的资产

(2) 在面向过程的编程中，代码的复用机制，只是达到函数级别，但是在面向的变成中，代码复用的级别，到达了类级别，这是当前软件编程行业最高的复用级别

① 代码的复用级别：

l Object类是JAVA系统的根类，任何一个JAVA类都不是它的子类

l 你编写一个JAVA类，如果没有任何类，将默认继承Object，Object类中的方法在所有JAVA类均存在

l 在JAVA世界，你写的类都是子类，你没有书写根类的权力，是为来保障系统安全。

3) Inheritance的概念

(1) 子类继承父类的特征和行为，使子类对象（实例）具有父类的实例域和方法

4) Inheritance的作用

(1) 在很多类中有共同属性和方法，存放在父类中

5) Inheritance的优点

(1) 提高代码的复用性

(2) 为多态提供了前提

6) Inheritance的弊端

(1) 当父类发生变化时，子类随着变化，削弱了子类的独立性

7) Inheritance子类的调用

调用的引入

(1) 全家大扫除，要先敲爸爸的门，把里面的垃圾全部扫出来，再自己把垃圾扫出去，才算清理完毕

构造初始化

(1) 子类体内的父类部分，必须通过调用父类构造方法来完成，子类不能自行完成父类的构造，因为父类部分是子类的构成的部分

(2) 子类必须调用至少一个父类的构造函数（不一定得是无参构造函数）

Super调用

名字原则

(1) 子类构造方法调用父类构造方法，不能直呼父类构造方法的名字，只能使用代词super

第一原则

(1) 要调用父类的构造方法，super（）必须First Statement(语句)

Syntax sugar

(1) 子类调用父类时，子类的默认构造方法中自动生成super();

8) Inheritance父类的调用

(1) 父类调用子类使用强制转换

public static void print(Student user) {

System.out****.println("GO!");

}-

Student student = new Student("牛马班级");

User user = new User();

If（ user instanceof Student）

print((Student)user);

(2) 用途，父类对象设置子类对象的属性之前，还需使用instanceof判断引用类型能否指向该对象

9) Inheritance环境下的子类对象构建理解

Inheritance的判断方法

(1) 父类指向子类的判断方法

① 内容包含判断：引用变量的类型是否在对象中包含

② Is判断：Animal aninal ----->Tiger instance：老虎是动物

Object指向

(1) 引用变量可以指向所有的JAVA对象

(2) Object指向对象只能看到Objcet的部分

(3) Animal指向对象只能看到Animal的部分

Object例子

栓老虎的绳子

(1) 100元标配：能发挥老虎的所有作用

(2) 10元动物绳：能发挥动物的作用，跟养猫一样

(3) 1元通 用绳：任何东西都能栓，跟石头一样

萎缩效应概念

(1) 父类引用变量可以指向子类对象，但是在父类引用变量眼中只看到了子类对象中的父类部分，这种现象叫做“萎缩”效应。是一种调用能力的受限，无法发挥这个对象所有的功能，有功能不用是可以的

l 注：买手机

l （里氏代替原则）

膨胀效应概念

(1) 子类引用变量不能指向父类对象，应为子类引用变量眼中其看到的对象都会是子类对象，其会尝试吧父类对象扩展成子类对象，无中生有是不可以的，这叫做“膨胀”效应

3. （override）方法重写机制的理解

1) override的概念

(1) 在继承环境下，子类认可父类的行为（认同和坚持方法的签名），但对行为的具体执行过程不认可，则决定对父亲这个方法进行局部或者完全的更新。

(2) :表示override（重写）

2) override的两种模式

(1) 颠覆性重写：子类完成否定父类这个方法的内容

(2) 改良型重写/补充性重写：子类对父类这个方法的内容也是认可的，只是做了点补充说明

3) Override的优点

(1) 子类可以根据需要，定义特定与自己的行为

4) override的super

子类调用父类的super

(1) 子类重写父类方法时，调用父类方法不能使用相同的方法名，应该用super.sound(),因为默认是this.sound()

重写与构造的super

(1) 重写可以在任意一行，而构造必须在第一行（子类部分构造，必须完成体内父类的构造）

Override的覆盖

(1) 当重写后在外部满足时，就不会继续向后运行

5) toString()重写

(1) toString的返回

① 该对象字符串表达形式

l com.abc.objectmenthod.Apple：new Apple(“hong”)对象是Apple类的实例

l @32f2d23：哈希码（不同对象的哈希码不一样）

6) Equals()重写

(1) Obj instanceof Apple：传进来的引用变量是否是苹果类的实例

(2) Apple otherApple = (Apple)obj：强制类型转换，更改引用变量，完成标配指向

(3) StringCharCounter

① Character.isDigit(str.charAt(i))：判断数字

② Character.isLetter(str.charAt(i))：判断字母

(4) ReverseStringWork

① String [] sections = Str.split(“\|”)：Reguar Expression（有规律的表达式）

② Sb.append(sections[i]).reverse();

③ Sb.delete(0,sb.length())

第十章多态性

1. 多态技术的引入

(1) 多（poly） + 变动的（morph） + ism（马克思后缀）（polygon）多边形

2. 多态技术的概念

(1) 同一行为具有多种不同表现形式或形态的能力，就是在同一个接口，使用不同的实例而执行不同的操作

(2) 多态是个美丽的意外，是在特殊环境下才发生的化学反应

(3) 减少耦合性

3. ploymorphism三要素

(1) 继承环境系下，子类重写父法类方法

(2) 通过父类引用变量，指向子类对象

(3) 通过父类引用变量，恰好调用的就是子类重写方法

4. 多态的用途

(1) 多态技术为了我们今后框架代码和通用底层代码的构建提供了技术基础。（springmvc,spring,hibernate,mybatis,struts2..）

(2) 实现多态的两种形式

① 使用父类作为方法形参实现多态

② 使用父类作为方法返回值实现多态

(3) 形参实现多态（形参写父类，实参传子类（子类可以当作父类使用））

(4)

5. 多态技术的好处

(1) 为以后的通用代码，框架代码，稳定不变的代码，建立稳定的基础

① 减少代码量

② 提高可扩展性和可维护性

(2) 转型

① 子类转父类，自动转型

② 父类转子类，instanceof

(3) 实现方法

① 形参实现

② 返回值实现

第十一章抽象类、Final的理解和访问修饰符

1. Abstract（抽象类）

1) abstract概念

(1) 一个概念或者想法不和任何特定的具体实例绑死

2) Abstract引入

(1) 例子：一个瓶子内有三个方法：瓶口，瓶身，瓶底，只有瓶底未完工，这个模具不能生产对象，所以一个抽象类不能实例化，new A():Cannot instantiate the type A

(2) 类是模具，有了类，就可以生产对象，如果一个类计划有若干个功能，但是有一些功能未实现，类似模具为完工。

3) Abstract方法

(1) 有3个方法，实现了2个，有1个还没实现，但方法签名已经计划好了，这个未实现的方法，必须用abstract来修饰，以通知系统本方法未实现，否者无法通过编译，该方法为抽象方法

4) Abstract分类

(1) 被动抽象类：拥有一个或者多个抽象方法的类，必须用abstract来修饰

(2) 主动抽象类：没有实例化的必要，避免程序员实例化

① 一个类的作者为了不让使用者去创建这个类的实例，其故意申明此类为抽象类

5) Abstract的优点

(1) 隐藏具体细节

(2) 强迫子类完成指定行为

6) Abstract的继承

(1) 抽象继承的引入

① 抽象类可以被继承，而且渴望被继承（愚公移山的故事）

(2) 抽象创建子类

① 子类重写父类未完成的类，称为类B实现了类A的抽象方法（implement），进行抽象类的子类实例化，方可调用子类的重写方法

② implement（实现）

l 已实现：void run(){sysout}

l 空实现：void run(){};

l 未实现：void run()

l Inherited abstract methods

(3) 抽象子类

l Public abstract class B extend A

(4) 一个JAVA文件中可以有很多个类，但只能有一个类是共有类对应着一个文件，JAVA文件名必须和共有类名字保持一致,只有与文件名一直的类才可以声明public

l The public type Base must be defined in its own file

7) Abstractc注意事项

(1) 抽象类语法识别注意点：

① Abstract void method3(){}

l 已经实现了，就不能再说是抽象方法，这是矛盾的

② Void method3(){}

l 空实现也是实现

(2) 抽象继承注意事项

① 子类未完全实现父类的抽象方法，则子类还得是抽象类

2. Final（最终）

1) final的引入

(1) 一个烂尾楼，渴望得到资金复盘，但政府不给予资金，所以跳楼了

2) Final的概念

(1) 最终的，不可改变的

3) Final的用法

(1) 当程序员认为一个方法、属性和类特别重要。

4) Final的修饰

修饰一个类

(1) 类不可以被继承,必可以创建实例与抽象相反

修饰属性

(1) 属性无法被修改，每一个实例属性都有一份拷贝，如果不做成静态属性，那么该属性将毫无意义。

(2) 在JAVA中，我们使用static final来作为常量修饰

(3) Final设置的属性值可以用set方法修改，对于对象而言，其内容值并不是它的具体位置，指针才是

修饰方法

(1) 方法不能被重写

修饰形参

(1) 传入的值，将不再改变

书写规范

(1) 在JAVA中，为了识别方便，常量全部大写，单词和单词之间使用_间隔

3. Accessmodifier（访问修饰符）

1) Accessmodifier的引入

(1) Access：存取，modifier修饰符

(2) 现实生活中，一个人有很多属性，你不会把所有属性都告诉任何人，而是有选择性对外说明，起到一个自我保护的作用，这也是算是一种“封装（encapsulation）

(3) 根据软件模拟现实的原则，语言设计者了访问修饰符这个机制来实现封装。

Private int money：该属性只有子类可见

String sleepingLocation：只有本类和本包类可见（三包）

Protected int age：只有本类、本包和异包子类可见（环保）

Public String name：所有类均可见

2) Accessmodifier的作用

(1) 控制类及类的方法和变量的访问权限，从而向使用者暴露接口，但隐藏细节

3) Accessmodifier的角度

从继承角度谈访问修饰符

<package>修饰符只有本包内部类可见，外部类，即使是子类也看不到。

Protected修饰符不仅本包内部可见，外包子类也可见

从引用角度谈访问修饰符

(1) 异包子类的protected修饰符

① 继承角度——使用方法——this指针：生效

② 引用角度——使用方法——实例化调用：无效

\1) 引用角度：叔叔等同于邻居阿姨，不存在血缘关系

4) 访问修饰符的策略

(1) 能够限制子类对父类的继承，一种访问修饰符能影响一个类对另一个类的表现

4. Javabean的概念

1) Javabean的广义概念

(1) Bean：豆——>java豆

(2) 一杯咖啡——>咖啡豆

(3) Java应用——>javabean

l 任何一个构成java应用程序的java class，就是javabean

2) Javabean侠义概念（引入）

(1) 属性对于类十分重要，属性因为外界的恶意赋值，导致类无法表示原本的含义，走上的属性私有的道路，私有属性只有本类可访问，就无法赋值，专门设立了私有的方法，set、get。身上带有代码更好了保护了系统，

(2) 私有属性的访问：setXXX、getXXX（setter方法、getter方法）

l 香港剧里，杀人犯为了脱罪，在审判时，不说话，等到律师到了，才说话

3) Javabean的用法

(1) JAVABEAN是一种给强制的类书写规范

① 所有属性私有，每个私有属性有一组getter/setter方法对其进行访问

② 有一个无参构造方法

l 因为系统会自动创建类的实例，必须要有无参构造方法，若是有参构造方法，系统无法判断传入的值，就无法自动创建。

(2) Javabean的封装技术

① Javabean本质上是一种封装技术

② 系统生成私有boolean类型是，getXXX——>isXXX

③ Js是模拟、java是原生的

5. 封装

1) 封装的概念

(1) 封装把对象的所有的组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。

2) 封装的用法

(1) 封装是一种信息隐藏技术，在java中通过关键字private、protected和public实现封装

3) 封装的简述

(1) 隐藏实现细节，根据权限控制完成对象的高内聚化

第十二章 接口

1. 接口的引入

1) 接口的出现

(1) 若用继承关系，子类都不满意父类方法的内容，但又必须有这些方法，就必须全部重写，失去了继承原本的意义

(2) 没有接口技术，我们无法模拟没有血缘关系的对象之间的群体活动。

① 飞毛腿公司的员工都有上班的这个一致的行为，无法描述过程：步行、骑车...

2) 接口的设计目标

(1) 要求所有学生都有父类的方法。

(2) 该方法的内容又各自不同。

3) 接口的命名

(1) Swimmable：....+able

2. 接口的概念

(1) 接口是极度抽象类的一种缩略书写的形式，接口本质上也是类，拥有类的各种特性，接口中的所有方法都是共有的抽象方法

① 极度抽象类：内部全是抽象方法，是最干瘪的类，提供了一套契约，是一种强制规范

(2) 从某种意义上接口也是继承，只是把继承的接口腾出来了，实现一个类就是一个继承模拟多继承

① Public abstract class Student ——> public interface

② Public class Mary extend Student ——> public class Mary implements Student

3. 接口的用法

1) 接口的作用

(1) 接口的作用等同抽象类：

① 丰富java面向对象的思想

② 有理由代码的规范

③ 有敌意代码进行维护

④ 保证代码的安全和严密性

(2) 接口本身无法实例化，是极度抽象类，抽象类无法实例化

2) 接口的调用

(1) 一个方法的参数能否接收一个变量，就看方法参数能否指向这个对象（对象是否实现接口的类），必须是这个接口的实现类

① 国际规范实现类 实现策略 + Impl

(2) 接口继承Object：接口类的引用变量可以查找到除自身以外的方法

① Public interface Mary extends Object

(3) 接口变量可以指向任何实现这个接口的对象（实例化），但是只能调用这个变量的接口部分，类似父类访问子类，只能访问到子类中的父类部分

3) 接口的继承

(1) 子类可以implement（实现）多个接口，只能extend（继承）一个类

① 大学生可以拥有除上学以外的行为

(2) 子类实现父类的接口，子类未完全重写父类接口中的空实现方法，两种解决办法：

① 用absract来修饰

② 实现相关方法

4. 接口的应用

(1) 电插头都是一个样的但是电插头后面运作的设备有各种各样的，

(2) 电脑的USB接口，USB所连接的接口都是一样的，但可以连接很多不同的设备，USB的生产者与电脑的生产者无联系。都是按生产规范来生产，形成了完全的分工，生产者、使用者、接受者，都是围绕接口规范

5. 框架技术（围绕接口编程）

1) 框架技术的概念

(1) 使用多态和接口，所谓的框架技术就是，框架不动，程序员根据框架实现创建很多实现类，使用接口，为今后编写固件、分工协作鉴定了基础，

2) 接口编程

(1) 创建接口引用变量不指定是哪个类因为不确定是哪个类在编写接口中没有用到USB接口的实现类，都是围绕接口编程，调用也只是接口中的方法，看不到具体的设备

(2) 接口就是一个契约，只要有传入的对象，必然有接口中定义的方法

第十三章Exception（异常）**

1. 异常与错误

1) 错误（error）

(1) 语法错误，逻辑错误（运行结果问题）

(2) 错误是系统的设计缺陷，必须返回软件公司修复

(3) 使用throwable捕获，因为它是error和exception

2) 异常（exception）

异常的引入

(1) 异常不是根本的问题，是运行中美丽的意外（在多态中，子类重写父类方法时，父类引用变量，不小心访问到了子类的方法，但是编译运行时，异常的捕获依然是从父类身上查找），能救就救

异常的概念

(1) 不是因为软件自身的原因，而是软件运行环境的意外没导致的运行停止，我们把其叫做异常。

异常的例子

(1) 现代软件在运行过程中，往往容易受到周边因素的影响，比如网络意外中断，磁盘文件被误删除，用户录入不正常的数据，导致软件运行中断（系统健壮性），我们把这种

异常解决后

(1) 解决完毕后，将积极重新尝试未完成的操作，使程序能够得以继续运行。

2. 异常处理

1) 异常的处理方式

(1) 异常对象只有两条出路：1、内部处理、捕获，2、抛出

① 抛出方法：则方法必须声明异常信息

② 捕获：不在类中被捕获，就必须做好方法的异常声明工作。

2) 异常处理的说明

(1) 异常对象在系统运行过程中自动创建，当然创建的对象类型是根据不同类型的异常而有差异的，系统会把出现异常的具体信息以及导致异常的原因写在这个对象中

3) 异常中的兄弟类

IOException和RuntimeException

(1) RuntimeException：

① 方法签名的后面要写入允许抛出异常的品种，默认throws RuntimeException,Error

② 任何一个方法，如果没有做特殊处理，默认抛出运行异常和错误

(2) IOException：

① 在IOE包中，其他异常都在lang包，导入包后提示Unfandled exception type IOEcxeption（没有被异常处理的类型）既没有被抛出，也没有被捕获，是Exception的子类，RuntimeException的兄弟类

NumberFormatException和ArithmeticException

(1) NumberFormatException（数字格式化）

(2) ArithmeticException（数学异常）

① Try捕获的异常catch中查找对应的类型

② 想用钱私了，但是派来的是共产党员，私了失败

3. 异常的抛出

1) 选择异常类

(1) 异常是一个对象，是一份出错报告系统会根据异常的类型选择一个异常类，然后创建其对象，填写相关异常信息

① 安全委员会给煤老板两个本子，一个用来煤矿出现的瓦斯爆炸写红本，一个是漏水事故写蓝本，过一天，就出现了瓦斯爆炸，煤老板就撕下红本的一张纸，填写信息

② Java语句出现异常选择一个异常类，创建它的实例，填写相关信息

l detailMsg（异常的明细）

l cause（异常的原因）

2) 异常抛出

(1) 再把异常对象交给该方法的调用者，这个过程，术语：抛出（throw out）JVM是main方法的调用者，JVM收到异常对象后，首先直接停止这个程序的运行，也就是说这个程序抛出异常语句之后的语句就不再运行了，然后打印异常信息到屏幕上

① 煤老板填写信息后，就交给了安全委员会，安全委员会让煤老板停止生产，并向全乡公布信息。

l 异常被捕获处理后，异常try…catch…结构后的语句交给你继续运行，程序不会中止，但是try块中发生异常的语句之后的语句将不再运行

3) JVM接收

(1) 如果异常抛出给调用者仍然无妨运行，则继续向上抛，最后抛给JVM，类似水泡，因为方法允许抛出RuntiemException,Error,(运行时异常是NumberformatException…的父类)，只要是运行时异常及其子类都可以抛出，错误及其子类也可以出去。

① 煤老板把信息交给村委，村委无作为，就交给镇委，都无作作为，最后就会国家委会

4. Try和catch的概念

(1) Try：我们可以把最容易，最有可能抛出异常的语句监控起来，使用try块进行监控， Try中的某条语句抛出异常，try块之后的程序将不再运行，无论是否被捕获，try中的语句尽量少。

① 高危语句：有可能抛出异常的语句

(2) Catch：捕获者 try块抛出的异常能被catch中的引用变量指向（标配），就能被捕获。就不会送到main。

① Exception：万金油，是JAVA世界中所有引用变量的父类 ,放在catch语句的第一行后面的语句将不被运行

② Throwable是所有异常的父类

5. 异常位置的跟踪和定位

(1) printStackTrace()的引入

① 由于try块中可能有多条语句，异常爆发了，对象被抛出了，到底是哪条语句导致的呢?

(2) printStackTrace()的作用

① JVM会打印相关的信息

② 会详细的告诉对应的位置

6. 异常的书写

(1) 自己抛出用throw，方法抛出用throws（可以抛出多个异常）Throw抛出。

① 通常情况下，是由系统帮助我们创建对应的异常对象，然后抛出

② 特定情况下，我们也可以手动创建异常对象，手动抛出

(2) 例子：If(b>0) throw new RuntimeException(“b不能为负数”,null)

① Throws：声明一个方法可能抛出的所有信息

② Throw：指的是抛出的一个具体的异常类型

7. Catch的级联

1) Catch的引入

(1) 由于一个try块中的语句，可能会拍出多中异常，应尽早部署多个catch块对异常进行捕获处理，以免造成程序停机处理。

2) Catch的万金油

(1) 但可抛出的异常种类实在难以预测，避免有漏网之鱼，所以，一般来说，我们catch级联块的最后会安排一个“万能“异常捕获者，来抓漏网之鱼。

(2) Java.lang.Exception是万能捕获者，其是对所有异常类的父类，根据父类引用变量可以指向所有子类对象的原则，其一般放在catch级联的最后一环对遗漏的异常进行捕获。但其处理缺乏针对性，较为粗糙，建议具体的捕获者处理。

3) Catch的注意事项

(1) Exception catch模组应避免放在级联块的第一个，否则后头的catch模组因代码无法到达，将全部失效，编译器将敏锐地发现问题，导致编译失败。

8. 异常的抛出

1) 自动异常（公认的不可以）

(1) 概念：异常类的选型、异常类的实例化、异常类信息的填充、抛出的动作，由系统一气呵成，只用于公认的错误形态，比如：被0整除，下标越界等

2) 手动异常

(1) 概念：其他的异常，就需要自己选型捕获、自己实例化、自己填充异常信息、自己抛出

9. Finally

1) Finally的引入

(1) 为了有效的释放在try语句运行过程中申请的资源

2) Finally的概念

(1) Finally：是个坚强的语句，无论任何情况都运行。Finally只怕System.exit(0)整个系统摧毁，整个进程自杀。还怕throw new Error()跟finally是兄弟类，不能捕获，要用Throwable,但错误一般不救

3) Finally语句三件套、

(1) Try…catch..finally

(2) Try…finally…

(3) Try…catch…

(4) try消失了，catch、finally就失去作用了，匪徒都没有了，你要警察干嘛

10. 异常类的分类

1) 运行时异常（Runtime Exception）

(1) 运行时异常extends RuntimeException

(2) 运行时异常是在程序运行过程中爆发的异常，其相对影响面小，问题不严重，一般不影响运行继续运行

(3) 运行时异常无需捕获，自动抛出，也无需throws声明

2) 检查异常（check Exception）

(1) 检查异常extends Exception

(2) 检查异常：代码书写的过程中，抛出的异常。

(3) 其要么try…catch…捕获，要么在方法签名末尾显式申明抛出

(4) 检查异常都在本地处理，如果是主动抛出，何必写成主动异常

11. 重写方法时的异常和修饰符

(1) 子类重写父类方法，不能抛出比父类更多的异常，可以抛出一样的异常（平抛）或少抛

(2) 子类重写父类方法，子类方法的访问修饰符要么平级，要么更开放，不能更严格。

12. 自定义异常

1) 自定义异常的引入

(1) 无法在系统中找到我们需要的异常·，选型时无法找到合适的，找个大概的异常，我们无法进行针对性处理时

① Detailmsg

② Cause

2) 自定义异常的继承

(1) 一般情况，使用运行时异常

(2) 严重情况，使用异常

3) 自定义异常的作用

(1) 为了程序员更好的辨别异常

(2) 捕获时，可以针对处理

(3) 命名一般使用Invalid

4) 异常的注意事项

(1) 生成测试类时，Constructors from superclass，一般不勾选

(2) 异常中getMessage()：打印异常中的信息，

第十四章 时间

1. 时间的引入

(1) 过期方法：JDK不合时宜，NsuchMethodError在未来的某一个JDK可能被取消，可以通过源码找replaced替代

(2) 计算机的内部是数字：不是数字的东西，都是通过数字在后台支撑，字符就是数字，字符就是ask码的数字编号

2. 时间的应用

(1) Now.toLocaleString()：返回东八区的时间

(2) Now.tozGMTString()：返回格林的时间

(3) Now,getTime()：时间本质是数字，返回1970-1-1 8：00：00至今的毫秒

(4) New.setTime()：在1970-1-1的时间上增加或减少时间

3. 时间的文字化输出和时间的本质

时间和字符串互转

(1) 时间转字符串

① SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss SSS,是今年的dd天，第w周");

② Sysout,sdf.format(sdf2.format(now))：输出现在的时间

(2) 字符串转时间

① String futureDateStr = "2022-10-13 212:12:12"：超过的时间会向后推

② SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")：24小时

③ sdf2.setLenient(false)：关闭容错开关

④ Date future = sdf2.parse(futureDateStr)：根据本地时间转换字符串

4. 时间的比较

(1) future.after(now)：future是否在now时间之前

(2) future.before(now)：future是否在now时间之后

(3) nowpareTo(now)：now与now的时间是否相等，-1（小于）、0、1（大于）

5. 时间部分参数分析

(1) Calendar c = Calendar.getInstance()：

① 父类对象指向子类对象，calendar是专用的时间分析工具,具备有强大的时间各方面分析能力

(2) getInstance():

① 获取一个Calendar类型的通用对象。因为Calendar是抽象类不能实例化

(3) System.out.println(c);

① 打印子类GregorianaCalendar和toString的结果

(4) setTime(now)

① ;设置Calendar的时间

(5) 获取星期几

① String dateStr = "日一二三四五六"

l calender的用法都是用123来表示的，我们可以用常量来记忆

② System.out.println("星期" + dateStr.charAt(c.get(Calendar.DAY_OF_WEEK)-1 ));

第十五章 Inner class（内部类）

1. 内部类的引入

(1) 书写JAVA类时，顶级类的访问修饰符只能时public或者是包级别

(2) Java的文件中可以有两个类，并且只能有一个public，而且pulic类的名字要与文件名相同

① 每个编 译单元只能有一个公开的接口(main)，而这个接口就由其public类来表示。

② 如果有一个类，访问权限定义为 public时(但不可以是protected和private)，则该类名必须与文件名一致。否则将会报错。

(3) 因为接口也是类，但是公用接口只能放在自己的文件中。

2. 内部类的由来

(1) 一个java类和另一个java类关系密切，如果离开的java类将没有任何作用，这个java类就自降身份写到另一个java类中，成为它的内部类

(2) 例子：棋子和棋盘的关系密切，如果棋子离开了棋盘，就像一个石头一样没有任何作用

3. 内部类的概念

(1) 把一个类定义在另外一个类的内部，在类里面的类

(2) 内部类是属性级别内部类，跟属性、方法平级

(3) 能够修饰属性和方法的任何修饰符都可以修饰内部类

4. 内部类的分类

(1) 静态内部类

(2) 成员内部类

(3) 局部内部类

(4) 匿名内部类

5. 内部类的用法

(1) 内部类的封装

① 如果两个java类的交互非常密切，写成平行的两个类，调用时，一封装，很多东西都调用不到，就可以使用内部类。

(2) 内部类的实例化

① 引用变量的书写，写外部类的归属，创建外部类的实例，再创建内部类的实例

6. 内部类的用途

(1) 调用更轻松

(2) 一个类对另一类有强烈的依赖，一旦离开外部类就没有用处了。

7. 静态内部类

(1) 静态内部类不需要外部类的存在，就可以创建它的实例。（直接用类访问）

(2) 静态内部类不能访问外部类的实例属性和方法，可以访问外部类的静态属性和方法

(3) 静态内部类的访问

Teather.A name = new Teather.A();

name.run();

8. 内部类的发现机制

(1) 用private,内部类只想被本类使用，用package级别用于同包类。

9. 局部变量级别内部类

(1) 局部变量级别内部类的作用

① 内部类专门为方法使用，其他地方均不可用

② 因为有些方法的结构比较复杂，使用类可以更好的归纳功能

l Void hello(){class A()}}

(2) 局部变量级别内部类的注意事项

① 所用能修饰局部变量修饰符都能修饰局部变量级别内部类

② 访问修饰符只能在方法和属性身上。访问修饰符是调用属性和方法

③ 局部变量无法使用访问修饰符、静态，可以final、abstract

④ 大环境私有，小环境公共作用不大

(3) 局部变量级别内部类的文件

① ChessBoard$1A.class

② ChessBoard文件中第一个方法中的A内部类

(4) 类名的目的：反复创建多个实例

10. 匿名类

M m = new M(); + class M extends D{}+m.work();——>M m = new D(){}.work();

因为匿名类没有名字就删除，M m = new D;{} + m.work();

创建对象后要有构造方法——>M m = new D(){}.work();

多加了public因为子类重写方法的权限不能比父类小（里氏代换原则）

里氏代换原则：任何基类出现的地方，子类也一定可以出现。

例题：

public Check check(){

/*通过匿名类访问接口/

Check check1 = new Check() {



@Override

public boolean isCheck() {

// TODO Auto-generated method stub

if(Teather.this.integral > 80)

return true;

return false;

}



@Override

public String toString() {

return "" + isCheck();

}



};



return check1;

}

(1) 匿名类的出现

① 创建一个类的一次实例，用完就算了。就不给类起名字了，再创建实例

(2) 是一种特殊的局部变量级别内部类

(3) 只有创建一次实例。可以用引用变量指向，续命。

(4) 一个包级别的类只能本同包类可见，其他包的类均不可见

(5) 例子1：

① class D{void work() {}}

② D d = new D() { void study() {}；void work() {} };

③ new class ???extends D

l 父类引用对象指向子类对象，只能看到父类的部分

(6) 例子2：

① class D{ int i; public D(int i) {};void work() {}}

② D d = new D(10) { void study() {}；void work() {} };

l 父类中出现了有参构造方法，匿名类需要调用父类的有参构造方法，匿名类子类就要显示调用父类的有参构造方法，要写自己的构造方法，构造方法与类同名，就无法写，这种可以多次使用

(6) 例子2：

① interface A{ void swim();}

② new A() {public void swim() {};}.swim

l 一次性使用

l New class ??? extends Object implements A()

第十六章 IO输出

1. IO的引入

(1) java代码输入关机之后在内存中的对象不能存在，要将数据落地，

① 通过IO保存到磁盘文件上，自己拟定一个文件保存

② 保存到数据库

2. File

1) File的分类

广义文件

(1) 任何设备都是文件

(2) 打印机、扫描仪

侠义文件

(1) 磁盘上的文件以及目录，目录也是文件，是一个文本文件，记录了这个目录下属的文件

2) File的新建

File file = new File("D:\records.txt")

① File：存在IO包中

② New File()：新建文件

③ ("D:\records.txt")：文件的路径

l \：反斜杆两个，转义符

l /：正斜杠一个

3) File的语法

File的判断

(1) file.isFile()：判断是否是文件

(2) file.isDirectory()：判断是否是目录

(3) file.exists()：判断是否存在

File的读写情况和权限情况检测

(1) file.canWrite()：能否写入

(2) file.canExecute()：能否执行

(3) file.length()：文件大小

(4) file.lastModified()：1970至今的毫秒数

(5) new Date(file.lastModified()).toLocaleString()：格式化打印时间

File的目录操作

(1) dir.list()：可以得到目录下所有文件的名字构成的列表，是字符串数组

(2) dir.listFiles())：目录下所有子文件的信息

(3) dir.listFiles()：录下所有子文件的信息

(4) subFile.getName()：获得文件的名字

blic static void main(String[] args) {

/** 创建删除文件 */

File file = new File("D:/file.txt");



if(!file.exists()) {

try {

file.createNewFile();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}



System.out****.println("创建文件成功！");

}else {

file.delete();

System.out****.println("删除文件成功！");

}

3. API

(1) 全称叫(Application Programming Interface)，中文名叫应用程序接口，是对java预先定义的类或接口功能和函数功能的说明文档，目的就是提供给开放人员使用帮助说明，多指API文档，是对java提供的类和接口中的功能进行一个说明

(2) IO的学习就是功能模块

4. 流

1) 流的引入

流的概念

(1) Java中所有数据都是使用流读写的

流的出现

(1) 程序员将写入的java程序放在显示器上展示，去了解cpu的底层文件操作划不来，

流的方向

(1) 以CPU为参照物来识别流的方向

① 输出流（先碰到CPU的流）

② 输入流

标注

流的思路

(1) 先创建流，因为是手工创建的流，要自己来关闭。系统创建的流，会在关机的时候，自动关掉。系统再编译时，偷偷创建流。

2) 流的规范

标准输出、入流

(1) 标准输出设备（显示器）

① 输出流的末端的文件，连接者为显示器

② 系统帮助应用程序构建，是自动的

③ 使用system.out（是个引用变量，指向输出流）

(2) 标准输入设备（键盘）

① 输出流的开端的文件，连接者为键盘

② 系统帮助应用程序构建，是自动的

In、out、print

(1) 不考虑print（）里的内容，技术称为重载，根据参数类型及数量的不同

(2) In和out都是引用变量指向一个对象，这个对象就是一个流

(3) In = InputSteam = 二进制

流的数据格式

(1) 字节流、二进制流（默认流）：

(2) 字符串

l 任何一个流都是字节流，字节流是流的原生形态，任何设备和数据，都是按二进制处理 传送任何数据都是有效的

字节流的命名风格

(1) 字节流

① 输入流：xxxinputStream（二进制）

② 输出流：xxxoutputSteam（二进制）

(2) 字符流：xxxxReader、xxxWriter

IO流的分类

(1) 按数据流方向不同，分为输入流和输出流，是先对于计算机内存来说的

① 输出流：outputStream和Write作为基类

② 输入流：InputStream和Reader作为基类

(2) 按数据处理单元划分，分为字节流和字符流

① 字节流

l 字节输入流InputStream基类

l 字节输出流outPutStream基类

② 字符流

l 字符输入流Reader基类

l 字符输出流Write基类

3) 二进制转字符的意义

(1) 键盘输入的0101，但是转成字符有意义（建议转）

(2) 摄像头传入是0101，但转成字符无意义

(3) 每16bit转成conicode编码，

4) 传输文件的框架

(1) 键盘就是丢几个文字到流中，流顺着方向到CPU上

(2) CPU就是丢几个文字到流中，流顺着方向到显示屏上

(3) IO流就是不谈细节、不谈硬件、谈的是想象和抽象，就是逻辑思维能力

(4) 键盘输入保存到文件中，键盘先流到CPU，CPU在保存文件到

5. InputStreamReader

1) InputStreamReader的概念

(1) 从字节流到字符流的桥接器

2) InputStreamReader的作用

(1) 将键盘中输入的二进制转换器字母

(2) 字节流转为字符流，字节流就是二进制流

(3) 文件输出流只拥把数据保存到文件的能力

3) InputStreamReader用法

(1) 创建一个向具有指定名称的文件中写入数据的输出文件流

(2) inputStreamReader()：传入的是二进制流，传出的reader（字符）

(3) 判断是否转为字符：键盘（有必要）、摄像头（没必要）

4) read的用法

(1) System.in.read()：一次性只能读入一个字节或数组等等

(2) Reader.read()：可以读入字符数组

6. BufferedReader

1) BufferedReader的引入

(1) 因为inputStreamReader效率低：无法一次性都一句话

(2) BufferedReader：带缓存的Reader，到达一定容量在传输，而不是16bit提高效率

2) BufferedReader的扩展

(1) Buffered缓存：从上往下越来越慢，容量越来越大

① Register

② Cache

③ Buffer

④ Pool

(2) 例子：洗碗的工作，碗放在50米的地方，要用大的容器装，再一起推过去

7. KeyBorad到Text的流程

(1) 输入字节——>转换字符——>缓存——>读取文件——>CPU——>指向文件——>新建流（根据流的方向）——>转换字节——>写入文件——>关闭流

1) 输入字节

(1) System.in

2) 转换字符：

(2) InputStreamReader reader = new InputStreamReader(System.in)

3) 缓存：

(3) BufferedReader br = new BufferedReader(reader);

l 管道：BufferedReader br = new BufferedReader(new InputStreamReader(System.in))

4) 读取文件

(4) String entry = br.readLine()//返回字符串

5) 指向文件

(5) File file = new File("D:/novel.txt")

6) 新建流

(6) FileOutputStream fos = new FileOutputStream(file)

l 字节流

7) 转换字节

(7) PrintWriter writer = New PrintWriter(fos)

8) 写入文件

(8) Writer.println(entry)

9) 关闭流

(9) Write.flush()（清空缓存）、write.close()

10) 注意事项

(1) 当CPU把文件保存到文件的时候，其实只是说把数据保存到了流，数据还没保存到文件，要到一定量才传输数据，表面写盘了，其实没有。

(2) 系统还开着system.in，流就不要关闭。默认已经写了关闭代码，提前关闭会出错

8. 持续录入Text

(1) readLine().equalsIgnoreCase(“END)

l 用于将字符串与指定的对象比较，不考虑大小写

9. 文件的拷贝

1) 流一

(1) ：新建文件——>指向文件——>新建输入流——>转换字节——>缓存

2) 流二

(2) ：新建文件——>指向文件——>新建输出流

3) 判断流

(3) ：流一的文件不为空时，写入

10. 图片的拷贝

1) 新建流

① 新建图片——>指向文件——>新建输入流

② 新建图片——>指向文件——>新建输出流

2) 新教缓存

(1) ：byte[] buffer = new byte[2000]

3) 读取图片

(2) ：fis.read(buffer)不等-1时，读取

4) 写入图片

(3) ：fos,writer(buffer)

5) 关闭流

6) 读入写入注意事项

(4) 图片的传输过程中，复制的图片会多出几字节，图片有一定的纠错能能力，多出的字节会忽略

(5) 问题解决：最后一车会有100多字节

7) 读入写入解决方法

(7) fos,writer(buffer，0，len)

11. 对象的录入

(1) 新建文件——>指向文件——>新建输出流——>转为对象输出流（对象转二进制）——>实例化对象——>写入文件

1) 新建流

2) 对象输出流

(2) ：ObjectOutputStream

3) 写入文件

(3) ：oos.writeObject(stu)

① 将指定的对想写入文件

4) 关闭输出

(1) Writer.flush

(2) Writer.close

5) 序列化

(1) 概念：对象编程二进制的字符串，这个过程叫序列化，只是一个标识位（不是所有的对象都可以转成接口）

(2) 一个java对象如果能被对象输出流保存，需要实现序列化接口，类中的所有非transient属性都要实现序列化

(3) 实现：对象转为二进制存盘需要实现接口 Serializable

(4) 反序列化：将0101变成对象

(5) 内部操作

l if（stu instanceof Student）开启序列化功能让系统发现这个类要有序列化的能力，额外补充相关的代码，语法糖

12. 对象的读取

(1) 新建文件——>指向对象——>新建输出流——>新建对象输出流（转为字节）——>新建Object读取字节——>判断类型一致——>打印——>关闭

1) 新建Object读取字节

(1) Object object = ois.readObject()

2) 判断类型一致

(2) If(obj instanceof Student)

3) 打印

4) 关闭流

(3) Ois.close

① 读取不需要flush，写入要flush，close的过程中发现没有flush,也会flush

13. 序列化类中添加类

(1) 一个类对象要能够序列化，必须确保这个类的所有属性的数据类型均能支持序列化，并实现

(2) 大部分的基本数据都实现了序列化

(3) Transient

① 不想被存盘（如果不想实现序列化，使用transient）

② 类没必要实现序列化，在属性前面加transient·（暂时，临时）

③ 在Data中可以看见transient

第十七章 集合（Collection）

1. 集合的引入

(1) 对六个毫无关系的数进行排序，比较困难的，科学家们就发明了数组，是最原始的集合类型，原生态的集合类型。

(2) 数组

① 数组的作用

l 相同数据类型在同个集体名下，共同作战，提升了团队协作能力，为更复杂的操作鉴定基础。

② 数组的缺陷

l 容量确定后，无法改变规模

l 删、插的成本高，造成“内存波动”

l 数据类型单一

l 内存成片高，大量连续空间

③ 数组的优点

l 轻量级、低成本的变量集群（内存消耗少）

l 随机检索速度快

2. 集合的出现

程序价格低、程序员价格高，需要更加容易编程，提高效率

3. 集合的类型（现代的变量集群）

1) Collection（interface）

概念

Collection是所有集合的根接口

用法

通过子接口实现

2) List（interface）

(1) 概念;模拟队列等生活中对先后顺序敏感的场合

(2) 排序，不唯一

(3) 排队买ipone，可以重复买

ArrayList（大掌门）

(1) 概念：ArrayList内部依赖的是一个对象数组Object[]，其有众多方法，均围绕该对象数组展开。

① Size()：获得arraylist中内部的实际包含元素的数量（会警告）

② ArrayList<Object> a1 = new ArrayList<Object>();

③ Get()：通过下标，获取数组元素

(2) 优点：

① 随机定位很快，边界

② 添加方便，Add的引用变量参数类型：Object

(3) 缺点：

① 删、插波动大，在元素数量超出范围时，有大量的数组元素拷贝的操作发生，对系统性能有影响

(4) 适用：

① 数据录入后，较为稳定，删、插较少，大多定位查询

② 数据增加频率间隔较长，不持续连续增加

③ 对先后顺序敏感的数据结构

(5) 遍历：

① 常规遍历

② 集合遍历

l Foeach循环

//每次选出a1赋值obj

for(Object obj:a1) {

System.out****.println(obj);

l }。//syntax sugar，1.5版本

③ 迭代器

Iterator itr = a1.iterator();

while(itr.hasNext())//有下一个

{

System.out****.println(itr.next());}//里面的值；foreach的原生态

}

l 任何集合类型对象都有Iterator,返回iterator对象，能够遍历某种类型的元素

JAVA类实现了这个接口，就允许JAVA类的对象作为foreach循环语句的目标，

目标就是：后面的，什么样的java实例能放在右侧，只要实现Iterator接口

(6) 泛型（generic）：

① 出现：

l 获取困难：get的硬功变量参数类型：Object，需要换成标配

l 类转换可能出现异常

l 限定传入和输出的类型

l E：entity（实体

l

② 用法：

l 可以指定传入的类型

ArrayList<Apple> apples = new ArrayList<Apple>();

apples.add(null);

③ 概念：模板类就是类的模具，动态的，JAVA叫泛型

l 用处：类与类之间只有轻微的不同

④ 泛型类

User<String> user = new User<String>();

public class User<T> {//泛型类

T t;//成员属性



public T getT() {

return t;

}

public void setT(T t) {

this.t = t;

}

}

⑤ 泛型方法

/* 泛型方法 ：传入任意类型/创建当前类型的对象且获取这个类型的全部属性/

/** 且其属性为name，则可以传入name为小李 ，与反射搭配

传入的类创建对象，设置他们的属性或方法*/

@SuppressWarnings("deprecation")

public static <T> T print(Class c1) {

/** 1、强制转换2、反射 */



/** 2、传入任何对象都可取出这个对象 */

// System.out.println(t.getClass());



/** 3、泛型没有构造函数 */

// T t = new T();



/* 4、泛型的使用：被创建或者传入/



/**5、通过反射传入数值 */



/**将传入的类型取出 */

// Class c1 = t.getClass();

/* 通过类创建对象（调用构造函数）,传入class形参时，使用/

T t = null;

try {

t = (T) c1.newInstance();

 

//反射属性

c1.getDeclaredField(null)//根据名称获取属性

c1.getDeclaredFields()//根据名称获取属性数组

c1.getDeclaredMethod(null, null)//根据方法名获取方法

c1.getDeclaredMethods()//获取方法们

// field[]:属性对象

// method[]:方法对象



/* 数组————遍历/

Field[] fields = c1.getDeclaredFields();



for(Field field:fields) {

// System.out.println(field);

field.setAccessible(true);//开权限private开锁

if("name".equals(field.getName())) {//获取属性的类型

field.set(t, "小李");

}

}

} catch (InstantiationException | IllegalAccessException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return t; }



/**

* @param args

*/

public static void main(String[] args) {



/* 通过User类创建User对象/

User user = print(User.class)



Object user = print(User.class);;

System.out****.println(user);

}

LikedList（链表为基础）（二掌门）

(1) 概念：

① 也属于泛型

(2) 优点

① 对内存成片性低

② 增、删无难度

(3) 缺点

① 随机查找低

② 内存存储高，除记录本身外，还要记录前后

(4) 循环

① Foreach：实现List，List实现collection，collection实现iterable

(5) 适用:

① 数据录入后，较为不稳定，有着频繁删除和插入操作，随机定位查询相对较少

② 适合队列等对元素的先后顺序极为敏感的数据结构

Vector

(1) 每个方法都是单线程

LikedList

3) Set（interface）

概念

(1) 无排序，不重复

(2) 公告栏看成绩，不排序，但成绩唯一

HashSet

(1) 特点:

① 无序，不重复

② 根据Hash算法进行内存分配

(2) 用法：

① Add：继承了collection

② 重写hashcode和equals

(3) 顺序：

① 自然顺序：从小到大排序

(4) Hashcode()：

① 流程对象进入HashCode存储空间需要出示哈希值，对象就调用HashCode（），把值交给保安，保安会根据列表，判断hashcode，完全不一致直接收对象，若hashcode的值一致，判断equals()方法，不一致接受对象0，一致拒绝接收

② Object.hashCode()

l Object对象有一个hashCode方法，该方法时本地方法，由C语言实现，返回的时这个对象在内存中的开始地址，返回值时一个整数

l 任何对象如果其没有重写Object的hashCode方法，那么其hashCode的值均是不同的

③ Hashcode()的出现

l 集合类型对性能要求很高，equals判断涉及较为复杂的逻辑，成本很高，在某种程度上会减低性能，但equlas判断也是精度最高的判断。

④ Hashcode的速度

l HashCode内部是整数运算，而底层还是C的。

⑤ HashCode与equals的契约

l 由于hashCode和equals方法之间有着主从关系，特别如果一个对象最终要与hashset打交道的时候，就必须同时重写hashcode和equals方法，两个方法在重写的时候，必须保证一个 约定，否则将重写失败。

(1) Hashcode不同，equals一定要不同

(2) Hashcode相同，equals可以不同

l 一块钱的试剂，检测不是非典，一百块试剂，检测也一定不是非典

(5) 例题

/**

* HashSet的判断

* @author 64308

*

*/

public class User {



String name;

/** 包装类：具有equals方法方可比较 */

Integer age = 0;



public User(String name) {

super();

this.name = name;

}



@Override

public String toString() {

return "User [name=" + name + "]";

}

/* 重写hashCode，创建属于自己的hashCode/

@Override

public int hashCode() {

System.out****.println("hashcod！");

return this.name.hashCode() + this.age.hashCode();

}



/** 自定义类的判断 */
@Override

public boolean equals(Object obj) {

System.out****.println("调用了equals......");



if(obj == null)return false;

if(obj == this)return true;



if(obj instanceof User) {

User otherUser = (User)obj;

return this.name.equals(otherUser.name) && this.age.equals(otherUser.age);

}

return false;

}

}

(6) TreeSet

① 排序

l 自然排序

② 用法

l 实现comparable（可比较接口），需重写companies方法

l 为0时，覆盖前面

③ 注意事项

l 系统的类，都能再度TreeSet中使用，因为都已经实现

④ 代码

@Override

public int compareTo(User o) {



System.out****.println("compareTo.........");

// if(this.age > o.age)

// return 1;

// else if(this.age < o.age)

// return -1;

//

// return 0;//等于零时，不存放



return this.agepareTo(o.age);//系统自动帮你写好了

}



@Override

public String toString() {

return "User [name=" + name + ", age=" + age + "]";

}

4. 集合的常用方法

(1) Add：追加到最后一个

(2) Add(index,obj)：插入数据到index所指定的下标位置

(3) Remove（index）：删除指定index位置的元素

(4) Remove（obj）：删除与该对象匹配的元素（依靠equals匹配）

(5) Contains（obj）：查看是否存在该元素

(6) indexOf（obj）：查看元素出现的索引位（从头开始查）

(7) lastIndexOf（obj）：查看元素出现的索引位（从末尾开始查）

(8) isEmpty（）：查看arraylist是否存在有效元素

(9) subList（）：创造子List

(10) toArray（）：把List转数组

(11) trimToSize（）：缩小容量到实际元素大小

5. 集合类型的注意事项

(1) 集合类型只能操作对象

① Int——>Integer

(2) Native

① 是由底层C语言代码，不可见

(3) 适配器模式。

第十八章集合（Map）

1. Map的概念

(1) 理解：去超市存东西，小妹给你一张小票，后续可以根据小票，拿东西

(2) Map<K，V>：Key 和 Value（键、值）

(3) 以HashCode作为key管理机制的map实现，所以一个java类想作为HashCode的key，该类必须同时重写hashCode和equals方法，并通过某种协议

(4) HashMap是线程不安全的，速度快，使用更广泛

2. HashMap

1) HashMap的理解

(1) 同样的key不能指向不同的对象，将会产生覆盖，不同的key可以指向相同的对象

(2) 理解：一把钥匙只能开一个门，多把钥匙可以开一个门

2) HashMap的方法

(1) Get（Object）：输入key返回value

(2) keySet（）：返回所有key

3) HashMap的遍历

Set<Integer> keySet = hashMap.keySet();

for(Integer key:keySet)

System.out****.println(key + "——>" + hashMap.get(key));

}

4) HshMap的雷同

(1) hashMap的key是否雷同，hasCode先判断，然后再equals

5) HasSet的管理机制

(1) 这个类的hashCode和equals的实现有何要求

(2) 以HashSet为key管理机制的map实现，所以一个java类像作为HashMap的Key，该类必须重写hashcode和equals方法，并开通某种协议

6) HashMap的注意事项

(1) 同样的key不能指向同样的对象，不同的key能指向相同对象

① 一把钥匙只能开一扇门，多把钥匙能开一扇门

(2) key位置的存放： hashMap的key必须能放在能放在hashSet中工作的java类对象，

7) HashMap例题

Map<Integer, User> map2 = new HashMap<Integer,User>();

map2.put(1, new User("11"));

map2.put(2, new User("11"));

map2.put(3, new User("11"));

map2.put(4, new User("11"));

map2.put(5, new User("11"));



Set<Integer> integers = map2.keySet();

for(Integer integer:integers) {

System.out****.print(integer + " ");

System.out****.println(map2.get(integer));

}

3. TreeMap

1) TreeMap的概念

(1) 以TreeSet作为key管理机制的Map实现，所以一个java类想作为TreeMap的key，该类必须实现Comparable接口，实现CompareTo方法

@Override

public int compareTo(Apple o) {



System.out****.println("compareTo.........");

if(!this.color.equals(o.color))

return this.colorpareTo(o.color);

else if(!this.weight.equals(o.weight))

return o.weightpareTo(this.weight) * -11;

else

return 0;

}

4. Hashtable

1) Hashtable的概念

(1) Hashtable的实现机制和HashMap类似，

(2) 是线程安全的，速度较慢

第十九章静态块

1. 静态块的出现

(1) 当我们实例属性复杂初始化时，使用构造方法可以自动加载

(2) 当我们静态属性复杂初始化时，使用静态方法却要手动加载

(3) 静态块的出现可以在类加载时，自动执行静态属性复杂初始化

2. 静态块的注意事项

(1) 生命周期只有一次，不会反复调用

(2) 在一个类中可以定义多个静态块，当类被加载时，这些静态块会根据源代码先定义的次序依次加载

(3) 当静态块初始化异常时，直接报错误，系统崩盘，因为类加载的调用者是JVM

第二十章 设计模式

1. 概念

(1) 前人经过多次尝试，总结出来的解决问题方法

(2) 常考：工厂模式、适配器模式，单例模式，观察者模式

1) 软件编码设计模式

(1) 在软件编程方面，如何去写编程，并写好程序，提高服用效率，软件大师们经过长时间的摸索，得出一些写代码的一般规律

2) 历史

(1) 四人帮23种设计模式，GOF23，（Gang Of Four GOF）,<<design

3) 意义

(1) 提高代码效率，提高可复用性

(2) 能看懂大师的代码

4) 反模式

(1) 经典的不合理做法

2. 分类

(1) 创建模式

① 工厂模式（Factory）

② 简单工厂模式（Simple Factory）

③ 工厂方法模式（Factory Method）

④ 抽象工厂模式（Abstractor Factory）

(2) 建造者模式（Builder）

(3) 原型模式（Prototype）

(4) 单例模式（singleton）

3. 基本设计原则

(1) 单一职责原则

① 一个类应该仅有一个引起它变化的原因

② 多个类的类似功能，或者是多个方法类似功能

③ 类的复杂度降低，可读性提高，可维护性提高

(2) 里氏替换原则

① 子类必须能够替换它们的基类

② 父类定义子类实现

(3) 依赖导致原则*

① 高层模块不应该依赖于底层模块，二者应该都依赖于抽象

② 抽象不应该依赖于实现细节，实现细节应该依赖于抽象

③ 定义父类接口，更换子类实现接口

(4) 接口隔离原则

① 不应该强迫客户程序依赖于他们的不用的方法

② 将通用的功能和特有的功能都形成一个接口，子接口调用父接口

(5) 迪米特原则

① 一个对象应该对其对象最少的了解

② 降低耦合性，父类只需要命令子类

(6) 开放封闭原则*

① 类模块应该是可扩展的，但是不可修改

② 对扩展开放，对更改封闭

③ 通过扩展属性，关闭修改

4. 简单工厂模式

(1) 概念

① 专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类

② 又称静态工厂模式，通常它根据自变量的不同返回不同的类的实例

(2) 优缺点

① 优点

l 能使客户端独立于产品的创建过程，并在系统中引入产品时，无需对客户端进行修改

② 缺点

l 当有产品要加入系统中时，必须修改工厂类，以加入必要大的处理逻辑

5. 单例模式（singleton pattern）

1) 适用场合

(1) 创建一个对象的成本高昂，需要消耗大量的CPU时间以及内存资源

(2) 对象之间没有差异（无状态），没必要创建多个对象

① 全球限量

2) 使用方法

(1) 收回对象的构造权

① ·构造方法的私有，只能在本类可见，创建类必须调用构造方法，只能类调用方法

(2) 在体内实例静态属性，和静态方法

(3) 创建返回值为接口类型、类类型..方法

6. 工厂模式

1) 出现

单体工作无法推动社会发展

2) 概念

(1) ：把细节隐藏，往往返回接口，

3) 协同性

(1) ：与单例协同工作

4) 工厂的构建

(1) ，很消耗体力的过程，往往做成单例，

7. 适配器模式

1) 出现

(1) 只对接口的某个方法感兴趣，却要实现所有的方法

2) 使用

(1) 实现接口使用抽象类，类继承接口

第二十一章 线程

1. 线程的概念

(1) 进程是个逻辑单位，一个进程至少有一个线程（thread），线程是真正的执行者

(2) 只有线程才能得到CPU时间，才能够使用CPU，所以我们任何一个方法都跑在某个线程上

① CPU时间：CPU允许使用的时间

(3) 识别线程的位置， System.out**.println(Thread.currentThread**().getName());

① 获得当前方法的执行所依赖的线程

2. 线程的使用

(1) J2EE使用不多，web服务器解决了线程问题。

(2) 多线程：多人访问服务器

3. 线程的理解

(1) 时间片轮转：把时间切成很小的单位轮流的为线程服务。

(2) 一个进程结束，线程应该全部跑完

(3) 线程按顺序放入，不一定先运行

① 把菜放入锅里，不一定先炒

4. 线程的创建

(1) 继承线程类，重写run方法

① Run方法：线程任务的载体，run方法内写的线程执行的任务，任务运行完线程结束，需要所有线程结束，进程也将结束

② 班级来了五个人扫地，小明开始扫地（小明正在完成自己的任务），小明把地扫完了，线程结束了，五个人都扫完，大扫除结束

③ 占用继承位

(2) 线程的启动：可以通过其他线程，没有从主关系，都是平行的

(3) 实现runnable（常用）

① Thread t2 = new Thread(new MyTask());

l 新建线程Thread把，把实现runnbable接口的对象存入，空出继承位

(4) 例题：

① t.start();：

l 申请并获得属于这个线程的执行空间，也就是栈空间，

l 执行run方法跑线程的任务

② 如果只执行run（）；

l 只是调用了run方法，并没有申请内存空间

(5) 线程默认名字：Thread-0

5. 线程创建的比较

(1) 继承Thread类方式的多线程

① 优势：编写简单，可直接操作线程

② 劣势：无法继承其他父类，适用于单继承

(2) 实现Runnabel接口方法的多线程

① 优势：可以继承其他类，多线程可共享同一个Thread对象

② 劣势：编程方式稍微复杂，如果需要访问当前线程，需要调用Thread,currentThread（）方法

6. Thread类的常用方法

(1) Static Thread currentThread（）：得到当前线程（CPU正在运行的线程）

(2) Final String getName（）：返回线程的名称

(3) Final void setName（）：将线程的名称设置为由name指定的名称

(4) Void start（）：调用run（）方法启动线程，开始线程的执行

7. 线程的启动

(1) 线程可以创建启动其他线程，必须靠其他线程，线程之间都是平级的，对CPU进行争夺

(2) 直接执行run（）没有start（）就只是执行run方法，运行start可以创建栈空间，没有创建多线程，运行在main线程之上

(3) 调用start（）方法，子线程执行run方法，多条执行路径，主线程和子线程并行交替执行-

8. 线程的调度

(1) 概念：按照特定的机制为多个线程分配CPU的使用权

(2) SetPriority（int newPriority）：更改线程的优先级

(3) Static void sleep（long milis）：在指定的毫秒数内让当前正在执行的线程休眠

(4) Void join（）：等待该线程终止（强制执行当前线程）

(5) Static void yield（）：暂停当前正在执行的线程对象，并执行其他线程

① 让步：该方法不一定有效，可能一刹车就立马启动

(6) Void interrupt（）： 中断线程

Boolean isAlive（）：测试线程是否处于活跃状态

9. 线程的优先级

(1) t2.setPriority(Thread.MAX_PRIORITY****);

(2) 默认情况下，一个线程继承其父类线程的优先级

(3) Sleep（）：

① 使线程停止运行一段时间，将处于阻塞状态

② 阻塞的时间由毫秒数决定

③ 设置休眠时间，运行时与设定的时间有一定差距，运行也需要时间

System.out**.println("当前时间" + System.currentTimeMillis**());

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out**.println("结束时间" + System.currentTimeMillis**());

(1) Join（）：

① 阻塞指定线程等到另一个线程完成以后在继续执行

for(int i =0; i < 100; i++) {



System.out****.println(i);

if(i == 3) {

Thread1 thread1 = new Thread1(10);

thread1.start();//可执行状态

thread1.join();//终止正在执行的线程（主线程），先执行当前线程

}

}

Yield（）：

l 暂停后：直接将当前线程转入可运行状态

l 没有其他等待运行的线程，当前线程马上恢复执行

l 等待线程的优先级别：将优先级相同或更高的线程运行

③ SetDemon（）：

l 可以将指定的线程设置为后台线程

l 创建后台线程的线程结束时，后台线程也随之消亡

l 主线程时后台线程，而继承Thread的线程的独立线程，关闭软件后仍然运行while（True）

this.setDaemon(true);//守护线程，主线程结束，后台关闭

while(true) {

System.out****.println("线程1");

l }

④

1) 线程的同步

(1) 多线程默认：异步

(2) 鸡腿——>一次只处理一个同学的请求（同步）

(3) 异步：同时进行（不排队，插队）

(4) 同步：排队进行一个一个来（操作同一共享资源，先后操作）

① 同步关键字方法，同步方法块//同步锁

② private synchronized void makeWithdrawal(int amt)

③ synchronized (acct) {}

(5) 同步锁：将别线程锁死，只有线程运行完时，再开锁，放下一个线程

(6) 线程具有独立性——>不能确定当前数据的正确性

(7) 线程同步的好处

① 解决了线程安全的问题

(8) 线程同步的缺点

① 性能会下降

② 会带来死锁

(9) 死锁：当两个线程相互等待对方释放“锁“时，就会发生死锁

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

② 多线程编程时，应该注意避免死锁的发生

③ 解决代码块写少一点

2) 线程的生命周期

(1) 线程对象构建态（new）：只是普通对象，没获得CPU运行的权力，堆、栈的空间

(2) 可执行态（runnable）：通过thread.start()，获得栈等专为线程内执行设置的空间

(3) 运行态（running）

(4) 死亡

10. 线程的注意事项

(1) 一个进程至少要有一个线程，这个线程是自动创建的，是由JVM自动创建，这个最早的线程的名字叫main线程

(2) 跟面向对象没什么关系

(3) 线程以前都是单线程，无论调用多么复杂，其实只调用一条路径最后回到main

(4) 线程的时间片到了，就返回队列，进行下一次等待

① 优先级高的线程，在等待队列中，被选中的概率就大，就先跑完

(5) 线程执行结束：进入死亡状态，t.isAlive()：判断线程是否处于死亡状态

① 进入死亡状态，不能再次调用start（）唤醒

11. 线程的阻塞、等待、加入

(1) new Thread(new Runnable() {//new class ??? implement Runnable（语法糖）

(2) 例子

new Thread(new Runnable() {



@Override

public void run() {



for(int i = 0; i < 100; i++) {

System.out****.println(i);

}



}

},"work").start();;

(3) Yeile（）自愿让位：当前线程注定放弃CPU，从运行态回到等待执行态，然后公平选择，有可能下次选中的还是他，

(4) Join（）：当前main线程停下来，等t1线程跑完后，main线程接着跑，t1好像加入到了mian线程内部，成为mian线程的一部分

12. 线程的通信

(1) 解决问题的方法

① Final void wait（）：表示一个线程一直等待，直到其他线程通知

② Void wait（long timeout）：线程等待指定毫秒参数的时间

③ Final void wait（long timeout，int nanos）：线程等待指定毫秒，微秒的时间

④ Final void notify（）：唤醒一个处于等待状态的线程

⑤ Final void notifyAll（）：唤醒同一个对象上所有调用wait（）方法的线程，优先级别高的线程先运行

(2) Wait 和 Sleep

① sleep只能再本类中休眠

② 例子

③ 消费者给生产者发送notifyAll请求，消费者wait，生产者激活，生产完向消费者发送notifyAll请求，生产wait。直到

(3) Timer定时器

① 用处：凌晨自动发邮件，凌晨自动删除数据库

② 例题：定时删除

/** 定时删除数据库 */

Date date = new Date();

date.setHours(20);

date.setMinutes(0);

date.setSeconds(0);//判断是否超过预定时间

Date now = new Date();



if(!date.after(now)) {//预定时间比现在晚

date.setTime(date.getTime() + 1000 * 60 * 60 * 24);

}



Timer timer = new Timer();

timer.schedule(new TimerTask() {



@Override

public void run() {

System.out****.println("删除数据库！");

}

l }, date,1000 * 60 * 60 * 24);

③ 例题

timer.schedule(new TimerTask() {//制定计划，是个子线程

//new TimerTask()任务列表

@Override

public void run() {

//进入线程时，把值当作常量，当同时操作时，会出现线程污染

//地址不变就可以当作常量,改变堆中的地址，引用变量不变

// account.setBalance(100);

System.out****.println(1);

System.out****.println("时间到了！");

}

},0, 3000);//毫秒数,零秒后执行，每三秒执行一次

Account account = new Account();

Timer timer = new Timer();

Date date = new Date();

date.setMinutes(01);

// 要把秒数清空，00：30——>01：30
timer.schedule(new TimerTask() {//制定计划，是个子线程

//new TimerTask()任务列表

@Override

public void run() {

//进入线程时，把值当作常量，当同时操作时，会出现线程污染

//地址不变就可以当作常量,改变堆中的地址，引用变量不变

// account.setBalance(100);

System.out****.println(1);

System.out****.println("时间到了！");

}

},date, 3000);//毫秒数,零秒后执行，每三秒执行一次

13. Lambda表达式

用法：仅有一个方法的接口

语法：(参数列表)->{}

特殊：方法只有一条返回值的语句，()->语句

本文标签： 基础Java