Java学习day14-常用类1(比较器，内部类)

今日目标：

1.内外部比较器
2.内部类
3.包装类

一.比较器

Comparator 和 Comparable 比较：
1.Comparable是排序接口；若一个类实现了Comparable接口，就意味着“该类支持排序”。
（作用在实体类上）
2.而Comparator是比较器；我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。
（作用在排序类上）
总结：Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。

案例：创建一个实体类House,属性（面积，总价），创建一个房屋数组，里面有5套房子，分别使用两个不同的比较器，和数组工具类，对房屋进行排序，可以按照总价或面积进行排序。


分别按照面积升序和降序输出，分别按照总价升序和降序输出

public class House implements Comparable<House>{
    private double area;
    private double money;

    @Override
    public int compareTo(House o) {
        return Double.compare(this.getArea(),o.getArea());
    }

    @Override
    public String toString() {
        return "House{" +
                "area=" + area +
                ", money=" + money +
                '}';
    }

    public House(double area, double money) {
        this.area = area;
        this.money = money;
    }

    public House() {
    }

    public double getArea() {
        return area;
    }

    public void setArea(double area) {
        this.area = area;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

import java.util.Arrays;

public class TestHouse {
    public static void main(String[] args) {
        House[] house={
                new House(100,200),
                new House(80,150),
                new House(80.5,90),
                new House(110,190),
                new House(60,160)
        };
        Arrays.sort(house);
        System.out.println(Arrays.toString(house));
    }

}

练习：使用两种不同的比较器对5只狗狗进行排序，狗狗属性有：昵称，年龄。
分别按照昵称排序，年龄排序。

import java.util.Comparator;

public class MyComparator implements Comparator<Dog> {
    @Override
    public int compare(Dog o1, Dog o2) {
        return o1.getName().compareTo(o2.getName());
    }
}

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

    public Dog() {
    }

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

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

import java.util.Arrays;

public class TestDog {
    public static void main(String[] args) {
Dog[]dogs={
        new Dog("来福",2),
        new Dog("旺财",5),
        new Dog("大黄",1),
        new Dog("小白",3),
        new Dog("大胖",4)
};
char c1='来',c2='旺';
        System.out.println((int)c1);
        System.out.println((int)c2);
        System.out.println(c2-c1);
        Arrays.sort(dogs,new MyComparator());
        System.out.println(Arrays.toString(dogs));
    }
}

拓展：
尝试着不用比较器，也不用数组工具类，只用冒泡排序自己实现将房屋按照面积升序输出

对比两个比较器的优缺点：
内部：简洁，简单
外部：同时定义多个实体类的比较规则，也可以定义多个比较器，从不同的维度比较某个实体类。

二.内部类

在 Java 中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。下面就先来了解一下这四种内部类的用法。
1.成员内部类
定义在类中，充当类的一个成员。

访问权限：内部类可以访问外部类的属性和方法，外部类想要访问内部类的成员必须先创建内部类的对象来访问。
创建对象：new Outer().new Inner()

public class Outer {
    int a=1;
    public void show(){
        System.out.println("外部类show方法");
    }

    public static void main(String[] args) {
        System.out.println(new Outer().new Inner().a);
        new Outer().new Inner().show();
    }

    public class Inner{
        int a=2;
        public void show(){
            System.out.println("内部类的show方法");
            System.out.println(new Outer().a);
            new Outer().show();
        }
    }
}

2.静态内部类
静态内部类可以理解为类的一个静态成员。
静态内部类不需要依赖于外部类的对象，可以直接创建自己的对象。
不能访问外部类的非static成员属性或方法，因为静态内部类不依赖外部对象，就可以自己创建对象，所以如果没有外部对象，就调用外部的实例成员，就产生了矛盾，因为外部的实例成员必须要有外部对象。

public class Outer2 {
    int a=5;
    static int b=6;
    public void show1(){
        System.out.println("外部类的实例方法");
    }
    static public void show2(){
        System.out.println("外部类的静态方法");
    }

    public static void main(String[] args) {
        System.out.println(new Inner().a);
        new Inner().show1();
        System.out.println(Inner.b);
        Inner.show2();
    }

    public static class Inner{
        int a=55;
        static int b=66;
        public void show1(){
            System.out.println("内部类的实例方法");
        }
        static public void show2(){
            System.out.println("内部类的静态方法");
        }

        public static void main(String[] args) {
            System.out.println(new Outer2().a);
            new Outer2().show1();
            System.out.println(new Inner().a);
            new Inner().show1();

            System.out.println(Outer2.b);
            System.out.println(b);
            System.out.println(Outer2.Inner.b);
            System.out.println(Inner.b);
            Outer2.show2();
            Outer2.Inner.show2();
            show2();
            Inner.show2();
        }
    }

}

3.局部内部类
定义在方法中，充当方法的一个变量，注意: 局部内部类就像是方法里面的一个局部变量一样，是不能有 public、protected、private 以及 static 修饰符的。

4.匿名内部类
匿名内部类，通常作为方法传参时使用，用于继承抽象类或实现接口，代替子类或实现类，并不需要额外定义方法。Jdk8开始可以使用Lambda表达式进行简化。
参考：https://mp.weixin.qq.com/s/7oiqyizsusMqwno5tDSVCA

案例：使用匿名内部类重新实现打印机案例，使用Lambda表达式简化

三.包装类

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

2.包装类的应用
由于集合中不能存储基本数据类型，我们所看到的 list.add(6);事实上存储的都是包装类型，由基本数据类型升级成包装类的过程叫做“装箱”，反之称为“拆箱”；
1.装箱—拆箱 包装类 –基本数据类型 自动进行
2.向上转型—向下转型 父类—子类
3.强制类型转换—自动转换 byte-short-int-long float-double

3.包装类的构造方法
1.所有包装类都可将与之对应的基本数据类型作为参数，来构造它们的实例
2.除Character类外，其他包装类可将一个字符串作为参数构造它们的实例
注意事项
1.Boolean类构造方法参数为String类型时，若该字符串内容为true(不考虑大小写)，则该Boolean对象表示true，否则表示false
2.当Number包装类（除了Character和Boolean其它的包装类）构造方法参数为String 类型时，字符串不能为null，且该字符串必须可解析为相应的基本数据类型的数据，否则编译不通过，运行时会抛出NumberFormatException异常
总结：
1.包装类的构造方法一般都有重载，一个构造方法的参数是对应的基本数据类型，另一个构造方法的参数是字符串类型。

4.包装类的常用方法
1.XXXValue():包装类转换成基本类型（实例方法）
byteValue()、intValue()、longValue()、shortValue()、doubleValue()、floatValue()
charValue()、booleanValue()

2.toString():以字符串形式返回包装对象表示的基本类型数据（基本类型->字符串）
（静态方法）
3. parseXXX()：把字符串转换为相应的基本数据类型数据（Character除外）（字符串->基本类型）（静态方法）
4.valueOf()（静态方法）
(1)所有包装类都有如下方法（基本类型->包装类）
public static Type valueOf(type value)
(2)除Character类外，其他包装类都有如下方法（字符串->包装类）
public static Type valueOf(String s)

作业

1.使用两种不同的比较器分别对5本书进行排序，书的属性有：书名，作者，价格。
要求使用内部比较器按书名进行排序，使用外部比较器按价格进行排序。

2.使用匿名内部类实现：
2.1：接口UsbInterface，实现类usb电风扇UsbFan和u盘UDisk，接口中有service方法，实现类予以实现。

2.2：抽象类门有两个抽象方法，关和开；接口锁也有两个抽象方，锁门（lockUp）和开锁(openLock);防盗门类TheftproofDoor，继承门，实现锁接口的抽象方法（共4个）。编写测试类，调用防盗门重写的四个抽象方法。

2.3：需求说明：原始的手机，可以发短信，通电话。随着发展，手机增加了音频、视频播放、拍照、上网功能。按照下面的类图进行程序设计：首先，编写类及接口，参照以下类的结构图；其次，编写测试类，让普通手机播放音频、发信息和通电话，让智能手机上网、播放视频、照相、发彩信和视频通电话。

实现如下图所示的程序运行效果。

2.4：接口实现计算机
需求说明：采用面向接口编程思想组装一台计算机，计算机的主要组成部分有：CPU、硬盘、内存：首先，定义CPU的接口CPU，返回CPU品牌和主频；其次，定义内存的接口EMS，返回容量；再次，定义硬盘的接口HardDisk，返回容量；然后，编写各组件厂商分别实现CPU、EMS、和HardDisk接口，编写计算机类，组装计算机并显示相关信息；最后，编写测试类运行如图所示的效果。

解题思路：

3.默写四类八种基本数据类型对应的包装类，自己演示每种包装类的5大方法，对比理顺包装类和基本类型以及String类型之间的转换关系。提交演示代码和运行效果截图。

扩展
题目2.3中，除了传统的实现方式，还可以使用：
1.测试类中，写成员内部类
2.测试方法中，写匿名内部类
代替手机Handset的子类，作为普通手机或智能手机的实现。

第一题

public class Book implements Comparable<Book>{
    private String bookName;
    private String name;
    private double  price;

    @Override
    public int compareTo(Book o) {
       // return Double.compare(getPrice(),o.getPrice());
        return this.getBookName().compareTo(o.getBookName());
    }//o1.getName().compareTo(o2.getName()

    @Override
    public String toString() {
        return "Book{" +
                "bookName='" + bookName + '\'' +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}'+"\n";
    }

    public Book() {
    }

    public Book(String bookName, String name, double price) {
        this.bookName = bookName;
        this.name = name;
        this.price = price;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }


}

import java.util.Arrays;

public class TestBook {
    public static void main(String[] args) {
        Book []b={
                new Book("java","张三",30),
                new Book("c++","李四",40),
                new Book("数据库","王五",60),
                new Book("图形学","老六",20),
                new Book("unity3D","小明",80),
        };
        char a='数',b1='图';
        System.out.println((int)a+"-------"+(int)b1);
        Arrays.sort(b);
        System.out.println(Arrays.toString(b));
    }
}

public class Book1 {
    private String bookName;
    private String name;
    private double  price;

    @Override
    public String toString() {
        return "Book1{" +
                "bookName='" + bookName + '\'' +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}'+"\n";
    }

    public Book1() {
    }

    public Book1(String bookName, String name, double price) {
        this.bookName = bookName;
        this.name = name;
        this.price = price;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

import java.util.Comparator;

public class Book1Comparator implements Comparator<Book1> {

    @Override
    public int compare(Book1 o1, Book1 o2) {
        return Double.compare(o1.getPrice(),o2.getPrice());
    }
}

import java.util.Arrays;

public class TestBook1 {
    public static void main(String[] args) {
        Book1 []b={
                new Book1("java","张三",30),
                new Book1("c++","李四",40),
                new Book1("数据库","王五",60),
                new Book1("图形学","老六",20),
                new Book1("unity3D","小明",80),
        };
        Arrays.sort(b,new Book1Comparator());
        System.out.println(Arrays.toString(b));
    }
}

第二题 2.1

@FunctionalInterface
public interface Usb {
    void service();
}

public class TestUsb {
    public static void main(String[] args) {
        Usb usb = new Usb() {
            @Override
            public void service() {
                System.out.println("电风扇正在为主人服务");
            }
        };
        usb.service();

        Usb usb1 = () -> System.out.println("U盘正在为主人传输数据");
        usb1.service();
    }
}

第二题2.2

public abstract class Door {
    private Lock lock;

    public Lock getLock() {
        return lock;
    }

    public void setLock(Lock lock) {
        this.lock = lock;
    }

    abstract void open();
    abstract void close();
}

public interface Lock {
    void openLock();
    void lockUp();
}

public class TestDoor {
    public static void main(String[] args) {
        Door d=new Door() {
            @Override
            void open() {
                System.out.println("开门");
            }

            @Override
            void close() {
                System.out.println("关门");
            }
        };
        d.setLock(new Lock() {
            @Override
            public void openLock() {
                System.out.println("开锁");
            }

            @Override
            public void lockUp() {
                System.out.println("上锁");
            }
        });

        d.close();
        d.getLock().lockUp();
        d.getLock().openLock();
        d.open();

    }

}

第二题2.3

public interface TakePicture {
    void takePicture();
}

public interface Play {
    void play(String content);
}

public interface Network {
    void netWorkConn();
}

public abstract class Handset {
    //功能接口作为属性
    private Network network;
    private Play play;
    private TakePicture takePicture;
    //普通属性
    private String brand;
    private String type;
    //抽象方法
    public abstract void sendInfo();
    public abstract void call();
    //info方法
    public  void info(){
        System.out.println(brand+"--"+type);
    }
    //封装setter,getter
    public Network getNetwork() {
        return network;
    }

    public void setNetwork(Network network) {
        this.network = network;
    }

    public Play getPlay() {
        return play;
    }

    public void setPlay(Play play) {
        this.play = play;
    }

    public TakePicture getTakePicture() {
        return takePicture;
    }

    public void setTakePicture(TakePicture takePicture) {
        this.takePicture = takePicture;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }


}

public class TestHandset {
    public static void main(String[] args) {
        //1.构造普通手机
        Handset h=new Handset() {
            @Override
            public void sendInfo() {
                System.out.println("文字信息");
            }

            @Override
            public void call() {
                System.out.println("语音电话");
            }
        };
        //2.属性赋值
        h.setPlay(new Play() {
            @Override
            public void play(String music) {
                System.out.println("播放音乐"+music);
            }
        });
        h.setBrand("索尼");
        h.setType("G502C");
        //3.测试输出
        h.info();
        h.getPlay().play("热血");
        h.sendInfo();
        h.call();

        //1.智能手机
        h=new Handset() {
            @Override
            public void sendInfo() {
                System.out.println("图片和文字信息");
            }

            @Override
            public void call() {
                System.out.println("视频通话");
            }
        };
        //2.属性赋值
        h.setNetwork(new Network() {
            @Override
            public void netWorkConn() {
                System.out.println("连上5G网络");
            }
        });
        h.setPlay(new Play() {
            @Override
            public void play(String content) {
                System.out.println("正在播放视频"+content);
            }
        });
        h.setTakePicture(new TakePicture() {
            @Override
            public void takePicture() {
                System.out.println("拍照");
            }
        });
        h.setBrand("I9100");
        h.setType("HTC");
        //3.测试输出
        h.info();
        h.getNetwork().netWorkConn();
        h.getPlay().play("小时代");
        h.getTakePicture().takePicture();
        h.sendInfo();
        h.call();
    }
}

第二题2.4

public interface Cpu {
    String type();
    String hz();
}

public interface EMS {
    String emscapacity();
}

public interface HardDisk {
    String harddiskcapacity();
}

public class Computer {
private Cpu cpu;
private EMS ems;
private HardDisk hardDisk;

    public Cpu getCpu() {
        return cpu;
    }
    public void setCpu(Cpu cpu) {
        this.cpu = cpu;
    }
    public EMS getEms() {
        return ems;
    }
    public void setEms(EMS ems) {
        this.ems = ems;
    }
    public HardDisk getHardDisk() {
        return hardDisk;
    }
    public void setHardDisk(HardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }
}

public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.setCpu(new Cpu() {
            @Override
            public String type() {
                return "Inter";
            }

            @Override
            public String hz() {
                return "3.8";
            }
        });
        computer.setHardDisk(new HardDisk() {
            @Override
            public String harddiskcapacity() {
                return "3000";
            }
        });
    computer.setEms(new EMS() {
        @Override
        public String emscapacity() {
            return "4";
        }
    });
        System.out.println("计算机的信息如下：\nCpu的品牌是："
                +computer.getCpu().hz()+",主频是："+computer.getCpu().hz()+"GHz\n硬盘容量是："
                +computer.getHardDisk().harddiskcapacity()+
                "GB\n内存容量是："+computer.getEms().emscapacity()+"GB");
    }

}

Java学习顺序