01.第一章：Object类_概述
1).java.lang.Object(类)：它是Java中所有引用类型(包括类库中的类、数组、我们自定义的类)的父类。
2).任何的类都隐式的直接或间接继承自Object类。
3).包括我们自己定义的类，都隐式的继承自Object，也从Object继承了一些方法：
1).public boolean equals(Object obj)
2).public String toString()
…
这也就意味着，任何类都有：equals和toString方法。
02.第一章：Object类_toString方法
1).Object类的toString()方法的默认实现：全名限定的类名@十六进制的地址值
2).这样的信息对于我们来说，没有任何意义；
3).我们通常用它来：打印(封装)这个对象中所有的属性的值；
所以我们需要“重写此方法”
4).怎么重写：IDEA下：alt + insert -> t -> 回车
示例代码：
public class Student {
private String name;
private int age;
private String sex;
public Student() {
}
public Student(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
}
}
测试类：
public static void main(String[] args) {
Student stu = new Student();
stu.setName("刘德华");
stu.setAge(18);
stu.setSex("男");
//打印这个学员信息：
System.out.println(stu);//隐式的就是调用(stu.toString())
Student stu2 = new Student();
stu2.setName("杨幂");
stu2.setAge(17);
stu2.setSex("女");
System.out.println(stu2);
}
03.第一章：Object类_equals方法
1).equals()方法是用来：比较"两个对象"中所有的属性值是否完全相同；
2).equals()方法的默认实现：比较两个对象的“地址”是否完全相同：
类似于：
stu == stu2(判断的是两个对象的地址是否相同:这不是我们想要的)
所以，我们需要重写此方法：
3).怎么重写：alt + insert -> e -> 回车(会同时生成equals()和hashCode())
4).示例代码：
public class Student {
....
..
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name) &&
Objects.equals(sex, student.sex);
}
}
测试代码：
public static void main(String[] args) {
Student stu = new Student();
stu.setName("刘德华");
stu.setAge(18);
stu.setSex("男");
//打印这个学员信息：
System.out.println(stu);//隐式的就是调用(stu.toString())
Student stu2 = new Student();
stu2.setName("刘德华");
stu2.setAge(17);
stu2.setSex("男");
System.out.println(stu2);
System.out.println("判断两个对象：" + stu.equals(stu2));//true
}
04.第一章：Object类_Objects类
1).java.util.Objects(类):它是Object的工具类，它里面包含了一些对“对象”操作的一些方法。
2).学习的方法：
public static boolean equals(Object a,Object b)：比较a和b两个对象的属性值是否完全相同。
3).Objects的equals()的作用同Object的equals()一样，但比Object的equals()更安全，
可以避免空指针异常；
public static void main(String[] args) {
Student stu = null;
Student stu2 = new Student();
stu2.setName("刘德华");
stu2.setAge(18);
stu2.setSex("男");
System.out.println(Objects.equals(stu,stu2));//false--避免了空指针异常
}
05.第二章：日期和时间类_Date类
1).java.util.Date(类):它可以处理日期和时间，精确到毫秒；
2).构造方法：
A).Date():使用当前系统时间构造一个Date对象；
B).Date(long date):使用一个"毫秒值"构造一个Date对象；
3).示例代码：
public static void main(String[] args) {
Date date = new Date();
System.out.println(date);
Date date2 = new Date(1000 * 10);//Date起点：1970-01-01 00:00:00
System.out.println(date2);
}
).常用方法：
1).public long getTime():获取当前Date对象从1970-01-01 00时以来的毫秒值
2).public void setTime(long date):设置一个新的毫秒值。
5).示例代码：
public static void main(String[] args) {
Date date = new Date();
System.out.println(date.getTime());//从1970-01-01 00时到现在的毫秒值
date.setTime(1000 * 5);
}
06.第二章：日期和时间类_DateFormat类_将Date转换为String
1).java.text.DateFormat(抽象类):作用：对日期进行格式化操作的工具类。
它是一个抽象类，不能直接用。我们可以用它的子类：SimpleDateFormat
2).SimpleDateFormat类的构造方法：
A).SimpleDateFormat(String pattern)
3).将Date对象转换为String使用的方法：
1).public String format(Date date):
4).示例代码：
public static void main(String[] args) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH小时mm分ss秒");
//1.将一个Date对象转换为我们指定格式的字符串
Date date = new Date();
String strDate = sdf.format(date);
System.out.println(strDate);
}
07.第二章：日期和时间类_DateFormat类_将String转换为Date
1).将String转换为Date对象：
1).public Date parse(String source)
2).示例代码：
public static void main(String[] args) throws ParseException {
2.将一个String转换为Date
String str = "1997-02-12";
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
Date date2 = sdf2.parse(str);
System.out.println(date2);
}
08.第二章：日期和时间类_练习1_转换字符串的日期格式
1).将字符串“2019-02-12”转换为字符串“2019年02月12日”：
2).示例代码：
public static void main(String[] args) throws ParseException {
//将字符串"2019-02-12"转换为字符串"2019年02月12日"：
String str1 = “2019-02-12”;
//1.将字符串转换为Date
SimpleDateFormat sdf1 = new SimpleDateFormat(“yyyy-MM-dd”);
Date date1 = sdf1.parse(str1);
//2.将Date转换为目标格式的字符串
SimpleDateFormat sdf2 = new SimpleDateFormat(“yyyy年MM月dd日”);
String str2 = sdf2.format(date1);
System.out.println(“结果：” + str2);
}
09.第二章：日期和时间类_练习2_计算来到世界多少天
1).思路：
2).代码实现：
public static void main(String[] args) throws ParseException {
//计算来到世界多少天
Scanner sc = new Scanner(System.in);
System.out.println(“请输入你的出生日期(格式：yyyy-MM-dd)”);
String strDate = sc.next();//1995-05-12
//1.将String转换为Date
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date1 = sdf.parse(strDate);
long t1 = date1.getTime();
Date date2 = new Date();
long t2 = date2.getTime();
//3.计算差值
System.out.println(“你来到世界一共：” + ((t2 - t1) / 1000 / 3600 / 24) + " 天");
}
==========================================================
10.第二章：日期和时间类_Calendar（日历）类
1).java.util.Calendar(抽象类):它是一个“日历”处理类，可以进行日期运算；它是一个抽象类，
我们可以直接使用它的子类：GregorianCalendar
2).GregorianCalendar的构造方法：
1).GregorianCalendar():使用当前系统时间构造。
3).成员方法：
1).public int get(int field):获取某个字段的值；
示例：
public static void main(String[] args) {
GregorianCalendar gc = new GregorianCalendar();
System.out.println(gc);
//1.获取日期值
int year = gc.get(Calendar.YEAR);
int month = gc.get(Calendar.MONTH);
int day = gc.get(Calendar.DAY_OF_MONTH);
int hour = gc.get(Calendar.HOUR_OF_DAY);
int minute = gc.get(Calendar.MINUTE);
int second = gc.get(Calendar.SECOND);
int week = gc.get(Calendar.DAY_OF_WEEK);//返回值：1--7的值（代表：星期日，星期一，星期二...，星期六)
System.out.println(year + "年" + (month + 1) + "月" + day + "日 " + hour + ":" + minute + ":" + second);
System.out.println(getWeek(week));
}
public static String getWeek(int week) {//week : 1--7
//制作一个表
String[] arr = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};//索引：0--6
return arr[week - 1];
}
2).public void set(int field,int value):设置某个字段为value值。
示例：
public static void main(String[] args) {
//set()方法
GregorianCalendar gc2 = new GregorianCalendar();
gc2.set(Calendar.YEAR, 1995);
gc2.set(Calendar.MONTH,5 - 1);
gc2.set(Calendar.DAY_OF_MONTH, 12);
int w = gc2.get(Calendar.DAY_OF_WEEK);
System.out.println("班长出生那天是：" + getWeek(w));
}
public static String getWeek(int week) {//week : 1--7
//制作一个表
String[] arr = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};//索引：0--6
return arr[week - 1];
}
3).public void add(int field,int value):将field字段加value值
示例：
public static void main(String[] args) {
//add()方法
GregorianCalendar gc3 = new GregorianCalendar();
//100天后
gc3.add(Calendar.DAY_OF_MONTH, -100)
int year = gc3.get(Calendar.YEAR);
int month = gc3.get(Calendar.MONTH);
int day = gc3.get(Calendar.DAY_OF_MONTH);
int hour = gc3.get(Calendar.HOUR_OF_DAY);
int minute = gc3.get(Calendar.MINUTE);
int second = gc3.get(Calendar.SECOND);
int week = gc3.get(Calendar.DAY_OF_WEEK);//返回值：1--7的值（代表：星期日，星期一，星期二...，星期六)
System.out.println(year + "年" + (month + 1) + "月" + day + "日 " + hour + ":" + minute + ":" + second);
System.out.println(getWeek(week));
}
public static String getWeek(int week) {//week : 1--7
//制作一个表
String[] arr = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};//索引：0--6
return arr[week - 1];
}
11.第三章：System类_作用及常用方法
1).java.lang.System(类):它内部包含了一些实用的工具性方法。
2).内部全部都是一些“静态方法”：
3).常用方法：
1).public static void arraycopy(Object src,//原数组
int srcPos,//原数组的起始位置
Object dest,//目标数组
int destPos,//目标数组的起始位置
int length)//复制的长度
示例代码：复制一个数组到另一个数组，
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4};
int[] arr2 = new int[arr1.length];
System.arraycopy(arr1, 0, arr2, 0, arr1.len
gth);
for (int i = 0; i < arr2.length; i++) {
System.out.println(arr2[i]);
}
}
示例代码：复制一个数组中的一部分到本数组的其它位置
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4};
System.out.println("----------------------------------");
//将arr1数组中的1，替换4，最终：{1,2,3,1}
System.arraycopy(arr1,0,arr1,3,1);
for (int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);
}
}
2).
public static long currentTimeMillis():获取系统时间的毫秒值：
class Demo{
String s = "";
long strat = System.currentTimeMillis();
for(int i = 0;i < 1000000; i++){
s += i;
}
long end = System.currentTimeMillis();
System.out.println("代码执行了：" + (end - start) + " 毫秒");
}
12.第四章：StringBuilder类_回顾String类的不可变性
String str = "Hello";
str = str + "World";//整个过程产生了3个String对象空间，效率比较低；
System.out.println(str);//HelloWorld
--------------------------------------------------------
下面的整个过程全部使用String的+符号，整体效率很低：
int[] arr = {1,2,3,4};
String str = "[";
for(int i = 0;i < arr.length ; i++){
str += arr[i];
if(i < arr.length - 1){
str += ", ";
}else{
str += "]";
}
}
System.out.println(str);//[1, 2, 3, 4]
13.第四章：StringBuilder类_概述及常用方法
1).java.lang.StringBuilder(类):它是String的工具类，做字符串拼接的。
可以避免使用String时产生大量的垃圾。StringBuilder是可变的。
2).构造方法：
1).StringBuilder():内部会产生16个空的字符位置，等待添加字符；
3).示例代码：
示例代码：
public static void main(String[] args) {
StringBuilder builder = new StringBuilder("Hello");
builder.append("World");
builder.append(10);
builder.append(3.14);
builder.append(true);
//也可以写成--方法链
builder.append("World").append(10).append(3.14).append(true);
System.out.println(builder.toString());
}
14.第四章：String类和StringBuilder类的区别小结
1).String类：代表的“字符串”，内部是不可变的；
2).StringBuilder类：代表的“字符串的构建器”，内部是可变的；
当做“字符串拼接时”要考虑使用StringBuilder类。
String转换为StringBuilder:
String str = “Hello”;
StringBuilder bul = new StingBuilder(str);
StringBuilder转换为String:
StringBuilder bld = new StringBuilder(“Hello”);
String s = bld.toString();
--------------------------------------------------------------------------------
15.第五章：包装类_概念
1).Java中有四类八种的基本类型，它们都有对应的包装类：
基本类型 包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
2).包装类的作用：里面都包含了一些对此种类型数据操作的一些实用的工具性方法。
16.第五章：包装类_常见应用
1).将字符串转换为某种基本类型的数据：
String age = “24”;
int intAge = Integer.parseInt(age);
String height = “1.75”;
double doubleHeight = Double.parseDouble(height);
任何的包装类都有：parseXXX(String s):
2).将某种基本类型的数据转换为字符串：
int age = 24;
String s = age + “”;
比较优雅的方式：
String s = Integer.toString(age);
17.第五章：包装类_装箱和拆箱
1).JDK5以前，要使用包装类：
Integer intObj1 = new Integer(10);//Integer对象中存储了一个10
//取出这个10
int v = intObj1.intValue();
v++;
2).JDK5以后，要使用包装类：
Integer intObj2 = 10;//自动装箱–内部：Integer intObj2 = Integer.valueOf(10);
int v = intObj2;//自动拆箱–内部：int v = intObj2.intValue();
自动装箱：将基本类型自动转换为“包装类型”
自动拆箱：将“包装类型”转换为“基本类型”
3).意义：有了自动装箱和自动拆箱，可以将“包装类”和“基本类型”混合使用。
class Student{
Double score;
Boolean marry ;
}
Student stu = new Student();
System.out.println(stu.score);//null
System.our.println(stu.marry);//null
================================================================================
学习目标总结：
01.能够说出Object类的toString和equals方法的作用
1).toString():打印所有的属性值；(重写)
2).equals():比较两个对象的所有属性值是否完全相同；(重写)
02.能够使用SimpleDateFormat完成字符串和日期的相互转换
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//将Date转换为String
String str = sdf.format(date);
//将String转换为Date
String s = "2019-02-12";
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
Date d = sdf2.parse(s);
03.能够使用System类获取当前毫秒时刻值
System.currentTimeMillis();
04.能够说出使用StringBuilder类可以解决的问题
字符串拼接
05.能够使用StringBuilder进行字符串拼接操作
StringBuilder bld = new StringBuilder();
bld.append(“hello”).append(“World”).append(10);
System.out.println(bld.toString());
06.能够说出8种基本类型对应的包装类名称
Byte
Short
Integer
Long
Float
Double
Charactor
Boolean
07.能够说出自动装箱、 自动拆箱的概念
自动装箱：Integer v = 10;//将基本类型转换为包装类型
自动拆箱：int i = v;//将包装类型自动转换为基本类型
08.能够将字符串转换为对应的基本类型
String age = "24";
int intAge = Integer.parseInt(age);
String height = "1.80";
double h = Double.parseDouble(height);