精华内容
下载资源
问答
  • 创建子类对象时,Student s = new Student("school"); 该构造方法中没有显示调用父类的 构造方法,但还是编译成功了,![图片说明](https://img-ask.csdn.net/upload/201604/14/1460599555_25628.png) 该构造方法...
  • Java规定:一个父类可以有多个子类,但是一个子类只有一个父类子类通关键字extends继承父类。 //父类: public class FatherClass { int a=3; FatherClass(){ System.out.println("父类无参构造函数"); } ...

    Java规定:一个父类可以有多个子类,但是一个子类只有一个父类。子类通关键字extends继承父类。

    //父类:
    public class FatherClass {
    	int a=3;
    	FatherClass(){
    		System.out.println("父类无参构造函数");
    	}
    	
    	FatherClass(int i){
    		System.out.println("有一个形参i");
    	}
    	FatherClass(int i, int j){
    		System.out.println("有两个形参i,j");
    	}
    
    }
    
    //子类:
    class SonClass extends FatherClass{
    	int a;
    	int b;
    	public SonClass(){
    		System.out.println("123一起上");
    	}
        public SonClass(int a){     
        	this.a= a;
        	System.out.println("456一起上");
        }
        public SonClass( ){
            super.(3,4); 
        }
        public show(){
            System.out.println("show 中!");
        }
        
    	public static void main(String[] args) {
    		SonClass sc1 = new Sonclass ();    //创建一个子类对象
    		FatherClass sc2 = new SonClass (); //父类引用指向子类对象
    		FatherClass sc3= new SonClass(3,4); //父类引用指向子类对象,调用含指定参数的子类构造方法
    
    	}
    }
    

    1.如果父类没有定义构造函数,系统会默认定义一个无参无返回值的构造函数,子类继承时无需(即可写可不写)在子类构造函数中显式调用super( );如果父类定义了有参构造函数,子类想调用父类的有参构造函数的话,必须在第一行必须显式调用。即,显式调用对应的参数个数、对应参数类型与此super( [arg0][,arg1]…. )的父类构造函数。
    SonClass( ) 该子类构造函数实际上在函数类第一行隐式调用了父类无参构造函数super()

    public SonClass(){
    	System.out.println("123一起上");
    }
    

    若子类的构造函数要调用父类的某个有参构造函数必须在第一行显示调用
    如下:正确

    public SonClass(){
     	super(5);
    	this.a = a;
    	System.out.println("456一起上");
    }
    

    如下:错误

    public SonClass(){
    	this.a = a;
    	super(5);      // 此父类构造函数调用应放在第一行
    	System.out.println("456一起上");
    }
    

    2.关于父类引用指向子类对象:
    定义一个父类类型的引用指向一个子类的对象后,父类类型的引用可以调用父类中定义的所有属性和方法,而对于子类中定义而父类中没有的方法,是无法调用的;

     FatherClass  sc2 = new SonClass( );
     sc2.show( )     //会报错
    

    子类对象可以向上转换,因为子类是父类的延伸,猫是动物的子类,猫是动物 。即:

     SonClass sc4 = new SonClass();
     FatherClass fc1 = (FatherClass) sc4;
    

    也可以这样,fc1由子类对象向上转换成父类对象,再转换成子类对象sc5

    SonClass sc4 = new SonClass();
    FatherClass fc1 = (FatherClass) sc4;
    SonClass sc5 = (SonClass) fc1;
    

    从对象的内存角度来理解
    假设父类FatherClass它的变量需要占用1M内存,它的子类对象SonClass的变量需要占用0.5M内存.
    FatherClass f = new FatherClass(); //系统将分配1M内存.
    SonClass s = new SonClass(); //系统将分配1.5M内存!因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例化一个父类,也就是说会先执行父类的构造函数.由于s中包含了父类的实例,所以s可以调用父类的方法

    展开全文
  • 在了解java类加载机制的时候,我们有时候会遇到一些谁先谁后的问题,我们当然不能一眼看出来,我们需要实践代码来总结结论 下面是我封装好两个类 public class People { private String name; private int age; ...

    在了解java类加载机制的时候,我们有时候会遇到一些谁先谁后的问题,我们当然不能一眼看出来,我们需要实践代码来总结结论
    下面是我封装好两个类

    public class People {
        private String name;
        private int age;
        private static  String a = father();
        public static String father()
        {
            System.out.println("父类静态变量");
            return "父类静态变量";
        }
        static {
            System.out.println("父类静态块");
        }
        {
            System.out.println("父类非静态块");
        }
        public People(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public People(){
            System.out.println("父类构造方法");
        }
        public void speak(){
            System.out.println("我是人");
        }
    }
    
    public class Student extends People {
        private String stuNo;
        static {
            System.out.println("子类静态块");
        }
        private static  String b = child();
        public static String child()
        {
            System.out.println("子类静态变量");
            return "子类静态变量";
        }
    
        public Student(String name, int age, String stuNo) {
            super(name, age);
            this.stuNo = stuNo;
        }
        public Student(String stuNo) {
            this.stuNo = stuNo;
        }
        public Student(){
            System.out.println("子类构造方法");
        }
    
        {
            System.out.println("子类非静态块");
        }
        @Override
        public void  speak(){
            System.out.println("我是学生");
        }
    }
    

    我们新建了两个学生对象,并且执行了代码的结果如图所示:

     public static void main(String[] args) {
            Student s1 = new Student();
            System.out.println("================================");
            Student s2 = new Student();
    
        }
    

    在这里插入图片描述

    我们有了代码运行的基础可以总结出来以下几点:

    1.所有的静态变量,无论是父类还是子类只会被加载一次。
    其中 静态代码块,在类被加载的时候运行,因此只加载一次,且优先于其他变量,常用于运行一些项目启动时需要运行的代码,比如加载项目需要的系统资源等等。静态变量 所有该类的对象共同具有的属性。

    2.静态变量的加载顺序与代码的书写顺序有关
    我们可以发现父类与子类的静态块与静态变量加载的顺序不一样,因为我们的书写顺序不同。

    3.代码块顺序优先于构造方法
    构造代码块(代码块),在创建对象的时候执行,且先于构造函数执行。目的也是用于初始化对象,关于和构造函数的不同,我的理解是,如果有多个不同参数的构造函数,就可以提取他们共同的初始化语句到构造代码块,减少重复。

    4.如果一个类具有父类,在类加载的时候都是先加载父类的方法(相当于构造了一个父类对象)

    1. 子类继承父类后,获取到父类的属性和方法,这些属性和方法在使用前必须先初始化,所以须先调用父类的构造器进行初始化。
    2. 在子类构造器的第一行会隐式的调用 super();,即调用父类的构造器
      如果父类中没有定义空参的构造器,则必须在子类的构造器的第一行显示的调用super(参数); ,以调用父类中构造器
      如果子类中构造器的第一行写了this();,则就隐式的super();会消失,因为super()和this()都只能在构造器的第一行定义

    下面我们更改测试代码:

     		People p1 =new People();
            System.out.println("================================");
            Student s1 = new Student();
            System.out.println("================================");
            Student s2 = new Student();
     
    

    在这里插入图片描述

    !!再一次向我们证明

    不管是父类还是子类加载(静态变量和静态语句块)都只能加载一次。
    不管是父类还是子类加载(非静态变量和非静态语句块和构造函数)都可重复加载

    展开全文
  • 1.Java类内部加载顺序 首先我们看一个类内部变量的加载顺序: Java的类在Java编译器中,一个基本规则是按照变量定义的顺序来觉得初始化顺序,但对于静态变量和构造方法有些特殊的规则,如下: 静态代码块,在类被...

    1.Java类内部加载顺序

    • 首先我们看一个类内部变量的加载顺序:
    • Java的类在Java编译器中,一个基本规则是按照变量定义的顺序来觉得初始化顺序,但对于静态变量和构造方法有些特殊的规则,如下:
    1. 静态代码块,在类被加载的时候运行,因此只加载一次,且优先于其他变量,常用于运行一些项目启动时需要运行的代码,比如加载项目需要的系统资源等等。
      示例:
    static{
    	System.out.println("静态代码块");
    }
    
    1. 构造代码块,在创建对象的时候执行,且先于构造函数执行。目的也是用于初始化对象,关于和构造函数的不同,我的理解是,如果有多个不同参数的构造函数,就可以提取他们共同的初始化语句到构造代码块,减少重复。

    示例:

    {
    	System.out.println("子类构造代码块");
    }
    
    1. 还有一种普通代码块,写在方法内部。
      示例:
    public void Method(){
    	{
    		System.out.println("普通代码块");
    	}
    }
    

    2.父类和子类的加载顺序

    • 在加载父类和子类时,父类优先于子类,但静态内容要先执行,包括静态方法和静态代码块。即:
      1. 先执行父类静态内容
      2. 再执行子类静态内容
      3. 再执行父类构造代码块,父类构造方法
      4. 再执行子类构造代码块,子类构造方法

    3.Java内部类

    • Java四种内部类的介绍,我是学习的下面这篇文章
    • java内部类及类的加载顺序(二)
    • 提几点注意事项:
      1.普通成员内部类中不能有static静态变量或静态方法,除非声明为final。原因:一个静态域只有一个实例,不过对于每个外部类对象,会分别有一个单独的内部类实例;如果这个静态域不是final,它就可能不是唯一的(借鉴上面的文章)
      2.普通成员内部类中可以直接调用外部类的变量和方法,包括静态的。
      3.静态内部类中只能调用外部类的静态变量和方法。

    4.代码示例及结果

    //父类
    public class SuperClass {
        static{
            System.out.println("父类静态代码块");
        }
        {
            System.out.println("父类构造代码块");
        }
        public SuperClass(){
            System.out.println("父类无参构造方法");
        }
        public void SuperMethod(){
            {
                System.out.println("父类普通方法");
            }
        }
    }
    
    //子类
    public class SubClass extends SuperClass{
        public int value = 1;
        static{
            System.out.println("子类静态代码块");
        }
        public SubClass(){
            System.out.println("子类无参构造方法value="+value);
            value = 3;
        }
        {
            System.out.println("子类构造代码块value="+value);
            value = 2;
        }
    
        //普通内部类
        public class SubNormalInner {
            {
                System.out.println("普通内部类的构造代码块value="+value);
            }
            SubNormalInner(){
                System.out.println("普通内部类的构造方法");
            }
            public void InnerMethord(){
                System.out.println("普通内部类的普通方法");
            }
        }
    
        //静态内部类
        public static class SubStaticInner{
            static {
                System.out.println("静态内部类的静态代码块");
            }
    
            SubStaticInner(){
                System.out.println("静态内部类的构造方法");
            }
    
            {
                System.out.println("静态内部类的构造代码块");
            }
    
            public static void SubStaticInnerStaticMethod(){
                System.out.println("静态内部类的静态方法");
            }
    
            public void InnerMethord(){
                System.out.println("静态内部类的普通方法");
            }
        }
    
        public static void main(String[] args) {
            System.out.println("子类执行了main方法");
            new SubClass().SubMethod();
        }
    
        public void SubMethod(){
            System.out.println("子类的普通方法value="+value+",此时调用内部类方法:");
            //调用子类普通内部类
            SubClass.SubNormalInner innerCommonClass=new SubClass.SubNormalInner();
            innerCommonClass.InnerMethord();
            //调用子类静态内部类
            SubClass.SubStaticInner innerStaticClass=new SubClass.SubStaticInner();
            innerStaticClass.InnerMethord();
            SubClass.SubStaticInner.SubStaticInnerStaticMethod();
        }
    }
    

    写这个文章主要供自己学习用,如有错误请大佬们指点!
    另外文章借鉴了下面两篇文章的内容,声明一下:
    https://blog.csdn.net/tys19980519/article/details/96764053
    https://blog.csdn.net/dreamsever/article/details/79686008

    展开全文
  • 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.变量名)的方法才可以访问父类中的该属性。

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

        

       

    }

     

    展开全文
  • 详细解释Java父类子类的关系1 定义类2 构造方法3 成员变量4 成员方法5 类型转换6 隔代继承 主要包括:成员变量(覆盖)、构造方法、成员方法(覆盖)、类型转换 1 定义类 定义A、B、C、D四个类,B、C继承A,D继承B ...
  • 子类的方法可以访问父类的实例变量,
  • java父类子类的关系

    千次阅读 2014-06-30 22:15:48
    子类继承父类子类中jiu
  • Java父类子类的加载顺序详解

    千次阅读 2017-08-30 08:52:00
    然后就看到有关于Java父类子类的加载顺序的题,出简单点的就出选择题,出复杂的就出成简答题了。说句实话,在实际开发工作中,好像用不到(也许是我技术不到家,所以没用到吧)但是为了应付笔试还是得了解。开始...
  • java基础】——java父类声明子类实例化

    万次阅读 多人点赞 2018-11-27 00:07:14
    问题: 1、比如两个类父类:... //创建对象这样看来 声明的时候,是父类,而在产生对象的时候,实际的对象是子类。怎么理解??? 知识点: Java的多态性 面向对象编程有三个特征,即封装、继承和多态。封装隐...
  • java父类子类继承问题

    2019-12-25 17:01:14
    java子类继承父类,在初始化时,初始化子类可读取父类的方法,但如果初始化父类,则不可读取子类的方法。 创建对象时,Father c = new Child() 子类继承父类时,针对覆写的方法,调用的是子类方法,在静态属性上...
  • 3、如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,将会调用子类中的这个方法;(动态连接、动态调用) 4、变量不能被重写(覆盖),“重写”的概念只针对方法,如果在子类中“重写”了父类中的...
  • java父类子类变量及方法继承问题 1.变量的类型 1.类变量:static variable,每个类共用一个,在类创建创建,从该类的准备阶段起开始存在,直到系统完全销毁这个类,类变量的作用域与这个类的生存范围相同; 2.实例...
  • 之前一直没弄懂的父类引用指向子类对象,即 Person,是Student的父类,则这个父类引用...则使用父类引用指向子类对象,可以成功创建对象(即可以且只能使用这个父类里面的方法) 用法Person p = new Student(); ...
  • 答案是:创建子类对象时不会创建父类对象。我们创建子类对象时,只是说创建了父类空间,并进行了初始化。如果说创建子类的时候就会创建它的父类,那内存空间中不都是Object类的对象吗?(想想java的设计师也不会这么...
  • 父类引用指向子类对象指的是: 例如父类Animal,子类Cat,Dog。其中Animal可以是类也可以是接口,Cat和Dog是继承或实现Animal的子类。 Animal animal = new Cat(); 即声明的是父类,实际指向的是子类的一个对象。 ...
  • Java父类子类抛出异常的处理

    千次阅读 2018-12-20 08:05:00
    子类需要修改父类的一些方法进行扩展,增大功能,程序设计者常常把这样的一种操作方法称为重写,也叫称为覆盖。 可以这么理解:重写就是指 子类中的方法与父类中继承的方法有完全相同的返回值类型、方法名、...
  • Java中用父类定义子类的意思

    千次阅读 2013-08-20 16:10:18
    继承是为了重用父类代码,同时为实现多态性作准备。那么什么是多态呢? 方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念,原因之一是它在类的继承问题上和C++不同,后者允许多继承,这确实给其...
  • //变量是人可以创建一个学生对象(需要一个人可以来一个学生)父类为变量可以创建子类的对象 3、如果父类对象引用指向的实际是一个子类对象,那么这个父类的引用可以强制类型转换为子类的对象引用。 例:Person p=...
  • 父类: public class Animal { static{ System.out.println("父类的静态方法"); } { System.out.println("执行父类的构造代码块"); } public Animal(){ System.o...
  • Java父类子类关于构造方法和私有属性的几个问题一、什么是默认构造方法?子类构造方法与父类构造方法的关系? 通过前面的学习可以知道:默认构造方法是指无参构造方法,(1)隐式包含的默认构造方法:当类的...
  • public static String p_StaticField = "父类--静态变量"; // 变量(其实这用对象更好能体同这一点,如专门写一个类的实例)   //如果这个变量放在初始化块的后面,是会报错的,因为你根本没有被初始化 public ...
  • 关于java创建子类对象时,父类对象到底创建不创建 一个对象可以理解为一个房子,而一个类只是规定了什么地方要放什么东西,比如客厅要放沙发,餐厅要有餐桌 创建一个新对象,就是建造一栋新房子,如果你不去初始化...
  • Java 父类引用指向子类对象

    千次阅读 2013-10-01 20:10:55
    1.背景 面向对象的三大特点,继承,封装,多态。何为多态(Polymorphism)?...在程序语言中,通过子类继承父类,然后重写覆盖的方法,在创建对象时,将父类的引用指向子类的对象,就可以利用父类引用调
  • java中的父类子类的构造函数

    千次阅读 2018-04-09 11:23:25
    1.为什么创建子类的对象也调用父类的构造函数? class Super { String s; public Super(){ System.out.println("Super"); } } public class Sub extends Super { public Sub(){ ...
  • 答案是否定的,在Java创建一个子类对象是不会创建父类对象的。 通过一个实例来证明:实例:父类Base.javapublic class Base { private String str; public Base() { System.out.println("Base()"); ...
  • Java父类子类创建方式

    千次阅读 2009-12-02 10:43:51
    Java扩展类中,在初始化子类的时候,会先初始化父类的构造函数。   父类: package test; public class FatherClass { public FatherClass() { System.out.println("FatherClass Create");...
  • 创建子类实例的时候会调用父类的构造方法,但是构造方法被执行并不代表实例化了这个类。父类构造方法的执行,是为了给变量进行赋值。 每个类的这些元数据,无论是在构建这个类的实例还是调用这个类某个对象的方法,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 231,395
精华内容 92,558
关键字:

java父类创建子类

java 订阅