一、多态
多态:可以理解为事物存在的多种体现形态
例如:
人:男人,女人
动物:猫,狗
猫 x = new 猫();
动物 x = new 猫();
1.多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接受自己的对象。
2.多态的前提
(1)必须是类与类之间有关系,要么继承,要么实现
(2)通常存在覆盖
3.多态的好处
多态的出现大大的提高了程序的扩展性。
4.多态的弊端
提高了扩展性,但是只能使用父类的引用访问父类中的成员。
5.多态的应用
6.多态的出现代码中的特点(多态使用的注意事项)
class Animal{
abstract void eat();
}
class Cat extends Animal{
public void eat(){
system.out.prinln("吃鱼");
}
public void catchMouse(){
system.out.prinln("抓老鼠");
}
}
class Dog extends Animal{
public void eat(){
system.out.prinln("吃骨头");
}
public void kanJia(){
system.out.prinln("看门");
}
}
class Pig extends Animal{
public void eat(){
system.out.prinln("饲料");
}
public void gongDi(){
system.out.prinln("gongDi");
}
}
class DuoTaiDemo{
public static void main(String[] args){
//Cat c = new Cat();
//c.eat();
// Dog d = new Dog();
//d.eat();
/*Cat c = new Cat();
Cat c1 = new Cat();
function(c1);*/
///Animal c = new Cat();
//c.eat();
function(new Cat());
function(new Dog());
function(new Pig());
}
public static void function(Animal a){
a.eat();
}
}
二、多态的转型
class Animal{
abstract void eat();
}
class Cat extends Animal{
public void eat(){
system.out.prinln("吃鱼");
}
public void catchMouse(){
system.out.prinln("抓老鼠");
}
}
class Dog extends Animal{
public void eat(){
system.out.prinln("吃骨头");
}
public void kanJia(){
system.out.prinln("看门");
}
}
class Pig extends Animal{
public void eat(){
system.out.prinln("饲料");
}
public void gongDi(){
system.out.prinln("gongDi");
}
}
class DuoTaiDemo{
public static void main(String[] args){
Animal a = new Cat();//类型提升,向上转型。
a.eat();
//如果想要调用猫的特有方法时,如何操作?
//强制将父类的引用,转成子类类型,向下转型。
Cat c = (Cat)a;
c.catchMouse();
//千万不要出现这样的操作,就是将父类对象转成子类类型。
//我们能转换的是父类应用指向了自己的子类对象时,该应用可以被提升,也可以
//被强制转换
//Animal a = new Animal(); //这种写法就不对了,不能强制把动物转成猫
//Cat c=(Cat)a;
}
public static void function(Animal a){
a.eat();
}
}
三、多态示例
基础班学生:
学习,睡觉。
高级班学生:
学习,睡觉。
可以将这两类事物进行抽取
abstract class Student{
public abstract void study();
public void sleep(){
System.out.println("躺着睡");
}
}
class BaseStudent extends Student{
public void study(){
System.out.println("study");
}
public void sleep(){
System.out.println("裸睡");
}
}
class AdvStudent extends Student{
public void study(){
System.out.println("adv study");
}
}
class DoStudent{
public void doSomething(Student stu){
stu.study();
stu.sleep();
}
}
class DuoTaiDemo3{
public static void main(String[] args){
DoStudent ds = new DoStudent();
ds.doSomething(new BaseStudent());
ds.doSomething(new AdvStudent());
//BaseStudent ba = new BaseStudent();
//ba.study();
//ba.sleep();
//AvdStudent as = new AvdStudent();
//as.study();
//as.sleep();
}
}
四:多态中成员(函数与变量)的特点
1.
class Fu{
void method1(){
System.out.println("fu method_1");
}
void method2(){
System.out.println("fu method_2");
}
}
class Zi extends Fu{
void method1(){
System.out.println("zi method_1");
}
void method3(){
System.out.println("zi method_3");
}
}
class Test{
public static void main(String[] args) {
Zi z = new Zi();
z.method1();
z.method2();
z.method3();
}
}
//打印结果:
zi method_1
fu method_2
zi method_3
分析:Zi复写了Fu的method1,把Fu的method2继承过来,method3是特有的
2.在多态中成员函数的特点
class Fu{
void method1(){
System.out.println("fu method_1");
}
void method2(){
System.out.println("fu method_2");
}
}
class Zi extends Fu{
void method1(){
System.out.println("zi method_1");
}
void method3(){
System.out.println("zi method_3");
}
}
class Test{
public static void main(String[] args) {
Fu f = new Zi();
f.method1();
f.method2();
//f.method3(); //这样编译会出错
}
}
//打印结果:
zi method_1
fu method_2
在多态中成员函数的特点:
在编译时期:参与引用型变量所属的类中是否有调用的方法,如果有,编译通过,
如果没有编译失败。例如:f这个引用型变量中有method1和method2,但没有method3,编译失败
在运行时期:参阅对象所属的类中是否有调用的方法。
简单总结:成员函数在多态调用时,编译看左边,运行看右边。
编译看左边:因为f这个引用型变量中有method1和method2,但没有method3,编译失败
运行看右边:Zi类中有method1,method2从Fu中继承了过来,所以运行结果为:
zi method_1
fu method_2
3.多态中成员变量的特点:
(1)
class Fu{
int num = 5;
void method1(){
System.out.println("fu method_1");
}
void method2(){
System.out.println("fu method_2");
}
static void method4(){
System.out.println("fu method_4");
}
}
class Zi extends Fu{
int num = 8;
void method1(){
System.out.println("zi method_1");
}
void method3(){
System.out.println("zi method_3");
}
static void method4(){
System.out.println("zi method_4");
}
}
class Test{
public static void main(String[] args) {
Fu f = new Zi();
f.method4();
}
}
//打印结果:
fu method_4
在多态中,静态成员函数的特点:
无论编译和运行,都参考左边。
(2)class Fu{
int num = 5;
void method1(){
System.out.println("fu method_1");
}
void method2(){
System.out.println("fu method_2");
}
static void method4(){
System.out.println("fu method_4");
}
}
class Zi extends Fu{
int num = 8;
void method1(){
System.out.println("zi method_1");
}
void method3(){
System.out.println("zi method_3");
}
static void method4(){
System.out.println("zi method_4");
}
}
class Test{
public static void main(String[] args) {
Fu f = new Zi();
System.out.println(f.num);
}
}
//打印结果:5
在多态中,成员变量的特点:
无论编译和运行,都参考左边(引用型变量所属的类) |
|