java基础 - 内部类-CSDN博客

本文链接：https://blog.csdn.net/jyx_boy/article/details/134162898

本文详细介绍了Java中的内部类（包括成员内部类、静态内部类、局部内部类和匿名内部类），讨论了它们的作用、使用场景、访问权限以及JDK版本变化。同时，还提到了lambda表达式的出现，如何简化匿名内部类的使用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

内部类

概念

在类的内部再次声明定义类

作用

打破封装又不破坏封装

成员内部类

位置：类以内方法以外，和属性方法平级

[public ] class 外部类类名{
	[public] class 内部类名{
	}
}

使用

当外部类属性，内部类属性内部类局部变量重名时；
- 局部变量：变量名
- 内部类属性：this.属性名
- 外部类属性：外部类类名.this.属性名
2.创建成员内部类的对象必须借助外部类的对象

外部类类名.内部类类名 对象名=外部类对象名.new 内部类类名（）；

//创建一个外部类的对象
        Outer1 o1 = new Outer1();
        //创建内部类的对象
        Outer1.Inner1 i1 = o1.new Inner1();
        i1.mb();

8.0版本及前后的JDK成员内部类中不允许定义静态内容,只可访问.
后期高版本的JDK中成员内部类中也可以定义静态内容,并且可以通过外部类类名.内部类类名.静态内容的方式直接访问

静态内容类

位置：与成员内部类相同

[public] class 外部类名{
	[public] static class 内部类类名{

	} 
}

使用

可以定义静态内容，但是无法访问外部类非静态内容
当外部类属性与内部类属性重名时；
- 在内部类的静态方法中重名
  - 内部类属性：内部类类名.属性名
  - 外部类属性：外部类类名.属性名
- 在内部类的非静态方法中重名
  - 内部类属性: 内部类类名.属性名 | this.属性名
  - 外部类属性: 外部类类名.属性名
静态内部类的静态内容可以通过外部类类名.内部类类名.静态内容的方式访问
静态内部类对象的创建必须基于外部类类名

外部类类名. 内部类类名 对象名=new 外部类类名.内部类类名（）；

package com.by.entity;

/**
 * 静态内部类
 */
public class Outer2 {
    int a=100;//非静态属性
    static int b = 200;//静态属性
    static String str = "外部类静态属性";

    public static class Inner2{
        static String str = "内部类静态属性";

        public static void method(){
            String str = "内部类局部变量";
            System.out.println(str);//局部变量
            System.out.println(Inner2.str);//内部类属性
            System.out.println(Outer2.str);//外部类属性
            //System.out.println(a);
            System.out.println(b);
        }
        public void ma(){
            String str = "内部类局部变量";
            System.out.println(str);
            System.out.println(this.str);//静态内部类中的实例方法执行时一定存在当前对象
            System.out.println(Outer2.str);//外部类的实例对象this无法进入静态内部类使用,无法使用Outer2.this
           // System.out.println(a);
            System.out.println(b);
        }


    }
}

 //直接访问内部类的静态内容
        Outer2.Inner2.method();
        //访问静态内部类的非静态内容
        Outer2.Inner2 i2 = new Outer2.Inner2();
        i2.ma();

局部内部类

位置：外部类方法内部，与外部类局部变量平级

[public] class 外部类类名{
	访问修饰符 返回值类型 方法名{形参列表}{
	class 内部类类名{
		
		}
	}
}

使用

无法在声明类的时候添加访问修饰符
作用范围：与局部变量一致
无法访问外部类的局部变量，可以访问局部变量
- JDK7.0之前：访问内容必须通过final修饰
- JDK7.0之后：事实上的常量即可（未二次赋值）
局部内部类对象的创建只能在所属方法内部完成


package com.by.entity;

/**
 * 局部内部类
 */
public class Outer3 {


    public void method(){

        String str = "外部类的局部变量";
       // str = "正在更改外部类局部变量的值";

        //局部内部类
        class Inner{

            public void get(){
                System.out.println(str);
            }
        }

        //创建内部类对象
        Inner inner = new Inner();
        inner.get();
    }
}

匿名内部类

作用

创建一个接口的实现类对象或者父类的子类对象

语法

接口名|父类类名 引用名=new 接口名|父类类名（）{
	//实现类内容
}

使用

必须实现一个接口或者继承一个父类
对象创建必须使用多态
一个匿名内部类只能创建一个对象
存在一个默认的无参构造
类中无法显示定义构造
类中可以定义独有内容，都是只能在类中使用，无法在类外通过应用调用

匿名内部类无法参与类型强制转换

public interface IA {
    void method();
}

public class Test2 {
    public static void main(String[] args) {
        //利用匿名内部类创建一个IA接口的实现类对象
        IA ia=new IA(){
            //重写接口方法
            public void method(){
                m1();
                System.out.println("这是匿名实现类中的方法method");
            }

            //匿名内部类中的独有方法
            public void m1(){
                System.out.println("这是匿名内部类的独有方法");
            }

        };//IA ia=匿名实现类对象;

        ia.method();
        //无法进行类型强转
       // ia.m1();
    }
}

public abstract class Super {
    public abstract void add(int a,int b);
}

public class Test3 {
    public static void main(String[] args) {
        //利用匿名内部类创建子类对象
        Super s=new Super() {
            @Override
            public void add(int a, int b) {
                System.out.println(a+b);
            }
        };
        s.add(1,1);
    }
}
/*
* 定义一个抽象父类Super,书写抽象方法add(int a,int b),计算参数和输出
* 在测试类中通过匿名内部类创建Super类的子类对象
* 并调用方法测试
*
* */

package com.by.test;

import com.by.dao.impl.StudentComparator;
import com.by.entity.Student;

import java.util.Arrays;
import java.util.Comparator;

public class TestStudent {
    public static void main(String[] args) {
        Student[] ss = {new Student("zhangsan", 20, 98),
                new Student("lisi", 19, 8),
                new Student("wangwu", 23, 60)};


        //Arrays.sort(ss, new StudentComparator());
//利用匿名内部类创建比较器实现类对象并传参
        Arrays.sort(ss,new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //根据年龄从小到大
                if (o1.getAge() > o2.getAge()) {
                    return 1;
                } else if (o1.getAge() < o2.getAge()) {
                    return -1;
                } else {
                    return 0;
                }
            }
        });

        for (int i = 0; i < ss.length; i++) {
            System.out.println(ss[i].getName()+"  "+ss[i].getAge());
        }
    }
}

lambda

JDK8.0

作用

简化部分匿名内部类的书写，可以生成一个接口实现类对象

语法

（形参列表）->{操作语句}
结合引用：
       接口名  引用名=（形参列表）->{操作语句}；

接口的分类

标记式接口：无任何内容
函数式接口：内部只有一个需要重写的方法
常量式接口：内部只声明了属性
普通接口：内部声明了多个需要重写的方法

使用

只能作用于函数式接口
无法定义独有内容，只关注唯一方法的实现
简化标准：
- 形参的数据类型可省
  - 要省都省
- 参数只有一个时，小括号可省
- 操作语句只有一条时，大括号可省
- 操作语句只有一条并且为return语句时，大括号和return都可以省
  - 要省都省

public interface IA {
    void method();
}

public interface IB {
    /**
     * 计算参数之和并输出
     * @param a
     * @param b
     */
    void mb(int a, int b);
}

public interface IC {
    /**
     * 判断n是否为偶数并返回
     * @param n
     * @return
     */
    boolean mc(int n);
}

public class TestLambda {
    public static void main(String[] args) {
        //利用lambda表达式创建一个IA接口的实现类对象
        IA ia=()->System.out.println("这是lambda生成的实现类中的method");
        //IB
        IB ib = (a,b) -> System.out.println(a + b);
        //IC
        IC ic = n -> n % 2 == 0 ? true : false;

        ia.method();
        ib.mb(1, 1);
        System.out.println(ic.mc(10));;

    }
}