在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));
}
}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));
}
}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();
}
}祝大家健健康康，快快樂樂。