Java day8【第十七章】Object类的基本概念

【第十七章】Object类的基本概念

一.Object 的基本概念：

Object类的主要特点是可以解决参数的统一问题，也就是说使用Object类可以接收所有的数据类型。

Object类简介：

　　在Java中只有一个类是不存在有继承关系的，那么这个类就是Object，也就是说所有的类默认情况下都是Object类的子类

以下俩种类的定义效果完全相同。

class Person {}
class Person extends Object {}

　　在Object类设计的时候考虑到了所有继承的问题，所以该类提供有无参数构造方法（子类调用默认调用父类的无参构造方法）。

　　那么既然Object类是所有类的父类，那么这种情况下就可以使用Object类来接收所有子类对象。

　　如果一个程序的方法要求可以接受所有类对象的时候就可以利用Object实现处理。

　　但是还有一点需要注意，在Java程序制作对于所有的引用数据类型实际上都可以利用Object进行接收，包括数组也可以。

范例：使用Object类接收数组：

class Person{}

 public class tsy
{
	public static void main(String[] args) 
	{
		Object obj = new int [] {1,2,3};	//向上转型
		if(obj instanceof int[]){		
			int date[] = (int[])obj;
			for (int temp:date){
				System.out.println(temp);
			}
		}
	}
}

　　Object是一个万能的数据类型，更适合于进行程序的标准设计。

 

二.取得对象信息（toString（））：

　　Object虽然是一个类，但是这个类本身也是提供有一些处理方法的。

　　Object中的toString可以获取一个对象的完整信息：

class Person{}

 public class tsy
{
	public static void main(String[] args) 
	{
		Person per = new Person();
		System.out.println(per);
		System.out.println(per.toString());
	}
}
//输出Person@2a84aee7
//输出Person@2a84aee7

　　可以发现在之前进行对象直接输出的时候所调用的就是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 tsy
{
	public static void main(String[] args) 
	{
		Person per = new Person("同思远",19);
		System.out.println(per);
		System.out.println(per.toString());
	}
}
//输出姓名：同思远、年龄：19
//输出姓名：同思远、年龄：19

　　

三.对象比较：equals():

Object类之中另外一个比较重要的方法就是在于对象比较的处理上，所谓的对象比较主要主要的功能是比较俩个对象的类型是否相同

假如说现在有俩个Person对象，要想确认这俩个对象是否一致 ，就要进行Object比较：

范例：观察比较

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 String getName(){
		return this.name;
	}
	public int getAge(){
		return this.age;
	}
}

 public class tsy
{
	public static void main(String[] args) 
	{
		Person perA = new Person("同思远",19);
		Person perB = new Person("同思远",19);
		if(perA.getName() == perB.getName() && perA.getAge() == perB.getAge()){
			System.out.println("俩个对象一样");
		}else{
			System.out.println("俩个对象不一样");
		}

	}
}

　　此时的确实现了对象比较的功能，但是这个功能比较麻烦：

　　　　　由于需要进行对象比较的时候，要将每一个属性都进行相等判断。所以在外部要调用大量的get方法

　　　　　对象比较应该是一个类内部所具备的功能，而不应该在外部定义。

　　Object类作为所有类的父类，提供了对象比较操作的支持。可以使用equals（）方法完成

public boolean equals（Object obj），可以接收所有类型。默认情况下该方法只是进行了俩个对象地址的判断

也就是说对于实际的使用者而言，如果要想正确实现判断处理，那么就必须在子类中覆写此方法，并且进行属性判断

源代码如下

public boolean equals(Object obj) {
    return (this == obj);

范例：观察Object类中的equals（）方法覆写：

 

class Person{
    private    String name;
    private int age;
    public Person(String name , int age){
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString(){
        return"姓名："+this.name+"、年龄："+this.age;
    }
    @Override
    public boolean equals(Object obj){            //覆写应该和原方法一摸一样，和上面的源代码比较
        Person per = (Person)obj;
        return this.name.equals(per.name) && this.age == age;
    }
}

 public class tsy
{
    public static void main(String[] args) 
    {
        Person perA = new Person("同思远",19);
        Person perB = new Person("同思远",19);
        System.out.println(perA.equals(perB));        //返回true
    }
}

 

　　但是如果传入的是null，程序就会出现空指向错误，那么我们进行优化

 

class Person{
    private    String name;
    private int age;
    public Person(String name , int age){
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString(){
        return"姓名："+this.name+"、年龄："+this.age;
    }
    @Override
　　//equals方法这时候会有俩个对象，一个是当前对象this，另一个是传入的obj
    public boolean equals(Object obj){//覆写应该和原方法一摸一样，和上面的源代码比较
        if(obj == null)return false;
        Person per = (Person)obj;
        //如果在类内部，我们可以直接访问类的属性（per.name）
        return this.name.equals(per.name) && this.age == age;
    }
}

 public class tsy
{
    public static void main(String[] args) 
    {
        Person perA = new Person("同思远",19);
        Person perB = new Person("同思远",19);
        System.out.println(perA.equals(null));        
    }
}

最后我们对所有可能出现的情况进行优化：

class Person{
    private    String name;
    private int age;
    public Person(String name , int age){
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString(){
        return"姓名："+this.name+"、年龄："+this.age;
    }
    @Override
    public boolean equals(Object obj){　　　　　　　　　　　　  //覆写应该和原方法一摸一样，和上面的源代码比较
        if(obj == null)return false;　　　　　　　　　　　　　　//比较方法不会考虑跟null比较
        else if(this == obj) return true;　　　　　　　　　　　//如果自己跟自己比较，直接返回true
        else if(!(obj instanceof Person)) return false;　　 //确保同类比较
        Person per = (Person)obj;
        //如果在类内部，我们可以直接访问类的属性（per.name）
        return this.name.equals(per.name) && this.age == age;
    }
}

 public class tsy
{
    public static void main(String[] args) 
    {
        Person perA = new Person("同思远",19);
        Person perB = new Person("同思远",19);
        System.out.println(perA.equals(null));        
    }
}

 

　　String类作为Object的子类，已经对equals方法进行了覆写