㈠ java內部類怎麼使用
1.內部類的方法可以訪問它所在的外部類中的所有域，包括私有型別的；
2.對於同一個包中的其它類它是隱藏的；
3. 匿名的內部類可以讓我們很方便的定義事件響應(call back)，這在GUI編程中很常見
interface OutInterface{ //定義一個介面 public void f(); } public class InterfaceInner { //主類 public static void main(String args[]){ OuterClass2 out=new OuterClass2(); OutInterface outinter=out.doit(); outinter.f(); } } class OuterClass2{ //定義一個內部類，並且介面OutInterface private class InnerClass implements OutInterface{ InnerClass(String s){ System.out.println(s); } public void f(){ System.out.println("訪問內部類中的f()方法"); } } public OutInterface doit(){ //方法返回介面 return new InnerClass("訪問內部類構造方法"); } }
㈡ java內部類有哪些
共有四種內部類，分別是:
1.常規內部類
2.靜態內部類
3.局部內部類
4.匿名內部類
常規內部類：常規內部類沒有用static修飾且定義在在外部類類體中。
常規內部類中的方法可以直接使用外部類的實例變數和實例方法。在常規內部類中可以直接用內部類創建對象。
靜態內部類：與類的其他成員相似，可以用static修飾內部類，這樣的類稱為靜態內部類。靜態內部類與靜態內部方法相似，只能訪問外部類的static成員，不能直接訪問外部類的實例變數，與實例方法，只有通過對象引用才能訪問。
由於static內部類不具有任何對外部類實例的引用，因此static內部類中不能使用this關鍵字來訪問外部類中的實例成員，但是可以訪問外部類中的static成員。這與一般類的static方法相通。
局部內部類：在方法體或語句塊（包括方法、構造方法、局部塊或靜態初始化塊）內部定義的類成為局部內部類。局部內部類不能加任何訪問修飾符，因為它只對局部塊有效。
局部內部類只在方法體中有效，就想定義的局部變數一樣，在定義的方法體外不能創建局部內部類的對象
在方法內部定義類時，應注意以下問題：1.方法定義局部內部類同方法定義局部變數一樣，不能使用private、protected、public等訪問修飾說明符修飾，也不能使用static修飾，但可以使用final和 abstract修飾2.方法中的內部類可以訪問外部類成員。對於方法的參數和局部變數，必須有final修飾才可以訪問。3.static方法中定義的內部類可以訪問外部類定義的static成員
匿名內部類：定義類的最終目的是創建一個類的實例，但是如果某個類的實例只是用一次，則可以將類的定義與類的創建，放到與一起完成，或者說在定義類的同時就創建一個類。以這種方法定義的沒有名字的類成為匿名內部類。
㈢ 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內部調用內部方法的問題
classt
{
publicstaticvoidc()
{
jdf();//這樣是可以的，方法中不能定義方法，只能調用方法，內部類除外
}
publicstaticvoidjdf()
{
System.out.println("你好");
}
}
㈤ java內部類，匿名內部類這些是什麼求詳細用法，還有語法。
一、內部類：
內部類是定義在另一個類中的類，使用它的原因主要有3個：
內部類方法可以訪問該類定義所在的作用域中的數據，包括私有的數據；
內部類可以對同一個包中的其他類隱藏以來；
當想要定義一個回調函數且不想編寫大量代碼時，使用匿名內部類比較便捷。
【舉例：《Java核心技術（卷I）》，6.4節——內部類，程序清單6-6】
importjava.awt.*;
importjava.awt.event.*;
importjava.util.*;
importjavax.swing.*;
importjavax.swing.Timer;
/**
*.
*@version1.102004-02-07
*@authorCayHorstmann
*/
publicclassInnerClassTest
{
publicstaticvoidmain(String[]args)
{
TalkingClockclock=newTalkingClock(1000,true);
clock.start();
//"Ok"
JOptionPane.showMessageDialog(null,"Quitprogram?");
System.exit(0);
}
}
/**
*.
*/
classTalkingClock
{
privateintinterval;
privatebooleanbeep;
/**
*Startstheclock.
*@(inmilliseconds)
*@
*/
publicTalkingClock(intinterval,booleanbeep)
{
this.interval=interval;
this.beep=beep;
}
/**
*Startstheclock.
*/
publicvoidstart()
{
ActionListenerlistener=newTimePrinter();
Timert=newTimer(interval,listener);
t.start();
}
{
publicvoidactionPerformed(ActionEventevent)
{
Datenow=newDate();
System.out.println("Atthetone,thetimeis"+now);
if(beep)Toolkit.getDefaultToolkit().beep();
}
}
}
上述代碼中，TimePrinter就是在TalkingClock類的內部定義的一個內部類，因此它可以訪問外圍類的數據域，包括interval和beep這種私有域。
二、局部內部類：
討論匿名內部類之前，先看看局部內部類，它是在一個方法中定義的類。代碼示例如下，這里將上例中的TimePrinter類放到了start()方法中進行定義：
publicvoidstart(intinterval,finalbooleanbeep)
{
{
publicvoidactionPerformed(ActionEventevent)
{
Datenow=newDate();
System.out.println("Atthetone,thetimeis"+now);
if(beep)Toolkit.getDefaultToolkit().beep();
}
}
ActionListenerlistener=newTimePrinter();
Timert=newTimer(interval,listener);
t.start();
}
局部內部類不能用public或private訪問說明符來聲明，它的作用域被限定在聲明這個局部內部類的塊中。局部內部類可以對外部世界完全地隱藏起來。
局部內部類不僅能訪問其外圍類，還可以訪問局部變數，不過這些局部變數必須被聲明為final，如上述代碼中start()方法的參數beep所示。
三、匿名內部類
將上面的局部內部類的代碼修改一下，就可以定義一個匿名內部類，這種類沒有類名。
publicvoidstart(intinterval,finalbooleanbeep)
{
ActionListenerlistener=newActionListener()
{
publicvoidactionPerformed(ActionEventevent)
{
Datenow=newDate();
System.out.println("Atthetone,thetimeis"+now);
if(beep)Toolkit.getDefaultToolkit().beep();
}
};
Timert=newTimer(interval,listener);
t.start();
}
請參照局部內部類的代碼，比較不同之處。TimePrinter這個類名被省略了，定義listener這個局部內部類時，在其後的new ActionListener()後面跟了一個大括弧括起的語句塊，也就是此匿名內部類的定義語句。匿名內部類除了具有內部類的優點外，還可以減少代碼量。
【內容有些多，但願能幫到你^_^】
㈥ java 主方法怎麼調用內部類的方法
一般來說，外部類調用內部類的方法分為以下幾種情況：
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();
}
};
public class InnerClassDemo04
{
public static void main(String args[])
{
//外部類實例化對象
Outer out = new Outer();
//實例化內部類對象
Outer.Inner in = out.new Inner();
//調用內部類的方法
in.print();
}
};
3.在方法中定義內部類 ，使外部調用
//定義外部類
class Outer
{
//定義外部類的私有屬性
private String info = "hello world";
//定義外部類的方法
public void fun(final int temp)
{
//在方法中定義的內部類
class Inner
{
//定義內部類的方法
public void print()
{
//直接訪問外部類的私有屬性
System.out.println("類中的屬性：" + info);
System.out.println("方法中的參數：" + temp);
}
};
//通過內部類的實例化對象調用方法
new Inner().print();
}
};
public class InnerClassDemo05
{
public static void main(String args[]){
//調用外部類的方法
new Outer().fun(30);
}
};
㈦ 在Java中什麼是內部類
內部類就是寫在類中或方法中的類，它還是一個類，與其他類的不同就是他只為這個外部類（包含內部類的類）類所用