Java基础复习-1-重载和重写

重载

在Java中，同一个类中的多个方法可以有相同的方法名称，但是有不同的参数列表，这就称为方法重载（method overloading）。重载是面向对象的一个基本特性。

参数列表又叫参数签名，包括参数的类型、参数的个数、参数的顺序，只要有一个不同就叫做参数列表不同。

public class Demo {
 
	//一个普通得方法，不带参数，无返回值
	public void add(){
		//method body
	}
	
	//重载上面的方法，并且带了一个整形参数，无返回值
	public void add(int a){
		//method body
	}
	
        //重载上面的方法，并且带了两个整型参数，返回值为int型
	public int add(int a,int b){
		//method body
		return 0;
	}
 
}

通过上面的例子，不难看出，重载就是在一个类中，有相同的函数名称，但形参不同的函。重载的结果，可以让一个程序段尽量减少代码和方法的种类。举例：// 在调用输出语句的时候，println方法其实就是进行了多种数据类型的重载形式。

说明：
参数列表不同包括：个数不同、顺序不同、类型不同。（仅仅参数变量名称不同是不可以的）跟成员方法一样，构造方法也可以重载。
声明为final的方法不能被重载。声明为static的方法不能被重载，但是能够被在此声明。

方法的重载和下列因素相关：
1、参数个数不同；
2、参数类型不同（个数相同时）；
3、方法的返回类型可以相同也可以不相同。仅仅返回类型不同不足以称为方法的重载；
4、仅仅参数名称不同是错误的

方法重载的实现：
方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错，这叫做重载分辨。

package cn.itcast.day04.demo04;

/*
题目要求：
比较两个数据是否相等。
参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，
并在main方法中进行测试。
 */
public class Demo02MethodOverloadSame {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        System.out.println(isSame(a, b));
        System.out.println(isSame((short) 20, (short) 20));
        System.out.println(isSame(11, 12));
        System.out.println(isSame(10L, 10L));
    }
    public static boolean isSame(byte a, byte b) {
        System.out.println("两个byte参数的方法执行！");
        boolean same;
        if (a == b) {
            same = true;
        } else {
            same = false;
        }
        return same;
    }
    public static boolean isSame(short a, short b) {
        System.out.println("两个short参数的方法执行！");
        boolean same = a == b ? true : false;
        return same;
    }
    public static boolean isSame(int a, int b) {
        System.out.println("两个int参数的方法执行！");
        return a == b;
    }
    public static boolean isSame(long a, long b) {
        System.out.println("两个long参数的方法执行！");
        if (a == b) {
            return true;
        } else {
            return false;
        }
    }
}

重写

重写发生在父类子类之间,比如所有类都是继承与Object类的,Object类中本身就有equals,hashcode,toString方法等.在任意子类中定义了重名和同样的参数列表就构成方法重写。重写（override）：一般都是表示子类和父类之间的关系，其主要的特征是：方法名相同，参数相同，但是具体的实现不同。

重写的特征：

（1）：方法名必须相同，返回值类型必须相同

（2）：参数列表必须相同

（3）：访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。

（4）：子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。

（5）：构造方法不能被重写，

简单而言：就是具体的实现类对于父类的该方法实现不满意，需要自己在写一个满足于自己要求的方法。

方法覆盖重写的注意事项：

1. 必须保证父子类之间方法的名称相同，参数列表也相同。
   @Override：写在方法前面，用来检测是不是有效的正确覆盖重写。这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。
2. 子类方法的返回值必须【小于等于】父类方法的返回值范围。
   小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。
3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。
   小扩展提示：public > protected > (default) > private。 备注：(default)不是关键字default，而是什么都不写，留空。

package cn.itcast.day09.demo06;

// 本来的老款手机
public class Phone {
    public void call() {
        System.out.println("打电话");
    }
    public void send() {
        System.out.println("发短信");
    }
    public void show() {
        System.out.println("显示号码");
    }
}
// 定义一个新手机，使用老手机作为父类
public class NewPhone extends Phone {
    @Override
    public void show() {
        super.show(); // 把父类的show方法拿过来重复利用        // 自己子类再来添加更多内容， super关键字
        System.out.println("显示姓名");
        System.out.println("显示头像");
    }
}
//又比如下面的：
/*
继承关系中，父子类构造方法的访问特点：

1. 子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造。
2. 子类构造可以通过super关键字来调用父类重载构造。
3. super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
总结：
子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，super只能有一个，还必须是第一个。
 */
public class Fu {
    public Fu() {
        System.out.println("父类无参构造");
    }
    public Fu(int num) {
        System.out.println("父类有参构造！");
    }
}

public class Zi extends Fu {
    public Zi() {
        super(); // 在调用父类无参构造方法
//        super(20); // 在调用父类重载的构造方法
        System.out.println("子类构造方法！");
    }
    public void method() {
//        super(); // 错误写法！只有子类构造方法，才能调用父类构造方法。
    }
}

here