在Java中内部类的访问形式和内部类的作用分别是什么？

一.这个程序的目的是为了了解内部类的访问规则。


内部类的访问规则：
1.内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引


用，格式 外部类名.this
2.外部类要访问内部类，必须建立内部类对象。
3.外部类访问内部类的两种方式：
 （1).在外部类中创建调用内部类的函数。
 （2).直接通过new外部类.new内部类。
Outer.Inner1 in = new Outer().new Inner1(); 可以用来生成内部类的对象，这种方法存在两个小知识点需要注意


1).开头的Out是为了标明需要生成的内部类对象在哪个外部类当中


2).必须先有外部类的对象才能生成内部类的对象，因为内部类的作用就是为了访问外部类中的成员变量






package com.saiermeng;


class Outer{      //外部类
private int x = 3;
class Inner1{        //内部类
void function(){
System.out.println("inner1:"+Outer.this.x);
}
}
void method(){
Inner1 in = new Inner1();
in.function();                 //外部类访问内部类，必须要建立内部类对象

}
}


public class InnerClassDemo0 {
public static void main(String[] args){
Outer out = new Outer();    //调用外部类方法
out.method();
Outer.Inner1 in = new Outer().new Inner1();  //要调用内部类的对象首先先要拿到外部类
in.function();             //调用内部类方法
}


}
运行的结果是：
inner1:3
inner1:3


    
二.这个程序的目的是外部类如何访问内部类的静态成员和非静态成员(这个内部类定义在外部类的成员位置上)


访问格式：
1.当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。
可以直接建立内部类对象。
格式
外部类名.内部类名  变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();


2.当内部类在成员位置上，就可以被成员修饰符所修饰。
比如，private：将内部类在外部类中进行封装。
static:内部类就具备static的特性。
当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。


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


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


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


当描述事物时，事物的内部还有事物，该事物用内部类来描述。
因为内部事务在使用外部事物的内容。


package com.saiermeng;


class Outer22{
private static int x = 3;
static class Inner22{
static void function(){
System.out.println("inner:"+x);
}
}
class Inner23{
void show(){
System.out.println("inner23 show");
}
}
public static void method(){
Inner22.function();
}

}


public class InnerClassDemo22 {
public static void main(String [] args){
Outer22.method();
Outer22.Inner22.function();
Outer22.Inner23 in = new Outer22().new Inner23();
in.show();
}


}
运行的结果是：
inner:3
inner:3
inner23 show




三.局部位置上的内部类
package com.saiermeng;


/*
内部类定义在局部时，
1.不可以被成员修饰符修饰 。成员修饰符有：private,public,protected
2.可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
*/
class OuterLei
{
private int x = 3;


void method(final int a)
{
final int y = 4;
class Inner
{
void function()
{
System.out.println(y+"  "+x+"  "+a);//x是直接访问的，y是通过final修饰才可以被访问
}
}

new Inner().function();

}
}




class  InnerClassDemo3
{
public static void main(String[] args) 
{
OuterLei out = new OuterLei();
out.method(7);
out.method(8);
}


}
运行的结果是：
4  3  7
4  3  8


四.内部类中的变量访问形式


class Out {
    private int age = 12;
     
    class In {
        private int age = 13;
        public void print() {
            int age = 14;
            System.out.println("局部变量：" + age);
            System.out.println("内部类变量：" + this.age);
            System.out.println("外部类变量：" + Out.this.age);
        }
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Out.In in = new Out().new In();
        in.print();
    }
}
运行结果：
局部变量：14
内部类变量：13
外部类变量：12






五.内部类其实严重破坏了良好的代码结构，但为什么还要使用内部类呢？


因为内部类可以随意使用外部类的成员变量（包括私有）而不用生成外部类的对象，这也是内部类的唯一优点