1、操作符“==”
用來比較兩個操作元是否相等，這兩個操作元既可以是基本類型，也可以是引用類型。
代碼01：
/**
* Demo01.java
*
* Provider: CoderDream's Studio
*
* History
* Date(DD/MM/YYYY) Author Description
* ----------------------------------------------------------------------------
* Nov 13, 2007 CoderDream Created
*/
package com.coderdream.operator;
/**
* discription: 操作符“==”
*
* @author CoderDream
*
*/
public class Demo01 {
/**
* <pre>
* 操作符“==”用來比較兩個操作元是否相等，這兩個操作元既可以是基本類型，也可以是引用類型。
* </pre>
*/
public static void f1() {
int a1 = 1, a2 = 3;
boolean b1 = a1 == a2; // "=="的操作元為基本類型，b1變量值為false
System.out.println(b1);
String str1 = "Hello", str2 = "World";
boolean b2 = str1 == str2; // "=="的操作元為引用類型，b2變量值為false
System.out.println(b2);
}
/**
* <pre>
* 當操作符“==”兩邊都是引用類型時，這兩個引用變量必須都引用同一個對象，結果才為true。
* </pre>
*/
public static void f2() {
Integer int1 = new Integer(1);
Integer int2 = new Integer(1);
Integer int3 = int1; // int3和int1引用同一個對象
int[] array1 = new int[1];
int[] array2 = new int[1];
int[] array3 = array1; // array3和array1引用同一個對象
System.out.println("int1==int2 is " + (int1 == int2));
System.out.println("int1==int3 is " + (int1 == int3));
System.out.println("array1==array2 is " + (array1 == array2));
System.out.println("array1==array3 is " + (array1 == array3));
}
/**
* @param args
*/
public static void main(String[] args) {
System.out.println("-----------f1()-----------");
Demo01.f1();
System.out.println("-----------f2()-----------");
Demo01.f2();
}
}
輸出結果：
-----------f1()-----------
false
false
-----------f2()-----------
int1==int2 is false
int1==int3 is true
array1==array2 is false
array1==array3 is true
2、操作符“==”與多態性
a、對于引用類型變量，Java編譯器根據變量被顯式聲明的類型去編譯。當“==”用于比較引用類型變量時，“==”兩邊的變量被顯式聲明的類型必須是同種類型或有繼承關系，即位于繼承樹的同一個繼承分支上，否則編譯出錯。
b、在運行時，Java 虛擬機將根據兩邊的引用變量實際引用的對象進行比較。
假設有4個類--Creature、Animal、Dog和Cat類，它們的繼承關系如圖所示：
代碼02：
/**
* Demo02.java
*
* Provider: CoderDream's Studio
*
* History
* Date(DD/MM/YYYY) Author Description
* ----------------------------------------------------------------------------
* Nov 13, 2007 CoderDream Created
*/
package com.coderdream.operator;
/**
*
* <pre>
* 操作符“==”與多態性
* 1、對于引用類型變量，Java編譯器根據變量被顯式聲明的類型去編譯。當“==”用于比較引用
* 類型變量時，“==”兩邊的變量被顯式聲明的類型必須是同種類型或有繼承關系，即位于
* 繼承樹的同一個繼承分支上，否則編譯出錯。
* 2、在運行時，Java 虛擬機將根據兩邊的引用變量實際引用的對象進行比較。
* </pre>
*
* @author CoderDream
*
*/
public class Demo02 {
/**
*
*/
public static void f1() {
Dog dog = new Dog(); // dog變量被聲明為Dog類型
Creature creature = dog; // 變量creature和dog引用同一個Dog對象
Animal animal = new Cat(); // animal 變量被聲明為 Animal 類型
System.out.println(dog == animal); // 合法，打印false
System.out.println(dog == creature);// 合法，打印false
}
/**
* <pre>
* 這里變量dog被聲明為Dog類型，變量cat被聲明為Cat類型，Dog類和Cat類之間沒有繼承關系，
* 因此這兩個變量不能用“==”比較。
* </pre>
*/
public static void f2() {
Dog dog = new Dog();
Cat cat = new Cat();
// System.out.println(dog == cat);// 編譯出錯
}
/**
* @param args
*/
public static void main(String[] args) {
Demo02.f1();
}
}
class Creature {
}
class Animal extends Creature {
}
class Dog extends Animal {
}
class Cat extends Animal {
}
輸出結果：
false
true
3、操作符“==”用于數組類型
數組類型也是引用類型，可以用“==”進行比較
代碼03：
/**
* Demo03.java
*
* Provider: CoderDream's Studio
*
* History
* Date(DD/MM/YYYY) Author Description
* ----------------------------------------------------------------------------
* Nov 13, 2007 CoderDream Created
*/
package com.coderdream.operator;
/**
* <pre>
* 操作符“==”用于數組類型
* </pre>
*
* @author CoderDream
*
*/
public class Demo03 {
/**
* <pre>
* 數組類型也是引用類型，可以用“==”進行比較
* </pre>
*/
public static void f1() {
// boolean b1 = new int[4] == new long[5];//編譯出錯，兩邊類型不一致
boolean b2 = new int[4] == new int[4];// 合法，b2的值為false
System.out.println(b2);
int[] array1 = new int[4];
int[] array2 = array1;
boolean b3 = array1 == array2; // 合法，b3的值為true
System.out.println(b3);
}
/**
* @param args
*/
public static void main(String[] args) {
Demo03.f1();
}
}
輸出結果：
false
true
4、equals() 方法
equals() 方法是在 Object 類中定義的方法，它的聲明格式如下：
public boolean equals(Object obj)
Object 類的 equals() 方法的比較規則為：當參數 obj 引用的對象與當前對象為同一個對象時，就返回true，否則返回false。
在JDK中有一些類覆蓋了 Object 類的equal()方法，它們的比較規則為：
如果兩個對象的類型一致，并且內容一致，則返回true。
這些類包括：java.io.File、java.util.Date、java.lang.String、包裝類(如java.lang.Integer和java.lang.Double類)。
代碼04：
/**
* Demo04.java
*
* Provider: CoderDream's Studio
*
* History
* Date(DD/MM/YYYY) Author Description
* ----------------------------------------------------------------------------
* Nov 13, 2007 CoderDream Created
*/
package com.coderdream.operator;
/**
* @author CoderDream
*
*/
public class Demo04 {
/**
* <pre>
* equals() 方法是在 Object 類中定義的方法，它的聲明格式如下：
* public boolean equals(Object obj)
* Object 類的 equals() 方法的比較規則為：當參數 obj 引用的對象與當前對象為
* 同一個對象時，就返回true，否則返回false。
* </pre>
*/
public boolean equals(Object obj) {
if (this == obj) {
return true;
} else {
return false;
}
}
/**
* <pre>
* 1、a1和a2變量引用不同的對象，因此用“==”或 equals() 方法比較的結果都為 false；
* 2、a1和a3變量都引用同一個Dog對象，因此用“==”或equals()方法比較的結果都為true；
* </pre>
*/
public static void f1() {
Animal a1 = new Dog();
Animal a2 = new Cat();
Animal a3 = a1;
System.out.println(a1 == a2); // 打印false
System.out.println(a1.equals(a2)); // 打印false
System.out.println(a1 == a3); // 打印true
System.out.println(a1.equals(a3)); // 打印true
}
/**
* <pre>
* 在JDK中有一些類覆蓋了 Object 類的equal()方法，它們的比較規則為：
* 如果兩個對象的類型一致，并且內容一致，則返回true。
* 這些類包括：java.io.File、java.util.Date、java.lang.String、
* 包裝類(如java.lang.Integer和java.lang.Double類)。
* </pre>
*/
public static void f2() {
Integer int1 = new Integer(1);
Integer int2 = new Integer(1);
String str1 = new String("Hello");
String str2 = new String("Hello");
System.out.println(int1 == int2); // 打印false
System.out.println(int1.equals(int2)); // 打印true
System.out.println(str1 == str2); // 打印false
System.out.println(str1.equals(str2)); // 打印true
}
/**
* <pre>
* Boolean 類是包裝類，只要兩個Boolean對象的布爾值內容一樣，
* equals()方法的比較結果就為true。
* </pre>
*/
public static void f3() {
Boolean b1 = new Boolean(true);
Boolean b2 = new Boolean(true);
if (b1 == b2) {
if (b1.equals(b2)) {
System.out.println("a");
} else {
System.out.println("b");
}
} else {
if (b1.equals(b2)) {
System.out.println("c"); // 執行這段代碼
} else {
System.out.println("d");
}
}
}
/**
* <pre>
* b1和obj1被聲明為不同的類型，但它們實際引用的是同一個Dog對象，
* 因此用“==”或equals()方法比較的結果都為true。
* </pre>
*/
public static void f4() {
Boolean b1 = new Boolean(true);
Object obj1 = (Object) b1;
if (b1 == obj1) {
if (b1.equals(obj1)) {
System.out.println("a"); // 執行這段代碼
} else {
System.out.println("b");
}
} else {
if (b1.equals(obj1)) {
System.out.println("c");
} else {
System.out.println("d");
}
}
}
/**
* <pre>
* Float 和 Double 類型是包裝類型，只要兩個 Float 對象或兩個 Double對象的內容一樣，
* equals()方法比較的結果就為true。
* </pre>
*/
public static void f5() {
Float f1 = new Float("10F");
Float f2 = new Float("10F");
Double d1 = new Double("10D");
System.out.println(f1 == f2); // 打印false
System.out.println(f1.equals(f2)); // 打印true
System.out.println(f1.equals(d1)); // 打印false,因為f2和d1不是相同類型
System.out.println(f1.equals(new Float("10"))); // 打印true
}
/**
* <pre>
* 例如以下變量a和b引用不同的String對象，但它們包含的內容都是“helle”，
* 所以a.equals(b)的結果為true；
* 而變量c是字符串數組類型，因此a.equals(c)的結果為false。
* </pre>
*/
public static void f6() {
String a = "hello";
String b = new String(a);
char[] c = { 'h', 'e', 'l', 'l', 'o' };
System.out.println(a == "hello"); // 打印true
System.out.println(a == b); // 打印false
System.out.println(a.equals(b)); // 打印true
System.out.println(a.equals(c)); // 打印false
}
/**
* @param args
*/
public static void main(String[] args) {
System.out.println("----------f1()------------");
Demo04.f1();
System.out.println("----------f2()------------");
Demo04.f2();
System.out.println("----------f3()------------");
Demo04.f3();
System.out.println("----------f4()------------");
Demo04.f4();
System.out.println("----------f5()------------");
Demo04.f5();
System.out.println("----------f6()------------");
Demo04.f6();
}
}
輸出結果：
----------f1()------------
false
false
true
true
----------f2()------------
false
true
false
true
----------f3()------------
c
----------f4()------------
a
----------f5()------------
false
true
false
true
----------f6()------------
true
false
true
false
5、在用戶自定義的類中也可以覆蓋Object類的equals()方法，重新定義比較規則。
代碼05：
/**
* Demo05.java
*
* Provider: CoderDream's Studio
*
* History
* Date(DD/MM/YYYY) Author Description
* ----------------------------------------------------------------------------
* Nov 13, 2007 CoderDream Created
*/
package com.coderdream.operator;
/**
* @author CoderDream
*
*/
public class Demo05 {
/**
* @param args
*/
public static void main(String[] args) {
Person p1 = new Person("Tom");
Person p2 = new Person("Tom");
System.out.println(p1 == p2); // 打印 false
System.out.println(p1.equals(p2)); // 打印 true
}
}
class Person {
private String name;
public Person(String name) {
this.name = name;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object o) {
if (this == o) {
return true;
}
final Person other = (Person) o;
if (this.name.equals(other.name)) {
return true;
} else {
return false;
}
}
}
輸出結果：
false
true
6、 instanceof操作符
instanceof操作符用于判斷一個引用類型所引用的對象是否是一個類的實例。
instanceof操作符左邊的操作元是一個引用類型，右邊的操作元是一個類名或接口名。
形式如下：
obj instanceof ClassName
或者：
obj instanceof InterfaceName
例如：
Dog dog = new Dog();
Systom.out.println(dog instanceof XXX);//XXX表示一個類名或接口名
一個類的實例包括類本身的實例，以及所有直接或間接的子類的實例，因此當"XXX"是以下
值時，instanceof 表達式的值為true。
● Dog類
● Dog類的直接或間接父類
● Dog類實現的接口，已經所有父類實現的接口。
代碼06：
/**
* Demo06.java
*
* Provider: CoderDream's Studio
*
* History
* Date(DD/MM/YYYY) Author Description
* ----------------------------------------------------------------------------
* Nov 13, 2007 CoderDream Created
*/
package com.coderdream.operator;
/**
* <pre>
* instanceof操作符用于判斷一個引用類型所引用的對象是否是一個類的實例。
* instanceof操作符左邊的操作元是一個引用類型，右邊的操作元是一個類名或接口名。
* 形式如下：
* obj instanceof ClassName
* 或者：
* obj instanceof InterfaceName
* 例如：
* Dog dog = new Dog();
* Systom.out.println(dog instanceof XXX);//XXX表示一個類名或接口名
*
* 一個類的實例包括類本身的實例，以及所有直接或間接的子類的實例，因此當"XXX"是以下
* 值時，instanceof 表達式的值為true。
* ● Dog類
* ● Dog類的直接或間接父類
* ● Dog類實現的接口，已經所有父類實現的接口。
* </pre>
*
*
* @author CoderDream
*
*/
public class Demo06 {
/**
* <pre>
* 由于Animal是Dog的直接父類，Creature類和Object類是Dog的間接父類，
* 因此以下 instanceof 表達式的值為true。
* </pre>
*/
public static void f1() {
Dog dog = new Dog();
System.out.println(dog instanceof Dog); // 打印 true
System.out.println(dog instanceof Animal); // 打印 true
System.out.println(dog instanceof Creature); // 打印 true
System.out.println(dog instanceof Object); // 打印 true
}
/**
* <pre>
* instanceof 右邊的操作元也可以是接口名。
* </pre>
*/
public static void f2() {
B b = new B();
System.out.println(b instanceof I); // 打印 true
}
/**
* @param args
*/
public static void main(String[] args) {
System.out.println("-----------f1()-----------");
Demo06.f1();
System.out.println("-----------f2()-----------");
Demo06.f2();
}
}
interface I {
}
class A implements I {
}
class B extends A {
}
輸出結果：
-----------f1()-----------
true
true
true
true
-----------f2()-----------
true
7、 instanceof 與多態性
對于引用類型變量，Java 編譯器只根據變量被先生聲明的類去編譯。
instanceof 左邊操作元被顯式聲明的類型與右邊操作元必須是同種類或者有繼承關系，即位于繼承樹的同一個繼承分支上，否則編譯出錯。
Dog dog = new Dog();
System.out.println(dog instanceof Cat); // 編譯出錯
Cat cat = new Cat();
System.out.println(cat instanceof Dog); // 編譯出錯
instanceof 用于數組類型
boolean b1 = new int[4] instanceof long[]; // 編譯出錯，兩邊操作元類型不一致
boolean b2 = new int[4] instanceof int[]; // 合法，b2的值為true
代碼07：
/**
* Demo07.java
*
* Provider: CoderDream's Studio
*
* History
* Date(DD/MM/YYYY) Author Description
* ----------------------------------------------------------------------------
* Nov 13, 2007 CoderDream Created
*/
package com.coderdream.operator;
/**
* <pre>
* instanceof 與多態性
* 對于引用類型變量，Java 編譯器只根據變量被先生聲明的類去編譯。
* instanceof 左邊操作元被顯式聲明的類型與右邊操作元必須是同種類或者有繼承關系，
* 即位于繼承樹的同一個繼承分支上，否則編譯出錯。
* Dog dog = new Dog();
* System.out.println(dog instanceof Cat); // 編譯出錯
*
* Cat cat = new Cat();
* System.out.println(cat instanceof Dog); // 編譯出錯
*
* instanceof 用于數組類型
* boolean b1 = new int[4] instanceof long[]; // 編譯出錯，兩邊操作元類型不一致
* boolean b2 = new int[4] instanceof int[]; // 合法，b2的值為true
* </pre>
*
* @author CoderDream
*
*/
public class Demo07 {
/**
* <pre>
* 在運行時，將根據左邊操作元實際引用的對象來判斷。
* </pre>
*/
public static void f1() {
Animal a = new Dog(); // a 變量被聲明為Animal類型，引用Dog對象
System.out.println(a instanceof Animal); // 合法， 打印true
System.out.println(a instanceof Dog); // 合法， 打印true
System.out.println(a instanceof Cat); // 合法， 打印false
}
/**
* <pre>
* 假定Animal類是非抽象類，允許實例化，
*
* </pre>
*/
public static void f2() {
System.out.println((new Demo07()).isInstanceOfAnimal(new Dog())); // 打印fasle
System.out.println((new Demo07()).isInstanceOfAnimal(new Cat())); // 打印fasle
System.out.println((new Demo07()).isInstanceOfAnimal(new Animal())); // 打印true
System.out.println((new Demo07()).isInstanceOfAnimal(new Creature())); // 打印fasle
}
/**
* <pre>
* 假定Animal類是非抽象類，允許實例化，以下判斷規則：
* 只有當參數 obj 引用 Animal 類本身的實例，而不是它的子類Dog或Cat多實例時，
* 才返回true。
*
* 如果 obj instanceof Animal為true，那么obj有可能引用 Animal本身、Dog類本身
* 或Cat類本身的實例；
* 如果 obj instanceof Dog 和 obj instanceof Cat均為false，那么 obj 不會引用
* Dog類本身或Cat類本身的實例。
* 如果同時滿足這幾個條件，就可以得出 obj 引用 Animal 類本身的實例的結論。
* </pre>
*
* @param obj
* @return
*/
public boolean isInstanceOfAnimal(Object obj) {
return obj instanceof Animal && !(obj instanceof Dog)
&& !(obj instanceof Cat);
}
/**
* <pre>
* instanceof 用于數組類型
* </pre>
*/
public static void f3() {
// boolean b1 = new int[4] instanceof long[]; // 編譯出錯，兩邊操作元類型不一致
boolean b2 = new int[4] instanceof int[]; // 合法，b2的值為true
System.out.println(b2);
}
/**
* @param args
*/
public static void main(String[] args) {
System.out.println("-----------f1()-----------");
Demo07.f1();
System.out.println("-----------f2()-----------");
Demo07.f2();
System.out.println("-----------f3()-----------");
Demo07.f3();
}
}
輸出結果：
-----------f1()-----------
true
true
false
-----------f2()-----------
false
false
true
false
-----------f3()-----------
true
posted on 2007-11-15 12:20
charlie 閱讀(336)
評論(0) 編輯 收藏