㈠ java 內部類如何被外部類調用
服了你了，能把程序寫成這樣。一個java文件里可以有多個類，但只能有一個public類，而且這個類必須是外部類，不能是內部類。而且你在Test里實例化inner的方法也不對，inner的類型始終是Outer.Inner，不會因為Outer實例化而變成outer.Inner，只不過編譯器還沒有報出那裡的錯誤而已。寫成這樣：
class Outer{
private int size=10;
class Inner{
public void doStuff(){
System.out.println(++size);
}
}
}
public class Test{
public static void main(String [] args){
Outer outer=new Outer();
Outer.Inner inner=outer.new Inner();
inner.doStuff();
}
}
㈡ JAVA基礎知識，關於outer和inner的。
這個是個變數名,for裡面的數代表,outer = 0從0開始循環,outer++每循環一次加1,outer<3 如果outer不小於3,則循環終止.
for(int outer = 0;outer<3;outer++){
循環了3次
for(int inner = 4;inner>1;inner--){
循環了3次
㈢ java裡面outer、 inner是什麼意思
outerinner分別指的是循環的外層內層，可以認為是一個名字吧，要跳出的時候可以直接用比如breakouter，跳出外層循環，也可以代表內部類和外部類：
packageFFtest2;
publicclassFFOuter{
privateStringfirst;
privateintsecond;
publicFFOuter(Stringl,intr){
first=l;
second=r;
}
publicStringaddStringInteger(Stringfirst,intsecond){
returnfirst+Integer.toString(second);
}
/**
*test1
*
*
*/
publicvoidoutterPrint(){
FFOuter.InnerDisplaytemp=this.newInnerDisplay("frog",20);
System.out.println("OuterclassusesInnerclassfield:"+temp.innerFirst+","+temp.innerSecond);
temp.print(first,second);
}
privateclassInnerDisplay{
privateStringinnerFirst;
privateintinnerSecond;
publicInnerDisplay(){
this("Somebody",0);
}
publicInnerDisplay(Strings,inti){
innerFirst=s;
innerSecond=i;
}
publicvoidprint(Stringf,ints){
System.out.println("Innerclass:first="+f+",second="+s);
}
/**
*test2
*
*/
publicvoidprint(){
System.out.println("Innerclassusesouterclass:first="+first+",second="+second);
}
/**
*test3
*.
*/
publicStringadd(Stringfirst,intsecond)
{
returnaddStringInteger(first,second);
}
}
publicstaticvoidmain(String[]args){
/**
*test4
*inmain(),callouttermethod
**/
FFOuteroutter=newFFOuter("zebra",25);
outter.outterPrint();
/**
*test5
*inmain(),callinnermethod
*/
InnerDisplayinnerDisplay=outter.newInnerDisplay();
innerDisplay.print();
System.out.println(innerDisplay.add("iphone",10));
}
}
輸出結果
OuterclassusesInnerclassfield:frog,20
Innerclass:first=zebra,second=25
Innerclassusesouterclass:first=zebra,second=25
iphone10
㈣ Java中的outer和inner的用法
Java中的outer，基本上用於當嵌套for循環時，如果使用break，用於跳出循環體，以防止死循環。
Java中Inner Class可以在一個類中把邏輯意義相同的部分放在一起，便於管理。
Outer Class 的成員函數可以像訪問其他類一樣來訪問Inner Class（來自thinking in java），除此之外，必須用OutClass.InnerClass的形式訪問Inner Class（例如main函數）。
public class Parcel {
class Destination{
private String label;
public Destination(String whereTo){
this.label = whereTo;
}
String readLabel(){
return label;
}
}
public Destination to(String s){
return new Destination(s);
}
public void ship(String dest){
Destination d = to(dest);
System.out.println(d.readLabel());
}
public static void main(String[] args){
Parcel p = new Parcel();
p.ship("Beijing");
Parcel q = new Parcel();
Parcel.Destination d = q.to("ShangHai");
System.out.println(d.readLabel());
}
}
㈤ JAVA，這個開始的outer：沒用的吧！是標志用的吧！
break outter裡面的outter是你的程序段標志，你的break outter是直接跳轉到那裡執行，這個outter可以用其它的詞來代替，但是用outter可以給人較直觀的提示，不過這種方法現在已經不提倡了，這種跳轉會使程序員對程序的理解產生偏差，最好能使用方法來代替
㈥ 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中報錯,未定意的標簽什麼意思下面是我寫的程序；麻煩高人指點，就是outer那！！
你應該放到循環裡面，你放到循環外面了
import java.util.*;
class Bank
{
public static void main(String[] args)
{
Clients c[] = new Clients[4];
c[0] = new Clients();
c[1] = new Clients();
c[2] = new Clients();
c[3] = new Clients();
init (c[0],"於淼",1111,1111,10000);
init (c[1],"呂鵬飛",2222,2222,20000);
init (c[2],"張根瑞",3333,3333,30000);
init (c[3],"高原",4444,4444,40000);
System.out.println("**歡迎來到中國建設銀行**");
System.out.println("*請輸入您的卡號*");
Scanner s = new Scanner(System.in);
int zh = s.nextInt();
int i;
outer:for(i = 0 ; i<4 ; i++)
{
if(zh == c[i].ID)
{
System.out.println("*請輸入您的密碼*");
Scanner a = new Scanner(System.in);
int mm = a.nextInt();
boolean flag = true;
while(flag)
{
if(mm == c[i].pwd)
{
System.out.println("查看余額請輸入1");
System.out.println("存款請輸入2");
System.out.println("取款請輸入3");
System.out.println("推出請輸入0");
Scanner b = new Scanner(System.in);
int shu = b.nextInt();
switch (shu)
{
case 1:
c[i].print();
break;
case 2:
c[i].saveM();
break;
case 3:
c[i].drawM();
break;
case 0:
flag = false;
break;
}
}
else
{
System.out.println("您的密碼有誤，請重新輸入！");
}
}
}
if(i == 4)
{
System.out.println("沒有該賬號，請重新輸入！");
continue outer;
}
}
}
static void init(Clients t,String n,int i,int p,int m)
{
t.name = n;
t.ID = i;
t.pwd = p;
t.money = m;
}
}
class Clients
{
String name;
int ID;
int pwd;
int money;
void print()
{
System.out.println(name+",您的賬戶余額為"+money+"元.");
}
void saveM()
{
System.out.println("請輸入你要儲存的金額數：");
Scanner s = new Scanner(System.in);
int m = s.nextInt();
money += m;
}
void drawM()
{
System.out.println("請輸入您要取的金額數：");
Scanner s = new Scanner(System.in);
int m = s.nextInt();
if(m > money)
{
System.out.println("您的余額不足");
}
else
{
money -=m;
}
}
}
㈧ java裡面的內部類和外部類是什麼_
外部類：
最普通的，我們平時見到的那種類，就是在一個後綴為.java的文件中，直接定義的類
內部類：
內部類，顧名思義，就是包含在外部類中的類，就叫做內部類。內部類有兩種，一種是靜態內部類，一種是非靜態內部類。
靜態內部類和非靜態內部類之間的區別主要如下：
1、內部原理的區別：
靜態內部類是屬於外部類的類成員，是一種靜態的成員，是屬於類的，就有點類似於private static Singleton instance = null；非靜態內部類，是屬於外部類的實例對象的一個實例成員,靜態類則是屬於所有外部共有的，也就是說，每個非靜態內部類，不是屬於外部類的，是屬於外部類的每一個實例的，創建非靜態內部類的實例以後，非靜態內部類實例，是必須跟一個外部類的實例進行關聯和有寄存關系的。
2、創建方式的區別：
創建靜態內部類的實例的時候，只要直接使用「外部類.內部類()」的方式，就可以，比如School.Teacher()；創建非靜態內部類的實例的時候，必須要先創建一個外部類的實例，然後通過外部類的實例，再來創建內部類的實例，new School().Teacher()
通常來說，我們一般都會為了方便，會選擇使用靜態內部類。
㈨ 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里outer和inter標簽用法！！！
java只有標簽的用法，至於標簽是outer 或inter還是其他字母都隨意
for(int i = 0; i <10; i++){
while(true){
break; //這句後會進入下一個for循環
}
}
而加上標簽
outer: for(int i = 0; i <10; i++){
while(true){
break outer; //這句會跳出for循環
}
}