内部类和一些API

已于 2023-11-21 11:26:39 修改
阅读量82 收藏
点赞数
文章标签： java python 开发语言
于 2023-11-15 12:32:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/learn_more1/article/details/134247566
版权

本周学习内容目录

一，面向对象高级三

1.成员内部类

  • 创建对象的格式：外部类名.内部类名 对象名 = new 外部类（）.new 内部类();
Outer.Inner in = new Outer().new Inner();
  • 当外部类和内部类中某一个变量名相同时，如何访问到不同的类变量？
public class Outer {
    private int age = 99;
    public static String a;

    public class Inner{
        private int age = 88;
        private String name;

        public void test(){
            System.out.println(age);
            System.out.println(a);
            int age = 66;
            System.out.println(age);// 66
            System.out.println(this.age); // 88
            System.out.println(Outer.this.age);// 99
        }

2.静态内部类

  • 概述：有static修饰的内部类，属于外部类自己特有
  • 创建对象的格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
Outer.Inner in = new Outer.Inner();
  • 静态内部类的特点：可以直接访问外部类的静态对象，不可以直接访问外部类的实例对象

3.匿名内部类

  • 概述：就是一种特殊的局部内部类；所谓匿名：指的是程序员不需要为这个类声明名字

  • new 类或接口（参数值）{
    类体（一般是方法重写）;
    };

public class Test {
    public static void main(String[] args) {
        // 目标：掌握匿名内部类并使用

        //1.把这个匿名内部类编译成一个子类，然后会立即创建一个子类对象出来
        Animal a = new Animal(){
            @Override
            public void cry() {
                System.out.println("猫喵喵的叫--");
            }
        };
        a.cry();
    }
}
abstract class Animal{
    public abstract void cry();
}
  • 特点:匿名内部类本质就是一个子类，并会立即创建出一个子类对象
  • 作用:用于更方便的创建一个子类对象

4.枚举

  • 注意：枚举的第一行只能罗列一些名称，这些名称都是常量，并且每个常量记住的都是枚举类的一个对象
  • 枚举类的构造器都是私有的，因此，枚举类不能对外创建对象
  • 枚举类都是最终类，不能被继承
  • 枚举类中，从第二行开始，可以定义类的其他各种成员变量
  • 编辑器为枚举类新增了几个方法，并且枚举类都是继承：Java.lang.Enum类的，从enum类也会继承到一些方法
 // 3.枚举类提供一个一些额外的api
        A[] as = A.values();
        A a3 = A.valueOf("Y");
        System.out.println(a3.name());
        System.out.println(a3.ordinal());

5.泛型

  • 认识泛型：
ArrayList<E> list1 = new ArrayList<>();
  • 泛型方法的定义和使用
  • 在这里插入图片描述
import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        // 目标：掌握泛型方法的定义和使用
        String rs = test("java");
        System.out.println(rs);

        Dog d  = test(new Dog());
        System.out.println(d);


        // 需求：所有的汽车可以一起参加比赛
        ArrayList<Car> cars = new ArrayList<>();
        cars.add(new BMW());
        cars.add(new BENZ());
        go(cars);

        ArrayList<BMW> bmws = new ArrayList<>();
        bmws.add(new BMW());
        bmws.add(new BMW());
        go(bmws);

        ArrayList<BENZ> benzs = new ArrayList<>();
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        go(benzs);

    }
    // 通配符，在使用泛型的时候可以代表一切类型  ？extends Car(上限） ？super Car(下限）
    public static void go(ArrayList<? extends Car>cars){

    }
    public static <T> T test (T t){
        return t;
    }
}
class Dog{}
class Car{}
class BMW extends Car{}
class BENZ extends Car{}

  • 泛型的注意事项

  • 泛型是工作在编译阶段的，一旦程序编译成class文件，class文件中就不存在泛型了，这是泛型擦除

  • 泛型不支持基本数据类型，只能支持对象类型9引用数据类型）

在这里插入图片描述

二.常见API（一）

1.Object类

  1. toString方法
    基本作用：返回对象的字符串形式
    存在的意义：让子类重写，以便返回子类的内容

  2. equals方法
    基本作用：默认是比较两个对象的地址是否一样
    存在的意义：让子类重写，以便用于比较对象的内容是否相同

3.clone方法

  • 要有Cloneable这个标志接口
public class User implements Cloneable{
}

@Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

2.Objects类

  1. 先判断空指针，在比较两个对象
System.out.println(Objects.equals(s1,s2));

源码分析

public static boolean equals(Object a,Object b){
        return (a == b) || (a != null && a.equals(b));
    }
  1. 判断对象是否为null。为null返回true，反之返回false
String s1 = null;
String s2 = "itheima";
System.out.println(Objects.isNull(s1));// true
System.out.println(Objects.isNull(s2));// false
  1. 判断对象是否不是null
String s1 = null;
String s2 = "itheima";
System.out.println(Objects.nonNull(s2));// true
System.out.println(Objects.nonNull(s1));// false

3.包装类

1.包装类

Java语言是一个面向对象的语言，但是Java中的基本数据类型确实不面向对象的。基本类型的数据不具备”对象“的特性（没有成员变量和成员方法可以调用），因此，Java为每种数据类型分别设计了对应的类，即包装类

在这里插入图片描述

（1）所有包装类都是final类型，因此不能创建他们的子类
（2）包装类是不可变类，一个包装类的对象自创建后，他所包含的基本类型数据就不能被改变

2.Integer类

自动装箱：可以自动把基本数据类型的数据变成包装类对象

        Integer a3 = 13;
        System.out.println(a3);

自动拆箱：可以自动把包装类型的对象转换成对应的基本数据类型

int a4 = a3;
System.out.println(a4);
  • 把基本数据类型的数据转换成字符串
		方法一：
		Integer a = 23;
		String rs1 = Integer.toString(a);// "23"
        System.out.println(rs1 + 1);// 231
        
		方法二：
        String rs2 = a.toString();
        System.out.println(rs2 + 1);// 231
        
		方法三：
        String rs3 = a + "";
        System.out.println(rs3 + 1);// 231
  • 把字符串类型的数据转换成对应的基本数据类型
        String ageStr = "29";
        // int age = Integer.parseInt(ageStr);
        int age = Integer.valueOf(ageStr);
        System.out.println(age + 1);// 30

        String scoreStr = "99.5";
        // double score = Double.parseDouble(scoreStr);
        double score = Double.valueOf(scoreStr);
        System.out.println(score + 0.5);// 100.0

4.StringBuilder

  • StringBuilder代表可变字符串对象，相当于是一个容器，它里面装的字符串时可以改变的，就是用来操作字符串的

StringBuilder s1 = new StringBuilder(); —>创建一个空白的可变的字符串对象，不包含任何内容
StringBuilder s2 = new StringBuilder(“itheima”); —>创建一个指定字符串内容的可变字符串对象

  1. 拼接内容
s2.append(12);
s2.append("黑马");
s2.append(true);
System.out.println(s2);// itheima12黑马true
// 支持链式编程
s2.append(666).append("好好学习Java").append(99.2);
System.out.println(s2); // itheima12黑马true666好好学习Java99.2

2.反转操作

s2.reverse();
System.out.println(s2);// 2.99avaJ习学好好666eurt马黑21amiehti

3.返回字符串的长度

System.out.println(s2.length());// 30

4.把String Builder对象又转成String类型

String rs = s2.toString();
System.out.println(rs);// 2.99avaJ习学好好666eurt马黑21amiehti
  • 对于字符串相关的操作，如频繁的拼接，修改等，建议用String Builder，效率更高
    注意：如果操作字符串较少，或者不需要操作，以及定义字符串变量，建议用String
// 需求：要拼接100万次abc
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 1000000 ; i++) {
            sb.append("abc");
        }
        System.out.println(sb);

5.StringJoiner

StringJoiner s = new stringJoiner(",'); —>间隔符

        StringJoiner s = new StringJoiner(",","[", "]");
        s.add("java1");
        s.add("java2");
        s.add("java3");
        System.out.println(s);// [java1,java2,java3]

三.常见API（二）

1.Math类

1.取绝对值

public static int abs(int a):取绝对值（拿到的结果一定是正数)

        System.out.println(Math.abs(-12)); // 12
        System.out.println(Math.abs(12));// 12
        System.out.println(Math.abs(-3.14)); // 3.14

2.向上取整

public static double ceil(double a):向上取整

        System.out.println(Math.ceil(4.00000000001)); // 5.0
        System.out.println(Math.ceil(4.0)); // 4.0

3.向下取整

public static double floor(double a):向下取整

        System.out.println(Math.floor(4.0)); // 4.0
        System.out.println(Math.floor(4.999)); // 4.0

4.四舍五入

public static long round(double a):四舍五入

        System.out.println(Math.round(3.4999));// 3
        System.out.println(Math.round(3.5001));// 4

5.求最大值和最小值

public static int max(int a, int b):取最大值
public static int min(int a, int b):取最小值

        System.out.println(Math.max(10,20)); // 20
        System.out.println(Math.min(10,20)); // 10

6.取次方

public static double pow(double a, double b):取次方

        System.out.println(Math.pow(2,2)); // 4

7.取随机数【0.0-1.0）（包前不包后）

public static double random(): 取随机数[0.0 , 1.0) (包前不包后）

System.out.println(Math.random());

2.System

  • 终止当前运行Java虚拟机的就不写了😎

public static long CurrentTimeMillis(): —>获取当前系统的时间
返回的时间是long类型的时间毫秒值，指的是从1970-1-1 0:0:0开始走到此刻的总的毫秒值

计算for循环所用时间（s）

		long time = System.currentTimeMillis();
        System.out.println(time);

        for (int i = 0; i < 1000000; i++) {

        }
        long time2 = System.currentTimeMillis();
        System.out.println((time2 - time) / 1000.0 + "s");

3.Runtime

public static Runtime getRuntime() —>返回与当前Java应用程序关联的运行时对象
public void exit(int status) —>终止当前运行的虚拟机，该参数用作状态代码；按照惯例：非零状态代码表示异常终止
public int availableProcessors():—>获取虚拟机能够使用的处理器数
public long totalMemory()—> 返回Java虚拟机中的内存总量
public long freeMemory()—> 返回Java虚拟机中的可用内存量

 // 1.public static Runtime getRuntime() 返回与当前Java应用程序关联的运行时对象
        Runtime r = Runtime.getRuntime();

        // 2.public void exit(int status) 终止当前运行的虚拟机，该参数用作状态代码；按照惯例：非零状态代码表示异常终止
        // r.exit(0);

        // 3.public int availableProcessors():获取虚拟机能够使用的处理器数
        System.out.println(r.availableProcessors());

        // 4.public long totalMemory() 返回Java虚拟机中的内存总量
        System.out.println(r.totalMemory()/1024.0/1024.0 + "MB");

        // 5.public long freeMemory() 返回Java虚拟机中的可用内存量
        System.out.println(r.freeMemory()/1024.0/1024.0 + "MB");

4.BigDecimal

  • 用于小数的精确计算
  • 用来表示很大的小数
    构造方法:

构造方法 获取public BigDecimal(double val)对象
public public BigDecimal(double val)
public BigDecimal(String val)
静态方法获取 BigDecimal对象
public static BigDecimal valueOf (double val)

把他们变成字符串封装成BigDecimal对象运算

		BigDecimal a1 = BigDecimal.valueOf(a);
        BigDecimal b1 = BigDecimal.valueOf(b);

        BigDecimal c1 = a1.add(b1);
        BigDecimal c2 = a1.subtract(b1);
        BigDecimal c3 = a1.multiply(b1);
        BigDecimal c4 = a1.divide(b1);

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);

精确小数点几位？

 		BigDecimal i = BigDecimal.valueOf(0.1);
        BigDecimal j = BigDecimal.valueOf(0.3);
        BigDecimal k = i.divide(j, 2, RoundingMode.HALF_UP);// 精		确到小数点两位
        System.out.println(k);

把BigDecimal转换成double类型的数据

        double rs = k.doubleValue();
        System.out.println(rs);

构造器和成员方法：
在这里插入图片描述

5.Data

创建一个Data对象，代表系统当前时间信息的

        Date d = new Date();
        System.out.println(d);

拿到时间毫秒值

        long time = d.getTime();
        System.out.println(time);

把时间毫秒值转换成日期对象，求出2s之后的时间

        time += 2 * 1000;
        Date d2 = new Date(time);
        System.out.println(d2);

直接把日期对象的时间通过setTime方法进行修改（与上面那个效果一样）
即

		time += 2 * 1000;
        Date d3 = new Date();
        d3.setTime(time);
        System.out.println(d3);

6.SimpleDateFormat

  • 代表简单日期格式化，可以用来把日期对象，时间毫秒值格式化成我们想要的形式
    在这里插入图片描述

创建简单日期格式化对象，指定的时间格式必须要与被解析的时间格式一样，否则程序会报错

String datestr = "2022-11-11 12:12:11";
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

格式化日期对象，和时间 毫秒值

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String rs1 = sdf.format(d);
        String rs2 = sdf.format(time);
        System.out.println(rs1);
        System.out.println(rs2);

7.Calender

  • calender是可变对象，一旦修改后其对象本身的时间将会产生变化
  1. 获取当前日历对象
        Calendar now = Calendar.getInstance();
        System.out.println(now);
  1. 获取日历中的某个信息
        int year = now.get(Calendar.MONTH);
        System.out.println(year);

        int days = now.get(Calendar.DAY_OF_YEAR);
        System.out.println(days);
  1. 拿到日历中记录的日期对象
        Date d = now.getTime();
        System.out.println(d);
  1. 拿到时间毫秒值
        long time = now.getTimeInMillis();
        System.out.println(time);
  1. 修改日历的某个信息
        now.set(Calendar.MONTH,9);// 修改日期为10月份（因为是从0开始）
        now.set(Calendar.DAY_OF_YEAR,150);
        System.out.println(now);
  1. 为某个信息增加或者减少多少
        now.add(Calendar.DAY_OF_YEAR,100);
        now.add(Calendar.DAY_OF_YEAR,-18);
        now.add(Calendar.DAY_OF_MONTH,6);
        System.out.println(now);

8.LocalDate

  1. 获取本地日期对象（不可变对象）
        LocalDate ld = LocalDate.now();// 年 月 日
        System.out.println(ld);
  1. 获取日期对象中的信息
        int year = ld.getYear(); // 年
        int month = ld.getMonthValue();// 月(1-12)
        int day = ld.getDayOfMonth();// 日
        int dayOfYear = ld.getDayOfYear();// 一年中的第几天
        int dayOfWeek = ld.getDayOfWeek().getValue();// 星期几
  1. 直接修改某个信息
        LocalDate ld2 = ld.withYear(2099);
        LocalDate ld3 = ld.withMonth(12);
        LocalDate ld4 = ld.withDayOfMonth(28);
        LocalDate ld5 = ld.withDayOfYear(360);
  1. 把某个信息加多少（plusYears,plusMonths,plusDays,plusWeeks）
        LocalDate ld6 = ld.plusYears(2);
        LocalDate ld7 = ld.plusMonths(2);
  1. 把某个信息减多少（minusYears,minusMonths,minusDays,minusWeeks）
        LocalDate ld8 = ld.minusYears(2);
        LocalDate ld9 = ld.minusMonths(2);
  1. 获取指定日期的LocalDate对象：public static LocalDate of(int year, int month, int dayOfMonth
        LocalDate ld10 = LocalDate.of(2099,12,12);
        LocalDate ld11 = LocalDate.of(2099,12,12);
  1. 判断2个日期对象，是否相等，在前还是在后：equals,isBefore ,isAfter
        System.out.println(ld10.equals(ld11));// true
        System.out.println(ld10.isAfter(ld));// true
        System.out.println(ld10.isBefore(ld11));// false

9.LocalDateTime

(与 LocalDate用法相同，只是这个有（时 分 秒 纳秒）
在这里插入图片描述

10.Zoneld

在这里插入图片描述

public static Zoneld systemDefault():—>获取系统默认的时区

        ZoneId zoneid = ZoneId.systemDefault();
        System.out.println(zoneid.getId());
        System.out.println(zoneid);

public static Set getAvailableZoneIds():—> 获取Java支持的全部时区Id

        System.out.println(ZoneId.getAvailableZoneIds());

把某个时区id封装成ZoneId对象

        ZoneId zoneId1 = ZoneId.of("America/New_York");

世界标准时间

        ZonedDateTime now1 = ZonedDateTime.now(Clock.systemUTC());
        System.out.println(now1);

获取系统默认时区的ZonedDateTime对象

        ZonedDateTime now2 = ZonedDateTime.now();
        System.out.println(now2);

11.Arrays

public static String toString(类型[] arr):返回数组的内容

     int[] arr = {10,20,30,40,50,60};
        System.out.println(Arrays.toString(arr));

.public static 类型[] copyOfRange(类型[] arr, 起始索引，结束索引）：拷贝数组9指定范围，包前不包后)

     int[] arr2 = Arrays.copyOfRange(arr, 1, 4);
        System.out.println(Arrays.toString(arr2));

public static copyOf(类型[] arr, int newLength):拷贝数组，可以指定新数组的长度

     int[] arr3 = Arrays.copyOf(arr, 10);
        System.out.println(Arrays.toString(arr3));

public static setAll(double[] array, IntTdDoubleFunction generator):把数组中的原数据改为新数据又存进去

     double[] prices = {99.8, 128,100};
        //                  0      1   2
        // 把所有价格都打八折，然后又存进去
        Arrays.setAll(prices, new IntToDoubleFunction() {
            @Override
            public double applyAsDouble(int value) {
                // value = 0 1 2
                return prices[value] * 0.8;
            }
        });
        System.out.println(Arrays.toString(prices));

public static void sort(类型[] arr):对数组进行排序（默认是升序排序）

     Arrays.sort(prices);
        System.out.println(Arrays.toString(prices));

如何对数组中的对象进行升序 ?

// 制定比较规则了： 左边对象o1 右边对象o2
// 约定1：认为左边对象 大于 右边对象 请返回正整数
// 约定1：认为左边对象 小于 右边对象 请返回负整数
// 约定1：认为左边对象 大于 右边对象 请返回零

        Student[] Students = new Student[4];
        Students[0] = new Student("蜘蛛精",169.5,23);
        Students[1] = new Student("紫霞",163.8,26);
        Students[2] = new Student("紫霞",163.8,26);
        Students[3] = new Student("至尊宝",167.5,24);
        Arrays.sort(Students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                 return Double.compare(o1.getHeight(),o2.getHeight());// 升序
            }
        });
        System.out.println(Arrays.toString(Students));
learn_more1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
《Java基础入门》第三版--黑马程序员课后习题（编程部分）
WZY22502701的博客
12-08 1万+
Java基础入门第三版——黑马练习题 第 1 章 Java 开发入门，第 2 章 Java 编程基础，第 3 章 面向对象（上） ，第 4 章 面向对象（下），第 5 章 异常 ，第 6 章 Java API ，第 7 章 集合类，第 8 章 泛型，第 9 章 反射，第 10 章 IO（输入输出） ，第 11 章 JDBC，第 12 章 多线程，第 13 章 网络编程
《Java基础入门》课后习题及答案
03-23
《Java基础入门》课后习题及答案
java基础入门（总结学习笔记）
chenyong6301567的博客
09-04 254
java基础入门（总结学习（关注公众号：三分恶）笔记）
Java基础教程(第3版)_ppt.rar
07-03
Java基础教程(第3版)_ppt.rar
黑马程序员Java基础入门第三版答案1
qq_68149578的博客
05-11 4038
正确答案是下面写了正确答案的
2022年接口内部类和JavaAPI基础.ppt
11-03
"2022年接口内部类和JavaAPI基础" 一、接口 1.1 声明接口 在Java中，接口是用来定义一组方法的集合，用于描述一个类的行为。声明接口使用关键字`interface`，例如： ```java public interface Area { public ...
接口、内部类和Java API基础
11-24
接口（interface）是一组常量和抽象方法的集合。接口是一种引用数据类型。 抽象方法的具体实现由实现接口的类完成，实现接口的类必须覆盖接口中的所有抽象方法。
Java__接口、内部类和Java_API基础
06-11
"Java接口、内部类和Java_API基础" Java接口是Java语言中的一个抽象概念，它定义了一组方法的集合，但不提供实现。Java接口的主要特点是它不能被实例化，必须由其他类来实现。接口的声明格式为： ``` public ...
day03-内部类&API
最新发布
06-11
day03-内部类&API
内部类&Lambda&API.md
11-01
内部类&Lambda&API.md
java基础教程第3版_java基础教程第3版习题解答
weixin_39574720的博客
02-16 1867
Java基础教程第3版习题解答第一章习题1.JamesGosling2．需3个步骤：1)用文本编辑器编写源文件2)使用javac编译源文件,得到字节码文件3)应用程序使用解释器运行。3.pathd:\jdk\binclasspath=d:\jdk\jre\lib\rt.jar;.;4．B5.java和class6．D。第二章习题1．用来标识类名、变量名、方法名、类型名、数组名、文件名的有...
java从入门到精通_必读！零基础学Java，快速入门到精通技巧
weixin_39525865的博客
10-29 447
很多同学在刚接触Java的时候，会有些迷茫，不知道该从哪里入手，该学习掌握哪些必要的基础知识。小编总结了零基础学习Java编程语言的几个基础知识要点。希望对刚入门的Java新手有所帮助。先了解Java的四个方面先弄清Java的基本概念是必不可少的，不提倡一味的死记硬背，重在理解，弄清它们之间的区别和联系，以及分别有哪些应用。在敲代码时也不要一味的照着书本狂敲，而是要思考这些代码中用到了哪些知识点。...
《Java基础入门:第2版》及部分第3版课后编程题
土豆~的博客
07-10 4980
《Java基础入门:第2版》及部分第3版课后编程题。
Java基础入门第三版部分编译题
m0_63715487的博客
09-13 3261
Java基础入门第三版部分编译题
《Java程序设计基础 第3版》pdf 附下载链接
qq_38491465的博客
07-08 7079
链接：https://pan.baidu.com/s/1AfDvT4MEl9FvQ-_SFsFs1w 密码：786t本书为完整版，以下为内容截图：
《Java从入门到精通(第3版)》
zhuwaitui4的专栏
05-16 1366
《Java从入门到精通(第3版)》从初学者角度出发，通过通俗易懂的语言、丰富多彩的实例，详细介绍了使用Java语言进行程序开发需要掌握的知识。 《Java从入门到精通(第3版)》编辑推荐：“软件开发视频大讲堂”丛书系清华社“视频大讲堂”重点大系之一。该大系包括多个子系列，每个子系列的图书在其同品种的图书中销售名列前茅，其中： 4个品种荣获“全行业优秀畅销品种”1个品种荣获2012年
2021字节面经最新分享：大厂Java核心架构进阶知识笔记（附带3500字解析）
weixin_56712358的博客
04-15 796
前言 当你准备跳槽面试的时候，明明只是一份15K的工作，却问你会不会多线程，懂不懂高并发，火箭造得让你猝及不防，结果就是两个字——凉凉！而在如今的市场，什么多线程、高并发、分布式、负载均衡、集群、微服务等等等等，都可说是Java高级后端开发求职的必备技能。 2021的春招可以说也是完美，前段时间收到字节跳动的面试邀请，虽有点震惊，但却依旧保持平常心去对待，结果一不小心就吊打了面试官（前后一个半小时的面试过程全程没卡壳，项目和算法全部搞定，甚至聊到了面试官的盲点…） 而最终...
java基础入门(完整详细版)
weixin_48948094的博客
07-28 4882
java基础入门(完整详细版)
Java从入门到精通+第三版.pdf
热门推荐
JavaUpgrade
05-08 1万+
Java从入门到精通+第三版.pdf 下载地址：Java从入门到精通+第三版.pdf 技术电子书目录：点击查看 版权声明 拒绝盗版，支持正版，购买正版书籍请移步京东或者线下书店 2019-05-08 21:47 ...
"2022年Java接口、内部类和API基础详解
2022年，北京邮电大学计算机学院的课程《Java程序设计实用教程（第3版）》中涵盖了接口、内部类和Java API基础的内容。在课程中，学生学习了接口的概念以及如何在类中实现接口。接口是一种抽象的类型，它定义了一组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值