Java内部类
基本介绍
一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class).嵌套其他类的类称为外部类(outer class)。是我们类的第五大成员
内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系
基本语法
class Outer{//外部类
class Inner{//内部类
}
}
class Other{//其他类
}
内部类的分类
定义在外部类局部位置上（比如一般在方法内,或者成员上）：
- 局部内部类(有类名)（定义在方法中）
- 匿名内部类(没有类名，重点)（方法和成员都行）
>定义在外部类的成员位置上:
- 成员内部类(没用static修饰)
- 静态内部类(使用static修饰)
局部内部类
说明:局部内部类是定义在外部类的局部位置,比如方法中，并且有类名。
- 可以直接访问外部类的所有成员,包含私有的
- 不能添加访问修饰符,因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final
- 作用域:仅仅在定义它的方法或代码块中。
- 局部内部类---访问---->外部类的成员[访问方式:直接访问]
- 外部类---访问---->局部内部类的成员
访问方式:创建对象,再访问(注意:必须在作用域内) - 外部其他类不能访问 局部内部类（局部变量）
- 如果外部类和局部内部类的成员重名时，默认遵循就近原则,如果想访问外部类的成员，则可以使用(外部类名.this.成员）去访问
package inerclass_;
public class interecalss02 {
public static void main(String[] args) {
Outer02 outer = new Outer02();
outer.m1();
}
}
class Outer02{
private int n1=100;
private void m2(){
System.out.println("interecalss02.Outer02.m2()");
}
public void m1(){
//1. 局部内部类是定义在外部类的局部位置,通常在方法
//3. 不能添加访问修饰符,但是可以使用final修饰
//4. 作用域:仅仅在定义它的方法或代码块中(局部)
//
final class Inner01{} //可以加final，不想被继承
class Inner02{//局部内部类（本质还是一个类）
public void f1(){
//5. 局部内部类，直接访问外部成员
System.out.println("n1="+n1);//可以访问外部类私有属性,就近原则，输出500
System.out.println("外部n1="+Outer02.this.n1);//用外部类名.this.属性名可以访问外部类私有;
m2();
}
}
class Inner03 extends Inner02{//局部内部类可以被继承
}
{//写个代码块，也可以搞个局部类
class Inner04{}
};
//6. 外部类在方法中，可以创建Inner02对象，然后调用方法即可
Inner02 inner02=new Inner02();
inner02.f1();
}
}
匿名内部类
(1)本质是类
(2)内部类
(3)该类没有名字
(4)同时还是一个对象
说明:匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名
匿名内部类的基本语法：
new 类或接口（参数列表）{
}；
类或接口名称 对象名 = new 类或接口（参数列表）{
}；
匿名内部类是为了减少代码量，如果一个类、抽象类、接口，只需要在运行的时候重写一次，就没必要再去搞个继承什么的，直接new的时候重写一下，然后就可以用了，本质上在底层编译类型是new的那个，运行类型是 匿名内部类；
- 因为匿名内部类既是一个类的定义,同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，可以调用匿名内部类方法。
- 可以直接访问外部类的所有成员,，包含私有的
- 不能添加访问修饰符,因为它的地位就是一个局部变量
- 作用域:仅仅在定义它的方法或代码块中。[过]
- 匿名内部类---访问---->外部类成员，直接访问
- 外部其他类---不能访问----->匿名内部类（因为匿名内部类地位是一个局部变量)
- 如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则,如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问
package inerclass_;
import interface_.phone;
public class interclass03 {
public static void main(String[] args) {
Outer04 outter04 = new Outer04();
outter04.method();
}
}
class Outer04{
private int n1=10;
//想使用IA接口，使用匿名内部类简化开发
//也可以
IA ib= new IA(){
public void cry(){
System.out.println("外部类属性处定义内部匿名类，但是实现还得在方法中");//也可在其他外部类直接调用
//Outer04 outter04 = new Outer04();
//outter04.ib.cry();
}
};
public void method(){
ib.cry();//但是实现还得在方法中
//IA tiger = new IA(){
// public void cry() {
// System.out.println("tiger cry");
// }
// }
// 等价于下面
/*底层：系统分配的类名。本质：
class Outer04$1 implements IA{
@Override
public void cry(){
System.out.println("tiger cry");
}
*/ //编译类型是IA,运行类型是内部匿名类Outer04$1
//jdlk底层在创建匿名内部类Outer04$1,立即马上就创建了0uter04$1实例，并且把地址返回给tiger
IA ia=new IA(){
@Override
public void cry(){
System.out.println("用内部匿名类实现IA接口");
}
};
//抽象类的匿名内部类
Animal dog=new Animal() {
void eat(){
System.out.println("new一个叫dog的对象实例，然后dog.eat()，实现内部匿名类");
}
};
dog.eat();
ia.cry();
new IA(){
@Override
public void cry(){
System.out.println("内部匿名类也是一个方法，可以用方法的方式实现，new IA(){@override cry}.cry()");
}
}.cry();
new IB(){
@Override
public void cry(){
System.out.println("");
}
@Override
public void ok(String str){
super.ok(str);
}
}.ok("可以重写多个，但是直接.ok()的方式只能执行一个");
new IB(){
@Override
public void cry(){
System.out.println("可以直接访问外部类的私有成员：n1="+n1);;
}
}.cry();
}
}
interface IA{//接口
public void cry();
}
abstract class Animal{
abstract void eat();
}
class IB{//接口
public void cry(){
}
public void ok(String str){
System.out.println("str:="+str);
}
}
运行结果：
1. 外部类属性处定义内部匿名类，但是实现还得在方法中
2. new一个叫dog的对象实例，然后dog.eat()，实现内部匿名类
3. 用内部匿名类实现IA接口
4. 内部匿名类也是一个方法，可以用方法的方式实现，new IA(){@override cry}.cry()
5. str:=可以重写多个，但是直接.ok()的方式只能执行一个
6. 可以直接访问外部类的私有成员：n1=10
成员内部类
定义在外部类的成员位置
说明:成员内部类是定义在外部类的成员位置，并且没有static修饰。
- 可以直接访问外部类的所有成员，包含私有的
- 可以添加任意访问修饰符(public、protected、默认、private),因为它的地位就是一个成员。
- 作用域和外部类的其他成员一样,为整个类体比如前面案例，在外部类的成员方法中创建成员内部类对象,再调用方法.
- 成员内部类---访问---->外部类成员 (比如:属性)访问方式:直接访问
- 外部类---访问------>内部类(说明)访问方式:创建对象,再访问
- 外部其他类---访问---->成员内部类（3种）
- 如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员,则可以使用(外部类名.this.成员)去访问
public class interclass01 {
public static void main(String[] args) {
//外部其他类调用内部类三种方式：
//第一种：，把他当成一个成员，outer的成员
//outer.new Inner08();相当于把new Inner08()当成outer的成员
Outer outer = new Outer(5);
Outer.Inner08 inner01 = outer.new Inner08();
//第二种方式：在外部类中编写一个方法getinner08()2
Outer.Inner08 inner02=outer.getinner08();
//第三种方式：
Outer.Inner08 inner03 = new Outer(00).new Inner08();
}
}
class Outer{
private int n1=100;
public Outer(int n1) {
this.n1 = n1;
}
class Inner08{
public double n1=200.0;
public void say(){
System.out.println("外部类访问内部类");
}
}
public void say(){
Inner08 inner08 = new Inner08();
inner08.say();
}
//返回一个inner08实例
public Inner08 getinner08(){
return new Inner08();
}
}
静态内部类
说明:静态内部类是定义在外部类的成员位置，并且有static修饰
- 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
- 可以添加任意访问修饰符(public、protected、默认、private),因为它的地位就是一个成员。
- 作用域:同其他的成员，为整个类体
静态方法只能访问静态成员，静态类也只能访问静态成员 - 静态内部类---访问---->外部类(比如:静态属性)访问方式:直接访问所有静态成员
- 外部类---访问------>静态内部类访问方式:创建对象,再访问
- 外部其他类---访问----->静态内部类（在外部类编写方法get...，new 外部类.静态内部类）
- 如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用 (外部类名.成员）访问
小结
(1)内部类有四种局部内部类，匿名内部类，成员内部类,静态内部类
()重点还是掌握匿名内部类使用
new类/接口(参数列表){
};
(3)成员内部类,静态内部类是放在外部类的成员位置,本质就是一个成员.
浙公网安备 33010602011771号