A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 罗忠文 中级黑马   /  2012-11-25 15:42  /  2540 人查看  /  8 人回复  /   1 人收藏 转载请遵从CC协议 禁止商业使用本文

java的多态性太难理解了能不能详细的解释下

8 个回复

倒序浏览
多态是指在执行期间(——而非编译期间——)判断所引用的对象的实际类型,并且根据其实际类型调用他的相应方法。多态的存在使程序的扩展性达到了最好的层次。要实现多态必须具备3个条件:1.要有继承2.要有重写3.要有父类引用指向子类对象,三个条件缺一不可!我也是新手举个可能不太合适的小例子:有一个Animal类其中有一个enjoy()方法,他有若干子类比如Cat、Dog(都重写了enjoy方法)...还有一个Person类,有一个构造方法:Person(string name,Animal animal),还定义了一个方法petenjoy() {animal.enjoy()},在这个构造方法中,我们不必仅仅只能传Animal类型的参数,我们也可以传他的子类,并且假如当我们new Person("Miss Li”,new Dog dog()),并调用petenjoy方法时,会自动的调用dog的enjoy方法。总之,多态是为了增强程序的扩展性。说的可能不清楚,但是希望能对你有帮助。

评分

参与人数 1技术分 +1 收起 理由
古银平 + 1 神马都是浮云

查看全部评分

回复 使用道具 举报
多态是对不同对象,产生不同处理。
多态体现多种多样,函数重载,传入不同参数,调用不同函数。
模板函数,模板类,模板接口,可以处理传入限定的不同类型对象。
覆盖:同一函数,子类处理不同于父类。
还有接口,虚基类,同一函数,在不同的子类中,有不同实现方式。

评分

参与人数 1技术分 +1 收起 理由
古银平 + 1 神马都是浮云

查看全部评分

回复 使用道具 举报
package 案例;

public class Test{

        /**
         * @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("旺旺叫!!!");
        }
}

看个代码会比较好理解吧

评分

参与人数 1技术分 +1 收起 理由
杨千里 + 1

查看全部评分

回复 使用道具 举报
多态的定义:将参数定义为一个父类,各子类中都重写了父类的方法,在方法中用传入的父类对象调用这个方法,当传入什么子类时就会调用相应的各子类的方法。
多态存在的条件:有继承,有重写,父类引用指向子类对象。一旦满足,当父类里被重写的方法时,实际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的构造方法中
//参数是父类的引用,实际传入的参数是子类对象)

评分

参与人数 1技术分 +1 收起 理由
杨千里 + 1

查看全部评分

回复 使用道具 举报
多态:可以理解为实物存在的多种体现形态。
  (貌似多态就是事物子类或是下级的细分,可以分出多种种类,看起来就是它的多种形态)。
  函数的重载与覆盖也是多态。
  
  1.多态的体现
   a.父类引用指向子类对象。
   b.父类的引用也可以接收自己的子类对象。
  2.多态的前提
   必须是类与类之间有父子关系(继承或是实现)。
   父类引用指向子类对象,但在使用子类对象方法功能时,必须是自己中也有该方法(功能)的定义。
  3.多态的好处
   a.多态的出现大大的提高了程序的扩展性。
  4.多态的弊端
   提高了扩展性,但是只能使用父类的引用访问父类中已有的成员。

评分

参与人数 1技术分 +1 收起 理由
冯海霞 + 1

查看全部评分

回复 使用道具 举报
孙玉伟 黑马帝 2012-11-29 11:49:16
7#
这里我说下: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;//此为对象的向下转型
    }
}

希望能帮助你!

评分

参与人数 1技术分 +1 收起 理由
冯海霞 + 1

查看全部评分

回复 使用道具 举报
陈山 中级黑马 2012-11-29 17:52:14
8#
多态是指某一事物有不同的具体的体现。
多态的好处是可以提高程序的扩展性。
多态的前提:       
           1:必须要有关系,比如继承、或者实现。
        2:通常会有覆盖操作。
多态中成员的特点:
                Fu f = new Zi();
                1:成员变量:编译和运行都看Fu。
                2:非静态方法:编译看Fu,运行看Zi。
                3:静态方法:编译和运行都看Fu。
具体实例看楼上

回复 使用道具 举报

java中的多态,可以总结它为:

    一、使用父类类型的引用指向子类的对象;

    二、该引用只能调用父类中定义的方法和变量;

    三、如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,将会调用子类中的这个方法;(动态连接、动态调用)

    四、变量不能被重写(覆盖),”重写“的概念只针对方法。
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马