JavaSE入门学习24：Java面向对象补充

        一Java中的Object类

        Object类是所有Java类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类默认

继承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)父类引用指向子类对象