方法呼叫：

同類中，類的不同成員方法之間可以互相呼叫，呼叫時直接使用成員方法名稱，其他類呼叫必須先建立這個類的物件，然後通過操作符.來呼叫這個類的成員方法。例如：

public class Test5 { 
    public String color(){
        return "黃色";
    }
    public void lion(){
    //同類中直接呼叫，呼叫時直接使用成員方法名稱
        System.out.print("這是一個"+color()+"的獅子");
    }
}  
public class test6 {
    public static
 
 void main(String[] args) {
    //其他類呼叫時先要建立這個類的物件
        Test5 t=new Test5();
    //通過操作符.來呼叫這個類的成員方法
        t.lion();
    }

}

常見錯誤：

return只能返回一個值，不能返回多個值
多個方法不能相互巢狀定義
不能在方法內部直接寫邏輯程式碼
void不能用return語句

成員變數&區域性變數：

成員變數：類中定義的變數稱為類的成員變數，類的方法可以直接引用成員變數，不同類引用要通過建立類的物件，然後通過操作符.來引用。成員變數未賦值系統會自動給其預設初始值。
區域性變數：

構造方法

構造方法是一個特殊的方法，方法名與類名同名，沒有返回值型別，主要作用是在建立類的物件時執行一些初始化操作。當沒有該方法時系統會提供一個空的該方法。（注：一旦自定義了構造方法，系統將不再提供這個預設構造方法，如要使用需自行新增）

public class Test6 {
private int a;
//無參構造
public Test6
 
() {
    super();
    // TODO Auto-generated constructor stub
}
//有參構造
public Test6(int a) {
    super();
    this.a = a;
}

}

方法的過載

同一個類中的兩個方法，方法名相同，引數個數或引數型別不同，則稱該方法被過載了。成員方法和構造方法都能過載。
（注：與方法返回值和方法修飾符（private,public等）無關。方法的返回型別、修飾符可以相同，也可不同。）

public class Test5 { 
    public int lion(int i){
        return i;
    }
    //方法修飾符不同返回值型別也不同，但是隻要引數不同，仍然是過載
    private boolean lion(){
        return false;
    }
}  

Static修飾符

可以用來修飾屬性，方法，和程式碼塊。
Static修飾的屬性稱為類屬性（類變數），修飾的方法稱為類方法，不使用Static修飾的屬性和方法稱為例項屬性（例項變數）和例項方法。

修飾變數：
當一個變數前面有了static這個修飾符，記憶體會為它分配唯一的一塊儲存空間。程式跑起來的時候，變數就存在在記憶體裡了。誰要用它，就去訪問一下它所在的記憶體。假如記憶體是澡堂子，static變數就像一坨肥皂，一整個澡堂子的人都共用之。不管澡堂子裡有沒有人，肥皂總是在這裡。編譯器想拿出肥皂來玩一玩，直接吼出肥皂的名字就好了。（即不需new物件，直接可以拿來用）
如果這是一個非static的變數，則是對每個物件有一份儲存空間。程式跑剛起來的時候，是沒有這個變數的。相當於一個澡堂子裡每個人都有一坨肥皂。如果沒有人，也就沒有肥皂。編譯器想要用肥皂來做點什麼，必須先製造一個手持肥皂的人。（即必須new一個物件出來）

public class XX{
    final static double PI = 3.14;
    final double E=2.71;
    public static void main(String[] args) {
        //下面要使用static變數PI了   
        System.out.print(PI);//直接引用無需新建物件 
        //下面要使用非static變數E
        XX b = new XX();    
        System.out.print(b.E);//要用new出的物件b引用
    }
}

修飾方法：
假如一個方法被static修飾，可直接訪問。不被static修飾，就需要用物件來訪問。

public class XX{
    public static void method1(){  } 
    public void method2(){  }
    public static void main(String[] args)
    {    //直接訪問
        method1();
        XX b = new XX();
        //通過新建的物件b來訪問
        b.method2();
    }
}

修飾程式碼塊：
static{ … … }

靜態塊、非靜態塊和構造函數出現的先後順序

public class XX{
    /**
     *  執行結果：   
     *  這是static修飾的程式碼塊
        這是無static修飾的程式碼塊
        這是無參構造方法
        這是普通例項方法
        這是無static修飾的程式碼塊
        這是無參構造方法
        這是普通例項方法
     */
    public XX() {
        System.out.println("這是無參構造方法");
    }
    {
        System.out.println("這是無static修飾的程式碼塊");
    }
    static{
        System.out.println("這是static修飾的程式碼塊");
    }
    public void method(){
        System.out.println("這是普通例項方法");
    }
    public static void main(String[] args) {
        //物件1的方法
        XX x1=new XX();
        x1.method();
        //物件2的方法
        XX x2=new XX();
        x2.method();
    }
}

結論： 靜態程式碼塊——非靜態程式碼塊——構造方法——普通方法，按照這個順序執行，其中，靜態塊的載入是在main()函式以前的，並且只執行一次 ，非靜態塊和建構函式則是new一次執行一次。

靜態匯入：

使用靜態匯入可以使被匯入類的靜態變數和靜態方法在當前類直接可見，使用這些靜態成員無需再給出他們的類名。

靜態匯入的語法是：

import static 包名.類名.靜態成員變數;
import static 包名.類名.靜態成員函式;

package com.example.learnjava;

public class Common
{

    public static final int AGE = 10;
    public static void output()
    {
        System.out.println("Hello World!");
    }
}

在另一個包中使用時，如果不用靜態匯入，是這樣用的：

package com.example.learnjava2;

import com.example.learnjava.Common;

public class StaticImportTest
{
    public static void main(String[] args)
    {
        int a = Common.AGE;
        System.out.println(a);

        Common.output();
    }

}

如前面的程式使用靜態匯入後：

package com.example.learnjava2;
//匯入屬性只需要寫屬性名即可
import static com.example.learnjava.Common.AGE;
//匯入方法只需要寫方法名即可，不需要加（）;
import static com.example.learnjava.Common.output;

public class StaticImportTest
{
    public static void main(String[] args)
    {
        //直接引用屬性名
        int a = AGE;
        System.out.println(a);
        //直接引用方法名
        output();
    }

}

Static需要注意的點：
1.類方法只能訪問類屬性和其他類方法
2.靜態方法中不能使用 this和super關鍵字
3.方法中不可以定義static變數，即類變數不能是區域性變數。