Java

您所在的位置：网站首页 › Java中定义类主要分为类的声明和类体 › Java

Java

2023-07-14 03:13| 来源: 网络整理| 查看: 265

目录接口实现接口常用接口：java.util.ComparatorArrays.sort(Object[] arr, Comparator c) 常用接口：java.lang.ComparableArrays.sort(Object[] arr) JDK1.8关于接口的新特性接口的回调与多态接口参数abstract类与接口的比较总结

接口

使用关键字interface来定义一个接口。定义接口包含接口声明和接口体

接口体：只有两种成员（1）全局的静态的常量：public static final，而且这三个单词可以省略

（2）公共的抽象的方法（没有方法体）：public abstract，而且这两个单词可以省略（没有变量，没有普通方法）

interface Printable{ public static final int MAX=100;//等价写法：int MAX=100; 可以省略修饰符 public abstract void add(); //等价写法：void add(); }

接口的思想在于它可以要求某些类有相同名称的方法，但是方法的具体内容（方法体的内容）可以不同，即要求这些类实现接口，以保证这些类一定有接口中声明的方法（方法绑定）。除此之外，接口在要求一些类有相同名称的方法的同时，并不强迫这些类具有相同的父类。（限定某些类，这些类不是同一个父类派生出来的，但是又希望他们有相同的行为特征）

实现接口

类实现接口：在java语言中，接口由类通过关键字implements来实现，以便使用接口中的方法。实现多个接口用逗号隔开。

class A implements Printable,Addable class A extends B implements Printable, Sleepable

重写接口中的方法： 1、一个非抽象类实现某个接口，那么这个类必须重写这个接口中的所有方法。由于接口中的方法是public abstract ，所以类在重写接口方法时不仅要去掉abstract修饰符，而且方法的访问权限一定要显示地用public来修饰。

2、一个抽象类实现某个接口，既可以重写接口中的方法，也可以直接拥有接口中的方法。（抽象类不必重写接口中所有方法）

interface Computable{ final int MAX=100; void speak(String s); int f(int x); float g(float x,float y); } abstract class A implements Computable{ public int f(int x){ int sum =0; for(int i=1;i public static void main(String[] args) { Student s1 = new Student("杨洪强", 24, 89); Student s2 = new Student("苏海波", 23, 100); //比较s1和s2的大小 /*if(s1 > s2){//错误的 < >只用于基本数据类型 System.out.println("s1 > s2"); }*/ AgeComparator c = new AgeComparator(); if(c.compare(s1, s2) > 0){//如果比较s1，s2的结果是正整数，说明s1>s2 System.out.println("s1 > s2的年龄"); }else if(c.compare(s1, s2) System.out.println("s1 = s2的年龄"); } ScoreComparator s = new ScoreComparator(); if(s.compare(s1, s2) > 0){//如果比较s1，s2的结果是正整数，说明s1>s2 System.out.println("s1 > s2的成绩"); }else if(s.compare(s1, s2) System.out.println("s1 = s2的成绩"); } } } //实现Comparator接口，来定制两个学生比较的具体实现方式 //例如：按照年龄比较 class AgeComparator implements Comparator{ @Override public int compare(Object o1, Object o2) { //（1）向下转型 Student s1 = (Student) o1; Student s2 = (Student) o2; //（2）开始比较 if(s1.getAge() > s2.getAge()){ return 1; }else if(s1.getAge() @Override public int compare(Object o1, Object o2) { //（1）向下转型 Student s1 = (Student) o1; Student s2 = (Student) o2; //（2）开始比较 if(s1.getScore() > s2.getScore()){ return 1; }else if(s1.getScore() private String name; private int age; private int score; public Student(String name, int age, int score) { super(); this.name = name; this.age = age; this.score = score; } public Student() { super(); } 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 getScore() { return score; } public void setScore(int score) { this.score = score; } @Override public String toString() { return "Student [name=" + name + ", age=" + age + ", score=" + score + "]"; } } Arrays.sort(Object[] arr, Comparator c)

根据“指定比较器”产生的顺序对指定对象数组进行排序。数组中的所有元素都必须是通过“指定比较器”可相互比较的

public static void sort(Object[] a, Comparator c) 第一个形参：需要排序的数组，Object[]说明可以是任意类型的对象数组第二个形参：比较器对象 Comparator接口不能创建对象，只能传入实现类对象

Student[] all = new Student[5]; all[0] = s1; all[1] = s2; all[2] = new Student("张三",23,88); all[3] = new Student("李四",24,44); all[4] = new Student("王五",25,45); //按年龄比较 Arrays.sort(all, new AgeComparator()); //按照成绩比较 Arrays.sort(all, new ScoreComparator()); for (int i = 0; i public static void main(String[] args) { Student s1 = new Student("杨洪强", 24, 89); Student s2 = new Student("苏海波", 23, 100); //按成绩比较 if(s1.compareTo(s2)>0){ System.out.println("s1 > s2成绩"); }else if(s1.compareTo(s2) System.out.println("s1 = s2成绩"); } //按年龄比较，只能再用定制比较，补充完成这个功能 } } class Student implements Comparable{ private String name; private int age; private int score; public Student(String name, int age, int score) { super(); this.name = name; this.age = age; this.score = score; } public Student() { super(); } 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 getScore() { return score; } public void setScore(int score) { this.score = score; } @Override public String toString() { return "Student [name=" + name + ", age=" + age + ", score=" + score + "]"; } @Override public int compareTo(Object obj) { //this与obj比较，this和obj都是学生对象 Student other = (Student) obj; //例如：对于学生对象来说，最常用的是按成绩排名，那么我就可以把自然顺序定位成绩升序 if(this.score > other.score){ return 1; }else if(this.score public static void main(String[] args) { Student[] all = new Student[5]; all[0] = new Student("杨洪强", 24, 89); all[1] = new Student("苏海波", 23, 100); all[2] = new Student("张三",23,88); all[3] = new Student("李四",24,44); all[4] = new Student("王五",25,45); Arrays.sort(all);//这里面排序过程中，调用了元素本身的compareTo()方法 //因为元素本身是Student类型，它实现了java.lang.Comparable接口 //本身就具备比较大小的能力，即拥有compareTo()方法 for (int i = 0; i public static void main(String[] args) { MyInter.test(); Son s = new Son(); s.test(); } } interface MyInter{ public static void test(){ System.out.println("接口中的静态方法"); } void fun(); public default void method(){ System.out.println("接口中的默认方法"); } } class InterImpl1 implements MyInter{ @Override public void fun() { System.out.println("aaaa"); } } class InterImpl2 implements MyInter{ @Override public void fun() { System.out.println("aaaa"); } } class InterImpl3 implements MyInter{ @Override public void fun() { System.out.println("bbbb"); } //在类中，重写接口的默认方法是，default要去掉 @Override public void method() { System.out.println("重写接口的默认方法"); } } interface A{ public default void test(){ System.out.println("aaa"); } } interface B{ public default void test(){ System.out.println("bbb"); } } class C implements A,B{ //选择一：保留其中一个，放弃另一个 //在类中，重写接口的默认方法是，default要去掉 /* public void test(){ // A.super.test();//保留A接口的实现 B.super.test();//保留B接口的实现 }*/ public void test(){ System.out.println("ccc"); } } class Father{ public void test(){ System.out.println("ffff"); } } interface D{ public default void test(){ System.out.println("dddd"); } } class Son extends Father implements D{ //选择一：默认选择，保留父类的 //选择二：该选，保留干爹的 // public void test(){ // D.super.test(); // } //选择三：完全自己重写 public void test(){ System.out.println("ssss"); } } 接口的回调与多态

接口回调：可以把实现某一接口的类创建的对象的引用赋值给该接口声明的接口变量，那么该接口变量就可以调用被类实现的接口方法。（实际上，当接口变量调用被类实现的接口方法时，就是通知相应的对象调用这个方法，但这个接口变量是无法调用类中其他的非接口方法的，终点强调了这个接口的方法特性——体现类根据接口里的行为标准给出的具体行为）

接口回调类似于向上转型对象调用子类的重写方法。

接口的思想在于它可以要求某些类有相同名称的方法，但方法的具体内容可以不同，即要求这些类实现接口，以保证这些类一定有接口中所声明的方法；接口在要求一些类有相同名称的方法的同时，并不强迫这些类具有相同的父类

接口多态：不同的类在实现同一个接口时可能具有不同的实现方式，那么接口变量在回调接口方法时就可能具有多种形态

interface ShowMessage { void 显示商标(String s); } class TV implements ShowMessage { public void 显示商标(String s) { System.out.println(s); } } class PC implements ShowMessage { public void 显示商标(String s) { System.out.println(s); } } public class Example6_2 { public static void main(String args[]) { ShowMessage sm; //声明接口变量 sm=new TV(); //接口变量中存放对象的引用 sm.显示商标("长城牌电视机"); //接口回调。 sm=new PC(); //接口变量中存放对象的引用 sm.显示商标("联想奔月5008PC机"); //接口回调 } } 接口参数

如果一个方法的参数是接口类型，可以将任何实现该接口的类的实例引用传递给该接口参数，那么接口参数就可以回调类实现的接口方法。（和向上转型一样，不用重载多个方法）

interface SpeakHello { void speakHello(); } class Chinese implements SpeakHello { public void speakHello() { System.out.println("中国人习惯问候语：你好,吃饭了吗? "); } } class English implements SpeakHello { public void speakHello() { System.out.println("英国人习惯问候语:你好,天气不错 "); } } class KindHello { public void lookHello(SpeakHello hello) { //接口类型参数 hello.speakHello(); //接口回调 } } public class Example6_5 { public static void main(String args[]) { KindHello kindHello=new KindHello(); kindHello.lookHello(new Chinese()); kindHello.lookHello(new English()); } } abstract类与接口的比较

1、abstract类和接口都可以有abstract方法。 2、接口中只可以有常量，不能有变量；而abstract类中既可以有常量，也可以有变量。 3、abstract类中也可以有非abstract方法，接口不可以。

abstract类除了提供重要的需要子类重写的abstract方法，也提供了子类可以继承的变量和非abstract方法。

如果某个问题需要使用继承才能更好地解决，例如，子类除了需要重写父类的abstract方法，还需要从父类继承一些变量或一些重要的非abstract方法，就可以考虑使用abstract类。如果不需要继承，只需要若干个类给出某些重要的abstract方法的实现细节，就可以考虑使用接口。

总结

可以将接口理解为类的继承（一种特殊的父类），无论是从形式上，还是使用方法上。

子类重写父类方法近似实现类“重写”接口的抽象方法。子类向上转型近似实现类回调接口方法。

【本文地址】

Java

Java

今日新闻

推荐新闻