JAVA内部类 （成员内部类、局部内部类、匿名内部类、静态内部类、内部类的继承））

成员内部类

1.成员内部类简介

package cn.com.inner;
/**
* 成员内部类<br>
* 使用方式：OuterClass.InnerClass
* @author wutz
*
*/
public class OuterClass {       //外部类
InnerClass inner = new InnerClass();

private class InnerClass{       //内部类
int y = 0;                  //内部类成员变量
InnerClass(){               //内部类构造函数
}
public void innerFunction(){    //内部类成员函数
System.out.println("调用内部类的方法");
}
}

public InnerClass getInsatnceOfInnerClass(){   //外部类操作内部类的属性
//y = 4;
inner.y = 100;
inner.innerFunction();
return inner;
}

public static void main(String[] args) {
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner1 = outer.getInsatnceOfInnerClass();
System.out.println(inner1.y);
System.out.println("********************");
OuterClass.InnerClass inner2 = outer.new InnerClass();
System.out.println(inner2.y);
inner2.innerFunction();
}
}

console:
调用内部类的方法
100
********************
0
调用内部类的方法

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

package cn.com.inner;
/**
* 通过this获取外部类内部类的引用
* @author wutz
*
*/
public class TheSameName {

private int x;

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

public static void main(String[] args) {
TheSameName outClass = new TheSameName();
TheSameName.Inner inner = outClass.new Inner();
inner.doit(100);
}
}

console:
101
10
1

局部内部类

局部内部类是指在类的方法中定义内部类，它的作用范围也是在这个方法体内

package cn.com.inner;

/**
* 局部内部类<br>
* 定义在方法内的类，作用方法仅限该方法
* @author wutz
*
*/
public class SellOutClass {

private String name;
public SellOutClass(){
name = "苹果";
}

public void sell(){
class Apple{
int innerPrice = 0;
public Apple(int price){
innerPrice = price;
}
public void price(){
System.out.println("现在开始销售:"+name);
System.out.println("价格:"+innerPrice);
}
}

Apple apple = new Apple(100);
apple.price();
}

public static void main(String[] args) {
SellOutClass outClass = new SellOutClass();
outClass.sell();
}
}

console：
现在开始销售:苹果
价格:100

匿名内部类

在编写程序代码时，不一定要给内部类取一个名字，可以直接以对象名来代替。匿名内部类的所有实现代码都需要在大括号之间进行编写。

package cn.com.inner;
/**
* 服务于匿名内部类
* @author wutz
*
*/
public interface OuterString {

public String filterBlankChar();
}

package cn.com.inner;
/**
* 匿名内部类
* @author wutz
*
*/
public class OutString{

public static void main(String[] args) {
final String sourceStr = "h e l l o w o r d";
OuterString outString = new OuterString() {

@Override
public String filterBlankChar() {
return sourceStr.replaceAll(" ","");
}
};

System.out.println("源字符串：" + sourceStr);
System.out.println("转换后的字符串：" +outString.filterBlankChar());

}
}

console:
源字符串：h e l l o w o r d
转换后的字符串：helloword

静态内部类

在内部类前添加修饰符static，这个内部类就变成静态内部类。一个静态内部类中可以声明static成员，但是在非静态内部类中不可以声明静态成员。静态内部类有一个最大的特点，就是不可以使用外部类的非静态成员。所以静态内部类在程序开发中比较少见。

静态内部类具有以下两个特点：

1.创建静态内部类的对象，不需要先创建外部类对象。

2.不能从静态内部类的对象中访问非静态外部类的对象。

package cn.com.inner;
/**
* 静态内部类1
* @author wutz
*
*/
public class StaticInnerClass {

private static int x = 0;

static class InnerClass{
static void doInner() {
System.out.println(x);
}
}

public static void main(String[] args) {
StaticInnerClass.InnerClass b = new StaticInnerClass.InnerClass();
b.doInner();

}
}

package cn.com.inner;
/**
* 静态内部类2
* @author wutz
*
*/
public class StaticInnerClass {

private static int x = 0;

static class InnerClass{
static void doInner() {
System.out.println(x);
}
public static void main(String[] args) {
doInner();
}
}
}

内部类的继承

package cn.com.inner;

public class Outer {

class Inner{

}
}

package cn.com.inner;

public class InnerExtend extends Outer.Inner{

public InnerExtend(Outer outer) {
outer.super();
}
}