Object类

目录

一：Object类的定义

                取得对象信息：toString() 

                对象比较：equals() 

二：Object类与引用数据类型 

                接收数组数据 

                接收接口对象

 三：修改链表 

---

一：Object类的定义

       Object类是所有类的父类，也就是说任何一个类在定义时候如果没有明确的继承一个父类的话，那么它就是Object类的子类。

由于Java里面的类的继承关系一直都存在（除了Object类）
class Book extends Object{  }等价于class Book{  }

   Object类是所有类的父类的好处：利用Object类可以接收全部类的对象，因为可以向上自动转型

class Book extends Object{  }//等价于class Book{ }
public class transfer {
    public static void main(String[] args) {
    	Object obja=new Book();//向上转型（大范围父类对象被小范围子类对象实例化）
    	Object objb="Hello";//向上转型，接收String子类对象
    	Book a=(Book) obja;//向下转型，强制父类对象转换成子类对象
    	String b=(String) objb;//向下转型
    }
 }

       所以如果不确定参数的实际类型，那么Object类就是最好的选择，最后强制向下转型为所需类型即可。
      Object类提供了一个无参构造方法：public Object(),因为：类对象实例化时，子类构造方法一定会默认调用父类的无参构造。

     理论上说：任意一个简单Java类都应该覆写Object地三个方法（一般不遵守）

方法	类型	描述
public  String toString()	普通	取得对象信息
public  boolean equals(Object obj)	普通	对象比较
public  int hashCode()	普通	取得对象哈希码

取得对象信息：toString() 

 发现：直接输出对象和调用了toString()方法后再输出对象是一样的功能。也就是说，在输出一个对象时，不管是否调用toString(),最后都是调用toString()将对象信息转换为String进行输出。Object类的toString()默认返回的是对象的编码，但是String类覆写了toString()方法，所以输出的是：字符串的的内容。

 下面Book类自己定义：toString()方法

class Book{
	private String title;
	private double price;
	public Book(String title,double price) {
		this.title=title;
		this.price=price;
	}
	public String toString() {//覆写toString()方法
		return "书名："+this.title+"；价钱："+this.price;
	}
}
public class transfer {
    public static void main(String[] args) {
          Book a=new Book("java开发",99.8);
          System.out.println(a);
    }
 }

 发现在进行对象输出时候，toString()是直接输出的。

对象比较：equals() 

class Book{
    private String title;
    private double price;
    public Book(String title,double price) {
        this.title=title;
        this.price=price;
    }
    public boolean equals(Object obj) {
        if(this == obj) {//地址相同
            return true;}
        if(obj == null) {
            return false;}
        if(!(obj instanceof Book)) {//防止向下转型出错
            return false;
        }
        Book book=(Book) obj;//向下转型
        if(this.title.equals(book.title)&&this.price==book.price) {//属性比较
            return true;
        }
        return false;
    }
}
public class transfer {
    public static void main(String[] args) {
          Book a1=new Book("java开发",99.8);
          Book a2=new Book("java开发",99.8);
          System.out.println(a1.equals(a2));//对象比较
    }
 } 

二：Object类与引用数据类型 

由于Object类可以接收引用类型，也就是说可以接收引用数据类型的数据，包括数组，接口，类。 

接收数组数据 

 向下转型别忘了加上判断语句：对象Instanceof类名

接收接口对象

 

         主程序：先实例化接口对象，Object接收了接口对象a，然后Object向下转型为接口实例。（前3行）

 三：修改链表 

解决：链表不能统一数据类型的问题 

class Link{
	private class Node{//内部类Node
		private Object data;
		private Node next;
		public Node(Object data) {
			this.data=data;
		}
		public void addNode(Node newNode) {//增加节点
			if(this.next==null) {
				this.next=newNode;
			}
			else {
				this.next.addNode(newNode);
			}
		}
		public Object getNode(int index) {//查询节点
			if(Link.this.foot++==index) {
				return this.data;
			}
			else {
				return this.next.getNode(index);
			}
		}
		public void setNode(int index,Object data) {//修改节点
			if(Link.this.foot++==index) {
				this.data=data;
			}
			else {
				this.next.setNode(index, data);
			}
		}
		public boolean containsNode(Object data) {//判断指定节点是否存在
			if(data.equals(this.data)) 
				return true;
			else {
				if(this.next!=null) {
					return this.next.containsNode(data);
				}
				else {
					return false;
				}
			}}
		public void removeNode(Node pre,Object data) {//删除节点
			if(data.equals(this.data)) {
				pre.next=this.next;
			}
			else {
				this.next.removeNode(this, data);
			}
		}
		public void toArrayNode() {//访问数据
			Link.this.ret[Link.this.foot++]=this.data;
			if(this.next!=null) {
				this.next.toArrayNode();
			}
		}
		}
	
	private Node root;//根节点
	private int count=0;
	private int foot;
	private Object[] ret;
	public void add(Object data) {//增
		Node newNode=new Node(data);
		if(this.root==null) {
			this.root=newNode;
		}
		else {
			this.root.addNode(newNode);
		}
		this.count++;
	}
    public Object get(int index) {//查
    	if(this.count<index) return null;
    	this.foot=0;
    	return this.root.getNode(index);
    }
    public void set(int index,Object data) {//改
    	if(this.count<index) return;
    	this.foot=0;
    	this.root.setNode(index, data);
    }
    public boolean contains(Object data) {//判断存在与否
		if (data==null||this.root==null) {
			return false;
		}
		else {
			return this.root.containsNode(data);
		}
	}
    public void remove(Object data) {//删
    	if(this.contains(data)) {
    	if(data.equals(this.root.data)) {//Link直接处理根节点的删除
    		this.root=this.root.next;
    	}
    	else {
    		this.root.next.removeNode(this.root,data);
    	}
    	this.count--;
    }}
    /*数据的访问*/
	public Object[] toArray(){
		if(this.root==null) {
			return null;
		}
		this.foot=0;
		this.ret=new Object[this.count];
		this.root.toArrayNode();
		return this.ret;
	}
	public int size() {
		return this.count;
	}
	}
public class transfer {
    public static void main(String[] args) {
    	Link all=new Link();
    	all.add("aaa");
    	all.add("bbb");
    	all.add("ccc");
    	Object data[]=all.toArray();
    	for(int x=0;x<data.length;x++) {
    		String str=(String) data[x];
        System.out.println(str);}
    }
 }

1：链表所有数据的对象类型都是Object；
2：主程序输出时：把Object对象转型为String输出即可。