内部类全面了解

格式： 

public class A类{
   修饰符 class B类{
   }
   }

  注意点：
  1.内部类可以直接访问外部类成员，包括私有
  2.外部类要访问内部类成员必须要创建对象

根据内部类在类中定义的位置，分为：
1.在类的成员位置：成员内部类
2.在类的局部位置：局部内部类

成员内部类
成员内部类，外界如何创建对象使用：
格式：
    外部类名.内部类名 对象名=外部类对象.内部类对象；
    范例：Outer.lnner oi =new Outer().new lnner();

实例：

public class OuterClass {
	innerClass in = new innerClass(); // 在外部类实例化内部类对象引用
	
	public void ouf() {
		in.inf(); // 在外部类方法中调用内部类方法
	}
	
	class innerClass {
		innerClass() { // 内部类构造方法
		}
		
		public void inf() { // 内部类成员方法
		}
		
		int y = 0; // 定义内部类成员变量
	}
	
	public innerClass doit() { // 外部类方法，返回值为内部类引用
		// y=4; //外部类不可以直接访问内部类成员变量
		in.y = 4;
		return new innerClass(); // 返回内部类引用
	}
	
	public static void main(String args[]) {
		OuterClass out = new OuterClass();
		// 内部类的对象实例化操作必须在外部类或外部类中的非静态方法中实现
		OuterClass.innerClass in = out.doit();
		OuterClass.innerClass in2 = out.new innerClass();
	}
}

public class text内部类 {
    public static void main(String[] args) {
        outerclass.innerclass oi=out.new innerclass();
    }

}

内部类向上转型为接口
 

package com.lzw;

interface OutInterface { // 定义一个接口
    public void f();
}

public class InterfaceInner {
    public static void main(String args[]) {
        OuterClass2 out = new OuterClass2(); // 实例化一个OuterClass2对象
        // 调用doit()方法，返回一个OutInterface接口
        OutInterface outinter = out.doit();
        outinter.f(); // 调用f()方法
    }
}

class OuterClass2 {
    // 定义一个内部类实现OutInterface接口
    private class InnerClass implements OutInterface {
        InnerClass(String s) { // 内部类构造方法
            System.out.println(s);
        }
        
        public void f() { // 实现接口中的f()方法
            System.out.println("访问内部类中的f()方法");
        }
    }
    
    public OutInterface doit() { // 定义一个方法，返回值类型为OutInterface接口
        return new InnerClass("访问内部类构造方法");
    }
}

使用this关键字获取内部类与外部类的引用

public class TheSameName {
	private int x;
	
	private class Inner {
		private int x = 9;
		public void doit(int x) {
			x++; // 调用的是形参x
			this.x++; // 调用内部类的变量x
			TheSameName.this.x++; // 调用外部类的变量x
		}
	}
}

局部内部类

public class text12 {
    private int num =1250;
    public void method(){
        class inner{
        public void show(){
            System.out.println(num);
        }}
        inner i=new inner();
        i.show();
    }
}

public class text内部类 {
    public static void main(String[] args) {
      text12 io=new text12();
      io.method();
    }
}

局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用该类可以直接访问外部类成员，也可以访问方法内的局部变量

匿名内部类（归属于局部内部类）

前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类
new 类名或者接口（）{
}；
范例：
new inter(){
    public void show(){
    }
}
本质：
    是一个继承了该类或者实现了该接口的子类匿名对象

public interface inter {
    void show();
}

public class text12 {
    public void method(){
        new inter(){
        public void show(){
            System.out.println("这是一个匿名内部类");
        }
        }.show();
    }
}
//也可以是
public class text12 {
    public void method(){
        inter i=new inter(){
        public void show(){
            System.out.println("这是一个匿名内部类");
        }
        }
    i.show();
    }
}

public class text内部类 {
    public static void main(String[] args) {
      text12 io=new text12();
      io.method();
    }
}