/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Animal an=new Cat();
an.Cry();
an=new Dog();
an.Cry();
Master master =new Master();
master.Feed(new Dog(), new Bone());
master.Feed(new Cat(), new Fish());
}
}
class Master
{
//使用多态喂食
public void Feed(Animal an,Food f)
{
an.eat();
f.ShowName();
}
}
class Food
{
String name;
public void ShowName()
{}
}
class Fish extends Food
{
public void ShowName()
{
System.out.println("鱼!!!");
}
}
class Bone extends Food
{
public void ShowName()
{
System.out.println("骨头!!!");
}
}
class Animal
{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void Cry()
{
System.out.println("不知道怎么叫!!!");
}
public void eat()
{
System.out.println("不知道!!!");
}
}
class Cat extends Animal
{
public void eat()
{
System.out.println("猫爱吃鱼!!!");
}
public void Cry()
{
System.out.println("喵喵叫!!!");
}
}
class Dog extends Animal
{
public void eat()
{
System.out.println("狗爱吃骨头!!!");
}
public void Cry()
{
System.out.println("旺旺叫!!!");
}
}
看个代码会比较好理解吧作者: 彭璞 时间: 2012-11-25 18:16
多态的定义：将参数定义为一个父类，各子类中都重写了父类的方法，在方法中用传入的父类对象调用这个方法，当传入什么子类时就会调用相应的各子类的方法。
多态存在的条件:有继承，有重写，父类引用指向子类对象。一旦满足，当父类里被重写的方法时，实际new的哪个子类对象，就调用子类对象方法。
父类引用指向子类对象解释：
A a = new B() ;
A是我们的引用类型，他是父类，B是子类。
a是一个子类对象，但是引用的是父类的类型。
举例：
//定义父类
abstract class Animal {
private String name;
Animal(String name) {
this.name = name;
}
public void enjoy(){
System.out.println("叫声......");
}
// public abstract void enjoy();
}
//定义Cat类继承Animal
class Cat extends Animal {
private String eyesColor;
Cat(String n,String c) {
super(n);
eyesColor = c;
}
public void enjoy() {
System.out.println("猫叫声......");
}
//public abstract void enjoy();
}
//定义dog类继承Animal
class Dog extends Animal {
private String furColor;
Dog(String n,String c) {
super(n);
furColor = c;
}
public void enjoy() {
System.out.println("狗叫声......");
}
}
//定义Bird类继承Animal
class Bird extends Animal {
Bird() {
super("bird");
}
public void enjoy() {
System.out.println("鸟叫声......");
}
}
//定义一个人物类
class Lady {
private String name;
private Animal pet;
Lady(String name,Animal pet) {
this.name = name; this.pet = pet;
}
public void myPetEnjoy(){
pet.enjoy();
}
}
//测试类
public class Test {
public static void main(String args[]){
Cat c = new Cat("catname","blue");
Dog d = new Dog("dogname","black");
Bird b = new Bird();
Lady l1 = new Lady("l1",c);
Lady l2 = new Lady("l2",d);
Lady l3 = new Lady("l3",b);
l1.myPetEnjoy();
l2.myPetEnjoy();
l3.myPetEnjoy();
}
}
//上面程序人的构造方法中传的参数是Animal类型，但是我们在测试类中传入的参数分别是Cat,Dog还有Bird
//对象，每个人l1,l2,l3在调用自己的myPetEnjoy（）方法时候，会根据自己宠物的不同而输出不同的叫声；
//此列中有继承（Cat,dog,bird都是继承animal），有重写（都重写了enjoy()方法），有父类的引用指向子类对象（Lady的构造方法中
//参数是父类的引用，实际传入的参数是子类对象）作者: 冯盼 时间: 2012-11-29 10:12
多态:可以理解为实物存在的多种体现形态。
(貌似多态就是事物子类或是下级的细分，可以分出多种种类，看起来就是它的多种形态)。
函数的重载与覆盖也是多态。
1.多态的体现
a.父类引用指向子类对象。
b.父类的引用也可以接收自己的子类对象。
2.多态的前提
必须是类与类之间有父子关系（继承或是实现）。
父类引用指向子类对象，但在使用子类对象方法功能时，必须是自己中也有该方法（功能）的定义。
3.多态的好处
a.多态的出现大大的提高了程序的扩展性。
4.多态的弊端
提高了扩展性，但是只能使用父类的引用访问父类中已有的成员。作者: 孙玉伟 时间: 2012-11-29 11:49
这里我说下：1.朋友多态性并不是java独有，而是所有oop都具有的特性。
2.oop的另外2个特性是封装和继承
下面我来浅谈下3大基本特征：
封装表现为对对象的属性用private进行修饰，使其对外部不可见，而只是通过setter和getter方法来对其进行操作。
继承的主要的功能是用于扩展父类的功能。
多态是面向对象语言中最重要的，掌握了多态，有助于理解各种设计模式。方法的重载和覆盖都体现了多态的性质，这都比较好理解，也就没必要做过多记录了。面向对象的多态性的另一块体现就是对象的多态，就自身而言，感觉掌握好了对象的多态，程序的很多结构都能理解和把握了。
对象的多态分为向上转型和向下转型两种，子类对象向父类对象转换，为向上转型；父类对象向子类对象转换，为向下转型。向上转型为自动转型（父类对象=子类对象），向下转型为强制转型（子类对象=（子类对象）父类对象）。
以下为一个初步描述面向对象的封装、继承与对象的多态性的例子：
package com.mytest.test;
abstract class Person{
//对抽象类Person类中的属性进行封装
private String name;
private int age;
public Person(String name,int age){
this.setName(name);
this.setAge(age);
}
//定义操作Person属性的getter和setter方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void walk();
public String say(){
System.out.println("父类say()方法。。。");
return "姓名："+this.name+"，年龄："+this.age;
}
}
class Student extends Person{
//对score进行封装
private int score;
public Student(String name,int age,int score){
super(name,age);
this.setScore(score);
}
//操作score属性的getter和setter方法
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public void walk(){
System.out.println("此方法覆盖了父类的抽象方法。。。");
}
public String say(){
System.out.println("子类say()方法。。。");
//通过super调用父类的say()方法
return super.say()+"，数学分数："+this.score;
}
public void test(){
System.out.println("在子类中定义的一个父类中没有的方法");
}
}
public class Test {
public static void main(String[] args){
Person p=new Student("赵六",18,90);//此为对象的向上转型
//test()方法对p不可见，即p无法调用test()方法
p.walk();
//p调用的是覆写过后的say()方法，即子类中的say()方法
System.out.println(p.say());
// Student s=(Student)p;//此为对象的向下转型
}
}
希望能帮助你！作者: 陈山 时间: 2012-11-29 17:52
多态是指某一事物有不同的具体的体现。
多态的好处是可以提高程序的扩展性。
多态的前提：
1：必须要有关系，比如继承、或者实现。
2：通常会有覆盖操作。
多态中成员的特点：
Fu f = new Zi();
1：成员变量：编译和运行都看Fu。
2：非静态方法：编译看Fu，运行看Zi。
3：静态方法：编译和运行都看Fu。
具体实例看楼上