面向对象——方法重载与重写

1.概念

类的共同行为，封装了一段逻辑代码。
在封装方法时，一个方法尽可能只完成一项功能
避免将多个功能封装到一个方法内

2.方法的定义

1)语法格式：
    修饰词  返回值类型 方法名（有参传参）{
        逻辑代码
    }

2)方法的位置
    在类体里，与mian方法并列。
    一个类中，可以有多个方法。

    // 修饰词 返回值类型 方法名  形式参数
        public  void   sum (int a,int b) {
        //逻辑代码
        int c = a;
        int d = b*c;
        int sum = c+d;
        System.out.println("sum:"+sum);
    }

3.方法的重载（overload）

1）定义
    在同一个类型中，方法名相同，参数列表不同

2）方法签名：
    方法名+形参列表
    形参列表:指的是形参的类型顺序列表

   如：public void  sum(int a,int b)  
       方法签名是：  sum + int,int   

public class Calcultor {
    //方法签名为：sum + int,int
    public void sum(int a,int b) {
        System.out.println(a+b);
    }
    //方法签名为：sum + int,int,int
    public void sum(int a,int b,int c) {
        System.out.println(a+b+c);
    }
}

4.方法的重写（override）

1）定义：
    在继承时，子类可以重新编写与父类中方法名相同，参数列表相同的方法
2）规则：
    (1)父子类关系，方法名相同，参数列表相同
    (2)返回值类型可以相同，也可以不同。
       不同的话，子类方法的返回值类型必须是父类方法的返回值类型的子类
    (3)修饰词可以不变，或者可以比父类的修饰权限更大

public class Person {
    String name;
    int age;
    char gender;
    public Person(String name,int age,char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    public void eat(String food) {
        System.out.println(name+"喜欢吃"+food);
    }
    public void sleep() {
        System.out.println("Person类中的行为");
    }
}

/**
 * Student是Person的子类
 */
public class Student extends Person{
    int score;
    public Student(String name,int age,char gender,int score) {
        super(name,age,gender);
        this.score = score;
    }
    //对父类的sleep()方法进行重写
    public void sleep() {
        System.out.println("Student类中的行为");
    }
    //子类独有的方法
    public void study() {
        System.out.println("非常喜欢学习");
    }
}

5.方法的使用

方法属于对象的行为

没有static修饰的方法，必须使用：引用.方法（有参传参）
这些方法是动态绑定到对象上的

在方法调用时，编译器会检查类的信息中是否有此方法签名的方法

public class Calcultor {
    /**计算两个数的和*/
    public void sum(int a,int b) {
        System.out.println(a+b);
    }
    public void sum(int a,int b,int c) {
        System.out.println(a+b+c);
    }
    /**使用重载方式：计算四个整数a,b,c,d的和*/
    public void sum(int a,int b,int c,int d) {
        System.out.println(a+b+c+d);
    }

    public void sum(double a,long b) {
        System.out.println(a+b);
    }

    public static void main(String[] args) {
        //创建计算器对象
        Calcultor cal = new Calcultor();
        //计算3和5的和
        cal.sum(3, 5);

        /*编译器先检查，是否有sum(byte,byte)的方法
         * 没有，但是检查到有sum(int,int)符合，byte的自动转换，
         * 所以，编译通过
         * */
        byte a = 1;
        byte b = 4;
        cal.sum(a,b);

        /*编译器检查是否有sum(byte,long)
         * 没有，检查到了sum(double,long)*/
        byte m = 10;
        long n = 5;
        cal.sum(m, n);

        /*编译器检查sum(byte,short)是否存在
         * 不存在
         * 检查到了sum(int,int)符合要求
         * 不会再去检查
         * */
        byte p = 10;
        short q = 5;
        cal.sum(p, q);
    }
}