最适合小白的java接口教程

可能是老板看我太辛苦,就新招聘了一个员工 – 小A。我,小白,作为老员工,肯定要好好带带他。我真的很担心小A的代码不规范,咋办呢?
我把我的想法跟老板说了,老板也很赞同我的想法。因为我属于老员工了,老板也比较信任我。

“小白啊,小A刚来,你要多带带他。这个项目是你一手做起来的,这一点上我很赞同你的想法。你可以做接口设计,然后把具体的实现交给小A去做。”

“接口啊,大学里面好像有教过。”

“是啊,接口是一种特殊的类,里面只有方法的声明而没有方法的实现。不过最新的jdk也允许写方法体了。”

“嗯嗯,我知道的,可是上学那会我就特别不理解接口到底有啥用,不写方法实现,就是一个空壳子哇!”

“嗯,接口的作用还是很大的,这一点你以后会慢慢明白的。小A刚来,代码不规范,逻辑思维还不完善,所以你作为老员工,就需要用接口来规范代码。”

"哦。。。"我似懂非懂地点了点头。

接着,老板又仔细给我讲解了接口的用法,我这才茅塞顿开。原来,用接口能做这么优雅的事情,看来我在学校学的,还有自己理解的,都还只是皮毛啊,与实际工作脱节了。

先不说接口到底啥概念了,先来看看怎么用接口。现在的菜单是这样子的:

image

控制台输入1,则登录客户信息。这个登录信息的代码,目前全部写在Application.java里面了,这样会带来一个问题,就是程序不好维护。随着业务逻辑越来越复杂,Application.java 就会越来越难懂。所以,要把这部分业务拆分出去。

老板的意思是,我来制定接口,然后让新来的小A来实现,这样的话,项目的大概思路就不至于滑坡。

创建一个service包,然后创建ICustomerService接口,看下面的步骤图。

image

image

注意,下面的Kind是Interface。

image

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

image

因为暂时没有接口的实现类(方法都是空的),所以这边只是引用,不去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,所以把实现类也建好了。

image

image

image

image

image

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();

CustomerServiceImpl 是 ICustomerService接口的实现类,ICustomerService是父,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();

运行:

image

听说老板曾经在真正的软件公司工作过,这天我跟他请教企业中怎么体现多态了,我看了下我的代码,改了下,然后让我拿去思考。

我看了一下,改动还是挺大的。

1.主类放在了一个包中,所有的类都不推荐放在默认包。

image

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接口,为啥,请容我慢慢道来。
首先我们思考一个问题,如果要去遍历一个对象,我们需要知道什么?

答案很显而易见,就是我们需要知道,当我们从这个对象中随便拿出一个元素的时候,还有没有下一个元素?如果有,下一个元素是什么?

如果我们能把这两个问题给解决了,那就可以去遍历了。

image

所以,我们需要在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方法。

image

首先,添加一个新的属性:

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);
}

image

可惜了,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方法,会报错。

你能修改代码,解决这个问题吗?

image

因为如果没有数据,nodeForEach只会是null,我们的代码逻辑,需要保证第一次hasNext的时候返回true,才玩得转。因为只有第一次hasNext的时候返回true,才会去调用next方法,同时会给nodeForEach赋值,下一次hasNext的时候,nodeForEach就有值了。所以,修改bug的方法,就是加一个非空判断。

  • 1
    点赞
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

剽悍一小兔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值