javafinal與static

⑴ java中的關鍵字static和final的作用是什麼

java中static方法自動的就是final的嗎？是不對的，他們兩個是不同的定義，你可以再網上找一些資料對比下，下面簡單說下static與final的作用：
static作用
是靜態修飾符，什麼叫靜態修飾符呢？大家都知道，在程序中任何變數或者代碼都是在編譯時由系統自動分配內存來存儲的，而所謂靜態就是指在編譯後所分配的內存會一直存在，直到程序退出內存才會釋放這個空間，也就是只要程序在運行，那麼這塊內存就會一直存在

final作用
final關鍵字是最終的、最後的意思，在程序中可以用來修飾類、成員變數和方法的聲明，由該關鍵字修飾的內容都是不可變的。

⑵ Java中static和final的區別

static是靜態修飾關鍵字，可以修飾變數和程序塊以及類方法：
當定義一個static的變數的時候jvm會將將其分配在內存堆上，所有程序對它的引用都會指向這一個地址而不會重新分配內存；
當修飾一個程序塊的時候(也就是直接將代碼寫在static{...}中)時候，虛擬機就會優先載入靜態塊中代碼，這主要用於系統初始化；
當修飾一個類方法時候你就可以直接通過類來調用而不需要新建對象。
final可以修飾變數、方法及類：
當定義一個final變數時，jvm會將其分配到常量池中，程序不可改變其值；
當修飾一個方法時，該方法在子類中將不能被重寫；
當修飾一個類時，該類不能被繼承。

⑶ Java中的關鍵字static和final的作用

final

根據程序上下文環境，Java關鍵字final有「這是無法改變的」或者「終態的」含義，它可以修飾非抽象類、非抽象類成員方法和變數。你可能出於兩種理解而需要阻止改變：設計或效率。

final類不能被繼承，沒有子類，final類中的方法默認是final的。

final方法不能被子類的方法覆蓋，但可以被繼承。

final成員變數表示常量，只能被賦值一次，賦值後值不再改變。

final不能用於修飾構造方法。

注意：父類的private成員方法是不能被子類方法覆蓋的，因此private類型的方法默認是final類型的。

1、final類

final類不能被繼承，因此final類的成員方法沒有機會被覆蓋

，默認都是final的。在設計類時候，如果這個類不需要有子類，類的實現細節不允許改變，並且確信這個類不會載被擴展，那麼就設計為final類。

2、final方法

如果一個類不允許其子類覆蓋某個方法，則可以把這個方法聲明為final方法。

使用final方法的原因有二：

第一、把方法鎖定，防止任何繼承類修改它的意義和實現。

第二、高效。編譯器在遇到調用final方法時候會轉入內嵌機制，大大提高執行效率。

例如：

publicclassTest1{
publicstaticvoidmain(String[]args){
//TODO自動生成方法存根
}
publicvoidf1(){
System.out.println("f1");
}
//無法被子類覆蓋的方法
publicfinalvoidf2(){
System.out.println("f2");
}
publicvoidf3(){
System.out.println("f3");
}
privatevoidf4(){
System.out.println("f4");
}
}
publicclassTest2extendsTest1{

publicvoidf1(){
System.out.println("Test1父類方法f1被覆蓋!");
}
publicstaticvoidmain(String[]args){
Test2t=newTest2();
t.f1();
t.f2();//調用從父類繼承過來的final方法
t.f3();//調用從父類繼承過來的方法
//t.f4();//調用失敗，無法從父類繼承獲得
}
}

3、final變數（常量）

用final修飾的成員變數表示常量，值一旦給定就無法改變！

final修飾的變數有三種：靜態變數、實例變數和局部變數，分別表示三種類型的常量。

從下面的例子中可以看出，一旦給final變數初值後，值就不能再改變了。

另外，final變數定義的時候，可以先聲明，而不給初值，這中變數也稱為final空白，無論什麼情況，編譯器都確保空白final在使用之前必須被初始化。但是，final空白在final關鍵字final的使用上提供了更大的靈活性，為此，一個類中的final數據成員就可以實現依對象而有所不同，卻有保持其恆定不變的特徵。

packageorg.leimin;
publicclassTest3{
privatefinalStringS="final實例變數S";
privatefinalintA=100;
publicfinalintB=90;
publicstaticfinalintC=80;
privatestaticfinalintD=70;
publicfinalintE;//final空白,必須在初始化對象的時候賦初值
publicTest3(intx){
E=x;
}
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
Test3t=newTest3(2);
//t.A=101;//出錯,final變數的值一旦給定就無法改變
//t.B=91;//出錯,final變數的值一旦給定就無法改變
//t.C=81;//出錯,final變數的值一旦給定就無法改變
//t.D=71;//出錯,final變數的值一旦給定就無法改變
System.out.println(t.A);
System.out.println(t.B);
System.out.println(t.C);//不推薦用對象方式訪問靜態欄位
System.out.println(t.D);//不推薦用對象方式訪問靜態欄位
System.out.println(Test3.C);
System.out.println(Test3.D);
//System.out.println(Test3.E);//出錯,因為E為final空白,依據不同對象值有所不同.
System.out.println(t.E);
Test3t1=newTest3(3);
System.out.println(t1.E);//final空白變數E依據對象的不同而不同
}
privatevoidtest(){
System.out.println(newTest3(1).A);
System.out.println(Test3.C);
System.out.println(Test3.D);
}
publicvoidtest2(){
finalinta;//final空白,在需要的時候才賦值
finalintb=4;//局部常量--final用於局部變數的情形
finalintc;//final空白,一直沒有給賦值.
a=3;
//a=4;出錯,已經給賦過值了.
//b=2;出錯,已經給賦過值了.
}
}

4、final參數
當函數參數為final類型時，你可以讀取使用該參數，但是無法改變該參數的值。

publicclassTest4{
publicstaticvoidmain(String[]args){
newTest4().f1(2);
}
publicvoidf1(finalinti){
//i++;//i是final類型的,值不允許改變的.
System.out.print(i);
}
}

二、static

static表示「全局」或者「靜態」的意思，用來修飾成員變數和成員方法，也可以形成靜態static代碼塊，但是Java語言中沒有全局變數的概念。

被static修飾的成員變數和成員方法獨立於該類的任何對象。也就是說，它不依賴類特定的實例，被類的所有實例共享。只要這個類被載入，Java虛擬機就能根據類名在運行時數據區的方法區內定找到他們。因此，static對象可以在它的任何對象創建之前訪問，無需引用任何對象。

用public修飾的static成員變數和成員方法本質是全局變數和全局方法，當聲明它類的對象市，不生成static變數的副本，而是類的所有實例共享同一個static變數。

static變數前可以有private修飾，表示這個變數可以在類的靜態代碼塊中，或者類的其他靜態成員方法中使用（當然也可以在非靜態成員方法中使用--廢話），但是不能在其他類中通過類名來直接引用，這一點很重要。實際上你需要搞明白，private是訪問許可權限定，static表示不要實例化就可以使用，這樣就容易理解多了。static前面加上其它訪問許可權關鍵字的效果也以此類推。

static修飾的成員變數和成員方法習慣上稱為靜態變數和靜態方法，可以直接通過類名來訪問，訪問語法為：

類名.靜態方法名(參數列表...)

類名.靜態變數名

用static修飾的代碼塊表示靜態代碼塊，當Java虛擬機（JVM）載入類時，就會執行該代碼塊（用處非常大，呵呵）。

1、static變數

按照是否靜態的對類成員變數進行分類可分兩種：一種是被static修飾的變數，叫靜態變數或類變數；另一種是沒有被static修飾的變數，叫實例變數。兩者的區別是：

對於靜態變數在內存中只有一個拷貝（節省內存），JVM只為靜態分配一次內存，在載入類的過程中完成靜態變數的內存分配，可用類名直接訪問（方便），當然也可以通過對象來訪問（但是這是不推薦的）。

對於實例變數，沒創建一個實例，就會為實例變數分配一次內存，實例變數可以在內存中有多個拷貝，互不影響（靈活）。

2、靜態方法

靜態方法可以直接通過類名調用，任何的實例也都可以調用，因此靜態方法中不能用this和super關鍵字，不能直接訪問所屬類的實例變數和實例方法(就是不帶static的成員變數和成員成員方法)，只能訪問所屬類的靜態成員變數和成員方法。因為實例成員與特定的對象關聯！這個需要去理解，想明白其中的道理，不是記憶！！！

因為static方法獨立於任何實例，因此static方法必須被實現，而不能是抽象的abstract。

3、static代碼塊

static代碼塊也叫靜態代碼塊，是在類中獨立於類成員的static語句塊，可以有多個，位置可以隨便放，它不在任何的方法體內，JVM載入類時會執行這些靜態的代碼塊，如果static代碼塊有多個，JVM將按照它們在類中出現的先後順序依次執行它們，每個代碼塊只會被執行一次。例如：

publicclassTest5{
privatestaticinta;
privateintb;
static{
Test5.a=3;
System.out.println(a);
Test5t=newTest5();
t.f();
t.b=1000;
System.out.println(t.b);
}
static{
Test5.a=4;
System.out.println(a);
}
publicstaticvoidmain(String[]args){
//TODO自動生成方法存根
}
static{
Test5.a=5;
System.out.println(a);
}
publicvoidf(){
System.out.println("hhahhahah");
}
}

運行結果：
3
hhahhahah
1000
4
5

利用靜態代碼塊可以對一些static變數進行賦值，最後再看一眼這些例子，都一個static的main方法，這樣JVM在運行main方法的時候可以直接調用而不用創建實例。

4、static和final一塊用表示什麼

static final用來修飾成員變數和成員方法，可簡單理解為「全局常量」！

對於變數，表示一旦給值就不可修改，並且通過類名可以訪問。

對於方法，表示不可覆蓋，並且可以通過類名直接訪問。

特別要注意一個問題：

對於被static和final修飾過的實例常量，實例本身不能再改變了，但對於一些容器類型（比如，ArrayList、HashMap）的實例變數，不可以改變容器變數本身，但可以修改容器中存放的對象，這一點在編程中用到很多。

也許說了這么多，反倒把你搞暈了，還是看個例子吧：

publicclassTestStaticFinal{
="aaa";
=null;
privatefinalStringstrFinalVar=null;
=0;
=newInteger(8);
privatestaticfinalArrayList<String>alStaticFinalVar=newArrayList<String>();
privatevoidtest(){
System.out.println("-------------值處理前----------
");
System.out.println("strStaticFinalVar="+strStaticFinalVar+"
");
System.out.println("strStaticVar="+strStaticVar+"
");
System.out.println("strFinalVar="+strFinalVar+"
");
System.out.println("intStaticFinalVar="+intStaticFinalVar+"
");
System.out.println("integerStaticFinalVar="+integerStaticFinalVar+"
");
System.out.println("alStaticFinalVar="+alStaticFinalVar+"
");
//strStaticFinalVar="哈哈哈哈";//錯誤，final表示終態,不可以改變變數本身.
strStaticVar="哈哈哈哈";//正確，static表示類變數,值可以改變.
//strFinalVar="呵呵呵呵";//錯誤,final表示終態，在定義的時候就要初值（哪怕給個null），一旦給定後就不可再更改。
//intStaticFinalVar=2;//錯誤,final表示終態，在定義的時候就要初值（哪怕給個null），一旦給定後就不可再更改。
//integerStaticFinalVar=newInteger(8);//錯誤,final表示終態，在定義的時候就要初值（哪怕給個null），一旦給定後就不可再更改。
alStaticFinalVar.add("aaa");//正確，容器變數本身沒有變化，但存放內容發生了變化。這個規則是非常常用的，有很多用途。
alStaticFinalVar.add("bbb");//正確，容器變數本身沒有變化，但存放內容發生了變化。這個規則是非常常用的，有很多用途。
System.out.println("-------------值處理後----------
");
System.out.println("strStaticFinalVar="+strStaticFinalVar+"
");
System.out.println("strStaticVar="+strStaticVar+"
");
System.out.println("strFinalVar="+strFinalVar+"
");
System.out.println("intStaticFinalVar="+intStaticFinalVar+"
");
System.out.println("integerStaticFinalVar="+integerStaticFinalVar+"
");
System.out.println("alStaticFinalVar="+alStaticFinalVar+"
");
}
publicstaticvoidmain(Stringargs[]){
newTestStaticFinal().test();
}
}

看了上面這個例子，就清楚很多了，但必須明白：通過static final修飾的容器類型變數中所「裝」的對象是可改變的。這是和一般基本類型和類類型變數差別很大的地方。

⑷ Java中static 和final的區別

static 表示的是靜態方法
final 表示最終的
final常用在常量上, 讓這個值固定, 不修改的 上面.
static常用在
1、只想用一個存儲區域來保存一個特定的數據
2、我們需要一個特殊的方法，它沒有與這個類的任何對象關聯。可以直接調用的

⑸ java語言中 final和static 的 區別是什麼

final 被修飾的變數為常量一旦賦值不能修改,被修改的方法為最終方法不能

被重寫，被修飾的類是最終類，不能被繼承

static 被修飾的變數和方法，為該整個類及其類的對象所共享，一個類或對

象修改了被定義的類或方法，其他的也會跟著變數。。這就是說被static修飾的

是大家共用的。。

就一塊肥皂多個人用，每個人用都會少而不是像不用static修飾的是每個人有

每個人的肥皂，你用自己的和別人沒有關系。。

祝你好運！

如果還是不很明白，到我空間轉轉也許會更明白。。。

⑹ final和static的區別 java

當修飾一個類方法時候你就可以直接通過類來調用而不需要新建對象。
final可以修飾變數、方法及類：
當定義一個final變數時，jvm會將其分配到常量池中，程序不可改變其值；
當修飾一個方法時，該方法在子類中將不能被重寫；
當修飾一個類時，該類不能被繼承。

⑺ Java中 final和static修飾的變數有什麼區別

final定義的變數可以看做一個常量，不能被改變；
final定義的方法不能被覆蓋；
final定義的類不能被繼承。
final static 就是再加上static的特性就可以了

static 和final是沒有直接關系的

static 是在內存中分配一塊區域，供整個類通用，所有的類的對象都享有共同的值static 和final的區別 。

一、static ：

1、只想用一個存儲區域來保存一個特定的數據——無論要創建多少個對象，甚至根本不創 建對象。

2、需要一個特殊的方法，沒有與這個類的任何對象關聯。也就是說，即使沒有創建對象，也需要一個能調用的方法。
為滿足這兩方面的要求，可使用static（靜態）關鍵字。
下面先舉個例子：

一旦將什麼東西設為static，數據或方法就不會同那個類的任何對象實例聯繫到一起。所以盡管從未創建那個類的一個對象，仍能調用一個static方法，或訪問一些static數據。
為了將數據成員或方法設為static，只需在定義前置和這個關鍵字即可。
例如，下述代碼能生成一個static數據成員，並對其初始化：

class StaticTest {
Static int i = 47;
}

現在，盡管製作了兩個StaticTest對象，但仍然只佔據StaticTest.i的一個存儲空間。這兩個對象都共享同樣的i。請考察下述代碼：
StaticTest st1 = new StaticTest();
StaticTest st2 = new StaticTest();
此時，無論st1.i還是st2.i都有同樣的值47，因為引用的是同樣的內存區域。
有兩個辦法可引用一個static變數。正如上面展示的那樣，可通過一個對象命名，如st2.i。亦可直接用類名引用，而這在非靜態成員里是行不通的（最好用這個辦法引用static變數，因為強調了那個變數的「靜態」本質）。
StaticTest.i++;
其中，++運算符會使變數增值。此時，無論st1.i還是st2.i的值都是48。

類似的邏輯也適用於靜態方法。既可象對其他任何方法那樣通過一個對象引用靜態方法，亦可用特殊的語法格式「類名.方法()」加以引用。靜態方法的定義是類似的：
class StaticFun {
static void incr() { StaticTest.i++; }
}
從中可看出，StaticFun的方法incr()使靜態數據i增值。可用典型的方法調用incr()：

StaticFun sf = new StaticFun();
sf.incr();

或者，由於incr()是一種靜態方法，所以可通過類直接調用：
StaticFun.incr();
對方法來說，static一項重要的用途就是幫助我們在不必創建對象的前提下調用那個方法。

舉簡單一例如下：
public class TestStatic {
public static void main(String args[]){
PhoneCard mycard_1 = new PhoneCard();//創建第一張卡對象
PhoneCard mycard_2 = new PhoneCard();//創建第二張卡對象

mycard_1.addFee = 0.8;//給第一張卡的附加費addFee賦值為0.8
//注意到我們沒有給第二張卡賦值

System.out.println("第一張卡的附加費：" + mycard_1.addFee);
System.out.println("第二張卡的附加費：" + mycard_2.addFee);
//發現沒有？輸出結果中第二張卡的附加費也是0.8 了。
System.out.println("卡的附加費：" + PhoneCard.addFee);
//該句的列印輸出表明卡類的附加費都是0.8
}
}

class PhoneCard{
static double addFee;//靜態域addFee
}

該例創建了兩個類，PhoneCard類只定義了一個變數，TestStatic類里創建了兩個PhoneCard類對象，並給其中的一個對象的附加費addFee賦值，而另一個對象沒賦值。

由上例可以看出，靜態域保存在類的公共存儲單元，而不是保存在對象的存儲單元內。

static 修飾方法時是同理。

二、final:

final可修飾類、域（變數和常量）、方法 （而static不修飾類)

1、final修飾類，表示該類不可被繼承。
如定義了一個final類：
final class SnowBird{
int i;
String s;
static void fly(){
System.out.println("snowbird is flying");
}
}

//現在定義一個類，試圖繼承SnowBird類:

public class Bird extends SnowBird{
public static void main(String[] args){
SnowBird.fly();
}
}

把上面的兩個類拷貝到文件中，文件名保存為Bird.java

出錯信息是：cannot inherit from final SnowBird
表明final 類不可被繼承。

2、final修飾變數
程序中經常需要定義各種類型的常量，如：3.24268,"201"等等。這時候就用final來修飾一個類似於標志符名字。如：final String connectNumber = "201";

final表明 connectNumber是一個常量，取值在整個過程都不會改變。

如果把final 去掉則connectNumber就成為變數了。

有時為了節省空間，常量通常聲明為 static .因為如上所說的 static 用的是類的內存空間。

3、修飾方法：
final修飾的方法，稱為最終方法。最終方法不可被子類重新定義，即不可被覆蓋。
如父類定義了public void fly(){ ....}
則子類就不能定義
public void fly(){。。。。。。}
但注意覆蓋與重載的區別。不能被覆蓋並不是不能被重載，如你還可以定義
public void fly(int i){.....}，

舉個例子如下：

class FinalValue {
static final int i = 1;
final void fly(){
System.out.println("SnowBird is flying over FinalValue ");
}
}

class TestFinal extends FinalValue {
int i = 2;
void fly(){
System.out.println("SnowBird is flying over TestFinal");
System.out.println("In class FinalValue static Final i = "+ FinalValue.i);
System.out.println("In class TestFinal i = "+ i);
}
void fly(String s){
System.out.println("fly("+ s + ")");
}
}

public class Test {
public static void main(String args[]){
TestFinal tf = new TestFinal();
tf.fly();
tf.fly("ok");
System.out.println(tf.i);
}
}
把上面的程序保存為Test.java編譯看看，出現什麼錯誤？
然後，把TestFinal類中的 void fly(){ ... } 註解掉
即 如下
/* void fly(){
System.out.println("SnowBird is flying over TestFinal");
System.out.println("In class FinalValue static Final i = "+ FinalValue.i);
System.out.println("In class TestFinal i = "+ i);
}*/

⑻ Java中static final與final的不同。

1、final可以修飾：屬性，方法，類，局部變數（方法中的變數）

2、final修飾的屬性的初始化可以在編譯期，也可以在運行期，初始化後不能被改變。

3、final修飾的屬性跟具體對象有關，在運行期初始化的final屬性，不同對象可以有不同的值。

4、final修飾的屬性表明是一個常數（創建後不能被修改）。

5、final修飾的方法表示該方法在子類中不能被重寫，final修飾的類表示該類不能被繼承。

6、對於基本類型數據，final會將值變為一個常數（創建後不能被修改）；但是對於對象句柄（亦可稱作引用或者指針），final會將句柄變為一個常數（進行聲明時，必須將句柄初始化到一個具體的對象。而且不能再將句柄指向另一個對象。

7、但是，對象的本身是可以修改的。這一限制也適用於數組，數組也屬於對象，數組本身也是可以修改的。方法參數中的final句柄，意味著在該方法內部，我們不能改變參數句柄指向的實際東西，也就是說在方法內部不能給形參句柄再另外賦值）。

⑼ java語言中 final和static 的 區別是什麼

final
被修飾的變數為常量一旦賦值不能修改,被修改的方法為最終方法不能
被重寫，被修飾的類是最終類，不能被繼承
static
被修飾的變數和方法，為該整個類及其類的對象所共享，一個類或對
象修改了被定義的類或方法，其他的也會跟著變數。。這就是說被static修飾的
是大家共用的。。
就一塊肥皂多個人用，每個人用都會少而不是像不用static修飾的是每個人有
每個人的肥皂，你用自己的和別人沒有關系。。
祝你好運!
如果還是不很明白，到我空間轉轉也許會更明白。。。

⑽ java 中的static和final怎麼使用它們的區別

static是靜態修飾關鍵字，可以修飾變數和程序塊以及類方法：當你定義一個static的變數的時候jvm會將將其分配在內存堆上，所有程序對它的引用都會指向這一個地址而不會重新分配內存；修飾一個程序塊的時候(也就是直接將代碼寫在static{...}中)時候，虛擬機就會優先載入靜態塊中代碼，這主要用於系統初始化；當修飾一個類方法時候你就可以直接通過類來調用而不需要新建對象。
final可以修飾變數、方法及類，當你定義一個final變數時，jvm會將其分配到常量池中，程序不可改變其值；當你定義一個方法時，改方法在子類中將不能被重寫；當你修飾一個類時，該類不能被繼承。