Java基础语法练习36（内部类）

目录

一、局部内部类

二、匿名内部类

三、成员内部类

---

一个类的内部嵌套了另一个类结构。被嵌套的类称为内部类

基本语法如下：

class Outclass{   //外部类
    class InnerClass{   //内部类
         
    }
}
class OuterClass{      //外部其他类
    
}

内部类的分类：

定义在外部局部位置上（比如方法内）： 1.局部内部类（有类名） 2.匿名内部类（没有类名，重点！！！！）

定义在外部类的成员位置上：1.成员内部类（无static修饰） 2.静态内部类（有static修饰）

一、局部内部类

直接上代码，代码如下：

public class innerClass01 {
    public static void main(String[] args){
        OuterClass01 outer= new OuterClass01();
        outer.m1();
    }
}

class OuterClass01{
    private int n1 = 100;
    private void m2(){
        System.out.println("m2");
    }

    public void m1(){  //外部类的方法
        //1.局部内部类是定义在外部类的局部位置，通常在方法
        //3.不能添加访问修饰符，但是可以使用final修饰
        //4.作用域 ： 仅仅在定义它的方法或代码块中（相当于一个局部变量）
        class InnerClass01{    //局部内部类（本质仍然是一个类） 五大特点：属性、方法、构造器、代码块和内部类
            private int n1 = 500;
            //2.可以直接访问外部类的所有成员，包含私有的
            public void f1(){
                //局部内部类可以直接访问外部类成员
                System.out.println("内部类的n1="+n1);  //7.如果外部类和局部内部类的成员重名时，遵循就近原则
                System.out.println("外部类的n1="+OuterClass01.this.n1);  //8.如果就想访问外部类，则使用：外部类名.this.成员
                m2();
            }
        }

        //6.外部类在方法中，可以创建局部内部类的对象，然后调用方法即可
        InnerClass01 i1 = new InnerClass01();
        i1.f1();

    }
}

二、匿名内部类

最关键的一点就是把匿名类看成一个普通类即可，只是说没有名字

示例代码如下：

public class AnonymousInnerClass {
    public static void main(String[] args){
        Outer01 O1 = new Outer01();
        O1.m1();

    }
}

class Outer01{
    private int n1 = 10;
    public void m1(){

        //1.father的编译类型为Father
        //2.father的运行类型为
        //若把大括号去除，则变为类的实例化
        Father father = new Father("jack"){

            public void test(){
                System.out.println("使用匿名内部类重写test方法 ");
            }
        };
        father.test();  //3.把匿名类看成一个普通类即可，只是说没有名字
        System.out.println("father对象的运行类型="+father.getClass());

        A a = new A(){//3.把匿名类看成一个普通类即可，只是说没有名字
            public void cry(){
                System.out.println("A开始哭了");
            }
        };
        a.cry();
    }
}
interface A{
    void cry();
}

class Father{
    public Father(String name){
        super();
    }
    public void test(){

    }
}

匿名内部类的细节，可以把其看做一个对象实例，但是只使用一次。示例代码如下：

package interClass;

public class AnonymousInnerClass {
    public static void main(String[] args){
        Outer01 O1 = new Outer01();
        O1.m1();

    }
}

class Outer01{
    private int n1 = 10;
    public void m1(){

        //1.father的编译类型为Father
        //2.father的运行类型为
        //若把大括号去除，则变为类的实例化
        new Father("jack"){

            public void test(){
                System.out.println("使用匿名内部类重写test方法 ");
            }
        }.test();

        new A(){//3.把匿名类看成一个普通类即可，只是说没有名字
            public void cry(){
                System.out.println("A开始哭了");
            }
        }.cry();
    }
}
interface A{
    void cry();
}

class Father{
    public Father(String name){
        super();
    }
    public void test(){

    }
}

匿名内部类的实践，匿名内部类可以当做形参进行传递，直接看代码如下：

package interClass;

public class AnonymousInnerClass {
    public static void main(String[] args){
        //匿名内部类可以当做实参直接传递，简洁高效
        f1(new IA() {
            @Override
            public void show() {
                System.out.println("show");
            }
        });

    }
    public static void f1(IA ia){
        ia.show();
    }
}

//接口
interface IA{
    void show();
}

三、成员内部类

无static进行修饰，且是定义在外部类的成员位置上，不在方法和代码块内，所以可以使用修饰符进行修饰。

较为简单，代码如下：

public class AnonymousInnerClass {
    public static void main(String[] args){
        Outer02 a1 = new Outer02();
        a1.q1();

        //外部其他类使用成员内部类的两种方式
        //第一种 把new Inner02()看成是a1的成员
        Outer02.Inner02 inner02 = a1.new Inner02();
        inner02.say();
        //编写一个方法返回对象实例
        Outer02.Inner02 inner03 = a1.getInner02();
        inner03.say();
    }

}

class Outer02{
    private int n1 = 10;
    public String name = "jack";
    class Inner02{
        public void say(){
            System.out.println("n1 = "+n1+", name = "+name);
        }
    }

    public void q1(){
        Inner02 i = new Inner02();
        i.say();
    }

    public Inner02 getInner02(){   //第二种外部其他类的访问方法
        return new Inner02();
    }


}

四、静态内部类

有static修饰、跟static一样，只能访问static修饰的，可以使用修饰符进行修饰，不做具体介绍