java中的多态关系的运用

1、多态发生的三个必备条件

　　继承、重写、父类引用指向子类对象

2、注意

　　当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

　　方法的重写，也就是子类能够重写父类的方法

　　当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。要想调用父类中被重写的方法，则必须使用关键字super。

3、好处

　　可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

4、例子

 //父类

 package com.test.five;

 public class Parent {

     public void Test(){

         System.out.println("我 是 父类");

     }

 }

 //子类一

 package com.test.five;

 public class Child extends Parent {

     public void Test(){

         System.out.println("我 是大儿子");

     }

     public void Sex(){

         System.out.println("我 是个男的");

     }

 }

 //子类二

 package com.test.five;

 public class Sister extends Parent{

     public void Test(){

         System.out.println("我也是个子类");

     }

     public void Sex(){

         System.out.println("我是个女儿");

     }

 }

 //测试类

     package com.test.five;

 public class Test {

     public static void main(String[] args) {

         Parent p = new Child();

         p.Test();//父类声明，子类创建，调用该对象的方法(子类父同时所拥有的方法)

         Show(p);

         Show(new Sister());

         Show(new Child());

     }

     //测试类中的静态类方法，在测试类中可以直接调用此方法（不用再实例化类的对象）

     public static void Show(Parent p){

         p.Test();

         if( p instanceof Child){

             Child c = (Child)p;

             c.Sex();

         }else if(p instanceof Sister){

             Sister s = (Sister)p;

             s.Sex();

         }

     }

 }

得出的结果是：

我 是大儿子

我 是大儿子

我 是个男的

我也是个子类

我是个女儿

我 是大儿子

我 是个男的

　5、注意（例子）

 //父类

 package com.test.six;

 public class Emploee {

     private String name;

     private String address;

     private int num;

     public Emploee(String name,String address,int num){

         System.out.println("Emploee的构造函数");

         this.name = name;

         this.address = address;

         this.num = num;

     }

     public void check(){

         System.out.println("Emploee中check的name:"+this.name+" ，address =  "+this.address);

     }

     public String toString(){

         return name+"  "+address+"  "+num;

     }

     public String getName() {

         return name;

     }

     public void setName(String name) {

         this.name = name;

     }

     public String getAddress() {

         return address;

     }

     public void setAddress(String address) {

         this.address = address;

     }

     public int getNum() {

         return num;

     }

 }

 //子类

 package com.test.six;

 public class Salary extends Emploee {

     private double salary;

     //构造函数

     public Salary(String name, String address, int num,double salary) {

         super(name, address, num);

         System.out.println("salary的构造函数");

         setSalary(salary);

     }

     public double getSalary() {

         return salary;

     }

     public void setSalary(double salary) {

         if(salary >=0.0){

             this.salary = salary;

         }

     }

     public void check(){

         System.out.println("这是salary的check的方法");

         System.out.println("Salary中的name="+getName()+"  薪资="+getSalary());

     }

      public double computePay() {

           System.out.println("计算工资，付给：" + getName());

           return salary/52;

        }

 }

 //测试类

 package com.test.six;

 public class Test {

     public static void main(String[] args) {

         Salary s = new Salary("张三", "北京", 3, 8000.0);

         Emploee e = new Salary("李四", "上海", 5, 10000.0);

         System.out.println("salary对象引用中的方法调用");

         s.check();

         s.computePay();

         System.out.println("emploee对象引用中的方法调用");

         e.check();

     }

 }

得到的结果如下：

 Emploee的构造函数

 salary的构造函数

 Emploee的构造函数

 salary的构造函数

 salary对象引用中的方法调用

 这是salary的check的方法

 Salary中的name=张三  薪资=8000.0

 计算工资，付给：张三

 emploee对象引用中的方法调用

 这是salary的check的方法

 Salary中的name=李四  薪资=10000.0

----一旦实例化一个对象，其执行顺序，首先：

在不涉及继承的前提下，当首次加载类时，按照如下顺序执行：
1、按照出现顺序先后执行静态成员变量定义与静态块；
2、按照出现顺序先后执行动态成员变量定义与动态块；
3、执行构造函数；
4、再次实例化对象时只执行第2、4步即可；

在涉及到继承时，按照如下顺序执行：
1、执行父类的静态成员变量定义与静态块，执行子类的静态成员变量与静态块
2、执行父类非静态成员变量定义与动态块，执行父类构造方法；
3、执行子类的非静态成员变量定义与动态块，执行子类构造方法；
注意：父类构造方法中用到的方法如果已被子类重写，那么在构造子类对象时在
调用父类构造函数中使用子类重写的方法。

例子一：

package com.test.seven;

public class TestOne {

    private static TestOne t1 = new TestOne();

    //静态变量

    private static int i1;

    private static int i2 = 2;

    public TestOne(){

        i1++;

        i2++;

    }

    public static void main(String[] args) {

        TestOne t2 = new TestOne();

        System.out.println("t2.i1 = " +t2.i1);

        System.out.println("t2.i2 = "+t2.i2);

    }

}

得到的结果如下：

t2.i1 = 2
t2.i2 = 3

执行过程：

　　首先执行给t1、i1、i2分别给予初始值null,0,0,在执行TestOne t1 = new TestOne()；
这样子i1++,i2++被执行，i1，i2都变成1，执行完毕后接着执行int i1 ， i1,i2的值仍然是1，1，当执行int i2=2时，i2被赋予了值，即i1=1，i2=2；再执行
TestOne t2 = new TestOne()，i1，i2在执行++，此时i1=2，i2=3，输出i1，i2，结果就是：t2.i1=2,t2.i2=3通过上面代码可以知道：
系统默认的给予比通过等号的赋予先执行。

例子二：

package com.test.seven;

public class TestOne {

    private static TestOne t1 = new TestOne();

    //静态变量

    private static int i1;

    private static int i2 = 2;

    //静态块

    static{

        System.out.println("静态块");

    }

    //动态块

    {

        System.out.println("动态块");

    }

    public TestOne(){

        i1++;

        System.out.println("i1--------------"+i1);

        i2++;

        System.out.println("i2--------------"+i2);

    }

    public static void main(String[] args) {

        TestOne t2 = new TestOne();

        System.out.println("t2.i1 = " +t2.i1);

        System.out.println("t2.i2 = "+t2.i2);

    }

}

得到的结果如下：

 动态块

 i1--------------1

 i2--------------1

 静态块

 动态块

 i1--------------2

 i2--------------3

 t2.i1 = 2

 t2.i2 = 3

巴特西

java中的多态关系的运用

最新文章

热门文章