转载

java编程思想 -- 多态

一 : 向上转型和向下转型

面向对象中的转型只会发生在有继承关系的子类和父类中（接口的实现也包括在这里）。
父类：人子类：男人
向上转型： Person p = new Man() ; // 向上转型不需要强制类型转化
向下转型： Man man = (Man)new Person() ; // 必须强制类型转化

向上转型子类创建对象时 , 可以使用向上转型的形式操作 , 方法程序的后期维护 , List 队列也是使用的向上转型

package com.wj.interfaceDemo;  /**  *向上转型  */  class People{ //定义一个基类:三个属性和打印属性的方法  String name ="java",sex="android";//名字和性别  int age=15;//年龄  //打印输出  public void getAll(){   System.out.println("name:"+name+"  sex:"+sex+"  age:"+age);  }   }   //子类继承基类  public class Man extends People{   //主方法  public static void main(String[] args) {   //向上转型     Man p = new Man();   //调用父类的方法   p.getAll();  } }

运行结果 :

name:java sex:android age:15

2)  , 向下转型

子类必须强制的转型为父类的数据类型

向下转型： Man man = (Man)new Person() ; // 必须强制类型转化

向上转型子类不需要强制转型为父类的数据类型

向下转型不要使用一下的方式

A demo =(A) new ManDemo();

demo.getName() ;

/**  * 向下转型  */   class ManDemo {  String name = "android";   public void getName() {   System.out.println(name);  } }  //A类继承ManDemo class A extends ManDemo {  }  public class PeopleDemo {  public static void main(String[] args) {   // 向下转型   // cannot convert from ManDemo to PeopleDemo   // 必须要向上转型,ManDemo不可以转为PeopleDemo   // PeopleDemo p=new ManDemo();   // 向下转型必须要是子类才可以转型   ManDemo demo = new A();   // 将父类转为子类   A a = (A) demo;   // 调用父类的方法   a.getName();    // *************第二种转型   ManDemo demos = new A();   //使用instanceof控制类型,防止类型不一样的情况   if(demos instanceof A){    //转为A   A aa = (A) demos;         aa.getName();   }  } }

运行结果 ;

android

二 : 多态 : 允许不同类的对象对同一消息做出处理

package com.wj.interfaceDemo;  //*多态  public class Shape {  public static void main(String[] args) {   // 创建对象时使用的是多态   ShapeMain s = new ShapeMain();   s = new Circle();   // 此时的s.draw()调用的是父类还是子类的方法   s.draw();  }  }  // 基类 class ShapeMain {  // 基类定义方法  public void draw() {   System.out.println("ShapeMain");  }; }  // Circle继承基类 class Circle extends ShapeMain {  @Override  // 重写基类基类的方法  public void draw() {   System.out.println("Circle");  }; }

运行结果 :

Circle

三;多态的缺陷缺陷

1)  . 不能 “ 覆盖 ” 私有方法

package com.wj.interfaceDemo;  //覆盖私有的方法  public class PrivateOverride {   private void f() {   System.out.println("private f()");  }   public static void main(String[] args) {   创建   PrivateOverride p = new Derived();   p.f();//调用f()方法  } }  class Derived extends PrivateOverride {  public void f() {   System.out.println("public f()");  } }

运行结果 :

P rivate f()

从前面写的程序中一眼就看出执行的结果是 :public f(), 但是多态中是不能够覆盖私有方法如果存在私有的方法就睡直接在前面加上 final 执行结果为 private f() , 只有非 private 的方法才可以被覆盖这是多态的缺陷之一

2)  缺陷 : 不能覆盖域与静态方法

What is a field in java?

A field is an attribute. A field may be a class's variable, an object's variable, an object's method's variable, or a parameter of a function.

package com.wj.interfaceDemo;  class Super{  public int field=0;  public int getField(){   return field;   } }   class Sub extends Super{  public int field=1;  public int getField(){   return field;   }    public int getSuperField(){   //调用父类的Field   return super.field;     } }  public class FieldAccess {   public static void main(String[] args) {   //创建对象    Super sup=new Sub();   System.out.println("sup.field ="+sup.field+"  sup.getField()="+sup.getField());     //创建对象   Sub sub = new Sub();     System.out.println("sub.field ="+sub.field+"  sub.getField()="+sub.getField()+" sub.getSuperField() ="+sub.getSuperField());   } }

sup.field =0 sup.getField()=1

sub.field =1 sub.getField()=1 sub.getSuperField() =0

3), 不能覆盖静态属性和方法

package com.wj.interfaceDemo; /*  * 多态性不能覆盖静态方法  */  class StaticSuper{  //静态属性  public static String getName(){   return "java";  }    public String getSex(){   return "男";  }  //静态方法  static int age=10; }  class StaticSub extends StaticSuper{  //静态方法  public static String getName(){   return "android";  }    public String getSex(){   return "女";  }  //静态属性  static int age=7; }  public class StaticField {   public static void main(String[] args) {   //静态属性在多态性中是不能被覆盖的   StaticSuper s=new StaticSub();   System.out.println(s.getName());   System.out.println(s.getSex());   System.out.println(s.age);  } }

运行结果 :

java

女

四 : 构造器的执行顺序

构造器是不同于其它种类的方法 , 涉及到多态时也是如此 , 构造器是不具有多态性的 , 通过 static 方法 ,static 为隐式的

package com.wj.interfaceDemo;  /*构造器的调用顺序  */  class Construct1 {  public Construct1() {   print();  }   private int print() {   System.out.println("Construct1");   return 1;  } }  class Construct2 extends Construct1 {  public Construct2() {   print();  }   private int print() {   System.out.println("Construct2");   return 2;   } }  class Construct3 extends Construct2 {  public Construct3() {   print();  }   private int print() {   System.out.println("Construct3");   return 3;  } }  public class Construct {  public static void main(String[] args) {  Construct1 c = new Construct3();  }  }

运行结果 :

Construct1

Construct2

Construct3

五:用继承进行设计

package com.wj.interfaceDemo;  /**  * 用继承设计  */  class Actor {  public void act() {  } }  class HappyActor extends Actor {  public void act() {   System.out.println("HappyActor");  } }  class SadActor extends Actor {  public void act() {   System.out.println("SadActor");  } }  class Stage {  private Actor actor = new HappyActor();   public void change() {   actor = new SadActor();  }   public void performplay() {   actor.act();  } }  public class ExtendsDesign {  public static void main(String[] args) {   Stage stage = new Stage();   stage.performplay();   stage.change();   stage.performplay();  } }