JavaSE入门学习24：Java面向对象补充
Posted life is wonderful
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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();
}
}运行结果：
