Java 学习笔记

类型	占用存储空间	表数范围
byte	1字节	-128~127
short	2字节	-2的15次方~2的15次方-1
int	4字节	-2的31次方~2的31次方-1
long	8字节	-2的63次方~2的63次方-1
浮点类型
float	4字节
double	8字节

十进制整数，如12，-314,0。1).Java语言整型常量的三种表示形式：
八进制整数，要求以0开头，如012。
十六进制数，要求0x或0X开头，如0x12。

2).Java语言的整型常亮默认为int 型，如：int i=3;

3).声明long型常亮可以后加'l'或者'L'，如 long l=3L;

12.变量命名规范：

1.变量命名语法规范:

1).应该以字母、下划线或者美元符开头。

2).后面跟字母、下划线、美元符或者是数字。

3).Java变量名没有长度的限制。

4).Java变量名对大小写敏感。

2.驼峰命名法：

1).变量名应该是有意义的英文单词。

2).变量名如果只有一个单词，则所有字母小写。

3).变量名如果由多个英文单词组成，则从第二个单词开始首字母大写。

13.Java字符使用Unicode字符集：

ASCII全称为：American Standard Code for Information Interchange(美国标准信息交换码)

1.对字符集的理解可以从以下几方面入手：

1).在计算机当中，所有的数据都需要使用二进制数字表示

2).类似a、b、c之类的字母无法直接用二进制表示。

3).所以就将所有常见的符号进行编号。标准ASCII码使用7位二进制数来表示字符。

4).7位2进制可以表示所有的数字，大写字母以及一些常见的符号。 (例如：!,@,#,$等等)

2.Unicode 为每种语言的每个字符设定了统一并且唯一的二进制编码

1).Unicode满足了跨语言文本转换和处理的需求。

2).Unicode在互联网当中扮演着十分重要的角色。

3).Unicode使用数字0-0x10ffff来表示字符。

4).最多允许1114112个字符。

例子:打开文本编辑器:输入联通，保存，再次打开，出现乱码？

答：当写入联通两个字的时候，是通过字符集，装换成数字，存放在硬盘如果用 a字符集，转换联通存入一个二进制到硬盘，读取的时候，用 b字符集翻译回来，就会出错。

14.Java与Unicode字符集

答：由于Java在设计初期就考虑到将语言使用在互联网当中，所以设计者们就选用Unicode 字符集，这也使得Java程序能够在互联网当中更好的流通，也正是由于这样的原因，以下代码是合法的：char c = '中'；

在Unicode当中，一个中文字符和一个英文字符所占的字节数是一样的。

3.什么是面向对象，如何学习？

15.什么是面向对象？

1).面向对象是一种编程方法。

2).面向对象是一种思维方式。

3).面向对象不是一种编程语言。

16.如何学习面向对象？

1).掌握一门面向对象语言的语法。

2).掌握面向对象的思维方式（现实方式的思维方式）。

2.1).首先确定谁来做，其次确定怎么做。

2.2).首先考虑整体，其次考虑局部。

2.3).首先考虑抽象，其次考虑具体。

3).熟悉面向对象设计原则（呈金字塔型，消除应用程序重复代码）。

4).掌握面向对象的设计模式（前人设计经验总结，解决问题的方法）。

4.创建类的方法，类的表示方法？

17.创建

创建类的方法：

class 类名（相当c语言的结构体）

{

属性； //属性也叫成员变量，主要用于描述类的状态

方法； //方法也叫成员方法，主要用于描述类的行为

}

类的表示方法：

class Person{ //Person为类名

int age; //age为成员变量

void shout() { //shout 为成员函数

System.out.println("oh,my god! I am" + age);

}

-age是类的属性，也叫类的成员变量。

-shout是方法也叫类的成员函数。

-shout方法可以直接访问同一个类中age变量，如果一个方法中

有与成员变量同名的局部变量，该方法中对这个变量名的访问

时局部变量，而不是成员变量。

生成对象的方法：

例子：在c语言中定义一个结构体：

typedef struct st{

int age;

int high;

}Dog;

例子：在Java中创建一个名为 Dog 的类。

引用过程：创建一个新(引用)变量：Dog dog;

格式：类名对象名=new 类名();

例如：Dog dog =new Dog(); //已经定义一个Dog的对象

Dog和int 是一个意思，是一个类型，而Dog是一个引用数据类型（跟c语言的结构体是一样的）。

1.Dog d //创建一个Dog的引用

2.new Dog(); //创建一个Dog对象

3.= //将创建的Dog对象赋值给引用‘d’

5.1.类和对象的关系

类是抽象的，一系列具有共同特征的事物，比如狗，有身高体重，而对象是具体的，比如具体是哪一条狗。

18.使用变量和函数：

1).对象的使用方法：

使用对象调用变量和函数：对象.变量

例子：在Dog.java 中创建一个类

Java 学习笔记

在Text.java 中创建一个对象和调用对象

运行Text.java

进去命令运行窗口：

Java 学习笔记

然后再进入你文件所在的位置：

Java 学习笔记

注意：在这里提示一下，编译java文件的时候最好不要使用window自带的文本编辑器，容易出现一些摸不着头脑的错误，博主使用的是Notepad++文本编辑器。
下载链接：NodtPad下载链接,密码:38hc

5.2.函数的重载

19.函数的重载：

1.两个或多个函数出现在同一个类当中。

2.函数名相同。

3.参数列表不同。

例子：在A.java 中建立一个类：

在Text.java 中

输出结果：

Java 学习笔记

通俗例子：生活中有 “洗”这个概念，洗衣服也是洗，洗脸也是洗，不能用同样的方法去洗，洗是一个抽象的概念，洗什么是具体的事件。

5.3构造函数（函数和函数名相同，没有返回值）

构造函数：函数和函数名相同，没有返回值

在Text.java 中

运行结果：

Java 学习笔记

构造函数的例子：

在Text.java 中

运行结果:

Java 学习笔记

注意：如果一个类没有建立构造函数，这个类在运行的时候就会自动为这个类添加一个参数为空何函数体为空的构造函数，如果一个类中已经有构造函数，编译器不会自动添加参数为空的构造函数（调用无参数的构造函数就会出错）。

6.this关键词的用法

使用this调用成员变量和成员函数，使用this调用构造函数

1).例子：创建一个Person.java 的文件

再创建一个Text.java的函数入口

运行结果：

Java 学习笔记

例子：“我” 这个词，当张三说：我的年龄为15岁，这个”我“代表张三。当李四说：我的年龄为16岁，这个“我”代表李四。

2).this的第二种用法：

例子：创建一个Person.java 的文件

再创建一个Text.java的函数入口

输出结果：

Java 学习笔记

7.static 关键字的用法

static 关键字的用法：

1.静态成员变量只有一份。

2.在静态函数当中不能使用this.

3.静态代码块的主要作用是为静态成员变量赋值。

1). 静态成员变量的语法特点：

如何定义：在变量前面加一个 static int i;

普通成员变量:

Person p1 = new Person();

P1.i=10;

Person p2 = new Person();

P2.i=20;

如果“i”为静态变量，他们使用同一个变量：
在Person.java 文件中定义一个类：

注意：所有的静态变量使用的是同一个，无论是p1修改还是p2修改这个i成员变量的值，这个值就会同时变化；

在Text.java 文件中写主函数

输出结果为：

Java 学习笔记

2). 静态函数的语法特点：

例子1：

Java 学习笔记

编译通过没有错误。
例子2：

Java 学习笔记

编译出错：

解释：在静态函数中，不能直接引用非静态变量。
3). 静态代码块的语法特点：
例子3：

Java 学习笔记

在Text.java 中代码如下：

Java 学习笔记

运行java Text结果为：

Java 学习笔记

分析：静态代码开无需调用，在装载的时候自动调用。

8.继承（三大特征：继承，封装，多态）

继承（三大特征：继承，封装，多态），为了减少应用程序的重复代码

什么是继承？

在现实生活中，继承就是儿子得到了老子的东西。
在面向对象的世界当中，继承就是一个类得到了另一类当中的成员变量和成员函数的方法。

注意：Java只支持单继承，不允许多继承。

例子1：

Java 学习笔记

如何继承一个类？

新建一个类 Student.java 文件（让Student 类去继承Person 这个类）

//Person 为父类，Student 为子类，extends为继承的关系

如果为继承关系，那Student这个类应该也有name ,eat(),introduce()，成员变量和方法。

证实：

新建一个Text.java 的类

执行步骤：1.编译javac Person 2.编译 javac Student 3.编译 javac Text 4.执行java Text

--除了继承还可以增加新的东西？

然后修改 Text.java

输出结果：

Java 学习笔记

8.1.使用super调用父类构造函数的方法

生成子类的过程

注意:子类能继承父类的成员变量和函数，却不能继承父类的构造函数，在成员变量赋值的时候可能出现重复代码，可以通过调用 super();来调用父类的构造函数

例子1：1).建立Person.java的文件,加上构造函数

2).定义一个Student 的类，继承Person，但是构造函数不能被继承；

3).建立一个Text.java 的函数入口

输出结果：

Java 学习笔记

如果在子类Student.java当中代码是这样

在Text.java 文件中，创建一个新的对象 student

运行结果：

Java 学习笔记

8.2函数的复写

函数的复写(voerride)/使用super 调用父类的成员函数

1.函数的复写

例子：

Java 学习笔记

2).再创建一个子类 Student ,继承父类 Person 的name ,age ,introduce();

3).创建一个类，调用Student 函数

运行结果：

Java 学习笔记

9.JAVA的对象转型（面向对象多态性的一种体现）

9.1向上转型

1).什么是对象的向上转型？

向上转型—将子类的对象赋值给父类引用。（一定可以成功）

前提：Student 是 Person 的子类。

例如：s 代表张三这个学生对象。说张三是个Person对象也是没毛病。

例子：

2).再创建一个子类 Student,继承父类Person

3).创建一个类，调用Student 函数

注意：1.一个引用能调用那些成员（变量和函数），取决于这个引用类型。

2.一个引用调用的是哪一个方法，取决于这个引用所指的对象。

输出结果：

Java 学习笔记

9.2向下转型

2).什么是向下转型？

向下转型：将父类的对象赋值给子类引用。

//首先向上转型

Student s1 = new Student();

Person p = s1;

Student s2 = (Student)p; //强制类型转换

例子：

class Text{

public static void main(String args[]){

Student s1 = new Student(); //生成一个新的 Student 的对象p

Person p = s1; //首先向上继承

Student s2 = (Student)p; //再向下继承

}

10.模拟客户需求例子（面向对象方法）

模拟需需求场景，应用前面所学知识。

1).客户的第一要求：开发一个打印机控制程序，能够实现开机、关机、和打印功能。

程序员：先建一个类 Printer.java

建立一个类 Text 用于测试：

测试：

2).客户二次需求：我的办公室加了一台新的打印机，把你的程序修改一下，应该很简单吧（不是同一个型号）。

1.修改打印机的类名为 HPPrinter.然后再增加一个类 CanonPriner

Java 学习笔记

2.测试程序：

--虽然程序开发完成了，但是存在很多重复代码？？？？？？？？？？

如果类越多，重复代码就越多。

解决方案：惠普打印机和佳能打印机都是打印机，则创建一个类为打印机这个类，则打印机为父类，佳能和惠普继承这个父类。

创建父类，Printer

2.创建惠普 HPPrinter 这个类继承父类 Print

3．创建佳能 CannonPriner 这个类，继承父类Print

重复代码全部消除，如果再次添加一个打印机就会容易很多，我们只需要新建一个类去继承Printer这个类，然后根据功能复写父类

11.抽象类和抽象函数

抽象类和抽象函数

1.抽象函数就是没有函数体的函数。

2.抽象函数使用abstract 来定义

3.抽象类不能生成对象，但是却可以拥有构造函数。

1).抽象函数的语法特征

函数的定义：有返回值类型，函数名，参数列表

函数体 ：大括号，和大括号中间的内容

什么是抽象函数？

答：只有函数的定义，没有函数体的函数，被称为抽象函数。

abstract void fun();

2).抽象类的语法特征

什么是抽象类？

使用abstract 定义的类被称为抽象类。

抽象类不能生成对象。
如果一个类中包含有抽象函数，那么这个类必须被声明为抽象类。
如果一个类当中没有抽象函数，那么这个类也可以被声明为抽象类。（不能被生成对象，被称为基类，只能被继承）

例子：新建一个类Person（抽象类不能生成对象）

Java 学习笔记

反推：如果能生成抽象类对象的话，就能调用抽象类函数，如果这样的话，抽象类函数没有函数体，就会出错（所以抽象类不能生成对象）！

如果生成了一个类不能调用，要这个类干嘛？

答：抽象类天生就是用来当爹的，只能用于继承。

新建一个类 Chinese 继承Person

新建一个类 Text

输出结果：

Java 学习笔记

3).抽象类的特征

抽象类可以有构造函数吗？

条件：

抽象类不能生成对象。
构造函数用于生成类的对象。

可以有构造函数：但是为子类集成的时候用的，可以通过super(); 继承抽象类函数的构造函数。

证明：

例子：新建一个类Person（抽象类不能生成对象）

新建一个类 Chinese 继承Person

Java 学习笔记

新建一个类 Text

输出结果：

Java 学习笔记

结论：Person 这个类，虽然不能直接调用他的抽象函数的构造函数，但是抽象类的子类却可以通过super(); 调用父类的构造函数。

11.1为什么要使用抽象类

27.为什么要用抽象类？

抽象类是一个概念。
电脑也是一个概念，电脑也有很多种，笔记本电脑也是电脑，笔记本电脑相对于电脑更抽象一点。
就像前面有一个实例的打印机，都有打开，关闭，打印，但是打印机不同，打印方法就不同，具体方式不同，所以说 Printer 是抽象的，具体哪个打印机的打印是具体的HPPrinter 和 CannonPrinter .(可以定义一个抽象类定义一个抽象的函数 abstract void Printer(); 然后通过在类中HPPrinter和CannonPrinter 复写的具体方法)。
这种在生活中常常出现，比如汽车，“开”这个方法，有手动挡和自动挡，所以需要去定义一个抽象类，减少重复代码！

注意：如果把一个类定义为抽象类，里面有一个抽象函数。如果需要继承这个父类，必须去复写这个函数，才能编译通过。

12.包和访问权限

包和访问权限

1).什么是Java 当中的软件包

1.软件包为Java类提供了命名的空间（两个类可以同名，但不同空间（文件夹））。

2.打包时需要使用package指令。

3.一个类的全名应该是“包名”+“类名”。

2).为什么要使用软件包

有两个软对分别开发，学生管理系统，和注册用户管理系统

团队A 团队B

Java 学习笔记

——在分开测试的时候没有任何问题。但一旦合并使用就会出现重名的问题。

解决方法：

1.可以使用不同的User 比如 Auser 和 Buser

2.使用软件包

12.1给一个类打包

3).如何给一个类打包

//将类放置到一个包当中，需要使用package+包名

//编译时需要使用 –d，该参数的作用是依照包生成相应的文件夹

//一个类的全名应该是”包名” + ”.” + “类名” yuan.Text 。

//即使进入到 yuan 文件夹，然后执行Text 也不行。

运行指令：javac -d . Text.java //-d依照包生成文件夹“.”代表当前目录
运行这条指令会生成yuan文件夹，生成一个 Text.class文件

运行指令：java yuan.Text。输出：打包

注意：即使进入yuan文件夹执行java Text 出错。只能运行整个类

Java 学习笔记

——包名的命名规范

1.要求包名所有的字母都要小写

2.包名一般情况下，是你的域名倒过来写

12.2JAVA当中访问权限

4).Java当中的访问权限：

1.public : 公共权限

2.private: 私有权限

3.default: 包级别访问权限

4.protected: 受保护权限

总结：

1.public可以修饰成员变量和成员函数,没有任何限制，在不在同个包都可以 访问。

2.private 可以修饰成员变量和成员函数，只能在本类当中使用

3.default(不写权限修饰符，就是default 权限)可以修饰类、成员变量和成员函数，在同一个包可以*访问，不同不可以。

1).例子：

新建一个类Person.java

public 权限的作用是什么？

新建一个Text.java 的类。

Java 学习笔记

编译：

此时编译没有问题，但是当去掉 Person 类的public 声明去掉。

Java 学习笔记

再次编译：

Java 学习笔记

出错，解释，如果一个类不是公共，那么在Text 类中就没有办法使用同一个类（前提：两个类不在同一个包中）。

2).例子：

新建一个类Person.java

新建一个Text.java 的类。

结论：（两个类在不同的包）一个类向访问另一类，被访问的类必须有public 权限，被访问的成员变量也必须有public权限。

2).private 权限

例子：新建一个类Person.java

新建一个Text.java 的类。

出错：结论：无论在不在同一个包里，如果声明为private ,只能在本类使用成员变量或者是成员函数。

3).default 包级别访问权限：什么都不声明就是default 权限

新建一个类Person.java

解析：如果Text 和Person 在同一个包当中，那么可以任意使用，使用生成对象调用类的变量问题。
注意：如果不在同一个包当中，还想访问Person 当中，在Text 中就不能访问了，除非 public 权限。

12.3如何导入一个包

如何导入一个包

例子：新建一个Text.java 的类。Person 的包在org.yuan 中

12.4包的访问权限和继承

5).访问权限与继承

1.如果父类和子类不在同一个包中，子类可以继承default 权限成员变量和成员函数，但是由于权限不够，无法使用。

2.如果希望一个包的变量和成员函数，被跨包继承的话，就需要给被继承的变量public权限。

1).新建一个类Person,给Person 打个包

2).新建一个Student 继承Person,给Student 打个包

6). protected 权限

1.protected 权限首先拥有和default 一样的功能，但是该权限只能修饰成员变量和成员函数。

总结：public > protected > default >private

13.Java 的接口（重点）

29. Java 的接口（重点）

1).什么是接口？

接口就是标准

2).接口的基本语法（一）

1.使用interface 定义

2.接口当中的方法是抽象方法（默认为 abstract（抽象方法）,用来继承）。（用一个类用来继承接口，然后复写抽象函数）

3.接口当中的所有权限都是public权限

例子：（implements(实现)是特殊的继承）

Java 学习笔记

2).接口的基本语法（二）

1.实现接口使用 implements 关键字。

2.一个类可以实现多个接口（手机可以用usb和WiFi功能）。（每个标准是一个接口）

3.一个接口可以继承多个接口。

例子：手机能用usb 跟电脑通信，又能用WiFi和电脑通信，所以这手机既支持usb接口，又支持WiFi接口。所以一个类可以实现（ipmlememts）多个接口.

实例：建立一个接口称为 USB

Java 学习笔记

再建立一个WIFI接口：

用 Phone 这个类去实现 USB和WiFi 接口

建立一个类Text 作为程序入口

Java 学习笔记

3.为什么要使用接口？

工程方法模式：

例子：打印机，新建一个打印机（Printer）的接口,然后让（HPPrinter）惠普打印机，和（Canon）打印机实现这个接口，然后通过Text作为程序的入口。

建立一个Text 的主程序入口调用

编译输出结果：

上面的Text 知识模拟一个设备而已，如果有多个设备，就会产生重复代码，而面向对象就是需要消除重复代码。那我们把重复代码打包成一个函数？

新建一个类 PrinterFactory

Java 学习笔记

在Text中调用

Java 学习笔记

如果多个设备调用只需调用：Printer printer = PrinterFactory.getPrinter(flag);如果增加了一个打印机，比如 xxxPrinter,我们只需要添加一个类，然后去实现Printer中的方法体（open 、close 、print），然后修改函数PrinterFactory 类，增加选项else if(flag == xx) 然后去实现，不需要修改Text文件，如果有多个设备调用打印机就可以避免重复代码。

14.JAVA当中的异常机制

14.1.什么是异常？

异常：中断了正常指令流的事件;是在程序运行的时候产生的（编译已经通过）；
实例：异常是如何发生的？

一个简单的例子，语法没有错误：

Java 学习笔记

但是在运行Text 的时候出现了异常（异常在运行产生）

再次修改，看是整个Text 不运行，还是被中断了：

Java 学习笔记

可以看到“1”被打印出来，而 “2” 没有打印（说明是被中断）

Java 学习笔记

14.2.异常的分类

Java 学习笔记

异常的处理

Java 学习笔记

小结：1.程序员对Error无能为力，只能处理Exception

2.对异常的处理关系到系统的健壮性能

3.使用 try...catch...finally 来处理可能出现的异常代码。

14.3.自定义异常

1.throw的作用：抛出一个异常

Java 学习笔记

编译可以通过，但是运行出现错误：

我们修改一下User.java：

Java 学习笔记

再次编译，编译没有办法通过：

小提示：

使用命令行编译运行java代码，编译时出现 “编码GBK的不可映射字符” 的错误提示，并且需输出的中文全部变为乱码，此时有两种解决方法：

（方法一）

在输入 javac 命令时，额外输入 -encoding utf-8, 例如：如果编译的源文件名为 Test.java ，那么编译时原先只需输入

javac Test.java，而现在需要输入 javac -encoding utf-8 Test.java

（方法二）

使用 EditPlus 软件编写代码时，通过修改相关设置然后保存文件即可，具体操作如下：

Document菜单---File Encoding---Convert Encoding...----ANSI，OK后保存文件 (需要保存文件，才能使设置生效)，然后编译时就无需像（方法一）那样添加 -encoding utf-8 了，可以直接 javac Test.java

Java 学习笔记

2.throws的作用：声明一个异常

再次修改User.java

Java 学习笔记

再次编译User.java,编译通过

Java 学习笔记

编译 Text.java时出现问题

Java 学习笔记

这时我们就可以用 try..catch 来处理异常了：

Java 学习笔记

15.JAVA的IO系统

15.1.I/O操作的目标

从数据源当中读取数据，以及将数据写入到数据目的地当中

Java 学习笔记

15.2.IO的分类方法

第一种分发：

1.输入流

2.输出流

第二种分发：

1.字节流

2.字符流

第三种分发：

1.节点流

2.处理流

I/O当中的核心类：

Java 学习笔记

15.3.读取文件和写入文件的方法

核心类的核心方法：

字节流方法函数：

ImputStream:

int read(byte[ ]b,int offset, int len) ------>返回读取的读取的字节数,读完数据返回：-1

OutoutStream:

void Write(byte[ ]b,int offset,int len)

例子:

新建一个文档：from.txt 和 to.txt

from.txt的内容为，路径为 g:/src/from.txt：

15.4.读取数据的方法（字节流）：

运行Text.java :

把数字转换成字符：

运行结果：

15.5数据的写入方法（字节流）:

新建一个 to.txt ,文本为空，路径为 g:/src/to.txt.

Java 学习笔记

运行后查看 to.txt:

Java 学习笔记

小结：1.I/O系统的主要目标是为了对数据进行读写操作。

2.数据的流向以Java程序为参照物。

3.I/O可以有三种分类方法。

4.read方法和write方法的用法。

15.6.大文件的读写方法

1. 改写from.txt:

Java 学习笔记

修改Text.java，把from.txt的大文件，读取到to.txt中。

Java 学习笔记

运行后，to.txt文本内容和from文本内容一模一样。

15.7.字符流的使用方法

字符流方法函数：

字符流：读写文件时，以字符为基础
字节输入流：Reader <-- FileReader
int read(char [] c,int offset,int len)
字节输出流：Writer <--FileWriter
void Write(char [] c,int offset,int len)

Java 学习笔记

15.8.节点流和处理流

1.处理流使用实例

BufferedReader对象的使用方法：

Java 学习笔记

运行Text.java

Java 学习笔记

2.装饰者（Decorate）模式

假如使用继承的话我们实现以下功能就会需要一个父类工人(Worker) 用然后水管工（Plumber）和木匠（Carpenter）去实现（implements）工人(Worker) 这个接口，然后再用（A公司水管工）和（B公司水管工）去都实现水管工（Plumber）这个类，木匠也一样采用继承的方式。目前看似我们建立的类并不多，但我们如果还有电工、水泥工等工总，还有C公司、D公司等公司，类的数量就会成几何增长，没增加一个工总和公司，增加的类就会很多，代码就会变得冗杂。

Java 学习笔记

那我们如何简化这个程序？使用装饰者模式，我们用实例说明：

1.建立一个Worker的父类接口：

Java 学习笔记

2.建立Plumber(水管工)和Carpenter(木匠)去实现工人（Worker）这个接口：

Java 学习笔记

3.接下来就到了精髓的地方了，建立一个Aworker(A公司工人) 这个类也去实现Worker(工人),这样一来水管工（Plumber）、木匠(Carpenter)、和A公司员工(Aworker)全部是工人(Worker)的子类了，我们同样去实现Worker(工人)这个接口：

Java 学习笔记

4.建立一个 Text01.java 作为程序入口：

我们试运行一下 Text01.java:

Java 学习笔记

目前我们只用了一个接口，三个类就实了A公司的功能（采用继承我们需要的是4个类），看起来好像也差不多？但是我们增加一个公司呢，使用装饰者模式，只需要增加一个类Bworker（采用继承增加两个类，随着工总和公司的增多增加类的数目成倍增长），而使用装设者模式就可以大大简化程序。

细心的可以我们前面使用处理流的时候使用的就是装饰者模式，我们再看看程序：

Java 学习笔记

FileReader 本来只能是几个字节的读取，但是有了bufferedReader之后，就可以一行一行来读取数据，其实就是在FileReader 之上加了新的功能。所以bufferedReader不仅可以修饰FileReader还可以修饰来自键盘和网络的数据！

3.节点流和处理流之间的关系

处理流是用来装饰节点流的，节点流是被装饰者，处理流是装饰者，处理流在为节点流在基础的功能上，添加新的功能。

16.内部类和匿名内部类

16.1.什么是内部类？

Java 学习笔记

编译A.java这个文件，会产生两个类文件

如何生成内部类文件的对象？

编译结果验证了内部类可以随意调用外部类的成员变量和成员函数：

Java 学习笔记

16.2.匿名内部类

例子1：

采用正常的方法，使用装饰者模式：

Java 学习笔记

用Text.java生成 B类的对象，调用成员函数：

运行Text.java

Java 学习笔记

这是正常的逻辑。

例子2：采用匿名内部类的方法

运行的结果也是一样的，只不过，这个生成的类是没有名字的，而且是在别的类里面的类，所以称为 “匿名内部类”。

再看下面一个实现Rnanable接口的例子：不使用匿名内部类方法如下：

Java 学习笔记

使用匿名内部类的方法,一对比就很容易看出端倪啦：

Java 学习笔记

17.JAVA 当中的线程

17.1.进程和线程

多线程和多进程？

多进程：在操作系统中能（同时）运行多个任务（程序）。

多线程：在同一应用程序中有过个顺序流（同时）执行。

一个应用程序有一个进程，一个进程有多个线程。

注意：线程也是一个对象。有对象就有生成对象的类。

Java 学习笔记

17.2.线程的创建方法

实现线程方法一：定义一个线程类，它继承类 Thread 并复写其中的方法 run(),方法 run( ) 称为“线程体” （由于Java只支持单继承，用这种方法定义的类不能再继承其他的类）。

Java 学习笔记

注意：如果上面调用的不是 ft.start( )方法，而是执行ft.run( )就不是多线程，而是单线程运行，结果是：先执行 FirstThread ---->0 -100 然后再执行 main---->0 - 100。

运行Text.java,两个线程无规律运行，谁抢占到CPU使用权，就是谁运行:

实现线程方法二(常用)：提供一个实现接口 Runnable 的类作为线程的目标对象，在初始化一个Thread类或者Thread子类的线程对象时，把目标对象传递给这个线程实例，由该目标对象提供线程体。

下面采用实例演示：

Java 学习笔记

运行Text.java:

17.3.线程的简单控制方法：

中断线程：

——Thread.sleep( x ms); //睡眠醒了进去就绪态，不一定运行

——Thread.yiled(); //当前线程自动让出CPU，但是此线程还会去抢cpu使用权

Java 学习笔记

设置线程的优先级：

——getPriority(); //得到当前线程优先级

——setPriority(); //设置当前线程优先级

Java 学习笔记

17.4.多线程程序运行模式

1.多线程数据安全

例子：多线程数据访问出错：

建立一个类 MyThread去实现Runnable 接口：

Java 学习笔记

建立Text.java去调用线程运行：

Java 学习笔记

运行Text.java

Java 学习笔记

如果是卖火车票的话这个数据访问就会出现很大的问题。

如何解决这个问题呢？

使用同步代码块： synchronized( this ) { }

Java 学习笔记

运行：前面的问题解决，但是出现新的问题，我们后续解释：

Java 学习笔记

17.5.深入理解synchronized关键字：

例子：新建一个类 Service.java,这个类有两个函数，全部有同步代码块，且程序会从funA()开始运行，那么就会进去休眠，且这个 this 对象被锁住，在休眠期间，funB也没有办法执行，只有等到funA()执行结束，才会轮到funB,所以说同步代码块，锁住的是对象，而不是特定某一段程序。

Java 学习笔记

再新建两个实现类（MyThread1和MyThread2）去实现Runnable接口(实现线程的第二种方法)：

Java 学习笔记

新建Text.java 作为程序入口：

Java 学习笔记

运行程序Text.java，执行java Text 语句后，程序休眠4s,才打印输出以下结果，说明funA()和funB全部被锁住了，更加说明了，同步代码块锁住的是 service 这个对象:

Java 学习笔记

为了进一步验证，我们把，funB() 里面的同步代码块去掉，看程序运行结果：

Java 学习笔记

执行结果，程序一开始就打印出了 ”执行 funB 函数“，然后过4s后才打印 ”执行 funA 函数“，没有加控制代码块的线程，正常运行，不受其他任务控制代码块的影响：

Java 学习笔记

18.JAVA数组（一维和二维）

18.1.数组的类型

18.2数组的定义方法

18.3数组的操作方法

1.一维数组静态定义方法：

Java 学习笔记

2.动态方法：

3.二维数组定义方法：

Java 学习笔记

19.JAVA的类集框架

19.1.什么是类集框架？

1.类集框架是一组类和接口

2.放置于java.util包当中

3.主要用户存储和管理的对象

4.主要分为三大类:集合、列表和映射

19.2.集合的种类：

集合（一种存储数据的方式）中的对象不安特定的方式排序，并且没有重复对象。

Java 学习笔记

列表：集合中对象按照索引位置排序，可以有重复的对象

Java 学习笔记

映射：集合中的每一个元素包含一个键对象和一个值对象，键不可重复，值可以重复。

Java 学习笔记

19.3类集框架的基础结构

Java 学习笔记

从上面的集合框架图可以看到，Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。

例子：

列表方法：

1.arrayList.add(参数1 ) //向列表添加数据，参数是需要添加的数据

2.arrayList.remove(参数1) //参数是需要移除数据的索引号

3.arrayList.size() //得到当前列表长度

import java.util.List;     //导入包
import java.util.ArrayList;

class Text{
	public static void main(String args[]){
		//生成ArrayList对象
		//和数组不同的是，这个列表不是固定死的长度
		//根据你的数据大小调节
		//ArrayList<String> 表示列表只能存放Sring类型数据
		ArrayList<String> arrayList = new ArrayList<String>();
		//向 arrayList 列表添加数据,用 arrayList.add()方法
		arrayList.add("a");
		arrayList.add("b");
		arrayList.add("c");
		arrayList.add("d");
		//使用arrayList.remove() 方法去除列表的数据
		arrayList.remove(2); //参数为索引号，去掉"c"
		
		//取出 arrayList 列表的数据,用arrayList.get()方法
		//用 arrayList.size()方法可以获取列表长度
		for(int i=0;i<arrayList.size();i++){
			String s = arrayList.get(i); //参数为索引号
			System.out.println(s);
		}
		
		
	}
	
}

运行结果Text.java：

19.4.Collection和Iteractor(迭代器)接口

Collection接口

boolean add(Object o)	向集合加入一个对象
void clear( )	删除集合当中所有对象
blloean isEmpty( )	判断集合是否为空
remove(Object o)	从集合中删除一个对象的引用
int size( )	返回集合元素的数目

Set（集合）与HashSet（Set的实现类）的使用方法：
Set是Collection的子接口。

一个例子演示函数用法：

注意：Set 不允许有重复元素，重复的话会被忽略掉

import java.util.Set;
import java.util.HashSet;//导入包

class Text{
	public static void main(String args[]){
	    //<String>称为泛型的声明
		HashSet<String> hashset = new HashSet<String>();
        //把HashSet的对象向上转型
		//子类 HashSet的对象,赋值给父类Set的引用
		Set<String> set = hashset; //只能调用Set有的方法
		//使用set的方法,增加集合成员
		set.add("a");
		set.add("b");
		set.add("c");
		set.add("d");
		set.add("d"); //重复元素，被忽略
		//集合的个数
		int i = set.size();
		System.out.println("clear之前set对象的长度"+i);
		//清空集合
		set.clear();
		//再次获取集合个数
		i = set.size();
		System.out.println("clear之后set对象的长度"+i);
	}
	
}

运行Text.java结果:

Java 学习笔记

2.Iteractor(迭代器)接口

Java 学习笔记

import java.util.Set;
import java.util.HashSet;//导入包
import java.util.Iterator;//导入迭代器包
class Text{
	public static void main(String args[]){
	    //<String>称为泛型的声明
		HashSet<String> hashset = new HashSet<String>();
        //把HashSet的对象向上转型
		//子类 HashSet的对象,赋值给父类Set的引用
		Set<String> set = hashset; //只能调用Set有的方法
		//使用set的方法,增加集合成员
		set.add("a");
		set.add("b");
		set.add("c");
		set.add("d");
		set.add("d"); //重复元素，被忽略
	    //调用Set对象的Iteractor方法，会生成一个迭代器对象，该对象用于遍历整个Set
		//需要使用泛型声明
		Iterator<String> it = set.iterator();
		// 使用it.hasNext() 方法返回一个bollean类型数值
		while(it.hasNext()){
			//使用it.next()方法获取游标下一个元素的值
			String s = it.next();
			System.out.println(s);
		}
		
		
	}
	
}

19.5.Map与HashMap的使用方法

映射（Map）：集合中的每一个元素包含一个键对象和一个值对象，键不可重复，值可以重复。

注意：JdK API帮助文档是我们非常重要的工具，里面详细介绍了API函数的用法。

在线帮助文档地址：点我查看JDK帮助文档

我们看一看Map的帮助文档，里面的解释非常详细和权威：

Java 学习笔记

最重要的方法摘要：

Java 学习笔记

咋们用一个简单的例子，调用一下这个函数：

import java.util.Map;
import java.util.HashMap;

class Text{
	public static void main(String args[]){
	  //指定泛型，两个对象，键值对，两个对象
	  HashMap<String,String> hashMap = new HashMap<String,String>();
	  //向上转型为Map类型
	  Map<String,String> map = hashMap;
	  //就可以使用map的put方法了
	  map.put("1","a");
	  map.put("2","b");
	  map.put("3","c");
	  map.put("4","d");
	  map.put("3","f"); //键值没有办法重复，键值为3的值会被"f"覆盖
	  //使用map.size()方法返回此映射中的键-值映射关系数。
	  int i = map.size();
	  System.out.println(i);
	  //使用map.get()方法，返回指定键所映射的值；
	  //如果此映射不包含该键的映射关系，则返回 null
	  String s = map.get("3");
	  System.out.println(s);
	  
	  
		
	}
	
}

运行Text.java:

Java 学习笔记

20.equals函数

20.1.equals函数在什么地方

我们可以在java安装的文件夹里的 Object.java中找到 equals函数的原形

Java 学习笔记

20.2.equals函数的作用:

那么在 equals函数中“==”的作用是什么？

操作符的作用：判断这个两个引用是否指向堆内存当中的同一个地址（对象）

例子1：

调用equals函数，：

Java 学习笔记

如果没有去复写 equals函数，和直接调用 “==”是完全一样的：

注意：User已经是继承了Object的

运行结果和我们预想的一样：

Java 学习笔记

小结：如上所述，如果这个原型equals( ) 函数只能去判断，两个引用是否指向同一个对象，如果指向同一个对象就返回 ture,否则返回 false.而并不能去比较在同一个类指向不同对象的内容是否相等。像上图所示，虽然 u1指向的对象和 u3指向的对象内容是一样的，但是在堆内存中指向的不是同一个对象，随意判定为 false.

例子2：我们试一下比较，指向不同对象，但是内容相同的对象，进行比较，看是否能得到我们想要的结果：

运行Text.java,可见和我们预想的一样，一旦指向不同对象，不管你的内容是否一样，我都返回false:

在实际应用中我们往往需要去复写equals函数,去判断对象的内容是否相等：

什么是对象的内容相等？

1.对象的类型相同（可以使用instenceof操作符进行比较）。（比如是否都为 User类，如果类不同，肯定不能比较了）。

2.两个对象的成员变量的值完全相同（比如在User类有两个变量 name 和 age）。

我们依照这两个条件在User.java中复写这个 equals() 这个方法：

class User{  
	String name;  //因为 String是引用数据类型，不能用equals进行比较内容，
	int age;      //基本数据类型用 “==” 进行比较
	//复写 equals 函数
	public boolean equals(Object obj){ 
		//this 就是调用equals函数的那个对象
		//谁能调用这个equals呢？属于User这个类,this就是User类型的。
		//所以只有User类的对象可以调用equals这个函数
		if(this == obj){ //如果在堆内存中指向同一个对象，内容一定相等
			return true; //直接返回真
		}
		//那 obj 是属于User类型的吗？
		//instanceof 关键字用于判断前面的对象是不是后面的那种类型
		//是的话返回真，否返回假
		boolean b = obj instanceof User;
		if(b){  //那么说明obj也是User类型
			//那么需要把 obj 向下转型为 User的对象
			//向下转型，能成功，因为我们知道 obj 这个对象是 User这个类生出的
			//在前面这个 obj 之所以是 Object 类型，是因为有过一次向上转型
			//现在把它转回来也是 ok 的
			User u = (User)obj;
			//接下来判断 u 对象和 this 他们成员变量的值是否相等
			//这里调用的 String类型equals()方法不是本函数的
			if(this.age == u.age && this.name.equals(u.name)){
				return true; //那就是相等的
			}
			else{
				return false;
			}
		
		}
		else{
			return false; //如果不是的话，就不用比较了
		}
	}
}

然后在Text.java 引用3个创建 User 的对象进行比较内容：

class Text{
	public static void main(String args[]){
		//创建u1、u2、u3的引用
		User u1 = new User();
		User u2 = new User();
		User u3 = new User();
		
		u1.name = "zhangsan";
		u1.age  = 12;
		
		u2.name = "lisi";
		u2.age  = 12;
		
		u3.name = "zhangsan";
		u3.age  = 12;
		
		System.out.println("u1和u2的比较结果是：" + u1.equals(u2));
		System.out.println("u1和u3的比较结果是：" + u1.equals(u3));
	}
			
}

运行Text.java，输出结果：

Java 学习笔记

所以没有去复写 equals() 函数，功能和“==” 是一样的，只能比较这两个对象是否指向堆内存的同一个地址。
小结：现在我们只需要了解复写 equals函数的方法，在后期开发当中，我们更多使用开发工具，帮我们自动生成equals 方法。

21.hashCode 和 toString方法（继承Object）

1.hashCode()的作用

什么是Hash算法？

Java 学习笔记

Hash算法的特点，可以根据唯一的散列值直接找到输入:

2.hashCode()的实现方法

我们用一个简单的例子：
在复写equals函数的基础上，增加两个构造函数，修改User.java函数：

class User{  
	String name;  
	int age;
	//新增两个构造函数
	public User(){
		
	}
	public User(String name,int age){
		this.name = name;
		this.age  = age;
	}
	public boolean equals(Object obj){ 
		
		if(this == obj){ 
			return true; 
		}
		boolean b = obj instanceof User;
		if(b){  
			User u = (User)obj;
			
			if(this.age == u.age && this.name.equals(u.name)){
				return true; 
			}
			else{
				return false;
			}
		
		}
		else{
			return false; 
		}
	}
}

然后修改Text.java类，如下,new User("zhangsan",20) 和 u 的内容用equals比较的结果为true：

import java.util.*; //导入包

class Text{
	public static void main(String args[]){
		User u = new User("zhangsan",20);
		//声明HashMap对象，指明泛型为<User,String>
		HashMap<User,String> map = new HashMap<User,String>();
		//向map对象put
		map.put(u,"abcd");
		//用equals比较new User("zhangsan",20)和 u 的结果应该为true
		System.out.println("比较结果是：" + new User("zhangsan",20).equals(u));
		//根据键得到值
		String s =map.get(new User("zhangsan",20));
		System.out.println(s);

	}
	
}

运行Text.java,可见，虽然比较结果一样，输入键值new User("zhangsan",20) 却找不到一个值对应，就是说没有找到对象的Hash码，因为键值对不是通过比较对象的内容，而是通过计算对象的HashCode去配对键值对:

Java 学习笔记

然而我们并没有去复写User.java 里面的HashCode方法，而是用默认的，则是继承过来的。按照逻辑来说我们应给认为相同的对象都认为同一个键，那我们去复写User里面的HashCode的方法。修改User.java

class User{  
	String name;  
	int age;
	//新增两个构造函数
	public User(){
		
	}
	public User(String name,int age){
		this.name = name;
		this.age  = age;
	}
	public boolean equals(Object obj){ 
		
		if(this == obj){ 
			return true; 
		}
		boolean b = obj instanceof User;
		if(b){  
			User u = (User)obj;
			
			if(this.age == u.age && this.name.equals(u.name)){
				return true; 
			}
			else{
				return false;
			}
		
		}
		else{
			return false; 
		}
	}
	//对于不同的对象生成hashcode的数值是不一样的
	//对于用equals相比结果为ture的对象来讲hashCode是一样的
	//因为为true则，name和age肯定是一样的，那么返回result的值肯定是一样的
	public int hashCode(){
		int result = 17; //初始值为除0外的素数
		
		result = 31 * result + age;
		result = 31 * result + name.hashCode(); //调用String的hashCode方法
		return result;
	}
}

修改Text.java:

import java.util.*; //导入包

class Text{
	public static void main(String args[]){
		User u = new User("zhangsan",20);
		//声明HashMap对象，指明泛型为<User,String>
		HashMap<User,String> map = new HashMap<User,String>();
		//向map对象put
		map.put(u,"abcd");
		//用equals比较new User("zhangsan",20)和 u 的结果应该为true
		System.out.println("比较结果是：" + new User("zhangsan",20).equals(u));
		
		//根据键得到值
		String s =map.get(new User("zhangsan",20));
		System.out.println("得到的键值为："+s);

	}
	
}

运行Text.java,因为hashCode被复写了，对象 u 和:new User("zhangsan",20) 得到相同hashCode，所以键值对能够匹配，跟equals函数相同，后期我们大多都是用软件自动生成代码的：

Java 学习笔记

3.toString()的作用

Java当中的toString函数

以下代码的运行结果：System.out.println("abc") ------>打印 abc 字符

其实toString是Object类的函数，意味着所有的类都继承了这个函数，所以都能进行复写！

那么下面两行呢？

User u = new User();

System.out.println(u);

以上代码执行的时候，实际是调用u的toSring方法。我们是实例看一下：

Java 学习笔记

4.toString()实现方法

那我们在User.java中复写一下toString方法：
修改User.java如下：

class User{  
	String name;  
	int age;
	//新增两个构造函数
	public User(){
		
	}
	public User(String name,int age){
		this.name = name;
		this.age  = age;
	}
	public String toString(){
		String s = "name:"+name+",  age:"+age;
		return s;
	}
}

修改Text.java,如下：

import java.util.*; //导入包

class Text{
	public static void main(String args[]){
		User u = new User("zhangsan",20);
		//当你打印一个字符串的时候，首先会调用这个类的toSring方法
		System.out.println(u);

	}
	
}