模块14.基础API

第一章.String

1.String介绍

1.概述:String 类代表字符串
2.特点:a.Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例(对象)实现凡是带双引号的,都是String的对象String s = "abc""abc"就是对象;String就是对象的数据类型;s就是对象名b.字符串是常量,它们的值在创建之后不能更改String s = "hello"s+="world" -> 会产生新对象c.String 对象是不可变的，所以可以共享String s1 = "abc"String s2 = "abc"

s+=“world” -> 会产生新对象

2.String的实现原理 ★

private final char[] value;

private final byte[] value;

1.jdk8的时候:String底层是一个被final修饰的char数组-> private final char[] value;
2.jdk9开始到之后:底层是一个被final修饰的byte数组-> private final byte[] value;一个char类型占2个字节一个byte类型占1个字节 -> 省内存空间  

字符串定义完之后,数组就创建好了,被final一修饰,数组的地址值直接定死

3.String的创建 ★ （无参、字符串、字符数组、字节数组）

1.String()  -> 利用String的无参构造创建String对象
2.String(String original) -> 根据字符串创建String对象
3.String(char[] value) -> 根据char数组创建String对象
4.String(byte[] bytes) -> 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 Stringa.平台:操作系统b.操作系统默认字符集:GBKGBK:一个中文占2个字节UTF-8:一个中文占3个字节而且,中文对应的字节一般都是负数代码在idea中写的,idea启动的时候,会自动加一个启动参数,此启动参数为UTF-8-Dfile.encoding=UTF-8    5.简化形式:String 变量名 = ""

public class Demo02String {public static void main(String[] args) {//1.String()  -> 利用String的无参构造创建String对象String s1 = new String(); //System.out.println(s1);//2.String(String original) -> 根据字符串创建String对象String s2 = new String("abc");System.out.println(s2);//3.String(char[] value) -> 根据char数组创建String对象char[] chars = {'a','b','c'};String s3 = new String(chars);System.out.println(s3);/*4.String(byte[] bytes) -> 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String*/byte[] bytes1 = {97,98,99};String s4 = new String(bytes1);System.out.println(s4);byte[] bytes2 = {-97,-98,-99};String s5 = new String(bytes2);System.out.println(s5);byte[] bytes3 = {-28,-67,-96};String s6 = new String(bytes3);System.out.println(s6);//5.简化形式String s7 = "abc";System.out.println(s7);}
}

1.String(char[] value, int offset, int count)->将char数组的一部分转成String对象 value:要转String的char数组offset:从数组的哪个索引开始转count:转多少个
2.String(byte[] bytes, int offset, int length)->将byte数组的一部分转成String对象 bytes:要转String的byte数组offset:从数组的哪个索引开始转length:转多少个

public class Demo03String {public static void main(String[] args) {/* 1.String(char[] value, int offset, int count)->将char数组的一部分转成String对象value:要转String的char数组offset:从数组的哪个索引开始转count:转多少个*/char[] chars = {'a','b','c','d','e','f'};String s1 = new String(chars,1,3);System.out.println(s1);/* 2.String(byte[] bytes, int offset, int length)->将byte数组的一部分转成String对象bytes:要转String的byte数组offset:从数组的哪个索引开始转length:转多少个*/byte[] bytes = {97,98,99,100,101};String s2 = new String(bytes,0,2);System.out.println(s2);}
}

4.String 面试题【String s = new String(“abc”)】 ★

public class Demo04String {public static void main(String[] args) {String s1 = "abc";String s2 = "abc";String s3 = new String("abc");System.out.println(s1==s2);//trueSystem.out.println(s1==s3);//falseSystem.out.println(s2==s3);//false}
}

问1:String s = new String("abc")共有几个对象? 2个一个new本身   一个是"abc"问2:String s = new String("abc")共创建了几个对象?  1个或者2个就看abc有没有提前创建出来了

5.字符串常见问题（会不会产生新的字符串）

public class Demo05String {public static void main(String[] args) {String s1 = "hello";String s2 = "world";String s3 = "helloworld";String s4 = "hello"+"world";String s5 = s1+"world";String s6 = s1+s2;System.out.println(s3==s4);//trueSystem.out.println(s3==s5);//falseSystem.out.println(s3==s6);//false}
}

1.字符串拼接,如果等号右边是字符串字面值拼接,不会产生新对象

2.字符串拼接,如果等号右边有变量参数拼接,会产生新字符串对象

第二章.String的方法

1.判断方法（equals equalsIgnoreCase）

boolean equals(String s) -> 比较字符串内容
boolean equalsIgnoreCase(String s) -> 比较字符串内容,忽略大小写           

public class Demo01String {public static void main(String[] args) {String s1 = "abc";String s2 = new String("abc");String s3 = "Abc";System.out.println(s1==s2);//比较地址值了//boolean equals(String s) -> 比较字符串内容System.out.println(s1.equals(s2));//boolean equalsIgnoreCase(String s) -> 比较字符串内容,忽略大小写System.out.println(s1.equalsIgnoreCase(s3));System.out.println("=========================");String s4 = "123";String s5 = "一二三";System.out.println(s4.equalsIgnoreCase(s5));//falseString s6 = "壹贰叁";System.out.println(s5.equalsIgnoreCase(s6));//false}
}

2.练习1

已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录成功与否，给出相应的提示
步骤:1.先定义两个字符串,表示注册过的用户名和密码2.创建Scanner对象,键盘录入用户名和密码3.比较,如果输入的用户名和密码跟已经注册过的用户名和密码内容一样,就登录成功,否则就登录失败

public class Demo02String {public static void main(String[] args) {//1.先定义两个字符串,表示注册过的用户名和密码String username = "root";String password = "123";//2.创建Scanner对象,键盘录入用户名和密码Scanner sc = new Scanner(System.in);for (int i = 0; i < 3; i++) {System.out.println("请您输入用户名:");String name = sc.next();System.out.println("请您输入密码:");String pwd = sc.next();//3.比较,如果输入的用户名和密码跟已经注册过的用户名和密码内容一样,就登录成功,否则就登录失败if (name.equals(username) && pwd.equals(password)) {System.out.println("登录成功");break;} else {if (i == 2) {System.out.println("账号冻结");} else {System.out.println("登录失败!");}}}}
}

package com.atguigu.b_stringmethod;import java.util.Objects;public class Demo03String {public static void main(String[] args) {//String s = "abc";String s = null;//method(s);String s1 = null;String s2 = "abc";method01(s1,s2);}/*工具类:Objects方法:判断两个对象是否相等 -> 自带防空指针作用public static boolean equals(Object a, Object b) {return (a == b) || (a != null && a.equals(b));}*/private static void method01(String s1, String s2) {if (Objects.equals(s1,s2)){System.out.println("是abc");}else{System.out.println("不是abc");}}/*如果传递过来的对象是null,再去点其他方法,就会空指针解决:不要让一个字符串变量去点,用确定的字符串去点,可以防空*/private static void method(String s) {/*if (s.equals("abc")){System.out.println("是abc");}else{System.out.println("不是abc");}*/if ("abc".equals(s)){System.out.println("是abc");}else{System.out.println("不是abc");}}
}

3.获取功能（length、concat、charAt、indoxOf、subString）

int length() -> 获取字符串长度
String concat(String s)-> 字符串拼接,返回新串儿
char charAt(int index) -> 根据索引获取对应的字符
int indexOf(String s) -> 获取指定字符串在大字符串中第一次出现的索引位置
String subString(int beginIndex) -> 截取字符串,从指定索引开始截取到最后,返回新串儿
String subString(int beginIndex,int endIndex) -> 截取字符串,从beginIndex开始到endIndex结束含头不含尾,返回新串儿

public class Demo04String {public static void main(String[] args) {String s1 = "abcdefg";//int length() -> 获取字符串长度System.out.println(s1.length());//String concat(String s)-> 字符串拼接,返回新串儿System.out.println(s1.concat("haha"));//char charAt(int index) -> 根据索引获取对应的字符System.out.println(s1.charAt(0));//int indexOf(String s) -> 获取指定字符串在大字符串中第一次出现的索引位置System.out.println(s1.indexOf("a"));//String subString(int beginIndex) -> 截取字符串,从指定索引开始截取到最后,返回新串儿System.out.println(s1.substring(3));//String subString(int beginIndex,int endIndex) -> 截取字符串,从beginIndex开始到endIndex结束//含头不含尾,返回新串儿System.out.println(s1.substring(1,6));}
}

4.练习2

遍历字符串

public class Demo05String {public static void main(String[] args) {String s = "abcdefg";for (int i = 0; i < s.length(); i++) {System.out.println(s.charAt(i));}}
}

5.转换功能（toCharArray、getBytes、replace）

1.char[] toCharArray() -> 将字符串转成char数组
2.byte[] getBytes() -> 将字符串转成byte数组
3.String replace(CharSequence c1,CharSequence c2)-> 替换字符CharSequence->String的接口4.byte[] getBytes(String charsetName) -> 按照指定的编码将字符串转成byte数组    

public class Demo06String {public static void main(String[] args) throws UnsupportedEncodingException {String s = "abcdefg";//1.char[] toCharArray() -> 将字符串转成char数组char[] chars = s.toCharArray();for (int i = 0; i < chars.length; i++) {System.out.println(chars[i]);}System.out.println("===============");//2.byte[] getBytes() -> 将字符串转成byte数组byte[] bytes = s.getBytes();for (int i = 0; i < bytes.length; i++) {System.out.println(bytes[i]);}System.out.println("===============");//3.String replace(CharSequence c1,CharSequence c2)-> 替换字符 CharSequence->String的接口System.out.println(s.replace("a","z"));System.out.println("===============");//4.byte[] getBytes(String charsetName) -> 按照指定的编码将字符串转成byte数组byte[] bytes1 = "你好".getBytes("GBK");for (int i = 0; i < bytes1.length; i++) {System.out.println(bytes1[i]);}}
}

7.练习4

键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)
步骤:1.创建Scanner对象,键盘录入2.定义三个变量,用来统计3.调用next方法录入一个字符串,遍历字符串,将每一个字符拿出来4.统计大写字母A-Z -> 65-90比如:B -> 66 -> 在65-90之间,证明就是大写字母5.统计小写字母a-z -> 97-122比如:b -> 98 -> 在97-122之间,证明就是小写字母6.统计数字:0-9 -> 48-57比如:字符1 -> 49 -> 在48-57之间,证明就是数字7.将统计结果打印出来

public class Demo07String {public static void main(String[] args) {//1.创建Scanner对象,键盘录入Scanner sc = new Scanner(System.in);//2.定义三个变量,用来统计int big = 0;int small = 0;int number = 0;//3.调用next方法录入一个字符串,遍历字符串,将每一个字符拿出来String data = sc.next();char[] chars = data.toCharArray();for (int i = 0; i < chars.length; i++) {char num = chars[i];/*4.统计大写字母A-Z -> 65-90比如:B -> 66 -> 在65-90之间,证明就是大写字母*/if (num>='A' && num<='Z'){big++;}/*5.统计小写字母a-z -> 97-122比如:b -> 98 -> 在97-122之间,证明就是小写字母*/if (num>='a' && num<='z'){small++;}/*6.统计数字:0-9 -> 48-57比如:字符1 -> 49 -> 在48-57之间,证明就是数字*/if (num>='0' && num<='9'){number++;}}//7.将统计结果打印出来System.out.println("大写有"+big+"个");System.out.println("小写有"+small+"个");System.out.println("数字有"+number+"个");}
}

8.分割功能（split）

1.String[] split(String regex)->按照指定的规则分割字符串注意:regex写的是正则表达式 -> . 在正则表达式中代表任意一个字符

public class Demo08String {public static void main(String[] args) {String s = "abc,txt";String[] split = s.split(",");for (int i = 0; i < split.length; i++) {System.out.println(split[i]);}System.out.println("===============");String s2 = "haha.hehe";String[] split1 = s2.split("\\.");for (int i = 0; i < split1.length; i++) {System.out.println(split1[i]);}}
}

第三章.其他方法

contains、endsWith、startWith、toLowerCase、toUpperCase、trim

1.boolean contains(String s) -> 判断老串儿中是否包含指定的串儿
2.boolean endsWith(String s) -> 判断老串儿是否以指定的串儿结尾
3.boolean startsWith(String s) -> 判断老串儿是否以指定的串儿开头
4.String toLowerCase()-> 将字母转成小写
5.String toUpperCase() -> 将字母转成大写
6.String trim() -> 去掉字符串两端空格

public class Demo09String {public static void main(String[] args) {String s = "abcdefg";//1.boolean contains(String s) -> 判断老串儿中是否包含指定的串儿System.out.println(s.contains("a"));//2.boolean endsWith(String s) -> 判断老串儿是否以指定的串儿结尾System.out.println(s.endsWith("g"));//3.boolean startsWith(String s) -> 判断老串儿是否以指定的串儿开头System.out.println(s.startsWith("a"));//4.String toLowerCase()-> 将字母转成小写System.out.println("ADbcda".toLowerCase());//5.String toUpperCase() -> 将字母转成大写System.out.println("dafadRWERW".toUpperCase());//6.String trim() -> 去掉字符串两端空格System.out.println(" hadfhad hdsfha  sfhdsh ".trim());System.out.println("==================");System.out.println(" hadfhad hdsfha  sfhdsh ".replace(" ",""));}
}

第四章.StringBuilder类

1.StringBuilder的介绍

1.概述:一个可变的字符序列,此类提供了一个与StringBuffer兼容的一套API,但是不保证同步(线程不安全,效率高)
2.作用:主要是字符串拼接
3.问题:a.刚讲完String,String也能做字符串拼接,直接用+即可,但是为啥还要用StringBuilder去拼接呢?b.原因:String每拼接一次,就会产生新的字符串对象,就会在堆内存中开辟新的空间,如果拼接次数多了,会占用内存,效率比较底StringBuilder,底层自带一个缓冲区(没有被final修饰的byte数组)拼接字符串之后都会在此缓冲区中保存,在拼接的过程中,不会随意产生新对象,节省内存4.StringBuilder的特点:a.底层自带缓冲区,此缓冲区是没有被final修饰的byte数组,默认长度为16b.如果超出了数组长度,数组会自动扩容创建一个新长度的新数组,将老数组的元素复制到新数组中,然后将新数组的地址值重新赋值给老数组c.默认每次扩容老数组的2倍+2如果一次性添加的数据超出了默认的扩容数组长度(2倍+2),比如存了36个字符,超出了第一次扩容的34,就按照实际数据个数为准,就是以36扩容

StringBuilder,底层自带一个缓冲区(没有被final修饰的byte数组 拼接字符串之后都会在此缓冲区中保存,在拼接的过程中,不会随意产生新对象,节省内存

StringBuilder的特点:
a. 底层自带缓冲区,此缓冲区是没有被final修饰的byte数组,默认长度为16
b. 如果超出了数组长度,数组会自动扩容，创建一个新长度的新数组,将老数组的元素复制到新数组中,然后将新数组的地址值重新赋值给老数组
c.默认每次扩容老数组的2倍+2
如果一次性添加的数据超出了默认的扩容数组长度(2倍+2),比如存了36个字符,超出了第一次扩容的34,就按照实际数据个数为准,就是以36扩容

2.StringBuilder的使用

append、reverse、toString

1.构造:StringBuilder()StringBuilder(String str)    

public class Demo01StringBuilder {public static void main(String[] args) {StringBuilder sb = new StringBuilder();System.out.println(sb);StringBuilder sb1 = new StringBuilder("abc");System.out.println(sb1);}
}

常用方法:StringBuilder append(任意类型数据) -> 字符串拼接,返回的是StringBuilder自己StringBuilder reverse()-> 字符串翻转,返回的是StringBuilder自己String toString() -> 将StringBuilder转成String-> 用StringBuilder拼接字符串是为了效率,为了不占内存,那么拼完之后我们后续可能会对拼接好的字符串进行处理,就需要调用String中的方法,所以需要将StringBuilder转成String 

public class Demo02StringBuilder {public static void main(String[] args) {StringBuilder sb = new StringBuilder();StringBuilder sb1 = sb.append("张无忌");System.out.println(sb1);System.out.println(sb);System.out.println(sb==sb1);System.out.println("==============");//链式调用sb.append("赵敏").append("周芷若").append("小昭");System.out.println(sb);sb.reverse();System.out.println(sb);String s = sb.toString();System.out.println(s);}
}

练习:键盘录入一个字符串,判断此字符串是否为"回文内容"  比如: abcba  上海自来水来自海上

public class Demo03StringBuilder {public static void main(String[] args) {//1.创建Scanner对象Scanner sc = new Scanner(System.in);String data = sc.next();//2.创建StringBuilder对象StringBuilder sb = new StringBuilder(data);//3.翻转sb.reverse();//4.将StringBuilder转成StringString s = sb.toString();if (data.equals(s)){System.out.println("是回文内容");}else{System.out.println("不是回文内容");}}
}

3.练习

定义一个数组,以[元素1, 元素2, 元素3..]的形式输出,用StringBuilder拼接

自己做

String:拼接字符串效率低,每拼接一次,都会产生一个新的字符串对象,耗费内存资源

StringBuilder和StringBuffer区别:

a.相同点:

用法一样,作用一样

b.不同点:

StringBuilder:拼接效率比StringBuffer高

​ 线程不安全

StringBuffer:效率比较底,线程安全

拼接效率:StringBuilder>StringBuffer>String

模块15.常用API

模块14回顾:String:1.构造:String()  String(String s) String(char[] chars) String(byte[] bytes)String(char[] chars,int offset,int count) String(byte[] chars,int offset,int count)2.判断方法:equals   equalsIgnoreCase3.获取方法:length()  concat(String s)  charAt(int index) indexOf(String s) subString(开始索引)subString(开始索引,结束索引) -> 含头不含尾4.转换方法:toCharArray()  getBytes()   getBytes(String charsetName) replace(c1,c2)5.分割方法:split(String regex)6.其他方法:contains(String s) endsWith(String s) statsWith(String s) toLowerCase()toUpperCase() trim()StringBuilder:1.append(任意类型数据)2.reverse()3.toString()模块十五重点:1.会BigInteger和BigDecimal操作2.会Date和SimpleDateFormat的操作3.会System中的常用方法 -> 主要是数组复制4.会Arrays中的常用方法5.会利用包装类定义一个标准的javabean6.会包装类和String之间的转换

第一章.Math类

1.Math类介绍

1.概述:数学工具类
2.作用:主要用于数学运算
3.特点:a.构造方法私有了b.方法都是静态的
4.使用:类名直接调用

2.Math类方法

abs、ceil、floor、round、max、min

static int abs(int a) -> 求参数的绝对值
static double ceil(double a) -> 向上取整
static double floor(double a) ->向下取整
static long round(double a)  -> 四舍五入
static int max(int a, int b) ->求两个数之间的较大值 
static int min(int a, int b) ->求两个数之间的较小值

public class Demo01Math {public static void main(String[] args) {//static int abs(int a) -> 求参数的绝对值System.out.println(Math.abs(-10));//static double ceil(double a) -> 向上取整System.out.println(Math.ceil(3.6));//static double floor(double a) ->向下取整System.out.println(Math.floor(3.6));//static long round(double a)  -> 四舍五入System.out.println(Math.round(3.6));System.out.println(Math.round(-2.8));//static int max(int a, int b) ->求两个数之间的较大值System.out.println(Math.max(10,20));//static int min(int a, int b) ->求两个数之间的较小值System.out.println(Math.min(10,20));}
}

第二章.BigInteger

1.BigInteger介绍

add、subtract、multiply、divide

1.问题描述:我们操作数据,将来的数据有可能非常大,大到比long还要大,这种数据我们一般称之为"对象"
2.作用:处理超大整数
3.构造:BigInteger(String val) -> 参数的格式必须是数字形式
4.方法:BigInteger add(BigInteger val)  返回其值为 (this + val) 的 BigIntegerBigInteger subtract(BigInteger val) 返回其值为 (this - val) 的 BigIntegerBigInteger multiply(BigInteger val)  返回其值为 (this * val) 的 BigIntegerBigInteger divide(BigInteger val)    返回其值为 (this / val) 的 BigInteger   

2.BigInteger使用

public class Demo02BigInteger {public static void main(String[] args) {BigInteger b1 = new BigInteger("121212121212121212121212121212121212121");BigInteger b2 = new BigInteger("121212121212121212121212121212121212121");//BigInteger add(BigInteger val)  返回其值为 (this + val) 的 BigIntegerSystem.out.println(b1.add(b2));//BigInteger subtract(BigInteger val) 返回其值为 (this - val) 的 BigIntegerSystem.out.println(b1.subtract(b2));//BigInteger multiply(BigInteger val)  返回其值为 (this * val) 的 BigIntegerSystem.out.println(b1.multiply(b2));//BigInteger divide(BigInteger val)    返回其值为 (this / val) 的 BigIntegerSystem.out.println(b1.divide(b2));}
}

int intValue() 将BigInteger转成int

long longValue() 将BigInteger 转成 long

BigInteger上限:42亿的21亿次方,内存根本扛不住,所以我们可以认为BigInteger无上限

第三章.BigDecimal类

1.BigDecimal介绍

1.问题描述:我们知道直接用float或者double做运算会出现精度损失的问题,所以将来设计到钱,我们就不能用float或者double直接做运算2.作用:主要是解决float和double直接做运算出现的精度损失问题3.构造方法:BigDecimal(String val)  -> val必须要是数字形式4.常用方法:static BigDecimal valueOf(double val)  -> 此方法初始化小数时可以传入double型数据BigDecimal add(BigDecimal val)  返回其值为 (this + val) 的 BigDecimalBigDecimal subtract(BigDecimal val) 返回其值为 (this - val) 的 BigDecimalBigDecimal multiply(BigDecimal val)  返回其值为 (this * val) 的 BigDecimalBigDecimal divide(BigDecimal val)    返回其值为 (this / val) 的 BigDecimal BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)  divisor:除号后面的那个数scale:指定保留几位小数roundingMode:取舍方式static int ROUND_UP -> 向上加1static int ROUND_DOWN -> 直接舍去static int ROUND_HALF_UP -> 四舍五入5.注意:如果除不尽,会报错,出现运算异常

2.BigDecimal使用

public class Demo03BigDecimal {public static void main(String[] args) {//big01();//big02();big03();}private static void big03() {BigDecimal b1 = new BigDecimal("3.55");BigDecimal b2 = new BigDecimal("2.12");BigDecimal divide = b1.divide(b2, 2, BigDecimal.ROUND_UP);System.out.println("divide = " + divide);double v = divide.doubleValue();System.out.println("v = " + v);}private static void big02() {BigDecimal b1 = new BigDecimal("3.55");//BigDecimal b2 = new BigDecimal("2.12");BigDecimal b2 = BigDecimal.valueOf(2.12);//BigDecimal add(BigDecimal val)  返回其值为 (this + val) 的 BigDecimalBigDecimal add = b1.add(b2);System.out.println("add = " + add);//BigDecimal subtract(BigDecimal val) 返回其值为 (this - val) 的 BigDecimalBigDecimal subtract = b1.subtract(b2);System.out.println("subtract = " + subtract);//BigDecimal multiply(BigDecimal val)  返回其值为 (this * val) 的 BigDecimalBigDecimal multiply = b1.multiply(b2);System.out.println("multiply = " + multiply);//BigDecimal divide(BigDecimal val)    返回其值为 (this / val) 的 BigDecimalBigDecimal divide = b1.divide(b2);System.out.println("divide = " + divide);}private static void big01() {float a = 3.55F;float b = 2.12F;float result = a-b;System.out.println("result = " + result);//1.4300001}
}

double doubleValue() 将此BigDecimal转成double

3.BigDecimal除法过时方法解决

1.注意:如果调用的成员上面有一个横线,证明此成员过时了,底层会有一个注解@Deprecated修饰,但是过时的成员还能使用,只不过被新的成员代替了,不推荐使用了2.方法:divide(BigDecimal divisor, int scale, RoundingMode roundingMode) divisor:代表除号后面的数据scale:保留几位小数roundingMode:取舍方式-> RoundingMode是一个枚举,里面的成员可以类名直接调用UP:向上加1 DOWN:直接舍去 HALF_UP:四舍五入 

    private static void big04() {BigDecimal b1 = new BigDecimal("3.55");BigDecimal b2 = new BigDecimal("2.12");BigDecimal divide = b1.divide(b2, 2, RoundingMode.HALF_UP);System.out.println("divide = " + divide);}

第四章.Date日期类

1.Date类的介绍

 1.概述:表示特定的瞬间,精确到毫秒2.常识:a.1000毫秒 = 1秒b.时间原点:1970年1月1日 0时0分0秒(UNIX系统起始时间),叫做格林威治时间,在0时区上c.时区:北京位于东八区,一个时区经度差15度,时间相差一个小时,所以北京时间比时间原点所在时区时间差8个小时d.北京经纬度:东经116 北纬39.56 -> 温带大陆性季风气候e.赤道   本初子午线(0度经线)    

2.Date类的使用

1.构造:Date() -> 获取当前系统时间Date(long time) -> 获取指定时间,传递毫秒值 -> 从时间原点开始算   

    private static void date01() {//Date() -> 获取当前系统时间Date date1 = new Date();System.out.println("date1 = " + date1);//Date(long time) -> 获取指定时间,传递毫秒值 -> 从时间原点开始算Date date2 = new Date(1000L);System.out.println("date2 = " + date2);}

3.Date类的常用方法

1.void setTime(long time) -> 设置时间,传递毫秒值-> 从时间原点开始算
2.long getTime()->获取时间,返回毫秒值

        private static void date02() {Date date = new Date();//1.void setTime(long time) -> 设置时间,传递毫秒值-> 从时间原点开始算date.setTime(1000L);//2.long getTime()->获取时间,返回毫秒值System.out.println(date.getTime());}

第五章.Calendar日历类

1.Calendar介绍

1.概述:日历类,抽象类
2.获取:Calendar中的方法:static Calendar getInstance() 
3.月份对比:国外: 0 1 2 3 4 5 6 7 8 9  10 11国内: 1 2 3 4 5 6 7 8 9 10 11 12    

常用方法:int get(int field) ->返回给定日历字段的值void set(int field, int value)  :将给定的日历字段设置为指定的值void add(int field, int amount) :根据日历的规则,为给定的日历字段添加或者减去指定的时间量Date getTime():将Calendar转成Date对象field:代表的是日历字段-> 年 月 日 星期等,都是静态的    

    private static void calendar02() {Calendar calendar = Calendar.getInstance();//多态//int get(int field) ->返回给定日历字段的值int year = calendar.get(Calendar.YEAR);System.out.println("year = " + year);//void set(int field, int value)  :将给定的日历字段设置为指定的值//calendar.set(Calendar.YEAR,2028);//System.out.println(calendar.get(Calendar.YEAR));//void add(int field, int amount) :根据日历的规则,为给定的日历字段添加或者减去指定的时间量calendar.add(Calendar.YEAR,-1);System.out.println(calendar.get(Calendar.YEAR));//Date getTime():将Calendar转成Date对象Date date = calendar.getTime();System.out.println("date = " + date);}

扩展方法:

void set(int year, int month, int date) -> 直接设置年月日需求:键盘录入一个年份,判断这一年是闰年,还是平年
步骤:1.创建Calendar对象2.创建Scanner对象,键盘录入一个年份3.调用set方法,传递年,月,日set(年,2,1) -> 国外是0-11,所以设置成2月就是代表3月  4.将day减1天(3月1日减1天,就是2月最后一天,知道2月最后一天了,就知道是平年还是闰年了)5.获取day判断平年还是闰年,输出结果    

private static void calendar03() {//1.创建Calendar对象Calendar calendar = Calendar.getInstance();//2.创建Scanner对象,键盘录入一个年份Scanner sc = new Scanner(System.in);int year = sc.nextInt();//3.调用set方法,传递年,月,日//set(年,2,1) -> 国外是0-11,所以设置成2月就是代表3月calendar.set(year,2,1);//4.将day减1天(3月1日减1天,就是2月最后一天,知道2月最后一天了,就知道是平年还是闰年了)calendar.add(Calendar.DATE,-1);int day = calendar.get(Calendar.DATE);//5.获取day判断平年还是闰年,输出结果if (day==29){System.out.println("闰年");}else{System.out.println("平年");}}

第六章.SimpleDateFormat日期格式化类

1.SimpleDateFormat介绍

1.概述:日期格式化类
2.构造:SimpleDateFormat(String pattern)
3.pattern代表啥:代表的是我们自己指定的日期格式字母不能改变,但是中间的连接符我们可以改变 yyyy-MM-dd HH:mm:ss  

时间字母表示	说明
y	年
M	月
d	日
H	时
m	分
s	秒

2.SimpleDateFormat常用方法

1.String format(Date date) -> 将Date对象按照指定的格式转成String 
2.Date parse(String source)-> 将符合日期格式的字符串转成Date对象      

public class Demo03SimpleDateFormat {public static void main(String[] args) throws ParseException {SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//1.String format(Date date) -> 将Date对象按照指定的格式转成StringString time1 = sdf.format(new Date());System.out.println("time1 = " + time1);//2.Date parse(String source)-> 将符合日期格式的字符串转成Date对象String time2 = "2000-10-10 10:10:10";Date date = sdf.parse(time2);System.out.println("date = " + date);}
}

第七章.JDK8新日期类

1. LocalDate 本地日期

1.1.获取LocalDate对象

1.概述:LocalDate是一个不可变的日期时间对象，表示日期，通常被视为年月日
2.获取:static LocalDate now()  -> 创建LocalDate对象static LocalDate of(int year, int month, int dayOfMonth)  -> 创建LocalDate对象,设置年月日   

public class Demo04LocalDate {public static void main(String[] args) {//static LocalDate now()  -> 创建LocalDate对象LocalDate localDate = LocalDate.now();System.out.println("localDate = " + localDate);//static LocalDate of(int year, int month, int dayOfMonth)  -> 创建LocalDate对象,设置年月日LocalDate localDate1 = LocalDate.of(2000, 10, 10);System.out.println("localDate1 = " + localDate1);}
}

1.2.LocalDateTime对象

1.LocalDateTime概述:LocalDateTime是一个不可变的日期时间对象，代表日期时间，通常被视为年 - 月 - 日 - 时 - 分 - 秒。2.获取:
static LocalDateTime now()  创建LocalDateTime对象
static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute, int second) 创建LocalDateTime对象,设置年月日时分秒

public class Demo05LocalDateTime {public static void main(String[] args) {//static LocalDateTime now()  创建LocalDateTime对象LocalDateTime localDateTime = LocalDateTime.now();System.out.println("localDateTime = " + localDateTime);//static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute, int second) 创建LocalDateTime对象,设置年月日时分秒LocalDateTime localDateTime1 = LocalDateTime.of(2000, 10, 10, 10, 10, 10);System.out.println("localDateTime1 = " + localDateTime1);}
}

1.3.获取日期字段的方法 : 名字是get开头

int getYear()->获取年份
int getMonthValue()->获取月份
int getDayOfMonth()->获取月中的第几天

private static void get() {LocalDate localDate = LocalDate.now();//int getYear()->获取年份System.out.println(localDate.getYear());//int getMonthValue()->获取月份System.out.println(localDate.getMonthValue());//int getDayOfMonth()->获取月中的第几天System.out.println(localDate.getDayOfMonth());}

1.4.设置日期字段的方法 : 名字是with开头

LocalDate withYear(int year):设置年份
LocalDate withMonth(int month):设置月份
LocalDate withDayOfMonth(int day):设置月中的天数

    private static void with() {LocalDate localDate = LocalDate.now();//LocalDate withYear(int year):设置年份//LocalDate localDate1 = localDate.withYear(2000);//System.out.println(localDate1);//LocalDate withMonth(int month):设置月份//LocalDate localDate2 = localDate1.withMonth(10);//System.out.println("localDate2 = " + localDate2);//LocalDate withDayOfMonth(int day):设置月中的天数//LocalDate localDate3 = localDate2.withDayOfMonth(10);//System.out.println("localDate3 = " + localDate3);LocalDate localDate1 = localDate.withYear(2000).withMonth(10).withDayOfMonth(10);System.out.println("localDate1 = " + localDate1);}

1.5.日期字段偏移

设置日期字段的偏移量,方法名plus开头,向后偏移
设置日期字段的偏移量,方法名minus开头,向前偏移

    /*向后偏移 -> plus开头方法向前偏移 -> minus开头方法*/private static void plusAndMinus() {LocalDate localDate = LocalDate.now();// LocalDate localDate1 = localDate.plusYears(1L);// System.out.println("localDate1 = " + localDate1);LocalDate localDate1 = localDate.minusYears(1L);System.out.println("localDate1 = " + localDate1);}

2.Period和Duration类

2.1 Period 计算日期之间的偏差

方法:static Period between(LocalDate d1,LocalDate d2):计算两个日期之间的差值getYears()->获取相差的年getMonths()->获取相差的月getDays()->获取相差的天

    private static void period() {LocalDate local1 = LocalDate.of(2022, 12, 12);LocalDate local2 = LocalDate.of(2021, 11, 11);Period period = Period.between(local2, local1);System.out.println(period.getYears());System.out.println(period.getMonths());System.out.println(period.getDays());}

2.2 Duration计算时间之间的偏差

1.static Duration between(Temporal startInclusive, Temporal endExclusive)  -> 计算时间差
2.Temporal : 是一个接口实现类:LocalDate LocalDateTime3.参数需要传递 Temporal 的实现类对象, 注意要传递LocalDateTime因为Duration计算精确时间偏差,所以需要传递能操作精确时间的 LocalDateTime4.利用Dutation获取相差的时分秒 -> to开头toDays() :获取相差天数toHours(): 获取相差小时toMinutes():获取相差分钟toMillis():获取相差秒(毫秒)

    private static void duration() {LocalDateTime local1 = LocalDateTime.of(2022, 12, 12,12,12,12);LocalDateTime local2 = LocalDateTime.of(2021, 11, 11,11,11,11);Duration duration = Duration.between(local2, local1);System.out.println(duration.toDays());System.out.println(duration.toHours());System.out.println(duration.toMinutes());System.out.println(duration.toMillis());}

如果计算年月日 ,就用Period

如果计算时分秒,就用Duration

3.DateTimeFormatter日期格式化类

1.获取:static DateTimeFormatter ofPattern(String pattern)   -> 获取对象,指定格式
2.方法:String format(TemporalAccessor temporal)-> 将日期对象按照指定的规则转成String TemporalAccessor:接口,子接口有TemporalTemporal的实现类:LocalDate LocalDateTime    TemporalAccessor parse(CharSequence text)-> 将符合规则的字符串转成日期对象 如果想将TemporalAccessor转成我们常见的LocalDateTime日期对象,就需要用到LocalDateTime中的静态方法:static LocalDateTime from(TemporalAccessor temporal)  

    private static void parse() {DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");String time = "2000-10-10 10:10:10";TemporalAccessor temporalAccessor = dtf.parse(time);//System.out.println(temporalAccessor);LocalDateTime localDateTime = LocalDateTime.from(temporalAccessor);System.out.println("localDateTime = " + localDateTime);}

第八章.System类

currentTimeMillis() 、exit、 arraycopy

1.概述:系统相关类,是一个工具类
2.特点:a.构造私有,不能利用构造方法new对象b.方法都是静态的
3.使用:类名直接调用

方法	说明
static long currentTimeMillis()	返回以毫秒为单位的当前时间,可以测效率
static void exit(int status)	终止当前正在运行的 Java 虚拟机
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length	数组复制 src:源数组 srcPos:从源数组的哪个索引开始复制 dest:目标数组 ldestPos:从目标数组哪个索引开始粘贴 length:复制多少个元素

public class Demo01System {public static void main(String[] args) {//currentTimeMillis();//exit();arraycopy();}/*static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)src:源数组srcPos:从源数组的哪个索引开始复制dest:目标数组destPos:从目标数组的哪个索引开始粘贴length:复制多少个元素*/private static void arraycopy() {int[] arr1 = {1,2,3,4,5};int[] arr2 = new int[10];System.arraycopy(arr1,0,arr2,0,5);for (int i = 0; i < arr2.length; i++) {System.out.print(arr2[i]+" ");}}private static void exit() {for (int i = 0; i < 100; i++) {if (i==5){System.exit(0);}System.out.println("helloworld"+i);}}private static void currentTimeMillis() {long time = System.currentTimeMillis();System.out.println("time = " + time);}
}

第九章.Arrays数组工具类

toString、sort、binarySearch、copyOf

1.概述:数组工具类
2.特点:a.构造私有b.方法静态
3.使用:类名直接调用

方法	说明
static String toString(int[] a)	按照格式打印数组元素 [元素1, 元素2, …]
static void sort(int[] a)	升序排序
static int binarySearch(int[] a, int key)	二分查找(前提是升序)
static int[] copyOf(int[] original, int newLength)	数组扩容

public class Demo02Arrays {public static void main(String[] args) {int[] arr = {5,3,4,6,5,4,7};System.out.println(Arrays.toString(arr));System.out.println("==============");Arrays.sort(arr);System.out.println(Arrays.toString(arr));System.out.println("==============");int[] arr1 = {1,2,3,4,5,6,7};int index = Arrays.binarySearch(arr1, 3);System.out.println("index = " + index);System.out.println("==============");int[] arr2 = {1,2,3,4,5};int[] newArr = Arrays.copyOf(arr2, 10);System.out.println(Arrays.toString(newArr));arr2 = newArr;System.out.println(Arrays.toString(arr2));}
}

第十章.包装类

1.基本数据类型对应的引用数据类型(包装类)

1.概述:就是基本类型对应的类(包装类),我们需要将基本类型转成包装类,从而让基本类型拥有类的特性(说白了,将基本类型转成包装类之后,就可以使用包装类中的方法操作数据)2.为啥要学包装类:a.将来有一些特定场景,特定操作,比如调用方法传递包装类比如:ArrayList集合,里面有一个方法add(Integer i),此时我们不能调用add方法之后直接传递基本类型,因为引用类型不能直接接收基本类型的值,就需要先将基本类型转成包装类,传递到add方法中b.将来我们还可以将包装类转成基本类型:包装类不能直接使用+ - * /,所以需要将包装类转成基本类型,才能使用+ - * /

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Charactor
boolean	Boolean

2.Integer的介绍以及使用

2.1.Integer基本使用

1.概述:Integer是int的包装类
2.构造:  不推荐使用了,但是还能用Integer(int value)Integer(String s) s必须是数字形式

public class Demo01Integer {public static void main(String[] args) {Integer i1 = new Integer(10);System.out.println("i1 = " + i1);Integer i2 = new Integer("10");System.out.println("i2 = " + i2);System.out.println("================");Boolean b1 = new Boolean("true");System.out.println("b1 = " + b1);Boolean b2 = new Boolean("false");System.out.println("b2 = " + b2);Boolean b3 = new Boolean("True");System.out.println("b3 = " + b3);}
}

1.装箱:将基本类型转成对应的包装类
2.方法:static Integer valueOf(int i)  static Integer valueOf(String s)  

public class Demo02Integer {public static void main(String[] args) {Integer i1 = Integer.valueOf(10);System.out.println("i1 = " + i1);Integer i2 = Integer.valueOf("100");System.out.println("i2 = " + i2);}
}

1.拆箱:将包装类转成基本类型
2.方法:int intValue();

public class Demo03Integer {public static void main(String[] args) {Integer i1 = Integer.valueOf(10);System.out.println("i1 = " + i1);int i = i1.intValue();System.out.println("(i+10) = " + (i + 10));}
}

2.2.自动拆箱装箱

1.拆箱和装箱很多时候都是自动完成的

public class Demo04Integer {public static void main(String[] args) {Integer i = 10;//发生了自动装箱了Integer sum = i+10;//发生了自动拆箱装箱System.out.println("sum = " + sum);}
}

public class Demo05Integer {
public static void main(String[] args) {Integer i1 = 100;Integer i2 = 100;System.out.println(i1==i2);Integer i3 = 128;Integer i4 = 128;System.out.println(i3==i4);
}
}

3.基本类型和String之间的转换

3.1 基本类型往String转

1.方式1:+ 拼接
2.方式2:String中的静态方法static String valueOf(int i) 

  private static void method01() {int i = 10;String s1 = i+"";System.out.println(s1+1);System.out.println("============");String s = String.valueOf(10);System.out.println(s+1);}

3.2 String转成基本数据类型

每个包装类中都有一个类似的方法:  parseXXX

位置	方法	说明
Byte	static byte parseByte(String s)	将String转byte类型
Short	static short parseShort(String s)	将String转成short类型
Integer	static int parseInt(String s)	将String转成int类型
Long	static long parseLong(String s)	将String转成long类型
Float	static float parseFloat(String s)	将String转成float类型
Double	static double parseDouble(String s)	将String转成double类型
Boolean	static boolean parseBoolean(String s)	将String转成boolean类型

    private static void method02() {int number = Integer.parseInt("1111");System.out.println(number+1);}

1.在实际开发过程中如何定义一个标准javabean定义javabean的时候一般会将基本类型的属性定义成包装类型的属性  

public class User {//private int uid;//用户idprivate Integer uid;//用户idprivate String username;//用户名private String password;//密码public User() {}public User(Integer uid, String username, String password) {this.uid = uid;this.username = username;this.password = password;}public Integer getUid() {return uid;}public void setUid(Integer uid) {this.uid = uid;}public String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}
}

1.举例:如果uid为Integer型,默认值是null
2.将来javabean中的数据都是和数据库表联系起来的,我们可以将javabean中的数据添加到表中如果表中的uid为主键自增的,此时添加语句时uid中的数据不用我们单独维护赋值了,添加语句的sql语句就可以这样写:insert into user(uid,username,password) values (NULL,'金莲','36666');3.到时候,我们需要将javabean中封装的数据获取出来放到sql语句中,如果uid为主键自增,而且javabean中的uid为包装类型,默认值为NULL,这样就不用单独维护uid的值了,也不用先给javabean中的uid赋值,然后在保存到数据库中了,咱们就可以直接使用uid的默认值,将默认值放到sql语句的uid列中4.而且将javabean中的属性变成包装类,还可以使用包装类中的方法去操作此属性值    

常用API(1)

今日目标：

• 能够知道什么是API
• 能够使用帮助文档学习API
• 能够理解包和导包
• 能够知道Scanner的作用和基本使用
• 能够知道Random的作用和基本使用
• 能够知道GUI的作用和基本使用
• 能够完成GUI相关的授课案例
• 能够理解事件监听机制
• 能够对按钮添加事件

1：API 概述

1.1 API概述和课程安排

来，继续啊，我们在讲解面向对象的时候，提到了学习面向对象重点就是学习两块内容：

第一块：学习如何自己设计对象并使用

第二块：学习获取已有对象并使用

而关于第一块知识：学习如何自己设计对象并使用，我们现在已经有一些基础了。

通过前面的学习呢，我们知道了如何定义类，并通过构造方法创建对象，然后通过对象使用成员变量和成员方法。

接下来，我们要学习的是第二块知识：获取已有对象并使用。而获取已有对象并使用呢，在Java中我们习惯称之为常用API的学习。

所以下面我们来学习常用API。首先，我们来说一下什么是API：

• API(Application Programming Interface) ：应用程序编程接口

那如何理解应用程序编程接口呢？这里我们通过下面的场景给大家解释一下。

看这里，我想编写一个机器人踢足球的程序，那么程序就要向机器人发出向前跑、向后跑、射门、抢球等各种命令。

如果我自己来编写呢，就会比较麻烦，因为机器人不是我设计的。所以，为了方便其他的开发者使用机器人，

机器人厂商呢就会提供一些用于控制机器人的类，这些类中会定义好操作机器人各种动作的方法。

有了这些类之后，开发一个机器人踢足球的程序就会非常的方便了。

其实，这些类就是机器人厂商提供给开发者的应用程序编程接口，而这些类我们称之为：API

知道了什么是API之后呢，我们来说一下，Java的API。

• Java API ：指的就是 JDK 中提供的各种功能的 Java类。

这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，

为了帮助我们使用这些类，Java还提供了对应的帮助文档。我们可以通过帮助文档来学习这些API如何使用

下面呢，我们一起来学习一下帮助文档的使用：

要想使用帮助文档，首先我们得有一个帮助文档：来，打开课程资料下面，我们这里有一个帮助文档。

这个文档对应的是JDK11版本的，是目前比较新的中文版的帮助文档。

有了文档之后呢，我们来打开帮助文档。

文档打开后，找到索引这里，下面有一个输入框，在这个框框里输入我们要学习的API。

这里，我们拿字符串类做一个说明：在这个框框里面我们输入：String，然后一回车，看到一个新的界面

这个界面中，就是关于String相关的知识了。

接着，我们来说一下，在学习一个API的时候，我们重点要看四个地方：

第一个地方：看类所在的包

为什么要看这里呢，因为java.lang包下的类，我们是可以直接使用的，不需要导包。

其他包下的类，我们都是要导包后才能使用的，至于如何导包，下个知识我们会讲解。

很明显，String类在使用的时候，我们是不需要导包的。

第二个地方：看类的描述

也就是看这里，这里一般描述了类是干什么的。

比如说：String类表示字符串。 Java程序中的所有字符串文字（例如"abc" ）都实现为此类的实例。

告诉了我们String就是用来表示字符串的类，直接写一个字符串数据：abc就是String类的一个对象。

第三个地方：看类的构造方法

往下滑，这就是String类的构造方法，为什么要看构造方法呢？因为我们在使用一个类的时候，其实使用的是该类的对象，

而创建对象，我们是需要通过构造方法实现的，所以，我们得看看它提供了哪些构造方法。

这里的构造方法提供的比较多，至于用哪个，后面我们用到的时候再讲解，目前知道看哪里就行了

第四个地方：看类的成员方法

这是我们学习一个API的重点，我们之所以学习一个API，重点就是为了使用该API来完成某些功能。

而API的功能，都是通过一个个方法实现的，所以我们重点得看看类的成员方法。往下滑，这就是String提供的成员方法，有很多。

而一个方法，我们重点又看什么呢？回到第一个方法，我们说一下：

先看描述，通过描述，我们就知道了方法是干什么的。

再看方法名和参数，这样我们就知道调用哪个方法，以及参数的类型和个数。

最后，我们看返回值类型，这样我们就知道调用该方法后，最终给我们返回了一个什么类型结果

通过这些步骤，我们就知道了所学习的API该如何使用了，然后就可以到IDEA中去使用API了。

知道了帮助文档的使用步骤后，回到资料我们总结一下帮助文档的使用流程：

① 打开帮助文档

② 找到索引选项，输入要学习的API，然后回车

③ 看类所在包：因为java.lang包下的类在使用的时候不需要导包

④ 看类的描述：这样我们就知道了类是干什么的

⑤ 看类的构造方法：这样我们就可以创建对象了

⑥ 看类的成员方法：这样我们就可以通过这些方法完成某些功能了

知道了什么是API，以及通过帮助文档如何学习API后，我们来说一下常用API这部分内容的课程安排：

首先，我们学习一下包和导包的基本概念和操作，为API的使用做一个基础铺垫

接着我们来学习两个API：Scanner和Random

Scanner：是用来实现键盘录入数据的

Random：是用来产生随机数的

通过这两个API的学习，可以让我们熟悉帮助文档的使用

再接着我们来学习GUI相关的API，这里不是一个API的学习，而是多个API的学习，通过这部分内容的学习，可以让我们的操作可视化，也就是有界面了，不在仅仅是在控制台输出数据了。

最后，我们学习这几个API，学习这几个API的目的，是为了完成我们在GUI部分未完成的案例。

好了，到此关于API概述和常用API的课程安排我们就先讲到这里

1.2 包和导包

来，继续啊，下面我们来学习一下，包和导包。

那什么是包呢？

• 包其实就是文件夹
• 作用：对类进行分类管理

包的定义格式：

• 格式：package 包名;
• 注意：包名一般是公司域名反写，并且多级包用.分开
• 举例：www.itheima.com
• 范例：package com.itheima;

知道了如何定义包之后，下面我们来定义两个包，并且在不同包下定义同名的类。

package com.itheima_01;public class Student {public void study() {System.out.println("好好学习天天向上");}
}

package com.itheima_01;public class StudentTest {public static void main(String[] args) {Student s = new Student();s.study();}
}

package com.itheima_02;public class StudentTest {public static void main(String[] args) {com.itheima_01.Student s = new com.itheima_01.Student();s.study();com.itheima_01.Student s2 = new com.itheima_01.Student();s2.study();}
}

在这里我们讲解了同一个包下类的使用，以及不同包下类的使用。发现不同包下类的使用太麻烦了，所以，这个时候，我们就要学习一下导包了。

使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了。

为了简化带包的操作，Java就提供了导包的功能。

导包的格式：

• 格式：import 包名;
• 范例：import com.itheima.Student;

知道了如何导包后，我们再来修改一下不同包下类的使用代码：

package com.itheima_02;import com.itheima_01.Student;
//Alt+Enter 快捷键导包public class StudentTest {public static void main(String[] args) {Student s = new Student();s.study();Student s2 = new Student();s2.study();//        com.itheima_01.Student s = new com.itheima_01.Student();
//        s.study();
//
//        com.itheima_01.Student s2 = new com.itheima_01.Student();
//        s2.study();}
}

在这里我们讲解了导包的三种方式：

1. 手动导包
2. 快捷键导包
3. 写一个类，写一部分的时候，如果给出了对应的提示，回车后会自动导包

讲解完毕后，大家赶快动手练习一下吧。

2：Scanner

2.1 Scanner基本使用

了解了API相关的知识后，下面我们来学习一下Scanner的使用。

通过查看帮助文档，我们知道了如下的信息：

Scanner：

• 一个简单的文本扫描程序，可以获取基本类型数据和字符串数据

构造方法：

• Scanner(InputStream source)：创建 Scanner 对象
• System.in：对应的是InputStream类型，可以表示键盘输入
• Scanner sc = new Scanner(System.in);

成员方法：

• int nextInt()：获取一个int类型的数据
• int i = sc.nextInt();

知道了Scanner的构造方法和成员方法后，我们到IDEA中去使用一下：

import java.util.Scanner;/*Scanner的基本使用*/
public class ScannerDemo {public static void main(String[] args) {//Scanner(InputStream source)：创建 Scanner 对象Scanner sc = new Scanner(System.in);//int nextInt()：获取一个int类型的数据System.out.println("请输入一个整数：");int i = sc.nextInt();//输出获取到的数据System.out.println("你输入的数据是：" + i);}
}

讲解完毕后，大家赶快动手练习一下吧。

2.2 练习(数据求和)

需求：键盘录入两个整数，求两个数据和，并在控制台输出求和结果

首先，我们来简单的分析一下：

分析：

① 创建键盘录入数据对象

② 通过键盘录入数据对象调用nextInt()方法获取数据

③ 对获取的两个整数求和

④ 在控制台输出求和结果

分析完毕后，我们到IDEA中去实现一下：

/*需求：键盘录入两个整数，求两个数据和，并在控制台输出求和结果分析：1:创建键盘录入数据对象2:通过键盘录入数据对象调用nextInt()方法获取数据3:对获取的两个整数求和4:在控制台输出求和结果*/
public class ScannerTest {public static void main(String[] args) {//创建键盘录入数据对象Scanner sc = new Scanner(System.in);//通过键盘录入数据对象调用nextInt()方法获取数据System.out.println("请输入第一个整数：");int firstNumber = sc.nextInt();System.out.println("请输入第二个整数：");int secondNumber = sc.nextInt();//对获取的两个整数求和int sum = firstNumber + secondNumber;//在控制台输出求和结果System.out.println("求和结果是：" + sum);}
}

讲解完毕后，大家赶快动手练习一下吧。

3：Random

3.1 Random基本使用

来，继续啊，下面我们来学习一下Random的使用。

通过查看帮助文档，我们知道了如下的信息：

Random：

• 该类的实例用于生成随机数

构造方法：

• Random()：创建一个新的随机数生成器

成员方法：

• int nextInt(int bound)：获取一个int类型的随机数，参数bound表示获取到的随机数在[0,bound)之间

知道了Random的构造方法和成员方法后，我们到IDEA中去使用一下：

import java.util.Random;/*Random的基本使用*/
public class RandomDemo {public static void main(String[] args) {//Random()：创建一个新的随机数生成器Random r = new Random();//int nextInt(int bound)：获取一个int类型的随机数，参数bound表示获取到的随机数在[0,bound)之间
//        int i = r.nextInt(10);
//        System.out.println(i);//        for (int i=1; i<=10; i++) {
//            int j = r.nextInt(10);
//            System.out.println(j);
//        }//需求：如何获取1-100之间的随机数呢？
//        int number = r.nextInt(100);//0-99
//        int number = r.nextInt(101);//0-100int number = r.nextInt(100) + 1;System.out.println(number);}
}

讲解完毕后，大家赶快动手练习一下吧。

3.2 练习(猜数字游戏)

需求：系统自动产生一个1-100之间的整数，使用程序实现猜这个数字是多少？

猜的时候根据不同情况给出相应的提示如果猜的数字比真实数字大，提示你猜的数据大了如果猜的数字比真实数字小，提示你猜的数据小了如果猜的数字与真实数字相等，提示恭喜你猜中了

首先，我们来简单的分析一下：

分析：

① 使用Random获取一个1-100之间的整数

② 使用Scanner实现键盘录入猜的数据值

③ 使用if…else if…else 的格式实现猜数字，并给出对应的提示

分析完毕后，我们到IDEA中去实现一下：

import java.util.Random;
import java.util.Scanner;/*需求：系统自动产生一个1-100之间的整数，使用程序实现猜这个数字是多少？猜的时候根据不同情况给出相应的提示如果猜的数字比真实数字大，提示你猜的数据大了如果猜的数字比真实数字小，提示你猜的数据小了如果猜的数字与真实数字相等，提示恭喜你猜中了分析：1:使用Random获取一个1-100之间的整数2:使用Scanner实现键盘录入猜的数据值3:使用if…else if…else 的格式实现猜数字，并给出对应的提示*/
public class RandomTest {public static void main(String[] args) {//使用Random获取一个1-100之间的整数Random r = new Random();int number = r.nextInt(100) + 1;System.out.println("系统已经产生了一个1-100之间的整数");while (true) {//使用Scanner实现键盘录入猜的数据值Scanner sc = new Scanner(System.in);System.out.println("请输入你要猜的数字：");int guessNumber = sc.nextInt();//使用if…else if…else 的格式实现猜数字，并给出对应的提示if (guessNumber > number) {System.out.println("你猜的数据" + guessNumber + "大了");} else if (guessNumber < number) {System.out.println("你猜的数据" + guessNumber + "小了");} else {System.out.println("恭喜你猜中了");break;}}}
}

讲解完毕后，大家赶快动手练习一下吧。

4：GUI

4.1 GUI概述

来，继续啊，下面呢我们来学习GUI相关的API。

首先呢，我们来说一下，什么是GUI：

• GUI Graphical User Interface(图形用户接口)
• 用图形的方式，来显示计算机操作的界面

怎么理解呢？我们把后面要做的案例拿来举例说明一下：

看这里：

这是用户登录的案例，在这个界面上，有显示文本的标签，显示输入内容的文本框以及按钮。

再来看一个：

聊天室的案例，在这个界面上，有显示聊天内容的文本域，显示输入内容的文本框以及操作的按钮。

给出这样的界面，我们自己就能够看明白，非常的方便直观，这就是使用GUI相关的API来实现的。

而Java为GUI提供的API都存在java.awt和javax.Swing两个包中，我们分别来看一下这两个包：

• java.awt 包：
  • awt是这三个单词首字母的缩写，翻译过来是抽象窗口工具包，只不过这个包的API，需要调用本地系统方法实现功能，和本地系统有关联，不利于代码移植，属重量级控件
• javax.swing 包：
  • 它是在awt的基础上，建立的一套图形界面系统，提供了更多的组件，而且完全由Java实现。增强了移植性，属轻量级控件

所以，我们做图形界面开发使用的是swing包下的类。

这里出现了一个名词：组件。那什么是组件呢？

• 组件是具有图形表示的对象，该图形表示可以显示在屏幕上并且可以与用户交互

比如说，在用户登录中，文本框和按钮等，都是能够表示图形的对象，所以它们都称为组件。

最后，我们来说一下，我们会用到的常用组件，

看这里：

组件：

• **基本组件：**具有图形表示的对象
• **容器组件：**是可以添加组件的组件。也就是在容器中可以通过add方法添加组件，既可以添加基本组件，也可以添加容器组件。

我们先来看常用的基本组件：

• JButton，这是按钮

• JLabel，这是用来显示文本内容的，或者展示图片使用

• JTextFile，这是文本框，用来输入内容的

• JTextArea，这是文本域，用来输入多行多列的数据的

接着，我们再来看容器组件：

• 面板也是一个容器，我们常用JPanel，后面用到在具体讲解
• 窗体，下面是Frame，这是awt包下，而我们使用的是JFrame，这是swing包下。

看到这里，我要说一下，由于我们使用的都是swing包下的，所以将来使用的组件，都是以J开头的。

好了，GUI相关的基础知识我们就先讲到这里

4.2 常用组件

4.2.1 JFrame(初识窗体)

来，继续啊，下面我们来学习JFrame窗体类。

在学习JFrame之前，先说一下，在学习GUI相关的API的时候，我就不带着大家到帮助文档中查看了。

在资料中，我们会把要讲解的类的作用，构造方法，和成员方法给大家展示出来，简单的分析后，到IDEA中去实现。

首先，我们来看一下JFrame：

JFrame：

• 是一个顶层窗口

构造方法：

• JFrame()：构造一个最初不可见的新窗体

成员方法：

• void setVisible(boolean b)：显示或隐藏此窗体具体取决于参数b的值
• void setSize(int width, int height)：调整此组件的大小，使其宽度为width，高度为height，单位是像素

知道了JFrame的构造方法和成员方法后，我们到IDEA中去使用一下：

import javax.swing.*;/*构造方法JFrame()：构造一个最初不可见的新窗体成员方法void setVisible(boolean b)：显示或隐藏此窗体具体取决于参数b的值void setSize(int width, int height)：调整此组件的大小，使其宽度为width，高度为height，单位是像素*/
public class JFrameDemo01 {public static void main(String[] args) {//JFrame()：构造一个最初不可见的新窗体JFrame jf = new JFrame();//void setSize(int width, int height)：调整此组件的大小，使其宽度为width，高度为height，单位是像素jf.setSize(400,300);//void setVisible(boolean b)：显示或隐藏此窗体具体取决于参数b的值jf.setVisible(true);}
}

讲解完毕后，大家赶快动手练习一下吧。

4.2.2 JFrame(常用设置)

来，继续啊，下面呢，我们再来学习几个JFrame窗体的常用方法：

• void setTitle(String title)：设置窗体标题
• void setLocationRelativeTo(Component c)：设置位置，值为null，则窗体位于屏幕中央
• void setDefaultCloseOperation(int operation)：设置窗体关闭时默认操作
  • 整数3表示：窗口关闭时退出应用程序
• void setAlwaysOnTop(boolean alwaysOnTop)：设置此窗口是否应始终位于其他窗口之上

了解了这几个方法后，我们到IDEA中去使用一下：

import javax.swing.*;/*void setTitle(String title)：设置窗体标题void setLocationRelativeTo(Component c)：设置位置，值为null，则窗体位于屏幕中央void setDefaultCloseOperation(int operation)：设置窗体关闭时默认操作(整数3表示：窗口关闭时退出应用程序)void setAlwaysOnTop(boolean alwaysOnTop)：设置此窗口是否应始终位于其他窗口之上*/
public class JFrameDemo02 {public static void main(String[] args) {//创建窗体对象JFrame jf = new JFrame();//void setTitle(String title)：设置窗体标题jf.setTitle("百度一下，你就知道");//设置窗体大小jf.setSize(400, 300);//void setDefaultCloseOperation(int operation)：设置窗体关闭时默认操作(整数3表示：窗口关闭时退出应用程序)jf.setDefaultCloseOperation(3);//void setLocationRelativeTo(Component c)：设置位置，值为null，则窗体位于屏幕中央jf.setLocationRelativeTo(null);//void setAlwaysOnTop(boolean alwaysOnTop)：设置此窗口是否应始终位于其他窗口之上jf.setAlwaysOnTop(true);//设置窗体可见jf.setVisible(true);}
}

讲解完毕后，大家赶快动手练习一下吧。

4.2.3 JButton(窗口中添加按钮)

来，继续啊，下面我们来学习JButton，它是按钮的实现。

JButton：

• 按钮的实现

构造方法：

• JButton(String text)：创建一个带文本的按钮

成员方法：

• void setSize(int width, int height)：设置大小
• void setLocation(int x, int y)：设置位置(x坐标，y坐标)

知道了JButton的构造方法和成员方法后，我们到IDEA中去使用一下：

import javax.swing.*;/*构造方法JButton(String text)：创建一个带文本的按钮成员方法void setSize(int width, int height)：设置大小void setLocation(int x, int y)：设置位置(x坐标，y坐标)*/
public class JButtonDemo {public static void main(String[] args) {//创建窗体对象JFrame jf = new JFrame();jf.setTitle("窗口中添加按钮");jf.setSize(400, 300);jf.setDefaultCloseOperation(3);jf.setLocationRelativeTo(null);jf.setAlwaysOnTop(true);jf.setLayout(null); //取消窗体的默认布局//JButton(String text)：创建一个带文本的按钮JButton btn = new JButton("我是按钮");
//        //void setSize(int width, int height)：设置大小
//        btn.setSize(100,20);
//        //void setLocation(int x, int y)：设置位置(x坐标，y坐标)
        btn.setLocation(0,0);
//        btn.setLocation(100,100);btn.setBounds(100,100,100,20);JButton btn2 = new JButton("我是按钮2");btn2.setBounds(100,120,100,20);jf.add(btn);jf.add(btn2);//设置窗体可见jf.setVisible(true);}
}

演示完毕之后，回到资料再总结一下：

JButton：

• 按钮的实现

构造方法：

• JButton(String text)：创建一个带文本的按钮

成员方法：

• void setSize(int width, int height)：设置大小

• void setLocation(int x, int y)：设置位置(x坐标，y坐标)

• void setBounds(int x, int y, int width, int height)：设置位置和大小

和窗体相关操作：

• 取消窗体默认布局：窗体对象.setLayout(null);
• 把按钮添加到窗体：窗体对象.add(按钮对象);

讲解完毕后，大家赶快动手练习一下吧。

4.2.4 JLabel(显示文本和图像)

来，继续啊，下面呢，我们来学习JLable，它是用来做短文本字符串或图像的显示的。

JLable：

• 短文本字符串或图像的显示区域

构造方法：

• JLabel(String text)：使用指定的文本创建 JLabel实例
• JLabel(Icon image)：使用指定的图像创建 JLabel实例
  • ImageIcon(String filename)：从指定的文件创建ImageIcon
  • 文件路径：绝对路径和相对路径
  • 绝对路径：完整的路径名，不需要任何其他信息就可以定位它所表示的文件
    • 例如：D:\IdeaProjects\javase_code\itheima-api-gui\images\mn.png
  • 相对路径：必须使用取自其他路径名的信息进行解释
    • 例如：itheima-api-gui\images\mn.png

成员方法：

• void setBounds(int x, int y, int width, int height)：设置位置和大小

知道了JLabel的构造方法和成员方法后，我们到IDEA中去使用一下：

import javax.swing.*;/*构造方法JLabel(String text)：使用指定的文本创建 JLabel实例JLabel(Icon image)：使用指定的图像创建 JLabel实例ImageIcon(String filename)：从指定的文件创建ImageIcon成员方法void setBounds(int x, int y, int width, int height)：设置位置和大小*/
public class JLabelDemo {public static void main(String[] args) {//创建窗体对象JFrame jf = new JFrame();jf.setTitle("显示文本和图像");jf.setSize(400, 300);jf.setDefaultCloseOperation(3);jf.setLocationRelativeTo(null);jf.setAlwaysOnTop(true);jf.setLayout(null);//JLabel(String text)：使用指定的文本创建 JLabel实例JLabel jLabel = new JLabel("好好学习");jLabel.setBounds(0,0,100,20);//JLabel(Icon image)：使用指定的图像创建 JLabel实例//ImageIcon(String filename)：从指定的文件创建ImageIcon//D:\IdeaProjects\javase_code\itheima-api-gui\images\mn.png
//        ImageIcon imageIcon = new ImageIcon("D:\\IdeaProjects\\javase_code\\itheima-api-gui\\images\\mn.png");
//        JLabel jLabel2 = new JLabel(imageIcon);
//        JLabel jLabel2 = new JLabel(new ImageIcon("D:\\IdeaProjects\\javase_code\\itheima-api-gui\\images\\mn.png"));JLabel jLabel2 = new JLabel(new ImageIcon("itheima-api-gui\\images\\mn.png"));jLabel2.setBounds(50,50,100,143);jf.add(jLabel);jf.add(jLabel2);//设置窗体可见jf.setVisible(true);}
}

讲解完毕后，大家赶快动手练习一下吧。

注意：在实际开发中，大家不用担心每个组件的位置和大小。因为这些都是前端人员设计好的。

4.3 案例

来，继续啊，下面呢，我们通过几个案例，来使用一下GUI中的常用组件。目前呢，我们仅仅是把界面做出来，下一次课呢，我们就要把最终的功能给实现了。首先，我们来看第一个案例。

4.3.1 案例1(用户登录)

需求：如图所示，做出界面

提示：给出的数据就是按照组件位置和大小给出的

首先，我们来简单的分析一下：

分析：

① 2个JLabel

② 2个JTextField

③ 1个JButton

分析完毕后，我们到IDEA中去实现一下：

import javax.swing.*;/*用户登录*/
public class UserLogin {public static void main(String[] args) {//创建窗体对象JFrame jf = new JFrame();jf.setTitle("用户登录");jf.setSize(400, 300);jf.setDefaultCloseOperation(3);jf.setLocationRelativeTo(null);jf.setAlwaysOnTop(true);jf.setLayout(null);//显示用户名文本JLabel usernameLable = new JLabel("用户名");usernameLable.setBounds(50,50,50,20);jf.add(usernameLable);//用户名输入框JTextField usernameField = new JTextField();usernameField.setBounds(150,50,180,20);jf.add(usernameField);//显示密码文本JLabel passwordLable = new JLabel("密码");passwordLable.setBounds(50,100,50,20);jf.add(passwordLable);//密码输入框
//        JTextField passwordField = new JTextField();
//        passwordField.setBounds(150,100,180,20);
//        jf.add(passwordField);JPasswordField passwordField = new JPasswordField();passwordField.setBounds(150,100,180,20);jf.add(passwordField);//登录按钮JButton loginButton = new JButton("登录");loginButton.setBounds(50,200,280,20);jf.add(loginButton);jf.setVisible(true);}
}

在讲解的过程中，引入了一个新的组件JPasswordField，用来表示密码框。

讲解完毕后，大家赶快动手练习一下吧。

4.3.2 案例2(聊天室)

需求：如图所示，做出界面

提示：给出的数据就是按照组件位置和大小给出的

首先，我们来简单的分析一下：

分析：

① 1个JTextArea

② 1个JTextField

③ 2个JButton

分析完毕后，我们到IDEA中去实现一下：

import javax.swing.*;/*聊天室*/
public class ChatRoom {public static void main(String[] args) {//创建窗体对象JFrame jf = new JFrame();jf.setTitle("聊天室");jf.setSize(400, 300);jf.setDefaultCloseOperation(3);jf.setLocationRelativeTo(null);jf.setAlwaysOnTop(true);jf.setLayout(null);//显示聊天信息的文本域JTextArea messageArea = new JTextArea();messageArea.setBounds(10,10,360,200);jf.add(messageArea);//输入聊天信息的文本框JTextField messageField = new JTextField();messageField.setBounds(10,230,180,20);jf.add(messageField);//发送按钮JButton sendButton = new JButton("发送");sendButton.setBounds(200,230,70,20);jf.add(sendButton);//清空聊天按钮JButton clearButton = new JButton("清空聊天");clearButton.setBounds(280,230,100,20);jf.add(clearButton);jf.setVisible(true);}
}

讲解完毕后，大家赶快动手练习一下吧。

4.3.3 案例3(猜数字)

需求：如图所示，做出界面

提示：给出的数据就是按照组件位置和大小给出的

首先，我们来简单的分析一下：

分析：

① 1个JLabel

② 1个JTextField

③ 1个JButton

分析完毕后，我们到IDEA中去实现一下：

import javax.swing.*;/*猜数字*/
public class GuessNumber {public static void main(String[] args) {//创建窗体对象JFrame jf = new JFrame();jf.setTitle("猜数字");jf.setSize(400, 300);jf.setDefaultCloseOperation(3);jf.setLocationRelativeTo(null);jf.setAlwaysOnTop(true);jf.setLayout(null);//提示信息JLabel messageLable = new JLabel("系统产生了一个1-100之间的数据，请猜一猜");messageLable.setBounds(70,50,350,20);jf.add(messageLable);//输入要猜的数字JTextField numberField = new JTextField();numberField.setBounds(120,100,150,20);jf.add(numberField);//猜数字的按钮JButton guessButton = new JButton("我猜");guessButton.setBounds(150,150,100,20);jf.add(guessButton);jf.setVisible(true);}
}

讲解完毕后，大家赶快动手练习一下吧。

4.3.4 案例4(手机日期和时间显示)

需求：如图所示，做出界面

提示：给出的数据就是按照组件位置和大小给出的

参照图：

我们要实现的图：

首先，我们来简单的分析一下：

分析：

① 4个JLabel

分析完毕后，我们到IDEA中去实现一下：

import javax.swing.*;/*手机日期和时间显示*/
public class ShowDateTime {public static void main(String[] args) {//创建窗体对象JFrame jf = new JFrame();jf.setTitle("手机日期和时间显示");jf.setSize(400, 300);jf.setDefaultCloseOperation(3);jf.setLocationRelativeTo(null);jf.setAlwaysOnTop(true);jf.setLayout(null);//提示日期JLabel dateLable = new JLabel("日期");dateLable.setBounds(50,50,100,20);jf.add(dateLable);//按照格式显示日期的字符串JLabel showDateLable = new JLabel("xxxx年xx月xx日");showDateLable.setBounds(50,80,200,20);jf.add(showDateLable);//提示时间JLabel timeLable = new JLabel("时间");timeLable.setBounds(50,150,100,20);jf.add(timeLable);//按照格式显示时间的字符串JLabel showTimeLable = new JLabel("xx:xx");showTimeLable.setBounds(50,180,200,20);jf.add(showTimeLable);jf.setVisible(true);}
}

讲解完毕后，大家赶快动手练习一下吧。

4.3.5 案例5(考勤查询)

需求：如图所示，做出界面

提示：给出的数据就是按照组件位置和大小给出的

首先，我们来简单的分析一下：

分析：

① 3个JLabel

② 2个JTextField

③ 1个JButton

分析完毕后，我们到IDEA中去实现一下：

import javax.swing.*;/*考勤查询*/
public class AttendanceQuery01 {public static void main(String[] args) {//创建窗体对象JFrame jf = new JFrame();jf.setTitle("考勤查询");jf.setSize(400, 300);jf.setDefaultCloseOperation(3);jf.setLocationRelativeTo(null);jf.setAlwaysOnTop(true);jf.setLayout(null);//显示考勤日期的文本JLabel dateLable = new JLabel("考勤日期");dateLable.setBounds(50,20,100,20);jf.add(dateLable);//显示开始时间文本JLabel startDateLable = new JLabel("开始时间");startDateLable.setBounds(50,70,100,20);jf.add(startDateLable);//开始时间输入框JTextField startDateField = new JTextField();startDateField.setBounds(50,100,100,20);jf.add(startDateField);//显示结束时间文本JLabel endDateLable = new JLabel("结束时间");endDateLable.setBounds(250,70,100,20);jf.add(endDateLable);//结束时间输入框JTextField endDateField = new JTextField();endDateField.setBounds(250,100,100,20);jf.add(endDateField);//确定按钮JButton confirmButton = new JButton("确定");confirmButton.setBounds(250,180,60,20);jf.add(confirmButton);jf.setVisible(true);}
}

讲解完毕后，大家赶快动手练习一下吧。

4.3.6 案例5(考勤查询之日历控件)

需求：用日历控件改进考勤查询的日期字符串填写

来，继续啊，下面我们来学习考勤查询之日历控件

首先，我们看一下需求：用日历控件改进考勤查询的日期字符串填写

什么意思呢？我们刚在做的考勤查询系统，是需要手动输入日期字符串的，而在实际开发中，我们一般会选择使用日历控件来实现，

也就是下面这个样子的，我们点击一下，就会出现日历控件，我们选择日期就可以了。

这个相信大家有见过。

知道了要做什么之后，下面我们来说一下，怎么做。

我们可以自己写这个日历控件，也可以使用别人写好的日历控件。鉴于目前所学知识有限，我们先使用别人提供的日历控件。

这里呢，我准备好了一个日历控件类(DateChooser.java)，我们到IDEA中一起去看一下如何使用：

public static void main(String[] args) {//创建窗体JFrame jf = new JFrame();//设置窗体大小jf.setSize(400, 300);//设置窗体标题jf.setTitle("日历控件");//设置位置，值为null，则窗体位于屏幕中央jf.setLocationRelativeTo(null);//设置窗体关闭时默认操作，窗口关闭时退出应用程序jf.setDefaultCloseOperation(3);//设置此窗口是否应始终位于其他窗口之上jf.setAlwaysOnTop(true);//取消窗体默认布局：窗体对象.setLayout(null);jf.setLayout(null);//创建日期选择器对象，指定日期字符串格式DateChooser dateChooser = DateChooser.getInstance("yyyy-MM-dd");JTextField showDateField = new JTextField("单击选择日期");showDateField.setBounds(50, 50, 100, 20);//把日历控件和文本框进行绑定dateChooser.register(showDateField);jf.add(showDateField);jf.setVisible(true);
}

了解了如何使用日历控件后，我们把开始写的代码改进一下：

import javax.swing.*;/*考勤查询*/
public class AttendanceQuery02 {public static void main(String[] args) {//创建窗体对象JFrame jf = new JFrame();jf.setTitle("考勤查询");jf.setSize(400, 300);jf.setDefaultCloseOperation(3);jf.setLocationRelativeTo(null);jf.setAlwaysOnTop(true);jf.setLayout(null);//显示考勤日期的文本JLabel dateLable = new JLabel("考勤日期");dateLable.setBounds(50,20,100,20);jf.add(dateLable);//显示开始时间文本JLabel startDateLable = new JLabel("开始时间");startDateLable.setBounds(50,70,100,20);jf.add(startDateLable);DateChooser dateChooser1 = DateChooser.getInstance("yyyy/MM/dd");DateChooser dateChooser2 = DateChooser.getInstance("yyyy/MM/dd");//开始时间输入框JTextField startDateField = new JTextField();startDateField.setBounds(50,100,100,20);dateChooser1.register(startDateField);jf.add(startDateField);//显示结束时间文本JLabel endDateLable = new JLabel("结束时间");endDateLable.setBounds(250,70,100,20);jf.add(endDateLable);//结束时间输入框JTextField endDateField = new JTextField();endDateField.setBounds(250,100,100,20);dateChooser2.register(endDateField);jf.add(endDateField);//确定按钮JButton confirmButton = new JButton("确定");confirmButton.setBounds(250,180,60,20);jf.add(confirmButton);jf.setVisible(true);}
}

讲解完毕后，大家赶快动手练习一下吧。

4.4 事件监听机制

来，继续啊，目前呢，我们做好了几个GUI的界面，但是具体的功能，我们没法实现。因为要想实现功能，就必须要学习一下事件监听机制。

这里，我们一起来说一下事件监听机制的组成：

• **事件源：**事件发生的地方。可以是按钮，窗体，图片等
• **事件：**发生了什么事情。例如：鼠标点击事件，键盘按下事件等
• **事件绑定：**把事件绑定到事件源上，当发生了某个事件，则触发对应的处理逻辑
  • 事件源对象. addXXXListener(事件);

GUI中的事件比较多，这里呢，我们先告诉一下大家如何给按钮添加事件，能够把我们前面的案例给实现就可以了。至于其他事件，后面我们用到的时候再去学习。

了解了如何给按钮添加事件后，我们到IDEA中去体验一下：

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;/*事件监听机制*/
public class ActionListenerDemo {public static void main(String[] args) {//创建窗体对象JFrame jf = new JFrame();jf.setTitle("事件监听机制");jf.setSize(400, 300);jf.setDefaultCloseOperation(3);jf.setLocationRelativeTo(null);jf.setAlwaysOnTop(true);jf.setLayout(null);//创建按钮JButton jButton = new JButton("你点我啊");jButton.setBounds(0, 0, 100, 100);jf.add(jButton);jButton.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {System.out.println("你点我啊");}});jf.setVisible(true);}
}

讲解完毕后，大家赶快动手练习一下吧。

1 编程题

1.1 视频中的案例

​ 视频中的案例如果有没练习的，先补上

1.2 编程题一

训练目标：Scanner的使用，方法的定义和使用

需求描述：用户在控制台输入行数和列数，然后定义一个带参方法实现输出对应矩形

public class Test01 {public static void main(String[] args) {//键盘对象Scanner sc = new Scanner(System.in);//提示并接收System.out.println("行:");int hang = sc.nextInt();System.out.println("列:");int lie = sc.nextInt();//外管行for (int i = 1; i <= hang; i++) {//内管列for (int j = 1; j <= lie; j++) {//一行打印System.out.print("#");}//一列走完换行System.out.println();}}
}

1.3 编程题二

训练目标：键盘对象Scanner的使用, 方法的复习

需求描述：设计一个方法, 可以获取一个指定长度的数组, 数组元素为键盘录入的整数

public class Test02 {public static void main(String[] args) {//调用方法int[] arr = getScannerArray(5);//查看结果System.out.println("遍历数组:");for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}}/*定义方法的两个明确:1.参数列表: int 长度2.返回值类型: int[]*/public static int[] getScannerArray(int length){//动态初始化指定长度的数组int[] arr = new int[length];//创建键盘对象Scanner sc= new Scanner(System.in);//遍历数组for (int i = 0; i < arr.length; i++) {//提示录入System.out.println("请输入第"+(i+1)+"个元素:");//给元素赋值arr[i] = sc.nextInt();}//返回数组return arr;}
}

1.4 编程题三

训练目标：随机数对象Random的使用, 方法的复习

需求描述：设计一个方法, 可以获取一个指定长度的数组, 数组元素为指定范围的整数

public class Test03 {public static void main(String[] args) {//调用方法int[] arr = getRandomArray(5,1,10);//查看结果System.out.println("随机数组:");for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}}/*定义方法的两个明确:1.参数列表: int 长度, int 随机数起始范围, int 随机数结束范围2.返回值类型: int[]*/public static int[] getRandomArray(int length, int min, int max) {//动态初始化指定长度的数组int[] arr = new int[length];//创建随机数对象Random r = new Random();//遍历数组for (int i = 0; i < arr.length; i++) {//给元素赋随机值, 范围是用户指定的arr[i] = r.nextInt(max - min + 1) + min;}//返回数组return arr;}
}

常用API(2)

今日目标：

• 能够使用String类的功能完成用户登录案例
• 能够使用String类的功能完成聊天室案例
• 能够使用Integer类的功能完成猜数字案例
• 能够使用Date类和SimpleDateFormat类的功能完成手机日期和时间显示案例
• 能够使用Date类和SimpleDateFormat类的功能完成考勤查询案例

1：String

1.1 String(构造方法)

来，继续啊，前面我们做过了GUI中的案例，也就是把一些小应用的界面做好了，但是具体功能并没有实现。接下来呢，我们就来一起实现一下。

首先，我们先来学习String类，它涉及到两个案例：用户登录和聊天室。

先来看用户登录案例：需要输入用户名和密码，和已知的用户名和密码进行比较，涉及到比较的方法，

一般来说，用户名和密码的长度可能会有一定限制，涉及到获取字符串长度的方法，

再来看聊天室案例，这里输入聊天的内容，然后把聊天内容显示到上面的文本域。

在聊天的时候，可能不小心打了空格，我们不需要的，需要去掉前后空格，

当然了，还有很多其他的成员方法，只不过，目前我们暂时用不上，后面用的时候再讲。

下面，我们就来学习一下字符串类String，最后完成用户登录案例和聊天室案例。

而关于String类呢，我们先到帮助文档中去查看，然后回来总结，最后到IDEA中去演示。

来，打开我们准备好的帮助文档，关于通过帮助文档查看String，大家按照老师讲解的API的使用步骤看看即可。

通过文档了解了String类之后，下面我们回到资料中总结一下：

String：

• String类表示字符串。 Java程序中的所有字符串文字（例如"abc" ）都实现为此类的实例

构造方法：

• String()：初始化新创建的 String对象，使其表示空字符序列
• String(String original)：初始化新创建的String对象，使其表示与参数相同的字符序列

知道了String的构造方法后，我们到IDEA中去使用一下：

/*String类表示字符串。 Java程序中的所有字符串文字（例如"abc" ）都实现为此类的实例构造方法：String()：初始化新创建的 String对象，使其表示空字符序列String(String original)：初始化新创建的String对象，使其表示与参数相同的字符序列*/
public class StringDemo01 {public static void main(String[] args) {//String()：初始化新创建的 String对象，使其表示空字符序列String s1 = new String();System.out.println(s1);//int length() 返回此字符串的长度System.out.println(s1.length());System.out.println("------------");//String(String original)：初始化新创建的String对象，使其表示与参数相同的字符序列String s2 = new String("itheima");System.out.println(s2);System.out.println(s2.length());System.out.println("------------");//Java程序中的所有字符串文字（例如"abc" ）都实现为此类的实例String s3 = "itheima";System.out.println(s3);System.out.println(s3.length());}
}

讲解完毕后，大家赶快动手练习一下吧。

1.2 String(成员方法)

来，继续啊，下面我们来学习String类中常用的成员方法：

• int length()：返回此字符串的长度
• boolean equals(Object anObject)：将此字符串与指定的对象进行比较
• boolean equalsIgnoreCase(String anotherString)：将此 String与另一个 String比较，忽略了大小写
• String trim()：返回一个字符串，其值为此字符串，删除了所有前导和尾随空格

而关于这几个成员方法呢，我们到IDEA中一边使用，一边讲解。

/*int length()：返回此字符串的长度boolean equals(Object anObject)：将此字符串与指定的对象进行比较boolean equalsIgnoreCase(String anotherString)：将此 String与另一个 String比较，忽略了大小写String trim()：返回一个字符串，其值为此字符串，删除了所有前导和尾随空格*/
public class StringDemo02 {public static void main(String[] args) {String s1 = "itheima";String s2 = "itheima";String s3 = "Itheima";//boolean equals(Object anObject)：将此字符串与指定的对象进行比较System.out.println(s1.equals(s2));System.out.println(s1.equals(s3));//boolean equalsIgnoreCase(String anotherString)：将此 String与另一个 String比较，忽略了大小写System.out.println(s1.equalsIgnoreCase(s2));System.out.println(s1.equalsIgnoreCase(s3));System.out.println("-------------------");String s4 = " itheima ";//String trim()：返回一个字符串，其值为此字符串，删除了所有前导和尾随空格System.out.println(s4);System.out.println(s4.trim());String s5 = "it heima";System.out.println(s5.trim());}
}

讲解完毕后，大家赶快动手练习一下吧。

1.3 GUI案例1(用户登录实现)

需求：根据下列要求，完成用户登录的逻辑，并给出相应的提示

要求：

① 已知的用户名和密码

用户名：itheima密码：123456

② 用户名和密码的长度都是6-12位

③ 点击登录按钮

先判断输入的用户名和密码是否符合要求再判断用户登录是否成功

知道了用户登录案例的需求和要求后，下面我们到IDEA中去实现一下：

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;/*1:已知的用户名和密码用户名：itheima密码：1234562:用户名和密码的长度都是6-12位3:点击登录按钮先判断输入的用户名和密码是否符合要求再判断用户登录是否成功*/
public class UserLogin {public static void main(String[] args) {//创建窗体对象JFrame jf = new JFrame();jf.setTitle("用户登录");jf.setSize(400, 300);jf.setDefaultCloseOperation(3);jf.setLocationRelativeTo(null);jf.setAlwaysOnTop(true);jf.setLayout(null);//显示用户名文本JLabel usernameLable = new JLabel("用户名");usernameLable.setBounds(50, 50, 50, 20);jf.add(usernameLable);//用户名输入框JTextField usernameField = new JTextField();usernameField.setBounds(150, 50, 180, 20);jf.add(usernameField);//显示密码文本JLabel passwordLable = new JLabel("密码");passwordLable.setBounds(50, 100, 50, 20);jf.add(passwordLable);//密码输入框JPasswordField passwordField = new JPasswordField();passwordField.setBounds(150, 100, 180, 20);jf.add(passwordField);//登录按钮JButton loginButton = new JButton("登录");loginButton.setBounds(50, 200, 280, 20);jf.add(loginButton);//已知的用户名和密码String name = "itheima";String pwd = "123456";loginButton.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {//获取用户输入的用户名和密码String username = usernameField.getText();String password = passwordField.getText();//先判断输入的用户名和密码是否符合要求//用户名和密码的长度都是6-12位if(username.length()<6 || username.length()>12) {
//                    System.out.println("用户名的长度是6-12位，请重新输入");//静态的成员方法和成员变量是可以通过类名访问的JOptionPane.showMessageDialog(jf,"用户名的长度是6-12位，请重新输入");usernameField.setText("");return;}//再判断用户登录是否成功if(username.equals(name) && password.equals(pwd)) {
//                    System.out.println("登录成功");JOptionPane.showMessageDialog(jf,"登录成功");usernameField.setText("");passwordField.setText("");} else {
//                    System.out.println("用户名或者密码有误");JOptionPane.showMessageDialog(jf,"用户名或者密码有误");}}});jf.setVisible(true);}
}

讲解完毕后，大家赶快动手练习一下吧。

1.4 GUI案例2(聊天室实现)

需求：根据下列要求，完成聊天室的逻辑

要求：

① 把文本框的内容发送到文本域中

② 每次发送的文本内容不带前后空格

③ 多次发送的内容在文本域以追加的方式呈现

④ 清空聊天就是把文本域的内容设置为空

知道了聊天室案例的需求和要求后，下面我们到IDEA中去实现一下：

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;/*1:把文本框的内容发送到文本域中2:每次发送的文本内容不带前后空格3:多次发送的内容在文本域以追加的方式呈现4:清空聊天就是把文本域的内容设置为空*/
public class ChatRoom {public static void main(String[] args) {//创建窗体对象JFrame jf = new JFrame();jf.setTitle("聊天室");jf.setSize(400, 300);jf.setDefaultCloseOperation(3);jf.setLocationRelativeTo(null);jf.setAlwaysOnTop(true);jf.setLayout(null);//显示聊天信息的文本域JTextArea messageArea = new JTextArea();messageArea.setBounds(10, 10, 360, 200);jf.add(messageArea);//输入聊天信息的文本框JTextField messageField = new JTextField();messageField.setBounds(10, 230, 180, 20);jf.add(messageField);//发送按钮JButton sendButton = new JButton("发送");sendButton.setBounds(200, 230, 70, 20);jf.add(sendButton);//清空聊天按钮JButton clearButton = new JButton("清空聊天");clearButton.setBounds(280, 230, 100, 20);jf.add(clearButton);sendButton.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {//获取文本框的内容
//                String message = messageField.getText();
//                messageField.setText("");//每次发送的文本内容不带前后空格
//                String message = messageField.getText();
//                message = message.trim();String message = messageField.getText().trim(); //链式调用messageField.setText("");//把文本框的内容发送到文本域中
//                messageArea.setText(message);//多次发送的内容在文本域以追加的方式呈现messageArea.append(message+"\n");}});clearButton.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {//清空聊天就是把文本域的内容设置为空messageArea.setText("");}});jf.setVisible(true);}
}

讲解完毕后，大家赶快动手练习一下吧。

2：Integer

2.1 Integer(构造方法)

来，继续啊，下面我们来学习基本类型包装类，它涉及到1个案例：猜数字。

来，我们一起看一下，在这个输入框里，我们要输入一个猜的数据，然后点击我猜这个按钮，和已经产生的数据进行比对，给出相应的提示即可。

而且呢，猜数字案例的基本逻辑，我们前面是讲解过的，只不过当时使用的是键盘录入数据，而这里我们采用的是在输入框里输入数据而已。

那我们为什么要学习基本类型包装类呢？

因为，在输入框里输入的数据，我们得到的是一个字符串数据，而实际比较的时候我们需要的是一个int类型的数据，所以，我们得想办法把字符串数据转换为int类型的数据。

为了实现这个效果，Java就提供了基本类型包装类供我们使用。所以，我们说，将基本数据类型封装成对象的好处就是可以通过对象调用方法操作数据。

而我们常用的操作之一呢：就是用于基本数据类型与字符串之间的转换。

在这里呢，我们一起来看一下，八种基本数据类型和其对应的包装类类型

从名字上看，包装类类型就是把基本类型的第一个单词改为大写即可。

当然，这里也有两个比较特殊的，一个是int类型的包装类，一个是字符类型的包装类，它们的包装类名称是这个样子的，大家了解一下即可。

下面呢，我们以Integer举例来讲解字符串和int类型之间的相互转换，其他基本类型和字符串的转换方式类似，在使用的时候，大家参照Integer的使用即可。

而关于Integer类的学习呢，我们先到帮助文档中去查看，然后回来总结，最后到IDEA中去演示。

来，打开我们准备好的帮助文档，关于通过帮助文档查看Integer，大家按照老师讲解的API的使用步骤看看即可。

通过文档了解了Integer类之后，下面我们回到资料中总结一下：

Integer：

• Integer类在对象中包装基本类型int的值

构造方法：

• Integer(int value)：根据 int 值创建 Integer 对象(过时)
• Integer(String s)：根据 String 值创建 Integer 对象(过时)

成员方法：

• static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例
• static Integer valueOf(String s)：返回一个保存指定值的 Integer 对象 String

知道了Integer的构造方法后，我们到IDEA中去使用一下：

/*构造方法Integer(int value)：根据 int 值创建 Integer 对象(过时)Integer(String s)：根据 String 值创建 Integer 对象(过时)成员方法static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例static Integer valueOf(String s)：返回一个保存指定值的 Integer 对象 String*/
public class IntegerDemo01 {public static void main(String[] args) {
//        //Integer(int value)：根据 int 值创建 Integer 对象(过时)
//        Integer i1 = new Integer(100);
//        System.out.println(i1);
//
//        //Integer(String s)：根据 String 值创建 Integer 对象(过时)
//        Integer i2 = new Integer("100");
//        System.out.println(i2);//        static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例
//        static Integer valueOf(String s)：返回一个保存指定值的 Integer 对象 StringInteger i1 = Integer.valueOf(100);Integer i2 = Integer.valueOf("100");System.out.println(i1);System.out.println(i2);}
}

讲解完毕后，大家赶快动手练习一下吧。

2.2 Integer(int和String的相互转换)

来，继续啊，下面我们来学习int类型数据和String类型数据的相互转换，关于它们之间的相互转换，我们先到IDEA中去讲解，然后回来总结。

/*int和String的相互转换*/
public class IntegerDemo02 {public static void main(String[] args) {//int --- Stringint number = 100;//方式1String s1 = number + "";System.out.println(s1);//方式2//static String valueOf(int i)String s2 = String.valueOf(number);System.out.println(s2);System.out.println("---------------");//String --- intString s = "100";//方式1：String --- Integer --- intInteger i = Integer.valueOf(s);//int intValue() 返回此值 Integer为 intint x = i.intValue();System.out.println(x);//方式2//static int parseInt(String s)int y = Integer.parseInt(s);System.out.println(y);}
}

讲解完毕int类型和String类型的相互转换后，回到资料总结一下：

• int 转换为 String
  • static String valueOf(int i)：返回 int 参数的字符串表示形式。该方法是 String 类中的方法
• String 转换为 int
  • static int parseInt(String s)：将字符串解析为 int 类型。该方法是 Integer 类中的方法

好了，int类型数据和String类型数据的相互转换我们就先讲到这里。

2.3 GUI案例3(猜数字实现)

需求：根据下列要求，完成猜数字的逻辑

要求：

① 系统产生一个1-100之间的随机数

② 猜的内容不能为空

③ 每次根据猜的数字给出相应的提示

知道了猜数字案例的需求和要求后，下面我们到IDEA中去实现一下：

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;/*1:系统产生一个1-100之间的随机数2:猜的内容不能为空3:每次根据猜的数字给出相应的提示
*/
public class GuessNumber {public static void main(String[] args) {//创建窗体对象JFrame jf = new JFrame();jf.setTitle("猜数字");jf.setSize(400, 300);jf.setDefaultCloseOperation(3);jf.setLocationRelativeTo(null);jf.setAlwaysOnTop(true);jf.setLayout(null);//系统产生一个1-100之间的随机数Random r = new Random();int number = r.nextInt(100) + 1;//提示信息JLabel messageLable = new JLabel("系统产生了一个1-100之间的数据，请猜一猜");messageLable.setBounds(70, 50, 350, 20);jf.add(messageLable);//输入要猜的数字JTextField numberField = new JTextField();numberField.setBounds(120, 100, 150, 20);jf.add(numberField);//猜数字的按钮JButton guessButton = new JButton("我猜");guessButton.setBounds(150, 150, 100, 20);jf.add(guessButton);guessButton.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {//猜的内容不能为空String stringNumber = numberField.getText().trim();if(stringNumber.equals("")) {JOptionPane.showMessageDialog(jf,"猜的数字不能为空");return;}//每次根据猜的数字给出相应的提示int guessNumber = Integer.parseInt(stringNumber);if(guessNumber > number) {JOptionPane.showMessageDialog(jf,"你猜的数字"+guessNumber+"大了");numberField.setText("");} else if(guessNumber < number) {JOptionPane.showMessageDialog(jf,"你猜的数字"+guessNumber+"小了");numberField.setText("");} else  {JOptionPane.showMessageDialog(jf,"恭喜你猜中了");}}});jf.setVisible(true);}
}

讲解完毕后，大家赶快动手练习一下吧。

2.4 Integer(自动装箱和拆箱)

来，继续啊，下面我们来学习自动装箱和拆箱。

首先，我们来说一下什么是装箱和拆箱：

• **装箱：**把基本数据类型转换为对应的包装类类型
• **拆箱：**把包装类类型转换为对应的基本数据类型

了解了装箱和拆箱后，下面我们到IDEA中去演示一下：

/*装箱：把基本数据类型转换为对应的包装类类型拆箱：把包装类类型转换为对应的基本数据类型*/
public class IntegerDemo03 {public static void main(String[] args) {//装箱：把基本数据类型转换为对应的包装类类型
//        Integer i = Integer.valueOf(100);Integer ii = 100; //Integer.valueOf(100);//拆箱：把包装类类型转换为对应的基本数据类型ii += 200;/*ii = ii + 200;ii = ii.intValue() + 200;   //自动拆箱ii = 300; //Integer.valueOf(300);*/System.out.println(ii);}
}

好了，自动装箱和拆箱我们就先讲到这里。

3：Date和SimpleDateFormat

3.1 Date(构造方法)

来，继续啊，下面我们来学习Date类和SimpleDateFormat类，它们涉及到两个案例：手机日期和时间显示和考勤查询

先来看手机日期和时间显示案例：获取当前时间，按照指定的格式显示在窗体上。

也就是在这里我们要进行把一个Date类型的数据，按照指定的格式，变成一个字符串数据显示出来。

再来看考勤查询案例，我们要通过输入的指定格式的日期字符串数据，得到Date类型的数据。

所以，我们学习Date类和SimpleDateFormat类的重点就是为了把Date类型数据和String类型数据之间进行按照指定格式进行转换。

首先呢，我们先来学习一下Date类，而关于Date类呢，我们先到帮助文档中去查看，然后回来总结，最后到IDEA中去演示。

来，打开我们准备好的帮助文档，关于通过帮助文档查看Date，大家按照老师讲解的API的使用步骤看看即可。

通过文档了解了Date类之后，下面我们回到资料中总结一下：

Date：

• Date类表示特定的时刻，精度为毫秒

构造方法：

• Date()：分配 Date对象并对其进行初始化，使其表示分配时间，测量 Date到毫秒
• Date(long date)：分配 Date对象并初始化它以表示自标准基准时间以来的指定毫秒数，即1970年1月1日00:00:00

知道了(的构造方法后，我们到IDEA中去使用一下：

import java.util.Date;/*构造方法：Date()：分配 Date对象并对其进行初始化，使其表示分配时间，测量 Date到毫秒Date(long date)：分配 Date对象并初始化它以表示自标准基准时间以来的指定毫秒数，即1970年1月1日00:00:00*/
public class DateDemo {public static void main(String[] args) {//Date()：分配 Date对象并对其进行初始化，使其表示分配时间，测量 Date到毫秒Date d1 = new Date();System.out.println(d1);//Date(long date)：分配 Date对象并初始化它以表示自标准基准时间以来的指定毫秒数，即1970年1月1日00:00:00Date d2 = new Date(1000 * 60 * 60);System.out.println(d2);}
}

而目前呢，Date类中没有我们要使用的成员方法，所以，我们也就不看它的成员方法了。

讲解完毕后，大家赶快动手练习一下吧。

3.2 SimpleDateFormat(Date和String的相互转换)

来，继续啊，下面我们来学习SimpleDateFormat这个类。

打开我们准备好的帮助文档，关于通过帮助文档查看SimpleDateFormat，大家按照老师讲解的API的使用步骤看看即可。

通过文档了解了SimpleDateFormat类之后，下面我们回到资料中总结一下：

SimpleDateFormat：

• SimpleDateFormat 是一个用于以区域设置敏感的方式格式化和解析日期的具体类。我们重点学习日期格式化和解析

• 日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从‘A’到‘Z’以及从‘a’到‘z’引号的字母被解释为表示日期或时间字符串的组成部分的模式字母

常用的模式字母及对应关系如下：

• **举例：**2021年10月27日 11:11:11
• **模式：**yyyy年MM月dd日 HH:mm:ss

构造方法：

• SimpleDateFormat()：构造一个SimpleDateFormat，使用默认模式和日期格式
• SimpleDateFormat(String pattern)：构造一个SimpleDateFormat使用给定的模式和默认的日期格式

格式化(从 Date 到 String )：

• String format(Date date)：将日期格式化成日期/时间字符串

解析(从 String 到 Date )：

• Date parse(String source)：从给定字符串的开始解析文本以生成日期

了解了SimpleDateFormat类，以及Date和String相互转换的方法后，我们到IDEA中去体验一下：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;/*构造方法SimpleDateFormat()：构造一个SimpleDateFormat，使用默认模式和日期格式SimpleDateFormat(String pattern)：构造一个SimpleDateFormat使用给定的模式和默认的日期格式格式化(从 Date 到 String )String format(Date date)：将日期格式化成日期/时间字符串解析(从 String 到 Date )Date parse(String source)：从给定字符串的开始解析文本以生成日期*/
public class SimpleDateFormatDemo {public static void main(String[] args) throws ParseException {//格式化(从 Date 到 String )Date d = new Date();//SimpleDateFormat()：构造一个SimpleDateFormat，使用默认模式和日期格式
//        SimpleDateFormat sdf = new SimpleDateFormat();//SimpleDateFormat(String pattern)：构造一个SimpleDateFormat使用给定的模式和默认的日期格式SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");String s = sdf.format(d);System.out.println(s);System.out.println("-----------------");//解析(从 String 到 Date )String ss = "2021-10-27 11:11:11";
//        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date dd = sdf2.parse(ss);System.out.println(dd);}
}

讲解完毕后，大家赶快动手练习一下吧。

3.3 GUI案例4(手机日期和时间显示实现)

需求：根据下列要求，完成手机日期和时间显示

要求：以当前时间根据格式分别获取日期和时间显示

知道了手机日期和时间显示案例的需求和要求后，下面我们到IDEA中去实现一下：

import javax.swing.*;
import java.text.SimpleDateFormat;
import java.util.Date;/*手机日期和时间显示*/
public class ShowDateTime {public static void main(String[] args) {//创建窗体对象JFrame jf = new JFrame();jf.setTitle("手机日期和时间显示");jf.setSize(400, 300);jf.setDefaultCloseOperation(3);jf.setLocationRelativeTo(null);jf.setAlwaysOnTop(true);jf.setLayout(null);//提示日期JLabel dateLable = new JLabel("日期");dateLable.setBounds(50, 50, 100, 20);jf.add(dateLable);Date d = new Date();SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");String dateString = sdf.format(d);//按照格式显示日期的字符串JLabel showDateLable = new JLabel(dateString);showDateLable.setBounds(50, 80, 200, 20);jf.add(showDateLable);//提示时间JLabel timeLable = new JLabel("时间");timeLable.setBounds(50, 150, 100, 20);jf.add(timeLable);SimpleDateFormat sdf2 = new SimpleDateFormat("HH:mm");String timeString = sdf2.format(d);//按照格式显示时间的字符串JLabel showTimeLable = new JLabel(timeString);showTimeLable.setBounds(50, 180, 200, 20);jf.add(showTimeLable);jf.setVisible(true);}
}

讲解完毕后，大家赶快动手练习一下吧。

3.4 GUI案例5(考勤查询实现)

需求：根据下列要求，完成考勤查询的逻辑

要求：根据开始时间和结束时间的字符串解析为日期提示出来

知道了考勤查询案例的需求和要求后，下面我们到IDEA中去实现一下：

这里用到了日历控件类，需要大家把DateChooser.java类准备好

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;/*考勤查询*/
public class AttendanceQuery {public static void main(String[] args) {//创建窗体对象JFrame jf = new JFrame();jf.setTitle("考勤查询");jf.setSize(400, 300);jf.setDefaultCloseOperation(3);jf.setLocationRelativeTo(null);jf.setAlwaysOnTop(true);jf.setLayout(null);//显示考勤日期的文本JLabel dateLable = new JLabel("考勤日期");dateLable.setBounds(50, 20, 100, 20);jf.add(dateLable);//显示开始时间文本JLabel startDateLable = new JLabel("开始时间");startDateLable.setBounds(50, 70, 100, 20);jf.add(startDateLable);DateChooser dateChooser1 = DateChooser.getInstance("yyyy/MM/dd");DateChooser dateChooser2 = DateChooser.getInstance("yyyy/MM/dd");//开始时间输入框JTextField startDateField = new JTextField();startDateField.setBounds(50, 100, 100, 20);dateChooser1.register(startDateField);jf.add(startDateField);//显示结束时间文本JLabel endDateLable = new JLabel("结束时间");endDateLable.setBounds(250, 70, 100, 20);jf.add(endDateLable);//结束时间输入框JTextField endDateField = new JTextField();endDateField.setBounds(250, 100, 100, 20);dateChooser2.register(endDateField);jf.add(endDateField);//确定按钮JButton confirmButton = new JButton("确定");confirmButton.setBounds(250, 180, 60, 20);jf.add(confirmButton);confirmButton.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");//获取开始时间和结束时间的字符串String startDateString = startDateField.getText();String endDateString = endDateField.getText();try {Date startDate = sdf.parse(startDateString);Date endDate = sdf.parse(endDateString);JOptionPane.showMessageDialog(jf,startDate+"\n"+endDate);} catch (ParseException ex) {ex.printStackTrace();}}});jf.setVisible(true);}
}

这里我们仅仅是演示了考勤查询的日期数据处理，将来呢，我们就可以根据这两个日期数据到考勤查询系统中去查询考勤信息了。

讲解完毕后，大家赶快动手练习一下吧。

1 简答题

1.1 简答题

String类中replace方法的作用是?并举例说明

答：replace(旧子串,新子串);该方法接收两个参数,使用新子串替换所有的旧子串,并返回新的字符串System.out.println("你TMD真是个人才".replace("TMD", "***")); //你***真是个人才

String类中trim方法的作用是?并举例说明

答：去除该字符串首尾的空格,并返回新的字符串System.out.println(" 123 ".trim()); //123

String类中length方法的作用是?并举例说明

答：返回字符串长度,也就是包含字符的个数System.out.println("12345".length()); //5

String类中toCharArray方法的作用是?并举例说明

答：将该字符串转为对应的字符数组,返回字符数组char[] chars = "abc".toCharArray(); //遍历数组chars查看结果

1.2 简答题

Integer类中parseInt方法的作用是？

答：将字符串类型,解析为int类型如果该字符串包含除了数字外的其他字符,则会报NumberFormatException异常int i1 = Integer.parseInt("100"); //转换成功int i2 = Integer.parseInt("123adb"); //NumberFormatException

Date类中getTime方法的作用是？

答：获取从时间原点开始,至今经历的毫秒值Date d = new Date();System.out.println(d.getTime()); //1651331634385可以转换为天数System.out.println(d.getTime() / 24 / 60 / 60 /1000); //从时间原点至今经历的天数为19112天

SimpleDateFormat类中format方法的作用是？

答：将Date对象,通过指定格式,格式化为String类型SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date d = new Date(); //当前时间String format = sdf.format(d);System.out.println(format); //2022-04-30 23:23:23

SimpleDateFormat类中parse方法的作用是？

答：将包含日期的字符串,通过指定格式,解析为Date对象parse方法有异常,Alt+回车抛出即可SimpleDateFormat带参构造的参数为解析格式,如果格式不匹配会报ParseException异常public static void main(String[] args) throws ParseException {String s = "2022-04-30 23:18:25";SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date date = sdf.parse(s);System.out.println(date); //Sat Apr 30 23:23:23 CST 2022}

2 编程题

完成上课的案例

AttendanceQuery 考勤查询 (注意要在同包下准备DateChooser类)

public class AttendanceQuery {public static void main(String[] args) {JFrame jf = new JFrame();jf.setSize(400, 300);jf.setTitle("考勤查询");//设置窗体标题jf.setLocationRelativeTo(null);//设置窗体位置在中央弹出jf.setDefaultCloseOperation(3);//设置窗体关闭停止程序jf.setAlwaysOnTop(true);//设置窗体置顶jf.setLayout(null);//取消默认布局//创建日期选择器对象，指定日期字符串格式DateChooser dateChooser1 = DateChooser.getInstance("yyyy-MM-dd");DateChooser dateChooser2 = DateChooser.getInstance("yyyy-MM-dd");//考勤日期文本JLabel date = new JLabel("考勤日期");date.setBounds(50,20,100,20);jf.add(date);//开始时间文本JLabel startTime = new JLabel("开始时间");startTime.setBounds(50,70,100,20);jf.add(startTime);//开始时间文本框JTextField startTimeText = new JTextField();startTimeText.setBounds(50,100,100,20);//把日历控件和文本框进行绑定dateChooser1.register(startTimeText);jf.add(startTimeText);//结束时间文本JLabel endTime = new JLabel("结束时间");endTime.setBounds(250,70,100,20);jf.add(endTime);//结束时间文本框JTextField endTimeText = new JTextField();endTimeText.setBounds(250,100,100,20);//把日历控件和文本框进行绑定dateChooser2.register(endTimeText);jf.add(endTimeText);//确定按钮JButton btn = new JButton("确定");btn.setBounds(250,180,60,20);jf.add(btn);/*根据开始时间和结束时间的字符串解析为日期提示出来注意自己当时定义的格式: yyyy-MM-dd*///给确定按钮加入点击事件btn.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {//日期格式化对象SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//获取文本框的开始时间String startTimeStr = startTimeText.getText();//获取文本框的结束时间String endTimeStr = endTimeText.getText();try {//将String分别解析为Date对象Date startDate = sdf.parse(startTimeStr); //这里有异常,alt+回车选择捕获异常即可Date endDate = sdf.parse(endTimeStr);//弹框打印JOptionPane.showMessageDialog(jf,startDate+"\n"+endDate);} catch (ParseException parseException) {parseException.printStackTrace();}}});jf.setVisible(true);//设置显示窗体(一般写在最后)}
}

ChatRoom 聊天室

public class ChatRoom {public static void main(String[] args) {JFrame jf = new JFrame();jf.setSize(400, 300);jf.setTitle("聊天室");//设置窗体标题jf.setLocationRelativeTo(null);//设置窗体位置在中央弹出jf.setDefaultCloseOperation(3);//设置窗体关闭停止程序jf.setAlwaysOnTop(true);//设置窗体置顶jf.setLayout(null);//取消默认布局//文本域对象JTextArea textArea = new JTextArea();textArea.setBounds(10,10,360,200);jf.add(textArea);//文本框JTextField text = new JTextField();text.setBounds(10,230,180,20);jf.add(text);//发送按钮JButton send = new JButton("发送");send.setBounds(200,230,70,20);jf.add(send);//清空聊天按钮JButton clear = new JButton("清空聊天");clear.setBounds(280,230,100,20);jf.add(clear);/*1. 将文本框的内容发送到文本域中2. 每次发送的文本,不带前后空格3. 多次发送的内容在文本域,追加呈现4. 清空聊天就是将文本域内容设置为空*///发送按钮绑定点击事件send.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {//获取文本框的内容,去除收尾空格String message = text.getText().trim();//发送到本文域,拼接加换行textArea.append(message+"\n");//清空文本框text.setText("");}});//清空聊天按钮绑定点击事件clear.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {//将文本域内容设置为空textArea.setText("");}});jf.setVisible(true);//设置显示窗体(一般写在最后)}
}

GuessNumber 猜数字小游戏

public class GuessNumber {public static void main(String[] args) {JFrame jf = new JFrame();jf.setSize(400, 300);jf.setTitle("猜数字");//设置窗体标题jf.setLocationRelativeTo(null);//设置窗体位置在中央弹出jf.setDefaultCloseOperation(3);//设置窗体关闭停止程序jf.setAlwaysOnTop(true);//设置窗体置顶jf.setLayout(null);//取消默认布局//文本对象JLabel jLabel = new JLabel("系统产生了一个1-100的随机数,请猜一猜");jLabel.setBounds(70, 50, 350, 20);jf.add(jLabel);//文本框对象JTextField jTextField = new JTextField();jTextField.setBounds(120, 100, 150, 20);jf.add(jTextField);//我猜按钮JButton btn = new JButton("我猜");btn.setBounds(150, 150, 100, 20);jf.add(btn);/*1. 系统产生一个1-100之间的随机数2. 猜的内容不能为空3. 每次根据猜的数组给出相应的提示*///产生随机数(正确答案)int randomNumber = new Random().nextInt(100) + 1;//给按钮添加点击事件btn.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {//猜的(用户输入的)内容不能为空String guessNumber = jTextField.getText().trim();if (guessNumber.equals("")) {//弹窗给出错误提示JOptionPane.showMessageDialog(jf, "猜的数字不能为空!");return; //不继续执行后面的代码}//猜的(用户输入的)转为intint number = Integer.parseInt(guessNumber);//判断if(number < 1 || number > 100){JOptionPane.showMessageDialog(jf, "请输入1-100的整数!");jTextField.setText("");//清空文本框} else if(number > randomNumber){JOptionPane.showMessageDialog(jf, "猜大了!");jTextField.setText("");//清空文本框}else if(number <randomNumber ){JOptionPane.showMessageDialog(jf, "猜小了!");jTextField.setText("");//清空文本框}else {JOptionPane.showMessageDialog(jf, "恭喜你,猜对了!");}}});jf.setVisible(true);//设置显示窗体(一般写在最后)}
}

ShowDateTime 展示当前日期

public class ShowDateTime {public static void main(String[] args) {JFrame jf = new JFrame();jf.setSize(400, 300);jf.setTitle("手机日期和时间显示");//设置窗体标题jf.setLocationRelativeTo(null);//设置窗体位置在中央弹出jf.setDefaultCloseOperation(3);//设置窗体关闭停止程序jf.setAlwaysOnTop(true);//设置窗体置顶jf.setLayout(null);//取消默认布局//日期文本JLabel dateText = new JLabel("日期");dateText.setBounds(50,50,100,20);jf.add(dateText);/*获取日期的字符串*/SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日");String dataStr = dateFormat.format(new Date());//具体日期JLabel date = new JLabel(dataStr); //替换日期为动态获取的dataStrdate.setBounds(50,80,200,20);jf.add(date);//时间文本JLabel timeText = new JLabel("时间");timeText.setBounds(50,150,100,20);jf.add(timeText);/*获取日期的字符串*/SimpleDateFormat timeFormat = new SimpleDateFormat("HH:mm:ss");String timeStr = timeFormat.format(new Date());//具体时间JLabel time = new JLabel(timeStr);//替换时间为动态获取的timeStrtime.setBounds(50,180,200,20);jf.add(time);jf.setVisible(true);//设置显示窗体(一般写在最后)}
}

UserLogin 用户登录

public class UserLogin {public static void main(String[] args) {JFrame jf = new JFrame();jf.setSize(400, 300);jf.setTitle("用户登录");//设置窗体标题jf.setLocationRelativeTo(null);//设置窗体位置在中央弹出jf.setDefaultCloseOperation(3);//设置窗体关闭停止程序jf.setAlwaysOnTop(true);//设置窗体置顶jf.setLayout(null);//取消默认布局//用户名文本框JLabel usernameJLabel = new JLabel("用户名");usernameJLabel.setBounds(50, 50, 50, 20);jf.add(usernameJLabel);//密码文本框JLabel passwordJLabel = new JLabel("用户名");passwordJLabel.setBounds(50, 100, 50, 20);jf.add(passwordJLabel);//用户名输入框JTextField usernameJTextField = new JTextField();usernameJTextField.setBounds(150, 50, 180, 20);jf.add(usernameJTextField);//密码输入框JPasswordField passwordJTextField = new JPasswordField();passwordJTextField.setBounds(150, 100, 180, 20);jf.add(passwordJTextField);//登录按钮JButton submitJButton = new JButton("登录");submitJButton.setBounds(50,200,280, 20);jf.add(submitJButton);/*1. 已知用户名和密码heima0011234562. 用户名和密码的长度都是6-12位3.点击登录按钮先判断输入的数据长度是否合法再判断是否登录成功*///定义用户名和密码String username = "heima001";String password = "123456";//给按钮添加点击事件submitJButton.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {//通过输入框,获取用户输入的数据String uname = usernameJTextField.getText();String psw = passwordJTextField.getText();//判断输入的数据长度是否合法if(uname.length() < 6 || uname.length() > 12){//System.out.println("用户名的长度是6-12位请重新输入!");//错误提示在窗体上弹出JOptionPane.showMessageDialog(jf,"用户名的长度是6-12位请重新输入!");//清空文本框usernameJTextField.setText("");return;//错误就停止方法}if(psw.length() < 6 || psw.length() > 12){//System.out.println("密码的长度是6-12位请重新输入!");JOptionPane.showMessageDialog(jf,"密码的长度是6-12位请重新输入!");//清空文本框passwordJTextField.setText("");return;//错误就停止方法}//如果合法,再判断是否登录成功if(uname.equals(username) && psw.equals(password)){//System.out.println("登陆成功!");JOptionPane.showMessageDialog(jf,"登陆成功!");//清空文本框usernameJTextField.setText("");passwordJTextField.setText("");}else {//System.out.println("用户名或密码错误,登陆失败");JOptionPane.showMessageDialog(jf,"用户名或密码错误,登陆失败");}}});jf.setVisible(true);//设置显示窗体(一般写在最后)}
}