tanyunlong_nice

黑马JAVA知识点总结

一、黑马程序员—java概述与基础知识 6

1、何为编程？ 6

2、Java语言概述，历史、特点 6

3、什么是跨平台性？原理是什么？JVM 7

4、Jre和Jdk的区别? 7

5、java虚拟机JVM 8

6、 Java程序运行机制 8

7、学习java注意的地方 8

8、Java语法格式 8

9、代码注释：单行//，多行/* */，文档注释/** */ 9

10、Java中的标识符 9

11、java中的常量和变量 9

12、Java成员变量和局部变量 10

14、基本数据类型转换之向上转型和向下转换 12

15、Java的运算符 12

16、表达式和三目运算符 13

17、程序流程控制 13

18、三大循环结构: 15

19、嵌套循环与流程控制 18

二、黑马程序员—方法与数组 19

1、什么是方法（Method）？ 19

2、 Java中方法的格式： 20

3、方法里的属性 20

4、方法特点 20

5、什么是方法的重载（Overload）？ 21

6、可变参数 22

7、数组简介： 23

8、一维数组的声明与初始化： 23

9、数组的使用： 24

10、分配内存空间 26

11、二维数组： 27

12、操作数组的工具类-Arrays 27

13、Java5新特性对数组的支持： 28

三、黑马程序员—面向对象（1） 29

1、什么叫面向对象？ 29

2、类 29

3、构造方法 30

4、static关键字 31

5、匿名对象 32

6、this关键字 32

7、面向对象之封装 33

8、访问修饰符 34

9、类的设计分析 34

10、面向对象之继承 34

11、子类访问父类和方法覆写 35

12、super关键字和调用父类构造方法 36

13、面向对象之多态 37

14、引用变量类型转换 39

四、黑马程序员—面向对象（2） 39

1、基本数据类型的包装类 40

2、基本数据类型和包装类相互转换 40

3、基本类型和String之间的转换 41

4、Object类 41

5、代码块 42

6、构造方法的私有化 44

7、 Singleton模式(单例模式) 饿汉式和懒汉式 44

8、final 关键字 46

9、抽象类 47

10、抽象类的体现-模板模式 49

11、接口(interface) 51

12、接口的使用 52

13、面向接口编程之制定标准和简单工厂模式 52

14、面向接口编程之适配器模式 54

15、接口和抽象类的比较 55

16、匿名内部类 56

17、枚举类 57

五、黑马程序员—异常处理和常用类 59

1、异常 59

2、异常处理格式 60

3、多异常处理 61

4、异常的分类 61

5、声明异常（throws） 62

6、throw 63

8、throw和catch同时使用 64

9、常用类 65

10、String方法 67

11、StringBuffer 与 StringBuilder 69

12、Math和Random和UUID 72

13、Date和Calendar 73

14、System 77

六、黑马程序员—线程技术 77

1、进程和线程 78

2、创建线程方式 78

3、两种进程创建方式比较 80

4、线程的生命周期 81

5、控制线程 82

6、多线程安全问题 84

7、多线程安全问题的解决方法 85

8、线程通信 90

七、黑马程序员—集合框架（1） 93

1、集合类 & 容器 93

2、Collection接口 94

3、Iterator接口 95

4、集合遍历输出方式 95

6、TreeSet 99

7、List接口 103

8、List接口中常用类 104

9、Map接口 108

八、黑马程序员—集合框架（2） 111

1、Collections类 111

2、Arrays 113

3、泛型(Generic) 113

4、泛型的使用 114

5、声明多个泛型类型和通配符 118

6、泛型的上限与下限 119

7、泛型接口和方法 121

8、泛型的嵌套（map例子） 122

九、黑马程序员—IO操作（1） 123

1、IO的概述和File方法 123

2、递归(Recursion) 125

3、文件过滤器 java.io.FilenameFilter 126

4、流 127

5、操作流的步骤（重点） 128

6、字节流和字符流 129

7、文件拷贝 131

8、字节→字符转换流 134

9、自动关闭资源的try语句 134

十、IO文件操作（2） 136

1、内存操作流 136

2、打印流 137

3、格式化输出 139

4、标准流 140

5、Scanner(简单文本扫描器) 141

6、缓冲流 144

7、合并流（SequenceInputStream） 145

十一、黑马程序员—网络编程 146

1、什么是网络编程？ 146

2、网络通讯要素 147

3、TCP和UDP的联系和用途 147

4、InetAddress与Socket 148

5、UDP传输 149

6、TCP传输 153

8、小例子 159

十二、黑马程序员—反射机制 162

1、反射的概念 162

2、获得Class对象 163

3、九个预定义Class对象 164

4、利用Class获取类的属性信息 165

5、Class中得到构造方法Constructor、方法Method、字段Field 167

6、利用反射创建对象 172

7、使用反射调用方法 175

8、使用反射调用可变参数方法 176

9、使用反射操作字段 178

10、反射和泛型-反射来获取泛型信息 179

十三、黑马程序员—反射机制 181

1、GUI(图形用户界面) 181

2、布局管理器 182

3、事件监听机制组成 183

4、Dialog 190

5、菜单 193

1、Eclipse的使用技巧 197

2、静态导入（1.5特性，好处是不用写类名） 199

3、可变参数 200

5、基本数据类型的自动拆箱与装箱 201

6、枚举 201

7、反射实现框架功能 203

1、内省à了解JavaBean 205

2、内省综合案例和Beanutils工具包 205

3、注解（Annotation） 208

4、泛型 211

1、类加载器 215

2、类加载器的委托机制 216

3、一个类加载器的高级问题分析 220

4、代理的概念与作用 220

5、动态代理技术 222

6、分析JVM动态生成的类 222

8、实现类似spring的可配置的AOP框架 229

黑马程序员——面试题之交通灯管理系统 233

1、面向对象的分析与设计 234

2、Road类的编写 234

3、Lamp类的编写 236

4、LampController类的编写 239

5、MainClass类的编写 239

黑马程序员——面试题之银行业务系统 241

1、需求 241

2、需求分析 242

3、NumberManager类 242

4、NumberMachine类 243

5、CustomerType枚举类 244

6、ServiceWindow类 244

7、MainClass类与Constants类 248

一、黑马程序员—java概述与基础知识

1、何为编程？
编程就是让计算机为解决某个问题而使用某种程序设计语言编写程序代码，并最终得到结果的过程。

为了使计算机能够理解人的意图，人类就必须要将需解决的问题的思路、方法、和手段通过计算机能够理解的形式告诉计算机，使得计算机能够根据人的指令一步一步去工作，完成某种特定的任务。这种人和计算机之间交流的过程就是编程。

2、Java语言概述，历史、特点

是SUN(Stanford University Network，斯坦福大学网络公司)1995年推出的一门高级语言。

是一种面向Internet的编程语言。
随着Java技术在web方面的不断成熟，已经成为Web应用程序的首选开发语言。
是简单易学，完全面向对象，安全可靠，与平台无关的编程语言。

java5.0之后的三大技术框架

J2EE(Java 2 Platform Enterprise Edition)企业版

在jdk5.0版本后称为JAVAEE,是为开发企业环境下的应用程序提供的一套解决方案。该技术体系中包含的技术如Servlet Jsp等，主要针对于Web应用程序开发。是传智播客就业班和黑马训练营的主要学习内容之一.。

J2SE（Java 2 Platform Standard Edition）标准版

在jdk5.0版本后称为JAVASE,这是在java基础阶段主要学习的内容,也是java的基础,以后不管从事Android开发或者是物联网+云计算的开发,等是建立在JSE基础上的,因此该技术是java的最核心技术,是传智播客基础班的主要上课内容.。

J2ME(Java 2 Platform Micro Edition)小型版

在jdk5.0版本以后称为JAVAME,该技术多应用于一些电子产品的嵌入式开发,以前在手机开发上应用的也比较多,但是随着智能手机的发展,现在手机应用程序(比如Android程序)的开发已经不再使用该技术。

3、什么是跨平台性？原理是什么？JVM
所谓跨平台性，是指java语言编写的程序，一次编译后，可以在多个系统平台上运行。

实现原理：Java程序是通过java虚拟机在系统平台上运行的，只要该系统可以安装相应的java虚拟机，该系统就可以运行java程序。（注意不是能在所有的平台上运行，关键是该平台是否能安装相应的虚拟机）。

我的总结：Java程序之所以能够实现跨平台运行，是因为它根本就不直接运行在任何底层平台上，而是需要在哪里运行，就在哪里(如Windows平台)事先准备好自己的Java平台，而这只是仅仅是安装和配置一个软件而已！

4、Jre和Jdk的区别?
JRE：（Java Runtime Environment），java运行环境。包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE 即可。

JDK：（Java Development Kit Java）开发工具包。JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。所以安装了JDK，就不用在单独安装JRE了。

其中的开发工具：编译工具(javac.exe) 打包工具(jar.exe)等

简单而言：使用JDK开发完成的java程序，交给JRE去运行。

我的总结：必须熟练的记忆，核心类库，开发工具！

5、java虚拟机JVM
Java Virtual Machine ，简称JVM;

它是运行所有Java程序的抽象计算机,是Java语言的运行环境，它是Java 最具吸引力的特性之一，JVM读取并处理编译过的与平台无关的字节码(class)文件。

Java编译器针对JVM产生class文件，因此是独立于平台的。

Java解释器负责将JVM的代码在特定的平台上运行。

Java虚拟机是不跨平台的.

6、Java程序运行机制

编译: javac 文件名.文件后缀名

运行: java 类名

我的总结：Java程序的组成：Java源文件，字节码文件。

7、学习java注意的地方

Java语言拼写上严格区分大小写；

一个Java源文件里可以定义多个Java类，但其中最多只能有一个类被定义成public类；

若源文件中包括了public类，源文件必须和该public类同名；

一个源文件中包含N个Java类时，编译后会生成N份字节码文件，即每个类都会生成一份单独的class文件，且字节码文件名和

其对应的类名相同；

我的总结：一个Java源文件只定义一个类,不同的类使用不同的源文件定义;

将每个源文件中单独定义的类都定义成public的;

保持Java源文件的主文件名与源文件中的类名一致;

8、Java语法格式
任何一种语言都有自己的语法规则,Java也一样,既然是规则,那么知道其如何使用就可以了。

代码都定义在类中,类由class来定义，区分 public class 和 class;

代码严格区分大小写,如main 和 Main 是不一样的;

Java中的标识符与关键字;

注释;

main方法的作用：

程序的入口

保证程序的独立运行

被JVM调用

9、代码注释：单行//，多行/* */，文档注释/** */
1.单行注释 //:

//后到本行结束的所有字符会被编译器忽略;

2.多行注释 /* */:

/* */之间的所有字符会被编译器忽略

3.文档注释 /** */:

在/** */之间的所有字符会被编译器忽略,java特有的(用于生成文档);

我的总结：多行和文档注释都不能嵌套使用。

10、Java中的标识符
可简单理解为在Java程序中为了增强阅读性自定义的名称。比如：类名，方法名，变量名等。

命名规则：

(1) 由字母、数字、下划线、$组成，不能以数字开头

注意:此处的字母还可以是中文,日文等;

(2) 大小写敏感

(3) 不得使用java中的关键字和保留字

(4) 别用Java API里面的类名作为自己的类名。

11、java中的常量和变量
变量的概念：

占据着内存中的某一个存储区域;

该区域有自己的名称（变量名）和类型（数据类型）;

该区域的数据可以在同一类型范围内不断变化;

为什么要定义变量：

用来不断的存放同一类型的常量，并可以重复使用；

使用变量注意：

变量的作用范围, 初始化值

定义变量的格式：

数据类型变量名 = 初始化值；

注：格式是固定的，记住格式，以不变应万变。

作用范围：定义开始到定义它的代码块结束;

同一范围内，不允许多个个局部变量命名冲突

12、Java成员变量和局部变量
局部变量：不是声明在类体括号里面的变量；

局部变量使用前必须初始化值;

局部变量没有默认初始化值;

局部变量的作用域是从定义开始到定义它的代码块结束;

成员变量:在方法体外,类体内声明的变量，又称字段(Field)或全局变量；（其实Java中没有全局变量，由于Java是面向对象语言，所有变量都是类成员）

成员变量的作用域是整个类中;

我的总结：注意成员变量和局部变量的区别

package reviewDemo;

public class Demo2 {
public static void main(String[] args) {
int i;
System.out.println(i);
}
}
备注：局部变量调用前没有初始化，所以编译的时候就会报错！

package reviewDemo;

public class Demo2 {
static int i;
public static void main(String[] args) {
System.out.println(i);
}
}
备注：此时i为全局变量，未初始化会被赋予默认的初始化值！程序正确！

我的总结：

局部变量是定义在方法中的变量,,,出了该方法就不能访问该变量了....
成员变量是在类中定义,,,,并且在类的成员方法中都能访问的变量..

13、基本数据类型

在数据类型中，最常用也是最基础的数据类型，被称作基本数据类型。可以使用这些类型的值来代表一些简单的状态。

Java 语言的基本数据类型总共有以下8 种，下面是按照用途划分出的4 个类别：

定点类型：
整数型是一类代表整数值的类型。当需要代表一个整数的值时，可以根据需要从4 种类型中挑选合适的，如果没有特殊要求的话，一般选择int 类型。4 种整数型区别主要在每个数据在内存中占用的空间大小和代表的数值的范围。

浮点类型：
小数型是一类代表小数值的类型。当需要代表一个小数的值时，可以根据需要从以下2 种类型中挑选合适的。如果没有特殊要求，一般选择double类型。
由于小数的存储方式和整数不同，所以小数都有一定的精度，所以在计算机中运算时不够精确。根据精度和存储区间的不同，设计了两种小数类型。

字符型：
字符型代表特定的某个字符，按照前面介绍的知识，计算机中都是以字符集的形式来保存字符的，所以字符型的值实际只是字符集中的编号，而不是实际代表的字符，由计算机完成从编号转换成对应字符的工作。Java 语言中为了更加方便国际化，使用Unicode 字符集作为默认的字符集，该字符集包含各种语言中常见的字符。在程序代码中，字符使用一对单引号加上需要表达的字符来标识，例
如’A’、’a’等，当然也可以直接使用字符编码，也就是一个非负整数进行表示。

布尔型：
布尔型代表逻辑中的成立和不成立。Java 语言中使用关键字true 代表成立，false 代表不成立。布尔型是存储逻辑值的类型，其实很多程序中都有逻辑值的概念，Java 把逻辑的值用布尔型来进行表达。

14、基本数据类型转换之向上转型和向下转换
向上转换：

整型，字符型，浮点型的数据在混合运算中相互转换，转换时遵循以下原则：

容量小的类型可自动转换为容量大的数据类型；

byte,short,char → int → long → float → double

byte，short，char之间不会相互转换，他们在计算时首先会转换为int类型。

boolean 类型是不可以转换为其他基本数据类型。

Eg：

int i = 123;

long l = i; //自动转换，不需强转

float f = 3.14F;

double d = f;

向下转换：

整型，字符型，浮点型的数据在混合运算中相互转换，转换时遵循以下原则：

容量小的类型可自动转换为容量大的数据类型；

byte,short,char → int → long → float → double

byte，short，char之间不会相互转换，他们在计算时首先会转换为int类型。

boolean 类型是不可以转换为其他基本数据类型。

Eg：

long l = 123L;

int i = (int) l;//必须强转

double d = 3.14;

float f = (float) d;

我的总结：类型转化

小转大，自动！自动类型转换（也叫隐式类型转换）

大转小，强转！强制类型转换（也叫显式类型转换）

15、Java的运算符
运算符是一种特殊符号，用以表示数据的运算、赋值和比较等共分以下几种：

算术运算符（+ 、— 、* 、/ 、%）

赋值运算符（= 、+=、-=、*=、/=,、%=）

关系运算符（>、>=、<、<=、!=）

条件运算符（&&、||、！&、|、^）

位运算符（&、|、^、~、>>、<<、<<<、>>>）

我的总结：

逻辑运算符用于连接布尔型表达式，在Java中不可以写成33 & x<6 。

“&”和“&&”的区别：单与时，左边无论真假，右边都进行运算；双与时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。

“ ^ ”与“|”不同之处是：当左右都为true时，"^"结果为false。

16、表达式和三目运算符
是由数字、运算符、数字分组符号(括号)等以能求得数值的有意义排列的序列;

a + b

3.14 + a

(x + y) * z + 100

boolean b= i < 10 && (i%10 != 0)

表达式的类型和值：

对表达式中操作数进行运算得到的结果是表达式的值。

表达式值的数据类型即为表达式的类型。

表达式的运算顺序

应按照运算符的优先级从高到低的顺序进行;

优先级相同的运算符按照事先约定的结合方向进行;

“三目运算符”，语法格式：

x ? y : z;

其中x为boolean类型表达式，先计算x的值，若为true,则整个三目运算符的结果是表达式y的值，否则就是z的值。

package reviewDemo;

public class Demo2 {

public static void main(String[] args) {

String s = "lz";

s = (s == "lz" ? "正确" : "错误");

System.out.println(s);

}

}

输出：正确

17、程序流程控制
顺序结构

分支结构（条件结构）

循环结构

控制循环结构

顺序结构：

如果代码里没有流程控制，程序是至上而下一行一行执行的，一条语句执行完之后继续执行下一条语句，直到程序的最后。

if语句:

基本语法:if(表达式){方法体}else if(表达式){方法体}else(方法体)

几种形式:

三种格式：

if(条件表达式){执行语句；}

if(条件表达式){执行语句；}else{执行语句；}

if(条件表达式){执行语句；}else if (条件表达式){执行语句；}……else{执行语句；}

public class If3

{

public static void main(String args[])

{

int i = 3;

if (i > 5)

{

System.out.println("变量i大于5");

}

else if (i > 4)

{

System.out.println("变量i小于4");

}

else

{

System.out.println("其他");

}

}

}

switch控制语句

格式：

switch(表达式)

{

case 表达式可能的结果值1:

执行语句；

break；

case 表达式可能的结果值2:

执行语句；

break；

...

default:

执行语句；

break；//最后这个一般不写

}

备注：

case之间与default没有顺序。先执行第一个case，都没有匹配的case值执行default。

结束switch语句的两种情况：遇到break，switch语句执行结束。

如果匹配的case或者default没有对应的break，那么程序会从第一次匹配的case语句开始继续向下执行，运行可以执行的语句，直到遇到break或者switch结束为止。

class switch2

{

public static void main(String[] args)

{

int a = 7,b = 5;

switch(a-b)

{

case 3://表达式可能的值；

{

System.out.println("33!");

}

break;

case 4:

{

System.out.println("44!");

}

break;

default://都没有执行则执行该语句!

System.out.println("其它的");

}

}

}

注意：switch语句只能使用byte、char、short、int四种基本类型以及它们的包装类和枚举

18、三大循环结构:
用于处理需要重复执行的操作；

根据判断条件的成立与否，决定程序段落的执行次数，而这个程序段落我们称为循环体；

while:事先不需要知道循环执行多少次；

do while:同上，只是至少要执行一次(先做，后判断)；

for:需要知道循环次数；

循环结构(while & do while)

while语句

格式：

while(条件表达式值为true)

{

执行语句；

}

do while语句

格式：

do

{

执行语句；

}

while(条件表达式值为true);

我的总结：do while特点是无论条件是否满足，循环体至少被执行一次。

循环里的条件表达式不能直接写false或直接写结果是false的表达式,不过可以使用变量来传递false值;

循环结构(for)

格式：

for(初始化表达式（1）；循环条件表达式（2）；循环后的操作表达式（3）)

{

执行语句；（4）

}

执行顺序：(1) → (2) → (4) → (3) → (2) → (4) → (3)

备注：

1, for里面的3个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。

2, while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。

3, 最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。

Eg：

用三种循环控制求出100以内前5个3的倍数的数字；

class while

{

public static void main(String[] args)

{

int i = 1,k = 0;

while(i<=100)

{

if(i%3==0)

{

if(k<5)

System.out.println(i);

k++;

}

i++;

}

}

}

class dowhile

{

public static void main(String[] args)

{

int i = 1,k = 0;

do{

if(i%3==0)

{

if(k<5)

System.out.println(i);

k++;

}

i++;

}

while(i<=100);

}

}

class for

{

public static void main(String[] args)

{

int i = 1,k = 0;

for(;i<100;i++)

{

if(i%3==0&&k<5)

{

System.out.println(i);

k++;

}

}

}

}

19、嵌套循环与流程控制
嵌套循环：循环里套循环

假设外循环的循环次数是m次,内循环的循环次数是n次，那么内层循环的循环次数需要 m * n次。

Eg：利用for循环语句的嵌套打印出乘法口诀表

class break1

{

public static void main(String[] args)

{

for(int i=1;i<=10;i++)//定义i与j的值必须在for循环里面，否则每次跳出循环重新执行就无法取值

{

for(int j=1;j<=10;j++)

{

if(j<=i)

System.out.print(j+"*"+i+"="+i*j+" ");//小注意:print()括号里面

必须传递参数,println()无限制!

}

System.out.println();

}

}

}

流程控制

break语句、 continue语句；

break：终止该层循环；

continue：跳过该层循环

注：

①：若这两个语句离开应用范围，存在是没有意义的。

②：这个两个语句后面都不能有语句，因为执行不到。

③：continue语句是跳过本次循环，继续下次循环。

④：标签的出现，可以让这两个语句作用于指定的循环。

Eg：

package reviewDemo;

public class Demo2 {

public static void main(String[] args) {

int i = 1;

for (; i < 10; i++) {

System.out.println(i);

if(i == 8){

break;//流程控制，不会完全执行！

}

}

}

}

二、黑马程序员—方法与数组
第二篇：

1、什么是方法（Method）？
方法是一组为了实现特定功能的代码块的集合。方法在语法上的功能主要有以下两个：
①：结构化代码
将代码按照功能进行组织，使代码的结构比较清晰，容易阅读和修改，也就是程序的可维护性强。
②：减少代码重复
一个固定的功能，可能会在程序中多次使用，在使用时只需要调用写好的方法，而不用重复书写对应的功能代码。

方法在书写时需要注意以下两点：
①：逻辑严谨
方法实现的一个完整的功能，所以在书写时要考虑到各种可能的情况，并对每种情况做出恰当的处理。
②：通用性强（可重复利用）
方法实现的是一种功能，在实际实现时，可以根据需要，使方法具备一定的通用性，除非必要，否则不要写专用的方法。在Java 语言中，恰当的使用方法，将使程序更加优雅，便于阅读和使用。

我的总结：

方法：一段可重复使用的代码段；

程序中完成独立功能的一段代码的集合。

2、Java中方法的格式：
[修饰符] 返回值类型方法名([参数类型形式参数1，参数类型形式参数2，……])

{

执行语句; [return 返回值;]//需要的话

}

参数列表（参数的类型，参数的个数，参数的顺序）

我的总结：只要上述有一个不一样，那么这个参数列表就不一样！对于方法而言，即使同名也不是同一个方法，也就是下面讲的方法签名。

3、方法里的属性
访问控制符：访问控制符限定方法的可见范围，或者说是方法被调用的范围。方法的访问控制符有四种，按可见范围从大到小依次是：public、protected，无访问控制符,private。其中无访问控制符不书写关键字即可。具体的范围在后续有详细介绍。

形式参数：在方法被调用时用于接收外界输入的数据。

实参：调用方法时实际传给方法的数据。

返回值：方法在执行完毕后返还给调用它的环境的数据。

返回值类型：事先约定的返回值的数据类型，如无返回值，必须给出返回类型 void。

方法签名：方法名和方法的参数列表(能区别方法)；//最关键的

java语言中调用方法：对象名.方法名（实参列表）。

实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配。

return 语句终止方法的运行并指定要返回的数据。

4、方法特点

它可以实现独立的功能;

必须定义在类里面;

它只有被调用才会执行;

它可以被重复使用;

方法结束后方法里的对象失去引用;

如何定义一个功能,并通过方法体现出来：

①　明确该功能运算后的结果.明确返回值类型;

②　明确在实现该功能过程中是否有未知内容参与运算，确定参数列表;

Eg：

package reviewDemo;

/**

* player 的值分别是1,2,3或者其他值时，该方法返回“大明”，“二明”，“小明”，“我没有这个孩子”。

*/

public class Demo2 {

public static void main(String[] args) {

int player = 5;

System.out.println("返回的结果是："+show(player));

}

public static String show(int p){

switch (p) {

case 1:

return "大明";

case 2:

return "二明";

case 3:

return "小明";

default:

return "我没有这个孩子！";

}

}

}

5、什么是方法的重载（Overload）？

概念：

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

存在的原因：

屏蔽了一个对象的同一类方法由于参数不同所造成的差异。

特点：

与返回值类型无关，只看参数列表。

以下是方法重载的示例：
public void a(int a){}
public int a(){}
public void a(int a,String s){}

Eg：

class Chongzai

{

public static void main(String[] args)

{

int ret = name(3,4,5);

System.out.println(ret);

}

public static int name(int a, int b)

{

int c = a+b;

return c;

}

public static int name(int a, int b, int m)//这就叫做方法的重载，只要参数列表不一样。好处：用户使用时限制很小；

{

int c = a+b+m;

return c;

}

}

我的总结：方法重载，方法名相同，但是参数列表不一致！（和方法覆写不一样，方法覆写的方法名和参数列表都必须一样），注意方法重载和方法覆写的不同！

6、可变参数
从java5开始出现了可变参数，这是对java方法及数组的拓展！

方法中可以接受的参数不再是固定个数的，而是随着具体需求传递的多少来决定。

定义格式：返回值类型方法名(参数类型 ... 形式参数){ }

可变参数的特点：

只能出现在参数列表的最后；

... 位于变量类型和变量名之间，前后有无空格都可以;

调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

Eg：

package reviewDemo;

import java.util.Arrays;

public class Demo6 {

public static void main(String[] args) {

int []age = {1,2,3,69,36,636,459};

show(age);

}

public static void show(int...a){//此时这里写的就是可变参数，和数组的作用一样！

//把数组给打印出来！

System.out.println(Arrays.toString(a));

}

}

7、数组简介：
数组(Array)是Java 语言中内置的一种基本数据存储结构，通俗的理解，就是一组数的集合，目的是用来一次存储多个数据。数组是程序中实现很多算法的基础，可以在一定程度上简化代码的书写。

备注：

1. 数组的好处：数组里的每个元素都有编号，编号从0开始，并且依次递增，方便操作这些元素；

2. 使用Java数组：必须先声明数组，再给该数组分配内存；

3. 数组对应在内存中一段连续空间。

4. 数组元素必须是相同数据类型，也可以是引用数据类型，但是同一个数组中的元素必须是同一类数据类型。

8、一维数组的声明与初始化：
一维数组：可以理解为一列多行、类型相同的数据，其中每个数据被称为数组元素；

一维数组的声明方式：

type varName[]; 或 type[] varName;(推荐)

Eg：int age[]; int []age;

数组的长度一旦确定,就不能改变,也就数组是定长的;

我的总结：java语言声明数组的时候不能指定其长度（元素的个数）

Eg：int a[5]; //非法

初始化：

Java中的数组必先初始化才可以使用，所谓初始化就是为数组的数组元素分配内存，并为每个数组元素赋值；

数组初始化的两种方式：

静态初始化：初始化时由我们自己指定每个数组元素的初始值，由系统决定需要的数组长度；

格式：数组名 = new 数组类型[]{元素1,元素2,元素3...元素n};

简化语法：数组名 = {元素1,元素2,元素3...元素n};

动态初始化：初始化时由我们指定数组的长度，由系统为数组元素分配初始值；

格式：数组名 = new 数组类型[数组长度];

我的总结：

不能静态和动态初始化同时使用：

也就是说不能同时指定数组的长度和元素；

Eg:

package reviewDemo;

/**

* 声明数组及初始化

*/

public class Demo3 {

public static void main(String[] args) {

int []age = new int[10];

//动态初始化

for (int i = 0; i < age.length; i++) {

age[i] = i;

System.out.print(age[i]+" ");

}

}

}

输出：0 1 2 3 4 5 6 7 8 9

9、数组的使用：
Java语言的数组索引是从0开始的，也就是说数组里的第一个元素的索引是0,第二个元素的索引是1，依次可以类推。

常见操作：

给数组元素赋值

数组名[索引] = 数组类型的值 ;

访问数组元素

数组类型变量 = 数组名[索引];

得到数组的长度

int len = 数组名.length; //length是数组的属性

遍历数组（备注：length 属性和循环语句）

数组元素的索引范围（0，长度—1）

Eg：判断数组是否重复

package reviewDemo;

/**

* 判断数组是否重复

*/

public class Demo3 {

public static void main(String[] args) {

int []age = {1,2,3,4,5,6,5};

for (int i = 0; i < age.length-1; i++) {//双层循环，定住一个，再考虑下一个！

for (int j = i+1; j < age.length; j++) {

if(age[i] == age[j]){

System.out.println("有重复的！"+i+" "+j);

break;

}

}

}

}

}

求最大值：

package reviewDemo;

public class Demo4 {

public static void main(String[] args) {

int age[] = new int[] { 12, 26, 3, 60, 55, 6, 48, 4, 98 };

int max = age[0];

for (int i = 0; i < age.length; i++) {

if (max < age[i]) {

max = age[i];

}

}

System.out.println(max);

}

}

经典用法：冒泡法排序

class Bubblesort

{

public static void main(String args[])

{

int [] arr={5,1,6,4,2,8,9};

bubble(arr);

printarray(arr);

}

public static void bubble(int[] arr)

{

for (int i=0;i

{

for (int y=0;y

{

if(arr[y]>arr[y+1]) //相邻两元素相比

{

int temp = 0;

temp = arr[y];

arr[y] = arr[y+1] ;

arr[y+1] = temp;

}

}

}

}

public static void printarray(int[] arr)

{

for (int i=0;i

{

if(i!=arr.length-1)

System.out.print(arr[i]+",");

else

System.out.println(arr[i]);

}

}

}

//选择排序

public class Demo6 {

public static void main(String[] args) {

int []age = {1,2,36,363,56,95,12,32,1232,3263};

for (int i = 0; i < age.length; i++) {

for (int j = i+1; j <= age.length-1; j++) {

if(age[i] > age[j]){

int temp = age[i];

age[i] = age[j];

age[j] = temp;

}

}

}

System.out.println(Arrays.toString(age));

}

}

//输出为：[1, 2, 12, 32, 36, 56, 95, 363, 1232, 3263]

10、分配内存空间
分配内存空间

数组名=new 数据类型[数组长度]；

new关键字用来实现为数组或对象分配内存（堆内存）

数组具有固定的长度。获取数组的长度：数组名.length

定义数组+分配内存空间

数据类型[]数组名=new 数据类型[数组长度];

定义数组时不指定长度，分配空间时指定数组长度；如：String cities[] = new String[6];

数组元素：

数组名[下标值];

数组下标从0开始 scores[0]=75；

数组的内存分配栈内存和堆内存

如定义一个数组 int[]scores将在栈内存中为scores 分配内存空间，其值是一个不确定的值。

当执行语句scores=new int[5]时，将在堆内存分配连续5个空间，每个空间4个字节，用于存放整型数据，其初始值为0，然后将该段空间首地址，也就是第一个元素的地址，比如0*3000，赋给scores变量。该地址相当于一个指针，指向堆内存中分配的空间。此时堆内存中分配的5个空间可以分别使用scores[0],一直到scores[4]来表示。当执行四个赋值语句时，分别用指定值填充到对应元素位置。如果此时将null值赋给scores时，scores变量将不再指向任何位置，此时堆内存中分配的空间就变成了垃圾，由垃圾回收器在某一时间进行回收。

在方法中定义的变量，包括基本数据类型变量和引用数据类型变量，都将在栈内存中分配空间，当超过变量作用范围后，自动回收

我的总结：初始化=定义数组+分配空间+赋值

11、二维数组：
二维数组：(其实是一个一维数组，它的每一个元素又是一个一维数组),

可以看做是一张表格。

初始化：

动态初始化

int[ ][ ] arr = new int[3][2];

定义了一个二维数组，其中有3个一维数组，每一个一维数组中有2个元素

静态初始化

int[ ][ ] arr = new int[][]{{1,2},{3,4},{5,6}};

int[ ][ ] arr = {{1,2},{3,4},{5,6}};

Eg：

public class Demo3 {

public static void main(String[] args) {

int age[][] = new int[][]{{1,2},{3,4},{5,6,7}};

System.out.println(age[0].length);//2

System.out.println(age[2].length);//3

}

}

12、操作数组的工具类-Arrays

static int binarySearch(type[] a, type key) 使用二分搜索法来搜索key元素在数组中的索引；若a数组不包括key，返回负数。（该方法必须已按升序排列后调用）。

static int binarySearch(type[] a, int fromIndex, int toIndex, type key) 使用二分搜索法来搜索key元素在数组中从fromIndex到toIndex的索引；若a数组不包括key，返回负数。（该方法必须已按升序排列后调用）。

static boolean[] copyOf(type[] original, int newLength) 复制指定的数组见下面备注

static byte[] copyOfRange(type[] original, int from, int to) 将数组的指定范围复制到一个新数组。

static boolean equals(type[] a, type[] a2) 如果两个数组长度相等和元素一一相等，则返回 true

static void fill(type[] a, type val) 将a数组所有元素都赋为val。

static void fill(type[] a, int fromIndex, int toIndex, type val) 将a数组从formIndex 到tiondex索引之间的元素都赋为val。

static void sort(type[] a) //sort(int[] arr)对指定的数组按数字升序进行排序。

static void sort(type[] a, int fromIndex, int toIndex) 对指定数组的从formIndex 到tiondex索引之间的元素按数字升序进行排序。

static String toString(type[] a) 返回指定数组内容的字符串表示形式。多个数组元素之间用英文逗号或空格隔开。

我的总结：使用数组工具类可以节省时间，提高效率，注意常查阅api；

Eg：

package reviewDemo;

import java.util.Arrays;

//使用Arrays类

public class Demo4 {

public static void main(String[] args) {

int[] age = new int[] { 12, 26, 3, 60, 55, 6, 48, 4, 98 };

System.out.println(Arrays.toString(age));//直接打印出数组的方法

int []age2 = {1,2,3,4,5,6,98,65,23};

int i = Arrays.binarySearch(age2, 98);

System.out.println(i);

}

}

13、Java5新特性对数组的支持：
增强for循环 → for-each

for (参数类型参数名 : 数组名) {

代码块

}

Eg：

package reviewDemo;

public class Demo6 {

public static void main(String[] args) {

int []age = {1,2,3,69,36,636,459};

for (int i : age) {

System.out.println(i);

}

}

}

这样就用for-each把数组遍历输出！

我的总结：for-each用于数组和Iterable对象！在以后的集合学习中还会经常用到for-each循环。

三、黑马程序员—面向对象（1）
第三篇：

1、什么叫面向对象？
面向对象(Object-Oriented，简称OO)就是一种常见的程序结构设计方法。
面向对象思想的基础是将相关的数据和方法放在一起，组合成一种新的复合数据类型，然后使用新创建的复合数据类型作为项目的基础。

面向对象是一个很抽象的概念，它相对面向过程而言。

过程与对象都是一种解决问题的思想。

面向过程：强调的是功能行为,一种过程,先干啥,再干啥;

面向对象：将功能封装到对象里，强调的是具备某功能的对象;

按照面向对象的思想，可以把任何的东西看做对象！

面向对象的三个特征：

封装(Encapsulation);

继承(Inheritance);

多态(Polymorphism)。

我的总结：

面向过程：强调的是具体的功能实现；（执行者）

面向对象：强调的是具备功能的对象。（管理者）

2、类

类(class)是Java 语言的最小编程单位，也是设计和实现Java 程序的基础，本部分将深入介绍类的相关知识。
类的概念
类是一组事物共有特征和功能的描述。类是对于一组事物的总体描述，是按照面向对象技术进行设计时最小的单位，也是组成项目的最基本的模块。类的概念是抽象的，类似于建筑设计中的图纸，是对于现实需要代表的具体内容的抽象。类只包含框架结构，而不包含具体的数据。所以类代表的是总体，而不代表某个特定的个体。

我的总结：类是抽象的，对象是具体的，实实在在的！

类的定义：

[修饰符] class 类名{

1~n个构造方法；

0~n个字段；

0~n个方法

}

定义类，其实就是定义类里面的对象

对象包含：

状态；（属性）

功能、行为；（方法）

通过类来描述对象；

状态--------成员变量；

功能、行为——方法；

Eg：

class Person{

//属性

private String name;

private int age;

private int sal;

//方法

public void show(){

System.out.println("个人情况："+name+age+sal);

}

}

3、构造方法
构造方法：用来构造类的实例（每一个类都默认有一个无参的构造方法，得使用new调用）

字段：类或对象所包含的数据，对类状态的一种描述；

方法：类或对象的特征或行为

作用：

给类中的字段进行初始化，可以用来创建对象。

特点：

方法名与类名相同

不用定义返回值类型

不需要写return语句

我的总结：

注意：

默认构造方法的特点。

多个构造方法是以重载的形式存在的。

构造方法的重载:（需要哪个就去适配哪个，调用哪个）

this([实参]);调用当前类的构造方法

注意: this([实参]);必须放在构造器的第一行;

对象的产生格式：

类名称对象名 = new 类名称();

因为有(),所以是方法,实际上它就是构造方法，并且是非私有的构造方法。

如：CellPhone cp = new CellPhone();

Eg：

class Person{

private String name;

private int age;

private int sal;

public void show(){

System.out.println("个人情况："+name+age+sal);

}

public Person(String name) {

super();

this.name = name;

}

public Person(String name, int age) {

super();

this.name = name;

this.age = age;

}

public Person(String name, int age, int sal) {

super();

this.name = name;

this.age = age;

this.sal = sal;

}

}

4、static关键字

特点：

随着类的加载而加载

优先于对象存在

被所有对象所共享

可以直接被类名调用

使用注意：

静态方法只能访问静态成员

但是非静态成员可以访问静态成员;

静态方法中不可以使用this，super关键字

主方法（main）是静态的（可以利用类名去调用静态的main方法，很正常！但是会陷入死循环，导致内存溢出，jvm自动停止！）

public static void main(String[] agrs){}

可修饰字段,方法。

用static 修饰的成员表示它属于这个类共有，而不是属于该类的单个实例。

static 修饰的字段 == 类字段

static 修饰的方法 == 类方法

没使用static修饰的字段和方法，成员属于类的单个实例，

不属于类。

没有static 修饰的字段 == 实例字段

没有static 修饰的方法 == 实例方法

类和实例访问字段和方法的语法：

访问类成员：类.字段类.方法

访问实例成员：实例.字段实例.方法

我的总结：

static 修饰的字段和方法，既可以通过类调用，也可以使用实例调用；

没static 修饰的字段和方法，只能使用实例来调用（建议使用:类名来调用;其实在底层,对象调用类成员,也会转换类名调用）

static关键字不能与this，super同时连用！

5、匿名对象

一个没有名字的对象, 创建了一个对象出来,没有赋给一个变量;

特点：

对方法或字段只进行一次调用时；

可作为实际参数进行传递；

只在堆里面开辟存储区域,

只能使用一次, 使用完就被销毁了;

何时使用？只拿来用一次！！

new Person();表示匿名对象,没有名字的对象

new Person().age = 17;//使用一次之后就被销毁了

6、this关键字
特点：this表示当前对象。

当前对象 ←→ 当前正在调用实例成员的对象

换言之：谁调用了方法，谁就是当前对象。

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

方法间的相互调用;

this.字段;

构造器中相互调用，但是此时this([参数])必须写在构造方法第一行。

this不能用在static修饰的方法里和static修饰的代码块里;

Eg：构造方法中的this.name = name;

7、面向对象之封装

封装的两个含义：

1.把对象的状态和行为看成一个统一的整体，将二者存放在一个独立的模块中(类)；

2."信息隐藏", 把不需要让外界知道的信息隐藏起来,尽可能隐藏对象功能实现细节,字段;

封装机制在程序中的体现是：把描述对象的状态用字段表示，描述对象的行为用方法表示，把字段和方法定义在一个类中，并保证外界不能任意更改其内部的字段值，也不允许任意调动其内部的功能方法。

程序中的一种体现：通常将类中的成员变量私有化(private)，通过对外提供方法（setXxx,getXxx）,可对该变量(xxx)进行访问。

boolean 类型的变量没有getXX,只有 isXX;

Eg：

class Person1{

private String name;

private int age;

private int sal;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

}

8、访问修饰符

private 类访问权限:本类内部可以访问,不能继承到子类;

default 什么都不写,包访问权限:本类内部可以访问，同包其他类也可以访问,同包可继承;

protected 子类访问权限:本类内部可以访问，不同包的子类也可以访问，同包其他类也可以访问,能继承到子类;

public 公共访问权限:任何地方都可以访问,能继承到子类;

我的总结：

9、类的设计分析
分析思路：

根据要求写出类所包含的字段；

所有的字段都必须私有化；

封装之后的字段可通过setter和getter设值和取得；

按需求可添加若干构造方法；

根据需求可添加相应的方法；

类中的所有方法都不要直接处理(输出打印)，而是交给调用者去处理。

10、面向对象之继承

首先有反映一般事物特性的类,然后在此基础上反映出特殊事物的类；

也就是说：继承是一种从一般到特殊的关系；

特点：

1、提高了代码的复用性。

2、让类与类之间产生关系，有了这个继承关系才有了多态的特性。

3、Java语言中只支持单继承（有别于C语言）。

因为多继承容易带来安全隐患（父类多了，功能相同的话，就会出现调用不确定性吗，覆写一个方法，到底覆写的谁的？）。

ps：接口可以实现多继承

4、Java支持多层继承，object是每个类的超类，实现树形结构。

我的总结：

继承是多态的前提。

对类而言，只支持单继承。接口可以实现多继承

格式：

[修饰符] class SubClass extends SuperClass

按照这种关系，我们把SuperClass类称为父类或基类，把SubClass称为子类或派生类或拓展类；

我的总结：

java.lang.Object是所有类的父类，

Object要么是直接父类要么是间接父类。

Eg：

学生属于人的一种特殊情况,此时我把人的共性写在Person类里面,为了让学生拥有这些共性（别的比如老师也可以有这些共性）,然后我就让学生来拓展Person类。

我的总结：

子类与父类的关系:

子类拓展父类（子类是父类的一种特殊情况）

主要是以父类为基础，然后添加属于自己的字段和方法。

父类的私有成员子类不能继承到;父类的构造方法不能被继承；

Java只支持单继承,不支持多继承;//不然的话，比如show方法，继承了多个，不知道到底调用那一个。

一个类有且只有一个直接父类;

一个类没显示的继承其他的一个类的时候,默认的直接父类就是Object类;

Student 的直接父类是Person,Object类也是Student类的父类,但是是间接父类;

一旦一个类显示的继承了其他的一个类的时候,此时默认的直接父类Object就会被取消;

Java里一个类只能有一个直接父类;java.lang.Object是所有类的父类，Object要么是直接父类要么是间接父类。

子类对象实例化过程

在继承操作中，对于子类对象的实例化：

子类对象在实例化之前必须首先调用父类中的构造方法之后再调用自身的构造方法。

11、子类访问父类和方法覆写

子类不能直接访问父类的私有成员；

但是子类可以调用父类中的非私有方法来间接访问父类的私有成员。

Person类中有私有字段name,Student继承Person

new Sudent().name; ×

new Student().getName(); √

子类拓展父类（子类是父类的一种特殊情况）

主要是以父类为基础，然后添加属于自己的字段和方法。

方法覆写产生原因：

当父类中某个方法不适合于子类时,子类出现父类一模一样的方法.

判断必杀技:子类方法前加上@Override能编译通过,表明是方法的覆写。

调用被覆盖的父类方法：使用super.方法名(实参);

方法覆写时应遵循的原则(一同两小一大)：

(一同):方法签名必须相同;

(两小):

子类方法的返回值类型比父类方法的返回值类型更小或相等

子类方法声明抛出的异常应比父类方法申明抛出的异常更小或相等;

(一大):子类方法的访问权限应比父类方法更大或相等;

子类需要覆写父类方法。

当父类的某个方法不适合于子类本身的特征行为时就当覆写父类中应当改变的方法。

12、super关键字和调用父类构造方法
表示父类对象的默认引用

如果子类要调用父类被覆盖的实例方法，可用super作为调用者调用父类被覆盖的实例方法。

使用super调用父类方法

使用super调用父类的构造方法

调用构造方法

本类中调用另一个重载构造方法用this(参数列表)

子类构造方法调用父类构造方法用super(参数列表)

子类调用父类的构造方法时：

super必须放在第一句

Java在执行子类的构造方法前会先调用父类无参的构造方法，其目的是为了对继承自父类的成员做初始化操作。

子类在创建对象的时候，默认调用父类的无参构造方法，要是子类构造方法中显示指定调用父类其他构造方法，就调用指定的父类构造方法，取消调用父类无参构造方法。

Eg：

package reviewDemo;

class A{

String name;

A(){

System.out.println("父类默认隐式的构造方法！");

}

A(String name){

System.out.println("父类显式的构造方法！");

}

}

class B extends A{

B(){

super(null);

System.out.println("子类默认隐式的构造方法！");

}

}

public class Demo10 {

public static void main(String[] args) {

new B();

}

}

结果：父类显式的构造方法！

子类默认隐式的构造方法！

13、面向对象之多态

多态:指同一个实体同时具有多种形式

好比,你去面馆吃面,说我要吃面,那么;老板给我牛肉面,鸡蛋面等都可以,

这就是说"面"有多种形态,也就是说实体有多种形态;

编译时的类型由声明该变量时使用的类型决定,运行时的类型由实际赋给变量的对象决定。

如果编译时类型和运行时类型不同，就出现多态。

Eg：

前提:Student extends Person:

Person p = new Person();

Student s = new Student();

Person p = new Student();//多态

引用关系:父类变量指向子类实例对象

实现多态的机制:

父类的引用变量可以指向子类的实例对象,而程序调用的方法在运行期才动态绑定，就是引用变量所指向的真正实例对象的方法,也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

多态的作用：

把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

只修改方法的实现，不必修改方法的声明

继承是多态产生的前提条件;

分类:

编译时多态：方法重载

运行时多态：方法覆写

Eg：

package test;

class Dog{

void eat(){

System.out.println("一般的狗吃一般的狗粮！");

}

}

class HashDog extends Dog{

void eat(){

System.out.println("哈士奇吃哈士奇的狗粮！");

}

}

class ZangAoDog extends Dog{

void eat(){

System.out.println("藏獒吃藏獒的狗粮！");

}

}

//定义一个动物园喂的方法

class Zoo{

void feed(Dog d){

d.eat();

}

}

public class Demo11 {

public static void main(String[] args) {

Dog hd = new HashDog();

Dog zd = new ZangAoDog();

Zoo z = new Zoo();

z.feed(hd);

z.feed(zd);

}

}

输出：

哈士奇吃哈士奇的狗粮！

藏獒吃藏獒的狗粮！

14、引用变量类型转换
向上转型（子类→父类）：(自动完成)

父类名称父类对象 = 子类实例 ;

向下转型（父类→子类）：(强制完成)

子类名称子类对象 = （子类名称）父类实例 ;

对象名 instanceof 类

判断指定的变量名此时引用的真正类型是不是当前给出的类或子类；

我的总结：对象的类型和类必须有继承关系

Eg：

class A extends B{}

B b = new A();

If(b instanceof A){ ...

}

四、黑马程序员—面向对象（2）
第四篇：

1、基本数据类型的包装类

引言：Java提倡的万物皆对象，但是数据类型的划分出现了基本数据类型和引用数据类型，那么我们怎么能把基本数据类型称为对象呢？

除了Integer和Character定义的名称和对应的基本类型差异大，其他六种都是将首字母大写就可以了。

Integer,Byte,Float,Double,Short,Long都是Number类的子类。(Number类后面讲)；

Character和Boolean都是Object直接子类；

8个类都是final修饰的(不可被继承)。

2、基本数据类型和包装类相互转换

把基本数据类型 → 包装类：

通过对应包装类的构造方法实现

除了Character外，其他包装类都可以传入一个字符串参数构建包装类对象。

包装类 → 基本数据类型

包装类的实例方法xxxValue(); // xxx表示包装类对应的基本数据类型

Eg：

boolean bool = false;

Boolean b2 = new Boolean(bool);

Integer i = new Integer(3);

int i2 = i.intValue();

Boolean b1 = new Boolean("TRue");//true

boolean b2 = b1.booleanValue();

Float f = new Float("3.14");//3.14

Integer i2 = new Integer("123s");//NumberFormatException

备注：

自动装箱&自动拆箱

jdk1.5开始出现的特性：

自动装箱：可把一个基本类型变量直接赋给对应的包装类对象或则Object对象

自动拆箱：允许把包装类对象直接赋给对应的基本数据类型

Eg：

Integer i = 3;//装箱

int i2 = i;//拆箱

Object flag = new Boolean(false);

if(flag instanceof Boolean){

Boolean b = (Boolean)flag;

boolean b2 = b;

}

我的总结：对于基本数据类型和包装类之间的装换，我们可以直接的用，相互转换，因为java5之后的自动拆箱、装箱功能！即便不知道这个，其实使用中也不影响！

3、基本类型和String之间的转换

String → 基本类型，除了Character外所有的包装类提供parseXxx(String s)静态方法，用于把一个特定的字符串转换成基本类型变量；

基本类型 → String，String 类有静态方法valueOf()，用于将基本类型的变量转换成String类型。

String str = "17";

int i = Integer.parseInt(str);//String --> 基本类型

String s1 = String.valueOf(i);//基本类型 --> String

我的总结：这个从后续的学习来看，用处不大，记住有这样的方法就行，查api！

4、Object类

所有类的公共父类，一旦一个类没有显示地继承一个类则其直接父类一定是Object。

一切数据类型都可用Object接收

class OOXX extends Object{}等价于class ooXX {}

常见方法

public boolean equals(Object obj)：对象比较

public int hashCode()：取得该对象的Hash码

public String toString()：对象描述

Object类的 toString()方法：“对象的描述”

建议所有类都覆写此方法

直接打印输出对象时，会调用该对象的toString()方法。//可以不写出来

打印对象的时候,实际调用的对象实际指向的类的自我描述；

全限定类名+@+十六进制的hashCode值，等价于

全限定类名+@+IntegertoHexString(该对象.hashCode)

equals也是判断是否指向同一个对象

没有实际意义，有必要可以重写

public boolean equals(Object obj) {}

String 覆写了 Object的equals方法：只比较字符的序列是否相同

==用于判断两个变量是否相等

基本类型：

引用类型：必须指向同一个对象，才true

只能比较有父子或平级关系的两个对象

new String("1") == new String("1"); ？

5、代码块

代码块指的是使用"{}"括起来的一段代码，根据代码块存在的位置可以分为4种:

普通代码块;

构造代码块;

静态代码块;

同步代码块(线程同步的时候讲解)。

代码块里变量的作用域：

只在自己所在区域(前后的{})内有效；

普通代码块：

普通代码块就是直接定义在方法或语句中定义的代码块：

public void show(){

普通代码块

}

构造代码块：

直接写在类中的代码块:

优先于构造方法执行，每次实例化对象之前都会执行构造代码块。

Eg：

public class Demo {

{

System.out.println("我是构造代码块");

}

public Demo(){

System.out.println("我是构造方法");

}

public static void main(String[] args) {

Demo d1 = new Demo();

Demo d2 = new Demo();

}

}

静态代码块

使用static 修饰的构造代码块:

优先于主方法执行，优先于构造代码块执行，不管有创建多少对象，静态代码块只执行一次，可用于给静态变量赋值；

Eg：

package reviewDemo;

/**

* 测试各代码块的优先级

*优先级顺序：静态代码块　＞　构造代码块　＞　普通代码块

*备注：无论创建几个对象，静态代码块只执行一次！

*/

public class Demo13 {

Demo13(){

System.out.println("我是构造方法！");

}

{

System.out.println("我是构造代码块！");//实例化对象的时候才会去调用！

}

static{

System.out.println("我是静态代码块！");

}

public static void main(String[] args) {

new Demo13();

new Demo13();//再次创建对象，证明无论创建几次对象，静态代码块都只执行一次

System.out.println("我是普通代码块！");

}

}

输出：

我是静态代码块！

我是构造代码块！

我是构造方法！

我是构造代码块！

我是构造方法！

我是普通代码块！

我的总结：这个例子非常好！

6、构造方法的私有化
有的时候我们为了避免外界创建某类的实例，就将某类的构造方法私有化，即将它的构造方法用private修饰：

外界如何用到？

提供get方法！不提供的话外界就没法创建对象！（对反射无效）

Eg：package reviewDemo;

class Stu{

//将构造方法私有化

private Stu(){

}

}

public class Demo15 {

public static void main(String[] args) {

Stu s = new Stu();

}

}

7、Singleton模式(单例模式) 饿汉式和懒汉式

目的：整个应用中有且只有一个实例，所有指向该类型实例的引用都指向这个实例。

好比一个国家就只有一个皇帝(XXX)，此时每个人叫的“皇帝”都是指叫的XXX本人;

常见单例模式类型：

饿汉式单例：直接将对象定义出来

懒汉式单例：只给出变量，并不将其初始化；

我的总结：

饿汉式，static修饰，随着类的加载而加载，会损耗性能，但是方法相对简单

懒汉式第一次用的时候相对较慢，因为需要加载！线程，不安全！

package reviewDemo;

//单例模式

//饿汉式,直接把对象构造出来

class SingleDemo{

private static SingleDemo s1 = new SingleDemo();

private SingleDemo(){

//提供私有化的构造方法，那么外界就不能构造对象了！

}

public static SingleDemo getS1() {

return s1;

}

}

//懒汉式，先定义，但是不创建对象

class SingleDemo2{

private static SingleDemo2 s3 ;

private SingleDemo2(){

//提供私有化的构造方法，那么外界就不能构造对象了！

}

public static SingleDemo2 getS3() {//这是一个方法，返回值为创建的对象！

if(s3 == null){

s3 = new SingleDemo2();

}//和饿汉式的区别，此时才来创建对象！

return s3;

}

}

public class Demo14 {

public static void main(String[] args) {

SingleDemo s1 = SingleDemo.getS1();

SingleDemo s2 = SingleDemo.getS1();

SingleDemo2 s3 = SingleDemo2.getS3();

SingleDemo2 s4 = SingleDemo2.getS3();

System.out.println(s1 == s2);

System.out.println(s3 == s4);

}

}

输出：true true

备注：枚举更加安全些

package reviewDemo;

enum Stu{

jake;

//将构造方法私有化起来，反射也不能创建对象，安全

private Stu(){

}

}

public class Demo15 {

public static void main(String[] args) {

}

}

8、final 关键字

①　final可以修饰类,方法,变量。

②　final修饰类不可以被继承，但是可以继承其他类。

③　final修饰的方法不可以被覆写,但可以覆写父类方法。

④　final修饰的变量称为常量，这些变量只能赋值一次。

⑤　内部类在局部时，只可以访问被final修饰的局部变量。

⑥　final修饰的引用类型变量,表示该变量的引用不能变,而不是该变量的值不能变;

Eg：

package reviewDemo;

final class Name{

}

class NewName extends Name{//ERROR，报错，因为Name有final修饰

}

public class Demo15 {

public static void main(String[] args) {

}

}

9、抽象类

当编写一个类时，我们往往会为该类定义一些方法，这些方法是用来描述该类的行为方式，那么这些方法都有具体的方法体。

但是有的时候，某个父类只是知道子类应该包含怎么样的方法，但是无法准确知道子类如何实现这些方法。

抽象方法的定义：通过abstract关键字来修饰的类称为抽象类；

我的总结：

抽象类用private修饰，里面可以有用private修饰的方法（没有方法体），强制子类进行覆写；

可以理解为：具有某些公共方法的一个总结类。

可以定义被abstract修饰的抽象方法

抽象方法只有返回类型和方法签名，没有方法体。

备注：

抽象类可以含有普通方法

抽象类不能创建实例对象（不能new）

需要子类覆盖掉所有的抽象方法后才可以创建子类对象，否则子类也必须作为抽象类

列举常见的几个抽象类：

流的四个基本父类

InputStream，OutputStream，Reader，Writer

我的总结：

抽象类是类的一种特殊情况:据有类的一切特点,但是不能实例化;一般的都得带有抽象方法。

抽象类不可以实例化，有时看到的近似实例化是多态机制的体现，并不是真正的实例化。

Eg：

Socket s = new Socket();

OutputStream os = s.getOutputStream();

左边是OutputStream类型变量的声明，右边是获取抽象类OutputStream的一个实例对象！

package testDemo2;

abstract class Person{

}

class Student extends Person{

}

public class Demo2 {

public static void main(String[] args) {

Person p = new Student();//体现的是多态，父类声明实例化子类对象。而不是抽象类实例化

}

}

abstract方法

分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是功能声明相同，但功能主体不同。

那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。

abstract [非private访问修饰符] 返回值类型方法名称(参数列表);

抽象方法要存放在抽象类中。

抽象方法也可以存在于接口中

Eg：

package reviewDemo;

abstract class Person3{

abstract void show();

abstract void inof();

void turn(){

}

}

class NewP extends Person3{

@Override

void show() {

}

@Override

void inof() {

}

//不覆写的话会报错

}

public class Demo15 {

public static void main(String[] args) {

//new Person3();报错！因为抽象类不可以实例化

}

}

10、抽象类的体现-模板模式

抽象类是多个具体子类抽象出来的父类,具有高层次的抽象性;以该抽象类作为子类的模板可以避免子类设计的随意性;

抽象类的体现主要就是模板模式设计,抽象类作为多个子类的通用模板,子类在抽象类的基础上进行拓展,但是子类在总体上大致保留抽象类的行为方式;

编写一个抽象父类,该父类提供了多个子类的通用方法,并把一个或多个抽象方法留给子类去实现,这就是模板设计模式;

模板模式应用的简单规则:

1.抽象父类可以只定义需要使用的某些方法,其余留给子类去实现;

2.父类提供的方法只是定义了一个通用算法,其实现必须依赖子类的辅助;

我的总结：

如果父类的方法不想被子类覆写，那么可以在前面加上final关键字修饰。

Eg：

package reviewDemo;

//模板模式

//抽象类中包含很多的抽象方法，子类必须去覆写！

abstract class Method{

abstract double mul();//返回值类型如果是void的话，下面报错，因为没有返回值，无法引用！

abstract double divid();

void show(){

System.out.println("面积是："+mul());//周长

System.out.println("面积是："+divid());//面积

}

}

class Square extends Method{

double d;

public Square(double d) {

super();

this.d = d;

}

@Override

double mul() {

return d * d;

}

@Override

double divid() {

return 4 * d;

}

}

class Cirle extends Method{

double r;

public Cirle(double r) {

super();

this.r = r;

}

@Override

double mul() {

return 2 * 3.14 * r;

}

@Override

double divid() {

return 3.14 * r * r;

}

}

public class Demo16 {

public static void main(String[] args) {

Square s = new Square(5);

s.show();

Cirle c = new Cirle(4);

c.show();

}

}

11、接口(interface)

引入：抽象类是从多个类中抽象出来的模板，若要将这种抽象进行得更彻底，就得用到一种特殊的“抽象类”→ 接口;

例子：

生活中听说过的USB接口其实并不是我们所看到的那些插槽,而是那些插槽所遵循的一种规范;而我们看到的那些插槽是根据USB规范设计出来的实例而已,也就说插槽是USB的实例;

对应不同型号的USB设备而言,他们各自的USB插槽都需要遵循一个规范,遵守这个规范就可以保证插入插槽的设备能与主板正常通信;

对于同一种型号的主板上的多个USB插槽,他们有相同的数据交换方式,相同的实现细节,可认为他们都是同一个类的不同实例

我的总结：

接口只定义了类应当遵循的规范,却不关心这些类的内部数据和其方法内的实现细节.

接口只规定了这些类里必须提供的方法;从而分离了规范和实现.增强了系统的可拓展性和维护性;

使用接口的好处,拓展性,维护性更好,所以我们在开发中会经常用到接口.（相当于定义了一种标准）

接口,类,对象示意图

interface定义

接口定义一种规范,规定一个类必须做什么,但它不管如何具体去做;

[修饰符] interface 接口名 extends 父接口1,父接口2....

没有构造方法,不能实例化;

接口只能继承接口,不能继承类

接口里没有普通方法,方法全是抽象的;

接口里的方法默认修饰符是public abstract；

接口里的字段全是全局常量,默认修饰符是public static final;

接口里的成员包括(主要是前两个)：

全局常量

公共的抽象方法

内部类(包括内部类,内部接口,内部枚举类);

我的总结：

接口没有构造方法，不能实例化！

接口里的方法全部是抽象的，没有普通方法，有默认的修饰符 public abstract，必须全部覆写！

12、接口的使用

格式:public class SubImpl extends Super implements IA,IB

接口可以多继承,但是只能继承接口,不能继承类。

实现接口(支持多实现)

[修饰符] class 类名 implements 接口1，接口2...

接口的实现必须在 extends 之后；

实现接口的方法必须是 public 类型

接口不能创建实例，但是可以声明引用类型的变量。

此时，引用类型的变量必须指向到其实现类对象。

IStudent s = new String();//

IStudent s = new StudentImpl();//

接口与类之间的关系：

实现关系或者说是继承关系.

可以说类实现了接口的方法，也可以说类继承了接口的方法，不同情况下不同的理解！

13、面向接口编程之制定标准和简单工厂模式

制定一个标准，让别人去实现或者说满足它！

Eg：

interface USB{//定义USB标准

void useUSB();//USB有使用USB的行为

}

简单工厂模式

构建一个工厂出来，在里面进行生产，用的时候直接拿

我的总结：

好处:屏蔽不同子类实现的差异，提高代码的可拓展性和可维护性;

package reviewDemo;

//简单工厂模式

interface Phone{//制定标准，都要实现send()方法

public void send();

}

class Iphone implements Phone{

@Override

public void send() {

System.out.println("Iphone手机在发短信");

}

}

class AndroidPhone implements Phone{

@Override

public void send() {

System.out.println("AndroidPhone手机在发短信");

}

}

class MyPhone implements Phone{

@Override

public void send() {

System.out.println("MyPhone手机在发短信");

}

}

class Factory{

public static void show(String type){//传入参数，根据不同的类型个性化定制

if(type.equals("")){//为空的情况，不用往下执行

System.out.println("对不起，类型为空！,请重新输入！");

return;

}

Phone p = null;

if("Iphone".equals(type)){//判断类型

p = new Iphone();

}else if("AndroidPhone".equals(type)){

p = new AndroidPhone();

}else{

p = new MyPhone();

}

p.send();

}

}

public class FactoryDemo17 {

public static void main(String[] args) {

new Factory().show("Iphone");//调用方法

new Factory().show("AndroidPhone");

new Factory().show("MyPhone");

new Factory().show("YourPhone");

new Factory().show("");

}

}

输出：

Iphone手机在发短信

AndroidPhone手机在发短信

MyPhone手机在发短信

MyPhone手机在发短信

对不起，类型为空！

14、面向接口编程之适配器模式

使用一个现成的类，但是它的接口不完全符合你的需求,我只想要它其中的一个方法，不想覆写其他的方法。

比如,窗体有变大,变小,关闭的行为,但是我现在只需要关闭行为;

package reviewDemo;

//适配器模式：只想用其中的某一个方法，用适配器作为中间的过渡

interface Windows{

void max();

void min();

void close();

}

//适配器模式，实现接口所有的方法，但是不写方法体！

class AdapterWindows implements Windows{

@Override

public void max() {

}

@Override

public void min() {

}

@Override

public void close() {

}

}

class MyWindows extends AdapterWindows{

//覆写父类的方法

public void close(){

System.out.println("这个实现的是关闭功能！");

}

}

public class Demo17 {

public static void main(String[] args) {

new MyWindows().close();

}

}

15、接口和抽象类的比较

相同点:

都位于继承的顶端,用于被其他实现或继承;

都不能实例化;

都包含抽象方法,其子类都必须覆写这些抽象方法;

区别:

抽象类为部分方法提供实现,避免子类重复实现这些方法,提供代码重用性;接口只能包含抽象方法;

一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)

二者的选用:

优先选用接口,尽量少用抽象类;

需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;

我的总结：

接口不能有构造函数，抽象类是可以有构造函数的，

abstract可以定义构造函数（包括带函数的构造函数），因为要保证其子类在创建的时候能够进行正确的初始化，但是Abstract类不能被实例化。

知识点：如果不可以或者没有创建对象，那么我们必须加上static修饰，不能用对象调用，就只好用类去调用。

16、匿名内部类

适合只使用一次的类

不能是抽象类，因为系统在创建匿名内部类的时候，会立即创建匿名内部类的对象。

匿名内部类不能定义构造器，因为匿名内部类没有类名。

格式：

new 父类构造器([实参列表]) 或接口()

{

//匿名内部类的类体部分

}

17、枚举类

使用enum声明,默认直接继承了java.lang.Enum类，而不是Object类；

枚举类的对象是固定的,实例个数有限,不可以再new( ),枚举对象后可以跟()。

枚举元素必须位于枚举类体中的最开始部分,枚举元素后要有分号与其他成员分隔。

枚举类的构造方法的权限修饰符默认是private；

一旦枚举对象后面加上{},那么该对象实际是枚举匿名内部类对象;

所有枚举类都提供一个静态的values()方法(返回该枚举类所有对象组成的数组),便于遍历所有枚举对象；

所有枚举类都提供一个静态的valueOf(String name)方法, 返回枚举类中对象名等于 name的对象。

Eg：public enum Color{

RED(), GREEN(){}, BLUE{};

}

package reviewDemo;

//枚举

enum Color{

Green,Blue,Yellow;

@Override

public String toString() {

String ret = super.toString();

switch (this) {

case Green:

ret = "绿色";

break;

case Blue:

ret = "蓝色";

break;

case Yellow:

ret = "黄色";

break;

default:

break;

}

return ret;

}

}

class Personp{

Color c = Color.Blue;

void show(){

System.out.println(c);

}

}

public class Demo18 {

public static void main(String[] args) {

Color []color = Color.values();

for (Color c : color) {

System.out.println(c);

}

new Personp().show();

}

}

输出：

绿色

蓝色

黄色

蓝色

枚举类覆写接口抽象方法的两种方式：

在枚举类中实现接口的抽象方法；

在枚举匿名内部类中实现接口的抽象方法；

interface I{

void show();

}

enum Color implements I{

RED(){

public void show(){

}

}, GREEN{

public void show(){

}

}, BLUE{

public void show(){

}

};

}

enum Color implements I{

RED(), GREEN, BLUE;

public void show() {

}

}

我的总结：

枚举不可以new();即便是反射也不可以！

备注：一个类如果没有构造方法，那么一定有相对应的某个方法可以获取对象！

五、黑马程序员—异常处理和常用类
第五篇

1、异常
异常：就是不正常，是指程序在运行时出现的不正常情况。其实就是程序中出现的问题。这个问题按照面向对象思想进行描述，并封装成了对象。因为问题的产生有产生的原因、有问题的名称、有问题的描述等多个属性信息存在。当出现多属性信息最方便的方式就是将这些信息进行封装。异常就是java按照面向对象的思想将问题进行对象封装。这样就方便于操作问题以及处理问题。

出现的问题有很多种，比如角标越界，空指针等都是。就对这些问题进行分类。而且这些问题都有共性内容比如：每一个问题都有名称，同时还有问题描述的信息，问题出现的位置，所以可以不断的向上抽取。形成了异常体系。

异常的体系 Throwable

Error

通常指JVM出现重大问题如：运行的类不存在或者内存溢出等。

不需要编写针对代码对其处理，程序无法处理。

Exception

在运行时运行出现的一些情况，可以通过try,catch,finally处理

异常处理两种方式：

1、捕获异常：try catch 直接处理可能出现的异常！

2、声明异常：throws 声明告诉调用者可能的异常，暴露问题，调用者自己处理！

我的总结：

Exception 和 Error的子类名大都是以父类名作为后缀。

Java异常其实是对不正常情况的一种描述,并将其封装成对象;

Java在设计异常体系时，将容易出现的异常情况都封装成了对象。

2、异常处理格式

异常处理的5个关键字

try ,catch,

finally

throw, throws

我的总结：

捕获异常：先捕获小异常再捕获大异常。

程序是调出来的，不是写出来的；多测试是程序员的必修课。

异常处理后，程序不会因为出现异常而退出!

异常处理格式

try{

//可能出异常的代码

} catch(异常类对象){

//处理该异常类型的语句

}

[finally] {

//一定会执行的代码

//catch块使用System.exit(1);除外

}

备注：当try语句块出现异常，程序会自动跳到catch语句块去找匹配的异常类型，并执行异常处理语句，finally语句块是异常的统一出口。

3、多异常处理
声明异常时尽可能声明具体异常类型,方便更好的处理;

方法声明几个异常就对应有几个catch块;

若多个catch块中的异常出现继承关系,父类异常catch块放在最后;

在catch语句块使用Exception类作为异常类型时：

所有子类实例都可以使用父类接收(向上转型)，即所有的异常对象都可以使用Exception接收;

注：在java处理多异常时捕获小范围的异常必须放在大范围异常之前。

java7 - 同时捕获多个异常类型

Java7之前：

try {

int a = Integer.parseInt("1");

int b = Integer.parseInt("0");

int c = a / b;

System.out.println(c);

} catch (NumberFormatException e)

{

e.printStackTrace();

} catch(ArithmeticException e)

{

e.printStackTrace();

}

Java7：将多个异常写到了同一个catch代码块

try {

Integer a = Integer.parseInt("1");

Integer b = Integer.parseInt("0");

Integer c = a / b;

System.out.println(c);

} catch (NumberFormatException

| ArithmeticException e ) {

e.printStackTrace();

}

4、异常的分类

异常分类:

编译时被检查异常; ---> Checked异常

在程序中必须使用try...catch处理；

编译时不被检测的异常; ---> Runtime异常

可以不使用try...catch处理，但一旦出现异常就将由JVM处理。

异常的分类之Runtime异常

RuntimeException(运行时异常)是指因设计或实现方式不当而导致的问题.

说白了,就是程序员造成的,程序员小心谨慎是完全可以避免的异常.比如,事先判断对象是否为null就可以避免NullPointerException异常,事先检查除数不为0就可以避免ArithmeticException异常;

特点:

这种异常Java编译器不会检查它,也就说程序中出现这类异常的时候,即使不处理也没有问题,但是一旦出现异常,程序将异常终止,若采用异常处理,则会被相应的程序执行处理.

异常的分类之Checked异常

除了RuntimeException以及子类,其他的Exception及其子类都是受检查异常,我们也可以称为非RuntimeException异常.

特点:

Java编译器会检查它,也就说程序中一旦出现这类异常,要么是没有try-catch语句捕获,或throws语句没有声明抛出它,编译就不会通过,也就说这种异常,程序要求必须处理.

5、声明异常（throws）

在可能出现异常的方法上声明抛出可能出现异常的类型：

声明的时候尽可能声明具体的异常,方便更好的处理.

当前方法不知道如何处理这种异常，可将该异常交给上一级调用者来处理(非RuntimeException类型的异常)。

方法一旦使用throws声明抛出方法内可能出现的异常类型，该方法就可以不再过问该异常了；

一个方法调用另一个使用throws声明抛出的方法，自己要么try...catch , 要么也throws;

格式：

public 返回值类型方法名(参数列表...)

throws 异常类A,异常类B... {

}

6、throw
自行抛出一个异常对象，抛出异常类的对象；

若throw抛出的是Runtime异常：

程序可以显示使用try...catch来捕获并处理，也可以不管，直接交给方法调用者处理；

若throw抛出Checked异常：

要么放在try里自己处理，要么放在一个throws声明的方法里面，交给调用者处理。

Eg：

public static void main(String[] args) {

try {

fn1(1);

} catch (Exception e) { e.printStackTrace(); }

fn2(2);

}

public static void fn1(int a) throws Exception{

if(a >0) { throw new Exception("fn1 -- a值不合法"); }

}

public static void fn2(int a) {

if(a >0) { throw new RuntimeException("a值不合法"); }

}

throws & throw

throws用于在方法上声明该方法不需要处理的异常类型。

throw用于抛出具体异常类的对象。

throws与throw的区别：

thorws用在方法上，后面跟异常类名,可以是多个异常类。

throw用在方法内，后面跟异常对象,只能是一个。

7、finally

异常的统一出口：

不管try块程序是否异常，也不管哪个catch执行，finally块总会执行。

try语句块或会执行的catch语句块使用了JVM系统退出语句例外;//System.exit(1);

try块必须和 catch块或和finally同在，不能单独存在，二者必须出现一个。

不要在finally中使用return 或throw语句，否则将会导致try、catch中的return或throw失效。

我的总结：finally代码块只在一种情况下不执行：System.exit(0)；

Eg：

package reviewDemo;

public class Demo19 {

public static void main(String[] args) {

try{

System.out.println(17/0);

}catch(Exception e){

//e.printStackTrace();

System.out.println("程序错误，请修正！");

}finally{

System.out.println("这是finally代码块！");

}

}

}

输出：

程序错误，请修正！

这是finally代码块！

8、throw和catch同时使用

当异常出现在当前方法中,程序只对异常进行部分处理,还有一些处理需要在方法的调用者中才能处理完成,此时还应该再次抛出异常,这样就可以让方法的调用者也能捕获到异常;

Eg：

public static void buy(String price) throws Exception {

try {

if(price != null)

Double.parseDouble(price);

} catch (Exception e) {

e.printStackTrace();

throw new Exception("价格不能只能是数字组成");

}

}

public static void main(String[] args) {

try {

buy(null);

} catch (Exception e) {

System.out.println(e.getMessage());

}

}

9、常用类
String

String表示字符串,所谓字符串,就是一连串的字符;

String是不可变类，一旦String对象被创建，包含在对象中的字符序列(内容)是不可变的，直到对象被销毁；

常量池:JVM中一块独立的区域存放字符串常量和基本类型常量（public static final）。

String使用private final char value[]来实现字符串的存储,也就是说String对象创建之后,就不能再修改此对象中存储的字符串内容,就是因为如此,才说String类型是不可变的.

String对象比较:

单独使用""引号创建的字符串都是常量,编译期就已经确定存储到常量池中；

使用new String("")创建的对象会存储到堆内存中,是运行期新创建的；

使用只包含常量的字符串连接符如"aa" + "bb"创建的也是常量,编译期就能确定,已经确定存储到常量池中；

使用包含变量的字符串连接符如"aa" + s1创建的对象是运行期才创建的,存储在堆中；

Eg：

package string;

public class StringDemo {

public static void main(String[] args) {

/*

* "" 其实表示的是 String的匿名对象

*/

String s = "";

/**

* String() 初始化一个新创建的 String 对象，使其表示一个空字符序列。

* "",不是表示 null

* String(String original)

* String s = new String("asd");// s 的值就是 asd

*/

s = new String();//""

String s1 = new String("11");

String s2 = new String("11");

System.out.println(s1 == s2);//false

String s3 = "22";

String s4 = "22";

System.out.println(s3 == s4);//true

System.out.println(s3 == s2);//false

String s5 = "2" + "2";//这句话其实在编译器编译后的class文件中已经变成 "22"

//s5创建了几个对象?//回答：最多一个，如果常量池里面没有就是创建一个，如果常量池里本来就有就是创建零个！下面的str一样的道理。

String str = "A" +"B"+ "C" +"D" +"E";//String str = "ABCDE";

System.out.println(s3 == s5);//true

/**

* String特点: 不可变的, 一个String对象的内容不能变,一旦内容变量该对象就变成一个新的String对象了

* String str = "AAA";

* str = str+"12";

*/

String str1 = "ABCDE";

System.out.println(str == str1);//true

String str2 = "ABC" + "DE";

System.out.println(str == str2);//true

String ss = "AB";

String str3 = ss + "CDE";//这里的str3在运行期才能确定内容值

System.out.println(str3 == str2);//false

String str4 = getStr() +"CDE";//在运行期才能确定 str4的值

System.out.println(str == str4);//false

System.out.println(str3 == str4);//false

/*

* String s = "cd"; //一个String对象

s = s + "itcast"; //itcast也是String对象, 最后的s的值cditcast,也是一个String对象

System.out.print(s);

* */

}

public static String getStr(){

return "AB";

}

}

Eg:

package reviewDemo;

public class Demo20 {

public static void main(String[] args) {

//s1,s2只新建了一个对象

String s1 = "你好";

String s2 = "你好";

//s3,s4新建了两个对象

String s3 = "你好";

String s4 = "你好";

}

}

10、String方法

String():初始化一个新的 String 对象，使其表示一个空字符序列，并不是返回空(不等于 null)。

String(StringBuffer buffer):根据StringBuffer对象来创建String对象；

String(StringBuilder builder):同上

char charAt(int index):取字符串中指定位置的字符，index从0开始计算。

String concat(String str):连接字符串，等同于 “+”；

boolean contentEquals(StringBuffer buffer):若二者包含的字符序列相同时就返回true;

boolean equals(Object obj):将该字符串与指定对象比较，若二者包含的字符序列相等返回true；

boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写;

byte[] getBytes():将该字符串转换成byte数组；

int indexOf(String str):找出str字符串在该字符串中第一次出现的位置；

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

int lastIndexOf(String str) 返回指定子字符串在此字符串中最后一次出现处的索引;

int length():返回当前字符串长度；

String replace(char oldChar, char newChar) :返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。

String replaceAll(String regex, String replacement) 使用给定的字符串replacement 替换此字符串所有的regex字符串;

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

String[] split(String regex)：把字符串按指定的字符串分隔开。

String substring(int beginIndex) 返回一个新的字符串，从beginIndex开始截取，它是此字符串的一个子字符串;

String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串;[begin,end)

char[] toCharArray() 将此字符串转换为一个新的字符数组。

String toLowerCase() 将此 String 中的所有字符都转换为小写;

String toUpperCase()转成大写;

static String valueOf(基本类型 obj):把基本类型值转成字符串;

String trim() ：忽略字符串前导空白和尾部空白。

String小练习

判断字符串是否由数字组成：

package reviewDemo;

public class Demo20 {

public static void main(String[] args) {

String s1 = "123456789";

String s2 = "12345 6789";

System.out.print(isnum(s1));

System.out.print(isnum(s2));

}

public static boolean isnum(String s){

char []ch = s.toCharArray();

for (char c : ch) {

if(!(c > '0' && c <= '9')){

return false;

}

}

return true;

}

}

输出：

true

false

判断字符串是否为空：

分析：

字符串的空有两种情况：1、null；2、"";

package reviewDemo;

public class Demo21 {

public static void main(String[] args) {

String s1 = "";

System.out.println(isimpty(s1));

}

public static String isimpty(String s){

if(s != null & !"".equals(s)){

return "不为空";

}

return "为空！";

}

}

11、StringBuffer 与 StringBuilder
String是不可变类，一旦String对象被创建，包含在对象中的字符序列是不可变的，直到对象被销毁；

StringBuffer 与 StringBuilder对象则是可变的！

举例说明这两个的好处：（不用每次新建对象，效率高！）

package reviewDemo;

public class Demo22 {

public static void main(String[] args) {

String s = "";

long begintime = System.currentTimeMillis();

for(int i = 1;i <= 100000;i++){

s += i;

}

long endtime = System.currentTimeMillis();

long time = endtime - begintime;

System.out.println("运行时间为："+time);

StringBuffer s1 = new StringBuffer();

s = "";

begintime = System.currentTimeMillis();

for(int i = 1;i <= 100000;i++){

s = ""+i;

s1 = new StringBuffer(s);

}

endtime = System.currentTimeMillis();

time = endtime - begintime;

System.out.println("运行时间为："+time);

}

}

输出：

运行时间为：82922

运行时间为：15

可以看得出：StringBuffer这两个效率相当高！

StringBuffer：是线程安全的；

StringBuilder：是线程不安全的，性能高点，推荐使StringBuilder；(jdk1.5出现)

StringBuffer的字符序列是可变的(通过append等方法操作)

StringBuffer 和 String之间的转换；

String toString() 返回此序列中数据的字符串表示形式。

StringBuffer(String str):以指定的字符串创建StringBuffer对象。

StringBuffer方法

public StringBuilder()构造一个不带任何字符的StringBuilder对象。

StringBuffer(String str) ：构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

StringBuffer append(Object o) ：将指定的任意类型对象追加到此StringBuffer 对象。

StringBuffer insert(int offset, Object o) :将任意类型参数的字符串表示形式插入此序列中。

StringBuffer delete(int start, int end) :移除此序列的子字符串中的字符。

StringBuffer deleteCharAt(int index): 移除此序列指定位置的 char。

Eg：

package reviewDemo;

/**

* 用StringBuilder 或StringBuffer:

把字符串“ABCDE”;

转变成字符串“A,B,C,D”

*/

public class Demo23 {

public static void main(String[] args) {

//第一种方法：往里面插入；

StringBuilder sb = new StringBuilder("ABCDE");

sb.deleteCharAt(sb.length()-1);

System.out.println(sb);

for (int i = 0; i < sb.length(); i+=2) {

sb.insert(i, ",");

}

sb.deleteCharAt(0);

System.out.println(sb);

//第二种方法：往里面追加，要追加必须遍历，必须换为数组！

sb = new StringBuilder("ABCDE");

sb.deleteCharAt(sb.length()-1);

System.out.println(sb);

char []cs = sb.toString().toCharArray();

StringBuilder sb1 = new StringBuilder();

for (char c : cs) {

sb1.append(c).append(",");

}

sb1.deleteCharAt(sb1.length()-1);

System.out.println(sb1);

}

}

编写一个程序，这个程序把一个整数数组中的每个元素用逗号连接成一个字符串，例如，根据内容为{1，2，3}的数组形成内容为"1,2,3"的字符串。

package reviewDemo;

/**

* 编写一个程序，

* 这个程序把一个整数数组中的每个元素用逗号连接成一个字符串，

* 例如，根据内容为{1，2，3}的数组形成内容为"1,2,3"的字符串。

*/

public class Demo24 {

public static void main(String[] args) {

int []i = {1,2,3,4,5};

StringBuilder sb = new StringBuilder();

for (int j : i) {

sb.append(j).append(",");

}

sb.deleteCharAt(sb.length()-1);

System.out.println(sb);

}

}

12、Math和Random和UUID

Math类

public final class Math extends Object

以下X表示double,float,int, long

abs(X x):求绝对值

max(X x1,X x2):求最大值

min(X x1,X x2)：求最小值

public static double random()：返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。和使用new java.util.Random一样

Math.PI;

Random类

负责生成伪随机数；

Random() 创建一个新的随机数生成器。

int nextInt() 返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。

int nextInt(int n) 返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值n（不包括）之间均匀分布的 int 值。

package reviewDemo;

public class Demo26 {

public static void main(String[] args) {

System.out.println(Math.E);//2.718281828459045

int a = 12;

int b = 25;

System.out.println(Math.max(a,b));//这里可以使用静态导入（导入Math类中的方法，这样的话前面就不用写上Math.）

System.out.println(Math.min(a,b));

}

}

package reviewDemo;

import java.util.UUID;

public class Demo27 {

public static void main(String[] args) {

UUID u = UUID.randomUUID();

String s = u.toString();

System.out.println(s);//此时是随机生成的，肯定每次都不一样，全网唯一！

u = new UUID(1222222222, 12);//根据构造方法来

s = u.toString();

System.out.println(s);//这一个的UUID是固定的。

}

}

我的总结：UUID（用来标示文件名等（免得文件上传因为名字可能一样而被覆盖），可以保证全网唯一！）

UUID类:用唯一标识符 (UUID) 的类。 UUID 表示一个 128 位的值。

UUID(Universally Unique Identifier)全局唯一标识符,是指在一台机器上生成的数字，它保证对在同一时空中的所有机器都是唯一的。按照开放软件基金会(OSF)制定的标准计算，用到了以太网卡地址、纳秒级时间、芯片ID码和许多可能的数字。由以下几部分的组合：当前日期和时间(UUID的第一个部分与时间有关，如果你在生成一个UUID之后，过几秒又生成一个UUID，则第一个部分不同，其余相同)，时钟序列，全局唯一的IEEE机器识别号（如果有网卡，从网卡获得，没有网卡以其他方式获得），UUID的唯一缺陷在于生成的结果串会比较长。

标准的UUID格式为：xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx (8-4-4-4-12),其中每个 x 是 0-9 或 a-f 范围内的一个十六进制的数字;

UUID uuid = UUID.randomUUID();

String uid = uuid.toString();

13、Date和Calendar

处理日期，时间；

大部分的方法已过时，不推荐使用，但是你使用过时的方法也不会报错。

Date() 分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。

Date(long date) 分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。

SimpleDateFormat

java.text.SimpleDateFormat

SimpleDateFormat 是一个与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。

SimpleDateFormat(String pattern) 用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。

public final String format(Date date)将一个 Date 格式化为日期/时间字符串。

public Date parse(String source) throws ParseException：把字符串source表示的时间按source的格式转成Date对象。

练习：String与Date的相互转化

按某种时间格式来输出指定的String类型时间

date2String

format

把某种时间格式的String时间转成Date类型时间

string2Date

parse

package reviewDemo;

import java.text.SimpleDateFormat;

import java.util.Date;

public class Demo28 {

public static void main(String[] args) throws Exception {

Date d = new Date();

System.out.println(d);//获取当前时间

//格式化

SimpleDateFormat sd = new SimpleDateFormat("yyyy-M-d HH:mm:ss E");

String s = sd.format(d);//这个方法继承于SimpleDateFormat的父类DateFormat类！

System.out.println(s);

//反格式化

d = sd.parse(s);

System.out.println(d);

}

}

Calendar

推荐使用处理日期和时间的类Calendar;

是抽象类，不能实例化，通过

static Calendar getInstance() 获得一个Calendar对象。

int get(int field):返回指定日历字段值

静态常量：

YEAR 表示年的字段数字。

MONTH 表示月份字段数字,月份范围是[0,11]。

DATE 表示一个月中的某天。

DAY_OF_MONTH 表示一个月中的某天。

DAY_OF_WEEK 表示一个星期中的某天。

HOUR_OF_DAY / HOUR 表示第几小时

MINUTE 表示第几分钟

SECOND 表示第几秒

Date getTime() 返回一个表示此 Calendar 时间值的 Date 对象。

void set(int year, int month, int date, int hour, int minute, int second) 设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值。

abstract void add(int field, int amount) 根据日历的规则，为给定的日历字段添加或减去指定的时间量。

若 amount为负数，则减去一天，

若 amount为正数，则加上一天

例子

package reviewDemo;

import java.util.Calendar;

import java.util.Date;

public class Demo29 {

public static void main(String[] args) {

Calendar c = Calendar.getInstance();

System.out.println(c);

Date d = c.getTime();

System.out.println(d);

/**

* void set(int year, int month, int date, int hour, int minute, int second)

* 设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值。

*/

c.set(2015, 07, 15, 12, 24, 55);

d = c.getTime();

System.out.println(d);

c.add(Calendar.DAY_OF_MONTH, 3);

d = c.getTime();

System.out.println(d);

}

}

我的总结：注意常查看api！

Eg：“查询距今最近三天内的记录”，这里的‘三天内’是什么时间段？

将当前日期时间转换为只获取当天的00:00:00

如: 2011-08-08 12:12:12 转化为 2011-08-08 00:00:00、

package reviewDemo;

import java.text.SimpleDateFormat;

import java.util.Calendar;

import java.util.Date;

public class Demo30 {

public static void main(String[] args) {

Calendar c = Calendar.getInstance();

Date d = c.getTime();

System.out.println(d);

SimpleDateFormat sd = new SimpleDateFormat("yyyy-M-d HH:mm:ss E");

String s = sd.format(d);

System.out.println(s);

c.set(2015, 8, 23, 13, 24, 15);

d = c.getTime();

System.out.println(sd.format(d));

c.add(Calendar.DAY_OF_MONTH, -3);

d = c.getTime();

System.out.println(sd.format(d));

}

}

输出：

Thu Jul 04 08:56:51 CST 2013

2013-7-4 08:56:51 星期四

2015-9-23 13:24:15 星期三

2015-9-20 13:24:15 星期日

14、System

System 类包含一些与系统相关的类字段和方法。它不能被实例化，类中所有属性和方法都是static,可直接被System调用。

常用方法：

static void exit(int status) 终止虚拟机的运行.对于发生了异常情况而想终止虚拟机的运行,传递一个非0数值,对于正常情况下退出系统传递0值;

该方法实际调用的是Runtime.getRuntime().exit(int status)；

static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 数组拷贝

static long currentTimeMillis() 返回以毫秒为单位的当前时间。

String getenv(String name) 获得指定的环境变量;

static void gc() 运行垃圾回收器。

实际上调用了 Runtime中的gc()方法;

Runtime.getRuntime().exec("notepad ");

static Properties getProperties() 取得当前的系统属性。

static String getProperty(String key) 取得指定键指示的系统属性。

static String getProperty(String key, String def) 获取用指定键描述的系统属性,def表示默认信息。

Eg：package reviewDemo627;

import java.util.Properties;

public class Demo32 {

public static void main(String[] args) {

Properties p = System.getProperties();

System.out.println(p);

System.out.println(System.getenv());

}

}

六、黑马程序员—线程技术
第六篇

1、进程和线程
进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以有多个线程。比如在Windows系统中，一个运行的xx.exe就是一个进程。

Java程序的进程里有几个线程:主线程, 垃圾回收线程(后台线程)

线程是指进程中的一个执行任务(控制单元)，一个进程中可以运行多个线程,多个线程可共享数据。

多进程:操作系统中同时运行的多个程序;

多线程:在同一个进程中同时运行的多个任务;

一个进程至少有一个线程，为了提高效率，可以在一个进程中开启多个控制单元。

并发运行。如：多线程下载软件。

可以完成同时运行，但是通过程序运行的结果发现，虽然同时运行，但是每一次结果都不一致。

因为多线程存在一个特性：随机性。

造成的原因：CPU在瞬间不断切换去处理各个线程而导致的。

可以理解成多个线程在抢cpu资源。

我的总结：

多线程下载:此时线程可以理解为下载的通道，一个线程就是一个文件的下载通道，多线程也就是同时开起好几个下载通道.当服务器提供下载服务时，使用下载者是共享带宽的，在优先级相同的情况下，总服务器会对总下载线程进行平均分配。不难理解，如果你线程多的话，那下载的越快。现流行的下载软件都支持多线程。

多线程是为了同步完成多项任务,不是为了提供运行效率,通过提高资源使用效率来提高系统的效率.

线程是在同一时间需要完成多项任务的时候实现的.

线程与进程的比较

线程具有许多传统进程所具有的特征，故又称为轻型进程(Light—Weight Process)或进程元；而把传统的进程称为重型进程(Heavy—Weight Process)，它相当于只有一个线程的任务。在引入了线程的操作系统中，通常一个进程都有若干个线程，至少需要一个线程。

进程与线程的区别：

1.进程有独立的进程空间，进程中的数据存放空间（堆空间和栈空间）是独立的。

2.线程的堆空间是共享的，栈空间是独立的，线程消耗的资源也比进程小，相互之间可以影响的。

2、创建线程方式
1、继承Thread类

子类覆写父类中的run方法，将线程运行的代码存放在run中。

建立子类对象的同时线程也被创建。

通过调用start方法开启线程。

2、实现Runnable接口

子类覆盖接口中的run方法。

通过Thread类创建线程，并将实现了Runnable接口的子类对象作为参数传递给Thread类的构造函数。

Thread类对象调用start方法开启线程。

可使用匿名内部类来写

Eg：

package july7;

//线程的两种方法

class MyThread extends Thread{

private String name;

public MyThread(String name) {

super();

this.name = name;

}

public void run(){

System.out.println(name+"启动！");

}

}

class YourThread implements Runnable{

private String name;

public YourThread(String name) {

this.name = name;

}

@Override

public void run() {

for (int i = 0; i < 3; i++) {

System.out.println(Thread.currentThread().getName()+"第"+i+"次启动！");

}

}

}

public class Demo1 {

public static void main(String[] args) {

for (int i = 0; i < 100; i++) {

if(i == 50){

new MyThread("刘昭").start();

new Thread(new YourThread(""),"章泽天").start();

}

}

}

}

我的总结：

Thread类中run()和start()方法的区别如下：
run()方法:在本线程内调用该Runnable对象的run()方法，可以重复多次调用；
start()方法:启动一个线程，调用该Runnable对象的run()方法，不能多次启动一个

线程；

3、两种进程创建方式比较
A extends Thread：

简单

不能再继承其他类了(Java单继承)

同份资源不共享

A implements Runnable:(推荐)

多个线程共享一个目标资源，适合多线程处理同一份资源。

该类还可以继承其他类，也可以实现其他接口。

我的总结：

实现方式，因为避免了单继承的局限性，所以创建线程建议使用第二种方式。

Eg：

package july7;

//线程卖票的例子

class SellTicket extends Thread{

private String name;

private int num = 50;

public SellTicket(String name) {

super();

this.name = name;

}

public void run(){

for (int i = 1; i <= num; i++) {

System.out.println(name+"卖出了第"+i+"张票！");

}

}

}

class MySell implements Runnable{

private int num = 50;

@Override

public void run() {

for (int i = 1; i <= num; i++) {

System.out.println(Thread.currentThread().getName()+"卖出了第"+i+"张票！");

}

}

}

public class Demo2 {

public static void main(String[] args) throws Exception {

new SellTicket("A").start();

new SellTicket("B").start();

new SellTicket("C").start();

new Thread(new MySell(),"D").start();

new Thread(new MySell(),"E").start();

new Thread(new MySell(),"F").start();

for (int i = 10; i > 0; i--) {

System.out.println(i);

Thread.sleep(1000);

}

}

}

我的总结：

为什么要覆盖run方法呢？

Thread类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法.

也就是说Thread类中的run方法，用于存储线程要运行的代码。

4、线程的生命周期
Thread类内部有个public的枚举Thread.State，里边将线程的状态分为：
NEW-------新建状态，至今尚未启动的线程处于这种状态。
RUNNABLE-------运行状态，正在 Java 虚拟机中执行的线程处于这种状态。
BLOCKED-------阻塞状态，受阻塞并等待某个监视器锁的线程处于这种状态。
WAITING-------冻结状态，无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。
TIMED_WAITING-------等待状态，等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。
TERMINATED-------已退出的线程处于这种状态。

我的总结：

如何停止线程？

只有一种，run方法结束。开启多线程运行，运行代码通常是循环结构。只要控制住循环，就可以让run方法结束，也就是线程结束。

5、控制线程

join方法：调用join方法的线程对象强制运行，该线程强制运行期间，其他线程无法运行，必须等到该线程结束后其他线程才可以运行。

有人也把这种方式成为联合线程

join方法的重载方法:

join(long millis):

join(long millis,int nanos):

通常很少使用第三个方法:

程序无须精确到一纳秒;

计算机硬件和操作系统也无法精确到一纳秒;

Eg：

package july7;

class MyThreadDemo implements Runnable{

@Override

public void run() {

for (int i = 0; i < 50; i++) {

System.out.println(Thread.currentThread().getName()+"正在运行！"+i);

if(i == 25){

try {

new Thread(new MyThreadDemo(),"刘昭").join();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

}

public class DemoRe10 {

public static void main(String[] args) {

new Thread(new MyThreadDemo(),"刘昭").start();

new Thread(new MyThreadDemo(),"章泽天").start();

}

}

Daemon

后台线程：处于后台运行，任务是为其他线程提供服务。也称为“守护线程”或“精灵线程”。JVM的垃圾回收就是典型的后台线程。

特点：若所有的前台线程都死亡，后台线程自动死亡。

设置后台线程：Thread对象setDaemon(true);

setDaemon(true)必须在start()调用前。否则出现IllegalThreadStateException异常；

前台线程创建的线程默认是前台线程;

判断是否是后台线程：使用Thread对象的isDaemon()方法；

并且当且仅当创建线程是后台线程时，新线程才是后台线程。

sleep

线程休眠:

让执行的线程暂停一段时间，进入阻塞状态。

sleep(long milllis) throws InterruptedException：毫秒

sleep(long millis,int nanos)

throws InterruptedException:毫秒，纳秒

调用sleep()后，在指定时间段之内，该线程不会获得执行的机会。

控制线程之优先级

每个线程都有优先级，优先级的高低只和线程获得执行机会的次数多少有关。

并非线程优先级越高的就一定先执行，哪个线程的先运行取决于CPU的调度;

默认情况下main线程具有普通的优先级，而它创建的线程也具有普通优先级。

Thread对象的setPriority(int x)和getPriority()来设置和获得优先级。

MAX_PRIORITY : 值是10

MIN_PRIORITY : 值是1

NORM_PRIORITY : 值是5(主方法默认优先级)

yield

线程礼让:

暂停当前正在执行的线程对象，并执行其他线程；

Thread的静态方法，可以是当前线程暂停，但是不会阻塞该线程，而是进入就绪状态。所以完全有可能：某个线程调用了yield()之后，线程调度器又把他调度出来重新执行。

我的总结：用到时查询api！

6、多线程安全问题

导致安全问题的出现的原因：

多个线程访问出现延迟。

线程随机性。

注：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。

我们可以通过Thread.sleep(long time)方法来简单模拟延迟情况。

我的总结：

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

解决办法：

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

Eg：在前面的卖票例子上，在每卖票的前面加上模拟延时的语句！

package july7;

class SellDemo implements Runnable{

private int num = 50;

@Override

public void run() {

for (int i = 0; i < 200; i++) {

if(num > 0){

try {

//因为它不可以直接调用getName()方法，所以必须要获取当前线程。

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+"卖出第"+num--+"张票！");

}

}

}

}

public class Demo3 {

public static void main(String[] args) {

SellDemo s = new SellDemo();

new Thread(s,"A").start();

new Thread(s,"B").start();

new Thread(s,"C").start();

}

}

输出：这样的话，会出现买了第0，甚至-1张票的情况！

7、多线程安全问题的解决方法

三种方法：

同步代码块：

synchronized(obj)

{

//obj表示同步监视器,是同一个同步对象

/**.....

TODO SOMETHING

*/

}

同步方法

格式：

在方法上加上synchronized修饰符即可。（一般不直接在run方法上加！）

synchronized 返回值类型方法名(参数列表)

{

/**.....

TODO SOMETHING

*/

}

同步方法的同步监听器其实的是 this

静态方法的同步

同步方法

同步代码块

static不能和 this连用

静态方法的默认同步锁是当前方法所在类的.class对象

同步锁

jkd1.5后的另一种同步机制：

通过显示定义同步锁对象来实现同步，这种机制，同步锁应该使用Lock对象充当。

在实现线程安全控制中，通常使用ReentrantLock(可重入锁)。使用该对象可以显示地加锁和解锁。

具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。

public class X {

private final ReentrantLock lock = new ReentrantLock();

//定义需要保证线程安全的方法

public void m(){

//加锁

lock.lock();

try{

//... method body

}finally{

//在finally释放锁

lock.unlock();

}

}

}

修改后的例子：

//同步代码块

package july7;

class SellDemo implements Runnable{

private int num = 50;

@Override

public void run() {

for (int i = 0; i < 200; i++) {

synchronized (this) {

if(num > 0){

try {

//因为它不可以直接调用getName()方法，所以必须要获取当前线程。

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+"卖出第"+num--+"张票！");

}

}

}

}

}

public class Demo3 {

public static void main(String[] args) {

SellDemo s = new SellDemo();

new Thread(s,"A").start();

new Thread(s,"B").start();

new Thread(s,"C").start();

}

}

//同步方法

package july7;

//同步方法

class FinalDemo1 implements Runnable {

private int num = 50;

@Override

public void run() {

for (int i = 0; i < 100; i++) {

gen();

}

}

public synchronized void gen() {

for (int i = 0; i < 100; i++) {

if (num > 0) {

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "卖出了第"

+ num-- + "张票！");

}

}

}

}

public class Demo6 {

public static void main(String[] args) {

FinalDemo1 f = new FinalDemo1();

new Thread(f, "A").start();

new Thread(f, "B").start();

new Thread(f, "C").start();

}

}

//线程同步锁

package july7;

import java.util.concurrent.locks.ReentrantLock;

//同步锁

class FinalDemo2 implements Runnable {

private int num = 50;

private final ReentrantLock lock = new ReentrantLock();

@Override

public void run() {

for (int i = 0; i < 100; i++) {

gen();

}

}

public void gen() {

lock.lock();

try{

//for (int i = 0; i < 100; i++) {

if (num > 0) {

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "卖出了第"

+ num-- + "张票！");

}

//}

}finally{

lock.unlock();

}

}

}

public class Demo7 {

public static void main(String[] args) {

FinalDemo2 f = new FinalDemo2();

new Thread(f, "A").start();

new Thread(f, "B").start();

new Thread(f, "C").start();

}

}

8、线程通信

有一个数据存储空间,划分为两部分,一部分用于存储人的姓名,另一部分用于存储人的性别;

我们的应用包含两个线程,一个线程不停向数据存储空间添加数据(生产者),另一个线程从数据空间取出数据(消费者);

因为线程的不确定性，存在于以下两种情况：

若生产者线程刚向存储空间添加了人的姓名还没添加人的性别，CPU就切换到了消费者线程，消费者线程把姓名和上一个人的性别联系到一起；

生产者放了若干数据，消费者才开始取数据，或者是消费者取完一个数据，还没等到生产者放入新的数据，又重复的取出已取过的数据；

生产者和消费者

wait():让当前线程放弃监视器进入等待，直到其他线程调用同一个监视器并调用notify()或notifyAll()为止。

notify():唤醒在同一对象监听器中调用wait方法的第一个线程。

notifyAll():唤醒在同一对象监听器中调用wait方法的所有线程。

这三个方法只能让同步监听器调用:

在同步方法中: 谁调用

在同步代码块中: 谁调用

wait()、notify()、notifyAll()，这三个方法属于Object 不属于 Thread，这三个方法必须由同步监视对象来调用，两种情况：

1.synchronized修饰的方法，因为该类的默认实例(this)就是同步监视器，所以可以在同步方法中调用这三个方法;

2.synchronized修饰的同步代码块，同步监视器是括号里的对象，所以必须使用该对象调用这三个方法;

可要是我们使用的是Lock对象来保证同步的,系统中不存在隐式的同步监视器对象,那么就不能使用者三个方法了,那该咋办呢?

此时,Lock代替了同步方法或同步代码块,Condition代替了同步监视器的功能;

Condition对象通过Lock对象的newCondition()方法创建;

里面方法包括:

await(): 等价于同步监听器的wait()方法;

signal(): 等价于同步监听器的notify()方法;

signalAll(): 等价于同步监听器的notifyAll()方法;

例子：设置属性

容易出现的问题是：

名字和性别不对应！

线程通信，很好！

package july7;

class Person{

private String name;

private String sex;

private Boolean isimpty = Boolean.TRUE;//内存区为空！

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getSex() {

return sex;

}

public void setSex(String sex) {

this.sex = sex;

}

public void set(String name,String sex){

synchronized (this) {

while(!isimpty.equals(Boolean.TRUE)){//不为空的话等待消费者消费！

try {

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

this.name = name;//为空的话生产者创造！

this.sex = sex;

isimpty = Boolean.FALSE;//创造结束后修改属性！

this.notifyAll();

}

}

public void get(){

synchronized (this) {

while(!isimpty.equals(Boolean.FALSE)){

try {

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

System.out.println("姓名"+getName()+ ", "+"性别"+getSex());

isimpty = Boolean.TRUE;

this.notifyAll();

}

}

}

class Producer implements Runnable{

private Person p;

public Producer(Person p) {

super();

this.p = p;

}

@Override

public void run() {

for (int i = 0; i < 100; i++) {

if( i % 2 == 0){

p.set("刘昭", "男");

}else{

p.set("章泽天", "女");

}

}

}

}

class Consumer implements Runnable{

private Person p;

public Consumer(Person p) {

super();

this.p = p;

}

@Override

public void run() {

for (int i = 0; i < 100; i++) {

p.get();

}

}

}

public class Demo9 {

public static void main(String[] args) {

Person p = new Person();

new Thread(new Producer(p)).start();

new Thread(new Consumer(p)).start();

}

}

七、黑马程序员—集合框架（1）
第七篇集合框架（1）

1、集合类 & 容器

为什么出现集合类？

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就要对对象进行存储，集合就是存储对象最常用的一种方式。

数组和集合类同是容器，有何不同？

数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储任意数据类型，集合只能存储对象。

集合类的特点

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

我的总结：集合类比数组强大，类似于包装类与基本数据类型！

集合框架的构成及分类

两大接口

Java集合类主要由两个接口派生出来：

Collection

Set ：不能存放重复对象

List ：可存放重复对象，有序

Queue ：队列

SortedSet ：可对集合数据排序

Map

SortedMap ：可对集合数据排序

2、Collection接口

方法：

boolean add(Object o):该方法用于向集合里面添加一个元素，若集合对象被添加操作改变了，返回true.

boolean addAll(Collection c):把集合c里面的所有元素添加到指定集合里面去，如果集合对象被添加操作改变了返回true.

void clear():清除集合里面的所有元素，将集合长度变为0。

boolean contains(Object o):返回集合里是否包含指定的元素。

boolean containsAll(Collection c):返回集合里是否包含集合c内所有的元素。

boolean isEmpty()：返回集合是否为空（长度是否为0）。

Iterator iterator():返回一个Iterator对象，用于遍历集合里的元素。

boolean remove(Object o)：删除集合中指定元素o。

boolean removeAll(Collection c):从集合中删除集合c里面的元素。若删除一个或以上返回true。

boolean retainAll(Collection c):从集合中删除集合c里不包含的元素。

int size()：得到集合元素的个数。

Object[] toArray():把集合转成一个数组，所有集合元素编程数组元素。

Eg：

public class Demo10 {

public static void main(String[] args) {

Collection c = new ArrayList();

c.add("A");

c.add("A");

c.add("A");

c.add("A");

//c.add(new Date());上面写了泛型，这个语句就是错误的了，因为泛型规定了加进来的类型！

System.out.println(c);

}

}

3、Iterator接口

Iterator主要遍历Collection集合中的元素，也有称为迭代器或迭代精灵。

boolean hasNext()：若被迭代的集合元素还没有被遍历，返回true.

Object next():返回集合的下一个元素.

void remove():删除集合上一次next()方法返回的元素。(若集合中有多个相同的元素，都可以删掉)

iterator对于集合才能用，for不同，只要是循环都可用。

迭代是取出集合中元素的一种方式。

因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。

迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。

迭代器的next方法返回值类型是Object，所以要记得类型转换。（学到泛型就可以消除强转！）

Eg：Iterator iter = l.iterator();

while(iter.hasNext()){

System.out.println(iter.next());

}

4、集合遍历输出方式

Iterator：迭代输出

一旦操作集合的遍历输出，首选Iterator接口;

ListIterator:Iterator子接口，专门输出List中的元素;

Enumeration:古老的输出方式，迭代Vector元素，被Iterator取代;

foreach:可输出数组和Iterable对象;

我的总结：

集合遍历输出方式：

1. Iterable接口（迭代遍历）注：优先选择Iterator接口，遍历Collection里所有元素，也称为迭代器和迭代精灵；迭代是取出集合中元素的一种推荐方式。

2. Foreach循环注：可以直接用，使用场合：数组和Iterable对象！

3. For循环注：在（）内实例化Iterable对象，进行遍历！

4. 先用toArray方法输出成为数组，再用Foreach循环！

第一个和第三个很类似，第二个和第四个很类似！

很好

Eg：

package july7;

//遍历输出的四种方式

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

public class Demo11 {

public static void main(String[] args) {

List l = new ArrayList();

l.add("1");

l.add("2");

l.add("3");

l.add("4");

System.out.println(l);

/**

* 遍历输出：四种方式

*/

// 1、推荐使用的Iterator对象，迭代输出！

Iterator it = l.iterator();

while (it.hasNext()) {

System.out.println("迭代输出：" + it.next());

}

// 2、对集合进行fore循环！

for (String str : l) {

System.out.println("fore集合迭代输出：" + str);

}

// 3、for循环迭代，在for方法体内部实例化Iterator对象！

int i = 0;// for方法体内定义项不能出现多种不同类型

for (Iterator iter = l.iterator(); i < l.size(); i++) {

System.out.println("for循环迭代实例化输出：" + iter.next());

}

// 4、先将集合转换为数组，再利用数组的遍历输出；

Object[] o = l.toArray();

for (Object object : o) {

System.out.println("转换数组迭代输出：" + object);

}

}

}

5、Set接口（元素不可以重复）

Set是Collection子接口；

Set和Collection基本上一样，一点除外：

Set无法记住添加的顺序，不允许包含重复的元素。

当试图添加两个相同元素进Set集合，添加操作失败，add()方法返回false。

Set判断两个对象是否相等用equals,而不是使用==。

也就是说两个对象equals比较返回true，Set集合是不会接受这个两个对象的。

常用子类：

HashSet:散列存放

TreeSet:有序存放

hashCode方法对于HashSet的作用

HashSet类是Set接口最常用的实现类,采用hash算法存储数据,具有良好的存储和查找功能。

散列存储:不记录添加顺序;排列顺序时，顺序有可能发生变化;

线程不安全的，多个线程访问一个HashSet要使用同步代码;

HashSet集合元素值允许是null,但是最多只能有一个;//因为Set集合就不可以装重复的对象！

hash(翻译为哈希,或散列)算法的功能:

保证通过一个对象快速找到另一个对象;

其算法价值体现在速度,可以保证查询快速执行;

当从HashSet中访问元素时,HashSet先计算该元素的hashCode(也就是该对象的hashCode方法返回值),然后直接到该HashCode对应的位置取出该元素;

在这里对象的hashCode就好比是数组里的索引,但是不是索引;

HashSet元素添加

当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值,判断已经存储在集合中的对象的hashCode值是否与添加的对象的hashCode值一致:若不一致:直接添加进去;若一致,再进行equals方法比较,equals方法如果返回true,表明对象已经添加进去了,就不会再添加新的对象了,否则添加进去;

如果我们重写了equals方法,也要重写hashCode方法,反之亦然;。

HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode方法返回值也相等。

如果需要某个类的对象保存到HashSet集合中，覆写该类的equals()和hashCode()方法，应该尽量保证两个对象通过equals比较返回true时,他们的hashCode返回也相等。

我的总结：

很重要的一点：理解！往HashSet集合里面存入数据，要先后调用两个方法：hashCode方法和equals方法！！！

备注：使用eclipse添加这两个方法。

Eg：

package july7;

//hashset方法和equals方法判断输入的对象是否重复！

import java.util.HashSet;

import java.util.Set;

class PersonDemo{

private String name;

public PersonDemo(String name) {

super();

this.name = name;

}

@Override

public String toString() {

return "name= " + name ;

}

//没有覆写hashcode和equals方法前，显示三次（一样的）。覆写后，只剩下一个了！说明覆写后方法起作用了，重复的输入不进去！

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + ((name == null) ? 0 : name.hashCode());

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

PersonDemo other = (PersonDemo) obj;

if (name == null) {

if (other.name != null)

return false;

} else if (!name.equals(other.name))

return false;

return true;

}

}

public class Demo12 {

public static void main(String[] args) {

Set s = new HashSet();

s.add(new PersonDemo("章泽天"));

s.add(new PersonDemo("章泽天"));

s.add(new PersonDemo("章泽天"));

System.out.println(s);

}

}

6、TreeSet

TreeSet是SortedSet接口唯一的实现，与HashSet相比额外的方法有：

Comparator comparator():返回当前Set使用的Comparator,若返回null,表示以自然顺序排序。

Object first() 返回此 set 中当前第一个(最低)元素。

Object last() 返回此 set 中当前最后一个(最高)元素。

SortedSet subSet(Object fromElement, E toElement) 返回此 set 的部子集，其元素从 fromElement（包括）到 toElement（不包括）。

SortedSet headSet(Object toElement)返回此 set 的部分子集，其元素严格小于 toElement。

SortedSet tailSet(Object fromElement) 返回此 set 的部分子集，其元素大于等于 fromElement。

TreeSet的排序之自然排序

TreeSet会调用元素的compareTo(Object o)方法来比较元素之间的大小关系,然后将集合里的元素按升序排列.此时需要排序元素的类必须实现Compareble接口,并覆写其int compareTo(Object o)方法;

该方法用于比较对象,若:obj1,compareTo(obj2),返回0,表示两个对象相等,若返回一个正整数,表示obj1大于obj2,若返回一个负整数,表示obj1小于obj2;

对于TreeSet集合而言,判断两个对象相等的标准是:

compareTo()方法比较返回 0;

package july7;

//TreeSet可以自动进行排序！最简单的情况

import java.util.Set;

import java.util.TreeSet;

public class Demo13 {

public static void main(String[] args) {

Set s = new TreeSet();

s.add(1);

s.add(192);

s.add(123);

s.add(56);

s.add(13);

s.add(96);

System.out.println(s);//[1, 13, 56, 96, 123, 192]

}

}

稍复杂点的

package july7;

//TreeSet的自然排序，升序

import java.util.Set;

import java.util.TreeSet;

class Student implements Comparable{//必须实现接口

private Integer age;

public Student(Integer age) {

super();

this.age = age;

}

@Override

public int compareTo(Object o) {//比较的规则，运用泛型可以消除强转！

if(o instanceof Student){

Student s = (Student)o;

return this.age.compareTo(s.age);

}

return 0;

}

@Override

public String toString() {

return age+"" ;

}

}

public class Demo14 {

public static void main(String[] args) {

Set s = new TreeSet();

s.add(new Student(140));

s.add(new Student(15));

s.add(new Student(11));

s.add(new Student(63));

s.add(new Student(96));

System.out.println(s);//[11, 15, 63, 96, 140]

}

}

TreeSet的排序之定制排序

TreeSet的自然排序是根据元素的大小进行升序排序的,若想自己定制排序,比如降序排序,就可以使用Comparator接口了:

该接口包含int compare(Object o1,Object o2)方法,用于比较两个对象的大小,比较结果和compareTo方法一致;

要实现定制排序,需要在创建TreeSet集合对象时,提供一个一个Comparator对象,该对象里负责集合元素的排序逻辑;

TreeSet(Comparator comparator)

Eg：

package july7;

//定制排序的话，必须在创建TreeSet集合对象的时候提供一个Comparator方法

import java.util.Comparator;

import java.util.Set;

import java.util.TreeSet;

class Student1{

private Integer age;

public Student1(Integer age) {

super();

this.age = age;

}

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

@Override

public String toString() {

return age + "";

}

}

class MyComparator implements Comparator{

@Override

public int compare(Object o1, Object o2) {

if(o1 instanceof Student1 & o2 instanceof Student1){

Student1 s1 = (Student1)o1;

Student1 s2 = (Student1)o2;

if(s1.getAge() > s2.getAge()){

return -1;

}else if(s1.getAge() < s2.getAge()){

return 1;

}

}

return 0;

}

}

public class Demo15 {

public static void main(String[] args) {

Set s = new TreeSet(new MyComparator());

/**

* 要实现定制排序,需要在创建TreeSet集合对象时,提供一个一个Comparator对象,

* 该对象里负责集合元素的排序逻辑;

*/

s.add(new Student1(140));

s.add(new Student1(15));

s.add(new Student1(11));

s.add(new Student1(63));

s.add(new Student1(96));

System.out.println(s);

}

}

7、List接口
Collection子接口；

List是有序的集合，集合中每个元素都有对应的顺序序列。List集合可使用重复元素，可以通过索引来访问指定位置的集合元素（顺序索引从0开始）,List集合默认按元素的添加顺序设置元素的索引,比如第一个元素的索引就是0,好似数组。

List作为Collection子接口当然拥有其所有方法，同时也有自己的方法：

void add(int index,Object e):将元素e添加到List集合中的index处；

boolean addAll(int index,Collection c):将集合c所包含的所有元素都插入在List集合的index处；

Object get(int index):返回集合index索引处的元素；

int indexOf(Object o):返回对象o在List集合中第一次出现位置的索引；

int lastIndexOf(object o):返回对象o在List集合中最后一次出现的位置索引；

Object remove(int index)：删除并返回index索引处的元素；

Object set(int index,Object e):把集合index处的元素替换为e对象，返回以前在指定位置的元素；

List subList(int fromIndex,int toIndex):返回从所有fromIndex(包括)到toIndex(不包括)处所有集合元素的子集合。

ListIterator

Iterator的子接口，专门用于操作List集合的输出；

List自己还有一个listIterator()方法，该方法返回ListIterator对象，ListIterator继承了Iterator接口，提供了专门操作List的方法。在Iterator上额外增加的方法：

支持双向输出：

boolean hasPrevious():返回该迭代器关联集合是否还有上一个元素；

Object previous():返回该迭代器的上一个元素；

我的总结：这是相对更加特殊的一个接口，只用于List集合，可以完成逆序输出！

Eg：

package july7;

import java.util.ArrayList;

import java.util.List;

import java.util.ListIterator;

public class Demo16 {

public static void main(String[] args) {

List l = new ArrayList();

l.add(12);

l.add(24);

l.add(36);

l.add(23);

l.add(37);

System.out.println(l);

ListIterator it = l.listIterator();

while(it.hasNext()){

System.out.println("正序："+it.next());

}

System.out.println("==================================");

//使用向前迭代前必须将游标（指针）移动到后边！

while(it.hasPrevious()){

System.out.println("逆序："+it.previous());

}

}

}

输出：

[12, 24, 36, 23, 37]

正序：12

正序：24

正序：36

正序：23

正序：37

==================================

逆序：37

逆序：23

逆序：36

逆序：24

逆序：12

8、List接口中常用类

Vector：线程安全，但速度慢，已被ArrayList替代。

ArrayList：线程不安全，查询速度快。

LinkedList：链表结构，增删速度快。取出List集合中元素的方式：

get(int index)：通过脚标获取元素。

iterator()：通过迭代方法获取迭代器对象。

ArrayList和Vector类都是基于数组实现的List类,Vector比较古老,被ArrayList取代了;

ArrayList是线程不安全的,而Vector是线程安全的,但是即使这样,也不推荐使用Vector,因为Collections有方法可以得到线程安全的ArrayList对象;

Collections类: static List synchronizedList(List list) 返回指定列表支持的同步（线程安全的）列表。

Queue接口

继承Collection接口

模拟队列：先进先出(FIFO);

void add(Object e):将e插入到队列尾部；

Object element():获取队列头部的元素；

boolean offer(Object e):将e插入到队列的尾部，当使用有容量限制的队列时，此方法比add(Object e)方法更好。

Object peek():获取队列头部的元素。如果此双端队列为空，则返回 null。

Object poll():获取并删除队列头部的元素。如果此双端队列为空，则返回 null。

Object remove():获取并删除队列头部的元素。

Eg：练习：List的使用

设计Department 和 Employee 对象类(按照开发的样式没有写在一个文件里面)

//一个员工只可以有一个部门，所以按照普通的写法

//一个部门可以有许多员工，所以按照集合的写法；

//员工

package re538.Department;

public class Emp {

private Dept dept;//一个员工只可以有一个部门，所以按照普通的写法

private String name;

public Dept getDept() {

return dept;

}

public void setDept(Dept dept) {

this.dept = dept;

}

public Emp(String name) {

super();

this.name = name;

}

public String toString(){//覆写toString方法

return this.name+"";

}

}

//部门

package re538.Department;

import java.util.List;

public class Dept {

private String name;

private List emp;//一个部门可以有许多员工，所以按照集合的写法；部门里的属性，员工！

public Dept(String name) {

super();

this.name = name;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public List getEmp() {

return emp;

}

public void setEmp(List emp) {

this.emp = emp;

}

private Dept parent;//一个部门只有一个直接主管部门，所以普通写法

private List children;//但是一个部门可以管理很多部门，充当很多部门的直接主管部门，所以使用集合

public Dept getParent() {

return parent;

}

public void setParent(Dept parent) {

this.parent = parent;

}

public List getChildren() {

return children;

}

public void setChildren(List children) {

this.children = children;

}

public String toString(){

return this.name.toString();

}

}

//测试类，主方法！

package re538.Department;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

public class TestDemo {

public static void main(String[] args) {

Emp e1 = new Emp("刘亦菲");

Emp e2 = new Emp("章泽天");

Emp e3 = new Emp("张月娟");

Emp e4 = new Emp("王二五");

Emp e5 = new Emp("刘昭");

List list = new ArrayList();//把员工丢尽集合去

list.add(e1);

list.add(e2);

list.add(e3);

list.add(e4);

list.add(e5);

for (Object object : list) {//把员工给遍历出来，使用的是直接的foreach（四种方法之一）

System.out.println("----->"+object);

}

System.out.println("-------------------");

Dept d = new Dept("部门");//定义出一个部门来接收员工

d.setEmp(list);//把员工这个集合丢到部门去。

Dept d1 = new Dept("itcast");

Dept cditcast = new Dept("成都传智播客");

Dept gzitcast = new Dept("广州传智播客");

Dept d4 = new Dept("CSDN");

System.out.println(d4);

List children = new ArrayList();

children.add(cditcast);

children.add(gzitcast);

d1.setChildren(children);//定义直接被主管部门（集合）

d1.setParent(d4);//定义直接主管部门

Iterator it = children.iterator();//运用到了迭代遍历，四种之一！

while(it.hasNext()){

System.out.println(it.next());

}

}

}

9、Map接口

映射关系,也有人称为字典,Map集合里存在两组值，一组是key,一组是value。Map里的key不允许重复。通过key总能找到唯一的value与之对应。

Map里的key集存储方式和对应的Set集合中的元素存储方式一致;

学生都有一个学号，我们能点学号就能找到某个学生，好比这个学号就是key，学生就是value。

Map.Entry是Map接口的内部接口，专门用来保存key-value内容：

Map常用方法

void clear():删除该Map对象中所有的key-value对。也就是清理该集合；

boolean containsKey(Object key):查询Map中是否包含指定的key；

boolean containsValue(Object value):查询Map中是否包含至少一个value;

Set entrySet():返回Map所包含的key-value对所组成的Set集合，每个集合元素都是Map.Entry对象(Entry是Map内部类)；

Object get(Object key):返回指定key所对应的value,若此Map中不包含该key,返回null;

boolean isEmpty():判断Map集合是否为空；

Set keySet():返回该Map中所有key所组成的Set集合；

Object put(Object key,Object value):添加一个key-value对，若Map中已有与key相等的key-value对，则新的key-value对覆盖原来的key-value对；

void putAll(Map m):将m中的key-value赋值到调用该方法的Map对象中；

Object remove(Object key):删除指定key所对应的key-value对，返回本删除key所关联的value,若key不存在，返回null;

int size():返回该Map里面key-value对的个数；

Collection values():返回Map里所有value组成的Collection。

Eg：package july7;

import java.util.Collection;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

public class Demo17 {

public static void main(String[] args) {

Map m = new HashMap();

m.put(1, "jack");

m.put(2, "rose");

m.put(3, "lucy");

System.out.println(m);//{1=jack, 2=rose, 3=lucy}

Set s = m.entrySet();

System.out.println(s);//[1=jack, 2=rose, 3=lucy]

s = m.keySet();

System.out.println(s);//[1, 2, 3]

for (Object key : s) {

System.out.println(key);//Key

System.out.println(m.get(key));//Value

}

Collection c = m.values();

System.out.println(c);

}

}

Map.Entry

Entry是Map接口里面的一个内部接口.

该接口用于封装key- value,有3个方法:

Object getKey();返回Entry里包含的key值

Object getValue();返回Entry里包含的value值

Object setValue(Object value):设置Entry里包含的value值,并返回新设置的value值;

Map集合的输出

按照最正统的做法，所有的Map集合的内容都要依靠Iterator输出，以上虽然是完成了输出，但是完成的不标准，Map集合本身并不能直接为Iterator实例化，如果此时非要使用Iterator输出Map集合中内容的话，则要采用如下的步骤：

方法一：

1.通过entrySet方法变成Set对象

2.调用Set的Iterator方法，此时每个Iterator对象是Map.Entry对象

3.对Map.Entry分离出 key - value

方法二：

1.通过keySet得到Map集合多有key的Set集合

2.调用Set的Iterator方法，此时每个Iterator对象是key值

3.通过Map的getValue(key)得到value值

Eg：

package july7;

//把Map中的元素取出来

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

public class Demo18 {

public static void main(String[] args) {

Map m = new HashMap();

m.put(1, "jack");

m.put(2, "rose");

m.put(3, "lucy");

//第一种方法

Set s = m.entrySet();

Iterator it = s.iterator();

while(it.hasNext()){

Map.Entry me = (Entry) it.next();

System.out.println(me.getKey()+" "+me.getValue());

}

//第二种方法

s = m.keySet();//得到的是key的集合

it = s.iterator();//然后将key迭代出来

while(it.hasNext()){

int i = (int)it.next();

System.out.println(i+" "+m.get(i));

}

}

}

八、黑马程序员—集合框架（2）
第八篇集合框架（2）

1、Collections类

操作集合的工具类：

static void reverse(List list):反转指定List集合中的顺序；（和ListItertor的逆序排列一样！）

static void shuffle(List list):对集合元素随机排序

static void sort(List list):自然升序排序

static vois swap(List list,int i, int j):将指定的List集合i处元素和j处元素进行交换；

static void rotate(List list, int distance):

若distance为正数，将list集合后的distance个元素移到前面；

当distance为负数，将list集合前的distance个元素移到后面；

static int binarySearch(List list, Object key) 使用二分搜索法搜索指定列表，以获得指定对象。

调用之前必须调用 Collections.sort(List list)(完成自然排序);

static Object max(Collection coll) 根据元素的自然顺序，返回给定 collection 的最大元素。

static Object min(Collection coll) 根据元素的自然顺序，返回给定 collection 的最小元素。

static void fill(List list, Object obj) 使用指定元素替换指定列表中的所有元素。

static int frequency(Collection c, Object o) 返回指定 collection 中等于指定对象的元素数。

static int indexOfSubList(Listsource, List target) 返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。

static int lastIndexOfSubList(List source, List target) 返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。

static boolean replaceAll(List list, Object oldVal, Object newVal) 使用另一个值替换列表中出现的所有某一指定值。

同步集合

Eg：

import static java.util.Collections.binarySearch;

import static java.util.Collections.shuffle;

import static java.util.Collections.sort;

import java.util.ArrayList;

import java.util.List;

public class CollectionsDemo {

public static void main(String[] args) {

/**

* static int binarySearch(List list, Object ele) 使用二分搜索法搜索指定列表，以获得指定对象。

*

* static void sort(List list) 根据元素的自然顺序对指定列表按升序进行排序。

*/

List list = new ArrayList();

list.add(1);

list.add(-3);

list.add(5);

list.add(-99);

System.out.println(list);

sort(list);

System.out.println(list);

int index = binarySearch(list, 0);

System.out.println(index);

/*

* static void copy(List dest, List src) 将所有元素从一个列表复制到另一个列表。

*

* static void fill(List list, Object obj) 使用指定元素替换指定列表中的所有元素。

*

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

* 使用另一个值替换列表中出现的所有某一指定值。

*

* static void shuffle(List list) 使用默认随机源对指定列表进行置换。

*/

System.out.println("好的顺序" + list);

shuffle(list);

System.out.println("随机" + list);

/*

* static void swap(List list, int i, int j) 在指定列表的指定位置处交换元素。

*/

}

}

2、Arrays

public static List asList(Object... a)返回一个受指定数组支持的固定大小的列表(返回的是不可变的List(长度固定))。

（对返回列表的更改会“直接写”到数组。）此方法同 Collection.toArray() 一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的，并且实现了 RandomAccess。

此方法还提供了一个创建固定长度的列表的便捷方法，该列表被初始化为包含多个元素：

List list= Arrays.asList("Larry", "Moe", "Curly");

list.add("Will");×

Eg：

import java.util.Arrays;

import java.util.List;

public class ArraysDemo {

public static void main(String[] args) {

/*

* static List asList(Object... a)

返回一个固定长度的列表。

* */

List list = Arrays.asList("will","Lucy","小强");

System.out.println(list);

list.set(0, "你好");

//list.add("22");//错误，返回一个受指定数组支持的固定大小的列表。不可以再添加！

//list.remove(0);

System.out.println(list);

}

}

3、泛型(Generic)
引入：我想使用List集合装公司的员工，却装了一条狗进来；

使用TreeSet的时候,只能存放同一种数据类型,可惜存了不同的数据类型,依然没有报错,可是运行时出错.

泛型定义：

java5开始出现的一种对Java语言类型的一种拓展,以支持创建可以按类型进行参数化的类.可以把类型参数看作是使用参数类型时指定的类型占位符,就好比方法的形式参数是实际参数的占位符一样.

泛型能保证大型应用程序的类型安全和良好的维护性;

使用泛型的优势:

类型安全,使编译器对泛型定义的类型做判断限制.如保证TreeSet里的元素类型必须一致;消除强制类型的转换,如,使用Comparable比较时每次都需要类型强转；

4、泛型的使用

泛型类

在类声明时通过一个标识符表示类中某个字段的类型或者某个方法的返回值或参数的类型，这样在类声明或实例化的时候只要指定自己需要的类型就ok。

声明带泛型的类:

class 类名<泛型类型1,泛型类型2……>{

泛型类型变量名；

泛型类型方法名(){}

返回值类型方法名(泛型类型变量名){}

}

使用带泛型的类：

类名<具体类> 对象名 = new 类名<具体类>();

类型参数规范：推荐使用规范-常见的泛型,泛型只保存在源文件中,class文件中不存在;也就是说在编译阶段就会丢失,基本数据类型不能作为泛型类型;

K 键，比如映射的键 key的类型

V 值，比如Map的值 value类型

E 元素，比如Set Element表示元素,元素的类型

T 泛型，Type的意思

我的总结：泛型好处：限定添加类型和消除强转转换的麻烦！

泛型使用

public class Point {//声明任意符号的标识符

private Q x;//变量类型由外部组成

private Q y;

public Q getX() {

return x;

}

public void setX(Q x) {//类型由外部决定

this.x = x;

}

//..........................

}

.................main.........

{

Point p = new Point();//定义具体类型

p.setX(1.1);

p.setY(2.2);

}

练习例子

需求：设计一个表示点的类Point,该类有两个字段，一个是横坐标x,一个纵坐标y,要求坐标有3种表达形式（Integer，Double，String）：

如果不使用泛型的话可以新建多个类，但是内部方法体只有参数类型不一样，所以用泛型的话更加简单，给定一个占位符，并不明确表示到底是什么类型，在实际运用的时候才确定类型！！

很好的例子！

package generic;

class Point{

private T t1;

private T t2;

public T getT1() {

return t1;

}

public void setT1(T t1) {

this.t1 = t1;

}

public T getT2() {

return t2;

}

public void setT2(T t2) {

this.t2 = t2;

}

}

public class GenericDemo {

public static void main(String[] args) {

//String 类型的

Point p = new Point();

p.setT1("2");

p.setT2("3");

System.out.println(p.getT1());

System.out.println(p.getT2());

//Integer 类型的

Point p2 = new Point();

p2.setT1(23);

p2.setT2(24);

System.out.println(p2.getT1());

System.out.println(p2.getT2());

//Double 类型的

Point p3 = new Point();

p3.setT1(23.00);

p3.setT2(24.00);

System.out.println(p3.getT1());

System.out.println(p3.getT2());

//============================

Set s = new HashSet();//创建一个容器对象,应该在创建的时候就明确是装什么的

s.add("a");

//s.add(1);//此时就加不进去了，因为已经限制了容器内参数类型！

//此时就能保证集合里元素类型一致,

Set treeSet = new TreeSet();

//规定key只能是String,value是Date

Map map = new HashMap();

// V put(K key, V value)

Date v = map.put("", new Date());//和上面定义的类型一样

//V get(Object key)

Date val = map.get("");

}

}

运行结果

2

3

23

24

23.0

24.0

这样的话借助泛型一个类就可以表达多个不同类型的参数！

要求

消除强制类型的转换,如,使用Comparable比较时每次都需要类型强转;

1、没有加上泛型，最初的需要强制类型转换

package generic;

import java.util.Set;

import java.util.TreeSet;

class Person implements Comparable{//需要进行排序的类要实现Comparable

private Integer age;

public Person(Integer age) {

super();

this.age = age;

}

@Override

public int compareTo(Object o) {

Person p = (Person)o;//强制类型转换

return this.age.compareTo(p.age);

}

public String toString(){

return this.age.toString();

}

}

public class GenericDemo2 {

public static void main(String[] args) {

Set set = new TreeSet();

set.add(new Person(15));

set.add(new Person(12));

set.add(new Person(19));

set.add(new Person(53));

set.add(new Person(62));

System.out.println(set);

}

}

第二步：加上泛型，不再需要强转（因为类型已经固定了）！

package generic;

import java.util.Set;

import java.util.TreeSet;

class Person implements Comparable{//

private Integer age;

public Person(Integer age) {

super();

this.age = age;

}

@Override

public int compareTo(Person o) {

return this.age.compareTo(o.age);//按照什么排序

}

public String toString(){

return this.age.toString();

}

}

public class GenericDemo2 {

public static void main(String[] args) {

Set set = new TreeSet();

set.add(new Person(15));

set.add(new Person(12));

set.add(new Person(19));

set.add(new Person(53));

set.add(new Person(62));

System.out.println(set);

}

}

5、声明多个泛型类型和通配符

若一个类中多个字段需要不同的泛型声明，则在声明类的时候指定多个泛型类型即可；

格式：

public interface IDAO {

PK add(T t);

void remove(PK id);

void update(PK id, T t);

T get(PK id);

}

在进行引用传递的时候泛型类型必须匹配才可以传递，否则编译不通过；

使用？，表示未知类型的泛型对象：

List 表示未知元素的List集合；

这种带通配符的List仅表示各种泛型List的父类，并不能把元素添加入集合中；

List list = new ArrayList<>(); list.add(1);//ERROR

public void show(List list){}

//表示可接受任意类型的List集合

6、泛型的上限与下限

设置泛型对象的上限使用extends,表示参数类型只能是该类型或该类型的子类：

声明对象：类名对象名

定义类：类名<泛型标签 extends 类>{}

设置泛型对象的下限使用super,表示参数类型只能是该类型或该类型的父类：

声明对象：类名对象名称

定义类：类名<泛型标签 extends类>{}

public static void show(List l){

}

public static void show(List l){

}

public static void show(List l){}

public static void show(List l){}

泛型的上限

public static void main(String[] args) {

Person p1 = new Person<>();

p1.setVal(99);

Person p2 = new Person<>();

p2.setVal(3.14);

Person p3 = new Person<>();

p3.setVal("007");

show(p1);//√

show(p2);//√

show(p3);//×

}

public static void show(Person p){//此处限定了Person的参数类型只能是Number或者是其子类，而String并不属于Number。

System.out.println(p.getVal());

}

泛型的下限

public static void main(String[] args) {

Person p1 = new Person<>();

p1.setVal(99);//Integer

Person p2 = new Person<>();

p2.setVal(3.14);//Double

Person p3 = new Person<>();

p3.setVal("007");//String

Person

黑马JAVA知识点总结

你可能感兴趣的:(JAVA)