总结构建子类对象时的顺序

 1 package com.hanqi;
 2
 3 public class Animao {
 4     private String name;
 5     private int age;
 6
 7     public Animao()
 8     {
 9
10     }
11     public void cry ()
12     {
13         System.out.println("动物发出叫声!");
14     }
15     public void run ()
16     {
17         System.out.println("跑");
18     }
19     public String getName() {
20         return name;
21     }
22     public void setName(String gou) {
23         this.name = gou;
24         System.out.println("名字为"+name);
25     }
26     public int getAge() {
27         return age;
28     }
29     public void setAge(int age) {
30         this.age = age;
31
32         System.out.println("年龄为"+age);
33     }
34 }
 1 package com.hanqi;
 2
 3 public class Dog extends Animao {
 4
 5     private String name;
 6     private int age;
 7
 8     public Dog(){
 9
10     }
11     public void cry ()
12     {
13         System.out.println("狗发出“汪汪”声!");//子类重写父类第二个方法
14     }
15 }
 1 package com.hanqi;
 2
 3 public class Dog2 {
 4
 5     public static void main(String[] args) {
 6         // TODO 自动生成的方法存根
 7
 8         Dog r=new Dog();
 9
10         Animao f=new Dog();//向上转型
11
12         f.cry();  //调用这个方法
13
14         f.setName("小白");
15
16         f.setAge(16);
17     }
18
19 }

狗发出“汪汪”声!
名字为小白
年龄为16

总结:子类构造时调用父类的构造方法

时间: 2024-10-07 05:06:30

总结构建子类对象时的顺序的相关文章

Java子类继承父类,当实例化子类对象时的执行顺序

子类继承父类,当实例化子类对象时,执行顺序如下:     父类层级静态块      自身静态块     父类块      父类构造器     自身块      自身构造器 由于继承,肯定应该先加载父类再加载子类,加载类自然会调用静态块,然后是调用父类的构造函数和子类的构造函数,不过构造函数调用前肯定要先调用域或块,这样才能正确创建对象. ················································赋值顺序如下:     父类的静态变量赋值     自身的静态变

当父类指针指向子类对象时的函数调用

class A { public: void FuncA() { printf( "FuncA called\n" ); } virtual void FuncB() { printf( "FuncB called\n" ); } }; class B : public A { public: void FuncA() { A::FuncA(); printf( "FuncAB called\n" ); } virtual void FuncB(

多态父类引用指向子类对象时,如何调用子类的独有方法?

父类:A 子类:Person A a1 = new Person(); if(a1 instanceof Person) { System.out.println("true"); ((Person) a1).getPersonName();      //调用子类独有的方法 }

Java超类引用子类对象的规律

首先,对于JVM实现引用的一个机制是:类实例的引用就是指向一个句柄(handle)的指针,这个句柄就是一堆指针:一个指针指向一块从java堆中为分配出来内存空间:另一个指针指向一张表(实际上这个表格也有两个指针(一个指针指向一个包含了对象的方法表,另外一个指向类对象,表明该对象所属的类型)) 下面举例进行分析:  Student st=new Student();//Student为子类 Person p=st;//Person 为超类 p.sayHello();//该方法在超类和子类中都存在

java父类引用指向子类对象

父类引用指向子类对象指的是: 例如父类Animal,子类Cat,Dog.其中Animal可以是类也可以是接口,Cat和Dog是继承或实现Animal的子类. Animal animal = new Cat(); 即声明的是父类,实际指向的是子类的一个对象. 那这么使用的优点是什么,为什么要这么用?可以用这几个关键词来概括:多态.动态链接,向上转型 也有人说这是面向接口编程,可以降低程序的耦合性,即调用者不必关心调用的是哪个对象,只需要针对接口编程就可以了,被调用者对于调用者是完全透明的.让你更关

【转】父类引用指向子类对象

父类引用指向子类对象指的是: 例如父类Animal,子类Cat,Dog.其中Animal可以是类也可以是接口,Cat和Dog是继承或实现Animal的子类. Animal animal = new Cat(); 即声明的是父类,实际指向的是子类的一个对象. 那这么使用的优点是什么,为什么要这么用?可以用这几个关键词来概括:多态.动态链接,向上转型 也有人说这是面向接口编程,可以降低程序的耦合性,即调用者不必关心调用的是哪个对象,只需要针对接口编程就可以了,被调用者对于调用者是完全透明的.让你更关

js中对象的输出顺序

前言:最近用for-in时,看到说for-in不能保证遍历的对象顺序,对此有些疑问,于是便研究了下,本文做简要说明. 现象 let obj = { a: 'a', b: 'b', 1: 1, 2: 2 } let obj2 = { name: '张三', age: 13, gender: 'male' } for(key in obj){ console.log(key) } // 输出顺序为1,2,a,b for(key in obj2){ console.log(key) } // 输出的顺

Java超类对象引用访问子类对象

下面举例进行分析:  Student st=new Student();//Student为子类 Person p=st;//Person 为超类 p.sayHello();//该方法在超类和子类中都存在 分析: * 为什么子类的类型的对象实例可以覆给超类引用? 自动实现向上转型.通过该语句,编译器自动将子类实例向上移动,成为通用类型Person:  *p.sayHello()将执行子类还是父类定义的方法? 子类的.在运行时期,将根据p这个对象引用实际的类型来获取对应的方法.所以才有多态性.一个

java实例化对象时程序运行顺序

当java实例化对象时,首先先进行类加载,类加载的整个过程是将类字节码引入内存,并未类中的static变量赋值.上篇文章已经大概分析了类的加载机制,下面讲一下类的实例化过程. 首先引入示例代码 父类 package test; public class Fu { public int j = 9; public static int i = 10; static{ i = 9; System.out.println("Fu静态代码块"); } { j = 10; System.out.