package com.b_duotai;
/**
* 测试多态
* 第一次测试
*/
class Person{
public void fun1()
{
System.out.println("fun1--来自父类");
}
public void fun2()
{
System.out.println("fun2--来自父类");
}
}
class Son extends Person{
/**
* 定义一个和父类相同的方法,
* 达到了重写父类方法的目的
*/
public void fun1(){
System.out.println("fun1--来自子类");
}
public void fun3()
{
System.out.println("fun3--来自子类");
}
}
public class test1 {
public static void main(String[] args) {
/**
* 等号左边创建了一个Person对象
* 但是右边接收了一个没有名字的儿子的对象
* 因此P既可以拥有自己的方法
* 也可以拥有子类的方法,前提是子类的方法
* 进行了重写
* 比如,P就不可以调用fun3
*/
Person p = new Son();
p.fun1();
p.fun2();
}
}
运行结果:
1. 多态的思想
多态分为方法的多态和对象的多态。
重载就是方法的多态的一种体现,两个方法,方法名相同,返回值相同,但是参数列表不同,就是多态的一种体现。
对象的多态,即父类对象的引用需要通过子类对象实例化来实现,此时父类的引用再去调用方法时,如果子类对父类的方法进行了重写,则调用子类的方法,反之调用父类自己的方法。
2. 具体例子
2.1 方法的多态:
package c_duotai;
public class Demo1 {
public static void main(String[] args) {
int i = 2;
int j = 3;
Function function = new Function();
/**
* 1.虽然方法名称相同,但是由于传进去的参数不同,在运行的时候就会调用不同
* 的方法
* 2.不在同一个类里,你需要new一个对象,然后让该类的对象调用该类的方法。
*/
function.sum(i);
function.sum(4,6);
}
static class Function
{
//两个方法,只有参数不同
void sum(int i){
System.out.println("两数的和为:" + i);
}
void sum(int i,int j)
{
System.out.println("两数的和为:" + (i+j));
}
}
}
2.2 对象的多态
package c_duotai;
/**
* 对象的多态体现在
* 1. 父类引用指向子类
* 2. 如果子类对父类的方法进行了重写,则会调用子类的方法
*
*/
class Animal{
public void move()
{
System.out.println("动物移动");
}
}
class Fish extends Animal{
public void move()
{
System.out.println("鱼儿游");
}
}
class Bird extends Animal{
public void move()
{
System.out.println("鸟儿飞");
}
}
class Horse extends Animal{
public void move()
{
System.out.println("马儿跑");
}
}
public class Demo2 {
public static void main(String[] args) {
Animal a;
//父类引用指向子类new出来的对象
a = new Fish();
a.move();
a = new Bird();
a.move();
a = new Horse();
a.move();
}
}
运行结果:
程序分析:父类里面的move()方法在子类里面全部进行了重写,在main函数里,父类的引用来自子类new的对象,因此父类调用move()方法的时候,等于调用了子类重写的方法。如果子类不进行重写,则无法调用。如下所示:
注释掉Fish类里面的方法,即使接收了也无法调用。
注释掉
运行:
3. 总结
由上述例子可以看出,父类依据传入不同的子类对象,调用对应的子类的方法。如果子类没有对这个方法进行重写,父类就只能调用自己的;同理,子类自己独有的方法,父类也不能调用。多态是父类调用不同的子类的方法,继承是子类调用父类的方法。