Java-重载、重写（冷静分析）

一、方法的重载

　　重载就是根据不同的数据类型，自动匹配对应的方法。重载在编译的时候就决定调用哪个方法了，和重写不一样。（常见，构造函数重载）。

 

举个栗子：

1、基本数据类型的重载：

 

/**
 * @author 薛定谔的猫
 * 基本数据类型的重载
 * */
public class Main {
    
    static void methed( byte b) {
        System.out.println("byte:method");
    }
    
    static void method(double d) {
        System.out.println("double:method");
    }
    
    static void method(int i) {
        System.out.println("int:method");
    }
    
    static void method(String s) {
        System.out.println("String:method");
    }
    
    public static void main(String[] args) {
        methed((byte)1);
        method(2.0);
        method(1);
        method("zpoor");
    }
}

/*
 * 结果：
 *         byte:method
 *        double:method
 *        int:method
 *        String:method
*/

 

 

 

2、带对象引用参数的重载

 

/**
 * @author 薛定谔的猫
 * 带有对象引用参数的重载*/
class Animal {
    
}

class Pig extends Test{
    
}

class Test {
    static void method(Test a) {
        System.out.println("Animal");
    }
    
    static void method(Pig p) {
        System.out.println("Pig");
    }
    
    public static void main(String[] args) {
        Test a = new Test();
        Pig p = new Pig();
        Test b = new Pig();
        
        method(a);
        method(p);
        method(b);//为啥不是Pig，而是Animal
        /*
         * 盲目分析：看的是引用类型而不是对象类型，重载在编译时候就决定了，
         *             引用类型决定了哪个重载方法。
         * */
        
    }
}

/**
 * 结果：
 *     Animal
    Pig
    Animal
*/

 

 

 

总结：重载的规则

1、重载的方法必须改变参数列表，参数必须不同（参数的个数，参数的类型，参数的顺序）

2、被重载的方法与返回值没有关系，不是通过返回值类型来判断方法是不是重载了。

3、重载的方法可以改变访问修饰符。

4、重载的方法可以声明新的或者更广的建厂异常。

5、方法能够在一个类或者一个子类中被重载。

 

二、方法的重写

 

重写只能出现在继承关系中，只要父类的方法不是final修饰的，都可以重写父类的方法。重写的有点：能够定义某个子类特有的特征。

 

举个栗子：

 

 

/**
 * @author 薛定谔的猫
 * 重载例子*/
class Animal {
    public void eat() {
        System.out.println("吃点东西");
    } 
}

class Horse extends Animal {
    public void eat() {
        System.out.println("吃点草");//实现重载
        }
}

 

 

 

对于父类继承的抽象方法，要么子类是重写该方法，要么把子类也设为抽象子类。所以抽象方法可以说是必须重写的方法。

 

重写的意义：

　　重写可以实现多态，用父类的引用来指向子类对象。

 

举个栗子：

 

/**
 * @author 薛定谔的猫
 * 重写例子*/
public class Test {
    public static void main(String[] args) {
        Animal p = new Pig();
        p.eat();
    }
}


class Animal {
    public void eat() {
        System.out.println("吃点东西吧");
    }
}

class Pig extends Animal {
    public void eat() {
        System.out.println("吃点猪食beautiful");
    }
}

 

 

重载原则：（盲目分析）：

　　使用了什么引用，编译器只会调用引用类所拥有的方法。如果调用子类特有的方法就会报错。也就是说，编译器只看引用；类型，不看对象类型。

 

 

重写方法的规则：

1、重写方法不能比被重写方法限制有更要个的访问限权。（但是可以更加宽泛，父类是包访问，子类的重写方法可以使public访问权限，特别留意toSting()）

2、参数列表必须与被重写的方法相同（重写和重载的区别）

3、重写返回类型必须与被重写方法的返回类型相同

4、重写方法不能抛出新的异常，或者比被重载方法声明的检查异常更广的检查异常。但是可以抛出更少，更有限或者不抛出异常

5、final修饰的方法不能被重写

6、一个方法不能被继承，则不能重写他（比如被final修饰的类的方法，还有就是父类的private修饰的方法）

 

好了盲目分析完了，写点代码压压惊。