在Java编程语言里,程序是由类(class)构建而成的。在一个类的内部也可以声明类,我们把这样的类叫做内部类,一个简单内部类的定义如下:
public class Outer{
/**
* 我是一个内部类
*/
class Inner{
//...
}
}
为什么使用内部类
使用内部类最吸引人的原因是:每个内部类都能独立地继承一个(接口的)实现,所以无论外部类是否已经继承了某个(接口的)实现,对于内部类都没有影响,也就是说内部类拥有类的基本特征,可以继承父类,实现接口
/**
1. Outer类继承了ClassA,实现了IFunctionA
*/
public class Outer extends ClassA implements IFunctionA{
/**
* Inner类继承了ClassB,实现了IFunctionB
*/
public class Inner extends ClassB implements IfunctionB{
//
}
}
内部类特性
使用内部类最大的优点就在于它能够非常好的解决多重继承的问题,使用内部类还能够为我们带来如下特性
- 内部类可以用多个实例,每个实例都有自己的状态信息,并且与其他外部对象的信息相互独立。
- 在单个外部类中,多个内部类能以不同的方式实现同一个接口,或者继承同一个类。
- 创建内部类对象的时刻并不依赖于外围类对象的创建
- 内部类并没有令人迷惑的“is-a”关系,他就是一个独立的实体。
- 内部类提供了更好的封装,除了该外部类,其他类都不能访问。
总结而言该内部类更像是外部类的一部分。
内部类使用原则
内部类和外部类的使用原则主要分为以下几点:
- 外部类只能用public访问修饰符,但内部类可以使用所有的访问修饰符, public 、 protected 、 private 等
- 类的使用:外部类直接实例化即可使用,实例化的外部类里边没有关于内部类的东西,基本上外部类的使用可以忽视内部类;内部类的使用需要先实例化外部类对象,即:
内部类 对象名 = 外部类对象.new 内部类( );
- 内部类可以直接访问并且调用外部类的字段,但优先执行本内部类内部的字段方法。执行顺序:本内部类方法->方法外->外部类,如果外部类和内部类具有相同的成员变量或方法,内部类默认访问自己的成员变量或方法,如果要访问外部类的成员变量,可以使用 this 关键字,如:
Outer.this.name
- 外部类的所有字段无论是否private对于内部类都没有任何隐私可言
- 外部类不能直接访问内部类,但可以通过实例化直接当成一个普通的数据类型一样访问。直接new 内部类
内部类不定义为public也默认设定为同一包可访问,如果想不同包访问,必须定义为public类型
以上就是外部类和内部类的通用区分方式
内部类有哪几种
内部类分为成员内部类、静态内部类、局部内部类和匿名内部类。
成员内部类
以下为一个成员内部类的定义,其使用方式如下:
package com.company;
/**
* 外部类、成员内部类的定义
*/
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();
}
public static void main(String[] args){
Outer o = new Outer();
System.out.println("外部类的方法调用==================");
o.outerShow();
System.out.println("内部类的初始化调用==================");
Inner in = o.new Inner();
in.innerShow();
}
}
执行结果如下:
外部类的方法调用==================
内部的commonVariable:20
outerVariable:1
外部的commonVariable:2
outerStaticVariable:3
我是外部类的outerMethod方法
我是外部类的outerStaticMethod静态方法
内部类的初始化调用==================
内部的commonVariable:20
outerVariable:1
外部的commonVariable:2
outerStaticVariable:3
我是外部类的outerMethod方法
我是外部类的outerStaticMethod静态方法
以上内容分条解释如下:
-
Inner 类定义在 Outer 类的内部,相当于 Outer 类的一个成员变量的位置,Inner 类可以使用任意访问控制符,如 public 、 protected 、 private 等
-
Inner 类中定义的 innerShow方法可以直接访问 Outer 类中的数据,而不受访问控制符的影响,如直接访问 Outer 类中的私有属性commonVariable
-
如果外部类和内部类具有相同的成员变量或方法,内部类默认访问自己的成员变量或方法,如果要访问外部类的成员变量,可以使用 this 关键字,如:Outer.this.name
-
外部类是不能直接使用内部类的成员和方法的,可先创建内部类的对象,然后通过内部类的对象来访问其成员变量和方法;
-
定义了成员内部类后,必须使用外部类对象来创建内部类对象,而不能直接去 new 一个内部类对象,即:内部类 对象名 = 外部类对象.new 内部类( );
-
编译上面的程序后,会发现产生了两个 .class 文件: Outer.class,Outer$Inner.class
-
成员内部类中不能存在任何 static 的变量和方法,可以定义常量:
- 非静态内部类是要依赖于外部类的实例,而静态变量和方法是不依赖于对象仅与类相关,简而言之:加载静态域时,根本没有外部类,所在在非静态内部类中不能定义静态域或方法,编译不通过; 非静态内部类的作用域是实例级别
- 常量是在编译器就确定的,放到常量池了
以上就是成员内部类的使用说明,成员内部类可以类比一个非静态成员。
静态内部类
以下为一个静态内部类的定义,其使用方式如下:
package com.company;
/**
* 外部类、成员内部类的定义
*/
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();
}
public static void main(String[] args){
//访问静态内部类的静态方法,Inner类被加载,此时外部类未被加载,独立存在,不依赖于外围类。
Outer.Inner.innerStaticShow();
//访问静态内部类的成员方法
Outer.Inner oi = new Outer.Inner();
oi.innerShow();
Inner in=new Inner();
in.innerShow();
}
}
返回结果为:
Outer的静态块被执行了……
Outer.Inner的静态块执行了……
我是外部类的outerStaticMethod静态方法
outerStaticVariable3
innerVariable:10
内部的commonVariable:20
outerStaticVariable:3
我是外部类的outerStaticMethod静态方法
静态内部类和成员内部类有几点不同:
- 静态内部类可以包含任意的信息,静态或非静态,因为它不依赖于外部类的实例对象,所以可以有静态成员
- 静态内部类的方法只能访问外部类的static修饰的信息。
- 访问静态内部类的静态信息直接
Outer.Inner.innerStaticShow();
即可 - 访问静态内部类的非静态信息
Outer.Inner oi = new Outer.Inner();
,然后oi.innerShow();
即可 - 静态内部类可以独立存在,不依赖于其他外部类。创建静态内部类的对象时,不需要外部类的实例对象,可以直接创建 内部类 对象名 = new 内部类();
- 如果外部类的静态成员与内部类的成员名称相同,可通过“类名.静态成员”访问外部类的静态成员;如果外部类的静态成员与内部类的成员名称不相同,则可通过“成员名”直接调用外部类的静态成员
总而言之静态内部类的加载只依赖于外部类的类对象而非实例对象。更加的独立,静态内部类可以类比一个静态成员。
局部内部类
以下为一个静态内部类的定义,其使用方式如下:
/**
* 外部类、内部类
*/
public class Outer {
/**
* 属性和方法
*/
private int outerVariable = 1;
/**
* 外部类定义的属性
*/
private int commonVariable = 2;
/**
* 静态的信息
*/
private static int outerStaticVariable = 3;
/**
* 成员外部方法
*/
public void outerMethod() {
System.out.println("我是外部类的outerMethod方法");
}
/**
* 静态外部方法
*/
public static void outerStaticMethod() {
System.out.println("我是外部类的outerStaticMethod静态方法");
}
/**
* 程序的入口
*/
public static void main(String[] args) {
Outer outer = new Outer();
outer.outerCreatMethod(100);
}
/**
* 成员方法,内部定义局部内部类
*/
public void outerCreatMethod(int value) {
/**
* 女性
*/
boolean sex = false;
/**
* 局部内部类,类前不能有访问修饰符
*/
class Inner {
private int innerVariable = 10;
private int commonVariable = 20;
/**
* 局部内部类方法
*/
public void innerShow() {
System.out.println("innerVariable:" + innerVariable);
//局部变量
System.out.println("是否男性:" + sex);
System.out.println("参数value:" + value);
//调用外部类的信息
System.out.println("outerVariable:" + outerVariable);
System.out.println("内部的commonVariable:" + commonVariable);
System.out.println("外部的commonVariable:" + Outer.this.commonVariable);
System.out.println("outerStaticVariable:" + outerStaticVariable);
outerMethod();
outerStaticMethod();
}
}
//局部内部类只能在方法内使用
Inner inner = new Inner();
inner.innerShow();
}
}
返回结果如下:
innerVariable:10
是否男性:false
参数value:100
outerVariable:1
内部的commonVariable:20
外部的commonVariable:2
outerStaticVariable:3
我是外部类的outerMethod方法
我是外部类的outerStaticMethod静态方法
相比成员内部类和静态内部类,局部内部类有很多限制:
- 局部内部类就像是方法里面的一个局部变量一样,是不能有 public、protected、private 以及 static 修饰符的。
- 局部内部类无法包含静态成员。
- 局部内部类可以直接访问方法内的局部变量和参数 ,只能访问方法中定义的 final 类型的局部变量,但是不能更改。
- 局部内部类可以随意的访问外部类的任何信息。
当方法被调用运行完毕之后,局部变量就已消亡了。但内部类对象可能还存在, 直到没有被引用时才会消亡。此时就会出现一种情况,就是内部类要访问一个不存在的局部变量,使用final修饰符不仅会保持对象的引用不会改变,而且编译器还会持续维护这个对象在回调方法中的生命周期.局部内部类并不是直接调用方法传进来的参数,而是内部类将传进来的参数通过自己的构造器备份到了自己的内部,自己内部的方法调用的实际是自己的属性而不是外部类方法的参数;防止被篡改数据,而导致内部类得到的值不一致,局部内部类可以类比一个方法参数。
匿名内部类
以下为一个匿名内部类的定义,其使用方式如下,首先定义接口
/**
* 接口中方法默认为public
*/
public interface IAnimal{
void speak();
}
然后使用匿名内部类:
/**
* 外部内、内部类
*/
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("TTTTTTT").speak();
}
}
返回结果
TTTTTTT
匿名内部类在我们简化代码的时候还是蛮常见的
- 匿名内部类是直接使用 new 来生成一个对象的引用;匿名内部类没有类的名称
- 对于匿名内部类的使用它是存在一个缺陷的,就是它仅能被使用一次,创建匿名内部类时它会立即创建一个该类的实例,该类的定义会立即消失,所以匿名内部类是不能够被重复使用;
- 使用匿名内部类时,我们必须是继承一个类或者实现一个接口,但是两者不可兼得,同时也只能继承一个类或者实现一个接口;
- 匿名内部类中是不能定义构造函数的,匿名内部类中不能存在任何的静态成员变量和静态方法;
- 匿名内部类中不能存在任何的静态成员变量和静态方法,匿名内部类不能是抽象的,它必须要实现继承的类或者实现的接口的所有抽象方法
- 匿名内部类初始化:使用构造代码块!利用构造代码块能够达到为匿名内部类创建一个构造器的效果
匿名内部类可以类别一个方法返回值。