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

沙海

720
文章

2
评论

2018年10月5日16:53:21

评论 142 16243字阅读54分8秒

第一章.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);
    }
}