一Java中的Object类

Object类是全部Java类的父类。假设一个类没有使用extendskeyword明白标识继承另外一个类，那么这个类默认

继承Object类。

public class Person{

      //

}

//等价于

public class Person extends Object{

     //

}

Object类中的方法，适合全部子类。

1)toString()方法

在Object类中定义有public String toString()方法，其返回值是String类型。描写叙述当前对象的有关信息。在进行

String与其类型数据的连接操作时(如：System.ouy.println("info"+person))，将自己主动调用对象类的toString()方法。也可

以依据须要在用户自己定义类型中重写toString()方法

实例：

public class Test{

	public static void main(String[] arge){

		Dog d = new Dog();

		System.out.println(d);

		System.out.println("d："+d);

		System.out.println("d："+d.toString());

	}

}

class Dog{

	public String toString(){

		return "I am a dog";

	}

}

执行结果：

2)equals()方法

比較的是对象的引用是否指向同一块内存地址。普通情况下比較两个对象时比較它们的值是否一致。所以要进行

重写。

Object类中定义有：public boolean equals(Object obj)方法提供定义对象类型

实例：

public class Test{

	public static void main(String[] arge){

                String s1 = new String("hello");

		String s2 = new String("hello");

		System.out.println(s1 == s2);//比較对象的地址

		System.out.println(s1.equals(s2));//比較对象的内容

        }

}

执行结果：

二对象转型(casting)

一个基类的引用类型变量能够指向其子类的对象。

一个基类的引用不能够訪问其子类对象新增的成员(属性和方法)；

能够使用 引用变量 instanceof 类名 来推断该引用型变量所指向的对象是否属于该类或该类的子类。

子类的对象能够当作基类的对象来使用称作向上转型(upcasting)，反之称为向下转型(downcasting)。

向上转型是基类或父类的引用指向子类对象。

这个在前面的样例中我们遇到非常多，这里就不再多说，能够參考：JavaSE入门学习18：Java面向对象之多态。

三动态绑定(池绑定)与多态

动态绑定是指在运行期间(而非编译期)推断所引用对象的实际类型，依据事实上际的类型调用其对应的方法。

以下样例中。依据Lady对象的成员变量pet所引用的不同的实际类型而调用对应的enjoy()方法。

也就是你new的是

那个类型调用的就是该类型的enjoy()方法

实例代码：

class Animal{

	private String name;

	//构造方法

	Animal(String name){

		this.name = name;

	}

	public void enjoy(){

		System.out.println("叫声......");

	}

}

class Cat extends Animal{

	private String eyesColor;

	//构造方法

	Cat(String name,String eyesColor){

		//调用父类的构造函数

		super(name);

		this.eyesColor = eyesColor;

	}

	//重写父类Animal的enjoy()方法

	public void enjoy(){

		System.out.println("猫叫声......");

	}

}

class Dog extends Animal{

	private String furColor;

	//构造方法

	Dog(String name,String furColor){

		//调用父类的构造方法

		super(name);

		this.furColor = furColor;

	}

	//重写父类Animal的enjoy()方法

	public void enjoy(){

		System.out.println("狗叫声......");

	}

}

class Lady{

	private String name;

	//引用类型变量成员

	private Animal pet;

	//构造函数

	Lady(String name,Animal pet){

		this.name = name;

		this.pet = pet;

	}

	public void myPetEnjoy(){

		pet.enjoy();

	}

}

public class Test{

	public static void main(String[] arge){

		Cat c = new Cat("catname","blue");

		Dog d = new Dog("dogname","black");

		Lady l1 = new Lady("l1",c);

		Lady l2 = new Lady("l2",d);

		l1.myPetEnjoy();

		l2.myPetEnjoy();

	}

}

执行结果：

对于可扩展性的理解：

改写上述的样例：

加入一个Bird类：

class Bird extends Animal{

	//构造方法

	Bird(){

		//调用父类的构造方法

		super("bird");

	}

	//重写父类Animal的enjoy()方法

	public void enjoy(){

		System.out.println("鸟叫声......");

	}

}

改写main方法：

public class Test{

	public static void main(String[] arge){

		Cat c = new Cat("catname","blue");

		Dog d = new Dog("dogname","black");

		Bird b = new Bird();

		Lady l1 = new Lady("l1",c);

		Lady l2 = new Lady("l2",d);

		Lady l3 = new Lady("l3",b);

		l1.myPetEnjoy();

		l2.myPetEnjoy();

		l3.myPetEnjoy();

	}

}

执行结果：

多态特性对于系统可扩充性的重要性

继续改写鸟类：

class Bird extends Animal{

	private String featherColor;

	//构造方法

	Bird(String name,String featherColor){

		//调用父类的构造方法

		super(name);

		this.featherColor = featherColor;

	}

	//重写父类Animal的enjoy()方法

	public void enjoy(){

		System.out.println("鸟叫声......");

	}

}

改写mian方法：

public class Test{

	public static void main(String[] arge){

		Lady l4 = new Lady("l4",new Bird("birdname","green"));

		l4.myPetEnjoy();

	}

}

执行结果：

       

多态的条件：

1)要有继承

2)要有重写

3)父类引用指向子类对象