java中重写

1、重写【针对父类与子类而言】---------即java的多态性【子类与父类间有相同的名称和参数，此方法就被重写Overriding；又称：方法覆盖】

　子类对父类的允许访问的方法的实现过程进行重新编写！返回值和形参都不能改变。即外壳不变，核心重写！

　重写的好处在于子类可以根据需要，定义特定于自己的行为。

　　例如1：

package com.test.two;

//父类
public class Animal {

    public void move(){
        System.out.println("动物可以叫");
    }
}

package com.test.two;

//子类继承父类
public class Dog extends Animal{
    public void bark(){
        System.out.println("狗可以叫");
    }
    public void move(){
        System.out.println("狗可以移动");
    }
}

package com.test.two;

public class DogTest {
    public static void main(String[] args) {
        Animal a = new Animal();//父类声明对象
        Animal b = new Dog();//父类声明，子类创建
        Dog c = new Dog();//子类声明，子类创建
        a.move();
        b.move();//执行的是子类中与父类共有的方法
//        b.bark();--->The method bark() is undefined for the type Animal
        c.move();
        c.bark();

    }
}

运行结果是：

动物可以叫
狗可以移动
狗可以移动
狗可以叫

结论：【子类可以由父类声明，也可以由子类声明】，父类声明子类创建的对象，执行的方法只能是俩者共有的方法（输出的结果是：子类重写的方法内容）；由子类声明子类创建的对象，里面的方法都可以被执行到。

其执行的先后顺序如下：

　　

 package com.extend.test;

 //父类
 public class Father {
     private String name = "father";

     public Father(){
         testOne();
         testTwo();
     }

     public void testOne(){
         System.out.println("Father testOne : "+ name);
     }

     public void testTwo(){
         System.out.println("Father testTwo : "+ name);
     }
     public static void main(String[] args) {
         new Father();
     }
 }    

 package com.extend.test;

 //子类继承父类
 public class Son extends Father {
     private String son = "son";

     public Son(){
         testOne();
         testTwo();
     }

     public void testOne(){
         System.out.println("Son testOne : "+son);
     }

     public void testTwo(){
         System.out.println("Son testTwo : "+son);
     }

     public static void main(String[] args) {
         new Son();
     }
 }

　　运行子类java代码，输出结果是：

Son testOne : null
Son testTwo : null
Son testOne : son
Son testTwo : son

　先执行子类的main主函数，然后执行父类的无参构造函数，然后是子类的无参构造函数（子类重写了父类的方法），直接输出子类的方法中语句，