博客分类：
Java中线程的创建有两种方式：
1．通过继承Thread类，重写Thread的run()方法，将线程运行的逻辑放在其中
2．通过实现Runnable接口，实例化Thread类
在实际应用中，我们经常用到多线程，如车站的售票系统，车站的各个售票口相当于各个线程。当我们做这个系统的时候可能会想到两种方式来实现，继承Thread类或实现Runnable接口，现在看一下这两种方式实现的两种结果。
package com.
class MyThread extends Thread{
private int ticket = 10;
public MyThread(String name){
this.name =
public void run(){
for(int i =0;i&500;i++){
if(this.ticket&0){
System.out.println(this.name+"卖票----&"+(this.ticket--));
public class ThreadDemo {
public static void main(String[] args) {
MyThread mt1= new MyThread("一号窗口");
MyThread mt2= new MyThread("二号窗口");
MyThread mt3= new MyThread("三号窗口");
mt1.start();
mt2.start();
mt3.start();
运行结果如下：
一号窗口卖票----&10
一号窗口卖票----&9
二号窗口卖票----&10
一号窗口卖票----&8
一号窗口卖票----&7
一号窗口卖票----&6
三号窗口卖票----&10
一号窗口卖票----&5
一号窗口卖票----&4
一号窗口卖票----&3
一号窗口卖票----&2
一号窗口卖票----&1
二号窗口卖票----&9
二号窗口卖票----&8
三号窗口卖票----&9
三号窗口卖票----&8
三号窗口卖票----&7
三号窗口卖票----&6
三号窗口卖票----&5
三号窗口卖票----&4
三号窗口卖票----&3
三号窗口卖票----&2
三号窗口卖票----&1
二号窗口卖票----&7
二号窗口卖票----&6
二号窗口卖票----&5
二号窗口卖票----&4
二号窗口卖票----&3
二号窗口卖票----&2
二号窗口卖票----&1
通过实现Runnable接口的代码如下：
package com.
class MyThread1 implements Runnable{
private int ticket =10;
public void run(){
for(int i =0;i&500;i++){
if(this.ticket&0){
System.out.println(Thread.currentThread().getName()+"卖票----&"+(this.ticket--));
public class RunnableDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
//设计三个线程
MyThread1 mt = new MyThread1();
Thread t1 = new Thread(mt,"一号窗口");
Thread t2 = new Thread(mt,"二号窗口");
Thread t3 = new Thread(mt,"三号窗口");
MyThread1 mt2 = new MyThread1();
MyThread1 mt3 = new MyThread1();
t1.start();
t2.start();
t3.start();
运行结果如下：
一号窗口卖票----&10
三号窗口卖票----&9
三号窗口卖票----&7
三号窗口卖票----&5
三号窗口卖票----&4
三号窗口卖票----&3
三号窗口卖票----&2
三号窗口卖票----&1
一号窗口卖票----&8
二号窗口卖票----&6
为什么会出现这种结果呐。我们不妨做个比喻，其实刚的程序，
继承Thread类的，我们相当于拿出三件事即三个卖票10张的任务分别分给三个窗口，他们各做各的事各卖各的票各完成各的任务，因为MyThread继承Thread类，所以在new MyThread的时候在创建三个对象的同时创建了三个线程；
实现Runnable的， 相当于是拿出一个卖票10张得任务给三个人去共同完成，new MyThread相当于创建一个任务，然后实例化三个Thread，创建三个线程即安排三个窗口去执行。
用图表示如下：
在我们刚接触的时候可能会迷糊继承Thread类和实现Runnable接口实现多线程，其实在接触后我们会发现这完全是两个不同的实现多线程，一个是多个线程分别完成自己的任务，一个是多个线程共同完成一个任务。
其实在实现一个任务用多个线程来做也可以用继承Thread类来实现只是比较麻烦，一般我们用实现Runnable接口来实现，简洁明了。
大多数情况下，如果只想重写 run() 方法，而不重写其他 Thread 方法，那么应使用 Runnable 接口。这很重要，因为除非程序员打算修改或增强类的基本行为，否则不应为该类（Thread）创建子类。
浏览 99244
a 写道非常感谢……对于下面这段代码：&&&&&&&& MyThread1 mt = new MyThread1();& &&&&&&&& Thread t1 = new Thread(mt,"一号窗口");& &&&&&&&& Thread t2 = new Thread(mt,"二号窗口");& &&&&&&&& Thread t3 = new Thread(mt,"三号窗口"); 我们老大非常反感，说你这样写是错的，跟我说是在api里面找不到根据。我也不会解释，哎，无语。jdk api 里面没有说明，但是可以通过程序的执行来说明，事实。MyThread1 mt = new MyThread1(); 改成 Runnable mt = new MyThread1();
这篇文章举例和结论都没错，但是博主理解有误！实现Runable的一个好处就是能实现资源共享，结论正确（因为继承Thread实现不了）但是不是说实现Runable就是实现了资源共享，实际上还是通过MyThread1 mt = new MyThread1();
这个对象实现的共享，如果是三个不同对象：MyThread1 mt1 = new MyThread1();
MyThread1 mt2 = new MyThread1();
MyThread1 mt2 = new MyThread1();
Thread t1 = new Thread(mt1,"一号窗口");
Thread t2 = new Thread(mt2,"二号窗口");
Thread t3 = new Thread(mt3,"三号窗口");
这样执行的结果是和上面完全一样的。总结一下，实现Runable除了避免单继承的局限外，还有个好处就是能实现不同进程资源共享，而继承Thread没有这个功能。并不是这个特点是两者的绝对区别，继承Runable你可以选择不共享。Thread也能共享资源，MyThread mt= new MyThread();& Thread t1 = new Thread(mt,"一号窗口");&&& Thread t2 = new Thread(mt,"二号窗口");&& Thread t3 = new Thread(mt,"三号窗口"); 执行结果和Runnable一样
这个文章有错。。MyThread1 mt = new MyThread1();
Thread t1 = new Thread(mt,"一号窗口");
Thread t2 = new Thread(mt,"二号窗口");
Thread t3 = new Thread(mt,"三号窗口");
这里代码有问题啊，不是Thread和runnable的问题。。这里共享一个资源了。。其实就是接口和继承的问题。。
Thread t1 = new Thread(new MyThread1(),"一号窗口");
Thread t2 = new Thread(new MyThread1(),"二号窗口");
Thread t3 = new Thread(new MyThread1(),"三号窗口");
这样才是ok的。每一个线程一个资源thanks，明白了。楼主自己把自己讲糊涂了，让我也糊涂了。他的结果出现的原因是因为资源共享，与线程的实现方式并无关······大牛，接着帮忙回答下这个问题呗http://bbs.csdn.net/topics/
汗，你还是把这篇删了吧，太误人子弟了，这明明是
MyThread1 mt = new MyThread1();&
Thread t1 = new Thread(mt,"一号窗口");&
Thread t2 = new Thread(mt,"二号窗口");&
Thread t3 = new Thread(mt,"三号窗口");
和
MyThread mt1= new MyThread("一号窗口");&
MyThread mt2= new MyThread("二号窗口");&
MyThread mt3= new MyThread("三号窗口");&
mt1.start();&
mt2.start();&
mt3.start();&
两种写法之间的区别，不要上升到Java中继承thread类与实现Runnable接口的区别好不！
问下这两种写法不是正好对应继承thread类与实现Runnable接口吗？哪儿错了吗？只不过实现Runnable接口平常都是创建匿名对象直接调用start()方法吧
MyThread mt1= new MyThread("一号窗口");& &&&&&&& MyThread mt2= new MyThread("二号窗口");& &&&&&&& MyThread mt3= new MyThread("三号窗口"); 由于Thread类本身也实现了Runnable接口，所以上面的写法也可以写成
MyThread mt= new MyThread();
Thread t1 = new Thread(mt,"一号窗口");
Thread t2 = new Thread(mt,"二号窗口");
Thread t3 = new Thread(mt,"三号窗口");
当然这种写法并不好，但足以说明你的想法是错误对于第二种写法引用MyThread1 mt = new MyThread1();& Thread t1 = new Thread(mt,"一号窗口");& Thread t2 = new Thread(mt,"二号窗口");& Thread t3 = new Thread(mt,"三号窗口"); 可以改成引用 Thread t1 = new Thread(new MyThread1(),"一号窗口");& Thread t2 = new Thread(new MyThread1(),"二号窗口");& Thread t3 = new Thread(new MyThread1(),"三号窗口"); 这两种的区别主要还是接口和继承类的区别
a 写道非常感谢……对于下面这段代码：&&&&&&&& MyThread1 mt = new MyThread1();& &&&&&&&& Thread t1 = new Thread(mt,"一号窗口");& &&&&&&&& Thread t2 = new Thread(mt,"二号窗口");& &&&&&&&& Thread t3 = new Thread(mt,"三号窗口"); 我们老大非常反感，说你这样写是错的，跟我说是在api里面找不到根据。我也不会解释，哎，无语。jdk api 里面没有说明，但是可以通过程序的执行来说明，事实。谢谢 我在jdk api里面找到这种写法了哈……
非常感谢……对于下面这段代码：&&&&&&&& MyThread1 mt = new MyThread1();& &&&&&&&& Thread t1 = new Thread(mt,"一号窗口");& &&&&&&&& Thread t2 = new Thread(mt,"二号窗口");& &&&&&&&& Thread t3 = new Thread(mt,"三号窗口"); 我们老大非常反感，说你这样写是错的，跟我说是在api里面找不到根据。我也不会解释，哎，无语。jdk api 里面没有说明，但是可以通过程序的执行来说明，事实。
浏览: 337931 次
来自: 北京
感觉楼主还没理解透彻，可以先看看源代码这两个类是怎么实现的，T ...
mars914 写道a 写道非常感谢……对于 ...
博主用继承Thread用new，用Runnable时用共享，概 ...
flight2006 写道这篇文章举例和结论都没错，但是博主理 ...
MyThread1 mt = new MyThread1(); ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'　　摘要：Java中的构造方法是构建对象的必经之路，其中有着深刻的哲学思想和严谨的科学态度。尤其在继承中更是有着纷繁复杂的" />
免费阅读期刊
论文发表、论文指导
周一至周五
9：00&22：00
Java中构造方法的深入研究与探讨
　　摘要：Java中的构造方法是构建对象的必经之路，其中有着深刻的哲学思想和严谨的科学态度。尤其在继承中更是有着纷繁复杂的表象，这些表象背后隐藏着诸多的玄机。该文立足于日常教学，对该问题进行了较为深入的探究，通过具体的例子逐步得到解答问题的钥匙，并结合设计模式进行了初步的探讨。最后结合这些思考，提出了一些不成熟的建议，以期更为深入的交流和探究。 中国论文网 http://www.xzbu.com/8/view-4353942.htm　　关键词：构造方法；继承；设计模式；探究思维；内部类 　　中图分类号：TP311 文献标识码：A 文章编号：（6-05 　　1 概述 　　在教学中，经常面临这样的问题：已知人类（姓名，年龄，自我介绍（）），那么学生类（姓名，年龄，学号，自我介绍（），选课（））该如何定义？这是继承的一个常用的导入用例。利用继承的一个很好的标准是：is-a。所以这里的学生类一定是人类（注意这一点十分重要）。下面给出源程序： 　　/*@ 1 @*/ 　　/** Person（name，age，introduction（）） */ 　　class Person { 　　private String name； 　　private int age； 　　public void introduction（） { 　　System.out.println（"我是" + name +"，今年" + age + "岁。"）；}} // Person定义完毕 　　/** Student（name，age，id， introduction（），sc（）） */ 　　class Student extends Person { 　　}// Student定义完毕 　　/** 下面开始测试 */ 　　public class ExtendsDemo { 　　public static void main（String[] args） { 　　new Student（）.introduction（）；}}// Student定义完毕/*# 我是null，今年0岁。#*/ 　　好了，这是问题的原型，接着在此基础上逐步剖析构造方法。 　　为了便于讨论和交流，借用数据库理论中的关系模式来表述类，即类名（属性1，属性2……属性n，方法1（），方法2（）……方法n（）），显然做了修改，用一对圆括号表示方法。同时作出如下约定： 　　a）利用注释“/*# #*/“表示当前程序的输出，换行符默认失效； 　　b）利用注释“/*！ ！*/”表示当前的错误； 　　c）利用注释“/*？ ？*/”表示当前的疑问； 　　d）利用注释“/*@ n @*/“表示当前的版本，第n版一定来自第n-1版，所以第n版中与第n-1版中的相同部分不再显示，然后讨论的时候就用版本号来表示程序； 　　e）所有的代码都在同一个文件中； 　　f）凡是与问题无关的方法一概尽量地简化； 　　g）为了节省篇幅，尽量压缩代码，尽量减少注释，由此将损失规范性。 　　2 问题剖析 　　上述代码很好地执行了，继承得到了完美的体现。不足的是我们创建的实例是没有个性的，其名称为null，年龄为0，这是因为使用的是默认构造方法。形如public Person（）{}，这种结果可能会令人失望，但是后面的探讨将告诉我们它是多么重要。为了说明这个问题，开始我们的第一次修改，给Person类增加一个形如默认构造方法的构造方法，即第2个版本，按照引子中的约定，相同部分不再显示： 　　/*@ 2 @*/ 　　public Person（）{ 　　System.out.println（"public Person（）"）；}/*#public Person（） 我是null，今年0岁。#*/ 　　结果告诉我们这样一个事实，父类（Person）的构造方法被调用了，这是怎么回事？其实子类（Student）并没有“显式的”构造方法，所以系统会默默地提供一个形如public Student（）{}的构造方法，而这个构造方法会作出一个举动：默默地调用父类的构造方法。这个结论也许并不是什么新奇的结论，但是我开始并没有意识到或者认识的不够彻底，对后续的研究和探讨带了一定的羁绊。与此同时，正是对这个看似很简单的细节认识清楚以后，才有了本文的诞生，由此可见，关注细节是至关重要的。 　　探讨的序幕拉开了，一个很关键的问题来了：对于父类的构造方法的调用真的如此简单么？ 　　如果将第2个版本的构造方法修改如下，注意是修改，而不是重载： 　　/*@ 3 @*/ 　　public Person（String name， int age）{ 　　this.name = name； this.age = age； 　　System.out.println（"public Person（）"）；} 　　这会产生什么结果呢？结果是没有结果，因为等待我们的是编译错误。引用简化后的错误提示——无法将类 Person中的构造器（就是构造方法）Person应用到给定类型，需要： String，int找到： 没有参数。这是JDK给我们的帮助信息，善于利用调试工具，才是我们学习计算机语言的正确之路。错误提示说明了一个事实：如果你给出了任何一个构造方法，系统将不再提供默认的构造方法（这个结论是我经过细致入微的编码和思考得到的，虽然在一些书籍里面都有提及，但是”看到别人的“和”自己想到的“有很大的不同，多一些”自己想到的“是学习道路上最迷人的风景），因为你提供的方法在功能上要优于系统的（系统的是空的方法）。此时Student类面临创建对象的任务，调用自己默认的构造方法，而默认的构造方法势必调用父类的构造方法，这种机制是自动执行的，凡是自动执行的无外乎引起两种结果：一种是方便，另一种是隐蔽。抛开其便利性不说，追究其隐蔽（也正是本文的重要目的之一），我们从如何调用父类构造方法入手。
　　回头再次审视JDK给我们的错误提示不难发现编译器需要的是形如Student（String name， int age）的构造方法，但是却找到了形如Student（）的构造方法，这是从编译器的提示中得到的解释，看似没有问题。但是在这里，我想再次提到一个细节：按照一般的思路，当我们遇到这种错误的时候，会从主函数即从new Student（）.introduction（）这句话入手，当我们看到这句话的时候，首先想到的是调用形如Student（）的构造方法，可是从代码中明显看到并没有定义该方法，这就回到了上面提到的默认构造方法的问题。然而我们确切地知道子类必须要调用父类的构造方法（实际上，子类对象都包含了一个父类的对象，该对象必须有父类的构造方法实施创建），所以此时必须有一个父类的构造方法站出来，可惜失败了，所以错误产生了。对于这个推理，大家觉得如何？初步看来，有些道理，但是经不起更为周详的推敲啊！ 　　首先，我们可以做一个最为简单的事情——将new Student（）.introduction（）这句话注释掉，即： 　　这是本文程序的第4个版本，令人惊奇的是，注释掉这句话，还是会产生同样的错误？！上面的推理正是从这句话开始的，这不由得让我们开始怀疑，到底是怎么了？其实这个涉及到更为深层的议题——类的加载问题，该文不打算深入探讨。这就是计算机语言的迷人之处，我们如果经常做这样的推理和思考，不仅可以深入地研究问题，将相关的知识做一个深入的认知，同时也能发现其中的乐趣，对于这种乐趣，个人觉得是了不起的东西。 　　其次，如上所述，根据JDK的提示，我们可以轻易得出两个假设：一是系统确实给Student类提供了默认的构造方法，二是系统不需要这个默认的方法，而是需要形如Student（String name， int age）{}的方法。这又是一个推理，这个推理如何呢？能够经得住推敲么？为此我们产生了第5个版本： 　　/*@ 5 @*/ 　　class Student extends Person { 　　Student（）{} 　　}// Student定义完毕 　　这里我们显式地加上和系统提供的默认构造方法一样的方法，结果JDK给出了这样的提示：ExtendsDemo.java：21： 错误： 无法将类 Person中的构造器 Person应用到给定类型；Student（）{}，需要： String，int 找到： 没有参数；原因： 实际参数列表和形式参数列表长度不同。和上面的错误对比不难发现，几乎是一样的描述，这就证实了第一个假设，那么对于第二个假设呢？给出第6个版本： 　　此时的结果如何呢？真的会成功么？答案是否定的，错误依旧，而且给出的编译错误和第5个版本一模一样。到这里，我们看到第二个假设好像有些不对，并非我们初步预计的那样——只要形式一样就可以调用。这里我们要驻足好好思索一番，到底子类是如何调用父类构造方法的呢？ 　　第6个版本的问题归结为无法匹配父类的构造方法。为此我们让默认的进行匹配，通过第一个版本我们可以看到，默认的是可以进行匹配的，那么显式的也可以么？为此对于Student，回到了第5个版本，对Person，在第3个版本的基础上，增加了如下代码： 　　在第7个版本中，显式地给出了不带参数的构造方法，即“系统默认”的，也就是说，我们对Person的构造方法进行了重载，这时的结果如何呢？果不其然，编译成功了！其结果和第1个版本是一样的。看着是回到了从前，但是我们经过了一个较为复杂的过程，而且是为了看清隐藏的东西而利用了探究式思维。由此我们可以得出结论：形如默认的构造方法是可以进行父子类之间的自然匹配，如果还要加个状语的话，我想是“只有”。为什么是自然匹配呢？请看第8个版本： 　　我们保持了Person的定义不变，Student似乎回到了第5个版本，不过增加了super（name，age）；当然测试中，必须给出相应的参数列表。此时程序得到了预期的结果，这里super就成了主角。super表示父类的实例，所以这句话就完成了子类和父类的构造方法的匹配，显然这种匹配不是自然的，是经过super进行的。所以我们可以得出两个结论：一是进一步证实了只有默认构造方法才可以自然匹配，二是可以通过super进行显式匹配。注意本文中的匹配是特指子类和父类在构造方法上的匹配。当然可以做更为周密的求证，这里不再赘述！ 　　我们通过了super完成了子类对父类构造方法的调用，那么对于重载的构造方法之间可以相互调用么？看我们的第9个版本： 　　即给Person也重载了一个形如默认的构造方法，不过其方法体使用了this（null，0）；这里不再给出具体的测试程序和结果，大家可以自行测试。主要说明其意义和this的用法，this意味着当前的对象，后面的参数列表表明了调用哪个方法。这个不难理解，但是千万注意，对this的使用必须出现在构造方法的第一句，而且只能出现一次，同时不能出现递归调用。 　　考虑第10个版本： 　　如果将this（）放在第二行（只要不是第一行就行），则会有“ExtendsDemo.java：12： 错误： 对this的调用必须是构造器中的第一个语句”的错误提示。 　　这再次说明了利用JDK的错误提示的重要意义。 　　3 问题延伸 　　在前面的探讨中，我们有两个假设：类是外部类，构造方法都是非私有的（保护或者公有）。那么当我们面临内部类和私有的构造方法将如何呢？ 　　请看如下代码，这个和前面的没有关系，故重新从第1版开始。 　　在本例中，引入了两个内部类，A和B，而且A是父类，B是子类。同时A有一个私有的构造方法。在主方法中，有这么一句话：B b = new ExtendsDemo1（）.new B（）；这句话并不好理解，这实际上是外部类引用内部类的构造方法的问题，不过恰恰是在特定的场合出现的，所以看着比较别扭。 　　好了，至此我们基本上完成了有关构造方法的全部探讨，虽然仍然不够深入。不过上例是在内部类中演绎私有构造方法的，如果将其作为外部类，情况将有所不同。请看第2版： 　　可以看出这就不可以了，因为私有的方法是不可以被继承的。所以子类无法调用父类的构造方法，我做了很多尝试，试图在子类的构造方法中构造出一个父类的实例来，可是都以失败告终，具体的尝试不再列出。所以我不得不给出如下结论：如果一个类的全部构造方法都是私有的，则该类无法被继承。这和final有着异曲同工之妙。 　　那么除此之外，私有化构造方法还有什么意义么？有，而且很大！这就是单例设计模式。其思路是私有化构造方法，然后向外提供一个指向自己实例的静态属性，这样外界无论有多少指向自身的引用，都统统地指向这个唯一的实例，而且只能够如此！下面是一个简单的演绎： 　　本文仅仅给出设计模雏形，旨在演示构造方法的意义。 　　4 结论 　　本文通过两个简单的例子，利用探究式思维逐步剖析，结合具体的代码，主要从构造方法的必要性，子类和父类构造方法的关系，构造方法的重载以及调用几个方面进行了较为深入和完整的分析。最后结合内部类以及私有化做了延伸，并对单例设计模式做了初步的探讨。该文得到的结论全部建立在实践的基础之上，是对代码的深入思考以及和计算机及其相关领域的专家进行交流的结果。个人认为，结论并不重要，倒是从中获得的乐趣和其中的一些方法给了我很大的动力去抛砖引玉，对其中不足的地方，欢迎大家批评指正，在此表示深深的谢意！ 　　参考文献： 　　[1] 梁胜彬. Java程序设计实例教程[M].北京：清华大学出版社，2011. 　　[2] 王珊，萨师煊.数据库系统概论[M].4版.北京：高等教育出版社，2006. 　　[3] 埃史尔.Java编程思想[M].4版.陈昊鹏，译.北京： 机械工业出版社， 2007.
转载请注明来源。原文地址：
【xzbu】郑重声明：本网站资源、信息来源于网络，完全免费共享，仅供学习和研究使用，版权和著作权归原作者所有，如有不愿意被转载的情况，请通知我们删除已转载的信息。
xzbu发布此信息目的在于传播更多信息，与本网站立场无关。xzbu不保证该信息（包括但不限于文字、数据及图表）准确性、真实性、完整性等。百度拇指医生
&&&普通咨询
您的网络环境存在异常，
请输入验证码
验证码输入错误，请重新输入java 继承问题 实例化子类之前先要实例父类 执行子类构造方法前先执行父类构造方法 那么如果父_百度知道
java 继承问题 实例化子类之前先要实例父类 执行子类构造方法前先执行父类构造方法 那么如果父
java 继承问题 实例化子类之前先要实例父类执行子类构造方法前先执行父类构造方法那么如果父类成员变量是其他对象的引用呢 是先调用父类成员引用的构造方法初始化成员变量 还是 先执行父类构造方法之后初始化父类成员变量和其他
我有更好的答案
一定会调用，原因是这样的。因为子类继承了父类，那么就默认的含有父类的公共成员方法和公共成员变量，这些方法和变量在子类里不再重复声明。如果你初始化子类的时候，不初始化父类，那么你通过子类调用父类方法或变量的时候会出现什么情况呢？当然就是抛异常阿！所以，Java虚拟机会在你初始化子类的时候默认的初始化子类的父类。而且是一层一层的往上递进！
采纳率：89%
来自团队：
所以你的问题的解答应该是如果那个引用有用new进行对象实例化，就会先调用父类成员引用的构造方法初始化成员变量，没有初始化只是定义就会初始化为Null,然后再调用父类的构造器继续初始化的。，产生某个子类对象时，再依次递归找到最上层的父类先进行成员初始化（对象引用没有直接赋值就初始化为Null）,再调用相应的构造器产生对象，然后逐层的进行对象初始化直到最底层的子类，对象引用则是null），最初虚拟机会依次递推找到最上层的父类，执行完类加载与静态成员的初始化；当main函数中执行代码,float什么会初始化为0啊，char会初始化为空字符啊，boolean初始化false啊神马那个。。= =。java类的初始化都是先初始化非静态成员（就是那个基本变量intjava中扩展类的初始化过程是这样的，再调用构造函数初始化的
本回答被提问者采纳
参照百科：（5）子类必须调用父类的构造函数。可以通过系统自动调用父类的默认构造函数，如果父类没有默认构造函数时，子类构造函数必须通过super调用父类的构造函数。
？？？？？问题都不完全
如果父类没有构造函数，那么默认是父类的构造函数是空的，则直接实例子类构造方法
1.开门见山直接回答知识点2.对相关知识点进行延伸3.规范排版，内容充实更容易通过认证哦4.补充参考资料（没有可以忽略哦~）
其他3条回答
为您推荐：
其他类似问题
构造方法的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。