java類中的構造方法

Ⅰ 什麼叫做java的構造方法（含義）

在Java中，每個類都需要至少一個的構造方法（可以有多個），它用於構造類的對象；在Java中構造方法必須與類名相同；構造方法可以不帶有參數、也可以帶有參數，不帶有參數的構造方法被稱為無參構造（no-arg）方法。

這里大家可能會覺得奇怪，我們之前的MainClass好像就沒有構造方法。其實是這樣的，如果我們不給類提供構造方法，編譯器會自動提供一個無參構造方法。

定義構造方法的語法如下：

Java代碼
constructorName (listOfArguments) {
[constructor body]
}
其中constructorName必須和你定義的類的名字相同，listOfArgumengs是構造方法的參數列表，當然，這里也可以不帶有任何參數。然後大括弧內是我們的方法體。這里提一下，構造方法也可以帶有訪問控制符，即public、protected、private和default（忽略情況下）。

下面的例子給出了一個構造方法的實例：

Java代碼
public class MainClass {
double radius;

// Class constructor
MainClass(double theRadius) {
radius = theRadius;
}
}
可以看出，我們給MainClass定義了一個構造方法，它的修飾符是默認的。後面的教程大家會學到這幾個訪問控制符的作用。我們的MainClass的構造方法帶有一個double參數，這里大家也可以看出，構造方法的參數可以用於初始化類的屬性，其實強制要求帶參數的構造方法可以保持類的狀態的完整性，即保證構造出的對象是符合要求的。

默認構造方法
前面我講過，如果沒有提供構造方法，編譯器會提供一個默認的構造方法（沒有參數）。這里其實也隱含著一個意思，即，如果我們提供了構造方法，那麼編譯器是不會提供默認的構造方法的。我們可以通過下面的代碼來驗證。

Java代碼
public class MainClass {
double radius;

// Class constructor
MainClass(double theRadius) {
radius = theRadius;
}

public static void main(String[] args) {
MainClass mc = new MainClass();
}
}
大家可以嘗試編譯上面的代碼，可以發現編譯會出錯，提示的錯誤信息為：

Java代碼
The constructor MainClass() is undefined
這個信息的意思是構造方法MainClass()沒有定義，即編譯器沒有給我們提供默認的構造方法。那麼如果我們還想繼續使用無參的構造方法的話，這就需要我們自己來提供了，如：

Java代碼
public class MainClass {
double radius;

MainClass() {

}

// Class constructor
MainClass(double theRadius) {
radius = theRadius;

}

}
上面的代碼我們自己手動的提供了一個無參的構造方法MainClass()，大家現在嘗試編譯代碼，會發現，代碼是可以通過編譯的。所以在自己實際的工作中，稍微注意這點。

多個構造方法
其實我們前面已經見過多構造方法的例子了，不過這里給大家提示下，Java支持一個類中定義多個構造方法，如：

Java代碼
class Sphere {
int radius = 0;

Sphere() {
radius = 1;
}

Sphere(int radius) {
this.radius = radius;
}
}
這里我們定義了球（Sphere）類，然後定義了它的半徑並提供了兩個構造方法。在默認的構造方法里，我們將半徑設置為1，然後在帶有半徑作為參數的構造方法中，我們設置了半徑為提供的值。

在一個構造方法中調用另一個方法
我們一直稱呼構造方法，那麼既然是方法，當然支持方法的調用。在Java中，我們可以從一個構造方法中調用另一個構造方法。要調用另一個方法，只要使用this關鍵字，然後後面跟著括弧，如果要調用的構造方法中帶有參數，只要將參數放到對應的位置即可。如：

Java代碼
class Sphere {
int radius = 0;
double xCenter;
double yCenter;
double zCenter;

Sphere() {
radius = 1;
}

Sphere(double x, double y, double z) {
this();
xCenter = x;
yCenter = y;
zCenter = z;
}

Sphere(int theRadius, double x, double y, double z) {
this(x, y, z);
radius = theRadius;
}
}
在使用這種方式的時候，稍微注意下，不要引起循環調用。在出現循環調用的時候，編譯器會出現類似於如下的提示來阻止類編譯通過：

Java代碼
Recursive constructor invocation MainClass(int)
它的意思是遞歸的構造方法調用，大家遇到這個問題的時候，稍微檢查下自己的代碼，看看構造方法是否出現遞歸調用了。

Ⅱ Java類的構造方法，怎麼

你搏帆這里構造方法調用其他構造方法，不能這么用。可以用this關神圓鍵字去代替。
public Student(String name, int id){
this(name); //調用本類一個參數的構造方法。 用this調用其基瞎雹他的語句，必須要放在構造函數中的第一個語句。
this.id = id;
}
public Student(String name){
this.name = name;
}

Ⅲ java 類 構造方法

PublicclassHero{
privateStringname;
Privateintattack;
Privateinthp;
Privateintmp;
Privateintspeed;
//構造方法
publicFather(Stringname,intattack,inthp,intmp,intspeed){
李差this.name=name;
this.attack=attack;
哪滑皮this.hp=hp;
this.mp=mp;
this.speed=speed;
}
}

publicclassHeroesextendsHero{
	privateStringskill;
	//構造方法
	publicHeroes(Stringname,intattack,inthp,intmp,intspeed,Stringskill){
		super(name,attack,hp,mp,speed);
		this.skill=skill;
	}
	//測試
	publicstaticvoidmain(String[]args){
		Heroesh1=new讓纖Heroes("劍聖",250,2500,0,530,"高原血統");
		Heroesh2=newHeroes("蠻子",350,2500,0,470,"無盡的怒火");
	}
	
}


哥們你這是瞎搞啊我純手給你打的望採納吧

Ⅳ java中構造方法有哪些條件一般什麼時候被調用

構造方法是類中比較特殊液隱大的方法、它有如下幾個特點
1.方法沒有返回值
2.方法名和類名相同
3.構造方法可以重載(包括參數類型不同的重鬧豎載和參數個數不同的重載)
4.每個類默認會有一個無參的構造函數
例：攜明
public Class User{
public User(){}
public User(String name,int age){
this.name = name;
this.age = age;
}
private String name;
private int age;
public String getName(){
return this.name;
}
public void setName(String name){
this.name = name;
}

public int getAge(){
return this.age;
}

public void setAge(int age){
this.age = age;
}

}

構造函數是在你New對象的時候被調用的
例: User user = new User();

Ⅳ java中什麼是構造方法及其作用

無意中翻到這條提問,看了很多回答,發現歧義較重,在這里解答一下,為了避免後邊來的朋友們踩雷
新手學習Java在構造方法這里很容易踩雷,構造方法是用來初始化的,這句勉強沒錯,可構造方法是用來創建對象的,這句就錯了,實際上,在構造方法執行之前,類的內存空間已經開辟完成了,意思就是說對象已經創建了,這步是由new關鍵字來完成的,而構造方法的作用是給類中的變數進行初始化賦值
假設,假設構造方法是用來創建對象用的,就無法解釋抽象類中為什麼允許構造方法的存在,抽象類無法實例化,不能被創建,但是抽象類中允許構造方法的存在,舉例從側面證明一下:
abstract class Animal{
String name;
public Animal() {
System.out.println("抽象父類的無參構造");
}
abstract void eat();
}
class Dog extends Animal{
public Dog() {
super();
System.out.println("子類的無參構造");
}
@Override
void eat(){

}
}
public class Test {
public static void main(String[] args) {
Dog d = new Dog();
System.out.println(d.name);
}
}
隨手敲的很簡陋的一段代碼,不要在意格式上的不嚴謹,領會精神,這段代碼執行後的結果為:
抽象父類的無參構造
子類的無參構造
null

當執行Dog d = new Dog()這句代碼時,大致會分兩步,一是載入類,開辟類的內存空間,這是由new完成的,第二步執行構造方法,為類中的變數初始化賦值,在執行Dog的無參構造時,系統會默認調用父類的無參構造,也就是super(),super關鍵字是對該類的父類進行的引用,它並不是一個對象,這也是個難點,感興趣的可以去查一下,而super()這句代碼可以簡單理解為調用這個類的父類的無參構造
在上述代碼中,父類Animal是一個抽象類,而抽象類不可被實例化,如果構造方法的作用是創建對象,在這一步上邏輯就無法自洽,而實際情況是:抽象類執行了構造方法,但卻沒有創建對象,同時成員變數name也有了初始值null

Ⅵ java中什麼叫構造方法

構造方法是一種特殊的方法，與一般的方法不同是：
1.構造方法的名字必須與定義他的類名完全相同，沒有返回類型，甚至連void也沒有。
2.構造方法的調用是在創建一個對象時使用new操作進行的。構造方法的作用是初始化對象。
3.不能被static、final、synchronized、abstract和native修飾。構造方法不能被子類繼承。

class RectConstructor{
double length;
double width;
double area(){
return length*width;
}

//下面這個方法就是所謂的構造方法，沒有返回值，方法名與類名相同~~~
RectConstructor(double width,double length){//帶參數的構造方法
this.length=length;
this.width=width;
}
}
其實構造方法就是為了給類中成員賦初值~~~~~~~~~~~~~

Ⅶ JAVA構造方法

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

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

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

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

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

   例子：

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

Ⅷ 請問java中，構造方法是什麼 能通俗的講講嗎

首先要搞清楚什麼是類方法，什麼是構造方法
一個類中的方法分為三類：
1）全局方法 2) 成員方法 3）構造方法
例：
123456789101112public class Test{private int age; //這是成員變數public Test(int age){ //這是構造方法this.age = age;}public void setAge(int age){ //這是成員方法this.age = age;}public static int getAge(){ //這是全局方法，加了static ，成員方法就會變成全局方法return this.age;}}
成員方法和構造方法沒啥關系，區別在於成員方法必須用類的實例化對象進行訪問，而全局方法是用類直接訪問的，而構造方法是實例化對象時進行初始化的

先解釋構造方法：
Test t = new Test(34);
這里的new Test(34) 括弧代表了構造方法，一般的構造的方法是默認的，可以不用寫，如果上面的構造方法不寫，這里就應該這樣實例化對象：
Test t = new Test();

成員方法：
Test t = new Test(34);
t.setAge(35);
用實例化對象調用普通方法即可

普通成員變數:
Test t = new Test(34);
因為變數age加了private 不能這樣調用：t.age = 35; 這樣是錯的，只能通過方法來進行修改

全局方法：
Test.getAge();
直接這樣調用就可以了，當然如果沒有實例化過，這里的Test.getAge()為0

Ⅸ JAVA中構造方法和普通方法的區別

JAVA中構造方法和普通方法的區別 1.建構函式的命名必須和類名完全相同;在java中普通函式可以和建構函式同名，但是必須帶有返回值。
2.建構函式的功能主要用於在類的物件建立時定義初始化的狀態.它沒有返回值,也不能用void來修飾.這就保證了它不僅什麼也不用自動返回,而且根本不能有任何選擇.而其他方法都有返回值.即使是void返回值,盡管方法體本身不會自動返回什麼,但仍然可以讓它返回一些東西,而這些東西可能是不安全的.
3.建構函式不能被直接呼叫,必須通過new運運算元在建立物件時才會自動呼叫,一般方法在程式執行到它的時候被呼叫.
4.當定義一個類的時候，通常情況下都會顯示該類的建構函式,並在函式中指定初始化的工作也可省笑爛帆略，不過Java編譯器會提供一個預設的建構函式.此預設建構函式是不帶引數的.而一般方法不存在這一特點
java中構造方法和普通方法的區別
構造方法：一個類 被例項化 也就是被new的時候 最先執行的是 構造方法，在java類中，如果不顯示宣告建構函式，JVM 會給該類一個預設的建構函式。一個類 可以有多個建構函式。建構函式的主要作用 一是用來例項化該類。二是 讓該類例項化的時候執行哪些方法，初始化哪些屬性。當一個類聲明了建構函式以後，JVM 是不會再給該類分配預設的建構函式。
其實建構函式是用來對一個類以及變數進行例項化。
JAVA中構造方法和普通方法的區別是什麼？
只有構造方法才能new，用於生成例項物件，分配記憶體空間等。
普通方法是不能new 的，可以通過物件名來呼叫。在物件有記憶體空間後可以處理類成員變數和呼叫其他的方法。
拿個不算恰當的比喻來說，
構造方法相當於給你開房間，普通方法是進房間後在自己的許可權內隨便玩，設定可以開另外一個房間。沒有房間之前，歷辯普通方法無用武之地。
java構造方法和普通方法的區別
構造方法沒有返回值，普通方法有返回值，構造方法在類的物件被建立時執行，普通方法在類的物件建立後呼叫時被執行
java中的構造方法和普通方法的區別
構造方不能寫返回值型別
構造方法是用來例項化物件的有有參的有無參的

Java 普通方法和構造方法的區別
構造方法:
①方法名和 類名相同
②在方法名的前面沒有返回值型別的宣告
③在方法中不能使用return語句返回一個值
④在建立物件時碰雹，要呼叫new，如:book b1=new book();
⑤當沒有指定構造方法時，系統會自動新增無參的構造方法
⑥當有指定構造方法時，無論該構造方法是有參，還是無參，系統都不會再自動新增無參的構造方法
⑦構造方法的過載：方法名相同，但引數不同的多個方法，呼叫時會自動根據不同的引數選擇相應的方法
無參的構造方法
class person{
public person(){
System.out.println("無參的構造方法被呼叫了。。。");
}
}
class Ex11{
public static void main(String[] args){
person p=new person();
}
}
有參的構造方法（目的就是為了給物件例項變數賦值）
class person{
int age;
public person(int a){
age=a;
}
public void speak(){
System.out.println("I am "+age+" years old");
}
}
class Ex11{
public static void main(String[] args){
person p=new person();
p.speak();
}
}
普通方法有返回型別，方法名小寫，不能和類名相同，如:void XX(){}普通方法：代表物件可以干什麼
構造方法是初始化物件的重要途徑，如:student s=new student(); s這個例項，是通過構造方法初始化的構造方法：可建立一個物件，並可初始化物件的值
構造方法有對類屬性得初始化的功能，如:public people(String name){this name=name;}或public people(){name="zangsan";age=11;} 完成了people類屬性name或age的初始化
php構造方法析構方法和普通方法的區別
有的類，需要進行一些初始化，比如賦初值、預設值，為類成員申請臨時空間，這些工作可以在建構函式中完成；解構函式可以將建構函式中申請的臨時空間釋放，也可以逐一檢查類中成員如果申請了臨時空間也一一釋放。
java中構造方法和方法的區別
1.建構函式的命名必須和類名完全相同;在java中普通函式可以和建構函式同名，但是必須帶有返回值。 2.建構函式的功能主要用於在類的物件建立時定義初始化的狀態.它沒有返回值,也不能用void來修飾.這就保證了它不僅什麼也不用自動返回,
java中構造方法和成員方法的區別
構造方法是類的一種特殊方法，用於例項化類時給類的一些屬性賦初值；成員方法則是類的一般方法，用來呼叫的。

例如：
public class Users{ private String username; private String password; public Users(){ Users的空構造方法 } public Users(String name,String password) { Users的第二種構造方法給使用者名稱和密碼賦值 this.username=name; this.password=password; } 以下是一般的成員方法給使用者名稱和密碼set賦值及get獲取 public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public static void main(String[] args){ 接下來利用構造方法例項化類,構造方法一 Users u= new Users(); System.out.println("使用者名稱："+u.username); System.out.println("密碼："+u.password);可以看到是空值 使用構造方法二 Users u= new Users("zhangsan","123456"); System.out.println("使用者名稱："+u.username); System.out.println("密碼："+u.password);可以看到使用者名稱是zhangsan，密碼是123456 使用一般方法 u.setUsername("lisi") u.setPassword("654321") System.out.println("使用者名稱："+u.getUsername()); System.out.println("密碼："+u.getPassword());可以看到使用者名稱是lisi，密碼是654321 }
｝
Java中static方法和普通方法的區別
static方法就是靜態方法。
靜態方法是類方法，類名即可引用。
普通方法是物件方法，需要例項化物件才可以引用

Ⅹ JAVA中構造方法，例項方法，類方法，有什麼區別

JAVA中構造方法，例項方法，類方法，有什麼區別？

構造方法：構造方法是用來構造類的物件的，方法名和類名相同沒有返回值。一般用 new 構造方法名() 來建立該類的物件。在不寫構造方法的情況下會有一個預設的無參構造方法，當然你也可以重寫和過載構造方法（建議你找一本《Java程式設計思想》看看，裡面講的很透徹）。
例項方法：簡單地說就是可以通過類的例項（某個物件）呼叫的方法，也就是我們正常情況下使用的方法。例項方法也稱成員方法（成員方法和成員變數的知扒襲識你可以參考《Java程式設計思想》）。
類方法：簡單地說就是直接可以用類名呼叫的方法，也就是被關鍵字static修飾的方法，它不需要建立類的物件來呼叫該方法。（關於static關鍵字的詳細用法你也可以在《Java程式設計思想》這本書中找到）。
《Java程式設計思想》是目前最好的Java參考書，網上有第3版的中文版電子書下的，第4版是英文的

Java中的構造方法與例項方法，有什麼區別？

java中所謂的構造方法是指JAVA虛擬機器在LOAD載入這個類的時候，利用構造方法來建立這個類的一個例項所呼叫的方法，典型的就是構造方法的過載
public class student{
private int id;
private String name;
private int age;
以 *** 現出構造方法的過載
public void student() {}
public void student(int id ,String name) { this.id=id; this.name= name;}
public void student(int id ,String name,int age) {this.id=id; this.name=name; this.age=age;}
}
呼叫方法是指已經在類庫中寫好的方法我們直接去呼叫就可以了，如：System.out.println();
至於例項方法可以理解為類的中普通方法，就是我們在類中自己建立定義的。

行為差異：構造方法，建立物件後自動呼叫構造方法，例項方法必須物件.例項方法進行呼叫。
功能差異：構造方法多用於初始化物件狀態，對屬性賦初值，例項方法用於實現某個功能

java中構造方法和方法有什麼區別

我不知道怎麼和你解釋，所以在網上找了點資料，希望可以幫助你。
構造方法要與類名相同，無返回型別，在類初始化的時候呼叫。
方法最好與類名不同，物件呼叫，靜態方法可用類名.方法（）.
功能和作用的不同
構造器是為了建立一個類襲則的例項。這個過程也可以在建立一個物件的時候用到：Platypus p1 = new Platypus();
相反，方法的作用是為了執行java程式碼。
修飾符，返回值和命名的不同
構造器和方法在下面三個方便的區別：修飾符，返回值，命名。和方法一樣，構造器可拍此棚以有任何訪問的修飾： public, protected, private或者沒有修飾（通常被package 和 friendly呼叫）. 不同於方法的是，構造器不能有以下非訪問性質的修飾： abstract, final, native, static, 或者 synchronized。
返回型別也是非常重要的。方法能返回任何型別的值或者無返回值（void），構造器沒有返回值，也不需要void。
最後，談談兩者的命名。構造器使用和類相同的名字，而方法則不同。按照習慣，方法通常用小寫字母開始，而構造器通常用大寫字母開始。構造器通常是一個名詞，因為它和類名相同；而方法通常更接近動詞，因為它說明一個操作。
"this"的用法
構造器和方法使用關鍵字this有很大的區別。方法引用this指向正在執行方法的類的例項。靜態方法不能使用this關鍵字，因為靜態方法不屬於類的例項，所以this也就沒有什麼東西去指向。構造器的this指向同一個類中，不同引數列表的另外一個構造器，我們看看下面的程式碼：
public class Platypus {
String name;
Platypus(String input) {
name = input;
}
Platypus() {
this("John/Mary Doe");
}
public static void main(String args[]) {
Platypus p1 = new Platypus("digger");
Platypus p2 = new Platypus();
}
}
在上面的程式碼中，有2個不同引數列表的構造器。第一個構造器，給類的成員name賦值，第二個構造器，呼叫第一個構造器，給成員變數name一個初始值 "John/Mary Doe".
在構造器中，如果要使用關鍵字this,那麼，必須放在第一行，如果不這樣，將導致一個編譯錯誤。
"super"的用法
構造器和方法，都用關鍵字super指向超類，但是用的方法不一樣。方法用這個關鍵字去執行被過載的超類中的方法。看下面的例子：
class Mammal {
void getBirthInfo() {
System.out.println("born alive.");
}
}
class Platypus extends Mammal {
void getBirthInfo() {
System.out.println("hatch from eggs");
System.out.print("a mammal normally is ");
super.getBirthInfo();
}
}
在上面的例子中，使用super.getBirthInfo()去呼叫超類Mammal中被過載的方法。
構造器使用super去呼叫超類中的構造器。而且這行程式碼必須放在第一行，否則編譯將出錯。看下面的例子：
public class SuperClassDemo {
SuperClassDemo() {}
}
class Child extends SuperClassDemo {
Child() {
super();
}
}
在上面這個沒有什麼實際意義的例子中，構造器 Child()包含了 super,它的作用就是將超類中的構造器SuperClassDemo例項化，並加到 Child類中。
編譯器自動加入程式碼
編譯器自動加入程式碼到構造器，對於這個，java程式設計師新手可能比較混淆。當我們寫一個沒有構造器的類，編譯的時候，編譯器會自動加上一個不帶引數的構造器，例如：public class Example {}
編譯後將如下程式碼：
public class Example {
Example() {}
}
在構造器的第一行，沒有使用super，那麼編譯器也會自動加上，例如：
public class TestConstructors {
TestConstructors() {}
}
編譯器會加上程式碼，如下：
public class TestConstructors {
TestConstructors() {
super;
}
}
仔細想一下，就知道下面的程式碼
public class Example {}
經過會被編譯器加程式碼形如：
public class Example {
Example() {
super;
}
}
繼承
構造器是不能被繼承的。子類可以繼承超類的任何方法。看看下面的程式碼：
public class Example {
public void sayHi {
system.out.println("Hi");
}
Example() {}
}
public class SubClass extends Example {
}
類 SubClass 自動繼承了父類中的sayHi方法，但是，父類中的構造器 Example()卻不能被繼承。
總結
主題
構造器
方法
功能
建立一個類的例項
java功能語句
修飾
不能用bstract, final, native, static,
or synchronized
能
返回型別
沒有返回值，沒有void
有返回值，或者void
命名
和類名相同；通常為名詞，大寫開頭
通常代表一個動詞的意思，小寫開頭
this
指向同一個類中另外一個構造器，在第一行
指向當前類的一個例項，不能用於靜態方法
super
呼叫父類的構造器，在第一行
呼叫父類中一個過載的方法
繼承
構造器不能被繼承
方法可以被繼承
編譯器自動加入一個預設的構造器
自動加入（如果沒有）
不支援
編譯器自動加入一個預設的呼叫到超類的構造器
自動加入（如果沒有）
不支援
構造方法，可以理解為在物件使用之前必須呼叫的方法，而該類當中的其他方法則沒這個必要
所以在建立物件的時候，不但要分配記憶體，還要呼叫構造方法
細微的差別
構造方法必須沒有返回值，其他方法必須有返回值
構造方法有預設構造方法，而其他方法沒有
java 類當中方法有返回值，並且習慣方法名開頭小寫！
構造方法沒有返回值，而其寫法特殊是
public/private + 類名 +（）+{}。是固定的
例如
class A{
private int id;
private String name;
public A(){}
public A(int id,String name){
this.id = id;
this.name = name;
}
}
第一個 public A(){}是預設的構造方法，第二是過載Full的構造方法。

java中呼叫方法,構造方法,例項方法有什麼區別

java中所謂的構造方法是指JAVA虛擬機器在LOAD這個類的時候，利用構造方法來建立這個類的一個例項所呼叫的方法，典型的就是構造方法的過載，比如：
public class student{
private int id;
private String name;
private int age;
以 *** 現出構造方法的過載
public void student() {}
public void student(int id ,String name) { this.id=id; this.name= name;}
public void student(int id ,String name,int age) {this.id=id; this.name=name; this.age=age;}
}
呼叫方法是指已經在類庫中寫好的方法我們直接去呼叫就可以了，如：System.out.println();
至於例項方法可以理解為類的中普通方法如：get(),set()之類的

JAVA中構造方法和普通方法有什麼區別

構造方法，只在建立物件的時候呼叫，用於初始化物件中的屬性。
物件建立後，構造方法就不能呼叫了。
普通的物件方法，只能在物件建立後，被物件呼叫，可以呼叫多次。

JAVA類中類方法和例項方法有什麼區別

就是 類的方法 跟 物件的方法 區別； 類裡面的靜態方法，類是可以直接呼叫； 類 其他方法，需要例項化才能呼叫，也就是只有物件才能呼叫

java 中的類方法和例項方法有什麼區別呀?????

你說的類方法是不是靜態方法呀,例項方法是不是指宣告物件後使用這個物件的方法呢. 首先你這兩個名詞說法我是真沒聽說過. 如果指靜態方法的話,是指不用宣告就可以使用的方法, 這些方法被定義在一個靜態類中,使用的直接寫 類名.方法(); 而你所說的例項方法應該是那些非靜態的方法,也就是說必須先宣告包含這個方法的類的例項,然後通過這個例項來使用這些方法. 這就是它們兩個的不同點. 希望我沒有理解錯.

例項方法和類方法有什麼區別啊？？？

例項方法是建立例項才有的方法
類方法是直接可以使用類引用，不需要例項化就可以使用的方法，一般在專案中類方法都是設定為工具類使用的

呼叫類方法與例項方法有什麼區別

類方法可以直接呼叫，例項方法必須new出一個物件後，用物件引用來呼叫