【java基础系列】14- Java的内部类与常用类

Java的内部类与常用类

1、内部类

1.1 内部类的分类

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

1.2 什么是内部类？

• 概念：在一个类的内部再定义一个完整的类。
• 特点：
  • 编译之后可生成独立的字节码文件。
  • 内部类可直接访问外部类的私有成员，而不破坏封装。
  • 可为外部类提供必要的内部功能组件。

1.2.1 案例（一）

• 编译之后可生成独立的字节码文件。

package com.goshawk.chapter_02;

public class Outer {
    class Inner {

    }
}

1
2
3
4
5
6
7
8

将上述代码的文件进行编译：javac Outer.java

12.2 案例（二）

• 内部类可直接访问外部类的私有成员，而不破坏封装。

package com.goshawk.chapter_02;

public class Outer {
    private String name;

    class Inner {
        public void show(){
            System.out.println(name);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

1.3 成员内部类

• 在类的内部定义，与实例变量、实例方法同级别的类。
• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。
  • Outer out = new Outer();
  • Inner in = out.new Inner();
• 当外部类、内部类存在重名属性时，会优先访问内部类属性。
• 成员内部类不能定义静态成员，但是可以定义静态常量。
  • private static String country = "深圳"; ×
  • private static final String country = "深圳"; ✓

1.3.1 案例（一）

• 创建内部对象

package com.goshawk.chapter_02;

/**
 * 外部类
 */
public class Outer {
    // 实例变量
    private String name = "李四";
    private int age = 21;

    // 内部类
    class Inner {
        private String address = "深圳";
        private String phone = "18100000001";
        // 方法
        public void show(){
            // 打印外部类的属性
            System.out.println(name);
            System.out.println(age);
            // 打印内部类的属性
            System.out.println(address);
            System.out.println(phone);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package com.goshawk.chapter_02;

import com.goshawk.chapter_02.Outer.Inner;

public class TestOuter {
    public static void main(String[] args) {
        // 创建内部对象的方式一
        // 1、创建外部类对象
        Outer outer = new Outer();
        // 2、创建内部类对象
        Inner inner = outer.new Inner();
        inner.show();
        // 创建内部对象的方式二
        Inner inner1 = new Outer().new Inner();
        inner1.show();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1.3.2 案例（二）

• 当外部类、内部类存在重名属性时，会优先访问内部类属性。

package com.goshawk.chapter_02;

/**
 * 外部类
 */
public class Outer {
    // 实例变量
    private String name = "李四";
    private int age = 21;

    // 内部类
    class Inner {
        private String address = "深圳";
        private String phone = "18100000001";

        private String name = "乌米";
        // 方法
        public void show(){
            // 内部类与外部类的属性名相同，优先打印内部类的属性
            System.out.println(name);
            // 内部类的属性名和外部类的属性名相同时，使用Outer.this来进行访问外部类的属性
            System.out.println(Outer.this.name);

        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

1.4 静态内部类

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
• 只能直接访问外部类的静态成员（实例成员需实例化外部类对象）。
  • Outer.Inner inner = new Outer.Inner();
  • Outer.Inner.show();
• 注意：只有在内部类才能使用static修饰类，外部类或者普通类是不能使用static关键字进行修饰的。

1.4.1 案例

package com.goshawk.chapter_02.section_2;

/**
 * 外部类
 */
public class Outer {
    // 实例变量
    private String name = "李四";
    private int age = 21;


    /**
     * 静态内部类，和外部类相同
     * 为什么要使用静态内部类？
     * 因为这个静态内部类要被外部类所使用，给外部提供一些功能
     */
    static class Inner {
        private String address = "上海";

        // 静态成员
        private static int count = 1000;

        public void show(){
            // 调用外部类的属性
            // 1、先创建外部类对象
            Outer outer = new Outer();
            // 2、调用外部类对象的属性
            System.out.println(outer.name);
            System.out.println(outer.age);

            // 调用静态内部类的属性
            System.out.println(address);

            // 调用静态内部类的静态属性
            System.out.println(Inner.count);
        }

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

package com.goshawk.chapter_02.section_2;

public class TestOuter {
    public static void main(String[] args) {
        // 直接创建静态内部类对象
        Outer.Inner inner = new Outer.Inner();
        // 调用方法
        inner.show();
    }
}

1
2
3
4
5
6
7
8
9
10
11

1.5 局部内部类

• 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
• 限制类的使用范围。

1.5.1 案例

package com.goshawk.chapter_02.section_3;

/**
 * 外部类
 */
public class Outer {
    // 实例变量
    private String name = "李四";
    private int age = 21;

    public void show(){
        // 定义局部变量
        /**
         * 在JDK1.8之后则自动加final
         *
         * 为什么要加final呢？
         * 因为如果不加final的话，在show这个方法执行完毕后，局部变量就会释放（消失），
         *
         * 这里注意此时用于存放创建局部内部类对象的inner变量会消失，
         * 但是show方法内部创建的局部内部类对象（new Inner()）不会消失，
         * 以及局部内部类（Inner）也不会消失。
         * 如果此时的局部变量不存在，那么将导致局部内部类找不到这个局部变量address，
         * 所以这里必须要使其变成一个常量，而局部内部类引用的也不再是address，而是深圳。
         *
         * 所以说要想在局部内部类引用局部变量，则必须要使用final对局部变量进行修饰。
         *
         * 还要注意一点就是局部内部类不能声明静态变量，但是可以声明静态常量。
         */
        String address = "深圳";
        // final String address1 = "深圳";

        // 局部内部类：注意不能加任何访问修饰符
        class Inner{
            // 局部内部类的属性
            private String phone = "13100000001";
            private String email = "lisi@163.com";
            private final static int count = 1000;

            public void show2(){
                // 访问外部类的属性
                System.out.println(name);
                System.out.println(Outer.this.age);
                // 访问内部类的属性
                System.out.println(phone);
                System.out.println(this.email);
                // 访问局部变量，（在JDK1.7要求变量必须是常量，也就是要加上final，但是在JDK1.8之后则自动加final）
                System.out.println(address);
            }
        }
        // 创建局部内部类对象
        Inner inner = new Inner();
        inner.show2();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

package com.goshawk.chapter_02.section_3;

public class TestOuter {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}

1
2
3
4
5
6
7
8
9

1.6 匿名内部类

• 没有类名的局部内部类（一切特征都与局部内部类相同）。
• 必须继承一个父类或者实现一个接口。
• 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
• 优点：减少代码量。
• 缺点：可读性较差。

1.6.1 案例（一）

• 实现接口的匿名类

package com.goshawk.chapter_02.section_4;

/**
 * 接口
 */
public interface Usb {
    // 服务
    void service();
}

1
2
3
4
5
6
7
8
9
10

package com.goshawk.chapter_02.section_4;

/**
 * Mouse类实现了Usb接口
 */
public class Mouse implements Usb{
    @Override
    public void service() {
        System.out.println("连成功连接电脑，鼠标开始工作");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

package com.goshawk.chapter_02.section_4;

public class TestUsb {
    public static void main(String[] args) {
        // 创建接口类型的变量
        Usb usb = new Mouse();

        usb.service();

        // 局部内部类
        class Fan implements Usb{
            @Override
            public void service() {
                System.out.println("成功连接电脑，风扇开始工作");
            }
        }
        // 使用局部内部类创建对象
        Usb usb1 = new Fan();
        usb1.service();

        // 使用匿名内部类进行优化（相当于创建了一个局部内部类），new Usb() 可以是父类，也可以是接口
        Usb usb2 = new Usb() {
            @Override
            public void service() {
                System.out.println("成功连接电脑，风扇2开始工作");
            }
        };
        usb2.service();
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

1.6.2 案例（二）

• 匿名子类（继承父类）

package com.goshawk.chapter_02.section_4;

public class Animal {
    private String name;
    // 品种
    private String breed;
    // 年龄
    protected int age;
    // 性别
    public String sex;

    public Animal(){}

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

    public void eat(){
        System.out.println("动物吃东西");
    }

    public void sleep(){
        System.out.println("动物睡觉");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package com.goshawk.chapter_02.section_4;

public class Bird extends Animal{
    @Override
    public void eat() {
        System.out.println("cuckoo - 杜鹃吃虫子");
    }

    public void show() {
        System.out.println("大家好，我是杜鹃");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

package com.goshawk.chapter_02.section_4;

public class TestBird {


    public static void main(String[] args) {
        Bird bird = new Bird();
        bird.eat();

        // 匿名子类，继承自Animal类，可以重写父类方法
        Animal bird1 = new Animal(){
            @Override
            public void eat() {
                System.out.println("Magpie - 喜鹊鸟吃虫子");
                super.sleep();
                TestBird testBird = new TestBird();
                System.out.println("访问外部类final修饰的变量：");
            }
        };
        bird1.eat();


    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

1.6.3 案例（三）

• 匿名内部类访问其外部类方法

package com.goshawk.chapter_02.section_4;

public class Dog {
    private final String GOGS = "狗类";

    public void sleep(){
        System.out.println("匿名内部类访问其外部类方法");
        System.out.println("狗在睡觉");
    }

    class Poodle {
        private String name = "小帽";
        private String breed = "贵宾犬";

        public Poodle(String name, String breed){
            this.name = name;
            this.breed = breed;
        }

        public void eat(){
            System.out.println(breed + " " + name + "在吃狗粮");
        }

    }
    Poodle poodle = new Poodle("小华", "哈士奇"){
        @Override
        public void eat() {
            System.out.println("访问外部类final修饰的变量:" + GOGS);
            System.out.println("访问外部类方法");
            sleep();

            super.eat();
        }
    };

    public void print() {
        poodle.eat();
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.print();
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

• 注意：使用javac Dog.java进行编译后，匿名内部类编译之后可生成独立的字节码文件。
  • 匿名内部类：Dog$1.class。
  • 内部类：Dog$Poodle.class。

1.7 为什么要使用内部类？

• 每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
• 方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。
• 方便编写事件驱动程序。
• 方便编写线程代码。

1.8 内部类的作用

• 实现了更好的封装，普通类（非内部类）的访问修饰符不能为private或protected，而内部类可以。当我们将内部类声明为private时，只有外部类可以访问内部类，很好地隐藏了内部类。
• 内部类可以继承（extends）或实现（implements）其他的类或接口，而不受外部类的影响。
• 内部类可以直接访问外部类的字段和方法，即使是用private修饰的，相反的，外部类不能直接访问内部类的成员。

2、Object类

• 超类。基类，所有类的直接或间接父类，位于继承树的最顶层。
• 任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。
• Object类中所定义的方法，是所有对象都具备的方法。
• Object类型可以存储任何对象。
  • 作为参数，可接收任何对象。
  • 作为返回值，可返回任何对象。

3、Object类常用方法

3.1 getClass()方法

• public final Class getClass(){}
• 返回引用中存储的实际对象类型。
• 应用：通常用于判断两个引用中实际存储对象类型是否一致。

3.1.1 案例

package com.goshawk.chapter_02.section_5;

public class Student {
    private String name;
    private int age;

    public Student(){}

    public Student(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;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package com.goshawk.chapter_02.section_5;

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("小明", 20);
        Student s2 = new Student("小赵", 21);
        // 判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else {
            System.out.println("s1和s2不属于同一个类型");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.2 hashCode()方法

• public int hashCode(){}
• 返回该对象的哈希码值。
• 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。
• 一般情况下相同对象返回相同哈希码。

3.2.1 案例

package com.goshawk.chapter_02.section_5;

public class Student {
    private String name;
    private int age;

    public Student(){}

    public Student(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;
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package com.goshawk.chapter_02.section_5;

public class TestStudent {
    public static void main(String[] args) {

        Student s1 = new Student("小明", 20);
        Student s2 = new Student("小赵", 21);

        // hashCode()
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3 = s1;
        System.out.println(s3.hashCode()); // s3.hashCode() == s1.hashCode()
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.3 toString()方法

• public String toString(){}
• 返回该对象的字符串表示（表现形式）。
• 可以根据程序需求覆盖该方法，如：展示对象各个属性值。

3.3.1 案例

package com.goshawk.chapter_02.section_5;

public class Student {
    private String name;
    private int age;

    public Student(){}

    public Student(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;
    }
		// 重写toString()
    public String toString() {
        return name + ": " + age;
    }
    
    
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

package com.goshawk.chapter_02.section_5;

public class TestStudent {
    public static void main(String[] args) {

        Student s1 = new Student("小明", 20);
        Student s2 = new Student("小赵", 21);

        // toString()
        System.out.println("-----------3、toString()-----------");
        System.out.println(s1.toString());
        System.out.println(s2.toString());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.4 equals()方法

• public boolean equals(Object obj){}
• 默认实现为（this == obj），比较两个对象地址是否相同。
• 可进行覆盖，比较两个对象的内容是否相同。

3.4.1 equals()方法覆盖步骤

• 比较两个引用是否指向同一个对象。
• 判断obj是否为null。
• 判断两个引用指向的实际对象类型是否一致。
• 强制类型转换。
• 依次比较各个属性值是否相同。

package com.goshawk.chapter_02.section_5;

import java.util.Objects;

public class Student extends Object{
    private String name;
    private int age;

    public Student(){}

    public Student(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;
    }


    // 重写equals()
    @Override
    public boolean equals(Object obj) {
        // 判断两个对象是否是同一个引用
        if (this==obj){
            return true;
        }
        // 判断obj是否null
        if (obj==null){
            return false;
        }
        // 判断是否是同一个类型
//        if (this.getClass()==obj.getClass()){
//
//        }
        // instanceof判断对象是否是某种类型
        if (obj instanceof Student){
            // 强制转换类型
            Student s = (Student) obj;
            // 比较属性
            if (this.name.equals(s.getName())&&this.age==getAge()){
                return true;
            }
        }
        return false;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

package com.goshawk.chapter_02.section_5;

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("小明", 20);
        Student s2 = new Student("小赵", 21);
        System.out.println("-----------1、getClass()-----------");

        // equals()，判断两个对象是否相等
        System.out.println("-----------4、equals()-----------");
        System.out.println(s1.equals(s2));

        Student s4 = new Student("小李", 23);
        Student s5 = new Student("小李", 23);
        System.out.println(s4.equals(s5));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3.5 finalize()方法

• 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
• 垃圾对象：没有有效引用指向此对象时，为垃圾对象。
• 垃圾回收：由GC销毁垃圾对象，释放数据存储空间。
• 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
• 手动回收机制：使用System.gc()；通知JVM执行垃圾回收。

3.5.1 案例

package com.goshawk.chapter_02.section_5;

import java.util.Objects;

public class Student extends Object{
    private String name;
    private int age;

    public Student(){}

    public Student(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;
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name + "对象被回收");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

package com.goshawk.chapter_02.section_5;

public class TestStudent2 {
    public static void main(String[] args) {
//        Student s1 = new Student("小明", 20);
//        Student s2 = new Student("小赵", 21);
//        Student s3 = new Student("小李", 23);
//        Student s4 = new Student("小甘", 24);
        new Student("小明", 20);
        new Student("小赵", 21);
        new Student("小李", 23);
        new Student("小甘", 24);

        // 回收垃圾
        System.gc();
        System.out.println("回收垃圾");


    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4、包装类

4.1 什么是包装类？

• 基本数据类型所对应的引用数据类型。
• Object可统一所有数据，包装类的默认值是null。

4.2 包装类对应

4.3 类型转换与装箱、拆箱

4.3.1 什么是装箱？

• 装箱：将基本数据类型转换为包装类类型（引用类型）

  Integer integer1 = new Integer(num1);
  Integer integer2 = Integer.valueOf(num1);
  1
  2

4.3.2 什么是拆箱？

• 拆箱：将包装类类型转换为基本数据类型

  Integer integer3 = new Integer(100);
  int num2 = integer3.intValue();
  1
  2

4.3.3 自动装箱和自动拆箱

package com.goshawk.chapter_02.section_6;

public class Demo {
    public static void main(String[] args) {
        // 类型转换：装箱 --> 基本类型转成引用类型的过程

        // 基本类型
        int num1 = 18;
        // 使用Integer类创建对象

        // JDK1.5之前
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println("手动装箱");
        System.out.println(integer1);
        System.out.println(integer2);

        // 类型转换：拆箱 --> 引用类型转成基本类型的过程
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("手动拆箱");
        System.out.println(num2);

        // JDK1.5之后，提供自动装箱和拆箱
        int age = 30;
        // 自动装箱
        Integer integer4 = age;
        System.out.println("自动装箱");
        System.out.println(integer4);
        // 自动拆箱
        int age2 = integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

• 使用自动装箱或者自动拆箱后，将编译之后的.class文件进行反编译，会自动转成手动装箱或者手动拆箱的格式。

  

​

4.3.4 基本类型和字符串转换

• 8种包装类提供不同类型间的转换方式：
  • Number父类中提供的6个共性方法。
  • parseXXX()静态方法。XXX - > 基本类型
  • valueOf()静态方法。
• 注意：需保证类型兼容，否则抛出NumberFormatException异常。

package com.goshawk.chapter_02.section_6;

public class Demo {
    public static void main(String[] args) {

        // 基本类型和字符串之间转换
        // 1、基本类型转成字符串
        int n1 = 15;
        // 1.1> 使用 + 号
        String s1 = n1 + "";
        // 1.2> 使用Integer中的toString()方法
        String s2 = Integer.toString(n1);
        // 1.3> 使用使用Integer中的toString()的重载方法
        String s3 = Integer.toString(n1, 16); // radix 表示基数，我这里表示转成16进制

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);

        // 2、字符串转成基本类型

        String str = "150"; // 这里注意不能出现非数字类型
        // 使用Integer.parseXXX();
        int n2 = Integer.parseInt(str);
        System.out.println(n2);

        // boolean字符串转成基本类型 "true" -> true ，非"true" ->false（如果给的字符串不是true，那么将转成false）
        String str2 = "true";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

4.3.5 整数缓冲区

• Java预先创建256个常用的整数包装类型对象。
• 在实际应用当中，对已创建的对象进行复用。

package com.goshawk.chapter_02.section_6;

public class Demo1 {
    public static void main(String[] args) {
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1==integer2); // 因为这里比较的是引用类型的地址，所以这里打印出false

        Integer integer3 = 100; // 自动装箱，等同于调用Integer.valueOf方法
        Integer integer4 = 100;
        // Integer integer4 = Integer.valueOf(100);
        System.out.println(integer3 == integer4); // true 因为100在：-128 ~ 127之间内（为什么是这个范围呢？参考Integer.valueOf的源码）

        Integer integer5 = 200; // 自动装箱
        Integer integer6 = 200;
        System.out.println(integer5 == integer6); // false  因为200不在：-128 ~ 127之间内
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5、String类

5.1 String的概述

• 字符串是常量，创建之后不可改变。
• 字符串字面值存储在字符串池中，可以共享。（字符串池在方法区中；方法区在JDK1.8之前也称为永久代，JDK1.8之后称为元空间。）
• String s = "Hello";产生一个对象，字符串池中存储。
• String s = new String("Hello"); // 产生两个对象，堆、字符串池各存储一个 。

package com.goshawk.chapter_02.section_6;

public class Demo2 {
    public static void main(String[] args) {
        String name = "hello"; // 常量存储在字符串池中
        System.out.println(name.hashCode());
        name = "lisi"; // 李四赋值给name变量，给字符串赋值时，并没有修改数据，而是重新开辟一个空间。
        System.out.println(name.hashCode());
        String name1 = "lisi";
        System.out.println(name1.hashCode());

        // 字符串的创建方式
        String str = new String("Java");
        String str2 = new String("Java");
        System.out.println(str==str2); // -> false
        System.out.println(str.equals(str2)); // -> true
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5.2 String的常用方法

• public int length()：返回字符串的长度。
• public char charAt(int index)：根据下标获取字符。
• public boolean contains(String str)：判断当前字符串中是否包含str。
• public char[] toCharArray()：将字符串转换成数组。
• public int indexOf(String str)：查找str首次出现的下标，如果存在返回该下标，否则返回-1。
• public int lastIndexOf(String str)：查找字符串在当前字符串中最后一次出现的下标索引。
• public String trim()：去掉字符串前后的空格。
• public String toUpperCase()：将小写转成大写。
• public String toLowerCase()：将大写转成大写。
• public boolean endWith(String str)：判断字符串是否以str结尾。
• public boolean startWith(String str)：判断字符串是否以str开头。
• public String replace(char oldChar, char newChar)：将旧字符串替换成新字符串。
• public String[] split(String str)：根据str做拆分。

5.2.1 案例（一）

package com.goshawk.chapter_02.section_6;

import java.util.Arrays;

public class Demo2 {
    public static void main(String[] args) {

        // 字符串方法的使用
        String content = "java是一种编程语言";

        // length();返回字符串的长度
        // charAt(int index);返回某个位置的字符
        // contains(String str);判断是否包含某个子字符串
        System.out.println(content.length());
        System.out.println(content.charAt(content.length()-1));
        System.out.println(content.contains("java"));

        // toCharArray()返回字符串对应的数组
        // indexOf() 返回字符串首次出现的位置
        // lastIndexOf() 返回字符串最后一次出现的位置
        System.out.println(Arrays.toString(content.toCharArray()));
        System.out.println(content.indexOf("java"));
        System.out.println(content.indexOf("java", 4));
        System.out.println(content.lastIndexOf("java"));

        // trim() 去掉字符串前后的空格
        // toUpperCase() 将小写转成大写
        // toLowerCase() 将大写转成大写
        // endWith() 判断字符串是否以`str`结尾
        // startWith() 判断字符串是否以`str`开头
        String content2 = " hello word ";
        System.out.println(content2.trim());
        System.out.println(content2.toUpperCase());
        System.out.println(content2.toLowerCase());
        String filename = "hello.java";
        System.out.println(filename.endsWith(".java"));
        System.out.println(filename.startsWith("hello"));

        // replace() 用新的字符或字符串 替换 旧的字符或字符串
        // split() 对字符串进行拆分
        System.out.println(content.replace("java", "py"));

        String say = "java,python is the best   programing language";
        String[] arr = say.split("[ ,]+"); // + 表示可能出现多个
        System.out.println(arr.length);
        for (String string : arr){
            System.out.println(string);
        }

        // equals() 、 compareTo() 比较大小
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equalsIgnoreCase(s2)); // 忽略大小写比较

        String s3 = "abc";
        String s4 = "def";
        // 将a的ASCII码值97与d的ASCII码值100 -> 97-100。如果第一个都是a，则开始比较第二个字符，依次类推。
        System.out.println(s3.compareTo(s4));

        String s5 = "abc";
        String s6 = "abcdef";
        // s5的长度为3，s6的长度为6 -> 3-6=-3。
        System.out.println(s5.compareTo(s6));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

5.2.2 案例（二）

• 要求
  • 已知String str = "this is a text";
  • 将str中的单词单独获取出来
  • 将str中的text替换成practice
  • 在text前面插入一个easy
  • 将每个单词的首字母改成大写

package com.goshawk.chapter_02.section_6;

public class Demo3 {
    public static void main(String[] args) {
        String str = "this is the text";
        String[] arr = str.split(" ");
        for (String string : arr){
            System.out.println(string);
        }
        
        String str2 = str.replace("text", "practice");
        System.out.println(str2);
        
        String str3 = str.replace("text", "easy text");
        System.out.println(str3);
        
        for (int i=0;i<arr.length;i++){
            char first = arr[i].charAt(0);
            // 把第一个字符转成大写
            char upperfirst = Character.toUpperCase(first);
            
            String newStr = upperfirst+arr[i].substring(1); // 截取
            System.out.println(newStr);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

5.2.3 可变字符串

• StringBuffer：可变长字符串，`JDK1.0提供，运行效率慢、线程安全。
• StringBuilder：可变长字符串，JDK5.0提供，运行效率快，线程不安全。

5.2.3.1 案例（一）

package com.goshawk.chapter_02.section_6;

public class Demo4 {
    public static void main(String[] args) {
        StringBuffer str = new StringBuffer();
        // StringBuilder str = new StringBuilder();
        
        // append追加
        str.append("动物园有大象");
        System.out.println(str.toString());
        str.append("有猴子");
        System.out.println(str.toString());
        // insert添加
        str.insert(0, "先看到长颈鹿，");
        System.out.println(str.toString());
        // replace替换
        str.replace(0, 3, "孔雀");
        System.out.println(str.toString());
        // delete删除
        str.delete(0, 2);
        System.out.println(str.toString());
        // 清空
        str.delete(0, str.length());
        System.out.println(str.length());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

5.2.3.2 案例（二）

• 验证StringBuilder效率高于String。

package com.goshawk.chapter_02.section_6;

public class Demo5 {
    public static void main(String[] args) {
        // 开始时间
        long startTime = System.currentTimeMillis();
//        String string = "";
//        for (int i=0;i<99999;i++){
//            string+=i;
//        }
//        System.out.println(string);
        
        StringBuilder str = new StringBuilder();
        for (int i=0;i<99999;i++){
            str.append(i);
        }
        System.out.println(str.toString());

        long endTime = System.currentTimeMillis();
        System.out.println("用时："+(endTime-startTime));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

6、BigDecimal类

6.1 案例（一）

public class TestBigDecimal{
  public static void main(String[] args){
    double d1 = 1.0;
    double d2 = 0.9;
    System.out.println(d1-d2);
    
    double result = (1.4-0.5)/0.9;
    System.out.println(result);
  }
}
1
2
3
4
5
6
7
8
9
10

输出：

0.09999999999999998
0.9999999999999999
1
2

• 很多实际应用中需要精确运算，而double是近似值存储，不在符合要求，需要借助BigDecimal。

6.2 BigDecimal的使用

• 位置：java.math包中

• 作用：精确计算浮点数。

• 创建方式：BigDecimal bd = new BigDecimal("1.0");

• 除法：divide(BigDecimal bd, int scal, RoundingMode mode)

  • 参数scal：指定精确到小数点后几位。
  • 参数mode：
    • 指定小数部分的取舍模式，通常采用四舍五入的模式。
    • 取值为BigDecimal.ROUND_HALF_UP。

6.3 案例（二）

package com.goshawk.chapter_02.section_6;

import java.math.BigDecimal;

public class Demo6 {
    public static void main(String[] args) {

        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        // 减法
        BigDecimal result1 = bd1.subtract(bd2);
        System.out.println(result1);
        // 加法
        BigDecimal result2 = bd1.add(bd2);
        System.out.println(result2);
        // 乘法
        BigDecimal result3 = bd1.multiply(bd2);
        System.out.println(result3);
        // 除法
        BigDecimal result4 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));
        System.out.println(result4);
        // 除法除不尽
        BigDecimal result5 = new BigDecimal("10")
                // 保留两位小数，且四舍五入
                .divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);

    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

7、Date 类

• Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已被Calendar类中的方法所取代（JDK1.1之后）。
• 时间单位：
  • 1秒=1000毫秒。
  • 1毫秒=1000微秒。
  • 1微秒=1000纳秒。

7.1 案例（一）

package com.goshawk.chapter_02.section_6;

import java.util.Date;

public class Demo7 {
    public static void main(String[] args) {
        // 今天
        Date date1 = new Date();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());
        // 昨天
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());

        boolean b1 = date1.after(date2); // date1在date2之后，返回ture或者false
        System.out.println(b1);

        boolean b2 = date1.before(date2); // date1在date2之前，返回ture或者false
        System.out.println(b2);

        // 比较 compareTo
        int d1 = date1.compareTo(date2);
        System.out.println(d1);
        int d2 = date2.compareTo(date1);
        System.out.println(d2);
        // 比较是否相等equals()
        boolean b3 = date1.equals(date2);
        System.out.println(b3);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

8、Calendar 类

• Calendar提供了获取或设置各种日历字段的方法。

• 构造方法

  • protected Calendar()：由于修饰符是protected，所以无法直接创建该对象。

• 其他方法

  方法名	说明
  Static Calendar getlnstance()	使用默认时区和区域获取日历
  Void set(int year, int month, int date, int hourofday, int minute, int second)	设置日历的年、月、日、时、分、秒。
  int get(int field)	返回给定日历字段的值。字段比如年、月、日等。
  Void setTime(Date date)	用给定的Date设置此日历的时间。Date-Calendar
  Date getTime()	返回一个Date表示此日历的时间。Calendar-Date
  Void add(int field, int amount)	按照日历的规则，给指定字段添加或减少时间量
  long getTimeMillies()	毫秒为单位返回该日历的时间值。

8.1 案例（一）

package com.goshawk.chapter_02.section_6;

import java.util.Calendar;

public class Demo8 {
    public static void main(String[] args) {
        // 创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());

        // 获取时间信息
        // 获取年
        int year = calendar.get(Calendar.YEAR);
        // 获取月 0-11月，要想正常显示则+1
        int month = calendar.get(Calendar.MONTH);
        // 获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        // 获取小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY); // HOUR 12小时; HOUR_OF_DAY 24小时
        // 获取分钟
        int minute = calendar.get(Calendar.MINUTE);
        // 获取秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);

        // 修改时间
        Calendar calendar1 = Calendar.getInstance();
        calendar1.set(Calendar.DAY_OF_MONTH, 5);
        System.out.println(calendar1.getTime().toLocaleString());

        // add方法修改时间
        calendar1.add(Calendar.HOUR, 1);
        System.out.println(calendar1.getTime().toLocaleString());
        calendar1.add(Calendar.HOUR, -1);
        System.out.println(calendar1.getTime().toLocaleString());

        int max = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar1.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);
        System.out.println(min);

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

9、SimpleDateFormat 类

• SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。

• 进行格式化（日期 -> 文本）、解析（文本 -> 日期）。

• 常用的时间模式字母

  字母	日期或时间	示例
  y	年	2022
  M	年中月份	08
  d	月中天数	22
  H	1天中小时数（0-23）	16
  M	分钟	13
  s	秒	59
  S	毫秒	367

9.1 案例（一）

package com.goshawk.chapter_02.section_6;

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

public class Demo9 {
    public static void main(String[] args) throws Exception{
        // 创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy/MM/dd");
        // 创建Date
        Date date = new Date();
        // 格式化date 把日期转换成字符串
        String str = sdf.format(date);
        System.out.println(str);

        // 解析 把字符串转成日期
        Date date1 = sdf1.parse("1990/05/01");
        System.out.println(date1);

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

10、System 类

• System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的。

10.1 案例（一）

package com.goshawk.chapter_02.section_6;

public class Student {
    private String name;
    private int age;
    public Student(String name, int age){
        super();
        this.name = name;
        this.age = age;
    }

    public Student(){

    }

    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;
    }

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

    @Override
    protected void finalize() throws Throwable {
        System.out.println("回收了"+name+"   "+age);
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

package com.goshawk.chapter_02.section_6;

public class Demo10 {
    public static void main(String[] args) {
        // arraycopy 数组复制
        // src 源数组
        // srcPos：从哪个位置开始赋值 0
        // dest：目标数组
        // destPos: 目标数组的位置
        // length: 赋值的长度
        int[] arr = {20, 18, 16, 14, 26, 45, 89, 22};
        int[] dest = new int[8];

        System.arraycopy(arr, 0, dest, 0, arr.length);
        // System.arraycopy(arr, 4, dest, 4, 4);
        for (int i=0;i<dest.length;i++){
            System.out.println(dest[i]);
        }

        // Arrays.copyOf(original, newLength)
        System.out.println(System.currentTimeMillis());

        long start = System.currentTimeMillis();
        for (int i = 0; i<9999999;i++){
            for (int j=0;j<9999999;j++){
                int result=i+j;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时:"+(end-start));

        Student s1 = new Student("aaa", 17); // 对象被变量使用是不回收的
        Student s2 = new Student("bbb", 18);
        Student s3 = new Student("ccc", 19);

        new Student("aaa", 17);
        new Student("bbb", 18);
        new Student("ccc", 19);
        // System.gc() 告诉垃圾回收器回收垃圾
        System.gc();

        // 退出jvm
        System.exit(0);
        System.out.println("结束了"); // 此行代码不打印

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

11、总结

• 内部类
  • 在一个类的内部再定义一个完整的类。
  • 成员内部类、静态内部类、局部内部类、匿名内部类。
• Object类
  • 所有类的直接或间接父类，可存储任何对象。
• 包装类
  • 基本数据类型所对应的引用数据类型，可以使Object统一所有数据。
• String类
  • 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享。
• BigDecimal
  • 可精确计算浮点数。
• Date
  • 特定时间
• Calendar
  • 日历
• System
  • 系统类