Java不同状态下创建的对象调用成员变量、方法情况

Java类中通过 new运算符 和 构造方法 创建对象；

而对象又有：一般类对象、子类对象，父类对象，上转型对象，本文对这些对象进行分析，区分他们分别在操作成员变量和方法时不同的调用情况；

一、一般类对象的调用情况：

对于一般类，类中对象没有 重写（隐藏）的成员变量和方法、没有 继承 的成员变量和方法，所以类中对象只能调用自己声明的成员变量和方法；

如下代码↗：

public class objectUpward_Test {
	//子类自己新增的成员变量，声明并赋予初值
	int variableCh = 111; 
	//子类自己新增的方法，计算两个数的和
	void oneself(double x,double y){
		double sum = x+y;
		System.out.println("我是一般类自己新增的方法：sum的值="+sum);
	}
	public static void main(String[] args) {
		
		//1、一般类自己的对象
		objectUpward_Test out = new objectUpward_Test();
	      //操作自己新增的成员变量和方法；可以进行操作
		out.variableCh = 1111;
	System.out.println("我是一般类自己新增的成员变量：variableCh的值="+out.variableCh);
		out.oneself(11.11,11.11);
	}
}

代码输出结果：

我是一般类自己新增的成员变量：variableCh的值=1111

我是一般类自己新增的方法：sum的值=22.22

---

二、子类对象的调用情况：

子类中创建自己的对象，子类对象可以调用 重写（隐藏）的成员变量和方法、 继承 的成员变量和方法， 自己新增 的成员变量和方法；

如下代码↗：  父类：objectUpward；子类：objectUpward_Test；

//父类
public class objectUpward {
	// 被子类 继承的成员变量，声明并赋予初值
	int variableFa = 147; 
	// 被子类 重写的成员变量，声明并赋予初值
	int Fa = 258;
	// 被子类 继承的方法
	void methodFa(){
		System.out.println("继承父类的方法methodFa：被子类调用了");
	}
	// 被子类 重写的方法
	void Fa() {
		System.out.println("父类的方法Fa：被子类重写");
	}
}

//子类
public class objectUpward_Test extends objectUpward {
	//子类自己新增的成员变量，声明并赋予初值
	int variableCh = 111; 
	//子类自己新增的方法，计算两个数的和
	void oneself(double x,double y){
		double sum = x+y;
		System.out.println("一般类自己新增的方法：sum的值= "+sum);
	}
	//子类操作重写父类的成员变量和方法；
	int Fa = 117330;
	void Fa() {
		System.out.println("重写父类的方法Fa：父类方法被隐藏了");
	}
	public static void main(String[] args) {
		objectUpward_Test out = new objectUpward_Test();
		//操作自己新增的成员变量和方法；可以操作
    System.out.println("一般类自己新增的成员变量：variableCh的值= "+out.variableCh);
		out.oneself(11.11,11.11);
		System.out.println("");
		//操作继承父类的成员变量和方法；可以操作
		System.out.println("继承父类的成员变量：variableFa的值= "+out.variableFa);
		out.methodFa();
		System.out.println("");
		//操作重写父类的成员变量和方法；可以操作
		System.out.println("重写父类的成员变量：Fa的值= "+out.Fa);
		out.Fa();
	}
}

代码输出结果：

一般类自己新增的成员变量：variableCh的值= 111
一般类自己新增的方法：sum的值= 22.22

继承父类的成员变量：variableFa的值= 147
继承父类的方法methodFa：被子类调用了

重写父类的成员变量：Fa的值= 117330
重写父类的方法Fa：父类方法被隐藏了

---

三、父类对象的调用情况：

1、前提：子类中创建父类的对象；

2、该父类的对象可以调用自己的成员变量和方法，但是不可以调用 子类自己新增 的成员变量和方法；；

2、对于子类 重写（隐藏）的成员变量和方法，父类对象可以调用，但是输出的是父类中自己的成员变量和方法的值，而不是子类重写后成员变量和方法的值；

3、对于子类 继承 的成员变量和方法，父类对象可以调用，因为子类 继承的成员变量和方法 就是父类自己的成员变量和方法；

如下代码↗：  父类：objectUpward；子类：objectUpward_Test；

//父类
public class objectUpward {
	//被子类继承的成员变量，声明并赋予初值
	int variableFa = 147; 
	//被子类重写的成员变量，声明并赋予初值
	int Fa = 258;
	//被子类继承的方法
	void methodFa(){
		System.out.println("继承父类的方法methodFa：被子类调用了");
	}
	// 被子类重写的方法
	void Fa() {
		System.out.println("父类的方法Fa：被子类重写");
	}
}

//子类
public class objectUpward_Test extends objectUpward {
	//子类继承了父类，创建父类的对象，在子类中调用
	//子类自己新增的成员变量，声明并赋予初值
	int variableCh = 111; 
	//子类自己新增的方法，计算两个数的和
	void oneself(double x,double y){
		double sum = x+y;
		System.out.println("一般类自己新增的方法：sum的值= "+sum);
	}
	//子类操作重写父类的成员变量和方法；
	int Fa = 117330;
	void Fa() {
		System.out.println("重写父类的方法Fa：父类方法被隐藏了");
	}

	public static void main(String[] args) {
		objectUpward ou = new objectUpward();
		//父类对象操作子类新增的成员变量和方法；不可以操作；报错variableCh cannot be resolved or is not a field
	//	System.out.println("父类对象操作子类新增的成员变量：variableCh的值= "+ou.variableCh);
	//	ou.oneself(121.121,11.11);  //报错The method oneself(double, double) is undefined for the type objectUpward

		//子类中，父类对象操作子类 继承的成员变量和方法；可以操作；
		System.out.println("父类对象操作自己的成员变量：variableFa的值= "+ou.variableFa);
		ou.methodFa();
		//子类中，父类对象操作被子类 重写的成员变量和方法；可以操作；但是输出的是自己类中的成员变量和方法
		System.out.println("父类对象操作自己的成员变量：Fa的值= "+ou.Fa);
		ou.Fa();
		
	}
}

代码输出结果：

父类对象操作自己的成员变量：variableFa的值= 147
继承父类的方法methodFa：被子类调用了
父类对象操作自己的成员变量：Fa的值= 258
父类的方法Fa：被子类重写

---

四、上转型对象的调用情况：（不能将 父类对象 和 上转型对象 混淆在一起）

1、上转型对象：将子类对象的引用赋给父类的对象（也就是使用子类的构造方法创建引用，再赋给父类对象），那么这个父类的对象就是子类对象的上转型对象；

简单的说就是：父类对象 拥有了 子类对象 的 引用；

        //创建上转型对象方法1
        objectUpward ou = new objectUpward_Test();
        //创建上转型对象方法2
        objectUpward_Test out = new objectUpward_Test();
        objectUpward ous = out ;  

父类：objectUpward；子类：objectUpward_Test；

2、上转型对象可以调用 父类的成员变量和方法，但是不可以调用 子类自己新增 的成员变量和方法；

3、对于子类 重写（隐藏）的成员变量，上转型对象可以调用，但是输出的是父类中的成员变量值，而不是子类重写后成员变量的值；

4、对于子类 重写（隐藏）的方法，上转型对象可以调用，但是方法输出的是子类重写后的内容， 而不是父类中的方法的内容；

5、对于子类 继承 的成员变量和方法，父类对象可以调用，因为子类 继承的成员变量和方法 就是父类自己的成员变量和方法；

如下代码↗：  父类：objectUpward；子类：objectUpward_Test；

//父类
public class objectUpward {
	//被子类继承的成员变量，声明并赋予初值
	int variableFa = 147; 
	//被子类重写的成员变量，声明并赋予初值
	int Fa = 258;
	//被子类继承的方法
	void methodFa(){
		System.out.println("上转型对象 ou 调用子类 继承的方法methodFa");
	}
	// 被子类重写的方法
	void Fa() {
		System.out.println("上转型对象 ou 操作子类 继承的方法Fa");
	}
}

//子类
public class objectUpward_Test extends objectUpward {
	int variableCh = 111; 
	//子类自己新增的方法，计算两个数的和
	void oneself(double x,double y){
		double sum = x+y;
		System.out.println("一般类自己新增的方法：sum的值= "+sum);
	}
	//子类操作重写父类的成员变量和方法；
	int Fa = 117450;
	void Fa() {
	  System.out.println("上转型对象 ou 调用子类重写父类的方法Fa：父类方法被隐藏了");
	}
	
	public static void main(String[] args) {
		
		//4、子类中创建上转型对象，在子类中调用
//上转型对象：将子类对象的引用赋给父类的对象（也就是使用子类的构造方法创建引用，赋给父类对象）；
		//创建方法1
		objectUpward ou = new objectUpward_Test();
		//创建方法2
		objectUpward_Test out = new objectUpward_Test();
		objectUpward ous = out ;
		//分别输出这些对象的引用
		System.out.println("使用子类构造方法创建的上转型对象 ou，引用= "+ou);
		//引用相等，拥有的实体相等
		System.out.println("子类创建的对象 out，引用= "+out);		
		System.out.println("使用子类对象赋值引用创建的上转型对象 ous，引用= "+ous);
		
                //测试上转型对象 ou 的调用情况，效果等同于上转型对象 ous
		//上转型对象操作子类 新增的成员变量和方法；不可以操作；报错variableCh cannot be resolved or is not a field
	//	System.out.println("上转型对象操作子类新增的成员变量：variableCh的值= "+ou.variableCh);
	//	ou.oneself(121.121,11.11);  //报错The method oneself(double, double) is undefined for the type objectUpward

		//上转型对象操作被子类 继承的成员变量和方法；可以操作；
		System.out.println("上转型对象 ou 操作子类 继承的成员变量：variableFa的值= "+ou.variableFa);
		ou.methodFa();
		//上转型对象操作被子类 重写的成员变量；可以操作；输出的是父类中的成员变量
		System.out.println("上转型对象 ou 操作子类 重写的成员变量：Fa的值= "+ou.Fa);
		//上转型对象操作被子类 重写的方法；可以操作；输出的是子类重写后的方法内容
		ou.Fa();
	}
}

代码输出结果：

使用子类构造方法创建的上转型对象 ou，引用= Chapter_Five.objectUpward_Test@7852e922
子类创建的对象 out，引用= Chapter_Five.objectUpward_Test@4e25154f
使用子类对象赋值引用创建的上转型对象 ous，引用= Chapter_Five.objectUpward_Test@4e25154f
上转型对象 ou 操作子类 继承的成员变量：variableFa的值= 147
上转型对象 ou 调用子类 继承的方法methodFa
上转型对象 ou 操作子类 重写的成员变量：Fa的值= 258
上转型对象 ou 调用子类重写父类的方法Fa：父类方法被隐藏了

---

对象上转型对象的引用，和子类创建的对象引用是一样的；

总结：上转型对象 与 父类对象 的区别

这两个对象在操作子类 重写（隐藏）的方法时，方法输出的内容是不一样的；

上转型对象输出的是，子类重写方法后，子类重写方法中的内容；

父类对象输出的是，子类重写方法前，方法中的内容；也就是 父类原本方法中的内容；

详细了解上转型对象的定义，可以访问下面链接：

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