Object类

在java中一切的类都是以继承的关系存在的。

Object类的作用

如果一个类在定义时没有明确指明继承哪个类，则默认继承Object类，

Object类中toString()、equals()方法的作用

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()) ;
	}
};
1
2
3
4
5
6
7
8
9

运行发现，加不加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("李兴华",30) ;	 // 实例化Person
		System.out.println("对象信息：" + per) ;
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

equals()方法的主要功能是进行对象的比较。
String类也是Object类的子类，String类已经覆写过此方法，String的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")?"是同一个人！" : "不是同一个人！") ;
		
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

Object类是所有类的父类，所有类的对象都可以使用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()) ;
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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") ;
			}
		}
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

只要是引用数据类型，都可以使用Object接收。

1，Object类是所有类的父类，只要是引用数据类型，都可以使用Object接收。
2，对象在进行向下转型之前，一定要发生向上转型，要使用instanceof关键字判断。
3，toString()对象打印时调用。
4，equals()对象比较时调用。
5，String类也是Object类的子类。

包装类

java中提倡一切皆对象的思想，但是 八种基本数据类型并不是对象。此时就需要将基本数据类型进行包装，变为一个类的形式，这就是包装类的作用。
八种基本数据类型，对应有八种包装类。

包装类的作用

这八种包装类继承的父类不完全相同。包装类都是final的，不可继承。
Boolean和Character是Object类的直接子类；
Integer、Short、Long、Float、Double、Byte都属于Number的子类，Number类本身也提供了一系列返回这6种基本数据类型的操作。
Number类是一个抽象类，主要作用是将包装类中的内容变为基本数据类型。

包装类的自动装箱、自动拆箱操作

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

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

jdk1.5之后提供了自动装箱，自动拆箱。也可以直接进行加、减、乘、除、++、-- 操作。也提供了将全由数字组成的字符串转换为指定基本数据类型的操作。parse方法。

包装类的转换操作

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
	}
};
1
2
3
4
5
6
7
8

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)) ;
	}
};
1
2
3
4
5
6
7
8
9
10

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)) ;
	}
};
1
2
3
4
5
6
7
8
9
10

匿名内部类

匿名内部类的作用

如果一个类在整个使用中，只使用一次的话，就可以定义为匿名内部类。
匿名内部类是在接口和抽象类的基础上发展起来的。

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()方法
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

如果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()方法
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

匿名内部类的定义格式

匿名内部类是在接口和抽象类的基础上发展起来的。
不用单独定义一个类，不用定义类名称，直接在调用出，new接口或者抽象类并实例化抽象方法。