码迷,mamicode.com
首页 > 其他好文 > 详细

接口,Comparable和Comparator

时间:2019-04-02 21:18:42      阅读:174      评论:0      收藏:0      [点我收藏+]

标签:成员   隐式   ace   tst   prot   else   return   类继承   system   

 

1.抽象类和接口的区别

  抽象类

    含有abstract修饰符的class 即为抽象类,abstract类不能创建实例对象,含有abstract的方法的类必须定义为abstract class ,abstract class 里的方法不必是抽象的,抽

   象类定义抽象方法必须放在具体子类中实现,所以,不能有抽象的构造方法或抽象的静态方法,如果子类没有实现抽象父类中的所有方法,那么,子类也必须定义为抽象类。

     接口(interface):

    可以说成是抽象类的特例。接口中的所有方法都必须是抽象的,接口中的方法定义默认为public  abstract 。接口中的变量是全局常量,即public static final修饰的。

在语法上的区别:

   a. 抽象类里可以有构造方法,而接口内不能有构造方法。

   b. 抽象类中可以有普通成员变量,而接口中不能有普通成员变量。

   c. 抽象类中可以包含非抽象的普通方法,而接口中所有的方法必须是抽象的,不能有非抽象的普通方法。

   d. 抽象类中的抽象方法的访问类型可以是public ,protected和默认类型,但接口中的抽象方法只能是public类型的,并且默认即为public abstract类型。

   e. 抽象类中可以包含静态方法,接口内不能包含静态方法。

   f. 抽象类和接口中都可以包含静态成员变量,抽象类中的静态成员变量的访问类型可以任意,但接口中定义的变量只能是public  static类型,并且默认为public static类型。

   g. 一个类可以实现多个接口,但只能继承一个抽象类。

设计思想上的区别:

    抽象类:找到类和类之间的共性,慢慢向上提取,一种自底而上抽象出来的
      对象-->类-->父类-->抽象类
    接口:考虑不同类之间的通用功能的扩展,一种自顶向下的设计思想

      创建一个飞的接口,超人飞,小鸟飞,飞机飞,都要实现这个接口

再补充点两者在应用上的区别:

   a. 接口更多的是在系统框架设计方法发挥作用,主要定义模块之间的通信,而抽象类在代码实现方面发挥作用,可以实现代码的重用。

   b. 在JDK1.8之后可以添加有实现的方法。

2.什么是接口

  Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)。

  接口是把隐式公共方法和属性组合起来,以封装特定功能的一个集合。一旦类实现了接口,类就可以支持接口所指定的所有属性和成员。

3.使用接口的好处

  a.弥补了java不能多继承的缺点

  b.

4.接口的使用步骤:

  1.实现接口 implements 
  2.重写方法
  3.传递接口实现类 使用instantsOf

5.理解(转)

  这个问题这困扰了我很久,后来我才想明白,大家都说接口就是实现扩展功能用的,这句话其实是最误导人的,因为接口本身并没有实现方法,它只是一条路,是一个工具,千万别想复杂,真正实现功能扩展的是实现方法的对象和调用接口的方法。下面举个栗子。
  狗这个类继承了走兽类,它有跑,跳,啃,等方法。但是它不会飞,它的父类也没有这个方法。但是你想让狗有飞这个功能,怎么办呢?当然你可以直接在狗的类中给它添加一个飞的方法就行了。有可能你并不会写这个方法,或者是这个方法需要几千几万行代码,硬写吗?那以后你还想要猪,牛,羊等等都可以飞呢?那又怎么办呢?这时候你发现你有一个类,这个类就叫飞行兽吧。它有一个方法就是飞行,这下好了,你决定让狗继承它,结果发现不能多继承,你又想让狗的父类继承它,结果发现还有其他的走兽不能让他们飞。这时候就需要接口出来了,这个接口我们叫它插翅膀吧,这个接口有一个方法就是插翅膀,但没有实现,因为接口不管你怎么给狗插翅膀。同时你还发现在飞行兽里有一个带参数的构造方法,而参数类型就是这个接口类型。但是狗的类型是狗而不是接口类型,没法作为参数传进去,这时你就可以让狗实现这个接口,这个狗对象就成了插了翅膀的狗,接着通过多态的原理把插了翅膀的狗这个对象传给飞行兽,这狗这就成了飞行兽,可以飞了。
  ChiBang chibangdog=new Dog()
  FlyShou flydog =new FlyShou(chibangdog)

可以飞的狗就出来了,以后要猪飞就让猪实现插翅膀,要羊飞就让羊实现插翅膀,要牛飞就......直接吹吧。不知道这样说明白没有。

  1 //实现Comparable类
  2 public class Student implements Comparable<Student> {
  3     private String name;
  4     private int age;
  5     private int iD;
  6 
  7     public Student(String name, int age, int iD) {
  8         super();
  9         this.name = name;
 10         this.age = age;
 11         this.iD = iD;
 12     }
 13 
 14     @Override
 15     public String toString() {
 16         return "Student [name=" + name + ", age=" + age + ", iD=" + iD + "]";
 17     }
 18 
 19     public String getName() {
 20         return name;
 21     }
 22 
 23     public void setName(String name) {
 24         this.name = name;
 25     }
 26 
 27     public int getAge() {
 28         return age;
 29     }
 30 
 31     public void setAge(int age) {
 32         this.age = age;
 33     }
 34 
 35     public int getiD() {
 36         return iD;
 37     }
 38 
 39     public void setiD(int iD) {
 40         this.iD = iD;
 41     }
 42 
 43     @Override
 44     public int compareTo(Student o) {
 45 
 46         return this.age - o.age;
 47     }
 48 
 49 }
 50 
 51 public class School {
 52     private Student[] students;
 53 
 54     public Student[] getStudents() {
 55         return students;
 56     }
 57 
 58     public void setStudents(Student[] students) {
 59         this.students = students;
 60     }
 61 
 62     @Override
 63     public String toString() {
 64         return "School [students=" + Arrays.toString(students) + "]";
 65     }
 66 
 67 }
 68 
 69 public class SchoolTest {
 70     public static void main(String[] args) {
 71         School sc = new School();
 72         Student[] students = new Student[3];
 73 //        Student stu = null;
 74 
 75         students[0] = new Student("林青霞", 18, 1);
 76         students[1] = new Student("杨坤", 12, 2);
 77         students[2] = new Student("周杰伦", 20, 3);
 78         sc.setStudents(students);
 79 //Student没有排序的方法,这个方法的底层是靠Comparable接口的CompareTo方法实现排序的,
 80 //        如果要让学生有比较功能,那就要实现这个比较接口,然后通过多态的方式把学生这个类的对象传递Object,这样就可以比较了
 81         Arrays.sort(students);
 82         System.out.println(sc.toString());
 83 
 84     }
 85 
 86 }
 87 
 88 //sort内部使用学生类调用了compareTo
 89   // Find end of run, and reverse range if descending
 90         if (((Comparable) a[runHi++]).compareTo(a[lo]) < 0) { // Descending
 91             while (runHi < hi && ((Comparable) a[runHi]).compareTo(a[runHi - 1]) < 0)
 92                 runHi++;
 93             reverseRange(a, lo, runHi);
 94         } else {                              // Ascending
 95             while (runHi < hi && ((Comparable) a[runHi]).compareTo(a[runHi - 1]) >= 0)
 96                 runHi++;
 97         }
 98 
 99         return runHi - lo;
100     }
101 School [students=[Student [name=杨坤, age=12, iD=2], Student [name=林青霞, age=18, iD=1], Student [name=周杰伦, age=20, iD=3]]]

 

 

//自定义比较器,调用的是sort(T[] a, Comparator<? super T> c) 
 //         根据指定比较器产生的顺序对指定对象数组进行排序。
public class Student {
    private String name;
    private int age;
    private int iD;

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

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", 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;
    }

    public int getiD() {
        return iD;
    }

    public void setiD(int iD) {
        this.iD = iD;
    }
}
//比较器
public class StudentTest {

    public static void main(String[] args) {
        Student st1 = new Student("zs", 12, 1);
        Student st2 = new Student("ls", 10, 2);
        Student st3 = new Student("ww", 19, 3);
        Student[] students = { st1, st2, st3 };
        Arrays.sort(students, new MynameascComparator());
        System.out.println(Arrays.toString(students));

    }
}
//测试类
public class MynameascComparator implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {
        if (o1 instanceof Student && o2 instanceof Student) {
            Student one = (Student) o1;
            Student another = (Student) o2;
            return one.getName().compareTo(another.getName());
        }
        return 0;
    }

}
执行结果:
[Student [name=ls, age=10, iD=2], Student [name=ww, age=19, iD=3], Student [name=zs, age=12, iD=1]]

 

//使用匿名内部类改写Comparator
public class Student {
    private String name;
    private int age;
    private int iD;

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

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", 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;
    }

    public int getiD() {
        return iD;
    }

    public void setiD(int iD) {
        this.iD = iD;
    }
}

import java.util.Arrays;
import java.util.Comparator;

public class StudentTest {

    public static void main(String[] args) {
        Student st1 = new Student("zs", 12, 1);
        Student st2 = new Student("ls", 10, 2);
        Student st3 = new Student("ww", 19, 3);
        Student[] students = { st1, st2, st3 };
        Arrays.sort(students, new Comparator() {

            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Student && o2 instanceof Student) {
                    Student one = (Student) o1;
                    Student another = (Student) o2;
                    return one.getName().compareTo(another.getName());
                }
                return 0;
            }
        });
        System.out.println(Arrays.toString(students));

    }
}
执行结果
[Student [name=ls, age=10, iD=2], Student [name=ww, age=19, iD=3], Student [name=zs, age=12, iD=1]]

6.匿名内部类

  

接口,Comparable和Comparator

标签:成员   隐式   ace   tst   prot   else   return   类继承   system   

原文地址:https://www.cnblogs.com/19322li/p/10645152.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!