集合框架

1，接口
集合中用到的类，接口在java.util包中，在使用时注意将其引入import。

Collection

用来管理多个对象，集合中的每个元素都是对象。

1)List 一个List的实现类的对象在管理多个对象时会按顺序组织对象（即按照将对象放入的顺序存储）List实现类的对象是有顺序的，List实现类对象中的内容是可重复的。（注意，顺序和排序的区别）
2)Set 一个Set的实现类表示一个数学概念上的集合，Set的实现类的对象中的元素是无顺序的，也就是不会按照输入顺序来存放，Set的实现类对象中的元素是不重复的。
3)SortedSet,他是Set的子接口，他的实现类会对集合中的元素进行排序。但是要指定排序规则，他会按排序规则进行排序。

Map，Map中没有对象，而是键值对，由Key，value组成的键值对
Key是没有顺序，不可重复的。
value是可以相同的,一个Key和一个value一一对应。

Map 接口（以下介绍其子接口）
SortedMap，这个接口的实现类同样可以实现，不过是对键值对中的Key进行排序，这个接口的实现类也是要指定排序规则的。

1> ArrayList

是接近于功能的集合类，ArryList的实质就是一个会自动增长的数组，ArrayList是用封装的数组来实现的List接口的。
Collection的实现类对象的遍历方式是用迭代来实现的。

在使用迭代器时先要获得一个迭代器的对象，Iterator（迭代器接口）这是一个接口，迭代器是在集合类中实现的，也就是说，他是一个内部类（匿名内部类）实现的。
  Iterator接口中定义的常用方法方法hasNext()，next()。
  hasNext(),这个方法会使用一个游标，并通过判断游标指向的位置是否存放有对象。
  next()方法也是Iterator接口中定义好的方法，这个方法会使游标指向下一个元素的位置，游标会跳过第一个元素，并返回其中的内容。

Collections 这是一个工具类，也是java.util包中的，这个类中的sort(list接口的实现类的对象)方法，其参数是一个集合类的对象，这个方法使用来对集合类的对象进行排序的。以后，我将以集合这个名字来称呼集合类的对象。，对于字符串对象内容的集合来说会按字典顺序排序（升序），对于数字内容的集合排序也会按照升序排序。

排序可分为两部分内容，一个是排序的规则，也就是按照什么来进行排序，并且排成什么样的顺序。
第二个就是排序的算法，他决定了排序的效率。

在对自定义的集合内容排序时，需要先定义那个类型的排序规则。

Comparable接口，这个接口中只定义了一个compareTo(Object o)，方法的返回类型是整型，如果当前对象大于参数对象就返回正数，当前对象等于参数对象是就返回0，当前对象小于参数对象时就返回负值，这样写就是升序排列，反之则是进行降序排列，在实现这个接口中的方法时，返回值定义方式，只有这两种。

根据指定类型的排序规则实现了Comparable接口，那么就可以对存有这个类型的集合进行整体排序。Comparable接口，也叫做可比较接口。这个接口在java.lang包下。只要实现了这个接口，就是可排序的。

接下来介绍另外一种对自定义类型对象的集合整体排序的方法，也就是实现比较器接口（Comparator），这个接口中定义了一个compare(Object o1，Object o2)方法来比较两个对象，这个方法的返回值定义和上面介绍的那个方法是一样。

注意：在API，帮助文档中以上两个方法的参数类型是T，这代表的模板类型，也就是集合中存放的内容的类型，在JDK1.4中其参数就是Object类型，模板类型的详细内容会在最后的JDK5.0新特性中讲到。

Comparator接口可以在匿名内部类中实现，Collections 中的sort(集合了的对象，比较器)方法，可以对自定义类型内容的集合进行整体排序。

2> LinkedList

，它是List接口的实现类，其底层是用双向循环链表来实现的。

注意：ArrayList的查询效率比较高，增删动作的效率比较差，适用于查询比较频繁，增删动作较少的元素管理的集合。
        LinkedList的查询效率低，但是增删效率很高。适用于增删动作的比较频繁，查询次数较少的元素管理集合。

ArrayList，LinkedList都是线程不安全的。

实现堆栈 1，数组（ArrayList，增删效率比较低，不适合）
              2，LinkedList（实现堆栈的好方法）
              3，java.util.Stack类，Stack是Vector的子类，Vector类是一个线程安全的（是一个重量级的类），并继承了Vector的方法，Verctor类（这个类也是List接口的实现类）和ArrayList的功能近乎相同。（不推荐使用Stack类来实现堆栈）。

内部类的分类：

1. 成员内部类
2. 局部内部类
3. 静态内部类
4. 匿名内部类（图形监听时要用到，要掌握）。

一、成员内部类

四个访问权限修饰符都可以修饰成员内部类。

内部类和外部类在编译时是不同的两个类，内部类对外部类没有任何依赖。

内部类是一种编译时语法，在编译时生成的各自的字节码文件(Outer.class和Outer$Inner.class)，内部类和外部类没有关系。

内部类中可以访问外部类的私有成员。（与C++的友员相比，不破坏封装）

作为外部类的一个成员存在，与外部类的属性、方法并列。

内部类和外部类的实例变量可以共存。

在内部类中访问实例变量：this.属性

在内部类访问外部类的实例变量：外部类名.this.属性。

在外部类的外部访问内部类，使用out.inner.

成员内部类的特点：

（1）内部类作为外部类的成员，可以访问外部类的私有成员或属性。（即使将外部类声明为private，但是对于处于其内部的内部类还是可见的。）

（2）用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。 
注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。

对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。

（3）成员内部类不能含有静态成员。
建立内部类对象时应注意：

在外部类的内部可以直接使用inner s=new inner();（因为外部类知道inner是哪个类，所以可以生成对象。）

而在外部类的外部，要生成（new）一个内部类对象，需要首先建立一个外部类对象（外部类可用），然后在生成一个内部类对象。内部类的类名是外部类类名.内部类类名。

1
2

 Outer o=new Outer(); 
Outer.Inner in=o.new.Inner();

二、静态内部类

（注意：前三种内部类与变量类似，所以可以对照参考变量）

静态内部类定义在类中，任何方法外，用static class定义。

静态内部类只能访问外部类的静态成员。

生成（new）一个静态内部类对象不需要外部类对象：这是静态内部类和成员内部类的区别。

静态内部类的对象可以直接生成：

Outer.Inner in=new Outer.Inner()；

而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。 静态内部类不可用private来进行定义。

三、局部内部类

在方法中定义的内部类称为局部内部类。

与局部变量类似，在局部内部类前不加修饰符public和private，其范围为定义它的代码块。

注意：

局部内部类不仅可以访问外部类私有实例变量，还可以访问外部类的局部常量（也就是局部变量必须为final的）

在类外不可直接访问局部内部类（保证局部内部类对外是不可见的）。

在方法中才能调用其局部内部类。

通过内部类和接口达到一个强制的弱耦合，用局部内部类来实现接口，并在方法中返回接口类型，使局部内部类不可见，屏蔽实现类的可见性。

四、匿名内部类

匿名内部类是一种特殊的局部内部类，它是通过匿名类实现接口，并只创建一次。

匿名内部类的特点：

（1）一个类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的事先或是覆盖。

（2）只是为了获得一个对象实例，不许要知道其实际类型。

（3）类名没有意义，也就是不需要使用到。

注：一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类，没有类名，根据多态，我们使用其父类名。 因其为局部内部类，那么局部内部类的所有限制都对其生效。

匿名内部类是唯一一种无构造方法类。

大部分匿名内部类是用于接口回调用的。

匿名内部类在编译的时候由系统自动起名Out$1.class。

如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。

因匿名内部类无构造方法，所以其使用范围非常的有限。

当需要多个对象时使用局部内部类，因此局部内部类的应用相对比较多。匿名内部类中不能定义构造方法。

匿名内部类的写法：

1
2
3
4
5
6
7
8
9
10

interface A{ 
    void ia();    
} 
class B{ 
    public A bc(){ 
        return new A(){      //匿名类实现了A接口 
            void ia(){……} 
        }; 
        } 
}

使用匿名内部类：

1
2
3

B b=new B(); 
A a=b.bc(); 
a.ia();

注意：

当类与接口（或者是接口与接口）发生方法命名冲突的时候，此时必须使用内部类来实现。 
用接口不能完全地实现多继承，用接口配合内部类才能实现真正的多继承。

对于两个类，拥有相同的方法：

1
2
3
4
5
6
7

 class People 
{ 
  run(); 
} 
interface Machine{ 
   run(); 
}

此时有一个robot类：

class Robot extends People implement Machine.

名为run()的方法有2个，不可直接实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

interface Machine{ 
    void run(); 
} 
class Person{ 
    void run(){System.out.println("run");} 
} 
class Robot extends People{ 
    class Heart implements Machine{ 
        public void run(){ 
            System.out.println("发动机运行"); 
        } 
    } 
    public Machine getHeart(){ 
        return new Heart(); 
    } 
    public void run(){ 
        System.out.println("机器人跑"); 
    } 
} 
public class Test{ 
    public static void main(String[] args){ 
              Robot r=new Robot(); 
        r.run(); 
        r.getHeart().run(); 
    } 
}

1、Object 所有的类直接或间接的父类
        finalize:垃圾收集的时候调用
        toString:返回对象的字符串形式
        equals:判断两个对象内容是否相同
2、包装类
     8种基本类型各自提供了对象形式
3、异常处理
     提高容错性
     异常的分类：Throwable
                Error    :错误，不可避免，不可处理
                Exception:Runtime：未检查：可处理可不处理，首先应该努力避免异常（本可避免的）
                          非Runtime：已检查：必须要处理
     异常对象的产生：throw 抛出异常，沿着方法调用链反向传递
     异常处理：throws 消极，声明抛出
              try-catch 捕获异常
              try-catch-finally
              try-finally
     方法覆盖 ：子类覆盖方法不能比父类被覆盖方法抛出更多的，范围更宽的异常
4、自定义异常

二、断言

在JDK1.4之后开始出现，是一个调试工具
其后跟的是布尔类型的表达式，如果表达式结果为真不影响程序运行。如果为假系统出现低级错误(Error)，在屏幕上出现assert信息。

assert a%2==0;
编译器的默认设置：把断言语句忽律 
javac -source 1.4 源文件名   //表示用1.4新特性编译
java -enableassert(-ea) 类名  //打开断言功能
assert a%2==0:"a必须是偶数";  //出现错误时的提示信息
assert只是用于调试。在产品编译完成后上线assert代码就被删除了。

（1）声明抛出 

是方法声明的第五部分  throws+异常名字（多个异常用“，”分隔）
出现异常，不处理，抛给上一级处理
并且子类抛出异常的范围不能比父类抛出异常的范围更宽。

(2）捕获异常

       try – catch
       try – catch – finally
       try – finally     //不捕获异常，当异常发生，返回上一级之前，要运行finally中的代码
       以上语句可以嵌套

       返回类型 方法名（参数）｛
        try{
            可能出错语句
            正常语句
        }catch(异常类 e)｛  //某种异常的引用
            对异常的处理
        ｝
        正常语句       
    ｝

      捕获多个异常：
       程序任何时刻只发生一个异常

可对产生的每个异常分别捕捉，也可由同一异常进行处理，前提是这个共用的异常应该是所有这些该被捕获的异常的父类,但是，对于非受查异常不成立

当try后面有多个语句块时，注意catch异常的顺序，子类必须放在父类的前面

finally关键字

无论异常是否发生，一定会执行的代码，可放在finally块内。

要点：
没有异常产生时：正常执行try{}catch(){} —> 进入finally语句块 —> 方法中剩余代码

有异常产生时（捕找到） —> 进入catch处理 —> 进入finally语句块 —> 方法中剩余代码

有异常产生时（没捕找到）—> 进入finally语句块 —> 离开方法

一般写一些释放资源的代码

在try – catch 块中遇到System.exit(0);则不会执行finally中的代码
Throwable有一个message属性。在使用catch的时候可以调用：
Catch(IOException e){System.out.println(e.getMessage())};  //打印出来的是创建(throw new)异常对象的时候，给定的参数
Catch(IOException e){e.printStackTrace()};                 //打印堆栈追踪信息
以上两条语句都是可以打印出错的过程信息。告诉我们出错类型所历经的过程，在调试的中非常有用。

开发中的两个道理：
①如何控制try的范围：根据操作的连动性和相关性，如果前面的程序代码块抛出的错误影响了后面程序 代码的运行，那么这个我们就说这两个程序代码存在关联，应该放在同一个try中。
②对已经查出来的例外，有throw(消极)和try catch（积极）两种处理方法。
对于throws把异常抛到try catch能够很好地处理异常的位置（即放在具备对异常进行处理的能力的位置 ）。如果没有处理能力就继续上抛。

2、自定义异常

（1）继承Exception类
（2）构造方法：不带参数的构造方法
带参数的构造方法：参数指出错误性质，super(message)；把参数传递给父类构造异常

1、异常的分类

Throwable有两个子类：Error和Exception。

一个Error对象表示一个程序错误，指的是底层的、低级的、不可恢复的严重错误。此时程序一定会退出，因为已经失去了运行所必须的物理环境。

对于Error错误我们无法进行处理，因为我们是通过程序来应对错误，可是程序已经退出了。

我们可以处理的Throwable类中只有Exception类的对象（例外/异常）。

                       Throwable
                          |
                  ——————
                  |                 |
              Error             Exception
                                    |
                             ————–
                            |              |
                  RuntimeException      非Runtime异常
                  未检查异常             已检查异常
                  由于程序员疏忽造成的    不可避免的
                  可避免的               必须处理
                  可处理，可不处理

2、异常的产生和传递

throw  new一个异常对象;   —表示抛出一个异常

throw new NullPointerException();
相当于return，函数返回上一级

异常的传递：
沿着方法调用链反向传递！
当一个方法中出现异常，而没有作处理，则以异常对象为返回值返回调用处（逐级传递）
异常返回给虚拟机时，虚拟机终止退出，程序结束

JAVA为每一个简单数据类型提供了一个封装类，使每个简单数据类型可以被Object来装载。

除了int（Integer）和char（Character），其余类型首字母大写即成封装类类型名。

转换字符的方式：

int I=10;
String s=I+” ”;
String s1=String.valueOf(i);

Int I=10;
Interger I_class=new integer(I);

封装类.字符串.基本类型

int——————–(Integer(x.toString))—————->Integer
String —————–(Integer.valueOf() )—————->Integer
Integer—————–(x.toString() )———————>String
int———————-(100+””)————————->String
String——————(Integer.parseInt() )—————>int
Integer—————–(Integer.intValue() )—————>int

接口
是个特殊的抽象类，
属性：公开静态常量，方法：公开抽象方法
没有构造方法
接口之间可以多继承，一个类在继承另外一个类的同时，和可以实现多个接口

优点：
1、实现多继承，不会破坏类之间的单继承简单的树状关系。区分主类型和次要类型。
2、标准，解耦合工具

标准的使用者和标准的实现者通过借口隔离开，使得接口实现者的改变对使用者没有影响

接口的回调：
有了接口之后，先有接口使用者，后有接口的实现者，把接口实现者对象传给接口使用者，接口使用者通过接口，调用接口实现这中的方法

二、Object类

java中所有的类的父类或直接或间接的或隐含的都是Object类。
java不允许循环继承，也就是互相继承是不可以的。

主要方法：
（１）finalize()：对象被垃圾收集的时候最后调用的方法
      不能把释放资源的代码写在其中，程序员不能控制调用时机
（２）equals(): 对象内容的比较
      Object类中的boolean equals(Object o)方法是用来比较对象的内容是否相等，其返回值是boolean类型的值，相同为真，不同则为假。
      实际上还是比较对象地址是否相同。String类覆盖了equals()方法，他比较是对象中的内容是否相同。
      子类中也推荐覆盖Object类中继承的equals()方法，自己制定比较规则

1. 自反性：s.equals(s)  true
2. 对称性：s1.equals(s2) true
                s2.equals(s1) true
3.  传递性：s1.equals(s2) true
                s2.equals(s3) true
                则 s1.equals(s3) true

覆盖equals()方法的步骤         

1
2
3
4
5
6

 boolean equals(Object o){
                if(this==o) return true;//1,看看是不是一个对象
                if(o==null) return true;//2,看看对象是不是空
                if(!(o instanceof 本类类名)) return false；//看看是不是本类对象
                ......//根据本类设计。 
            }

（３）toString()：返回对象的字符串表现形式

      Object类中的toString()方法他返回的是类名加上他的地址的一个字符串。在子类中推荐覆盖toString()方法。

      System.out.println(person);实际上打印的是person对象toString方法的返回值.

接口中的方法必须都是公开的抽象方法（public abstract），接口中的属性都是公开静态常量（public static final）。 

接口中没有构造方法

1
2
3
4
5
6
7
8
9
10
11
12

  abstract class ClassA{                                  
       public static final int A = 10;
       public static final double B = 3.14;
       public abstract void m1();
       public abstract void m2();
   }
   interface IA{
       int A = 10;
       double B = 3.14;
       void m1();
       void m2();
   }   //与上面的抽象类逻辑上等价，编译之后，也会生成一个IA.class文件

所以一个源文件中可以写多个接口，但只能有一个公开接口，并且要与源文件的名字一致

接口可以继承，但是只能由接口继承。

在用类去继承时要换用 implements 关键字，这时类和接口也不叫做继承关系，而是实现关系，但其实质也是继承。

   一个类可以继承也只能继承另外一个类，但是可以实现多个接口，其语法是在implements后面写接口名，多个接口以“，”分隔。

接口之间是可以多继承的，其语法和类的继承语法是相同的。

在接口多继承时，在extends后写接口名如果要继承多个接口，接口名以“，”分隔，接口的继承关系只是把其父接口中的抽象方法继承到子接口中。

要实现接口就必须实现接口中的所有方法。

一个类可以在继承一个类的同时，还可以实现一个或多个接口。采用接口就绕开了单继承限制。

   class Impl extends ClassE implements IA，IB{……}

接口类型也可以做为编译时类型使用，但其实际的运行时类型必须是完全实现接口的类的对象实例，这样就使多态变得很灵活了

接口类型的引用指向接口某一个实现类的对象

接口的意义： 

1. 接口可以实现多继承。
2. 用接口可以实现混合类型（主类型，副类型），java中可以通过接口分出主次类型。主类型使用继承，副类型，使用接口实现。
3. 接口进一步深化了标准的思想，接口本身就是一个标准，他起到了降低耦合性的作用，接口可以使方法的定义和实现相分离，也就是将接口的定义者和实现者相分离， 接口也可以用于降低模块间或系统间的耦合性。
4. 针对接口编程可以屏蔽不同实现间的差异，看到的只是实现好的功能。

接口：定义标准，

接口的实现：实现标准

接口的调用者：标准的使用

针对接口编程原则，也就是按照标准实现。

接口的定义者定义好了标准，接口的使用者就可以写使用代码，接口的实现者写好实现之后把实现对象传入接口的使用者中。

他调用接口中方法也就是掉用接口实现中的方法。

这种过程叫做接口的回调（先有标准使用者，后有标准实现者，把标准的实现者对象传给使用者，再由使用者通过接口调用标准实现者的方法）。

1. 属性：类变量；全类共有；类加载时初始化；类名访问
2. 方法：静态方法；类名调用；静态方法中不能访问类的非静态成员，可以覆盖，只能被静态方法覆盖；没有多态初始代码块；类加载时运行

类加载：
一个类编译之后会形成.class文件，储存了类的全部信息。
当JVM第一次使用一个类的时候，会根据ClassPath找到对应的.class文件，用输入流把文件中的信息读入JVM并保存起来，这样，JVM就“认识”了这个类

类加载时机：第一次用这个类的时候

1. 第一次创建类的对象，会加载
2. 访问类的静态成员，会加载
3. 声明类的引用，不会加载
4. 加载子类，必然先加载父类
5. 如果调用的是子类从父类中继承下来的静态方法，只会加载父类
6. 如果访问的是类的静态常量，如果在编译的时候能够确定这个常量的值，则运行时不会加，否则，编译时无法确定常量值，那么运行时就会加载

final

1. 变量：常量，一旦赋值，不能改变，为属性常量赋值的时机：对于实例常量，初始化或者构造方法中可以赋值；
           对于类常量(static final)，初始化或者静态初始代码块中可以赋值
2. 方法：不能被覆盖
3. 类 ：不能被继承  所有方法默认都是final的

abstract

1. 方法 ：只有定义，没有实现
2. 类 ：不能构造对象，但可以用来声明一个引用（作为编译时类型）

如果一个类有抽象方法，这个类必须是抽象类，如果一个类是抽象类，不一定有抽象方法

子类继承一个抽象类，就必须覆盖（实现）父类（抽象类）中的所有抽象方法，否则，子类就也得是抽象类

抽象类有构造方法，给子类继承，通过abstract，我们可以把一个方法的定义放在父类，留给子类实现。 

一、abstract修饰类Class 抽象类

abstract修饰的类为抽象类：

• 不能创建对象，可以声明引用，并通过引用调用类中的方法
• 主要用于被子类继承的，可以用父类引用指向子类对象

二、abstract修饰方法method

• abstract修饰的方法只有声明，没有实现，用“；”代替“{ }”
• 需要子类继承实现（覆盖）。
• 如果一个类中有抽象方法，那么这个类必须是抽象类。
• 抽象类中不一定有抽象方法

注意：父类是抽象类，其中有抽象方法，子类继承父类，必须把父类中的所有抽象方法都实现（覆盖）了，子类才有创建对象的能力， 否则子类也必须是抽象类。

抽象类中可以有构造方法，是子类在构造子类对象时需要调用的父类（抽象类）的构造方法。

抽象类的合理性：

1. 没有抽象类的实例，只有抽象类子类的实例
2. 抽象方法，定义和实现分离
3. 抽象（abstract）方法代表了某种标准，定义标准，定义功能，在子类中去实现功能（子类继承了父类并需要给出从父类继承的抽象方法的实现）。
4. 方法一时间想不到怎么被实现，或有意要子类去实现而定义某种标准，这个方法可以被定义为抽象。(abstract) 

注：static、final、abstract修饰方法的比较：

1、构造方法在创建对象的时候使用，如果是static，那么只会在加载类的时候调用一次
构造方法不能被继承（final），谈不到覆盖，更不会由子类实现（abstract）

2、final和abstract，private和abstract，static和abstract，这些是不能放在一起的修饰符
因为abstract修饰的方法是必须在其子类中实现（覆盖），才能以多态方式调用，以上修饰符在修饰方法时子类都覆盖不了这个方法。

final是不可以覆盖，private是不能够继承到子类，所以也就不能覆盖。

static是可以覆盖的，但是在调用时会调用编译时类型的方法（引用类型的方法），因为调用的是父类的方法，而父类的方法又是抽象的方法，不能调用。

所以上的修饰符不能放在一起。