类的引用和内部类

• 类的引用就是这个类的对象的句柄，也就是说由这个句柄来代替这个对象  
    就象我们的名字，每个名字对应一个人  
    类的对象放到了内存的堆里，  
    而引用放到了内存的栈里，并指向相应的对象．  
    而有static修饰的对象，享有固定的内存空间，  
    并且多个引用指向同一个对象
• 就是一个散列码。一般情况下，如果hashCode相同，则equals应该也判定相等。就像MD5一样，但没MD5那么复杂。
• 散列的价值在于速度，使得查询得以快速进行。
• 查询一个值的过程首先就是计算散列码，然后使用散列码查询数组。数组并不直接保存值，而是保存值的list。
  然后对list中的值使用equals（）方法进行线性查询。这部分查询会比较慢，但是，如果散列函数好的话，数组的每个位置只有较少的值。
  因此不是查询真个list，而是快速的跳到数组的某个位置，只对少数的元素进行比较。
• ===================================================================
• 匿名内部类
• 
  new YourClass{
  ...
  }
• 这个例子是一个多线程的小程序，这里面就应用到了匿名内部类，实现了Runnable接口。
  匿名内部类的一般好处是：是代码更加简洁，紧凑，但带来的是易读性下降。他一般用在GUI编程中
  实现事件处理等等。希望大家一起讨论
• public class RunnableTest{
  public static void main(String[] args){
  MyThread1 mt1 = new MyThread1();
  MyThread2 mt2 = new MyThread2();
  MyThread3 mt3 = new MyThread3();
  mt2.th.start();
  mt1.th.start();
  mt3.th.start();
  }
  }
• class MyThread1 implements Runnable{
  Thread th = new Thread(this);
  public void run(){
  for (int i = 0; i < 10; i++){
  System.out.println("BMW" + i);
  }
  }
  }
• class MyThread2{
  Thread th = new Thread(){
  public void run(){
  for (int i = 0; i < 10; i++){
  System.out.println(i);
  }
  }
  };
  }
  class MyThread3{
  Runnable ra = new Runnable(){
  public void run(){
  for (char ch = 65; ch < 70; ch++){
  System.out.println(ch);
  }
  }
  };
  Thread th = new Thread(ra);
  }
• 匿名内部类可以访问外部类的私有成员，其他的方式实现接口和继承类做不到
  实现方式：
  SuperType aa = new SuperType(construction parameters){methods and data}
  或
  InterfaceType aa = new InterfaceType(){methods and data}
  具体实现时需要把SuperType 和InterfaceType 换成具体的超类和接口。
  匿名内部类可以访问外部类的私有成员，其他的方式实现接口和继承类做不到
• 内部类应该都可以的。
  我觉得匿名的应该是隐藏实现，而且用完就out的那种。
• 
  class A{
• class B{}
• }这样的类被称为内部类,又 被称为内隐类.
• 从简单到深入一步一步的分析内部类的特点.
• class OuterClass
• { static class A //静态内部类
• { public A( )
• { System.out.println("Test$A !"); } }
• class B //非静态内部类
• { public B( )
• { System.out.println("Test$B !"); } }
• public void disp( )
• {
• final int a=10; int b;
• class C //成员函数中的局部内部类
• { public C( )
• { System.out.println(“in class C a="+a);
• //System.out.println(b);
• }
• }
• C c=new C( );
• }
• public class Test extends OuterClass
• {
• public static void main(String args[])
• { OuterClass.A a=new OuterClass.A( );
• //建立静态内部类对象
• B b=new OuterClass( ).new B( );
• 
  //建立非静态内部类的对象
• //注意这个OuterClass().new B();相当于生成一个外部类的对象,然后在利用外部类对象生成内部类对象
• OuterClass t=new OuterClass( );
• t.disp( );
• //通过外部对象调用一个对象方法的形式,新建立了对象C.
• }
• }
• 注意在上面的b在运行时会为0,因为是类属性.
• class OuterClass
• {
• static class A { } //静态内部类
• class B { } //非静态内部类
• public void disp( )
• {
• class C{ } //局部内部类
• }
• }
• 
  编译后的结果:
• 
  OuterClass.class
• OuterClass$A.class
• OutClass$B.class
• OuterClass$1$C.class
• 记住以下几句话:
• 
  1,一个内部类的对象能够访问创建它的外部类对象的所有属性及方法（包括私有部分）。
• //可以闭上眼镜,把这个内部类等同于一个类的一个方法,当然就可以访问这个外部类的
• //所有方法和属性,私有方法和属性是属于外部类的,当然也就等同于内部类的.
• 
  2,对于同一个包中的其它类来说，内部类能够隐藏起来。（将内部类用private修饰即可）
• //只有在内部类中,才能定义一个为private类型的class,因为这时编译器已经把这个类看作这个类的成员了,但是在一般使用时,就是所谓的”顶级类时”,不能使用private,只能是public 或者是friendly.
• 如果要是想保证一个类不产生任何的对象,请在构造函数中,把构造函数声明成private.
• 3, 内部类可定义在方法中,称为局部内部类，但它只能使用方法中的final常量。
• //定义在一个方法内的类,又被成为局部内部类,这个类只能使用在方法中的final常量,注意,这个常量是在一个方法中的,那么能否使用一个类中的常量呢?
• 当然是可以的,因为类中的常量在在一个方法中是可见的.
• //
• 如果把一个类写在了一个if中,比如这样:
• class A{
• int a = 10;
• if(a!=10){
• class B{
• B(){
• System.out.println(a);
• }
• }
• }
• }
• 在编译后会有几个错误呢?
• 首先那个a没有被定义为final,你有一次上了圈套.
• 类B同样会被生成出来,只是离开了if域就失效了.
• 4,内部类可以被定义为抽象类
• // abstract 类同样可以在内部类中
• 5, 非静态内部类不能声明本类的static成员
• //只有一个静态的内部类,才可以声明一个static成员,
• class A{
• static class B{
• 
  //如果这里不是一个static类,是不可以被声明这个gg方法的.
• static void gg(){
• int a = 100;
• System.out.println(a);
• }
• }
• }
• 
  class aa{
• public static void main(String args[]){
• A.B hh = new A.B();
• hh.gg();
• }
• }