java方法不同

『壹』 java中普通方法、抽象方法、構造方法等都有什麼不同和作用呢

舉例說明吧，學生是一個大類（在程序中就是class），其中的一個學生是一個對象也叫一個實體（在程序中就是我們new的一個對象），介面實際上是一個類，實現介面的類相當於是一個調用關系，抽象類也是一個類，但和介面不同，實現抽象類的類是一個繼承的關系，繼承只能繼承一個，好比只有一個父親，但是介面可以接很多個，好比usb插口，普通方法就是我們平時寫的void
int
string
等等的函數方法，如果是寫在類裡面，那麼其他地方調用需要先實例化一個對象（new一個對象）然後再按.調用出來，靜態方法就是前面加了static的方法，是使用公共內存空間的，所有對象都可以直接引用而不需要實例化一個對象再使用該方法。靜態塊的就是在類載入的時候就執行，而且是一個類在第一次被使用的時候會被載入執行（這東西不常用）。

『貳』 java靜態方法和非靜態方法有什麼不同

靜態方法和實例方法的區別主要體現在兩個方面：

在外部調用靜態方法時，可以使用"類名.方法名"的方式，也可以使用"對象名.方法名"的方式。而實例方法只有後面這種方式。也就是說，調用靜態方法可以無需創建對象。

靜態方法在訪問本類的成員時，只允許訪問靜態成員（即靜態成員變數和靜態方法），而不允許訪問實例成員變數和實例方法；實例方法則無此限制。

下面幾個例子展示了這一區別。

1、調用靜態方法示例。

//-----------文件名hasStaticMethod.java，程序編號1-----------------public
class hasStaticMethod{//定義一個靜態方法public static void
callMe(){System.out.println("This is a static method.");}}

下面這個程序使用兩種形式來調用靜態方法。
//-----------文件名invokeStaticMethod.java，2-----------------

public class invokeStaticMethod{
public static void main(String args[]){
hasStaticMethod.callMe(); //不創建對象，直接調用靜態方法
hasStaticMethod oa = new hasStaticMethod(); //創建一個對象oa.callMe(); //利用對象來調用靜態方法}}

程序3.36兩次調用靜態方法，都是允許的，程序的輸出如下：
This is a static method.This is a static method.
允許不創建對象而調用靜態方法，是Java為了減少程序員調用某些常用方法時的麻煩，而允許程序員按照傳統的C語言中使用函數的方式來使用方法。典型的例子是前面某些程序中使用"Math.ramdon()"來獲取隨機數。
2、靜態方法訪問成員變數示例。
//-----------文件名accessMember.java，程序編號3.37-----------------class
accessMember{private static int sa; //定義一個靜態成員變數private int ia;
//定義一個實例成員變數//下面定義一個靜態方法static void statMethod(){int i = 0;
//正確，可以有自己的局部變數sa = 10; //正確，靜態方法可以使用靜態變數otherStat(); //正確，可以調用靜態方法ia =
20; //錯誤，不能使用實例變數insMethod(); //錯誤，不能調用實例方法}static void otherStat(){}
//下面定義一個實例方法 void insMethod(){int i = 0; //正確，可以有自己的局部變數sa = 15;
//正確，可以使用靜態變數ia = 30; //正確，可以使用實例變數statMethod(); //正確，可以調用靜態方法}}

本例其實可以概括成一句話：靜態方法只能訪問靜態成員，實例方法可以訪問靜態和實例成員。之所以不允許靜態方法訪問實例成員變數，是因為實例成員變數是屬於某個對象的，而靜態方法在執行時，並不一定存在對象。同樣，因為實例方法可以訪問實例成員變數，如果允許靜態方法調用實例方法，將間接地允許它使用實例成員變數，所以它也不能調用實例方法。基於同樣的道理，靜態方法中也不能使用關鍵字this。

main()方法是一個典型的靜態方法，它同樣遵循一般靜態方法的規則，所以它可以由系統在創建對象之前就調用。

『叄』 java實現線程的兩種方法有什麼區別

為什麼Java要提供兩種方法來創建線程呢？它們都有哪些區別？相比而言，哪一種方法更好呢？

在Java中，類僅支持單繼承，也就是說，當定義一個新的類的時候，它只能擴展一個外部類.這樣，如果創建自定義線程類的時候是通過擴展 Thread類的方法來實現的，那麼這個自定義類就不能再去擴展其他的類，也就無法實現更加復雜的功能。因此，如果自定義類必須擴展其他的類，那麼就可以使用實現Runnable介面的方法來定義該類為線程類，這樣就可以避免Java單繼承所帶來的局限性。

還有一點最重要的就是使用實現Runnable介面的方式創建的線程可以處理同一資源，從而實現資源的共享.

1、通過擴展Thread類來創建多線程

假設一個影院有三個售票口，分別用於向兒童、成人和老人售票。影院為每個窗口放有100張電影票，分別是兒童票、成人票和老人票。三個窗口需要同時賣票，而現在只有一個售票員，這個售票員就相當於一個CPU，三個窗口就相當於三個線程。通過程序來看一看是如何創建這三個線程的。

[html]view plain

結果正如前面分析的那樣，程序在內存中僅創建了一個資源，而新建的三個線程都是基於訪問這同一資源的，並且由於每個線程上所運行的是相同的代碼，因此它們執行的功能也是相同的。

可見，如果現實問題中要求必須創建多個線程來執行同一任務，而且這多個線程之間還將共享同一個資源，那麼就可以使用實現Runnable介面的方式來創建多線程程序。而這一功能通過擴展Thread類是無法實現的

『肆』 java 兩個線程執行不同的方法

首先你這說法似乎有點錯誤，不知道你是否把C#裡面的線程用法用到java上面了。
首先，java裡面的線程，只是執行一個方法，那個方法名為 public void run(){}
再次，在java裡面，使用線程是要繼承Thread類(重寫run方法)，或者是實現Runnable介面（實現run方法）
然後，建立一個線程，是
1、繼承線程Thread類： MyThread thread=new MyThread();
啟動：thread.start();這樣就啟動一個線程，但它只是執行run方法裡面的東西

2、實現Runnable介面的：MyRunnableThread thread=new MyRunnableThread()；
啟動： Thread runThread=new Thread(thread); runThread.start();(或者直接寫為：new Thread(thread).start() )

最後，在這里你應該可以看到了，這是一個類線程，不是一個方法線程。如果你要執行多個方法，就要多寫和創建啟動多個線程類

『伍』 java課程培訓機構分享Java構造器和方法的區別

構造函數（構造器）是一種特殊的函數。其主要功能是用來在創建對象時初始化對象，即為對象成員變數賦初始值，總與new運算符一起使用在創建對象的語句中。構造函數與類名相同，可重載多個不同的構造函數。在JAVA語言中，構造函數與C++語言中的構造函數相同,JAVA語言中普遍稱之為構造方法。java課程培訓機構http://www.kmbdqn.com/來為大家介紹一下。

構造方法的聲明：

修飾符class_name(類名)(參數列表){

邏輯代碼

}

構造器特性：

1.如果我們的類當中沒有定義任何構造器，系統會給我們默認提供一個無參的構造器。

2.如果我們的類當中定義了構造器，那麼系統就不會再給我們提供默認的無參構造器。

作用：構建創造一個對象。同時可以給我們的屬性做一個初始化操作。

下面主要學習構造器和方法的區別：

我們說構造器是一種方法，就象講澳大利亞的鴨嘴獸是一種哺育動物。（按：老外喜歡打比喻，我也就照著翻譯）。要理解鴨嘴獸，那麼先必須理解它和其他哺育動物的區別。同樣地，要理解構造器，那麼就要了解構造器和方法的區別。所有學習java的人，尤其是對那些要認證考試的，理解構造器是非常重要的。下面將簡單介紹一下，最後用一個表作了些簡單的總結。

1、功能和作用的不同

構造器是為了創建一個類的實例。用來創建一個對象，同時可以給屬性做初始化。這個過程也可以在創建一個對象的時候用到：Platypusp1=newPlatypus();

相反，方法的作用是僅僅是功能函數，為了執行java代碼。

2、修飾符，返回值和命名的不同

構造器和方法在下面三個方便的區別：修飾符，返回值，命名。

和方法一樣，構造器可以有任何訪問的修飾：public,protected,private或者沒有修飾（通常被package和friendly調用）.不同於方法的是，構造器不能有以下非訪問性質的修飾：abstract,final,native,static,或者synchronized。

3、返回類型

方法必須要有返回值，能返回任何類型的值或者無返回值（void），構造器沒有返回值，也不需要void。

4、命名

構造器使用和類相同的名字，而方法則不同。按照習慣，方法通常用小寫字母開始，而構造器通常用大寫字母開始。

構造器通常是一個名詞，因為它和類名相同；而方法通常更接近動詞，因為它說明一個操作。

5、調用：

構造方法：只有在對象創建的時候才會去調用，而且只會調用一次。

一般方法：在對象創建之後才可以調用，並且可以調用多次。

『陸』 Java的方法區和本地方法區有何不同什麼是Native Method

java的方法區在jdk7及以前是永久代，使用的是虛擬機的內存，而到了jdk8，元空間取代了永久代，使用的是本地的內存。
Native Method是本地方法的意思，非java編寫，比如c/c++，一般用於操作底層的硬體。在java中通過本地方法介面也就是帶native修飾符的方法來調用本地方法。

『柒』 Java語言中，構造方法和一般方法有何不同

構造方法和方法的區別：
構造方法要與類名相同，無返回類型，在類初始化的時候調用。
方法最好與類名不同，對象調用，靜態方法可用類名.方法（）.

構造器和方法在下面三個方面區別：修飾符，返回值，命名。

1。和方法一樣，構造器可以有任何訪問的修飾： public, protected, private或者沒有修飾（通常被package 和 friendly調用）. 不同於方法的是，構造器不能有以下非訪問性質的修飾： abstract, final, native, static, 或者 synchronized。
2。返回類型也是非常重要的。方法能返回任何類型的值或者無返回值（void），構造器沒有返回值，也不需要void。
3。兩者的命名。構造器使用和類相同的名字，而方法則不同。按照習慣，方法通常用小寫字母開始，而構造器通常用大寫字母開始。構造器通常是一個名詞，因為它和類名相同；而方法通常更接近動詞，因為它說明一個操作。

構造方法和方法中this和supper的用法區別：

"this"的用法
構造器和方法使用關鍵字this有很大的區別。方法引用this指向正在執行方法的類的實例。靜態方法不能使用this關鍵字，因為靜態方法不屬於類的實 例，所以this也就沒有什麼東西去指向。構造器的this指向同一個類中，不同參數列表的另外一個構造器，我們看看下面的代碼：

package com.dr.gouzao;

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();
System.out.println(p1.name + "----" + p2.name);
}
}
在上面的代碼中，有2個不同參數列表的構造器。第一個構造器，給類的成員name賦值，第二個構造器，調用第一個構造器，給成員變數name一個初始值 "John/Mary Doe".

在構造器中，如果要使用關鍵字this,那麼，必須放在第一行，如果不這樣，將導致一個編譯錯誤。
在一個構造方法中只能調用一次其它的構造方法，並且調用構造方法的語句必須是第一條語句。

"super"的用法

構造器和方法，都用關鍵字super指向超類，但是用的方法不一樣。方法用這個關鍵字去執行被重載的超類中的方法。看下面的例子：

package com.dr.gouzao;

class Mammal {
void getBirthInfo() {
System.out.println("born alive.");
}
}

class Platypus1 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類中。

編譯器自動加入代碼 ，當我們寫一個沒有構造器的類，編譯的時候，編譯器會自動加上一個不帶參數的構造器。

現在具體介紹一下構造方法的幾種用法：
類的繼承機制使得子類可以使用父類的功能（即代碼），並且子類也具有父類的類型。下面介紹類在繼承關繫上的初始化的順序問題。
示例1：

class SuperClass
{
SuperClass()
{
System.out.println("SuperClass constructor");
}
}
public class SubClass extends SuperClass
{
SubClass()
{
System.out.println("SubClass constructor");
}
public static void main(String[] args)
{
SubClass sub = new SubClass();
}
}

輸出結果： SuperClass constructor
SubClass constructor
在子類中只實例化了一個子類對象。從輸出結果上看，程序並不是一開始就運行自己的構造方法，而是先運行其父類的默認構造方法。注意：程序自動調用其父類的默認構造方法。
實例2

class SuperClass
{
SuperClass(String str)
{
System.out.println("Super with a string.");
}
}
public class SubClass extends SuperClass
{
SubClass(String str)
{
System.out.println("Sub with a string.");
}
public static void main(String[] args)
{
SubClass sub = new SubClass("sub");
}
}

在JDK下編譯此程序不能成功。正如上例中說的：程序在初始化子類時先要尋找其父類的默認構造方法，結果沒找到，那麼編譯自然不能通過。

解決這個問題有兩個辦法：

1．在父類中增加一個默認構造方法。
2．在子類的構造方法中增加一條語句：super(str); 且必須在第一句。

這兩種方法都能使此程序通過編譯，但就本程序來說運行結果卻不相同。

第1種方法的運行結果是：

Sub with a string.

第2種方法的運行結果是：

Super with a string.
Sub with a string.

第2種解決方法實際上是指定編譯器不要尋找父類的默認構造方法，而是去尋找帶一個字元串為參數的構造方法。

下面介紹對象的初始化順序問題。

示例3：

class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
One one_1 = new One("one-1");
One one_2 = new One("one-2");
One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
}
public class Test
{
public static void main(String[] args)
{
System.out.println("Test main() start");
Two two = new Two("two");
}
}

輸出結果：
Test main() start...
one-1
one-2
one-3
two
在main()方法中實例化了一個Two類的對象。但程序在初始化Two類的對象時，並非先調用Two類的構造方法，而是先初始化Two類的成員變數。這里Two類有3個成員變數，它們都是One類的對象，所以要先調用3次One類的相應的構造方法。最後在初始化Two類的對象。
即在創建對象時，對象所在類的所有數據成員會首先進行初始化，如果其中的成員變數有對象，那麼它們也會按照順序執行初始化工作。在所有類成員初始化完成後，才調用對象所在類的構造方法創建對象。構造方法作用就是初始化。

示例4：

class One

{
One(String str)
{
System.out.println(str);
}
}
class Two
{
One one_1 = new One("one-1");
One one_2 = new One("one-2");
static One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
}
public class Test
{
public static void main(String[] args)
{
System.out.println("Test main() start");
Two two_1 = new Two("two-1");
System.out.println("------------");
Two two_2 = new Two("two-2");
}
}

輸出結果：
Test main() start...
one-3
one-1
one-2
two-1
------------
one-1
one-2
two-2
如果一個類中有靜態對象，那麼它會在非靜態對象前初始化，但只初始化一次。非靜態對象每次調用時都要初始化。
實例5

class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
One one_1 = new One("one-1");
One one_2 = new One("one-2");
static One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
3
}
public class Test
{
static Two two_3 = new Two("two-3");
public static void main(String[] args)
{
System.out.println("Test main() start");
Two two_1 = new Two("two-1");
System.out.println("------------");
Two two_2 = new Two("two-2");
}
}

輸出結果：
one-3
one-1
one-2
two-3
Test main() start...
one-1
one-2
two-1
------------
one-1
one-2
two-2
程序中主類的靜態變數會在main()方法執行前初始化。結果中只輸出了一次one-3，這也說明：如果一個類中有靜態對象，那麼它會在非靜態對象前初始化，但只初始化一次。非靜態對象每次調用時都要初始化。

實例6

class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
static int i = 0;
One one_1 = new One("one-1");
static One one_2 = new One("one-2");
static One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
}
public class Test
{
public static void main(String[] args)
{
System.out.println("Test main() start");
System.out.println("Two.i = " Two.i);
}
}

輸出結果：
Test main() start...
one-2
one-3
Two.i = 0
不僅第1次創建對象時，類中所有的靜態變數要初始化，第1次訪問類中的靜態變數（沒有創建對象）時，該類中所有的靜態變數也要按照它們在類中排列的順序初始化。

初始化的順序包括構造方法調用的順序如下：

1．主類的靜態成員首先初始化。
2．主類的超類的構造方法按照從最高到最低的順序被調用。
3．主類的非靜態對象（變數）初始化。
4．調用主類的構造方法。

夠詳細了，記得結貼。

『捌』 Java里不同方法里的局部變數的名稱可以相同么！

java里不同方法里的局部變數的名稱是可以相同的，因為不在一個作用域裡面，如下代碼：

packagecom.qiu.lin.he;


publicclassCeShi{
	publicstaticvoidmain(String[]args){
		CeShice=newCeShi();
		ce.ceshi();//調用第一個方法，輸出他的局部變數i
		ce.ceshi2();//調用第二個方法，輸出他的局部變數i

	}

	publicvoidceshi(){
		inti=1;
		System.out.println("我的局部變數是i");
	}

	publicvoidceshi2(){
		inti=1;
		System.out.println("我的局部變數也是i");
	}
}

輸出結果為：

『玖』 java 同名的不同方法共存的情況稱為什麼如何區分這些同名方法。

一般來說，分為兩種情況。
一是在同一個類裡面有兩個或兩個以上的同名的方法，這些方法的名字相同，但參數不同，這種情況中叫重載。當你調用方法時，會根據你傳進去的參數的類型來決定調用哪個方法。
二是一個類繼承了另外一個類，子類中有和父類中一樣的方法，這兩個方法不僅名字相同，參數也相同，這種情況叫方法覆蓋。也就是在子類中重新定義父類中已有的方法。當你創建一個子類的實例後調用這個方法，就會按照你在子類中新定義的方法來實現。