匿名内部类笔记

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

匿名内部类

         内部类：在一个类的内部定义了另外的类，称为内部类，匿名内部类指的是没有名字的内部类。为了清楚内部类的主要作用，下面首先来观察如下的程序：

范例：思考程序的问题

interface Message {      // 定义了一个接口

         public void print() ;       // 抽象方法

}

class MessageImpl implements Message {    // 定义接口的实现类

         public void print() {

                   System.out.println("Hello World .") ;

         }

}

class Demo {

         public static void get(Message msg) {      // 接收接口对象

                   msg.print() ;

         }

}

public class TestDemo {

         public static void main(String args[]) {

                   Message msg = new MessageImpl() ;      // 子类为接口实例化

                   Demo.get(msg) ; // 传递msg对象

         }

}

         以上的代码是属于正常的开发范畴，但是如果说现在MessageImpl这个子类只使用那么唯一的一次，有必要按照以上的方式进行定义吗？这个时候那么MessageImpl就没有什么意义了，但是可以利用匿名内部类的概念来解决此问题。匿名内部类是在抽象类和接口的基础之上所发展起来的一种应用。

interface Message {      // 定义了一个接口

         public void print() ;       // 抽象方法

}

class Demo {

         public static void get(Message msg) {      // 接收接口对象

                   msg.print() ;

         }

}

public class TestDemo {

         public static void main(String args[]) {

                   Demo.get(new Message() {   // 匿名内部类

                            public void print() {

                                     System.out.println("Hello World .") ;

                            }

                  }) ;

         }

}

         对于匿名内部类的使用，暂时只需要记住它的语法即可，因为如果要想真正的去使用它，还需要一段时间的课程。

 

总结:

匿名对象的创建是基于普通类

匿名内部类的创建是基于接口

抽象类和接口的实现是基于多态通过子类实例化

3.2、Object类

         在Java的定义之中，除了Object类之外，所有的类实际上都存在继承关系，即：如果现在定义了一个类，没有默认继承任何一个父类的话，则默认将继承Object类，以下两种类的最终定义效果是完全一样的。

class Person {}

class Person extends Object {}

         那么按照这样的方式理解，即：Object类可以接收所有类的实例化对象。

class Person {}

public class TestDemo {

         public static void main(String args[]) {

                   Object obj = new Person() ;

                   Person per = (Person) obj ;

         }

}

         如果在日后的开发之中，一个操作可能接收所有类的对象，那么使用Object作为参数最合适。

         除此之外，对于任意的一个简单Java类而言，理论上讲应该覆写Object类之中的三个方法：

                   · 取得对象信息：public String toString()；

                   · 对象比较：public boolean equals(Object obj)；

                   · 取得哈希码：public int hashCode()。

3.2.1 、取得对象信息：toString()

         在之前提示过，如果说现在一个对象直接输出，那么默认情况下输出的是一个对象的地址。

class Person {}

public class TestDemo {

         public static void main(String args[]) {

                   Person per = new Person() ;

                   System.out.println(per) ;        // Person@ 1f 6226

                   System.out.println(per.toString()) ; // Person@ 1f 6226

         }

}

         现在可以清楚地发现，如果直接输出一个类的对象，那么和这个对象调用toString()方法的结果是完全一样的，那么就可以得出一个结论：对象直接输出默认调用了Object类之中的toString()方法，但是默认的toString()方法有一个特点：为了适用于所有的子类，那么在toString()默认情况下就是输出了对象地址，当然，每一个子类也可以自己进行修改。

class Person {

         private String name ;

         private int age ;

         public Person(String name,int age) {

                   this.name = name ;

                   this.age = age ;

         }

         public String toString() {       // 方法覆写

                   return "姓名：" + this.name + "，年龄：" + this.age ;

         }

}

public class TestDemo {

         public static void main(String args[]) {

                   Person per = new Person("张三",20) ;

                   System.out.println(per) ;        // Person@ 1f 6226

         }    //子类Person覆写了父类Object中的toString()方法，直接输出子类对象时，就不在默认调用Object类中的//toString()方法，而是默认调用子类Person中的toString()方法(new谁调谁，没有调父)

}

3.2.2 、对象比较：equals()

         实际上对于equals()方法应该并不陌生了，这个方法在String类中见过，String是Object类的子类，所以String类的equals()方法就是覆写了Object类中的equals()方法，在Object类之中，默认的equals()方法实现比较的是两个对象的内存地址数值，但是并不符合于真正的对象比较需要。

对象比较之前也写过，但是之前是自己定义了一个新的方法名称，今天可以给出标准的方法名称：equals()。

class Person {

         private String name ;

         private int age ;

         public Person(String name,int age) {

                   this.name = name ;

                   this.age = age ;

         }

         public String toString() {       // 方法覆写

                   return "姓名：" + this.name + "，年龄：" + this.age ;

         }

         public boolean equals(Object obj) {

                   if (this == obj) {     //this指代当前调用equals()方法的对象

                            return true ;

                   }

                   if (obj == null) {

                            return false ;

                   }

                   if (! (obj instanceof Person)) {        // 不是本类对象

                            return false ;

                   }

                   // 因为name和age属性是在Person类中定义，而Object类没有

                   Person per = (Person) obj ;

                   if (this.name.equals(per.name) && this.age == per.age) {

                            return true ;

                   }

                   return false ;

         }

}

public class TestDemo {

         public static void main(String args[]) {

                   Person per1 = new Person("张三",20) ;

                   Person per2 = new Person("张三",20) ;

                   System.out.println(per1.equals("Hello")) ;

                   System.out.println(per1.equals(per2)) ;

         }

}

3.2.3 、使用Object接收所有的引用数据类型

         Object是所有类的父类，那么Object类可以接收所有类的对象，但是在Java设计的时候，考虑到引用数据类型的特殊性，所以Object类实际上是可以接收所有引用数据类型的数据，这就包括了数组、接口、类。

范例：使用Object类接收数组，数组和Object没有任何明确的定义关系

public class TestDemo {

         public static void main(String args[]) {

                   Object obj = new int [] {1,2,3} ;     // 接收数组

                   if (obj instanceof int []) {

                            int [] data = (int []) obj ;         // 向下转型

                            for (int x = 0 ; x < data.length ; x ++) {

                                     System.out.println(data[x]) ;

                            }

                   }

         }

}

范例：接收接口对象，从接口定义而言，它是不能去继承一个父类的，但是由于接口依然属于引用类型，所以即使没有继承类，也可以使用Object接收。

interface Message {

}

class MessageImpl implements Message {        // 定义接口子类

         public String toString() {

                   return "New Message : Hello World ." ;

         }

}

public class TestDemo {

         public static void main(String args[]) {

                   Message msg = new MessageImpl() ;      // 向上转型

                   Object obj = msg ;        // 使用Object接收接口对象，向上转型

                   Message temp = (Message) obj ;    // 向下转型

                   System.out.println(temp) ;     // toString()

         }

}

         从代码上讲，以上只能算是一个固定的操作概念，不过从实际来讲，因为有了Object类的出现，所以的操作的数据就可以达到统一，那么之前的链表程序，就应该变的很方便了，所有的数据都使用Object接收，所有的对象比较（删除、查找）都可以使用equals()。