首页分享面向对象

面向对象

来源：花匠小妙招时间：2024-09-14 20:59

一、多态的基本概念

1、多态的概念

多态是指在同一时刻体现出不同的状态，如水的状态有气态、液态和固态。

2、多态的前提

1）必须要有继承关系

2）必须要有方法重写

3）父类引用必须指向子类对象（向上转型）

eg. Animal a = new Cat（）；（Animal为父类，Cat为子类）

通过父类对象的创建是通过子类在堆内存新建了了一个对象,由于子类又继承了父类,父类的初始化是通过子类新建对象进行的。

3、多态中成员访问的特点

成员变量：编译看左，运行看左

成员方法（非静态）：编译看左，运行看右（存在方法重写）

构造方法：无论是父类还是子类，都是对对象的初始化

成员方法（静态）：编译看左，运行看左（静态方法和类有关，不存在方法重写）

下面我们通过一个具体的代码来体会一下多态成员的访问特点：

class Fu{

int num = 20 ;

public void show() {

System.out.println("show Fu....");

}

public Fu(){

}

public static void function() {

System.out.println("function Fu...");

}

class Zi extends Fu{

int num = 30 ;

public void show() {

System.out.println("show Zi....");

}

public static void function() {

System.out.println("function Zi...");

}

public void method() {

System.out.println("------");

}

public class DuoTaiDemo {

public static void main(String[] args) {

Fu f = new Zi() ;

System.out.println(f.num);

f.show();

f.function();

}

程序运行结果：

show Zi....

function Fu...

可以看出，通过多态Fu f = new Zi（）；调用成员变量num值时调用的是父类的num值（编译看左，运行看左），调用的show方法（非静态）是子类重写后的方法（编译看左，运行看右，因为存在方法重写），此时调用子类的method方法则会报错，因为父类中没有method方法，调用function方法（静态方法），输出的是父类的method方法（编译看左，运行看左，因为静态方法和类有关，不存在方法重写）

4、多态的优缺点

优点：提高代码的复用性（由继承保证）

缺点：提高代码的扩展性（由多态保证）

改进之前：

class Animal{

public void eat() {

System.out.println("eat");

}

public void sleep() {

System.out.println("sleep");

}

class Cat extends Animal{

public void eat() {

System.out.println("猫吃鱼...");

}

public void sleep() {

System.out.println("猫趴着睡觉...");

}

class Dog extends Animal{

public void eat() {

System.out.println("狗吃骨头...");

}

public void sleep() {

System.out.println("狗卧着睡觉...");

}

public class DuoTaiDemo2 {

public static void main(String[] args) {

Cat c = new Cat() ;

c.eat();

c.sleep();

System.out.println("-------------");

Cat c2 = new Cat() ;

c2.eat();

c2.sleep();

System.out.println("-------------");

Cat c3 = new Cat() ;

c3.eat();

c3.sleep();

Dog d = new Dog() ;

d.eat();

d.sleep();

}

可以看出，如果没有多态，我们的代码将会非常臃肿，而且要进行很多重复性的工作，因此对代码进行改进，将动物的eat（）和sleep（）方法封装进一个AnimalTool（）的工具，该工具既可以接收Cat类的对象也可以接受Dog类的对象，这样我们在调用eat和sleep方法时无论该对象是什么类型的数据都可以接收。

改进之后：

class Animal{

public void eat() {

System.out.println("eat");

}

public void sleep() {

System.out.println("sleep");

}

class Cat extends Animal{

public void eat() {

System.out.println("猫吃鱼...");

}

public void sleep() {

System.out.println("猫趴着睡觉...");

}

class Dog extends Animal{

public void eat() {

System.out.println("狗吃骨头...");

}

public void sleep() {

System.out.println("狗卧着睡觉...");

}

class AnimalTool{

private AnimalTool() {}

public static void useAnimal(Animal a) {

a.eat();

a.sleep();

}

public class DuoTaiDemo2 {

public static void main(String[] args) {

Cat c = new Cat() ;

Cat c2 = new Cat() ;

Cat c3 = new Cat() ;

Dog d = new Dog() ;

AnimalTool.useAnimal(c);

AnimalTool.useAnimal(c2);

AnimalTool.useAnimal(c3);

AnimalTool.useAnimal(d);

}

虽然多态的优点十分明显，但它也是有弊端的：通过父类的引用调用子类特有功能,不能调用....（如上面讲过的例子，在调用子类的method方法时会报错，因为父类中没有method方法），那么该怎么解决这个问题呢？

上面我们讲过了向上转型：Animal a = new Cat（）；这里又引出了向下转型的概念：将父类的引用强制转换子类的引用，如：Animal a = new Cat（）（向上转型）；Cat b = （Cat）a；（向下转型），向下转型的前提是必须有父类的引用，将父类的引用强制转换子类的引用 ,但向下转型如果使用不当,会出现一个运行时期异常:ClassCastException。