精华内容
下载资源
问答
  • 创建子类对象时,Student s = new Student("school"); 该构造方法中没有显示调用父类的 构造方法,但还是编译成功了,![图片说明](https://img-ask.csdn.net/upload/201604/14/1460599555_25628.png) 该构造方法...
  • Father father = new Son(); 这样的吧,这有一种专业说法,叫“父类引用指向子类对象”。 首先 new Son();... 就是将父类引用指向子类对象,这是java里很常用的用法。这时候如果用father调用方法father,met...

     Father father = new Son(); 这样的吧,这有一种专业说法,叫“父类引用指向子类对象”。
    首先 new Son();是肯定动态创建了一个子类对象的 。
    Father father 则是一个创建了一个父类引用对象。
    Father father = new Son(); 就是将父类引用指向子类对象,这是java里很常用的用法。
    这时候如果用father调用方法father,method() ;如果method()方法只有父类有,子类里没有写。那么就调用父类里那个方法体。如果在子类里有对method()进行了重写(注意是重写不是重载), 那么就调用子类里的那个方法体

    子类构造器的默认第一行就是super(),默认调用直接父类的无参构造。这也就是一旦一个子类的直接父类没有无参的构造的情况下,必须在自己构造器的第一行显式的指明调用父类或者自己的哪一个构造器。

      父类中的实例方法可以被重写

    但静态方法,静态属性,非静态属性都不可以被重写,实现多态。

    例:

    public class A {

        public static String staticStr = "A's static field"

        public String nonStaticStr = "A's nonstatic field"

        public static void staticMethod(){ 

            System.out.println("A's static method"); 

        

        public void nonStaticMethod(){ 

            System.out.println("A's nonstatic method"); 

        

    public class extends A{

        public static String staticStr = "B's static field"

        public String nonStaticStr = "B's nonstatic field"

        public static void staticMethod(){ 

            System.out.println("B's static method"); 

        

    }

    public class extends A{

       

    }

    public class Test { 

       

        public static void main(String[] args) { 

            C c = new C(); 

            System.out.println(c.nonStaticStr);  //A's nonstatic field

            System.out.println(c.staticStr);  //A's static field

            c.staticMethod(); //A's static method

            

            System.out.println("-------------------------------"); 

               

            A c1 = new C(); 

            System.out.println(c1.nonStaticStr);  //A's nonstatic field

            System.out.println(c1.staticStr);  //A's static field

            c1.staticMethod(); //A's static method

              

            // 以上这说明java中静态属性和静态方法可以被继承

             

            System.out.println("-------------------------------"); 

            B b = new B(); 

            System.out.println(b.nonStaticStr); // B's nonstatic field

            System.out.println(b.staticStr);   //B's static field

            b.staticMethod();  //B's static method

             

            System.out.println("-------------------------------"); 

            A b1 = new B(); 

            System.out.println(b1.nonStaticStr);  //A's nonstatic field

            System.out.println(b1.staticStr);  //A's static field

            b1.staticMethod(); //A's static method

            //b1.nonStaticStr  输出的是父类的非静态属性,说明非静态属性不可以被重写,不能实现多态

            //b1.staticStr     输出的是父类的静态属性,说明静态属性不可以被重写,不能实现多态

            //b1.staticMethod()输出的是父类A的静态方法,不是子类B改写后的,所以没有实现多态

             

             

            //结论是:静态属性和静态方法只是可以继承没有表现出多态性。

            //因为静态方法和静态属性没有采用动态绑定。具体表现就是,

            //将子类实例向上转型则会调用到基类中的静态方法和属性,

            //不转型就调用子类自身的静态方法和属性。

            //编译器不推荐通过实例去调用静态方法和属性,因为这种调用方式容易造成混淆。

             

            //实际上,在Java的规范中,Java对于类的方法和属性采用了两种完全不同的处理机制:

            //对于方法,使用重载机制实现了多态性;对于属性,使用的是同名属性隐藏机制。

            //所谓的同名属性隐藏机制是指:在具有父子关系的两个类中,

            //子类中相同名字的属性会使得从父类中继承过来的同名属性变得不可见,

            //不管类型是否一致,名称一致的两个属性就是同名属性。

            //在子类中,无法简单地通过属性名称来获取父类中的属性,

            //而是必须通过父类名称加属性名称(super.变量名)的方法才可以访问父类中的该属性。

            //一般而言,为了代码容易阅读,极其不建议在父类和子类中使用同名属性。

        

       

    }

     

    展开全文
  • 子类的方法可以访问父类的实例变量,

    子类的方法可以访问父类的实例变量,子类可以获得父类的成员变量和方法,但弗雷德方法不能访问子类的实例变量,但是在极端情况下,也是可以访问的。

    讲到这些问题,就涉及到继承时,当我们去创建一个类的时候,构造方法的执行顺序,将是很关键的一个问题,子类的先执行还是父类的先执行,构造函数和实例变量的初始化的执行顺序又是怎么样的呢?我们通过一段代码实例来讲解一些这个问题

    class Person {
    private String name ="jiaojiao" ;
    public Person () {
    this.display ();
    }
    public void display (){
    system.out.println(name);
    }
    }
    class Student extends Person {
    private String name = "jiaojiao";
    public Student (){
    
    }
    public void display (){
    System.out.println(name);
    }
    }
    public Class Test {
    public void main(String []args){
    new Student ();
    }
    }

    执行完上面的程序将会打印出什么来呢,该段代码编译的时候,首先JVM要为两个类创建一个空间,这段空间将会用来保存该类中的一些类变量,然后当我们创建了一个Student对象,首先,开始执行时,为类里面的每一个实例变量分配一段内存,用来保存这些变量,这会开辟出两个空间来,分别用来保存这两个类中的实例变量,在这个时候是没有对其进行初始化的,只是为它分配好空间,等着来盛放数值。初始化的操作是在构造函数执行之前执行的,那么我们再来分析上面的代码,分配出两个空间之后,首先要执行的是父类的构造函数,执行到过程为 name = "jiaojiao";然后是this.dispaly();

    this现在的指向是什么呢,java中this表示的是当前正在初始化的对象,也就是Student的实例,所以当执行dispaly()方法的时候输出的就是Student类中的name实例变量,而此时Student类中并未执行对于实例变量的初始化操作,所以说输出的值是默认的值,也就是空。如果我们直接在Person类中加一行输出的代码,我们得到的值将是Person类中的实例变量的初始化的值。同时在这里又出现的问题就是this的编译类型运行类型的问题,上面当其执行的时候调用的是当前正在初始化的对象,当变量编译时的类型和运行时的类型不同时,通过该变量访问它引用的对象的实例变量时,该实例变量的值是由声明该变量的编译类型决定的,但通过该变量调用方法时,是由其当前实际引用的对象来决定的。这也就很好的解释了上面的问题,首先第一个是调用的方法,所以变量调用的就是实例变量是当前正在被初始化的,然后直接调用的调用的时候,我们用的是当前对象中的,我们所说的父类调用子类方法,无非就是编译类型和运行类型之间的问题,产生了一种调用了子类的方法的错觉。

    展开全文
  • 答案是:创建子类对象时不会创建父类对象。我们创建子类对象时,只是说创建了父类空间,并进行了初始化。如果说创建子类的时候就会创建它的父类,那内存空间中不都是Object类的对象吗?(想想java的设计师也不会这么...

    答案是:创建子类对象时不会创建父类对象。

    我们创建子类对象时,只是说创建了父类空间,并进行了初始化。如果说创建子类的时候就会创建它的父类,那内存空间中不都是Object类的对象吗?(想想java的设计师也不会这么做的)

    下面转自知乎

    作者:祖春雷
    链接:https://www.zhihu.com/question/51920553/answer/128761716
    来源:知乎

    这个问题主要涉及到java对象的内存布局。

    java对象的内存布局是由对象所属的类确定。也可以这么说,当一个类被加载到虚拟机中时,由这个类创建的对象的布局就已经确定下来的啦。

    Hotspot中java对象的内存布局:
    每个java对象在内存中都由对象头和对象体组成。

    对象头是存放对象的元信息,包括该对象所属类对象Class的引用以及hashcode和monitor的一些信息。
    对象体主要存放的是java对象自身的实例域以及从父类继承过来的实例域,并且内部布局满足由下规则:
    规则1:任何对象都是8个字节为粒度进行对齐的。
    规则2:实例域按照如下优先级进行排列:长整型和双精度类型;整型和浮点型;字符和短整型;字节类型和布尔类型,最后是引用类型。这些实例域都按照各自的单位对齐。
    规则3:不同类继承关系中的实例域不能混合排列。首先按照规则2处理父类中的实例域,接着才是子类的实例域。
    规则4:当父类中最后一个成员和子类第一个成员的间隔如果不够4个字节的话,就必须扩展到4个字节的基本单位。
    规则5:如果子类第一个实例域是一个双精度或者长整型,并且父类并没有用完8个字节,JVM会破坏规则2,按照整形(int),短整型(short),字节型(byte),引用类型(reference)的顺序,向未填满的空间填充。

    以上就是java对象的内存布局的规则。

    接下来说一下java对象的实例化方法,也就是常见的<init>方法。
    当我们new一个对象时,其实jvm已经把这个对象的整个空间已经分配好,并且整个对象的实例域布局已经确定下来啦。
    实例化方法<init>就是将对象实例域的值设置到相应空间中。

    <init>方法以调用父类的<init>方法开始,以自身构造方法作为结束。实例域的声明与实例初始化语句块的位置关系会影响编译器生成的<init>方法的字节码顺序。

    还是以一个例子说明一下:
    class Parent {
    private short six;
    private int age;
    }

    class Sub extend Parent{
    private String name;
    private int age;
    private float price;
    }

    当前Sub对象的内存布局由下:
    &amp;amp;lt;img src=&quot;https://pic1.zhimg.com/50/v2-4ce1b61927241c3d7eea75248900b552_hd.jpg&quot; data-rawwidth=&quot;317&quot; data-rawheight=&quot;421&quot; class=&quot;content_image&quot; width=&quot;317&quot;&amp;amp;gt; super所谓的父类存储空间的表示到底是什么意思?
    这里的super存储我想就是绿色的那个位置吧!

    在java继承中,我们说子类继承了父类的所有属性和方法,但是有不能直接使用父类中的private属性和方法。这是不是矛盾呢?

    其实这并不矛盾,通过上面的java内存布局我们知道,子类确实继承了父类的所有属性和方法,即拥有了父类的所有的属性和方法,但是拥有不代表可以使用。

    比如说:你在银行存了5年的定期存款,这些钱是你所拥有的,但是你现在不能使用它。


    展开全文
  • //变量是人可以创建一个学生对象(需要一个人可以来一个学生)父类为变量可以创建子类的对象 3、如果父类对象引用指向的实际是一个子类对象,那么这个父类的引用可以强制类型转换为子类的对象引用。 例:Person p=...
    • 父类对象与子类对象之间的转换类似于基本数据类型之间的强制转换,存在继承关系的父类对象与子类关系之间,在一定条件下也是可以相互转换的。
      1、子类对象可被视为父类的一个对象,而父类对象不可视为子类的对象。
      2、变量是父类可以创建一个子类对象。
      例如:Person p=new Student();//变量是人可以创建一个学生对象(需要一个人可以来一个学生)父类为变量可以创建子类的对象
      3、如果父类对象引用指向的实际是一个子类对象,那么这个父类的引用可以强制类型转换为子类的对象引用。
      例:Person p=new Student();
      Student s=(Student)p;
    //父类
    public class Person {		
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    	}
    }
    //子类
    public class Student extends Person {
    	
    	public static void main(String[] args) {
    		Student s1=new Student();
    		//子类对象和父类对象的转换
    		Person p1=new Person();//可以创建父类的对象
    		Person p2=new Student();//变量是父类可以创建一个子类对象(需要一个人可以来一个学生)父类为变量可以创建学生对象
    		Student s2=(Student)p2;//虽然说子类为变量不可以创建父类的对象,但是可以强制类型转换为子类的对象(因为p2是以父类为变量创建的子类对象)
    		Student s3=(Student)p1;//可以编译但是不可运行(因为是以子类为变量强制类型转换的是以父类的对象)
    	}
    }
    
    
    展开全文
  • Java父类子类方法调用顺序 父类 FatherClass package 父类与子类方法调用顺序; /** * 父类 * @author shundong * */ public class FatherClass { private int i =0; private String name; /** * 父类无参...
  • 答案是否定的,在Java创建一个子类对象是不会创建父类对象的。 通过一个实例来证明:实例:父类Base.javapublic class Base { private String str; public Base() { System.out.println("Base()"); ...
  • 之前一直没弄懂的父类引用指向子类对象,即 Person,是Student的父类,则这个父类引用...则使用父类引用指向子类对象,可以成功创建对象(即可以且只能使用这个父类里面的方法) 用法Person p = new Student(); ...
  • 关于java创建子类对象时,父类对象到底创建不创建 一个对象可以理解为一个房子,而一个类只是规定了什么地方要放什么东西,比如客厅要放沙发,餐厅要有餐桌 创建一个新对象,就是建造一栋新房子,如果你不去初始化...
  • 父类引用指向子类对象指的是: 例如父类Animal,子类Cat,Dog。其中Animal可以是类也可以是接口,Cat和Dog是继承或实现Animal的子类。 Animal animal = new Cat(); 即声明的是父类,实际指向的是子类的一个对象。 ...
  • Java规定:一个父类可以有多个子类,但是一个子类只有一个父类子类通关键字extends继承父类。 //父类: public class FatherClass { int a=3; FatherClass(){ System.out.println("父类无参构造函数"); } ...
  • Java子类在创建子类的时候,不会创建父类对象,只是会调用父类的构造器,对从父类中继承过来的属性和方法进行初始化。特别要注意,调用父类的构造方法,并不意味这创建父类对象 具体详解 ...
  • 在了解java类加载机制的时候,我们有时候会遇到一些谁先谁后的问题,我们当然不能一眼看出来,我们需要实践代码来总结结论 下面是我封装好两个类 public class People { private String name; private int age; ...
  • Java 父类引用指向子类对象

    千次阅读 2013-10-01 20:10:55
    1.背景 面向对象的三大特点,继承,封装,多态。何为多态(Polymorphism)?...在程序语言中,通过子类继承父类,然后重写覆盖的方法,在创建对象时,将父类的引用指向子类对象,就可以利用父类引用调
  • JAVA创建子类对象不会实例化父类对象 学习java之初大家难免会遇到很多抽象的理论,在此分享下自己的微薄浅见,希望能给予读者略有帮助. 我们都知道,在java中子类会继承父类的一切属性(成员变量)和方法(构造方法除外)....
  • Java多态性详解——父类引用子类对象

    万次阅读 多人点赞 2013-05-21 21:07:02
    面向对象编程有三个特征,即封装、继承和多态。  封装隐藏了类的内部实现机制,从而可以在不影响使用者的前提下改变类的内部结构,同时保护了数据。  继承是为了重用父类代码,同时为实现多态性作准备。那么什么...
  • 实际过程是【先创建子类对象,创建过程进行一半,再去创建父类对象,父类对象创建完毕,再接着创建子类对象。】这种递归的流程。 =========以下 了解。勿纠结============= 涉及到一道经典面试题:。。。。 ...
  • 向上转型:就是把子类对象赋值给父类类型的变量。接下来用一个简单的例子来进行使用介绍: 创建父类 public class Person { public String name = "this is a people"; public String sing(Person person){ ...
  • 1、java父类引用指向子类对象时动态绑定针对的只是子类重写的成员方法; 2、父类引用指向子类对象时,子类如果重写了父类的可重写方法(非private、非 final 方法),那么这个对象调用该方法时默认调用的时子类重写...
  • 父类对象属性值赋值给子类对象 org.springframework.beans.BeanUtils.copyProperties(父类对象,子类对象);
  • 详细解释Java父类子类的关系1 定义类2 构造方法3 成员变量4 成员方法5 类型转换6 隔代继承 主要包括:成员变量(覆盖)、构造方法、成员方法(覆盖)、类型转换 1 定义类 定义A、B、C、D四个类,B、C继承A,D继承B ...
  • ①加入A是一个接口或者抽象类,那么不可以创建对象,用起引用去指向其他子类或实现类来创建对象是可以的具体来说,假如一个类需要实现各种水果,香蕉,苹果等,有共同的方法eat()就必须给每一个类写一个方法public ...
  • java父类声明new子类对象 和子类声明new子类对象

    千次阅读 多人点赞 2018-04-28 16:26:01
    父类名 a = new 子类名()子类名 b = new 子类名()a只能调用父类的函数,不能调用子类的函数,因为它没有继承b可以调用父类的函数也可以调用子类的函数但是对构造函数的执行上二者是没有区别的。...
  • 作者:Accelerator链接...我来说句,反对桑弘毅 的第一句:”在创建子类对象时,首先会调用父类的构造器,创造一个父类的对象“。调用父类构造方法是真的,但是根本没有创建父类对象,只不过是调用父类构造方法来初...
  • java父类子类的关系

    千次阅读 2014-06-30 22:15:48
    子类继承父类子类中jiu

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 221,222
精华内容 88,488
关键字:

java父类创建子类对象

java 订阅