12-20java面向对象之Object类&包装类&匿名内部类

浏览数：29 / 时间：2015年06月08日
1.Object类
在java的开发中，一切类都是以继承的方式存在的，如果一个类在定义时没有明确指明继承的是哪个类，那么默认情况继承Object类。

例如

class Person 
{
}

以上代码默认定义Object，其完整表达形式为：

class Person extends Object
{
}

在jdk文档中，API-> index->java.lang->Object寻找Object类。

一个完整的类应该是覆写Object类的方法，下面主要讲解重要的方法。

1.1public String toString()

对象打印的时候调用。

例如

class Person			// 定义了Person类，实际就是继承了Object类
{
}
public class TestObject 
{
	public static void main(String[] args) 
	{
		Person per = new Person();
		System.out.println(per);
	}
}

结果打印的是per的地址

由于Person是继承了Object类，所以Object类的所有方法（friendly和public）都能够使用。那么使用toString（）

class Person			// 定义了Person类，实际就是继承了Object类
{
}
public class TestObject 
{
	public static void main(String[] args) 
	{
		Person per = new Person();
		System.out.println(per.toString());
	}
}

发现结果相同，那么说明在打印的时候一定会调用toString（）方法，它是默认调用的。就可以用这个方法完成信息的输出。

class Person			// 定义了Person类，实际就是继承了Object类
{
	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 TestObject 
{
	public static void main(String[] args) 
	{
		Person per = new Person("Tyrion",24);
		System.out.println("使用toString()方法" + per.toString());
		System.out.println("不使用toString()方法" + per);
	}
}

所以今后要打印输出对象的信息时，直接覆写toString 方法，直接使用对象就可以打印。

1.2public boolean equals(Object obj)

equals（）完成对象内容的比较，以前在String类中使用过。

class Person			// 定义了Person类，实际就是继承了Object类
{
	private String name ;
	private int 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)  	//必须保证是一个类才能进行比较，不能因为两个对象属性相同就比较
		{
			// Object是父类，这使用要比较父类中的属性，需要向下转型
			Person per = (Person) obj ;
			if (this.name.equals(per.name) && this.age == per.age)
			{
				return true ;
			}
			else 
			{
				return false ;
			}
		}else
		{
			return false ;
		}			
	}
	public String toString()
	{
		return "姓名:" + this.name + ",年龄:" + this.age ;
	}
}
public class TestObject 
{
	public static void main(String[] args) 
	{
		Person per1 = new Person("Tyrion",24);
		Person per2 = new Person("Tyrion",24);
		System.out.println(per1.equals(""));	
		System.out.println(per1.equals(per2));	
	}
}

程序注意：

覆写过程中，使用Object，由于Object是所有类的父类，所以首先要进行instanceof判断，之后还要进行向下转型，将Object类变为子类才能继续进行比较。

程序拓展：

这个程序是说明这么个问题——可以定义不同的子类(相对于Object而言)，他们可能需要比较，则可以直接继承该方法。

但是问题来了： 

class Person			// 定义了Person类，实际就是继承了Object类
{
	private String name ;
	private int age ;
	public Person(String name , int age)
	{
		this.name =name ;
		this.age = age;
	}	
}
public class TestObject 
{
	public static void main(String[] args) 
	{
		Person per1 = new Person("Tyrion",24);
		Person per2 = new Person("Tyrion",24);
		System.out.println(per1.equals(per2));	
	}
}
false

class Person			// 定义了Person类，实际就是继承了Object类
{
	private String name ;
	private int age ;
	public Person(String name , int age)
	{
		this.name =name ;
		this.age = age;
	}	
}
public class TestObject 
{
	public static void main(String[] args) 
	{
		Person per1 = new Person("Tyrion",24);
		Person per2 = new Person("Tyrion",34);
		Object obj1 = per1;
		Object obj2 = per2;
		System.out.println(obj1.equals(per1));	
	}
}
true

Object 类的 equals 方法实现对象上差别可能性最大的相等关系；即，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true（x == y 具有值 true）。
第一个例子Person继承equals 方法,没有重写,所以还是比较对象的引用是否相同,-->相同为true不相同falsep1,p2都是new创建的,在堆分配两块不同的空间,所以false

第二个例子obj1.equals(per1),比较的是obj1和per1,Object obj1 = per1;传递时把per1的值传递给obj1,所以两个对象指向同一块空间,返回true;

 

由于Object是所有类的父类，所有类的对象都可以使用Object进行接收，Object还可以接收任意的引用数据类型。

 

使用Object进行接口接收

interface A
{
	public abstract String getInfo();
}
class B implements A			//B类实现接口A
{
	public String getInfo()
	{
		return "hello  world ";
	}
}
public class TestObject 
{
	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 TestObject 
{
	public static void main(String[] args) 
	{
		int arr[] = {1,3,4,5};			//定义数组
		Object obj = arr;
		print(obj);
	}
	public static void print(Object obj)
	{
		if (obj instanceof int[])		//判断是否是整型数组
		{
			int x[] = (int[]) obj;		//向下转型，将对象转变为整型数组
			for (int i=0;i<x.length ;++i )
			{
				System.out.println(x[i]);
			}
		}
	}
}

1.3总结

1、 Object是所有类的父类，只要是引用数据类型都可以使用Object进行传递

2、 对象在向下转型之前一定要向上传递，并且要用instanceof判断

2.包装类

在java中提出一种思想：一切皆对象。那么基本数据类型不是对象，把8种基本数据类型包装成类。

8种包装类

技术分享

对于Number类

技术分享

Number是Object直接子类，他是将数字包装类中的内容变为基本数据类型（拆箱）。

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

拆箱：将包装类变为基本数据类型

以Integer为例：

public Integer(int value)

public class TestWapper1 
{
	public static void main(String[] args) 
	{
		Integer i = new Integer(11) ;		// Integer类的构造方法，相当于子类实例化，装箱
		Number num = i ;		     //向上传递
		int x = num.intValue();		// 调用Number类的方法，拆箱
	}
}

以Float为例：

public class TestWapper2 
{
	public static void main(String[] args) 
	{
		Float f = new Float(11.1f) ;		// Float类的构造方法，相当于子类实例化，装箱
		float x = f.floatValue();		// 调用Number类的方法，拆箱
	}
}

在JDK1.5之前，程序的包装类不能直接使用“+ - * /”，因为他们都是一个类。之后对包装类的功能进行了改变，增加了自动装箱和拆箱，而且也可以使用包装类进行数字运算。

public class TestWapper3 
{
	public static void main(String[] args) 
	{
		Integer i = 30 ;		//自动装箱成Integer
		int j = i ;				//自动拆箱成int
	}
}

在包装类中，存在对大的特点——把字符串变为指定的数据类型。

在integer中

parseInt

public static int parseInt(String s)                    throws NumberFormatException

parseFloat

public static int parseFloat(String s)                    throws NumberFormatException

该字符串必须由数字组成，该方法的特点——可以通过输入传递字符串。

public class TestWapper3 
{
	public static void main(String[] args) 
	{
		String str1 = "300" ;		//该字符串必须全是数字
		String str2 = "300.33" ;		//该字符串必须全是数字
		int i = Integer.parseInt(str1) ;
		float j = Float.parseFloat(str2);
		System.out.println("整数的乘方:" + i + "*" + i + "="+ i*i);
		System.out.println("小数的乘方:" + j + "*" + j + "="+ j*j);
	}
}

public class TestWapper3 
{
	public static void main(String[] args) 
	{
		String str1 = new String(args[0]) ;		//该字符串必须全是数字
		String str2 = new String(args[1]) ;		//该字符串必须全是数字
		int i = Integer.parseInt(str1) ;
		float j = Float.parseFloat(str2);
		System.out.println("整数的乘方:" + i + "*" + i + "="+ i*i);
		System.out.println("小数的乘方:" + j + "*" + j + "="+ j*j);
	}
}

2.匿名内部类

定义：一个类在整个操作中只是用一次，定义为匿名内部类，在抽象类和接口的基础之上发展过来。

interface  A
{
	public abstract void print();		//定义内部抽象方法
}
class B implements A
{
	public void print()
	{
		System.out.println("hello java");
	}
}
class C
{
	public void fun1()
	{
		this.fun2(new B());			//传一个B的实例，调用接口方法
	}
	public void fun2(A a)
	{
		a.print();
	}
}
public class noName_Inner 
{
	public static void main(String[] args) 
	{
		C c =new C();
		c.fun1();
	}
}

如果此时，B类只是用一次，那么就没有必要单独定义一个类了。

interface  A
{
	public abstract void print();		//定义内部抽象方法
}
class C
{
	public void fun1()
	{
		this.fun2(new A()
					{
						public void print()
						{
							System.out.println("hello java");
						}
					}
			);			//传一个B的实例，调用接口方法
	}
	public void fun2(A a)
	{
		a.print();
	}
}
public class noName_Inner2 
{
	public static void main(String[] args) 
	{
		C c =new C();
		c.fun1();
	}
}

祝大家健健康康，快快乐乐。









郑重声明：本站内容如果来自互联网及其他传播媒体，其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享，并不代表本站赞同其观点和对其真实性负责，也不构成任何其他建议。

标签： 编程语言 Java C C# Javascript js Python Ruby Spring 程序 VB

相关文章

随机文章

您可能还喜欢

您可能还喜欢