java重写 /override/覆盖与多态
重写 =override=覆盖
override与多态息息相关！可以说二者是完全等价的。
重写
方法的重写(override / overwrite)
* 1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作，也就是重写同名方法。
*
* 2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
*
* 3. 重写的规定：
* 方法的声明： 权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{
* //方法体
* }
* 约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
* ① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
* ② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
* >特殊情况：子类不能重写父类中声明为private权限的方法
* ③ 返回值类型：
* >父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
* >父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
* >父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
* ④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）
* **********************************************************************
* 子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）。
多态
简单来说就是：将子类赋给父类的引用，通过该引用调用父类的方法（属性并不会生效）使如果子类重写了，那就调用子类的。
父类的引用可以调用子类重写的方法，但不能调用子类特有的方法(编译都无法通过，因为父类就没有这个方法)
这也很好理解：我编译时不知道该引用到底指向谁，他有可能指向父类也有可能任何一个子类，因此我干脆直接规定他不能调用父类已有属性和方法之外的东西。
也就是只能调用父类的方法，且父类的方法如果被重写则调用重写的方法
只适用于方法，不适用于属性，属性无论是否覆盖都会调用父类的
也就是多台的特殊性就体现在子类重写的方法，受了编译的约束
真正开发当中不用注意这么多细节，只是参考一下就行
对于属性而非方法是否有覆盖？
子类的同名属性确实会覆盖父类的，但并不会触发多态，并不会出现父类向子类寻找的情况
import org.junit.Test;
public class test1 {
@Test
public void test1() {
B newB = new NewB();
System.out.println(newB.num1);
}
}
class B{
int num1=3;
void f(){
this.func();
System.out.println(this.getClass());
}
void func(){
System.out.println("i use b");
}
}
class NewB extends B{
int num1=5;
void func(){
System.out.println("i use NewB");
}
private void testSuper() {
super.f();
}
}结果：
3
可以看到是哪个类的引用就调用哪个引用的属性，比如这里调用的是B的引用虽然真实对象为newB，但结果却为B的num1
同理如果改为test1()中改为
NewB newB = new NewB();
System.out.println(newB.num1);结果就为5了，与上面结论成立.
重写可能遇到的情况思考：
比如我B继承A，C继承了B，如果B重写了函数f，那么C实例会调用B的f，如果C也重写了f，那么会调用C的f，结论：调用某实例时，重写取该实例最年轻的子类(也就是向上寻找第一个重写的父类)的为最终重写，也很好理解
代码块中的this、super、缺省的区别
缺省首先查自己这个代码块中的局部变量，没有再找该类属性和方法，然后再找父类属性和方法（继承的东西要找也很正常），再找上层代码块的变量（符合代码块的搜寻逻辑，只不过有一个寻找父类的额外过程）
super也叫做父类的，只会调用父类的方法和属性。存在的意义就是父类的方法和属性不好调用到，因此使用super来表明我只调用父类的东西，你别给我覆盖了。
this直接查该类属性和方法，然后再找父类属性和方法，this永远是new他时的类型。
import org.junit.Test;
public class test1 {
@Test
public void test1() {
NewB newB = new NewB();
newB.testSuper();
}
}
class B{
void f(){
this.func();
System.out.println(this.getClass());
}
void func(){
System.out.println("i use b");
}
}
class NewB extends B{
void func(){
System.out.println("i use NewB");
}
public void testSuper() {
System.out.println(super);
System.out.println(this);
// super.func();
// this.func();
}
}
结果
NewB@1615099
NewB@1615099
可以看到this和super都指向同一个对象，这是很合理的。
子类和父类的this
原理就是
在NewB中：NewB this=newB
在B中： B this=newB
就是多态！！即子类的this在父类代码块中只能调用父类声明的属性和方法，但调用父类声明方法如果子类重写了会直接调用子类的，调用父类声明属性如果子类也有但不会调用子类的，因为属性并不会触发多态。
证明
class a{
int num=3;
public static void main(String[] args){
new NewB().f();
}
void f(){
System.out.println(num);
}
}
class b{
int num=3;
void f(){
this.func();
System.out.println(this.getClass());
}
void func(){
System.out.println("i use b");
}
}
class NewB extends b{
int num1=5;
void func(){
System.out.println("i use NewB");
}
}结果
i use NewB
class NewB
加入有父类B，子类NewB,NewB有1对象newB
B中的this指针是否相当于B this=newB
import org.junit.Test;
public class test1 {
@Test
public void test1() {
NewB newB = new NewB();
newB.testSuper();
}
}
class B{
int num=3;
void f(){
this.func();
System.out.println(this.getClass());
System.out.println(this.num);
}
void func(){
System.out.println("i use b");
}
}
class NewB extends B{
int num=5;
void func(){
System.out.println("i use NewB");
}
public void testSuper() {
super.f();
this.f();
}
}
结果
i use NewB
class NewB
3
i use NewB
class NewB
3
可以看出是符合猜测的