㈠ 关于java中内部类引用外部类的问题代码如下
因为你使用system.out.println这个方法输出个对象的时候，因为只能输出字符串，所以系统就会默认调用类中的toStringf方法，因为这个方法是源自object类的，所以几乎所有的类都有这个方法。而你的代码重写了这个方法，所以输出的时候就调用了这个方法，然后按你的规则进行了输出。
比如
publicclassTest{
publicTest(){}
publicvoidtoString(){
System.out.println("----test------");
}
//假设:Testtest=newTest();
//System.out.println(test);
//输出的结果就是"----test------"
}
㈡ java 中为什么引用外部类的变量和方法都要是final内型 的
Thinking In Java里面的说法（唯一正确的说法）： 如果定义一个匿名内部类，并且希望它使用一个在其外部定的对象，那么编译器会要求其参数引用是final 的。以下是分析过程：
首先看代码
publicclassTester{
publicstaticvoidmain(String[]args){
Aa=newA();
Cc=newC();
c.shoutc(a.shout(5));
}
}
////////////////////////////////////////////////////////
classA{
publicvoidshouta(){
System.out.println("HelloA");
}
publicAshout(finalintarg){
classBextendsA{
publicvoidshouta(){
System.out.println("HelloB"+arg);
}
}
returnnewB();
}
}
////////////////////////////////////////////////////////
classC{
voidshoutc(Aa){
a.shouta();
}
}
第5行c.shoutc(a.shout(5))，在a.shout(5)得到返回值后，a的shout()方法栈被清空了，即arg不存在了，而c.shoutc()却又调用了a.shouta()去执行System.out.println("Hello B" + arg)。
再来看Java虚拟机是怎么实现这个诡异的访问的：有人认为这种访问之所以能完成，是因为arg是final的，由于变量的生命周期，事实是这样的吗？方法栈都不存在了，变量即使存在，怎么可能还被访问到？试想下：一个方法能访问另一个方法的定义的final局部变量吗(不通过返回值)？
研究一下这个诡异的访问执行的原理，用反射探测一下局部内部类 。编译器会探测局部内部类中是否有直接使用外部定义变量的情况，如果有访问就会定义一个同类型的变量，然后在构造方法中用外部变量给自己定义的变量赋值，而后局部内部类所使用的变量都是自己定义的变量，所以就可以访问了。见下：
classA$1$B
{
A$1$B(A,int);
privatefinalintvar$arg;
privatefinalAthis$0;
}
A$1$B类型的对象会使用自定义的var$arg变量，而不是shout()方法中的final int arg变量，当然就可以访问了。
那么为什么外部变量要是final的呢？即使外部变量不是final，编译器也可以如此处理：自己定义一个同类型的变量，然后在构造方法中赋值就行了。原因就是为了让我们能够挺合逻辑的直接使用外部变量，而且看起来是在始终使用外部的arg变量(而不是赋值以后的自己的字段)。
考虑出现这种情况：在局部内部类中使用外部变量arg，如果编译器允许arg不是final的，那么就可以对这个变量作变值操作（例如arg++），根据前面的分析，变值操作改变的是var$arg，而外部的变量arg并没有变，仍然是5(var$arg才是6)。因此为了避免这样如此不合逻辑的事情发生：你用了外部变量，又改变了变量的值，但那个变量却没有变化，自然的arg就被强行规定必须是final所修饰的，以确保让两个值永远一样，或所指向的对象永远一样（后者可能更重要)。
还有一点需要注意的是内部类与方法不是同时执行的，比如实现ActionListener，只有当事件发生的时候才会执行，而这时方法已经结束了。
㈢ 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();
}
}
㈣ android java的类中类怎么调用外部类的方法
成员内部类可以无条件地访问外部类的成员，而外部类想访问成员内部类的成员却不是这么随心所欲了。在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问：
classCircle{//外部类
privatedoubleradius=0;
publicCircle(doubleradius){
this.radius=radius;
getDrawInstance().drawSahpe();//必须先创建成员内部类的对象，再进行访问
}
privateDrawgetDrawInstance(){//初始化内部类，以便可以访问
returnnewDraw();
}
classDraw{//内部类
publicvoiddrawSahpe(){
System.out.println(radius);//外部类的private成员
}
}
}
㈤ java里面的内部类和外部类是什么_
外部类：
最普通的，我们平时见到的那种类，就是在一个后缀为.java的文件中，直接定义的类
内部类：
内部类，顾名思义，就是包含在外部类中的类，就叫做内部类。内部类有两种，一种是静态内部类，一种是非静态内部类。
静态内部类和非静态内部类之间的区别主要如下：
1、内部原理的区别：
静态内部类是属于外部类的类成员，是一种静态的成员，是属于类的，就有点类似于private static Singleton instance = null；非静态内部类，是属于外部类的实例对象的一个实例成员,静态类则是属于所有外部共有的，也就是说，每个非静态内部类，不是属于外部类的，是属于外部类的每一个实例的，创建非静态内部类的实例以后，非静态内部类实例，是必须跟一个外部类的实例进行关联和有寄存关系的。
2、创建方式的区别：
创建静态内部类的实例的时候，只要直接使用“外部类.内部类()”的方式，就可以，比如School.Teacher()；创建非静态内部类的实例的时候，必须要先创建一个外部类的实例，然后通过外部类的实例，再来创建内部类的实例，new School().Teacher()
通常来说，我们一般都会为了方便，会选择使用静态内部类。
㈥ java内部类如何被外部引用
将public去掉，则默认为friendly，即友元。
而在同一个包中的友元中的类是可以被引用的。
㈦ java 请问非静态类为什么持有外部类的引用
非静态内部类依赖于外部类，没有外部类就不能创建内部类，内部类可以直接访问外部类的属性，包括私有属性
㈧ Java内部类怎么直接调用外部类啊
publicclassOuter{
intx;
Strings="hello";
publicvoidtest(){
System.out.print("test");
}
publicclassInner{
ints=20;
publicvoidtestInner(){
//可以直接使用外部类的成员变量和成员方法
x=0;
test();
//如果外部类的成员变量和内部类变量重名，可以这样调用外部类的变量
Outer.this.s="test";
//当然你可以new外部类对象这也是没问题的
Outero=newOuter();
o.x=30;
o.test();
}
}
}
㈨ Java内部类怎么直接调用外部类啊
在内部类中创建外部类对象 在调用
㈩ java类引用的问题
1.类之间不能调用各自的私有方法；
2.一个类只能直接调用另一个类的public static方法；
3.一个类只能在new出另一个类的时候才能调用它的public方法；
4.一个类要调用另一个类的方法时，2个类必须在同一个包中，不在同一个包的话需要import包；
5.只有子类可以调用父类的protect方法；
6.子类不可以调用抽象父类的抽象方法（需要重写）；
7.匿名内部类中的方法无法被其他类调用；
暂时想到这么多。