精华内容
下载资源
问答
  • 对象变量多态性:上转型对象和下转型对象 上转型对象 上转型对象只能访问父类中声明的成员变量和成员方法,不可以访问子类新增的特有的成员变量和成员方法。 如果子类重写了父类的方法,则上转型对象调用该方法...

    对象变量多态性:上转型对象和下转型对象

    上转型对象

    1. 上转型对象只能访问父类中声明的成员变量和成员方法,不可以访问子类新增的特有的成员变量和成员方法。

    2. 如果子类重写了父类的方法,则上转型对象调用该方法时,必定是调用重写的方法。

    3. 如果子类重新定义了父类的同名变量,则上转型对象应用该变量时是父类中的定义的变量,而不是子类中定义的变量。

    下转型对象

    将父类对象赋值给子类对象变量的情况称为向下转型。子类对象有上转型对象,父类变量才可以直接调用子类的对象;但是如果父类中没有下转型对象,子类变量不能被直接引用父类对象,必须通过强制转换,将上转型对象还原回子类对象。

    例如:定义一个Dog父类,定义两个子类Ala和Keji。

    Dog类代码:
    Dog类

    Keji类代码:
    在这里插入图片描述

    Ala类代码:
    在这里插入图片描述
    Test测试类代码:
    在这里插入图片描述
    结果:
    在这里插入图片描述

    如果要实现子类,以前需要实例化一个对象,就像Keji
    keji=new Keji();

    再用对象keji调用all方法,Ala也一样,非常麻烦。

    用上转型对象可以更简便的调用。

    格式:父类类名 父类对象=new 子类类名();

    再用父类对象.方法();调用方法。

    Dog dog=new Keji(“柯基”,15);
    Dog.all();
    调用的是Keji类中的all方法,Keji类中的all方法还有super.all(),再调用了父类Dog里的all方法。
    dog=new Ala(“阿拉斯加”,1);
    将指向Keji的具体实现指向Ala,然后再调用Ala类里的all方法。

    如果在Keji中再创建一个子类特有方法
    在这里插入图片描述

    在Test测试类中调用是会报错的

    在这里插入图片描述

    所以要用下转型对象来调用
    格式为 子类类名 子类对象=(子类类名)父类对象;
    然后再用子类对象.方法名();调用。

    在Test类中用子类对象调用
    在这里插入图片描述

    结果:

    在这里插入图片描述

    第一次写,写的不好,错了请指导。

    展开全文
  • 上转型对象不能操作子类新增的成员变量(失掉了这部分属性),不能调用子类新增的方法(失掉了一部分行为)。 上转型对象可以访问子类继承或隐藏的成员变量,也可以调用子类继承的方法或子类重写的方法。 上转型对象...

    抽象类的对象作上转型对象可以“操作”子类新增的对象:

    abstract class A{
    	 abstract void getM();
    }
    class B extends A{
    	int n = 10;
    	void getM(){
    		System.out.println(n);
    	}
    }
    class E{
    	public static void main(String args[]){
    		A a = new B();
    		a.getM();
    	//	System.out.println(a.n);(报错:找不到符号)
    	}
    }
    

    而抽象类的对象作上转型对象可以通过重写的方法操作新增的变量,那么普通的上转型对象可不可以?

    对象的上转型对象的实体是子类负责创建的,但上转型对象会失去原对象的一些属性和功能(上转型对象相当于子类对象的一个简化对象)。上转型对象具有如下特点:

    1. 上转型对象不能操作子类新增的成员变量(失掉了这部分属性),不能调用子类新增的方法(失掉了一部分行为)。
    2. 上转型对象可以访问子类继承或隐藏的成员变量,也可以调用子类继承的方法或子类重写的方法。
    3. 上转型对象操作子类继承的方法或子类重写的实例方法,其作用等价于子类对象去调用这些方法,因此如果子类重写了父类的某个实例方法后,当对象的上转型对象调用这个实例方法时一定是调用了子类重写的实例方法。

    在这里插入图片描述
    但通过以下例子,我们发现上转型对象实际上可以“操作”子类新增的成员变量:

     class A{
    	  void getM(){
    	  }
    }
    
    class B extends A{
    	int n = 10;
    	void getM(){
    		n = 20;
    		System.out.println(n);
    	}
    }
    class E{
    	public static void main(String args[]){
    		A a = new B();
    		a.getM();
    	//	System.out.println(a.n);(报错:找不到符号)
    	//  a.n = 20;(报错:找不到符号)
    	}
    }
    

    输出结果:20

    实验表明:对象的上转型对象实际上可以通过重写方法来“操作”成员新增的变量,而不能直接操作子类新增的变量。

    展开全文
  • Java实现运用上转型以及对象抽象方法计算圆形或圆锥的面积、周长等成员变量
  • class A { int m ; int ...//对B类的成员变量赋值 ...//对A类的成员变量赋值 ...结论:上转型对象通过重写的方法会调用继承的变量,通过“.”来直接访问隐藏的变量,未被重写的方法则会调用隐藏的变量
    class A{
    	int m;
    	int getM(){
    		return m;
    	}
    	int seeM(){
    		return m;
    	}
    	void setM(int m){
    		this.m = m;
    	}
    }
    
    class B extends A{
    	int m;
    	int getM(){
    		return 100+m;
    	}
    	void setM(int m){
    		this.m = m;
    	}
    	int seeM(){
    		return m+1;
    	}
    }
    
    public class E{
    	public static void main(String args[]){
    		B b = new B();
    		b.setM(20);
    		b.m = 20;
    		System.out.println(b.getM());
    		A a = b;
    		a.setM(-50);//对B类的成员变量赋值
    		a.m = -100;//对A类的成员变量赋值
    		System.out.println(a.getM());
    		System.out.println(b.seeM());
    		System.out.println(a.m);
    		System.out.println(b.m);
    	}
    }
    

    输出的结果:
    b重写的getM方法:120
    a重写的getM方法:50 //调用了B类的成员变量
    b重写的seeM方法:-49 //调用了B类的成员变量
    a隐藏的变量:-100
    b继承的变量:-50

    若B类不重写setM和getM方法,即:

    class A{
    	int m;
    	int getM(){
    		return m;
    	}
    	int seeM(){
    		return m;
    	}
    	void setM(int m){
    		this.m = m;
    	}
    }
    
    class B extends A{
    	int m;
    
    	int seeM(){
    		return m+1;
    	}
    		int seeM2(){
    		return super.m;
    	}
    }
    
    public class E{
    	public static void main(String args[]){
    		B b = new B();
    		b.setM(20);//设置A类的成员变量(隐藏变量),setM方法未被重写,直接继承A类的方法
    		System.out.println(b.m);
    		System.out.println(b.seeM());
    		System.out.println(b.seeM2());
    		A a = b;
    		a.setM(-50);
    		//a.m = -100;
    		System.out.println(a.getM());
    		System.out.println(b.seeM());
    		System.out.println(a.m);
    		System.out.println(b.m);
    	}
    }
    

    输出的结果:
    0 //b的成员变量
    1 //查看B类的成员变量(此时b.m=0),调用重写的seeM方法,调用B类的成员变量
    20 //查看A类的成员变量,调用未重写的(新的)seeM2方法
    -50 //调用了A类的成员变量,调用未重写的getM方法
    1 //调用了B类的成员变量,调用重写的seeM方法
    -50 //a的成员变量
    0 //b的成员变量

    结论:上转型对象通过重写的方法会调用继承的变量,通过“.”来直接访问隐藏的变量,未被重写的方法则会调用隐藏的变量

    展开全文
  • public String str="我是Father类变量"; public void say(){ System.out.println("我是Father类方法"); } } class Son extends Father{ public String str="我是Son类变量"; public void say(){ System....
    class Father{
    	public String str="我是Father类变量";
    	public void say(){
    		System.out.println("我是Father类方法");
    	}
    }
    
    class Son extends Father{
    	public String str="我是Son类变量";
    	public void say(){
    		System.out.println("我是Son类方法");
    	}
    }
    
    public class lianxi5{
    	public static void main(String args[]){
    		Father test=new Son();
    		System.out.println(test.str);
    		test.say();
    	}
    }

    运行结果:

    我是Father类变量
    我是Son类方法

    上转型对象引用test   引用的是父类成员变量和子类的成员方法;

    展开全文
  • 对象的上转型总结

    2018-08-01 10:08:00
    (1)上转型变量只能访问继承或隐藏的变量、继承或重写的方法;不可以使用子类新增的变量或新增的方法。 (2)可以把转型对象强制转换成一个子类对象,此时子类对象又可以访问所有的子类变量...
  • Java中的上转型对象

    2020-03-27 11:37:20
    java中的上转型变量 引言: 当学习到java的多态时,提到了上转型变量的概念,由于java中的多态十分重要,在本文中将介绍本人在学习过程中的疑惑和寻找到的解答并进行总结。 1.定义 如果B类是A类的子类或间接子类,...
  • 如果父类子类变量同名,向上转型后访问的是父类变量,那如果我想要访问子类变量该怎么做到?
  • Java向上转型时多态的体现,父类与子类有同名变量是内存的分配,向上转型时方法的覆盖
  • 在学习Java的过程中对于有一些概念还是要做一做笔记,比如说此处的上转型变量。 假设Animal类是Tiger类的父类,当用子类创建一个对象,并把这个对象的引用放到父类的对象中时,例如: Animal a; a = new Tiger(); ...
  • Java 上转型对象

    2019-10-14 21:56:56
    上转型对象不能操作子类新增加的成员变量,不能使用子类新增的方法。即上转型对象较子类B失去一些属性和功能,这些属性和功能是子类新增的。 上转型对象可以操作子类继承或隐藏的成员变量,也可以使用子类继承的或...
  • 聊聊你不知道的Java变量转型

    千次阅读 2020-06-05 17:28:45
    Java变量分为类变量、实例变量、局部变量。在Java语言中,所有的变量在使用前必须声明。定义变量就是要告诉编译器这个变量的数据类型,这样编译器才知道需要分配多少空间给它,以及它能存放什么样的数据。在程序运行...
  • 上转型对象

    2021-03-20 23:00:21
    上转型对象调用变量的时候,即使变量被子类重写了,但是还是调用父类的变量 ​ 3.上转型对象不可以调用子类新建的变量和方法 class A{ void set(){ System.out.println("我是父类的方法"); } int number = ...
  • 这里需要值得注意的是,当子类向上转型之后调用成员变量即实例变量是父类的,调用成员方法是子类的!如: public class A { int k = 3; public void test() { System.out.println("a"); } } public class ...
  • 向上转型,意思是指父类引用指向子类对象,这时候因为使用的是父类引用,所以方法都是以父类为主,如果子类对父类方法进行覆盖的话,这时候调用的会是子类的 public class People { public String name = "this is...
  • 上转型:重写父类方法才调用子类方法,其他仍用父类的,包括被子类隐藏的父类成员变量,而且不能调用子类新增的成员变量和成员方法。 下转型:只能是转上去的才能转下去。下转型类似于该子类直接继承父类。 ...
  • java上转型

    2015-11-25 11:27:29
    上转型对于成员变量、静态方法、静态变量是隐藏,对于成员方法是重写。如果子类中重写了父类成员方法,调用的时候调用子类方法,如果子类中定义了父类中同名的成员变量、静态方法、静态变量,此时由引用的类型决定,...
  • Java上转型对象

    2015-07-18 14:56:31
    如果A类是B类的子类,当用子类创建一个对象,并把这个...1,上转型对象会失掉原对象的一些属性和功能(方法),就是说上转型对象不能操作子类新增的成员变量和方法。 2,但是上转型对象可以访问被子类继承或隐藏的成
  • java中的上转型对象

    2018-05-16 17:09:50
    一、定义:类B是类A的子类A a;a=new B();或者A a;B b=new B();...3上转型对象可以操作子类继承的成员变量和隐藏的成员变量,也可以使用子类继承的或重写的方法。4、上转型对象不能操作子类新增的方法和成...
  • JAVA 上转型对象

    2017-01-10 13:29:19
    JAVA 上转型对象  假设,B是A的子类或间接子类,当用子类B创建一个对象,并把这个对象的引用放到A类声明的对象中时,比如:  A a;  a=new B();  那么就称对象a是子类对象b的上转型对象,对象的上转型...
  • 一个子类型的对象转型成父类,以及再次转回子类的过程中,对象的成员变量是如何变化的? 首先,验证代码如下:  class A { int x = 1; } class B extends A { int x = 2; int y = 3; } class Test { ...
  • 向上转型子类的成员变量的调用

    千次阅读 2016-08-11 21:35:49
    package StringDemo1; class Heihei { int x; } class Xixi extends Heihei { int x=7; Xixi() { super(); System.out.println(x); } public int getx() ... 向上转型 lol.x输出的是0,而不是7;
  • java 上转型对象

    2017-11-27 11:23:29
    B extends A ...1上转型对象不能操作子类新添加的成员变量与方法 。 2上转型对象可以操作父类中原有的属性和方法,无论这些方法是否被重写 3上转型对象调用的是子类继承和重写过的方法 4可以将对象的
  • 向上转型:就是把子类对象赋值给父类类型的变量。接下来用一个简单的例子来进行使用介绍: 创建父类 public class Person { public String name = "this is a people"; public String sing(Person person){ ...
  • 代码 public class Son extends Father { public int i = 100; public void show() { System.out.println("子类 方法!!!"); } public static void main(String[] args) { Father son = new Son...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 63,788
精华内容 25,515
关键字:

上转型变量