Ⅰ 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[])
{
// 通過Outer.Inner創建內部類的實例，並調用它的print方法
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 主方法怎麼調用內部類的方法
System.out.println(x);//這個是55
System.out.println(In.x);//這個是9
樓主這兩行是對的，樓上是不用兄弟認為人家這兒錯了？
1，後面那個是無法做到的那個x是方法 的局部變數，在進入方法時被推到棧里，方法結束後就出棧了。除非有方式可以跑一個在主方法中的線程監控當前棧中變數，就像是Debug一樣，我也研究好久這個，不過沒發現有。
2，
也像1一樣沒有侵入性，你可以用位元組碼框架去操作類，動態地改變方法的行為，也就是說你可以在main方法中用程序語言去改變doit(x)方法里所做的事情。
3，
再侵入點兒，你可以傳進那個doit(int)方法一個Callback, 你明白我意思？給你看個回調式：
public class HelloJava{
private interface Listener{
public void listenDoit(int x);
}
private static int x=55;
private class In{
private Listener listener;
private static final int x=9;
public In(Listener listener){this.listener=listener;}
public void doit(int x){
listener.listenDoit(x);
x=6;//這個X和上一行的應該是同一個吧？怎麼在主方法里輸出這個量？
listener.listenDoit(x);
HelloJava.this.x++;
}
}
public static void main(String[] args){
System.out.println(x);//這個是55
System.out.println(In.x);//這個是9
In in =new HelloJava().new In(new Listener(){
@Override
public void listenDoit(int x) {
System.out.println(x);
}});
in.doit(0);
System.out.println(x);//這個是55
System.out.println(In.x);//這個是10
}
}
還有許多方式可以做到，比如代理模式等等，不過都大同小異。該方法好處是不改變方法的原定義模型。如返回值從void改成int，如果doit的返回值本身就是String,要返回個其他的東西，怎麼去改變返回值完成？
另外運行一下會發現最後兩行輸出不是55
10，
而是56，
9，你就知道HelloJava.this.x++;做的是什麼了。
4，然後就是樓上朋友們都說的方式，返回值。
Ⅲ java內部類如何被外部引用
將public去掉，則默認為friendly，即友元。
而在同一個包中的友元中的類是可以被引用的。
Ⅳ java 內部類 能被外部使用嗎
1、內部類是指在一個外部類的內部再定義一個類。類名不需要和文件夾相同。
2、內部類可以是靜態static的，也可用public，default，protected和private修飾。（而外部頂級類即類名和文件名相同的只能使用public和default）。
3、內部類是一個編譯時的概念，一旦編譯成功，就會成為完全不同的兩類。對於一個名為outer的外部類和其內部定義的名為inner的內部類。編譯完成後出現outer.class和outer$inner.class兩類。 所以內部類的成員變數/方法名可以和外部類的相同。
4、內部類具有：成員內部類、局部內部類、嵌套內部類、匿名內部類。
以下以成員內部類示例：
成員內部類，就是作為外部類的成員，可以直接使用外部類的所有成員和方法，即使是private的。同時外部類要訪問內部類的所有成員變數/方法，則需要通過內部類的對象來獲取。
要注意的是，成員內部類不能含有static的變數和方法。 因為成員內部類需要先創建了外部類，才能創建它自己的 ，了解這一點，就可以明白更多事情，在此省略更多的細節了。
在成員內部類要引用外部類對象時，使用outer.this來表示外部類對象；
而需要創建內部類對象，可以使用outer.inner obj = outerobj.new inner();
示例代碼：
public class Outer {
public static void main(String[] args) {
Outer outer = new Outer();
Outer.Inner inner = outer. new Inner();
inner.print( "Outer.new" );
inner = outer.getInner();
inner.print( "Outer.get" );
}
public Inner getInner() {
return new Inner();
}
public class Inner {
public void print(String str) {
System.out.println(str);
}
}
}
Ⅳ 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外部類怎麼調用內部類的方法
首先，你要搞清楚靜態方法跟非靜態方法的區別：
非靜態方法是跟隨著類的生命周期的，當類實例化時，非靜態方法跟隨著實例化對象產生，實例化對象可以調用類中的非靜態方法，當實例化對象結束時，非靜態方法也跟著結束。就是說，非靜態方法是依附於實例化對象的，它的生命周期就是實例化對象的生命周期。
靜態方法是不受制於類的實例化對象的，即靜態方法從程序開始運行到最後釋放內存結束是一直存在的，它的生命周期就是程序的生命周期。
從以上可知，靜態方法調用非靜態方法會造成一個問題，就是生命周期的不一致，比如說：程序剛剛開始運行時，類的實例化構造函數還沒有執行，這時靜態方法是調用不了非靜態方法的；或者當實例化對象消亡之後，靜態方法也是不能夠去調用非靜態方法的。
靜態方法要想調用非靜態方法，必須要通過實例化對象去調用；當然也可以把非靜態方法變成靜態方法，這樣就不存在任何障礙了。
希望我的回答對你能夠有所幫助。
Ⅶ java外部類main方法調用內部類
main方法是主函數，是程序的入口，調用內部類，首先需要它的外部類，然後才可以獲得。
Ⅷ java外部類怎樣調用內部類方法
你這裡面有兩個錯：
1、Leis內部類是非靜態類，不能在靜態方法里初始化，即第三行Leis x=new Leis();報錯，可以把Leis類改成靜態類，即
public static class Leis{
......
}
2、Leis()是Leis類的構造函數，不能在第4行x.Leis()顯示調用
一句話：靜態方法里不能訪問非靜態內部類。但你可以在外部類的一個成員方法里訪問非靜態內部類，然後你再在靜態方法里初始化外部類，通過外部類來訪問非靜態內部類。