精华内容
下载资源
问答
  • java中规定:一个父类可以有多个子类,但是一个子类只能有一个父类子类可以通过extends关键字来继承父类。做个比较通俗的比喻,就像一个父亲可以有多个亲孩子,但是一个孩子只能有一个亲生父亲。 1.继承以及...

    在java中规定:一个父类可以有多个子类,但是一个子类只能有一个父类。子类可以通过extends关键字来继承父类。做个比较通俗的比喻,就像一个父亲可以有多个亲孩子,但是一个孩子只能有一个亲生父亲。

     

    1.继承以及重写:子类继承父类是对父类属性和方法的全面继承,同时子类在继承了父类的方法后,可对父类的方法进行重写。

    public class Son extends Fat{
    private int b;
    private String h1;
    public void   sss() {
    System.out.println("我要学好英语");    //在这我们对父类中的sss()方法进行了重写
    }
    public void   iii() {
    System.out.println("今天天气真好");  // 在这我们添加了子类特有的方法
    }

    }
    class Fat{
     public int a=5;
    private String h;
    public void   sss() {
    System.out.println("我要学好java");
    }
     

    }

    2.父类用作对象的声明类型,构造器用子类的构造器(有点类似于接口和实现类的对象的关系)。这样使得我们的应用场景和范围更为灵活和广泛。我们知道一个父类可以有多个子类,这样我们可以在声明的时候用父类,在具体的构造器时,我们用子类。这时,这个新生成的对象是父类类型的对象,也就是说这个对象中目前只有父类的属性和方法(如果子类重写,则用子类重写的方法)。如果我们需要调用子类中特有的方法和属性,则我们需要将该对象强制转换成子类类型的对象。看下面代码

    public class TestSon {
    public static void main(String[] args) {
    Fat s=new Son();     //我们在这进行了父类用作对象的声明类型,构造器用子类的构造器。
    s.sss();                    //我们调用了对象中的sss()方法,为我们重写过的方法
    System.out.println(s.a);    //  我们展示了父类中属性a的值,此处为public(没有进行封装)
    Son y=(Son)s;             //将s对象转化为Son类型的y对象
    y.iii();;                           //这样我们可以通过y对象来调用子类中特有的iii()方法。
    int u=y.b;                     //同时我们也可以接受子类中特有的属性b。

    }

    }

    对这个知识点的理解和记忆中,我们可以用七个葫芦娃和葫芦娃爸爸(我假设的)来理解。假设葫芦娃爸爸只有吃饭这一个技能包,七个葫芦娃的技能点儿除了吃饭之外,分别还有比如喷火、喷火等技能包(每个人都不一样)。故我们可以在用某一个对象时,可以先以葫芦娃爸爸作为声明类型,然后呢用具体的葫芦娃进行构造。当我们在表达吃饭的动作(每个小葫芦娃都要吃饭啊~~~)时,我们就可以用当前对象名,吃饭(方法)来表示。但是当需要用喷火(方法),我们就需要将这个对象转化成葫芦四娃类型的了(因为这个是他和葫芦娃爸爸不一样的地方,四娃特有)。

    3.Object类是所有类的父类,其中有方法equals等方法。

     

    转载地址:https://blog.csdn.net/moutain0101/article/details/79572611

    展开全文
  • **父类子类代码执行顺序:**父类静态代码块–>子类静态代码块–>父类代码块–>父类构造方法–>子类代码块—>子类构造方法 下面代码展示: 1、创建A和B类,让B继承A public class A { ...

    父类和子类代码执行顺序

    :父类静态代码块–>子类静态代码块–>父类代码块–>父类构造方法–>子类代码块—>子类构造方法

    下面代码展示:
    1、创建A和B类,让B继承A
    2、编写A和B的代码

    public class A {
    
        static {
            System.out.println("父类静态代码执行了");
        }
        {
            System.out.println("父类非静态代码执行了");
        }
        public A(){
            System.out.println("父类构造函数代码执行了");
        }
    
        public static void main(String[] args) {
            B b = new B();
        }
    
    }
    
    public class B extends A{
    
        static {
            System.out.println("子类静态代码执行了");
        }
        {
            System.out.println("子类非静态代码执行了");
        }
        public B(){
            System.out.println("子类构造函数代码执行了");
        }
    }
    

    3、输出结果
    在这里插入图片描述

    展开全文
  • java父类子类的关系

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

    子类继承父类,子类中就拥有父类的所有属性和方法。在创建子类的实例的时候,父类和子类到底是如何执行的呢?还有静态代码块和非静态代码块和构造方法的执行顺序?

    1.先执行父类的静态代码块,然后再子类静态代码块
    2.父类的非静态代码块,构造方法
    3.子类的非静态代码块,构造方法
    对象的初始化顺序
    静态代码块内容先执行,接着执行父类非静态代码块和构造方法,然后执行子类非静态代码块和构造方法。


    注意:子类的构造方法,不管这个构造方法带不带参数,默认的它都会先去寻找父类的不带参数的构造方法。

    如果父类没有不带参数的构造方法, 那么子类必须用supper关键子调用父类带参数的构造方法,否则编译不能通过。

    当一个类中有多个static{}的时候,按照static{}的定义顺序,从前往后执行;

    看代码:

    package com.zhb.basic;
    /**
     *子类和父类的关系
     * @author Administrator
     *
     */
    public class Test1 extends superTest1{
    	public Test1(){
    		super("xxx");//父类没有无参构造方法,有有参的构造方法,就要显式调用super(参数)
    		System.out.println("xxxx子类构造方法");
    	}
    	public Test1(String name){
    		super("xxx");//同上
    		System.out.println("子类类有参构造函数");
    	}
    	{
    		System.out.println("我是子类非静态代码块");
    	}
    	{
    		System.out.println("我是子类非静态代码块2");
    	}
    	static{
    		//当一个类中有多个static{}的时候,按照static{}的定义顺序,从前往后执行;
    		System.out.println("我是子类静态代码块");
    	}
    	
    	public static void main(String[] args){
    		/*Test1 t = new Test1();
    		char a = 'a' - 32;
    		char b = Character.toUpperCase('c');
    		System.out.println(b);
    		System.out.println(t.testUpperCase("AVVV"));
    		long x = 222_5555;
    		System.out.println(x);*/
    		
    		//子类和父类的关系
    		Test1 t1 = new Test1("xxx");	
    	    
    	}
    
    }
    
    
    class superTest1{
    	/*public superTest1(){
    		System.out.println("suerTest1无参构造方法");
    	}*/
    	public superTest1(String name){
    		System.out.println("父类有参构造函数");
    	}
    	{
    		System.out.println("我是父类类非静态代码块");
    	}
    	
    	static{
    		System.out.println("我是父类静态代码块");
    	}
    	
    	public final void cry(){
    		System.out.println("haha");
    	}
    }
     
    


    输出:
    我是父类静态代码块
    我是子类静态代码块
    我是父类类非静态代码块
    suerTest1构造方法
    我是子类非静态代码块
    xxxx子类构造方法





    展开全文
  • Java父类子类的加载顺序详解

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

    最近准备换工作,好久没笔试面试的我,就网上找了点大家分享的题随便看了看。然后就看到有关于Java中父类与子类的加载顺序的题,出简单点的就出选择题,出复杂的就出成简答题了。说句实话,在实际开发工作中,好像用不到(也许是我技术不到家,所以没用到吧)但是为了应付笔试还是得了解。开始正题吧。

    1、在没有子类的情况下

    package lcy;
    
    public class Test6 {
    
     /** 
      * 方法描述:移动端—
      * 创建人:汪俊 
      * 创建时间:2017-8-1 上午09:01:37 
      * 修改人:汪俊 
      * 修改时间:2017-8-1 上午09:01:37 
      * 修改备注: 
      * @version V1.0 
      */
      //静态变量 
      static String i=lcy();
      public static String lcy()
      {
       System.out.println("父类静态变量");
       return "静态变量";
      }	
      //静态语句块
      static {
          System.out.println("父类静态语句块1");
      }
      //静态语句块
      static {
          System.out.println("父类静态语句块2");
      }
      //静态语句块
      static{
          System.out.println("父类静态语句块3");
      }
      
      //非静态变量 
      String j=pplcy();
      public String pplcy()
      {
       System.out.println("父类非静态变量");
       return "父类非静态变量";
      }	
      //非静态语句块
      {
        System.out.println("父类非静态语句块1");
      }
      //非静态语句块
      {
        System.out.println("父类非静态语句块2");
      }
      //非静态方法
      public void bDisplay(){
          System.out.println("父类非静态方法");
          return ;
      }
      //静态方法
      public static void bTest(){
          System.out.println("父类静态方法");
          return ;
      }
      //构造函数
      public Test6(){
          System.out.println("父类构造函数");
      }
    
      
      public static void main (String args[]) {
       Test6 a=new Test6();
       a.bDisplay();
       a.bTest();
       
         }
    }
    运行结果分析①
    父类静态变量
    父类静态语句块1
    父类静态语句块2
    父类静态语句块3
    父类非静态变量
    父类非静态语句块1
    父类非静态语句块2
    父类构造函数
    父类非静态方法
    父类静态方法
    结论:在初始化类时候,首先加载类的静态变量和静态语句块(按照代码上下顺序执行),然后加载类的非静态变量和非静态语句块(按照代码上下顺序执行),最后加载类的构造函数。
    至于类的静态方法和非静态方法只有主动调用的时候才会执行,区别在于静态方法可以直接用类名直接调用(实例化对象也可以),而非静态方法只能先实例化对象后才能调用。
    2、在有子类的情况下
    package lcy;
    
    public class Test7 extends Test6 {
    
     /** 
      * 方法描述:移动端—
      * 创建人:汪俊 
      * 创建时间:2017-8-1 上午09:01:37 
      * 修改人:汪俊 
      * 修改时间:2017-8-1 上午09:01:37 
      * 修改备注: 
      * @version V1.0 
      */
      //静态变量 
      static String a=lcyhh();
      public static String lcyhh()
      {
       System.out.println("子类静态变量");
       return "静态变量";
      }	
      //静态语句块
      static {
          System.out.println("子类静态语句块1");
      }
      //静态语句块
      static {
          System.out.println("子类静态语句块2");
      }
      //静态语句块
      static{
          System.out.println("子类静态语句块3");
      }
      
      //非静态变量 
      String b=ppplcy();
      public String ppplcy()
      {
       System.out.println("子类非静态变量");
       return "子类非静态变量";
      }	
      //非静态语句块
      {
        System.out.println("子类非静态语句块1");
      }
      //非静态语句块
      {
        System.out.println("子类非静态语句块2");
      }
      //非静态方法
      public void bDisplay(){
          System.out.println("子类非静态方法");
          return ;
      }
      //静态方法
      public static void bTest(){
          System.out.println("子类静态方法");
          return ;
      }
      //构造函数
      public Test7(){
          System.out.println("子类构造函数");
      }
      
    }
    运行结果分析②:
    Test6 a=new Test6(); //在父类Test6中执行结果,和 运行结果分析①完全相同
    Test6 a=new Test6(); //在子类Test7中执行结果如下
    父类静态变量
    父类静态语句块1
    父类静态语句块2
    父类静态语句块3
    子类静态变量
    子类静态语句块1
    子类静态语句块2
    子类静态语句块3
    父类非静态变量
    父类非静态语句块1
    父类非静态语句块2
    父类构造函数
    结论:在初始化父类Test6的时候,首先加载父类的静态变量和静态语句块(按照代码上下顺序执行),然后加载子类的静态变量和静态语句块(按照代码上下顺序执行),然后加载父类的非静态变量和非静态语句块(按照代码上下顺序执行),最后加载父类的构造函数。
    运行结果分析③:
    Test7 a=new Test7(); //在父类Test6和子类Test7中执行结果相同,如下
    父类静态变量
    父类静态语句块1
    父类静态语句块2
    父类静态语句块3
    子类静态变量
    子类静态语句块1
    子类静态语句块2
    子类静态语句块3
    父类非静态变量
    父类非静态语句块1
    父类非静态语句块2
    父类构造函数
    子类非静态变量
    子类非静态语句块1
    子类非静态语句块2
    子类构造函数
    结论:在初始化子类Test7的时候,首先加载父类的静态变量和静态语句块(按照代码上下顺序执行),然后加载子类的静态变量和静态语句块(按照代码上下顺序执行),然后加载父类的非静态变量和非静态语句块(按照代码上下顺序执行),再加载父类的构造函数。然后加载子类的非静态变量和非静态语句块(按照代码上下顺序执行),最后加载子类的构造函数。

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






    展开全文
  • 创建子类对象时,Student s = new Student("school"); 该构造方法中没有显示调用父类的 构造方法,但还是编译成功了,![图片说明](https://img-ask.csdn.net/upload/201604/14/1460599555_25628.png) 该构造方法...
  • java父类声明子类实例化

    千次阅读 多人点赞 2020-11-01 19:31:25
    父类:Father ,子类 Child extends Father。在使用时候,这样写: Father child==new Child(); 这样看来,声明的时候,是父类,而在产生对象的时候,实际的对象是子类。怎么理解??? 知识点: Java的多态性 ...
  • 父类变量指向子类实例& &父类指针指向子类对象
  • 1、使用父类类型的引用指向子类的对象; 2、该引用只能调用父类中定义的方法和变量; 3、如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,将会调用子类中的这个方法;(动态连接、动态调用) 4、...
  • java基础】——java父类声明子类实例化

    万次阅读 多人点赞 2018-11-27 00:07:14
    1、比如两个类父类:Person 子类 Student extends Person在使用时候,这样写:Person person=null; //声明对象person=new Student(); //创建对象这样看来 声明的时候,是父类,而在产生对象的时候,实际的对象是子类...
  • Java中用父类定义子类的意思

    千次阅读 2013-08-20 16:10:18
    封装隐藏了类的内部实现机制,从而可以在不影响使用者的前提下改变类的内部结构,同时保护了数据。 继承是为了重用父类代码,同时为实现多态性作准备。那么什么是多态呢? 方法的重写、重载与动态连接构成多态...
  • Java父类子类关于构造方法和私有属性的几个问题一、什么是默认构造方法?子类构造方法与父类构造方法的关系? 通过前面的学习可以知道:默认构造方法是指无参构造方法,(1)隐式包含的默认构造方法:当类的...
  • Java父类子类抛出异常的处理

    千次阅读 2018-12-20 08:05:00
    子类需要修改父类的一些方法进行扩展,增大功能,程序设计者常常把这样的一种操作方法称为重写,也叫称为覆盖。 可以这么理解:重写就是指 子类中的方法与父类中继承的方法有完全相同的返回值类型、方法名、...
  • Java父类子类方法调用顺序 父类 FatherClass package 父类与子类方法调用顺序; /** * 父类 * @author shundong * */ public class FatherClass { private int i =0; private String name; /** * 父类无参...
  • Father father = new Son(); 这样的吧,这有一种专业说法,叫“父类引用指向子类对象”。 首先 new Son();... 就是将父类引用指向子类对象,这是java里很常用的用法。这时候如果father调用方法father,met...
  • class Parent { ... // 变量(其实这对象更好能体同这一点,如专门写一个类的实例)   //如果这个变量放在初始化块的后面,是会报错的,因为你根本没有被初始化 public String p_Field = "父类--变量";
  • class Parent { ... // 变量(其实这对象更好能体同这一点,如专门写一个类的实例)    //如果这个变量放在初始化块的后面,是会报错的,因为你根本没有被初始化  public String p_Field = "父类--变
  • class Parent { ... // 变量(其实这对象更好能体同这一点,如专门写一个类的实例)   //如果这个变量放在初始化块的后面,是会报错的,因为你根本没有被初始化 public String p_Field = "父类--变量";
  • 每次当new关键字创建出一个子类对象时,那么程序会先执行父类中不带参数的构造函数,然后再执行子类的构造函数.每次当new关键字创建出一个子类对象时,那么程序会先执行父类中不带参数的构造函数,然后再执行子类的...
  • Java规定:一个父类可以有多个子类,但是一个子类只有一个父类子类通关键字extends继承父类。 //父类: public class FatherClass { int a=3; FatherClass(){ System.out.println("父类无参构造函数"); } ...
  • 在了解java类加载机制的时候,我们有时候会遇到一些谁先谁后的问题,我们当然不能一眼看出来,我们需要实践代码来总结结论 下面是我封装好两个类 public class People { private String name; private int age; ...
  • 父类: public class Animal { static{ System.out.println("父类的静态方法"); } { System.out.println("执行父类的构造代码块"); } public Animal(){ System.o...
  • Java父类子类创建方式

    千次阅读 2009-12-02 10:43:51
    Java扩展类中,在初始化子类的时候,会先初始化父类的构造函数。   父类: package test; public class FatherClass { public FatherClass() { System.out.println("FatherClass Create");...
  • 向上向下转型的使用场景常见的是在集合类中,比如你有一个父类和N个子类,然后你想把这些子类装进一个集合里面,这个时候你肯定不会为每一个子类都去创建一个集合来分别存储,毕竟这么干会写很多重复的代码,你肯定...
  • 1.Java类内部加载顺序 首先我们看一个类内部变量的加载顺序: Java的类在Java编译器中,一个基本规则是按照变量定义的顺序来觉得初始化顺序,但对于静态变量和构造方法有些特殊的规则,如下: 静态代码块,在类被...
  • 关于java中子类父类之间的关系一点心得:声明一个父类引用(变量),可以赋值一个父类对象。 声明一个子类引用,可以赋值一个子类对象。 声明一个父类引用(变量),可以赋值一个子类对象。 声明一个子类引用,不...
  • java中的父类子类之间的转换规则: 子类转换成父类没有什么要求,直接赋值即可: eg: father f= new son() 父类转换成子类的话需要使用强制转换 : eg: son s = (son) f ; 子类继承父类的非私有的的...
  • 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 继承 父类子类 内存分配

    千次阅读 2016-09-23 10:16:25
    (1)Java不支持多继承,也就是说子类至多只能有一个父类。 (2)子类继承了其父类中不是私有的成员变量和成员方法,作为自己的成员变量和方法。 (3)子类中定义的成员变量和父类中定义的成员变量相同时,则...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 234,021
精华内容 93,608
关键字:

java用父类创建子类

java 订阅