java繼承構造
1. java繼承里關於構造方法的問題。
首先說不要用顯式這種詞語,哈佛大學的教授比起野雞大學里的教授區別就是他說的你能懂。然後AB在不在一個包里沒有區別,導入之後就在一個包里了。B默認繼承A的構造方法,B必須要重寫A的方法,具體為啥我忘了。這個問題是可以改進的,但是java規定子類必須重寫,反正就這樣記住就好了。另外protected的范圍是父類子類,和包沒有關系。
2. java 在繼承中的構造方法
java繼承中對構造函數是不繼承的，只是調用（隱式或顯式）。
舉例說明：
public class FatherClass {
public FatherClass() {
System.out.println(100);
}
public FatherClass(int age) {
System.out.println(age);
}
}
public class SonClass extends FatherClass{
public SonClass() {
}
public SonClass(int c) {
System.out.println(1234);
}
public static void main(String[] args) {
SonClass s = new SonClass(66);
}
}
編譯後執行結果如下：
分析：SonClass s = new SonClass(66);
執行這句時，調用
public SonClass(int c) {
System.out.println(1234);//系統會自動先調用父類的無參構造函數(super())
}
在這個構造函數中，等價於
public SonClass(int c) {
super();//必須是第1行，否則不能編譯
System.out.println(1234);
}
所以結果是 100 1234
在創建子類的對象時，Java虛擬機首先執行父類的構造方法，然後再執行子類的構造方法。在多級繼承的情況下，將從繼承樹的最上層的父類開始，依次執行各個類的構造方法，這可以保證子類對象從所有直接或間接父類中繼承的實例變數都被正確地初始化。
3.如果子類構造函數是這樣寫的
public SonClass(int c) {
super(22);//必須是第1行，否則不能編譯
//顯式調用了super後，系統就不再調用無參的super()了;
System.out.println(1234);
}
執行結果是 22
1234
總結1：構造函數不能繼承，只是調用而已。
如果父類沒有無參構造函數
創建子類時，不能編譯，除非在構造函數代碼體中第一行，必須是第一行顯式調用父類有參構造函數
如下：
SonClass (){
super(777);//顯示調用父類有參構造函數
System.out.println(66);
}
如果不顯示調用父類有參構造函數，系統會默認調用父類無參構造函數super();
但是父類中沒有無參構造函數，那它不是不能調用了。所以編譯就無法通過了。
總結2：創建有參構造函數後，系統就不再有默認無參構造函數。
如果沒有任何構造函數，系統會默認有一個無參構造函數。
3. java構造函數繼承問題
構造函數不能被繼承，跟你的這個問題沒關系的：
在子類實例化之前，要確保父類已經實例化，否則就會報錯；
如果父類有默認的構造函數 ，根據你的例子中來舉例，即：public Person（）{}；
則子類在繼承時，會在其默認的構造方法里調用父類的構造方法，即：
public Student() { super();}
在沒有顯示定義構造函數的時候，上面的例子就是默認的構造函數，隱藏著的；
如果父類顯示定義有構造函數，則默認的構造函數不存在了；
在他繼承的子類中，默認的構造函數無法自動調用父類的構造函數就會報錯了；
你在子類中寫這樣一個構造函數，就不會報錯；也容易理解；
public Student(){
super("", 0);
}；
另外：構造函數不能被繼承，是說子類不能直接用父類的構造函數來實例化；
應該解釋的比較清楚了！
4. java構造函數能否被繼承,為什麼
不能，因為子類繼承父類的時候，先運行父類構造函數；具體的說就是運行父類時就會先「調用」父類的構造函數，注意「調用」和繼承不是一個含義，實質上是「自動運行」。
繼承（extends）的含義其實是「擴展」，子類完全沒必要擴展父類的構造函數，因為反正每次調子類的時候都會「自動運行」它父類的構造函數，如果真的需要子類構造函數特殊的形式，子類直接修改或重載自己的構造函數就好了。
估計是你對「構造函數」的意義本身不理解，「調用」一個類有「繼承」和「組合（說白了new 一個類）」兩種方式，當你「調用」一個類的時候就會「自動運行」它的「構造函數」。
5. java構造方法繼承問題
對於一個對象， 如果沒有定義任何構造函數， 它繼承父類的無參構造函數，
但如果一個對象，定義了構造函數， 則，它不會繼承父類的無參構造函數，
6. Java 繼承和構造方法
Student(java.lang.String name, java.lang.String school);
0 aload_0 [this]
1 aload_1 [name]
2 ldc <String "beijing"> [10]
4 aload_2 [school]
5 invokespecial MyBatis.Student(java.lang.String, java.lang.String, java.lang.String) [12]
8 return
Student(java.lang.String n, java.lang.String l, java.lang.String school);
0 aload_0 [this]
1 aload_1 [n]
2 aload_2 [l]
3 invokespecial MyBatis.Person(java.lang.String, java.lang.String) [20]
6 aload_0 [this]
7 aload_3 [school]
8 putfield MyBatis.Student.school : java.lang.String [22]
11 return
直接查看class文件，我們會發現Student(String name, String school)這個方法調用的是5 invokespecial MyBatis.Student(java.lang.String, java.lang.String, java.lang.String) [12]，而在Student(String n,String l,String school) 中調用的是 3 invokespecial MyBatis.Person(java.lang.String, java.lang.String) [20]
7. Java構造方法繼承問題
你好，很高興為你解答。
這段代碼提示B的構造函數錯誤。這是因為B繼承A，B的構造函數會自動調用A的默認構造函數(即不帶參數的構造函數)，但A沒有定義默認構造函數，所以就會報錯。有兩種改法：
1）在A中增加默認構造函數。如下：
class
A
{
int
a;
String
name;
String
sex;
A(){
//修改這兒
}
A(int
a,
String
name,
String
sex)
{
this.a
=
a;
this.name
=
name;
this.sex
=
sex;
}
void
ShowMess()
{
}
}
class
B
extends
A
{
int
age;
B(int
a,
String
name,
String
sex,
int
age)
{
this.a=a;
this.name=name;
this.sex=sex;
this.age=age;
this.age
=
age;
}
void
ShowMess()
{
System.out.println("a+name+sex+age");
}
}
2）修改B的構造函數，顯式地調用A的非默認構造函數。如下：
class
A
{
int
a;
String
name;
String
sex;
A(int
a,
String
name,
String
sex)
{
this.a
=
a;
this.name
=
name;
this.sex
=
sex;
}
void
ShowMess()
{
}
}
class
B
extends
A
{
int
age;
B(int
a,
String
name,
String
sex,
int
age)
{
super(a,name,sex);
//修改這兒
this.age
=
age;
}
void
ShowMess()
{
System.out.println("a+name+sex+age");
}
}
8. java-繼承/構造方法
9. java中一個子類是否可以繼承父類的構造方法
子類可以繼承父類的構造方法，並遵循以下原則：
1、子類無條件的繼承父類的無參構造方法。
2、子類自身沒有定義構造方法，繼承父類的無參構造方法，作為構造方法；子類自身定義了無參構造方法。
3、對於父類的含參構造方法，子類可以在自己的構造方法的第一行使用關鍵字super來調用。
代碼如下：
//Fighter.java
class Airplane{
private int speed;
public Airplane(int s) {
speed=s;
System.out.println;
}
}
class Warplane extends Airplane{
public Warplane() {
super(600);
System.out.println;
}
public Warplane(int s) {
super(s);
System.out.println;
}
}
public class Fighter extends Warplane{
public Fighter(){
super();
System.out.println);
}
public Fighter(int s){
super(s);
System.out.println;
}
public static void main(String[] args) {
System.out.println;
Fighter f1=new Fighter();
System.out.println;
Fighter f2=new Fighter(500);
}
}
10. 關於java中子類繼承父類的構造方法
java繼承中對構造函數是不繼承的，只是調用（隱式或顯式）。
舉例說明：
public class FatherClass {
public FatherClass() {
System.out.println(100);
}
public FatherClass(int age) {
System.out.println(age);
}
}
public class SonClass extends FatherClass{
public SonClass() {
}
public SonClass(int c) {
System.out.println(1234);
}
public static void main(String[] args) {
SonClass s = new SonClass(66);
}
}
編譯後執行結果如下：
分析：SonClass s = new SonClass(66);執行這句時，調用
public SonClass(int c) {
System.out.println(1234);//系統會自動先調用父類的無參構造函數(super())
}
在這個構造函數中，等價於
public SonClass(int c) {
super();//必須是第1行，否則不能編譯
System.out.println(1234);
}
所以結果是 100 1234
3.如果子類構造函數是這樣寫的
public SonClass(int c) {
super(22);//必須是第1行，否則不能編譯
//顯式調用了super後，系統就不再調用無參的super()了;
System.out.println(1234);
}
執行結果是 22
1234
總結1：構造函數不能繼承，只是調用而已。
如果父類沒有無參構造函數
創建子類時，不能編譯，除非在構造函數代碼體中第一行，必須是第一行顯式調用父類有參構造函數
如下：
SonClass (){
super(777);//顯示調用父類有參構造函數
System.out.println(66);
}
如果不顯示調用父類有參構造函數，系統會默認調用父類無參構造函數super();
但是父類中沒有無參構造函數，那它不是不能調用了。所以編譯就無法通過了。
總結2：創建有參構造函數後，系統就不再有默認無參構造函數。
如果沒有任何構造函數，系統會默認有一個無參構造函數。