❶ 什麼是內部類內部類有什麼作用(java)
(1)、內部類仍然是一個獨立的類，在編譯之後內部類會被編譯成獨立的.class文件，但是前面冠以外部類的類名和$符號。(2)、內部類不能用普通的方式訪問。內部類是外部類的一個成員，因此內部類可以自由地訪問外部類的成員變數，無論是否是private的。(3)、內部類聲明成靜態的，就不能隨便的訪問外部類的成員變數，仍然是只能訪問外部類的靜態成員變數。典型的情況是，內部類繼承自某個類或實現某個介面，內部類的代碼操作創建其的外圍類的對象。所以你可以認為內部類提供了某種進入其外圍類的窗口。使用內部類最吸引人的原因是：每個內部類都能獨立地繼承自一個（介面的）實現，所以無論外圍類是否已經繼承了某個（介面的）實現，對於內部類都沒有影響。如果沒有內部類提供的可以繼承多個具體的或抽象的類的能力，一些設計與編程問題就很難解決。從這個角度看，內部類使得多重繼承的解決方案變得完整。介面解決了部分問題，而內部類有效地實現了「多重繼承」。
❷ 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編譯器MyEclipse創建一個內部類求大神指點！復制粘貼的的滾！
class 外部類名稱{
class 內部類名稱{
}
}
望採納
❹ idea怎麼編譯帶有內部類的
java中直接創建一個內部類對象導入外部類，可以訪問私有屬性，進行封裝，防止外界破壞。 內部類對象可以訪問創建它的外部類對象的內容，甚至包括私有變數。在設計時提供了更多的思路和捷徑。要想實現這個功能，內部類對象就必須有指向外部類對象...
❺ java 中的內部類和匿名內部類都是怎麼回事 該怎麼用
1、內部類分為成員內部類、靜態嵌套類、方法內部類、匿名內部類。
幾種內部類的共性：
A、內部類仍然是一個獨立的類，在編譯之後會內部類會被編譯成獨立的.class文件，但是前面冠以外部類的類命和$符號。
B、內部類不能用普通的方式訪問。內部類是外部類的一個成員，因此內部類可以自由地訪問外部類的成員變數，無論是否是private的。
2、成員內部類：形式如下
class Outer {
class Inner{}
}
編譯上述代碼會產生兩個文件：Outer.class和Outer$Inner.class。
3、方法內部類。
顧名思義，把類放在方法內。
class Outer {
public void doSomething(){
class Inner{
public void seeOuter(){
}
}
}
}
A、方法內部類只能在定義該內部類的方法內實例化，不可以在此方法外對其實例化。
B、方法內部類對象不能使用該內部類所在方法的非final局部變數。
因為方法的局部變數位於棧上，只存在於該方法的生命期內。當一個方法結束，其棧結構被刪除，局部變數成為歷史。但是該方法結束之後，在方法內創建的內部類對象可能仍然存在於堆中！例如，如果對它的引用被傳遞到其他某些代碼，並存儲在一個成員變數內。正因為不能保證局部變數的存活期和方法內部類對象的一樣長，所以內部類對象不能使用它們。
下面是完整的例子：
class Outer {
public void doSomething(){
final int a =10;
class Inner{
public void seeOuter(){
System.out.println(a);
}
}
Inner in = new Inner();
in.seeOuter();
}
public static void main(String[] args) {
Outer out = new Outer();
out.doSomething();
}
}
4、匿名內部類。
顧名思義，沒有名字的內部類。表面上看起來它們似乎有名字，實際那不是它們的名字。
A、繼承式的匿名內部類。
class Car {
public void drive(){
System.out.println("Driving a car!");
}
}
class Test{
public static void main(String[] args) {
Car car = new Car(){
public void drive(){
System.out.println("Driving another car!");
}
};
car.drive();
}
}
結果輸出了：Driving another car! Car引用變數不是引用Car對象，而是Car匿名子類的對象。
B、介面式的匿名內部類。
interface Vehicle {
public void drive();
}
class Test{
public static void main(String[] args) {
Vehicle v = new Vehicle(){
public void drive(){
System.out.println("Driving a car!");
}
};
v.drive();
}
}
上面的代碼很怪，好像是在實例化一個介面。事實並非如此，介面式的匿名內部類是實現了一個介面的匿名類。而且只能實現一個介面。
C、參數式的匿名內部類。
class Bar{
void doStuff(Foo f){}
}
interface Foo{
void foo();
}
class Test{
static void go(){
Bar b = new Bar();
b.doStuff(new Foo(){
public void foo(){
System.out.println("foofy");
}
});
}
}
5、靜態嵌套類。
從技術上講，靜態嵌套類不屬於內部類。因為內部類與外部類共享一種特殊關系，更確切地說是對實例的共享關系。而靜態嵌套類則沒有上述關系。它只是位置在另一個類的內部，因此也被稱為頂級嵌套類。
詳細內容請見：http://hi..com/honglin_bd/blog/item/fa60c4d3866f972933fa1c87.html
❻ java裡面的內部類和外部類是什麼_
外部類：
最普通的，我們平時見到的那種類，就是在一個後綴為.java的文件中，直接定義的類
內部類：
內部類，顧名思義，就是包含在外部類中的類，就叫做內部類。內部類有兩種，一種是靜態內部類，一種是非靜態內部類。
靜態內部類和非靜態內部類之間的區別主要如下：
1、內部原理的區別：
靜態內部類是屬於外部類的類成員，是一種靜態的成員，是屬於類的，就有點類似於private static Singleton instance = null；非靜態內部類，是屬於外部類的實例對象的一個實例成員,靜態類則是屬於所有外部共有的，也就是說，每個非靜態內部類，不是屬於外部類的，是屬於外部類的每一個實例的，創建非靜態內部類的實例以後，非靜態內部類實例，是必須跟一個外部類的實例進行關聯和有寄存關系的。
2、創建方式的區別：
創建靜態內部類的實例的時候，只要直接使用「外部類.內部類()」的方式，就可以，比如School.Teacher()；創建非靜態內部類的實例的時候，必須要先創建一個外部類的實例，然後通過外部類的實例，再來創建內部類的實例，new School().Teacher()
通常來說，我們一般都會為了方便，會選擇使用靜態內部類。
❼ 什麼是內部類
內部類的共性
內部類分為: 成員內部類、靜態嵌套類、方法內部類、匿名內部類。 (1)、內部類仍然是一個獨立的類，在編譯之後內部類會被編譯成獨立的.class文件，但是前面冠以外部類的類名和$符號。 (2)、內部類不能用普通的方式訪問。內部類是外部類的一個成員，因此內部類可以自由地訪問外部類的成員變數，無論是否是private的。 (3)、內部類聲明成靜態的，就不能隨便的訪問外部類的成員變數，仍然是只能訪問外部類的靜態成員變數。
編輯本段成員內部類
class Outer { class Inner{} } 編譯上述代碼會產生兩個文件：Outer.class和Outer$Inner.class。
編輯本段方法內部類
把類放在方法內 class Outer { public void doSomething(){ class Inner{ public void seeOuter(){ } } } } (1)、方法內部類只能在定義該內部類的方法內實例化，不可以在此方法外對其實例化。 (2)、方法內部類對象不能使用該內部類所在方法的非final局部變數。 因為方法的局部變數位於棧上，只存在於該方法的生命期內。當一個方法結束，其棧結構被刪除，局部變數成為歷史。但是該方法結束之後，在方法內創建的內部類對象可能仍然存在於堆中！例如，如果對它的引用被傳遞到其他某些代碼，並存儲在一個成員變數內。正因為不能保證局部變數的存活期和方法內部類對象的一樣長，所以內部類對象不能使用它們。 下面是完整的例子： class Outer { public void doSomething(){ final int a =10; class Inner{ public void seeOuter(){ System.out.println(a); } } Inner in = new Inner(); in.seeOuter(); } public static void main(String[] args) { Outer out = new Outer(); out.doSomething(); } }
編輯本段匿名內部類
顧名思義，沒有名字的內部類。表面上看起來它們似乎有名字，實際那不是它們的名字。 匿名內部類就是沒有名字的內部類。什麼情況下需要使用匿名內部類？如果滿足下面的一些條件，使用匿名內部類是比較合適的： ·只用到類的一個實例。 ·類在定義後馬上用到。 ·類非常小（SUN推薦是在4行代碼以下） ·給類命名並不會導致你的代碼更容易被理解。 在使用匿名內部類時，要記住以下幾個原則： ·匿名內部類不能有構造方法。 ·匿名內部類不能定義任何靜態成員、方法和類。 ·匿名內部類不能是public,protected,private,static。 ·只能創建匿名內部類的一個實例。 ·一個匿名內部類一定是在new的後面，用其隱含實現一個介面或實現一個類。 ·因匿名內部類為局部內部類，所以局部內部類的所有限制都對其生效。 A、繼承式的匿名內部類 public class Car { public void drive(){ System.out.println("Driving a car!"); } public static void main(String[] args) { Car car = new Car(){ public void drive() { System.out.println("Driving anther car!"); } }; car.drive(); } } 結果輸出了：Driving another car! Car引用變數不是引用Car對象，而是Car匿名子類的對象。 B、介面式的匿名內部類。 interface Vehicle { public void drive(); } class Test{ public static void main(String[] args) { Vehicle v = new Vehicle(){ public void drive(){ System.out.println("Driving a car!"); } }; v.drive(); } } 上面的代碼很怪，好像是在實例化一個介面。事實並非如此，介面式的匿名內部類是實現了一個介面的匿名類。而且只能實現一個介面。 C、參數式的匿名內部類。 class Bar{ void doStuff(Foo f){} } interface Foo{ void foo(); } class Test{ static void go(){ Bar b = new Bar(); b.doStuff(new Foo(){ public void foo(){ System.out.println("foofy"); } }); } }
編輯本段靜態嵌套類
靜態內部類中可以定義靜態或者非靜態的成員。 從技術上講，靜態嵌套類不屬於內部類。因為內部類與外部類共享一種特殊關系，更確切地說是對實例的共享關系。而靜態嵌套類則沒有上述關系。它只是位置在另一個類的內部，因此也被稱為頂級嵌套類。 靜態的含義是該內部類可以像其他靜態成員一樣，沒有外部類對象時，也能夠訪問它。靜態嵌套類不能訪問外部類的成員和方法。 class Outer{ static class Inner{} } class Test { public static void main(String[] args){ Outer.Inner n = new Outer.Inner(); } }
為什麼需要內部類？
典型的情況是，內部類繼承自某個類或實現某個介面，內部類的代碼操作創建其的外圍類的對象。所以你可以認為內部類提供了某種進入其外圍類的窗口。使用內部類最吸引人的原因是： 每個內部類都能獨立地繼承自一個（介面的）實現，所以無論外圍類是否已經繼承了某個（介面的）實現，對於內部類都沒有影響。如果沒有內部類提供的可以繼承多個具體的或抽象的類的能力，一些設計與編程問題就很難解決。從這個角度看，內部類使得多重繼承的解決方案變得完整。介面解決了部分問題，而內部類有效地實現了「多重繼承」。
❽ java非靜態內部類
1、java的非靜態內部類是怎麼編譯的 ？
publicclassStaticClass{
}
classPerson{
classA{
voidadd(){}
}
}
//classA是一個非靜態內部類，當我們執行javacStaticClass.java的時候，
//會編譯成StaticClass.class、Person.class、Person$A.class三個文件。
//Person$A.class這個類的A就是內部類，用$A區分。2、如果外部類沒有定義內部類對象，系統會不會對他進行內存分配呢？
答：如果定義的這個類沒有內部類的話，不存在extends、implements、static和new的話，就不存在內存分配，當使用這些關鍵字的時候，JVM才會進行內存分配空間，棧、堆。
3、還有就是為什麼非靜態內部類不能定義靜態成員？
答：因為咱們知道調用內部類是用 類名.內部類 xx = new 類名().內部類();來實現對內部類的單獨調用，如果這個內部類定義了靜態成員，那麼意味著就是可以直接類名.內部類.靜態成員，這個是不允許的，不符合java規范。
所以，如果內部類中定義了靜態的成員或靜態方法，那麼這個內部類就必須也定義靜態的內部類。
❾ Java知多少（36）內部類及其實例化
在 Java 中，允許在一個類（或方法、語句塊）的內部定義另一個類，稱為內部類(Inner Class)，有時也稱為嵌套類(Nested Class)。
內部類和外層封裝它的類之間存在邏輯上的所屬關系，一般只用在定義它的類或語句塊之內，實現一些沒有通用意義的功能邏輯，在外部引用它時必須給出完整的名稱。
使用內部類的主要原因有：
內部類可以訪問外部類中的數據，包括私有的數據。
內部類可以對同一個包中的其他類隱藏起來。
當想要定義一個回調函數且不想編寫大量代碼時，使用匿名(anonymous)內部類比較便捷。
減少類的命名沖突。
請看下面的例子：
1 public class Outer {
2 private int size;
3 public class Inner {
4 private int counter = 10;
5 public void doStuff() {
6 size++;
7 }
8 }
9 public static void main(String args[]) {
10 Outer outer = new Outer();
11 Inner inner = outer.new Inner();
12 inner.doStuff();
13 System.out.println(outer.size);
14 System.out.println(inner.counter);
15 // 編譯錯誤，外部類不能訪問內部類的變數
16 System.out.println(counter);
17 }
18 }
這段代碼定義了一個外部類 Outer，它包含了一個內部類 Inner。將錯誤語句注釋掉，編譯，會生成兩個 .class 文件：Outer.class 和 Outer$Inner.class。也就是說，內部類會被編譯成獨立的位元組碼文件。
內部類是一種編譯器現象，與虛擬機無關。編譯器將會把內部類翻譯成用 $ 符號分隔外部類名與內部類名的常規類文件，而虛擬機則對此一無所知。
注意：必須先有外部類的對象才能生成內部類的對象，因為內部類需要訪問外部類中的成員變數，成員變數必須實例化才有意義。
內部類是 Java 1.1 的新增特性，有些程序員認為這是一個值得稱贊的進步，但是內部類的語法很復雜，嚴重破壞了良好的代碼結構， 違背了Java要比C++更加簡單的設計理念。
內部類看似增加了—些優美有趣，實屬沒必要的特性，這是不是也讓Java開始走上了許多語言飽受折磨的毀滅性道路呢？本教程並不打算就這個問題給予一個肯定的答案。