java复习第九天

一、复习
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、成员内部类

四个访问权限修饰符都可以修饰成员内部类。
内部类和外部类在编译时是不同的两个类，内部类对外部类没有任何依赖。
内部类是一种编译时语法，在编译时生成的各自的字节码文件(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）一个内部类对象，需要首先建立一个外部类对象（外部类可用），然后在生成一个内部类对象。内部类的类名是外部类类名.内部类类名。
Outer o=new Outer();
Outer.Inner in=o.new.Inner()。

2、静态内部类

（注意：前三种内部类与变量类似，所以可以对照参考变量）
静态内部类定义在类中，任何方法外，用static class定义。
静态内部类只能访问外部类的静态成员。
生成（new）一个静态内部类对象不需要外部类对象：这是静态内部类和成员内部类的区别。
静态内部类的对象可以直接生成：
Outer.Inner in=new Outer.Inner()；
而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。
静态内部类不可用private来进行定义。

3、局部内部类

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

注意：
局部内部类不仅可以访问外部类私有实例变量，还可以访问外部类的局部常量（也就是局部变量必须为final的）
在类外不可直接访问局部内部类（保证局部内部类对外是不可见的）。
在方法中才能调用其局部内部类。
通过内部类和接口达到一个强制的弱耦合，用局部内部类来实现接口，并在方法中返回接口类型，使局部内部类不可见，屏蔽实现类的可见性。

4、匿名内部类

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

匿名内部类的特点：
（1）一个类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的事先或是覆盖。
（2）只是为了获得一个对象实例，不许要知道其实际类型。
（3）类名没有意义，也就是不需要使用到。

注：一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类，没有类名，根据多态，我们使用其父类名。
因其为局部内部类，那么局部内部类的所有限制都对其生效。
匿名内部类是唯一一种无构造方法类。
大部分匿名内部类是用于接口回调用的。
匿名内部类在编译的时候由系统自动起名Out$1.class。
如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。
因匿名内部类无构造方法，所以其使用范围非常的有限。
当需要多个对象时使用局部内部类，因此局部内部类的应用相对比较多。匿名内部类中不能定义构造方法。

匿名内部类的写法：
interface A{
void ia();
}
class B{
public A bc(){
return new A(){      //匿名类实现了A接口
void ia(){……}
};
        }
}
使用匿名内部类：
B b=new B();
A a=b.bc();
a.ia();

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

对于两个类，拥有相同的方法：
class People
{
  run();
}
interface Machine{
   run();
}
此时有一个robot类：
class Robot extends People implement Machine.
名为run()的方法有2个，不可直接实现。

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();
}
}

练习：把前面石头剪刀布的游戏改写为:采用匿名内部类来实现接口,并获得对象去调用match方法


四、集合

集合（集合类的对象）是用来管理其他若干对象的。
集合中保存的是对象的引用，数组是最基本的集合

集合框架

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类来实现堆栈）。