A. 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);
}
};
B. 怎麼調用靜態方法
靜態方法不能訪問非靜態的實例變數和實例方法。實例方法可以訪問靜態成員和非靜態成員。
1在本來中直接調用靜態方法
2可以通過類名來調用該類的靜態方法
3通過實例調用靜態方法
// 外部類，不能是靜態的
public class OuterClass {
// 靜態方法，又稱為類方法，屬於Test類
public static void staticFun() {
}
// 非靜態方法，又稱為實例方法，屬於Test類的具體實例
public void nonStaticFun() {
}
// 靜態內部類，靜態類只能是內部類
public static class StaticInnerClass {
// 靜態方法，屬於StaticInnerClass類
public static void staticFun() {
}
// 非靜態方法，屬於StaticInnerClass類的實例
public void nonStaticFun() {
}
}
// 非靜態內部類，不能有靜態方法
public class NonStaticInnerClass {
// 非靜態方法，屬於NonStaticInnerClass的實例
public void nonStaticFun() {
}
}
// 測試代碼如下：
public static void main(String[] args) {
// 對於靜態方法，使用類直接訪問
OuterClass.staticFun();
StaticInnerClass.staticFun();
// 對於非靜態方法，需要使用類的實例訪問
new OuterClass().nonStaticFun();
new StaticInnerClass().nonStaticFun();
// 對於非靜態內部類，必須創建外部類後才能使用
OuterClass outerClass = new OuterClass();
NonStaticInnerClass nonStaticInnerClass = outerClass.new NonStaticInnerClass();
nonStaticInnerClass.nonStaticFun();
}
}
C. java涓 main錛堬級鏂規硶涓涓轟粈涔堜笉鑳絥ew 鍐呴儴綾
1.棣栧厛浣犵殑鍐呴儴綾諱笉鏄闈欐佺殑瀵瑰惂(涓嶆槸static class)銆
2.鑰宮ain鏂規硶鏄闈欐佺殑銆
3.main 鏂規硶鏄涓闈欐佹柟娉曪紝鑰 闈欐 綾諱笉鏄涓闈欐佸唴閮ㄧ被錛屾墍浠ヤ笉鑳界洿鎺ュ垵濮嬪寲銆
瀵筸ain鏂規硶鑰岃█錛岃櫧鐒跺啓鍦ㄧ被涓錛屽畠鏄娓哥諱簬浠諱綍綾諱箣澶栫殑(灝辮窡C++涓鏍鳳紝鍗曠嫭涓涓猰ain鏂規硶)錛屽洜姝ゆ煇綾葷殑闈為潤鎬佸唴閮ㄧ被瀵瑰畠鑰岃█鏄涓嶇洿鎺ュ彲瑙佺殑錛屼篃灝辨棤娉曠洿鎺ヨ塊棶
D. 濡備綍鍦ㄥ栭儴瀹炰緥鍖栫佹湁闈欐佸唴閮ㄧ被
class T1 {
class T2 {
public T2() {
System.out.println("T2");
}
}
static class T3 {
public T3() {
System.out.println("T3");
}
}
private static class T4 {
public T4() {
System.out.println("T4");
}
}
public static void main(String args[]) {
//瀹炰緥鍖栧唴閮ㄧ被T4,
//鍥犱負鍐呴儴綾籘4鏄痯rivate鐨勶紝鎵浠ヤ笉鍙琚鍏朵粬綾昏塊棶錛岃嚜鐒朵笉鑳藉湪鍏朵粬綾諱腑new鍑烘潵
T4 t4 = new T1.T4();
}
}
public class A {
public static void main(String args[]) {
//瀹炰緥鍖栧唴閮ㄧ被T2
T1 t1 = new T1();
T1.T2 t2 = t1.new T2();
//瀹炰緥鍖栧唴閮ㄧ被T3
T1.T3 t3 = new T1.T3();
}
}
E. 濡備綍鐞嗚В澶栭儴鍏朵粬綾昏塊棶闈欐佸唴閮ㄧ被涓鐨勬柟娉昻ew outer.inner().function();
/*
static鍏抽敭瀛椾慨楗板唴閮ㄧ被
*/
classOuter
{
//瀹氫箟涓涓澶栭儴綾葷殑鎴愬憳鍙橀噺
privateintnum=10;
//瀹氫箟涓涓澶栭儴綾葷殑鎴愬憳鍑芥暟
publicvoidshow()
{
Outer.Innerin=newOuter.Inner();
//鎵撳嵃鍐呴儴綾葷殑鎴愬憳鍙橀噺鐨勫
System.out.println("num1="+in.num1);
in.method();
}
//涔﹀啓鍦ㄥ栭儴綾繪垚鍛樹綅緗涓婄殑鍐呴儴綾
/*
鍐呴儴綾昏玸tatic淇楗板悗,闅忕潃Outer綾誨姞杞藉埌鍐呭瓨錛
琚玸tatic淇楗扮殑鍐呴儴綾諱篃浼氬姞杞藉埌鍐呭瓨涓錛屼篃灝辨槸璇磈vm浼氬皢紜鐩樹笂鐨凮uter.class鍜
Outer$Inner.class鏂囦歡涓璧峰姞杞藉埌鍐呭瓨涓錛岃繖鏍峰彲浠ユ妸涓涓闈欐佸唴閮ㄧ被鐞嗚В涓轟竴涓
鍜屽栭儴綾諱竴鏍風殑綾伙紝涓嶉渶瑕佸栭儴綾葷殑瀵硅薄鏉ヨ皟鐢ㄣ
濡傛灉鎯寵佸壋寤洪潤鎬佸唴閮ㄧ被鐨勫硅薄錛屽洜涓哄凡緇忚鍔犺澆鍒板唴瀛樹腑錛岄殢鏃跺彲浠ュ壋寤洪潤鎬佸唴閮ㄧ被鐨勫硅薄
*/
staticclassInner
{
//瀹氫箟涓涓鍐呴儴綾葷殑鎴愬憳鍙橀噺
intnum1=100;
//瀹氫箟涓涓鍐呴儴綾葷殑鎴愬憳鍑芥暟
publicvoidmethod()
{
//鎵撳嵃鍐呴儴綾葷殑鎴愬憳鍙橀噺鐨勫
System.out.println("num1="+num1);
}
}
}
//瀹氫箟涓涓嫻嬭瘯綾
classInnerClassDemo2
{
publicstaticvoidmain(String[]args)
{
/*
鎯寵佷嬌鐢ㄥ唴閮ㄧ被涓鐨勯潪闈欐佹柟娉曪紝鎴戜滑棣栧厛
瑕佸壋寤哄唴閮ㄧ被鐨勫硅薄錛岄偅涔堟庝箞鍒涘緩鍐呴儴綾葷殑瀵硅薄鍛錛
鍥犱負鍐呴儴綾繪槸闈欐佺殑錛屾墍浠ヤ笉闇瑕佸壋寤篛uter鐨勫硅薄錛屽彧闇瑕佹牴鎹鍐呴儴綾葷殑鍚嶅瓧
鍒涘緩灝卞彲浠
*/
Outer.Innerin=newOuter.Inner();
in.method();
}
}
/*
鎬葷粨錛
濡傛灉鎴戜滑鎯寵佸湪鍏朵粬綾諱腑璋冪敤鍐呴儴綾諱腑鐨勪竴鑸鍑芥暟(闈為潤鎬佸嚱鏁)錛屽繀欏昏佷嬌鐢ㄥ唴閮ㄧ被鐨勫硅薄鏉ヨ皟鐢錛屾墍浠ユ垜浠瑕佸壋寤哄唴閮ㄧ被鐨勫硅薄錛屽壋寤烘柟寮忥細
new鍐呴儴綾葷被鍚();--------->newOuter.Inner();
*/
F. Java如何調用內部類的方法
參閱下段： 《內部類》
內部類是指在一個外部類的內部再定義一個類。內部類作為外部類的一個成員，並且依附於外部類而存在的。內部類可為靜態，可用protected和private修飾（而外部類只能使用public和預設的包訪問許可權）。內部類主要有以下幾類：成員內部類、局部內部類、靜態內部類、匿名內部類
為什麼需要內部類？
典型的情況是，內部類繼承自某個類或實現某個介面，內部類的代碼操作創建其的外圍類的對象。所以你可以認為內部類提供了某種進入其外圍類的窗口。使用內部類最吸引人的原因是：
每個內部類都能獨立地繼承自一個（介面的）實現，所以無論外圍類是否已經繼承了某個（介面的）實現，對於內部類都沒有影響。如果沒有內部類提供的可以繼承多個具體的或抽象的類的能力，一些設計與編程問題就很難解決。從這個角度看，內部類使得多重繼承的解決方案變得完整。介面解決了部分問題，而內部類有效地實現了「多重繼承」。
A：成員內部類
作為外部類的一個成員存在，與外部類的屬性、方法並列。
publicclass Outer {
privatestaticinti = 1;
privateintj = 10;
privateintk = 20;
publicstaticvoidouter_f1() {
}
publicvoidouter_f2() {
}
// 成員內部類中，不能定義靜態成員
// 成員內部類中，可以訪問外部類的所有成員
class Inner {
// static int inner_i = 100;//內部類中不允許定義靜態變數
intj = 100; // 內部類和外部類的實例變數可以共存
intinner_i = 1;
void inner_f1() {
System.out.println(i);
//在內部類中訪問內部類自己的變數直接用變數名
System.out.println(j);
//在內部類中訪問內部類自己的變數也可以用this.變數名
System.out.println(this.j);
//在內部類中訪問外部類中與內部類同名的實例變數用外部類名.this.變數名
System.out.println(Outer.this.j);
//如果內部類中沒有與外部類同名的變數，則可以直接用變數名訪問外部類變數
System.out.println(k);
outer_f1();
outer_f2();
}
}
//外部類的非靜態方法訪問成員內部類
publicvoidouter_f3() {
Inner inner = new Inner();
inner.inner_f1();
}
// 外部類的靜態方法訪問成員內部類，與在外部類外部訪問成員內部類一樣
publicstaticvoidouter_f4() {
//step1 建立外部類對象
Outer out = new Outer();
//step2 根據外部類對象建立內部類對象
Inner inner = out.new Inner();
//step3 訪問內部類的方法
inner.inner_f1();
}
publicstaticvoid main(String[] args) {
//outer_f4();//該語句的輸出結果和下面三條語句的輸出結果一樣
//如果要直接創建內部類的對象，不能想當然地認為只需加上外圍類Outer的名字，
//就可以按照通常的樣子生成內部類的對象，而是必須使用此外圍類的一個對象來
//創建其內部類的一個對象：
//Outer.Inner outin = out.new Inner()
//因此，除非你已經有了外圍類的一個對象，否則不可能生成內部類的對象。因為此
//內部類的對象會悄悄地鏈接到創建它的外圍類的對象。如果你用的是靜態的內部類，
//那就不需要對其外圍類對象的引用。
Outer out = new Outer();
Outer.Inner outin = out.new Inner();
outin.inner_f1();
}
}
注意：內部類是一個編譯時的概念，一旦編譯成功，就會成為完全不同的兩類。對於一個名為outer的外部類和其內部定義的名為inner的內部類。編譯完成後出現outer.class和outer$inner.class兩類。
B:局部內部類
在方法中定義的內部類稱為局部內部類。與局部變數類似，局部內部類不能有訪問說明符，因為它不是外圍類的一部分，但是它可以訪問當前代碼塊內的常量，和此外圍類所有的成員。
publicclass Outer {
privateints = 100;
privateintout_i = 1;
publicvoid f(finalint k) {
finalint s = 200;
int i = 1;
finalint j = 10;
//定義在方法內部
class Inner {
ints = 300;// 可以定義與外部類同名的變數
// static int m = 20;//不可以定義靜態變數
Inner(int k) {
inner_f(k);
}
intinner_i = 100;
voidinner_f(int k) {
//如果內部類沒有與外部類同名的變數，在內部類中可以直接訪問外部類的實例變數
System.out.println(out_i);
//可以訪問外部類的局部變數(即方法內的變數)，但是變數必須是final的
System.out.println(j);
//System.out.println(i);
//如果內部類中有與外部類同名的變數，直接用變數名訪問的是內部類的變數
System.out.println(s);
//用this.變數名訪問的也是內部類變數
System.out.println(this.s);
//用外部類名.this.內部類變數名訪問的是外部類變數
System.out.println(Outer.this.s);
}
}
new Inner(k);
}
publicstaticvoid main(String[] args) {
// 訪問局部內部類必須先有外部類對象
Outer out = new Outer();
out.f(3);
}
}
C：靜態內部類(嵌套類)：（注意：前兩種內部類與變數類似，所以可以對照參考變數）
如果你不需要內部類對象與其外圍類對象之間有聯系，那你可以將內部類聲明為static。這通常稱為嵌套類（nested class）。想要理解static應用於內部類時的含義，你就必須記住，普通的內部類對象隱含地保存了一個引用，指向創建它的外圍類對象。然而，當內部類是static的時，就不是這樣了。嵌套類意味著：
1. 要創建嵌套類的對象，並不需要其外圍類的對象。
2. 不能從嵌套類的對象中訪問非靜態的外圍類對象。
publicclass Outer {
privatestaticinti = 1;
privateintj = 10;
publicstaticvoidouter_f1() {
}
publicvoidouter_f2() {
}
// 靜態內部類可以用public,protected,private修飾
// 靜態內部類中可以定義靜態或者非靜態的成員
staticclass Inner {
staticintinner_i = 100;
intinner_j = 200;
staticvoidinner_f1() {
//靜態內部類只能訪問外部類的靜態成員(包括靜態變數和靜態方法)
System.out.println("Outer.i" + i);
outer_f1();
}
voidinner_f2() {
// 靜態內部類不能訪問外部類的非靜態成員(包括非靜態變數和非靜態方法)
// System.out.println("Outer.i"+j);
// outer_f2();
}
}
publicvoidouter_f3() {
// 外部類訪問內部類的靜態成員：內部類.靜態成員
System.out.println(Inner.inner_i);
Inner.inner_f1();
// 外部類訪問內部類的非靜態成員:實例化內部類即可
Inner inner = new Inner();
inner.inner_f2();
}
publicstaticvoid main(String[] args) {
newOuter().outer_f3();
}
}
生成一個靜態內部類不需要外部類成員：這是靜態內部類和成員內部類的區別。靜態內部類的對象可以直接生成：Outer.Inner in = new Outer.Inner();而不需要通過生成外部類對象來生成。這樣實際上使靜態內部類成為了一個頂級類(正常情況下，你不能在介面內部放置任何代碼，但嵌套類可以作為介面的一部分，因為它是static 的。只是將嵌套類置於介面的命名空間內，這並不違反介面的規則）