精华内容
下载资源
问答
  • 1.基本数据类型 基本数据类型: 子类可以强转成父类,因为小范围可以强转...java中子类强转父类,实际上依然是子类; 该引用只能调用父类中定义的方法和变量; 如果子类中重写了父类中的一个方法,那么在调用这个方法

    1.基本数据类型

    • 基本数据类型:
      • 子类可以强转成父类,因为小范围可以强转大范围,不会有数据丢失。
      • 父类也可以强转成子类,但是因为大范围强转成小范围,所以会有数据丢失。

    2.Java 继承

    继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

    Java 子类强转父类

    父类引用指向子类对象:

    java中子类强转父类,实际上依然是子类;

    该引用只能调用父类中定义的方法和变量;

    如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,将会调用子类中的这个方法;

    // A是父类,B是子类
    A a = new A();
    a.setName("a1");
    a.sayA(); // sayA
    
    B b = new B();
    b.setName("b1");
    b.setSex(true);
    b.sayA(); // sayA from B
    b.sayB(); // sayB
    
    // Java中的对象进行类型提升,依然保持其原有的类型。
    A a2 = (A) b; // 子类强转父类,其实仍然是子类
    System.out.println(a2.toString()); // B [name=b1, age=0, sex=true]
    // 该引用只能调用父类中定义的方法和变量; 
    // a2.sayB(); // The method sayB() is undefined for the type A 报错
    // 如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,将会调用子类中的这个方法;
    a2.sayA(); // sayA from B a2其实是B,调用的是B方法
    

    Java 父类强转子类

    只有父类对象本身就是用子类new出来的时候, 才可以在将来被强制转换为子类对象.

    // B b2 = (B) a; // atest.A cannot be cast to atest.B a是A,转不成B
    // 只有父类对象本身就是用子类new出来的时候, 才可以在将来被强制转换为子类对象.
    B b2 = (B) a2; // a2其实是B,可以转成B
    System.out.println(b2.toString()); // B [name=b1, sex=true]
    b2.sayA(); // sayA from B
    b2.sayB(); // sayB
    
    展开全文
  • java中子类强转父类,实际上依然是子类; 该引用只能调用父类中定义的方法和变量; 如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,将会调用子类中的这个方法; // A是父类,B是子类 A a = new A...

    Java 继承

    继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

     

    Java 子类强转父类

    父类引用指向子类对象:

    java中子类强转父类,实际上依然是子类;

    该引用只能调用父类中定义的方法和变量;

    如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,将会调用子类中的这个方法;

    复制代码

    // A是父类,B是子类
    A a = new A();
    a.setName("a1");
    a.sayA(); // sayA
    
    B b = new B();
    b.setName("b1");
    b.setSex(true);
    b.sayA(); // sayA from B
    b.sayB(); // sayB
    
    // Java中的对象进行类型提升,依然保持其原有的类型。
    A a2 = (A) b; // 子类强转父类,其实仍然是子类
    System.out.println(a2.toString()); // B [name=b1, age=0, sex=true]
    // 该引用只能调用父类中定义的方法和变量; 
    // a2.sayB(); // The method sayB() is undefined for the type A 报错
    // 如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,将会调用子类中的这个方法;
    a2.sayA(); // sayA from B a2其实是B,调用的是B方法
    

    复制代码

     

    Java 父类强转子类

    只有父类对象本身就是用子类new出来的时候, 才可以在将来被强制转换为子类对象.

    复制代码

    // B b2 = (B) a; // atest.A cannot be cast to atest.B a是A,转不成B
    // 只有父类对象本身就是用子类new出来的时候, 才可以在将来被强制转换为子类对象.
    B b2 = (B) a2; // a2其实是B,可以转成B
    System.out.println(b2.toString()); // B [name=b1, sex=true]
    b2.sayA(); // sayA from B
    b2.sayB(); // sayB

    复制代码

     

     

    扩展:

    对于list也是这样

    复制代码

    List<A> aList = new ArrayList<A>();
    aList.add(a);
    aList.add(b);
    for (A item : aList) {
        System.out.println(item.getClass() + ":" + item.toString());
        // class atest.A:A [name=a1]
        // class atest.B:B [name=b1, sex=true]
    }

    复制代码

     

    附录:

    复制代码

      public class A {
    
            private String name;
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            public void sayA() {
                System.out.println("sayA");
            }
    
            @Override
            public String toString() {
                return "A [name=" + name + "]";
            }
        }
        
        public class B extends A {
    
            private boolean sex;
    
            public boolean isSex() {
                return sex;
            }
    
            public void setSex(boolean sex) {
                this.sex = sex;
            }
    
            @Override
            public void sayA() {
                System.out.println("sayA from B");
                // super.sayA();
            }
    
            public void sayB() {
                System.out.println("sayB");
            }
    
            @Override
            public String toString() {
                return "B [name=" + this.getName() + ", sex=" + sex + "]";
            }
        }
    
    
        public static void main(String[] args) {
    
            // A是父类,B是子类
            A a = new A();
            a.setName("a1");
            a.sayA(); // sayA
    
            B b = new B();
            b.setName("b1");
            b.setSex(true);
            b.sayA(); // sayA from B
            b.sayB(); // sayB
    
            // Java中的对象进行类型提升,依然保持其原有的类型。
            A a2 = (A) b; // 子类强转父类,其实仍然是子类
            System.out.println(a2.toString()); // B [name=b1, sex=true]
            // 该引用只能调用父类中定义的方法和变量; 
            // a2.sayB(); // The method sayB() is undefined for the type A 报错
            // 如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,将会调用子类中的这个方法;
            a2.sayA(); // sayA from B a2其实是B,调用的是B方法
            // B b2 = (B) a; // atest.A cannot be cast to atest.B a是A,转不成B
            // 只有父类对象本身就是用子类new出来的时候, 才可以在将来被强制转换为子类对象.
            B b2 = (B) a2; // a2其实是B,可以转成B
            System.out.println(b2.toString()); // B [name=b1, sex=true]
            b2.sayA(); // sayA from B
            b2.sayB(); // sayB
    
            List<A> aList = new ArrayList<A>();
            aList.add(a);
            aList.add(b);
            for (A item : aList) {
                System.out.println(item.getClass() + ":" + item.toString());
                // class atest.A:A [name=a1]
                // class atest.B:B [name=b1, sex=true]
            }
    
        }
    展开全文
  • java类型强转

    2017-07-27 13:49:00
    然后对象,只有继承关系的才能强转,改变的只是引用,而且向上转型是安全的,把你转为人类是安全的,你还是你,只是现在别人看你是个人类,看不清你的个性化细节,他们能知道的也仅仅局限于人类提供给别人访问的...

    知乎:

    首先基本数据类型不是对象,强转改的是值,分为有损和无损,有损会丢失数据细节。

    然后对象,只有继承关系的类才能强转,改变的只是引用,而且向上转型是安全的,把你转为人类是安全的,你还是你,只是现在别人看你是个人类,看不清你的个性化细节,他们能知道的也仅仅局限于人类提供给别人访问的属性和方法,记住你还是你。向下转型是有可能出错的,只要事先知道你是你的情况下才能把人类转成你,如果把另一个人类转成你是必定会报错的。总之改的只是这个对象的引用,对象还是老老实实的待在堆内存中。

    作者:知乎用户
    链接:https://www.zhihu.com/question/35262854/answer/61990920
    来源:知乎
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
     
    博客:
     

    总结  

    类型转换只要转换的类原来就在内存中存在。引用向下强转和向上转型都是可行的,只是换了指针而已

    转载于:https://www.cnblogs.com/hong2016/p/7244446.html

    展开全文
  • java 中对象数组不能强制转换成相应的子类数组  因为两个数组之间不...在指定的目录下进行的加载,当自定义加载器时,classpath 如果只有%JAVA_HOME%\lib则程序的.class文件只能在指定的路径下 1.5 之后可以不

    java 中对象数组不能强制转换成相应的子类数组

           因为两个数组之间不具有继承关系


    展开全文
  • java 对象之间的强转

    千次阅读 2019-02-28 09:06:37
    根据java多态,子类继承父类,子类可以强转为父类,说明子类就是父类,但是父类却不是子类,所以父类不能强转为子类 在继承关系中,如果一个实例的数据类型是某个子类,那它的数据类型也可以被看做是父类。但是,反...
  • java强转_java 强制转换

    2021-03-05 14:54:16
    Java中由于继承和向上转型,子类可以非常自然地转换成父类,但是父类转换成子则需要强制转换。因为子类拥有比父类更多的属性、更强的功能,所以父类转换为子需要强制。那么,是不是只要是父类转换为子类就会...
  • 1.引用数据类型(基本数据性的包装)之间不可以直接强转,基本数据类型之间可以直接强转。(基本数据类型)引用数据类型 可以这么去转 2.Char类型储存的是字符的Ascii码 泛型的好处:1.减少的膨胀(减少代码量...
  • 强转

    2019-10-08 18:46:01
     引用类型之间的转换,只能把一个父类变量转换成子类型,没有继承关系的,无法进行类型转换。如果想把一个父类转换成子,那么这个父类的对象是子类的实例才行。  示例:  有一个double类型的数值d想给...
  • Java中的数组和List集合以及类型强转

    万次阅读 2018-04-19 19:01:29
    java中,集合操作有两种方式...也都知道其实泛型在到字节码层面上时,会被擦除,虽然字节码中还会保留泛型参数(可以利用反射看到),但对真实的的并不产生多大影响。 那么,对于List来说,如果泛型存在继承关...
  • 关于Java继承的 向上转型和向下转型

    千次阅读 2016-03-25 19:58:47
    Java中, 向上转型(upcasting)和向下转型(downcasting)的前提,必须是有“继承关系”,向上转型是自动的,向下转型需要进行强转。例如:/**定义了一个“父”*/ public class Father { /**姓名*/ private ...
  • 多态 在程序中同一个方法,由于参数类型不同导致不同效果的现象就叫...新一个动物Animal,让Dog,Cat类继承Animal程序中的代码如下: public class Animal { private String name;public String getName() {
  • 也都知道其实泛型在到字节码层面上时,会被擦除,虽然字节码中还会保留泛型参数(可以利用反射看到),但对真实的的并不产生多大影响。 那么,对于List来说,如果泛型存在继承关系,是否可以强行...
  • 1、思考无论是ssm框架,还是springboot,只要使用mybatis都会使用到对象关系映射;实际项目中,往往除了表对象的基础属性,还需要加很多其他的...但是问题又来了,在java中父类不能强转成子,表对象有时候10+的...
  • Java泛型子类继承调用

    千次阅读 2016-01-17 22:37:47
    假设有这么一个需求:在一个函数中传入一个对象,并给出这个对象的及其一个子类,如果这个对象是其子类的实例,那么就执行子类的方法,如果不能强转那么就执行这个父类本身的方法。或者这样的需求:还是给出一个...
  • 1、思考无论是ssm框架,还是springboot,只要使用mybatis都会使用到对象关系映射;实际项目中,往往除了表对象的基础属性,还需要加很多其他的...但是问题又来了,在java中父类不能强转成子,表对象有时候10+的...
  • 1、子类可以向父类转型 2、父类向子类转型需要强转 3、没有继承关系的,不能转 4、实现可以向接口转型 2、接口向实现转型需要强转 3、没有实现关系的,不能转 ...
  • 强制类型转换的使用 强制类型转换 VS 专用转换方法 ----------- android培训、java培训、java... 转换的两个 (A和B) 之间不具有继承关系使用强制类型转换 [1]. 类型A的对象强转到类型B的引用 (对象 ---> 引用) 直接
  • Java多态与抽象

    2020-08-10 16:55:11
    nceof 判断是否属于这一及该的子类 基类的引用指向子类的对象,只能使用基类的属性,不能使用子类特有的属性 向上转型 向下转型(强转) 动态绑定: 在程序运行期间 多态:就是程序在运行过程中根据基类的...
  • java web之HttpServlet

    千次阅读 2018-09-01 16:53:18
    转型时,由父接口的ServletRequest转为子类的HttpServletRequest,需要强转继承GenericServlet时) 此时的HttpServletRequest.getMethod()是获取请求的类型(get/post) 重写servlet方法httpServletRe...
  • Object  常用方法:clone(),... 报错原因:clone()方法的返回值是Object型,然而TestClone继承Object,所以是大类型转小类型需要强转    报错原因:undandled exception type CloneNotSupportedExcept...
  • 继承关系 2.方法重写 3.父类引用指向子类 例子: 父类引用子类就是向上转型 此时访问成员变量显示的是父类的变量,而成员方法则先检查父类有没有该方法,若没有则显示错误,要是有的话就调用子类的同名方法。 ...
  • 要有(继承,实现)关系 2.要有方法重写,否则没有意义,但是不会报错。 3.要有父类引用指向子类对象 成员访问特点: 成员变量: 编译看左边(父类),运行看左边(父类) 成员方法: 编译看左边(父类)...
  • java 多态

    2017-04-01 14:09:00
    * 1、继承继承普通继承抽象、实现接口) * 2、重写 * 3、父类引用指向子类对象 * ------------------------------------- * java 父类引用不能访问子类成员变量、子类方法 * 需要强转...
  • Java泛型

    2020-11-22 17:45:13
    早期Java是使用Object来代表任意类型的,但是使用Object来代表任意类型向下转型有强转的问题,强转的过程中就可能会发生异常。有了泛型就可以在编译期确定类型,就不需要强转了,只要编译期不报错,运行期间就不会...
  • Java只有单继承,即一个最多只能继承一个; 所有,如果没有调用extends,那么默认继承Object强转 父类、子类可以互相转,但子类之间不能转; 子类向上转的时候,就需要用()强制转型,举例: Object...
  • JAVA强制类型转换的那些坑!!!

    千次阅读 2018-12-11 20:11:16
    也就是说,父类强转成子类,以及某个类强转成任何接口,都不会在编译时报错。只会在运行时报错。 比较典型的例子,object对象,可以在编译期强转成任何对象(因为它本身是所有对象的父类)、以及任何接口。却不会...
  • 文章目录oop基础包(package)类(class)构造器面向对象(oop)的三大特征封装(encapsulation)继承(extends)多态案例重写与重载重写(Override)重载子父类类型强转Person类Student类SmallStudent类Test类强转...

空空如也

空空如也

1 2 3 4
收藏数 71
精华内容 28
关键字:

java继承类强转

java 订阅