一、静态内部类的创建需要依赖外部类

二、非静态内部类

三、如何在成员内部类中区分调用外部类结构

四、开发当中，局部内部类的使用 

五、 内部类的示例

六、总结

简介 

内部类：
java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B为外部类

内部类分类：成员内部类（静态，非静态） VS 局部内部类（方法内，代码块内，构造器内）

调用非静态外部结构：Person.this.eat();

 1 成员内部类：

    一方面：作为外部类的成员
          》调用外部类的结构
          》可被static修饰
          》可以被4种不同的权限修饰
          
    另一方面：作为一个类
          》类内部可以定义属性，方法，构造器等
          》可以被final修饰，表示此类不能被继承，言外之意不使用final、修饰可以被继承
          
          》可以被abstract修饰
          

  2 局部内部类：不能写任何权限修饰符 

 

1.   因为局部成员的作用域是所在方法，其他程序单元永远不可能访问另一个方法中的局部变量，所以所有的局部成员都不能使用访问控制修饰符修饰。
2.   局部内部类访问包含他的方法中的变量必须有final修饰； java8如果局部内部类中使用到变量默认final可以省略不写
3.   如果局部内部类访问外部类的变量不用定义为final的，只有在访问包含他的方法中的变量需要定义为final

          
关注一下三问题
   1 如何实例化成员内部类
             //静态成员内部类创建
        Outer.InnerStatic innerStatic = new Outer.InnerStatic();
        innerStatic.show();
        //非静态成员内部类创建
        Outer.Inner inner = new Outer().new Inner();
        inner.sing();
   2 如何在成员内部类中区分调用外部类结构
            System.out.println(name); 形参
            System.out.println(this.name);内部类的属性
            System.out.println(Outer.this.name);外部类的属性
   3 开发当中，局部内部类的使用
    //局部内部类
    public Comparable getComparable() {   
        //方式一，显示实现类
       // 方式二 匿名内部类

       //创建一个实现Comparable接口的局部内部类
        class MyComparable implements Comparable {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        } return new MyComparable();
    }
   

一、静态内部类的创建需要依赖外部类

Out.Ind j=new Out.Ind();

//静态成员内部类创建
Outer.InnerStatic innerStatic = new Outer.InnerStatic();
innerStatic.show();

二、非静态内部类

Outside in=new Outside();

//在通过外部类对象创建一个内部类对象

Outside.Indoor oi = in.new Indoor();

Outer.Inner inner = new Outer().new Inner();
inner.sing();
System.out.println();
inner.display("AA");

三、如何在成员内部类中区分调用外部类结构

Outer.this.eat(); //调用外部方法
System.out.println(name); 形参
System.out.println(this.name);内部类的属性
System.out.println(Outer.this.name);外部类的属性

四、开发当中，局部内部类的使用 

//局部内部类
    public Comparable getComparable() {

        //创建一个实现Comparable接口的局部内部类
        //方式一，显示实现类
       // 方式二 匿名内部类
        class MyComparable implements Comparable {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }

        return new MyComparable();
    }

五、 内部类的示例

public class Outer {

    String name = "小明" ;
    int age;
    String  salary = "200";

    public void eat() {
        System.out.println("吃饭");
    }

    public static void main(String[] args) {
        //静态成员内部类创建
        Outer.InnerStatic innerStatic = new Outer.InnerStatic();
        innerStatic.show();
        System.out.println();
        //非静态成员内部类创建
        Outer.Inner inner = new Outer().new Inner();
        inner.sing();
        System.out.println();
        inner.display("AA");
    }

    static class InnerStatic {
        String  name ;
        int age;

        public void show() {
            System.out.println("卡巴是条狗");

        }
    }

    class Inner {

        String name="杜鹃";
        int age;

        public void sing() {
            System.out.println("我是一只小小鸟");
            Outer.this.eat(); //调用外部方法
        }

        public void display(String name) {
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(Outer.this.name);
            salary  = "aaa";
            System.out.println(salary);
        }


    }



    //局部内部类
    public Comparable getComparable() {

        //创建一个实现Comparable接口的局部内部类
        //方式一，显示实现类
       // 方式二 匿名内部类
      class MyComparable implements Comparable {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }

        return new MyComparable();
    }

    public void hello () {
        String name  = "小鸟" ;

        class Bird {

            public void say () {
                salary ="bbb";
//                name = "ccc";  方法中name 被默认是定义为final 这里编译会报错
                System.out.println(salary);// 成员变量没有必要定义为final
                System.out.println(name);
            }
        }
    }
}

六、总结

不管是静态内部类还是非静态内部类都需要先new 外部的类。然后用外部的去直接点静态内部类或者 点new 非静态内部类

文章原地址：https://www.cnblogs.com/runnigwolf/p/5570810.html

Java编写代码过程中遇到了一个问题，main方法中创建内部类的实例时，编译阶段出现错误，查看错误描述

No enclosing instance of type NoUseThreadDemo is accessible. Must qualify the allocation with an enclosing instance of type NoUseThreadDemo (e.g. x.new A() where x is an instance of NoUseThreadDemo).

参考文章：

Multiple markers at this line
 - The value of the local variable test is not used
 - No enclosing instance of type StaticCallDynamic is accessible. Must qualify the allocation with an enclosing instance of type StaticCallDynamic (e.g. 
  x.new A() where x is an instance of StaticCallDynamic).

经过查证，是因为内部类是动态的（无static关键字修饰），而main方法是静态的，普通的内部类对象隐含地保存了一个引用，指向创建它的外围类对象，所以要在static方法（类加载时已经初始化）调用内部类的必须先创建外部类。即应该这样创建“DanymicTest test = new StaticCallDynamic().new DanymicTest();”其中StaticCallDynamic为外部类，DanymicTest为内部动态类；如果将内部内修改为静态类，可以在main中直接创建内部类实例。

　　顺便看了下静态方法对动态方法的调用，如果在静态方法中直接调用动态方法，其中print()为类中的动态方法，会出现如下问题：

Cannot make a static reference to the non-static method print() from the type StaticCallDynamic

　　这个要从java的内存机制去分析，首先当你New 一个对象的时候，并不是先在堆中为对象开辟内存空间，而是先将类中的静态方法（带有static修饰的静态函数）的代码加载到一个叫做方法区的地方，然后再在堆内存中创建对象。所以说静态方法会随着类的加载而被加载。当你new一个对象时，该对象存在于堆内存中，this关键字一般指该对象，但是如果没有new对象，而是通过类名调用该类的静态方法也可以。

　　程序最终都是在内存中执行，变量只有在内存中占有一席之地时才会被访问，类的静态成员（变态和方法）属于类本身，在类加载的时候就会分配内存，可以通过类名直接去访问，非静态成员（变量和方法）属于类的对象，所以只有在类的对象产生（创建实例）的时候才会分配内存，然后通过类的对象去访问。在一个类的静态成员中去访问非静态成员之所以会出错是因为在类的非静态成员不存在的时候静态成员就已经存在了，访问一个内存中不存在的东西当然会出错。

　　所以要么将方法也改为静态方法，要么通过创建该方法所在的实例再通过实例来调用。

外部类调用非静态内部类的的方法

我们知道，一个类的内部类里面的方法，是不可以被直接调用的。但是如果我们想使用内部中的方法，我们应该怎么做呢？

第一种办法

public class test{
	public static void main(String[] args) {
	 Outer.inner p=new Outer().new inner(); // new 一个内部类inner的对象
	 p.show();                              //我们要注意对象p是无法直接调用Outer类里面的方法的
	 //Outer p1=new Outer();
     //p1.test();
 }
}
 class Outer{
	 int sum;
	 class inner{
		 public void show(){
			 System.out.println("这是内部类的方法");
		 }
	 }
	 public void test(){
		 System.out.println("这是外部类的方法");
	 }
 }

第二种办法

public class test{
	public static void main(String[] args) {
		Outer o=new Outer(); //让外部类的方法调用test方法调用内部类里面的show方法
		o.test();
	
 }
}
 class Outer{
	 int sum;
	 class Inner{
		 public void show(){
			 System.out.println("这是内部类的方法");
		 }
	 }
	 public void test(){      //在外部类中new一个内部类的对象，调用内部类中的方法
		 Inner i=new Inner();
		 i.show();
	 }
 }