Java基础:方法重写、方法重载、构造方法、this/super/final 关键字(附案例及源码)

前言:

关于这篇博文标题中提到的一些内容,在 Java 继承中体现的实现深刻,如果对继承不太了解的小伙伴,
可以先到下方链接,了解一下继承的相关知识,(嘻嘻,了解的小伙伴也可以看一下下,看看咱们理解的是
否有所偏差)。

继承: 戳我看诙谐的继承讲解

方法重写:

回想一下我们在继承中提到的 子类会继承父类的所有 非私有的属性和方法。
那么如果在子类中也有和父类同样的方法怎么办？
这就是方法的重写(覆写),在子类中重写的方法会替代在父类中的方法(既然你重写了,肯定是想实
现不同的功能)。通过一个小例子来实现一下:

现在 有 A 类(父类),B 类(子类)  B -- > A (B 继承 A):
而且 A (父类) 和 B(子类) 中都有一个共同的 方法 a()。
我们来测试一下 , 看结果如何: 

案例演示:

A.java（父类）：

package test;

public class A {

    public void a() {
        System.out.println("我是父类。。。。。。。。。");
    }
}

B.java(子类):

package test;

public class B extends A {
    public void a() {
        System.out.println("我是 A 的 子类。。。。。。。。。。。。。");
    }
}

Test.java

package test;

public class MyTest {

    public static void main(String[] args) {
        B b = new B();
        b.a();
    }
}

效果图:

结论:

通过上面的效果图,我们发现输出的是 子类中的方法,而且子类中的方法和父类总的方法是一样的。
这就是 方法重写。	

那么我要还想调用父类中相同的方法呢？

	这时候就需要用到 super(); 关键字啦。

B.java - - 利用 super 调用 父类中的方法：

package test;

public class B extends A {

    public void a() {
        super.a();
        System.out.println("我是 A 的 子类。。。。。。。。。。。。。");
    }
}

Test.java:

package test;

public class MyTest {

    public static void main(String[] args) {
        B b = new B();
        b.a();
    }
}

效果图:

结论:

当子类中的方法和父类中的方法重复时,可以利用 super 关键字调用父类中的方法。

注意:干货

子类重写父类:
如果父类中已经有方法 A(),子类比较叛逆,觉得 A不好,想要再写一下,就是重写父类中的方法。
如果子类和父类中都有 方法 A(),可以用 super.A() 调用父类中的方法，
会先在 当前类中找 A(),如果有,直接使用,如果没有,去父类中查找。


a(),this.a():会先在 当前类中找 A(),如果有,直接使用,如果没有,去父类中查找。
super.a() : 直接去父类中查找。

在这里就不再进行效果测试啦,有兴趣的小伙伴可以自行测试。

方法重载:

方法重载: 方法名相同,参数列表不同(类型不同,个数不同,顺序不同)

在确定是否时方法重载时注意两点:
   1、与返回值无关
   2、与参数名无关(与参数类型有关)

代码举例:

class Math {
    public void add(int num1,int num2){
        System.out.println(num1 + num2);
    }
	// 方法重载 -- 方法名相同,参数列表不同
    public void add(int num1,int num2,int num3) {
        System.out.println(num1 + num2 + num3);
    }
	// 方法重载
	public void add(double num1,double num2) {
		System.out.println(num1 + num2)
	}
	// 不是方法重载,方法名相同,参数列表相同
	public void add(int num1,int num2) {
		System.out.println(num1 + num2);
	}
	
}

方法重写与方法重载的区别:

构造方法:

构造方法的种类:

	构造方法有两种: 无参构造 (当没有  有参构造时,会默认有一个 无参构造)。
				   有参构造 (当有参构造存在时,就没有无参构造了,需要手动创建)

构造方法的用处:

	1、实例化对象( new )
		B b = new B(); -- new 后面 的 B() 实际上就是一个构造方法,通过构造方法来实例化
		对象。
	2、初始化多个属性,相当与 set 方法(主要是有参构造的用处)。

无参代码演示:
A.java

package test;

public class A {

    public A() {
        System.out.println("我是无参构造方法");
    }
    
}

Test.java – 检验我们在实例化对象时看是否回调用无参构造:

package test;

public class MyTest {

    public static void main(String[] args) {

        A a = new A();
    }
}

效果图:

结论:
通过效果图我们可以看出 当实例化对象时 是自动调用 类的无参构造方法的。

有参代码演示：

当只有有参构造方法而没有无参构造方法时,如果在 实例化对象的时候没有传入参数,是
会报错的。看下图:

所以,当我们创建有参构造方法时,最好也将 无参构造方法手动添加上,避免在 继承 的时候出错。
代码如下:

A.java – 构造方法进行初始化:

package test;

public class A {

    private String name ;
    private int age;

    // 无参构造
    public A() {
        System.out.println("我是无参构造方法。。。。。。。。");

    }
    // 有参构造
    public A(String name,int age) {
        // this 表示当前类
        this.name = name;
        this.age = age;
        System.out.println("我是有参构造方法 。。。。。。。。。。。。。。");

    }
    // 输出信息
    public void print() {
        System.out.println(this.name + " " + this.age);
    }

}

Test.java:

package test;

public class MyTest {

    public static void main(String[] args) {

        A a = new A("潘小蓝",23);

        a.print();

    }
}

效果图:

this/super 在构造方法中的使用:

	在同一个类中: 构造方法不能通过 方法名 直接 调用,非构造方法可以调用
	构造方法调用需要通过 this 关键字进行调用,调用 父类的构造方法可以通过 super 关键字
	进行调用。
	注意:
	用 this / super 调用构造方法时必须将其放在调用方法体内的 第一行(只能放一个).

this/super:

this: 调用本类的属性和方法。
super: 调用父类的方法和属性。

注意：

this() 调用本类中的构造 super():调用父类的构造方法。
同一个类中构造方法之间可以通过 this() 相互调用(区分不同的构造方法,根据构造方法中的参数),
但是不能循环调用,会出现死循环。

无论是调用同一个类中的构造方法还是父类的构造方法,this/super 关键字必须放在第一行。

final 关键字:

	final 关键字 -- 最终(不能改啦)
    final 修饰的类,不能被继承。
    final 修饰的方法,不能被重写
    final 修饰的属性、变量，不能被修改。
	override:重写
	overload:重载