精华内容
下载资源
问答
  • java 父类 子类 类型转换【父类不能转为子类
                   

    java 父类不能转为子类 

    package tao.test;class Base { public String str = "hello Base..."; public void hello(){  System.out.println(str); }}class Sub extends Base{ public String str = "hello Sub..."; public void hello(){  System.out.println(str); }}public class BaseSubTest{ public static void main(String[] args) {  Base base = new Base();  base.hello();    // hello Base...  System.out.println(base.str);// hello Base...    Sub sub = new Sub();  // hello Sub...  sub.hello();    // hello Sub...  System.out.println(sub.str);    Base bs = new Sub();    System.out.println(bs.getClass());//class tao.test.Sub  bs.hello();     // hello Sub...  System.out.println(bs.str); // hello Base...    Sub s = (Sub) bs;   s.hello();     // hello Sub...  System.out.println(s.str);  // hello Sub...    //Sub sb = (Sub) new Base();   //System.out.println(sb.getClass());  // error  //sb.hello();  error   }}

     Base bs = new Sub(); 

    本人理解: new Sub(); 的过程中  先去执行sub的 父类的构造方法 , 再去执行sub的构造方法

     所以可以这么转型 

    而 Sub sb = (Sub) new Base();  仅仅执行sub的父类Base 的构造方法 

    所以。。。。。。。。。。。。。。 

    故而转型失败。。。。。。。 

    仅仅是揣测!!!

     

               
    展开全文
  • java父类 子类问题

    2019-10-28 17:06:11
    父类对象可以通过强制转换 用子类变量接收 ,编译不报错,运行出错,可调用父类子类方法 父类变量可以接收子类对象以及子类的子类对象,编译运行不报错,只能调用父类方法 A extends B B extends C B b = new A(); b...
    1. 子类对象可以用父类变量来接收,编译运行不报错,这种情况下,只能调用父类方法,如果父类又是其他类的子类,则可以调用父类的父类
    2. 父类对象可以通过强制转换 用子类变量接收 ,编译不报错,运行出错,可调用父类子类方法
    3. 父类变量可以接收子类对象以及子类的子类对象,编译运行不报错,只能调用父类方法

    A extends B B extends C

    B b = new A();
    b.b_method();
    b.c_method();

    A a = (A) new B();(这种是错误的)
    a.a_method();
    a.b_method();

    C c = new B();
    C c = new A();
    c.c_method();

    展开全文
  • Java 父类子类的对象初始化过程摘要: Java基本的对象初始化过程,子类的初始化,以及涉及到父类和子类的转化时可能引起混乱的情况。1. 基本初始化过程:对于一个简单类的初始化过程是:  &...

    转载自 Java 父类子类的对象初始化过程

    摘要: Java基本的对象初始化过程,子类的初始化,以及涉及到父类和子类的转化时可能引起混乱的情况。

    1. 基本初始化过程:

    对于一个简单类的初始化过程是:

        static 修饰的模块(static变量和static 块)  —> 按照代码顺序依次执行。

            |

        实例变量  及非static模块—> 按照代码顺序依次执行。

            |

        构造函数 —> 执行对应的构造函数。

    子类的初始化过程。

        父类static修饰的模块

            |

        子类static修饰模块

            |

        父类实例变量和非static块

            |

        父类对应构造函数。当子类对应构造函数中没有显示调用时调用的是父类默认的构造函数。

            |

        子类实例变量和非static块

            |

        子类构造函数


    Class的static模块是唯一的,所以只初始化一次。所有类的实例公用Class的static模块。

    static模块的初始化条件: ( From: 引用1 )

        (1)遇到new、getstatic、putstatic 或 invokestatic这4条字节码指令时,如果类还没初始化,则触发初始化。对应场景是:new实例化对象时、读或设置一个静态字段时(被final修饰,已在编译器把结果放入常量池的静态字段除外),以及调用一个类的静态方法时

        (2)对类进行反射调用时

        (3)初始化子类。但父类还没有初始化时,先触发父类初始化

        (4)当虚拟机启动时,需指定一个需要执行的主类(包含main方法),虚拟机会先初始化该类



    2. 关于覆盖和隐藏

        覆盖:被覆盖的方法相当于被擦除了,不可恢复(即使类型强制转换也无法调用)。

        隐藏:一直保存的某个位置,等需要的时候可以继续使用(类型强制转换后可以调用)。

    关于父类子类之间的覆盖和隐藏关系: (From :引用2)

        1. 父类的实例变量和类变量能被子类的同名变量隐藏。 

        2. 父类的静态方法被子类的同名静态方法隐藏,父类的实例方法被子类的同名实例方法覆盖。 

        3. 不能用子类的静态方法隐藏父类的实例方法,也不能用子类的实例方法覆盖父类的静态方法,否则编译器会异常。 

        4. 用final关键字修饰的最终方法不能被覆盖。 

        5. 变量只能被隐藏不会被覆盖,子类的实例变量可以隐藏父类的类变量,子类的类变量也可以隐藏父类的实例变量。 


    涉及的典型情况:

    前提:

    —————————————–

    class B extends A{……}

    —————————————–

    (1) B instanceB = new B();

    instanceB的初始化过程如第一部分中:子类的初始化过程。

    此时instanceB中实际上有一个super的全部信息(除了父类中被覆盖的实例方法),但是当前的引用是子类的信息(如果子类中没有的变量和方法则是从父类继承来)。


    (2)A instanceA = new B();

    此时父类A的变量和静态方法会将子类的变量和静态方法隐藏。instanceA此时唯一可能调用的子类B的地方就是子类B中覆盖了父类A中的实例方法。

    执行 B instanceB = (B) instanceA; 后

    此时instanceB相当于 B instanceB = new B();


    注意:

        (1) 这里唯一的覆盖的情况:父类的实例方法被子类的同名实例方法覆盖。

        这里方法调用变量时,实际上是带有一个默认的this的。也就是此实例方法中调用的是当前Class的值。涉及到继承的情况时,要十分注意super,this的情况。

        (2) 在初始化的时候,有两个阶段。第一步是申请空间,第二步是赋值。

        具体见:

            static的值和final static值在初始化时的区别。(引用1)

            子类覆盖父类实例方法时,调用子类的实例方法,而此时子类的实例方法调用了子类中的变量(此时static变量已经初始化,但是实例变量并没有初始化)。(引用2)


    这段代码来自引用2,如何精炼,如此有趣。值得一看。

    1. class Parent{
    2. int x=10;
    3. public Parent(){
    4. add(2);
    5. }
    6. void add(int y){
    7. x+=y;
    8. }
    9. }
    10. class Child extends Parent{
    11. int x=9;
    12. void add(int y){
    13. x+=y;
    14. }
    15. public static void main(String[] args){
    16. Parent p=new Child();
    17. System.out.println(p.x);
    18. }
    19. }


    引用 1. 类加载机制:

    http://blog.csdn.net/kai_wei_zhang/article/details/8234146 

    引用 2. 隐藏和覆盖,以及一个好例子:

    http://www.cnblogs.com/binjoo/articles/1585342.html

    引用 3. 隐藏和覆盖

    http://renyanwei.iteye.com/blog/258304 

    引用 4. 基本的初始化过程

    http://www.cnblogs.com/miniwiki/archive/2011/03/25/1995615.html 


    展开全文
  • java父类子类继承问题

    2019-12-25 17:01:14
    java子类继承父类,在初始化时,初始化子类可读取父类的方法,但如果初始化父类,则不可读取子类的方法。 创建对象时,Father c = new Child() 子类继承父类时,针对覆写的方法,调用的是子类方法,在静态属性上...

        java的子类继承父类,在初始化时,初始化子类可读取父类的方法,但如果初始化父类,则不可读取子类的方法。

        创建对象时,Father c = new Child()   子类继承父类时,针对覆写的方法,调用的是子类方法,在静态属性上,不存在覆写,还是用的是父类的属性

    public class Father {
        protected  int age;
        public Father(){
            age=38;
        }
        void eat(){
            System.out.println("父亲吃饭");
        }
    }
    public class Child extends Father {
        protected int age;
        public Child(){
            age=18;
        }
        @Override
        void eat(){
            System.out.println("孩子吃饭");
    //        super.eat();  使用的是父类的该方法
        }
        void play(){
            System.out.println("孩子玩游戏");
        }
    }
    
    public class Test {
    
        public static void main(String[] args) {
    
            Father c = new Child();
            c.eat();       //输出为 “孩子在吃饭” 因为复写了父类的eat方法
    //        c.play();
            System.out.println("年龄:"+ c.age);  //输出为“年龄:40” 属性/变量不存在重写和覆盖
        }
    }

    在父类子类加载顺序上,大致可以分为

    1.父类静态代码块 (  java虚拟机加载类时,就会执行该块代码,故只执行一次)

    2 .子类静态代码块 (  java虚拟机加载类时,就会执行该块代码,故只执行一次)

    3.父类属性对象初始化

    4.父类普通代码块(每次new,每次执行)

    5.父类构造函数(每次new,每次执行)

    6.子类属性对象初始化

    7.子类普通代码块(每次new,每次执行)

    8.子类构造函数(每次new,每次执行)

    9.子类重写父类方法,调用时会调用子类重写之后的方法

    public class A {
        public static String AAA = "A静态代码";
    
        public A(){
            System.out.println("A");
        }
    
        B b = new B();
    
    }
    
    public class B {
        public static String BBB = "B静态代码";
        public B(){
            System.out.println("B");
        }
    }
    public class C extends A {
        public static String CCC = "C静态代码";
        B b = new B();
        public C(){
            System.out.println("C");
        }
    
        public static void main(String[] args) {
            new C();
        }
    
    }

    运行结果BABC

    进入程序后,先进入C类的父类,在A类中先加载了new B()方法【输出B】,然后执行A的构造方法【输出A】,进入C类,执行C的new B()【输出B】,执行C的构造方法【输出C】

     

    展开全文
  • JAVA父类子类转化问题

    2018-10-28 11:06:25
    1、可以用父类去声明子类对象 2、可以将父类对象强转为子类对象,前提是只有父类对象本身就是用子类new出来的时候, 才可以在将来被强制转换为子类对象 实例如下: package hrx; public class TestExtends { ...
  • 1. 子类可以转父类,不过这个父类仍然是子类。 2. 只有由这种子类转成的父类,才可以转化成相应的子类,否则父类不能转子类。
  • java 父类子类有同名方法时如何调用

    万次阅读 多人点赞 2017-10-22 12:15:44
    父类引用默认调用子类重写的方法 如果父类的引用p指向了子类的实例,则通过这个引用p访问同名方法时,调用的是子类重写的方法。 父类引用p可以指向不同的子类,调用不同子类重写的不同的同名方法,进而达到类间...
  • java父类子类执行顺序

    2019-06-15 11:17:08
    parent class static code block! child class static code block! parent class ordinary code block! parent class construction method ...静态优先,父类优先,代码块优先,构造优先,方法重写后只执行重写
  • Java 转型问题其实并不复杂,只要记住一句话:父类引用指向子类对象。 什么叫父类引用指向子类对象? 从 2 个名词开始说起:向上转型(upcasting)、向下转型(downcasting)。 举个例子:有2个类,Father 是父类,...
  • 父类子类中的同步方法是共用的同一个
  • java父类子类方法调用问题

    千次阅读 2019-03-08 16:04:26
    2.继续往下setvalue(getValue()-3),先执行getvalue,由于子类中无getvalue()于是调用父类方法getvalue(),进入方法value值变为11,接着执行finally语句this.setvalue,this指代子类B,于是调用B中setvalue(),...
  • 无意中发现的这个有趣的问题。...还是父类子类的name互相不相干? 通过赋值后,最后会输出什么?见如下 public class TestTest extends son { String name; // 子类中的name void value(){ name ="a";
  • Java父类子类加载顺序

    2011-08-08 11:07:21
    父类静态变量 父类静态初始化块 子类静态变量 子类静态初始化块 父类变量 父类初始化块 父类构造器 子类变量 子类初始化块 子类构造器 静态在类第一次加载时有效。
  • Java父类子类成员变量初始化

    千次阅读 2015-09-06 21:48:37
    初始化过程是这样的:  1.首先,初始化父类中的静态成员变量和静态代码块,按照在程序中出现的顺序初始化;  2.然后,初始化子类中的静态...4.最后,初始化子类的普通成员变量和代码块,在执行子类的构造方法;
  • java父类子类构造方法及方法的调用

    千次阅读 2019-04-13 13:43:44
    所以,即使我在finally那里改变了value的值,它也不会返回给A类的成员value,getValue()的结果仍然是11,我去掉了子类B弄了个简化版的 public class Testfina { static class A{ private int value; public ...
  • 子类继承父类
  • 关于Java父类子类那点事

    千次阅读 2012-10-03 11:01:12
    如果被重写了,那么:父类 a=new 子类(),运行的时候,调用的是子类的private方法。测试代码如下: package static_; public class M {  public static void test() {  System.out.println("in m");  }  ...
  • java中继承时代码块,方法,变量的执行顺序与调用
  • 废话不多说,直接上代码,我们先创建父类SuperClass,代码如下:public class SuperClass { static{ System.out.println("1.SuperClass Status Block"); } { System.out.println("3.SuperClass ...
  • 一段代码解析JAVA父类子类构造过程

    千次阅读 2014-03-20 00:20:35
    注意在这个时候代码已经全部放进了方法区,所以子类的add函数在内存中是存在的,所以子类add函数覆盖了父类的add函数。 调用了子类的add函数,里面有一个x,这个x是父类还是子类的呢? 是子类的,因为子类有一...
  • 1、第一个文件Print.java public class Print {  public Print(String s){  System.out.print(s + " ");  } } 2、第二个文件Test1.java public class Test1 {  ...
  • package page6;... System.out.println("我是父类的构造方法"); } static{ System.out.println("我在父类静态块当中"); } { System.out.println("我在父类非静态块当中"); } } pub
  • 关于这个问题,一般初中级面试中都会遇到,还记得我当初实习找工作的时候也遇到了这个问题,现在都...在《java核心技术卷 1》中将 ==归类于关系运算符; ==常用于相同的基本数据类型之间的比较,也可用于相同类型的...
  •  下面做的实验,主要是验证 当new 一个子类时,子类和它的父类中 静态成员变量,静态代码块,实例成员变量,实例代码块,构造方法 这5部分的执行顺序  父类代码: package _test; public abs
  • 来吧,直接上代码~ /** * Created by gjj on 2018-04-18. */ public class Father { ...父类静态代码块"); } { System.out.println("父类构造代码块"); } public Fathe...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,242
精华内容 15,296
关键字:

java父类子类

java 订阅