Java成员变量的隐藏、方法重写（方法覆盖）的语法规则和实现

Java成员变量的隐藏：

在编写子类时，子类中声明的成员变量名字和从父类继承过来的成员变量名字相同时，子类就会使用自己声明的成员变量，隐藏从父类继承过来的成员变量；

子类隐藏继承的成员变量的特点如下：

1、子类对象和子类自己定义的方法，在操作与父类同名的成员变量时，使用的是子类声明的成员变量，而不是父类的；

如下代码↗：

//创建父类
public class variableHidden {
     //父类成员变量
	double number = 456.456 ;
}

//创建子类
public class variableHidden_Test extends variableHidden{
	
//1、子类对象和子类自己定义的方法，在操作与父类同名的成员变量时，使用的是子类声明的成员变量，而不是父类的；
	//对父类的成员变量进行隐藏
	double number = 11.11;
        //方法中操作 number 成员变量，此时使用的number是子类自己声明的number
	void Operation(int x){
		number += x;
		System.out.println("成员变量number的值："+number);
	}
	public static void main(String[] args) {
		
		//子类对象操作成员变量number
		variableHidden_Test vht = new variableHidden_Test();
		vht.number = 111.111;
		System.out.println("子类对象操作成员变量number的值："+vht.number);
		//子类对象操作方法
		vht.Operation(100);
	}
}

代码输出结果：

子类对象操作成员变量number的值：111.111
成员变量number的值：211.111
 

---

2、对于父类被隐藏的成员变量，子类可以通过对象调用父类的方法来操作被隐藏的成员变量；也就是说，子类继承父类的方法中，所操作的成员变量一定是被子类继承或隐藏的成员变量，而不是子类自己声明的成员变量；

如下代码↗：

//父类
public class variableHidden {
     //父类成员变量
	double number = 456.456 ;
	//父类的方法，方法中操作自己的成员变量
	void Fa(){
		System.out.println("父类方法，操作自己的成员变量number："+number);
	}
}

//子类
public class variableHidden_Test extends variableHidden{
	//对父类的成员变量进行隐藏
	double number = 11.11;
        //方法中操作 number 成员变量
	void Operation(int x){
		number += x;
		System.out.println("成员变量number的值："+number);
	}
	public static void main(String[] args) {
		
		//子类对象操作成员变量number
		variableHidden_Test vht = new variableHidden_Test();
		vht.number = 111.111;
		System.out.println("子类对象操作成员变量number的值："+vht.number);
		//子类对象操作自己的方法
		vht.Operation(100);
		//子类对象操作父类的方法，方法中操作的是父类的成员变量
		vht.Fa();
	}
}

代码输出结果：

子类对象操作成员变量number的值：111.111
成员变量number的值：211.111
父类方法，操作自己的成员变量number：456.456

 

---

3、子类新定义的方法中，只能操作子类继承和子类新声明的成员变量，不能操作被子类隐藏的成员变量；

如下代码↗：

//父类
public class variableHidden {
     //父类成员变量
	double number = 456.456 ;
	double variableFa = 789.789;
}

public class variableHidden_Test extends variableHidden{
	
//2、子类新定义的方法中，只能操作子类继承和子类新声明的成员变量，不能操作被子类隐藏的成员变量；
	void childMethod(){
		//操作继承和新声明的变量
		variableFa = 101.110;
		number = 110.101;
System.out.println("继承的成员变量variableFa："+variableFa+" 新声明的成员变量number："+number);
	}
	public static void main(String[] args) {
		
		//子类对象操作成员变量number
		variableHidden_Test vht = new variableHidden_Test();
		//子类对象操作自己的方法
                vht.childMethod();
	}
}

代码输出结果：

继承的成员变量variableFa：101.11 新声明的成员变量number：110.101 

---

Java方法重写：

1、子类通过重写可以隐藏从父类继承过来的方法；（方法重写也称为方法覆盖）

2、子类一旦重写了父类的方法，那父类被重写的方法就会被隐藏；

方法重写的语法规则：

1、子类中定义一个方法，这个方法的类型和父类的方法的类型是一致的，

2、而且方法的名字，参数个数，参数类型也要和父类的方法一致；

3、只有方法体是可以不一致的；

如下代码↗：

//父类methodRewrite 
public class methodRewrite {
    //定义一个父类方法
	void Method(int x,int y){
		int sum = x * y ;
		System.out.println("我是父类的方法，输出x * y = "+sum);
	}
}

//子类
public class methodRewrite_Test extends methodRewrite {

	//对继承的父类方法进行重写
	void Method(int x,int y){
		System.out.println("我重写了父类的Method方法");
	}
	
	public static void main(String[] args) {
		methodRewrite_Test mrt = new methodRewrite_Test();
		mrt.Method(11,111);
	}
}

代码输出结果：

我重写了父类的Method方法

需要注意的是：

子类在重写父类的方法时，不允许降低方法的访问权限，但可以提高方法的访问权限；

---

Java方法重写的目的：

1、子类通过方法的重写可以隐藏继承的方法；

2、子类通过方法的重写可以把父类的状态和行为改变为自身的状态和行为；

---

当父类方法的类型为 “类” 时，子类要如何进行重写：

1、重写时，方法的类型可以和父类的方法类型一样；

2、重写时，方法的类型可以和父类的方法类型不一样；

如下代码↗：

//父类
public class variableHidden {
	//父类方法的类型是类时，子类重写时方法的类型也可以是该类型，也可以是该类型的子类
	Object TypeFa(){
		return null;  //返回一个空对象
	}
}

//子类
public class variableHidden_Test extends variableHidden{

	//父类方法的类型是类时，子类重写时方法的类型也可以是该类型，也可以是该类型的子类
//		Object TypeFa(){
//			return new Object();  //重写父类的方法，返回一个Object对象
//		}
	//或者，类型改为 Object 类的某个子类也可以
		Integer TypeFa(){
			return new Integer(111);  //返回一个Integer对象
		}
	
	public static void main(String[] args) {
		
		//子类对象
		variableHidden_Test vht = new variableHidden_Test();
		//子类对象操作自己的方法
                Integer it = vht.TypeFa();
                System.out.println("对象Integer："+it);
	}

}

 代码输出结果：对象Integer：111

---

Java方法重写的操作与调用：

1、重写方法时既可以操作继承的成员变量，调用继承的方法，也可以操作子类新声明的成员变量，调用新定义的其他方法，但无法使用被子类隐藏的成员变量和方法；

2、子类想要使用被隐藏的方法或成员变量，必须使用关键字 super ；

如下代码↗：

public class methodRewrite {
	//创建父类成员变量 和 方法
	int numberFa = 11;
	void methodFa(int x,int y){
		int sum = x+y;
		System.out.println("我是父类的方法，计算 x+y ="+sum);
	} 
	//被子类重写方法
	void Fa(int x,int y,int z){
		int muti = x*y*z;
		System.out.println("我是父类的方法，计算 x*y*z ="+muti);
	} 
	//被子类隐藏的成员变量
	int Fs = 100 ;
}

public class methodRewrite_Test extends methodRewrite {
	//子类新声明的成员变量和方法
	int numberCh = 111 ;
	void methodCh(double x,double y){
		double div = x/y;
		System.out.println("我是子类的方法，计算 x/y ="+div);
	}
	//隐藏父类的成员变量Fs
	int Fs = 159 ;
	
	//方法重写，在方法中操作继承的成员变量，调用继承的方法，操作自己新声明的成员变量和方法
	void Fa(int x,int y,int z){
		//操作继承的成员变量，调用继承的方法
		numberFa = 789;
		System.out.println("numberFa= "+numberFa);
		methodFa(111,111);
		//操作自己新声明的成员变量和方法
		numberCh = 456 ;
		System.out.println("numberCh= "+numberCh);
		methodCh(888,222);
		//但无法使用被子类隐藏的成员变量和方法；
		Fs = 77 ;  //此时的Fs是子类自己声明的成员变量，而父类的成员变量Fs已经被隐藏了
		System.out.println("Fs= "+Fs);
		//使用关键字 super 调用被子类隐藏的成员变量
		System.out.println("super.Fs= "+super.Fs);
		
		int sub = x-y-z;
		System.out.println("我重写了父类的方法，计算 x-y-z ="+sub);
		
	}
	
	public static void main(String[] args) {
		
		//调用继承父类的成员变量和方法；
		System.out.println("我调用了父类的成员变量numberFa："+mrt.numberFa);
		mrt.methodFa(123,1234);
		
		//调用子类自己的成员变量和方法；
		System.out.println("子类自己的成员变量numberCh："+mrt.numberCh);
		mrt.methodCh(100,2);
		
		//调用子类重写的方法
		mrt.Fa(100,10,10);
	}
}

代码的输出结果：

我调用了父类的成员变量numberFa：11
我是父类的方法，计算 x+y =1357
子类自己的成员变量numberCh：111
我是子类的方法，计算 x/y =50.0
numberFa= 789
我是父类的方法，计算 x+y =222
numberCh= 456
我是子类的方法，计算 x/y =4.0
Fs= 77
super.Fs= 100
我重写了父类的方法，计算 x-y-z =80

---

需要了解关键字 super 的详细使用，可以访问链接：

https://blog.csdn.net/LagerSwan/article/details/104276903