内部类
把类定义在其他类的内部，这个类就被称为内部类。
内部类可以直接访问外部类的成员，
内部类编译生成的.class文件是Outer$Inner.class
内部类具有延迟加载的功能
成员内部类
在类的成员位置的内部类，就是成员内部类
访问
public class InnerClassDome {
public static void main(String[] args) {
Outer.Inner i = new Outer().new Inner(); //不需要导包直接使用
i.show();
Inner i2 = new Outer().new Inner(); //需要导包import com.leex.interClass.Outer.Inner;
Inner i3 = new Outer().getInner(); //如果Inner是私有的类，private class Innter{}
Outer.Inner i4 = new Outer().getInner();
}
}
class Outer {
private int num = 10;
class Inner {
public void show() {
System.out.println(num);
}
}
public Inner getInner() { //这样写还可以给访问加限制,并用private修饰Inner,提高内部类的安全性
return new Inner();
}
}
普通的类只能被public和默认修饰，内部类可以被public，protected，默认，private
静态内部类
静态内部类可以理解成外部类的静态成员
- 普通的类不能被static修饰，而内部类可以
- 静态内部类只能访问外部内的静态属性，不能访问非静态的属性数
访问
成员内部类被静态修饰后的访问
public class InnerClassDome2 {
public static void main(String[] args) {
Outer2.Inner i = new Outer2.Inner();
Inner i1 = new Inner(); //要导包，一般不这样写，代码可读性差
}
}
class Outer2 {
private static int num = 10;
static class Inner {
public void show() {
System.out.println(num);
}
}
public Inner getInner() { //同样可以用方法访问，但是失去了static的意义
return new Inner();
}
}
内部类为了方便访问加static，为了安全加private
注意
内部类和外部类没有继承关系
/*
面试题：
要求请填空分别输出30，20，10。
注意：
1:内部类和外部类没有继承关系。
2:通过外部类名限定this对象
Outer.this
*/
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
//System.out.println()
//System.out.println(new Outer().num); //也可以
System.out.println(Outer.this.num);
}
}
}
class InnerClassTest {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
局部内部类
1.7之前只能访问final修饰的局部变量
1.8之后可以访问非final修饰的局部变量
public class InnerClassDome2 {
public static void main(String[] args) {
new Outer2().mothed();
}
}
class Outer2 {
private int num = 10;
public void mothed() {
class Inner {
private int num2 = 20;
public void show() {
System.out.println(num); //10
System.out.println(num2); //20
}
}
Inner i = new Inner();
i.show();
}
}
匿名内部类
- 匿名内部类
- 就是内部类的简化写法。
- 前提：存在一个类或者接口
- 这里的类可以是具体类也可以是抽象类。
- 本质是一个继承了该类或者实现了该接口的子类匿名对象。
class Outer2 {
Inner3 i3 = new Inner3() { //在外部类的成员位置，必须要有变量接收对象（多态）
@Override
public void show() {
System.out.println("Inner3");
}
};
public void mothed() {
new Inner() { //在局部位置，可以接收也可以接收
@Override
public void show() {
System.out.println("Inner");
}
}.show(); //直接调用方法，只能用一次
Inner2 i = new Inner2() { //多态
@Override
public void show() {
System.out.println("Inner2");
}
};
i.show(); //获取后调用
i3.show();
}
}
interface Inner{
public void show();
}
abstract class Inner2{
public abstract void show();
}
abstract class Inner3{
public abstract void show();
}
应用
当一个方法的形参是一个接口或抽象类时，传入的应该是一个该接口或抽象类的具体子类的对象，所以可以使用匿名内部类
/*
匿名内部类在开发中的使用
*/
interface Person {
public abstract void study();
}
class PersonDemo {
//接口名作为形式参数
//其实这里需要的不是接口，而是该接口的实现类的对象
public void method(Person p) {
p.study();
}
}
//实现类
class Student implements Person {
public void study() {
System.out.println("好好学习,天天向上");
}
}
class InnerClassTest2 {
public static void main(String[] args) {
//测试
PersonDemo pd = new PersonDemo();
Person p = new Student();
pd.method(p);
System.out.println("--------------------");
//匿名内部类在开发中的使用
//匿名内部类的本质是继承类或者实现了接口的子类匿名对象
pd.method(new Person(){
public void study() {
System.out.println("好好学习,天天向上");
}
});
}
}