Java基础——抽象类，接口和内部类（含JDK8接口新特性）

最新推荐文章于 2024-09-30 22:05:13 发布
最新推荐文章于 2024-09-30 22:05:13 发布
阅读量3k 收藏 22
点赞数 12
分类专栏： Java知识汇总 文章标签： 多态 抽象类 java interface 接口
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46215617/article/details/105470283
版权

目录

一 .抽象类

1. 介绍

1.1基本用法

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

  • 用abstract关键字来修饰一个类，这个类叫做抽象类。
    比如：abstract class A{ }

  • 用abstract来修饰一个方法，该方法叫做抽象方法。

    • 抽象方法：只有方法的声明，没有方法的实现。以分号结束：比如：public abstract void talk();

1.2 抽象类的匿名子类

以下代码中的Person类是一个抽象类

① 非匿名的类非匿名的对象

		Worker worker = new Worker();
		method1(worker);//非匿名的类非匿名的对象

② 非匿名的类匿名的对象

method1(new Worker());

③ 匿名子类的对象

            Person p = new Person(){//Person是一个抽象类，不能实例化，这儿运用了多态的性质
			@Override
			public void eat() {
				System.out.println("吃东西");
			}
		};
		
		method1(p);

④ 匿名子类的匿名对象

method1(new Person(){
			@Override
			public void eat() {
				System.out.println("吃好吃东西");
			}
		});

2. 注意事项

  • 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
  • 抽象方法不能包含在非抽象类中。如果抽象父类的子类不能实现所有的抽象方法，那么子类也必须定义为抽象的。换句话说，在抽象类扩展的非抽象子类中，必须实现所有的抽象方法。还要注意到，抽象方法是非静态的。
  • 不能用abstract修饰变量、代码块、构造器。
  • 不能用abstract修饰私有方法、静态方法、final的方法、final的类。但是可以有静态方法，静态方法的好处是不实例化就可由抽象类或子类类名直接调用
  • 可以定义一个抽象类的对象变量，但是他只能引用非抽象类的对象。 如下代码，这里的p是一个抽象类Person的变量，Person引用了一个非抽象子类Student的实例。
Person p = new Student("John");

  • 即使子类的父类是具体的，这个子类也可以是抽象的。

  • 不能使用 new 操作符从一个抽象类创建一个实例，但是抽象类可以用作一种数据类
    型。因此，下面的语句创建一个元素是 CeometricObject 类型的数组是正确的：

GeometricObject[] objects = new CeometricObject[10];

    然后可以创建一个 CeometricObject 的实例，并将它的引用陚值给数组，如下所示： 

objects[0] =new Circle（）;

关于构造器与静态方法的代码如下：

abstract class AbstractClass{
    /**
     * 输出
     */
    abstract void print();

    /**
     *
     */
    public AbstractClass() {//抽象类中可以定义构造器，虽然不能初始化，可以被子类继承
        System.out.println("abstract class");
    }
    public static void staticAbstractMethod() {
        System.out.println("I am static method");
    }
}
/**
 * @author sir
 */
public class AbstractClassTest extends AbstractClass{
    public AbstractClassTest() {
        System.out.println("子类构造器");
    }
    @Override
    void print() {
        System.out.println("test");
    }
    public static void main(String[] args) {
        AbstractClassTest.staticAbstractMethod();//抽象类中可以定义静态方法，可直接由类名调用
        AbstractClass.staticAbstractMethod();
        new AbstractClassTest().print();
    }

}

输出结果：
在这里插入图片描述

二. 接口

1.介绍

1.1 基本用法

接口是一种与类相似的结构，它在许多方面都与抽象类很相似，但是它的目的是指明相关或者不相关类的多个对象的共同行为。接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是 "能不能"的关系。
语法：

修饰符 interface 接口名 {
 /** 常量声明 */
  /** 方法签名 */
}

定义Java类的语法格式：先写extends，后写implements

 class SubClass extends SuperClass implements InterfaceA{ }
  • 接口中不能定义构造器的！意味着接口不可以实例化。
  • Java开发中，接口通过让类去实现(implements)的方式来使用。类和接口之间的关系称为接口继承（ interface inheritance)。因为接口继承和类继承本质上是相同的，所以我们将它们都简称为继承。如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化。如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类。
  • Java类可以实现多个接口，弥补了Java单继承性的局限性
    格式：class AA extends BB implements CC,DD,EE
  • 接口与接口之间可以继承，而且可以多继承

1.2接口和抽象类之间的对比

在这里插入图片描述
接口示例：
在这里插入图片描述

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

        Computer computer = new Computer();
        //1.创建了接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();
        computer.transferData(flash);

        //2. 创建了接口的非匿名实现类的匿名对象
        computer.transferData(new Printer());

        //3. 创建了接口的匿名实现类的非匿名对象
        USB phone = new USB(){

            @Override
            public void start() {
                System.out.println("手机开始工作");
            }

            @Override
            public void stop() {
                System.out.println("手机结束工作");
            }

        };
        computer.transferData(phone);


        //4. 创建了接口的匿名实现类的匿名对象

        computer.transferData(new USB(){
            @Override
            public void start() {
                System.out.println("mp3开始工作");
            }

            @Override
            public void stop() {
                System.out.println("mp3结束工作");
            }
        });
    }
}

class Computer{

    public void transferData(USB usb){//USB usb = new Flash();
        usb.start();

        System.out.println("具体传输数据的细节");

        usb.stop();
    }


}

interface USB{
    //常量：定义了长、宽、最大最小的传输速度等

    void start();

    void stop();

}

class Flash implements USB{

    @Override
    public void start() {
        System.out.println("U盘开启工作");
    }

    @Override
    public void stop() {
        System.out.println("U盘结束工作");
    }

}

class Printer implements USB{
    @Override
    public void start() {
        System.out.println("打印机开启工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机结束工作");
    }

}

在这里插入图片描述

1.3JDK8接口新特性

除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
Java 8中，你可以为接口添加静态方法和默认方法。从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。

  • 静态方法：使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。 我们经常在相互一起使用的类中使用静态方法。你可以在标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。
  • 默认方法：默认方法使用 default 关键字修饰。可以通过实现类对象来调用。 我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。比如：java 8 API中对Collection、List、Comparator等接口提供了丰富的默认方法。
  • 若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现：接口冲突。
    • 解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突。
  • 若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非抽象方法，则不会出现冲突问题。因为此时遵守：类优先原则。接口中具有相同名称和参数的默认方法会被忽略
public interface CompareA {
	
	//静态方法
	public static void method1(){
		System.out.println("CompareA:北京");
	}
	//默认方法
	public default void method2(){
		System.out.println("CompareA：上海");
	}
	
	default void method3(){
		System.out.println("CompareA：上海");
	}
}

**********************************************

public interface CompareB {
	
	default void method3(){
		System.out.println("CompareB：上海");
	}
	
}
public class SuperClass {
	
	public void method3(){
		System.out.println("SuperClass:北京");
	}
	
}

**********************************************

public class SubClassTest {
	
	public static void main(String[] args) {
		SubClass s = new SubClass();
		
//		s.method1();
//		SubClass.method1();
		//知识点1：接口中定义的静态方法，只能通过接口来调用。
		CompareA.method1();
		//知识点2：通过实现类的对象，可以调用接口中的默认方法。
		//如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
		s.method2();
		//知识点3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，
		//那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。-->类优先原则
		//知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
		//那么在实现类没有重写此方法的情况下，报错。-->接口冲突。
		//这就需要我们必须在实现类中重写此方法
		s.method3();
		
	}
	
}

*************************************************************

class SubClass extends SuperClass implements CompareA,CompareB{
	
	public void method2(){
		System.out.println("SubClass：上海");
	}
	
	public void method3(){
		System.out.println("SubClass：深圳");
	}
	
	//知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法
	public void myMethod(){
		method3();//调用自己定义的重写的方法
		super.method3();//调用的是父类中声明的
		//调用接口中的默认方法
		CompareA.super.method3();
		CompareB.super.method3();
	}
}

输出结果：
在这里插入图片描述

2. Comparable接口

2.1 用法

  1. Comparable 接口定义了 compareTo 方法，用于比较对象 。
  2. compareTo 方法判断这个对象相对于给定对象 o 的顺序，并且当这个对象小于、等于或大于给定对象 o 时，分别返回负整数、0或正整数。
  3. Comparable 接口是一个泛型接口。在实现该接口时，泛型类型 E 被替换成一种具体的类型。
  4. Java 类库中的许多类实现了 Comparable 接口以定义对象的自然顺序。Byte、Short、Integer、Long、Float、Double、Character、Biglnteger、BigDecimalx Calendar、String以及 Date 类 都 实 现 了 Comparable 接 口。
import java.util.Date;

/**
 * @author mazouri
 * @create 2020-04-12 17:40
 */
public class CompareTest {
    public static void main(String[] args) {
        System.out.println((new Integer(3).compareTo(new Integer(5))));
       // System.out.println((Integer.compare(3, 5)));当然可以用这个更好的方法
        System.out.println("ABC".compareTo("ABE"));
        Date date1 = new Date(1990, 1, 1);
        Date date2 = new Date(1989, 6, 4);
        System.out.println(date1.compareTo(date2));
    }
}

输出结果：
在这里插入图片描述

2.2 自定义实现Comparable的类进行比较

题目：
定义一个接口用来实现两个对象的比较。 interface CompareObject{ public int
compareTo(Object o);
//若返回值是 0 , 代表相等; 若为正数，代表当 前对象大；负数代表当前对象小 }
定义一个Circle类，声明width，height属性，提供getter和setter方法
定义一个ComparableRectangle.类，继承Rectangle类并且实现CompareObject接口。在
ComparableCircle类中给出接口中方法compareTo的实现体，用来比较两个长方形面积大小。
定义一个测试类ComparableRectangleTest，创建两个ComparableRectangle对象，调用compareTo 方法比较两个类的面积大小。

public interface CompareObject<C extends Rectangle> {
    /**
     * @return 若返回值是 0 , 代表相等; 若为正数，代表当前对象大；负数代表当前对象小
     */
    int compareTo(Object o);
}

******************************************************************
public class Rectangle {
    private double width;
    private double height;

    public Rectangle() {
    }

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public double getArea() {
        return height * width;
    }
}

******************************************************************

public class ComparableRectangle extends Rectangle implements CompareObject {
    public ComparableRectangle() {
    }

    public ComparableRectangle(double width, double height) {
        super(width, height);
    }

    @Override
    public int compareTo(Object o) {
        if (this == o) {
            return 0;
        }

        if (o instanceof ComparableRectangle) {
            ComparableRectangle c = (ComparableRectangle) o;
            // return Double.compare(getArea(), c.getArea());
            if (getArea() > c.getArea()) {
                return 1;
            } else if (getArea() < c.getArea()) {
                return -1;
            } else {
                return 0;
            }
        } else {
            throw new RuntimeException("传入的数据类型不匹配");
        }
    }
}

******************************************************************

public class ComparableRectangleTest {
    public static void main(String[] args) {
        ComparableRectangle c1 = new ComparableRectangle(2.2, 3.4);
        ComparableRectangle c2 = new ComparableRectangle(2.3, 3.4);

        int compareValue = c1.compareTo(c2);
        if (compareValue > 0) {
            System.out.println("c1对象大");
        } else if (compareValue < 0) {
            System.out.println("c2对象大");
        } else {
            System.out.println("c1与c2一样大");
        }
    }
}

输出结果：
在这里插入图片描述

三. 内部类

1. 介绍

  • 当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。
  • 在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。

分类：
① 成员内部类（static成员内部类和非static成员内部类）
② 局部内部类（不谈修饰符）、匿名内部类

2.局部内部类

2.1 基本用法

java局部内部类就是在方法中定义的类，它仅在该方法中有效。

class 外部类{
方法(){
     class 局部内部类{ 
     }
  }
  {
     class 局部内部类{ 
     } 
   } 
 }

2.2 如何使用局部内部类：

  • 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类
  • 但是它的对象可以通过外部方法的返回值返回使用，返回值类型只能是局部内部类的父类或父接口类型

2.3 局部内部类的特点

  • 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号，以及数字编号。
  • 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类。
  • 局部内部类可以使用外部类的成员，包括私有的。
  • 局部内部类可以使用外部方法的局部变量，但是必须是final的。 由局部内部类和局部变量的声明周期不同所致。
    • jdk 7及之前版本：要求此局部变量显式的声明为final的
    • jdk 8及之后的版本：可以省略final的声明
  • 局部内部类和局部变量地位类似，不能使用public,protected,缺省,private
  • 局部内部类不能使用static修饰，因此也不能包含静态成员

3.匿名内部类

3.1 基本用法

匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
格式：

new 父类构造器（实参列表）实现接口(){
//匿名内部类的类体部分
} 

interface A{
public abstract void fun1();
}
public class Outer{
public static void main(String[] args) {
new Outer().callInner(new A(){
//接口是不能new但此处比较特殊是子类对象实现接口，只不过没有为对象取名
public void fun1() {
System.out.println(“implement for fun1");
}
});// 两步写成一步了
}
public void callInner(A a) {
a.fun1();
}
}

3.2匿名内部类的特点

  • 匿名内部类必须继承父类或实现接口
  • 匿名内部类只能有一个对象
  • 匿名内部类对象只能使用多态形式引用

4.成员内部类

4.1 成员内部类作为类的成员的角色：

  • 和外部类不同，Inner class还可以声明为private或protected；
  • 可以调用外部类的结构
  • Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量；

4.2 成员内部类作为类的角色：

  • 可以在内部定义属性、方法、构造器等结构
  • 可以声明为abstract类 ，因此可以被其它的内部类继承
  • 可以声明为final
  • 编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）

注意

  1. 非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员内部类中才可声明static成员。
  2. 外部类访问成员内部类的成员，需要“内部类.成员”或“内部类.对象.成员”的方式
  3. 成员内部类可以直接使用外部类的所有成员，包括私有的数据
  4. 当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的
public class InnerClassTest {
	public static void main(String[] args) {
		
		//创建Dog实例(静态的成员内部类):
		Person.Dog dog = new Person.Dog();
		dog.show();
		//创建Bird实例(非静态的成员内部类):
//		Person.Bird bird = new Person.Bird();//错误的
		Person p = new Person();
		Person.Bird bird = p.new Bird();
		bird.sing();
		
		System.out.println();
		
		bird.display("黄鹂");
		
	}
}


class Person{
	
	String name = "小明";
	int age;
	
	public void eat(){
		System.out.println("人：吃饭");
	}
	
	
	//静态成员内部类
	static class Dog{
		String name;
		int age;
		
		public void show(){
			System.out.println("卡拉是条狗");
//			eat();
		}
		
	}
	//非静态成员内部类
	class Bird{
		String name = "杜鹃";
		
		public Bird(){
			
		}
		
		public void sing(){
			System.out.println("我是一只小小鸟");
			Person.this.eat();//调用外部类的非静态属性
			eat();
			System.out.println(age);
		}
		
		public void display(String name){
			System.out.println(name);//方法的形参
			System.out.println(this.name);//内部类的属性
			System.out.println(Person.this.name);//外部类的属性
		}
	}
}

输出结果：
在这里插入图片描述

马走日mazouri
关注
专栏目录
Java 关于抽象 -- Java 语言的抽象类、接口和函数式接口
栗筝i的博客
06-12 2682
在理解了 Java 的基础语法和面向对象编程概念之后，本篇文章将进一步探讨 Java 中的抽象机制。我们将讨论抽象类与接口的区别和使用场景，了解函数式接口在 Java 8 中的引入及其重要性。通过掌握这些高级概念，读者将能够编写出更灵活和可维护的代码。
Java基础——4、面向对象（下）——单例、final、抽象类、接口、内部类
强子的博客
11-11 285
接上一章 面向对象（中） 目录凡是被static修饰的结构，都是随着类的加载而加载，只加载一次1、关键字：static1.1、类变量（static修饰的）和实例变量的内存解析2、23种设计模式创建型模式——5种结构型模式——7种行为型模式——11种3、单例设计模式3.1、单例模式如何实现？饿汉式：懒汉式：3.2、饿汉式 VS 饿汉式3.3、单例设计模式—应用场景4、理解main方法的语法5.1、属性赋值的先后顺序6、关键字：final7、抽象类与抽象方法7.1、思考抽象类的问题?7.2、abstract关键
Java中的抽象类
EXECEL的博客
11-22 340
抽象类
Java 抽象类
零一百
03-02 303
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。 由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类
JAVA《抽象类》
最新发布
weixin_74772041的博客
09-30 1603
介绍了有关抽象类的内容，包括什么是抽象类，如何定义抽象类，以及抽象类的相关作用和注意要点，与普通类的区别，什么是匿名对象和匿名内部类
Java抽象类与接口的区别
weixin_33906657的博客
07-28 447
很多常见的面试题都会出诸如抽象类和接口有什么区别，什么情况下会使用抽象类和什么情况你会使用接口这样的问题。本文我们将仔细讨论这些话题。在讨论它们之间的不同点之前，我们先看看抽象类、接口各自的特性。抽象类抽象类是用来捕捉子类的通用特性的 。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。以JDK中的GenericServlet为例：publica...
java内部类总结（附代码说明）
wypdao的专栏
07-30 1052
内部类：1，概述内部类是指在一个外部类的内部再定义一个类。内部类作为外部类的一个成员，并且依附于外部类而存在的。内部类可为静态，可用PROTECTED和PRIVATE修饰。（而外部类不可以：外部类只能使用PUBLIC和DEFAULT）。2，分类成员内部类、局部内部类、静态内部类、匿名内部类（图形是要用到，必须掌握）。3，使用方法A，成员内部类：作为外部类的一个成员存在，与外部类
Java基础——抽象类和接口
explorer363的博客
07-06 490
抽象类、接口以及Object类toString方法、equals方法、comparable接口、cloneable接口的使用
十、Java接口——特殊的抽象类
Yeung_ZY的博客
11-22 581
1.接口概述 接口： 特殊的抽象类，使用方式及组成部分都与抽象类类似 语法： interface implements 注意： 在接口中只能定义公开的静态常量及公开的抽象方法 接口与抽象类的异同： 相同点： //可以编译成字节码文件 //都不能具体化 //都可以作为引用对象(多态) //都可以使用Object(祖宗类)的方法（继承） 不同点: //接口属性都是公开的静态常量 //接口方法都是公开的抽象方法 //接口没有构...
java内部类最全详解
热门推荐
weixin_46972127的博客
03-20 4万+
1、成员内部类 内部类与外部类的关系 a.成员内部类的创建需要依赖于外部类对象-（成员方法必须通过对象调用），在没有外部类实例之前无法创建成员内部类对象 b.内部类与外部类相对独立，不是is a 的关系（发动机-汽车） c.私有属性的互相访问，内部类可以直接访问外部类，而外部类访问内部类需要内部类的对象来访问 d.创建内部类的语法 1.在外部类内部创建内部类对象（Inner inner = new Inner()） 2.在外部类外部创建内部类对象，外部类.内部类 inner = new O
java内部类
朱颜辞镜花辞树
09-02 386
一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class）。是我们类的第五大成员
Java内部类
Grekit_Sun的博客
03-19 214
一、什么是内部类？ 可以将一个类的定义放在里另一个类的内部，这就是内部类。广义上我们将内部类分为四种：成员内部类、静态内部类、局部（方法）内部类、匿名内部类。 /** * 我是一个外部类（外部是相对内部而言） */ public class Outer{ /** * 我是一个内部类 */ class Inner{ //... } } 二、为什么要用内部类？ 使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都
java四种内部类详解
maguanghui_2012的专栏
06-26 678
一般来说，有4中内部类：常规内部类、静态内部类、局部内部类、匿名内部类。  一.常规内部类：常规内部类没有用static修饰且定义在在外部类类体中。   1.常规内部类中的方法可以直接使用外部类的实例变量和实例方法。   2.在常规内部类中可以直接用内部类创建对象   3.代码如下：  public class MyOuter {  private int x = 100;  //
java 内部类
qq_44761778的博客
10-18 103
java 内部类
Java的内部类
weixin_52385232的博客
03-24 577
Java的内部类
Java-内部类
CAFE-BABE的博客
04-26 700
首先内部类是指在一个类的内部定义的一个类，需要注意的是， 当成员内部类拥有和外部类同名的成员变量或这方法时， 默认情况下访问的是内部类的成员， 如要访问外部类的同名成员， 需要使用以下形式：外部类.this.成员变量/方法。 创建的时候：内部类 引用名 =new 外部类().new 内部类() 包括以下几种内部类： 静态内部类 声明时前面加了static。因为是静态的，因此不需要外部类...
Java基础：接口与抽象类——Java开发者必知
Java开发人员在深入学习和实践编程时，对接口和抽象类的理解至关...理解和掌握Java中的接口和抽象类，以及JDK、JRE和JVM的关系，是Java程序员的基础知识，对于构建健壮的软件架构和高效地开发维护应用程序至关重要。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

马走日mazouri

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值