内部类


文章目录

  • 内部类
  • 内部类概念
  • 成员内部类
  • 1、外部类、内部类
  • 2、其他类使⽤成员内部类
  • 3、⼩结：
  • 静态内部类
  • 1、外部类、内部类
  • 2、其他类使⽤成员内部类
  • 3、⼩结【和成员内部类对⽐理解（区别异同）】
  • 匿名内部类
  • 1、定义接⼝
  • 2、匿名内部类使⽤
  • 3、⼩结【匿名内部类常常被⽤来重写某个或某些⽅法】


内部类概念

可以将⼀个类的定义放在⾥另⼀个类的内部，这就是内部类。⼴义上我们将内部类分为四种：成员内部类、静态内部类、局部（⽅法）内部类、匿名内部类。
语法：

/**
* 我是⼀个外部类（外部是相对内部⽽⾔）
*/
public class Outer{
/**
* 我是⼀个内部类
*/
class Inner{
//...
}
}

使⽤内部类最吸引⼈的原因是：每个内部类都能独⽴地继承⼀个（接⼝的）实现，所以⽆论外围类是否已经继承了某个（接⼝的）实现，对于内部类都没有影响。

成员内部类

1、外部类、内部类

示例：

/**
* 外部类、成员内部类的定义
*/
public class Outer {
private int outerVariable = 1;
private int commonVariable = 2;
private static int outerStaticVariable = 3;
//省略getter/setter
/**
* 成员⽅法
*/
public void outerMethod() {
System.out.println("我是外部类的outerMethod⽅法");
}
/**
* 静态⽅法
*/
public static void outerStaticMethod() {
System.out.println("我是外部类的outerStaticMethod静态⽅法");
}
/**
* 内部类
*/
public class Inner {
private int commonVariable = 20;
/**
* 构造⽅法
*/
public Inner() {
}
/**
* 成员⽅法，访问外部类信息（属性、⽅法）
*/
public void innerShow() {
//当和外部类冲突时，直接引⽤属性名，是内部类的成员属性
System.out.println("内部的commonVariable:" + commonVariable);
//内部类访问外部属性
System.out.println("outerVariable:" + outerVariable);
//当和外部类属性名重叠时，可通过外部类名.this.属性名
System.out.println("外部的commonVariable:" +
Outer.this.commonVariable);
System.out.println("outerStaticVariable:" + outerStaticVariable);
//访问外部类的⽅法
outerMethod();
outerStaticMethod();
}
}
/**
* 外部类访问内部类信息
*/
public void outerShow() {
Inner inner = new Inner();
inner.innerShow();
}
}

2、其他类使⽤成员内部类

/*
* 其他类使⽤成员内部类
*/
public class Other {
public static void main(String[] args) {
//外部类对象
Outer outer = new Outer();
//创造内部类对象
Outer.Inner inner = outer.new Inner();
inner.innerShow();
/*
* 可在Outer中定义get⽅法，获得Inner对象,那么使⽤时，只需
outer.getInnerInstance()即可。
* public Inner getInnerInstance(Inner类的构造⽅法参数){
* return new Inner(参数);
* }
*/
}
}

3、⼩结：

  • 可以是任何的访问修饰符。
  • 外部类如何访问内部类信息，必须new之后通过（.）操作符访问。
  • 内部类可以直接使⽤外部类的任何信息，如果属性或者⽅法发⽣冲突，调⽤外部类.this.属性或者⽅法。
  • 其它类如何访问内部类：
Outer outer=new Outer();
//创造内部类对象
Outer.Inner inner=outer.new Inner();
inner.inner_show();

静态内部类

1、外部类、内部类

/**
* 外部类、内部类定义
*/
public class Outer {
private int outerVariable = 1;
/**
* 外部类定义的属性(重名)
*/
private int commonVariable = 2;
private static int outerStaticVariable = 3;
static {
System.out.println("Outer的静态块被执⾏了……");
}
/**
* 成员⽅法
*/
public void outerMothod() {
System.out.println("我是外部类的outerMethod⽅法");
}
/*
* 静态⽅法
*/
public static void outerStaticMethod() {
System.out.println("我是外部类的outerStaticMethod静态⽅法");
}
/**
* 静态内部类
*/
public static class Inner {
/**
* 成员信息
*/
private int innerVariable = 10;
//和外部的变量命名冲突
private int commonVariable = 20;
static {
System.out.println("Outer.Inner的静态块执⾏了……");
}
private static int innerStaticVariable = 30;
/**
* 成员⽅法
*/
public void innerShow() {
System.out.println("innerVariable:" + innerVariable);
System.out.println("内部的commonVariable:" + commonVariable);
System.out.println("outerStaticVariable:"+outerStaticVariable);
outerStaticMethod();
}
/**
* 静态⽅法
*/
public static void innerStaticShow() {
//被调⽤时会先加载Outer类
outerStaticMethod();
System.out.println("outerStaticVariable"+outerStaticVariable);
}
}
/**
* 外部类的内部如何和内部类打交道
*/
public static void callInner() {
System.out.println(Inner.innerStaticVariable);
Inner.innerStaticShow();
}
}

2、其他类使⽤成员内部类

public class Other {
public static void main(String[] args) {
//访问静态内部类的静态⽅法，Inner类被加载,此时外部类未被加载，独⽴存在，不依赖于外
围类。
Outer.Inner.innerStaticShow();
//访问静态内部类的成员⽅法
Outer.Inner oi = new Outer.Inner();
oi.innerShow();
}
}

3、⼩结【和成员内部类对⽐理解（区别异同）】

  • 作为静态成员属性存在，可以被任意的权限修饰符修饰
  • 静态内部类的⽅法只能访问外部类的static关联的信息。
  • 利⽤ 外部类.内部类 引⽤=new 外部类.内部类(); 然后利⽤引⽤.成员信息(属性、⽅法)调⽤。
//访问静态内部类的成员⽅法
Outer.Inner oi = new Outer.Inner();
oi.innerShow();
  • 访问内部类的静态信息，直接外部类.内部类.静态信息就可以了。
//访问静态内部类的静态⽅法，Inner类被加载,此时外部类未被加载，独⽴存在，不依赖于外围类。
Outer.Inner.innerStaticShow();
  • 静态内部类可以独⽴存在，不依赖于其他外围类。

匿名内部类

1、定义接⼝

/**
* 接⼝中⽅法默认为public
*/
public interface IAnimal{
void speak();
}

2、匿名内部类使⽤

/**
* 外部内、内部类
*/
public class Outer {
public static IAnimal getInnerInstance(String speak){
return new IAnimal(){
@Override
public void speak(){
System.out.println(speak);
}};
//注意上⼀⾏的分号必须有
}
public static void main(String[] args){
//调⽤的speak()是重写后的speak⽅法。
Outer.getInnerInstance("⼩狗汪汪汪！").speak();
}
}

3、⼩结【匿名内部类常常被⽤来重写某个或某些⽅法】

  1. 匿名内部类是没有访问修饰符的。
  2. 使⽤匿名内部类时，这个new之后的类⾸先是要存在的，其次我们要重写new后的类的某个或某些⽅法。