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

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

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

普通类

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++中多重继承所能解决的问题,而且容易理解的多。

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

欢迎评论,欢迎讨论。





阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页