Java基础(十一)：抽象类、接口、内部类

2025-07-22 23:27:18

Java基础(十一)：抽象类、接口、内部类 Java基础系列文章Java基础(一)：语言概述Java基础(二)：原码、反码、补码及进制之间的运算Java基础(三)：数据类型与进制Java基础(四)：逻辑运算符和位运算符Java基础(五)：流程控制语句Java基础(六)：数组Java基础(七)：面向对象编程Java基础(八)：封装、继承、多态性Java基础(九)：Object 类的使用Java基础(

Java基础(十一)：抽象类、接口、内部类

Java基础系列文章

Java基础(一)：语言概述	Java基础(二)：原码、反码、补码及进制之间的运算	Java基础(三)：数据类型与进制	Java基础(四)：逻辑运算符和位运算符
Java基础(五)：流程控制语句	Java基础(六)：数组	Java基础(七)：面向对象编程	Java基础(八)：封装、继承、多态性
Java基础(九)：Object 类的使用	Java基础(十)：关键字static、代码块、关键字final	Java基础(十一)：抽象类、接口、内部类	Java基础(十二)：枚举类
Java基础(十三)：注解(Annotation)	Java基础(十四)：包装类	Java基础(十五)：异常处理	Java基础(十六)：String的常用API
Java基础(十七)：日期时间API	Java基础(十八)：java比较器、系统相关类、数学相关类	Java基础(十九)：集合框架	Java基础(二十)：泛型
Java基础(二十一)：集合源码	Java基础(二十二)：File类与IO流	Java基础(二十三)：反射机制	Java基础(二十四)：网络编程
Java基础(二十五)：Lambda表达式、方法引用、构造器引用	Java基础(二十六)：Java8 Stream流及Optional类

一、抽象类

由来

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用
类的设计应该保证父类和子类能够共享特征
有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类

1、语法格式

抽象类：被abstract修饰的类
抽象方法：被abstract修饰没有方法体的方法

抽象类的语法格式

代码语言：javascript代码运行次数：0运行复制

[权限修饰符] abstract class 类名{
    
}
[权限修饰符] abstract class 类名 extends 父类{
    
}

抽象方法的语法格式

代码语言：javascript代码运行次数：0运行复制

[其他修饰符] abstract 返回值类型 方法名([形参列表]);

举例：

代码语言：javascript代码运行次数：0运行复制

public abstract class Animal {
    public abstract void eat();
}

代码语言：javascript代码运行次数：0运行复制

public class Cat extends Animal {
    public void eat (){
      	println("小猫吃鱼和猫粮"); 
    }
}

代码语言：javascript代码运行次数：0运行复制

public class CatTest {
 	 public static void main(String[] args) {
        // 创建子类对象
        Cat c = new Cat(); 
       
        // 调用eat方法
        ();
  	}
}

2、abstract修饰类

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象
- 理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义
- 抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体
- 若没有重写全部的抽象方法，仍为抽象类
抽象类中，也有构造方法，是供子类创建对象时，初始化父类成员变量使用的
- 理解：子类的构造方法中，有默认的super()或手动的super(实参列表)，需要访问父类构造方法
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类
- 理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类
- 理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义

、abstract修饰方法

抽象方法只有方法的声明，没有方法体
抽象方法其功能是确定的（通过方法的声明即可确定），只是不知道如何具体实现（体现为没有方法体）
子类必须重写父类中的所有的抽象方法之后，方可实例化。否则，此子类仍然是一个抽象类

注意事项

不能用abstract修饰变量、代码块、构造器
不能用abstract修饰私有方法、静态方法、final的方法、final的类
- 私有方法不能重写
- 避免使用类调用静态方法（没实现没意义）
- final方法不能被重写
- final类不能有子类

二、接口

1、定义格式

接口的定义，它与定义类方式相似，但是使用 interface 关键字
它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型
- 引用数据类型：数组，类，枚举，接口，注解

代码语言：javascript代码运行次数：0运行复制

[修饰符] interface 接口名{
    //接口的成员列表：
    // 公共的静态常量
    // 公共的抽象方法
    
    // 公共的默认方法（JDK1.8以上）
    // 公共的静态方法（JDK1.8以上）
    // 私有方法（JDK1.9以上）
}

举例：

代码语言：javascript代码运行次数：0运行复制

public interface USB{
    //静态常量
    long MAX_SPEED = 500*1024*1024;//500MB/s

    //抽象方法
    void in();
    void out();

    //默认方法
    default void start(){
        println("开始");
    }
    default void stop(){
        println("结束");
    }

    //静态方法
    static void show(){
        println("USB .0可以同步全速地进行读写操作");
    }
}

2、接口的说明

在JDK8.0 之前，接口中只允许出现：
- 公共的静态的常量：其中public static final可以省略
- 公共的抽象的方法：其中public abstract可以省略
- 理解：接口是从多个相似类中抽象出来的规范，不需要提供具体实现
在JDK8.0 时，接口中允许声明默认方法和静态方法：
- 公共的默认的方法：其中public 可以省略，建议保留，但是default不能省略
- 公共的静态的方法：其中public 可以省略，建议保留，但是static不能省略
在JDK9.0 时，接口又增加了：
- 私有方法

除此之外，接口中没有构造器，没有初始化块，因为接口中没有成员变量需要动态初始化

、接口的使用规则

.1、类实现接口

接口不能创建对象，但是可以被类实现（implements ，类似于被继承）
类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类
实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字

代码语言：javascript代码运行次数：0运行复制

【修饰符】 class 实现类  implements 接口{
	// 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
  	// 重写接口中默认方法【可选】
}

【修饰符】 class 实现类 extends 父类 implements 接口{
    // 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
  	// 重写接口中默认方法【可选】
}

注意

如果接口的实现类是非抽象类，那么必须重写接口中所有抽象方法
默认方法可以选择保留，也可以重写
- 重写时，default单词就不要再写了，它只用于在接口中表示默认方法，到类中就没有默认方法的概念了
接口中的静态方法不能被继承也不能被重写

.2、接口的多实现

之前学过，在继承体系中，一个类只能继承一个父类
而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现
并且，一个类能继承一个父类，同时实现多个接口

代码语言：javascript代码运行次数：0运行复制

【修饰符】 class 实现类  implements 接口1，接口2，接口。。。{
	// 重写接口中所有抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
  	// 重写接口中默认方法【可选】
}

【修饰符】 class 实现类 extends 父类 implements 接口1，接口2，接口。。。{
    // 重写接口中所有抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
  	// 重写接口中默认方法【可选】
}

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次

.、接口的多继承

一个接口能继承另一个或者多个接口
接口的继承也使用 extends 关键字，子接口继承父接口的方法

定义父接口：

代码语言：javascript代码运行次数：0运行复制

public interface Chargeable {
    void charge();
    void in();
    void out();
}

定义子接口：

代码语言：javascript代码运行次数：0运行复制

public interface UsbC extends Chargeable,USB {
    void reverse();
}

定义子接口的实现类：

代码语言：javascript代码运行次数：0运行复制

public class TypeCConverter implements UsbC {
    @Override
    public void reverse() {
        println("正反面都支持");
    }

    @Override
    public void charge() {
        println("可充电");
    }

    @Override
    public void in() {
        println("接收数据");
    }

    @Override
    public void out() {
        println("输出数据");
    }
}

所有父接口的抽象方法都有重写
方法签名相同的抽象方法只需要实现一次

.4、接口与实现类对象构成多态引用

实现类实现接口，类似于子类继承父类
因此，接口类型的变量与实现类的对象之间，也可以构成多态引用
通过接口类型的变量调用方法，最终执行的是你new的实现类对象实现的方法体

接口的不同实现类：

代码语言：javascript代码运行次数：0运行复制

public class Mouse implements USB {
    @Override
    public void out() {
        println("发送脉冲信号");
    }

    @Override
    public void in() {
        println("不接收信号");
    }
}

代码语言：javascript代码运行次数：0运行复制

public class KeyBoard implements USB{
    @Override
    public void in() {
        println("不接收信号");
    }

    @Override
    public void out() {
        println("发送按键信号");
    }
}

测试类：

代码语言：javascript代码运行次数：0运行复制

public class TestComputer {
    public static void main(String[] args) {
        Computer computer = new Computer();
        USB usb = new Mouse();
        computer.setUsb(usb);
        usb.start();
        ();
        usb.in();
        usb.stop();
        println("--------------------------");

        usb = new KeyBoard();
        computer.setUsb(usb);
        usb.start();
        ();
        usb.in();
        usb.stop();
    }
}

.5、使用接口的静态成员

接口不能直接创建对象，但是可以通过接口名直接调用接口的静态方法和静态常量

代码语言：javascript代码运行次数：0运行复制

public class TestUSB {
    public static void main(String[] args) {
        //通过“接口名.”调用接口的静态方法 (JDK8.0才能开始使用)
        USB.show();
        //通过“接口名.”直接使用接口的静态常量
        println(USB.MAX_SPEED);
    }
}

.5、使用接口的静态方法

对于接口的静态方法，直接使用“接口名.”进行调用即可
- 也只能使用“接口名."进行调用，不能通过实现类的对象进行调用
对于接口的抽象方法、默认方法，只能通过实现类对象才可以调用
- 接口不能直接创建对象，只能创建实现类的对象

代码语言：javascript代码运行次数：0运行复制

public class TestMobileHDD {
    public static void main(String[] args) {
        //创建实现类对象
        MobileHDD b = new MobileHDD();

        //通过实现类对象调用重写的抽象方法，以及接口的默认方法，如果实现类重写了就执行重写的默认方法，如果没有重写，就执行接口中的默认方法
        b.start();
        b.in();
        b.stop();

        //通过接口名调用接口的静态方法
//        MobileHDD.show();
//        b.show();
        Usb.show();
    }
}

4、JDK8中相关冲突问题

4.1、默认方法冲突问题

类优先原则

当一个类，既继承一个父类，又实现若干个接口时
父类中的成员方法与接口中的抽象方法重名
子类就近选择执行父类的成员方法

定义接口：

代码语言：javascript代码运行次数：0运行复制

public interface Friend {
    default void date(){//约会
        println("吃喝玩乐");
    }
}

定义父类：

代码语言：javascript代码运行次数：0运行复制

public class Father {
    public void date(){//约会
        println("爸爸约吃饭");
    }
}

定义子类：

代码语言：javascript代码运行次数：0运行复制

public class Son extends Father implements Friend {
    @Override
    public void date() {
        //(1)不重写默认保留父类的
        //(2)调用父类被重写的
//        super.date();
        //()保留父接口的
//        Friend.super.date();
        //(4)完全重写
        println("跟康师傅学Java");
    }
}

定义测试类：

代码语言：javascript代码运行次数：0运行复制

public class TestSon {
    public static void main(String[] args) {
        Son s = new Son();
        s.date();
    }
}

调用父类方法：super.方法名()
调用父接口默认方法：类名.super.方法名()

接口冲突（左右为难）

当一个类同时实现了多个父接口，而多个父接口中包含方法签名相同的默认方法时，怎么办呢？

声明接口：

代码语言：javascript代码运行次数：0运行复制

public interface BoyFriend {
    default void date(){//约会
        println("神秘约会");
    }
}

选择保留其中一个，通过“接口名.super.方法名"的方法选择保留哪个接口的默认方法

代码语言：javascript代码运行次数：0运行复制

public class Girl implements Friend,BoyFriend{

    @Override
    public void date() {
        //(1)保留其中一个父接口的
//        Friend.super.date();
//        BoyFriend.super.date();
        //(2)完全重写
        println("跟康师傅学Java");
    }
}

当一个子接口同时继承了多个接口，而多个父接口中包含方法签名相同的默认方法时，怎么办呢？

另一个父接口：

代码语言：javascript代码运行次数：0运行复制

public interface USB2 {
    //静态常量
    long MAX_SPEED = 60*1024*1024;//60MB/s

    //抽象方法
    void in();
    void out();

    //默认方法
    public default void start(){
        println("开始");
    }
    public default void stop(){
        println("结束");
    }

    //静态方法
    public static void show(){
        println("USB 2.0可以高速地进行读写操作");
    }
}

子接口：

代码语言：javascript代码运行次数：0运行复制

public interface USB extends USB2,USB {
    @Override
    default void start() {
        println("Usb.start");
    }

    @Override
    default void stop() {
        println("Usb.stop");
    }
}

子接口重写默认方法时，default关键字可以保留
子类重写默认方法时，default关键字不可以保留

4.2、常量冲突问题

当子类继承父类又实现父接口，而父类中存在与父接口常量同名的成员变量，并且该成员变量名在子类中仍然可见
当子类同时实现多个接口，而多个接口存在相同同名常量

此时在子类中想要引用父类或父接口的同名的常量或成员变量时，就会有冲突问题

父类和父接口：

代码语言：javascript代码运行次数：0运行复制

public class SuperClass {
    int x = 1;
}

代码语言：javascript代码运行次数：0运行复制

public interface SuperInterface {
    int x = 2;
    int y = 2;
}

代码语言：javascript代码运行次数：0运行复制

public interface MotherInterface {
    int x = ;
}

子类：

代码语言：javascript代码运行次数：0运行复制

public class SubClass extends SuperClass implements SuperInterface,MotherInterface {
    public void method(){
//        println("x = " + x);//模糊不清
        println("super.x = " + super.x);
        println("SuperInterface.x = " + SuperInterface.x);
        println("MotherInterface.x = " + MotherInterface.x);
        println("y = " + y);//没有重名问题，可以直接访问
    }
}

5、接口与抽象类之间的对比

6、面试题

1、为什么接口中只能声明公共的静态的常量？

因为接口是标准规范，那么在规范中需要声明一些底线边界值
当实现者在实现这些规范时，不能去随意修改和触碰这些底线，否则就有“危险”
例如
- USB1.0规范中规定最大传输速率是1.5Mbps，最大输出电流是5V/500mA
- USB.0规范中规定最大传输速率是5Gbps(500MB/s)，最大输出电流是5V/900mA

2、为什么JDK8.0 之后允许接口定义静态方法和默认方法呢？

静态方法
- 因为之前的标准类库设计中，有很多Collection/Colleti或者Path/Paths这样成对的接口和类
- 后面的类中都是静态方法，而这些静态方法都是为前面的接口服务的
- 那么这样设计一对API，不如把静态方法直接定义到接口中使用和维护更方便
默认方法
- 我们要在已有的老版接口中提供新方法时
- 如果添加抽象方法，就会涉及到原来使用这些接口的类就会有问题
- 那么为了保持与旧版本代码的兼容性，只能允许在接口中定义默认方法实现
- 比如：Java8中对Collection、List、Comparator等接口提供了丰富的默认方法

、为什么JDK1.9要允许接口定义私有方法呢？

因为有了默认方法和静态方法这样具有具体实现的方法
那么就可能出现多个方法由共同的代码可以抽取
而这些共同的代码抽取出来的方法又只希望在接口内部使用，所以就增加了私有方法

三、内部类

1、概述

什么是内部类

将一个类A定义在另一个类B里面
- 里面的那个类A就称为内部类（InnerClass）
- 类B则称为外部类（OuterClass）

为什么要声明内部类呢？

具体来说，当一个事物A的内部，还有一个部分需要一个完整的结构B进行描述
而这个内部的完整的结构B又只为外部事物A提供服务，不在其他地方单独使用
那么整个内部的完整结构B最好使用内部类

内部类的分类

2、成员内部类

概述

如果成员内部类中不使用外部类的非静态成员，那么通常将内部类声明为静态内部类，否则声明为非静态内部类

语法格式：

代码语言：javascript代码运行次数：0运行复制

[修饰符] class 外部类{
    [其他修饰符] [static] class 内部类{
    }
}

成员内部类的使用特征，概括来讲有如下两种角：

成员内部类作为类的成员的角：
- 和外部类不同，Inner class还可以声明为private或protected（四种都可以）
- 可以调用外部类的结构。（注意：在静态内部类中不能使用外部类的非静态成员）
- Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量
成员内部类作为类的角：
- 可以在内部定义属性、方法、构造器等结构
- 可以继承自己的想要继承的父类，实现自己想要实现的父接口们，和外部类的父类和父接口无关
- 可以声明为abstract类，因此可以被其它的内部类继承
- 可以声明为final的，表示不能被继承
- 编译以后生成OuterClass$字节码文件（也适用于局部内部类）

注意点：

外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式
成员内部类可以直接使用外部类的所有成员，包括私有的数据
当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的

创建成员内部类对象

实例化静态内部类

代码语言：javascript代码运行次数：0运行复制

外部类名.静态内部类名 变量 = 外部类名.静态内部类名();
变量.非静态方法();

实例化非静态内部类

代码语言：javascript代码运行次数：0运行复制

外部类名 变量1 = new 外部类();
外部类名.非静态内部类名 变量2 = 变量 非静态内部类名();
变量2.非静态方法();

举例：

代码语言：javascript代码运行次数：0运行复制

public class TestMemberInnerClass {
    public static void main(String[] args) {
        //创建静态内部类实例，并调用方法
        Outer.StaticInner inner = new Outer.StaticInner();
        inner.inFun();
        //调用静态内部类静态方法
        Outer.StaticInner.inMethod();

        println("*****************************");
        
        //创建非静态内部类实例（方式1），并调用方法
        Outer outer = new Outer();
         inner1 =  oStaticInner();
        inner1.inFun();

        //创建非静态内部类实例（方式2）
         inner2 = outer.getoStaticInner();
        inner1.inFun();
    }
}
class Outer{
    private static String a = "外部类的静态a";
    private static String b  = "外部类的静态b";
    private String c = "外部类对象的非静态c";
    private String d = "外部类对象的非静态d";

    static class StaticInner{
        private static String a ="静态内部类的静态a";
        private String c = "静态内部类对象的非静态c";
        public static void inMethod(){
            println("Inner.a = " + a);
            println("Outer.a = " + Outer.a);
            println("b = " + b);
        }
        public void inFun(){
            println("Inner.inFun");
            println("Outer.a = " + Outer.a);
            println("Inner.a = " + a);
            println("b = " + b);
            println("c = " + c);
//            println("d = " + d);//不能访问外部类的非静态成员
        }
    }

    class oStaticInner{
        private String a = "非静态内部类对象的非静态a";
        private String c = "非静态内部类对象的非静态c";

        public void inFun(){
            println("oStaticInner.inFun");
            println("Outer.a = " + Outer.a);
            println("a = " + a);
            println("b = " + b);
            println(" = " + );
            println("c = " + c);
            println("d = " + d);
        }
    }


    public oStaticInner getoStaticInner(){
        return new oStaticInner();
    }
}

、局部内部类

.1、非匿名局部内部类

语法格式：

代码语言：javascript代码运行次数：0运行复制

[修饰符] class 外部类{
    [修饰符] 返回值类型  方法名(形参列表){
            [final/abstract] class 内部类{
    	}
    }    
}

编译后有自己的独立的字节码文件，只不过在内部类名前面冠以外部类名、$符号、编号
- 这里有编号是因为同一个外部类中，不同的方法中存在相同名称的局部内部类
和成员内部类不同的是，它前面不能有权限修饰符等
局部内部类如同局部变量一样，有作用域
局部内部类中是否能访问外部类的非静态的成员，取决于所在的方法

举例：

代码语言：javascript代码运行次数：0运行复制

public class TestLocalInner {
    public static void main(String[] args) {
        ();
        println("-------------------");

        Outer out = new Outer();
        ();
        println("-------------------");

        Runner runner = Outer.getRunner();
        runner.run();

    }
}
class Outer{

    public static void outMethod(){
        println("");
        final String c = "局部变量c";
        class Inner{
            public void inMethod(){
                println("Inner.inMethod");
                println(c);
            }
        }

        Inner in = new Inner();
        in.inMethod();
    }

    public void outTest(){
        class Inner{
            public void inMethod1(){
                println("Inner.inMethod1");
            }
        }

        Inner in = new Inner();
        in.inMethod1();
    }

    public static Runner getRunner(){
        class LocalRunner implements Runner{
            @Override
            public void run() {
                println("LocalRunner.run");
            }
        }
        return new LocalRunner();
    }

}
interface Runner{
    void run();
}

.2、匿名内部类

因为考虑到这个子类或实现类是一次性的，那么我们“费尽心机”的给它取名字，就显得多余
那么我们完全可以使用匿名内部类的方式来实现，避免给类命名的问题

语法格式：

代码语言：javascript代码运行次数：0运行复制

new 父类([实参列表]){
    重写方法...
}

代码语言：javascript代码运行次数：0运行复制

new 父接口(){
    重写方法...
}

举例1：使用匿名内部类的对象直接调用方法：

代码语言：javascript代码运行次数：0运行复制

interface A{
	void a();
}
public class Test{
    public static void main(String[] args){
    	new A(){
			@Override
			public void a() {
				println("aaaa");
			}
    	}.a();
    }
}

举例2：通过父类或父接口的变量多态引用匿名内部类的对象

代码语言：javascript代码运行次数：0运行复制

interface A{
	void a();
}
public class Test{
    public static void main(String[] args){
    	A obj = new A(){
			@Override
			public void a() {
				println("aaaa");
			}
    	};
    	obj.a();
    }
}

举例：匿名内部类的对象作为实参

代码语言：javascript代码运行次数：0运行复制

interface A{
	void method();
}
public class Test{
    public static void test(A a){
    	();
    }
    
    public static void main(String[] args){
    	test(new A(){

			@Override
			public void method() {
				println("aaaa");
			}
    	});
    }   
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。原始发表：2024-02-24，如有侵权请联系 cloudcommunity@tencent 删除接口java对象继承基础

#感谢您对电脑配置推荐网 - 最新i3 i5 i7组装电脑配置单推荐报价格的认可，转载请说明来源于"电脑配置推荐网 - 最新i3 i5 i7组装电脑配置单推荐报价格

本文地址：http://www.dnpztj.cn/biancheng/1161974.html

本站网友 seo网站关键词优化	5分钟前发表
补码及进制之间的运算Java基础(三)：数据类型与进制Java基础(四)：逻辑运算符和位运算符Java基础(五)：流程控制语句Java基础(六)：数组Java基础(七)：面向对象编程Java基础(八)：封装
本站网友 sayno	25分钟前发表
概述什么是内部类将一个类A定义在另一个类B里面里面的那个类A就称为内部类（InnerClass）类B则称为外部类（OuterClass）为什么要声明内部类呢？具体来说
本站网友鼻翼缺损修复	6分钟前发表
接口的多继承一个接口能继承另一个或者多个接口接口的继承也使用 extends 关键字
本站网友申购新股的技巧	7分钟前发表
编译无法通过而报错
本站网友麦卡隆	10分钟前发表
abstract修饰方法抽象方法只有方法的声明
本站网友郑多燕减肥前后	2分钟前发表
可以考虑内部类声明为静态的创建成员内部类对象实例化静态内部类代码语言：javascript代码运行次数：0运行复制外部类名.静态内部类名变量 = 外部类名.静态内部类名(); 变量.非静态方法();实例化非静态内部类代码语言：javascript代码运行次数：0运行复制外部类名变量1 = new 外部类(); 外部类名.非静态内部类名变量2 = 变量非静态内部类名(); 变量2.非静态方法();举例：代码语言：javascript代码运行次数：0运行复制public class TestMemberInnerClass { public static void main(String[] args) { //创建静态内部类实例
本站网友美国在线时代华纳	18分钟前发表
面试题1
本站网友严彬	4分钟前发表
而父类中存在与父接口常量同名的成员变量
本站网友国产电动汽车	19分钟前发表
直接使用“接口名.”进行调用即可也只能使用“接口名."进行调用
本站网友什么叫大盘	13分钟前发表
静态方法
本站网友外面的世界很精彩	23分钟前发表
那么可以不重写 // 重写接口中默认方法【可选】 }接口中
本站网友孕妇哈密瓜	13分钟前发表
它只用于在接口中表示默认方法
本站网友刘昊然图片	1分钟前发表
就会涉及到原来使用这些接口的类就会有问题那么为了保持与旧版本代码的兼容性

Java基础(十一)：抽象类、接口、内部类