内部类，是在一个类的内部在定义一个新的类，在访问时内部类可以直接访问外部类成员，但是外部类访问内部类时任然要建立内部类对象，通过对象调用。

/*
        内部类：
                就是把类Ｂ定义在类Ａ里面，Ｂ就被称为内部类。

        内部类的位置：
                A:成员位置        -        成员内部类
                B:局部位置        -        局部内部类

        成员内部类：
                如果想在测试类中，直接使用内部类。那么请按照如下格式：
                        外部类名.内部类名 变量 = 外部类对象.内部类对象;
*/
class Outer
{
        private int num = 10;

        class Inner
        {
                public void show()
                {
                        System.out.println(num);
                }
        }

        public void method()
        {
                Inner i = new Inner();
                i.show();
        }
}

class InnerTest
{
        public static void main(String[] args)
        {
                //Outer o = new Outer();
                //o.method();
       
                //我能不能直接使用Inner类呢
                //Inner i = new Inner();
                //i.show();
                //可以用，但是必须加限定。
                //格式：
                //外部类名.内部类名 变量 = 外部类对象.内部类对象;
                Outer.Inner oi = new Outer().new Inner();
                oi.show();
        }
}

外部类没什么好说的，平时使用的类都是外部类，内部类是在外部类中定义的类，可以直接访问外部类中的成员，因为内部类持有了外部类的引用，访问格式：外部类名.this.成员名。而外部类需要访问内部类需要创建内部类的对象。如：class Outer
{
        private static int num = 30;

        class Inner// 内部类。
        {
                void show()
                {
                        System.out.println("show run..."+num);
                }
                /*static void function()//如果内部类中定义了静态成员，该内部类也必须是静态的,即static class Inner()
                {
                        System.out.println("function run ...."+num);
                }
                */
        }

        public void method()
        {
                Inner in = new Inner();
                in.show();
        }
}


class InnerClassDemo
{
        public static void main(String[] args)
        {
                Outer out = new Outer();
                out.method();
                直接访问外部类中的内部类中的成员。
                Outer.Inner in = new Outer().new Inner();
                in.show();


                //如果内部类是静态的。 相当于一个外部类
//                Outer.Inner in = new Outer.Inner();
//                in.show();


                //如果内部类是静态的，成员是静态的。
//                Outer.Inner.function();
               
        }
}

另一种特殊情况：内部类可以存放在局部位置上，内部类在局部位置上只能访问局部中被final修饰的局部变量。
class Outer
{
        int num = 3;
        void method()
        {
                final int x = 9;

                class Inner
                {
                        void show()
                        {
                                System.out.println("show..."+x);
                        }
                }
                Inner in = new Inner();
            in.show();
        }
}
class InnerClassDemo
{
        public static void main(String[] args)
        {
                new Outer().method();
        }
}

内部类
        一个类定义到另一个类的内部.对于内部的这个类就被称为内部类(嵌套类).
特点       
内部类可以直接访问外部类的成员,
                外部类想访问内部类的成员必须创建内部类的对象.
               
内部类分类及使用
        分类:
                成员内部类
                局部内部类
        使用:
                内部类使用格式:
                外部类名.内部类名 变量名 = 外部类对象.内部类对象;
                例如: Outer.Inner oi = new Outer().new Inner();
               
        成员内部类
                        修饰符:
                                private  -- 为了安全.
                               
                                static -- 为了方便
                                调用格式:
                                        外部类名.内部类名 变量名 = new 外部类名.内部类名();
                                        例如:Outer.Inner oi = new Outer.Inner();       
               
        局部内部类:
                局部内部类访问外部类的局部变量,变量就需要加final修饰.
                原因:延长变量的生命周期.
               

内部类作用主要实现功能的隐藏、减少内存开销，提高程序的运行速度




内部类和外部类联系：内部类可以访问外部类所有的方法和属性，如果内部类和外部类有相同的成员方法和成员属性，内部类的成员方法调用要优先于外部类即内部类的优先级比较高（只限于类内部，在主方法内，内部类对象不能访问外部类的成员方法和成员属性），外部类只能访问内部类的静态常量或者通过创建内部类来访问内部类的成员属性和方法

内部类定义的静态常量可以全局访问




创建内部类

第一种方式

假设A是外部类，B是内部类

A a=new A();

A.B b=a.new B();




或者用A类的匿名对象来访问




A.B b=new A().new B();




普通类权限

public和default




而内部类具有四种权限




A.this.name（反射机制创建当前对象）

类优先于字节码文件执行，编译完类才生成字节码文件




字节码文件可以通过反射机制来改变




类中的私有属性可以通过发射机制在类外访问，通过反射机制改变字节码文件中的东西




编译时和运行时




反射机制工作在运行时

静态内部类.

public class StaticInner {
//{
/*static class hello
{
普通代码块内不能定义静态内部类
}*
/
}*/
static
{
class hello
{
//静态代码块内可以定义静态内部类
public void test()
{
System.out.println("it's a inner class");
}
public void practice()//静态代码块内不能定义静态方法
{
System.out.println("it's a demo");
//System.out.println(a);
//method();这两句编译报错，可看出静态内部类不能访问外部类的普通成员和方法
System.out.println(a1);
test1();
//从这两句可以看出，静态内部类只能访问外部类的静态成员和静态方法
}
//从上看出静态内部类可以定义普通方法和静态方法


}
}
private int a;
private void method()
{
System.out.println("hello");
}
private static String a1;
private static void  test1()
{
System.out.println("you can access this method,because it is static");
}
//静态内部类
static class Inner{
public void test()
{
System.out.println("it's a inner class");
}
public static void practice()
{
System.out.println("it's a demo");
//System.out.println(a);
//method();这两句编译报错，可看出静态内部类不能访问外部类的普通成员和方法
System.out.println(a1);
test1();
//从这两句可以看出，静态内部类只能访问外部类的静态成员和静态方法
}
//从上看出静态内部类可以定义普通方法和静态方法

}

}


静态内部类创建对象




StaticInner.Inner inn=new StaticInner.Inner();

这里可以把内部类当做外部类的一个静态成员

局部内部类

定义在方法体内

定义在普通代码块内

实例如下

public class Outer {
private int a;
private void practice()
{
System.out.println("This is a outer class method");
}
public void method()
{
int a1;
final int a2=0;
class inner
{
public void test()
{
//能访问外部类任何属性和方法
System.out.println(a);
practice();
//
// System.out.println(a1);//这句话出现编译错误--报错--不能访问外部类方法中定义的变量
System.out.println(a2);//把变量声明为final常量，final的另一用法
//final 提高局部变量的可见性   声明时需要同时赋值并初始化
}
}
//类的作用范围为这个方法体内，所以对象的创建在这个类声明以后
inner in=new inner();

{
class a{}//代码块中的内部类
}

}
//inner in=new inner();//因为在方法体之外所以报错
//总结：局部内部类具有普通类的功能
//内部类如果访问它所在方法中的局部变量是无法获取的
//解决办法加上final关键字，提高变量的可见性
//局部内部类的对象只能在该方法体的局部创建只能在局部类定义的后面创建对象
}





匿名内部类

出现背景

经常出现在使用其他技术时，出现接口类的情况，此时无法创建接口类型的实现

实例如下

public interface Fruit {
void seed();
void grow();
}


public class Worker {


public void getFruit(Fruit fruit)
{
System.out.println("this is a no name class");
fruit.grow();
fruit.seed();
}
}


public class Test1 {
public static void main(String[] args) {
Worker w=new Worker();
w.getFruit(new Fruit(){


@Override
public void seed() {
// TODO Auto-generated method stub
System.out.println("the seed is planted");

}


@Override
public void grow() {
// TODO Auto-generated method stub
System.out.println("it's growing");

}});
//1.匿名类没有名字
//2.匿名类是一个子类
//3.匿名类用它父类（接口，抽象）当名字，父接口的名字
//4.执行效率奇高
//多用在android开发中

//匿名类实现父类（接口，抽象）中的方法
}

}

/*
内部类：在A类内部中定义另外一个B类，B类则称作为内部类。

注意： 内部类的class文件的命名是： 外部类$内部类.class .   这样子的命名意义主要是为了区分开目前内部类是属于哪个外部类的。

内部类的类型:

        成员内部类:       

                成员内部类的访问方式：
                        方式一： 在外部类提供一个方法用于创建内部类的对象，然后进行访问。
                        方式二：在其他类直接创建内部类的对象。
                                        格式：
                                                        外部类.内部类   变量名  = new 外部类().new 内部类();
               
                内部类的好处： 内部类可以直接访问外部类的任何成员。               
               
                内部类的应用场景：       
                        我们在描述一类A事物的时候，发现该A事物内部还具备另外一个事物B，而且B事物需要用到
                        A事物的一些成员数据，那么这时候B事物我们就可以使用内部类来描述。

                比如：
                        class 人{
                               
                                氧气

                                血液

                                class 心脏{
                                       
                                }
                        }
               
                内部类要注意的事项：
                        1. 如果外部类与内部类存在着同名的成员时，在内部类中默认是访问内部类的成员(就近原则)。
                                如果需要指定访问外部类的成员，可以使用  "外部类.this.成员"格式进行指定访问。
                        2. 如果一个内部类使用了private修饰，那么该内部类就只能在外部类提供 一个方法创建内部类的
                                对象了，在其他类无法再创建该内部类的对象。
                        3. 如果内部出现了静态的成员，那么该内部类也必须使用static修饰.
                               
                        疑问： 为什么内部出现了静态的成员，那么该内部类就必须使用static修饰？？




*/

class Outer
{
        static int x=4;
        static class Inner
        {
                static int x=3;//如果内部类有静态类型,内部类也要用静态修饰.如果想访问到int=4,注释掉这句,外部类指定的成员变量也要变成静态才能访问.
                public  void print(){
                        System.out.println(x);//如果需要访问静态的同名成员变量,改为Outer.x
                }                                                                //为什么不能Outer.this.x?因为this是非静态变量,静态不能访问.
        }
        public void show(){
                Inner i=new Inner();
                i.print();
        }
}
class Demo4
{
        public static void main(String[] args)
        {
                Outer o=new Outer();
                o.show();// 结果为3   把x或者this.x,改为Outer,x 结果为4
        }
}

暂时无法解决你的问题，老师讲这个的时候我也蒙了，但是我又不想回去复习这部分内容:dizzy:

长知识了

我是观看的啦

给你找个内部类怎么调用外部类的方法  你看看吧  网上这个例子看着比较简单


public class B {
int i = 0;
public void e(){
System.out.println("我是外部内的方法");
}
class C{
public void d(){
e();
}
}
public static void main(String[] args) {
new B().new C().d();
}
}

1、内部类可以直接访问外部类成员，包括私有。
2、外部类访问内部类，必须建立内部类对象（内部类非私有）。
     直接访问内部类成员 例：Outer.Inner in = new Outer().newInner();
3、内部类在成员位置上可以被private、static修饰。
4、静态内部类只能访问外部类中被static修饰的成员。
5、直接访问static内部非静态成员：--------- = new Outer.Inner().function();
     直接访问static内部静态成员：Outer.Inner.function
6、内部类定义了静态成员，该内部类必须是静态的，内部类的静态方法访问内部类中的成员也必须是静态的。
7、匿名内部类的前提是，内部类必须继承一个类或实现接口。
     匿名内部类格式：new 父类或者接口（）{定义子类的内容}；

内部类可以使用外部类的所有方法与变量，外部类方法通过new 内部类对象来使用内部类的方法。

果断来学习，不解释

1.内部类可以直接访问外部类中的成员，包括私有
  之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式：外部类名。this
2.外部类要访问内部类，必须建立内部类对象

访问格式：
1.当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。
可以直接建立内部类对象
格式：
  外部类名.内部类名 变量名= 外部类对象.内部类对象；
   Outer.Inner in = new Outer().new Inner();
2.当内部类在成员位置上，就可以被成员修饰符所修饰
   比如，private 将内部类在外部类中进行封装
        static 内部类就具备了static的特性
        当内部类被static修饰后，只能直接访问外部类的static成员，出现了访问局限
       
        在外部其他类中，如何直接访问static内部类的非静态成员呢？
        new Outer.Inner().function();

        在外部其他类中，如何直接访问static内部类的静态成员呢？
        outer.Inner.function();

   注意：当内部类中定义了静态成员，该内部类必须是static的
        当外部类中的静态方法访问内部类时，内部类也必须是静态方法

内部类可以直接访问外部类中的所有成员，包括私有的。
而外部类要想访问内部类中的成员，必须创建内部类的对象

当内部类定义在在外部类类成员位置上，非私有，可以在外部其他类中直接访问可以被成员修饰符修饰
当内部类定义在局部位置时不可以被成员修饰符修饰，访问他的局部变量时只能访问被final修饰的局部变量
外部类名.内部类名.变量名=外部类对象.内部类对象
Other.Inner in=new Other().new Inner();
在外部类中直接调用非静态方法
new Other.Inner().function()
在外部类中直接调用静态方法
Other.Inner.function()

内部类作用主要实现功能的隐藏、减少内存开销，提高程序的运行速度

内部类和外部类联系：内部类可以访问外部类所有的方法和属性，如果内部类和外部类有相同的成员方法和成员属性，内部类的成员方法调用要优先于外部类即内部类的优先级比较高（只限于类内部，在主方法内，内部类对象不能访问外部类的成员方法和成员属性），外部类只能访问内部类的静态常量或者通过创建内部类来访问内部类的成员属性和方法
内部类定义的静态常量可以全局访问

创建内部类
第一种方式
假设A是外部类，B是内部类
A a=new A();
A.B b=a.new B();

或者用A类的匿名对象来访问

A.B b=new A().new B();

普通类权限
public和default

而内部类具有四种权限

A.this.name（反射机制创建当前对象）
类优先于字节码文件执行，编译完类才生成字节码文件

字节码文件可以通过反射机制来改变

类中的私有属性可以通过发射机制在类外访问，通过反射机制改变字节码文件中的东西

编译时和运行时

反射机制工作在运行时
静态内部类.
public class StaticInner {
//{
/*static class hello
{
普通代码块内不能定义静态内部类
}*
/
}*/
static
{
class hello
{
//静态代码块内可以定义静态内部类
public void test()
{
System.out.println("it's a inner class");
}
public void practice()//静态代码块内不能定义静态方法
{
System.out.println("it's a demo");
//System.out.println(a);
//method();这两句编译报错，可看出静态内部类不能访问外部类的普通成员和方法
System.out.println(a1);
test1();
//从这两句可以看出，静态内部类只能访问外部类的静态成员和静态方法
}
//从上看出静态内部类可以定义普通方法和静态方法


}
}
private int a;
private void method()
{
System.out.println("hello");
}
private static String a1;
private static void  test1()
{
System.out.println("you can access this method,because it is static");
}
//静态内部类
static class Inner{
public void test()
{
System.out.println("it's a inner class");
}
public static void practice()
{
System.out.println("it's a demo");
//System.out.println(a);
//method();这两句编译报错，可看出静态内部类不能访问外部类的普通成员和方法
System.out.println(a1);
test1();
//从这两句可以看出，静态内部类只能访问外部类的静态成员和静态方法
}
//从上看出静态内部类可以定义普通方法和静态方法

}

}
静态内部类创建对象

StaticInner.Inner inn=new StaticInner.Inner();
这里可以把内部类当做外部类的一个静态成员
局部内部类
定义在方法体内
定义在普通代码块内
实例如下
public class Outer {
private int a;
private void practice()
{
System.out.println("This is a outer class method");
}
public void method()
{
int a1;
final int a2=0;
class inner
{
public void test()
{
//能访问外部类任何属性和方法
System.out.println(a);
practice();
//
// System.out.println(a1);//这句话出现编译错误--报错--不能访问外部类方法中定义的变量
System.out.println(a2);//把变量声明为final常量，final的另一用法
//final 提高局部变量的可见性   声明时需要同时赋值并初始化
}
}
//类的作用范围为这个方法体内，所以对象的创建在这个类声明以后
inner in=new inner();
{
class a{}//代码块中的内部类
}

}
//inner in=new inner();//因为在方法体之外所以报错
//总结：局部内部类具有普通类的功能
//内部类如果访问它所在方法中的局部变量是无法获取的
//解决办法加上final关键字，提高变量的可见性
//局部内部类的对象只能在该方法体的局部创建只能在局部类定义的后面创建对象
}

匿名内部类
出现背景
经常出现在使用其他技术时，出现接口类的情况，此时无法创建接口类型的实现
实例如下
public interface Fruit {
void seed();
void grow();
}
public class Worker {


public void getFruit(Fruit fruit)
{
System.out.println("this is a no name class");
fruit.grow();
fruit.seed();
}
}
public class Test1 {
public static void main(String[] args) {
Worker w=new Worker();
w.getFruit(new Fruit(){


@Override
public void seed() {
// TODO Auto-generated method stub
System.out.println("the seed is planted");

}


@Override
public void grow() {
// TODO Auto-generated method stub
System.out.println("it's growing");

}});
//1.匿名类没有名字
//2.匿名类是一个子类
//3.匿名类用它父类（接口，抽象）当名字，父接口的名字
//4.执行效率奇高
//多用在android开发中
//匿名类实现父类（接口，抽象）中的方法
}

}
//总结在代码中写了，有错请批评指出，谢谢哈

看我的帖子，我写了一些总结

内部类    在类里又定义了一个类
1 内部类可以直接访问外部类中的成员，包括私有，之所以可以是因为内部类中持有了外部类的引用，格式 外部类名.this.参数名默认省略的；
2 外部类要访问内部类 ，必须建立内部类对象
注意：当内部类中定义了静态成员，该内部类也必须是静态的
当外部类中的静态成员访问内部类时，内部类也必须是静态的

class  Outer{
private int x=3;
class Inter
{
void function(){
Ststem.out.println("inner"+Outer.this.x);
}
}//外部类访问内部类
void method(){

Inter in =new Inter();
in.function();}
}
classInterclass{
public static void mian(String[]args){
Outer.Inter.in=new Outer().new Inter();
in.function();//直接访问内部类成员
}

}
内部类定义在局部时 不可以被成员修饰符修饰 可以直接访问 外部类中的成员，因为还持有外部类中的医用 但是不能访问它所在局部中的变量。只能访问被final修饰的局部变量。
class Outer{

int x=3;
void method(final int a){
final int y=4;
class Innter{
void function(){

System.out.println(a)
}
}
new Innter().functon();
}

}
class Innterclass{


public  static void mian(String[] args){
Outer out=new Outer();
out.method(7);
out.method(8);}
}
0112
//因为所有的类都是object的子类所以下面的写法是可行的
class InnerTest{
public static void main(String[] args）{
new object(){
public void function(){
System.out.println("nihao ");}

}.function;

}

}

外部类访问内部类，先new一个外部类对象，然后再通过外部类对象new一个内部类：new OuterClass().new InnerClass()；外部类访问内部类的成员或方法：new OuterClass().new InnerClass().innerFeild;或者new OuterClass().new InnerClass().innerMethod()；内部类访问外部类的成员变量或方法通过内部类对象直接访问：new InnerClass().outerFeild;或者new InnerClass().outerMethod();