内部类按定义可以分为四种, 静态内部类/成员内部类/局部内部类/匿名内部类.
我的理解里, 包含内部类的类叫外部类, 其他类也叫外部类. 比如同包的其它类, 用到的测试Test类, 他们可以通过classNameA.classNameB的方式进行对内部类的访问操作.
创建内部类对象- 静态内部类–直接创建内部类对象
- 成员内部类—先创建外部类对象再创建内部类对象
- 局部内部类—内部类实现接口/抽象类,方法返回接口/抽象类 类型的引用
- 匿名内部类—内部类实现接口/抽象类, 写一个 “接口/抽象的类型 方法名()” 的方法, 返回值为接口类型的引用, 类体写进return之后的{ }; 之中
用static修饰的内部类(嵌套类), 不需外部类对象便可直接获取内部类对象
//如果内部类被static修饰, 则为静态内部类,不需要创建外部类的对象即可完成创建实例.
public class A {
static class B{
}
public class Test {
public static void main(String[] args) {
A.B b = new A.B();//直接创建
}
}
成员内部类
普通的内部类,相当于外部类的一个成员
public class A {
class B{
}
public class Test {
public static void main(String[] args) {
A a= new A();
A.B b1 = a.new B(); // 用new 关键字构造B类对象
// PS:如果内部类引用外部类对象使用 A.this
}
}
局部内部类
定义在方法体中的内部类,只在域内生效
interface Bridge { //定义一个接口
void doSomething();
}
public class A {
public Bridge Binclud() {
class B implements Bridge { //内部类实现接口
private String s = "私有字段";
private void f(){
System.out.println("私有方法");
}
@Override
public void doSomething() {
System.out.println(s);
f();
}
}
return new B(); //方法返回 引用classB的对象的 Bridge类型变量.
}
}
----------------------------------------------------------------------------------
public class Test {
public static void main(String[] args) {
A a = new A();
a.Binclud(); // 一旦调用该方法就得到 对象引用
a.Binclud().doSomething(); //仍然可以通过内部类实现接口的方式
//打通外部类与内部类的联系,访问到字段或方法
}
}
匿名内部类
定义成方法的内部类,没有名字
public interface Bridge {// 可以是实现接口也可以是实现抽象类
}
public class A { // public [接口类型] [方法名] (参数){retrun new类型(){类体};}
public Bridge bridge(final int x){ //参数只能是final
return new Bridge() { //从外部调用看来, 返回的都是接口变量引用到该类对象 所以直接将类匿名,写成一个接口类型的方法
private int i = 10; //该方法一旦被class A的对象a调用bridge() 就会return一个引用
// 匿名类的相关内容 写进return语句内部,最后有一个冒号结束语句
};
}
}
------------------------------------------------------------------------------------
public class Test {
public static void main(String[] args) {
A a = new A(); //匿名类可以可以传入常量参数实现构造, 但不能重载,只有参数类型匹配的一种构造器
Bridge bridge = a.bridge(10); //匿名类可以扩展类也可以实现接口, 但不能兼具.实现接口也只能实现一个.
System.out.println(bridge.value());//结果为10
}
}
另外: protected/private 修饰的内部类
public class Test {
A a = new A();
A.M m = a.new M(); //报错 !!!!!!!!!!!!!!!!!!
A.W w = a.new W(); // 内部类W 被private修饰 所以在测试类无法看到它,即无法知道它是什么类型,更不能去new.
// 当然protected修饰的 M类 也会在超出访问范围的地方报错
Bridge bridgeM = a.getMInstance(); //使用接口变量接收 a调用方法构造的M类对象
Bridge bridgeW = a.getWInstance();//使用接口变量接收 a调用方法构造的W类对象
//接口的使用像一座桥梁中继
}
-----------------------------------------------------------------------------------------
interface Bridge{
}
--------------------------------------------------------------------------------------
public class A {
private class W implements Bridge{ //private修饰的内部类 W 实现接口
}
protected class M implements Bridge{ //protected修饰的内部类 M 实现接口
}
public W getWInstance(){ //获取W类对象方法 ,使得超出访问范围的外部类也能得到class W的对象
return new W();
}
public M getMInstance(){//获取M类的对象方法 ,使得超出访问范围的外部类也能得到class W的对象
return new M();
}
}
总结 : 一条主线就是 无论内部类是被static修饰的, 或者不同的访问权限,或是匿名类. 重点在于如何创建他的对象和它进行交流调用使用到他, 内部类的使用野丰富了类的多继承, 类只可以继承一个类, 但类里的内部类又可以实现不同的接口或继承.
初学者,作为笔记记录, 肯定有大量偏颇,望指正,后期边学边修改.
