java內部類對象

1. java中怎樣獲取內部類對象

解決方法如下：
public class PrivateClassTest {

class A{
private int aa=90;
public int bb=70;
}
public static void main(String[] args) {
System.out.println(new PrivateClassTest().new A().aa);
System.out.println(new PrivateClassTest().new A().bb);
}
}

2. Java 靜態內部類作用

1、變值許可權修飾作用，在定義內部類的時候，可以在其前面加上一個許可權修飾符static。此時這個內部類就變為了靜態內部類。

2、在某些特殊的情況下，少了這個靜態內部類還真是不行。如在進行代碼程序測試的時候，如果在每一個Java源文件中都設置一個主方法(主方法是某個應用程序的入口，必須具有)，那麼會出現很多額外的代碼。

3、最主要的時這段主程序的代碼對於Java文件來說，只是一個形式，其本身並不需要這種主方法。但是少了這個主方法又是萬萬不行的。在這種情況下，就可以將主方法寫入到靜態內部類中，從而不用為每個Java源文件都設置一個類似的主方法。

這對於代碼測試是非常有用的。在一些中大型的應用程序開發中，則是一個常用的技術手段。

(2)java內部類對象擴展閱讀

例如：

對於兩個類，擁有相同的方法：

class People{

run();

}

interface Machine{

run();

}

此時有一個robot類：

class Robot extends People implement Machine.

此時run()不可直接實現。

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");

}

}

public void run(){

System.out.println("Robot run");

}

Machine.getMachine(){returnnew MachineHeart();

}

class Test{

publicstaticvoid main(String[] args){

Robot robot=new Robot();

Machine m=robot.getMachine();

m.run();

robot.run();

}

}

3. Java里什麼叫內部類什麼叫外部類

對普通類（沒有內部類的類）來說，內部類和外部類都與他無關；對有內部類的類來說，它們就是其內部類的外部類，外部類是個相對的說法，其實就是有內部類的類。
所以，要回答這個問題，只需要講解內部類是什麼：
Java中的內部類共分為四種：
靜態內部類static inner class (also called nested class)
成員內部類member inner class
局部內部類local inner class
匿名內部類anonymous inner class

靜態內部類Static Inner Class
最簡單的內部類形式。
類定義時加上static關鍵字。
不能和外部類有相同的名字。
被編譯成一個完全獨立的.class文件，名稱為OuterClass$InnerClass.class的形式。
只可以訪問外部類的靜態成員和靜態方法，包括了私有的靜態成員和方法。
生成靜態內部類對象的方式為：
OuterClass.InnerClass inner = new OuterClass.InnerClass();
示例代碼：
package com.learnjava.innerclass;
class StaticInner
{
private static int a = 4;
// 靜態內部類
public static class Inner
{
public void test()
{
// 靜態內部類可以訪問外部類的靜態成員
// 並且它只能訪問靜態的
System.out.println(a);
}
}
}
public class StaticInnerClassTest
{
public static void main(String[] args)
{
StaticInner.Inner inner = new StaticInner.Inner();
inner.test();
}
}

成員內部類Member Inner Class
成員內部類也是定義在另一個類中，但是定義時不用static修飾。
成員內部類和靜態內部類可以類比為非靜態的成員變數和靜態的成員變數。
成員內部類就像一個實例變數。
它可以訪問它的外部類的所有成員變數和方法，不管是靜態的還是非靜態的都可以。
在外部類裡面創建成員內部類的實例：
this.new Innerclass();
在外部類之外創建內部類的實例：
(new Outerclass()).new Innerclass();
在內部類里訪問外部類的成員：
Outerclass.this.member
示例代碼：
package com.learnjava.innerclass;
class MemberInner
{
private int d = 1;
private int a = 2;
// 定義一個成員內部類
public class Inner2
{
private int a = 8;
public void doSomething()
{
// 直接訪問外部類對象
System.out.println(d);
System.out.println(a);// 直接訪問a，則訪問的是內部類里的a
// 如何訪問到外部類里的a呢？
System.out.println(MemberInner.this.a);
}
}
}
public class MemberInnerClassTest
{
public static void main(String[] args)
{
// 創建成員內部類的對象
// 需要先創建外部類的實例
MemberInner.Inner2 inner = new MemberInner().new Inner2();
inner.doSomething();
}
}

局部內部類Local Inner Class
局部內部類定義在方法中，比方法的范圍還小。是內部類中最少用到的一種類型。
像局部變數一樣，不能被public, protected, private和static修飾。
只能訪問方法中定義的final類型的局部變數。
局部內部類在方法中定義，所以只能在方法中使用，即只能在方法當中生成局部內部類的實例並且調用其方法。
示例代碼：
package com.learnjava.innerclass;
class LocalInner
{
int a = 1;
public void doSomething()
{
int b = 2;
final int c = 3;
// 定義一個局部內部類
class Inner3
{
public void test()
{
System.out.println("Hello World");
System.out.println(a);
// 不可以訪問非final的局部變數
// error: Cannot refer to a non-final variable b inside an inner
// class defined in a different method
// System.out.println(b);
// 可以訪問final變數
System.out.println(c);
}
}
// 創建局部內部類的實例並調用方法
new Inner3().test();
}
}
public class LocalInnerClassTest
{
public static void main(String[] args)
{
// 創建外部類對象
LocalInner inner = new LocalInner();
// 調用外部類的方法
inner.doSomething();
}

}

匿名內部類Anonymous Inner Class
匿名內部類就是沒有名字的局部內部類，不使用關鍵字class, extends, implements, 沒有構造方法。
匿名內部類隱式地繼承了一個父類或者實現了一個介面。
匿名內部類使用得比較多，通常是作為一個方法參數。
生成的.class文件中，匿名類會生成OuterClass$1.class文件，數字根據是第幾個匿名類而類推。
示例代碼：
package com.learnjava.innerclass;
import java.util.Date;
public class AnonymouseInnerClass
{
@SuppressWarnings("deprecation")
public String getDate(Date date)
{
return date.toLocaleString();
}
public static void main(String[] args)
{
AnonymouseInnerClass test = new AnonymouseInnerClass();
// 列印日期：
String str = test.getDate(new Date());
System.out.println(str);
System.out.println("----------------");
// 使用匿名內部類
String str2 = test.getDate(new Date()
{
});// 使用了花括弧，但是不填入內容，執行結果和上面的完全一致
// 生成了一個繼承了Date類的子類的對象
System.out.println(str2);
System.out.println("----------------");
// 使用匿名內部類，並且重寫父類中的方法
String str3 = test.getDate(new Date()
{
// 重寫父類中的方法
@Override
@Deprecated
public String toLocaleString()
{
return "Hello: " + super.toLocaleString();
}
});
System.out.println(str3);
}
}

4. java為什麼要用內部類

1.內部類能訪問外圍類的所有成員，包括私有成員。

當生成一個內部類對象時，此對象與製造它的外圍類對象之間就有了一種聯系，所以它能訪問其外圍類對象的所有成員，而不需要任何特殊的條件。如下面代碼所示：

[java]view plain

• classOutterClass{

• privateinti=1;

• classInnerClass{

• publicvoiddisplayPrivate(){

• System.out.println(i);

• }

• }

• }

• publicclassMainClass{

• publicstaticvoidmain(String[]args){

• OutterClassoutter=newOutterClass();

• OutterClass.InnerClassinner=outter.newInnerClass();

• inner.displayPrivate();

• }

• }

由上面的代碼可以看出，內部類能夠訪問外部類的私有成員變數。在這段代碼中，還需要注意的是

①生成內部類對象，必須要先有外圍類對象，具體的做法請見代碼；

②內部類能訪問外圍類的私有成員這一點，C++中的嵌套類是沒有這個特性的。

2.內部類與static

①內部類不能含有static方法；

②內部類不能含有static數據成員，除非是static final；

③內部類可以繼承含有static成員的類。


3.匿名內部類

匿名內部類，看起來非常奇怪。因為它太簡潔了，但這也帶來一個好處，用匿名內部類寫出來的代碼通常比較簡潔啦！

5. java 內部類的對象怎樣創建

public class InnerClass {
class A{
A(){
System.out.println("A class");
}
A getInstance() {
System.out.println("return a new A");
return new A();
}
}
public static void main(String[] args)
{
System.out.println("closing class ");
InnerClass innerClass=new InnerClass();
InnerClass.A a=innerClass.new A();
a=a.getInstance();
//如果上面沒有創建外部類對象，那麼就不能這樣
//A a =new A();這是因為在沒有創建外部類對象的時候，不能創建內部類對象（這個情況除了嵌套類之外），構建內部類的對象時，需要指向一個外部類對象的引用。

}
}

6. 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成員
匿名內部類：定義類的最終目的是創建一個類的實例，但是如果某個類的實例只是用一次，則可以將類的定義與類的創建，放到與一起完成，或者說在定義類的同時就創建一個類。以這種方法定義的沒有名字的類成為匿名內部類。

7. java有幾種內部類,分別舉一個例子,並且創建一個對象.

成員內部類
class Outer {

class Inner{}

}

編譯上述代碼會產生兩個文件：Outer.class和Outer$Inner.class。

方法內部類
class Outer {

public void doSomething(){

class Inner{

public void seeOuter(){

}

}

}

}

(1)、方法內部類只能在定義該內部類的方法內實例化，不可以在此方法外對其實例化。

(2)、方法內部類對象不能使用該內部類所在方法的非final局部變數。

匿名內部類
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();

}

}

8. java內部類的方法內部類

把類放在方法內
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();
}
}