Java中类和接口的一些概念_类与接口总概念-优快云博客

本文链接：https://blog.youkuaiyun.com/qq496013218/article/details/78227970

本文详细介绍了Java中的内部类（包括常规内部类、静态内部类、局部内部类和匿名内部类）和接口的概念与使用方式，并探讨了它们带来的优势，如解决多继承问题、实现数据隐藏等。

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

类和接口分别有哪些：

常规内部类，静态内部类，局部内部类，匿名内部类，抽象类，接口。

内部类的一些好处：

1.解决多继承
2.解决继承和实现接口时候方法名相同引起的冲突情况（使用内部类可以间接实现多继承，可以解决实现的多个接口之间，或继承的类与接口之间方法同名的冲突）
3.实现数据隐藏(非内部类是不允许使用private 与protected来修饰类的，但内部类可以。且内部类为private的时候,通过外部类提供方法来访问内部类)

4.内部类拥有外围类的所有元素的访问权限

普通内部类

1.不能有静态属性和方法
2.内部类可以使用外部类的所有属性和方法
3.外部类不能直接使用内部类的属性和方法,使用前必须先实例化

实例：

public class Example {

    private String name ="exampleName";

    public void ExampleMethod(){
        String innerStr = new ExampleInner().innerStr;//在外部类中调用内部类属性
        System.out.println("ExampleMethod->ExampleInner.innerStr = " + innerStr);
        new ExampleInner().ExampleInnerMethod();//在外部类中直接调用属性
    }
    public class ExampleInner {

        private String innerStr = "exampleInnerStr";
        
        public void ExampleInnerMethod(){
            System.out.println("ExampleInnerMethod-> Example.name：" + name);
        }
    }
    public static void main(String[] args) {
        new Example().ExampleMethod();//外部类调用本类方法输出调用内部类的方法及属性的内容
        new Example().new ExampleInner().ExampleInnerMethod();//外部类和内部类实例化后调用内部类方法
        String s = new Example().new ExampleInner().innerStr;//外部类和内部类实例化后调用内部类属性
        System.out.println("s = " + s);
    }
}

静态内部类

1.可以包含静态方法和属性

2.不需要再实例化外部类 StaticOutter.StaticInner in = new StaticOutter.StaticInner();

3.和静态方法不一样的是，静态内部类中可以定义静态的也可以定义非静态的成员

实例：

public class Example {
    private String name ="exampleName";
    private static String name_1 = "name_1";

    public static void ExampleMethod(){
        System.out.println("ExampleMethod");
    }

    /**
     * 可以把静态内部类当成一个外部类的静态成员
     */
    public static class ExampleInner {
        private String name ="exampleInnerName";
        protected String innerStr = "innerStr";
        protected static String staticInnerStr = "staticInnerStr";

        public static void ExampleInnerMethod(){
            //外部类的静态方法,不能调用非静态方法
            ExampleMethod();
            //静态内部类调用外部内的属性及常量必须为static
            System.out.println("ExampleInnerMethod-> Example.name_1：" + name_1);
        }
        public void method(){
            System.out.println("method");
        }
    }
    public static void main(String[] args) {
        //调用内部类的静态方法；方法和属性可直接通过innerClass.方法/属性调用
        Example.ExampleInner.ExampleInnerMethod();
        //调用内部类的静态属性
        String staticInnerStr = Example.ExampleInner.staticInnerStr;
        System.out.println("staticInnerStr = " + staticInnerStr);
        //调用内部类的非静态属性;同包名下使用 new Example.ExampleInner().innerStr;操作
        String innerStr = new ExampleInner().innerStr;
        System.out.println("innerStr = " + innerStr);
        //内部类非静态方法必须要实例化才能调用
        new Example.ExampleInner().method();
    }
}

局部内部类（外部类的方法中的内部类;实际开发中不常用)

可以把局部内部类当作外部类方法中的一个局部变量

1.不能有访问修饰符（public,protected,private,static等）

2.局部内部类在方法中，静态和非静态都可以

2.可以访问方法中的局部变量和类中的所有属性、方法

3.与局部变量不一样的是，局部内部类只能访问 final 修饰的局部变量(也即只能访问常量)

4.局部内部类中不可定义静态变量(不管外部类的方法是不是静态的)

实例：

public class Example {

    private String name="exampleName";

    public void ExampleMethod(final String methodName){
        String exampleMthodStr="exampleMthodStr";
        final String exampleMthodStr_1="exampleMthodStr_1";
        final String name="ExampleMethod-->>name";
        class ExampleInner{
            String innerStr="innerStr";
            //static String innerStr_1="innerStr_1"; //局部内部类不能有静态属性和方法
            public ExampleInner(String methodName) {
                ExampleMethod();//外部类方法
                System.out.println(name);//外部类属性
                System.out.println(methodName);//构造方法参数
                System.out.println("ExampleInner :" + innerStr);//局部内部类属性
                System.out.println("exampleMthodStr_1 :" + exampleMthodStr_1);//局部内部类访问局部变量
                System.out.println("Example :" + Example.this.name);//外部内部类属性
                System.out.println("name :" + name);//局部内部类访问局部变量
                //System.out.println(exampleMthodStr);//错误，只能访问由final修饰的局部变量
            }
            public static void (){
                
            }
        }
        System.out.println("ExampleMethod");
        new ExampleInner(methodName);//初始化局部内部类的构造方法
    }

    /**
     * 外部类普通方法
     */
    public void ExampleMethod(){
        System.out.println("example-->>");
    }
    public static void main(String[] args) {
        new Example().ExampleMethod("main");
    }
}