java基础7_继承_重载_常用方法

package java基础;
class FatherClass {
    public int value;
    public void f(){
        value = 100;
        System.out.println
        ("FatherClass.value="+value);
    }
    public FatherClass() {
    	System.out.println("父类的构造方法被调用了");//该语句能打印出来
    }
}
class ChildClass extends FatherClass {
    public int value;
    public void f() {//重写父类的方法
        super.f();
        value = 200;
        System.out.println
             ("ChildClass.value="+this.value);//200
        System.out.println("this.value="+value);//200
        System.out.println("super.value="+super.value);//100
    }
    public ChildClass() {
    	System.out.println("haha");//Constructor call must be the first statement in a constructor
    	super();//子类可以在构造方法中调用父类的构造方法,该super()方法必须放在构造方法的第一句，否则报错
    }
}
public class TestInherit {
public static void main(String[] args) {
ChildClass cc = new ChildClass();
cc.f();
}
}

public class Object

类

Object

是类层次结构的根类。每个类都使用

Object

作为超类。所有对象（包括数组）都实现这个类的方法。

默认提供一个构造方法 Object()，子类在调用自己的构造方法时，首先要去调用父类的构造方法，所以最好是养成每个类都定义个空的构造方法，方便子类继承extends

toString

public String toString()

返回该对象的字符串表示。通常，

toString

方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。

Object

类的

toString

方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“

@

”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：

getClass().getName() + '@' + Integer.toHexString(hashCode())

返回：该对象的字符串表示形式。

hashCode 独一无二的代表了一个对象，并且通过hashCode找到这个对象的位置

public int hashCode()

返回该对象的哈希码值。支持此方法是为了提高哈希表（例如

java.util.Hashtable

提供的哈希表）的性能。

hashCode

的常规协定是：

在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用

hashCode

方法都必须生成相同的整数结果。
如果根据

equals(java.lang.Object)

方法，两个对象不相等，那么对这两个对象中的任一对象上调用hashCode 方法不 要求一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。
实际上，由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。（这一般是通过将该对象的内部地址转换成一个整数来实现的，但是 JavaTM 编程语言不需要这种实现技巧。）

返回：此对象的一个哈希码值。另请参见：

equals(java.lang.Object)

,

Hashtable

equals

public boolean equals(Object obj)

指示其他某个对象是否与此对象“相等”。

equals

方法在非空对象引用上实现相等关系：

自反性：对于任何非空引用值

x

，

x.equals(x)

都应返回

true

。
对称性：对于任何非空引用值

x

和

y

，当且仅当

y.equals(x)

返回

true

时，

x.equals(y)

才应返回

true

。
传递性：对于任何非空引用值

x

、

y

和

z

，如果

x.equals(y)

返回

true

，并且

y.equals(z)

返回

true

，那么

x.equals(z)

应返回

true

。
一致性：对于任何非空引用值

x

和

y

，多次调用 x.equals(y) 始终返回

true

或始终返回

false

，前提是对象上

equals

比较中所用的信息没有被修改。
对于任何非空引用值

x

，

x.equals(null)

都应返回

false

。

Object

类的 equals 方法实现对象上差别可能性最大的相等关系；即，对于任何非空引用值

x

和

y

，当且仅当

x

和

y

引用同一个对象时，此方法才返回

true

（

x == y

具有值

true

）。

注意：当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。

参数：

obj

- 要与之比较的引用对象。 返回：如果此对象与 obj 参数相同，则返回

true

；否则返回

false

。另请参见：

hashCode()

,

Hashtable

java.lang

类 String的equas

equals

public boolean equals(Object anObject)

将此字符串与指定的对象比较。当且仅当该参数不为

null

，并且是与此对象表示相同字符序列的

String

对象时，结果才为

true

。

覆盖：类

Object

中的

equals

参数：

anObject

- 与此

String

进行比较的对象。 返回：如果给定对象表示的

String

与此

String

相等，则返回

true

；否则返回

false

。另请参见：

compareTo(String)

,

equalsIgnoreCase(String)

package java基础;

public class TestToString {
public static void main(String[] args) {
Dog dog = new Dog();

  System.out.println("d:"+dog);//等于System.out.println("d:"+dog.toString());

  System.out.println("d:"+dog.toString());//可以注释掉重写的toString()，看看打印效果

 

  System.out.println("d:"+dog.getClass());//拿到dog对象运行时的类

  System.out.println("d:"+dog.getClass().getName());//拿到dog对象运行时的类的类名Dog

 

  //测试equals()方法

  Dog d1 = new Dog();

  Dog d2 = new Dog();

  System.out.println(d1 == d2);//false，这种是两个对象的引用进行比较，永远为false，因为每个引用对象占据的内存位置不一样，即hashCode不一样

  Dog d3 = new Dog("Mark","black");

  Dog d4 = new Dog("Mark","black");

  Dog d5 = new Dog("Mark","yellow");

 

  System.out.println(d3 == d4);//false

  System.out.println(d3.equals(d4));//true

  System.out.println(d3.equals(d5));//false

 

  //尝试拿一只猫和一只狗看是否相等

  Cat c = new Cat();

  System.out.println(d3.equals(c));//运行后报错：java基础.Cat cannot be cast to java基础.Dog，看重写的equals()方法

  System.out.println(d3.equals(c));//执行第二种写法，则不报错，结果false

 

  String s1 = "hello dog";

  String s2 = "hello dog";

  System.out.println("s1==s2:"+(s1 == s2));//true，s1/s2是字符串常量，存放在Data segment里（前面的笔记里有讲到），引用对象其实是同一个

  String s3 = new String("hello dog");

  String s4 = new String("hello dog");

  System.out.println("s3==s4:"+(s3 == s4));//false，s3/s4是存放在heap中的两个不同的引用对象，各自都分配了内存空间

  System.out.println("s3.equals.s4:"+(s3.equals(s4)));//true，参考String类，重写了equals方法
}

}

class Cat {

}

class Dog {
//所有的类都默认extens了Object类

//重新Object类的toString方法，重写方法养成去查文档copy的形式去重写，api中有方法的申明，直接copy申明，再写自己的实现
//（英文、中文j2se API免费下载，可以加我微信Jobs1127，通过百度云好友分享）
public String toString() {
return "my name is Mack!";
}

private String name;
private String color;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}

//空的构造方法即无参构造方法，提供给子类继承时使用
public Dog(){}
//重新构造方法
public Dog(String name,String color) {
this.name = name;
this.color = color;
}
public boolean equals(Object obj) {
/**
* 第一种写法，该代码注释掉，打开可以测试，报错java基础.Cat cannot be cast to java基础.Dog，因为写得不严谨
* if(obj != null) {
Dog o = (Dog)obj;
if(this == obj) {
return true;
} else if(this.getName().equals(o.getName())&&this.getColor().equals(o.getColor())) {
return true;
}
}
return false;
*/

//第二种写法，比较严谨的写法
if(obj != null) {//首先如果形参obj为null则直接return false;
if(obj instanceof Dog) {//否则则要判断该对象是否属于Dog对象，只有obj对象是属于Dog才比较，否则直接知道他们不相等
Dog o = (Dog)obj;//知道obj为Dog对象时，方可将Object对象强制转换成Dog对象
if(this == o) {//对象自己与自己比较，直接return true;否则则比较name和color,假设名字和颜色一样咱们认为他们相等
return true;
} else if(this.getName().equals(o.getName())&&this.getColor().equals(o.getColor())) {
return true;
}
}
}
return false;
}

}