㈠ 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循环
}
}