可能是老板看我太辛苦，就新招聘了一个员工 – 小A。我，小白，作为老员工，肯定要好好带带他。我真的很担心小A的代码不规范，咋办呢？
我把我的想法跟老板说了，老板也很赞同我的想法。因为我属于老员工了，老板也比较信任我。
“小白啊，小A刚来，你要多带带他。这个项目是你一手做起来的，这一点上我很赞同你的想法。你可以做接口设计，然后把具体的实现交给小A去做。”
“接口啊，大学里面好像有教过。”
“是啊，接口是一种特殊的类，里面只有方法的声明而没有方法的实现。不过最新的jdk也允许写方法体了。”
“嗯嗯，我知道的，可是上学那会我就特别不理解接口到底有啥用，不写方法实现，就是一个空壳子哇！”
“嗯，接口的作用还是很大的，这一点你以后会慢慢明白的。小A刚来，代码不规范，逻辑思维还不完善，所以你作为老员工，就需要用接口来规范代码。”
"哦。。。"我似懂非懂地点了点头。
接着，老板又仔细给我讲解了接口的用法，我这才茅塞顿开。原来，用接口能做这么优雅的事情，看来我在学校学的，还有自己理解的，都还只是皮毛啊，与实际工作脱节了。
先不说接口到底啥概念了，先来看看怎么用接口。现在的菜单是这样子的：
控制台输入1，则登录客户信息。这个登录信息的代码，目前全部写在Application.java里面了，这样会带来一个问题，就是程序不好维护。随着业务逻辑越来越复杂，Application.java 就会越来越难懂。所以，要把这部分业务拆分出去。
老板的意思是，我来制定接口，然后让新来的小A来实现，这样的话，项目的大概思路就不至于滑坡。
创建一个service包，然后创建ICustomerService接口，看下面的步骤图。
注意，下面的Kind是Interface。
package service; import entity.Customer; import java.util.List; /** * 客户服务接口 * author 小白 */ public interface ICustomerService { //加载文本的客户资料 public abstract List<String> loadCustomerFormTxt(String path); //填充属性到客户对象 //public 和 abstract可以省略 Customer fillCustomer(List<String> props); /** * 保存客户对象到Excel * @param cst 客户对象 * @param excelPath Excel的路径 * @return */ boolean saveToExcel(Customer cst,String excelPath); }
接口的定义和类非常像，区别是：
1.接口用的关键字是interface，而不是class
2.接口里面的方法只有声明，没有方法体，这种方法也叫做抽象方法（用abstract关键字修饰）
3.接口里面的方法默认都是public
因为暂时没有接口的实现类（方法都是空的），所以这边只是引用，不去new。
先把原来的保存代码注释掉，然后依次调用接口的方法，顺便说一句，<preconsolas’;font-size:10.5pt;" style=“box-sizing: border-box; font-size: 15px; font-family: Helvetica;”>cstList做成static的，方便调用。</preconsolas’;font-size:10.5pt;">
static TuziLinkedList cstList = new TuziLinkedList();
main方法源码：
public static void main(String[] args){ newLine("******欢迎使用兔子餐厅会员系统******"); newLine("[1]客户登记入库"); newLine("[9]退出程序"); //创建一个控制台输入对象，反正就这么写，目前不用去深究含义 Scanner scanner = new Scanner(System.in); //获取用户的输入，程序会挂起等待 int input = scanner.nextInt(); //直接退出程序 if(input == 9){ newLine("程序退出，谢谢使用！"); return; } //自动读取D盘的customer.txt文件，保存入库 if(input == 1){ // List<String> lines = FileUtil.readLines(new File("D:/customer.txt"), "GBK"); Application app = new Application(); //1、读取文本，获取客户资料 List<String> props = app.customerService.loadCustomerFormTxt("D:/customer.txt"); //2、解析客户资料到客户对象 Customer customer = app.customerService.fillCustomer(props); //3、直接将客户对象保存到Excel中（暂时先不做批量入库了） boolean isSuccess = app.customerService.saveToExcel(customer,"D:/customer.xls"); if(!isSuccess){ System.out.println("保存失败，系统出现异常！"); }else{ //4、将这个对象存入链表，备用 cstList.add(customer); } // //先创建一个客户对象，就是setFieldValue方法的第一个参数（给谁的属性赋值） // Customer cst = new Customer(); // // for (String line : lines) { // //System.out.println(line); // //用字符串的split方法，根据=分割成数组，比如name=张大胖，就会变成['name','张大胖'] // String[] split = line.split("="); // String key = split[0]; //获取数组的第一个元素 // String value = split[1]; //获取数组的第二个元素 // //System.out.println(key + "," + value); // ReflectUtil.setFieldValue(cst,key,value); // } // // //打印顾客对象，就是调用他的toString方法 // System.out.println(cst); // System.out.println(cst.getName() + "保存完毕！"); } //运行完毕后，继续执行main方法，这样程序就不会关闭 Application.main(null); }
代码瞬间清晰了，这就是接口的魅力啊！我只需要负责设计出方法的名字，参数和返回值就可以了，剩下的，我去交给别人做。当然，现在这个程序是不能运行的，因为customerService没有赋值，还是null。
“小A啊，这个接口你帮忙实现一下了哇！”，虽然有点不好意思，但我毕竟是老员工。而且很多业务逻辑已经在main方法里面写了，小A可以去照搬我之前的代码。不过，我也怕小A在别的地方胡乱创建class，所以把实现类也建好了。
package service.impl; import entity.Customer; import service.ICustomerService; import java.util.List; public class CustomerServiceImpl implements ICustomerService{ @Override public List<String> loadCustomerFormTxt(String path) { return null; } @Override public Customer fillCustomer(List<String> props) { return null; } @Override public boolean saveToExcel(Customer cst, String excelPath) { return false; } }
接口的实现类必须重写所有抽象方法，CustomerServiceImpl既然实现了ICustomerService，就必须重写所有的抽象方法，这是一种约定。既然你打算遵循我设计的接口，就必须实现我要求的所有方法。
@Override public List<String> loadCustomerFormTxt(String path) { return FileUtil.readLines(new File(path), "GBK"); }
小A基本照搬了我的代码。
@Override public Customer fillCustomer(List<String> props) { //先创建一个客户对象，就是setFieldValue方法的第一个参数（给谁的属性赋值） Customer cst = new Customer(); for (String line : props) { //用字符串的split方法，根据=分割成数组，比如name=张大胖，就会变成['name','张大胖'] String[] split = line.split("="); String key = split[0]; //获取数组的第一个元素 String value = split[1]; //获取数组的第二个元素 ReflectUtil.setFieldValue(cst,key,value); } return cst; }
还是照搬。
@Override public boolean saveToExcel(Customer cst, String excelPath) { System.out.println("不会"); return true }
这。。。
我们修改一下Application的代码，给接口对象赋值。
private ICustomerService customerService = new CustomerServiceImpl();
核心代码
Application app = new Application(); //1、读取文本，获取客户资料 List<String> props = app.customerService.loadCustomerFormTxt("D:/customer.txt"); //2、解析客户资料到客户对象 Customer customer = app.customerService.fillCustomer(props); //3、直接将客户对象保存到Excel中（暂时先不做批量入库了） boolean isSuccess = app.customerService.saveToExcel(customer,"D:/customer.xls"); if(!isSuccess){ System.out.println("保存失败，系统出现异常！"); }else{ //4、将这个对象存入链表，备用 cstList.add(customer); } System.out.print("打印链表---" ); cstList.display();
运行：
听说老板曾经在真正的软件公司工作过，这天我跟他请教企业中怎么体现多态了，我看了下我的代码，改了下，然后让我拿去思考。
我看了一下，改动还是挺大的。
1.主类放在了一个包中，所有的类都不推荐放在默认包。
2.创建了一个私有方法 saveCustomer，把service对象当做参数传进去。
boolean isSuccess = saveCustomer(app.customerService);
方法如下：
private static boolean saveCustomer(ICustomerService customerService) { //1、读取文本，获取客户资料 List<String> props = customerService.loadCustomerFormTxt("D:/customer.txt"); //2、解析客户资料到客户对象 Customer customer = customerService.fillCustomer(props); //3、直接将客户对象保存到Excel中（暂时先不做批量入库了） boolean isSuccess = customerService.saveToExcel(customer,"D:/customer.xls"); Application.cstList.add(customer); return isSuccess; }
目前我对于多态的看法，除了父类引用可以指向子类对象以外，就是这个传参的情况。
boolean isSuccess = saveCustomer(app.customerService);
其实本质还是一样的，因为app.customerService的真实对象，还是CustomerServiceImpl，是子类对象。
我想了很久，终于明白了，多态的好处就是：代码未动，设计先行！
比如这个例子，我只是设计了这个接口需要哪些方法。
//加载文本的客户资料 public abstract List<String> loadCustomerFormTxt(String path); //填充属性到客户对象 //public 和 abstract可以省略 Customer fillCustomer(List<String> props); /** * 保存客户对象到Excel * @param cst 客户对象 * @param excelPath Excel的路径 * @return */ boolean saveToExcel(Customer cst,String excelPath);
我是接口管理员，是设计人员，我觉得这样设计是合理的，可以完成当前的项目需求。那就ok了，写程序就是这样，得先有图纸，然后图纸要评审，评审完成后再交给施工人员去施工。
在这个项目里面，我就是那个设计者，新同事小A是技术落地。
那什么时候需要用到多态呢？我想，应该就是有多人协作，项目比较大的时候，必须要先做好设计！然后，开发人员再根据项目经理写好的接口去做技术实现。
“说的不错。”这时候，老板走了过来。
“小白啊，你能悟到这一点，很是难得。没错，多态最核心的意义就是如此，接口的意义就是为了规范开发的代码。”
“那真正的企业里面做项目也有接口管理员吗，是不是也要像这样先做设计？”我激动地问道。
只见老板的脸轻微地抽搐了一下，仿佛想起来各种被烂代码击垮的往事，“这个，小白啊，虽然这样做是最好的。但是很多企业里面，都是以效率优先，也不管到底合不合理，也没有需求和代码评审。都是一个项目分给你，干就完了。”
“…”
一个对象，怎么去遍历呢？一种做法是实现Iterator接口，为啥，请容我慢慢道来。
首先我们思考一个问题，如果要去遍历一个对象，我们需要知道什么？
答案很显而易见，就是我们需要知道，当我们从这个对象中随便拿出一个元素的时候，还有没有下一个元素？如果有，下一个元素是什么？
如果我们能把这两个问题给解决了，那就可以去遍历了。
所以，我们需要在class中添加两个方法，分别为：
public boolean hasNext(); public Object next();
这时候又要看到接口的魅力了，瞧瞧，我们自己都能想到的问题，你说Java的创建者能想不到吗？所以，在 java.util 包里面，就存在一个Iterator接口。这个接口的意思就是“可遍历的”。
如果我们实现了这个接口，就必须要实现里面的hasNext方法和next方法。如果翻开Iterator的源码，我们还会发现有几个方法竟然有方法体。我们重点看这个方法：
default void forEachRemaining(Consumer<? super E> action) { Objects.requireNonNull(action); while (hasNext()) action.accept(next()); }
这是JDK1.8以后才有的，接口允许写方法体了。我们如果实现了这个接口，也就默认拥有了这个方法。
这个方法干啥用的，待会再说，我们先去实现hasNext方法和next方法。
首先，添加一个新的属性：
public CustNode nodeForEach; //用于遍历的节点，默认等于第一个节点
遍历的时候，需要专门弄一个属性，避免和currentNode混淆。
然后，编写hasNext方法
@Override public boolean hasNext() { if(nodeForEach == null && firstNode != null) return true; return nodeForEach.next != null; }
思路：第一次调用hasNext方法的时候，nodeForEach肯定是空，如果add成功了，则firstNode肯定不为空，那么就应该返回true。否则，就取nodeForEach.next。那我们在什么时候给nodeForEach赋值呢，自然是next方法。
@Override public Object next() { if(nodeForEach == null && firstNode != null){ nodeForEach = firstNode; return nodeForEach.data; } nodeForEach = nodeForEach.next; return nodeForEach.data; }
同样做了是否是第一次的判断，如果是第一次进来，那么给nodeForEach赋值为firstNode，然后直接返回第一个元素的data。如果不是第一次进来，那么就取当前循环节点nodeForEach的next，然后别忘了，一定要重新给nodeForEach赋值为next，指针就偏移过去了。最后，再返回nodeForEach的data。
我怕有些人忘记CustNode咋写的了，所以再把代码贴一下。
package tool; import entity.Customer; public class CustNode{ public Customer data; public CustNode next; public CustNode(Customer data){ this.data = data; } }
default void forEachRemaining(Consumer<? super E> action) { Objects.requireNonNull(action); while (hasNext()) action.accept(next()); }
解读一下这段源码，<? super E>是泛型，现在你简单理解为是某个类型E的父类，比如E是Customer，那就是<? super Customer>。有趣的是，如果？就是Customer，也是符合规则的。所以，这是一种** >= **的关系。
Consumer<? super E> action，Consumer也是一个接口，意思是消费者。它的源码如下：
@FunctionalInterface public interface Consumer<T> { void accept(T t); default Consumer<T> andThen(Consumer<? super T> after) { Objects.requireNonNull(after); return (T t) -> { accept(t); after.accept(t); }; } }
看不懂没关系，现在我们只需要知道它里面有一个很重要的方法是accept：
void accept(T t);
T代表某一个对象，为啥我们要关注这个方法，因为forEachRemaining里面用到了。
default void forEachRemaining(Consumer<? super E> action) { Objects.requireNonNull(action); while (hasNext()) action.accept(next()); }
Objects.requireNonNull(action);表示判断这个Consumer是否是空，如果为空的话肯定就报错了。
然后是一个while循环，当hasNext方法返回true的时候，就执行action.accept(next());
next() 不就是我们链表的下一个元素嘛，所以整个方法的意思就是，你需要一个Consumer的实现类，比如叫做ConsumerImpl，然后实现accept方法。接着创建ConsumerImpl类的对象，作为参数传入forEachRemaining方法，就可以实现遍历了。
在这个流程中，思考一下，我们最需要关注的是啥，是不是这个accept方法，这个方法就是让我们去设计遍历的时候，对每一个元素做些什么？
public Customer(String name){ this.setName(name); }
可惜了，Java不支持直接传入一个方法， 在Java的语法里面，是不能直接传入一个方法的，在下面的代码中
default void forEachRemaining(Consumer<? super E> action) { Objects.requireNonNull(action); while (hasNext()) action.accept(next()); }
我们希望直接传入一个Consumer的实现类对象，里面包含了accept方法，至于这个实现类叫什么名字，我们不关心。也许叫**ConsumerImpl1，****ConsumerImpl2。**随便叫什么，我的关注的点其实是在accept方法。
还好，Java提供了一种方案来帮我们偷这个懒，叫做**“new一个匿名实现类”，**也有的地方叫做匿名内部类。
@Override public boolean saveToExcel(TuziLinkedList customers, String excelPath) { customers.forEachRemaining(new Consumer() { @Override public void accept(Object o) { //把Object类型的o对象，强制转化成Customer类型 Customer cst = (Customer) o; System.out.println(cst.getName() + "已经成功保存到Excel！"); } }); return true; }
从表面来看，就是new了一个接口。虽然我们说接口是不能new的，必须要写一个类去实现这个接口，然后去new实现类。但是，从语义上看这个写法，直接理解成new一个接口是非常贴切的。
在CustomerServiceImpl直接写一个main方法来测试。
public static void main(String[] args) { TuziLinkedList customers = new TuziLinkedList(); customers.add(new Customer("孙悟空")); customers.add(new Customer("猪八戒")); customers.add(new Customer("沙和尚")); customers.add(new Customer("唐僧")); new CustomerServiceImpl().saveToExcel(customers,null); }
效果：
孙悟空已经成功保存到Excel！ 猪八戒已经成功保存到Excel！ 沙和尚已经成功保存到Excel！ 唐僧已经成功保存到Excel！
hasNext方法有一个bug，就是如果我没有给customers对象调用add方法，直接放进saveToExcel方法，会报错。
你能修改代码，解决这个问题吗？
因为如果没有数据，nodeForEach只会是null，我们的代码逻辑，需要保证第一次hasNext的时候返回true，才玩得转。因为只有第一次hasNext的时候返回true，才会去调用next方法，同时会给nodeForEach赋值，下一次hasNext的时候，nodeForEach就有值了。所以，修改bug的方法，就是加一个非空判断。
