Java【14_3】接口(Comparable和Comparator)、内部类-示例

最新推荐文章于 2025-05-17 17:01:31 发布

keke10

最新推荐文章于 2025-05-17 17:01:31 发布

阅读量371

点赞数 22

文章标签： java 开发语言 servlet

本文链接：https://blog.csdn.net/keke10/article/details/148026299

版权

示例：单继承与实现多接口(JDK1.8 新增：静态方法、默认方法)
public class Demo1 {
public static void main(String[] args) {
Fly.staticMethod();//StaticMethod的修饰符是public(跨类调用了)

Aircraft aircraft=new Aircraft(); //飞机
aircraft.defaultMethod();//通过实现类的对象调用

aircraft.function();//调用的是谁的？父类的

aircraft.fly();
}
}

public interface Fly {
void fly();//抽象方法

//公有的静态方法 --> 通过对象或者类名调用
//好多接口，都会伴随着工具类 Collection --> Collections(对Collection的操作)
static void staticMethod(){
System.out.println("Fly中的静态方法。。。");
}
//公有的默认方法接口中的普通方法
default void defaultMethod(){
System.out.println("Fly中的默认方法");
}

default void function(){
System.out.println("这是父接口fly中的function方法。。。");
}
}

public class Aircraft extends Car implements Fly,Run {

@Override
public void run() {

}

public void function(){
//System.out.println("实现类重写后的function");
//就想用fly中的function
Fly.super.function();//调用Fly中的function
Run.super.function();//调用Run中的function

super.function();//调用父类的--继承的知识点
}

/*
静态方法，不是重写，自己的方法
*/
/*public void staticMethod(){

}*/

public void defaultMethod(){
System.out.println("飞机重写的默认方法。。");
}
}

public class Car {

public void function(){
System.out.println("这是父类中的function...");
}

public void fly(){}
}

public interface Run {
void run();

default void function(){
System.out.println("这是父接口Run中的function方法。。。");
}
}

D:\javademo\day14_am>javac Demo1.java
D:\javademo\day14_am>java Demo1
Fly中的静态方法。。。
飞机重写的默认方法。。
这是父接口fly中的function方法。。。
这是父接口Run中的function方法。。。
这是父类中的function...

上面代码中，如果把 Aircraft类中的“public void function()”函数去掉，【亲爹优先】输出如下

D:\javademo\day14_am>java Demo1
Fly中的静态方法。。。
飞机重写的默认方法。。
这是父类中的function...

示例：Comparable(自然排序) 与 Comparator(定制排序) 实现对象数组按某属性升序排序
import java.util.Arrays;

public class Demo2 {
public static void main(String[] args) {
int[] arrs={1,2,4,6,7,3};

Person[] persons=new Person[5];
persons[0]=new Person(1,"翠花",18);
persons[1]=new Person(2,"小芬",28);
persons[2]=new Person(3,"lily",16);
persons[3]=new Person(4,"狗蛋",38);
persons[4]=new Person(5,"石破天",19);

//面向过程对persons数组排序！根据age排序！
/*for (int i = 0; i < persons.length-1; i++) {
for (int j = 0; j < persons.length-i-1; j++) {
if(persons[j].getAge()>persons[j+1].getAge()){
Person temp=persons[j];
persons[j]=persons[j+1];
persons[j+1]=temp;
}
}
}*/
//面向对象-->谁能完成次任务！Arrays.sort();
//sort方法也不知道根据什么排！Person类自己创建的，属性自己制定的
//sort方法会自动调用compareTo方法，此时可以使用sort方法对Person数组排序了
Arrays.sort(persons);

//java官方：
// 得解决这个问题！定义一个规范！如果用户(程序员)想通过sort方法进行排序
// 必须实现我们的规范(一个接口)，制定根据什么排，并且指定，降序或者升序
// 为什么官方需要你去实现接口，因为sort方法需要调用该接口中的compareTo方法
// 实现接口就必须实现compareTo方法！

for (int i = 0; i < persons.length; i++) {
System.out.println(persons[i]);
}
}
}

import java.util.Comparator;

public class Person implements Comparable {
private int id;
private String name;
private int age;

public Person(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}

public Person() {
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

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 "Person{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
/*
根据age对比大小
per1--this
per2--o
*/
//年龄从小->大【比较规则：this 和传入的对象比较：返回 >0 =0 <0】
@Override
public int compareTo(Object o) {//多态参数 Object o=new Person()
if(this==o)//地址一样，是同一个对象，返回0
return 0;
if(o instanceof Person){//
Person per=(Person)o;
return this.age-per.age;
}
//如果o不是person类型，我就认为是this小
return -1;
}
}

D:\javademo\day14_am>javac Demo2.java
D:\javademo\day14_am>java Demo2
Person{id=3, name='lily', age=16}
Person{id=1, name='翠花', age=18}
Person{id=5, name='石破天', age=19}
Person{id=2, name='小芬', age=28}
Person{id=4, name='狗蛋', age=38}

示例：单独比较两个对象大小
public class Demo3 {
public static void main(String[] args) {
Person per1=new Person(1,"张三",26);
Person per2=new Person(2,"李四",25);
//比较这两个对象的大小！
int i = per1.compareTo(per2);
System.out.println(i);
}
}

D:\javademo\day14_am>java Demo3
1

输出 >0 说明：per1 比 per2 大

示例：Comparator(定制排序)
import java.util.Arrays;
import java.util.Comparator;

public class Demo4 {
public static void main(String[] args) {
Person[] persons=new Person[5];
persons[0]=new Person(1,"翠花",18);
persons[1]=new Person(2,"小芬",28);
persons[2]=new Person(3,"lily",16);
persons[3]=new Person(4,"狗蛋",38);
persons[4]=new Person(5,"石破天",19);

Arrays.sort(persons,new MyComparator());//自然排序
//前提：你没有权限修改Person类的代码！有可能是第三方的产品(class文件)
//如何排序：采用定制排序
//如果Person有自然排序,根据年龄从小到大
//自然排序不满足我的要求，我想要根据age从大到小
/*
1. 改自然排序万万使不得
当你遇到现在的需求的时候，发现自然排序已存在！
肯定是之前有其他人有目前自然排序的需求！如果你修改
会为别人(半年前的自己)带来麻烦
不要修改动别人写的代码！
2. 采用定制排序(就是定制和自然都存在，是以定制为主)
*/

for (int i = 0; i < persons.length; i++) {
System.out.println(persons[i]);
}
}
}
//作为定制排序的实现类
class MyComparator implements Comparator {

@Override
public int compare(Object o1, Object o2) {
if(o1==o2)
return 0;
if(o1 instanceof Person && o2 instanceof Person){
Person per1=(Person)o1;
Person per2=(Person)o2;
//这边刚好是int型可以相减，【如果是 double型，可以通过 if(db1 > db2) return 1; …… 判断返回 0 或 -1
//或者 return Double.compare(db1, db2);】
return per2.getAge()-per1.getAge();
}
return -1;
}
}

D:\javademo\day14_am>javac Demo4.java
注: Demo4.java使用了未经检查或不安全的操作。
注: 有关详细信息, 请使用 -Xlint:unchecked 重新编译。

D:\javademo\day14_am>java Demo4
Person{id=4, name='狗蛋', age=38}
Person{id=2, name='小芬', age=28}
Person{id=5, name='石破天', age=19}
Person{id=1, name='翠花', age=18}
Person{id=3, name='lily', age=16}

如果想查看编译时警告信息，可以如下：
D:\javademo\day14_am>javac -Xlint:unchecked Demo4.java

示例：Comparator(定制排序) 采用匿名内部类按id降序
import java.util.Arrays;
import java.util.Comparator;

public class Demo5 {
public static void main(String[] args) {
/*new Car();//实例化了一个匿名对象(没有引用) */
//抽象类和接口是不能够实例化对象的！都是通过其子类去使用的！
Person[] persons=new Person[5];
persons[0]=new Person(1,"翠花",18);
persons[1]=new Person(2,"小芬",28);
persons[2]=new Person(3,"lily",16);
persons[3]=new Person(4,"狗蛋",38);
persons[4]=new Person(5,"石破天",19);
//2. 定制排序的规则时，先创建一个实现类，在实现抽象方法
//相当于创建了一个Comparator接口实现类的对象，
// 实现类没有名称，所以称之为匿名内部类
Comparator comparator=new Comparator(){
//此处相当于是Comparator接口的实现类的类体
@Override
public int compare(Object o1, Object o2) {
if(o1==o2)
return 0;
if(o1 instanceof Person && o2 instanceof Person){
Person per1=(Person)o1;
Person per2=(Person)o2;
return per2.getId()-per1.getId();
}
return -1;
}
};

Arrays.sort(persons,comparator);//定制排序

for (int i = 0; i < persons.length; i++) {
System.out.println(persons[i]);
}

//匿名内部类
new Car(){
//此处的大括号相当于是Car子类的类体
};

new Animal(){
//此处的大括号相当于Animal子类的类体
@Override
public void method() {

}
};

}
}

public abstract class Animal {
public abstract void method();
}

D:\javademo\day14_am>javac Demo5.java
D:\javademo\day14_am>java Demo5
Person{id=5, name='石破天', age=19}
Person{id=4, name='狗蛋', age=38}
Person{id=3, name='lily', age=16}
Person{id=2, name='小芬', age=28}
Person{id=1, name='翠花', age=18}

示例：成员内部类、静态成员内部类、方法(局部)内部类
//Outher外部类
public class Outher {
private int id=10;
private static int age=18;
public Outher(){}
{}

public void function(){
int id=30;//局部变量如果内部类有id,局部变量就无法访问

//如果局部内部类使用了，当前局部的局部变量，那么该变量必须是常量！
//为什么要有这个要求？因为Inner3对象的生命周期比，局部变量要长！
//方法内部类
class Inner3{
private String email;
//private int id=20;
public Inner3(){}
{}
public void inner3Method(){
System.out.println(id);//说明id不是常量，用不了！
//想用Outher的id
System.out.println(Outher.this.id);//10
}
class Inner33{}
}
//id=40; //【报错】，因为Inner3局部内部类中有用到id，则这边id就变成常量；上面灰色注释去掉，这边不会报错

Inner3 inner3=new Inner3();
inner3.inner3Method();
}

/*public void method2(){
Inner3 inner3=new Inner3();//创建不了Inner3的对象
System.out.println(email);
inner3Method();
}*/

//成员内部类 Outher$Inner1.class
public class Inner1{//成员内部类的对象实例化，依赖于外部类的对象
private int id=20;
private String name;
{}
public Inner1(){}
public void inner1Method(){
//可以使用id? 可是调用method1吗？
/*System.out.println(id);
System.out.println(age);
System.out.println(name);
method1();*/
System.out.println(this.id);//如果重名，就近原则！
//如果想用外部类的怎么办
System.out.println(Outher.this.id);
System.out.println(Outher.age);//因为是静态的
}
class Inner11{}
}
//静态成员内部类
public static class Inner2{//不依赖于外部类的对象
private int id=20;
private int age=20;
private String phone;
private static String address;
{}
static{}
public Inner2(){}
public static void inner2StaticMethod(){
Outher outher=new Outher();
System.out.println(outher.id);
//System.out.println(id);
//System.out.println(age);
/*method1();*/
}
public void inner2Method(){
System.out.println(age);//默认就近原则
System.out.println(Outher.age);//外部类的age
}
class Inner22{}
}
public void method1(){
//外部类的method1方法
Inner1 inner1=new Inner1();
System.out.println(inner1.name);
inner1.inner1Method();