【Java学习笔记】日期类

原创 已于 2025-06-08 21:44:40 修改 · 1.1k 阅读 · 22 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #学习 #笔记

于 2025-06-08 21:42:55 首次发布

日期类

第一代日期类：Date

引入包

  • import java.text.ParseException：日期转换可能会抛出转换异常

  • import java.text.SimpleDateFormat

  • import java.util.Date

1. 基本介绍

  • Date：精确到毫秒，代表特定的瞬间

  • SimpleDateFormat：格式化和解析日期

    • 日期 --> 文本（format方法）

    • 文本 --> 日期（parse方法）

2. Date 格式化的参数表

请添加图片描述

3. 方法介绍

（1）Date

  • 调用无参构造器：获取当前时间

  • 传入数值（单位是毫秒）：计算从1970 - 1 - 1 00:00:00开始，经过传入数值（毫秒）后的时间

（2）SimpleDateFormat

  • 创建该对象，传入格式化的字符串（yyyy 年 MM 月 dd 日 hh:mm:ss E）

  • format方法：实现日期的格式化

  • parse方法：字符串转日期

    • 注意点

      • （1）输出时会按照国外的形式输出，如果希望指定格式输出，需要使用format方法格式化

      • （2）String 中的格式必须和SimpleDateFormat中传入构造器的字符串格式一样，否则会抛出转换异常，需要在该类中添加throws ParseException

代码示例

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class main {
    public static void main(String[] args) throws ParseException {
        Date date = new Date();
        System.out.println("date：" + date);

        Date date1 = new Date(89875);
        System.out.println("date1：" + date1);

        // 使用 SimpleDateFormat 来格式化日期（Date --> String）
        SimpleDateFormat sf = new SimpleDateFormat("yyyy 年 MM 月 dd 日 hh:mm:ss E");
        String format_date = sf.format(date);
        System.out.println("Formatted date: " + format_date);

        // String --> Date
        String s = "1996 年 01 月 01 日 10:20:30 星期一";
        Date String_to_Date = sf.parse(s);
        System.out.println("parse = " + sf.format(String_to_Date));
    }
}

// 输出结果
date：Sun Jun 08 17:51:23 CST 2025
date1：Thu Jan 01 08:01:29 CST 1970
Formatted date: 2025 年 06 月 08 日 05:51:23 星期日
parse = 1996 年 01 月 01 日 10:20:30 星期一

二、第二代日期类：Calendar

引入包：java.util.Calendar

基本介绍

  • Calendar 类是一个抽象类，构造器是private，即不可以创建该对象，通过getinstance()方法来获取该对象实例

  • 它为特定时间与一组诸如 YEAR, MONTH, DAY_OF_MONTH, HOUR 等日历字段之间的转换提供了一些方法，并操作日历字段

  • 注意：Calendar类没有专门的日期格式化方法，需要自己通过获取字段，用组合的方式实现日期格式化（使用get()方法）

常用字段

字段描述
YEAR年份
MONTH月份（0-11） 从 0 开始编号
DAY_OF_MONTH当前月的天数
HOUR当前小时（0-23）
MINUTE当前分钟（0-59）
SECOND当前秒数（0-59）
DAY_OF_WEEK一周中的某一天（1-7，1 代表星期天）
WEEK_OF_YEAR一年的第几周
WEEK_OF_MONTH当前月的第几周
AM_PM上午或下午（0 为上午，1 为下午）

获取当前时间：getTime()方法

Calendar date = Calendar.getInstance();

// 输出当前日期时间
System.out.println("日期：" + date.getTime());

代码示例

package arrays;

import java.util.Calendar;

public class main {
    public static void main(String[] args) {
        Calendar date = Calendar.getInstance();

        // 输出当前日期时间
        System.out.println("=====输出当前日期时间=====");
        System.out.println("日期：" + date.getTime());
        System.out.println();

        // 输出年、月、日、时、分、秒等信息
        System.out.println("=====输出年、月、日、时、分、秒等信息=====");
        System.out.println("年：" + date.get(Calendar.YEAR));
        System.out.println("月：" + (date.get(Calendar.MONTH) + 1)); // 月份是从0开始的，所以要加1
        System.out.println("日：" + date.get(Calendar.DAY_OF_MONTH));
        System.out.println("小时：" + date.get(Calendar.HOUR_OF_DAY)); // 24小时制
        System.out.println("分钟：" + date.get(Calendar.MINUTE));
        System.out.println("秒：" + date.get(Calendar.SECOND));
        System.out.println();

        // 拼接年月日时分秒
        System.out.println("=====拼接年月日时分秒=====");
        String currentDateTime = date.get(Calendar.YEAR) + "年"
                + (date.get(Calendar.MONTH) + 1) + "月"
                + date.get(Calendar.DAY_OF_MONTH) + "日 "
                + date.get(Calendar.HOUR_OF_DAY) + ":"
                + date.get(Calendar.MINUTE) + ":"
                + date.get(Calendar.SECOND);

        System.out.println("当前时间：" + currentDateTime);
        System.out.println();

        // 输出一周中的某一天、周数等
        System.out.println("=====输出一周中的某一天、周数等=====");
        System.out.println("星期几：" + date.get(Calendar.DAY_OF_WEEK)); // 1代表星期天，7代表星期六
        System.out.println("一年中的第几周：" + date.get(Calendar.WEEK_OF_YEAR));
        System.out.println("当前月的第几周：" + date.get(Calendar.WEEK_OF_MONTH));
        System.out.println();

        // 输出上午下午信息
        System.out.println("=====输出上午下午信息=====");
        System.out.println("上午 / 下午：" + (date.get(Calendar.AM_PM)));
    }
}

// 输出结果
=====输出当前日期时间=====
日期：Sun Jun 08 18:14:53 CST 2025

=====输出年、月、日、时、分、秒等信息=====
年：2025
月：6
日：8
小时：18
分钟：14
秒：53

=====拼接年月日时分秒=====
当前时间：2025年6月8日 18:14:53

=====输出一周中的某一天、周数等=====
星期几：1
一年中的第几周：24
当前月的第几周：2

=====输出上午下午信息=====
上午 / 下午：1

三、第三代日期类

引入包

  • java.time.LocalDateTime

  • java.time.LocalDate

  • java.time.LocalTime

  • java.time.format.DateTimeFormatter

1. 引言

前面两代日期类的不足分析

JDK 1.0 中包含了一个 java.util.Date 类，但是它的大多数方法已经在 JDK 1.1 引入 Calendar 类之后被弃用了。而Calendar也存在问题是：

  • （1） 可变性：像日期和时间这种类别应该是不可变的。

  • （2） 偏移性：Date 中的年份是从 1900 开始的，而月份都从 0 开始。

  • （3） 格式化：格式化只对Date有效，Calendar则不行。

  • （4） 此外，它们也不是线程安全的；不能处理时区秒等（每隔 2 天，多出 1s）。

2. 常用类

（1）时间的表示

  • LocalDate：用于表示没有时间部分的日期（年、月、日）。例如：2025-06-08。

  • LocalTime：用于表示没有日期部分的时间（小时、分钟、秒）。例如：17:30:00。

  • LocalDateTime： 用于表示日期和时间。可以精确到秒或纳秒。例如：2025-06-08T17:30:00。

  • get...()方法：获取相应的时间信息

补充：时间的创建

方法名描述
LocalTime.of(hour, minute)创建一个表示特定时间的 LocalTime 对象（包含小时、分钟）。
LocalTime.of(hour, minute, second)创建一个表示特定时间的 LocalTime 对象（包含小时、分钟和秒）。
LocalTime.of(hour, minute, second, nanoOfSecond)创建一个表示特定时间的 LocalTime 对象（包含小时、分钟、秒和纳秒）。

（2）日期的计算

适用于LocalDate、LocalTime、LocalDateTime

方法解释
plusDays(long daysToAdd)将指定的天数加到当前日期（LocalDate、LocalDateTime）。
minusDays(long daysToSubtract)从当前日期（LocalDate、LocalDateTime）中减去指定的天数。
plusMonths(long monthsToAdd)将指定的月数加到当前日期（LocalDate、LocalDateTime）。
minusMonths(long monthsToSubtract)从当前日期（LocalDate、LocalDateTime）中减去指定的月数。
plusYears(long yearsToAdd)将指定的年数加到当前日期（LocalDate、LocalDateTime）。
minusYears(long yearsToSubtract)从当前日期（LocalDate、LocalDateTime）中减去指定的年数。

补充类

  • Period: 常用于计算两个日期之间的差异

    • 年：getYears()方法

    • 月：getMonths()方法

    • 日：getDays()方法

  • Duration: 常用于计算两个时间点之间的差异

    • 时：toHours()方法

    • 分：toMinutes()方法

    • 秒：getSeconds()方法

  • 使用说明：使用beteween(起始时间，结束时间)创建间隔时间，使用对应的方法获取时间差信息

关于between()方法传参问题的说明

（1）Period.between()方法

方法名传入参数类型适用情况说明
Period.between()LocalDate用于计算日期差（年、月、日）只能用于 LocalDate 类型的日期之间的差异。无法处理时间差（时、分、秒）。

（2）Duration.between()方法

方法名传入参数类型适用情况说明
Duration.between()Temporal（如 LocalTime, LocalDateTime, Instant）用于计算时间差（时、分、秒）Temporal 是一个接口，LocalTime、LocalDateTime 和 Instant 实现了此接口，可以用于计算这三者之间的时间差。

（3）日期的格式化：DateTimeFormatter类（不可变且线程安全的类）

（4）时间戳

  • Instant: 用于表示时间戳，通常与 UTC 时间一起使用，精确到纳秒。例如：2025-06-08T09:30:00Z。

  • from()方法：Instant转Date

  • toInstant()方法：Date转Instant

3. get...()方法整理

注意：java.time 类库中的 get() 方法返回的是真实数据，并且不会从 0 开始编号

方法描述
年月日相关
getYear()获取当前年份
getMonthValue()获取当前月份（1-12）
getMonth()获取当前月份的名称
getDayOfMonth()获取当前日期（1-31）
getDayOfYear()获取当前日期是今年的第几天（1 - 365/366）
getDayOfWeek().getValue()获取当前星期几（1=星期一, 7=星期天）
时分秒相关
getHour()获取当前小时（0-23）
getMinute()获取当前分钟（0-59）
getSecond()获取当前秒数（0-59）

一、时间的表示：代码示例

说明：LocalDate和LocalTime方法类似（需要导入相关的包），这以LocalDateTime为例

import java.time.LocalDateTime;

public class main {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();

        // 年月日相关
        System.out.println("当前年份: " + now.getYear());
        System.out.println("当前月份（1-12）: " + now.getMonthValue());
        System.out.println("当前月份名称: " + now.getMonth());
        System.out.println("当前日期（1-31）: " + now.getDayOfMonth());
        System.out.println("当前日期是今年的第几天: " + now.getDayOfYear());
        System.out.println("当前星期几（1=星期一, 7=星期天）: " + now.getDayOfWeek().getValue());

        // 时分秒相关
        System.out.println("当前小时（0-23）: " + now.getHour());
        System.out.println("当前分钟（0-59）: " + now.getMinute());
        System.out.println("当前秒数（0-59）: " + now.getSecond());
    }
}

// 输出信息
当前年份: 2025
当前月份（1-12）: 6
当前月份名称: JUNE
当前日期（1-31）: 8
当前日期是今年的第几天: 159
当前星期几（1=星期一, 7=星期天）: 7
当前小时（0-23）: 19
当前分钟（0-59）: 55
当前秒数（0-59）: 59

二、日期的格式化：代码示例

  • 1. 调用ofPattern()方法传入格式化信息的字符串，创建DateTimeFormatter类对象

  • 2. 调用方法

    • format：日期格式化为字符串

    • parse：字符串转为日期

补充：类比记忆Date中的格式化

调用SimpleDateFormat的构造器传入格式化信息的字符串

（1）format代码示例

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class main {
    public static void main(String[] args) {
        LocalDateTime now  = LocalDateTime.now();

        // 创建格式化对象
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss E");

        // 格式化字符串
        String format_date = dtf.format(now);

        // 输出格式化后的时间信息
        System.out.println(format_date);
    }
}

// 输出示例
2025-06-08 20:14:56 星期日

（2）parse代码示例

传参：parse(n1，n2)

  • n1 ： 要解析的字符串

  • n2：DateTimeFormatter对象（用于指定解析的格式）

注意：被格式化字符串要和格式化信息匹配，否则会抛出异常（DateTimeParseException）

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class main {
    public static void main(String[] args) {
        String str_datetime = "2025-06-08 14:30:00";

        // 创建格式化对象
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // String --> LocalDateTime
        LocalDateTime localDateTime = LocalDateTime.parse(str_datetime,dtf);

        System.out.println(localDateTime);
    }
}

// 输出结果
2025-06-08T14:30

三、日期的计算：代码示例

（1）对于LocalDateTime、LocalDate、LocalTime的计算方法

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class main {
    public static void main(String[] args) {
        // 获取当前时间
        LocalDateTime now = LocalDateTime.now();

        // 定义日期格式化器
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // 格式化当前日期
        String formattedDate = now.format(formatter);
        System.out.println("当前日期和时间（格式化）: " + formattedDate);

        // 添加和减去天数并格式化
        LocalDateTime newDate = now.plusDays(10);
        System.out.println("加10天后的日期（格式化）: " + newDate.format(formatter));

        newDate = now.minusDays(5);
        System.out.println("减去5天后的日期（格式化）: " + newDate.format(formatter));

        // 添加和减去月数并格式化
        newDate = now.plusMonths(3);
        System.out.println("加3个月后的日期（格式化）: " + newDate.format(formatter));

        newDate = now.minusMonths(2);
        System.out.println("减去2个月后的日期（格式化）: " + newDate.format(formatter));

        // 添加和减去年数并格式化
        newDate = now.plusYears(1);
        System.out.println("加1年后的日期（格式化）: " + newDate.format(formatter));

        newDate = now.minusYears(4);
        System.out.println("减去4年后的日期（格式化）: " + newDate.format(formatter));
    }
}

// 输出结果
当前日期和时间（格式化）: 2025-06-08 20:48:42
加10天后的日期（格式化）: 2025-06-18 20:48:42
减去5天后的日期（格式化）: 2025-06-03 20:48:42
加3个月后的日期（格式化）: 2025-09-08 20:48:42
减去2个月后的日期（格式化）: 2025-04-08 20:48:42
加1年后的日期（格式化）: 2026-06-08 20:48:42
减去4年后的日期（格式化）: 2021-06-08 20:48:42

（2）Period 代码示例

import java.time.LocalDate;
import java.time.Period;

public class PeriodExample {
    public static void main(String[] args) {
        LocalDate startDate = LocalDate.of(2020, 1, 1);
        LocalDate endDate = LocalDate.of(2025, 6, 8);

        Period period = Period.between(startDate, endDate);

        System.out.println("期间：");
        System.out.println("年: " + period.getYears());
        System.out.println("月: " + period.getMonths());
        System.out.println("日: " + period.getDays());
    }
}

// 输出结果
期间：
年: 5
月: 5
日: 7

（3）Duration 代码示例

import java.time.Duration;
import java.time.LocalDateTime;

public class DurationExample {
    public static void main(String[] args) {
        LocalDateTime startTime = LocalDateTime.of(2025, 6, 8, 10, 30, 0);
        LocalDateTime endTime = LocalDateTime.of(2025, 6, 9, 12, 45, 0);

        Duration duration = Duration.between(startTime, endTime);

        System.out.println("持续时间：");
        System.out.println("小时: " + duration.toHours());
        System.out.println("分钟: " + duration.toMinutes());
        System.out.println("秒: " + duration.getSeconds());
    }
}

// 运行结果
持续时间：
小时: 26
分钟: 1575
秒: 94500

（4）综合计算年月日时分秒的差值

Period类和Duration类的综合使用

注意点：注意取模

import java.time.Duration;
import java.time.LocalDateTime;
import java.time.Period;


public class main {
    public static void main(String[] args) {
        // 定义两个时间点
        LocalDateTime start = LocalDateTime.of(2025, 6, 1, 14, 30, 0);
        LocalDateTime end = LocalDateTime.of(2025, 6, 8, 18, 45, 30);

        // 计算日期差（年月日）
        Period period = Period.between(start.toLocalDate(), end.toLocalDate());

        // 计算时分秒差（从完整的时间差中提取）
        Duration duration = Duration.between(start, end);

        // 计算日期差（年、月、天）
        int years = period.getYears();
        int months = period.getMonths();
        int days = period.getDays();

        // 计算时间差（时、分、秒）
        long hours = duration.toHours() % 24; // 剩余小时
        long minutes = duration.toMinutes() % 60; // 剩余分钟
        long seconds = duration.getSeconds() % 60; // 剩余秒数

        // 输出日期差（年、月、天）
        System.out.println("日期差： " + years + "年 " + months + "月 " + days + "天");

        // 输出时间差（时、分、秒）
        System.out.println("时分秒差： " + hours + "小时 " + minutes + "分钟 " + seconds + "秒");
    }

// 运行结果
日期差： 0年 0月 7天
时分秒差： 4小时 15分钟 30秒

四、时间戳：代码示例

import java.time.Instant;
import java.util.Date;

public class main {
    public static void main(String[] args) {
        // 获取当前时间戳
        Instant instant_now = Instant.now();
        System.out.println("instant_now：" + instant_now);

        // Instant --> Date
        Date date = Date.from(instant_now);
        System.out.println("date：" + date);

        // Date --> instant
        Instant date_to_instant = date.toInstant();
        System.out.println(date_to_instant);
    }
}
Java学习笔记——Calendar类
D77的博客
05-02 7569
Java中的日期类主要包括：Date类和Calendar类，本文中将对Calendar类进行讲解。 一、Calendar类的简介 Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，只需要使用getInstance方法创建即可。 二、Calendar类中的常用字段 YEAR 年份 MONTH 月份 DATE 日期 WEEK_OF_YEAR 当前年中的第几个星期 WEEK_OF_MONTH 当前月中的第几个星期 DAY_OF_YEAR 一年中的第几天 DAY_OF_MON
Java学习笔记——Date类
D77的博客
05-02 1274
目录 一、时间的获取 二、时间的比较 三、过时的方法 四、代码 Java中的日期类主要包括：Date类和Calendar类，本文中将对Date类进行讲解。 一、时间的获取 getTime()：返回自1970.1.1 00:00:00以来的毫秒数 setTime()：设置自1970.1.1 00:00:00以来的毫秒数 代码实例1 /* 时间的获取 */ Date date = new Date(); System.out.println("现在的日期: " + date); //
Java学习笔记
PaulHoldOn的博客
01-31 2702
Java
java8学习笔记-日期新特性
nimqbiyq的博客
07-30 1139
在 Java 1.8 之前，处理日期和时间的主要类是 java.util.Date、java.util.Calendar和 java.util.TimeZone。新的java.time 主要包含了处理日期、时间、日期/时间、时区、时刻 (instants)、和时钟（clock） 等操作。它允许你获取和设置日期和时间的各个部分（年、月、日、时、分、秒），但这种方式并不直观，且容易出错。类是一个抽象类，提供了操作日历字段如年、月、日、时、分、秒的方法。类更丰富的日期和时间处理能力，比如日期的加减、比较等。
Java全栈学习笔记2
clp01263756的博客
07-19 1492
inputtype:radio 单选框 value就是选择框的值checkbox 复选框 value选择框的值file 文件域 触发选择文件控件data 日期 触发日期控件time 触发时间控件datetime-local 日期时间控件number 只能输入数字email 邮件hidden 隐藏表单checked 选择框的时候有用。默认选中/是否选中multiple 多选 除了输入框和单选按钮复选按钮的选择项中使用select 下拉列表 地址selected 默认选中。
《Java学习笔记》：日期类常用方法全归纳，值得收藏。
yzh2776680982的博客
05-17 1830
优快云话题挑战赛第1期 活动详情地址：话题团队PK赛5/9-5/22-优快云https://marketing.youkuaiyun.com/p/bb5081d88a77db8d6ef45bb7b6ef3d7f 参赛话题：Java学习记录 话题描述：每个人学习的路线不同，学习的方式视频教学和跟的老师不同，一个知识点会多种不同的讲解之法，下面这篇文章记录了我的学习记录并且我不懂或漏掉的知识点又去找其他书籍进行了补充，我觉得依旧不是最完整的，等我遇到了还会对这部分知识点进行补充。 目录 一、前言 二、第一代日
java日期类学习笔记
qq_42838450的博客
05-30 1111
文章目录Java日期1. java中日期类1.1 继承关系1.2 简单介绍2. java.util.Date类2.1 构造函数2.2 常用方法1.3 日期比较3. java.sql.Date3.1 构造函数3.2 常用方法3.3 互相转换4. java.sql.Time类4.1 构造方法4.2 可用方法5. java.sql.Timestamp5.1 构造方法5.2 所有方法5.3 往数据库里存日期数据5.4 从数据库中取数据6. java.util.Calendar类6.1 构造方法6.2 常用方法6.3
Java学习笔记21——常用API
R_R的博客
05-28 1287
Java学习笔记21——常用的API
JAVA学习笔记DAY3——菜鸟教程Java基础
weixin_47227105的博客
06-09 1399
菜鸟教程面向对象之前的部分都走马观花看了一遍。用于突击学习和复习。
Java学习路线总结，搬砖工逆袭Java架构师
热门推荐
学Java，找哪吒
09-07 26万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
精选资源
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
精选资源
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
java学习笔记
12-22
Java学习笔记涵盖了大量的Java基础知识，包括面向对象编程和高级特性。以下是对这些知识点的详细解释： **基础语法** 1. **数据类型**：Java有基本数据类型和引用数据类型。基本数据类型包括整型（byte, short, int...
Java学习笔记整理
05-21
这些学习笔记将带你深入了解Java的核心概念，特别是面向对象编程和集合框架。以下是对每个文件内容的详细阐述： 1. **Day0804_HashMap的基本使用.docx**：HashMap是Java集合框架中的一个重要组件，它提供了键值对的...
动力节点Java学习笔记
02-13
动力节点Java学习笔记深入探讨了Java编程语言的基础知识和核心概念，适用于初学者和希望巩固Java基础的开发者。这份笔记可能包含了Java的基本语法、数据类型、运算符、控制流程以及数组等初级内容。此外，也可能涵盖...
【java入门到放弃】网络
最新发布
WZDBXHNL的博客
12-28 979
防火墙既可以是硬件，也可以是软件，本质上是一种，而不是只能对应某一种形态。
点赞系统问题
amdkk的博客
12-26 991
​​：Spring Pulsar 提供的接口，允许通过customize方法深度定制消费者行为。批量接收策略配置。：控制批量消息接收策略maxNumMessages：单次批量拉取多少条信息timeout：超时后触发批量处理。NACK重试策略当消费者调用时触发重试。：消息重投递的退避策略接口。.minDelayMs(1000) // 初始延迟 1 秒 .maxDelayMs(60000) // 最大延迟 60 秒 .multiplier(2) // 指数退避倍数。
抽象类和接口的区别
tryxr的博客
12-27 982
本文对比了Java中接口（Interface）与抽象类（AbstractClass）的8个核心区别。主要差异包括：抽象类使用abstract class定义，支持单继承，可包含实例字段和构造器，体现"is-a"关系；接口使用interface定义，允许多实现，仅包含常量，体现"can-do"能力。抽象类适合共享代码和状态，接口适合定义跨类能力。建议优先使用接口定义能力，仅在需要共享状态或实现模板方法时使用抽象类，并考虑组合优于继承。二者可结合使用，如Shape抽象类实
c#Socket学习，使用Socket创建一个在线聊天，日志笔记（5）
学不会shader
12-25 1225
32位整数：0x12345678高位字（High Word）：0x1234（高16位）低位字（Low Word）：0x5678（低16位）64位整数：0x123456789ABCDEF0高位双字（High Dword）：0x12345678（高32位）低位双字（Low Dword）：0x9ABCDEF0（低32位）
Java学习笔记：深入理解Java编程精髓
标题和描述中重复强调了“Java学习笔记”，这表明文档是一个关于Java语言的学习资料。由于描述中并没有提供更多的具体信息，因此无法从中获得更多关于文档内容的线索。不过，考虑到“Java”这一关键词，我们可以推断...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

jackson凌

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

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

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

打赏作者

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

抵扣说明：

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

余额充值