Object类、包装类

Object类
在java中一切都是继承关系，以下代码：

public class ObjectDemo01 {
}

如上如果一个类没有明确指定继承哪个类，那么默认都是继承Object类。即：

public class ObjectDemo01 extends Object {
}

所有任何类对象都可以使用Object进行接收。

package com.smw.objectdemo;
class Person2 extends Object{
}
public class ObjectDemo02 {
	public static void main(String[] args) {
		Object obj1 = new Person2();
		Object obj2 = "Hello";
	}
}

那么对于Object接收来讲，不光可以接收类的引用，只要是引用数据类型都可以使用Object类接收。如下接收接口：

package com.smw.objectdemo;
interface National{}
class Person3 extends Object implements National{
}
public class ObjectDemo03 {
	public static void main(String[] args) {
		National na = new Person3();		//子类为借口实例化
		Object obj = na;		//Object接收借口实例
		National temp = (National) obj;
	}
}

如下接收数组：

package com.smw.objectdemo;
public class ObjectDemo04 {
	public static void main(String[] args) {
		int i[] = {1,2,3,4,5};		//定义一个数组
		Object obj = i;			//使用Object接收数组
		int x[] = (int[])obj;	//向下转型
		for (int j = 0; j < x.length; j++) {
			System.out.print(x[j]+"、");
		}
	}
}

Object类的功能不止于此，对于一个完整的类来讲，应该覆写Object中以下三个方法：
toString()：对象打印是调用 public String toString()
equals()：对象比较时调用，实际上String类就已经覆写好了此方法
public boolean equals(Object obj)
hashCode()：暂时不看
先看toString()方法：

package com.smw.objectdemo;
class Person5{
	public String toString(){
		return "Hello";
	}
}
public class ObjectDemo05 {
	public static void main(String[] args) {
		System.out.println(new Person5());
	}
}

发现此时直接输出对象时，实际上就是调用了类中的toString方法，因为此方法被子类覆写了，所以最终调用的是覆写过的方法。
也就是说toString是表示对象信息的。

package com.smw.objectdemo;
class Person6{
	private String name;
	private int age;
	public Person6(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public String toString(){
		return "姓名："+this.name+","+"年龄："+this.age;
	}
}
public class ObjectDemo06 {
	public static void main(String[] args) {
		System.out.println(new Person6("傻逼波", 38));
	}
}

在Object类中标准的对象比较方法就是equals方法，那么如果要进行对象比较，在系统中找的也是equals方法。
package com.smw.objectdemo;
class Person7{
	private String name;
	private int age;
	public boolean equals(Object obj){	//完成对象的比较操作
		if (this == obj) {		//两个地址相等
			return true;
		}
		if (!(obj instanceof Person7) ) {	//不是同一个类型
			return false;
		}
		Person7 per = (Person7) obj;
		if (this.name.equals(per.name) && this.age == per.age) {
			return true;
		}else{
			return false;
		}
	}
	public Person7(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public String toString(){
		return "姓名："+this.name+","+"年龄："+this.age;
	}
}
public class ObjectDemo07 {
	public static void main(String[] args) {
		System.out.println(new Person7("傻逼波", 38).equals("Hello"));
	}
}

Object可以接收任意类型的对象引用。
匿名内部类
内部类：在类的内部还有一个类。
以下正常代码：

package com.smw.nonamedemo;
interface A{
	public void fun();
}
class B implements A{
	public void fun() {
		System.out.println("Hello World");
	}
}
class X{
	public void fun1(A a){
		a.fun();
	}
	public void fun2(){
		this.fun1(new B());
	}
}
public class NoNameDemo01 {
	public static void main(String[] args) {
		new X().fun2();
	}
}

假如B类只是用一次，那么有必要将其定义成一个单独的类吗？
此时就可以使用匿名内部类：

package com.smw.nonamedemo;
interface A{
	public void fun();
}
class X{
	public void fun1(A a){
		a.fun();
	}
	public void fun2(){
		this.fun1(new A(){
			public void fun() {
				System.out.println("Hello World");
			}
		});
	}
}
public class NoNameDemo01 {
	public static void main(String[] args) {
		new X().fun2();
	}
}

在一般的java开发中，匿名内部类 比较少见，只有以下两种情况系常见：
java的图形界面
Spring开发框架
包装类
在java中提倡：一切皆对象，但是这样一来就会出现矛盾点，数据类型分为基本数据类型和引用数据类型。基本数据类型是类吗？
为了解决这样的矛盾，在java中针对八种数据类型，设置了八个包装类，以类的形式表示出基本数据类型。

基本数据类型	包装类
int	Integer
char	Character
byte	Byte
short	Short
long	Long
double	Double
float	Float
boolean	Boolean

这八种包装类中实际上分为以下两组：
数值型： Integer，Byte，Short，Double，Long，Float
都是Number的子类。
其它类型：Character,Boolean

以上方法的返回值都是基本数据类型。
在包装类的操作中存在装箱和拆箱操作：
装箱操作：将基本数据类型变为包装类称为装箱操作。
拆箱操作：将包装类变为基本数据类型称为拆箱操作。
Integer例子：

package com.smw.integerdemo;
public class IntegerDemo01 {
	public static void main(String[] args) {
		int i = 10;
		Integer i2 = new Integer(i);	//装箱操作
		int j = i2.intValue();		//拆箱操作
		System.out.println(j*j);
	}
}

Float例子：

package com.smw.integerdemo;
public class FloatDemo01 {
	public static void main(String[] args) {
		float i = 10.3f;
		Float i2 = new Float(i);	//装箱操作
		float j = i2.floatValue();		//拆箱操作
		System.out.println(j*j);
	}
}

以上的做法是JDK 1.5之前的，在JDK 1.5之前，所有的数据必须进行手工的装箱和拆箱操作。而且包装类本身不能进行任何的数学运算。
但是在JDK 1.5之后增加了许多新特性，例如：foreach，可变参数，自动装箱，拆箱操作。

package com.smw.integerdemo;

public class IntegerDemo02 {
	public static void main(String[] args) {
		int i = 10;
		Integer i2 = i;	//自动装箱操作
		int j = i2;		//自动拆箱操作
		System.out.println(j*j);
	}
}

实际上通过包装类也能取得最大值和最小值。

package com.smw.integerdemo;
public class IntegerDemo03 {
	public static void main(String[] args) {
		System.out.println(Integer.MAX_VALUE);
		System.out.println(Integer.MIN_VALUE);
	}
}

对于包装类来讲，虽然自动装箱和拆箱是一个很重要的特点，但重要的特点还有一个：
将字符串转化为基本数据类型。
范例：将字符串变为int类型。
方法：public static int parseInt(String s)

package com.smw.integerdemo;
public class IntegerDemo04 {
	public static void main(String[] args) {
		String str = "123";
		int i = Integer.parseInt(str);
		System.out.println(i++);
	}
}

注意：要转换的字符串必须是由数字组成，不能有非数字。
既然可以将字符串变为int型数据，也可以变为float数据。