java怎麼構造函數

1. java構造函數

1.程序首先執行main函數
2.創建Fact的對象N，並用有參構造函數初始化。
3.程序進入到Fact類中的構造函數Fact（int nn）中，用nn給成員變數n賦值。然後跳出。
4.執行N.fact（）。就是用對象調用其方法fact（）
5.程序進入到fact（）中。聲明變數i、f，並初始化f，使其值為1。然後程序進入到for循環中，為i賦初值為1，循環控制條件為i小於等於n。進入循環體中，執行f×i，並將其結果賦值給f。每執行一次循環i加1.執行n次循環後返回f。
6.執行System.out.println,意思是輸出N.fact（）的返回值，就是第五步返回的f值。
7.程序結束，執行默認析構函數，釋放對象。
//看看我哪沒說清楚

2. java構造函數怎麼寫

構造函數是對象被創建時初始對象的成員函數。它具有和它所在的類完全一樣的名字。一旦定義好一個構造函數，創建對象時就會自動調用它。
構造函數沒有返回類型，即使是void類型也沒有。這是因為一個類的構造函數的返回值的類型就是這個類本身。

3. java 構造方法 函數

java的構造函數其實很簡單。
一個類 被實例化 也就是被new的時候 最先執行的是 構造函數，如果你有留心。你會發現很多類裡面根本沒有寫構造函數。
在java類中，如果不顯示聲明構造函數，JVM 會給該類一個默認的構造函數。一個類 可以有多個構造函數。構造函數的主要作用 一是用來實例化該類。二是 讓該類實例化的時候執行哪些方法，初始化哪些屬性。當一個類聲明了構造函數以後，JVM 是不會再給該類分配默認的構造函數。
比如一個實體類
public class entity{
private int id;
private String userName;
get...set..方法
}
如果這樣寫該類就是默認的構造函數。該類實例化的時候 id 和 username 就是默認值 即 id=0,username=null.
如果在裡面加入這樣一個方法
public entity(int id,String userName){
調用get..set..
}
如果這樣寫 該類實例化的時候 必須給出 id 和username參數。 JVM不會再給這個類默認構造函數
你也可以理解成 在沒有給構造函數的時候 JVM 給你的類加了一個這樣的函數
public entity(){
this.id=0;
this.userName=null;
}
其實構造函數是用來對一個類以及變數進行實例化。

4. Java中構造函數是什麼它應該具體怎麼用呢

是構造方法,不是構造函數,後者是C++的概念

首先要注意的是Java的構造器並不是函數，所以他並不能被繼承，這在我們extends的時候寫子類的構造器時比較的常見，即使子類構造器參數和父類的完全一樣，我們也要寫super就是因為這個原因。
構造器的修飾符比較的有限，僅僅只有public private protected這三個，其他的例如任何修飾符都不能對其使用，也就是說構造器不允許被成名成抽象、同步、靜態等等訪問限制以外的形式。
因為構造器不是函數，所以它是沒有返回值的，也不允許有返回值。但是這里要說明一下，構造器中允許存在return語句，但是return什麼都不返回，如果你指定了返回值，雖然編譯器不會報出任何錯誤，但是JVM會認為他是一個與構造器同名的函數罷了，這樣就會出現一些莫名其妙的無法找到構造器的錯誤，這里是要加倍注意的。

在我們extends一個子類的時候經常會出現一些意想不到的問題，我在這里說一些和構造器有關的。
首先說一下Java在構造實例時的順序（不討論裝載類的過程）
構造的粗略過程如下
1、分配對象空間，並將對象中成員初始化為0或者空，java不允許用戶操縱一個不定值的對象。
2、執行屬性值的顯式初始化（這里有一點變化，一會解釋，但大體是這樣的）
3、執行構造器
4、將變數關聯到堆中的對象上

介紹一下准備知識，以備一會來詳細說明這個的流程
this() super()是你如果想用傳入當前構造器中的參數或者構造器中的數據調用其他構造器或者控制父類構造器時使用的，在一個構造器中你只能使用this()或者super()之中的一個，而且調用的位置只能在構造器的第一行， 在子類中如果你希望調用父類的構造器來初始化父類的部分，那就用合適的參數來調用super()，如果你用沒有參數的super()來調用父類的構造器（同時也沒有使用this()來調用其他構造器），父類預設的構造器會被調用，如果父類沒有預設的構造器，那編譯器就會報一個錯誤，注意此處，我們經常在繼承父類的時候構造器中並不寫和父類有關的內容，此時如果父類沒有預設構造器，就會出現編譯器添加的預設構造器給你添麻煩的問題了哦。例如：Class b extends a{public b(){}}就沒有任何有關父類構造器的信息，這時父類的預設構造器就會被調用。

舉個SL-275中的例子
1 public class Manager extends Employee {
2 private String department;
3
4 public Manager(String name, double salary, String dept)
{
5 super(name, salary);
6 department = dept;
7 }
8 public Manager(String n, String dept) {
9 super(name);
10 department = dept;
11 }
12 public Manager(String dept) { // 這里就沒有super()，編譯器會自動地添加一個空參數的預設super構造器，此時如果Employee類中沒有空參數的預設構造器，那就會導致一個編譯錯誤
13 department = d;
14 }
15 }

你必須在構造器的第一行放置super或者this構造器，否則編譯器會自動地放一個空參數的super構造器的，其他的構造器也可以調用super或者this，調用成一個遞歸構造鏈，最後的結果是父類的構造器（可能有多級父類構造器）始終在子類的構造器之前執行，遞歸的調用父類構造器

在具體構造類實例的過程中，上邊過程的第二步和第三步是有一些變化的，這里的順序是這樣的，分配了對象空間及對象成員初始化為默認值之後，構造器就遞歸的從繼承樹由根部向下調用，每個構造器的執行過程是這樣的：
1、Bind構造器的參數
2、如果顯式的調用了this，那就遞歸調用this構造器然後跳到步驟5
3、遞歸調用顯式或者隱式的父類構造器，除了Object以外，因為它沒有父類
4、執行顯式的實例變數初始化（也就是上邊的流程中的第二步，調用返回以後執行，這個步驟相當於在父構造器執行後隱含執行的，看樣子像一個特殊處理）
5、執行構造器的其它部分

這里的步驟很重要哦！！！！！

從這個步驟中可以很明顯的發現這個實例初始化時的遞歸調用過程，估計看過這個你應該能夠理解這個遞歸構造鏈是怎麼樣回事了。

這里還是給出SL-275中的一個例子，讓你充分理解一下這個遞歸的過程。

public class Object {
...
public Object() {}
...
}
public class Employee extends Object {
private String name;
private double salary = 15000.00;
private Date birthDate;
public Employee(String n, Date DoB) {
// implicit super();
name = n;
birthDate = DoB;
}
public Employee(String n) {
this(n, null);
}
}

public class Manager extends Employee {
private String department;
public Manager(String n, String d) {
super(n);
department = d;
}
}

在創建Manager("Joe Smith","Sales"):時，步驟如下
0 basic initialization
0.1 allocate memory for the complete Manager object
0.2 initialize all instance variables to their default values (0 or null)
1 call constructor: Manager("Joe Smith", "Sales")
1.1 bind constructor parameters: n="Joe Smith", d="Sales"
1.2 no explicit this() call
1.3 call super(n) for Employee(String)
1.3.1 bind constructor parameters: n="Joe Smith"
1.3.2 call this(n, null) for Employee(String, Date)
1.3.2.1 bind constructor parameters: n="Joe Smith", DoB=null
1.3.2.2 no explicit this() call
1.3.2.3 call super() for Object()
1.3.2.3.1 no binding necessary
1.3.2.3.2 no this() call
1.3.2.3.3 no super() call (Object is the root)
1.3.2.3.4 no explicit variable initialization for Object
1.3.2.3.5 no method body to call
1.3.2.4 initialize explicit Employee variables: salary=15000.00;注意：在父構造器返回後子類才會初始化實例變數的值。
1.3.2.5 execute body: name="Joe Smith"; date=null;
1.3.3 - 1.3.4 steps skipped
1.3.5 execute body: no body in Employee(String)
1.4 no explicit initializers for Manager
1.5 execute body: department="Sales"

這個流程就說明了一切，這個步驟是要注意的。一會還有些內容是要涉及到這里的。

寫在後邊的一些在使用構造器中的注意事項。

一、構造器中一定不要創建自身的實例，否則會造成調用棧溢出錯誤。這個規則也適用於對象的實例變數，如果對象中有自身的引用，這個引用一定不能在定義中或者構造器中初始化。

class a
{
a _a = new a();

public a()
{
_a = new a();
a _b = new a();
}
}

以上三種情況都會造成棧溢出，呵呵，這樣會造成一個無窮遞歸的調用棧。

二、如果父類是一個抽象類，那通過調用父類的構造器，也可以將它初始化，並且初始化其中的數據。
三、如果你要在構造器中調用一個方法時，將該方法聲明為private。
對於這個規則是需要一些說明的，假使你的父類構造器中要調用一個非靜態方法，而這個方法不是private的又被子類所重載，這樣在實際創建子類的過程中遞歸調用到了父類的構造器時，父類構造器對這個方法的調用就會由於多態而實際上調用了子類的方法，當這個子類方法需要用到子類中實例變數的時候，就會由於變數沒有初始化而出現異常（至於為什麼子類中的實例變數沒有初始化可以參考上邊的實例初始化過程），這是Java不想看到的情況。而當父類構造器中調用的方法是一個private方法時，多態就不會出現，也就不會出現父類構造器調用子類方法的情況，這樣可以保證父類始終調用自己的方法，即使這個方法中調用了父類中的實例變數也不會出現變數未初始化的情況（變數初始化總是在當前類構造器主體執行之前進行）。

5. 求問java的一個構造函數怎麼寫！！！急！！！

你需要的構造函數：

public class Car {
public static int NUM = 0;
public int VIN = 0;
public Car(){
NUM++;
VIN = NUM;
}
}
思考點：在於new幾次之後，car裡面的vin屬性就是幾。所以需要用到一個靜態變數來存儲，創建對象的次數，然後在將這個變數賦值給vin。

6. java 中構造函數怎麼編呢

舉個列子吧
private long money; 定義一個私有變數類型為LONG 的MONEY
private double rate 定義一個私有變數類型為double 的rate
public (void) bank(long money,double rate)
{
this.money=money; 這個私有變數等於這個構造函數中參數
this.rate=rate; 同上
}
這個就是簡單的構造函數，通俗的講就是你實現這個功能的演算法，比如累加，判斷，循環等等
最常用的就是GET 和SET方法
構造方法可以有參數，也可以無參數。
這就是簡單的概念，深入點的話就要重寫，重載，多態，繼承，介面等等了，你可以隨便找本JAVA的書看看，都有的

7. java的構造函數是怎樣的，跟c語言有什麼區別

構造函數，是在類實例化對象時，自動調用的，例如實例化A的一個對象a
A
a
=
new
A()，就一定先走A（），其實就是先走構造函數。
構造函數里可以進行一些初始化的工作，
構造函數可以是傳參數也可以無參，並且構造函數必須和類同名，沒有返回類型，void類型也不可以。

8. java 構造函數的執行過程

java 構造函數的執行過程
類初始化時構造函數調用順序：
（1）初始化對象的存儲空間為零或null值；
（2）調用父類構造函數；
（3）按順序分別調用類成員變數和實例成員變數的初始化表達式；
class Dollar {
Money m = new Money();
Rmb r = new Rmb();
public Dollar() {
System.out.println(Dollar is construct!);
}
public static void main(String[] args) {
new Dollar();
}
}
class Money {
public Money() {
System.out.println(Money is construct!);
}
}
class Rmb {
public Rmb() {
System.out.println(RMB is construct!);
}
}
輸出結果:
Money is construct
RMB is construct
Dollar is construct!

9. JAVA構造方法

1. 構造方法的方法名必須與類名一樣。

2. 構造方法沒有返回類型，也不能定義為void，在方法名前面不聲明方法類型。

3. 構造方法不能作用是完成對象的初始化工作，他能夠把定義對象時的參數傳遞給對象的域。

4. 構造方法不能由編程人員調用，而要系統調用。

5. 構造方法可以重載，以參數的個數，類型，或排序順序區分。

   例子：

   1；單個構造函數方法；』
   

10. JAVA的構造函數是怎麼寫的。萬分感謝。路過的請不要嘲笑%>_<%

JAVA的構造函數是：SetLocal EnableDelayedExpansion

set classpath=.

for %%c in (lib*.jar) do set classpath=!classpath!;%%c

set classpath=%classpath%;./classes;

java com.ham.server.Server。

1、無參構造方法

無參構造方法又分為隱式無參構造方法和顯示無參構造方法。

隱式無參構造方法

在定義類的時候，如果沒有給類定義一個構造方法，Java編譯器在編譯時會默認提供一個隱式的構造方法，它沒有任何參數，並且有一個空的方法體。例如，Person類中隱含一個無參構造方法，在main方法中可以通過new關鍵字來調用此默認的構造方法，代碼如下：