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