Java进阶学习1:【Object类、时间日期类、System类、StringBuilder、包装类】

第一章.Object

01. Object类的介绍

Object是所有类的父类，所有类都直接或者间接的继承自Object。

如果我们在一个类中没有使用extends继承其他类，那么这个类是默认继承自Object的。

02. Object的toString方法

/*
    在Object中，有一个方法叫做toString，可以将对象转成一个字符串。
    String toString()：返回对象的字符串表示形式。
    当通过一个对象调用toString方法时，会先看一下自己有没有这个方法，如果自己没有，那么就会向上找父类，    一直到Object。Object中的toString方法，是将对象转成地址值的字符串。
​
    当我们直接输出一个对象名时，内部会调用这个对象的toString方法， 这个对象的toString方法的内容是什    么，那么直接输出这个对象名的结果就是什么。
​
    一般来说，输出地址值没有什么意义。 如果想要调用toString方法后得到我们想要的内容，比如对象的属性，     那么我们可以在子类中重写toString。
 */
public class Demo02ObjectToString {
    public static void main(String[] args) {
        //创建一个Person对象
        Person p = new Person("小苍", 36);
        //调用该对象的toString方法。
        System.out.println(p.toString());//小苍-36
        //直接输出这个对象的对象名
        System.out.println(p); //小苍-36
    }
}
​
public class Person/*extends Object*/{
    //姓名
    private String name;
    //年龄
    private int age;
​
    //重写toString方法，使用快捷键一步到位： alt + insert
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    
    public Person() {
    }
​
    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}

03. Object中的equals方法

/*
    在Object中，有一个方法叫做equals，这个方法可以比较两个对象是否相同。
    boolean equals(Object obj)： 比较两个对象是否相同。
​
    当我们通过一个对象调用equals方法时，会先看一下自己有没有这个方法，如果自己没有，就会向上找父类，一    直到Object。
    Object中的equals是使用==比较对象的地址值。
​
    比较对象的地址值一般没有意义，如果我们要自己定义比较的规则（比如对象的属性完全相同就看成是同一个对    象）， 那么我们可以在子类中重写equals
 */
public class Demo03ObjectEquals {
    public static void main(String[] args) {
        //创建三个Person对象
        Person p1 = new Person("王宝强", 30);
        Person p2 = new Person("贾乃亮", 32);
        Person p3 = new Person("贾乃亮", 32);
        //输出对象使用==比较的结果
        System.out.println(p1 == p2); //false
        System.out.println(p2 == p3); //false
        System.out.println("============");
        System.out.println(p1.equals(p2));//false
        System.out.println(p2.equals(p3));//true
    }
}

public class Person/*extends Object*/{
    //姓名
    private String name;
    //年龄
    private int age;
​
    //alt + insert： 直接生成equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
​
        Person person = (Person) o;
​
        if (age != person.age) return false;
        return name != null ? name.equals(person.name) : person.name == null;
    }
​
    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
​
    //重写equals方法，定义自己的比较规则，对象的属性如果完全相同，那么就看成是同一个对象
    //要比较的两个对象，一个是参数obj， 另一个是调用者（使用this表示）
    /*
    @Override
    public boolean equals(Object obj) {
        //为了保证程序的健壮性，先加入非空判断。
        if(obj == null) {
            return false;
        }
        //判断参数obj是否是一个Person对象，如果不是Person，那么其实就不需要比较了。 如果是人，那么才需要比较。
        //使用instanceof进行判断，判断obj是否是一个Person
        if(obj instanceof Person) {
            //如果obj表示的是Person对象，那么就进行操作。
            //向下转型，将obj转型成Person
            Person p = (Person) obj;
            //对两个对象的姓名和年龄进行比较，如果完全相同，那么就表示两个对象是相同的对象，那么就返回true。
            return this.getName().equals(p.getName()) && this.getAge() == p.getAge();
        }
        //其他情况，直接返回false。
        return false;
    }
    */
​
    //重写toString方法，使用快捷键一步到位： alt + insert
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
​
    //重写toString方法。
    //ctrl + o：可以直接重写父类的任何方法
    /*
    @Override
    public String toString() {
        return name + "-" + age;
    }
    */
    public Person() {
    }
​
    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}

04. Objects的equals方法

/*
    在JDK7之后，多了一个类，叫做Objects。 他是一个操作对象的工具类。
    Objects有一个方法叫做equals，可以比较两个对象是否相同。
    static boolean equals(Object a, Object b)： 比较a对象和b对象是否相同。
​
    当我们调用Objects的equals方法比较两个对象时， 内部其实真正是调用的Object的equals进行的比较。
    如果想要通过属性比较两个对象是否相同，那么还需要重写equals方法。
 */
public class Demo04ObjectsEquals {
    public static void main(String[] args) {
        //创建两个Teacher对象
        Teacher t1 = new Teacher("小苍老师", 30);
        Teacher t2 = new Teacher("小苍老师", 30);
        //使用Objects的equals方法进行比较
        System.out.println(Objects.equals(t1, t2));//false
        System.out.println("===============");
        //Objects的equals和Object的equals的区别。
        Teacher t3 = null;
        Teacher t4 = null;
        //使用Object的equals进行比较。
        //通过null访问任何属性或方法都会引发空指针异常。
        //System.out.println(t3.equals(t4)); //NullPointerException
        //使用Objects的equals进行比较
        System.out.println(Objects.equals(t3, t4)); //true
    }
}

public class Teacher {
    private String name;
    private int age;
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
​
        Teacher teacher = (Teacher) o;
​
        if (age != teacher.age) return false;
        return name != null ? name.equals(teacher.name) : teacher.name == null;
    }
​
    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
​
    public Teacher() {
    }
​
    public Teacher(String name, int age) {
​
        this.name = name;
        this.age = 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;
    }
}

第二章.时间日期类

05. Date的介绍以及构造方法

/*
    在Java中，有一个类叫做Date(java.util.Date)， 这个类叫做日期类，
    但是Java中的Date类表示的是特定的时间瞬间， 精确到了毫秒。
​
    构造方法：
    Date()：使用空参构造方法创建的Date对象会以当前操作系统的时间构建一个Date。
    Date(long date)：参数要传递一个long类型的毫秒值。 表示从1970年1月1日 0点0分0秒开始过了多少毫秒。
    中国使用的是北京时间，北京时间是东八区，比标准时间快八个小时。 时间是从1970年1月1日 8点0分0秒开始的。
 */
public class Demo01Date {
    public static void main(String[] args) {
        //使用空参构造创建对象。表示的是当前操作系统的时间
        Date date = new Date();
        System.out.println(date);
        //使用有参构造创建Date对象，传递一个毫秒值
        Date date2 = new Date(0L);
        System.out.println(date2);
    }
}

06. Date的getTime方法

/*
    在Date类中，有一个方法叫做getTime，可以获取Date对象对应的毫秒值。
        long getTime()： 获取Date对象表示的毫秒并返回。
 */
public class Demo02Date {
    public static void main(String[] args) {
        //创建一个Date对象， 表示的是当前操作系统的时间
        Date date = new Date();
        //调用date对象的getTime方法，获取Date对象对应的毫秒值
        long millis = date.getTime();
        //输出
        System.out.println(millis);
    }
}

07. Date的setTime方法

/*
    在Date类中，有一个方法叫做setTime，可以设置Date对象的毫秒值。
    void setTime(long time)：设置Date对象表示的时间（毫秒值）。 调用此方法后，Date对象表示的时间会发生改变。
 */
public class Demo03Date {
    public static void main(String[] args) {
        //创建一个Date对象，表示当前操作系统的时间
        Date date = new Date();
        //调用date对象的setTime方法，重新设置时间
        date.setTime(0L); //把date对象表示的时间进行了改变。 因为参数是0，所以新的时间为从1970年（时间原点）开始过了0毫秒。
        //输出date对象
        System.out.println(date);
    }
}

08. DateFormat的format方法

/*
    如果想要把一个Date对象转成一个指定格式的字符串，那么可以使用DateFormat类去实现。
    DateFormat是一个抽象类，如果要用，需要使用子类SimpleDateFormat
​
    构造方法：
    SimpleDateFormat(String pattern)： 参数需要传递一个字符串类型的模式。
​
    举例：
        要转成的格式： 2019年03月22日 10时17分54秒
        对应的模式：   yyyy年MM月dd日 HH时mm分ss秒
        就是使用英语字母替换掉数字。
        y：年
        M：月
        d：日
        H：时
        m：分
        s：秒
​
    其他的方法：
    String format(Date date) ：将参数Date对象格式化为一个字符串。并把这个字符串返回。
​
    日期格式化的步骤：
        1. 创建一个Date对象。
        2. 创建一个SimpleDateFormat对象，在构造方法中给出指定的模式。
        3. 调用SimpleDateFormat对象的format方法，将Date对象转成一个字符串。
 */
public class Demo01DateFormat {
    public static void main(String[] args) {
        //创建一个Date对象
        Date date = new Date();
        //2. 创建一个SimpleDateFormat对象，在构造方法中给出指定的模式。
        //要转成的日期格式为：  2019年03月22日 10时17分54秒
        //SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        //要转成的日期格式为： 2019-03-22 10:17:54
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
​
        //3. 调用SimpleDateFormat对象的format方法，将Date对象转成一个字符串。
        String str = sdf.format(date);
        System.out.println("str:" + str);
    }
}

09.DateFormat的parse方法

/*
    如果要把一个字符串转成一个Date对象，那么我们可以使用SimpleDateFormat去完成。
    使用的方法：
    Date parse(String source)：将字符串转成（解析）一个Date对象并返回
​
    使用步骤：
        1. 定义一个字符串，表示时间。
        2. 创建一个SimpleDateFormat对象， 参数位置指定一个模式。
        3. 调用SimpleDateFormat的parse方法，将字符串转成一个Date对象。
​
    注意：
        1. 调用parse方法后会有一个红色波浪线的错误。 这个操作需要抛异常（以后讲解）。
           解决方式： 把光标移动到红色波浪线上面，然后按alt + 回车，选择第一个。
        2. SimpleDateFormat构造方法中传递的模式必须和要转换的字符串格式一致。否则会报错。
​
    小结：
        Date->String：格式化。 使用SimpleDateFormat的format方法去完成。
        String->Date：解析。 使用SimpleDateFormat的parse方法去完成。
 */
public class Demo02DateFormat {
    public static void main(String[] args) throws ParseException {
        //1. 定义一个字符串，表示时间。
        String str = "2019-03-22 10:27:13";
        //2. 创建一个SimpleDateFormat对象， 参数位置指定一个模式。
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //3. 调用SimpleDateFormat的parse方法，将字符串转成一个Date对象。
        Date date = sdf.parse(str);
        //4. 输出date对象
        System.out.println(date);
    }
}

10. Calendar的getInstance方法

/*
    在Date类中有很多方法都已经过时了，原因是因为在Calendar中有了更好的方法可以代替他们。
​
    Calendar叫做日历类。 和Date一样，Calendar也可以表示精确的时间瞬间（精确到毫秒）
​
    Calendar是一个抽象类， 如果要用，需要使用它的子类。
    因为地区敏感性， Calendar的子类对象不能由我们自己去new，而是要调用Calendar的静态方法            getInstance进行获取。
​
    Calendar中的方法：
    static Calendar getInstance()： 获取一个Calendar子类对象， 然后把这个子类对象返回了。
​
    获取Calendar对象的方式：
    之前都是通过new的方式获取一个对象，而此时是通过Calendar的静态方法getInstance获取的Calendar对象（真正是Calendar子类对象）
 */
public class Demo01Calendar {
    public static void main(String[] args) {
        //通过Calendar的静态方法获取一个日历对象
        Calendar c = Calendar.getInstance();
        //进行输出
        System.out.println(c);
    }
}

11. Calendar中的get方法

/*
    在Calendar中，有一个方法叫做get，可以获取到指定字段的值：
    int get(int field)： 参数field表示要获取哪个字段的值。
    举例：
        get(年)： 获取年这个字段的值。
        get(月)： 获取月这个字段的值
        get(日)： 获取日这个字段的值。
​
    get方法参数是int类型， 所以我们要使用数字表示对应的字段。
    如果在get方法中传递数字的话，会大大的影响我们程序的可阅读性。
    我们可以使用Calendar中的静态常量代替这些数字， 这些常量的常量名具有见名之意的效果， 每一个常量都表    示一个数字。
    注意：
        Calendar中的月份是从0开始的范围是（0-11）。 Calendar中的月份比现实生活要少1
 */
public class Demo02Calendar {
    public static void main(String[] args) {
        //获取一个日历对象
        Calendar c = Calendar.getInstance();
        //获取年的值进行输出
        int year = c.get(Calendar.YEAR);
        System.out.println(year);
        //获取月的值进行输出
        int month = c.get(Calendar.MONTH) + 1;
        System.out.println(month);
        //获取日的值进行输出
        int day = c.get(Calendar.DATE);
        System.out.println(day); 
    }
}

12. Calendar中的set方法

/*
    在Calendar中还有一个方法叫做set，可以给指定字段设置值。
    void set(int field, int value)： 可以给指定字段设置值。
            参数field：表示要给哪个字段设置值。
            参数value：表示要设置成什么值。
 */
public class Demo03Calendar {
    public static void main(String[] args) {
        //获取一个日历对象
        Calendar c = Calendar.getInstance();
        //输出这个日历对象的年月日的值
        System.out.println(c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) + "-" + c.get(Calendar.DATE));
        //使用set方法，给日历对象重新设置值
        c.set(Calendar.YEAR, 2012);
        c.set(Calendar.MONTH, 4); //表示的是现实生活中的5月
        c.set(Calendar.DATE, 11);
        //重写输出这个日历对象的年月日的值。
        System.out.println(c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) + "-" + c.get(Calendar.DATE));
    }
}

13. Calendar中的add方法

/*
    在Calendar中，还有一个方法叫做add，可以对指定字段的值进行计算。
    void add(int field, int amount)： 可以对指定字段的值进行计算。
            参数field： 表示要对哪个字段进行计算。
            参数amount： 表示如何计算。 如果该参数是正数，那么就是加上该值。
                                    如果该参数是负数，那么就是减去该值。
 */
public class Demo04Calendar {
    public static void main(String[] args) {
        //获取一个日历对象
        Calendar c = Calendar.getInstance();
        //输出该日历对象的年月日的值。
        System.out.println(c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) +         "-" + c.get(Calendar.DATE));
        //使用add方法，对年进行计算， 加上2年
        //c.add(Calendar.YEAR, 2);
        //使用add方法对月进行计算
        c.add(Calendar.MONTH, 10);
        //重新输出
        System.out.println(c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) +         "-" + c.get(Calendar.DATE));​
    }
}

14. Calendar中的getTime方法

/*
    在Calendar中还有一个方法叫做getTime，可以获取到Calendar对应的Date对象
    Date getTime(): 获取Calendar对应的Date对象
 */
public class Demo05Calendar {
    public static void main(String[] args) {
        //获取一个日历对象
        Calendar c = Calendar.getInstance();
        //将这个日历对象转成一个Date对象。
        Date date = c.getTime();
        //输出date的值
        System.out.println(date);
    }
}
​

第三章. System类

15. System的currentTimeMillis的使用

/*
    System叫做系统类，里面有很多方法都和系统有关。
​
    常见方法：
    static long currentTimeMillis()：获取当前操作系统的时间（以毫秒值表示的）
 */
public class Demo01System {
    public static void main(String[] args) {
        //调用System的currentTimeMillis获取当前的时间
        long millis = System.currentTimeMillis();
        System.out.println(millis);
    }
}

练习：

/*
    要求： 统计输出1000次HelloWorld使用的时间。
​
    步骤：
        1. 在输出之前记录当前的时间。
        2. 输出1000次HelloWorld
        3. 在输出之后记录当前的时间。
        4. 让这两个时间相减
 */
public class Demo02SystemTest {
    public static void main(String[] args) {
        //1. 在输出之前记录当前的时间。
        long start = System.currentTimeMillis();
        //2. 输出1000次HelloWorld
        for(int i = 0; i < 1000; i++) {
            System.out.println("HelloWorld");
        }
        //3. 在输出之后记录当前的时间。
        long end = System.currentTimeMillis();
        //4. 让这两个时间相减
        System.out.println(end - start);
    }
}

16. System的arraycopy方法

/*
    在System中有一个方法可以对数组进行复制，这个方法叫做arraycopy
    static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)： 对数组进行复制的方法。
            参数src：表示源数组。
            参数srcPos： 表示源数组的起始位置。
            参数dest： 表示目标数组。
            参数destPos： 表示目标数组的起始位置。
            参数length： 表示要复制几个元素。
    要求：
    将src数组中前3个元素，复制到dest数组的前3个位置上
    复制元素前：src数组元素[1,2,3,4,5]，dest数组元素[6,7,8,9,10]
    复制元素后：src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]
​
    arraycopy是系统级别的，性能非常高。
 */
public class Demo03System {
    public static void main(String[] args) {
        //定义两个数组
        int[] src = {1,2,3,4,5};
        int[] dest = {6,7,8,9,10};
        //进行复制，将src数组的前三个元素，复制到dest数组的前3个位置上。
        System.arraycopy(src, 0, dest, 0, 3);//将src中的内容复制到dest。 从src中索引为0的位置开始复制，从dest数组索引为0的位置开始放， 一共复制3个。
        //输出两个数组的结果
        System.out.println("src:" + Arrays.toString(src));
        System.out.println("dest:" + Arrays.toString(dest));
    }
}

第四章. StringBuilder

17. String拼接产生的问题

/*
    字符串拼接的问题
​
    因为字符串具有不变性，所以每次对字符串进行拼接，都会产生新的字符串。这样既耗时又浪费空间。
​
    StringBuilder可以变的， 如果使用StringBuilder进行拼接，效率会更高。
 */
public class Demo01String {
    public static void main(String[] args) {
        //定义一个字符串
        String s = "Hello";
        s += "World";
        System.out.println(s);
    }
}

18. StringBuilder的介绍

StringBuilder是一个可变的字符序列。 我们可以把它看成一个可变的字符串。
StringBuilder的本质和String一样，都是由一个字符数组组成的，在使用字符数组保存数据。
​
String和StringBuilder的区别：
        String是不可以改变的。
        StringBuilder是可以改变的。

19. StringBuilder的构造方法

/*
    StringBuilder的构造方法：
    StringBuilder(): 空参构造。 使用这个构造方法创建的StringBuilder对象，里面不会保存任何内容
    StringBuilder(String str)： 会根据参数字符串构建一个StringBuilder对象
 */
public class Demo02StringBuilder {
    public static void main(String[] args) {
        //使用空参数构造方法创建对象
        //使用空参构造创建的StringBuilder对象中没有任何内容。 相当于 String str = ""
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:" + sb);
        //使用有参构造创建一个StringBuilder对象
        StringBuilder newSb = new StringBuilder("你好，你今天早上吃了吗");
        System.out.println("newSb:" + newSb);//你好，你今天早上吃了吗
    }
}

20. StringBuilder的常见方法

/*
    StringBuilder中的常见方法：
    StringBuilder append(任何类型)： 对任何类型的数据进行拼接。返回值表示调用者对象本身。
    String toString()： 将StringBuilder转成一个String并返回。
 */
public class Demo03StringBuilder {
    public static void main(String[] args) {
        //创建一个StringBuilder对象
        StringBuilder sb = new StringBuilder();
        //StringBuilder newSb = sb.append("你好");
        //输出
        //System.out.println("sb:" + sb);
        //System.out.println("newSb:" + newSb);
​
        //拼接任何类型的数据
        /*
        sb.append("你好");
        sb.append(10);
        sb.append(3.14);
        sb.append(true);
        sb.append('a');
        */
        //链式编程。
        sb.append("你好").append(10).append(3.14);
​
        //进行输出
        System.out.println("sb:" + sb); //你好103.14
        //String toString()： 将StringBuilder转成一个String并返回
        String str = sb.toString();
        System.out.println("str:" + str);//你好103.14
    }
}

第五章. 包装类

21. 包装类的介绍

每一个基本类型都有其对应的引用类型（包装类）
​
基本类型            引用类型（包装类）
byte                  Byte
short                Short
int                    Integer(特殊)
long                Long
float                Float
double            Double
boolean          Boolean
char                Character(特殊)
​
基本类型其实就是简单的数据，用法也非常简单，只能直接使用或运算，不能调用方法。
引用类型(包装类)可以创建对象， 这样的话他们不仅可以表示数据，也可以调用方法完成一些功能。
​
包装类的功能比其对应的基本类型的功能要强大。基本类型能做的，对应的包装类也能做。

22. 自动拆装箱

/*
    在JDK5的时候，出现了一个新特性，叫做自动拆装箱
    拆箱： 包装类转成对应的基本类型。
    装箱： 基本类型转成对应的包装类。
 */
public class Demo01Warp {
    public static void main(String[] args) {
        //自动装箱。 把int类型的10自动转成了Integer类型。
        Integer a = 10;
        //自动装箱。 把int类型的20自动转成了Integer类型。
        Integer b = 20;
        //会先把Integer类型的a和b自动拆箱为int类型，a和b相加求出来的结果是int类型。 然后又把这个int类型的结果自动装箱成了Integer。
        Integer sum = a + b;
        System.out.println(sum);
    }
}

23. 手动拆装箱

/*
    手动拆装箱
    手动装箱（int -> Integer）
    可以使用包装类（Integer）中的valueOf的方法
    static Integer valueOf(int i)：传递一个int类型的数据，返回一个Integer类型的结果。
​
    手动拆箱（Integer -> int）
    使用包装类（Integer）中的intvalue方法
    int intValue() ：将Integer的值转成int并返回。
 */
public class Demo02Warp {
    public static void main(String[] args) {
        //定义一个变量
        int num = 10;
        //把int类型的变量手动装箱为Integer类型
        Integer warpNum = Integer.valueOf(num);
        System.out.println(warpNum);
        System.out.println("===============");
        int basicNum = warpNum.intValue();
        System.out.println(basicNum);
    }
}

24. 基本类型和字符串的相互转换

/*
    基本类型和字符串的相互转换
    基本类型转字符串：
        1. 可以使用String的静态方法valueOf。 不推荐
        2. 可以使用包装类的toString方法。 不推荐。
        3. 直接在这个基本类型数据的后面加上""。 推荐
​
    字符串转基本类型：
        我们需要使用对应包装类的parseXXX方法（静态方法）。
        如果要把字符串转成int，那么我们可以使用Integer的parseInt方法。
        如果要把字符串转成double，那么我们使用Double的parseDouble方法。
        如果要把字符串转成long，那么我们可以使用Long的parseLong方法。
​
 */
public class Demo02Parse {
    public static void main(String[] args) {
        //定义一个数字
        int num = 10;
        //把num转成字符串
        //String numStr = String.valueOf(num);
        //String numStr = Integer.valueOf(num).toString();
        String numStr = num + "";
        System.out.println("numStr:" + numStr);
        System.out.println("=============");
        //定义一个字符串
        String str = "12345";
        int basicNum = Integer.parseInt(str);
        System.out.println("basicNum:" + basicNum);
    }
}