面向对象高级04对象的多态性以及对 象多态性在抽象类和接口中的实际应用.docx
- 文档编号:6002645
- 上传时间:2023-01-02
- 格式:DOCX
- 页数:26
- 大小:506.54KB
面向对象高级04对象的多态性以及对 象多态性在抽象类和接口中的实际应用.docx
《面向对象高级04对象的多态性以及对 象多态性在抽象类和接口中的实际应用.docx》由会员分享,可在线阅读,更多相关《面向对象高级04对象的多态性以及对 象多态性在抽象类和接口中的实际应用.docx(26页珍藏版)》请在冰豆网上搜索。
面向对象高级04对象的多态性以及对象多态性在抽象类和接口中的实际应用
16.面向对象高级(04)
本季要点:
对象的都态性、instanceof关键字、Object类。
本季为Java基础中面向对象的重要一季,讲解了对象的多态性,以及对象多态性在抽象类和接口中的实际应用。
blog:
[零基础学JAVA]JavaSE面向对象部分-16.面向对象高级(04)2009-01-15
上季内容回顾:
1、final关键字
·修饰类不能被继承
·修饰方法不能被覆写
·修饰的变量就是一个常量,全局常量(publicstaticfinal)
2、抽象类和接口
·抽象类:
只包含一个抽象方法的类,抽象方法只需声明而不需要实现,必须有子类
·接口:
只包含抽象方法和全局常量的类——接口,也是必须有子类
在实际中一个类很少会去继承一个已经完全实现好的类,基本上都是继承抽象类和实现接口。
本季主要知识点:
1、对象的多态性
2、instanceof关键字
3、Object类
对象的多态性
注意点:
为了清楚的阐述出概念,现在先使用普通类的继承关系。
向上转型:
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 Demo01
{
public static void main(Stringargs[])
{
Bb= new B();
Aa= new A();
b.fun1();
a.fun2();
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 fun1()
{
System.out.println("B类===>public void fun1()");
}
public void fun3()
{
System.out.println("B类===>public void fun3()");
}
}
public class Demo02
{
public static void main(Stringargs[])
{
//声明一个父类对象
Aa= null;
//newB()是子类对象向父类对象转换
a= new B();
a.fun1();
}
}
现在我们来看下a.fun1()调用的是哪个类的方法哈~
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 Demo02
{
public static void main(Stringargs[])
{
//声明一个父类对象
Aa= null;
//newB()是子类对象向父类对象转换
//子类对象向父类对象转型之后,所调用的方法一定是被覆写过的方法
a=newB();
a.fun1();
a.fun2();
}
}
子类对象向父类对象转型之后,所调用的方法一定是被覆写过的方法,这就是对象的向上转型哈~
向下转型:
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(Stringargs[])
{
//声明一个父类对象
Aa= null;
//newB()是子类对象向父类对象转换
//子类对象向父类对象转型之后,所调用的方法一定是被覆写过的方法
a= new B();
a.fun1();
a.fun2();
a.fun3();
}
}
现在我们来看下能否调用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(Stringargs[])
{
//声明一个父类对象
Aa= null;
//newB()是子类对象向父类对象转换
//子类对象向父类对象转型之后,所调用的方法一定是被覆写过的方法
a= new B();
//可以进行向下转型,需要使用强制性手段哈~
Bb=(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(Stringargs[])
{
Aa= new B();
a.fun1();
}
}
程序找不到B类中被覆写的fun1()方法,所以去查找父类A中的fun1()方法了哈~
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 Demo04
{
public static void main(Stringargs[])
{
Aa= new A();
a.fun1();
}
}
现在对象实例化时没有子类哈,所以a.fun1()调用的是父类A中本身的fun1()方法
如果现在我们要调用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 Demo04
{
public static void main(Stringargs[])
{
Aa=newA();
//如果我们要调用fun3()方法呢?
现在使用向下转型可以吗?
Bb=(B)a;
b.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(Stringargs[])
{
fun(new B());
fun(new C());
}
//现在要求定义几个方法,可以接收父类A的子类对象
//如果不知道多态性的时候应该使用以下的方式编写代码
publicstaticvoidfun(Bb)
{
b.fun2();
}
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 面向对象高级04对象的多态性以及对 象多态性在抽象类和接口中的实际应用 面向 对象 高级 04 多态性 以及 抽象 接口 中的 实际 应用