【Java寒假打卡】Java基础-內部类

概述

内部类：在一个类中定义一个类

package com.hfut.edu.test2;

public class TestInner1 {
    public static void main(String[] args) {

        // 外部类名.内部类名  对象名 = new 外部类对象().new 内部类对象();
        Outer.Inner i = new Outer().new Inner();
        i.show();// 调用内部类的方法
    }
}

class Outer{
    class Inner{
        int num = 10;
        public void show(){
            System.out.println("Inner show");

        }
    }
}

成员内部类：按照内部类在类中定义的位置不同，可以分为如下两种形式：

• 在类的成员位置：成员内部类
• 在类的局部位置：局部内部类

成员内部类被修饰符进行修饰

成员内部类可以访问到外部类的成员变量

• 私有的成员内部类

package com.hfut.edu.test2;

public class TestInner1 {
    public static void main(String[] args) {

        // 外部类名.内部类名  对象名 = new 外部类对象().new 内部类对象();
        Outer  o = new Outer();
        o.method();
    }
}

class Outer{
    private class Inner{
        int num = 10;
        public void show(){
            System.out.println("Inner show");
        }
    }
    
    // 通过成员方法调用内部类的成员方法  不可以直接实例化私有成员内部类
    public void method(){
        Inner i = new Inner();
        i.show();
    }
}

私有成员的内部类 不可以实例化对象，要想调用它的成员变量或者方法，必须在外部类中创建一个方法进行调用内部类的成员或者方法

• 静态内部类的创建

外部类名.内部类名 对象名 = new 外部类名.内部类名()

package com.hfut.edu.test2;

public class TestInner1 {
    public static void main(String[] args) {
        // 外部类名.内部类名  对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();// 创建静态内部类的对象
        oi.show();
    }
}

class Outer{
    static class Inner{
        int num = 10;
        public void show(){
            System.out.println("Inner show");

        }
    }
}

调用静态内部类中的静态方法

package com.hfut.edu.test2;

public class TestInner1 {
    public static void main(String[] args) {
        // 外部类名.内部类名  对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();// 创建静态内部类的对象
        oi.show();
        Outer.Inner.method();// 调用静态内部类的静态方法
    }
}

class Outer{
    static class Inner{
        int num = 10;
        public void show(){
            System.out.println("Inner show");
        }

        public static void method(){
            System.out.println("静态内部类中的静态方法");
        }
    }
}

总结：

• private
  私有成员内部类访问：在自己所在的外部类中创建对象进行访问

• static
  静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();

  静态成员内部类的静态方法：外部类名.内部类名.静态方法();

局部内部类

• 局部内部类是在方法中定义的类，所以在外界是无法直接使用，需要在方法内部创建对象并使用
• 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

package com.hfut.edu.test2;

public class TestInner1 {
    public static void main(String[] args) {
        // 外部类名.内部类名  对象名 = new 外部类名.内部类名();
        Outer o = new Outer();
        
        o.method();// 调用内部类的成员方法
    }
}

class Outer{
    public void method(){
        class Inner{
            public void show(){
                System.out.println("局部内部类的成员方法");
            }
        }

        // 局部内部类 必须在方法内部创建对象 并进行访问
        Inner i = new Inner();
        i.show();
    }
}

局部内部类可以访问外部类的成员变量

package com.hfut.edu.test2;

public class TestInner1 {
    public static void main(String[] args) {
        // 外部类名.内部类名  对象名 = new 外部类名.内部类名();
        Outer o = new Outer();

        o.method();// 调用内部类的成员方法
    }
}

class Outer{
    int a = 10;
    public void method(){
        class Inner{
            public void show(){
                System.out.println("局部内部类的成员方法");
                System.out.println(a);// 局部内部类访问外部类的成员变量
            }
        }

        // 局部内部类 必须在方法内部创建对象 并进行访问
        Inner i = new Inner();
        i.show();
    }
}

匿名内部类

概述： 匿名内部类本质上是一个特殊的局部内部类（定义在方法内部）
前提：需要存在一个接口或者类

package com.hfut.edu.test2;
import java.sql.SQLOutput;

public class TestInner1 {
    public static void main(String[] args) {
        // 创建实现类 通过implements关键字实现接口
        // 重写方法
        // 创建实现类对象
        // 调用重写之后的方法

        InterImpl ii = new InterImpl();
        ii.show();

        // 使用匿名内部类
        new Inter(){
            public void show(){
                System.out.println("匿名內部类中的show方法");
            }
        }.show();

        // 如果接口中存在多个方法
        // 创建接口的引用 指向子类对象  多态的应用
        Inter2 i = new Inter2(){
            @Override
            public void method1() {
                System.out.println("xxxx");
            }
            @Override
            public void method2() {
                System.out.println("nnnnnn");
            }
        };
        i.method1();
        i.method2();
    }
}

interface Inter{
    void show();
}

interface  Inter2{
    void method1();
    void method2();
}

// 创建实现类
class InterImpl implements Inter{

    @Override
    public void show() {
        System.out.println("重写接口的show方法");
    }
}

使用场景：当方法的形式参数是接口或者抽象类的时候，可以将匿名內部类作为实际参数进行传递

package com.hfut.edu.test3;

public class Test {
    public static void main(String[] args) {

        // 创建一个匿名内部类 使用接口引用指向实现类对象  就不需要创建一个实现类对象
        Swimming s = new Swimming() {
            @Override
            public void swim() {
                System.out.println("去游泳");
            }
        };

        goSwimming(s);

    }

    public static void goSwimming(Swimming s)
    {
        s.swim();
    }
}


interface Swimming{
    void swim();
}