[零基础学JAVA]Java SE面向对象部分-16.面向对象高级（04）-阿里云开发者社区

上季内容回顾：

1、final关键字
· 修饰类不能被继承
· 修饰方法不能被覆写
· 修饰的变量就是一个常量，全局常量（public static final）
2、抽象类和接口
· 抽象类：只包含一个抽象方法的类，抽象方法只需声明而不需要实现，必须有子类
· 接口：只包含抽象方法和全局常量的类——接口，也是必须有子类

在实际中一个类很少会去继承一个已经完全实现好的类，基本上都是继承抽象类和实现接口。

本季主要知识点：

1、对象的多态性
2、instanceof关键字
3、Object类

对象的多态性

注意点：
为了清楚的阐述出概念，现在先使用普通类的继承关系。

向上转型：

对象多态性体现在对象相互转型上面哈~

现在我们来看下a.fun1()调用的是哪个类的方法哈~

子类对象向父类对象转型之后，所调用的方法一定是被覆写过的方法，这就是对象的向上转型哈~

向下转型：

现在我们来看下能否调用a.fun3()哈~

程序提示找不到fun3()方法，A类中没有fun3()方法哈，如果我们一定要调用的话，我们就要使用向下转型哈~

class A
{
         public void fun1()
        {
                System.out.println( "A类===>public void fun1()");
        }
         public void fun2()
        {
                 //fun2方法调用的是fun1方法
                 this.fun1();
        }
}
class B extends A
{
         //覆写A类中的fun1()方法
         public void fun1()
        {
                System.out.println( "B类===>public void fun1()");
        }
         public void fun3()
        {
                System.out.println( "B类===>public void fun3()");
        }
}
public class Demo03
{
         public static void main(String args[])
        {
                 //声明一个父类对象
                A a = null;
                 //new B()是子类对象向父类对象转换
                 //子类对象向父类对象转型之后，所调用的方法一定是被覆写过的方法
                a = new B();
                 //可以进行向下转型，需要使用强制性手段哈~
                 B b = (B)a;
                b.fun3();
        }
}

验证下效果：

这就是对象向下转型哈~

观察以下一种代码，检查下有没问题哈~：

class A
{
         public void fun1()
        {
                System.out.println( "A类===>public void fun1()");
        }
         public void fun2()
        {
                 //fun2方法调用的是fun1方法
                 this.fun1();
        }
}
class B extends A
{
         //现在我们不覆写A类中的fun1()方法
         public void funX()
        {
                System.out.println( "B类===>public void fun1()");
        }
         public void fun3()
        {
                System.out.println( "B类===>public void fun3()");
        }
}
public class Demo04
{
         public static void main(String args[])
        {
                A a = new B();
                a.fun1();
        }
}

程序找不到B类中被覆写的fun1()方法，所以去查找父类A中的fun1()方法了哈~

现在对象实例化时没有子类哈，所以a.fun1()调用的是父类A中本身的fun1()方法

如果现在我们要调用fun3()方法呢？现在使用向下转型可以吗?

这样修改的话，我们看下有没问题哈，验证一下，发现编译时没有错误，但执行时却出现ClassCastException错误了哈~

在程序开发中有两大错误是比较常见的：
· NullPointerException：表示空指向异常，如果没有开辟堆内存空间，则出现此异常
· ClassCastException：表示类转换异常，两个不相关的类的对象进行向下转型操作。

上面一个解释比较难理解哈，我们光看A类的话，我们不能知道A类有什么子类哈，但是如果我们光看B类的话，我们可以看出B类是继承A类的话，所以得出了下面一个结论。

结论：
在进行向下转型之前，两个对象必然先发生向上转型关系，这样好建立起关系，否则两个没有关系的对象是不能相互转型的。

对象多态性到底有那些用处呢？

如果不知道多态性的时候应该使用以下的方式编写代码，利用方法的重载完成。

class A
{
         public void fun1()
        {
                System.out.println( "A类===>public void fun1()");
        }
         public void fun2()
        {
                 //fun2方法调用的是fun1方法
                 this.fun1();
        }
}
class B extends A
{
         //覆写A类中的fun1()方法
         public void fun1()
        {
                System.out.println( "B类===>public void fun1()");
        }
         public void fun3()
        {
                System.out.println( "B类===>public void fun3()");
        }
}
class C extends A
{
         //覆写A类中的fun1()方法
         public void fun1()
        {
                System.out.println( "C类===>public void fun1()");
        }
         public void fun4()
        {
                System.out.println( "C类===>public void fun4()");
        }
}
public class Demo05
{
         public static void main(String args[])
        {
                fun( new B());
                fun( new C());
        }
         //现在要求定义几个方法，可以接收父类A的子类对象
         //如果不知道多态性的时候应该使用以下的方式编写代码
         public static void fun(B b)
        {
                b.fun2();
        }
        public static void fun(C c)
        {
                c.fun2();
        }
}

如果按此做法，就会面临一个很严重的问题：
· 如果现在A类有30个子类，则方法要重写30遍。
所以此时就可以利用对象的多态性完成，因为所有的子类对象都可以向父类对象转换。

class A
{
         public void fun1()
        {
                System.out.println( "A类===>public void fun1()");
        }
         public void fun2()
        {
                 //fun2方法调用的是fun1方法
                 this.fun1();
        }
}
class B extends A
{
         //覆写A类中的fun1()方法
         public void fun1()
        {
                System.out.println( "B类===>public void fun1()");
        }
         public void fun3()
        {
                System.out.println( "B类===>public void fun3()");
        }
}
class C extends A
{
         //覆写A类中的fun1()方法
         public void fun1()
        {
                System.out.println( "C类===>public void fun1()");
        }
         public void fun4()
        {
                System.out.println( "C类===>public void fun4()");
        }
}
public class Demo06
{
         public static void main(String args[])
        {
                fun( new B());
                fun( new C());
        }
         //现在要求定义几个方法，可以接收父类A的子类对象
         //现在使用多态性编写代码
         public static void fun(A a)
        {
                a.fun2();
        }
}

现在我们就只留一个fun()方法，new B()，new C()都是A类的子类哈，所以现在不管调用时传什么子类，都调用所传子类被覆写的fun1()方法哈~~~这就是对象多态性带来的好处，谁被其实例化就具备这样的功能哈~如果父类设计的非常的完善，则方法中会非常的好写。

要求：
如果传入的是B类的对象，则要求再调用fun3()方法，如果传入的是C类的对象，则要求再调用fun4()
方法。

问题：
如何去判断一个对象是否是某个类的实例呢？这就需要instanceof关键字支持哈。

instanceof关键字

class A
{
         public void fun1()
        {
                System.out.println( "A类===>public void fun1()");
        }
         public void fun2()
        {
                 //fun2方法调用的是fun1方法
                 this.fun1();
        }
}
class B extends A
{
         //覆写A类中的fun1()方法
         public void fun1()
        {
                System.out.println( "B类===>public void fun1()");
        }
         public void fun3()
        {
                System.out.println( "B类===>public void fun3()");
        }
}
class C extends A
{
         //覆写A类中的fun1()方法
         public void fun1()
        {
                System.out.println( "C类===>public void fun1()");
        }
         public void fun4()
        {
                System.out.println( "C类===>public void fun4()");
        }
}
public class Demo07
{
         public static void main(String args[])
        {
                B b = new B();
                System.out.println(b instanceof A);
        }
}

我们来判断下对象b是否是A类的实例哈，我们分析下哈，子类B可以直接向父类A转型哈，说明父类A可以接收子类B的实例，那两者必然有关系哈，我们验证一下，结果返回true哈，证明对象b是A类的实例哈~

class A
{
         public void fun1()
        {
                System.out.println( "A类===>public void fun1()");
        }
         public void fun2()
        {
                 //fun2方法调用的是fun1方法
                 this.fun1();
        }
}
class B extends A
{
         //覆写A类中的fun1()方法
         public void fun1()
        {
                System.out.println( "B类===>public void fun1()");
        }
         public void fun3()
        {
                System.out.println( "B类===>public void fun3()");
        }
}
class C extends A
{
         //覆写A类中的fun1()方法
         public void fun1()
        {
                System.out.println( "C类===>public void fun1()");
        }
         public void fun4()
        {
                System.out.println( "C类===>public void fun4()");
        }
}
public class Demo07
{
         public static void main(String args[])
        {
                B b = new B();
                System.out.println(b instanceof A);
                System.out.println(b instanceof B);
        }
}

对象b也肯定是B类的实例哈~

class A
{
         public void fun1()
        {
                System.out.println( "A类===>public void fun1()");
        }
         public void fun2()
        {
                 //fun2方法调用的是fun1方法
                 this.fun1();
        }
}
class B extends A
{
         //覆写A类中的fun1()方法
         public void fun1()
        {
                System.out.println( "B类===>public void fun1()");
        }
         public void fun3()
        {
                System.out.println( "B类===>public void fun3()");
        }
}
class C extends A
{
         //覆写A类中的fun1()方法
         public void fun1()
        {
                System.out.println( "C类===>public void fun1()");
        }
         public void fun4()
        {
                System.out.println( "C类===>public void fun4()");
        }
}
public class Demo07
{
         public static void main(String args[])
        {
                A a = new A();
                System.out.println(a instanceof A);
                System.out.println(a instanceof B);
        }
}

那相反对象a是B类的实例吗？验证显示不是哈~说明不能向子类转换哈~

class A
{
         public void fun1()
        {
                System.out.println( "A类===>public void fun1()");
        }
         public void fun2()
        {
                 //fun2方法调用的是fun1方法
                 this.fun1();
        }
}
class B extends A
{
         //覆写A类中的fun1()方法
         public void fun1()
        {
                System.out.println( "B类===>public void fun1()");
        }
         public void fun3()
        {
                System.out.println( "B类===>public void fun3()");
        }
}
class C extends A
{
         //覆写A类中的fun1()方法
         public void fun1()
        {
                System.out.println( "C类===>public void fun1()");
        }
         public void fun4()
        {
                System.out.println( "C类===>public void fun4()");
        }
}
public class Demo08
{
         public static void main(String args[])
        {
                fun( new B());
                System.out.println( "#########################");
                fun( new C());
        }
         public static void fun(A a)
        {
                a.fun2();
                 if (a instanceof B)
                {
                        B b = (B)a;
                        b.fun3();
                }
                 if (a instanceof C)
                {
                        C c = (C)a;
                        c.fun4();
                }
        }
}

这就是instanceof关键字的作用哈~

Instanceof的使用时机：
一般情况下都是在转型之前进行一下判断，这样就可以进行比较安全的转型操作。

Object类

在Java中用户所编写的一切类都是一个类的子类，称为Object类。

实际上此类默认继承了Object类，以上代码等价于以下代码：

Object类的作用：
· 如果一个好的类需要覆写Object类中的三个方法：
|- public String toString()：对象输出时的操作
|- public boolean equals(Object obj)：对象比较时的操作
|- public int hashCode()： 返回该对象的哈希码值。

class Student //extends Object
{
         private String name;
         private int age;
         public Student(String name, int age)
        {
                 this.name = name;
                 this.age = age;
        }
}
public class Demo09
{
         public static void main(String args[])
        {
                System.out.println( new Student( "王乾",27));
        }
}

现在我们看下效果哈~

现在Student类是Object类的子类哈，那我们加上toString()看下效果

我们发现和没加toString()之前的效果一样哈~

加和不加都是一样滴，那我们下面就覆写Object类的toString()方法哈~

class Student //extends Object
{
         private String name;
         private int age;
         public Student(String name, int age)
        {
                 this.name = name;
                 this.age = age;
        }
         public String toString()
        {
                 return "Michael";
        }
}
public class Demo09
{
         public static void main(String args[])
        {
                System.out.println( new Student( "王乾",27));
        }
}

现在我们再来执行下看下效果，现在程序输出打印字符串“Michael”了哈~

我们查下System的JDK文档，找到out.print()方法哈~

实际上out.print()方法是调用的这个方法哈~

所以System.out.println(new Student("王乾",27));这行代码会默认调用toString()方法，它会找到Student类中被子类覆写的toString()方法哈~Student子类向Object父类进行向上转型，只要方法被子类覆写了，则此时要调用被覆写过的方法哈~

class Student //extends Object
{
         private String name;
         private int age;
         public Student(String name, int age)
        {
                 this.name = name;
                 this.age = age;
        }
         public String toString()
        {
                 return "姓名："+ this.name+ "，年龄："+ this.age;
        }
}
public class Demo09
{
         public static void main(String args[])
        {
                System.out.println( new Student( "王乾",27));
        }
}

现在输出信息了哈~

还有一个equals()方法哈~

现在我们来判断两个对象是否相等哈~

class Student //extends Object
{
         private String name;
         private int age;
         public Student(String name, int age)
        {
                 this.name = name;
                 this.age = age;
        }
         public boolean equals(Object obj)
        {
                 if( this==obj)
                {
                         //内存地址的值相等，则肯定是同一个对象
                         return true;
                }
                Student stu = (Student)obj;
                 if (stu.name.equals( this.name)&&stu.age== this.age)
                {
                         return true;
                }
                 else
                {
                         return false;
                }
        }
         public String toString()
        {
                 return "姓名："+ this.name+ "，年龄："+ this.age;
        }
}
public class Demo10
{
         public static void main(String args[])
        {
                Student stu1 = new Student( "王乾",27);
                Student stu2 = new Student( "王乾",27);
                System.out.println(stu1.equals(stu2));
        }
}

以上的对象比较代码有严重问题：
· 因为equals方法接收的是Object类型，所以肯定可以接收任意的对象。

比较时我们传入一个字符串“51cto”，发现提示转换异常ClassCastException错误

class Student //extends Object
{
         private String name;
         private int age;
         public Student(String name, int age)
        {
                 this.name = name;
                 this.age = age;
        }
         public boolean equals(Object obj)
        {
                 if( this==obj)
                {
                         //内存地址的值相等，则肯定是同一个对象
                         return true;
                }
                 if (!(obj instanceof Student))
                {
                        return false;
                }
                Student stu = (Student)obj;
                 if (stu.name.equals( this.name)&&stu.age== this.age)
                {
                         return true;
                }
                 else
                {
                         return false;
                }
        }
         public String toString()
        {
                 return "姓名："+ this.name+ "，年龄："+ this.age;
        }
}
public class Demo10
{
         public static void main(String args[])
        {
                Student stu1 = new Student( "王乾",27);
                Student stu2 = new Student( "王乾",27);
                System.out.println(stu1.equals( "51cto"));
        }
}

我们加入判断，如果对象obj不是Student类的实例的话，那就不要再进行比较了哈，直接返回false,现在看下程序能否正常执行哈~

这就是Object类的对象比较，所以在进行转型之前一定要加入验证代码哈~这一点很重要哈~

总结
1、对象的多态性
· 向上自动转型
· 向下强制转型
2、instanceof关键字
3、Object类

注意：
在开发中很少去继承一个已经实现好的类，一般都会去继承一个抽象类或实现一个接口。

ps:下季我们将使用多态性来理解抽象类和接口的应用，敬请期待~~~O(^_^)O

################################################

附件：http://down.51cto.com/data/2351640

本文转自redking51CTO博客，原文链接：http://blog.51cto.com/redking/126674，如需转载请自行联系原作者

[零基础学JAVA]Java SE面向对象部分-16.面向对象高级（04）

热门文章

最新文章

相关课程

相关电子书

相关实验场景