/*
* 语法1：使用interface关键字定义
* 语法2：接口中，允许定义“抽象方法”，public 和 abstract关键字可以省略
* 语法3：接口中，允许定义“默认方法”
* 语法4：实现类通过implements关键字实现接口，可以同时实现多个接口
*/
package com.ztt.Demo01MyInterface;
/*
* 语法1：使用interface关键字定义
* 语法2：接口中，允许定义“抽象方法”，public 和 abstract关键字可以省略
* 语法3：接口中，允许定义“默认方法”
* 语法4：实现类通过implements关键字实现接口，可以同时实现多个接口
*/
public interface MyInterface {
//允许定义“抽象方法”
void dosth();
public abstract void absTDowork();
//允许定义“默认方法”
public default void dolist() {
}
//不允许定义“构造方法”
// public MyInterface() {
//
// }
//不允许定义“普通方法”
// public void dolist() {
//
// }
}
class Ext implements MyInterface,AnotherInterface{
@Override
public void dosth() {
// TODO Auto-generated method stub
}
@Override
public void absTDowork() {
// TODO Auto-generated method stub
}
@Override
public void todo() {
// TODO Auto-generated method stub
}
}
package com.ztt.Demo01MyInterface;
public interface AnotherInterface {
public default void todo() {
}
}package com.ztt.Demo01MyInterface;
import java.util.Arrays;
import java.util.Comparator;
//interface 接口的使用场景：Arrays.sort()方法自定义排序
public class test1 {
public static void main(String[] args) {
String[] arr= {"def","abcd","abb","aaa","hij","aaaa","bnn","cdd"};
//默认按照字符串的ASCII码值进行比较
//Arrays.sort(arr);
//按照字符串的长度进行比较，如果长度一致，再按照ASCII码值进行比较
//默认升序
StringLengthAndAsciiComparator comp1=new StringLengthAndAsciiComparator();
//升序
Arrays.sort(arr,comp1);
//降序
Comparator<String> comp2=comp1.reversed();
Arrays.sort(arr,comp2);
for(String s:arr) {
System.out.println(s);
}
}
}
//Comparator接口实现类：封装“排序是的比较”逻辑
class StringLengthAndAsciiComparator implements Comparator<String>{
//正数代表o1>o2
//负数代表o1>o2
//零代表o1=o2
public int compare(String o1,String o2) {
//按照字符串的长度进行比较，如果长度一致，再比较Ascii码值进行比较
if(o1.length()==o2.length()) {
//按照字符串Ascii码值进行比较
return o1.compareTo(o2);
}
return o1.length()-o2.length();
}
}
运行结果：
def
cdd
bnn
abb
aaapackage com.ztt.Demo01MyInterface;
import java.util.Arrays;
import java.util.Comparator;
public class test2 {
public static void main(String[] args) {
//对象数组
Book[] books = {
new Book("E",1247,17.85,10005),
new Book("A",8547,33.58,10005),
new Book("H",7413,18.88,10007),
new Book("K",9631,19.85,10001),
new Book("B",7581,22.51,10006),
new Book("M",1574,16.89,10002)
};
//排序
//按照图书名称进行比较排序
BookNameComparator comp1=new BookNameComparator();
// Arrays.sort(books,comp1);
//按照图书页数进行比较排序
BookPageSizeComparator comp2=new BookPageSizeComparator();
//传入不同的Comparator比较器对象
//比较规则不同，则排序结果不同
//Arrays.sort( books, comp2);
//按照默认比较规则
Arrays.sort(books);
//输出
for(Book b: books) {
System.out.println(b);
}
}
}
//按照图书名称进行"自定义比较规则"
class BookNameComparator implements Comparator<Book>{
@Override
public int compare(Book b1, Book b2) {
// 按照书名进行比较
return b1.getBookName().compareTo(b2.getBookName());
}
}
//按照图书页数进行"自定义比较规则"
class BookPageSizeComparator implements Comparator<Book>{
@Override
public int compare(Book o1, Book o2) {
// 按照页数进行比较
return o1.getPageSize()-o2.getPageSize();
}
}
//图书类
class Book implements Comparable<Book>{
private String bookName;//图书名称
private int pageSize;//总页数
private double price;//销售价格
private int sale;//销量
public Book(String bookName,int pageSize,double price,int sale) {
this.bookName=bookName;
this.pageSize=pageSize;
this.price=price;
this.sale=sale;
}
//实现Comparable接口时，重写compareTo
@Override
public int compareTo(Book anotherBook) {
// this和anotherBook进行比较
//默认按照销量进行比较
return this.getSale()-anotherBook.getSale();
}
//重写Object类的toString()方法
@Override
public String toString() {
return String.format("<<%s>>,共计%d页，销售价格$%.2f, 总销量%d本",bookName,pageSize,price,sale);
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public int getPageSize() {
return pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getSale() {
return sale;
}
public void setSale(int sale) {
this.sale = sale;
}
}
运行结果：
<<K>>,共计9631页，销售价格$19.85, 总销量10001本
<<M>>,共计1574页，销售价格$16.89, 总销量10002本
<<E>>,共计1247页，销售价格$17.85, 总销量10005本
<<A>>,共计8547页，销售价格$33.58, 总销量10005本
<<B>>,共计7581页，销售价格$22.51, 总销量10006本
<<H>>,共计7413页，销售价格$18.88, 总销量10007本
小结
1.Java的接口( interface )用于定义纯粹的抽象行为(方法)规范。
2.一个类只能extends继承自另一个类(单继承)。但是，一个类可以implements实现多个interface接口(多重实现)。
3.一个interface可以继承自多个interface(接口之间允许多重继承)。。一个类实现interface接口时，要求必须实现该接口中所有的抽象方法。
4.接口也是一种“高层”的数据类型，可以用于定义“引用”的类型，也适用于"向上转型"和"向下转型"。·接口不允许实例化。
5.接口的所有方法都是抽象方法，接口不能定义实例字段(成员变量)。
6.接口可以定义default方法（[ JDK版本>= 1.8 ) , default方法可以包含方法体。7.实现 Comparable接口的类，该类的对象之间可以进行“比较”，用于“排序”。?
?
?
?
?
?
?
?
?