java程序员的自我修养

超级详细的java程序员的自我修养入门笔记！下图详细地梳理汇总了java常见异常、final关键字、静态初始化块、多态、权限修饰符、流程控制等知识要点，值得收藏学习。

java 程序员自我修养

第一篇 基础知识

第一章 初识 java

1.1 Java简介

1.1.1 什么是 Java语言

是一种通过解释方式执行的Java语言

跨平台的程序语言

是编译型的 又是解释型的

javaJVM 对字节码进行解析和运行

编译 只运行一次 而解析在每次运行都启用

虚拟机将字节码解释为机器码 然后在运行

1.1.2Java的应用领域

应用领域

桌面应用系统的开发

嵌入式系统的开发

电子商务应用

企业应用开发

交互式系统开开发

多媒体系统开发

分布式系统开发

Web应用系统开发

1.1.3 Java的版本

Java SE

java基础版

包含

Java的基础语言

JDBC

IO

网络通信

多线程技术开发

JavaEE

Java企业版

作用

企业级分布式网络程序

JavaME

嵌入式系统开发

1.1.4 怎么学好 Java

明确目标

找本书 系统的学习

了解设计模式 代码必须有高度的可读性 维护性 和升级的价值 学习设计模式掌握整体结构

掌握基本语法 了解一些功能即可 不要死记硬背

多动手 多思考 多请教

遇见问题 不急躁 冷静思考

多查阅资料

多阅读源代码

1.1.5 Java API 文档

API:

应用程序编程接口

是编程 词典

1.2 Java 语言的特性

1.2.1 简单性

面向对象的编程语言

java 对 C++ 进行了简化和提高

java 提供丰富的类库 和第三方开发包 有大量的开源项目 JDK已经开源代码 分析项目源码提高自己的编程水平

1.2.2 面向对象

java 语言最外部的数据类型是对象 所有元素都通过类对象访问

1.2.3 分布性

操作分布

不同的主机上布置相关操作

数据分布

数据可以存在不同的机器上

原理

这些主机是网络中的不同成员 java可以通过URL 对象访问网络对象 访问方式与访问本地相同

1.2.4 可移植性

可以把程序移植到不同的电脑上

实现针对不同平台的接口 使类库可以移植

1.2.5 解释性

任何移植了java解释器的计算机 都可以对字节码进行解释

1.2.6 安全性

删除指针 内存释放的语法 避免非法操作内存

不能出现损系统平台的事情

1.2.7 健壮性

编译时就能检查错误

运行时候也能检查错误

1.2.8 多线程

同一时间执行多个任务

1.2.9 高性能

编译后的字节码 在解释器中运行 字节码在运行时 被翻译成特定的机器指令

1.2.10 动态

可以动态的调整方法 和变量 客户端不需要做人和操作

1.3 搭建 Java环境

1.3.1 JDK 下载

1.3.2 Windosws系统的JDK 环境

1.4 第一个Java程序

第二章 熟悉 Eclipse开发工具

2.1 熟悉 Eclipse

2.1.1 Eclipse 简介

2.1.2 下载Eclipse

2.1.3 安装 Eclipse的中文语言包

2.1.4 Eclipse的配置与启动

2.1.5 Eclipse 工作台

2.1.6 透视图和视图

2.1.7 菜单栏

2.1.8 工具栏

2.1.9 "包资源管理器"视图

2.1.10 控制台视图

2.2 使用Eclipse

2.2.1 创建 Java项目

2.2.2 创建 Java类文件

2.2.3 使用编译器编写程序代码

2.2.4 运行Java代码

2.3 程序测试

第三章 Java语言基础

3.1 Java 主类结构

基本组成单位是类

3.1.1 包声明

package 为包的关键词

3.1.2 声明成员变量 和局部变量

类的属性为成员变量

方法的属性为局部变量

3.1.3 编写主方法

main方法是程序执行的位置

3.1.4 导入API类库

import关键词来导入

子主题

3.2 基本数据类型

3.2.1 整数类型

byte

short

int

long

3.2.2 浮点类型

float

double

3.2.3 字符类型

char

3.2.4 布尔类型

boolean

true

flase

3.3 变量与常量

3.3.1 标识符和关键字

标识符

命名规则：只能由字母，下划线，“_”，$或者数字组成，应该以字母，下划线，$开头，数字不能开头

关键字

在java中被赋予特殊意义的关键字

3.3.2 生命变量

int age;

3.3.3 声明常量

final double p1=3.1465;

3.3.4 变量的有效范围

成员变量

类中有效

局部变量

方法中有效

3.4 运算符

3.4.1复制运算符

=

3.4.2 算数运算符

+

-

*

/

%

3.4.3 自增和自减运算符

++a

先自增在运算

a++

现运算在自增

--a

先自减在运算

a--

现运算在自减

3.4.4 比较运算符

>

<

==

>=

<=

!=

3.4.5 逻辑运算符

&&

并且

||

或

!

非

3.4.6 位运算符

不会

3.4.7 三元运算符

条件是?1:2

3.4.8 运算符优先级

1 自增 自减

2 算数运算符

3 比较运算符

4 逻辑运算怒

5 赋值运算

3.5 数据类型的转换

3.5.1 隐式类转换

重低级转换成高级

int x=0;

float y=x;

3.5.2 显式类型转换

高精度赋予给低精度

注意有可能会损失精度

3.6 代码注释和编码规范

3.6.1 代码注释

1,单行注释

//

2,多行注释

/**/

3.文档注释

/** */

3.6.2 编码规范

每条语句要单独占一行 结束后用分号结束

声明变量 要单独占一行

关键字和关键字中间只能有一个空格 如果多个也视为一个

不要使用技术很高,难懂容易混交的判断语句

对于关键字尽量多加注释

第四章 流程控制

4.1 复合语句

{}

真个块为一个单位

4.2 条件语句

4.2.1 if条件语句

if(布尔表达式){执行体}

4.2.2 switch 多分支语句

switch(表达式){case 常量值 1 语句体 break default 语句体 break}

表达式里的值 去跟各个常量比对 如果都不是就走 deaeult语句

4.3 循环语句

4.3.1 while 循环语句

while(条件表达式){执行体}

while(x<=10){sum=sum+x; x++}

如果x<10就进入循环体 因为本身没有判断语句 所有每次我们自己让他++

4.3.2 do...while循环语句

特点

先执行一次 在进行循环

do{执行体}while(){}

4.3.3 for 循环语句

for(表达式1,表达式2,表达式3){执行体}

表达式1

初始化表达式 负责变量初始化

表达式2

循环表达式 值为boolean 制定循环条件

表达式3

循环后操式 否则修正变量,改变循环条件

循环方式

首先执行表达式1 初始化 然后执行表达式2 整个循环结束然后执行 表达式3 在此循环从第二表达式开始 如果第二个表达式 为 flase那么就不执行跳出

注意: 如果跳出就等于第二个表达式没执行

foreach 语句 for(元素变量x:便利对象 obj){引用x的java语句}

4.4 循环控制

4.4.1 break 语句

可以跳出所有循环语句

break 标签名称

跳出当前标记的循环体

4.4.2 continue 语句

重新开始条件判断不再往下执行

4.4.3return 语句

返回返回值，终止所有循环

第五章 字符串

5.1 String 类

5.1.1 声明字符串

在java语言中用双引号""之内

5.1.2 创建字符串

String s = new String();

5.2 连接字符串

5.2.1 连接多个字符串

用+连接字符串返回一个新的字符串

5.2.2 连接其他数据类型

一个字符串都其他类型连接 那么也变成一个字符串

5.3 获取字符串信息

5.3.1 获取字符串长度

int size=Str.length();

5.3.2 字符串查找

str.indexof("x")

返回x 在str的位置 重0 开始 返回值为int

str.lastindexof("x");

返回x 在str的最后位置

5.3.3 获取指定索引位置的字符串

str.charAt(int index);

返回当前位置的字符

5.4.字符串操作

5.4.1 获取子字符串

substring(int index)

返回 重指定索引出截取截取到结尾

substring(beginindex,endindex)

返回 重beginindex 开始 一直到 endindex结束

5.4.2 去除空格

trim()

取出字符串前后空格

5.4.3 字符串替换

replace('a','b');

把该字符串里的a全部替换成b

5.4.4 判断字符串的开始与结束

str.startsWith(s);

返回boolean 判断是否是s开始的字符串

str.endWith(s)

返回boolean 判断是否是s结束的字符串

5.4.5判断字符串是否相等

==

判断两个字符串地址是否相等 是否是同一个字符串

str.equals(str1)

判断两个字符串是否有相同的字符跟长度,顺序

5.4.6 按照字典顺序比较两个字符串

a.compartTo(b)

返回1 调换位置返回-1

5.4.7 字母大小写转换

toLowerCase()

全部转为小写

toUpeerCase()

全部转为大写

5.4.8 字符串分割

str.spit("-")

用-分割返回个数组

如果参数是空 则直切切分

5.5 格式化字符串

5.6 使用正则表达式

5.7 字符串生成器

str.append(z);

返回字符串加上z

第六章 数组

6.1 数组概述

相同数据类型的数据集合

6.2 一维数组的创建跟使用

6.2.1 创建一维数组

数组元素类型 数组名称 []

int arr[]=new int[]{}

注意

创建数组的时候必须左测有接受 否则报错

6.2.2 初始化一位数组

int arr[]=new int[]{1,2,3}

6.2.3 使用一维数组

6.3 二维数组的创建及使用

6.3.1 二维数组的创建

数组类型 数组名称 [][]

6.3.2 二维数组的初始化

type a[][]=={v,v,v}

6.3.3 使用二维数组

6.4 数组的基本操作

6.4.1 遍历数组

6.4.2 填充替换数组元素

Arrays.fill(arr,8)

arr 替换的数组

8 替换完的元素

还有一个一样的方法 四个参数没看懂

6.4.3 对数组进行排序

Arrays.sort(arr);

默认升序

6.4.4 复制数组

copyOf(arr,int newlength)

赋值数组 并指定长度

Arrays.copyOfRange(arr,int Fromindex,Int,toIndex)

复制 制定起始位置 和结束位置

6.4.5 数组查询

Arrays.binarSerch(arr,vl)

返回该值的位置

Arrays.binarSerch(arr,起始索引,结束索引,要搜说的值)

返回位置

注意:如果值在开始或者结束位置不建议使用

6.5 数组的排序方法

6.5.1 冒泡排序方法

1 基本思想

相邻比对 如果条件满足就交换

2 算法事例

1 双层循环实现

2 外层长度减去1

3 交换次数随排序顺序减少

3 算法实现

双层for 内层长度减去一 内层做判断 如果当前循环的值大于喜爱一个的值

就做个中间值 把这两个值调换 就可以了

6.5.2 直接选择排序

6.5.2 直接选择排序

1 基本思想

满足条件后直接放到指定位置\

2 算法示例

63 4 24 13 15

15 4 24 1 3 63

15 4 3 1 24 63

1 4 3 15 24 63

3 算法实现

双层for循环 外层做一个计数器 0 第二层长度减去1 进行对比如果数字大于上一个计数器替换

外层循环 用外层循环的常去减去 循环变量I 得到这个值

array[array.length-i]array.length-i=array[index]

array[index]=temp;

6.5.3 反转排序

1 基本思想

第一个和到最后一个替换 一次类图

2 算法示例

1 2 3 4 5 6

6 2 3 4 51

3 算法实现

一次循环就行了 用 循环变量替换 就可以

第七章 类和对象

7.1 面向对象的概述

7.1.1 对象

对象是类抽象出来的一个实例（对象因关注而产生）

7.1.2 类

对同一类事务的统称（根据问题域具有相同属性和行为的对象抽取为同一个类）

7.1.3 封装

将对象的属性和行为进行封装就是类

7.1.4 继承extends

两个类有包含关系

子类(派生类)的属性 和动作都可以是父类（基类）的实例 但反过来不行

7.1.5 多态

父类 去接受子类 有多种形态就叫多态

7.1.6结构化和OO的区别

在结构化编程中，程序围绕着要解决的任务来设计

面向对象编程中，程序围绕着问题域中的对象来设计

7.2 类

7.2 1 成员变量

在类中定义，在堆内存中（成员变量属于对象，对象进堆内存）

有默认初始化，引用类型默认为null

存活时间，在类销毁时候结束

7.2.2 成员方法

类里的方法 叫做成员方法

7.2.3 权限修饰符（从小到大）

private私有的

本类

可见

同包其他类

不可见

同包的子类

不可见

其他包的类

不可见

其他包的子类

不可见

默认不写的情况（同包）

本类

可见

同包其他类

可见

同包的子类

可见

其他包的类

不可见

其他包的子类

不可见

protected受保护的

本类

可见

同包其他类

可见

同包的子类

可见

其他包的类

不可见

其他包的子类

可见

public公共的

本类

可见

其他包的类

可见

其他包的子类

可见

同包的子类

可见

同包其他类

可见

7.2.4 局部变量

在成员方法或者是成员方法参数中定义（局部变量属于方法，方法进栈内存）

存活时间

方法执行时创建 结束时候销毁

没有默认初始化，必须要定义，赋值才能使用。

7.2.5 局部变量的有效范围

在成员方法内

目的是：父类的构造和子类的构造代码共享

7.2.6 this 关键字

this.

this引用的是当前类的一个对象

可以访问本类自己定义的属性和行为不受访问修饰符的限制

可以访问父类定义的方法和属性，受到访问修饰符的限制

this()

本类的构造方法中调用本类另外一个构造方法

调用构造方法this()时只能放在第一句并且只能调用一个其他构造方法

目的是：构造方法的共享

7.2.7super 关键字

super.

不能访问本类自己定义的属性和行为

可以访问父类定义的属性和行为，受访问修饰符的限制

super()

在本类构造方法中调用父类指定的构造方法

只能放在第一句并且只能调用一个其他构造方法

不写也有默认的调用，调用的是父类公共无参构造

7.2.9属性和行为

类的属性又被称为“成员”可以是多个，而且可以各有各的数据类型；

行为是类自带的方法，可以直接完成各种属于该类对象的操作。

7.3 类的构造方法（创建对象）

无参构造

有参构造

7.4 静态变量,常量和方法

static

用static 修饰的变量 常量 方法 称之为静态的变量常量 方法

作用

通常是为了提供共享数据和方法

注意

静态方法中不能使用this 关键字

静态方法不能调用非静态方法和属性

static不能修饰构造方法

特点

修饰的内容一定与对象无关，是类级别的。

修饰的内容一定是在加载期有特殊操作的。

如static属性加载期被产生；static方法加载期首先加载

用static修饰属性（类变量）

现象：这个属性将不再存放在每个对象身上，而是全类共享一个，无论哪个对象对该属性进行改动，全类所有对象都被改动。

原因：static的属性是单独存放在内存中的静态区，而不是存放在每个对象身 上的；它会在程序运行之前，即加载类之前就产生并放入。

特殊操作：static的属性可以用类名.的方式直接调用；牢记：这是结果，而不是设计成static的原因;常量属性可以无脑设计为static（常量属性写法统一：public static final ......）

用static修饰方法（与对象无关，属于类级别的方法）

现象：可以用类名.的方式直接访问，导致在方法中没有当前对象（不能以任何形式引用this和super），没有当前对象又导致在方法当中不能操作对象身上的非静态属性和方法。

原因：加载期，会首先加载静态方法和静态属性，在加载静态方法的时候还不认识非静态属性或静态方法，因此会报错。

特殊设计：只有工具类的工具方法（如果一个方法不需要操作到执行对象本身相关的数据或行为的时候），才能定义成static的

建议用类名直接调用静态方法和属性

7.5 类的主方法

main

特性

主方法是静态的所以只能调用其他的静态方法

没有返回值

形参为数组

7.6 对象

7.6.1 对象的创建

new text()

new text(a)

特性

创建就是一个对象的引用

内存中分配存储空间

每个对象是互相对立的 对立的内存地址

生命周期结束就变成了垃圾 java虚拟机进行回收处理 不能在使用

7.6.2 访问对象的属性和行为

7.6.3 对象的引用

Book book

7.6.4 对象的比较

==

比较两个对象的引用是否一致

equals

比较两个对象是否相等

7.5.5 对象的销毁

对象生命周期结束 内存地址将被回收

垃圾的定义

对象的引用超过其作用范围

将对象赋值为null

7.7 JavaBean

书写类的标准，设计人员又称为POJO

必须要写公共无参构造

必须为私有属性提供符合命名规范的get/set方法

第八章 包装类

8.1 Integer

int的包装类

1 能在Sting interger 类型中互相转换

2 常用方法

i.byteValue

返回值

byte

亿byte 类型返回 integer 的值

i.compareto(integer anotherIntger)

返回值

int

0 相等

-1 括号的大

1 括号的小

功能描述

两个intger进行大小比较

equals( object object)

返回值

boolean

功能描述

比较两个对象是否相等

intValue()

返回值

int

功能描述

int类型返回此值

short()

返回值

short

功能描述

以 short类型返回此对象

valueOf(String s)

返回值

short

功能描述

以String类型返回此对象

参数

String

tostring()

返回值

String

功能描述

以 String类型返回此对象

parseInt(String s)

返回值

int

功能描述

以 short类型返回此对象

参数

返回字符串包含的int值

3 常量

Integer.MAX_VALUE

获取int类型最大值

Integer.MIN_VALUE

获取int类型最小值

Integer.SiZE

二进制补码方式表示int值的位数

8.2 Boolean

1 构造方法

Boolean b =new Boolean(true);

2 常用方法

booleanValue()

返回值

将Boolean 对象的值对应的Boolean 值返回

功能描述

将Boolean 对象的值对应的Boolean 值返回

equals()

Boolean.paseBoolean(String s)

返回值

boolean

功能描述

将字符串解析成boolean 值

toString()

返回值

String

功能描述

返回表示该boolean值的字符串

Boolean.valueOf(String s)

返回值

boolean

功能描述

返回一个用制定字符串表示的boolean值

3.常量

Boolean.TRUE

true

Boolean.FALSE

FALSE

Boolean.TYPE

返回booleanclass对象

8.3 Byte

1 构造方法

Byte byte=45;

Byte b= new Byte(mybyte)

Byte c =new Byte("12")

2 常用方法

Byte.byteValue()

返回值

byte

功能描述

用byte 值 返回一个byte 值

byte.compareTo(Byte anybyte)

返回值

int

功能描述

比较两个byte的值大小

byte.doubleVlaue()

返回值

double

功能描述

转成double类型

byte.intValue

返回值

int

功能描述

转成int类型

byte.parseByte(String s)

返回值

byte

功能描述

String 转成 Byte

byte.toString()

返回值

String

功能描述

返回一个String值

byte.valueOf(String s)

返回值

byte

功能描述

String 转成 byte

byte.equals(Obejct obj)

返回值

boolean

功能描述

判断两个值是否相等

8.4 Character

1 构造方法

Character mychar=new Character9('a');

注意

放入但引号的一个字符

2 常用方法

char.charvalue();

返回值

char

功能描述

返回此CharActer 的对象值

char.compareTo(Character another angchar)

返回值

int

功能描述

返回两个char的比较结果

char.equals(Object o)

返回值

boolean

功能描述

比较两个值是否相同

char.toUpperCase(char ch)

返回值

char

功能描述

将字符全部转为大写

char.toLowerCase(char ch)

返回值

char

功能描述

将字符全部转为小写

char.toString();

返回值

String

功能描述

转换成String类型

char.charValue();

返回值

char

功能描述

没有啥用

char.isUpperCase(Char ch)

返回值

boolean

功能描述

判断是否是大写

char.isUpperCase(Char ch)

返回值

boolean

功能描述

判断是否是小写

3 常量

8.5 Double

1 构造方法

Double doube=new Double();

2 常用方法

d.byteValue()

返回值

byte

功能描述

Double 转成byte类型

d.dompareTo(Double d)

返回值

int

-1

0

1

功能描述

两个double比较大小

d.equals()

返回值

boolean

功能描述

比较两个值是否一致

d.intValue()

返回值

int

功能描述

转成int值

d.isNaN()

返回值

boolean

功能描述

判断这个值是不是数字

d.toString()

返回值

String

功能描述

转换成字符串

d.valueOf(String s)

返回值

Double

功能描述

把字符串转为 Double

d.doubleValue()

返回值

double

功能描述

以double形式放回Double对象

d.longValue()

返回值

double

功能描述

转换成double

3 常量

8.6 Number

返回各种数据类型的方法

第九章 数字处理类

9.1 数字格式化

9.2 数字运算

9.2.1 Math 类

1个工具类 里边放了许多数学方法

9.2.2 常用的数学方法

1 三角函数方法

Math.sin(Double d)

返回该数的三角正炫

Math.cos(Double d)

返回该数的三角余弦

Math.tan(Double d)

返回该数的三角正切

Math.asin(Double d)

返回该数的三角反正弦

Math.acos(Double d)

返回该数的三角反余弦

Math.atan(Double d)

返回该数的三角反正切

Math.toRadias(Double d)

角度转为弧度

Math.toDegress(Double d)

弧度转为角度

2 指数函数方法

Math.exp(double a)

用于获取e的a次方

Math.long(double a)

取自然数的对数

Math.long10(double a)

底数为10 的对数

Math.sqrt(double a)

a的平方根

a 不能是负数

Math.cbrt(double a)

取a的立方根

Math.pow(double a,double b)

取a的b次方的跟

3 取整函数方法

Math.double(double a)

返回大于等于当前数的最小整数

Math.foor(double a)

返回小于等于当前树的最小整数

Math.rint(double a)

返回最接近当前数的整数 如果两头相等取偶数

Math.round(double a)

将参数加0.5后返回最接近的整数

Math.round(double a)

将参数加0.5后返回最接近的整数

返回类型

long

4 取最大值,最小值, 绝对值函数的方法

Math.max(double a,double b)

获取a b 中的大值

方法重载

int

long

double

floart

Math.min(int a,int b)

获取两个数中小的那个值

方法重载

int

long

double

floart

Math.abs(int a)

返回绝对值

方法重载

int

long

double

floart

9.3 随机数

9.3.1 Math.random() 方法

生成0 到1之间的随机数

9.3.2 Random 类

创建无参构造

Random r=new Random(seedValue)

返回一个创建的随机数

方法

r.nextInt(int n)

返回一个大于0 切小于n的随机整数

r.nextLong(Long 0)

返回一个随机长整数类型

r.nextBoolean()

返回一个随机布尔型

r.nextFloat()

返回一个随机浮点型值

r.nextDouble()

返一个双精度型

r.nextGaussian()

返回一个概率密度为高斯分布的双精度值

9.4 大数字运算

9.4.1 Biginteger

最大值

2的31次方 -1

方法

big.add(Binginteger val)

加法运算

big.subtract(BigInteger val)

减法运算

big.multiply(BigInteger val)

做乘法运算

big.divide(Biginteger val)

做除法运算

big.remainder(Biginteger val)

做取余运算

big.diveAndRemainder(BigInteger val)

用数组返回余数 和上结果数组中第一个值为商 第二个值为余数

big.pow(int exponet)

进行取当前数的exponet次方

big.negate()

取相反数

big.equals(Object o)

看看两个数值是否相同

big.min(Biginteger val)

返回较小的数值

big.max(Bigintger val)

返回较大的数值

9.4.2 BigDecimal

特点

加入小数概念

方法

b.(double val)

强制转换成大数据类型

b.(String val)

强制转换成大数据类型

b.add(BigDecimal val)

加法

b.subtact(BigDecimal val)

减法

b.multiply(BigDecimal val)

乘法

b.divide(BigDecimal val,int scale ,int roundingModel)

除法

divsor

除数

scale

保留小数点位数

rounding

处理模式

第三篇 高级应用

第四篇 项目实战

第二篇 核心技术

第十章 接口,继承和多态

10.1 类的继承

继承父类的所有方法 并可以重写

语法 public class 子类 extends 父类

10.2 Object 类

所有类的父类

方法

getClass()

获得当前对象的实例

toString()

返回一个对象的字符串描述（注意不是把对象转换成字符串）

equals()

比较两个对象在业务场景中内容上是否相等（注意与双等号的区别）

finalize()

销毁对象(该方法由垃圾回收GC进行调用)

hashCode()

子主题

clone()

子主题

wait()

子主题

notify()

子主题

10.3 对象类型的转换

10.3.1 向上转型（自动转化）

子类对象转换成父类对象

10.3.2 向下转型（强制转化）

向下转型有可能出现问题 因为鸽子都是鸟 而鸟不都是鸽子

必须使用显示转换 1.本类的引用指向本类的对象；2.父类的引用指向子类的对象；

风险：可能编译通过，运行报异常（ClassCastException）

编译通过：因为子类和父类的关系是is-a关系，所以说子类对象就是父类类型。

运行通过：因为每一个子类对象在产生过程中，都是使用内存叠加的方式，先产生父类对象部分，然后再叠加子类特有。所以，这个子类对象拥有父类类型定义的一切内容。

10.4 使用instanceof 操作符判断对象的类型

方法

myobject instanceof Exampleclass

myobject

实列对象

exampeclas

判断这个对象是否属于这个子类

注意

方法必须在if里使用

（运算符关键字）返回值为布尔类型

10.5 方法的重载

同名方法

参数或类型不同即可

10.6 多态

优点

使程序有更好的扩展性

相同的行为，不同的实现

分类

静态多态

在编译期就能够确定代码中的对象执行的是哪个方法（重载和单独重写就是一种静态多态）

动态多态

在编译期不确定要运行起来以后，要根据实际绑定的对象才能确定调用的是哪个方法（使用动态绑定和重写实现）

动态绑定技术：运行时根据父类引用变量所指对象的实际类型执行相应的子类方法，从而实现多态性。（接口也可以实现动态绑定 即：接口的引用也可以指向实现类的对象）

如果子类重写了父类的行为，那么只要对象是子类对象，不管用什么引用去指向（父类，子类都好），效果都会是子类自己重写后的效果

10.7 抽象与接口

10.7.1 抽象

abstact

抽象的关键词

放在类上就是抽象类（不能产生对象）

相关概念：终态类（必须产生对象）

放在 方法上就是抽象方法（必须重写）

特点

没有方法体

它可以在编译期，强制要求子类的实现必须重写来自于父类的抽类方法。

相关概念：最终方法（不能被重写）

抽象类与抽象方法的关系

1.有抽象方法的类一定是抽象类；

2.抽象类不一定有抽象方法；

3.抽象是可以通过继承传递的；比如：父类有3个抽象方法，子类只能确定实现其中一个或者2个，那么子类任然具有抽象方法，所以这个子类必须是抽象类，再由子类的子类进一步去实现。

10.7.2 接口

抽象类的延伸 全部方法都是抽象的

interface

接口中属性只能是公共静态常量，说明接口这种类型不关注属性（就算不写public static final 也会默认为公共静态常量）

接口中方法是抽象方法，不能有方法体，（就算不写publc abstract 也会默认公共抽象）注：JDK1.7之后，java中的接口开始被允许书写被实现了的方法，不过要在方法声明default修饰符（实际使用中，目前并不多见）

说明：接口中没有构造方法，所以接口不能产生对象

接口的继承

使用extends后面跟上父接口的名字多继承用,分开

接口的实现

一个 class 类可以实现多个接口

implements 是实现接口的关键词

继承父类与实现接口不冲突，可以同时存在。但是要先继承，再实现

为了解决让没有继承关系的类也能共享行为

接口也可以实现动态绑定 即：接口的引用也可以指向实现类的对象

效果——该引用只能看到来自接口的行为和属性，假如要看该对象特有的行为属性，要做强制类型转化

第十一章 类的高级特性

11.1 Java类包

11.1.1 类名的冲突

类名是不可以重复的 所以用包来区分

11.1.2 完整的类路径

包.包.包.类

11.1.3 创建包

11.1.4 导入包

1 使用import关键词导入包

2 可以导入静态成员

import stacic 位置 成员

11.2final关键字

11.2.1 final 变量

修饰变量

特点

最终 不可改变

效果是：这个变量成为常量不可变

实例

final double p =3.14 不可变

11.2.2 final 方法

修饰方法

效果是：这个方法不能被子类重写 这样的方法被称为最终方法

final 方法不能被覆盖

11.2.3 final 类

修饰类

这个类不能被继承，也就是不能产生子类 这个类被称为终态类

如果一个类被final 了 那么默认其所有方法都是如此 不能在被继承

总结

final的含义就是：最终的，即不可变的。 变量不可变，就是常量； 方法不可变，就是不能重写； 类不可变，就是不能继承；

11.3 内部类

一个类在定义一个类叫做内部类

除了定义的位置特殊以外，它任然是一个完整的类，所以有独立的class文件。

11.5.1 成员内部类

1 成员内部类简介

成员内部类书写位置是直接写在外部类本身当中，与外部类，构造，行为，初始化块平行！

2 内部类像上转型为接口

3 在内部类的内部可以操作外部类的属性和行为，使用this 关键词获取当前内部类的对象。（如果一定要特指外部类的属性方法应该用外部类类名.this）

4.在第三方类中产生语法：先产生外部类对象，再用外部类.new的语法才能产生该内部类的对象；（会受到访问修饰符限制）

11.5.2 静态内部类

类前加载static

在第三方类中产生语法：首先保证访问修饰符可见的；然后直接使用外部类名.内部类类名 new出来（受访问修饰符的限制）

在内部类的方法中，不能访问外部类的非静态属性行为（原因：因为没有外部类对象）如果重名直接用外部类.的方式调用

11.5.3 局部内部类

一个类定义到方法中（只能在它所定义的外部这个方法中使用）

特点

用内部类对象可以直接访问该内部类对象的属性和行为，不受访问修饰符限制；

访问外部类属性行为没问题（受static影响）,语法也和成员内部类保持一致；但是对它所在的外部方法的局部变量只能读取不能修改，要当成final常量处理。

11.5.4 匿名内部类

没有类名，是在new 对象的同时给出类的定义，所以只能产生一个对象用这一次

是局部内部类的一种(遵循局部内部类的使用特点)，class文件名字是外部类类名$数字。class

11.5.5 内部类的继承

exends 主类.内部类

11.4 实例初始化

语法

｛语句块｝

特点

是在new对象时候，被自动调用，而且每产生一个对象就会被调用一次

实例初始化块产生对象之后，构造方法内部代码被执行之前被调用执行。

分析

凡是可以在初始化块写的代码块，也可以在构造方法中写

构造方法内部代码在实例初始化之后执行，所以最终结果也会以构造为准

结论

初始化对象要写的代码语句，宁愿写在构造里面，本类所有的构造方法都要执行的共有代码可以写在初始化块，只需要写一次。这个功能和this()一样

11.4 静态初始化块

语法

static{语句块}

特点

是在类加载的时候被自动调用，由于一个只加载一次（第一次使用的时候），所以这个代码只执行一次

由于在加载期是没有对象的，所以这个代码块与当前对象(this)无关

分析

这是在加载期能够执行的代码块

在加载期做事情，消耗的是加载期的时间，不会影响运行期的时间

结论

静态初始化块在大型项目中，一些预先需要准备的动作可以写在里面，从而不影响运行时间。很常用！

第十二章 异常处理

12.1异常概述

程序运行中出现的错误叫异常

12.2 处理程序异常错误

12.2.1 错误

异常出现后不作处理程序就会暂停

12.2.2 捕捉异常

try{} cath(E e) {}finally

1 try catch 语句块

try 里的语句进行判定如果出现错误 cath进行判定

catch(exception e){e.printStackTrace()}

e.printStackTrace()

输出异常信息

e.getMessage()

输出错误性质

e.toString()

给出异常的类型和性质

2 finally 语句块

前边不论什么结果后边都会执行

12.3 Java 常见异常

ClassCastException

类型转换异常

ClassNotFoundException

没找到相应的类异常

ArithmeticException

算数异常

ArrayIndexOutBoundsException

数组下表越界异常

ArrayStoreException

数组包含不兼容的值

SQLException

操作数据库异常

NUllpointerException

空指针异常

NoSuchFieldException

字段没找到异常

NoSuchMethodException

方法没找到异常

NumberFormatException

字符串转成数组异常

NegativeArraySizeException

数组元素为负数异常

StringIndexOutOfBOundsException

字符串索引超出范围

IOException

输入输出异常

IllegalAccessException

不可以访问某类异常

Instantiationexception

创建摸个class 实体类 无法被实现异常

EOFException

文件已经结束一场

FileNOtFoundException

文件没找到异常

12.4 自定义异常

在程序中使用自定义异常类的步骤

1 创建一场类 继承Exception

2 在方法中通过throw关键词抛出异常对象

3 可以用try catch 处理异常也可以给使用者 调用

12.5 在方法中抛出异常

12.5.1 使用throws关键字抛出异常

放在方法上 说明名方法可能会抛出异常

public void p() throws 异常名称{}

12.5.2使用throw 关键字抛出异常

一般放在方法体中,并且抛出一个方法对象 如果如果执行到了throw 则程序立即中止

使用

if(1=1){ throw new Exception()}

注意

如果需要网上抛 就必须在当前方法上 thorows 解决就是try cath

12.6 运行时异常

关键词

RuntimeException

所有异常类的父类

throwable

常见的异常

NUllpointerException

空指针异常

ArrayIndexOutBoundsException

数组下标约界

ArithmeticException

算数异常

ArrayStoreException

数组不包含制定的数值

IllegalAccessException

非法参数异常

securtyException

安全性异常

NegativeArraySizeException

数组常数为负异常

12.7 异常的使用原则

当法相某个方法可能发生异常时

使用try-catch 语句捕获异常

一个方法被覆盖时候 必须抛出相同的异常和异常的子类

如果一个父类抛出多个异常 则覆盖的方法必须抛出多个异常的子集,不能抛出新异常

12.8 异常的使用目标和解决

1.程序不能中断掉

2.让程序回到正确的业务目标

解决方法

1.改代码，让异常不发生（运行时异常百分之99这样做）

2.try-catch-finally

3.throw-throws

第十三章 Swing程序设计

13.1 Swing 概述

13.1.1 Swing 特点

允许开发人员跨平台制定统一外观跟峰哥

Swing 轻量级组建

可插入外观组建

13.1.2 Swing 包

第十四章 集合类

集合类的概述

集合类存放对象的引用

Collection 接口

Collection常用方法

添加一个对象到集合

add( String string )

在集合中移除一个对象

removed(String string )

判断集合是否为空

isEmpty() return boolean

返回次对象的迭代期

iterator();

返回元素个数

size() return int

迭代的应用

duixiang.iterator.next return 对象

Collections工具类常用方法

降序

Collections.reverse(list);

升序

子主题

List集合

特点 可以重复 顺序就是插入顺序 通过索引访问集合中的元素

List集合的索引重0开始

List 接口

继承 Collection 类 并追加了两个方法

get(int index) 通过索引返回对象

set(int index Object obj) 将指定索引的对象修改值

List 接口的实现类

ArrayList

可以保存所有元素 包括 null 根据索引快速访问

缺点: 像指定位置 插入对象 或删除对象速度比较慢

LinkedList

特点: 采用链表结构

优点:插入和删除速度快 效率高 但对于所及访问没有 ArrayList 快

Set集合

特点：不按特定方式排序 不包含重复对象 继承Collection

Set 接口

Set 接口的实现类

HashSet

由hash表支持 不保证迭代顺序 支持null

TreeSet

还实现了SortedSet接口

遍历按照自然顺序递增排列

TreeSet 新增方法

fitst(); 返回第一个元素

last() 返回最后的元素

compartor() 返回元素排序的比较器 如果是自然顺序 则返回null

subSet(E e,E e)返回一个新的Set但是 是包含第一个元素 不包含第二个元素 中间的所有元素

tailSet(String s)返回一个新集合包含s对象之后的所有元素

Map集合

Map 接口

内置方法

put( K,key,V value) 放入一个键值对

containkey(K key) 是否包含该键值对

headSet( E e) 返回一个新的Setj集合 获取 e之前的所有元素

containValue(V value) 是否包含一个或多个键值对

get(K key) 通过key取值

KeySet() 获取所有的key

Values( ) 获取所有的值

Map 接口实现类

HashMap

优点：添加删除速度快

特点：可以有NUll 建 但必须保证唯一性

缺点： 不保证顺序 很久不变

线程安全的

TreeMap

优点 : 有一定的顺序

特点：实现了SortedMap接口 key不可以null

缺点：添加 删除 定位映射关系慢

第十五章 I/O流

15.1 流概述

通过程序吧数据传送到目的地

输入流

吧程序读到内存中去

输出流

数据要传送的目的地

15.2 输入/输出流

15.2.1输入流

IntputStream

是一个抽象类所有输入流的父类

抽象方法

read(byte[]b)

从输入流中读一个长度的字节,亿整数的形式返回字节数

mark(int redlimst)

在输入流当前位置放入个标记 ,redimt 参数告知此输入流在标志位置是小钱润许读取的字节数

rest()

将输入指针返回到当前标记出

skip(long n)

跳过输入流的n个字节 并返回实际跳过的字节数

markSuported()

判断当前流是否支持 标记 和rest() 方法

close()

关闭输入流释放所有关联的系统资源

15.2.2 输出流

OutputStream

是一个抽象类 所有输出流的接口

抽象方法

write(int b)

将制定的字节写入此输出流

write(byte[] b)

将制定的数组写入输出流

write(byte[]b int off,int len )

从偏移量off 开始llen 个字节开始读取到输出流

flush()

清空缓存区

close()

关闭输入流

15.3 File 类

IO 包中唯一能代表磁盘文件本身的对象

15.3.1 文件的创建与删除

新建一个文件

new File("d:/1.txt")

new File("D:/","1.txt")

new File("D:/doc/","a.txt")

执行创建这个文件

file.createNewFile();

删除这个文件

file.delete();

15.3.2 获取文件信息

内置的方法

file.getName();

获取文件名称

file.canRead();

判断文件是否可读

file.canWrite()

说明

判断文件是否可写

返回值

boolean

file.exits()

说明

判断文件是否存在

返回值

boolean

file.length();

说明

查看文件长度

返回值

long

file.getAbsolutPath()

说明

获取文件的绝对的绝对路径

返回值

String

file.getParent();

说明

获取文件的父路径

返回值

String

file.isFile();

说明

判断文件是否存在

返回值

boolean

file.isDirectory();

说明

判断文件是否是一个文件夹

返回值

boolean

file.isHidden()

说明

判断文件是否是一个隐藏文件

返回值

boolean

file.lastModified();

说明

获取文件的最后修改时间'

返回值

long

15.4 文件输入/输出流

15.4.1 FileInputStram FileOutStream 类

FileInPutStream

构造方式

new FileInputStream(String name)

new FileInputStream(File file)

读取文件的实现方法

File file = new File("D:/1.txt"); FileInputStream fileInputStream = new FileInputStream(file); byte[] b = new byte[1024]; int read = fileInputStream.read(b);String string = new String(b, 0, read);

15.4.2 FileReader 和 FileWriter

new FileRead(File file)

15.5 带缓存的输入/输出流

15.5.1 BufferedInputStream与BufferendOUtputStream类

构造方式

new BufferedOutPUtStream(OutputStream in)

new buffereOutputStream(OutputStream in,in,int size)

15.5.2 BufferedReader 与BufferedWriter 类

BufferedRead 类的常用方法

.read()

读取单个字符

.read.link();

读取一个问本行

BufferWriter 的常用方法

.write(String)

写入

.flush()

刷新该流的缓存

.newLine()

写入一个行的分割符号

15.6 数据输入/输出流

DataInPutStream

构造方法

DataInputStream(InputStream in)

DateOutPutStream

构造方法

DataOutPutStream(OutPutStream out)

常用方法

writeByte(String s);

写入

writeChars(String s)

写入

writeUTF(String s)

写入

15.7 ZIP 压缩输入/输出流

15.7.1

常用方法

z.putNextEntry(ZipEntry)

写一个压缩文件

z.finsh()

关闭流

setComment(String comment)

设置注视文件

ZipOutputStream(OutputStream out)

z.write(byte[]b,int off,int len)

数组的方式写入

ZipInputStream(inPutStream in)

方法

z.read(byte[]不,int off,int,len)

b 读取

z.available()

判断是否读完制定的数据

z.closeEntry()

关闭当前压缩条 并取吓一跳

z.skip(long n)

跳过压缩条中制定的数据

z.getNextEntry()

读取下一个压缩

z.createZipEntry(String name)

新建一个ZipEntry 对象

第十六章 反射

16.1 Class类与Java反射

可以反问构造方法JVM中包含的java对象

可以实现对象大访问 检测和修改描述 本身嘻嘻等

通过反射可以访问的主要描述信息

a.getPackage()

返回值

Package对象

功能描述

获得该类的存放路径

a.getName()

返回这

String 对象

功能描述

获得该类的名称

a.getSuperClass()

返回值

Class 对象

功能描述

获得该类继承的所有类

agetInterFaces()

返回值

class 对象

功能描述

获得该类实现的所有接口

a.getConstructors()

功能描述

获取所有权限为public 构造方法

返回值

ConStructor 数组

a.getConstuctor(Class<?>....parameterType)

返回值

ConStructor 数组

功能描述

获取所有权限为public 制定的 构造方法

a.getDeclaredConstuctors()

返回值

ConStructor 数组

功能描述

获取所有构造方式

a.a.getDeclaredConstuctors(Class<?>....parameterType)

返回值

获取所有的构造方式

返回值

Cotructor

第十七章 枚举类型和泛型

17.1 枚举类型

17.1.1 使用枚举类型设置常量

常量

一般情况下 接口中定义常量 因为

关键词

enum

public enum Constants{constants1,constab}

使用方式

放在接口中

17.1.2 深入了解枚举类型

1 操作枚举类型成员方法

values()

具体含义

1️⃣数组的方式返回枚举

使用方法

枚举类型名称.values()

valuesof()

具体含义

将普通字符串转为枚举类型那

compareTo()

具体含义

定义两个美剧对象的顺序

ordinal()

得到枚举成员位置

17.1.3 使用枚举类型的优势

特点

类型安全

紧凑有效数据定义

可以程序其他部分完美交互

运行效率高

17.2 泛型

17.2.1 回顾向上转型与向下转型

17.2.2 定义泛型类

类名<T>

17.2.3 泛型的常规用法

1 定义泛型类型声明多个类型

MuitOverClass<T1,T2>

2 定义泛型类声明数组类型

privet T[] array;

3 集合类生命容器的元素

Map<k,v>

17.2.4 泛型的高级应用

1 限制泛型可用类型

class 雷名称<T extends anyClass>

2 使用类型通配符

3 继承泛型类与实现泛型接口

第十八章 多线程

18.1 线程简介

一个线程的执行流程,一个进程可以包含多个线程

单线程

程序代码顺序执行,如果一个代码同时需要多段代码操作 就需要多线程

18.2 实现多线程的两种方式

18.2.1 继承Thread类

在类中继承Thread

18.2.2 实现Runnable接口

在类中继承 Runnable 接口

18.3 线程的生命周期

县城生命周期的七种状态

出生状态

就是现场创建出来的状态 在start()之前都是出生状态

就需状态

start() 之后是就绪状态 又被成为可执行状态

一旦到了就绪状态线程就有可能进入其他状态互相转换

使线程处于就绪状体的几个方法

调用sleep()

wait()

等待输入/输出完成

运行状态

当线程得到系统资源时候进入运行状态

线程处于就绪状态后 使其在进行运行状态的几个方法

notify

nirfyall

interrupt

休眠时间结束

输入/输出结束

等待状态

线程调用 wait() 进入等待状态

必须用 notify 才能唤醒

notifyAll() 唤醒所有处于等待状态

休眠状态

sleep()

调用这个线程进入休眠状态可以设置时间

阻塞状态

如果一个线程在运行状态发出输入输出请求 线程就会阻塞

18.4 操作线程的方法

18.4.1 线程的休眠

sleep( 毫秒)

通常在run() 方法内使用

18.4.2 线程的加入

b.jion()\

b线程加入

注意

B线程结束后在执行原有线程

18.4.3 线程的中断

interrupt()

18.4.4 线程的礼让

yield()

替班很少用

18.5 线程的优先级

t.setPrioityz(int 级别)

线程级别1 10

18.6 线程同步

18.6.1 线程安全

18.6.2 线程同步机制

synchroized(){}

同步块

同步块中有个标志 分别是 0 1 如果是0 表面用其他线程运行 这时候该线程处于就需状态

同步方法

sybcgronized void f(){}

该对象在器同步繁重必须等待其他方法执行后才能执行

注意: 每个访问方法都得都必须使用synchronied 修饰

第十九章 网络通信

19.1 网络程序设计基础

19.1.1 局域网与因特网

局域网

一群机器因为一定形式连接在一起

因特网

延伸更广的范围所以叫广域网

19.1.2 网络协议

1 IP协议

internet地址 就是 IP

IPv4

192.16.81.1.

Ipv6

192.1.5.2.3.2

2 TCP 与UDP协议

TCP

固定连线为基础的协议

UDP

无连接通信协议

不保证数据的可靠传输

可以像多人传输 也可以获取多人

19.1.3 端口和套接子

端口

port0 -65535

19.2 TCP程序设计基础

分为 服务器程序 客户端程序

19.2.1 inetAddress 类

java 分装的d地址类

方法

getbyname()

获取inetaddress对象

gethostaddress

获取对象的ip地址

gethost name

获取ip 地址的主机名]

getlocalhost()

返回本机的inetaddress对象

19.2.2 ServerSocket 类

19.2.3 TCP 网络协议

19.3UDP程序设计基础

特点 传输数据块 但不提供有效的保证

19.3.1. DatagramPacket 类

子主题

19.3.2 DatagramSocket 类

19.3.3 UDP 网络协议

类似于广播

第二十章 数据库操作