面向对象 -- 方法重写和方法重载，带上点抽象类

之前写多态的时候涉及到了关于方法重载的问题，现在就来写写方法的重写和重载。

啥也不说就是代码，就是这么任性

还是之前的Person类

public class Person {

    //属性封装
    protected String name;

    int age;

    protected double tall;

    protected double weight;

    public Person() {

    }

    //这是不是就是方法重载，我去真的是
    public Person(String name, int age, double tall, double weight) {
        this.name = name;
        this.age = age;
        this.tall = tall;
        this.weight = weight;
    }

    public Person setName(String name) {
        this.name = name;
        return this;
    }

    public void doing() {
    System.out.println("doing");
    }

    public String description() {
        return "This is a person";
    }
}

之后再上他的派生类，为啥要写派生类
重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

public abstract class Father extends Person {

    //别问我这个单词啥意思，自己查
    Object sperm;

    /**
     * 实际上这两个方法都是重写方法
     * 重写方法的要求是与父类的方法名和参数类型必须一致
     * 重载则要求方法名相同但是参数类型不一致
     * 这样重写的作用就是扩展子类的功能，
     * 当父类的功能不足以满足业务需求的时候就可以在子类中重新编写业务逻辑要求实现的代码
     * 那么如果我一抽筋又需要原先业务的方法了呢
     * 那就需要使用super关键字或者删掉这个方法（具体情况具体分析，但是super一定是安全的，通用的）
     */
    @Override
    public void doing() {
        System.out.println("Do what I can do.");
    }

    @Override
    public String description() {
        return "He is a father.";
    }

    public Object makeSex(Person obj) {
        if(sperm!=null)
            return new Object();
        else
            return null;
    }

    public abstract void fatherLove(Person son);
}

接下来开始测试：

Person p = new Father();//呵呵你是写不出来这句话的，因为本来就是错的

为什么要把Father设定成抽象类，实际上father有需要具体实现的逻辑，也有不能具体实现的逻辑。就像做爱的方式和结果都是一样的，但是父爱的方式和结果却天差地别。可能有的人会说那可以去实现接口啊，但是那样单独设置一个接口是不是会造成代码冗余。所以就需要一个介于父类和接口之间的东西 —— 抽象类。

好了我要正经的测试了：

//先写一个Father的派生类，实现他的抽象方法
public class MyFather extends Father {

    @Override
    public String description() {
        return "He is my father";
    }

    @Override
    public void educate(Person son) {
        String action = "打";
        System.out.println(action + son.name);
    }

}

-----------------------------------------------------------------

import org.junit.Test;

public class TestCase {

    @Test
    public void test() {

        Person person = new Person();

        //这样就写了一个匿名内部类，其实现在完全可以用lambda表达式代替了，
        //但是我还是写的简单易懂一些把
        Person father1 = new Father() {

            @Override
            public void educate(Person son) {
                String action = "打";
                System.out.println(action + son.name);
            }

        };

        MyFather father2 = new MyFather();

        System.out.println(person.description());
        System.out.println(father1.description());
        System.out.println(father2.description());

        father2.doing();
        /**
         * 大家可以看看这个的输出结果。你会知道一个很有意思的事情，
         * 他的答案是输出Father中的doing方法而不是Person中的，
         * 所以一定是先找到父类的方法，若没有才会继续向上查找
         */
        father1.doing();

        //你会发现你无法使用father1.educate(new Person().setName("张三")),
        //但是如果你把Person换成Father就可以调用了，这个之后再说
        father2.educate(new Person().setName("张三"));
    }
}

其实通过这个测试案例就可以知道，每次方法重写之后得到的结果都不一样，但是不重写的方法就会继承父类中实现的方法。但是翻过来如果是子类的引用指向父类的对象。。。可以想一想

好了关于重写就说这么多，接下来是重载，重载解释起来就比重写要简单多了。

概念：方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。调用重载方法时，Java编译器能通过检查调用的方法的参数类型和个数选择一个恰当的方法。

public class Overload {

     public void method(int a, int b) {}

     public void method(int a){}

     public void method(){}

     public void method(String str) {}

     //那可不可以让返回值不一样呢？可以，但是前提是他已经满足重载的条件
     //public int method() { return 1; }这样就不行，因为之前就有无参的method方法
     public int method(int a, int b, String str) {
         return a;
     }
}