在定義內部類的時候，可以在其前面加上一個許可權修飾符static。此時這個內部類就變為了靜態內部類。不過由於種種的原因，如使用上的限制等等因素(具體的使用限制，筆者在下面的內容中會詳細闡述)，在實際工作中用的並不是很多。但是並不是說其沒有價值。在某些特殊的情況下，少了這個靜態內部類還真是不行。

下面的例子所示:

public class Student {
	//.......程式碼
	
	
}
 

public class Person{  
     //姓名  
     private String name;  
     //家庭  
     private Home home;  
     //建構函式設定屬性值  
     public Person(String _name){  
          name = _name;  
     }  
     /* home、name的getter/setter方法省略 */  
 public void setHome(Home home){
	 this.home = home;
 }
 
 public Home getHome(){
	 return home;
 }
 
 
 
     public static class Home{  
          //家庭地址  
          private String address;  
          //家庭電話  
          private String tel;  
 
          public Home(String _address,String _tel){  
            address = _address;  
            tel = _tel;  
          }  
          /* address、tel的getter/setter方法省略 */ 
          
          public static void main(String[] args) {  
 

      	    Student student = new Student();

      	}
     }  
      
} 

package com.devin;

public class MyMain{
    private static String name = "woobo";
    private String num = "X001";
 
    // 靜態內部類可以用public,protected,private修飾
    static class Person {
        // 靜態內部類中可以定義靜態或者非靜態的成員
        private String address = "China";

        private static String x = "as";
        public String mail = "[email protected]";// 內部類公有成員

        public void display() {
            // System.out.println(num);//不能直接訪問外部類的非靜態成員

            // 靜態內部類不能訪問外部類的非靜態成員(包括非靜態變數和非靜態方法)
            System.out.println(name);// 只能直接訪問外部類的靜態成員

            // 靜態內部類只能訪問外部類的靜態成員(包括靜態變數和靜態方法)
            System.out.println("Inner " + address);// 訪問本內部類成員。
        }
    }

    public void printInfo() {
        Person person = new Person();

        // 外部類訪問內部類的非靜態成員:例項化內部類即可
        person.display();

        // System.out.println(mail);//不可訪問
        // System.out.println(address);//不可訪問
        System.out.println(person.address);// 可以訪問內部類的私有成員

        System.out.println(Person.x);// 外部類訪問內部類的靜態成員：內部類.靜態成員
        System.out.println(person.mail);// 可以訪問內部類的公有成員
    }

    public static void main(String[] args) {
        MyMain staticTest = new MyMain();
        staticTest.printInfo();
    }
}

1. 巢狀類的物件，並不需要其外圍類的物件。 即它可以不依賴於外部類例項被例項化。

2. 不能從巢狀類的物件中訪問非靜態的外圍類物件。 這是由Java語法中"靜態方法不能直接訪問非靜態成員"所限定

3. 外部類訪問內部類的的成員有些特別, 不能直接訪問, 但可以通過內部類例項來訪問, 這是因為靜態巢狀內的所有成員和方法預設為靜態的了.同時注意, 內部靜態類Person只在類StaticTest 範圍內可見, 若在其它類中引用或初始化, 均是錯誤的.
4 . 靜態內部類可以有靜態成員，而非靜態內部類則不能有靜態成員。 
5. 靜態內部類的非靜態成員可以訪問外部類的靜態變數，而不可訪問外部類的非靜態變數；

6 . 非靜態內部類的非靜態成員可以訪問外部類的非靜態變數。

    生成一個靜態內部類不需要外部類成員：這是靜態內部類和成員內部類的區別。靜態內部類的物件可以直接生成：Outer.Inner in = new Outer.Inner();而不需要通過生成外部類物件來生成。這樣實際上使靜態內部類成為了一個頂級類(正常情況下，你不能在介面內部放置任何程式碼，但巢狀類可以作為介面的一部分，因為它是static 的。只是將巢狀類置於介面的名稱空間內，這並不違反介面的規則）

Java裡面static一般用來修飾成員變數或函式。但有一種特殊用法是用static修飾內部類，普通類是不允許宣告為靜態的，只有內部類才可以。被static修飾的內部類可以直接作為一個普通類來使用，而不需例項一個外部類（見如下程式碼）:

public class OuterClass {
	public static class InnerClass{
		InnerClass(){
			System.out.println("============= 我是一個內部類'InnerClass' =============");
		}
	}
}

public class TestStaticClass {
	public static void main(String[] args) {
		// 不需要new一個OutClass
		new OuterClass.InnerClass();
	}
}

package inner_class;

public class OuterClass {
	public class InnerClass{
		InnerClass(){
			System.out.println("============= 我是一個內部類'InnerClass' =============");
		}
	}
}

public class TestStaticClass {
	public static void main(String[] args) {
		// OutClass需要先生成一個例項
		OuterClass oc = new OuterClass();
		oc.new InnerClass();
	}
}