javastatic方法可以覆蓋嗎?,javastatic方法可以覆蓋嗎?

本文目錄一覽：

• 1、java中的static到底有什麼作用?
• 2、Java中static的作用?
• 3、java中static的用法
• 4、java static是什麼意思？
• 5、java中的static如何使用?
• 6、java中static是什麼意思？能不能通俗的講下，讓我這個菜鳥好理解一點

java中的static到底有什麼作用?

static表示「全局」或者「靜態」的意思，用來修飾成員變量和成員方法，也可以形成靜態static代碼塊，但是Java語言中沒有全局變量的概念。被static修飾的成員變量和成員方法獨立於該類的任何對象。也就是說，它不依賴類特定的實例，被類的所有實例共享。static變量前可以有private修飾，表示這個變量可以在類的靜態代碼塊中，或者類的其他靜態成員方法中使用（當然也可以在非靜態成員方法中使用–廢話），但是不能在其他類中通過類名來直接引用，這一點很重要。實際上你需要搞明白，private是訪問權限限定，static表示不要實例化就可以使用，這樣就容易理解多了。static前面加上其它訪問權限關鍵字的效果也以此類推。

Java中static的作用?

1.static 成員變量

在類中一個成員變量可用 static 關鍵字來修飾，這樣的成員變量稱為 static 成員變量，或靜態成員變量。而沒有用 static 關鍵字修飾的成員變量稱為非靜態成員變量。

靜態成員變量是屬於類的，也就是說，該成員變量並不屬於某個對象，即使有多個該類的對象實例，靜態成員變量也只有一個。只要靜態成員變量所在的類被加載，這個靜態成員變量就會被分配內存空間。因此在引用該靜態成員變量時，通常不需要生成該類的對象，而是通過類名直接引用。引用的方法是「類名 . 靜態變量名」。當然仍然可以通過「對象名 . 靜態變量名」的方式引用該靜態成員變量。相對應的非靜態成員變量則屬於對象而非類，只有在內存中構建該類對象時，非靜態成員變量才被分配內存空間。

2.static 成員方法

Java 中也支持用 static 關鍵字修飾的成員方法，即靜態成員方法。與此相對應的沒有用 static 修飾的成員方法稱為非靜態成員方法。

與靜態成員變量類似，靜態成員方法是類方法，它屬於類本身而不屬於某個對象。因此靜態成員方法不需要創建對象就可以被調用，而非靜態成員方法則需要通過對象來調用。

特別需要注意的是，在靜態成員方法中不能使用 this、super 關鍵字，也不能調用非靜態成員方法，同時不能引用非靜態成員變量。這個道理是顯而易見的，因為靜態成員方法屬於類而不屬於某個對象，而 this、super 都是對象的引用，非靜態成員方法和成員變量也都屬於對象。所以當某個靜態成員方法被調用時，該類的對象可能還沒有被創建，那麼在靜態成員方法中調用對象屬性的方法或成員變量顯然是不合適的。即使該類的對象已經被創建，也是無法確定它究竟是調用哪個對象的方法，或是哪個對象中的成員變量的。所以在這裡特彆強調這一點。

3.static 代碼塊

static 代碼塊又稱為靜態代碼塊，或靜態初始化器。它是在類中獨立於成員函數的代碼塊。static 代碼塊不需要程序主動調用，在JVM加載類時系統會執行 static 代碼塊，因此在static 代碼塊中可以做一些類成員變量的初始化工作。如果一個類中有多個 static 代碼塊，JVM將會按順序依次執行。需要注意的是，所有的static 代碼塊只能在JVM加載類時被執行一次。

4.static 內部類

在 Java 中還支持用 static 修飾的內部類，稱為靜態內部類。靜態成員內部類的特點主要是它本身是類相關的內部類，所以它可以不依賴於外部類實例而被實例化。靜態內部類不能訪問其外部類的實例成員（包括普通的成員變量和方法），只能訪問外部類的類成員（包括靜態成員變量和靜態方法）。即使是靜態內部類的實例方法（非靜態成員方法）也不能訪問其外部類的實例成員。

java中static的用法

1.靜態方法

通常，在一個類中定義一個方法為static，那就是說，無需本類的對象即可調用此方法

聲明為static的方法有以下幾條限制：

·它們僅能調用其他的static 方法。

·它們只能訪問static數據。

·它們不能以任何方式引用this 或super。

class Simple {

staticvoid go() {

System.out.println(“Welcome”);

}

}

publicclass Cal {

publicstaticvoid main(String[] args) {

Simple.go();

}

}

調用一個靜態方法就是「類名.方法名」,靜態方法的使用很簡單如上所示。一般來說，靜態方法常常為應用程序中的其它類提供一些實用工具所用，在Java的類庫中大量的靜態方法正是出於此目的而定義的。

2.靜態變量

聲明為static的變量實質上就是全局變量。當聲明一個對象時，並不產生static變量的拷貝，而是該類所有的實例變量共用同一個static變量。靜態變量與靜態方法類似。所有此類實例共享此靜態變量，也就是說在類裝載時，只分配一塊存儲空間，所有此類的對象都可以操控此塊存儲空間，當然對於final則另當別論了

class Value {

staticintc = 0;

staticvoid inc() {

c++;

}

}

publicclass Count2 {

publicstaticvoid prt(String s) {

System.out.print(s);

}

publicstaticvoid main(String[] args) {

Value v1, v2;

v1 = new Value();

v2 = new Value();

prt(“v1.c=” + v1.c + ” v2.c=” + v2.c);

v1.inc();

prt(” v1.c=” + v1.c + ” v2.c=” + v2.c);

}

}

結果為：v1.c=0 v2.c=0 v1.c=1 v2.c=1

由此可以證明它們共享一塊存儲區。static變量有點類似於C中的全局變量的概念。

值得探討的是靜態變量的初始化問題。

如果你需要通過計算來初始化你的static變量，你可以聲明一個static塊，Static 塊僅在該類被加載時執行一次。下面的例子顯示的類有一個static方法，一些static變量，以及一個static 初始化塊：

class Value3 {

staticintc = 0;

Value3() {

c = 15;

}

Value3(int i) {

c = i;

}

staticvoid inc() {

c++;

}

}

publicclass Count {

publicstaticvoid prt(String s) {

System.out.println(s);

}

Value3 v = new Value3(10);

static Value3 v1, v2;

static {//此即為static塊

prt(“v1.c=” + v1.c + ” v2.c=” + v2.c);

v1 = new Value3(27);

prt(“v1.c=” + v1.c + ” v2.c=” + v2.c);

v2 = new Value3(15);

prt(“v1.c=” + v1.c + ” v2.c=” + v2.c);

}

publicstaticvoid main(String[] args) {

Count ct = new Count();

prt(“ct.c=” + ct.v.c);

prt(“v1.c=” + v1.c + ” v2.c=” + v2.c);

v1.inc();

prt(“v1.c=” + v1.c + ” v2.c=” + v2.c);

prt(“ct.c=” + ct.v.c);

}

}

結果為：

v1.c=0 v2.c=0

v1.c=27 v2.c=27

v1.c=15 v2.c=15

ct.c=10

v1.c=10 v2.c=10

v1.c=11 v2.c=11

ct.c=11

這個程序展示了靜態初始化的各種特性。如果你初次接觸Java，結果可能令你吃驚。可能會對static後加大括號感到困惑。首先要告訴你的是，static定義的變量會優先於任何其它非static變量，不論其出現的順序如何。正如在程序中所表現的，雖然v出現在v1和v2的前面，但是結果卻是v1和v2的初始化在v的前面。在static{後面跟着一段代碼，這是用來進行顯式的靜態變量初始化，這段代碼只會初始化一次，且在類被第一次裝載時。如果你能讀懂並理解這段代碼，會幫助你對static關鍵字的認識。在涉及到繼承的時候，會先初始化父類的static變量，然後是子類的，依次類推。

3．靜態類

通常一個普通類不允許聲明為靜態的，只有一個內部類才可以。這時這個聲明為靜態的內部類可以直接作為一個普通類來使用，而不需實例一個外部類。

publicclass StaticCls {

publicstaticvoid main(String[] args) {

OuterCls.InnerCls oi = newOuterCls.InnerCls();

}

}

classOuterCls {

publicstaticclass InnerCls {

InnerCls() {

System.out.println(“InnerCls”);

}

}

}

結果為：InnerCls

java static是什麼意思？

是靜態修飾符，什麼叫靜態修飾符呢？大家都知道，在程序中任何變量或者代碼都是在編譯時由系統自動分配內存來存儲的，而所謂靜態就是指在編譯後所分配的內存會一直存在，直到程序退出內存才會釋放這個空間，也就是只要程序在運行，那麼這塊內存就會一直存在。這樣做有什麼意義呢？

在Java程序裏面，所有的東西都是對象，而對象的抽象就是類，對於一個類而言，如果要使用他的成員，那麼普通情況下必須先實例化對象後，通過對象的引用才能夠訪問這些成員，但是有種情況例外，就是該成員是用static聲明的（在這裡所講排除了類的訪問控制），例如：

未聲明為static

class ClassA{

int b;

public void ex1(){

…

}

}

class ClassB{

void ex2{

int i;

ClassA a = new ClassA();

i = a.b; //這裡通過對象引用訪問成員變量b

a.ex1; //這裡通過對象引用訪問成員函數ex1

}

}

聲明為static

class ClassA{

static int b;

static void ex1(){

…

}

}

class ClassB{

void ex2{

int i;

i = ClassA.b; //這裡通過類名訪問成員變量b

ClassA.ex1; //這裡通過類名訪問成員函數ex1

}

}

通過以上兩種比較，就可以知道static用來修飾類成員的主要作用了，在java類庫當中有很多類成員都聲明為static，可以讓用戶不需要實例化對象就可以引用成員，最基本的有Integer.parseInt()，Float.parseFloat()等等用來把對象轉換為所需要的基本數據類型。這樣的變量和方法我們又叫做類變量和類方法。

接下來講一下被static修飾後的變量的值的問題，剛才在前面講過，被static修飾後的成員，在編譯時由內存分配一塊內存空間，直到程序停止運行才會釋放，那麼就是說該類的所有對象都會共享這塊內存空間，看一下下面這個例子：

class TStatic{

static int i;

public TStatic(){

i = 4;

}

public TStatic(int j){

i = j;

}

public static void main(String args[]){

TStatic t = new TStatic(5); //聲明對象引用，並實例化

TStatic tt = new TStatic(); //同上

System.out.println(t.i);

System.out.println(tt.i);

System.out.println(t.i);

}

}

這段代碼裏面Tstatic類有一個static的int變量I，有兩個構造函數，第一個用於初始化I為4，第二個用於初始化i為傳進函數的值，在main中所傳的值是5，程序首先聲明對象的引用t，然後調用帶參數的構造函數實例化對象，此時對象t的成員變量I的值為5，接着聲明對象tt，調用無參數的構造函數，那麼就把對象tt的成員變量i的值初始化為4了，注意了，在這裡i是static，那就是說該類的所有對象都共享該內存，那也就是說在實例化對象tt的時候改變了i的值，那麼實際上對象t的i值也變了，因為實際上他們引用的是同一個成員變量。最後打印的結果是三個4。呵呵，寫到這裡大家是否明白了呢？不明白就再看看書或者多寫幾個例子印證一下，呵呵。

java中的static如何使用?

有時你希望定義一個類成員，使它的使用完全獨立於該類的任何對象。通常情況下，類成員必須通過它的類的對象訪問，但是可以創建這樣一個成員，它能夠被它自己使用，而不必引用特定的實例。在成員的聲明前面加上關鍵字static(靜態的)就能創建這樣的成員。如果一個成員被聲明為static，它就能夠在它的類的任何對象創建之前被訪問，而不必引用任何對象。你可以將方法和變量都聲明為static。static成員的最常見的例子是main( )。因為在程序開始執行時必須調用main()，所以它被聲明為static。聲明為static的變量實質上就是全局變量。當聲明一個對象時，並不產生static變量的拷貝，而是該類所有的實例變量共用同一個static變量。

聲明為static的方法有以下幾條限制：

· 它們僅能調用其他的static方法。

· 它們只能訪問static數據。

· 它們不能以任何方式引用this或super（關鍵字super與繼承有關，在下一章中描述）。

如果你需要通過計算來初始化你的static變量，你可以聲明一個static塊，Static塊僅在該類被加載時執行一次。

下面的例子顯示的類有一個static方法，一些static變量，以及一個static 初始化塊：

class UseStatic {

static int a = 3;

static int b;

static void meth(int x) {

System.out.println(“x = ” + x);

System.out.println(“a = ” + a);

System.out.println(“b = ” + b);

}

static {

System.out.println(“Static block initialized.”);

b = a * 4;

}

public static void main(String args[]) {

meth(42);

}

}

一旦UseStatic類被裝載，所有的static語句被運行。首先，a被設置為3，接着static塊執行(打印一條消息)，最後，b被初始化為a*4或12。然後調用main()，main()調用meth()，把值42傳遞給x。3個println ( )語句引用兩個static變量a和b，以及局部變量x 。

注意：在一個static方法中引用任何實例變量都是非法的。

下面是該程序的輸出：

Static block initialized.

x = 42

a = 3

b = 12

在定義它們的類的外面，static方法和變量能獨立於任何對象而被使用。這樣，你只要在類的名字後面加點號運算符即可。例如，如果你希望從類外面調用一個static方法，你可以使用下面通用的格式：

classname.method( )

這裡，classname 是類的名字，在該類中定義static方法。可以看到，這種格式與通過對象引用變量調用非static方法的格式類似。一static變量可以以同樣的格式來訪問——類名加點號運算符。這就是Java如何實現全局功能和全局變量的一個控制版本。

下面是一個例子。在main()中，static方法callme()和static變量b在它們的類之外被訪問。

class StaticDemo {

static int a = 42;

static int b = 99;

static void callme() {

System.out.println(“a = ” + a);

}

}

class StaticByName {

public static void main(String args[]) {

StaticDemo.callme();

System.out.println(“b = ” + StaticDemo.b);

}

}

下面是該程序的輸出：

a = 42

b = 99

static成員是不能被其所在class創建的實例訪問的。

如果不加static修飾的成員是對象成員，也就是歸每個對象所有的。

加static修飾的成員是類成員，就是可以由一個類直接調用，為所有對象共有的

java中static是什麼意思？能不能通俗的講下，讓我這個菜鳥好理解一點

static英文是靜態的意思，所以它在java中也是這麼用的，是一個修飾詞，在定義數據前面加上它是指這個數據是靜態不變的，在方法明加上它是指這個方法是靜態的。一般就是這些用處