- 类的引用就是这个类的对象的句柄,也就是说由这个句柄来代替这个对象
就象我们的名字,每个名字对应一个人
类的对象放到了内存的堆里,
而引用放到了内存的栈里,并指向相应的对象.
而有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();
- }
- }