Java学习18-- Override方法重写【★】

重点：super类 & 方法重写

★看不明白多看几遍，记住static优先级>>高于override

重写Override methods★

重写Override：child class可以覆盖father class中的method，即子类child class和父类father class有相同名称、相同参数列表和相同返回类型的方法method。当子类对象调用这个方法method时，会执行子类中的具体语句，而不是父类中的具体语句。

必须有继承关系，一般是“子类"重写"父类"的method(同名称，内芯不同)。重写是子类对父类那些允许访问的method实现过程进行重新编写(private method不行), 返回值和形参都不能改变。即外壳不变，核心重写！
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以尽量用大的，但不能进一步写小了 Public > Protected > Default > Private
4.抛出的异常： 范围，可以被缩小，但不能扩大：比如ClassNotFoundException（类找不到错误，范围相对小） --> Exception(范围相对大)

重写，子类的method名和父类method名必须要一致，方法体内部可以不同

为什么要重写
1.父类的功能，子类不一定全需要，或者不一定满足！
在IDEA里面，可以用快捷键Alt + Insert: 选择override，快速让系统帮你在子类里面抓出父类的一个功能进行override即重新覆盖写，一般写好之后系统在子类的代码里会加进一个@Override标志
类似这样

@Override
public void test() {
        super();//然后用户自行删除或者更改这一句的内容
    }
}

@Override是伪代码,表示重写(当然不写这个标志也可以)，不过写上有如下好处:
1、可以当注释用,方便阅读；
2、编译器可以给你验证@Override下面的方法名是否是父类中所有的，如果没有则报错。例如，你如果没写@Override，而你下面的method方法名又写错了，这时你的编译器是可以编译通过的，因为编译器以为这个方法是你的子类中自己增加的method方法。

举例：在重写父类的onCreate时，在方法前面加上@Override 系统可以帮你检查method方法的正确性。

@Override
public void onCreate(Bundle savedInstanceState)

{…….}

以上这种写法是正确的，如果你写成下面这样：

@Override
public void oncreate(Bundle savedInstanceState)
{…….}

编译器会报如下错误：
The method oncreate(Bundle) of type HelloWorld must override or implement a supertype method，以确保你正确的重写onCreate方法（注意oncreate大小写写错了，应该为onCreate）。而如果你不加@Override，则编译器将不会检测出错误，而是会认为你为子类定义了一个新方法叫做小写的oncreate

思考：同样是父类子类调用重名的method，method定义时候加了static和没加static，在结果上有什么区别？
小tips: static优先级>>高于Override

//注意： method定义没有加static关键字（可以考虑Override）
//比如fatherclass F= new childclass ()这样的语句，需要读完整句，到右侧才算结束
//符合Override，所以第一种fatherclass A = new childclass ();最后用的是childclass
//符合Override，第二种childclass B = new childclass ();最后用的是childclass

父类名 a = new 子类名 ();
a.non-method1();

子类名 b = new 子类名 ();
b.non-method1();

public class 父类名 {
public void non-method1(){do sth non static method1};
}

public class 子类名 {
public void non-method1(){do sth Override non static method1};
}

运行结果：

do sth Override non static method1
do sth Override non static method1

//注意：  method定义有static关键字（因为static优先级高，肯定不会Override了）
//第一种fatherclass A = new childclass ();A直接用左侧fatherclass
//第二种childclass B = new childclass ();B直接用左侧childclass

父类名 a = new 子类名 ();
a.method3();

子类名 b = new 子类名 ();
b.method3();

public class 父类名 {
public static void sti_method3(){do sth method3};
}

@Override
public class 子类名 {
public static void sti_method3(){do sth Override method3};
}

运行结果

do sth method3
do sth Override method3

运行分析：
如果程序写了public static void method，加了static关键字，由于JAVA内存中static和class部分会一起先加载且仅加载一次，static优先级高于Override，不用考虑重写的问题，父类名 a = new 子类名 ();这样的语句a直接取父类名。

而如果method没有static关键字，那么考虑Override，这时候属于子类重写了父类的方法，对于语句F_class A = new C_class ()这种定义的A就主要随右侧子类C_class ()的结构了。

助记：为什么static优先级高？
JVM中存储时候，除了第一部分stack先加载
第二部分method area里面有class structure和static存储区，他们在程序开始时候只加载一次，如果有method定义时候写了static，它在程序开始时候就加载了，优先级自然是高于子类重写父类的Override。

实例举例，思考下例输出的结果是什么？

public class testjan05{
public static void main(String args[]) {

    kids ki = new kids();
    ki.call();//non static, follow kids()(right) class, calling kids
    ki.read_book();//static, follow kids(left) baby is reading baby books


human hu = new kids();
hu.call();//non static, follow new kids()(right) calling kids
hu.read_book();//non static, follow human(left) human is reading books
}
}

public class kids extends human{
//class kids是从class human那里继承的
//在主程序里 new 一个kids的时候 kids是子类
//子类kids可以指向父类human，就是父类human的引用指向了子类kids
    public void call() {
        System.out.println("non static calling kids");
    }
    public static void read_book(){
        System.out.println("baby is reading baby books");
    }
}

public class human {

    public void call() {
        System.out.println("non static calling human");
    }
    //public static void eat(){System.out.println("human is eating");}
    public static void read_book(){
        System.out.println("human is reading books");
    }
}

运行结果

non static calling kids
baby is reading baby books
non static calling kids
human is reading books

简化版举例，classA是classB的子类，他们内部都有一个叫做test的method，先在在主程序分别调用这两个classA.test和ClassB.test并观察他们的输出结果。注意，在建立new object的时候，右侧都是写的子类。

public class testjan05 {
    public static void main(String[] args) {

        A x= new A();
        x.sta_test();//调用的是静态的方法,那么x应该跟随左侧A class,输出为static A=>test()
        x.non_test();//调用的是非静态的方法,那么x应该跟随右侧子类new A的class输出为 non-static A=>test()


        B y=new A();//父类B的引用 可以指向子类A
		//static优先级高于Override，如果见到static直接按B class父类走，不用再往句子右侧读了
        //如果调用的non-static的方法,需要走完全语句，Override之后程序object按照右侧new A()子类走
		
        y.sta_test();//调用的是静态的方法,输出应该就是左侧B class输出为static B=>test()
        y.non_test();调用的是非静态的方法,输出应该就是右侧子类new A()输出为non-static A=>test()


    }
}

public class A extends B{
    public static void sta_test() {
        System.out.println("static A=>test()");
    }

    public void non_test() {
        System.out.println("non-static A=>test()");
    }
}

//重写Override 子类重写父类的方法 只存在于non-static类的method

public class B {
    public static void sta_test(){
        System.out.println("static B=>test()");
    }

    public void non_test() {
        System.out.println("non-static B=>test()");
    }

}

运行结果

static A=>test()
non-static A=>test()
	
static B=>test()
non-static A=>test()

总结：

• 当有static时：不用管Override，对于语句ClassF x= new ClassC();x直接跟着父类ClassF走

例如
A子类 extends B父类

A x = new A();
x.test();
x就是和A有关的

B y = new A();
y.test();
y就是和B有关的

• 当删掉static时，要考虑子类Override父类(子类重写父类的同名方法)
  例如
  A子类 extends B父类

A x = new A();
x.test();
x跟new A()有关

B y = new A();//考虑子类重写父类方法
y.test();
y和new A()有关