面向对象高级——Object类、包装类以及匿名内部类

Object类

 知识点：掌握Object类的作用、掌握Object类中toString()、equal()方法的作用 ，掌握Object接收引用数据类型的操作。

假设一个类在定义时没有明白指明继承哪个类，则默认继承Object类。

在java中全部的类都有一个公共的父类就是Object类，一个类仅仅要没有明显的继承一个类，则肯定就是Object的子类。

例如以下两种代码表示是一样的：

class Person extends Object{}

class Person{}

class Demo{	// 定义Demo类。实际上就是继承了Object类
};
public class ObjectDemo01{
	public static void main(String args[]){
		Demo d = new Demo() ;	// 实例化Demo对象
		System.out.println("不加toString()输出："+d) ;
		System.out.println("加上toString()输出："+d.toString()) ;
	}
};

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="">

从以上代码 的执行结果看，加和不加toString()完毕的功能是一样的。也就是证明了对象打印时一定会调用toString ()方法是默认调用的，那么此时就能够覆写toString进行信息的输出。

class Person{
	private String name ;	// 定义name属性
	private int age ;		// 定义age属性
	public Person(String name,int age){
		this.name = name ;
		this.age = age ;
	}
	public String toString(){
		return "姓名：" + this.name + "；年龄：" + this.age ;
	}
};
public class ObjectDemo02{
	public static void main(String args[]){
		Person per = new Person("刘勋",24) ;	 // 实例化Person
		System.out.println("对象信息：" + per) ;
	}
};

就是打印对象所包括的信息。

equals()方法

equals()方法的主要功能是进行对象的比較操作。

String本身也是Object类的子类，所以已经覆写了此方法。

剖析equals例如以下所看到的：

class Person{
	private String name ;	// 定义name属性
	private int age ;		// 定义age属性
	public Person(String name,int age){
		this.name = name ;
		this.age = age ;
	}
	public boolean equals(Object obj){
		if(this==obj){		// 地址相等
			return true ;	// 肯定是同一个对象
		}
		if(!(obj instanceof Person)){	// 不是Person对象
			return false ;
		}
		Person per = (Person) obj ;	// 向下转型
		if(per.name.equals(this.name)&&per.age == this.age){
			return true ;	// 依次比較内容
		}else{
			return false ;
		}
	}
	public String toString(){
		return "姓名：" + this.name + "；年龄：" + this.age ;
	}
};
public class ObjectDemo03{
	public static void main(String args[]){
		Person per1 = new Person("刘勋",30) ;	 // 实例化Person
		Person per2 = new Person("刘勋",30) ;	 // 实例化Person
		System.out.println(per1.equals(per2)?

"是同一个人。" : "不是同一个人！

") ;
		System.out.println(per1.equals("hello")?

"是同一个人！" : "不是同一个人。") ;

	}
};

Object类是全部类的父类。则全部类的对象都能够使用Object接收，可是Object不光能够接收对象。还能够接收随意的引用数据类型。

使用Object接收接口实例。

interface A{
	public String getInfo();
}
class B implements A{
	public String getInfo(){	// 覆写方法
		return "Hello World!!!" ;
	}
};
public class ObjectDemo04{
	public static void main(String args[]){
		A a = new B() ;	// 向上转型。为接口实例化
		Object obj = a ;	// 使用Object接收，向上转型
		A x = (A)obj ;	// 向下转型
		System.out.println(x.getInfo()) ;
	}
};

数组实际上也能够使用Object类进行接收。

public class ObjectDemo05{
	public static void main(String args[]){
		int temp[] = {1,3,5,7,9} ;	// 定义数组
		Object obj = temp ;	// 使用Object接收数组
		print(obj) ;
	}
	public static void print(Object o){
		if(o instanceof int[]){		// 推断是否是整型数组
			int x[] = (int[])o ;
			for(int i=0;i<x.length;i++){
				System.out.print(x[i] + "\t") ;
			}
		}
	}
};

Object类的总结：

1、Object类是全部类的父类，仅仅要是引用数据类型都能够使用Object进行接收。

2、对象在进行向下转型之前一定要先发生向上转型，要使用instanceofkeyword推断。

3、toString（）：对象打印时调用。

4、equals(): 对象比較时调用。

5、String类也是Object类的子类。

包装类

包装类的要点：须要掌握包装类的作用、掌握包装类的自己主动装箱以及自己主动拆箱操作、掌握包装类的转换操作。

一切皆对象，可是八种数据类型不是对象。比如：把int包装成一个类，这样就能够以对象的形式操作基本数据类型。

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="">

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="">

以下以Integer和Float为例。

装箱以及拆箱：

将基本数据类型变为包装类称为装箱。

将包装类的类型变为基本数据类型称为拆箱。

public class WrapperDemo01{
	public static void main(String args[]){
		int x = 30 ;		// 基本数据类型
		Integer i = new Integer(x) ;	// 装箱：将基本数据类型变为包装类
		int temp = i.intValue()	;// 拆箱：将一个包装类变为基本数据类型
	}
};

以下再以小数为例：

public class WrapperDemo02{
	public static void main(String args[]){
		float f = 30.3f ;		// 基本数据类型
		Float x = new Float(f) ;	// 装箱：将基本数据类型变为包装类
		float y = x.floatValue()	;// 拆箱：将一个包装类变为基本数据类型
	}
};

在JDK1.5之前对于程序本身来说包装类是不能直接进行“+、-、*、/、++、......”,是不能够的，由于是一个类不能这样做。可是在JDK1.5之后对程序包装类功能进行了改变。添加了自己主动装箱以及自己主动拆箱的功能并且也能够使用包装类直接进行数字运算。

public class WrapperDemo03{
	public static void main(String args[]){
		Integer i = 30 ;	// 自己主动装箱成Integer
		Float f = 30.3f ;	// 自己主动装箱成Float
		int x = i ;			// 自己主动拆箱为int
		float y = f ;		// 自己主动拆箱为float
	}
};

在包装类中还存在一个最大的特点，就是能够将字符串变为指定的数据类型。

public class WrapperDemo04{
	public static void main(String args[]){
		String str1 = "30" ;	// 由数字组成的字符串
		String str2 = "30.3" ;	// 由数字组成的字符串
		int x = Integer.parseInt(str1) ;	// 将字符串变为int型
		float f = Float.parseFloat(str2) ;	// 将字符串变为int型
		System.out.println("整数乘方：" + x + " * " + x + " = " + (x * x)) ;
		System.out.println("小数乘方：" + f + " * " + f + " = " + (f * f)) ;
	}
};

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="">

包装类总结：

1、java中有八种基本数据类型的包装类，能够将基本数据类型以类的形式进行操作。

2、基本数据类型变为包装类的过程称为装箱。将包装类变为基本数据类型的过程称为拆箱。

3、在JDK1.5之后提供了自己主动装箱和自己主动拆箱的操作。

4、实际上这而八个类是JAVA中提供的类库。

5、使用包装类能够将字符串进行基本数据类型的转换。

匿名内部类

内部类：在一个类的内部还有另外一个类称为内部类，那么匿名内部类，假设一个类在整个操作中仅仅使用一次的话。就能够将其定义为匿名内部类。匿名内部类是在抽象类以及接口的基础上发展而来的。

interface A{
	public void printInfo() ;	//
}
class B implements A{	// 实现接口
	public void printInfo(){
		System.out.println("Hello World!!!") ;
	}
};
class X {
	public void fun1(){
		this.fun2(new B()) ;
	}
	public void fun2(A a){
		a.printInfo() ;
	}
};
public class NoInnerClassDemo01{
	public static void main(String args[]){
		new X().fun1() ;		// 实例化X类的对象，并调用fun1()方法
	}
};

假设B类仅仅使用一次的话。就没有必要为其单独定义一个类，此时就能够使用匿名内部类解决这个问题。

interface A{
	public void printInfo() ;	//
}
class X {
	public void fun1(){
		this.fun2(new A(){
				public void printInfo(){
					System.out.println("Hello World!!!") ;
				}
			}
			) ;
	}
	public void fun2(A a){
		a.printInfo() ;
	}
};
public class NoInnerClassDemo02{
	public static void main(String args[]){
		new X().fun1() ;		// 实例化X类的对象，并调用fun1()方法
	}
};

在实际的开发中常常会用到各种开发的框架，在框架上会大量的引用匿名内部类。

interface A{
	public void printInfo() ;	//
}
class X {
	public void fun1(){
		this.fun2(new A(){
				public void printInfo(){
					System.out.println("Hello World!!!") ;
				}
			}
			) ;
	}
	public void fun2(A a){
		a.printInfo() ;
	}
};
public class NoInnerClassDemo02{
	public static void main(String args[]){
		new X().fun1() ;		// 实例化X类的对象，并调用fun1()方法
	}
};