Java进阶第一天

1、Object类

1.1 Object类的toString方法

public class Demo01ObjectToString {
　　public static void main(String[] args) {
　　　　Person p = new Person(“张三”, 19);
　　　　String s = p.toString();
　　　　//直接打印对象名其实就是调用对象的toString方法，结果就是对象名存储的地址值
　　　　System.out.println(s);//cn.itcast.day01.demo01.Person@7c30a502
　　　　System.out.println§;//cn.itcast.day01.demo01.Person@7c30a502
　
　　　　//看一个类有没有重写toString方法，就打印该类对象名，没重写则输出地址值
　　　　Random r = new Random();
　　　　System.out.println®;//java.util.Random@38082d64 没重写

Scanner sc = new Scanner(System.in);
　　　　System.out.println(sc); //打印的不是地址值，Scanner重写了toString方法
　 　
　　　　ArrayList list = new ArrayList<>();
　　　　list.add(1);
　　　　list.add(2);
　　　　list.add(3);
　　　　System.out.println(list);//[1, 2, 3] 重写
　　}
}

1.2 Object类的equals方法

Object中的equals方法：
　　基本数据类型比较二者的值
　　引用数据类型比较二者的地址
public class Demo02ObjectEquals {
　　public static void main(String[] args) {
　　　　Person p1 = new Person(“张三”, 30);
　　　　Person p2 = new Person(“李四”, 20);
　　　　boolean b1 = p1.equals(p2);//比较p1和p2这两个对象的地址，false
　　　　System.out.println(b1);
　　　　p1 = p2;//将p2存储的地址值赋给p1
　　　　boolean b2 = p1.equals(p2);//true
　　　　System.out.println(b2);
　　}
}

1.3 重写Object类的toString方法和equals方法

在idea中直接右键生成代码即可
public class Person {
　　private String name;
　　private int age;
　　
　　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 Person(String name, int age) {
　　　　this.name = name;
　　　　this.age = age;
　　}
　
　　public Person() {
　　}

//重写toString方法
　　@Override
　　public String toString() {
　　　　return “Person{” +
　　　　　　　“name=’” + name + ‘’’ +
　　　　　　　“, age=” + age +
　　　　　　　‘}’;
　　}
　
　　@Override
　　public boolean equals(Object o) {
　　　　if (this == o) return true;
　　　　//getClass() != o.getClass() 采用反射机制，判断o向上转型为Object之前是否为Person
　　　　if (o == null || getClass() != o.getClass()) return false;
　　　　//将new的Person对象当作方法参数时被向上转型为了Object类，为了比较原来的Person的内容，需要将其先向下转型还原为Person类
　　　　Person person = (Person) o;
　　　　return age == person.age &&
　　　　　　　Objects.equals(name, person.name);
　　}
}

1.4 Objects类

Objects是一个工具类，包含许多静态方法，可以直接用类名.方法调用
public class Demo03Objects {
　　public static void main(String[] args) {
　　　　String s1 = null;
　　　　String s2 = “sss”;
　
　　　　//调用String类的equals方法，因为s1是null，会出现空指针异常,因为null不能调用方法
　　　　//boolean b1 = s1.equals(s2);
　　　　//System.out.println(b1);

boolean b2 = Objects.equals(s1, s2);
　　　　System.out.println(b2);//Objects的equals方法可以容忍空指针
　　}
}

2、Date类

１、Date类通常使用两种构造方法：
　　无参构造 表示当前时间的毫秒值
　　有参构造 传入一个long类型的毫秒值
２、Date对象通过getTime()方法可以得到当前对象所代表时间的毫秒值，也可以通过System.currentTimeMillis()方法获得
public class Demo01Date {
　　public static void main(String[] args) {
　
　　//空参数构造，当前时间 CST 中国标准时间
　　Date d1 = new Date();
　　System.out.println(d1);//Thu Sep 10 16:34:14 CST 2020
　　//参数为毫秒的构造，参数是long类型，0L表示格林威治时间1970.1.1 00:00:00，中国是1970.1.1 08:00:00
　　Date d2 = new Date(0L);
　　System.out.println(d2);//Thu Jan 01 08:00:00 CST 1970
　　//输出当前时间代表的毫秒值，也就是从格林威治时间1970.1.1 00:00:00到现在经过了多少毫秒
　　System.out.println(System.currentTimeMillis());
　　//也是输出当前时间代表的毫秒值
　　Date d3 = new Date();//1599727362206 long类型
　　System.out.println(d3.getTime());//1599727362206
　　}
}

DateFormat类

１、DateFormat是一个抽象类，要通过其子类SimpleDateFormat使用，构造方法为传入参数日期模式
２、SimpleDateFormat的对象常用两个方法
　　format 将一个Date对象转换为一个字符串
　　parse 将一个字符串转换为一个Date对象 parse方法需要抛出异常，可以传递异常也可以自己处理，悬停在编译红线上点击即可
public class Demo02DateFormat {
　　public static void main(String[] args) throws ParseException {
　　　　SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日，HH时mm分ss秒”);
　　　　Date d = new Date();
　　　　System.out.println(sdf.format(d));//2020年09月10日，17时03分10秒
　　　　System.out.println(sdf.parse(“2020年09月10日，17时03分10秒”));
　　　　calculateBirthDays();
　　}
　
　　public static void calculateBirthDays() throws ParseException {
　　　　Scanner sc = new Scanner(System.in);
　　　　System.out.print(“请输入你的出生日期：格式（yyyy年MM月dd日）”);
　　　　String birthDate = sc.next();
　　　　Date d1 = new Date();
　　　　long nowTime = d1.getTime();
　　　　Date d2 = new Date();
　　　　SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日”);
　　　　d2 = sdf.parse(birthDate);
　　　　long birthTime = d2.getTime();
　　　　long countTime = nowTime - birthTime;
　　　　long countDays = countTime / 1000 / 60 / 60 / 24;
　　　　System.out.println(“从你出生到现在，一共过去了” + countDays + “天”);
　　}
}

３、Calendar类

１、Calendar是一个抽象类，提供了很多操作日历字段（YEAR MONTH DAY_OF_MONTH HOUR）的方法
无法直接创建对象使用，需要通过一个静态方法getInstance获取其子类GregorianCalendar的对象
２、常用成员方法：
　　int get(int field);//field是日历类的字段，可以使用类中的静态成员变量获取
　　YEAR=1 MONTH=2 DATE=5 DAY_OF_MONTH=5 HOUR=10 MINUTE=12 SECOND=13
　　void set(int field, int value);
　　abstract void add(int field, int amount);
　　Date getTime();//将日历对象转换为日期对象
public class Demo01Calendar {
　　public static void main(String[] args) {
　　　　Calendar ca = Calendar.getInstance();//父类引用指向子类对象，多态　
　　　　System.out.println(ca);
　　　　//java.util.GregorianCalendar[time=1599737291158,areFieldsSet=true… 重写了toString方法
　　
　　　　//get方法
　　　　int year = ca.get(Calendar.YEAR);//相当于获取field[Calendar.YEAR]的值，其中下标Calendar.YEAR是一个final变量，不会改变
　　　　int month = ca.get(Calendar.MONTH);
　　　　System.out.println(year);//2020
　　　　System.out.println(month);//8对应9月 西方的月份是0-11
　
　　　　//set方法，单独设置
　　　　ca.set(Calendar.YEAR, 9999);
　　　　ca.set(Calendar.MONTH, 9);
　　　　//同时设置
　　　　ca.set(1997, 3, 29);
　　　　year = ca.get(Calendar.YEAR);
　　　　month = ca.get(Calendar.MONTH);
　　　　System.out.println(year);
　　　　System.out.println(month);
　
　　　　//add方法
　　　　ca.add(Calendar.YEAR, 20);//1997.3+20.-6=2016.9
　　　　ca.add(Calendar.MONTH, -6);
　　　　year = ca.get(Calendar.YEAR);
　　　　month = ca.get(Calendar.MONTH);
　　　　System.out.println(year);
　　　　System.out.println(month);
　
　　　　//getTime方法
　　　　Date d = ca.getTime();
　　　　System.out.println(d);//Sat Oct 29 20:18:40 CST 2016
　　}
}

４、System类

System类常用方法：
　　long currentTimeMillis();//返回毫秒为单位的当前时间
　　void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
　　复制数组，src是原数组，dest是目标数组，srcPos是原数组复制的起始位置，destPos是目标数组复制的起始位置
public class Dem01System {
　　public static void main(String[] args) {
　　　　//countTime();
　　　　arrayCopy();
　　　　String s = “sdf”;
　　　　s = “aaa”;
　　　　System.out.println(s);
　　}
　　public static void countTime() {
　　　　long startTime = System.currentTimeMillis();
　　　　for (int i = 1; i <= 9999; i++) {
　　　　　　System.out.println(i);
　　　　}
　　　　long endTime= System.currentTimeMillis();
　　　　long countTime = endTime - startTime;
　　　　System.out.println(“打印9999一共需要” + countTime + “ms”);
　　}
　　public static void arrayCopy() {
　　　　int[] src = {1, 2, 3, 4, 5};
　　　　int[] dest = {6, 7, 8, 9, 10};
　　　　System.out.println(Arrays.toString(src));
　　　　System.out.println(Arrays.toString(dest));
　　　　System.arraycopy(src, 0, dest, 0, 3);
　　　　System.out.println(Arrays.toString(src));
　　　　System.out.println(Arrays.toString(dest));
　　}
}

５、StringBuilder类

字符串缓冲区类
StringBuilder类常用的方法
　　StringBuilder append(任意类型的数据);
　　StringBuilder reverse();反转缓冲区内容
　　StringBuilder对象与String对象互相转换
　　String -> StringBuilder 使用StringBuilder的构造方法StringBuilder(String s)
　　StringBuilder -> String 使用StringBuilder的toString方法
public class Demo01StringBuilder {
　　public static void main(String[] args) {
　　　　//无参构造
　　　　StringBuilder b1 = new StringBuilder();
　　　　System.out.println(b1);
　　　　//有参构造，传入一个字符串
　　　　StringBuilder b2 = new StringBuilder(“asd”);
　　　　System.out.println(b2);//打印了asd 说明重写了toString方法
　　　　StringBuilder b3 = b2.append(“zxc”);
　　　　System.out.println(b3);//asdzxc
　　　　System.out.println(b2 == b3);//true 说明append返回的对象是当前调用方法的对象，没有创建新对象
　　　　//链式编程，方法的返回值是对象时，可以根据这个对象继续调用方法
　　　　b3.append(1).append(‘A’).append(“fgh”).append(“1.89”);
　　　　System.out.println(b3);//asdzxc1Afgh1.89
　　　　b3.reverse();
　　　　System.out.println(b3);
　
　　　　//创建字符串对象
　　　　String s1 = “hello”;
　　　　//将字符串对象转换为字符串缓冲区对象
　　　　StringBuilder b = new StringBuilder(s1);
　　　　//字符串缓冲区对象可以改变字符串内容,字符串对象不能改变内容
　　　　b.append(“world”);
　　　　//将改变内容后的字符串缓冲区对象转换为字符串对象
　　　　String s2 = b.toString();
　　　　System.out.println(b);
　　}
}

６、包装类　装箱与拆箱

包装类，使得可以使用基本数据类型所对应的包装类中定义好的方法操作基本数据类型
　　int Integer char Character byte Byte short Short
　　long Long float Float double Double boolean Boolean
装箱：将基本数据类型转换为包装类
构造方法
　　Integer(int value);
　　Integer(String s);//这里的参数字符串必须是int类型的字符串，比如"100"。否则会抛出异常，如"a"
静态方法
　　valueOf(int value);
　　valueOf(String s);
拆箱：取出包装类中的基本数据类型的数据
成员方法
　　int intValue();
public class Demo01Integer {
　　public static void main(String[] args) {
　　　　//构造方法装箱
　　　　Integer int1 = new Integer(1);
　　　　Integer int2 = new Integer(“2”);
　　　　//Integer int5 = new Integer(“1.6”);//数据格式化异常NumberFormatException
　　　　//Integer int5 = new Integer(“a”);//数据格式化异常NumberFormatException
　　　　//静态方法装箱
　　　　Integer int3 = Integer.valueOf(3);
　　　　Integer int4 = Integer.valueOf(“4”);
　　　　System.out.println(int4);//4 说明重写了toString方法
　
　　　　//拆箱
　　　　int a3 = int3.intValue();
　　　　System.out.println(a3);
　
　　　　//自动装箱
　　　　Integer int5 = 5;
　　　　//自动拆箱，包装类对象无法参与运算，但可以自动转换为基本类型进行运算
　　　　int5 += 2;
　　　　System.out.println(int5);
　
　　　　//自动装箱和拆箱例子
　　　　ArrayList list = new ArrayList<>();
　　　　list.add(1);//相当于list.add(new Integer(1));
　　　　list.get(0);//相当于list.get(0).intValue();
　　}
}

基本数据类型与String之间的转换

基本类型 -> String
1、基本类型对象+空字符串""
2、基本类型的包装类中的toString静态方法 static String toString(int i)
3、String类中的静态方法static String valueOf(int i)
String -> 基本类型
基本类型的包装类中的parseInt方法(8钟基本类型的包装类只有Character没有该方法)
public class Demo02IntegetToString {
　　public static void main(String[] args) {
　　　　//基本类型 -> String
　　　　String s1= 5 + “”;
　　　　System.out.println(s1 + 100);//5100
　　　　String s2 = Integer.toString(6);
　　　　System.out.println(s2 + 200);//6200
　　　　String s3 = String.valueOf(7);
　　　　System.out.println(s3 + 300);//7300
　
　　　　//String -> 基本类型
　　　　int i = Integer.parseInt(“100”);//传入的字符串需要是包含int数字否则会报错
　　　　//int i1 = Integer.parseInt(“a”);//数字格式化异常NumberFormatException
　　　　System.out.println(i + 200);//300
　　}
}