嗯，刚刚看了一下评论区，小弟给大家初学设计模式以及刚刚接触项目的同学一些建议，其实在学这一章更以及往后正式的20多种设计模式时候更加锻炼的是一种抽象思维，以我个人的一点经验，就像老师一开始说的，在学习的时候，不要总是类比生活中的一些阿猫啊狗的例子，没错初次是很好理解，而且你会感觉好像懂了，但是实际上你还是不懂（可能是以为我笨），建议大家没学习一种模式的时候，思考一下现在在做的项目中那些业务可以进行优化，如果可以的话，可以进行重构，这样对你的学习才有很大的帮助；举个栗子，例如策略模式，我们在代码是不是经常调用第三方接口，每个接口都有它的规范之类的，如果你按照low 的方式就是按照规范组织一些报文请求，但是这个时候，你可以用的你的抽象思维，比如,在这类业务中，无外乎就是，1、构建报文，2、请求结构，3、解析返回，那么我就可以这样设计：
    /**
     * 请求统一接口
     */
    public interface Fun<T> {
        /**
         * 发送请求报文
         */
        String constructionRequest();
        /**
         * 请求报文
         */
        String doPost(String request);
        /**
         * 解析回执报文
         */
        T resolveResponse(String responseText);
    }
然后再写一个策略的算法簇（应该是这么叫）
/**
 * 统一实现接口
 */
public class DealWithHandle {
    
    /**
     * 描述 create.
     *
     * @param <T> the type parameter
     * @param fun the fun
     * @return the t
     * @author Maurice Mao
     * @created 2018 -07-13 10:58:32 Handle t.
     */
    public static <T> T handle(Fun<T> fun) {
        
        String request = fun.constructionRequest();
        
        String response = fun.doPost(request);
        
        T t = fun.resolveResponse(response);
        
        return t;

    }
}
这个时候，假设你做支付宝扫码支付的时候（或者微信以及第三方支付），是不是可以这么调用：
public class OfficialAliScan {

    private static Logger logger = LoggerFactory.getLogger(OfficialAliScan.class);

    public static ApiTradeResultDto operate(final TradeOrderDO orderDO, final SubMerchatAuthDO subMerchatAuthDO, final String authCode) {
        return DealwithHandle.handle(new DealwithHandle.Fun<ApiTradeResultDto>() {
            @Override
            public String constructionRequest() {
                  ///todo
            }

            @Override
            public String doPost(String bizContent) {
                ///todo
            }

            @Override
            public ApiTradeResultDto resolveResponse(String responseTxt) {
                ///todo
            }
        });
    }
这样的话，你的业务代码组织的就很清晰，也便于调试维护

举个例子吧，附件上传服务端实现

需求：支持上传、下载、删除以及文件的存储，存储的话需要支持存本地和云端，涉及附件上传的业务点有十几个。

设计思路：
1、接口设计：上传、下载、删除是公共行为，抽象到接口中

2、存储方法是一大块公共代码，写到抽象类里面

3、每个业务的附件上传子类实现接口、继承抽象类

Python中抽象类是通过 abc 模块中的 abstractmethod 和 ABCMeta

from abc import abstractmethod, ABCMeta

class BaseClass(metaclass=ABCMeta):
    @abstractmethod
    def fun(self, x): pass

因为 Python 需要天然支持多继承，所以可以直接用上述的抽象类实现接口

关于抽象类和接口有一个疑问，也可能是对业务模型不够了解，同一件事其实可以表达成is a也可以表达成has a，这个就看你的语言描述到底是个名词还是行为。
举例说明：
宠物猫和宠物狗都是宠物。
宠物猫和宠物狗都有会被宠。
is a基类定义：宠物类
has a 接口定义：可被宠的
如果取决于需求的语言阐述，感觉就太依赖个人表达习惯了，这不是一个团队持续迭代好项目的方式吧
希望老师可以帮忙解惑

个人认为，jdk8中，接口的默认实现之后。接口和抽象的区别渐渐模糊了。接口，从一定程度上也可以当抽象类使用。而且最主要的是，支持多实现，但不支持多继承。
并且，我认为，多实现也是接口和抽象类最主要的区别，没有之一！

我的理解：
抽象类：描述整个类的一个概况。（举例来说，抽象类，爬行动物）
接口： 描述的是需要具备的能力。（举例来说，飞行，游泳）

乌龟，在类上，应该继承爬行动物。因为属于爬行动物（说实话不确定是不是爬行动物），但是乌龟同时也会游泳。会游泳，就只能是乌龟实现的接口。如果，有一天，乌龟长翅膀会飞了（致敬超级马里奥），那这时候，实现会飞行接口就可以了。

在使用到这个接口的角度，某个游戏，需要十个飞行的小怪。以前是十个各种鸟类。但是现在需要十一个了，于是乎给乌龟安上了翅膀（实现飞行接口），拿来充当飞行小怪使用。

抽象类 vs 接口

            抽象类 接口
实例化         否     否
属性         是 否
方法 是 是
实现 是 否
目的 复用 扩展
意义 is-a has-a

1.普通类模拟抽象类方法：
私有构造器，protected修饰的方法和成员变量，模拟抽象方法的时候在实现体内直接抛出异常并写好交由子类具体实现的注释说明
2.用的JAVA。天然支持，abstract和interface
3.抽象类：
不支持多继承，为了解决代码复用问题而产生，他可以内部定义方法实现、公用属性以及需要子类各自实现的抽象方法，应用场景最典型的就是模板模式，is a的关系。爸爸儿子的关系。
接口：
支持多继承，为了让代码更加解耦合，更加灵活而产生，他所定义的方法都是抽象的，has a的关系，好比一种协议，一种规范，应用场景贼广泛，比如各大设计模式，设计原则。再比如责任链模式

问题1:
c#接口两种实现方式：
// 直接实现接口
interface IAttack
{
    void Attck();
}
class Gun : IAttack
{
    public void Attck()
    {
        throw new NotImplementedException();
    }
}
class Rifle : IAttack
{
    public void Attck()
    {
        throw new NotImplementedException();
    }
}

// 显示实现接口（当多个接口的中需要实现的方法名称一样的时候）
interface IAttack
{
    void Attack();
}
interface ISpecialAttack
{
    void Attack();
}
class Gun : IAttack, ISpecialAttack
{
    public void Attack()
    {
        Console.WriteLine("普通攻击");
        throw new NotImplementedException();
    }
    void ISpecialAttack.Attack() // 接口的显示实现
    {
        Console.WriteLine("特殊攻击");
        throw new NotImplementedException();
    }
}
class Rifle : IAttack, ISpecialAttack
{
    public void Attack()
    {
        Console.WriteLine("普通攻击");
        throw new NotImplementedException();
    }
    void ISpecialAttack.Attack() // 接口的显示实现
    {
        Console.WriteLine("特殊攻击");
        throw new NotImplementedException();
    }
}
public class TestWeapons
{
    public void TestMethod()
    {
        ISpecialAttack desertEagle = new Gun();
        desertEagle.Attack();

        IAttack rifle = new Rifle();
        rifle.Attack();
    }
}


c#抽象类定义以及实现：
abstract class Weapon{
    public float attackRange;
    public float damage;
    public virtual void Attack(Enemy enmey)
    {
        enmey.health -= damage;
        Console.WriteLine("attack...");
    }
}

class Gun: Weapon
{
    public override void Attack(Enemy enmey)
    {
        base.Attack(enmey);
    }
}

public class TestWeapon02
{
    public static void main02(string[] args)
    {
        Enemy enemy = new Enemy();
        Weapon gun = new Gun()
        {
            damage = 5,
            attackRange = 100,
        };
        gun.Attack(enemy);
        Console.WriteLine("enemy health: " + enemy.health);
    }
}

问题2:
总的来说，抽象类就是类别上的总称；接口就是行为上的规范