学习记录——进阶版01

@学习记录

开始学习Java

遵从同学的指导，从Java se开始学习

黑马的JavaSE零基础入门

第一章 Object类

1.1 概述

1.2 toString方法

方法摘要
覆盖重写

day12-02 Object的toString方法

package day12.Demo01;

public class Demo01ToString {
    
    

    public static void main(String[] args) {
    
    
        // Person类默认继承了Object类，所以可以使用Object类中的toString方法
        // 返回该对象的字符串表示
        Person one = new Person("张三", 18);
        String s = one.toString();
        System.out.println(s);

        // 直接打印对象的名字，就是调用对象的toString
        System.out.println(one);

        // 看一个类是否重写了toString，直接打印这个类的对象即可
        // 如果没有，则打印的是对象的地址值
    }
}

package day12.Demo01;

public class Person {
    
    

    private String name;
    private int age;

    public Person() {
    
    
    }

    public Person(String name, int age) {
    
    
        this.name = name;
        this.age = age;
    }

    /*
    直接打印对象的地址值没有意义，需要重写Object类中的toString方法
    打印对象的属性（name, age）
     */

    @Override
    public String toString() {
    
    
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

1.3 equals方法

方法摘要
默认地址值比较
对象内容比较

day12-03 Object的equals方法

package day12.Demo01;

public class Demo02Equals {
    
    

    public static void main(String[] args) {
    
    
        /*
        Person类默认继承了Object类，所以可以使用Object类中的equals方法
        用于比较对象是否相等
        equals方法源码：
            public boolean equals(Object obj) {
                return (this == obj)
            }

        参数：
            Object obj：可以传递任意的对象
            == 比较运算符，返回的是一个布尔值 true / false
            基本数据类型：比较的是值
            引用数据类型：比较的是两个对象的地址值
         */

        Person one = new Person("张三", 20);
        Person two = new Person("李四", 22);
        boolean b = one.equals(two);
        System.out.println(b);


    }
}

day12-04 重写Object的equals方法

package day12.Demo01;

public class Demo02Equals {
    
    

    public static void main(String[] args) {
    
    
        /*
        Person类默认继承了Object类，所以可以使用Object类中的equals方法
        用于比较对象是否相等
        equals方法源码：
            public boolean equals(Object obj) {
                return (this == obj)
            }

        参数：
            Object obj：可以传递任意的对象
            == 比较运算符，返回的是一个布尔值 true / false
            基本数据类型：比较的是值
            引用数据类型：比较的是两个对象的地址值
         */

        Person one = new Person("张三", 20);
        Person two = new Person("张三", 20);

        //

        boolean b = one.equals(one);
        System.out.println(b);


    }
}

package day12.Demo01;

import java.util.Objects;

public class Person {
    
    

    private String name;
    private int age;

    public Person() {
    
    
    }

    public Person(String name, int age) {
    
    
        this.name = name;
        this.age = age;
    }

    /*
    直接打印对象的地址值没有意义，需要重写Object类中的toString方法
    打印对象的属性（name, age）
     */

    @Override
    public String toString() {
    
    
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    /*
    Object类的equals方法，默认比较的是两个对象的地址值，没有意义
    所以要重写equals方法，比较两个对象的属性（name,age）
    问题：
        隐含着一个多态
        多态的弊端：无法使用子类特有的内容（属性和方法）
        Object obj = two;
    解决：可以使用向下转型（强转），把obj类型转换为Person
     */

//    @Override
//    public boolean equals(Object obj) {
    
    
//        // 增加一个判断，传递的参数obj如果是this本身，直接返回true，提高程序效率
//        if (obj == this) {
    
    
//            return true;
//        }
//
//        // 增加一个判断，传递的参数obj如果是null，直接返回false,提高程序的效率
//        if (obj == null) {
    
    
//            return false;
//        }
//
//        // 增加一个判断，防止类型转换异常
//        if (obj instanceof Person) {
    
    
//            // 使用向下转型，把obj类型转换为Person
//            Person person = (Person) obj;
//            // 比较两个对象的属性，一个是this,一个是person
//            boolean b = this.name.equals(person.name) && this.age == age;
//            return b;
//        }
//
//        return false;
//
//    }


    @Override
    public boolean equals(Object o) {
    
    
        if (this == o) return true;
        // getClass() != o.getClass() 使用反射技术，判断o是否是Person类型
        // 等效于obj instanceof Person
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
    
    
        return Objects.hash(name, 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;
    }
}

1.4 Objects类

day12-05 Objects的equals方法

容忍空指针异常

package day12.Demo01;

import java.util.Objects;

public class Demo03Objects {
    
    
    public static void main(String[] args) {
    
    
//        String s1 = "abc";
        String s1 = null;
        String s2 = "abc";
//        boolean equals = s1.equals(s2); // 空指针异常
//        System.out.println(equals);

        /*
        Objects类的equals方法：对两个对象进行比较，防止空指针异常
        public static boolean equals (Object a, Object b) {
            return (a == b0 || （a != null && a.equals(b)）);
        }
        */

        boolean equals1 = Objects.equals(s1, s2);
        System.out.println(equals1);
    }
}

第二章 日期时间类

2.1 Date类

概述
常用方法

day12-06 毫秒值的概念和作用

package day12.Demo02;

/*
Date类，表示日期和时间的类
类Date表示特定的瞬间，精确到毫秒
毫秒：千分之一秒
特定的时间：一个时间点

毫秒值的作用：可以对时间和日期进行计算
    将日期转换为毫秒进行计算，计算完毕，再把毫秒转换为日期

把日期转换为毫秒：
    计算当前日期到时间原点（英国格林威治时间）之前一共经历了多少毫秒
注意：中国属于东八区，会把时间增加8个小时

把毫秒转换为日期：
    1 天 = 86400000 毫秒


 */
public class Demo01Date {
    
    

    public static void main(String[] args) {
    
    
        System.out.println(System.currentTimeMillis()); // 获取当前系统时间一共到原点经历了多少毫秒，结果是L类型


    }
}

day12-07 Date类的构造方法和成员方法

package day12.Demo02;

import java.util.Date;

public class Demo02Date {
    
    

    public static void main(String[] args) {
    
    
        demo01();
        demo02();
        demo03();
    }

    /*
    Date类的空参数构造方法：
    Date() 获取当前系统的日期和时间
     */
    private static void demo01() {
    
    
        Date date = new Date();
        System.out.println(date); // 打印的不是地址是，Date类重写了toString方法
    }

    /*
    Date类的带参数构造方法：
    Date(long date) 传递毫秒值，把毫秒值转换为Date日期
     */
    private static void demo02() {
    
    
        Date date = new Date(0L);
        System.out.println(date);
    }

    /*
    long getTime() 把日期转换为毫秒，相当于System.currentTimeMillis()方法
     */
    private static void demo03() {
    
    
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time);
    }



}

2.2 DateFormat类

构造方法
格式规则
常用方法：
　format方法
　parse方法

day12-08 DateFormat类&SimpleDateFormat类介绍

day12-09 DateFormat类的format方法和parse方法

package day12.Demo03;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
java.text.DateFormat 时间/日期格式化子类的抽象类
作用：
    格式化（也就是日期 -> 文本）、解析（文本 -> 日期）
成员方法：
    String format(Date date) 按照指定的模式，把Date日期格式化为符合模式的字符串
    Date parse(String source) 把符合模式的字符串，解析为Date日期
DateFormat类是一个抽象类，无法直接创建对象使用，可以使用DateFormat的子类

java.text.SimpleDateFormat extends DateFormat
构造方法：
    SimpleDateFormat(String pattern)
    用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat
参数：
    String pattern 传递指定的模式
模式：区分大小写的
        y       年
        M       月
        d       日
        H       时
        m       分
        s       秒
    写对应的模式，把模式替换为对应的日期和时间
    注意：模式中的字母不能更改，连接模式的符号可以改变


 */
public class DateFormat {
    
    

    public static void main(String[] args) throws ParseException {
    
    
        demo01();
        System.out.println("=========================");
        demo02();
    }


    /*
    使用DateFormat类中的方法format,把日期格式化为文本
    使用步骤：
        1.创建SimpleDateFormat对象，构造方法中传递指定的模式
        2.调用SimpleDateFormat对象中的format方法，按照构造方法中指定的模式，把Date日期格式化为符合模式的字符串（文本）
     */
    private static void demo01() {
    
    
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        Date date = new Date();
        String d = sdf.format(date);
        System.out.println(date);
        System.out.println(d);

    }

    /*
    使用DateFormat类中的方法方法parse,把文本解析为日期
    使用步骤：
        1.创建SimpleDateFormat对象，构造方法中传递指定的模式
        2.调用SimpleDateFormat对象中的方法parse，把符合构造方法中模式的字符串解析为Date日期
    注意：parse方法声明了一个异常叫ParseException，如果字符串和构造方法的模式不一样，那么程序就会抛出此异常
    处理方法：要么throws继续抛出这个异常，要么try catch自己处理
     */
    private static void demo02() throws ParseException {
    
    
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        Date date = sdf.parse("2021年01月07日 21时32分17秒");
        System.out.println(date);
    }

}

2.3 练习

day12-10 计算一个人的出生天数

package day12.Demo03;

import org.w3c.dom.ls.LSOutput;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/*
练习：
使用日期时间相关的API，计算出一个人已经出生了多少天

分析：
1.使用Scanner类中的方法next获取出生日期
2.使用DateFormat类中的方法parse，把字符串的出生日期解析为Date格式的出生日期
3.把Date格式的出生日期转换为毫秒值，
4.获取当前的日期，转换为毫秒值
5.使用当前日期的毫秒值-出生日期的毫秒值
6.把毫秒值转换为天

 */
public class Demo02Test {
    
    
    public static void main(String[] args) throws ParseException {
    
    
        // 使用Scanner类中的方法next获取出生日期
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的出生日期，格式为yyyy-MM-dd：");
        String birthday = scanner.next();

        // 使用DateFormat类中的方法parse，把字符串的出生日期解析为Date格式的出生日期
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
        Date birthdayDate = sdf1.parse(birthday);

        // 把Date格式的出生日期转换为毫秒值
        long birthdayDateTime = birthdayDate.getTime();

        // 获取当前的日期，转换为毫秒值
        Date date = new Date();
        long dateTime = date.getTime();

        // 使用当前日期的毫秒值-出生日期的毫秒值
        long time = dateTime - birthdayDateTime;

        // 把毫秒值转换为天
        System.out.println(time / 1000 / 60 / 60 / 24);


    }

}

2.4 Calendar类

概念
获取方式
常用方法：
　get/set方法
　add方法
　getTime方法

day12-11 Calendar类的介绍，获取对象的方式

package day12.Demo04;

import java.util.Calendar;

/*
java.util.Calendar类；日历类
Calendar类是一个抽象类，里面提供了很多操作日历字段的方法（YEAR、MOUTH、DAY_OF_MONTH、HOUR）
Calendar类无法直接创建对象使用，里面有一个静态方法getInstance()，该方法返回了Calendar类的子类对象
getInstance()使用默认时区和语言环境获得一个日历
 */
public class Demo01Calendar {
    
    
    public static void main(String[] args) {
    
    
        Calendar instance = Calendar.getInstance();
        System.out.println(instance);

    }
}

day12-12 Calendar类的常用成员方法

package day12.Demo04;

import java.util.Calendar;
import java.util.Date;

/*
Calendar类常用的成员方法：
public int get(int field); 返回给定日历字段的值
public void set(int field, int value); 将给定的日历字段设置为给定值
public abstract void add(int field, int amount); 根据日历的规则，为给定的日历字段添加或减去指定的时间量
public Date getTime(); 返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象

成员方法的参数：
int field 日历类的字段，可以使用Calendar类的静态成员变量获取
    public static final int YEAR = 1;
    public static final int MONTH = 2;
    public static final int DATE = 5;
    public static final int DAY_OF_MONTH = 5;
    public static final int HOUR = 10;
    public static final int MINUTE = 12;
    public static final int SECOND = 13;




 */
public class Demo02Calendar {
    
    
    public static void main(String[] args) {
    
    
        demo01();
        System.out.println("==================");

        demo02();
        System.out.println("==================");

        demo03();
        System.out.println("==================");

        demo04();

    }



    /*
    public int get(int field); 返回给定日历字段的值
    参数：传递指定的日历字段
    返回值：日历字段代表的具体的值
     */
    private static void demo01() {
    
    
        // 使用getInstance()方法获取Calendar对象
        Calendar calendar = Calendar.getInstance();
        int year = calendar.get(Calendar.YEAR);
        System.out.println(year);
        System.out.println("======================");

        int month = calendar.get(Calendar.MONTH);
        System.out.println(month); // 西方的月份0-11，东方的月份1-12
        System.out.println("=======================");

        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
        int date = calendar.get(Calendar.DATE);
        System.out.println(date);
    }


    /*
    public void set(int field, int value); 将给定的日历字段设置为给定值
    参数：
    int field 传递指定的日历字段
    int value 给指定字段设置的值
     */
    private static void demo02() {
    
    
        // 使用getInstance()方法获取Calendar对象
        Calendar calendar = Calendar.getInstance();

        // 设置年为2000
        calendar.set(Calendar.YEAR, 2000);
        // 设置月为8
        calendar.set(Calendar.MONTH, 8);
        // 设置天为20
        calendar.set(Calendar.DAY_OF_MONTH, 20);
        System.out.println(calendar.get(Calendar.YEAR));
        System.out.println(calendar.get(Calendar.MONTH));
        System.out.println(calendar.get(Calendar.DATE));
        System.out.println("===========================");


        // 同时设置年月日，可以使用set的重载方法
        calendar.set(2020, 10, 30);
        System.out.println(calendar.get(Calendar.YEAR));
        System.out.println(calendar.get(Calendar.MONTH));
        System.out.println(calendar.get(Calendar.DATE));
    }


    /*
    public abstract void add(int field, int amount); 根据日历的规则，为给定的日历字段添加或减去指定的时间量
    把指定的字段增加/减少指定的值
    参数：
    int field 传递指定的日历字段
    int amount 增加/减少指定的值
        正数：增加
        负数：减少
     */
    private static void demo03() {
    
    
        // 使用getInstance()方法获取Calendar对象
        Calendar calendar = Calendar.getInstance();

        // 把年增加2
        calendar.add(Calendar.YEAR, 2);
        System.out.println(calendar.get(Calendar.YEAR));
        // 把月减少3
        calendar.add(Calendar.MONTH, -3);
        System.out.println(calendar.get(Calendar.MONTH));
    }


    /*
    public Date getTime(); 返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象
    b把日历对象转换为日期对象
     */
    private static void demo04() {
    
    
        // 使用getInstance()方法获取Calendar对象
        Calendar calendar = Calendar.getInstance();

        Date date = calendar.getTime();
        System.out.println(date);

    }


}

第三章 System类

3.1 currentTimeMIllis方法与练习

3.2 arraycopy方法与练习

day12-13 System类的常用成员方法

package day12.Demo05;

/*
java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：
    public static long currentTimeMillis(); 返回以毫秒为单位的当前时间
    public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length); 将数组中指定的数据拷贝到另一个数组中
 */

import java.util.Arrays;

public class Demo01System {
    
    
    public static void main(String[] args) {
    
    
//        demo01();
//        System.out.println("===================");

        demo02();
    }


    /*
    public static long currentTimeMillis(); 返回以毫秒为单位的当前时间
    用来测试程序的效果
    练习：验证for循环打印数字1-9999所需要的时间（毫秒）
     */
    private static void demo01() {
    
    
        // 程序执行前获取一次毫秒值
        long start = System.currentTimeMillis();
        // 执行for循环
        for (int i = 0; i < 9999; i++) {
    
    
            System.out.println(i + 1);
        }
        // 程序执行完毕，再获取一次毫秒值
        long end = System.currentTimeMillis();
        // 计算得到程序耗时
        long time = end - start;
        System.out.println("程序所需时间为：" + time);
    }


    /*
    public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length); 将数组中指定的数据拷贝到另一个数组中
    参数：
        Object src 源数组
        int srcPos 源数组中的起始位置（起始索引）
        Object dest 目标数组
        int destPos 目标数组中的起始位置
        int length 要复制的数组元素的数量
    练习：
        将src数组中的前3个元素复制到dest数组的前3个位置上
        复制元素前:scr数组元素[1，2，3，4，5]，dest数组元素[6，7，8，9，10]
        复制元素后scr数组元素[1，2，3，4，5].dest数组元素[1，2，3，9，10]
     */
    private static void demo02() {
    
    
        // 定义源数组
        int[] src = {
    
    1, 2, 3, 4, 5};
        // 定义目标数组
        int[] dest = {
    
    6, 7, 8, 9, 10};
        System.out.println("复制前的数组：" + Arrays.toString(dest));
        // 复制数组
        System.arraycopy(src, 0, dest, 0, 3);
        System.out.println("复制后的数组：" + Arrays.toString(dest));
    }

}

第四章 StringBuilder类(字符串缓冲区，可以提高操作效率)

4.1 字符串拼接问题

4.2 StringBuilder概述

day12-14 StringBuilder的原理

4.3 构造方法

package day12.Demo06;

/*
java,lang.StringBuilder类：字符串缓冲区，可以提高字符串的效率
构造方法：
StringBuilder() 构造一个不带任何字符的字符串生成器，其初始容量为16个字符
StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容
 */
public class Demo01StringBuilder {
    
    
    public static void main(String[] args) {
    
    
        // 空参数构造法
        StringBuilder bu1 = new StringBuilder();
        System.out.println(bu1);

        StringBuilder bu2 = new StringBuilder("abc");
        System.out.println(bu2);
    }
}

4.4 常用方法

append方法
　toString方法

day12-15 StringBuilder的构造方法和append方法

package day12.Demo06;

/*
StringBuilder的常用方法：
    public StringBuilder append(...); 添加任意类型数据的字符串形式，并返回当前对象自身
 */
public class Demo02StringBuilder {
    
    
    public static void main(String[] args) {
    
    
        // 创建StringBuilder对象
        StringBuilder builder = new StringBuilder();
        // 使用append方法往StringBuilder中添加数据
        // append方法返回的是this,调用方法的对象是builder，即this == builder
        StringBuilder builder1 = builder.append("abc"); // 把builder的地址值赋给了builder1
        System.out.println(builder);
        System.out.println(builder1);
        System.out.println(builder == builder1); // 比较的是地址值，true
        System.out.println("================");

        // 使用append方法无需接收返回值
        builder.append("cde");
        builder.append(8);
        builder.append('木');
        builder.append('@');
        builder.append(false);
        System.out.println(builder);
        System.out.println("======================");

        // 链式编程：方法返回值是一个对象，可以继续调用方法
        builder.append("gvjfi").append('你').append(true);
        System.out.println(builder);
    }
}

day12-16 StringBuilder的toString方法

package day12.Demo06;

/*
StringBuilder和String可以相互转化：
    StringBuilder --> String 可以使用StringBuilder的带参构造方法
        StringBuilder(String str); 构造一个字符串生成器，并初始化为指定的字符串内容
    String --> StringBuilder 可以使用StringBuilder的toString方法
        public String toString(); 将当前StringBuilder对象转换为String对象

 */
public class Demo03StringBuilder {
    
    
    public static void main(String[] args) {
    
    
        // StringBuilder --> String
        String str = "hello";
        StringBuilder stringBuilder = new StringBuilder(str);
        // 往StringBuilder中添加数据
        stringBuilder.append("world");
        System.out.println(stringBuilder);

        // String --> StringBuilder
        String s = stringBuilder.toString();
        System.out.println(s);

    }

}

第五章 包装类

5.1 概述

day12-17 包装类的概念

5.2 装箱与拆箱

day12-18 包装类_装箱与拆箱

package day12.Demo07;

/*
装箱：把基本类型的数据包装到包装类中（基本数据类型 --> 包装类）
1.构造方法
    Integer(int value) 构造一个新分配的Integer对象，它表示指定的int值
    Integer(String s) 构造一个新分配的Integer对象，它表示String参数所指示的int值
    注意：传递的字符串，必须是基本类型的字符串，否则回抛出异常，例如："100" 正确；"a" 抛异常
2.静态方法
    static Integer valueOf(int i) 返回一个表示指定int值的Integer实例
    static Integer valueIf(String s) 返回保存指定的String值的Integer对象

拆箱：在包装类中取出基本类型的数据（包装类 --> 基本类型数据）
1.成员方法
    int intValue() 以int类型返回该Integer值
 */

public class Demo01Integer {
    
    
    public static void main(String[] args) {
    
    
        // 装箱，构造方法
        Integer integer = new Integer(20); // 方法上有横线，说明方法过时了
        System.out.println(integer);

        Integer integer1 = new Integer("30");
        System.out.println(integer1);

        // 静态方法
        Integer integer2 = Integer.valueOf(40);
        System.out.println(integer2);

        Integer integer3 = Integer.valueOf("50");
        System.out.println(integer3);

        // 拆箱，成员方法
        int value = integer.intValue();
        System.out.println(value);
    }
}

day12-19 包装类_自动装箱与自动拆箱

package day12.Demo07;

/*
自动装箱和自动拆箱：基本类型数据和包装类之间可以自动相互转换
JDK1.5之后出现的新特性
 */

import java.util.ArrayList;

public class Demo02Integer {
    
    
    public static void main(String[] args) {
    
    
        // 自动装箱：直接把int类型的整数赋值包装类
        Integer integer = 1; // 相当于Integer integer = new Integer(1);

        // 自动拆箱：integer是包装类，无法直接参与运算，可以自动转换为基本数据类型，再进行计算
        integer = integer + 2; // 相当于 integer = integer.intValue() + 2;结果的赋值是有一个自动装箱

        ArrayList<Integer> list = new ArrayList<>();
        list.add(30); // 自动装箱，list.add(Integer.valueOf(30)); list.add(new Integer(30));
        int i = list.get(0); // 自动拆箱,list.get(0).intValue();
    }
}

5.3 基本类型与字符串之间的转换

基本类型转换为String

day12-20 包装类_基本类型与字符串类型之间的转换

package day12.Demo07;

/*
基本数据类型与字符串类型之间的相互转换：
基本类型 --> 字符串
1.基本类型的值+"" 最简单的方法（工作中常用）
2.包装类的静态方法toString(参数)，不是Object类的toString() 重载
    static String toString(int i); 返回一个表示指定整数的String对象
3.String类的静态方法valueOf(参数)
    static String valueOf(int i); 返回int参数的字符串表示形式

字符串 --> 基本类型
使用包装类的静态方法parseXXX("字符串");
    Integer类：static int parseInt(String s)
    Double类：static double parseDouble(String s)
 */
public class Demo03Integer {
    
    
    public static void main(String[] args) {
    
    
        // 基本类型 --> 字符串
        int i = 100;
        String s = i + "";
        System.out.println(s + 200); // 字符串相加是字符串相连
        System.out.println("=================");

        String s1 = Integer.toString(200);
        System.out.println(s1 + 300);
        System.out.println("====================");

        String s2 = String.valueOf(300);
        System.out.println(s2 + 400);
        System.out.println("====================");

        // 字符串 --> 基本类型
        int i1 = Integer.parseInt(s1);
        System.out.println(i1);
    }
}