本文目錄一覽：
java中內部類
在java語言中，有一種類叫做內部類(inner class)，也稱為嵌入類(nested class)，它是定義在其他類的內部。內部類作為其外部類的一個成員，與其他成員一樣，可以直接訪問其外部類的數據和方法。只不過相比較外部類只有public和默認的修飾符不同，內部類作為一個成員，可以被任意修飾符修飾。編譯器在編譯時，內部類的名稱為OuterClass$InnerClass.class 。
1、內部類訪問數據變量
當在某些時候，內部類中定義的變量與外部類中變量名稱相同時，如何確保正確地訪問每一個變量呢？
1.1在main中直接從外部類調用內部類的方法
class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(this); // the object created from the Inner
System.out.println(Outer.this); // the object created from the Outer
System.out.println(index); // output is 30
System.out.println(this.index); // output is 20
System.out.println(Outer.this.index); // output is 10
}
}
void print()
{
Inner inner = new Inner();//得到內部類的引用
inner.print();
}
}
class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
outer.print();
}
}
在這裡內部類Inner中關鍵字this指向內部類Inner的對象，如果要想指向外部類的對象，必須在this指針前加上外部類名稱，表示this是指向外部類構造的碎屑，如Outer.this 。
1.2在main中顯式返回內部類引用
class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}
Inner getInner()
{
return new Inner();//返回一個內部類的引用
}
}
class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
Outer.Inner inner = outer.getInner();
inner.print();
}
}
Inner是Outer的內部類，所以在類Test中必須用屬性引用符來標識出內部類。
1.3當main方法在Outer類內部
class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}
Inner getInner()
{
return new Inner();//返回一個內部類的引用
}
public static void main(String[] args)
{
Outer outer = new Outer();
Inner inner = outer.getInner(); // 注意此處變化
inner.print();
}
}
因為main方法在Outer內部，故可以直接引用，不需要屬性引用符。
1.4在main方法中直接產生內部類對象
class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(); // 注意此處變化
inner.print();
}
}
在利用new構造方法構造一個外部類對象時，並沒有連帶着構造一個內部類對象，故需要訪問內部類方法時，必須使用new操作符為這個外部類對象再構造一個內部類對象。
2、局部內部類
在方法中定義的內部類是局部內部類，它只能訪問方法中的final類型的局部變量，因為用final定義的局部變量相當於是一個常量，延長了其生命周期，使得方法在消亡時，其內部類仍可以訪問該變量。另外，它同樣也可以引用定義在外部類的變量和方法。而且方法體中的局部內部類不允許有訪問修飾符。
class Outer
{
int num=10;
public void print(final int aArgs)
{
class Inner
{
int num=20;
public Inner()
{
System.out.println(“This is Inner.”);//此句可看出它與匿名內部類用法的不同。
}
public void print()
{
int num=30;
System.out.println(this); // the object created from the local Inner
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
System.out.println(aArgs);
}
}
Inner inner=new Inner();//此句必須放在定義類Inner的後面
inner.print();
}
public static void main(String[] args)
{
Outer outer=new Outer();
outer.print(40);
}
}
對於局部類的命名，不管是在一個方法中定義多個類還是在幾個方法中分別定義類，其編譯後命名是：OuterClass$1InnerClass.class
3、匿名內部類
匿名內部類作為一種特殊的內部類，除了具有普通內部類的特點，還有自己的一些獨有特性：
匿名內部類必須擴展一個基類或實現一個接口，但是不能有顯式的extends和implements子句；
匿名內部類必須實現父類以及接口中的所有抽象方法；
匿名內部類總是使用父類的無參構造方法來創建實例。如果是實現了一個接口，則其構造方法是Object()；
匿名內部類編譯後的命名為：OuterClass$n.class，其中n是一個從1開始的整數，如果在一個類中定義了多個匿名內部類，則按照他們的出現順序從1開始排號。
abstract class A
{
abstract public void sayHello();
}
class Outer
{
public static void main(String[] args)
{
new Outer().callInner(new A()
{
public void sayHello()
{
System.out.println(this); // the object created from the anonymous Inner
System.out.println(“Hello!”);
}
});
}
public void callInner(A a)
{
a.sayHello();
}
}
4、靜態內部類
和非靜態內部類相比，區別就在於靜態內部類沒有了指向外部類的引用。除此之外，在任何非靜態內部類中，都不能有靜態數據，靜態方法或者又一個靜態內部類（內部類的嵌套可以不止一層）。不過靜態內部類中卻可以擁有這一切。這也算是兩者的第二個區別吧。一個靜態的內部類,才可以聲明一個static成員，靜態內部類可以訪問外圍類的靜態方法、成員（包括private static的成員）。靜態內部類實例化的時候不必先實例化外圍類，可以直接實例化內部類。而對於非靜態內部類則必須先實例化其外部類，才能再實例化本身。
5．內部類的繼承
當一個類繼承自一個內部類時，缺省的構造器不可用。必須使用如下語法：
class WithInner
{
class Inner
{
public void sayHello()
{
System.out.println(“Hello.”);
}
}
}
public class Test extends WithInner.Inner
{
Test(WithInner wi)
{
wi.super();
}
public static void main(String[] args)
{
WithInner wi=new WithInner();
Test test=new Test(wi);
test.sayHello();
}
}
因為每一個內部類都有一個指向外部類的引用，在繼承一個內部類，必須先創建一個外部類，通過這個外部類引用來調用其內部類的構造方法。如果繼承的內部類是一個靜態內部類，則就不需要這樣，直接super()調用即可；
6、內部類的2種特殊用法
一個類從另一個類派生出來，又要實現一個接口。但在接口中定義的方法與父類中定義的方法的意義不同，則可以利用內部類來解決這個問題。
interface Machine
{
void run();
}
class Person
{
void run()
{
System.out.println(“run”);
}
}
class Robot extends Person
{
private class MachineHeart implements Machine
{
public void run()
{
System.out.println(“heart run”);
}
}
Machine getMachine()
{
return new MachineHeart();
}
}
class Test
{
public static void main(String[] args)
{
Robot robot = new Robot();
Machine m = robot.getMachine();
m.run();
robot.run();
}
}
在Robot類內部使用內部類MachineHeart來實現接口Machine的run方法。同時Robot類又繼承了父類Person的run方法。如果不使用內部類MachineHeart而使Robot直接實現接口Machine，則該如何調用父類的run方法？
利用內部類可解決c++中多重繼承所解決的問題
class A
{
void fn1()
{
System.out.println(“It’ s fn1.”);
}
}
abstract class B
{
abstract void fn2();
}
class C extends A
{
B getB()
{
return new B()
{
public void fn2()
{
System.out.println(“It’ s fn2.”);
}
};
}
}
class Test
{
public static void main(String[] args)
{
C c = new C();
c.fn1();
c.getB().fn2();
}
}
類C既要繼承類A又要繼承類B，則可將類B的定義放入類C內部，使之成為內部類。
一般情況下 當我們需要在某一情形下實現一個接口，而在另一情形下又不需要實現這個接口時，我們可以使用內部類來解決這一問題。讓內部類來實現這個接口。另外一個很好的理由是java內部類加上接口可以有效地實現多重繼承。
在Java中什麼是內部類？
內部類就是寫在類中或方法中的類，它還是一個類，與其他類的不同就是他只為這個外部類（包含內部類的類）類所用
Java的內部類有什麼特點 作用和注意
需要了解2個概念：內部類和靜態修飾符static
1）首先，用內部類是因為內部類與所在外部類有一定的關係，往往只有該外部類調用此內部類。所以沒有必要專門用一個java文件存放這個類。
2）靜態都是用來修飾類的內部成員的。比如靜態方法，靜態成員變量，靜態常量。它唯一的作用就是隨着類的加載（而不是隨着對象的產生）而產生，以致可以用類名+靜態成員名直接獲得。
這樣靜態內部類就可以理解了，因為這個類沒有必要單獨存放一個文件，它一般來說只被所在外部類使用。並且它可以直接被用
外部類名+內部類名
獲得。
以下舉例說明怎麼使用：
student類有個叫school的內部類（非靜態）
student
stu
=
new
student();
stu.school
sch
=
new
stu.school();
sch就是school的一個對象。
假如school是內部靜態類：
student.school
sch
=
new
student.school();
然而在開發中並沒有什麼卵用
java中內部類的概念？
簡單的說，內部（inner）類指那些類定義代碼被置於其它類定義中的類；而對於一般的、類定義代碼不嵌套在其它類定義中的類，稱為頂層（top-level）類。對於一個內部類，包含其定義代碼的類稱為它的外部（outer）類。 1 Static member class（靜態成員類） 類聲明中包含“static”關鍵字的內部類。如以下示例代碼， Inner1/Inner2/Inner3/Inner4就是Outer的四個靜態成員類。靜態成員類的使用方式與一般頂層類的使用方式基本相同。
1內部類的嵌套可以理解成類的鏈關係，在構造一個內部類(非static)的實例的時候，會將直接外層類的實例
作為參數傳進構造函數，而外層類的實例也是用其外層類的實例構造，所以是一種鏈狀關係，內部的類可以使用所有
外層的類的實例，而外層的類不能使用內層的類， 應用a.this(最外層類實例) ，a.b.c.this(鏈中某個外層的實例)。
class TheOuter{
class kk {
class gg {
int tt = 100;
}
}
class aa {
class bb {
int jj = 10;
class cc {
{ int ff = TheOuter.aa.bb.this.jj;
// 無法直接訪問到gg不在鏈關係內
System.out.println(ff);
}
}
}
}
}
2 創建一個內部類 new aa().new bb().new()cc 實際上是調用 外層類實例.new 本層構造函數()
如果內部類是static的不需要外層類的實例 多個static嵌套的內部類的實例 aa.bb.cc test = new aa.bb.cc();
3
class a0 {
class b0 {
}
}
class vvv{
class ff extends a0.b0 {// ff這裡不是內部類也行
ff(a0 kk){
kk.super();
}
}
}
繼承自內部類要調用父類的外層類的super()
4
class dd {
void print(){
System.out.println(“dd.println is there”);
}
class kk {
kk(int i){}
class cc {
void pp() {
System.out.println(“****”);
}
void ddpp() {
dd.this.print();
}
}
}
}
class aa {
public static void main (String agrs[]) {
dd.kk.cc test = new dd().new kk(10).new cc();
test.ddpp();
}
}
在類內部可以是使用外層類，但是如果生成一個實例的句柄就沒有提供訪問上層類的功能。
5 this 是指本類的實例
6 缺省的new
class cc {
{
new test();
}
class kk {
{
System.out.println(“there kk”);
}
}
class test {
{
new kk();
}
class kk {
{
System.out.println(“there test_kk”);
}
}
}
}
可以直接使用new,new的範圍可以是 之際外層.this.new 和this.new 但是如果內層與外層出現同名類以內部優先
7
//當有鏈關係的時候要注意類不要重名
class vv {
class bb {} //!
class kk {
//class vv{} 這樣就會出錯
class bb {} //!這樣就不會出錯
}
}
8
class a0 {
class b0 {
}
}
class vvv{
class ff extends a0.b0 {// 不是內部類也行
ff(a0 kk){
kk.super();
}
}
}
繼承自內部類要調用父類的外層類的super()
9 匿名內部類
interface oo {
//oo(int g) {}
int k = 10;
void pt();
}
class pp {
pp(int g) {
}
int get() {
return 100;
}
}
class me {
/*
interface oo {
void pt();
}
*/
class kk{
oo testmed() {
final int i = 10;
int g = 100;
return new oo() {
int kk;
{
// 使用外面的東西要聲名成final
// 繼承接口內部優先
// 匿名內部類沒有構造函數，只能使用塊，初始化
kk = i + k ;
}
public void pt() {
System.out.println(kk);
}
};
}
pp testmed0() {
return new pp(10){ // 繼承自類
public int get() {
return super.get() * 10;
}
};
}
}
}
匿名內部類可以繼承自接口也可以繼承自類，繼承自類的構造函數中 可以有參數。
10
class bf {
interface kk {}
class aa {
// 接口能嵌套在接口中（不受限制），或者嵌套在頂層，下面就不行
//interface gg {}
}
}
原創文章，作者：SJNV，如若轉載，請註明出處：https://www.506064.com/zh-hant/n/139481.html
微信掃一掃 
支付寶掃一掃 