1.md · fafnir/JavaNotes

# Java基础

author [fafnir](http://git.oschina.net/fafnir)

--------------------------------------------------------------------------------

- 1. java 的数据类型转换

- 2. && || 和 & |

- 3. 交换两数字

- 4. 移位操作

- 5. switch语句

- 6. 键盘录入

- 7. 循环

- 8. break 和 return

- 9. 方法

- 10. 数组

- 11. 内存分配

- 12. 参数传递

- 13. 命名规范

- 14. 面向对象堆栈分析

- 15. 成员变量和局部变量

- 16. 匿名对象

- 17. 封装

- 18. 构造方法

- 19. 静态static

- 20. 主方法

- 21. lang包

- 22. 代码块

- 23. 继承extends

- 24. 方法的重写升级

- 25. final

- 26. 多态

- 27. 抽象

- 28. 接口

- 29. package

- 30. 修饰符

- 31. 成员内部类

- 32. 局部内部类

- 33. 匿名内部类

- 34. 链式编程

- 35. Object类

- 36. Scanner类

- 37. String类

- 38. StringBuffer类

- 39. append方法

- 40. insert，deleteCharAt，delete，substring方法

- 41. String和StringBuffer的相互转换

- 42. StringBuilder类

- 43. Arrays类

- 44. 基本数据类型的包装类

- 45. String 和 int 的相互转换

- 46. 自动装箱和自动拆箱

- 47. 自动装箱时Integer对象的存储

- 48. java中的正则表达式

- 49. Math类

- 50. Random类

- 51. System类

- 52. BigInteger和BigDecimal类

- 53. Date类

- 54. DateFormat类

- 55. Calendar类

- 56. Collection接口和Iterator接口

- 57. List接口

- 58. ListIterator接口

- 59. 数组和链表

- 60. 去除ArrayList中的重复值

- 61. 链表LinkedList类

- 62. LinkedList进栈出栈的模拟

- 63. 泛型

- 64. 泛型类和泛型方法

- 65. 泛型接口

- 66. foreach

- 67. 静态导入

- 68. 可变参数

- 69. asList()方法

- 70. HashSet类

- 71. LinkHashSet类

- 72. TreeSet类

- 73. Comparator比较器

- 74. Map类集合

- 75. Map.Entry 内部接口

- 76. LinkedHashMap类

- 77. TreeMap类

- 78. Map统计

- 79. HashMap嵌套

- 80. Hashtable类

- 81. Collections集合工具类

- 82. 高级泛型

- 83. 异常捕获

- 84. 编译时异常和运行时异常

- 85. Throwable类里的常见方法

- 86. throws方法处理异常

- 87. throw和throws区别

- 88. finally

- 89. final finally finalize

- 90. 自定义异常

- 91. 父类和子类的异常

- 92. File类

- 93. File筛选文件

- 94. IO流处理文件

- 95. IO图片处理

- 96. 音频处理

- 97. 数组容器拷贝

- 98. BufferedInputStream和BufferedOutputStream类

- 99. flush和close方法

- 100. 读写中文

- 101. IO流标准异常处理

- 102. 字符流

- 103. BuffereReader和BufferedWriter类

- 104. LineNumberReader类

- 105. 装饰设计模式

- 106. 字符流指定编码表

- 107. IO流统计字符

- 108. 计算文件夹大小

- 109. SequenceInputStream类

- 110. ByteArrayOutStream类

- 111. 对象IO流

- 112. IO流加入Id号

- 113. 打印流

- 114. 标准输入输出流

- 115. 随机访问流

- 116. 数据输入输出流

- 117. Properties类

- 118. Thread类

- 119. 多线程的方法

- 120. 线程休眠

- 121. 守护线程

- 122. 加入线程

- 123. 同步代码块

- 124. 同步方法

- 125. 多线程的线程安全

- 126. 死锁

- 127. setPriority()方法

- 128. yield()方法

- 129. 单例设计模式

- 130. Runtime类

- 131. TimerTask类

- 132. 线程等待唤醒机制

- 133. ReentrantLock类

- 134. 线程组和线程池

- 135.Callable接口

--------------------------------------------------------------------------------

_1\. java 的数据类型转换_

```java
byte a = 3 ,b = 4, c; c = a + b; //报错：a,b 是变量，jvm不知道具体值，按byte进行运算时转换为为int类型
final byte a = 3, b = 4; //正确：a和b是常量，jvm可以找到实际值进行优化，同3 + 4
c = 3 + 4; //3 + 4 由于jvm优化极致被认为是 7，在byte范围内
short s = 1; s = s + 1; //错误：short进行运算的时候转为int
short s = 1; s += 1; //正确：相当于赋值操作，进行了类型转换
long l = 100L;   //注意加L
float f = 0.1f;  //注意加f
```

_2\. && || 和 & |_

```
&& || 是短路与和短路或(短路机制)，&和|是逻辑与和逻辑或(全都运算)
```

_3.交换两数字_

```
1.第三方变量
2.x = x + y; y = x - y; x = x - y;
3.x = x ^ y; y = x ^ y; x = x ^ y; //一个数异或另一个数两次就等于它本身
```

_4.移位操作_

```
高效率计算二乘八
2 << 3 //移位运算，对2的二进制操作
左移 m 位为乘以 2^m, 右移为除
<<< 为有符号移位, 当为负数时右移补1
<<  无符号移位, 只补0
```

_5.switch语句_

```java
switch(s){
  case "yes":
    System.out.println("yes");
    break;
  case "no":
  case "n":
    System.out.println("no");
    break;
  default:
    System.out.println("None"); //永远先判断default，最后判断case, 中间必须有break
 }
```

_6.键盘录入_

```java
import java.util.Scanner;                //1.导入包

public class TestScanner {

public static void main(String[] args) {
    Scanner s = new Scanner(System.in);  //2.创建对象
    System.out.println("请输入字符串：");

while (true){
      String line = s.nextLine();        //3.录入 next,nextInt,nextDouble,nextLine等方法
      if (line.equals("exit"))
        break;
      System.out.println(">>>" + line);
    }                                   //http://www.runoob.com/java/java-scanner-class.html
  }
}
```

_7.循环_

```java
for(int i = 0; ;){} //i只为了循环而定义，建议for，明确次数，for可以将初始化拿进来
while(i--){};       //i还有别的意义，不明确次数  while不可以在内初始化
do{} while();       //至少有一次执行
```

_8.break 和 return_

```java
class Hello {
  public static void main(String[], args) {
    for(int i = 0; i < 5; i++){  
      if(i == 3)
      //break    为break时结束循环 有 “执行”
      return;    //为return时，结束方法 无 “执行”
    }
    System.out.println("执行")
  }
}
```

_9.方法_

```
1.不能嵌套定义
2.void 方法 JVM 会自动加上 return;
```

_10.数组_

```java
 //一维数组的遍历操作
int[] arr1 = new int[5]; //数据类型+[]+数组名  动态初始化，没有赋值
//必须先初始化才能使用  new 来创建对象 必须有长度，在内存画出连续的五个空间
int[] arr2 = new int[]{1,2,3}; //静态初始化  堆中线默认初始化0，仔赋值
int[] arr3 = {1,2,3}; //静态初始化的简写，必须在一行(静态)

for(int i = 0; i < arr.length; i++) {
  System.out.println(arr[i] + ' ');
}
```

```java
//数组反转
public static int[] revArray(int[] arr) {
  for(int i = 0; i < arr.length/2; i++) {
    int temp = arr[i];
    arr[i] = arr[arr.length-1-x];
    arr[arr.length-1-x] = temp;
  }
  return arr;
}
```

```java
int[][] arr; //二维数组 声明
int[] arr[]; //二维数组
int[] x,y[]; //一维数组和二维数组

int[][] arr = new arr[2][3]; //矩形二维数组

int[][] arr = new arr[3][]; //自定义二维数组
int arr[0] = new arr[2];
int arr[1] = new arr[3];
int arr[2] = new arr[4];

int[][] arr = {{1,2,3},{1,2},{1,2,3,4}}; //静态初始化
```

```

数组地址:
  [I@1afb7ac7 '['的个数为数组维数，'I'为类型，@分配符，后面十六进制地址
  当数组声明未null时，打印地址会有空指针异常，说明未分配地址

二维数组在堆栈中:
  一维数组是引用数据类型，引用数据类型初始值为null
  第一维在堆中存储进第二维的地址值
  第二维存储值
```

_11.内存分配_

```
局部变量(方法中和方法上的) 在栈内存(stack)
new出来的对象在堆内存 只有new出来的对象才会在堆中开辟空间

步骤:
  1.运行时JVM开出一个栈空间一个堆空间
  2.每个方法都是一个栈帧，主方法先进栈(压栈)
  3.在栈帧中 声明的变量在栈，而new出来的实体对象存储在堆
  4.堆中默认初始值 整数0，小数0.0，布尔false，字符\u'0000'(unicode，16进制的0000，char2个字节，2*8位), 引用数据类型都是null
  5.堆的地址给了栈，把存储的数据和变量名对应出来

垃圾回收:
  没有栈中的引用指向的堆会被JVM垃圾回收机制处理(不定时回收)
  栈中当主方法弹栈就意味程序结束，堆中全为垃圾
  从栈中弹出不会变成垃圾，弹出就会消失

主方法作为栈帧压入，主方法调用了f1方法，f1栈帧又被压入栈，然后……fn压入执行完毕后，先弹出fn 先入后出原则
arr3[] = arr2[]时, arr3[]不再在堆中开辟空间，而是传入地址值
```

_12.参数传递_

```java
public static void main(String[] args) {
  int a = 10, b = 20;
  changeInt(a, b);
  int[] arr = new int[]{1,2};
  changeArray(arr);
}

public static void changeInt(int a, int b) {
  a = b;
  b = a + b;
}

public static void changeArray(int[] a) {
  a[0] = 2;
}
```

```
java传值，因为地址值也是值

堆栈分析:
  main压入栈，基本变量a,b在main栈帧中；
  changeInt压入栈，成员变量a,b在changeInt栈帧中，改变该栈帧中的数据，chachangeInt弹栈:原数据不变
  引用数据类型arr变量在栈中，new出的对象值存储在堆中，stack中存储地址
  changeArray压入栈，a变量在changeArray栈帧中，通过调用，arr对应heap中地址传给a，修改地址对应的值，changeArray弹栈，main弹栈:原数据改变
```

_13.命名规范_

```
类名接口名  大驼峰
方法名和变量名 小驼峰
```

_14.面向对象堆栈分析_

```java
public class MakePerson{
  public static void main(){
    Person p1 = new Person();
    p1.name = "fafnir";
    p1.speak(p1.name);
  }
}
public class Person{
  String name;
  int age;
  public void speak(name){
    System.out.println("hello, I'm " + name)
  }
}
```

```
  MakePerson.class加载进入方法区(存储java的字节码文件(.class))
  main方法进栈，执行到 Person p1 = new Person时，会找Person.class(没有.class就用jvm编译.java文件)
  Person进入方法区
  在steak中出现Person类型的变量(引用数据类型的局部变量)，new出的实体在heap中，属性(name,age)在heap中，默认属性值
  p1.name = "fafnir", p1包含地址值，可以找到heap中对应的部分修改
  speak()进栈，通过p1调用，所以该方法可以记住p1的地址值，相应的使用属性
  speak()弹栈，main()弹栈；
```

_15.成员变量和局部变量_

```java
public class Person{
  int x = 10; //成员变量
  public static void main(){
    int x = 10; //局部变量
  }
}
```

```
成员变量在类中，方法外，局部变量在方法内
  方法弹栈，局部变量消失
成员变量属于对象的，在heap中；局部变量属于方法，在steack中
  没有指向时，被垃圾回收
```

_16.匿名对象_

```java
public class Car{
  String name;
  String color;
  public static void run(){}
}
public void Show(Car){}

//简化一次调用的情况
Car c1 = new Car();
c1.run();

new Car.name = "Benz";   //在heap中开辟了三个内存，前两个赋值后就被垃圾回收机制回收
new Car.color = "black";
//两种匿名对象的方法调用
new Car.run();   //run弹栈后改空间被回收
Show(new Car()); //作为参数传递
```

```
匿名对象使用属性没有意义，调用方法可以减少代码，仅适用于一次调用
```

_17.封装_

```java
//1.private封装
class Person{
  private name;  //private只能在本类访问
  public String getName(){  
    return name;
  }
  public void setName(name){
    this.name = name;  //this关键字 代表当前对象的引用  主要应用于成员变量和局部变量重名的情况
    //setName进栈后this在该栈帧中，调用时将调用它的对象的地址给了this
  }
}
Person p = new Person();
p.setName("fafnir")
```

_18.构造方法_

```java
public Person(){}//没有自定义构造方法时，系统默认给一个空参构造方法
public Person(name){}//自定义构造方法后系统不再给默认空参构造方法，要自己定义一个空参的构造  构造方法不能有返回值类型
//空参构造方法用于只调用里面的方法
public Person(){
  this("张三"); //this调用本类的其他构造方法
}
```

```
class加载进内存方法区
声明一个引用类型s
在堆内存创建对象，初始化值
栈内存压入构造方法栈帧，对对象属性赋值，构造方法弹栈
将对象地址值赋给s
```

_19.静态static_

```
有static的静态方法不需要实例化对象就可以调用
没有则必须有new出的对象

静态属性随着类的加载而加载，在字节码文件中，优先于对象，所有创建的对象共享(共性用静态)
  static可以由类来调用(推荐)，也可以由对象调用，但是非静态只能用对象调用
方法区(字节码文件)有共享区(static修饰，解压缩文件)和非共享区(普通变量和方法，压缩文件)，对象实例化相当于解压缩文件

主要作用是节省了内存空间，只在方法区存在一个，不会再heap中创建多个

非静态的方法可以访问静态成员，但静态方法不能访问非静态成员(非静态成员是属于对象的，静态优先存在方法区，不能往后访问非静态)，也不能使用this
```

_20.主方法_

```java
public static void main(String[] args){  //主方法由jvm调用，权限足够大，不需要对象static修饰，不需要返回值
//main是主方法不是关键字，但是jvm会识别找到入口，jvm传入了了一个String空字符串(长度为0，args明可改)
}
//args 以前用来接收键盘录入(现在不需要)
```

`javac Hello.java` `java Hello 向args输入的字符串`

_21.lang包_

```
lang中的类都不需要导包

…………待补充
```

_22.代码块_

```
{}内的代码
1.局部代码块(写在方法里)，用于限定变量的生命周期 //开发时基本不用
2.构造代码块(写在类中方法外)，先执行构造代码块，后调用构造方法，创建*对象*自动调用，用于相同属性和相同行为 //开发中基本不用
3.静态代码块，随着*类*的加载执行一次，静态代码块优先于主方法来执行 //用于加载驱动
```

_23.继承 extends_

```java
public class Animal{
  public Animal(){};
  String color;
  String sleep(){}
}
public class Cat extends Animal{  //继承Animal
  public Cat(){
                          //默认 会有super(); 所有构造方法都有，都从object类继承下来，默认空参构造函数
  }
  String  number;
}
```

```
1.Ad:提高了代码的复用性，维护性，使类和类产生了关系
  DisAd不符合高内聚低耦合的原则
2.只支持单继承，不支持多继承，但可以多层继承，然后创建底层对象
3.只能继承非私有成员，
  不能继承构造方法，但可以用super关键字，super.name-->父类; name-->子类; this.name-->子类/父类(子类没有时，把父类拿下来当成自己的)
4.要不为了部分功能而继承
5.共名就近原则，子类没有则从父类找
6.super this 都要放在构造函数第一句  //初始化
```

```
子父类方法重名-->重写/重载，想访问父类，使用super.
语句必须放在方法里，但是定义可以放在方法外类里
```

_24.方法的重写升级_

```java
public class Iphone4{
  public void speak(){
    System.out.println("hello world");
  }
}
public class Iphone4s extends Iphone4{
  public void speak(){
    super.speak();  //继承父类  升级父类方法
    System.out.println("你好");
  }
  public void static print(){}
}
class Iphone5 extends Iphone4s{
  public void speak(){}//子类权限必须必父类大
  public void static print(){}//父类静态方法子类必须也是静态 静态覆盖静态
}
```

_25.final_

```
1.final修饰的类不可被继承，修饰的方法不可被重写。修饰的变量是常量(变量名大写)
2.final修饰基本数据类型变量-->不可再改变值，引用数据类型-->final Person p1 = new Person("张三"); p1地址值就被指定不可再改变，但可以用setName()方法更改属性
3.final修饰的变量  定义时显示初始化，或者在构造方法中赋值
```

_26.多态_

```java
class Animal{
  public void eat(){}
}
class Cat extends Animal  //继承
  public void eat(){}     //重写
}
Animal a = new Cat();     //父类引用指向子类对象
a.eat(); //调用了Cat里的eat()
```

```
多态的三个前提：继承，重写，父类引用指向子类对象

成员变量 编译看左边，运行看左边
      内存: 在heap中引用变量申请的空间有一部分是super空间，整个属于this空间
      Animal a = new Cat(); a只能访问到super空间的变量
成员方法 编译看左边，运行看右边 //动态绑定
      编译看父类有没有，运行看子类有没有重写
静态成员方法 编译看左边，运行也看左边 都是父类
      静态方法属于类，不能被覆盖

只有成员变量才会存在多态
```

```java
class Test {
  public static void main(String[] args){
    Person p = new SuperMan(); //父类引用指向子类对象 向上转型自动类型转换
    p.name;//成员变量为父类  --> John
    p.speak();//成员方法为子类的speak
    SuperMan sm = SuperMan(p);//向下转型 强制类型转换
    sm.fly();//使用子类特有的方法
  }
}
class Person{
  String name = "john";
  public void speak();
}
class SuperMan extends Person{
  String name = "SuperMan";
  public void fly();
}
```

```
Test加载进内存，主方法进栈，Person.class(speak())和SuperMan(speak(),fly())进方法区
heap加载进SuperMan,其中包含一段为super空间(Pesron),一段为子类特有属性，整个为SuperMan
p.name --> super内的地址  //编译看父类，运行也看父类
p.speak() --> 多态成员方法//便宜看父类有没有speak方法，运行时运行子类的speak
SuperMan sm = SuperMan(p);没有new,因此只是把p提升，可以访问整个SuperMan在heap中的内存空间

多态多用于 传入一个大的类，然后把他的子类传进来，调用成员方法来使用子类(不能调用子类特有方法，必须向下转型)，在继承时可减少父类方法
```

_27.抽象_

```java
abstract class Animal{ //抽象类 抽象类中可以没有抽象方法
  public abstract void eat(){} //空代码块 抽象方法 抽象方法必须在抽象类中
}
class Cat extends Animal {
  public void eat(){
    System.out.println("Eat Fish");
  }
}
public class Test(){
  public static void main(String[] args){
    Animal a = New Cat();
    a.eat(); //
  }
}
```

```
抽象类不能创建对象，没有抽象方法的抽象类作用是不让其他类创建本类对象，只能交给子类完成
作用：制定一种规则，强制子类重写限制命名，所继承的抽象类中抽象方法必须被重写，负责就要abstract抽象类(抽象方法必须在抽象类中)
不能和abstract关键字共存的的关键字:
  1.private(不让子类看到)，abstract(让子类重写)
  2.static(可以用类名调用)，abstract(类名调用抽象方法没有意义)
  3.final(不允许子类重写)，abstract(就是为了让子类重写)
```

_28.接口_

```java
interface Inter1{ //大驼峰
  void print();// public abstract 接口中所有的方法都是抽象的
  public abstract void print(); // <--
  int num = 10; //默认为 public static final int num 三个关键字 接口中所有的变量都是常量
  public static final int num; // <--
}
class Demo implements Inter1{
  public void print(){
    System.out.print("yes"); //必须要重写接口中的方法
  }
}
interface Inter2{}
class A{}
class B extends Demo{} //类和类之间是继承只能单继承 防止两个类有相同的方法有安全隐患
class B implements Inter1, Inter2{}//类和接口之间是实现，可以单实现也可以多实现 即使有相同的方法也是抽象没有具体方法体，相当于同时覆盖两个
interface Inter3 extends Inter1,Inter2{} //接口可以多继承
```

```
用于制定规则, 对外提供规则，所有的常量和方法都是public，所以重写的权限必须也是public
抽象类和接口
 成员区别
    抽象类
      可以有变量也可以有常量//和普通类相同
      构造方法：有，给子类对象进行初始化
      成员方法：可抽象也可以非抽象
    接口 常量，抽象
  关系区别：
    类和类：单继承
    类和接口：单实现，多实现
    接口和接口：单继承，多继承
  设计理念：
    抽象类：共性功能，每个对象都需要具备(is a)
    接口类：扩展功能，
```

```java
class abstract Animal{}
interface GuardHouse{}
interface CatchMouse{}
interface Swimming{}
class Dog extends Animal implements GuardHouse,Swimming {} //抽象类是共性。接口是扩展
```

_29.package_

```java
package net.oschina; //必须在第一行声明包名
import net.oschina.Demo; //导入oschina里Demo类 可以用Demo实例化对象
import net.oschina.*;//导入所有的类
```

`javac -d . HelloWorld.java` 根据HelloWorld里的导包在当前目录创建包

```
将字节码文件(.class)进行分类存放
将.class放在net/oschina里面
在文件夹外运行 java net.oschina.hello
被导入的包里面的类必须声明为public，方法也是public
```

_30.修饰符_

![chart](http://chuantu.biz/t6/31/1504247683x2728278590.png)

```
* A:修饰符：
    * 权限修饰符：private，默认的，protected，public
    * 状态修饰符：static，final
    * 抽象修饰符：abstract
* B:类：
    * 权限修饰符：默认修饰符，public      //私有就无法创建对象
    * 状态修饰符：final                  //最终类，不可继承
    * 抽象修饰符：abstract               //抽象类

* 用的最多的就是：public

* C:成员变量：
    * 权限修饰符：private，默认的，protected，public
    * 状态修饰符：static，final

* 用的最多的就是：private    //提供set,get方法

* D:构造方法：
    * 权限修饰符：private，默认的，protected，public

* 用的最多的就是：public     //类中所有方法都是静态时私有构造方法，不创建对象，ClassName.来调用

* E:成员方法：
    * 权限修饰符：private，默认的，protected，public
    * 状态修饰符：static，final   //静态成员方法    不让子类重写
    * 抽象修饰符：abstract        //抽象成员方法

* 用的最多的就是：public

* F:除此以外的组合规则：
    * 成员变量：public static final  //常量
    * 成员方法：
        * public static          //静态
      * public abstract        //抽象
        * public final           //最终
```

_31.成员内部类_

```java
class Outer{
  private num = 1;

class Inner{                 //成员内部类
    public void speak();
    System.out.println(num);   //内部类可以直接访问外部类不用创建对象，并且可以访问private变量 num代表了 Outer.this.num
  }

private class PrivateInner{   //私有成员内部类
    number = 1;
  }
  public void print(){    //在内部创建对象  写在一个方法里
    PrivateInner pi = new PrivateInner();  //创建了一个成员内部类对象
    System.out.println(pi.number);
  }

private class StaticInner{  //静态成员内部类
    number = 1;
  }

// class Inner2{   -->  非静态成员内部类不能定义静态方法  成员在实例化对象时加载进内存，而static在类进入方法区就会创建，因此不能
  //   public static void speak(){};
  // }

}

class Demo{
  public static void main(String[] args){
    Outer.Inner i = new Outer().new Inner(); //内部类成员不能直接访问，外部类访问内部类成员必须创建对象
    i.speak();

Outer o = new Outer();  //内部私有成员变量，定义方法，创建外部类对象，调用方法
    o.print();

StaticInner si = new Outer.StaticInner();  //静态内部类直接使用外部类调用，不需要外部实例化对象
  }
}
```

```
内部类可以私有但是外部类不能私有
```

```java
//要求：使用已知的变量，在控制台输出30，20，10。

class Outer {
  public int num = 10;
  class Inner {
    public int num = 20;
    public void show() {
      int num = 30;
      System.out.println(num);       //就近
      System.out.println(this.num);  //访问内部类本身的成员变量
      System.out.println(Outer.this.num); //内部类把持外部类的引用
    }
  }
}
class InnerClassTest {
  public static void main(String[] args) {
    Outer.Inner oi = new Outer().new Inner();
    oi.show();
  }
}
```

_32.局部内部类_

```java
class Outer{
  public int method(){
    final methodnum = 1;    //jdk1.7版本需要声明final，jdk1.8不需要
    class Inner{            //局部内部类，在方法中的类
      int num = 1;
      public void print(){
        System.out.println(methodnum);  //内部类访问外外部类变量
      }
    }
    Inner i = new Inner(); //在成员方法中实例化对象，因为在成员方法外会消失
    return i.num;
  }
}

class InnerClassTest {
  public static void main(String[] args) {
    Outer o = new Outer();
    int num = o.method();  //拿到了成员内部类的num
  }
}
```

```
final methodnum解释
InnerClassTest进方法区，主方法进栈，Outer.class进方法区，
在主方法栈帧中创建了o对象指向heap中的一块地址0x0011
method进栈:
如果不加final: methodnum在栈帧中，Inner加载进方法区，new出的i进堆指向0x0022地址，i.print(),调用了print方法进栈
            在print栈帧中有this,记录了0x0022地址，执行print()输出methodnum = 1;
            后print，method会弹栈，但堆中的两个对象不会马上消失(等待垃圾回收)
            其中的Inner对象就调用不了已经弹栈的method方法，就再找不到method栈帧中的methodnum
使用了final: 常量会进入方法中的常量池,这时不再存储在method栈帧中，method弹栈不会产生影响
```

_33.匿名内部类_

```java
/*两个接口*/
interface Inter{
  public void print(){}
}
interface Inter2{
  public method1(){}
  public method2(){}
}
/*有名字的内部类实现外部接口*/
class Outer{
  class Inner implements Inter{    //成员内部类 实现接口
    public void print() {          //重写接口中的方法
      System.out.println("HelloWorld");
    }
  }
  public void method(){
    Inner i = new Inner();
    i.print();
  }
/*******进行简化*******/
/*匿名内部类    没有类还能实现接口*/
  public void method(){
    new Inter(){        //new Inter{}相当于实现了Inter接口，该部分代表了Inter的子类对象，相当于"有名字的内部类实现外部接口"中的new Inter
      public void print(){
        System.out.println("HelloWorld");//重写接口内的抽象方法
      }
    }.print();   //调用方法
  }
  /*内部匿名类接口中多个方法*/
  Inter2 i = new Inter2(){   //父类引用指向子类对象  -->Inter2 i = new Inner();Inter2是Inner的父类，Inner实现了Inter
    public method1(){
      System.out.println("Hello,");
    }
    public method2(){
      System.out.println("world");
    }
  };
  i.method1();
  i.method2();
}
```

`new Inter(){} -->实现这个接口或者继承这个类，{}内是要重写的抽象方法`

```
匿名内部类的写法:
    new 接口或者类名(){
      需要重写的方法
    }.调用的方法

前半部分就相当于一个实例化的对象，但是并没有给起名字

建议只有一个方法的时候使用匿名内部类，匿名内部类不能调用特有的方法(弊端)

匿名内部类可以当作参数传递的实例(使用较多)，可以不用单独定义一个类去继承Person抽象类
```

```java
abstract class Person{
  public void show(){}
}
class PesronDemo {
  public void method(Person p){
    p.show();
  }
}
class Demo {
  public static void main(String[] args){
    /*调用method方法*/
    PersonDemo pd = new PersonDemo();
    pd.method(new Person(){    
      public void show(){
        System.out.println("HelloWorld");
      }});
  }
}
```

_34.链式编程_

```java
interface Inter{
  abstract void show();
}
class Outer{
  public static Inter method(){   //Inter i = Inter的子类对象
    return new Inter(){           //返回一个Interde子类对象,有一个自动类型提升
      public void show(){
        System.out.println("HelloWorld");
      }
    };
  }
}
class Demo{
  public static void main(String[] args){
    Outer.method().show();          //编译看interface的show, 运行看子类对象的show()
  }
}    //调用一个方法返回了一个对象，这个对象还可以继续调用方法
```

_35.Object类_

```
位于lang包中，是所有类层次结构的根类，每个类都使用object作为超类
构造方法 object();

getClass(),getName(),toString()，hashCode(),equals(Object obj)方法
```

```java
class Demo{
  public static void main(String[] args){
    Object obj = new Object();
    int x = obj.hashCode();   //hashCode方法，返回该对象的哈希码值，该方法会根据对象的地址来计算
    System.out.println(x);
    Person p1 = new Person();
    Class c = p1.getClass();   //返回当前对象的运行时类(字节码文件)，class是字节码文件的类型
    String name = c.getName(); //以String的形式返回Class对象的名字，c(Class类表示p的运行时类即Person类)
    String s = p1.toString();  //获取所属对象的类名 @ 16进制的hash值
    System.out.println(s);    //可以简化
    System,out.println(p1);   //默认调用Object类的toString方法，只有在打印的时候会默认调用，赋值的时候不会
    //toString方法一般会重写
    Person p11 = new Person();
    boolean b = p1.equals(p11);  // 判断是否是一个对象，比较地址值，一般进行重写
  }
}
class Person{
  int age;
  /*equals如果没有重写，equals方法就和" == " 没有区别，因为在Object类中equals就是 == 实现的*/
  public boolean equals(Object obj){   //Object obj = new Person(); 父类引用指向子类对象，自动类型提升没有风险，创建的是Person，有Object的属性
    Person p = (Person)obj;  //强制类型转换，向下转型，将object赋予了Person的属性，有风险
    //开始进入的是Object类，Object中没有name等属性，必须向下转换到Person类型
    return this.name.equals(p.name) && this.age == p.age;  //字符串的equals方法(引用数据类型使用方法比较)，基本数据类型使用 == 比较    this.(调用的对象的属性)  name,age(传入的对象的属性)     在String里有equals方法，比较字符串序列    " == "比较引用数据类型比较的是地址
  }
}
class Person2{
  String name;
  int age;
  public String toString(){          //重写用于展现里面的属性值
    return "名字是"+name+" 我的年龄是"+age;  
  }
}
```

_36.Scanner类_

```
位于java.util包内，应用时必须要导包 由final修饰
```

```java
Scanner sc = new Scanner(System.in);
// int x = sc.nextInt(); 不能判断接受
if (sc.hasnextInt()){   //hasnextInt()判断是否是Int数据类型，返回true or false
  int x = sc.nextInt();
  System.out.println(x);
}else {
  System.out.println("输入错误");
}
String line = sc.nextLine(); //输入字符串

/*nextLine通过判断换行来判定结束，在先nextInt接收后就不能用nextLine()接受*/
sc.next();//遇到空格结束
sc.nextLine();//遇到回车结束
```

_37.String类_

```java
class Demo{
  public static void main(String[] args){
    String s1 = new String(); //空字符串 --> String s1 = ""; 有地址值，但没有存储值
    String s3 = null; //空指针，没有地址，不是一个对象
    System.out.println(s3); //判断，如果是null会返回null

byte[] arr = {97,98,99};     //字节数组
    String s = new String(arr);  //对字节数组解码 --> 形成字符串
    System.out.println(arr);  // a b c
    //String(byte[] bytes,int offset,intlength); 参数为 要解码的字节数组，开始解码的索引，要解的个数   也可以对字符数组同样操作
    char[] arr = {'a','b','c'};
    String s = new String(arr); //字符数组转化为字符串

String s = new String("HelloWorld"); //创建副本，与参数相同

String s1 = "Hello";
    String s1 = "Hello";
    System.out.println(s1 == s2);//-->true
    //堆栈分析，String s1 = "Hello"进入方法区的常量池，在创建s2时会现在常量池中找是否有"Hello",有的话直接把常量池的地址值给s2

String s1 = new String("abc");//堆栈分析
    // 主方法进栈，栈帧中有s1变量，对于String类型特有的是:"abc"先进方法区的常量池，(如果原来常量池没有"abc"的话)，然后new出的空间在heap,常量池中"abc"的副本拷贝给new 出的地址值，堆的地址再赋给栈帧中的s1
    //因此会创建两个对象，记住的都是heap中的副本
    String s0 = "ab";
    String s2 = "abc";
    String s3 = "a"+"b"+"c";  //常量优化，便宜的时候已经是"abc"字符串
    String s4 = s0 + "c";
    //s1 != s2 == s3 != 4
    //字符串串联 " + " :先创建一个StringBuffer对象(heap)，该对象有一个append方法，追加了"c";然后又在heap中创建了String对象(toString()方法)
  }
}
```

```
所有的字符串都是String的实例化对象
字符串是常量，创建后不能更改(再次赋值就相当于重新new了一个对象，原来的变成垃圾)
String类重写的toString方法，返回该对象本身(一个字符串)
```

_38.StringBuffer类_

```
线程安全的可变字符序列
原理:构造了一个缓冲区，创建了一个长度为16的char数组，装满后会增长
```

```java
class Demo{
  public static void main(String[] args){
    StringBuffer sb = new StringBuffer;
    System.out.println(sb.capacity()); //capacity -->容器大小
    System.out.println(sb.length()); //length -->实际值

StringBuffer sb2 = new StringBuffer(10); // 参数为指定的容器大小
    StringBuffer sb3 = new StringBuffer("HelloWorld"); //把字符串作为初始化的一部分
    System.out.println(sb3.capacity()); // --> 26
    System.out.println(sb3.length()); // --> 10
  }
}
```

_39.append方法_

```
public StringBuffer append(String str){}  --> 定义  可以把任何类型的变量追加到字符串
```

```java
class Demo{
  public static void main(String[] args){
    StringBuffer sb = new StringBuffer();
    StringBuffer sb2 = sb.append(123);  //没有重新创建对象，都是在同一个缓冲区添加
    StringBuffer sb3 = sb.append(true);
    sb.append("hello"); //也可以不进行接收

System.out.println(sb); //输出 --> 123true 说明对原来的toString()方法进行重写
    System.out.println(sb2);
    System.out.println(sb3);
    //都输出123true,按个引用指向同一个对象
  }
}
```

_40.insert，deleteCharAt，delete，substring方法_

```java
//StringBuffer基本不需要接收
class Demo{
  public void static main(String[] args){
    StringBuffer sb = new StringBuffer("HelloWorld");
    sb.insert(1, "test");  //在指定位置进行添加 --> HtestelloWorld
    //返回值也是 StringBuffer
    sb.deleteCharAt(1); //删除指定位置索引
    sb.delete(1,3); //删除索引 1和2
    sb.delete(0.sb.length()); //清除缓冲区
    sb.replace(0,3,"yes");//索引0到2替换为yes
    sb.reverse(); //反转缓冲区里的内容

s = sb.substring(1);  //返回的不是StringBuffer,是一个字符串,从索引1向后截取
    s2 = sb.substring(1,3); //返回索引1和2的字符串

}
}
```

_41.String和StringBuffer的相互转换_

```java
/*String转换为StringBuffer两种方法*/
StringBuffer sb = new StringBuffer("hello");
StringBuffer sb2 = new StringBuffer();
sb.append("helllo");
/*StringBuffer转换为String*/
String s1 = sb.substring(0,sb.length());
String s2 = sb.toString();
String s3 = new String(sb); //String类的构造方法的重载了 String(StringBuffer);
```

_42.StringBuilder类_

```java
StringBuilder sb = new StringBuilder(); //方法与StringBuffer相同
```

```
与StringBuffer区别是StringBuilder多个线程不安全,但是效率要高
String是一个不可变的字符序列，StringBuffer和StringBuilder是可变的
```

_43.Arrays类_

```java
class Demo{
  public static void main(){
    int arr[] = {2,4,1};
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));
    System.out.println(Arrays.binarySearch(arr,2)); //包含返回索引
    System.out.println(Arrays.binarySearch(arr,3)); //不包含返回负的插入点减一 --> -2
  }
}
```

_44.基本数据类型的包装类_

```java
class Demo{
  public static void main(String[] args){
    Scanner sc = new Scanner();
    String s = sc.nextLine();
    int i = Integer.parseInt(s); //将数字字符串转换为数字，多在输入前使用 静态方法使用类名直接调用
    Integer it = new Integer(100); //Integer的构造方法 重载多种类型
    Integer it2 = new Integer("100");

}
}
```

```
基本数据类型不能创建对象和调用方法，因此使用包装类来封装方法提供给我们使用,即将其包装为一个对象
int short byte long float double char boolean 四类八种数据类型，
除int和char其余的首字母大写即为包装类  int --> Integer  char --> Charactor
```

_45.String和 int 的相互转换_

```java
class Demo{
  public static void main(String[] args){
    // int --> String
    int num = 100;
    String s1 = num + ""; //加空串
    String s2 = String.valueOf(num); //valueOf,静态方法，可以将任何类型的数据转换为字符串
    // String --> int
    String s = "123";
    int i1 = Integer.parseInt(s); //其他基本数据类型的包装类也有对应的parseXxx()方法，char除外
    //如：
    float f = Float.parseFloat(s);
    boolean b = Boolean.parseBoolean(s);
  }
}
```

_46.自动装箱和自动拆箱_

```java
class Demo{
  public static void main(String[] args){
    int num = 10;
    Integer i1 = new Integer(num);  //将num变成对象的一个实例
    /*简化后*/
    Interger i2 = num; //自动装箱，将num变成一个对象

int j1 = i1.intValue(); //手动转换 Interger对象转换成int值
    /*简化后*/
    int j2 = i2 + 2; //自动拆箱 将Interger对象转换为int基本数据类型
  }
}
```

_47.自动装箱时Interger对象的存储_

```java
class Demo{
  public static void main(String[] args){
    Interger it1 = 127;
    Interger it2 = 127;
    System.out.println(it1 == it2); //true ：在-128到127之间不会创建新的对象，在底层会有一个数组存储-128到127之间的Interger对象值，不会在创建新的对象，相当于有了一个类似常量池，直接从里面提取Interger对象，因此it1和it2的地址都指向这个byte数组
    //在这个byte范围内都是对象
    Interger it = {new Interger(-128),127,126};//本质表示(数组可以存储引用数据类型)
  }
}
```

_48.java中的正则表达式_

```
在java.util.regex类中
```

```
1.字符类： --> []匹配的只能是单个字符
  []  匹配中括号内的 单个字符
  [^]  表示不能匹配括号内的任意字符，单个字符
  [a-zA-Z]  所有任意字母   相同写法 --> [a-z[A-Z]]
  [a-c&&[b-e]] 匹配左右两部分的交集
  [a-z&&[^bcd]] 匹配除bcd内的a-z的字符   相同写法 --> [a-z&&[b-d]]
```

```
2.预定义字符类  --> 字符串中 / 写为 // 转义字符
  . 任何单个字符
  \d 数字0-9 --> [0-9]
  \D 非数字单个字符 --[^0-9]
  \s 空白字符     --> [ \t\n\x0B\f\r]
  \S 单个非空白字符 -->[^\s]
  \w 单词字符 [a-ZA-Z_0-9] 字母数字下划线
  \W 非单词字符
```

```
3.数量词
  X? 一次或者一次也没有 [abc]? abc一个都不出现或者只出现一个
  X* 出现任意次数
  X+ 至少出现一次
  X{n} 出现n次
  X{n,} 至少n次
  X{m,n} m到n次
```

```
4.分组
  每个()
  判断AABB型 (.)\\1  --> \\代表拿到了()内匹配出的字符，因此()中内容又会出现一次  1代表第一组
            (.)\\2  --> 第二组
            (.)\\1{3} --> (.)获取一个字符，\\拿到字符。{3}再连着出现三次
  判断ABAB型 (..)\\1
```

```java
//在String中
String s = "he l  lo wor ld";
String regex = "\\s+" //空白符切割字符
String[] arr = s.split(regex);

String s2 = s.replaceAll(regex,"x"); //返回一个字符串,替换为x

String s0 = "ABCCCCDD";
String regex ="(.)\\1+";
String[] arr =

String s0 = "A...AA..BB..B..c....c"; //转换
String s3 = s.replaceAll("\\.+",""); //替换掉所有的.  .需要转义
String s4 = s3.replaceAll("(.)\\1+","$1");
//s2 输出 --> ABc

Pattern p = Pattern.compile("a*b");  //获取正则对象
Matcher m =p.matcher("aabbbc");      // 获取匹配器
boolean b = m.matches();             // 进行匹配 查看是否匹配
boolean b2 = m.find();               // 进行匹配查看regex在String是否存在
String s = m.group();                //将匹配出下一个子序列的输出

while(m.find()){    //进行循环输出
  System.out.println(m.group());
}
```

_49.Math类_

```java
//多为静态方法。直接用类名调用
class Demo{
  public static void main(){
  Math.PI;
  Math.abs(-10);  //10 --> int
  Math.ceil(12.3); //12.0
  Math.floor(12.3); //13.0
  Math.max(10,100); //取 max   /min(,) 取min
  Math.pow(2,3); // 8.0
  Math.random(); //0.0到1.0之间的随机数
  }
}
```

_50.Random类_

```java
//伪随机数，用算法计算出来
class Demo{
  public static void main(String[] args){
    Random r = new Random();  //创建一个新的随机数生成器 空参-->当前时间毫秒值  或 Random(100);--> 指定种子,会生成相同的一组随机数
    int i = r.nextInt(); //取自 int范围内的值
    int i = r.nextInt(100); //返回0到99之间随机Int
  }
}
```

_51.System类_

```java
//多为静态 类名调用
class Demo{
  public static void main(){
    /*gc()垃圾回收*/
    Person p = new Person("name","15");  //new出一个新对象
    p = null;     //指向空，原堆中变成垃圾
    System.gc();  //主动启动垃圾回收
    /*exit(0)退出jvm*/
    System.out.println(1);
    System.exit(0); //关闭jvm ,不会继续运行
    System.out.println(2);
    /*返回毫秒值*/
    System.out.println(System.currentTimeMillis()); //返回以豪秒为单位的时间值，返回值为 long
    //利用时间差可以计算程序运行时间
  }
}
class Person{
  /**
  空参构造
  有参构造
  get set方法
  */
  public void finalize(){
    super.finalize();    //对父类(object)的垃圾回收方法重写升级
    System.out.println(" 垃圾被回收");
  }
}
```

_52.BigInteger和BigDecimal类_

```java
//位于math包下

class Demo{
  public static void main(String[] args){
  /*BigInteger 足够大的数*/
  //BigInteger(string_val)  将一个字符串转换为BigInteger类
    BigInteger b1 = new BigInteger("100");
    BigInteger b2 = new BigInteger("100");
    /*加减乘除*/
    System.out.println(b1.add(b2));
    System.out.println(b1.subtract(b2));
    System.out.println(b1.mulyiply(b2));
    System.out.println(b1.divide(b2));

BigInteger[] arr = b1.divideAndRemainder(b2); //返回商和余数的数组
    System.out.println(arr[0]);  //商
    System.out.println(arr[1]);  //余数

/*BigDecimal 更精确的计算小数*/
  BigDecimal b = new BigDecimal(2.0); //不精确
  /*推荐使用的两种形式*/
  BigDecimal b1 = new BigDecimal("2.0"); //字符串
  BigDecimal b2 = new BigDecimal("1.1");
  //同上有加减乘除
  BigDecimal b1 = BigDecimal.vauleOf(2.0); //valueOf方法
  }
}
```

_53.Date类_

```java
//util包下  不是sql包
class Demo{
  public static void main(String[] args){
    /*两个构造方法*/
    Date d1 = new Date(); //获取了当前的时间对象
    System.out.println(d1);
    Date d1 = new Date(0);//根据制定的毫秒值创建时间对象 --> 1970.7.1.8:00
    Date d1 = new Date(1000);//8:00:01
    /*两个成员方法*/
    // public long getTime(); 获取当前时间对象的毫秒值
    // public void setTime(long time);
    d1.setTime(1000);//1000ms
    d1.getTime(); // --> 1000 和System.currentTimeMillis();返回值相同
  }
}
```

_54.DateFormat类_

```java
//是一个抽象类，不能实例化对象  位于text包下
class Demo{
  public static void main(String[] args){
    /*Date返回的对象*/
    Date d = new date();
    System.out.println(d);  //打印原有格式
    /*DateFormat类返回的对象，抽象类*/
    DateFormat df = DateFormat.getDateInstance();//getDateInstance()方法的底层会创建一个DateFormat的子类对象  //父类引用指向子类对象
    System.out.println(df.format(d));  //-->2017-9-2   format()该对象的方法，格式化
    /*使用SimpleDateFormat格式化SimpleDateFormat对象*/
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); //SimpleDateFormat是从DateFormat中继承下来
    System.out.println(sdf.format(d)); // --> 2017年9月2日03:20:30
    /*字符串*/
    String str = "2017年9月2日03:20:30";  //字符串
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); //格式化类型
    Date d = sdf.parse(str);
    System.out.println(d); // 获取到日期对象(Date类)
  }
}
```

```java
//计算出生到现在多少天
import java.util.Date;  //注意是util包，不是sql包
import java.text.ParseException;
import java.text.SimpleDateFormat;

public class LiveDate {

public static void main(String[] args) throws ParseException {
        String birth = "1998年4月23日";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        Date d1 = (Date) sdf.parse(birth);
        Date d2 = new Date;    //获取当前时间对象
        long time = d2.getTime() - d1.getTime();
        long date = time/1000/60/60/24;
        System.out.println(date);
    }
}
```

```java
//Date对象和String类对象相互转换的封装类
public class MyDate{
  private MyDate(){  //工具类，创建一个私有的构造函数，直接用类名调用
    // Date --> String
    public static String dateToString(Date d, String format){
      SimpleDateFormat sdf = new SimpleDateFormat(format); //把格式传入
      return sdf.format(d); //返回时间格式的字符串
    }
    // String --> Date
    public static String stringToDate(String time, String format) throws ParseException{
      SimpleDateFormat sdf = new SimpleDateFormat(format)
        return sdf.parse(time);
    }
  }
}
// 调用该封装类
class Demo{
  public static void main(String[] args){
    Date d = new Date;
    String time = MyDate.dateToString(d,"yyyy年MM月dd日");

String time = "2017年9月2日";
    Date d = MyDate.stringToDate(time, "yyyy年MM月dd日");
  }
}
```

_55.Calendar类_

```java
//抽象类 不能直接创建对象
//月份数组 0-11代表1-12月
class Demo{
  public static void main(String[] args){
    Calendar c = Calendar.getInstance();
     //或者get(1);月get(2);一年的第几周get(3); 以下都是用Calendar类的静态常量
    int x = c.get(Calendar.YEAR);  //类名.调用静态常量
    int y = c.get(Calendar.MONTH)+1;  //月份要加上1
    int z = c.get(Calendar.WEEK_OF_YEAR); //一年的第几个周
    int d = c.get(Calendar.DAY_OF_MONTH); //一个月的第几天
  }
}
```

```java
//Calendar类的add()和set();
class Demo{
  public static void main(String[] args){
    Calendar c = new Calendar();
    //add(int field, int amount); 根据日历规则给日历字段加上或者减去时间量
    c.add(Calendar.YEAR,1); //c对象的年 +1
    c.add(Calendar.MONTH,-1);//c对象的月减一

c.set(Calendar.YEAR,2018); //设置为2018年
    c.set(2018, 5, 23); //指定年月日 2018年4月23日
  }
}
```

```java
//判断闰年
class Demo{
  public static void main(String[] args){
    boolean b = leapYear(2008);
  }
  public static boolean leapYear(int year){
    Calendar c = Calendar.getInstance();
    c.set(year, 3, 1);
    c.add(Calendar.DAY_OF_MONTH,-1); //3月1日前一天
    if(c.get(Calendar.DAY_OF_MONTH)==29)
    return true;
    else false;
  }
}
```

_56.Collection接口和Iterator接口_

![pic](http://chuantu.biz/t6/32/1504354940x2728278590.jpg)

```
和数组的区别
  数组：存储基本数据类型或引用数据类型，长度不可变
  集合：引用数据类型，长度可以根据元素的增长而加长
```

```java
//Collection
class Demo{
  public static void main(String[] args){
    Collection c = new ArrayList(); //使用了Collection接口作为实例化后接受的数据类型，ArrayList类

Collection c2 = new ArrayList();
    c2.add(1);  //集合中的一切元素都是对象，自动装箱 new Integer(1)
    c2.add("hello");
    //boolean add()方法
    boolean b1 = c.add(1);  //添加进返回true  --> 自动装箱 new Integer(1)
    boolean b2 = c.add("hello");
    boolean b3 = c.add(new Person("name",18));
    boolean b4 = c.add(1); //List有索引可以重复

System.out.println(c);
    //打印 [1,hello,Student[Stdunt@hashcode],1] 重写后 Student[名字 = "name",年龄 = 18]
    //boolean contains()判断是否包含某个元素
    boolean b5 = c.contains(1); //true
    //equals()方法
    boolean b6 = c.equals(c2);//集合与集合之间的比较,顺序必须一致
    //isEmpty()判断集合是否为空
    boolean b8 = c.isEmpty(); //false
    //remove();  删除成功 -->true 失败 -->false
    boolean b9 = c.remove(1); //true
    boolean b10 = c.remove(1); //false
    //int size() 获取元素个数
    int x =c.size(); //获取数组中元素个数
    //Object[] toArray() 转换为数组
    Object[] arr = c.toArray();
    //clear()
    c.clear();//清空集合

c.add(new Person("张三",18));  //添加过程会有类型提升 Object obj = new Person("张三",18);
    c.add(new Pesron("李四",19));
    Object[] arr = c.toArray();  //集合转换为数组
    for (int i = 0; i < arr.length; i++){
      Person s = Person(arr[i]); //将每个元素强制转换为Person, 原来为Object类,没有相应的属性  --> 向下转型
      System.out.println(s.getName);
    }
    //addAll方法 把一个集合中的元素添加进另一个集合
    c.addAll(c2); //[, , , ,]
    c.add(c2);    //[, , , [, , ]]
    //containsAll()方法
    c.containsAll(c2); //c中是否包含c2中的所有元素 --> true/false
    //removeAll()
    c.removeAll(c2); //删除c与c2交集中的元素  有交集 --> true
    //retainAll()
    c.retainAll(c2); //取交集赋值给 c  c中的元素发生改变 --> true  c与c2没有交集时，c变为[]  返回true
    c.clear();

//iterator()  迭代 集合自身的遍历
    c.add("a");
    c.add("b");
    c.add("c");
    Iterator it = c.iterator(); //iterator是Collection类的方法，返回Iterator对象,c是Collection类
    boolean b1 = it.hasNext(); //迭代器在集合中是否有元素  --> true
    Object obj1 = it.next(); //如果有元素就获取 next()返回Object对象
    System.out.println(obj1); //获取到元素a
    //迭代输出集合
    Iterator it = c.iterator();
    while(it.hasNext()){
      System.out.println(it.next());
    }
    //
    c.add(new Person("张三", 23)); // 自动类型提升
    c.add(new Person("李四", 24));
    c.add(new Person("王五", 25));

Iterator it = c.iterator();  //使用while进行迭代
    while(it.hasNext){
      Person p = (Person)it.next();  //获取到Object对象向下转型
      System.out.println(p.getName()+" "+p.getAge());
    }

for(Iterator i = c.iterator();i.hasNext();){ //for迭代
      Person p = (Person)it.next();  //获取到Object对象向下转型
      System.out.println(p.getName()+" "+p.getAge());
    }
  }
}
```

```
迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样
那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿
迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式
这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现
```

_57.List接口_

```
Collection类的子接口，List包下
```

```java
class Demo{
  public static void main(String[] args){
    List list =  new ArrayList(); //List和Collection都可作为ArrayList的接口
    //add()的重写
    list.add("a");  //根据索引添加元素 --> 其他的按顺序后移
    list.add("b");
    list.add(0,"z");
    //1.addAll(0,list2);在指定位置添加集合
    System.out.println(l); // --> [z,a,b]
    //get(index) 根据索引获取对象
    Object obj = list.get(1); //返回值Object
    System.out.println(obj); //  --> a
    //indexOf通过对象获取索引值
    int index = list.indexOf("b");//从前向后遍历，有重复的返回第一个
    int index = list.lastIndexOf("b");//从后向前遍历，有重复返回后一个
    //remove(index)
    Object obj = list.remove(1);//根据索引删除，返回被删除对象
    boolean b = list.remove("b");//根据对象删除，返回true/false,重复会删除找到的第一个
    //set(index,element)
    list.set(1,"e"); //索引处替换
    //subList
    List slist = subList(2,4); //截取子集合，包含头不包含尾
  }
}
```

_58.ListIterator接口_

```java
//父类是Iterator 作为List的接口
class Demo{
  public static void main(String[] args){
    List list = new List();
    list.add("a");
    list.add("b");
    //ListIterator的迭代遍历
    ListIterator lt = list.ListIterator();
    while(lt.hasNext()){ // 正  hasPrevious()-->倒遍历，默认从0开始，需要将索引指向最后
      System.out.println(lt.next());
    }
  }
}
```

```java
//使用Iterator迭代器和List中add方法引起的并发修改异常
//例如：判断是否有"c",有的话加入"ok"
/****并发修改异常****/
class Demo{
  public static void main(String[] args){
    List list = new List();
    list.add("a");
    list.add("b");
    list.add("c");
    Iterator it = list.iterator(); //创建一个迭代器
    while(it.hasNext()){
      String str = (String)it.next();
      if(str.equals("c"))   //Iterator it 和 List l.add()同时对集合操作
        list.add("yes");  
    }
  }
}
/****使用ListIterator中的add()方法******/
class Demo{
  public static void main(String[] args){
    List list = new List();
    list.add("a");
    list.add("b");
    list.add("c");
    ListIterator it = list.ListIterator(); //创建一个迭代器
    while(it.hasNext()){
      String str = (String)it.next();
      if(str.equals("c"))   //Iterator it 和 List l.add()同时对集合操作
        it.add("yes");  
    }
  }
}
```

_59.数组和链表_

```
数组:根据索引，查询快，修改快，增删慢
链表:查询慢，修改慢，增删快
A:List的三个子类的特点

ArrayList:
    底层数据结构是数组，查询快，增删慢。
    线程不安全，效率高。
Vector:
    底层数据结构是数组，查询快，增删慢。
    线程安全，效率低。
Vector相对ArrayList查询慢(线程安全的)
Vector相对LinkedList增删慢(数组结构)
LinkedList:
    底层数据结构是链表，查询慢，增删快。
    线程不安全，效率高。

Vector和ArrayList的区别
    Vector是线程安全的,效率低
    ArrayList是线程不安全的,效率高
ArrayList和LinkedList的区别
    ArrayList底层是数组结果,查询和修改快
    LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
```

_60.去除ArrayList中的重复值_

```java
/*字符对象去除重复*/
class Demo{
  public static void main(String[] args){
    ArrayList list = new ArrayList();
    list.add(new Person("a"));
    list.add(new Person("b"));
    list.add(new Person("b"));
    list.add(new Person("c"));
  }
  public static ArrayList simpleList(ArrayList list){
    ArrayList newlist = new ArrayList();  //创建一个新集合
    Iterator it = list.iterator();        //获取迭代器
    while(it.hasNext()){               
      String temp = (String)it.next();  //将元素临时存储
      if(!newlist.contains(temp)){      //新集合中没有   contains的底层由equals实现 String重写了equals
        newlist.add(temp);              //增加到新集合中
      }
    }
    return newlist;
  }
}
/*自定义对象  不能被修改的分析*/
class Demo{
  public static void main(String[] args){
    ArrayList list = new ArrayList();
    list.add(new Person("张三",23));
    list.add(new Person("张三",23));
    list.add(new Person("张三",23));
    list.add(new Person("李四",24));
  }
  public static ArrayList simpleList(ArrayList list){
    Iterator it = list.iterator();        //获取迭代器
    ArrayList newlist = new ArrayList();
    while(it.hasNext()){
      Person temp = (Person)it.next();
      if(!newlist.contains(temp)){      //contains的底层依赖了equals方法,比较了地址值,需要进行重写
        newlist.add(temp);
      }
    }
    return newlist;
  }
}
/*在student类中对equals方法的重写*/
public boolean equals(Object obj){  //传入的都是Object类对象
  Person p = (Person)obj; //强制类型转换，向下转型为Person才具有相应的属性
  return this.name.equals(p.name) && this.age == p.age; //这里是已经被重写过的String的equals方法
}
//remove方法也以来了Object的equals方法
```

_61.链表 LinkedList类_

```java
class Demo{
  public static void main(String[] args){
    LinkedList lk = new LinkedList();
    lk.addFirst("a");//首位添加 添加的时候会自动类型提升为Object
    lk.addFirst("b");
    lk.addLast("c"); //末尾添加   --> bac

Object obj1 = lk.getFirst();
    Object obj2 = lk.removeFirst(); //返回删除的第一个元素
  }
}
```

_62.LinkedList进栈出栈的模拟_

```java
/**封装一个Stack***/
class Stack{
  private LinkedList list = new LinkedList();
  public void in(Object obj){
    list.addLast(obj);
  }
  public void out(Object obj){
    return list.removeLast();
  }
  public boolean isEmpty(Object obj){
    return list.isEmpty();
  }
}

Stack s = new Stack();
s.in("a");            //进栈
```

_63.泛型_

```
<>泛型 , 放入引用数据类型
```

```java
class Demo{
  public static void main(String[] args){
    ArrayList<String> list = new ArrayList<String>(); //规定集合中的引用数据类型
    list.add("hello");
    ArrayList<Person> list2 = new ArrayList<>();  //后面的<>中可以不加内容
    list2.add(new Person("张三",23));
    while(list2.hasNext()){
      Person p = list2.next(); //规定集合存入的引用数据类型，不需要再从Object进行强制转换
      System.out.println(p.getName());
    }
  }
}
```

_64.泛型类和泛型方法_

```java
//把泛型定义到类上  传入时决定Person的类型
public class Person<E>{
  private E e;
  public E getE(){
    return e;
  }
  public void setE(E e){
    this.e = e;
  }
}
class Demo{
  public static void main(String[] args){
    Person<Student> t = new Person<>();  
    t.setE(new Student("张三",23))
    Student s = t.getE();  //将运行时期的error转移到编译时期
  }                        //   用Worker w = (Worker)t.getE();编译不报错但是运行会报错
}
class Animal<A>{
  public void speak(W w){     //成员方法，在类加载后出现对象才能调用，可以与类相同泛型
    System.out.println("ok");
  }
  /*
  public static void show(W w){ //静态方法，优先于对象，由类名.调用随着类的加载而加载，不能与类同泛型
  */
  public static<T> void show(T t){ //所以静态方法不能和类名同泛型
    System.out.println("yes");
  }
}
```

_65.泛型接口_

```java
Interface Inter<T>{  //泛型接口
  public void show(T t){}
}
/*实现接口的时候决定泛型的具体类型*/
public class Demo implements Inter<String>{ //用String类型来承接
  @Override
  public void show(String t){  //重写接口中的方法 T类型变量由实现接口时的<>泛型来调用
    System.out.println("yes");
  }
}
/*将泛型也从接口实现过程中转移下来,在实例化对象的过程中再决定*/
public class Demo<T> implements Inter<T>{
  @Override
  public void show(T t){
    System.out.println("yes");
  }
}
//泛型通配符 <?>  不确定参数类型时
//  Person<?> t = new Person<>(Student);  不确定右边返回的数据类型
//可以替换为 <T> 用T t取出
public static void show(ArrayList<?> list){ //把一个集合当作参数，<?>可以传任意类型的集合
  Iterator<?> it = list.iterator();
  while(it.hasNext()){
    //Object obj = it.next();  //只能用Object接收  --> 可以将?都转为T 用T t接受
  }
  System.out.println("yes");
}
```

_66.foreach_

```java
/**for(临时变量:容器名){     //容器-->集合或数组  foreach可以遍历集合与数组，但是Iterator只能遍历集合
  输出临时变量
} //临时变量数据类型和泛型一致*/
public void main(String[] args){
  ArrayList<String> list = new ArrayList<>();
  list.add("a");
  list.add("b");

for(String s : list){    //底层使用迭代器实现
    System.out.println(s);
  }
}
```

_67.静态导入_

```java
//导入的是静态的方法 (jdk1.5的特性) 不建议使用，容易引起名字冲突
import static java.util.ArrayList.sort;  //加 static和 .方法
```

_68.可变参数_

```java
/******一般**********/
int[] arr = {1,2,3,4,5};
public static print(int[] arr){
  for(int i : arr){
    System.out.println(i);
  }
}
print(arr);// --> 调用
/******可变参数*****/
public static print(int ... arr){ //int ... arr 可以传入无限值
  for(int i : arr){
    System.out.println(i);
  }
}
print(arr); print(1,2,3);// --> 调用
```

_69.asList()方法_

```java
//Arrays类中  把数组转换成集合 可以用用集合中的方法
String[] str = {"a","b"};
System.out.println(arr.toString(arr)); //Ljava.包名@地址
List<String> list = Arrays.asList(arr);
System.out.println(arr); // --> [a,b]
```

_70.HashSet类_

```java
//并非随机排序，由hash算法计算
class Demo{
    public static void main(String[] args){
        //String类型中对equals和hashCode都有重写
        HashSet<String> hs = new HashSet();
        hs.add("a");                        
        hs.add("b");
        hs.add("c");
        hs.add("c");
        System.out.println(hs); //以Hash值对传入的参数进行排序,保证不重复
    /***自定义对象**/
        HashSet<Person> st = new HashSet();
        st.add("张三",23);
        st.add("张三",23);
        st.add("李四",24);
    }
}
class Person{
    /**
    @Override
    public boolean equals(Object obj){  //对equals方法进行重写
        Person p = (Person)obj;
        return this.age = p.age && this.name = p.name;
    }
    */
    // equals重写 优化 健壮性判断 在强转Person前判断是否为null
    @Override
    public boolean equals(Object obj) {
        if (this == obj)                            //调用的对象和传入的对象是同一个对象
            return true;                              //直接返回true
        if (obj == null)                            //传入的对象为null
            return false;                              //返回false
        if (this.getClass() != obj.getClass())        //调用的对象对应的字节码对象和传入对象对应的字节码对象不是同一个对象
            return false;                              //返回false
        Person other = (Person) obj;    //向下转型,可以调用子类特有的属性和行为
        if (age != other.age)                    //如果调用的对象的age不等于传入对象的age
            return false;                              //返回false
        if (name == null) {                        //如果调用的name为null
            if (other.name != null)            //而传入的对象name不为
                return false;                          //返回false
        } else if (!name.equals(other.name))        //如果调用对象的name和传入对象的name不是同一个name
            return false;                              //返回false
        return true;                                  //返回true
    }
    /**
    @Override     hashcode值相同的时候才调用了equals方法
    public int HashCode(){
        return 10;
    }
    */
    //hashCode的优化重写  31: 质数，大小合适，2^5 -1
    @Override       //对每个元素的hashcode进行判断，如果相同才会调用equals,不同直接存储
  public int hashCode() {  //根据属性来判断，属性相同返回相同 ，属性不同返回值尽量不同
    final int prime = 31;
    int result = 1;
    result = prime * result + age;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
    }
}
```

_71.LinkHashSet类_

```java
LinkHashSet<String> lhs = new LinkHashSet<>();
lhs.add("a");
lhs.add("b");
//怎么存就怎么取，不是根据HashCode排列
```

_72.TreeSet类_

```java
/*TreeSet是有序的一个集合*/
class Demo{
    public static void main(String[] args){
        TreeSet<String> ts = new TreeSet<>();
        ts.add("b");
        ts.add("a");
        System.out.println(ts); //安装 a b 字典顺序输出
        /*自定义对象 */
        TreeSet<Person> p = new TreeSet<>();
        p.add(new Person("张三",23));   //add()会将对象自动提升为Comparable类型，利用Comparable类型中的compareTo()方法
        p.add(new Person("张三",23));
        p.add(new Person("张三",23));
        p.add(new Person("李四",24));
    }
}
/** 为对象设置排序的方法 **/
class Person implements Comparable<Person>{ //要实现Comparable接口的compareTo方法
    /* 输入顺序排序
    @Override
    public int compareTo(Person p){  //根据返回值决定在二叉树中的排序，正数在右，负数在左，为0不存
        return 1;
    } */

/* 先年龄后姓名
    @Override
    public int compareTo(Person o) {                //按照年龄排序
        int num = this.age - o.age;                    //年龄作为主要条件比较
        return num == 0 ? this.name.compareTo(o.name) : num;//姓名作为次要条件,只有年龄相同的时候比较姓名
    }*/

/* 先姓名后年龄
    @Override
    public int compareTo(Person o) {                //按照姓名排序
        int num = this.name.compareTo(o.name);        //姓名作为主要条件
        return num == 0 ? this.age - o.age : num;    //年龄是次要条件
    }*/

@Override //按照姓名的长度排序
    public int compareTo(Person o) {                
        int num = this.name.length() - o.name.length();    //长度作为主要条件
        int num2 = num == 0 ? this.name.compareTo(o.name) : num;//姓名的内容作为次要条件
        return num2 == 0 ? this.age - o.age : num2;        //年龄作为次次要条件
    }
}
```

_73.Comparator比较器_

```java
class Demo{
    public static void main(String[] args){
        TreeSet<> ts = new TreeSet()<>(new ComparByLen); //传入一个比较器的对象，优先考虑传入的比较器
        ts.add("sas");       //add()自动调用比较器(ComparByLen)中的compare方法
        ts.add("dsd");
        ts.add("dfsds");
        System.out.println(ts);  // --> dsd sas dfsds
    }
}
class ComparByLen implements Comparator<String>{    //定义比较器
    @Override
    public int compare(String s1,String s2){
        int num = s1.length() - s2.length();
        return num == 0? s1.compareTo(s2) : num; //compareTo按照字典顺序
    }
}
/*将ComparByLen变为匿名内部类，用匿名内部类实现重复且排序*/
  TreeSet<> ts = new TreeSet()<>(new Comparable<String>{
    @Override
    public int compare(String s1,String s2){
      int num = s1.compareTo(s2); //比较s1 和 s2 的内容
      return num == 0? 1 : num;
    }
  });
```

```
使用方式
 * a.自然顺序(Comparable)
     * TreeSet类的add()方法中会把存入的对象提升为Comparable类型
     * 调用对象的compareTo()方法和集合中的对象比较
     * 根据compareTo()方法返回的结果进行存储
 * b.比较器顺序(Comparator)
     * 创建TreeSet的时候可以制定 一个Comparator
     * 如果传入了Comparator的子类对象, 那么TreeSet就会按照比较器中的顺序排序
     * add()方法内部会自动调用Comparator接口中compare()方法排序
```

_74.Map类集合_

```
Map<K V>双列集合，类似字典，key唯一，value不唯一
HashMap重写了父类AbstactMap中toString方法，可以直接print
```

```java
class Demo{
    public static void main(String[] args) {
        //HashSet(对于Set)依赖于 HashMap(对于Map)
        HashMap<String Integer> hm = new HashMap();
        //返回value
        hm.put("张三" 23);  // 添加值 返回被覆盖值  --> null
        hn.put("张三" 24);  // 返回 23 (被覆盖的值)
        hm.remove("张三");  //移除key对应的value并返回对应的值
        hm.get("张三");            //根据键返回值
        //返回Boolean
        hm.containsKey("张三"); //查看是否包含Key --> true/false
        hm.isEmpty();       // 是否为空
        //返回Collection
        Collection c = hm.value();//返回所有的 value存储在Collection中
        //返回int
        hm.size();           //返回键值对的个数
        //返回Set
        hm.keySet();                 //返回key组成的set集合
        //无返回
        hm.clear();                  //清空
        /*遍历键获取值*/
        hm.put("张三",23);
        hm.put("李四",24);
        hm.put("王五",25);
        /*第一种迭代遍历输出map*/
        Set<String> key =  hm.keySet();    //将key存储在set中
        Iterator<String> it = key.iterator(); //获取迭代器
        while(it.hasNext()){                                 //迭代器遍历
            String key = it.next();                     //获取key
            Integer value = hm.get(key);     //获取值
            System.out.println("key " + key " value "+ value );
        }
    }
}
```

_75.Map.Entry 内部接口_

```java
//第二种迭代遍历
//内部接口，接口中的接口
//将key和value封装成一个对象  --> Map<K V> 成为一个对象
class Demo{
    public static void main(String[] args) {
        HashMap<String Integer> hm = new HashMap<String Integer>();
        hm.put("张三",23);
        hm.put("李四",24);
        hm.put("王五",25);
        /*Map.Entry*/
        Set<Map.Entry<String Integer>> et = hm.entrySet(); //获取到一个键和值封装到一起的set集合
        Iterator<Map.Entry<String Integer>> it = entrySet.iterator(); //获取迭代器 Map.Entry<>变成一个对象
        while(it.hasNext){
            Map.Entry<String Integer> = it.next();
            String key = it.getKey();
            Integer value = it.getValue();
            System.out.println("key " + key + " value "+ value );
        }
        /*第一种foreach遍历*/
        for(String key : hm.keySet()){
            System.out.println("key " + key " value "+ value );
        }
        /*第二种foreach遍历*/
        for(Entry<String Integer> en : hm.entrySet()){
            System.out.println("key " + en.getKey() + " value "+ en.getValue());
        }
    }
}
```

_76.LinkedHashMap类_

```java
//保证怎么存就怎么取
class Demo{
    public static void main(String[] args) {
        LinkedHashMap<String Integer> lhm = new LinkedHashMap<>();
        lhm.put("张三",23);
        lhm.put("王五",23);
        lhm.put("李四",23);
        System.out.println(hm);
    }
}
```

_77.TreeMap类_

```java
class Demo {
    public static void main(String[] args) {
        TreeMap<String,String> tm = new TreeMap<>(); //键和值都是字符串
        tm.put("1","a");
        tm.put("2","c");
        tm.put("3","b");
        System.out.println(tm);  //比较键不比较value

TreeMap<Person,String> tm2 = new TreeMap<>();
        tm2.put(new Person("张三", 23));
        tm2.put(new Person("李四", 24));
        /*  System.out.println(tm2);  报错 --> 无法比较自定义的Person对象
             需要重写Person类中的compareTo方法
        */
        System.out.println(tm2);
    }
}
/* 重写Person中的compareTo方法*/
class Person{
    String name;
    int age;
    @Override
    public int compareTo(Person p){
        int num = this.age - p.age;
        return num == 0 ? this.name.compareTo(p.name) : num;
    }
}
/*传入比较器来比较对象排序*/
class Demo{
    public static void main(String[] args) {
        TreeMap<Person,Integer> tm = new TreeMap<>(new Comparator<Person>(){
            @Override
            public int compare(Person p1, Person p2){
                int num = p1.getName().compareTo(p2.getName());
                return num == 0 ? p1.getAge() - p2.getAge() : num;
            }
        });
        tm.put(new Person("张三", 23));
        tm.put(new Person("李四",24));
        System.out.println(tm);
    }
}
```

_78.Map统计_

```java
//Map统计字符串单个字符个数
class Demo{
    public static void main(String[] args) {
        String s = "aaabbbbccc";
        char[] arr = s.toCharArray();
        HashMap<String Integer> hm = new HashMap<>();
        for(char c : arr){
            if(!hm.containsKey(c)){      //如果没有这个字符，在HashMap存入char和 1
                hm.put(c,1);
            }else{
                hm.put(c,c.getKey(c)+1);    //如果有该字符获取到相应的value+1
            }
            // hm.put(c, !hm.containsKey(c)?1:hm.get(c)+1); 使用三元运算符代替if else
        }
        for(Charactor key : hm.keySet()){  //HashMap中都是对象(引用数据类型变量),因此必须使用Charactor来接受
            System.out.println(key+ "出现了" + key.get());
        }
    }
}
```

_79.HashMap嵌套_

```java
//集合中嵌套集合
class Demo{
    public static void main(String[] args) {
        //外层
        HashMap<String HashMap<Person, String>> hm = new HashMap<>();
        //内层
        HashMap<Person, String> class1 = new HashMap<>();
        class1.put(("张三",23),"北京"));
        class1.put(("李四",24),"北京"));
        class1.put(("王五",23),"上海"));

HashMap<Person, String> class2 = new HashMap<>();
        class1.put(("王五",23),"天津"));
        class1.put(("赵六",23),"广州"));

hm.put("一年级", class1);
        hm.put("二年级", class2);

for(String key : hm.keySet()){  //双层嵌套遍历  keySet获取所key对其遍历            
            HashMap<Person, String> value = hm.getKey;  //外层的value是一个HashMap,获取到HashMap
            for(Person k : value.keySet()){  
                System.out.print(key + "," +k+ value.get(k));
            }
            System.out.println();
        }
    }
}
```

_80.Hashtable()_

```java
//相比于HashMap 出现较早，命名不规范 线程安全效率低
//Hashtable不能存null key/value
```

_81.Collections集合工具类_

```java
class Demo{
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("b");
        list.add("a");
        int index = Collections.binarySearch(list,"a");
        System.out.println(index); // --> 0 二分查找发
        Collections.sort(list); //按照索引排序
        String max = Collections.max(list); //获取max
        Collections.reverse(list); // 将集合反转
        Collections.shuffle(list); // 随机排序集合
    }
}
```

_82.高级泛型_

```java
// ? extend E    E是固定的(Person)  子类是不确定的(Worker/Student)    
//  --> List<? extends Person> list --> List的上限位Person,list中可放入Person和Person的子类

// ? super E    E是固定的，E是下限
//  --> List<? super Worker> list --> list的下限为Worker
class Person{

}
class Worker extends Person {

}
class Demo{
    public static void main(String[] args) {
        // ? super E 固定了下边界
        TreeSet<Person> ts1 = new TreeSet<>(new ComparByAge());  //拿出来时调用比较器，拿出来可以用本类或父类的比较器
        ts1.add("张三",23);
        TreeSet<Worker> ts2 = new TreeSet<>(new ComparByAge());
        ts2.add("张三",23);
        ts2.add("李四",24);
        System.out.println(ts2);                    //使用了父类的比较器
        /*? extends E*/
        ArrayList<Person> list1 = new Person<>();  //固定上边界，addAll时可以将子类型填进去
        list1.add("张三",23);
        ArrayList<Worker> list2 = new Worker<>();
        list1.addAll(list2);      //Worker是Person的子类,添加集合可以添加子类
    }
}
/*重写比较器*/
class ComparByAge implements Comparator<Person>{
    @Override
    public int compare(Pesron p, Person p){
        int num = p.getAge() - p2.getAge();
        return num == 0 ? p1.getName().compareTo(p2.getName()) : num;
    }
}
```
*83.异常捕获*
```java
//Throwable类 --> 可抛出
//Android 端多用try EE多用catch
class Demo{
  public static void main(String[] args) {
    try{

}catch (ArithmeticException e){
      System.out.println("除数不能为0");
    }catch (ArrayIndexOutOfBoundsException e2){
      System.out.println("索引越界");
    }catch (Exception e3){
      System.out.println(“出错了”);
    }
    /*输入字符串转换为整数*/
    System.out.println("请输入一个整数");
    Scanner sc = new Scanner(System.in);
    while(true){
      String line = sc.nextLine();
      try{
        int num = Integer.parseInt(line);     //转换为整数
        System.out.println(Integer.toBinaryString());
        break;
      }catch(Exception e1){                   //出现了问题 --> catch
        try{
          new BigInteger(line);               // BigInteger()可存入大整数
          System.out.println("输入的整数过大");
        }catch(Exception e2){
          try{
            new BigDecimal(line);            // BigDecimal可存入小数
          }catch(Exception e3){
            System.out.println("非法字符");
          }  
        }
      }
    }
  }
}

```
*84.编译时异常和运行时异常*
```
运行时异常编译时不会报错(多位人为错误) --> RuntimeException类
越界，并发修改异常，类型转换异常，空指针异常
编译时异常  --> Exception类
```
*85.Throwable类里的常见方法*
```java
class Demo{
  public static void main(String[] args) {

try{

}catch(ArithmeticException e){  //获取到异常赋值给e对象，可以使用父类Throwable里的的1方法
      System.out.println(e.getMessage()); //错误信息
      System.out.println(e.toString());   //错误类名+异常信息+位置 (jvm默认处理异常使用)
    }
  }
}
```
*86.throws方法处理异常*
```java
class Demo{
  public static void main(String[] args) {
    Test t = new Test();
    int x = t.div(10,0);
    System.out.println(x);
  }
}
class Test{
  public int div(int a, int b) throws ArithmeticException{ //throws Exception
  //向上抛出ArithmeticException(RuntimeException及其子类) --> 运行时异常，可以不进行处理(和不抛效果一样)
  //向上抛出Exception --> 一个编译时异常 ,必须要在使用时进行try catch处理
    return a/b ;
  }
}
```
*87.throw和throws区别*
```java
// throws在方法后面加上异常类名，可以多个异常类名，
// throw在方法内，跟的是异常对象
class Demo{
  public static void main(String[] args) throws Exception {
    Person p = new Person();
    p.setAge(-1);
  }
}
class Person{
  private age;
  public int getAge(){
    return age;
  }
  public void setAge(age) throws Exception { //提醒该方法有异常，使用的时候需要进行try 或者throws
    if(age > 0 && age < 100){
    this.age = age;
    }else{
    // System.out.println("年龄错误");
    throw new Exception("年龄错误"); //在方法内部的异常，程序不能继续运行需要继续跳转，throw把异常对象抛出，只能抛一个异常对象，异常由方法内对应的语句来处理
    }
  }
}
```
*88.finally*
```java
//一定会执行，释放资源
class Demo{
  public static void main(String[] args) {
    int x = 10;
    try{
      System.out.println(1/0);
    }catch (Exception e){
      x = 20;
      System.out.println("catch");
      return x; //即使有return finally也会执行,但是退出虚拟机就无法运行
    }finally{
      x = 30;
      System.out.println("finally");
    }
  }
}    //最后返回 x= 20;在catch中已经建立起了返回路径，x = 20已经被传入;执行finally不会对传出的x产生影响
```
*89.final finally finalize*
```java
//final, finally, finalize
class Demo{
  public static void main(String[] args) {
    final i = 10; //final 用来定义常量
    try{          //finally 用来释放资源

}finally{

}
    public finalize(){  //finalize Object类的垃圾回收
      super.finalize();
      System.out.println("重写升级Object的finalize方法");
    }
  }
}
```
*90.自定义异常*
```java
public class AgeErrorException extends Exception{ //自定义的AgeErrorException异常
  public AgeErrorException(){
    super();  //空参构造
  }
  public AgeErrorException(String message){
    super(message);
  }
}
// Exception中message相关方法在父类执行 --> Throwable
// Throwable 的message方法返回message详细信息
```
*91.父类和子类的异常*
```java
//子类重写父类方法，必须抛出和父类相同的异常或者父类异常的子类
class Person{
  public void print() throws Exception{

}
}
class Student{
  public void print() throws FileNotFoundException{

}
}
//父类多个异常，子类重写的方法抛出的是相同，子类异常或者父类异常的子集
//父类不抛出异常，子类不能抛出异常，只能在内部try catch处理
```
*92.File类*
```java
//不属于IO流类
import java.io.File;
class Demo{
  public static void main(String[] args) {
    File f1 = new File("xxx.txt");
    String parent = "D:\\java";
    String child = "Note\\test.java";
    File f2 = new File(parent,child);
    System.out.println(f2.exist());  // 判断文件是否存在
    /*File parent , String child*/
    File parent = new File("D:\\java");  //变为文件对象可以使用文件的方法
    String child = "Note\\test";
    System.out.println(new File(parent, child));
    /*创建文件*/
    File file = new File(test.txt);
    boolean b = file.creatNewFile(); //会抛出异常 --> throws IOException 创建成功返回true,失败false
    /*创建文件夹*/
    File dir1 = new File("test");
    boolean b = dir1.mkdir(); // 当前目录下创建test文件夹
    File dir2 = new File("test\\java");
    boolean b2 = dir2.mkdirs(); //创建多级文件夹
    /*delete*/
    File file = new File("test");
    file.delete(); //删除文件test  -->成功true失败false
    File dir = new dir("test");
    dir.delete(); //删除文件夹  只能删除空文件夹
    /*renameTo*/
    File file1 = new File("oldname");
    File file2 = new File("newname");//同路径下改名
    File file3 = new File("D://newname");//不同路径改名+移动
    boolean b = file1.renameTo(file2);
    /*isDirectory()*/
    File dir = new File("D://dir1");
    System.out.println(dir.isDirectory());   //是否是一个目录 --> boolean
    File file = new File("D://newname");
    System.out.println(file.isFile());        // 是否是一个文件
    /*setReadable(boolean b) setWritable(boolean b)   true可,false不可*/
    /*windows下所有文件都是可读的*/
    //canRead(), canWrite()   是否可读可写
    long l = file.length(); //获取文件大小 --> 字节
    long l = dir.length();  //直接获取文件夹的大小返回0
    //获取时间
    long time = file.lastModified(); //获取文件最后一次修改的毫秒值
    Date d = new Date(time);  //转换为Date
    System.out.println(d);
    //获取文件夹内文件夹和文件的名字数组
    String[] arr = dir.list();    
    for(String s : arr){
      System.out.println(s);
    }
    //获取文件夹下所有文件对象组成的数组
    File[] arr = dir.listFile();    
    for(File file : arr){
      System.out.println(file);
    }
  }
}
```
*93.File筛选文件*
```java
class Demo{
  public static void main(String[] args) {
    File dir = new File("D:\\"); //获取路径封装成file对象
    //获取名字数组
    String[] arr = dir.list();   //文件和文件夹路径
    for(String s : arr){
      if(s.endWith(.jpg)){
        System.out.println(s);
      }
    }
    //获取文件对象
    File[] file = dir.listFile();
    for(File f : file){
      if(f.isFile() && f.getName().endWith(.jpg)){
        System.out.println(f.getName());
      }
    }
    //文件名过滤器
    String[] arr = dir.list(new FilenameFilter(){  //匿名内部类，放入一个FilenameFilter对象
      @Override
      public boolean aceept(File dir, String name){   //dir是路径 name是文件
        File file = new File(dir,name);
        return file.isFile() && file.getName().endWith(".jpg");   //判断放入arr什么样的文件   true--> 放入，false --> 不放入
      }
    });
  }
}

/*递归打印java文件*/
//递归在方法末尾对传入参数进行判断来确定是否继续调用本方法
class Demo{
  public static void main(String[] args) {
    File file = getDir();

}
  public static File getDir(){   //获取文件
    Scanner sc = new Scanner(System.io);
    System.out.println("输入文件夹");
    while(true){
      String line = sc.nextLine();
      File dir = new File(line);
      if(!dir.exist()){
        System.out.println("不存在");
      }else if(!dir.isFile()){
        System.out.println("是一个文件路径");
      }else{
        return dir;
      }      
    }
  }
  public static void printJavaFile{
    File[] subfiles = dir.listFile();
    for(File f : subfiles){
      if(f.isFile() && f.getName().endWith(.java)){  //是文件，以.java皆为
        System.out.println(f);
      }else if(f.isDirectory()){                     //是文件夹，返回给方法
        printJavaFile(f);
      }
    }
  }
}
```
*94.IO流处理文件*
```java
//IO流四个抽象父类
//流式处理 ——>字节流和字符流
//字节流的两个抽象父类 -> InputStream / OutputStream
//字符流的两个抽象父类 -> Writer/Reader
//(逐个字节拷贝)
class Demo{
  public static void main(String[] args) throws FileNotFoundException {
    //FileInputStream是InputStream的一个子类
    FileInputStream fis = new FileInputStream("test.txt"); //必须保证test.txt存在 创建了一个文件输入流对象并关联test.txt
    int x = fis.read(); //读取一个字节  抛出IOException读写异常，防止文件不可写，每次read()向后移动以动
    System.out.println(x);   //字母会打印出一个Ascii码 读完会显示-1
    fis.close();
    /*循环读取*/
    while((b = fis.read()) != -1){ //read返回int类型，防止byte中的-1，(int)前面加0-->(int)255，来避免遇到-1停止，而文件结束返回的就是int类型的-1
      System.out.println(b);
    }
    fis.close(); //关闭字节流
    //FileOutputStream --> 输出
    FileOutputStream fos = new FileOutputStream("a.txt"); //不存在就会新建
    fos.write(97); // -->在a.txt中写入a
    fos.write(98); // 覆盖原来的a,写入b
    f.close();
    //非覆盖续写
    FileOutputStream fos = new FileOutputStream("a",true); //可以续写
    fos.write(c);
    fos.close();
  }
}
```
*95.IO图片处理*
```java
//(逐个字节拷贝)
class Demo{
  public static void main(String[] args) throws IOException {
    FileInputStream fis = new FileInputStream("a.jpg");//创建一个输入流对象关联a.jpg
    FileOutputStream fos = new FileOutputStream("b.jpg");//输出流关联b.jpg
    int b;
    /*逐个字节拷贝*/
    while((b = fis.read()) != -1){   //输入流中存在图片
      fos.write();                   //写入输出流
      fis.close();
      fos.close();
    }

}
}
```
*96.音频处理*
```java
//(逐个字节拷贝)   --> 单个字节搬运
class Demo{
  public static void main(String[] args) throws IOException {
    FileInputStream fis = new FileInputStream("1.mp3");
    FileOutputStream fos = new FileOutputStream("2.mp3");
    int b;
    while((b = fis.read()) != -1){
      fos.write();
      fis.close();
      fos.close();
    }
  }
}
//程序存储在内存，1.mp3在硬盘中，FileInputStream 建立关系
// FileOutputStream同理        -->在建立连接的过程中费时
```
*97.数组容器拷贝*
```java
class Demo{      //整个文件拷贝
  public static void main(String[] args) throws IOException {
    FileInputStream fis = new FileInputStream("1.mp3");
    FileOutputStream fos = new FileOutputStream("2.mp3")
    byte[] arr = new byte[fis.available()];   //根据文件大小做一个字节数组 available() 获取文件字节
    fis.read(arr);
    fos.write(arr);
    fis.close();
    fos.close();
  }               //  容易溢出
}

class Demo{       //拷贝标准写法
  public static void main(String[] args) throws IOException {
    FileInputStream fis = new FileOutputStream("1.mp3");
    FileOutputStream fos = new FileOutputStream("2.mp3");
    byte[] b = new byte(1024*8); //建立一个字节数组
    while((len = fis.read(b)) != -1){  
      fos.write(arr,0,len);
    }
  }
}
```
*98.BufferedInputStream和BufferedOutputStream类*
```java
//建立一个缓冲区,对输入输出流进行包装
//缓冲区大小是 8192  --> 1024*8
//read是把8192个字节存入缓冲区的BufferedInputStream对象
//在缓冲区将每个字节传给给 b
//write是在缓冲区读满后再返回
class Demo{
  public static void main(String[] args) throws IOException {
    BufferedInputStream bis = new BufferedInputStream("1.mp3");
    BufferedOutputStream bos = new BufferedOutputStream("2.mp3");
    int b;
    while((b = fis.read()) != -1){
      System.out.println(b);
    }
    bis.close();   
    bos.close();   //FileInputStream/Out和BufferedInputStream/Out 相比只关B
  }                //close()回对缓冲区进行刷新，在文件最后会将未补满的缓冲区填入文件
}
```
*99.flush和close方法*
```java
bos.close();   //close()关闭后对缓冲区进行刷新，在文件最后会将未补满的缓冲区填入文件,调用后不能再写
bos.fiush();   //刷新之后可以继续写   --> 实时刷新缓冲区内容
```
*100.读写中文*
```java
class Demo{
  public static void main(String[] args) throws IOException{
    /*字节流读中文有弊端，必须要写入字节数组，可能读到半个中文*/    
    FileInputStream fis = new FileInputStream("a.txt");
    byte[] arr = new byte(4);
    int len;
    while((b = fis.read(arr)) != -1){
      System.out.println(new String(arr,0,len));
    }
    /*字符流读中文*/
    //中文的第一个字节是负数,(编码表+字符流)
  }
}
```
*101.IO流标准异常处理*
```java
//jdk1.6  流对象 -> try流对象赋值，读写代码)finally{try{判断null}finally{判断null}}
class Demo{
  public static void main(String[] args) throws IOException {
    FileInputStream fis = null; //局部变量使用前必须赋值
    FileOutputStream fos = null;
    try{     //有try没有catch,有异常抛出不内部解决
      fis = new FileInputStream("1.txt");
      fos = new FileOutputStream("2.txt");
      int b;
      while((b = fis.read()) != -1){
        fos.write(b);
      }
    }finally{
      try{
        if(fis != null){  //防止空指针异常，防止创建不成功
          fis.close();        
        }
      }finally{
        if(fos != null){
          fos.close();      
        }      
      }
    }
  }
}
//jdk1.7  ——> try(流对象){读写代码}
class Demo{
  public static void main(String[] args) throws IOException {
    try(FileInputStream bis = new FileInputStream("1.mp3");   //流对象
        FileOutputStream bos = new FileOutputStream("2.mp3");
        ){                //读写代码
          int b;
          while((b = fis.read()) != -1){
            fos.write(b);
          }
        }   //执行完后会自动关闭文件流
  }
}
```
*102.字符流*
```java
//字节流+编码表  只能表示纯文本 FileReader和FileReader编码表与平台默认相同GBK编码
//Reader类 -> InputStreamReader类 -> FileReader类
//Writer类 -> OutputStreamWrite类 -> FileWriter类
class Demo{
  public static void main(String[] args) throws IOException {
    FileReader sr = new FileReader("test"); //文件必须要存在
    int x = fr.read(); //char类型提升为int类型，char(0到65535)不能存储-1
    System.out.println(char(x)); //强转
    FileWriter fw = new FileWriter("a.txt");
    fw.write(97);   //写入a,自动转换为字符  --> 内置2k的缓冲区
    fw.close();     //关闭刷新缓冲区
  }
}
//拷贝文本字节流更快，字符流用于只读和只写，一次读取一个字符不会显示乱码
//字符流操作非纯文本时遇到不能编码的字节会 ?代替
```
*103.BuffereReader和BufferedWriter类*
```java
//包装类，分别对FileReader和FileWriter进行包装
//缓冲区默认8192字符数组 -> 4K
class Demo{
  public static void main(String[] args) throws IOException{
    BufferedReader br = new BufferedReader(new FileReader("a.txt"));
    BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
    int ch;       //接受每一个字符
    while((ch = br.read()) != -1){  //read()
      bw.write(ch);
    }
    String Line;
    while((ch = br.readLine()) != null){ //readLine()不读\r\n 读到末尾 null
      bw.write(line);
      bw.newline(); //跨平台换行
    }
    bw.close();
  }
}
```
*104.LineNumberReader类*
```java
//父类是BufferedReader
//getLineNumber(),setLineNumber() ->对行号设置
class Demo{
  public static void main(String[] args) throws IOException {
    LineNumberReader lnr = new LineNumberReader(new FileReader("a.txt"));
    String line;
    lnr.setLineNumber(100); //规定初始行号 以下从101行开始写，
    while((line = lnr.readLine()) != null){  //readLine()都取整行，LineNumber++
      System.out.println(lnr.getLineNumber() + ":" +line); //getLineNumber()获取行号
    }
    lnr.close();
  }
}
```
*105.装饰设计模式*
```java
//将原有类进行装饰，丰富功能
//Student和 Doctor都继承 Coder,Doctor的构造方法中传入了Student
//相比于子父类耦合性降低，Student可以换其他包装类改变功能
interface Coder{  
  public void code();
}
class Student implements Coder{
  public void code(){
    System.out.println("javaEE");
  }
}
class Doctor implements Coder{
  private Student s;
  public Dotor(Student s){  //构造方法中包含了一个Student变量，在用Doctor创建对象时要传入一个Student对象
    this.s = s;
  }
  @Override
  public void code(){
    s.code();  //Coder中的code()
    System.out.println("Machine Learning");
  }
}
class Demo{
  public static void main(String[] args) throws IOException{
    Doctor d = new Doctor(new Student());
  }
}
```
*106.字符流指定编码表*
```java
class Demo{
  public static void main(String[] args) throws IOException{
    FileReader fr = new FileReader("1.txt");//windows平台默认GBK
    FileWriter fw = new FileWriter("2.txt");
    InputStreamReader isr = new InputStreamReader(FileInputStream("1.txt","utf-8")); //以utf-8读文件
    OutputStreamWrite osw = new OutputStreamWrite(FileOutputStream("2.txt","GBK")); //以GBK写文件
    int ch;
    while((ch = isr.read()) != -1){
      osw.write(ch);
    }
    isr.close();
    osr.close();
  }
}

BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("1.txt","utf-8")));
//InputStreamReader(字符流)包装FileInputStream(字节流)，再用BufferedReader包装成缓冲区提高效率

//FileReader和FileWriter与平台默认编码表相同(GBK)
//utf-8中文3个字节，读取时按照GBK中文两个字节，输出是也按照GBK
//InputStreamReader和OutputStreamWrite
//FileInputStream获取字节->InputStreamReader依靠编码表将字节变字符->int ch接受每一个字符->OutputStreamWrite依靠编码表将字符变字节->FileOutputStream写入字节
```
*107.IO流统计字符*
```java
class Demo{
  public static void main(String[] args) throws IOException{
    BufferedReader br = new BufferedReader(new FileReader("txt"));
    TreeMap<Charactor, Integer> tm = new TreeMap<>(); //双链集合,排序HashMap
    int ch;
    while((ch = br.read()) != -){
      char c = (char)ch;
      tm.put(c, !tm.containsKey(c) ? 1 : tm.get(c) + 1);
    }
    br.close();
    BufferedWriter bw = new BufferedWriter(new FileWriter(test.txt));
    for(Charactor key : tm.keySet()){
      switch(key){    //将/t/r/n空白符替换掉，防止写入文件直接是空白
        case '\t':
          bw.write("\\t"+"="+tm.getKey());
          break;
        case '\r':
          bw.write("\\r"+"="+tm.getKey());
          break;
        case '\n':
          bw.write("\\n"+"="+tm.getKey());
          break;
        default:
          bw.write(key + "=" + tm.getKey());
      }
      bw.newline();
    }
    bw.close();
  }
}
```
*108.计算文件夹大小*
```java
class Demo{
  public static void main(String[] args) {
    File dir = getDir();
    long l = getFileLen(dir);
    System.out.println(l);

}
  public static File getDir(){
    Scanner sc = new Scanner(System.in);
    System.out.println("输入文件夹");
    while(true){
      String line = sc.nextLine();
      File dir = new File(line);
      if(!dir.exists()){
        System.out.println("重新输入");
      }else if(!dir.isFile()){
        System.out.println("是一个对象重新输入");
      }else {
        return dir;
      }
    }
  }
  public static long getFileLen(File dir){//统计文夹夹大小
    long len = 0;
    File[] subfiles = dir.listFile();
    for(File subfile : subfiles){
      if(subfile.isFile()){
        len = len + subfile.length();
      }else{
        len = len + getFileLen(subfile);
      }
    }
  }
}
```
*109.SequenceInputStream类*
```java
class Demo{
  public static void main(String[] args) {
    //两个输入输出流整合为一个
    SequenceInputStream sis = new SequenceInputStream(new FileInputStream("1.txt"),new FileInputStream("2.txt"));
    //多个输入流整合   --> 构造方法的重载 (Enumeration<? extends FileInputStream> e)
    Vector<FileInputStream> v = new Vector<>();   
    v.add(new FileInputStream("1.txt"));
    v.add(new FileInputStream("2.txt"));
    v.add(new FileInputStream("3.txt"));
    v.add(new FileInputStream("4.txt"));
    Enumeration<FileInputStream> en = v.element();   //vector类的elements方法返回Enumeration
    SequenceInputStream sis = new SequenceInputStream(en);
  }
}
```
*110.ByteArrayOutStream类*
```java
//字节流在读中文的过程中会出现乱码，编码不同，对应每个中文对应的字节不同
//内存中的IO流，在内存中创建了一个字节数组，不需要关流
class Demo{
  public static void main(String[] args) throws IOException{
    FileInputStream fis = new FileInputStream("1.txt");
    ByteArrayOutStream baos = new ByteArrayOutStream();
    int b;
    while((b = fis.read()) != -1){
      baos.write(b);
    }
    byte arr[] = baos.toByteArray();
    System.out.println(new String(arr));
  }
}
```
*111.对象IO流*
```java
//字符输出流不能写出对象
//存档ObjectOutputStream 序列化  读档ObjectInputStream 反序列化
class Demo{
  public static void main(String[] args) throws IOException{
    Person p1 = new Person("张三",23);
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("1.txt")); //对象存档
    oos.writeObject(p1); //把对象p1按照字节数组写入1.txt
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("1.txt")); //ObjectInputStream关联1.txt文档来读
    Person p2 = (Person)ois.readObject(); //将刚刚写入的对象字节读档
    System.out.println(p2); //读出p2
    ois.close();
    oos.close();
  }
}
class Person implements Serializable{ //Person必须序列化，是一个存档的过程，把属性都写入

}
```
```java
class Demo{
  public static void main(String[] args) throws IOException{
    Person p1 = new Person("张三",23);
    Person p2 = new Person("张三",23);
    Person p3 = new Person("张三",23);
    ArrayList<Person> list = new ArrayList<>(); //将对象放入集合中  ArrayList实现了Serializable接口
    list.add(p1);
    list.add(p2);
    list.add(p3);
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("1.txt")); //存档关联1.txt
    oos.writeObject(list);
    ois.close();
    oos.close();
  }
}
```
*112.IO流加入Id号*
```java
class Demo{
  public static void main(String[] args) throws IOException{

}
}
class Person implements Serializable{
  /*每次ID号默认随机生成*/
  private static final long serialVersionUID = 1L; //自己写入ID,就不会进行检测
  private String name;
  private int age;//第二次还没有存档，加入age后直接读档会报错:serialVersionUID不同(默认随机生成)
}
```
*113.打印流*
```java
//可以讲对象的toString方法输出，并且换行
class Demo{
  public static void main(String[] args) throws IOException {
    Person p = new Person("张三", 23);
    PrintStream ps = System.out; //System,out返回的是PrintStream对象
    ps.println(p);   //会自动调用toString方法
  }
}
```
*114.标准输入输出流*
```java
class Demo{
  public static void main(String[] args) throws Exception {
    InputStream is = System.in; //等待键盘录入 标准输入流 System.in 默认指向键盘，返回一个InputStream
    int x = is.read();          //读入录入的数值,read只读一个字节
    System.out.println(x);      //System.out 标准输出，默认指向控制台
    /*改变标准输入流和标准输出流   -> 开发中不会使用*/
    System.setIn(new FileInputStream("1.txt"));     //改变标准输入流指向 接受一个InputStream参数(输入流)
    System.setOut(new PrintStream("2.txt"));        //改变标准输出流指向 接受一个PrintStream对象作为参数
    InputStream is = System.in;
    PrintStream ps = System.out;
    int b;
    while((b = is.read()) != -1){
      ps.write(b);
    }
    is.close();
    os.close();
  }
}
```
*115.随机访问流*
```java
//RandomAccessFile
class Demo{
  public static void main(String[] args) throws IOException{
    RandomAccessFile raf = new RandomAccessFile("1.txt","rw");//文件+权限
    int x = raf.read();//指针从头开始，读取第一个字符给int,然后指针后移
    raf.seek(10); //找到指针插入的位置
    raf.write(102);//写入int   write(int)   write(byte[], int off, int len)
  }
}
```
*116.数据输入输出流*
```java
//DataInputStream和DataOutputStream可以写如何读取大数
class Demo{
  public static void main(String[] args) throws IOException {
    //字节流只能读入一个字节
    FileOutputStream fos = new FileOutputStream("1.txt");
    fos.write(997); //该数是一个int类型，写入是byte，会改变数值 32字节 -> 8字节
    //数据输入输出流
    DataOutputStream dos = new DataOutputStream(new FileOutputStream("1.txt"));
    dos.writeInt(997); //将int数转换为字节数组存入
    DataInputStream dis = new DataInputStream(new FileInputStream("1.txt"));
    int x = dis.readInt();
    System.out.println(x);
  }
}
```
*117.Properties类*
```java
//Hashtable的子类
//多用做配置文件 -> String 因此不加泛型
class Demo{
  public static void main(String[] args) {
    Properties p = new Properties();
    p.setProperty("username","zhansan");
    p.setProperty("password","123456");
    p.setProperty("QQ","1234560");
    //按照hash值来进行排序
    System.out.println(p);
    //通过key获取value
    String value = p.getProperty("username");
    System.out.println(value);
    //遍历 propertyNames() -> 获取所有key的枚举  进行键值对象的迭代
    Enumeration<String> en = (Enumeration<String>)p.propertyNames();
    while(en.hasMoreElements()){
      String key = en.nextElements();
      String value = p.getProperty(key);
      System.out.println(key + ":" + value);
    }
    //load()和list()方法
    //创建 config.properties 文件 其中等号会自动识别
    /**
    username=zhansan
    password=123456
    */
    Properties pr = new Properties();
    pr.load(new FileInputStream("config.properties")); //传入InputStream参数 读取配置文件
    System.out.println(pr);
    //修改配置文件
    pr.properties("username","lisi"); //通过key覆盖进行修改
    p.list(new PrintStream("config.properties"));//将修改后的文件保存到内存
  }
}
```
*118.Thread类*
```
并发：交替执行 并发：同时执行(多核)
jvm是多线程的
垃圾回收也是一条线程
```
```java
/**
/*第一种:定义一个Thread子类,重写Thread的run方法*/
class Demo{
  public static void main(String[] args) {
    MyThread mt = new Thread();     //3.创建一个子类对象
    mt.start();                     //4.start是该线程开始执行，jvm会自动调用run方法
    for(int i = 0; i < 10000; i++){
      System.out.println("Main");
    }
  }
}
class MyThread extends Thread{ //1.自定义类继承Thread
  @Override
  public void run(){           //2.重写run方法，将要执行的代码写到run方法中
    for(int i = 0; i < 10000; i++){
      System.out.println("MyThread");
    }
  }
}
```
```java
//第二种:定义一个实现Runnable接口的类
/**1.自定义Runnable接口
2.重写Run方法
3.将代码写到run方法中
4.创建Runnable接口的子类对象
5.创建线程对象，将Runnable的子类对象以参数传递
6.开启线程
*/
class Demo{
  public static void main(String[] args) {
    MyRunnable mr = new MyRunnable(); //是由Runnable接口实现，没有start()方法 /Thread类中
    Thread t = new Thread(mr);        //Thread()构造方法传入有参->Runnable的子类对象
    t.start();                        //start()开始执行，开出新线程
    for(int i = 0; i < 10000; i++){
      System.out.println("Main");
    }
  }
}
class MyRunnable implements Runnable{
  @Override
  public void run(){
    for(int i = 0; i < 10000; i++){
      System.out.println("MyRunnable");
    }
  }
}
```
```java
//使用匿名内部类开启线程
class Demo{
  public static void main(String[] args) {
    //Thread实现线程
    new Thread() {
      public void run(){
        for(int i = 0;i < 10000; i++){
          System.out.println("Thread");
        }
      }
    }.start();
    //Runnable实现线程
    new Thread(new Runnable(){
              @Override
              public void run(){
                for(int i = 0; i < 10000; i++){
                  System.out.println("Runnable");
                }
              }
            }).start();
  }
}
```
*119.多线程的方法*
```java
class Demo{
  public static void main(String[] args) {
    //修改线程名：构造方法/setName
    Thread t = new Thread("线程一") {  //使用构造方法设置线程名
      public void run(){
        for(int i = 0;i < 10000; i++){
          System.out.println(this.getName()); //Thread类的getName()获取线程名 默认Thread-0/1...
        }
      }
    };
    t.setName("线程一"); //使用setName设置线程名
    t.start();

Thread tt = new Thread(new Runnable(){
      public void run(){
        for(int i = 0;i < 10000; i++){
          System.out.println(Thread.currentThread().getName()); //currentThread()返回当前执行对象的引用
        }
      }      
    }, "线程二");
    tt.setName("线程二");
  }
}
```
*120.线程休眠*
```java
class Demo{
  public static void main(String[] args) throws InterruptedException{ //抛出中断异常
    //主线程休眠
    for(int i = 0; i < 10; i++){
      Thread.sleep(1000); //静态方法，类名调用，以毫秒值计算 1000ms -> 1s
      System.out.println("第"+i+"秒");
    }

new Thread(){
      @Override
      public void run(){   //父类中的run方法没有抛出异常，所以只能子类重写的try catch处理
        for(int i = 0;i < 1000; i++){
          try{
            Thread.sleep(10);
          }catch(InterruptedException e){
            e.printStackTrace();
          }
        }
      }
    }.start();
  }
}
```
*121.守护线程*
```java
class Demo{
  public static void main(String[] args) {

Thread t1 = new Thread("线程二") {  //使用构造方法设置线程名
      public void run(){
        for(int i = 0;i < 1000; i++){
          System.out.println(this.getName()); //Thread类的getName()获取线程名 默认Thread-0/1...
        }
      }
    };

Thread t2 = new Thread("线程一") {  //使用构造方法设置线程名
      public void run(){
        for(int i = 0;i < 1000; i++){
          System.out.println(this.getName()); //Thread类的getName()获取线程名 默认Thread-0/1...
        }
      }
    };
    t2.setDaemon(true);  //设置t2为守护线程，在线程1结束后，线程2也会结束
    t1.start(); //开启线程
    t2.start();
  }
}
```
*122.加入线程*
```java
class Demo{
  public static void main(String[] args) {

final Thread t1 = new Thread("线程一") {
      @Override
      public void run(){
        for(int i = 0;i < 1000; i++){
          System.out.println(this.getName());
        }
      }
    };

Thread t2 = new Thread("线程二") {
      @Override
      public void run(){
        for(int i = 0;i < 1000; i++){
          if(i == 2){
            try{
              t1.join();    //匿名内部类使用当前方法中的局部变量时局部变量用final修饰
              //此时线程1先执行完
              /**
              t1.jion(30);  //t1先执行30ms,然后交替执行
              Thread.sleep()
              */
            }catch(InterruptedException e){
              e.printStackTrace();
            }

}
          System.out.println(this.getName()); //Thread类的getName()获取线程名 默认Thread-0/1...
        }
      }
    };  
  }
}
```
*123.同步代码块*
```java
class Demo{
  public static void main(String[] args) {
    final Printer p = new Printer();
    //线程一
    new Thread(){
      public void run(){
        while(true){
          p.print1();
        }
      }
    }.start();
    //线程二
    new Thread(){
      public void run(){
        while(true){
          p.print2();  
        }
      }
    }.start();
  }
}
class Printer{
  Object obj = new Object;
  public void print1(){
    synchronized(obj){   //同步代码块，synchronized中cpu不会进行切换,其中参数传入一个任意的对象,但是匿名对象不能当作锁，因为不能保证锁相同
      System.out.println("1");
      System.out.println("2");
      System.out.println("3");      
    }
  }
  public void print2(){
    synchronized(obj){
      System.out.println("一");
      System.out.println("二");
      System.out.println("三");    
    }
  }
}
```
*124.同步方法*
```java
//非静态的同步方法锁对象是this,
//静态方法的锁对象是Printer.class，静态方法随着类的加载而加载，此时只有字节码对象
//Printer.class是加载类的时候返回的对象(万能锁对象)，同步代码块的时候可以都使用类名.class
class Demo{
  public static void main(String[] args) {

}
}
class Printer{
  Object obj = new Object;
  public synchronized void print1(){
    System.out.println("1");
    System.out.println("2");
    System.out.println("3");

}
  public synchronized void print2(){
    System.out.println("一");
    System.out.println("二");
    System.out.println("三");    
  }
}
```
*125.多线程的线程安全*
```java
class Demo{
  public static void main(String[] args) {

}
}
/*方法一 Thread子类*/
class TicketSeller extends Thread {
  private static int tickets = 100; //静态属性随着类的加载而加载，在字节码文件中，优先于对象，所有创建的对象共享(共性用静态)
  @Override
  public void run(){
    while(true){
      synchronized(TicketSeller.class){  //静态锁来保证每次只有一个线程进入
        if(tickets <= 0)
        break;
        System.out.println(getName()+"第"+tickets+"号票");
      }
    }
  }
}
```
```java
/*方法二 Runnable对象*/
class Demo{
  public static void main(String[] args) {
    TicketSeller ts = new TicketSeller();
    Thread t1 = new Thread(ts,"窗口一");
    Thread t1 = new Thread(ts,"窗口二");
    Thread t1 = new Thread(ts,"窗口三");
    t1.start();    //多次启动一条线程是非法的
    t2.start();
    t3.start();
  }
}
class TicketSeller implements Runnable {
  private static int tickets = 100; //静态属性随着类的加载而加载，在字节码文件中，优先于对象，所有创建的对象共享(共性用静态)
  @Override
  public void run(){
    while(true){
      synchronized(this){  
        if(tickets <= 0)
        break;
        System.out.println(Thread.currentThread().getName()+"第"+tickets+"号票");
      }
    }
  }  
}
```
*126.死锁*
```java
//避免同步代码块的嵌套
class Demo{
  public static void main(String[] args) {
    private String s1 = "左";
    private String s2 = "右";
    //获取到s1对象，没有被释放，等待s2
    new Thread(){
      @Override
      public void run(){
        while(true){      //线程一先开始，会先完成几次，但当线程二加入后就会变成死锁
          synchronized(s1){
            System.out.println("获取"+s1+"等待"+s2);
            synchronized(s2){
              System.out.println("获取"+s2+"完成");
            }
          }          
        }
      }
    }.start();
    //获取到s2对象，没有被释放，等待s1
    new Thread(){
      @Override
      public void run(){
        while(true){
          synchronized(s2){
            System.out.println("获取"+s2+"等待"+s1);
            synchronized(s1){
              System.out.println("获取"+s2+"完成");
            }
          }        
        }
      }
    }.start();
  }
}
```
*127.setPriority()方法*
```java
//设置线程优先级
// MAX_PRIORITY MIN_PRIORITY NORM_PRIORITY
class Demo{
  public static void main(String[] args) {
    Thread t1 = new Thread(){
      @Override
      public void run(){
        for(int i = 0; i < 1000; i++){
          System.out.println(getName());
        }
      }
    };
    Thread t2 = new Thread(){
      @Override
      public void run(){
        for(int i = 0; i < 1000; i++){
          System.out.println(getName());
        }
      }
    };
    t1.setPriority(MAX_PRIORITY);  //设置t1的优先级高(10)
    t2.setPriority(MIN_PRIORITY);  //设置t2最低级别(1)   不设置默认为NORM_PRIORITY (5)
   }
}
```
*128.yield()方法*
```java
//礼让线程
//静态方法，直接用类名调用 Thread.yield()
//支持不是很好
class Demo{
  public static void main(String[] args) {
    new MyThread().start();
    new MyThread().start();
  }
}
class MyThread extends Thread{
  @Override
  public void run(){
    for(int i =0; i<1000; i++){
      if(i % 10 == 0){      
        Thread.yield();
      }
      System.out.println(getName());
    }
  }
}
```
*129.单例设计模式*
```java
//私有构造方法，不让其他类创建子类对象
//本类中创建对象
//对外提供公共的访问方法，返回本类对象

//第一种 public final static
class Demo{
  public static void main(String[] args) {
    Singlenton s1 = Singlenton.s;
    Singlenton s2 = Singlenton.s;
    System.out.println(s1 == s2);  // --> true 说明是同一个对象
  }
}
class Singlenton{
  private Singlenton(){   //创建私有构造
    public final static Singlenton s = new Singlenton(); //创建本类公共的静态的final修饰的对象
  }
}
//第二种 饿汉式  --> 先创建对象
//空间换时间
//多线程没有安全隐患
class Demo{
  public static void main(String[] args) {
    Singlenton s1 = Singlenton.getInstance();
    Singlenton s2 = Singlenton.getInstance();
    System.out.println(s1 == s2); //true
  }
}
class Singlenton{
  private Singlenton(){}                  //私有构造方法
  static Singlenton s = new Singlenton(); //创建本类对象,使用static,可以直接使用类类访问成员变量
  public static Singlenton getInstance(){ //公共访问方法，返回本类对象
    return s;
  }
}
//懒汉式   --> 需要的时候创建对象
//时间换空间
//多线程有安全隐患，可能会创建多个对象
class Demo{
  public static void main(String[] args) {
    Singlenton s1 = Singlenton.getInstance();
    Singlenton s2 = Singlenton.getInstance();
    System.out.println(s1 == s2); //true
  }
}
class Singlenton{
  private Singlenton(){}
  private static Singlenton s;            //声明一个本类的引用
  public static Singlenton getInstance(){
    if(s == null){                        //判断是否有对象再决定是否创建，不用的时候不创建
      s = new Singlenton();               //多线程时可能会有会有延时加载，线程一在判断后没有创建对象，就被线程二抢走
    }
    return s;
  }
}
```
*130.Runtime类*
```java
//Runtime是一个内部类，其中exec()方法可以传入命令行命令
class Demo{
  public static void main(String[] args) throws IOException{
    Runtime r = Runtime.getRuntime(); //获取到Runtime类(单例设计模式的类)的对象
    r.exec("shutdown -s -t 300");
  }
}
```
*131.TimerTask类*
```java
class Demo{
  public static void main(String[] args) {
    Timer t = new Timer();  //创建计时器对象
    t.schedule(new MyTimerTask,new Date(117,8,10,0,4,00));  //schedule(TimerTask task,long delay) 安排在指定时间完成的任务
  //t.schedule(new MyTimerTask,new Date(117,8,10,0,4,00),3000);//  schedule(TimerTask task, long delay, long period)  每隔3秒钟启动一次
    while(true){
      sleep(1000);
      System.out.println(new Date);
    }
  }
}
class MyTimerTask extends TimerTask{
  @Override
  public void run(){
    System.out.println("到时间了");
  }
}
```
*132.线程等待唤醒机制*
```java
//wait() notify()
//两个Thread之间的通信
class Demo{
  public static void main(String[] args) {
    final Printer p = new Printer();
    new Thread(){
      @Override
      public void run(){    //run()使用try catch，因为在父类的run方法中没有报错
        while(true){
          try{
            p.print1();
          }catch (InterruptedException e){
            e.printStackTrace();
          }
        }
      }
    }.start();
    new Thread(){
      @Override
      public void run(){
        while(true){
          try{
            p.print2();
          }catch (InterruptedException e){
            e.printStackTrace();
          }
        }
      }
    }.start();
  }
}
class Printer{
  private flag = 1;
  public void print1() throws InterruptedException{
    synchronized(this){
      if(flag != 1){
        this.wait();
      }
      System.out.println("一");
      System.out.println("二");
      flag = 2;
      this.notifyAll(); //随机唤醒线程，但是flag 为 2，执行第二个线程
    }
  }
  public void print2() throws InterruptedException{
    if(flag != 2){
      this.wait();
    }
    synchronized(this){
      System.out.println("1");
      System.out.println("2");
      flag = 1;
      this.notifyAll();
    }
  }
}
//锁对象和调用wait()方法的对象相同
//wait()和notify()定义在object类中，因为所有对象都可以作为锁对象
//wait(long time) //传入参数-->等待参数时间到后等待
//sleep()方法在同步代码块中不释放锁，wait()释放锁
```
```java
//多个线程之间的通信 第一种：notifyAll()唤醒所有
//if -> while  //多次循环判断是否满足条件
//notify -> notifyAll //将所有线程唤醒 防止只唤醒的线程不满足条件
class Demo{
  public static void main(String[] args) {
    final Printer p = new Printer();
    new Thread(){
      @Override
      public void run(){
        while(true){
          try{
            p.print1();
          }catch (InterruptedException e){
            e.printStackTrace();
          }
        }
      }
    }.start();
    new Thread(){
      @Override
      public void run(){
        while(true){
          try{
            p.print2();
          }catch (InterruptedException e){
            e.printStackTrace();
          }
        }
      }
    }.start();
    new Thread(){
      @Override
      public void run(){
        while(true){
          try{
            p.print3();
          }catch (InterruptedException e){
            e.printStackTrace();
          }
        }
      }
    }.start();
  }
}
class Printer{
  private flag = 1;
  public void print1() throws InterruptedException{
    synchronized(this){
      while(flag != 1){
        this.wait();
      }
      System.out.println("一");
      System.out.println("二");
      flag = 2;
      this.notifyAll(); //随机唤醒线程，但是flag 为 2，执行第二个线程
    }
  }
  public void print2() throws InterruptedException{
    while(flag != 2){
      this.wait();
    }
    synchronized(this){
      System.out.println("1");
      System.out.println("2");
      flag = 3;
      this.notifyAll();
    }
  }
  public void print3() throws InterruptedException{
    while(flag != 3){
      this.wait();
    }
    synchronized(this){
      System.out.println("A");
      System.out.println("B");
      flag = 1;
      this.notifyAll();
    }
  }
}
```
*133.ReentrantLock类*
```java
//ReentrantLock类替换synchronized锁
//实例化出c对象使用await()和signal()方法
//唤醒指定线程
//if()  因为唤醒线程是确定的不用多次判断
class Demo{
  public static void main(String[] args) {

}
}
class Printer{
  private ReentrantLock r = new ReentrantLock();
  private Condition c1 = new Condition();
  private Condition c2 = new Condition();
  private Condition c3 = new Condition();
  private flag = 1;
  public void print1() throws InterruptedException{
    r.lock(); //获取锁
    if(flag != 1){
      c1.await(); //c1等待
    }
    System.out.println("一");
    System.out.println("二");
    flag = 2;
    this.notifyAll();
    c2.signal();  //叫醒 c2
    r.unlock(); //释放锁
  }
  public void print2() throws InterruptedException{
    if(flag != 2){
      c2.await();
    }
    r.lock();
    System.out.println("1");
    System.out.println("2");
    flag = 3;
    this.notifyAll();
    c3.signal();
    r.unlock();
  }
  public void print3() throws InterruptedException{
    if(flag != 3){
      c3.await();
    }
    r.lock();
    System.out.println("A");
    System.out.println("B");
    flag = 1;
    this.notifyAll();
    c1.signal();
    r.unlock();
  }  
}
```
*134.线程组和线程池*
```java
//线程组
//ThreadGroup类
//getThreadGroup()返回线程组的名称
class Demo{
  public static void main(String[] args) {
    MyRunnable mr = new MyRunnable();
    ThreadGroup tg = new ThreadGroup("线程组一");
    Thread t1 = new Thread(mr, "线程一");
    ThreadGroup tg1 = t1.getThreadGroup();  //默认属于主线程组 println(tg1)-> main

Thread t2 = new Thread(tg, mr, "线程二");
    Thread t3 = new Thread(tg, mr, "线程三");
    //对线程整组操作
    //tg.setDaemon();守护线程
    tg.setMaxPriority(); //最大优先级
    System.out.println(tg.geyName()); //getName()返回线程组名字 -> 线程组一
  }
}
class MyRunnable implements Runnable{
  @Override
  public void run(){
    for(int i = 0; i < 1000; i++){
      System.out.println(Thread.currentThread().getName()+".."+i);
    }
  }
}
```
```java
//线程池
//newFixedThreadPool(int n)是一个静态方法，返回的对象是ExecutorSeivce类,创建含有n个线程的线程池
//线程池中的线程结束后不会死亡，在创建大量生存周期短的线程池时使用
class Demo{
  public static void main(String[] args) {
    ExecutorSeivce pool = Executors.newFixedThreadPool(2); //创建一个可以放2条线程的线程池
    MyRunnable mr1 = new MyRunnable(); //创建Runnable的子类对象
    MyRunnable mr2 = new MyRunnable();
    //将mr1和mr2放入同一个线程池  submit ,线程执行完后没有消失
    pool.submit(mr1);
    pool.submit(mr2);
    //关闭线程池
    pool.shutdown(); //不接受先任务
  }
}
class MyRunnable implements Runnable{
  @Override
  public void run(){
    for(int i = 0; i < 1000; i++){
      System.out.println(Thread.currentThread().getName()+".."+i);
    }
  }
}
```
*135.Callable接口*
```java
class Demo{
  public static void main(String[] args) {
    ExecutorSeivce pool = Executors.newFixedThreadPool(2);
    MyCallable mc1 = new MyCallable(100);  //第一个线程求100的和
    MyCallable mc2 = new MyCallable(200);
    Future<Integer> f1 = pool.submit(mc1); //submit()有返回 Future<V>
    Future<Integer> f2 = pool.submit(mc2); //Future接口
    Integer i1 = f1.get();                 //Future中的get方法，拿到计算结果
    Integer i2 = f2.get();
    System.out.println(i1);
    System.out.println(i2);
    pool.shutdown();
  }
}
public class MyCallable implements Callable <Integer> {
  private int num;
  @Override
  public Integer call() throws Exception{
    int sum = 0;
    for(int i = 0; i <= num; i++){
      sum+=i;
    }
    return sum;
  }
}
```
*136.静态工厂方法模式*
```java
//定义一个工厂类，负责产生对象，只要条用静态方法来返回对象
//扩展性较差，需要对工厂类进行修改
class Demo{
  public static void main(String[] args) {
    // Dog d = AnimalFactory.creatDog();
    // Cat c = AnimalFactory.creatCat();
    // d.eat();
    // c.eat();
    Animal a = AnimalFactory.createAnimal("Dog");//父类引用指向子类对象
    if(a != null){  //需要进行判断是否为空
      a.eat();
    }else{
      System.out.println("没有该类型");
    }
  }
}
//动物类
class abstract Animal{  //定义一个抽象类
  public abstract void eat();//抽象方法，不能有方法体
}
class Dog extends Animal{
  @Override
  public void eat(){
    System.out.println("Bone");
  }
}
class Cat extends Animal{
  @Override
  public void eat(){
    System.out.println("Fish");
  }
}
//工厂类，负责创建并返回对象
public class AnimalFactory{
  //所有方法都是静态的，私有构造函数,不让其他类创建本类对象
  private AnimalFactory(){};
  /*创建的对象较少时*/
  // public static Dog creatDog(){ //返回Dog类的方法, static->使用类名调用
  //   return new Dog();
  // }
  // public static Cat creatCat(){ //返回Cat类的方法
  //   return new Cat();
  // }

//写入一个方法中进行传入参数的判断来确定返回的对象
  public static Animal createAnimal(String name){
    if(name.equals("Dog")){
      return new Dog();
    }if else(name.equals("Cat")){
      return new Cat();
    }else{
      return null;
    }
  }
}
```
*137.工厂方法设计模式*
```java
//不需要每次都对工厂进行修改，设计一个抽象父类工厂，由子类对创建的对象进行返回
//客户端不需要对类进行创建，明确了各个类的职责，增加新对象只需要增加新的类和对应的工厂类
class Demo{
  public static void main(String[] args) {
    DogFactory df = new DogFactory();
    Animal a = df.createAnimal();
    a.eat();
  }
}
//创建动物类
public abstract class Animal{
  public abstract void eat();
}
class Dog extends Animal{
  @Override
  public void eat(){
    System.out.println("Bone");
  }
}
class Cat extends Animal{
  @Override
  public void eat(){
    System.out.println("Fish");
  }
}
//创建工厂接口,然后创建子类工厂实现接口
public interface Factory{
  public Animal createAnimal();
}
public class DogFactory implements Factory{
  @Override
  public Animal createAnimal(){
    return new Dog();
  }
}
```
*138.GUI窗体*
```java
//位于java.awt.Frame包下
//创建一个窗体
import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Toolkit;

public class Demo2 {

public static void main(String[] args) {
		Frame f = new Frame("窗口名字");
		f.setSize(400, 600);//设置大小
		f.setLocation(100, 300);//设置位置
		f.setIconImage(Toolkit.getDefaultToolkit().createImage("music.png"));//窗口图象
		f.setVisible(true);	//设置窗体显示
		Button b = new Button("按钮名称");
		f.add(b);	//默认流式布局
		f.setLayout(new FlowLayout());
		b.setVisible(true);
	}
}
//FlowLayout 流式 plane默认
//BonderLayout  边界布局管理器
//GridLayout 网格布局管理器
//CardLayout 卡片布局管理器
//GridBagLayout 网格包布局管理器
```
*139.窗口监听*
```java
class Demo{
  public static void main(String[] args) {
    Frame f = new Frame("Name");
    f.setSize(400, 600);//设置大小
		f.setLocation(100, 300);//设置位置
    //WindowListener接口
    f.addWindowListener(new MyWindowListener());
    //WindowAdapter类
    f.addWindowListener(new MyWindowAdapter()); //也可使用匿名内部类
    // f.addWindowListener(new WindowAdapter() {
    //   @Override
    //   public void windowClosing(WindowEvent e) {
    //     System.exit(0);
    //   }
    // });
    f.setVisible(true);
  }
}
//方法一 WindowListener接口
class MyWindowListener implements WindowListener{
  @Override//需要对WindowListener接口所有方法 (抽象)重写
	public void windowOpened(WindowEvent e) {
	}
	@Override
	public void windowClosing(WindowEvent e) {
		System.exit(0);	//退出虚拟机 -> 关闭窗口
	}
	@Override
	public void windowClosed(WindowEvent e) {
	}
	@Override
	public void windowIconified(WindowEvent e) {
	}
	@Override
	public void windowDeiconified(WindowEvent e) {
	}
	@Override
	public void windowActivated(WindowEvent e) {
	}
	@Override
	public void windowDeactivated(WindowEvent e) {
	}
}
//方法二 WindowAdapter类
//是对WindowListener接口的一个实现，全为空方法
class MyWindowAdapter extends WindowAdapter{
  @Override
  public void windowClosing(WindowEvent e) {
		System.exit(0);	//退出虚拟机 -> 关闭窗口
	}  
}
```
*140.鼠标监听*
```java
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
class Demo{
  public static void main(String[] args) {
    Frame f = new Frame("Name");
    f.setSize(400, 600);//设置大小
		f.setLocation(100, 300);//设置位置
    Button b = new Button("按钮");
    f.add(b);
    b.addMouseListener(new MouseAdapter() {
			@Override
			public void mouseReleased(MouseEvent e) {
				System.exit(0);
			}
		});
    f.setLayout(new FlowLayout());
    f.setVisible(true);
    b.setVisible(true);
  }
}
```
*141.键盘监听*
```java
class Demo{
  public static void main(String[] args) {
    Frame f = new Frame("Name");
    f.setSize(400, 600);//设置大小
		f.setLocation(100, 300);//设置位置
    b.addKeyListener(new KeyAdapter() {
			@Override
			public void keyReleased(KeyEvent e) {  //KeyEvent e 接受了录入的键盘值
				System.out.println(e.getKeyCode()); //打印ascii
        if(e.getKeyCode() == KeyEvent.VK_SPACE){
          System.exit(0);
        }
			}
		});
    f.setLayout(new FlowLayout());
    f.setVisible(true);
  }
}
```
*142.动作监听*
```java
//默认监听空格键
class Demo{
  public static void main(String[] args) {
    Frame f = new Frame("窗体");
    f.setVisible(true);
    Button b = new Button("按钮");
    f.add(b);
    b.setVisible();

b.addActionListener(new ActionListener(){ //只有一个方法，没有对应的Adapter类
      @Override
      public void actionPerformed(ActionEvent e){ //空格 和 鼠标同时监听
        System.exit(0);
      }
    });
  }
}
```
*143.适配器设计模式*
```java
//在抽象类和子类之间实现一个空方法重写抽象方法的适配器，子类继承适配器不需要对所有方法重写
class Demo{
  public static void main(String[] args) {
    LazyMan lm = new LazyMan();
    lm.eat();
  }
}
interface Man{
  public void eat();
  public void work();
}
abstract class MyAdapter implements Man{ //适配器类MyAdapter,抽象类，其他类不能创建本类对象
  @Override
  public void eat(){}
  @Override
  public void work(){}
}
class LazyMan implements MyAdapter{
  @Override
  public void eat(){
    System.out.println("eat");
  }
}
```

fafnir/JavaNotes

About

Releases

Contributors

Activities