JAVA中局部變量和成員變量的區別

根據定義變量位置的不同，可以將變量分為成員變量和局部變量

漢臺網站建設公司創新互聯建站,漢臺網站設計制作，有大型網站制作公司豐富經驗。已為漢臺成百上千家提供企業網站建設服務。企業網站搭建\成都外貿網站建設公司要多少錢，請找那個售后服務好的漢臺做網站的公司定做！

成員變量是在類范圍內定義的變量

局部變量是在一個方法內定義的變量

成員變量可以分為：

實例屬性 （不用static修飾）：隨著實例屬性的存在而存在

類屬性 （static修飾）：隨著類的存在而存在

成員變量無需顯式初始化，系統會自動對其進行默認初始化

局部變量可分為：

形參（形式參數）： 在整個方法內有效

方法局部變量 （方法內定義）：從定義這個變量開始到方法結束這一段時間內有效

代碼塊局部變量 （代碼塊內定義）：從定義這個變量開始到代碼塊結束這一段時間內有效

局部變量除了形參外，都必須顯示初始化，也就是要指定一個初始值，否則不能訪問。

還有，在內存中的位置也不一樣。成員變量在所在類被實例化后，存在堆內存中；局部變量在所在方法調用時，存在棧內存空間中。

如何調用被局部變量屏蔽的成員變量

Java 中局部變量與成員變量同名時，局部變量會隱藏成員變量。如果我們想訪問成員變量，可以使用 this 關鍵字

調用時我們要知道下面幾點1.位置：在方法里，局部代碼塊中

2.使用范圍：在哪里定義就在哪里使用

3.當類對應的方法或局部代碼塊結束以后，對應的局部變量才會被釋放

4.局部變量必須是手動賦值否則不能施行

2.成員變量

1.在類里方法外

2.使用范圍：在整個類中起作用，類消失，成員變量才會被釋放。

3.成員變量無需手動賦值。會自動賦予對應類型的默認值String 類型的默認nullint類型的默認值0double類型的默認值是0.0布爾類型的默認值是falsech類型是/u0000

方法的修飾符方法名前提方法需要被調用，只有被調用的時候才能使用。怎么調用：方法名+方法的參數列表

Java中全局變量和局部變量的用法 兩者有哪些不同的地方 ？

給你個例子吧：

public class Test001 {

8. static int a = 27;//全局變量

9. static void test() {

10. boolean flag = false;// flag是局部變量，他的有效范圍市整個方法體

11. if (!flag) {

12. int a = 20;// 局部變量a，是必須進行初始化的且只在if塊中有效

13. System.out.println("a1=" + a);

14. }

15. // a = 10;// 注意，這一行是會報編譯錯誤：未聲明變量a

16. }

17. /**

18. * @param args

19. */

20. public static void main(String[] args) {

21. System.out.println("a2=" + a);

22. int a = 23;//局部變量a

23. test();

24. System.out.println("a3=" + a);

25. }

結果為：

a2=27

a1=20

a3=23

注意：

1，對于局部變量要先賦值后使用

2，局部變量局部有效，在定義這個變量的代碼塊也就是在“{}”中有效

3，在重合的有效范圍內，不允許兩個局部變量發生命名沖突。

在Java程序中需要更多的Int變量改如何定義

java中變量是有作用域，全局變量在整個類中都可調用，局部變量只在局部代碼塊中作用

package

test;

public

class

test

{

private

int

global;//全局變量

public

void

show(){

int

a;//局部變量

}

public

void

showTow(){

int

a;//局部變量

}

public

void

showThree(){

int

a;//局部變量

}

}

JAVA中局部內部類和匿名內部類的特點和作用是什么?

Java 內部類

分四種：成員內部類、局部內部類、靜態內部類和匿名內部類。

1、成員內部類： 即作為外部類的一個成員存在，與外部類的屬性、方法并列。

注意：成員內部類中不能定義靜態變量,但可以訪問外部類的所有成員。

public class Outer{

private static int i = 1;

private int j=10;

private int k=20;

public static void outer_f1(){

//do more something

}

public void out_f2(){

//do more something

}

//成員內部類

class Inner{

//static int inner_i =100; //內部類中不允許定義靜態變量

int j=100;//內部類中外部類的實例變量可以共存

int inner_i=1;

void inner_f1(){

System.out.println(i);//外部類的變量如果和內部類的變量沒有同名的，則可以直接用變量名訪問外部類的變量

System.out.println(j);//在內部類中訪問內部類自己的變量直接用變量名

System.out.println(this.j);//也可以在內部類中用"this.變量名"來訪問內部類變量

//訪問外部類中與內部類同名的實例變量可用"外部類名.this.變量名"。

System.out.println(k);//外部類的變量如果和內部類的變量沒有同名的，則可以直接用變量名訪問外部類的變量

outer_f1();

outer_f2();

}

}

//外部類的非靜態方法訪問成員內部類

public void outer_f3(){

Inner inner = new Inner();

inner.inner_f1();

}

//外部類的靜態方法訪問成員內部類，與在外部類外部訪問成員內部類一樣

public static void outer_f4(){

//step1 建立外部類對象

Outer out = new Outer();

//***step2 根據外部類對象建立內部類對象***

Inner inner=out.new Inner();

//step3 訪問內部類的方法

inner.inner_f1();

}

public static void main(String[] args){

outer_f4();

}

}

成員內部類的優點：

⑴ 內部類作為外部類的成員，可以訪問外部類的私有成員或屬性。（即使將外部類聲明為PRIVATE，但是對于處于其內部的內部類還是可見的。）

⑵ 用內部類定義在外部類中不可訪問的屬性。這樣就在外部類中實現了比外部類的private還要小的訪問權限。

注意：內部類是一個編譯時的概念，一旦編譯成功，就會成為完全不同的兩類。對于一個名為outer的外部類和其內部定義的名為inner的內部類。編譯完成后出現outer.class和outer$inner.class兩類。

2、局部內部類： 即在方法中定義的內部類，與局部變量類似，在局部內部類前不加修飾符public或private，其范圍為定義它的代碼塊。

注意：局部內部類中不可定義靜態變量，可以訪問外部類的局部變量(即方法內的變量)，但是變量必須是final的。

public class Outer {

private int s = 100;

private int out_i = 1;

public void f(final int k){

final int s = 200;

int i = 1;

final int j = 10;

class Inner{ //定義在方法內部

int s = 300;//可以定義與外部類同名的變量

//static int m = 20;//不可以定義靜態變量

Inner(int k){

inner_f(k);

}

int inner_i = 100;

void inner_f(int k){

System.out.println(out_i);//如果內部類沒有與外部類同名的變量，在內部類中可以直接訪問外部類的實例變量

System.out.println(k);//*****可以訪問外部類的局部變量(即方法內的變量)，但是變量必須是final的*****

// System.out.println(i);

System.out.println(s);//如果內部類中有與外部類同名的變量，直接用變量名訪問的是內部類的變量

System.out.println(this.s);//用"this.變量名" 訪問的也是內部類變量

System.out.println(Outer.this.s);//用外部"外部類類名.this.變量名" 訪問的是外部類變量

}

}

new Inner(k);

}

public static void main(String[] args) {

//訪問局部內部類必須先有外部類對象

Outer out = new Outer();

out.f(3);

}

}

注意：

在類外不可直接生成局部內部類（保證局部內部類對外是不可見的）。要想使用局部內部類時需要生成對象，對象調用方法，在方法中才能調用其局部內部類。通過內部類和接口達到一個強制的弱耦合，用局部內部類來實現接口，并在方法中返回接口類型，使局部內部類不可見，屏蔽實現類的可見性。

3、靜態內部類： 靜態內部類定義在類中，任何方法外，用static定義。

注意：靜態內部類中可以定義靜態或者非靜態的成員

public class Outer {

private static int i = 1;

private int j = 10;

public static void outer_f1(){

}

public void outer_f2(){

}

// 靜態內部類可以用public,protected,private修飾

// 靜態內部類中可以定義靜態或者非靜態的成員

static class Inner{

static int inner_i = 100;

int inner_j = 200;

static void inner_f1(){

System.out.println("Outer.i"+i);//靜態內部類只能訪問外部類的靜態成員

outer_f1();//包括靜態變量和靜態方法

}

void inner_f2(){

// System.out.println("Outer.i"+j);//靜態內部類不能訪問外部類的非靜態成員

// outer_f2();//包括非靜態變量和非靜態方法

}

}

public void outer_f3(){

// 外部類訪問內部類的靜態成員：內部類.靜態成員

System.out.println(Inner.inner_i);

Inner.inner_f1();

// 外部類訪問內部類的非靜態成員:實例化內部類即可

Inner inner = new Inner();

inner.inner_f2();

}

public static void main(String[] args) {

new Outer().outer_f3();

}

}

注意：*******生成（new）一個靜態內部類不需要外部類成員：這是靜態內部類和成員內部類的區別。靜態內部類的對象可以直接生成：

Outer.Inner in=new Outer.Inner()；

而不需要通過生成外部類對象來生成。這樣實際上使靜態內部類成為了一個頂級類。靜態內部類不可用private來進行定義。*******

例子：

對于兩個類，擁有相同的方法：

class People

{

run();

}

class Machine{

run();

}

此時有一個robot類：

class Robot extends People implement Machine.

此時run()不可直接實現。

注意：當類與接口（或者是接口與接口）發生方法命名沖突的時候，此時必須使用內部類來實現。用接口不能完全地實現多繼承，用接口配合內部類才能實現真正的多繼承。

4、匿名內部類

匿名內部類是一種特殊的局部內部類，它是通過匿名類實現接口。

IA被定義為接口。

IA I=new IA(){};

匿名內部類的特點：

1，一個類用于繼承其他類或是實現接口，并不需要增加額外的方法，只是對繼承方法的事先或是覆蓋。

2，只是為了獲得一個對象實例，不需要知道其實際類型。

3，類名沒有意義，也就是不需要使用到。

public class Outer {

private static int i = 1;

private int j = 10;

public static void outer_f1(){

}

public void outer_f2(){

}

// 靜態內部類可以用public,protected,private修飾

// 靜態內部類中可以定義靜態或者非靜態的成員

static class Inner{

static int inner_i = 100;

int inner_j = 200;

static void inner_f1(){

System.out.println("Outer.i"+i);//靜態內部類只能訪問外部類的靜態成員

outer_f1();//包括靜態變量和靜態方法

}

void inner_f2(){

// System.out.println("Outer.i"+j);//靜態內部類不能訪問外部類的非靜態成員

// outer_f2();//包括非靜態變量和非靜態方法

}

}

public void outer_f3(){

// 外部類訪問內部類的靜態成員：內部類.靜態成員

System.out.println(Inner.inner_i);

Inner.inner_f1();

// 外部類訪問內部類的非靜態成員:實例化內部類即可

Inner inner = new Inner();

inner.inner_f2();

}

public static void main(String[] args) {

new Outer().outer_f3();

}

}

注：一個匿名內部類一定是在new的后面，用其隱含實現一個接口或實現一個類，沒有類名，根據多態，我們使用其父類名。因他是局部內部類，那么局部內部類的所有限制都對其生效。匿名內部類是唯一一種無構造方法類。大部分匿名內部類是用于接口回調用的。匿名內部類在編譯的時候由系統自動起名Out$1.class。如果一個對象編譯時的類型是接口，那么其運行的類型為實現這個接口的類。因匿名內部類無構造方法，所以其使用范圍非常的有限。當需要多個對象時使用局部內部類，因此局部內部類的應用相對比較多。匿名內部類中不能定義構造方法。如果一個對象編譯時的類型是接口，那么其運行的類型為實現這個接口的類。

________________________________________________________________________________

內部類總結：

1.首先，把內部類作為外部類的一個特殊的成員來看待，因此它有類成員的封閉等級：private ,protected,默認(friendly),public

它有類成員的修飾符: static,final,abstract

2.非靜態內部類nested inner class,內部類隱含有一個外部類的指針this,因此，它可以訪問外部類的一切資源（當然包括private）

外部類訪問內部類的成員，先要取得內部類的對象,并且取決于內部類成員的封裝等級。

非靜態內部類不能包含任何static成員.

3.靜態內部類：static inner class,不再包含外部類的this指針，并且在外部類裝載時初始化.

靜態內部類能包含static或非static成員.

靜態內部類只能訪問外部類static成員.

外部類訪問靜態內部類的成員，循一般類法規。對于static成員，用類名.成員即可訪問，對于非static成員，只能

用對象.成員進行訪問

4.對于方法中的內部類或塊中內部類只能訪問塊中或方法中的final變量。

類成員有兩種static , non-static，同樣內部類也有這兩種

non-static 內部類的實例，必須在外部類的方法中創建或通過外部類的實例來創建(OuterClassInstanceName.new innerClassName(ConstructorParameter)),并且可直接訪問外部類的信息,外部類對象可通過OuterClassName.this來引用

static 內部類的實例, 直接創建即可，沒有對外部類實例的引用。

內部類不管static還是non-static都有對外部類的引用

non-static 內部類不允許有static成員

方法中的內部類只允許訪問方法中的final局部變量和方法的final參數列表，所以說方法中的內部類和內部類沒什麼區別。但方法中的內部類不能在方法以外訪問，方法中不可以有static內部類

匿名內部類如果繼承自接口,必須實現指定接口的方法,且無參數

匿名內部類如果繼承自類,參數必須按父類的構造函數的參數傳遞

java局部變量和全局變量的區別

只有方法變量、類變量，沒有全局變量

————————————————

新聞名稱：java局部代碼塊 java中的代碼塊
鏈接地址：http://www.yijiale78.com/article48/hgodep.html

成都網站建設公司_創新互聯，為您提供網站營銷、手機網站建設、品牌網站制作、網站改版、搜索引擎優化、網頁設計公司

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯