Java_方法重写

记录JAVA知识点_方法重写

一开始先声明一下Object类：

Object类定义对象的计本状态和行为，没有成员变量，但是提供一组供所有对象继承的方法，包括通用方法和支持线程的方法。

当一个类没有声明父类时，默认该类的父类是Object。如下：

public class Person{
    ......
}
public class Person extends Object{
    ......
}

1.方法重写

（1）成员方法的重写概念
成员方法的重写：在有继承关系的类中，子类重新实现了父类中同一个方法的功能，其方法名称、参数类型/个数、返回值类型都完全相同。

举例：
首先是没有方法重写的

class A {
         public void print() {
                   System.out.println("Hello World .") ;
         }
}
class B extends A {
}
public class Test {
         public static void main(String args[]) {
                   B b = new B() ;
                   b.print() ;    // 方法从父类继承而来
         }
}

这时实例化的是子类对象，但是在子类中，没有定义print()方法，那么就使用从父类中继承而来的pritn()方法。

然后是进行方法重写的

class A {
         public void print() {
                   System.out.println("Hello World .") ;
         }
}
class B extends A {
         public void print() {      // 方法名称、参数类型及个数、返回值全相同
                   System.out.println("世界，你好！") ;
         }
}
public class Test {
         public static void main(String args[]) {
                   B b = new B() ;
                   b.print() ;    // 方法从父类继承而来，输出“世界，你好
                   ！”
         }
}

！方法重写的限制：

（1）当一个类中的方法被重写后，如果实例化的是这个子类对象，则调用的方法就是被重写过的方法。
（2）在进行方法重写的时候有一点需要注意：被子类所重写的方法不能拥有比父类更严格的访问控制权限，对于访问控制权限现在已经接触过三种：private < default（不写） < public；
如果此时父类中的方法是default权限，那么子类重写的时候只能是default或public权限，而如果父类的方法是public，那么子类中重写的方法的访问权限只能是public。

举例：
子类重写方法时没有注意权限时的状况

package review_chongxie;

class A2 {
    public void print() {
          System.out.println("Hello World .") ;
    }
}

class B2 extends A2 {
    void print() {
         System.out.println("世界，你好！") ;
    }
}
public class Demo3 {
	public static void main(String[] args){
		B2 b2 = new B2();
		b2.print();
		//bug:Cannot reduce the visibility of the inherited method from A2
	}
}

提示：为了方便代码编写，只要是方法大都使用public进行修饰，99.9999%可以解决问题。
当一个子类重写了一个父类方法的时候，如果子类想调用父类的被重写的方法，则在方法前要加上“super”关键字。

class A {
         public void print() {
                   System.out.println("Hello World .") ;
         }
}
class B extends A {
         public void print() {
                   super.print() ;
                   System.out.println("世界，你好！") ;
         }
}
public class Test {
         public static void main(String args[]) {
                   B b = new B() ;
                   b.print() ;    // 方法从父类继承而来
         }
}

运行结果：

ps：使用了private修饰的方法一般都无法被真正重写。

如下

class A { 
	private void print() { 
		System.out.println("Hello World .") ; 
	} 
	public void fun() { 
		this.print() ; 
	} 
} 
class B extends A { 
	public void print() {	// 不叫覆写
		System.out.println("世界，你好！") ; 
	} 
} 
public class Test { 
	public static void main(String args[]) { 
		B b = new B() ; 
		b.fun() ;	// 方法从父类继承而来
	} 
}

由于class A的print（）方法是private私有的，所以class B无法对其重写，运行结果为“Hello World！”

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

成员变量的重写：

当一个子类定义了和父类重名的属性名称的时候，就表示属性的重写了，但是这种操作几乎没有意义，因为从开发角度来讲，属性一定要封装，封装之后就没有重写这一概念了。

class A {
         public String msg = "Hello World ." ;
}
class B extends A {
         public int msg = 100 ;  // 属性同名
         public void print() {
                   System.out.println("msg = " + this.msg) ;
                   System.out.println("msg = " + super.msg) ;
         }
}
public class Test {
         public static void main(String args[]) {
                   B b = new B() ;
                   b.print() ;    // 方法从父类继承而来
         }
}

运行结果：

ps：参考老师的笔记以及加上自身的理解