• java约定，当把一些共用骨架功能抽取出为一个父类时，可定义为Abstract抽象类

  • 如果需要要求子类去覆盖抽象类的某个方法，却不想提供默认实现，可采取如下策略：

    • 运行时策略，丢出异常 throw new UnsupportedOperationException();
    • 编译时策略，方法抽象化 public abstract void foo();

      抽象类

  • 抽象类用Abstaract声明，与类无本质区别，好处是可以声明抽象方法，要求子类必须实现抽象方法覆盖

  • 抽象类不能被实例化，可以包含成员变量等普通类的任何内容
  • 可以实例化的类一定要补全所有的方法体，这样实例的方法在被调用时才能提供具体的功能

  • 可以包含抽象方法，抽象方法不能是private或static的

    接口

  • 接口不是类，只代表一种功能，接口可以视为 所有方法均为抽象的“类”

  • 接口只代表一种功能，例如 public class 鸟 extends 动物 implements 会飞,会呼吸,会新陈代谢
  • 类继承就是is，接口则表示can 它拥有什么功能
  • 经典的接口定义是不能提供任何方法实现的，java8后可提供默认方法
  • 接口可以通过继承实现所有父接口的抽象方法
  • 实现某个接口的类需要实现接口的所有方法，除非是抽象类
  • 接口中的成员均为 public static final的，这样的常量为全大写

  • 接口一旦发布则无法增添方法，否则打破了向后兼容性backward compatibility

    默认方法

  • java8之前接口只有抽象方法，所有方法没有具体实现，之后包含了具有方法体的默认方法

  • 默认方法是为了保证向后兼容性，既为接口增加了新功能，也没有破坏实现该接口的用户代码
  • 但是默认方法的引入出现了二义性，因为一个类是可以实现多个接口的，如果两个接口提供了相同方法名的默认方法，就出现了选择二义性问题

    接口与抽象类对比

    | | 抽象类 | 接口 | | —- | —- | —- | | 相同 | 抽象的，不可实例化 | 抽象的，不可实例化 | | 相同 | 包含抽象方法
    （没有方法体，非static、private、final的） | 包含抽象方法
    （没有方法体，非static、private、final的） | | 不同 | 是类，可以包含类的一切东西 | 只能包含受限的成员（public static final）
    和方法（抽象方法和默认方法） | | 不同 | 只能单一继承 | 可以多继承，甚至继承多次 |

小结

  • java设计类与接口体系的原因是实现最大程度的灵活性与最大程度的代码复用
  • 实现某个接口代表对面向对象系统做出一种承诺，当你对该类成员调用某方法时，可以利用多态做出正确的响应
  • instanceof不仅仅可以检测是否是一个对象的实例，也可以检测是否是一个接口的实例

  • API应用程序接口（application program interface）和java中的接口有相似的含义，代表和一个系统通信时遵循的一系列约定

    实战案例

  • Comparable接口，（set中要避免比较完毕返回0）

  • Comparable接口，（使用collection.sort对某类型）
  • 实现一个通用的过滤器
  • Files.walkFileTree 自定义实现一个文件过滤器 ```java // comparable约定自然顺序为从小到大，ab返回正数，a=b返回0 // 修复compareTo方法不正确实现导致产生相同对象，进而导致set错误丢失对象的问题 import java.util.Arrays; import java.util.List; import java.util.Objects; import java.util.TreeSet;

public class User implements Comparable { /* 用户ID，数据库主键，全局唯一 / private final Integer id;

  1. /** 用户名 */
  2. private final String name;
  4. public User(Integer id, String name) {
  5.     this.id = id;
  6.     this.name = name;
  7. }
  9. public Integer getId() {
  10.     return id;
  11. }
  13. public String getName() {
  14.     return name;
  15. }
  17. @Override
  18. public boolean equals(Object o) {
  19.     if (this == o) {
  20.         return true;
  21.     }
  22.     if (o == null || getClass() != o.getClass()) {
  23.         return false;
  24.     }
  26.     User person = (User) o;
  28.     return Objects.equals(id, person.id);
  29. }
  31. @Override
  32. public int hashCode() {
  33.     return id != null ? id.hashCode() : 0;
  34. }
  36. /** 老板说让我按照用户名排序 */
  37. @Override
  38. public int compareTo(User o) {
  39.     if(name.compareTo(o.name)==0){
  40.         return id.compareTo(o.id);
  41.     }
  42.     return name.compareTo(o.name);
  43. }
  45. public static void main(String[] args) {
  46.     List<User> users =
  47.             Arrays.asList(
  48.                     new User(100, "b"),
  49.                     new User(10, "z"),
  50.                     new User(1, "a"),
  51.                     new User(2000, "a"));
  52.     TreeSet<User> treeSet = new TreeSet<>(users);
  53.     // 为什么这里的输出是3？试着修复其中的bug
  54.     System.out.println(treeSet.size());
  55. }

}

  1. ```java
  2. 使用Collection.sort对某类型排序，需要在该类实现comparable接口
  3. import java.io.IOException;
  4. import java.util.Arrays;
  5. import java.util.Collections;
  6. import java.util.List;
  9. public class Point implements Comparable<Point> {
  11.     private final int x;
  12.     private final int y;
  13.     // 代表笛卡尔坐标系中的一个点
  14.     public Point(int x, int y) {
  15.         this.x = x;
  16.         this.y = y;
  17.     }
  19.     public int getX() {
  20.         return x;
  21.     }
  23.     public int getY() {
  24.         return y;
  25.     }
  28.     @Override
  29.     public boolean equals(Object o) {
  30.         if (this == o) {
  31.             return true;
  32.         }
  33.         if (o == null || getClass() != o.getClass()) {
  34.             return false;
  35.         }
  37.         Point point = (Point) o;
  39.         if (x != point.x) {
  40.             return false;
  41.         }
  42.         return y == point.y;
  43.     }
  45.     @Override
  46.     public int hashCode() {
  47.         int result = x;
  48.         result = 31 * result + y;
  49.         return result;
  50.     }
  52.     @Override
  53.     public String toString() {
  54.         return String.format("(%d,%d)", x, y);
  55.     }
  58.     // 按照先x再y，从小到大的顺序排序
  59.     // 例如排序后的结果应该是 (-1, 1) (1, -1) (2, -1) (2, 0) (2, 1)
  60.     public static List<Point> sort(List<Point> points) {
  61.         Collections.sort(points);
  62.         return points;
  63.     }
  65.     public static void main(String[] args) throws IOException {
  66.         List<Point> points =
  67.                 Arrays.asList(
  68.                         new Point(2, 0),
  69.                         new Point(-1, 1),
  70.                         new Point(1, -1),
  71.                         new Point(2, 1),
  72.                         new Point(2, -1));
  73.         System.out.println(Point.sort(points));
  74.     }
  76.     @Override
  77.     public int compareTo(Point o) {
  78.         if(x < o.getX()){
  79.             return -1;
  80.         }else if(x > o.getX()){
  81.             return 1;
  82.         }
  84.         if(y < o.getY()){
  85.             return -1;
  86.         }else if(y > o.getY()){
  87.             return 1;
  88.         }
  89.         return 0;
  90.     }
  91. }
  1. // 通过predicate接口抽取公用过滤器函数，以内置匿名类的策略模式简化代码
  2. // 通过jdk内置Predicate（判定）函数接口将上述代码抽取成一个公用的过滤器函数
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.function.Predicate;
  7. public class User {
  8.     /** 用户ID，数据库主键，全局唯一 */
  9.     private final Integer id;
  11.     /** 用户名 */
  12.     private final String name;
  14.     public User(Integer id, String name) {
  15.         this.id = id;
  16.         this.name = name;
  17.     }
  19.     public Integer getId() {
  20.         return id;
  21.     }
  23.     public String getName() {
  24.         return name;
  25.     }
  27.     // 过滤ID为偶数的用户
  28.     public static List<User> filterUsersWithEvenId(List<User> users) {
  29.         return User.filter(users, new Predicate<User>() {
  30.             @Override
  31.             public boolean test(User o) {
  32.                 return o.id % 2 == 0;
  33.             }
  34.         });
  35.     }
  37.     // 过滤姓张的用户
  38.     public static List<User> filterZhangUsers(List<User> users) {
  39.         return User.filter(users, new Predicate<User>() {
  40.             @Override
  41.             public boolean test(User o) {
  42.                 return o.getName().startsWith("张");
  43.             }
  44.         });
  45.     }
  47.     // 过滤姓王的用户
  48.     public static List<User> filterWangUsers(List<User> users) {
  49.         return User.filter(users, new Predicate<User>() {
  50.             @Override
  51.             public boolean test(User o) {
  52.                 return o.getName().startsWith("王");
  53.             }
  54.         });
  55.     }
  57.     public static List<User> filter(List<User> users, Predicate<User> predicate) {
  58.         List<User> results = new ArrayList<>();
  59.         for (User user : users) {
  60.             if (predicate.test(user)) {
  61.                 results.add(user);
  62.             }
  63.         }
  64.         return results;
  65.     }
  66. }
  1. // 通过多态、匿名内部类实现一个文件过滤器
  2. import java.io.IOException;
  3. import java.nio.file.*;
  4. import java.nio.file.attribute.BasicFileAttributes;
  5. import java.util.ArrayList;
  6. import java.util.List;
  8. public class FileFilter {
  9.     public static void main(String[] args) throws IOException {
  10.         Path projectDir = Paths.get(System.getProperty("user.dir"));
  11.         Path testRootDir = projectDir.resolve("test-root");
  12.         if (!testRootDir.toFile().isDirectory()) {
  13.             throw new IllegalStateException(testRootDir.toAbsolutePath().toString() + "不存在！");
  14.         }
  16.         List<String> filteredFileNames = filter(testRootDir, ".csv");
  17.         System.out.println(filteredFileNames);
  18.     }
  20.     /**
  21.      * 实现一个按照扩展名过滤文件的功能
  22.      *
  23.      * @param rootDirectory 要过滤的文件夹
  24.      * @param extension 要过滤的文件扩展名，例如 .txt
  25.      * @return 所有该文件夹（及其后代子文件夹中）匹配指定扩展名的文件的名字
  26.      */
  27.     public static List<String> filter(Path rootDirectory, String extension) throws IOException {
  28.         List<String> fileNames = new ArrayList<>();
  29.         Files.walkFileTree(rootDirectory, new SimpleFileVisitor<Path>() {
  30.             @Override
  31.             public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
  32.                 if (file.getFileName().toString().endsWith(extension)){
  33.                     fileNames.add(file.getFileName().toString());
  34.                 }
  35.                 return FileVisitResult.CONTINUE;
  36.             }
  37.         });
  38.         return fileNames;
  39.     }
  40. }

内部类

  • 如果两个类的逻辑非常紧密，可以考虑将其中一个放入另一个类中，作为内部类
  • 内部类可以提供更加精细的封装，该类可以不受控制的访问外部类的所有成员（private也可以），本质上是一种封装
  • 内部类之所以可以调用外围类的成员方法，是因为jvm的编译器在底层自动注入了一个外围类的实例（private 外围类 this$0）共内部类使用
  • 内部类用于补充一次性的逻辑，类似于一段函数逻辑，java8可采用lambda表达式来处理

  • 注意内部类不一定非要定义在一个类中，可以定义在任何地方

    静态内部类

  • 内部类和静态内部类的区别是，内部类是和外围类的实例相绑定的（隐式被this调用），而静态内部类不与任何外围类的实例绑定，所以不调用任何外围类实例方法（如果非要用，要么改为非静态，要么通过构造器传入外围类）

  • 通过注入外围类的实例来在静态内部类中调用外围类的成员方法的方式其实是补充了jvm提供的方式
  • 要永远优先使用静态内部类，除非编译器报错，这样可以节省创造一个对象的内存开支 ```java import java.util.ArrayList; import java.util.List; import java.util.function.Consumer;

public class Home { List cats = new ArrayList<>();

  1. public List<String> getCatNames() {
  2.     CatNameCollector collector = new CatNameCollector();
  3.     cats.forEach(collector);
  4.     return collector.getCatNames();
  5. }
  7. // 记录日志
  8. private void log(Cat cat) {
  9.     System.out.println("Collecting cat " + cat.getName());
  10. }
  12. // 在这个类里会产生一个编译错误
  13. // 请思考一下为什么
  14. // 并将此类改写成非静态的内部类，以修复此问题
  15. class CatNameCollector implements Consumer<Cat> {
  16.     private List<String> catNames = new ArrayList<>();
  18.     @Override
  19.     public void accept(Cat cat) {
  20.         log(cat);
  21.         catNames.add(cat.getName());
  22.     }
  24.     private List<String> getCatNames() {
  25.         return catNames;
  26.     }
  27. }

}

  1. ```java
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. import java.util.function.Consumer;
  6. public class Home2 {
  7.     List<Cat> cats = new ArrayList<>();
  9.     public List<String> getCatNames() {
  10.         CatNameCollector collector = new CatNameCollector(this);
  11.         cats.forEach(collector);
  12.         return collector.getCatNames();
  13.     }
  15.     // 记录日志
  16.     private void log(Cat cat) {
  17.         System.out.println("Collecting cat " + cat.getName());
  18.     }
  20.     static class CatNameCollector implements Consumer<Cat> {
  21.         // 在这个类里会产生一个编译错误
  22.         // 请思考一下为什么
  23.         // 不要将此类改写成非静态的内部类
  24.         // 而是引入一个外围类的实例以调用外围类的实例方法
  25.         // private Home2 home;
  26.         private List<String> catNames = new ArrayList<>();
  27.         private Home2 $this0;
  29.         public CatNameCollector(Home2 home) {
  30.             this.$this0 = home;
  31.         }
  33.         @Override
  34.         public void accept(Cat cat) {
  35.             $this0.log(cat);
  36.             catNames.add(cat.getName());
  37.         }
  39.         private List<String> getCatNames() {
  40.             return catNames;
  41.         }
  42.     }
  43. }

匿名内部类

  • 直接实例化一个接口或一个被继承的父类，并提供覆盖方法，其实就是在使用匿名内部类的实现
  • 匿名内部类可以转换为lambda表达式
  • 匿名内部类的字节码中是有名字的，jvm用外围类$1、外围类$2这样的形式来命名 ```java class xxx implements Predicate { @Override public boolean test(Object o){
    1.   return false
    } }

    new xxx() // ————————与下面代码等价——————-

    new Predicate() { @Override public boolean test(Object o){ return false } }

    1. <a name="ABImL"></a>
    2. ## predicate判定
    4. - 给定一个泛型元素，返回布尔值
    5. ```java
    6. public interface Predicate<T> {
    7.     boolean test(T t)
    8. }