Java——Object

最新推荐文章于 2025-05-20 22:23:34 发布

Gao_xu_sheng

最新推荐文章于 2025-05-20 22:23:34 发布

阅读量1.3k

点赞数 28

文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/Gao_xu_sheng/article/details/136182546

版权

1.Object万类之祖

1.1 Object类型的概述

Object类是所有类型的顶层父类，所有类型的直接或者间接的父类；所有的类型中都含有Object类中的所有方法。
随意定义一个类型,不手动显式定义其父类，那么这个类的父类就是Object类
public Object() {

}
Object类的构造方法：Object()
- 可以自己创建对象
- 让子类访问,所有子类都会直接或者间接的访问到这个顶层父类的构造方法
- Object类在执行构造方法时，不去访问自己的父类，因为没有父类了

1.2 getClass()

返回当前对象的运行时类
- 目前记住其中Class类型中有一个getName，可以返回当前类型的全类名
示例

public class Demo {
    public static void main(String[] args) {
        Demo demo = new Demo();
        System.out.println(demo.getClass().getName());
    }
}

1.3 hashCode()

根据对象的情况，生成的一个整数，就是哈希码值。生成数字的方法就是hashCode方法，它是一个特征值。
示例：

public class Demo {
    public static void main(String[] args) {
        Demo demo = new Demo();
        System.out.println(demo.hashCode());

        demo = new Demo();
        System.out.println(demo.hashCode());
    }
}

1.4 toString方法

返回当前对象的字符串表示
对象返回一个地址值的字符串，没有什么意义
最终操作：不需要手动重写，可以直接使用快捷键生成：Alt+Insert
使用打印语句打印一个对象，其实打印的就是这个对象的toString内容

1.5 equals

用于比较两个对象是否相等的方法，比较的就是“调用者”和“参数”这两个对象

boolean equals(Object obj)

在Object类型中，是比较两个对象的地址值是否相同。

实际生活中，比较两个对象的内存地址，没有什么意义。因此在自定义的子类中，都要重写这个方法。
- 按照自定义的方式比较两个对象是否相同
重写原则：
- 一般比较两个对象中的所有属性，是否全部相同
- <比如两个对象的name值相同，那么两个对象就相同>
代码实例

public class Simple01 {
    public static void main(String[] args) {
        Cat cat1 = new Cat("咪咪");
        Cat cat2 = new Cat("咪咪");
        boolean bool = cat1.equals(cat2);
        System.out.println(bool);
        // 表示获取全类名 包 +类名
        System.out.println(cat1.getClass());
    }
}

class Cat {
    private String name;

    public String getName() {
        return name;
    }

    public Cat(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Cat cat = (Cat) o;
        return this.getName().equals(cat.getName());
    }
}

1.6 ==和equals方法的区别

相同点
- ==和equals都是用于比较数据是否相等的方式
不同点：
- 比较内容的不同：
  - ==可以比较任意数据类型，既可以比较基本数据类型，也可以比较引用数据类型
  - equals方法只能比较引用数据类型
- 比较规则不同：
  - ==在比较基本类型的时候，比较的是数据的值；比较引用类型时，比较的是地址值
  - equals方法在重写之前，比较的是两个对象的地址值；在重写之后，比较的属性值也就是类里面的属性值的大小。

2.内部类

2.1内部类的概述

定义在内部的类，就是内部类。可以定义在类的内部,可以定义在方法的内部。
根据定义的位置不同，可以分为：

成员内部类
- 普通的成员内部类
- 私有的成员内部类
- 静态的成员内部类
局部内部类
匿名内部类

2.2普通的成员内部类

定义在成员位置上的类，就是成员内部类
定义格式：
class 内部类类名 {
内部类成员
}
成员内部类的说明：
- 内部类可以直接访问外部类的所有成员，包括私有成员
- 外部类访问内部类的成员，必须先创建内部类的对象
- 在外部类以外，创建内部类的对象的格式：
  - 外部类名.内部类名内部类对象名 = new 外部类名().new 内部类名();
代码实例：

/**
 * 普通成员内部类
 */
public class Simple02 {
    public static void main(String[] args) {
       
        Body.Heart heart = new Body().new Heart();
        heart.show();
    }
}

//类嵌套类\
class Body {
    private double height = 1.74;

    class Heart {
        int beats = 90;

        public void show() {
            System.out.println("身高是" + height + ",心跳每分钟" + beats);
        }
    }
	 
}

2.3私有的成员内部类

也是一个成员内部类，在成员内部类前面加上一个private关键字
访问方式说明：
- 在外部类以外，不能直接访问外部类中的私有成员内部类
- 可以在外部类中，定义一个访问私有内部类的公有方法，让外界可以调用公有方法，间接的访问外部类中的私有成员内部类。
代码示例:

public class Simple02 {
    public static void main(String[] args) {
        Body body = new Body();
        body.test();
    }
}

//类嵌套类\
class Body {
    private double height = 1.79;

    private class Heart {
        int beats = 90;

        public void show() {
            System.out.println("身高是" + height + ",心跳每分钟" + beats);
        }
    }
    public void test() {
        Heart hh = new Heart();
        hh.show();
    }
}

2.4 静态的成员内部类

也是一个成员内部类，在成员内部类前面加上一个static关键字

访问特点：

静态内部类中的非静态成员，需要将所在的内部类对象创建出来之后，才能被调用。
静态内部类中的静态成员,可以通过外部类名.内部类名的方式直接访问，而不需要创建外部类的对象
总结：一个类是否需要创建对象，不取决于该类本身是否是静态，而取决于要访问的成员是否是静态
静态成员内部类的对象创建格式：
外部类名.内部类名内部类对象名 = new 外部类名.内部类名();
代码实例

public class Simple03 {
    public static void main(String[] args) {
        // 方式一：外部类名.内部类名 内部类对象名 = new 外部类名.内部类名();
        Body2.Liver liver = new Body2.Liver();
        liver.show();

        // 方式二：外部类名.内部类名的方式直接访问
        System.out.println(Body2.Liver.FUNC);

    }

}

class Body2 {
    private double weight = 180;

    static class Liver {
        String color = "black";
        static final String FUNC = "解毒";

        void show() {
            System.out.println("肝都变成" + color + "色了，少整点吧！");
        }
    }
}

2.5局部内部类

定义在方法中的内部类

说明：

问题：属于方法中的局部变量，外界都没有办法访问到
解决方式:在方法内部定义调用方式
代码示例：

public class Simple3 {
        public static void main(String[] args) {
                new Body2().methodTest();
        }
    }
    
    class Body2 {
        void methodTest () {
            class SeaFood {
                void eat () {
                    System.out.println("喝酒不能吃海鲜");
                }
    
            }
            new SeaFood().eat();
        }
    
}

2.6 匿名内部类【常用】

没有名字的内部类
匿名内部类的使用前提：
- 匿名类：继承一个类
- 匿名类：实现一个接口
格式：
new 父类类名或者接口名() {
父类方法的重写或者是接口内容的实现
}
本质：创建了一个类的子类对象、接口的实现类对象
示例代码

public class Simple04 {
    public static void main(String[] args) {
        // 父 new 子
        Games games = new MyGames();
        games.play("LOL");
        // 匿名内部类
        new Games() {
            @Override
            public void play(String name) {
                System.out.println("会玩" + name);
            }
        }.play("王者荣耀");

        // 拉姆达表达式
        Games games1 = (name) -> System.out.println("会玩" + name);
        games1.play("三国杀");

    }
}

interface Games {
    void play(String name);
}

class MyGames implements Games {
    @Override
    public void play(String name) {
        System.out.println("会玩" + name);
    }
}

3.String

3.1概述

String就是字符串类型，属于java.lang包，不需要导包
所有的字符串常量"Hello World","abc"都属于String类型的对象
字符串字面值属于常量，存储在方法区的常量池中。
String类型是一个常量，在创建之后就无法更改（是一个不可变的字符序列）。
不可变的原因是String类型只提供了构造方法，没有提供set方法，因此只能在创建对象的时候，初始化成员变量，将来对象创建完成之后，无法通过方法来修改。
代码示例:

public class Simple05 {
    public static void main(String[] args) {
        String str2 = "abc";
        System.out.println(str2);//abc
        str2 = "xyz";
        System.out.println(str2);//xyz
    }
}

3.2 String类型的构造方法

String()：创建一个空字符串
String(String original)：创建参数字符串的一个副本（字符串是在常量池中，构造方法创建的字符串是在堆内存中）
String(byte[] arr)：将一个字节数组转成一个字符串,将我们不认识的字节数组，转成了我们认识的字符串，过程叫做【解码】查询的是当前平台默认的编码表
String(byte[] arr, int offset, int length)：将字节数组的一部分转成字符串
String(char[] arr)：将字符数组转成字符串
- 既不是编码，也不是解码，只不过是把字符串成了串
String(char[] arr, int offset, int length)：将字符数组的一部分转成字符串
代码示例：

public class Simple06 {

    public static void main(String[] args) {
        //test1_空参构造();
        //test2_原始字符串转换();
        //test3_字节数组转字符串();
        test4_字符数组转成字符串();
    }

    private static void test4_字符数组转成字符串() {
        char[] arr = {'a', 'b', 'X', 'Y'};
        String str1 = new String(arr);
        System.out.println(str1);//abXY  只是组成字符串而已

        //将字符 数组的一部分转成字符串，
        String str2 = new String(arr, 1, 2);
        System.out.println(str2);//bX
    }

    private static void test3_字节数组转字符串() {
       //将整个字节数组转成了字符串
        byte[] bytes = {99, 111, 100, 105, 110, 103, 45, 102, 117, 116, 117, 114, 101};
        String s = new String(bytes);
        System.out.println(s);
      
        /*将字节数组的一部分转成字符串，
         * 其中offset是从哪个索引开始，length表示要将多少个字节是转成字符串
         */
        byte[] arr = {99, 111, 100, 105, 110, 103, 45, 102, 117, 116, 117, 114, 101};
        String str2 = new String(arr, 1, 4);
        System.out.println(str2);
    }

    private static void test2_原始字符串转换() {
        String str = new String("abc");//这个对象，在堆内存中
        //"abc"常量，在方法区的常量池
        //new String("abc")这个对象，在堆内存中
        //str指向了堆内存中的对象
        System.out.println(str);//abc
        System.out.println(str == "abc");//false
        System.out.println("abc" == "abc");//true
    }

    public static void test1_空参构造() {
        String str = new String();
        System.out.println(str);
    }
}

3.3 String类型的判断功能

equals(Object obj)：判断调用者和参数对象描述的字符串内容是否相同
equalsIgnoreCase(String otherStr)：忽略大小写判断两个字符串内容是否相同
contains(String str)：判断调用者是否包含了str这个子串
startsWith(String prefix)：判断调用者是否以prefix开头
endsWith(String suffix)：判断调用者是否以suffix结尾
isEmpty()：判断调用者是否是空串
代码示例

public class Simple07 {

    public static void main(String[] args) {
//        test1_equals();
//        test2_equalsIgnoreCase();
//        test3_包含();
//        test4_5_判断开始和结束();
//        test6_判断为空();
    }
    private static void test6_判断为空() {
        String str = "abc";
        System.out.println(str.isEmpty());//false  字符串不为null
    }

    private static void test4_5_判断开始和结束() {
        String str = "abcdefg";
        System.out.println(str.startsWith("abc"));//true
        System.out.println(str.startsWith("abd"));//fasle
        System.out.println(str.startsWith("cde"));//false
        System.out.println(str.endsWith("efg"));//true
    }

    private static void test3_包含() {
        String str1 = "abcdefg";
        System.out.println(str1.contains("abc"));//true
        System.out.println(str1.contains("efg"));//true
        System.out.println(str1.contains("cde"));//true
        System.out.println(str1.contains("ace"));//false 必须是连续的
    }

    private static void test2_equalsIgnoreCase() {
        String str1 = "abcDEF";
        String str2 = "abcdef";
        System.out.println(str1.equals(str2));//false 字符串不相等
        //忽略大小写判断两个字符串内容是否相同
        System.out.println(str1.equalsIgnoreCase(str2));//true
    }

    private static void test1_equals() {
        String str1 = new String("abc");//在堆中
        String str2 = new String("abc");
        System.out.println(str1 == str2);//false 两个对象地址不一样 new了两次
        System.out.println(str1.equals(str2));//true  指向同一个对象
    }
}

3.4 String类型的获取功能

length()：获取字符串字符的个数
charAt(index)：返回调用者字符串中索引为index的字符（和length方法结合之后可以遍历字符串）
substring(int beginIndex)：获取一个字符串，内容是从当前字符串的beginIndex索引开始，一直到最后一个字符机截止
substring(int beginIndex, int endIndex)：获取一个指定索引范围的子串
- 注意事项：1、包含头不包含尾，返回的结果中，不包含endIndex索引指向的字符；2、所有的方法都无法修改字符串对象本身，一般都是返回一个新的字符串对象
indexOf家族：
- indexOf(int ch)：返回ch字符在当前调用者字符串中，第一次出现的索引
- indexOf(int ch, int fromIndex)：从fromIndex索引开始寻找，找到ch字符在当前字符串中第一次出现的索引
- indexOf(String str)：返回的是str这个字符串在调用者字符串中第一次出现的索引
- indexOf(String str, int fromIndex)：从fromIndex索引开始寻找，找到str字符串在当前字符串中第一次出现的索引（注意：无论从哪个位置开始找，所有字符的索引都不会变化）
lastIndexOf家族：
- 和IndexOf基本一样，只不过是从后往前找，所有字符和字符串的索引也都不会发生变化
示例代码

public class Simple08 {

    public static void main(String[] args) {
        test1_length();
        test2_charAt();
        test3_字符串遍历();
        test4_获取子串();
        test5_indexOf();
        test6_lastIndexOf();
    }
    private static void test6_lastIndexOf() {
        String str = "abcdabcd";
        System.out.println(str.lastIndexOf('c'));
        System.out.println(str.lastIndexOf('c', 5));

        System.out.println(str.lastIndexOf("cd"));
        System.out.println(str.lastIndexOf("cd", 5));
    }

    private static void test5_indexOf() {
        String str = "abcdabcd";
        //返回第一个c出现的索引
        System.out.println(str.indexOf('c'));
        System.out.println(str.indexOf('c', 3));

        System.out.println(str.indexOf("cd"));//2
        System.out.println(str.indexOf("cd", 3));
    }

    private static void test4_获取子串() {
        String str = "abcdefg";
        String result = str.substring(3);
        //str本身不会变化，因为字符串对象是一个不可变的字符序列
        System.out.println(str);
        //substring可以返回一个新的字符串对象
        System.out.println(result);
        //通过两个参数的substring获取子串
        System.out.println(str.substring(2, 5));
    }

    private static void test3_字符串遍历() {
        String str = "abcdefg";
        //遍历字符串
        for (int i = 0; i < str.length(); i++) {
            System.out.println(str.charAt(i));
        }
    }

    private static void test2_charAt() {
        String str = "abcdefg";
        char c = str.charAt(3);
        System.out.println(c);
    }

    private static void test1_length() {
        String str = "abcdefg";
        System.out.println(str.length());
    }
}

3.5 String类型的转换功能

byte[] getBytes()：将当前字符串，转成字节数组(编码)
char[] toCharArray()：将当前的字符串，转成字符数组
toUpperCase()：将当前的字符串，转成全大写形式
toLowerCase()：将当前的字符串，转成全小写形式
concat(String str)：将当前调用者，和参数str进行拼接，返回拼接后的长字符串（不常用，因为更多使用的是运算符+）
valueOf家族：可以将任意数据类型的数据，转换成字符串 (静态方法)
代码示例：

public class Simple09 {
    public static void main(String[] args) {
        test1_getBytes();
        test2_toCharArray();
        test3_upperAndLower();
        test4_concat();
        test5_valueOf();
    }

    private static void test5_valueOf(){
        //可以将任意数据类型的数据，转换成字符串
        System.out.println(String.valueOf(false));
        System.out.println(String.valueOf('x'));
        System.out.println(String.valueOf(new char[] {'a', 'b'}));
        System.out.println(String.valueOf(100));
        Object obj = null;
        System.out.println(String.valueOf(obj));
    }

    private static void test4_concat() {
        String str = "abc";
        String result = str.concat("xyz");
        System.out.println(result);
        System.out.println(str + "xyz");
        //将当前调用者，和参数str进行拼接，返回拼接后的长字符串（不常用，因为更多使用的是运算符+）
    }

    private static void test3_upperAndLower() {
        String str = "aBCdEfG";
        String upper = str.toUpperCase();//：将当前的字符串，转成全大写形式
        System.out.println(str);
        System.out.println(upper);
        String lower = str.toLowerCase();//：将当前的字符串，转成全小写形式
        System.out.println(lower);
    }

    private static void test2_toCharArray() {
        String str = "abcdefg";
        char[] arr = str.toCharArray();//将当前的字符串，转成字符数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();

    }

    private static void test1_getBytes() {
        String str = "abc";
        byte[] arr = str.getBytes();//将当前字符串，转成字节数组(编码)
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

3.6 String类型的其他方法

replace(String oldStr, String newStr)：将调用者中的老串替换成新串
trim()：去掉字符串左右两边的空格、制表符

split：

split(String regex, int limit)：字符串按照某个字符串进行分割，返回字符串数组，且限制返回元素个数。
split()：不限制返回元素个数。
String str = "Hello,World!com.coding-future";
String[] s = str.split("[,!.-]");
System.out.println(Arrays.toString(s));
}
format
String str = String.format("我是%s人，我爱%s","中国","中国");
代码示例

public class Simple10 {
    public static void main(String[] args) {
        test2_trim();
        test1_replace();
    }

    //去掉字符串左右两边的空格、制表符
    private static void test2_trim() {
        String str = "  I love java,  java is good ";
        String result = str.trim();
        System.out.println(str);
        System.out.println(result);
    }

    //将调用者中的老串替换成新串
    private static void test1_replace() {
        String str = "I love java, java is good";
        String result = str.replace("java", "study");
        System.out.println(str);
        System.out.println(result);
    }
}

4. StringBuffer && StringBuilder

4.1概述

内存理解:

public class Simple11 {
    public static void main(String[] args) {
        String[] strArr = {"java", "javascript", "html", "css", "nodejs"};
        String s1 = "我会的技能有：";
        for (String s : strArr) {
            s1 += s;
            s1 += ",";
        }
        System.out.println(s1);
    }
}

StringBuilder是一个可变的字符序列，因为在类中提供了修改私有成员变量的方法
- 常用的方法是append和insert，就是在StringBuilder对象本身上，进行修改操作
String类型和StringBuilder的关系：都是用于描述字符串
- String是不可变的字符序列，没有提供修改私有成员的方法；StringBuilder是可变的字符序列，因为提供了修改成员变量的方法；
- String长度本身也不可以变化，StringBuilder长度可以变化，可以认为StringBuilder就像一个可以伸缩的容器，用于存储字符

4.2构造方法

构造方法作用：创建当前对象、将其他类型的数据，转换成当前类型
StringBuilder的构造方法：
- StringBuilder()：创建一个生成器，初始容量为16个字符
- StringBuilder(int capacity)：创建一个生成器，初始容量为capacity大小
- StringBuilder(String str)：创建一个生成器，初始值就是str这些字符，初始大小是str+16
获取容积的方法：
- capacity()：获取当前生成器的容器大小
- length()：获取当前生成器中的字符个数
代码示例

public class Simple12 {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();
        System.out.println(sb1.capacity());//16

        StringBuilder sb2 = new StringBuilder(10);
        System.out.println(sb2.capacity());//10

        StringBuilder sb3 = new StringBuilder("Hello");
        System.out.println(sb3.capacity());//21
        System.out.println(sb3.length());//字符个数是5
    }
}

4.3添加功能

append(任意类型)：可以将任意数据类型，转成字符，添加到生成器中
insert(int index, 任意数据类型)：可以将任意数据类型，添加到指定的位置
- index的范围是0~当前缓冲区的大小
- 插入数据之后，数据本身的索引就是参数中指定的index
实例代码

private static void test1insert() {
        StringBuilder sb1 = new StringBuilder();//"1"
        sb1.insert(0, "a");
        System.out.println(sb1);//1
        sb1.insert(0, "b");
        System.out.println(sb1);//ba
        sb1.insert(1, "xyz");
        System.out.println(sb1);//bxyza
   }

4.4删除功能

deleteCharAt(int index) ：删除指定索引的字符
delete(int start, int end)：删除指定范围的字符，被删除的部分包含头不包含尾
实例代码

public class Simple13 {
    public static void main(String[] args) {
        //test1_deleteCharAt();
        test2_delete();
    }

    private static void test2_delete() {
        StringBuilder sb1 = new StringBuilder("abcdef");
        //删除cd
        sb1.delete(2, 4);
        System.out.println(sb1);//abef
    }

    private static void test1_deleteCharAt() {
        StringBuilder sb1 = new StringBuilder("abcdefg");
        sb1.deleteCharAt(2);
        System.out.println(sb1);//abdefg  删除指定索引的字符
        sb1.deleteCharAt(6);//String索引越界异常
        System.out.println(sb1);
    }
}

4.5替换和反转功能

replace(int start, int end ,String str)：
- 将字符串缓冲区中的从start开始到end-1这部分内容，替换成str
reverse()：将原有字符序列进行反转
示例代码

public class Simple14 {
    public static void main(String[] args) {
        test1_replace();
        test2_reverse();
    }

    private static void test2_reverse() {
        StringBuilder sb1 = new StringBuilder("abcdefg");
        sb1.reverse();
        System.out.println(sb1);
    }

    private static void test1_replace() {
        StringBuilder sb1 = new StringBuilder("abcdefg");
        sb1.replace(2, 5, "qq");
        System.out.println(sb1);
    }
}

4.6.StringBuffer和StringBuilder的区别

共同点：
- 都是字符串的缓冲区，都是字符串的生成器，都是可变的字符序列
不同点：
- 出现版本不同：
  - StringBuffer在jdk1.0出现的
  - StringBuilder在jdk1.5出现的
- 线程安全性不同：
  - StringBuffer是线程安全的，在多线程环境下仍然保证数据安全
  - StringBuilder是线程不安全，在多线程环境下无法保证数据安全
- 效率不同：
  - StringBuffer效率低
  - StringBuilder效率高

5.包装类

5.1概述

class Test {
    String str = "50";
    int a = (int) str; //此方式是否可以将str转成int类型
    int age = null; // 是否可以这样操作？
}

基本数据类型有八种，都是非常简单的数据类型
在这些类型中，只能表示简单的数据，不能包含一些操作数据的方法，没有办法存储描述这些数据的内容。需要准备一个引用数据类型，能将基本数据类型进行包装，提供一些操作基本类型的方法，定义一些描述数据的数据。
基本类型的包装类：
- byte Byte
  short Short
  int Integer类型
  long Long
  float Float
  double Double
  char Character
  boolean Boolean
各种包装类型的方法、特点基本相同，只要学习一个Integer类型，其他的也触类旁通。
Integer类型的对象中，维护了一个私有的成员变量，是一个int类型的字段（成员变量、属性），用于表示这个Integer对象要表示的数字。
提供了在int、Integer、String类型之间相互转换的方法

byte Byte
short Short
int Integer类型
long Long
float Float
double Double
char Character
boolean Boolean

5.2 Integer的构造方法

Integer(int i)：将一个基本类型的int数，转换成Integer类型的对象使用i给Integer对象中的成员变量赋值
Integer(String s)：将一个字符串类型的数字，转换成Integer类型的对象转换的作用
示例代码

public class Simple15 {
    public static void main(String[] args) {
        //将一个基本类型的int数，转换成Integer类型的对象使用i给Integer对象中的成员变量赋值
        Integer it = new Integer(100);
        System.out.println(it);

        //将一个字符串类型的数字，转换成Integer类型的对象转换的作用
        Integer it1 = new Integer("100");
        System.out.println(it1 + 10);
    }
}

5.3 Integer、int、String类型互相转换的总结

Integer转换成int类型
- intValue()
int转换成Integer类型
- 构造方法Integer(int i)
Integer到String的转换
- toString方法即可
String到Integer的转换
- Integer.valueOf(String str)
int转换成String类型：
- Integer.toString(int i)

String转换成int类型

Integer.parseInt(String str)

public class Simple16 {
    public static void main(String[] args) {
    
        Integer it2 = 10;
        int i = it2.intValue(); // i 没有操作方法
        Integer it3 = new Integer(20);

        System.out.println(it3);// it3有操作方法

        String s = it3.toString();
        System.out.println(s);// 字符串

        Integer it4 = Integer.valueOf(s);
        System.out.println(it4); // Integer

        String s1 = Integer.toString(i);
        System.out.println(s1);// 字符串

        int i1 = Integer.parseInt(s1);
        System.out.println(i1);// int 类型

    }
}

5.4 自动装箱和拆箱

装箱和拆箱：
- 装箱：将基本数据类型，封装成包装类型的对象(引用类型)，这个过程就是装箱，使用构造方法即可
- 拆箱：从包装类型的对象中，将其包装的基本类型的数据取出，这个过程就是拆箱，使用intValue方法即可
自动装箱和拆箱
- 自动装箱：可以直接使用基本类型的数据，给引用类型的变量赋值
- 自动拆箱：可以直接使用包装类对象，给基本类型的变量赋值:包装类对象直接进行算数运算
示例代码

public class Simple17 {
    public static void main(String[] args) {
        Integer it = 100;//自动装箱，100基本数据类型给integer包装类型赋值
        int i = it;//自动拆箱，

        System.out.println(it + 1);//自动拆箱  变成基本类型 然后运算

        Integer inte = 100; // 先装箱
        inte = inte + 1;//先自动拆箱，计算，最后自动装箱
    }

    private static void test1_装箱和拆箱() {
        int i = 100;
        Integer it = new Integer(i);//装箱

        int j = it.intValue();//拆箱
    }
}

6. 包(package)

包：用于分类存放类文件(.class)的文件夹，在out/production目录下存放.class
作用：
- 包帮助管理大型软件系统:将功能相近的类划分到同一个包中。比如:MVC的设计模式
- 包可以包含类和子包，划分项目层次，便于管理
- 使用package声明类或接口所属的包,声明在源文件的首行
- 解决类命名冲突的问题,同一个包下,不能命名相同的类和接口,不同的包下,可以命名同名的类和接口。
- 每"."一次,就代表一层文件目录。
命名：域名倒着写：com.xxxx.www（全球唯一）
包的声明：使用package的关键字，声明当前的类是属于指定的包的。
效果：
- 编译的这个类，就会进入到一个指定的文件夹中。
- 当前的类，名称也发生了变化，类名变成了【包名 + 类名】
简化：

每次使用其他包的类的时候，都需要写很长一串全类名，所以非常麻烦，需要简化. 使用import语句进行简化，在类的声明上，写一个import语句，将这个类的全类名导入进来，在该类中，就可以直接使用这个类的简写形式了。
注意事项：
- 在源文件中使用import显式的导入指定包下的类或接口
- 声明在包的声明和类的声明之间。
- 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。 System, String...
- 如果需要导入多个类或接口，那么就并列显式多个import语句即可
- 可以使用java.util.*的方式，一次性导入util包下所有的类或接口,不建议使用import *，使用import到类名。