㈠ 怎麼調用靜態方法
靜態方法不能訪問非靜態的實例變數和實例方法。實例方法可以訪問靜態成員和非靜態成員。
1在本來中直接調用靜態方法
2可以通過類名來調用該類的靜態方法
3通過實例調用靜態方法
// 外部類，不能是靜態的
public class OuterClass {
// 靜態方法，又稱為類方法，屬於Test類
public static void staticFun() {
}
// 非靜態方法，又稱為實例方法，屬於Test類的具體實例
public void nonStaticFun() {
}
// 靜態內部類，靜態類只能是內部類
public static class StaticInnerClass {
// 靜態方法，屬於StaticInnerClass類
public static void staticFun() {
}
// 非靜態方法，屬於StaticInnerClass類的實例
public void nonStaticFun() {
}
}
// 非靜態內部類，不能有靜態方法
public class NonStaticInnerClass {
// 非靜態方法，屬於NonStaticInnerClass的實例
public void nonStaticFun() {
}
}
// 測試代碼如下：
public static void main(String[] args) {
// 對於靜態方法，使用類直接訪問
OuterClass.staticFun();
StaticInnerClass.staticFun();
// 對於非靜態方法，需要使用類的實例訪問
new OuterClass().nonStaticFun();
new StaticInnerClass().nonStaticFun();
// 對於非靜態內部類，必須創建外部類後才能使用
OuterClass outerClass = new OuterClass();
NonStaticInnerClass nonStaticInnerClass = outerClass.new NonStaticInnerClass();
nonStaticInnerClass.nonStaticFun();
}
}
㈡ 如何在main.c中如何調用static函數怎麼辦
你好，static在c裡面可以用來修飾變數，也可以用來修飾函數。
先看用來修飾變數的時候。變數在c裡面可分為存在全局數據區、棧和堆里。其實我們平時所說的堆棧是棧而不是堆，不要弄混。
int a ;
int main()
{
int b ;
int c* = (int *)malloc(sizeof(int));
}
a是全局變數，b是棧變數，c是堆變數。
static對全局變數的修飾，可以認為是限制了只能是本文件引用此變數。有的程序是由好多.c文件構成。彼此可以互相引用變數，但加入static修飾之後，只能被本文件中函數引用此變數。
static對棧變數的修飾，可以認為棧變數的生命周期延長到程序執行結束時。一般來說，棧變數的生命周期由OS管理，在退棧的過程中，棧變數的生命也就結束了。但加入static修飾之後，變數已經不再存儲在棧中，而是和全局變數一起存儲。同時，離開定義它的函數後不能使用，但如再次調用定義它的函數時，它又可繼續使用， 而且保存了前次被調用後留下的值。
static對函數的修飾與對全局變數的修飾相似，只能被本文件中的函數調用，而不能被同一程序其它文件中的函數調用。
㈢ 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修飾的成員是類成員，就是可以由一個類直接調用，為所有對象共有的
㈣ static 定義的函數，怎麼使用
static定義變數的使用：
一、靜態局部變數：
1、Static類內部變數同auto自動變數（即未加 Static 聲明的局部變數）一樣，是某個特定函數的局部變數，即只能在定義該變數的函數內使用該變數，2者作用域相同；兩者的不同在於：auto自動變數會隨著函數被調用和退出而存在和消失，而static類局部變數不會，它不管其所在的函數是否被調用，都將一直存在；不過，盡管該變數還繼續存在，但不能使用它。倘若再次調用定義它的函數時，它又可繼續使用，而且保存了前次被調用後留下的值。換言之，Static類型的內部變數是一種只能在某個特定函數中使用，但一直占據存儲空間的變數。
2、函數體內如果在定義靜態變數的同時進行了初始化，則以後程序不再進行初始化操作（出現在函數內部的基本類型的的靜態變數初始化語句只有在第一次調用才執行）。而對自動變數賦初值是在函數調用時進行，每調用一次函數重新給一次初值，相當於執行一次賦值語句。
3、靜態局部變數的初始化表達式必須是一個常量或者常量表達式。即使局部靜態變數定義時沒有賦初值，系統會自動賦初值0（對數值型變數）或空字元（對字元變數）；靜態變數的初始值為0。而對自動變數auto來說，如果不賦初值則它的值將是個不確定的值。
4、當多次調用一個函數且要求在調用之間保留某些變數的值時，可考慮採用靜態局部變數。雖然用全局變數也可以達到上述目的，但全局變數有時會造成意外的副作用，因此仍以採用局部靜態變數為宜。
註：局部靜態變數佔用內存時間較長，並且可讀性差，因此，除非必要，盡量避免使用局部靜態變數。
二、靜態全局變數
全局變數(外部變數)的說明之前再冠以static 就構成了靜態的全局變數。
全局變數本身就是靜態存儲方式，靜態全局變數當然也是靜態存儲方式。
這兩者在存儲方式上並無不同。
這兩者的區別雖在於：
1、非靜態全局變數的作用域是整個源程序，當一個源程序由多個源文件組成時，非靜態的全局變數在各個源文件中都是有效的。
2、靜態全局變數則限制了其作用域， 即只在定義該變數的源文件內有效，在同一源程序的其它源文件中不能使用它。
由於靜態全局變數的作用域局限於一個源文件內，只能為該源文件內的函數公用，因此可以避免在其它源文件中引起錯誤。
從以上分析可以看出
把局部變數改變為靜態變數後是改變了它的存儲方式，即改變了它的生存期。
把全局變數改變為靜態變數後是改變了它的作用域，限制了它的使用范圍。
因此static這個說明符在不同的地方所起的作用是不同的。應予以注意。
㈤ 如何調用內部類中的靜態方法
一般來說，外部類調用內部類的方法分為以下幾種情況：
1.使用static可以聲明一個內部類， 可以直接在外部調用
// 定義外部類
class Outer
{
// 定義外部類的私有屬性
private static String info = "hello world";
// 使用static定義內部類為外部類
static class Inner
{
// 定義內部類的方法
public void print()
{
// 直接訪問外部類的私有屬性
System.out.println(info);
}
};
// 定義外部類的方法
public void fun()
{
// 通過內部類的實例化對象調用方法
new Inner().print();
}
};
public class InnerClassDemo03
{
public static void main(String args[])
{
// 調用外部類的fun()方法
new Outer.Inner().print() ;
}
};
2.不使用statc聲明一個內部類 ，使外部調用
//定義外部類
class Outer
{
//定義外部類的私有屬性
private String info = "hello world";
//定義內部類
class Inner
{
//定義內部類的方法
public void print()
{
//直接訪問外部類的私有屬性
System.out.println(info);
}
};
//定義外部類的方法
public void fun()
{
//通過內部類的實例化對象調用方法
new Inner().print();
}
};
㈥ 怎樣用類調用static修飾的方法
當一個方法或者變數需要初始化載入，或者是經常被調用的時候可以加上static。
用static修飾的方法可以用類名直接調用，不用的一定要先實例化一個對象然後才可以調用
比如 person這個類裡面有一個方法public static add(){}
那麼可以直接用person類調用 person.add();當然也可以用下面的方法先出一個對象在調用也是可以
如果這個方法前面沒有static 比如 public add(){}
那麼先要person p=new person();
然後用p.add();
類載入器在載入這個類的時候就已經實例化了這個類。
壞處：初始化載入，比較占內存，所以不經常用的方法，不建議加此關鍵字。
㈦ static的方法怎麼調用資料庫
全局變數前加上關鍵字static，全局變數就定義成一個全局靜態變數.，全局靜態變數存儲在靜態存儲區，在整個程序運行期間一直存在。全局靜態變數在程序運行之前就存在。初始化：未經初始化的全局靜態變數會被自動初始化為0（自動對象的值是任意的，除非他被顯式初始化）。作用域：全局靜態變數在聲明他的文件之外是不可見的，准確地說是從定義之處開始，到文件結尾。
局部靜態數據
在局部變數之前加上關鍵字static，局部變數就成為一個局部靜態變數。局部靜態變數再程序執行到作用域時候，就會存在。
局部靜態數據再內存中的靜態存儲區。
初始化：未經初始化的全局靜態變數會被自動初始化為0（自動對象的值是任意的，除非他被顯式初始化）。
作用域：作用域仍為局部作用域，當定義它的函數或者語句塊結束的時候，作用域結束。但是當局部靜態變數離開作用域後，並沒有銷毀，而是仍然駐留在內存當中，只不過我們不能再對它進行訪問，直到該函數再次被調用，並且值不變。
靜態函數
在函數返回類型前加static，函數就定義為靜態函數。函數的定義和聲明在默認情況下都是extern的，但靜態函數只是在聲明他的文件當中可見，不能被其他文件所用。
函數的實現使用static修飾，那麼這個函數只可在本cpp內使用，不會同其他cpp中的同名函數引起沖突。
warning：不要再頭文件中聲明static的全局函數，不要在cpp內聲明非static的全局函數，如果你要在多個cpp中復用該函數，就把它的聲明提到頭文件里去，否則cpp內部聲明需加上static修飾。
類的靜態成員
靜態成員可以實現多個對象之間的數據共享，並且使用靜態數據成員還不會破壞隱藏的原則，即保證了安全性。
靜態數據成員不能在類中初始化，實際上類定義只是在描述對象的藍圖，在其中指定初值是不允許的。也不能在類的構造函數中初始化該成員，因為靜態數據成員為類的各個對象共享，否則每次創建一個類的對象則靜態數據成員都要被重新初始化靜態成員可以被初始化，但只能在類體外進行初始化。 一般形式：數據類型 類名::靜態數據成員名＝初值。
靜態成員不可在類體內進行賦值，因為它是被所有該類的對象所共享的。你在一個對象里給它賦值，其他對象里的該成員也會發生變化。
靜態成員屬於整個類所有，不需要依賴任何對象，它在對象中不佔用存儲空間。
靜態成員仍然遵循public，
㈧ 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