Tyme是一个非常强大的开源日历工具库,可以看作Lunar的升级版,拥有更优的设计和更强的扩展性,支持公历和农历、星座、干支、生肖、节气、法定假日等。生成如下的月历,您只需要写极少的代码:
开源地址:
您可以通过以下两种方式获得感兴趣的内容:
Ctrl
+F
进行搜索(Mac按Command
+F
)。几乎所有的类型,都可以调用以下几个方法:
调用getName()
返回名称字符串。
// 农历年名称
LunarYear lunarYear = LunarYear.fromYear(2023);
// 农历癸卯年(依据国家标准《农历的编算和颁行》GB/T 33661-2017,农历年有2种命名方法:干支纪年法和生肖纪年法,这里默认采用干支纪年法。)
String name = lunarYear.getName();
// 农历年名称
const lunarYear: LunarYear = LunarYear.fromYear(2023);
// 农历癸卯年(依据国家标准《农历的编算和颁行》GB/T 33661-2017,农历年有2种命名方法:干支纪年法和生肖纪年法,这里默认采用干支纪年法。)
const name: string = lunarYear.getName();
// 农历年名称
lunarYear, _ := tyme.LunarYear{}.FromYear(2023)
// 农历癸卯年(依据国家标准《农历的编算和颁行》GB/T 33661-2017,农历年有2种命名方法:干支纪年法和生肖纪年法,这里默认采用干支纪年法。)
name := lunarYear.GetName()
调用toString()
返回完整描述字符串。
// 农历月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
// 正月
String monthName = lunarMonth.getName();
// 农历癸卯年正月
String monthString = lunarMonth.toString();
// 农历月
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
// 正月
const monthName: string = lunarMonth.getName();
// 农历癸卯年正月
const monthString: string = lunarMonth.toString();
// 农历月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
// 正月
monthName := lunarMonth.GetName()
// 农历癸卯年正月
monthString := lunarMonth.String()
调用next(n)
推移指定的步数,参数正数顺推,负数逆推。例如农历年推移,则代表推移多少年;农历时辰推移,则代表推移多少个时辰。
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
// 得到5个月后的农历月
LunarMonth lunarMonth2 = lunarMonth.next(5);
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
// 得到5个月后的农历月
const lunarMonth2: LunarMonth = lunarMonth.next(5);
// 农历月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
// 得到5个月后的农历月
lunarMonth2 := lunarMonth.Next(5)
也有很多支持轮回的类型(以轮回标注),例如天干(10个为一轮)、地支(12个为一轮)、干支(60个为一轮)、星期(7个为一轮)等,可以通过索引值或名称进行初始化:
调用fromIndex(index)
得到其对象。index
为数字,从0开始,当索引值越界时,会自动轮回偏移。
// 日
Week week = Week.fromIndex(0);
// 六
week = Week.fromIndex(-1);
// 乙丑
SixtyCycle sixtyCycle = SixtyCycle.fromIndex(1);
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
// 得到5个月后的农历月
const lunarMonth2: LunarMonth = lunarMonth.next(5);
// go语言版本的FromIndex永远不会error
// 日
week := tyme.Week{}.FromIndex(0)
// 六
week = tyme.Week{}.FromIndex(-1)
// 乙丑
sixtyCycle := tyme.SixtyCycle{}.FromIndex(1)
调用fromName(name)
得到其对象。name
为字符串,当名称不存在时,会抛出参数异常。
// 日
Week week = Week.fromName("日");
// 六
week = Week.fromName("六");
// 乙丑
SixtyCycle sixtyCycle = SixtyCycle.fromName("乙丑");
// 日
let week: Week = Week.fromName('日');
// 六
week = Week.fromName('六');
// 乙丑
const sixtyCycle: SixtyCycle = SixtyCycle.fromName('乙丑');
// go语言版本的FromName可能会出错,在无法保证参数正确性的情况下,建议进行错误处理
// 日
week, err := tyme.Week{}.FromName("日")
if err != nil {
// 错误处理
}
// 六
week, _ = tyme.Week{}.FromName("六")
// 乙丑
sixtyCycle, _ := tyme.SixtyCycle{}.FromName("乙丑")
依据国家标准《农历的编算和颁行》GB/T 33661-2017,农历年以正月初一开始,至除夕结束。
参数为农历年,支持从-1到9999年。
LunarYear lunarYear = LunarYear.fromYear(2023);
const lunarYear: LunarYear = LunarYear.fromYear(2023);
lunarYear, _ := tyme.LunarYear{}.FromYear(2023)
// 农历2023年正月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
LunarYear lunarYear = lunarMonth.getLunarYear();
// 农历2023年正月
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
const lunarYear: LunarYear = lunarMonth.getLunarYear();
// 农历2023年正月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
lunarYear := lunarMonth.GetLunarYear()
返回为农历年数字,范围为-1到9999。
LunarYear lunarYear = LunarYear.fromYear(2023);
// 得到2023
int year = lunarYear.getYear();
const lunarYear: LunarYear = LunarYear.fromYear(2023);
// 得到2023
const year: number = lunarYear.getYear();
lunarYear, _ := tyme.LunarYear{}.FromYear(2023)
// 得到2023
year := lunarYear.GetYear()
返回为数字,从正月初一到除夕的总天数。
LunarYear lunarYear = LunarYear.fromYear(2023);
int dayCount = lunarYear.getDayCount();
const lunarYear: LunarYear = LunarYear.fromYear(2023);
const dayCount: number = lunarYear.getDayCount();
lunarYear, _ := tyme.LunarYear{}.FromYear(2023)
dayCount := lunarYear.GetDayCount()
返回为数字,代表当年的闰月月份,例如:5代表闰五月,0代表当年没有闰月。
LunarYear lunarYear = LunarYear.fromYear(2023);
int leapMonth = lunarYear.getLeapMonth();
const lunarYear: LunarYear = LunarYear.fromYear(2023);
const leapMonth: number = lunarYear.getLeapMonth();
lunarYear, _ := tyme.LunarYear{}.FromYear(2023)
leapMonth := lunarYear.GetLeapMonth()
返回为干支 SixtyCycle。
LunarYear lunarYear = LunarYear.fromYear(2023);
SixtyCycle sixtyCycle = lunarYear.getSixtyCycle();
const lunarYear: LunarYear = LunarYear.fromYear(2023);
const sixtyCycle: SixtyCycle = lunarYear.getSixtyCycle();
lunarYear, _ := tyme.LunarYear{}.FromYear(2023)
sixtyCycle := lunarYear.GetSixtyCycle()
返回为运 Twenty。
LunarYear lunarYear = LunarYear.fromYear(2023);
Twenty twenty = lunarYear.getTwenty();
const lunarYear: LunarYear = LunarYear.fromYear(2023);
const twenty: Twenty = lunarYear.getTwenty();
lunarYear, _ := tyme.LunarYear{}.FromYear(2023)
twenty := lunarYear.GetTwenty()
返回为九星 NineStar。
LunarYear lunarYear = LunarYear.fromYear(2023);
NineStar nineStar = lunarYear.getNineStar();
const lunarYear: LunarYear = LunarYear.fromYear(2023);
const nineStar: NineStar = lunarYear.getNineStar();
lunarYear, _ := tyme.LunarYear{}.FromYear(2023)
nineStar := lunarYear.GetNineStar()
返回为方位 Direction。
LunarYear lunarYear = LunarYear.fromYear(2023);
Direction direction = lunarYear.getJupiterDirection();
const lunarYear: LunarYear = LunarYear.fromYear(2023);
const direction: Direction = lunarYear.getJupiterDirection();
lunarYear, _ := tyme.LunarYear{}.FromYear(2023)
direction := lunarYear.GetJupiterDirection()
返回为农历月 LunarMonth的列表,从正月到十二月,包含闰月。
LunarYear lunarYear = LunarYear.fromYear(2023);
List<LunarMonth> months = lunarYear.getMonths();
const lunarYear: LunarYear = LunarYear.fromYear(2023);
const months: LunarMonth[] = lunarYear.getMonths();
lunarYear, _ := tyme.LunarYear{}.FromYear(2023)
months := lunarYear.GetMonths()
从正月开始,依次为:孟春、仲春、季春、孟夏、仲夏、季夏、孟秋、仲秋、季秋、孟冬、仲冬、季冬。
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
LunarSeason season = lunarMonth.getSeason();
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
const season: LunarSeason = lunarMonth.getSeason();
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
season := lunarYear.GetSeason()
农历月以初一开始,大月30天,小月29天。
参数农历年,支持从-1到9999年;参数农历月,支持1到12,如果为闰月的,使用负数,即-3代表闰三月。
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 5);
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 5);
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 5)
// 农历2023年正月初一
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
LunarMonth lunarMonth = lunarDay.getLunarMonth();
// 农历2023年正月初一
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
const lunarMonth: LunarMonth = lunarDay.getLunarMonth();
// 农历2023年正月初一
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
lunarMonth := lunarDay.GetLunarMonth()
返回为农历年 LunarYear。
// 农历2023年正月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
LunarYear lunarYear = lunarMonth.getLunarYear();
// 农历2023年正月
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
const lunarYear: LunarYear = lunarMonth.getLunarYear();
// 农历2023年正月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
lunarYear := lunarMonth.GetLunarYear()
返回为月份数字,范围为1到12,如闰七月也返回7。
// 农历2023年正月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
// 1
int month = lunarMonth.getMonth();
// 农历2023年正月
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
// 1
const month: number = lunarMonth.getMonth();
// 农历2023年正月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
// 1
month := lunarMonth.GetMonth()
返回为月份数字,范围为1到12,闰月为负数,如闰7月返回-7。
// 农历2023年正月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
// 1
int month = lunarMonth.getMonthWithLeap();
// 农历2023年正月
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
// 1
const month: number = lunarDay.getMonthWithLeap();
// 农历2023年正月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
// 1
month := lunarMonth.GetMonthWithLeap()
返回为布尔值,闰月返回true,非闰月返回false。
// 农历2023年正月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
// false
boolean leap = lunarMonth.isLeap();
// 农历2023年正月
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
// false
const leap: bool = lunarMonth.isLeap();
// 农历2023年正月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
// false
leap := lunarMonth.IsLeap()
返回为数字,范围0到12,正月为0,依次类推,例如五月索引值为4,闰五月索引值为5。
// 农历2023年正月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
// 0
int index = lunarMonth.getIndexInYear();
// 农历2023年正月
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
// 0
const index: number = lunarMonth.getIndexInYear();
// 农历2023年正月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
// 0
leap := lunarMonth.GetIndexInYear()
返回为数字,从初一开始的总天数,大月有30天,小月有29天。
// 农历2023年正月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
int dayCount = lunarMonth.getDayCount();
// 农历2023年正月
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
const dayCount: number = lunarMonth.getDayCount();
// 农历2023年正月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
dayCount := lunarMonth.GetDayCount()
返回为农历季节 LunarSeason。
// 农历2023年正月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
LunarSeason season = lunarMonth.getSeason();
// 农历2023年正月
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
const season: LunarSeason = lunarMonth.getSeason();
// 农历2023年正月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
season := lunarMonth.GetSeason()
返回为儒略日 JulianDay。
// 农历2023年正月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
JulianDay julianDay = lunarMonth.getFirstJulianDay();
// 农历2023年正月
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
const julianDay: JulianDay = lunarMonth.getFirstJulianDay();
// 农历2023年正月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
julianDay := lunarMonth.GetFirstJulianDay()
参数为起始星期,1234560分别代表星期一至星期天,返回为数字。
// 农历2023年正月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
int weekCount = lunarMonth.getWeekCount(1);
// 农历2023年正月
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
const weekCount: number = lunarMonth.getWeekCount(1);
// 农历2023年正月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
weekCount := lunarMonth.GetWeekCount(1)
参数为起始星期,1234560分别代表星期一至星期天,返回为农历周 LunarWeek的列表。
// 农历2023年正月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
List<LunarWeek> weeks = lunarMonth.getWeeks(1);
// 农历2023年正月
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
const weeks: LunarWeek[] = lunarMonth.getWeeks(1);
// 农历2023年正月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
weeks := lunarMonth.GetWeeks(1)
返回为干支 SixtyCycle。
// 农历2023年正月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
SixtyCycle sixtyCycle = lunarMonth.getSixtyCycle();
// 农历2023年正月
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
const sixtyCycle: SixtyCycle = lunarMonth.getSixtyCycle();
// 农历2023年正月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
sixtyCycle := lunarMonth.GetSixtyCycle()
返回为九星 NineStar。
// 农历2023年正月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
NineStar nineStar = lunarMonth.getNineStar();
// 农历2023年正月
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
const nineStar: NineStar = lunarMonth.getNineStar();
// 农历2023年正月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
nineStar := lunarMonth.GetNineStar()
返回为方位 Direction。
// 农历2023年正月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
Direction direction = lunarMonth.getJupiterDirection();
// 农历2023年正月
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
const direction: Direction = lunarMonth.getJupiterDirection();
// 农历2023年正月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
direction := lunarMonth.GetJupiterDirection()
返回为农历日 LunarDay的列表,从初一开始。
// 农历2023年正月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
List<LunarDay> days = lunarMonth.getDays();
// 农历2023年正月
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
const days: LunarDay[] = lunarMonth.getDays();
// 农历2023年正月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
days := lunarMonth.GetDays()
返回为逐月胎神 FetusMonth。闰月无胎神。
// 农历2023年正月
LunarMonth lunarMonth = LunarMonth.fromYm(2023, 1);
// 注意闰月会返回null
FetusMonth fetus = lunarMonth.getFetus();
// 农历2023年正月
const lunarMonth: LunarMonth = LunarMonth.fromYm(2023, 1);
// 注意闰月会返回null
const fetus: FetusMonth = lunarMonth.getFetus();
// 农历2023年正月
lunarMonth, _ := tyme.LunarMonth{}.FromYm(2023, 1)
// 注意闰月会返回nil
fetus := lunarMonth.GetFetus()
农历一个月最多有6个周,分别为:第一周、第二周、第三周、第四周、第五周、第六周。
// 农历癸卯年正月第一周,以星期2为一周的开始
LunarWeek lunarWeek = LunarWeek.fromYm(2023, 1, 0, 2);
// 农历癸卯年正月第一周,以星期2为一周的开始
const lunarWeek: LunarWeek = LunarWeek.fromYm(2023, 1, 0, 2);
// 农历癸卯年正月第一周,以星期2为一周的开始
lunarWeek, _ := tyme.LunarWeek{}.FromYm(2023, 1, 0, 2)
返回为农历日 LunarDay。
LunarWeek lunarWeek = LunarWeek.fromYm(2023, 1, 0, 2);
// 农历壬寅年十二月廿六
LunarDay lunarDay = lunarWeek.getFirstDay();
const lunarWeek: LunarWeek = LunarWeek.fromYm(2023, 1, 0, 2);
// 农历壬寅年十二月廿六
const lunarDay: LunarDay = lunarWeek.getFirstDay();
lunarWeek, _ := tyme.LunarWeek{}.FromYm(2023, 1, 0, 2)
// 农历壬寅年十二月廿六
lunarDay := lunarWeek.GetFirstDay()
返回为农历日 LunarDay的列表。
LunarWeek lunarWeek = LunarWeek.fromYm(2023, 1, 0, 2);
List<LunarDay> days = lunarWeek.getDays();
const lunarWeek: LunarWeek = LunarWeek.fromYm(2023, 1, 0, 2);
// 农历壬寅年十二月廿六
const days: LunarDay[] = lunarWeek.getDays();
lunarWeek, _ := tyme.LunarWeek{}.FromYm(2023, 1, 0, 2)
days := lunarWeek.GetDays()
参数农历年,支持从-1到9999年;参数农历月,支持1到12,如果为闰月的,使用负数,即-3代表闰三月;参数农历日,支持1到30,大月30天,小月29天。
// 农历2023年正月初一
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
// 农历2023年正月初一
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
// 农历2023年正月初一
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
// 农历2023年正月初一 13:00:00
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
LunarDay lunarDay = lunarHour.getLunarDay();
// 农历2023年正月初一 13:00:00
const lunarHour: LunarHour = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
const lunarDay: LunarDay = lunarHour.getLunarDay();
// 农历2023年正月初一 13:00:00
lunarHour, _ := tyme.LunarHour{}.FromYmdHms(2023, 1, 1, 13, 0, 0)
lunarDay := lunarHour.GetLunarDay()
// 公历2024年2月9日
SolarDay solarDay = SolarDay.fromYmd(2024, 2, 9);
// 农历癸卯年十二月三十
LunarDay lunarDay = solarDay.getLunarDay();
// 公历2024年2月9日
const solarDay: SolarDay = SolarDay.fromYmd(2024, 2, 9);
// 农历癸卯年十二月三十
const lunarDay: LunarDay = solarDay.getLunarDay();
// 公历2024年2月9日
solarDay, _ := tyme.SolarDay{}.FromYmd(2024, 2, 9)
// 农历癸卯年十二月三十
lunarDay := solarDay.GetLunarDay()
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
// 正月
LunarMonth lunarMonth = lunarDay.getLunarMonth();
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
// 正月
const lunarMonth: LunarMonth = lunarDay.getLunarMonth();
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
// 正月
lunarMonth := lunarDay.GetLunarMonth()
返回为数字,范围1到30。
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
// 1
int day = lunarDay.getDay();
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
// 1
const day: number = lunarDay.getDay();
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
// 1
day := lunarDay.GetDay()
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
Week week = lunarDay.getWeek();
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
const week: Week = lunarDay.getWeek();
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
week := lunarDay.GetWeek()
非当天所属的农历年干支,以立春换年。返回为干支 SixtyCycle。
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
SixtyCycle sixtyCycle = lunarDay.getYearSixtyCycle();
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
const sixtyCycle: SixtyCycle = lunarDay.getYearSixtyCycle();
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
sixtyCycle := lunarDay.GetYearSixtyCycle()
非当天所属的农历月干支,以节令换月。返回为干支 SixtyCycle。
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
SixtyCycle sixtyCycle = lunarDay.getMonthSixtyCycle();
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
const sixtyCycle: SixtyCycle = lunarDay.getMonthSixtyCycle();
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
sixtyCycle := lunarDay.GetMonthSixtyCycle()
返回为干支 SixtyCycle。
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
SixtyCycle sixtyCycle = lunarDay.getSixtyCycle();
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
const sixtyCycle: SixtyCycle = lunarDay.getSixtyCycle();
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
sixtyCycle := lunarDay.GetSixtyCycle()
返回为九星 NineStar。
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
NineStar nineStar = lunarDay.getNineStar();
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
const nineStar: NineStar = lunarDay.getNineStar();
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
nineStar := lunarDay.GetNineStar()
返回为方位 Direction。
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
Direction direction = lunarDay.getJupiterDirection();
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
const direction: Direction = lunarDay.getJupiterDirection();
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
direction := lunarDay.GetJupiterDirection()
返回为建除十二值神 Duty。
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
Duty duty = lunarDay.getDuty();
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
const duty: Duty = lunarDay.getDuty();
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
duty := lunarDay.GetDuty()
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
TwelveStar twelveStar = lunarDay.getTwelveStar();
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
const twelveStar: TwelveStar = lunarDay.getTwelveStar();
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
twelveStar := lunarDay.GetTwelveStar()
返回为逐日胎神 FetusDay。
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
FetusDay fetus = lunarDay.getFetusDay();
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
const fetus: FetusDay = lunarDay.getFetusDay();
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
fetus := lunarDay.GetFetusDay()
返回为月相 Phase。
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
Phase phase = lunarDay.getPhase();
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
const phase: Phase = lunarDay.getPhase();
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
phase := lunarDay.GetPhase()
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
TwentyEightStar twentyEightStar = lunarDay.getTwentyEightStar();
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
const twentyEightStar: TwentyEightStar = lunarDay.getTwentyEightStar();
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
twentyEightStar := lunarDay.GetTwentyEightStar()
返回为农历传统节日 LunarFestival,当天无节日返回null。
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
LunarFestival festival = lunarDay.getFestival();
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
const festival: LunarFestival = lunarDay.getFestival();
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
// 注意当天不是农历传统节日,返回nil
festival := lunarDay.GetFestival()
返回为公历日 SolarDay。
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
SolarDay solarDay = lunarDay.getSolarDay();
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
const solarDay: SolarDay = lunarDay.getSolarDay();
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
solarDay := lunarDay.GetSolarDay()
// 农历2023年正月初一
LunarDay a = LunarDay.fromYmd(2023, 1, 1);
// 农历2023年正月初二
LunarDay b = LunarDay.fromYmd(2023, 1, 2);
// a在b之前吗?这里返回true
boolean aIsBeforeB = a.isBefore(b);
// a在b之后吗?这里返回false
boolean aIsAfterB = a.isAfter(b);
// 农历2023年正月初一
const a: LunarDay = LunarDay.fromYmd(2023, 1, 1);
// 农历2023年正月初二
const b: LunarDay = LunarDay.fromYmd(2023, 1, 2);
// a在b之前吗?这里返回true
const aIsBeforeB: bool = a.isBefore(b);
// a在b之后吗?这里返回false
const aIsAfterB: bool = a.isAfter(b);
// 农历2023年正月初一
a, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
// 农历2023年正月初二
b, _ := tyme.LunarDay{}.FromYmd(2023, 1, 2)
// a在b之前吗?这里返回true
aIsBeforeB := a.IsBefore(b)
// a在b之后吗?这里返回false
aIsAfterB := a.IsAfter(b)
由于23:00-23:59、00:00-00:59均为子时,而农历日是从00:00-23:59为一天,所以获取当天的时辰列表,实际会返回13个。
LunarDay lunarDay = LunarDay.fromYmd(2023, 1, 1);
List<LunarHour> lunarHours = lunarDay.getHours();
const lunarDay: LunarDay = LunarDay.fromYmd(2023, 1, 1);
const lunarHours: LunarHour[] = lunarDay.getHours();
lunarDay, _ := tyme.LunarDay{}.FromYmd(2023, 1, 1)
lunarHours := lunarDay.GetHours()
参数农历年,支持从-1到9999年;参数农历月,支持1到12,如果为闰月的,使用负数,即-3代表闰三月;参数农历日,支持1到30,大月30天,小月29天;时为0-23;分为0-59;秒为0-59。
// 农历2023年正月初一 13:00:00
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
// 公历2024年2月9日 13:00:00
SolarTime solarTime = SolarTime.fromYmdHms(2024, 2, 9, 13, 0, 0);
// 农历癸卯年十二月三十 未时
LunarHour lunarHour = solarTime.getLunarHour();
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
// 初一
LunarDay lunarDay = lunarHour.getLunarDay();
返回为数字,范围0到23。
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
// 13
int hour = lunarHour.getHour();
返回为数字,范围0到59。
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
// 0
int minute = lunarHour.getMinute();
返回为数字,范围0到59。
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
// 0
int second = lunarHour.getSecond();
返回为数字,范围0到11。
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
// 7
int index = lunarHour.getIndexInDay();
非当时所属的农历年干支,以立春具体时刻换年。返回为干支 SixtyCycle。
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
SixtyCycle sixtyCycle = lunarHour.getYearSixtyCycle();
非当天所属的农历月干支,以节令具体时刻换月。返回为干支 SixtyCycle。
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
SixtyCycle sixtyCycle = lunarHour.getMonthSixtyCycle();
返回为干支 SixtyCycle。注意:23:00开始算做第二天。
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
SixtyCycle sixtyCycle = lunarHour.getDaySixtyCycle();
返回为干支 SixtyCycle。
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
SixtyCycle sixtyCycle = lunarHour.getSixtyCycle();
返回为九星 NineStar。
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
NineStar nineStar = lunarHour.getNineStar();
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
TwelveStar twelveStar = lunarHour.getTwelveStar();
返回为公历时刻 SolarTime。
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
SolarTime solarTime = lunarHour.getSolarTime();
默认23:00-23:59日干支为明天,返回为八字 EightChar。
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
EightChar eightChar = lunarHour.getEightChar();
由于有的流派认为23:00-23:59日干支为当天,有的流派则认为应该算明天,可通过EightCharProvider来切换,默认支持以下几种方式,你也可以自定义。
LunarHour.provider = new DefaultEightCharProvider();
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 23, 0, 0);
EightChar eightChar = lunarHour.getEightChar();
LunarHour.provider = new LunarSect2EightCharProvider();
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 23, 0, 0);
EightChar eightChar = lunarHour.getEightChar();
实现EightCharProvider接口。
// 方式1,实现EightCharProvider接口
public class MyEightCharProvider implements EightCharProvider {
// 实现getEightChar方法
}
LunarHour.provider = new MyEightCharProvider();
// 农历2023年正月初一 13:00:00
LunarHour a = LunarHour.fromYmdHms(2023, 1, 1, 13, 0, 0);
// // 农历2023年正月初二 09:00:00
LunarHour b = LunarHour.fromYmdHms(2023, 1, 2, 09, 0, 0);
// a在b之前吗?这里返回true
boolean aIsBeforeB = a.isBefore(b);
// a在b之后吗?这里返回false
boolean aIsAfterB = a.isAfter(b);
参数为公历年,支持从1到9999年。
SolarYear solarYear = SolarYear.fromYear(2024);
// 公历2024年2月
SolarMonth solarMonth = SolarMonth.fromYm(2024, 2);
SolarYear solarYear = solarMonth.getSolarYear();
返回为公历年数字,范围为1到9999。
SolarYear solarYear = SolarYear.fromYear(2023);
// 得到2023
int year = solarYear.getYear();
返回为数字,从1月1日到12月31日的总天数。平年365天,闰年366天,1582年355天。
SolarYear solarYear = SolarYear.fromYear(2023);
// 365
int dayCount = solarYear.getDayCount();
返回为true/false。
SolarYear solarYear = SolarYear.fromYear(2023);
// false
boolean leap = solarYear.isLeap();
返回为公历月 SolarMonth的列表,从1月到12月。
SolarYear solarYear = SolarYear.fromYear(2023);
List<SolarMonth> months = solarYear.getMonths();
返回为公历半年 SolarHalfYear的列表,上半年和下半年。
SolarYear solarYear = SolarYear.fromYear(2023);
List<SolarHalfYear> halfYears = solarYear.getHalfYears();
返回为公历季度 SolarSeason的列表,一季度、二季度、三季度和四季度。
SolarYear solarYear = SolarYear.fromYear(2023);
List<SolarSeason> seasons = solarYear.getSeasons();
公历半年分为:上半年和下半年。
参数为公历年和索引,支持从1到9999年,索引值为0或1,0代表上半年,1代表下半年。
// 2024年上半年
SolarHalfYear halfYear = SolarHalfYear.fromYear(2024, 0);
返回为公历年数字,范围为1到9999。
SolarHalfYear halfYear = SolarHalfYear.fromYear(2024, 0);
// 得到2024
int year = halfYear.getYear();
返回为数字,0代表上半年,1代表下半年。
SolarHalfYear halfYear = SolarHalfYear.fromYear(2024, 0);
// 0
int index = halfYear.getIndex();
返回为公历月 SolarMonth的列表,半年为6个月。
SolarHalfYear halfYear = SolarHalfYear.fromYear(2024, 0);
List<SolarMonth> months = halfYear.getMonths();
返回为公历季度 SolarSeason的列表,半年为2个季度。
SolarHalfYear halfYear = SolarHalfYear.fromYear(2024, 0);
List<SolarSeason> seasons = halfYear.getSeasons();
公历季度分为:一季度、二季度、三季度和四季度。
参数为公历年和索引,支持从1到9999年,索引值为0-3,0代表一季度,3代表四季度。
// 2024年上半年
SolarSeason season = SolarSeason.fromYear(2024, 0);
SolarMonth solarMonth = SolarMonth.fromYm(2023, 5);
// 二季度
SolarSeason season = solarMonth.getSeason();
返回为公历年数字,范围为1到9999。
SolarSeason season = SolarSeason.fromYear(2024, 0);
// 得到2024
int year = season.getYear();
返回为数字0-3,0代表一季度,3代表四季度。
SolarSeason season = SolarSeason.fromYear(2024, 0);
// 0
int index = season.getIndex();
返回为公历月 SolarMonth的列表,一季度为3个月。
SolarSeason season = SolarSeason.fromYear(2024, 0);
List<SolarMonth> months = season.getMonths();
公历1年有12个月,为1月到12月。
参数公历年,支持从1到9999年;参数公历月,支持1到12。
SolarMonth solarMonth = SolarMonth.fromYm(2023, 5);
// 公历2023年1月1日
SolarDay solarDay = Solar.fromYmd(2023, 1, 1);
SolarMonth solarMonth = solarDay.getSolarMonth();
返回为公历年 SolarYear。
SolarMonth solarMonth = SolarMonth.fromYm(2023, 5);
SolarYear solarYear = solarMonth.getSolarYear();
返回为月份数字,范围为1到12。
SolarMonth solarMonth = SolarMonth.fromYm(2023, 5);
// 5
int month = solarMonth.getMonth();
返回为数字,范围0到11,0代表1月,11代表12月。
SolarMonth solarMonth = SolarMonth.fromYm(2023, 5);
// 4
int index = solarMonth.getIndexInYear();
返回为数字,1582年10月只有21天,其余根据小学知识可知。
SolarMonth solarMonth = SolarMonth.fromYm(2023, 5);
int dayCount = solarMonth.getDayCount();
返回为公历季度 SolarSeason。
SolarMonth solarMonth = SolarMonth.fromYm(2023, 5);
// 二季度
SolarSeason season = solarMonth.getSeason();
参数为起始星期,1234560分别代表星期一至星期天,返回为数字。
SolarMonth solarMonth = SolarMonth.fromYm(2023, 5);
int weekCount = solarMonth.getWeekCount(1);
参数为起始星期,1234560分别代表星期一至星期天,返回为公历周 SolarWeek的列表。
SolarMonth solarMonth = SolarMonth.fromYm(2023, 5);
List<SolarWeek> weeks = solarMonth.getWeeks(1);
返回为公历日 SolarDay的列表,从1日开始。
SolarMonth solarMonth = SolarMonth.fromYm(2023, 5);
List<SolarDay> days = solarMonth.getDays();
公历一个月最多有6个周,分别为:第一周、第二周、第三周、第四周、第五周、第六周。
// 2023年1月第一周,以星期2为一周的开始
SolarWeek solarWeek = SolarWeek.fromYm(2023, 1, 0, 2);
返回为公历日 SolarDay。
SolarWeek solarWeek = SolarWeek.fromYm(2023, 1, 0, 2);
// 2022年12月27日
SolarDay solarDay = solarWeek.getFirstDay();
返回为公历日 SolarDay的列表。
SolarWeek solarWeek = SolarWeek.fromYm(2023, 1, 0, 2);
List<SolarDay> days = solarWeek.getDays();
注意:索引值是从0开始,即0代表第一周
SolarWeek solarWeek = SolarWeek.fromYm(2023, 1, 0, 2);
// 0
int index = solarWeek.getIndexInYear();
参数公历年,支持从1到9999年;参数公历月,支持1到12;参数公历日,支持1到31。
// 公历2023年1月1日
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
// 公历2023年1月1日 13:00:00
SolarTime solarTime = SolarTime.fromYmdHms(2023, 1, 1, 13, 0, 0);
SolarDay solarDay = solarTime.getSolarDay();
// 农历癸卯年十二月三十
LunarDay lunarDay = LunarDay.fromYmd(2023, 12, 30);
// 公历2024年2月9日
SolarDay solarDay = lunarDay.getSolarDay();
JulianDay julianDay = JulianDay.fromJulianDay(2451545);
// 公历2000年1月1日
SolarDay solarDay = julianDay.getSolarDay();
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
// 1月
SolarMonth solarMonth = solarDay.getSolarMonth();
返回为数字,范围1到31。
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
// 1
int day = solarDay.getDay();
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
Week week = solarDay.getWeek();
获取当天所在的公历周,参数为起始星期,1234560分别代表星期一至星期天。
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
// 2023年1月第一周
SolarWeek solarWeek = solarDay.getSolarWeek(0);
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
Constellation constellation = solarDay.getConstellation();
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
SolarTerm term = solarDay.getTerm();
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
PhenologyDay phenologyDay = solarDay.getPhenologyDay();
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
DogDay dogDay = solarDay.getDogDay();
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
NineDay nineDay = solarDay.getNineDay();
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
int index = solarDay.getIndexInYear();
返回为公历现代节日 SolarFestival,当天无节日返回null。
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
// 元旦
SolarFestival festival = solarDay.getFestival();
返回为法定假日 LegalHoliday,当天不是法定假日返回null。
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
LegalHoliday festival = solarDay.getLegalHoliday();
返回为农历日 LunarDay。
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
LunarDay lunarDay = solarDay.getLunarDay();
返回为儒略日 JulianDay。
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
JulianDay julianDay = solarDay.getJulianDay();
SolarDay a = SolarDay.fromYmd(2023, 1, 1);
SolarDay b = SolarDay.fromYmd(2023, 1, 2);
// a在b之前吗?这里返回true
boolean aIsBeforeB = a.isBefore(b);
// a在b之后吗?这里返回false
boolean aIsAfterB = a.isAfter(b);
返回为两个公历日之间相差的天数。
// -1
int days = SolarDay.fromYmd(2023, 1, 1).subtract(SolarDay.fromYmd(2023, 1, 2));
SolarDay solarDay = SolarDay.fromYmd(2024, 6, 11);
// 入梅第1天
PlumRainDay plumRainDay = solarDay.getPlumRainDay();
solarDay = SolarDay.fromYmd(2024, 7, 6);
// 出梅
plumRainDay = solarDay.getPlumRainDay();
solarDay = SolarDay.fromYmd(2024, 6, 10);
// null
plumRainDay = solarDay.getPlumRainDay();
参数公历年,支持从1到9999年;参数公历月,支持1到12;参数公历日,支持1到31;时为0-23;分为0-59;秒为0-59。
// 2023年1月1日 13:00:00
SolarTime solarTime = SolarTime.fromYmdHms(2023, 1, 1, 13, 0, 0);
// 农历癸卯年十二月三十 未时
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 12, 30, 13, 0, 0);
// 2024年2月9日 13:00:00
SolarTime solarTime = lunarHour.getSolarTime();
JulianDay julianDay = JulianDay.fromJulianDay(2451545);
// 公历2000年1月1日 12:00:00
SolarTime solarTime = julianDay.getSolarTime();
SolarTime solarTime = SolarTime.fromYmdHms(2023, 1, 1, 13, 0, 0);
// 2023年1月1日
SolarDay solarDay = solarTime.getSolarDay();
返回为数字,范围0到23。
SolarTime solarTime = SolarTime.fromYmdHms(2023, 1, 1, 13, 0, 0);
// 13
int hour = solarTime.getHour();
返回为数字,范围0到59。
SolarTime solarTime = SolarTime.fromYmdHms(2023, 1, 1, 13, 5, 0);
// 5
int minute = solarTime.getMinute();
返回为数字,范围0到59。
SolarTime solarTime = SolarTime.fromYmdHms(2023, 1, 1, 13, 5, 20);
// 20
int second = solarTime.getSecond();
SolarTime solarTime = SolarTime.fromYmdHms(2023, 1, 1, 13, 5, 20);
SolarTerm term = solarTime.getTerm();
返回为农历时辰 LunarHour。
SolarTime solarTime = SolarTime.fromYmdHms(2023, 1, 1, 13, 5, 20);
LunarHour lunarHour = solarTime.getLunarHour();
返回为儒略日 JulianDay。
SolarTime solarTime = SolarTime.fromYmdHms(2023, 1, 1, 13, 5, 20);
JulianDay julianDay = solarTime.getJulianDay();
SolarTime a = SolarTime.fromYmdHms(2023, 1, 1, 0, 0, 0);
SolarTime b = SolarTime.fromYmdHms(2023, 1, 1, 1, 0, 0);
// a在b之前吗?这里返回true
boolean aIsBeforeB = a.isBefore(b);
// a在b之后吗?这里返回false
boolean aIsAfterB = a.isAfter(b);
返回为两个公历时刻之间相差的秒数。
// -3600
int seconds = SolarTime.fromYmdHms(2023, 1, 1, 0, 0, 0).subtract(SolarTime.fromYmdHms(2023, 1, 1, 1, 0, 0));
十二生效依次为:鼠、牛、虎、兔、龙、蛇、马、羊、猴、鸡、狗、猪。
// 鼠
Zodiac zodiac = EarthBranch.fromName("子").getZodiac();
返回为地支 EarthBranch。
Zodiac zodiac = Zodiac.fromName("牛");
// 丑
EarthBranch earthBranch = zodiac.getEarthBranch();
月相从农历初一开始,依次为:朔月、既朔月、蛾眉新月、蛾眉新月、蛾眉月、夕月、上弦月、上弦月、九夜月、宵月、宵月、宵月、渐盈凸月、小望月、望月、既望月、立待月、居待月、寝待月、更待月、渐亏凸月、下弦月、下弦月、有明月、有明月、蛾眉残月、蛾眉残月、残月、晓月、晦月。
// 朔月
Phase phase = LunarDay.fromYmd(2000, 1, 1).getPhase();
星座依次为:白羊、金牛、双子、巨蟹、狮子、处女、天秤、天蝎、射手、摩羯、水瓶、双鱼。
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
Constellation constellation = solarDay.getConstellation();
节气依次为:冬至、小寒、大寒、立春、雨水、惊蛰、春分、清明、谷雨、立夏、小满、芒种、夏至、小暑、大暑、立秋、处暑、白露、秋分、寒露、霜降、立冬、小雪、大雪。节气的初始化需要带上公历年份:
调用fromIndex(year, index)
得到其对象。year
为公历年,当传入2013年时,取到的冬至,实际上是在2012年,这里一定要注意;index
为数字,从0开始,当索引值越界时,会自动轮回偏移。
// 2013年的第1个节气:冬至
SolarTerm term = SolarTerm.fromIndex(2013, 0);
调用fromName(year, name)
得到其对象。year
为公历年,当传入2013年时,取到的冬至,实际上是在2012年,这里一定要注意;name
为字符串,当名称不存在时,会抛出参数异常。
// 2013年的立春
SolarTerm term = SolarTerm.fromName(2013, '立春');
SolarDay solarDay = SolarDay.fromYmd(2023, 1, 1);
SolarTerm term = solarDay.getTerm();
也可以知道指定公历日位于节气的第几天:
SolarDay solarDay = SolarDay.fromYmd(2023, 12, 7);
// 大雪第1天
SolarTermDay termDay = solarDay.getTermDay();
// 0
int dayIndex = termDay.getDayIndex();
SolarTime solarTime = SolarTime.fromYmdHms(2023, 1, 1, 13, 5, 20);
SolarTerm term = solarTime.getTerm();
isJie()
返回为true或false。
SolarTerm term = SolarTerm.fromName(2013, '冬至');
// false
boolean isJie = term.isJie();
isQi()
返回为true或false。
SolarTerm term = SolarTerm.fromName(2013, '冬至');
// true
boolean isJie = term.isQi();
getJulianDay()
返回为儒略日 JulianDay。
SolarTerm term = SolarTerm.fromName(2013, '冬至');
JulianDay julianDay = term.getJulianDay();
儒略日可以通过以下几种方式得到:
调用fromJulianDay(jd)
得到其对象。jd
为小数。
// 公历2023年1月1日
JulianDay julianDay = JulianDay.fromJulianDay(2459945.5);
调用fromYmdHms(year, month, day, hour, minute, second)
得到其对象。
JulianDay julianDay = JulianDay.fromYmdHms(2023, 1, 1, 0, 0, 0);
JulianDay julianDay = SolarDay.fromYmd(2023, 1, 1).getJulianDay();
JulianDay julianDay = SolarTime.fromYmdHms(2023, 1, 1, 12, 30, 0).getJulianDay();
getDay()
返回小数。
JulianDay julianDay = SolarDay.fromYmd(2023, 1, 1).getJulianDay();
// 2459945.5
double jd = julianDay.getDay();
getSolarDay()
返回公历日 SolarDay。
JulianDay julianDay = JulianDay.fromJulianDay(2459945.5);
// 2023年1月1日
SolarDay solarDay = julianDay.getSolarDay();
getSolarDay()
返回公历时刻 SolarTime。
JulianDay julianDay = JulianDay.fromJulianDay(2459945.5);
// 2023年1月1日 00:00:00
SolarTime solarTime = julianDay.getSolarTime();
通过儒略日计算的星期是最准的,基姆拉尔森和蔡勒公式计算星期的准确性,在儒略日面前都是弟弟,不服来辩。
getWeek()
返回星期 Week。
JulianDay julianDay = JulianDay.fromJulianDay(2459945.5);
// 日
Week week = julianDay.getWeek();
法定假日有:元旦节、春节、清明节、劳动节、端午节、中秋节、国庆节、国庆中秋、抗战胜利日。仅支持2002年(含)至2025年(含)的法定假日。可以通过公历日 SolarDay得到,也可指定年、月、日得到。
SolarDay solarDay = SolarDay.fromYmd(2023, 10, 1);
// 国庆节
LegalHoliday holiday = solarDay.getLegalHoliday();
// 国庆节
holiday = LegalHoliday.fromYmd(2023, 10, 1);
// 非法定假日,返回null
holiday = LegalHoliday.fromYmd(2023, 4, 20);
通过调用法定假日的isWork()方法得到当天是否上班。
// 春节
LegalHoliday holiday = LegalHoliday.fromYmd(2024, 2, 4);
// true,代表要上班
boolean woek = holiday.isWork();
法定假日指国家规定的放假和调休安排,来源于国务院办公厅发布的国办发明电文件。可前往http://www.gov.cn/zhengce/xxgk/index.htm搜索节假日。一般是每年11月底12月初发布来年的节假日安排。
目前仅支持从2001年12月29日到2025年12月31日的法定假日安排,一般可以有两种方式更新法定假日数据:
1. Tyme发布新版本时更新,如果未及时更新,欢迎催更。
2. 自己维护节假日数据,可通过LegalHoliday.DATA = "节假日数据";
来简单粗暴的替换Tyme的所有节假日数据。
数据格式为将每一个法定节假日数据直接拼接为一个长字符串,每个法定假日长度固定位13,如:2001122900+03
20011229
为2001年12月29日);0
为上班);0
为元旦节);+
为元旦节在2001年12月29日之后);03
为元旦节在2001年12月29日之后第3天)。通过next(1)获取下一个法定假日,相同假期名称且不上班的,取第一天。
// javascript
// 设置最多10条
var size = 10;
// 取今天
var now = new Date();
var year = now.getFullYear();
var today = SolarDay.fromYmd(year, now.getMonth() + 1, now.getDate());
var name = null;
var l = [];
// 元旦节当天肯定放假
var holiday = LegalHoliday.fromYmd(year, 1, 1);
while (holiday && size > 0) {
var nm = holiday.getName();
if (nm != name && !holiday.isWork() && holiday.getDay().isAfter(today)) {
l.push(holiday);
name = nm;
size--;
}
holiday = holiday.next(1);
}
for (var i = 0, j = l.length; i < j; i++) {
var h = l[i];
console.log('距 ' + h.getName() + '放假 还有 ' + (h.getDay().subtract(today) - 1) + ' 天');
}
如果只取一个最近的法定假日,就简单许多。
// javascript
// 取今天
var now = new Date();
var year = now.getFullYear();
var today = SolarDay.fromYmd(year, now.getMonth() + 1, now.getDate());
// 元旦节当天肯定放假
var holiday = LegalHoliday.fromYmd(year, 1, 1);
while (holiday) {
if (!holiday.isWork() && holiday.getDay().isAfter(today)) {
console.log('距 ' + holiday.getName() + '放假 还有 ' + (holiday.getDay().subtract(today) - 1) + ' 天');
break;
}
holiday = holiday.next(1);
}
公历现代节日有:元旦、三八妇女节、植树节、五一劳动节、五四青年节、六一儿童节、建党节、八一建军节、教师节、国庆节。可以通过公历日 SolarDay得到,也可指定年、月、日得到,也可指定索引得到。
// 元旦
SolarFestival festival = SolarDay.fromYmd(2023, 1, 1).getFestival();
// 2023年第1个公历现代节日,元旦
festival = SolarFestival.fromIndex(2023, 0);
// 非公历现代节日,返回null
festival = SolarDay.fromYmd(2023, 1, 20).getFestival();
// 非公历现代节日,返回null
festival = SolarFestival.fromYmd(2023, 4, 20);
公历现代节日都设有起始年,你可以用getStartYear()得到。
// 元旦
SolarFestival festival = SolarDay.fromYmd(2023, 1, 1).getFestival();
// 1950
int startYear = festival.getStartYear();
农历传统节日有:春节、元宵节、龙头节、上巳节、清明节、端午节、七夕节、中元节、中秋节、重阳节、冬至节、腊八节、除夕。可以通过农历日 LunarDay得到,也可指定农历年、月、日得到,也可指定索引得到。
// 元宵节
LunarFestival festival = LunarDay.fromYmd(2023, 1, 15).getFestival();
// 2023年第1个农历传统节日,春节
festival = LunarFestival.fromIndex(2023, 0);
// 非农历传统节日,返回null
festival = LunarDay.fromYmd(2023, 1, 2).getFestival();
// 非农历传统节日,返回null
festival = LunarFestival.fromYmd(2023, 1, 2);
星期依次为:日、一、二、三、四、五、六。如下代码可指定从周几开始输出一周:
// 以周一为起点
int startIndex = 1;
Week week = Week.fromIndex(startIndex);
for (int i = 0; i < 7; i++) {
System.out.println(week);
// 往后推1天
week = week.next(1);
}
每个节气持续15天左右,每隔5天为一候,因此从节气日开始,分别为初候、二候、三候。
// 初候
ThreePhenology threePhenology = SolarDay.fromYmd(2020, 4, 23).getPhenologyDay().getPhenology().getThreePhenology();
三伏,是初伏、中伏和末伏的统称,是一年中最热的时节。
民谚云:“夏至三庚入伏,冬至逢壬数九。”
三伏即是从夏至后第3个庚日算起,初伏为10天,中伏为10天或20天,末伏为10天。当夏至与立秋之间出现4个庚日时中伏为10天,出现5个庚日则为20天。
// 末伏第2天
DogDay dogDay = SolarDay.fromYmd(2012, 8, 8).getDogDay();
五行依次为:木、火、土、金、水。
Element me = Element.fromName("火");
// 土 (火生土)
Element el = me.getReinforce();
Element me = Element.fromName("金");
// 木 (金克木)
Element el = me.getRestrain();
Element me = Element.fromName("土");
// 火 (火生土)
Element el = me.getReinforced();
Element me = Element.fromName("木");
// 金 (金克木)
Element el = me.getRestrained();
六曜是中国传统历法中的一种注文,用以标示每日的凶吉。它起源于中国,据传由诸葛亮首创,称为“孔明六曜星”,主要用于军事韬略。但实际上,六曜是否形成于三国时期尚无定论,另一说认为六曜为唐代李淳风所创。后来传至日本,并于当地流行,在中国则日渐式微。历代版本有所转变,现时的版本分为先胜、友引、先负、佛灭、大安和赤口六种。
大安是六曜中最为吉利的一天,可以说在一整天的任何时间段都是吉利的。
友引仅次于大吉,仅在正午(11时-13时)为凶。
先胜和先负为一对,分别为上午吉和下午吉。上午吉,因此叫作先胜(早即赢),上午不吉,因此叫作先负(早即输)。日本人认为先胜日很适合博一把赌输赢,因此会把运动会和各类比赛放到这一天。而在先负日则期待平稳度过。
赤口被认为是凶日,做什么都不好,只有在短暂的正午(11时-13时)是吉利的。
佛灭则是六曜当中最不吉利的一天。
// 友引
SixStar sixStar = SolarDay.fromYmd(2020, 4, 10).getLunarDay().getSixStar();
小六壬是一种传统的中国占卜方法,它使用一种特殊的掌诀系统来预测未来的事件。小六壬的占卜过程涉及六个掌诀位,分别是大安、留连、速喜、赤口、小吉和空亡,这些掌诀位代表了占卜的不同结果和事物的吉凶。
// 速喜
MinorRen minorRen = LunarMonth.fromYm(1991, 3).getMinorRen();
// 大安
MinorRen minorRen = LunarDay.fromYmd(2024, 3, 5).getMinorRen();
// 留连
MinorRen minorRen = LunarHour.fromYmdHms(2024, 9, 7, 10, 0, 0).getMinorRen();
大安、速喜、小吉为吉,留连、赤口、空亡为凶。
// 大安
MinorRen minorRen = LunarDay.fromYmd(2024, 3, 5).getMinorRen();
// 吉
Luck luck = minorRen.getLuck();
// 大安
MinorRen minorRen = LunarDay.fromYmd(2024, 3, 5).getMinorRen();
// 木
Element element = minorRen.getElement();
也称七政、七纬、七耀,与星期一一对应,分别为:日、月、火、水、木、金、土。以下为七曜和星期的相互转换示例:
// 二
Week week = Week.fromIndex(2);
// 火
SevenStar sevenStar = week.getSevenStar();
sevenStar = SevenStar.fromName("土");
// 六
week = sevenStar.getWeek();
所谓八字,就是出生年、月、日、时辰的干支(分别称年柱、月柱、日柱、时柱),共8个字。
参数为年干支、月干支、日干支、时干支,可以同为字符串,也可同为干支 SixtyCycle对象。
// 初始化方式一
EightChar eightChar = new EightChar("丁丑", "癸卯", "癸丑", "辛酉");
// 初始化方式二
eightChar = new EightChar(
SixtyCycle.fromName("丁丑"),
SixtyCycle.fromName("癸卯"),
SixtyCycle.fromName("癸丑"),
SixtyCycle.fromName("辛酉")
);
// 2023年正月初一 10:00:00的八字
EightChar eightChar = LunarHour.fromYmdHms(2023, 1, 1, 10, 0, 0).getEightChar();
由于有的流派认为23:00-23:59日干支为当天,有的流派则认为应该算明天,可通过EightCharProvider来切换,默认支持以下几种方式,你也可以自定义。(切换后会影响八字转公历时刻的结果)
LunarHour.provider = new DefaultEightCharProvider();
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 23, 0, 0);
EightChar eightChar = lunarHour.getEightChar();
LunarHour.provider = new LunarSect2EightCharProvider();
LunarHour lunarHour = LunarHour.fromYmdHms(2023, 1, 1, 23, 0, 0);
EightChar eightChar = lunarHour.getEightChar();
实现EightCharProvider接口。
// 方式1,实现EightCharProvider接口
public class MyEightCharProvider implements EightCharProvider {
// 实现getEightChar方法
}
LunarHour.provider = new MyEightCharProvider();
getSolarTimes(startYear, endYear)
,参数startYear
为开始年份,支持1-9999年;参数endYear
为结束年份,支持1-9999年。返回为公历时刻 SolarTime的列表。
// 1937年3月27日 18:00:00、1997年3月12日 18:00:00
List<SolarTime> solarTimes = new EightChar("丁丑", "癸卯", "癸丑", "辛酉").getSolarTimes(1900, 2024);
getYear()
,返回为干支 SixtyCycle。
EightChar eightChar = new EightChar("丁丑", "癸卯", "癸丑", "辛酉");
// 丁丑
SixtyCycle year = eightChar.getYear();
getMonth()
,返回为干支 SixtyCycle。
EightChar eightChar = new EightChar("丁丑", "癸卯", "癸丑", "辛酉");
// 癸卯
SixtyCycle month = eightChar.getMonth();
getDay()
,返回为干支 SixtyCycle。
EightChar eightChar = new EightChar("丁丑", "癸卯", "癸丑", "辛酉");
// 癸丑
SixtyCycle day = eightChar.getDay();
getHour()
,返回为干支 SixtyCycle。
EightChar eightChar = new EightChar("丁丑", "癸卯", "癸丑", "辛酉");
// 辛酉
SixtyCycle hour = eightChar.getHour();
getFetalOrigin()
,返回为干支 SixtyCycle。
EightChar eightChar = new EightChar("癸卯", "辛酉", "己亥", "癸酉");
// 壬子
SixtyCycle fetalOrigin = eightChar.getFetalOrigin();
getFetalBreath()
,返回为干支 SixtyCycle。
EightChar eightChar = new EightChar("癸卯", "辛酉", "己亥", "癸酉");
// 甲寅
SixtyCycle fetalBreath = eightChar.getFetalBreath();
getOwnSign()
,返回为干支 SixtyCycle。
EightChar eightChar = new EightChar("癸卯", "辛酉", "己亥", "癸酉");
// 癸亥
SixtyCycle ownSign = eightChar.getOwnSign();
getBodySign()
,返回为干支 SixtyCycle。
EightChar eightChar = new EightChar("癸卯", "辛酉", "己亥", "癸酉");
// 己未
SixtyCycle bodySign = eightChar.getBodySign();
getDuty()
,返回为建除十二值神 Duty。
EightChar eightChar = new EightChar("癸卯", "辛酉", "己亥", "癸酉");
Duty duty = eightChar.getDuty();
九野和方位一一对应,依次为:玄天、朱天、苍天、阳天、钧天、幽天、颢天、变天、炎天。
getDirection()
返回为方位 Direction。
Land land = Land.fromName("玄天");
// 北
Direction direction = land.getDirection();
九星指北斗九星,我们熟知的北斗七星(天枢、天璇、天玑、天权、玉衡、开阳、摇光),在古代实际上有9颗,而随着时间的推移,另外2颗(洞明、隐元)逐渐暗淡,人眼已经不容易观察到。
// 三碧木
NineStar nineStar = LunarYear.fromYear(2024).getNineStar();
// 二黑土
NineStar nineStar = LunarMonth.fromYm(2024, 4).getNineStar();
// 六白金
NineStar nineStar = LunarDay.fromYmd(2024, 4, 13).getNineStar();
// 九紫火
NineStar nineStar = LunarHour.fromYmdHms(2024, 4, 13, 21, 55, 0).getNineStar();
NineStar nineStar = LunarYear.fromYear(2024).getNineStar();
// 碧
String color = nineStar.getColor();
NineStar nineStar = LunarYear.fromYear(2024).getNineStar();
// 木
Element element = nineStar.getElement();
NineStar nineStar = LunarYear.fromYear(2024).getNineStar();
// 东
Direction direction = nineStar.getDirection();
NineStar nineStar = LunarYear.fromYear(2024).getNineStar();
// 天玑
Dipper dipper = nineStar.getDipper();
北斗九星分别为:天枢、天璇、天玑、天权、玉衡、开阳、摇光、洞明、隐元。
// 天玑
Dipper dipper = LunarYear.fromYear(2024).getNineStar().getDipper();
数九,又称冬九九,是中国民间一种计算寒天与春暖花开日期的方法。一般“三九、四九”是一年中最冷的时段。当数到九个“九天”(九九八十一天),便春深日暖、万物生机盎然,是春耕的时候了。
民谚云:“夏至三庚入伏,冬至逢壬数九。”
数九即是从冬至逢壬日算起,每九天算一“九”。但是大部分人都不知道壬日是哪一天,就干脆采用按冬至日作为一九的开始了。这里的算法也是按冬至日起算。
还记得小时候学的数九歌吗?
一九二九不出手,三九四九冰上走,五九六九沿河看柳,七九河开,八九燕来,九九加一九,耕牛遍地走。
// 一九第2天
NineDay nineDay = SolarDay.fromYmd(2020, 12, 22).getNineDay();
十神是根据两个天干之间的五行关系得出的。生我者,正印偏印。我生者,伤官食神。克我者,正官七杀。我克者,正财偏财。同我者,劫财比肩。
// 比肩
TenStar tenStar = HeavenStem.fromName("甲").getTenStar(HeavenStem.fromName("甲"));
长生十二神又叫地势,是天干和地支之间的关系得出的。分别为:长生、沐浴、冠带、临官、帝旺、衰、病、死、墓、绝、胎、养。
// 沐浴
Terrain terrain = HeavenStem.fromName("癸").getTerrain(EarthBranch.fromName("寅"));
建除十二值神依次为:建、除、满、平、定、执、破、危、成、收、开、闭。
// 农历2021年正月初一的建除十二值神
Duty duty = LunarDay.fromYmd(2021, 1, 1).getDuty();
有些场景需要以节令切换的时刻区分,节令切换当天则会有两个值神,就需要从八字获取。
// 农历2021年正月初一 13:00:00的建除十二值神
Duty duty = LunarHour.fromYmdHms(2021, 1, 1, 13, 0, 0).getEightChar().getDuty();
黄道黑道十二神依次为:黄道、黑道。
getEcliptic()
返回为黄道黑道 Ecliptic。
TwelveStar twelveStar = TwelveStar.fromName("青龙");
// 黄道
Ecliptic ecliptic = twelveStar.getEcliptic();
二十八宿,是黄道附近的二十八组星象总称。上古时代人们根据日月星辰的运行轨迹和位置,把黄道附近的星象划分为二十八组,俗称二十八宿,包括:
东方七宿:角、亢、氐、房、心、尾、箕;
北方七宿:斗、牛、女、虚、危、室、壁;
西方七宿:奎、娄、胃、昴、毕、觜、参;
南方七宿:井、鬼、柳、星、张、翼、轸。
七十二候,是我国古代用来指导农事活动的历法补充。它是根据黄河流域的地理、气候、和自然界的一些景象编写而成,以五日为候,三候为气,六气为时,四时为岁,一年“二十四节气”共七十二候。各候均以一个物候现象相应,称“候应”。其中植物候应有植物的幼芽萌动、开花、结实等;动物候应有动物的始振、始鸣、交配、迁徙等;非生物候应有始冻、解冻、雷始发声等。七十二候“候应”的依次变化,反映了一年中物候和气候变化的一般情况。
// 萍始生第5天
PhenologyDay phenologyDay = SolarDay.fromYmd(2020, 4, 23).getPhenologyDay();
干支,又叫六十甲子、六十干支周,依次为:甲子、乙丑、丙寅、丁卯、戊辰、己巳、庚午、辛未、壬申、癸酉、甲戌、乙亥、丙子、丁丑、戊寅、己卯、庚辰、辛巳、壬午、癸未、甲申、乙酉、丙戌、丁亥、戊子、己丑、庚寅、辛卯、壬辰、癸巳、甲午、乙未、丙申、丁酉、戊戌、己亥、庚子、辛丑、壬寅、癸卯、甲辰、乙巳、丙午、丁未、戊申、己酉、庚戌、辛亥、壬子、癸丑、甲寅、乙卯、丙辰、丁巳、戊午、己未、庚申、辛酉、壬戌、癸亥。
返回为天干 HeavenStem。
SixtyCycle sixtyCycle = SixtyCycle.fromIndex(1);
// 乙
HeavenStem heavenStem = sixtyCycle.getHeavenStem();
返回为地支 EarthBranch。
SixtyCycle sixtyCycle = SixtyCycle.fromIndex(1);
// 丑
EarthBranch earthBranch = sixtyCycle.getEarthBranch();
返回为纳音 Sound。
SixtyCycle sixtyCycle = SixtyCycle.fromIndex(1);
// 海中金
Sound sound = sixtyCycle.getSound();
返回为彭祖百忌 PengZu。
SixtyCycle sixtyCycle = SixtyCycle.fromIndex(1);
// 乙不栽植千株不长 丑不冠带主不还乡
PengZu pengZu = sixtyCycle.getPengZu();
返回为旬 Ten。
SixtyCycle sixtyCycle = SixtyCycle.fromName("乙卯");
// 甲寅
Ten ten = sixtyCycle.getTen();
也称空亡,10天干与12地支匹配,必定会多出来2个地支,这2个即为旬空。返回为地支 EarthBranch。
SixtyCycle sixtyCycle = SixtyCycle.fromName("甲子");
// 戌, 亥
EarthBranch[] extraEarthBranches = sixtyCycle.getExtraEarthBranches();
天干依次为:甲、乙、丙、丁、戊、己、庚、辛、壬、癸。
返回为五行 Element。
HeavenStem heavenStem = HeavenStem.fromName("丙");
// 火
Element element = heavenStem.getElement();
返回为阴阳 YinYang。
HeavenStem heavenStem = HeavenStem.fromName("甲");
// 阳
YinYang yinYang = heavenStem.getYinYang();
返回为方位 Direction。
HeavenStem heavenStem = HeavenStem.fromName("甲");
// 方位:东
Direction direction = heavenStem.getDirection();
// 喜神方位(《喜神方位歌》甲己在艮乙庚乾,丙辛坤位喜神安。丁壬只在离宫坐,戊癸原在在巽间。)
direction = heavenStem.getJoyDirection();
// 阳贵神方位(《阳贵神歌》甲戊坤艮位,乙己是坤坎,庚辛居离艮,丙丁兑与乾,震巽属何日,壬癸贵神安。)
direction = heavenStem.getYangDirection();
// 阴贵神方位(《阴贵神歌》甲戊见牛羊,乙己鼠猴乡,丙丁猪鸡位,壬癸蛇兔藏,庚辛逢虎马,此是贵神方。)
direction = heavenStem.getYinDirection();
// 财神方位(《财神方位歌》甲乙东北是财神,丙丁向在西南寻,戊己正北坐方位,庚辛正东去安身,壬癸原来正南坐,便是财神方位真。)
direction = heavenStem.getWealthDirection();
// 福神方位(《福神方位歌》甲乙东南是福神,丙丁正东是堪宜,戊北己南庚辛坤,壬在乾方癸在西。)
direction = heavenStem.getMascotDirection();
HeavenStem heavenStem = HeavenStem.fromName("甲");
// 甲不开仓财物耗散
PengZuHeavenStem pengZuHeavenStem = heavenStem.getPengZuHeavenStem();
调用getTenStar(heavenStem)
得到十神,参数为天干 HeavenStem ,返回为十神 TenStar。十神是通过五行判断,规则为:生我者,正印偏印。我生者,伤官食神。克我者,正官七杀。我克者,正财偏财。同我者,劫财比肩。
// 日元(日主)
HeavenStem me = HeavenStem.fromName("癸");
// 正财
TenStar tenStar = me.getTenStar(HeavenStem.fromName("丙"));
调用getTerrain(earthBranch)
得到长生十二神,参数为地支 EarthBranch ,返回为长生十二神 Terrain。长生十二神可通过不同的组合,得到自坐和星运。
// 日元(日主)
HeavenStem me = HeavenStem.fromName("癸");
// 星运:沐浴
Terrain terrain = me.getTerrain(EarthBranch.fromName("寅"));
地支依次为:子、丑、寅、卯、辰、巳、午、未、申、酉、戌、亥。
返回为五行 Element。
EarthBranch earthBranch = EarthBranch.fromName("寅");
// 木
Element element = earthBranch.getElement();
返回为阴阳 YinYang。
EarthBranch earthBranch = EarthBranch.fromName("子");
// 阳
YinYang yinYang = earthBranch.getYinYang();
返回为方位 Direction。
EarthBranch earthBranch = EarthBranch.fromName("子");
// 方位:北
Direction direction = earthBranch.getDirection();
EarthBranch earthBranch = EarthBranch.fromName("子");
// 子不问卜自惹祸殃
PengZuEarthBranch pengZuEarthBranch = earthBranch.getPengZuEarthBranch();
返回为生肖 Zodiac。
EarthBranch earthBranch = EarthBranch.fromName("子");
// 鼠
Zodiac zodiac = earthBranch.getZodiac();
子午冲,丑未冲,寅申冲,辰戌冲,卯酉冲,巳亥冲。getOpposite()
返回为地支 EarthBranch。
EarthBranch earthBranch = EarthBranch.fromName("子");
// 午
EarthBranch zodiac = earthBranch.getOpposite();
逢巳日、酉日、丑日必煞东;亥日、卯日、未日必煞西;申日、子日、辰日必煞南;寅日、午日、戌日必煞北。getOminous()
返回为方位 Direction。
EarthBranch earthBranch = EarthBranch.fromName("子");
// 南
Direction direction = earthBranch.getOminous();
getHideHeavenStemMain()
返回为天干 HeavenStem。
EarthBranch earthBranch = EarthBranch.fromName("子");
// 癸
HeavenStem heavenStem = earthBranch.getHideHeavenStemMain();
getHideHeavenStemMiddle()
返回为天干 HeavenStem,无中气的返回null。
EarthBranch earthBranch = EarthBranch.fromName("寅");
// 丙
HeavenStem heavenStem = earthBranch.getHideHeavenStemMiddle();
getHideHeavenStemResidual()
返回为天干 HeavenStem,无余气的返回null。
EarthBranch earthBranch = EarthBranch.fromName("寅");
// 戊
HeavenStem heavenStem = earthBranch.getHideHeavenStemResidual();
纳音依次为:海中金、炉中火、大林木、路旁土、剑锋金、山头火、涧下水、城头土、白蜡金、杨柳木、泉中水、屋上土、霹雳火、松柏木、长流水、沙中金、山下火、平地木、壁上土、金箔金、覆灯火、天河水、大驿土、钗钏金、桑柘木、大溪水、沙中土、天上火、石榴木、大海水。
彭祖百忌,指在天干地支记日中的某日或当日里的某时不要做某事否则会发生某事。口诀如下:
// 天干忌讳
甲不开仓财物耗散,乙不栽植千株不长;
丙不修灶必见灾殃,丁不剃头头必生疮;
戊不受田田主不祥,己不破券二比并亡;
庚不经络织机虚张,辛不合酱主人不尝;
壬不泱水更难提防,癸不词讼理弱敌强。
// 地支忌讳
子不问卜自惹祸殃,丑不冠带主不还乡;
寅不祭祀神鬼不尝,卯不穿井水泉不香;
辰不哭泣必主重丧,巳不远行财物伏藏;
午不苫盖屋主更张,未不服药毒气入肠;
申不安床鬼祟入房,酉不会客醉坐颠狂;
戌不吃犬作怪上床,亥不嫁娶不利新郎。
// 甲不开仓财物耗散 子不问卜自惹祸殃
PengZu pengZu = SixtyCycle.fromName("甲子").getPengZu();
getPengZuHeavenStem()
返回为天干彭祖百忌 PengZuHeavenStem。
PengZu pengZu = SixtyCycle.fromName("甲子").getPengZu();
// 甲不开仓财物耗散
PengZuHeavenStem pengZuHeavenStem = pengZu.getPengZuHeavenStem();
getPengZuHeavenStem()
返回为地支彭祖百忌 PengZuEarthBranch。
PengZu pengZu = SixtyCycle.fromName("甲子").getPengZu();
// 子不问卜自惹祸殃
PengZuEarthBranch pengZuEarthBranch = pengZu.getPengZuEarthBranch();
也可直接通过天干 HeavenStem获取天干彭祖百忌 PengZuHeavenStem,通过地支 EarthBranch直接获取地支彭祖百忌 PengZuEarthBranch。
// 甲不开仓财物耗散
PengZuHeavenStem pengZuHeavenStem = HeavenStem.fromName("甲").getPengZuHeavenStem();
// 子不问卜自惹祸殃
PengZuEarthBranch pengZuEarthBranch = EarthBranch.fromName("子").getPengZuEarthBranch();
黄道黑道就两种,依次为:黄道、黑道。
getLuck()
返回为吉凶 Luck。
Ecliptic ecliptic = Ecliptic.fromName("黄道");
// 吉
Luck luck = ecliptic.getLuck();
目前只支持两种,依次为:吉、凶。
依据后天八卦排序:坎北、坤西南、震东、巽东南、中、乾西北、兑西、艮东北、离南),方位依次为:北、西南、东、东南、中、西北、西、东北、南。
getLand()
返回为九野 Land。
Direction direction = Direction.fromName("北");
// 玄天
Land land = direction.getLand();
宫依次为:东、北、西、南。
getDirection()
返回为方位 Direction。
Zone zone = Zone.fromName("东");
// 东
Direction direction = zone.getDirection();
getBeast()
返回为神兽 Beast。
Zone zone = Zone.fromName("东");
// 青龙
Beast direction = zone.getBeast();
神兽和宫一一对应,依次为:青龙、玄武、白虎、朱雀。
getZone()
返回为宫 Zone。
Beast beast = Beast.fromName("青龙");
// 东
Zone zone = beast.getZone();
动物一般用于二十八宿,依次为:蛟、龙、貉、兔、狐、虎、豹、獬、牛、蝠、鼠、燕、猪、獝、狼、狗、彘、鸡、乌、猴、猿、犴、羊、獐、马、鹿、蛇、蚓。
LunarDay d = LunarDay.fromYmd(2020, 4, 13);
// 翼
TwentyEightStar star = d.getTwentyEightStar();
// 蛇
Animal animal = star.getAnimal();
一元等于三运,也就是60年,1甲子,元依次为:上元、中元、下元。常说三元九运,可以涵盖180年。
// 九运
Twenty twenty = LunarYear.fromYear(1863).getTwenty();
// 下元
Sixty sixty = twenty.getSixty();
20年为1运,一共有九运,依次为:一运、二运、三运、四运、五运、六运、七运、八运、九运。
// 二运
Twenty twenty = LunarYear.fromYear(1884).getTwenty();
旬依次为:甲子、甲戌、甲申、甲午、甲辰、甲寅。1旬=10,常听说的八旬老人指80岁的老人,每月有上旬、中旬、下旬,指的则是10天。6旬正好为60年,对应六十甲子。
从干支 SixtyCycle得到。
SixtyCycle sixtyCycle = SixtyCycle.fromName("乙卯");
// 甲寅
Ten ten = sixtyCycle.getTen();
江淮流域一带约6月上旬后出现的阴雨天气,称做梅雨期。梅雨期的始日谓“入梅”,也称“入霉”、“进梅”;梅雨期的终日谓“出梅”,也称“出霉”,“断梅”。梅雨期间的降水称为梅雨,此时正值江南梅子成熟期,故得名。
芒种后的第1个丙日入梅,小暑后的第1个未日出梅。
// 入梅第1天
PlumRainDay plumRainDay = SolarDay.fromYmd(2024, 6, 11).getPlumRainDay();
胎神是掌管妇女胎孕之事的神灵。民间认为胎神是不能触犯的,触犯了胎神就会危及母腹中的婴儿。胎神的活动被看成是有规律的,它往往按照时间的移动而处在房间的不同位置。正十二月在床房,二三九十门户中,四六十一灶勿犯,五甲七子八厕凶。闰月无胎神。
LunarMonth lunarMonth = LunarMonth.fromYm(2024, 4);
// 占厨灶
FetusMonth fetus = lunarMonth.getFetus();
参考多方资料对比、修正,最终形成了这个我自认为最靠谱的逐日胎神表。
甲子日 占门碓 外东南, 乙丑日 碓磨厕 外东南, 丙寅日 厨灶炉 外正南, 丁卯日 仓库门 外正南, 戊辰日 房床栖 外正南, 己巳日 占门床 外正南, 庚午日 占碓磨 外正南, 辛未日 厨灶厕 外西南, 壬申日 仓库炉 外西南, 癸酉日 房床门 外西南
甲戌日 占门栖 外西南, 乙亥日 碓磨床 外西南, 丙子日 厨灶碓 外西南, 丁丑日 仓库厕 外正西, 戊寅日 房床炉 外正西, 己卯日 占大门 外正西, 庚辰日 碓磨栖 外正西, 辛巳日 厨灶床 外正西, 壬午日 仓库碓 外西北, 癸未日 房床厕 外西北
甲申日 占门炉 外西北, 乙酉日 碓磨门 外西北, 丙戌日 厨灶栖 外西北, 丁亥日 仓库床 外西北, 戊子日 房床碓 外正北, 己丑日 占门厕 外正北, 庚寅日 碓磨炉 外正北, 辛卯日 厨灶门 外正北, 壬辰日 仓库栖 外正北, 癸巳日 占房床 房内北
甲午日 占门碓 房内北, 乙未日 碓磨厕 房内北, 丙申日 厨灶炉 房内北, 丁酉日 仓库门 房内北, 戊戌日 房床栖 房内中, 己亥日 占门床 房内中, 庚子日 占碓磨 房内南, 辛丑日 厨灶厕 房内南, 壬寅日 仓库炉 房内南, 癸卯日 房床门 房内西
甲辰日 占门栖 房内东, 乙巳日 碓磨床 房内东, 丙午日 厨灶碓 房内东, 丁未日 仓库厕 房内东, 戊申日 房床炉 房内中, 己酉日 占大门 外东北, 庚戌日 碓磨栖 外东北, 辛亥日 厨灶床 外东北, 壬子日 仓库碓 外东北, 癸丑日 房床厕 外东北
甲寅日 占门炉 外东北, 乙卯日 碓磨门 外正东, 丙辰日 厨灶栖 外正东, 丁巳日 仓库床 外正东, 戊午日 房床碓 外正东, 己未日 占门厕 外正东, 庚申日 碓磨炉 外东南, 辛酉日 厨灶门 外东南, 壬戌日 仓库栖 外东南, 癸亥日 占房床 外东南
LunarDay lunarDay = LunarDay.fromYmd(2024, 4, 22);
// 占房床 房内北
FetusDay fetus = lunarDay.getFetusDay();
FetusDay fetus = LunarDay.fromYmd(2024, 4, 22).getFetusDay();
// 内
Side side = fetus.getSide();
FetusDay fetus = LunarDay.fromYmd(2024, 4, 22).getFetusDay();
// 北
Direction direction = fetus.getDirection();
FetusDay fetus = LunarDay.fromYmd(2024, 4, 22).getFetusDay();
// 房
FetusHeavenStem fetusHeavenStem = fetus.getFetusHeavenStem();
FetusDay fetus = LunarDay.fromYmd(2024, 4, 22).getFetusDay();
// 床
FetusEarthBranch fetusEarthBranch = fetus.getFetusEarthBranch();
天干六甲胎神歌:甲己之日占在门,乙庚碓磨休移动。丙辛厨灶莫相干,丁壬仓库忌修弄。戊癸房床若移整,犯之孕妇堕孩童。
天干六甲胎神所在位置分别为:门、碓磨、厨灶、仓库、房床。
地支六甲胎神歌:子午二日碓须忌,丑未厕道莫修移。寅申火炉休要动,卯酉大门修当避。辰戌鸡栖巳亥床,犯着六甲身堕胎。
地支六甲胎神所在位置分别为:碓、厕、炉、门、栖、床。
宜忌包括每日宜忌、时辰宜忌,数据仅供参考。
LunarDay lunarDay = SolarDay.fromYmd(2024, 6, 26).getLunarDay();
// 宜:嫁娶, 祭祀, 理发, 作灶, 修饰垣墙, 平治道涂, 整手足甲, 沐浴, 冠笄
List<Taboo> taboos = lunarDay.getRecommends();
// 忌:破土, 出行, 栽种
taboos = lunarDay.getAvoids();
LunarHour hour = SolarTime.fromYmdHms(2024, 4, 22, 0, 0, 0).getLunarHour();
// 宜:嫁娶, 交易, 开市, 安床, 祭祀, 求财
List<Taboo> taboos = hour.getRecommends();
// 忌:出行, 移徙, 赴任, 词讼, 祈福, 修造, 求嗣
taboos = hour.getAvoids();
目前只支持农历日的吉神宜驱、凶神宜忌。
LunarDay lunarDay = SolarDay.fromYmd(1954, 7, 16).getLunarDay();
// 获得当天的神煞列表
List<God> gods = lunarDay.getGods();
// 吉神宜趋
List<God> goodGods = new ArrayList<>();
// 凶神宜忌
List<God> badGods = new ArrayList<>();
// 遍历,根据神煞吉凶区分吉神和凶神
for (God god : gods) {
if ("吉".equals(god.getLuck().getName())) {
goodGods.add(god);
} else {
badGods.add(god);
}
}
如上图所示,童限为从出生到起运之间的时间,童限的开始即出生,童限的结束即起运。
// 得到公历2022年3月9日 20:51:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(2022, 3, 9, 20, 51, 0), Gender.MAN);
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 辛未 辛丑 戊申 戊午
EightChar eightChar = childLimit.getEightChar();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// Gender.MAN (男)
Gender gender = childLimit.getGender();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// false (逆推)
boolean forward = childLimit.isForward();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 9
int n = childLimit.getYearCount();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 0
int n = childLimit.getMonthCount();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 9
int n = childLimit.getDayCount();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 6
int n = childLimit.getHourCount();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 58
int n = childLimit.getMinuteCount();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 1992年2月2日 12:00:00
SolarTime time = childLimit.getStartTime();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 2001年2月11日 18:58:00
SolarTime time = childLimit.getEndTime();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 庚子
DecadeFortune decadeFortune = childLimit.getStartDecadeFortune();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 戊申
Fortune decadeFortune = childLimit.getStartFortune();
童限的计算可通过ChildLimitProvider来切换,默认支持以下几种计算方式,你也可以自定义。
计算出生时刻和节令时刻相差的秒数,按3天 = 1年(3天 = 60秒 * 60 * 24 * 3 = 259200秒 = 1年)、1天 = 4月(1天 = 60秒 * 60 * 24 = 86400秒 = 4月,85400秒 / 4 = 21600秒 = 1月)、1时 = 5天(1时 = 60秒 * 60 = 3600秒 = 5天,3600秒 / 5 = 720秒 = 1天)、1分 = 2时(1分 = 60秒 = 2时,60秒 / 2 = 30秒 = 1时)、1秒 = 2分(1秒 / 2 = 0.5秒 = 1分)进行推移,最终起运时间精确到分钟。
ChildLimit.provider = new DefaultChildLimitProvider();
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(2022, 3, 9, 20, 51, 0), Gender.MAN);
计算出生时刻和节令时刻相差的分钟数,按3天 = 1年(3天 = 60分 * 24 * 3 = 4320分 = 1年)、1天 = 4月(1天 = 60分 * 24 = 1440分, 1440分 / 4 = 360分 = 1月)、1时 = 5天(1时 = 60分 = 5天,60分 / 5 = 12分 = 1天)进行推移,最终起运时间精确到日。
ChildLimit.provider = new China95ChildLimitProvider();
直接用相差的天数和时辰数计算,按3天 = 1年、1天 = 4月、1时辰 = 10天进行推移,最终起运时间精确到日。
ChildLimit.provider = new LunarSect1ChildLimitProvider();
计算出生时刻和节令时刻相差的分钟数,按3天 = 1年(3天 = 60分 * 24 * 3 = 4320分 = 1年)、1天 = 4月(1天 = 60分 * 24 = 1440分, 1440分 / 4 = 360分 = 1月)、1时 = 5天(1时 = 60分 = 5天,60分 / 5 = 12分 = 1天)、1分 = 2时进行推移,最终起运时间精确到小时。
ChildLimit.provider = new LunarSect2ChildLimitProvider();
实现ChildLimitProvider接口,或继承AbstractChildLimitProvider抽象类。
// 方式1,实现ChildLimitProvider接口
public class MyChildLimitProvider implements ChildLimitProvider {
// 实现getInfo方法
}
// 方式2,继承AbstractChildLimitProvider抽象类
public class MyChildLimitProvider extends AbstractChildLimitProvider {
// 实现getInfo方法
}
ChildLimit.provider = new MyChildLimitProvider();
自起运开始,每十年为一大运。童限结束的公历时刻,即开始起运,是大运的开始。
// 得到公历2022年3月9日 20:51:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(2022, 3, 9, 20, 51, 0), Gender.MAN);
// 开始的大运
DecadeFortune decadeFortune = childLimit.getStartDecadeFortune();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 开始的大运 (庚子)
DecadeFortune decadeFortune = childLimit.getStartDecadeFortune();
// 10 (10岁)
int age = decadeFortune.getStartAge();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 开始的大运 (庚子)
DecadeFortune decadeFortune = childLimit.getStartDecadeFortune();
// 19 (19岁)
int age = decadeFortune.getEndAge();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 开始的大运 (庚子)
DecadeFortune decadeFortune = childLimit.getStartDecadeFortune();
// 农历辛巳年
LunarYear year = decadeFortune.getStartLunarYear();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 开始的大运 (庚子)
DecadeFortune decadeFortune = childLimit.getStartDecadeFortune();
// 农历庚寅年
LunarYear year = decadeFortune.getEndLunarYear();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 开始的大运 (庚子)
DecadeFortune decadeFortune = childLimit.getStartDecadeFortune();
// 庚子
SixtyCycle sixtyCycle = decadeFortune.getSixtyCycle();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 开始的大运 (庚子)
DecadeFortune decadeFortune = childLimit.getStartDecadeFortune();
// 戊申
Fortune fortune = decadeFortune.getStartFortune();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 开始的大运 (庚子)
DecadeFortune decadeFortune = childLimit.getStartDecadeFortune();
// 下一轮大运
decadeFortune = decadeFortune.next(1);
// 上一轮大运
decadeFortune = decadeFortune.next(-1);
在十年大运中,每一年为一小运。童限结束的公历时刻,既是大运的开始,也是小运的开始。
// 得到公历2022年3月9日 20:51:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(2022, 3, 9, 20, 51, 0), Gender.MAN);
// 开始的小运
Fortune fortune = childLimit.getStartFortune();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 开始的小运 (戊申)
Fortune fortune = childLimit.getStartFortune();
// 10 (10岁)
int age = fortune.getAge();
由于1大运为10年,对应10小运,因此1小运对应1年,称为流年。
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 开始的小运 (戊申)
Fortune fortune = childLimit.getStartFortune();
// 农历辛巳年
LunarYear year = fortune.getLunarYear();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 开始的小运 (戊申)
Fortune fortune = childLimit.getStartFortune();
// 戊申
SixtyCycle sixtyCycle = fortune.getSixtyCycle();
// 得到公历1992年2月2日 12:00:00生男的童限
ChildLimit childLimit = ChildLimit.fromSolarTime(SolarTime.fromYmdHms(1992, 2, 2, 12, 0, 0), Gender.MAN);
// 开始的小运 (戊申)
Fortune fortune = childLimit.getStartFortune();
// 下一个小运
fortune = fortune.next(1);
// 上一个小运
fortune = fortune.next(-1);
枚举类型都可以调用以下几个方法:
调用getName()
返回名称字符串。
// 性别
Gender gender = Gender.fromName("男");
// 男
String name = gender.getName();
调用getCode()
返回数字代码。
// 性别
Gender gender = Gender.fromName("男");
// 1
int code = gender.getCode();
调用fromCode(code)
得到枚举对象。code
为数字代码。
// 阴
YinYang yinYang = YinYang.fromCode(0);
调用fromName(name)
得到枚举对象。name
为字符串,当名称不存在时,返回空。
// 阴
YinYang yinYang = YinYang.fromName("阴");
节日类型枚举值有:DAY=0=日期,TERM=1=节气,EVE=2=除夕。
性别枚举值有:WOMAN=0=女,MAN=1=男。
内外枚举值有:IN=0=内,OUT=1=外。
阴阳枚举值有:YIN=0=阴,YANG=1=阳。