小汤学编程之JAVA基础day09——常用类（一）：比较器、内部类和包装类

一、比较器

1.内部比较器      2.外部比较器

二、内部类

1.成员内部类     2.静态内部类     3.局部内部类     4.匿名内部类

三、包装类

1.概念     2.包装类的应用     3.装箱与拆箱     4.包装类的构造方法      5.包装类的常用方法

一、比较器

1.内部比较器（接口）

内部比较器Comparable 作用在实体类上，意味着“该类支持排序”。
使用步骤：
(1)将要比较的对象的类接上内部比较器接口，重写比较方法。

public class House implements Comparable<House>{
	@Override // 重写比较方法
	public int compareTo(House o){
		return this.getArea()-o.getArea();
	}
}

(2)直接用排序类进行排序即可。

Arrays.sort(houses);

2.外部比较器（类）

外部比较器Comparator 作用在排序类上，作为比较的规则。
使用步骤：
(1)创建比较器类，重写比较方法。

public class CompareDog implements Comparator<Dog>{
	@Override // 重写比较方法
	public int compare(Dog o1,Dog o2){
		// return o1.getAge()-o2.getAge();
		return o1.getName().compareTo(o2.getName());
	}
}

(2)在排序类里将比较器类的对象作为参数传入。

Arrays.sort(dogs, new CompareDog());

二、内部类

1.成员内部类

定义在类中，充当类的一个实例成员。
访问权限：内部类可直接访问外部类的属性和方法；外部类必须创建内部类的对象来访问。

// 成员(实例)内部类
public class Outer {
    private int a = 3;
    private void show(){
        System.out.println("我是外部类的实例方法");
    }

    public class Inner{
        private int b = 4;
        private int c = a; // 内部类访问外部类的成员属性(畅通无阻)
        private void showIn(){
            show();  // 内部类访问外部类的成员方法(畅通无阻)
            System.out.println("我是内部类的实例方法");
        }
    }

    public static void main(String[] args) {
        Inner inner = new Outer().new Inner();
        System.out.println(inner.b); // 外部类访问内部类的成员属性
        inner.showIn(); // 外部类访问内部类的成员方法
    }
}

2.静态内部类

定义在类中，充当类的一个静态成员。
访问权限：不能直接访问外部类的实例成员和方法；在外部可以直接创建自己的对象。

// 静态内部类
public class Outer {
    private int a = 1;
    private static int b = 2;

    public void show1() {
        System.out.println("外部类的实例方法");
    }

    public static void show2() {
        System.out.println("外部类的静态方法");
    }

    public static class Inner { // 静态内部类方法
        private int aa = 1;
        private static int bb = 2;

        public void show11() {
            System.out.println("内部类的实例方法");
        }

        public static void show22() {
            System.out.println("内部类的静态方法");
        }

        // 内部访问外部
        public static void main(String[] args) {
            // 调用静态属性和方法
            Outer.b = 9; // Outer 可以省略
            Outer.show2();
            // 调用实例属性和方法，创建外部对象
            new Outer().a = 11;
            new Outer().show1();
        }
    }

    // 外部访问内部
    public static void main(String[] args) {
        // 调用静态属性和方法
        Inner.bb = 9; // Outer 可以省略
        Inner.show22();
        // 调用实例属性和方法：创建内部对象
        new Inner().aa = 11;
        new Inner().show11();
    }
}

3.局部内部类

定义在方法中，充当方法的一个变量。
访问权限：无法在外部调用，使用范围仅限方法中；可以直接调外部类的属性和方法。

// 局部内部类
public class Outer {
    private int a = 6;

    private void show1() {
        int b = 8;
        System.out.println("外部类的成员方法");
        class Inner {
            // 局部内部类的使用范围仅限于方法中
            private int aa = 1;

            private void show2() {
                System.out.println("内部类的成员方法");
                // 内部调外部
                a = 9;
                show1();// 直接调
                Outer.this.show1();// 调外部方法
                this.show2();// 调内部方法
            }
        }
        new Inner().aa = 2;
        new Inner().show2();
    }

    // 外部调用局部内部类
    public static void main(String[] args) {
        // new Outer.Inner();  无法调用
    }
}

局部内部类类似方法里面的一个局部变量，不能有 public、protected、private 以及 static 修饰符。

4.匿名内部类（重点）

通常作为方法传参时使用，用于继承抽象类或实现接口。

(1)继承抽象类

创建抽象类的对象时，重写抽象类的抽象方法，从而达到继承抽象类的目的。

Handset c = new Handset("索尼", "G502c") {
	@Override
	public void sendInfo() {
		System.out.println("发送文字信息");
	}
	@Override
	public void call() {
		System.out.println("正在语音通话");
	}
};

(2)实现接口

在实体类中声明接口，并设置set/get方法。实现时调用set方法，创建接口的对象作为参数传入，创建时一并重写接口的抽象方法。

匿名内部类实现接口时，若接口只有一个抽象方法，可以使用Lambda表达式来简化。（Jdk8开始支持）

例如：

a.setPlayWiring(new PlayWiring() {
	@Override
	public void play(String incontent) {
		System.out.printf("开始播放视频%s", incontent);
	}
});

可以使用Lambda表达式简化为：

a.setPlayWiring(incontent -> System.out.printf("开始播放视频%s", incontent));

三、包装类

1.概念

由于基本数据类型没有类和对象的概念，java的设计理念是万事万物皆对象。所以特定为每一种基本数据类型量身定制了一个属于自己的类，称为包装类。

2.包装类的应用

由于集合无法存储基本数据类型，所以事实上集合存储的都是包装类。

3.装箱与拆箱

装箱：基本数据类型->包装类
拆箱：包装类->基本数据类型

int a = 1;
Integer a1 = a;// 装箱
a1 = 2;// 拆箱

目前Jdk的更新，装箱与拆箱的过程都可以由程序自动完成。

4.包装类的构造方法

所有包装类都有两种构造方法（除了Character类只有前一个构造方法）

1. 参数为对应的基本数据类型
2. 参数为字符串

Integer i1 = new Integer(123);// 参数为对应的基本数据类型
Integer i2 = new Integer("456");// 参数为字符串

注意：

• Boolean类构造方法参数为字符串时，若字符串内容为true（不分大小写）则该对象表示true，否则为false。
• 当Number包装类构造方法参数为字符串时，字符串不能为null，且必须为可解析为相应基本数据类型的数据，否则报NumberFormatException异常。

5.包装类的常用方法

(1)装箱方法 .value()

所有包装类都有的两个装箱方法（Character除外）(基本数据类型/字符串->包装类)

Integer i1 = Integer.valueOf(456);
Boolean b = Boolean.valueOf("true");

(2)拆箱方法 .XXXValue()

将包装类转化为基本数据类型(包装类->基本数据类型/字符串)

Byte a = new Byte((byte) 2);

(3)比较方法 .compare( , )

返回差。

Integer aa = 1;
Integer bb = 2;
System.out.println(Integer.compare(aa,bb));//-1

(4)转换字符串方法 .toString()

以字符串形式返回包装对象表示的基本数据类型（基本类型->字符串）

boolean b1 = true;
System.out.println(Boolean.toString(b1));

(5)转换基本数据类型方法.parseXXX()

把字符串转换为相应的基本数据类型数据（Character除外）（字符串->基本数据类型）

String c = "123";
System.out.println(Integer.parseInt(c));

(6)构造方法

详见上文