Java面向对象--多态

什么是多态

多态，顾名思义，就是多种形态；是同一个行为具有多个不同表现形式或形态的能力。如学生是人的一种，则一个具体的同学小明既是学生也是人，即出现两种形态

多态的体现格式

父类名称 变量名 = new 子类对象；

接口名称 对象名 = new 实现类名称();

多态存在的三个必要条件

多态的前提是类与类之间存在关系，要么继承、要么实现或方法存在覆盖
1、继承：多态中必须存在有继承关系的子类和父类
2、重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法
3、父类引用指向子类对象（向上转型）：多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法

例子

基于继承实现的多态

class Animal {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Animal(){
}
public void breathe(){
System.out.println("呼吸");
}
/**
* 重写Object类toString()
*/
public String toString(){
return null;
}
}

class Rabbit extends Animal{
public Rabbit(){
setName("兔子");
}
/**
* 重写父类方法，实现多态
*/
public void breathe(){
System.out.println(getName()+"呼吸");
}
public String toString(){
return "Animal:" + getName();
}
}
class Cat extends Animal{
public Cat(){
setName("Cat");
}
/**
* 重写父类方法，实现多态
*/
public void breathe(){
System.out.println(getName()+"呼吸");
}
public String toString(){
return "Animal:" + getName();
}
}
public class Test {
public static void main(String[] args) {
Animal rabbit = new Rabbit();
Animal cat = new Cat();
rabbit.breathe();
cat.breathe();
Rabbit rabbit1 = new Rabbit();
Cat cat1 = new Cat();
rabbit1.breathe();
cat1.breathe();
}
}

基于接口实现的多态

interface Animal {
public void eat();
public void activity();
}
class Rabbit implements Animal{

@Override
public void eat() {
System.out.println("吃草");
}

@Override
public void activity() {
System.out.println("跳");
}

public static void main(String[] args) {
Animal animal = new Rabbit();
animal.eat();
animal.activity();
Rabbit rabbit = new Rabbit();
rabbit.eat();
rabbit.activity();
}
}

多态中成员的特点

引用变量在编译阶段只能调用编译时类型所具有的方法，但运行时则执行他运行时类型所具有的方法

class Animal{
public int month = 1;

public void eat(){
System.out.println("吃东西");
}
}
class Dog extends Animal{
public int month = 2;

public void eat() {
System.out.println("小狗吃肉");
}

public void sleep() {
System.out.println("小狗睡觉");
}
}
class Cat extends Animal{
public int month = 3;

public void eat() {
System.out.println("小猫吃鱼");
}
}
public class Test {
public static void main(String[] args){
Animal a = new Dog();
Animal b = new Cat();
a.eat();
System.out.println(a.month);
//下面代码编译时会出错
//a.sleep();
b.eat();
System.out.println(b.month);
}
}

多态中成员函数的特点

在编译时期，参考引用型变量所属的类中是否有调用方法，如果有，编译通过，否则编译失败
在运行时期，参考对象所属的类中是否有调用的方法
也就是编译看左边，运行看右边

多态中成员变量的特点

编译和运行都参考左边（引用型变量所属的类）

多态中静态成员函数的特点

编译和运行都参考左边

多态中引用类型转换

向上转型： 多态本身就是向上转型过的过程

使用格式：父类类型 变量名=new 子类类型();
适用场景：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作

Animal animal = new Dog();

向下转型： 父类类型向子类类型向下转换的过程，这个过程是强制的。 一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型

使用格式：子类类型 变量名 = (子类类型) 父类变量名;
含义：将父类对象还原成为本来的子类对象

Dog dog = (Dog) animal;

注意：

必须保证对象创建的时候就是转型后的对象，才能向下转型。否则运行时，报出了 ClassCastException（类型转换异常）

多态的优点与弊端

优点

1、消除类型之间的耦合关系
2、可替换性
3、可扩充性
4、接口性
5、灵活性
6、简化性

弊端

只能使用父类的引用访问父类中的成员

• 点赞
• 收藏
• 分享
• 文章举报