java编程思想复用,多态,以及设计模式-多态

原创 2013年07月14日 22:51:39

多态是面向对象的编程语言中非常重要的一种特性,通过分离做什么和怎样做,可以把接口和实现分离开来。多态是通过向上转型实现的,而即使向上转型了还仍然可以正确调用子类的方法,这就是动态绑定,又叫后期绑定这种特性实现的。

下面,我分别举普通类,接口,内部类来说明多态。

普通类

class Instrument {
  void play(Note n) { print("Instrument.play() " + n); }
  String what() { return "Instrument"; }
  void adjust() { print("Adjusting Instrument"); }
}

class Wind extends Instrument {
  void play(Note n) { print("Wind.play() " + n); }
  String what() { return "Wind"; }
  void adjust() { print("Adjusting Wind"); }
}	

class Percussion extends Instrument {
  void play(Note n) { print("Percussion.play() " + n); }
  String what() { return "Percussion"; }
  void adjust() { print("Adjusting Percussion"); }
}



public class Music3 {
  public static void tune(Instrument i) {
    i.play(Note.MIDDLE_C);
  }
  public static void main(String[] args) {
    Instrument[] orchestra = {
      new Wind(),
      new Percussion()
    };
    for(Instrument i:orchestra)
	tune(i);
  }
} /* Output:
Wind.play() MIDDLE_C
Percussion.play() MIDDLE_C

这个例子可就体现出了多态的好处,可以后期添加新的类,进行扩展,而无需修改已有的调用方法,这就把需要改变的和不变的分开了,这就是多态的好处。

接口和抽象类:

接口和抽象类为多态提供了一种更加结构化的方法。接口和抽象类的区别,就是抽象类并不是纯接口,它可以实现方法。我就举个接口的例子吧。

interface Instrument {
 
  void play(Note n); // Automatically public
  void adjust();
}

class Wind implements Instrument {
  public void play(Note n) {
    print(this + ".play() " + n);
  }
  public String toString() { return "Wind"; }
  public void adjust() { print(this + ".adjust()"); }
}

class Percussion implements Instrument {
  public void play(Note n) {
    print(this + ".play() " + n);
  }
  public String toString() { return "Percussion"; }
  public void adjust() { print(this + ".adjust()"); }
}

class Brass extends Wind {
  public String toString() { return "Brass"; }
}	

class Woodwind extends Wind {
  public String toString() { return "Woodwind"; }
}

public class Music5 {
  
  static void tune(Instrument i) {
   
    i.play(Note.MIDDLE_C);
  }
  static void tuneAll(Instrument[] e) {
    for(Instrument i : e)
      tune(i);
  }	
  public static void main(String[] args) {
    // Upcasting during addition to the array:
    Instrument[] orchestra = {
      new Wind(),
      new Percussion(),
      new Brass(),
      new Woodwind()
    };
    tuneAll(orchestra);
  }
} /* Output:
Wind.play() MIDDLE_C
Percussion.play() MIDDLE_C
Stringed.play() MIDDLE_C
Brass.play() MIDDLE_C
Woodwind.play() MIDDLE_C

这个例子就看出接口的好处了,要调用这个方法,只要实现了这个接口即可,而如果用普通的类则必须继承,可见还是实现接口比比较方便。

这里还涉及到一种设计方式,可以完全解耦合,这个将放在设计模式里面讲。通过这种设计模式,你就会知道通过接口可以完全解耦合。

内部类:

内部类重要的特性且我们平常能过用到的就是,能够实现多重继承,你也许会说接口也能实现多重继承,但如果要继承的是2个类呢,那恐怕不行了吧,可内部类就可以。

当用内部类实现了多重继承时,你就可以多态地转换为多种类型了。看代码:

interface A {}
interface B {}

class X implements A, B {}

class Y implements A {
  B makeB() {
    // Anonymous inner class:
    return new B() {};
  }
}

public class MultiInterfaces {
  static void takesA(A a) {}
  static void takesB(B b) {}
  public static void main(String[] args) {
    X x = new X();
    Y y = new Y();
    takesA(x);
    takesA(y);
    takesB(x);
    takesB(y.makeB());
  }
} 

看这就是内部类的强大,当然如果你不需要多重继承的话,当然可以用到其它代码来实现。

总结:接口和内部类结合起来,就可以解决C++中多重继承所能解决的问题,而且容易理解的多。

多态机制,其实是设计阶段考虑的问题,到底该用什么样的设计方式,用接口还是内部类的,得看实际情况,随着编程经验的增加,到底用什么样的实现方式会有更深的理解。

欢迎评论,欢迎讨论。





java编程思想复用,多态,以及设计模式-复用篇

最近,在看java编程思想,觉得这的确是一本难得的好书。目前已经看到了第12章异常,个人觉得本书的最精华部分是讲述了,类的复用,多态以及几种常见的设计模式(这些其实就是面向的对象的编程思想),所以我就...
  • zbh24
  • zbh24
  • 2013年07月14日 11:25
  • 473

设计模式之三:工厂方法模式—多态工厂的实现

简单工厂的严重问题: 当系统中需要引进新产品时,静态工厂方法通过所传入参数的不同来创建不同的产品,这必定要修改工厂类的源代码,违背了开闭原则 引入工厂方法模式: 针对不同的产品提供不...
  • wujunwen
  • wujunwen
  • 2016年09月22日 15:25
  • 693

Java设计模式(五) 多态的极致应用——组合模式

本文介绍了组合模式的概念,UML类图,优缺点,实例讲解以及组合模式(未)遵循的OOP原则。...
  • Habren
  • Habren
  • 2016年06月08日 07:25
  • 1603

Java编程思想(五) —— 多态(下)

Java编程思想(五) —— 多态(下)
  • iaiti
  • iaiti
  • 2014年08月26日 10:07
  • 2564

设计模式_Java多态,继承,封装

何为多态分为**运行时多态**和**设计时多态**。 运行时多态是指
  • yi_master
  • yi_master
  • 2016年06月12日 14:52
  • 288

C++中 多态 重载 覆盖

面向对象的三大特征: 1.封装:保证对象自身数据的完整性、安全性 2.继承:建立类之间的关系,实现代码复用、方便系统的扩展 3.多态:相同的方法调用可实现不同的实现方式。多态是指两个...
  • jixianghahaxiao
  • jixianghahaxiao
  • 2015年05月11日 16:01
  • 1202

《编程导论(Java)·2.1.2 啊,我看到了多态》-什么是多态(polymorphism)

杀猪杀屁股,各有各的刀法
  • yqj2065
  • yqj2065
  • 2014年07月02日 11:12
  • 2989

里氏替换原则就已经说明了多态的精髓“子类对象可以替换父类对象的位置,而程序的功能不受影响

http://www.cnblogs.com/qq731109249/p/3542200.html
  • Baple
  • Baple
  • 2014年03月20日 07:41
  • 957

继承多态与虚函数及对类的理解

B是A的子类,子类会继承父类的public方法,子类对象可以调用父类的public接口,但是子类和父类函数重名时,父类的方法会被子类覆盖(隐藏),子类调用和父类同名同参函数或者重载父类的函数后不可以直...
  • qq_35956442
  • qq_35956442
  • 2016年11月17日 13:41
  • 379

C++的多态与虚函数

多态的作用:继承是子类使用父类的方法,而多态则是父类使用子类的方法。 在C++中,多态有两种,一种是函数重载,一种是虚函数。函数重载发生在编译的时候,它的函数参是不一样的。而虚函数是发生在运行的时候,...
  • chencheng126
  • chencheng126
  • 2015年01月06日 21:49
  • 1729
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java编程思想复用,多态,以及设计模式-多态
举报原因:
原因补充:

(最多只允许输入30个字)