- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类
1、成员内部类
定义在另一个类(外部类)的内部，而且与成员方法和属性平级叫成员内部类，......相当于外部类的非静态方法，如果被static修饰，就变成静态内部类了。
注意事项：
- 成员内部类中不能存在static关键字，即，不能声明静态属性、静态方法、静态代码块等。【非静态内部类也可以定义静态成员但需要同时有final关键词修饰，静态方法鉴于无法用final修饰，仍必须是在静态内部类 或者非内部类中定义。】
- 创建成员内部类的实例使用：外部类名.内部类名 实例名 = 外部类实例名.new 内部类构造方法(参数),可以理解为隐式地保存了一个引用，指向创建它的外部类对象。
- 在成员内部类中访问外部类的成员方法和属性时使用：外部类名.this.成员方法/属性。
- 内部类在编译之后生成一个单独的class文件，里面包含该类的定义，所以内部类中定义的方法和变量可以跟父类的方法和变量相同。例如上面定义的三个类的class文件分别是：MyTest.class、Outer.class和Outer$Inner.class三个文件。
- 外部类无法直接访问成员内部类的方法和属性，需要通过内部类的一个实例来访问。
- 与外部类平级的类继承内部类时，其构造方法中需要传入父类的实例对象。且在构造方法的第一句调用“外部类实例名.super(内部类参数)”。
public class InClass {
public static void main(String args[]){
// 5、非静态内部类要new实例
Outer.Inner inner = new Outer().new Inner();
inner.fun5();
}
}
class Outer{
int out=2;
static int cc=5;
/*成员内部类、非静态内部类*/
public class Inner{
//1、变量
int in=4;
static final int field1=7; //不报错
/*
static int field0=7;//报错：Inner classes cannot have static declaration
*/
//2、函数
public void fun0(){
System.out.print("fun0");
}
/*
public static void fun1(){//报错：Inner classes cannot have static declaration
System.out.print("fun1");
}
public static final void fun2(){//报错：Inner classes cannot have static declaration
System.out.print("fun2");
}
*/
//3、内部类访问外部变量
public void fun5(){
System.out.println(Outer.this.out);
System.out.println(Outer.cc);//访问静态的
System.out.println(Outer.this.cc);
}
}
//4、外部类访问内部类变量，需要生成实例
Inner inner=new Inner();
int a=inner.in;
/*int b=Outer.Inner.field0;//访问内部类静态变量，--- 报错*/
/*int c=Outer.Inner.in;//访问内部类成员变量，--- 报错*/
}
//6、继承内部类时，其构造方法中需要传入父类的实例对象。且在构造方法的第一句调用“外部类实例名.super(内部类参数)”。
class innerExtends extends Outer.Inner{
public innerExtends(Outer outer){
//外部类实例名.super(内部类参数列表)
outer.super();
}
}2、静态内部类
先看程序
/**
* Created by Administrator on 2018/9/15 0015.
*/
public class InClass {
public static void main(String args[]){
// 5、静态内部类不要new外面的实例
Outer.Inner inner = new Outer.Inner();
inner.fun5();
}
}
class Outer{
int out=2;
static int cc=5;
/*静态内部类*/
public static class Inner{
//1、变量
int in=4;
static final int field1=7; //不报错
static int field0=7;//不报错
//2、函数
public void fun0(){
System.out.print("fun0");
}
public static void fun1(){ //不报错
System.out.print("fun1");
}
public static final void fun2(){ //不报错
System.out.print("fun2");
}
//3、内部类访问外部变量
public void fun5(){
/*System.out.println(Outer.this.out);//不可访问外部类非static属性/方法*/
System.out.println(Outer.cc);//访问静态的
/*System.out.println(Outer.this.cc);//不能出现this，出现this说明是成员变量*/
}
}
//4、外部类访问内部类变量，需要生成实例
Inner inner=new Inner();
int a=inner.in;
int b=Outer.Inner.field0;//访问内部类静态变量
/*int c=Outer.Inner.in;//访问内部类成员变量，--- 报错*/
}
在做对比：
| 说明 | 成员内部类 | 静态内部类 |
| 静态成员 | 静态成员需同时有final关键词修饰 | 可以 |
| 静态方法 | 不可定义 | 可以 |
| 访问外部类非static属性/方法 | 外部类名.this.成员方法/属性 | 不可以 |
| 外部类访问内部类 | 需要通过内部类的一个实例来访问 | 需要通过内部类的一个实例来访问 |
| 创建实例 | 外部类名.内部类名 实例名 = 外部类实例名.new 内部类构造方法(参数) | 外部类名.内部类名 实例名 = new 外部类名.内部类名(参数) |
| 编译后的class文件 | 单独的class文件(so内部类中的方法和变量可以跟父类的方法和变量同名)，外部类$内部类.class | 单独的class文件(so内部类中的方法和变量可以跟父类的方法和变量同名)，外部类$内部类.class |
| 其他 | 与外部类平级的类继承内部类时，其构造方法中需要传入父类的实例对象。且在构造方法的第一句调用“外部类实例名.super(内部类参数)” | 无 |
3、局部内部类
定义在代码块、方法体内、作用域（使用花括号“{}”括起来的一段代码）内的类叫局部内部类。
- 局部内部类只能在代码代码块、方法体内和作用域中使用（如创建对象和使用类对象等）
-
1、内部类不能被public、private、static修饰，可以使用abstract修饰，声明为抽象类；
2、在外部类中不能创建内部类的实例；
3、创建内部类的实例只能在包含他的方法中；
4、内部类访问包含他的方法中的变量必须有final修饰；
5、外部类不能访问局部内部类，只能在方法体中访问局部内部类，且访问必须在内部类定义之后。
6、可知局部内部类可随意访问外部类的成员变量和方法，即使是私有的。
7、内部类和外部类有同名变量和方法时，需要通过Outer.this方式来访问外部类成员变量或方法。
public class InClass {
public static void main(String args[]){
}
}
class Outer{
int out=2;
static int cc=5;
private int gg=6;
/*局部内部类*/
//代码块局部内部类
{
//1、不能被public,private,protected,static修饰符修饰,但是可以声明为abstract
abstract class Innerr{}
/*public class Innner{}*/
class Inner1{
int a=5;
//2、访问外部类变量
int b=Outer.this.out;//代码块中可以正常访问外部类变量
int c=Outer.cc;
int g=Outer.this.gg;//私有的也可访问
}
}
//方法区局部内部类
public void fun(){
int funa=7;
final int funb =8;
class Inner1{
int a=5;
int b=Outer.this.out;//局部区中可以正常访问外部类变量
int c=Outer.cc;
int g=Outer.this.gg;//私有的也可访问
//3、只能赋值final的
/*int fa=funa;-----报错，因为不是final类型变量*/
int fb=funb;//final的赋值成功
}
//4、可在方法里面生成局部内部类的对象
Inner1 inner =new Inner1();
int f=inner.a;
}
//5、外部类不能创建内部类的实例
/*Inner1 in=new Outer().new Inner();-----报错*/
}
4、匿名内部类
匿名内部类定义和实例化形式如下：
new 父类构造方法（参数）{
//注：该方法名必须在父类中已经存在
修饰符 返回参数类型 方法名（参数列表）{
。。。
}
}- 只能使用一次，创建实例之后，类定义会立即消失（想要多次使用就要用到反射的知识了）
- 必须继承一个类（抽象的、非抽象的都可以）或者实现一个接口。如果父类（或者父接口）是抽象类，则匿名内部类必须实现其所有抽象方法。
- 不能是抽象类，因为匿名内部类在定义之后，会立即创建一个实例。
- 不能定义构造方法，匿名内部类没有类名，无法定义构造方法，但是，匿名内部类拥有与父类相同的所有构造方法。
- 可以定义代码块，用于实例的初始化，但是不能定义静态代码块。
- 可以定义新的方法和属性(不能使用static修饰)，但是无法显式的通过“实例名.方法名(参数)”的形式调用，因为使用new创建的是“上转型对象”（即父类声明指向子类对象）。
- 是局部内部类，所以要符合局部内部类的要求。
| 说明 | 成员内部类 | 匿名内部类 |
| 静态成员 | 静态成员需同时有final关键词修饰 | 不可定义 |
| 静态方法 | 不可定义 | 不可定义 |
| 访问外部类非static属性/方法 | 外部类名.this.成员方法/属性 | 外部类名.this.成员方法/属性 |
| 外部类访问内部类 | 需要通过内部类的一个实例来访问 | 需要通过内部类的一个实例来访问 |
| 创建实例 | 外部类名.内部类名 实例名 = 外部类实例名.new 内部类构造方法(参数) | 如上：父类 实例名 = new 父类（）{} |
| 编译后的class文件 | 单独的class文件(so内部类中的方法和变量可以跟父类的方法和变量同名)，外部类$内部类.class | 单独的class文件，使用类$数字.class |
| 其他 | 与外部类平级的类继承内部类时，其构造方法中需要传入父类的实例对象。且在构造方法的第一句调用“外部类实例名.super(内部类参数)” | 无 |
有时候我为了免去给内部类命名，便倾向于使用匿名内部类，因为它没有名字。例如：
((Button) findViewById(R.id.start)).setOnClickListener(new Button.OnClickListener() {
@Override
public void onClick(View v) {
new Thread() {
@Override
public void run() {
// TODO Auto-generated method stub
}
}.start();
}
});
匿名内部类是不能加访问修饰符的。要注意的是，new 匿名类，这个类是要先定义的，看下面例子：
public class Outer {
public static void main(String[] args) {
Outer outer = new Outer();
Inner inner = outer.getInner("Inner", "gz");
System.out.println(inner.getName());
}
public Inner getInner(final String name, String city) {
return new Inner() {
private String nameStr = name;
public String getName() {
return nameStr;
}
};
}
}
//注释后，编译时提示类Inner找不到
/* interface Inner {
String getName();
} */
同时在这个例子，留意外部类的方法的形参，当所在的方法的形参需要被内部类里面使用时，该形参必须为final。这里可以看到形参name已经定义为final了，而形参city 没有被使用则不用定义为final。为什么要定义为final呢？在网上找到本人比较如同的解释：
“这是一个编译器设计的问题，如果你了解java的编译原理的话很容易理解。
首先，内部类被编译的时候会生成一个单独的内部类的.class文件，这个文件并不与外部类在同一class文件中。
当外部类传的参数被内部类调用时，从java程序的角度来看是直接的调用例如：
public void dosome(final String a,final int b){
class Dosome{public void dosome(){System.out.println(a+b)}};
Dosome some=new Dosome();
some.dosome();
}
从代码来看好像是那个内部类直接调用的a参数和b参数，但是实际上不是，在java编译器编译以后实际的操作代码是
class Outer$Dosome{
public Dosome(final String a,final int b){
this.Dosome$a=a;
this.Dosome$b=b;
}
public void dosome(){
System.out.println(this.Dosome$a+this.Dosome$b);
}
}}
从以上代码看来，内部类并不是直接调用方法传进来的参数，而是内部类将传进来的参数通过自己的构造器备份到了自己的内部，自己内部的方法调用的实际是自己的属性而不是外部类方法的参数。
这样理解就很容易得出为什么要用final了，因为两者从外表看起来是同一个东西，实际上却不是这样，如果内部类改掉了这些参数的值也不可能影 响到原参数，然而这样却失去了参数的一致性，因为从编程人员的角度来看他们是同一个东西，如果编程人员在程序设计的时候在内部类中改掉参数的值，但是外部 调用的时候又发现值其实没有被改掉，这就让人非常的难以理解和接受，为了避免这种尴尬的问题存在，所以编译器设计人员把内部类能够使用的参数设定为必须是 final来规避这种莫名其妙错误的存在。”
(简单理解就是，拷贝引用，为了避免引用值发生改变，例如被外部类的方法修改等，而导致内部类得到的值不一致，于是用final来让该引用不可改变)
因为匿名内部类，没名字，是用默认的构造函数的，无参数的，那如果需要参数呢？则需要该类有带参数的构造函数：
public class Outer {
public static void main(String[] args) {
Outer outer = new Outer();
Inner inner = outer.getInner("Inner", "gz");
System.out.println(inner.getName());
}
public Inner getInner(final String name, String city) {
return new Inner(name, city) {
private String nameStr = name;
public String getName() {
return nameStr;
}
};
}
}
abstract class Inner {
Inner(String name, String city) {
System.out.println(city);
}
abstract String getName();
}
注意这里的形参city，由于它没有被匿名内部类直接使用，而是被抽象类Inner的构造函数所使用，所以不必定义为final。
而匿名内部类通过实例初始化，可以达到类似构造器的效果：
public class Outer {
public static void main(String[] args) {
Outer outer = new Outer();
Inner inner = outer.getInner("Inner", "gz");
System.out.println(inner.getName());
System.out.println(inner.getProvince());
}
public Inner getInner(final String name, final String city) {
return new Inner() {
private String nameStr = name;
private String province;
// 实例初始化
{
if (city.equals("gz")) {
province = "gd";
}else {
province = "";
}
}
public String getName() {
return nameStr;
}
public String getProvince() {
return province;
}
};
}
}
interface Inner {
String getName();
String getProvince();
}
扫一扫
1258
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
