Java中常用类案例（外部比较器、内部比较器、成员内部类、匿名内部类、局部内部类、静态内部类）

一、常用类案例

1.成员内部类

package com.practice3;

public class Outer {
    
    
    //外部类 属性和方法
    int a=1;
    public void show(){
    
    
        System.out.println("外部类的show方法");
    }
    //研究2：外部类调用内部类的成员
    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;
        //研究1：内部类调用外部类的成员
        public void show(){
    
    
            System.out.println("内部类的show方法");
            System.out.println(new Outer().a);
            new Outer().show();
        }
    }
}

2.匿名内部类案例（一）

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

代码如下（示例）：

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

package work21;

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

3.匿名内部类案例（二）

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

package work22;

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

package work22;

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();

    }


}

package work22;

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

4.匿名内部类案例（三）

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

package work23;

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("这是一款型号为"+type+"的"+brand+"手机");
    }
    //封装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;
    }


}

package work23;

public interface Network {
    
    
    void netWorkConn();
}

package work23;

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

package work23;

public interface TakePicture {
    
    
    void takePicture();
}

package work23;

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

5.匿名内部类案例（四）

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

package work24;

public class Computer implements EMS,CPU,HardDisk{
    
    
    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;
    }

    @Override
    public void brand() {
    
    
        cpu.brand();
    }

    @Override
    public void hz() {
    
    
        cpu.hz();
    }


    @Override
    public void hardDisk() {
    
    
        hardDisk.hardDisk();
    }

    @Override
    public void ems() {
    
    
        ems.ems();
    }
}

package work24;

public interface CPU {
    
    
    void brand();
    void hz();
}

package work24;

public interface EMS {
    
    
    void ems();
}

package work24;

public interface HardDisk {
    
    
    void hardDisk();
}

package work24;

public class Test {
    
    
    public static void main(String[] args) {
    
    
        System.out.println("计算机的信息如下：");
        Computer c=new Computer();
        c.setCpu(new CPU() {
    
    
            @Override
            public void brand() {
    
    
                System.out.print("CPU的品牌是：Intel,");
            }

            @Override
            public void hz() {
    
    
                System.out.println("主频是：3.8GHz");
            }
        });
        c.getCpu().brand();
        c.getCpu().hz();
        c.setEms(()-> System.out.println("硬盘容量是：3000GB"));
        c.ems();
        c.setHardDisk(()-> System.out.println("内存容量是：4GB"));
        c.hardDisk();
    }
}

6.局部内部类：

package com.practice5;

import com.practice4.Outer2;

public class Outer3 {
    
    
    int a=3;
    static int b=99;

    public static void main(String[] args) {
    
    
        new Outer3().show();

    }

    public void show(){
    
    
        int a=5;
        class Inner1{
    
    
            int a=6;
            public void show1(){
    
    
                //内 调  外
                System.out.println(a);
                System.out.println(new Outer3().a);
                System.out.println(Outer3.b);
                System.out.println("局部类的show");
            }
        }
    }

}

7.静态内部类：

package com.practice4;

import com.practice3.Outer;

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

    public static void main(String[] args) {
    
    
        //研究2：外部类调用内部类的成员
        new Inner().a=666;
        new Inner().show1();

        Inner.b=888;
        Inner.show2();
    }
    //静态内部类
    static public class Inner{
    
    
        int a=55;
        static int b=66;
        public void show1(){
    
    
            System.out.println("内部类的实例方法");
        }
        public static void show2(){
    
    
            System.out.println("内部类的静态方法");
        }
        //研究1：内部类种如何调用外部类的成员
        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(Outer2.Inner.b);
            Outer2.show2();
            Outer2.Inner.show2();
        }
    }
}

8.内部比较器案例：

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

package com.practice1;
//内部比较器
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;
    }


}

package com.practice1;

import java.util.Arrays;

public class TestHouse {
    
    
    public static void main(String[] args) {
    
    
        House[] houses ={
    
    
                new House(100,200),
                new House(80,150),
                new House(80.5,90),
                new House(110,190),
                new House(60,160),
        };

        //传统的方式排序--报错--需要让实体类实现Comparable接口
       Arrays.sort(houses);
    }
}

9.外部比较器案例：

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

package com.practice2;

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

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

package com.practice2;

import java.util.Comparator;

public class Mycomparator implements Comparator<Dog> {
    
    

    @Override
    public int compare(Dog o1, Dog o2) {
    
    
        return o1.getName().compareTo(o2.getName());
    }
}

package com.practice2;

import java.util.Arrays;

public class TestDog {
    
    
    public static void main(String[] args) {
    
    
        Dog[] dogs={
    
    
                new Dog("来福",2),
                new Dog("旺财",1),
                new Dog("二哈",4),
                new Dog("金毛",5),
                new Dog("柯基",3),
        };
        Arrays.sort(dogs,new Mycomparator());
        System.out.println(Arrays.toString(dogs));
    }
}

总结

以上就是常用类的全部内容，主要利用了内部类和比较器方面的知识。