Solidity 編譯問題：將參數轉換為外部類型時發生函式重載衝突

我是剛接觸solidity 的新手，試圖編譯程式碼，這是一個與舊編譯器一起執行良好的舊範例。當我嘗試使用最新的編譯器在 remix 中編譯相同的內容時，我遇到了以下問題。你能幫我解決這個問題嗎？

-- Error in function transfer in interface ERC223

Function overload clash during conversion to external types for arguments.
function transfer(address _to, uint _value, bytes _data) external returns (bool);


pragma solidity ^0.4.0;

interface ERC20 {
   function transferFrom(address _from, address _to, uint _value) external returns (bool);
   function approve(address _spender, uint _value) external returns (bool);
   function allowance(address _owner, address _spender) external constant returns (uint);
   event Approval(address indexed _owner, address indexed _spender, uint _value);
}

interface ERC223 {
   function transfer(address _to, uint _value, bytes _data) external returns (bool);
   event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}

contract ERC223ReceivingContract {
   function tokenFallback(address _from, uint _value, bytes _data) public;
}

contract Token {
   string internal _symbol;
   string internal _name;
   uint8 internal _decimals;
   uint internal _totalSupply = 1000;
   mapping (address => uint) internal _balanceOf;
   mapping (address => mapping (address => uint)) internal _allowances;

   constructor(string symbol, string name, uint8 decimals, uint totalSupply) public {
       _symbol = symbol;
       _name = name;
       _decimals = decimals;
       _totalSupply = totalSupply;
   }

   function name() public constant returns (string) {
       return _name;
   }

   function symbol() public constant returns (string) {
       return _symbol;
   }

   function decimals() public constant returns (uint8) {
       return _decimals;
   }

   function totalSupply() public constant returns (uint) {
       return _totalSupply;
   }

   function balanceOf(address _addr) public constant returns (uint);
   function transfer(address _to, uint _value) public returns (bool);
   event Transfer(address indexed _from, address indexed _to, uint _value);
}

library SafeMath {
 function mul(uint256 a, uint256 b) internal pure returns (uint256) {
   uint256 c = a * b;
   assert(a == 0 || c / a == b);
   return c;
 }

 function div(uint256 a, uint256 b) internal pure returns (uint256) {
   // assert(b > 0); // Solidity automatically throws when dividing by 0
   uint256 c = a / b;
   // assert(a == b * c + a % b); // There is no case in which this doesn't hold
   return c;
 }

 function sub(uint256 a, uint256 b) internal pure returns (uint256) {
   assert(b <= a);
   return a - b;
 }

 function add(uint256 a, uint256 b) internal pure returns (uint256) {
   uint256 c = a + b;
   assert(c >= a);
   return c;
 }
}

contract MyFirstToken is Token("MFT", "My First Token", 18, 1000), ERC20, ERC223 {

   using SafeMath for uint;

   constructor() public {
       _balanceOf[msg.sender] = _totalSupply;
   }

   function totalSupply() public constant returns (uint) {
       return _totalSupply;
   }

   function balanceOf(address _addr) public constant returns (uint) {
       return _balanceOf[_addr];
   }

   function transfer(address _to, uint _value) public returns (bool) {
       if (_value > 0 &&
           _value <= _balanceOf[msg.sender] &&
           !isContract(_to)) {
           _balanceOf[msg.sender] = _balanceOf[msg.sender].sub(_value);
           _balanceOf[_to] = _balanceOf[_to].add(_value);
           emit Transfer(msg.sender, _to, _value);
           return true;
       }
       return false;
   }

   function transfer(address _to, uint _value, bytes _data) public returns (bool) {
       if (_value > 0 &&
           _value <= _balanceOf[msg.sender] &&
           isContract(_to)) {
           _balanceOf[msg.sender] = _balanceOf[msg.sender].sub(_value);
           _balanceOf[_to] = _balanceOf[_to].add(_value);
           ERC223ReceivingContract _contract = ERC223ReceivingContract(_to);
           _contract.tokenFallback(msg.sender, _value, _data);
           emit Transfer(msg.sender, _to, _value, _data);
           return true;
       }
       return false;
   }

   function isContract(address _addr) private constant returns (bool) {
       uint codeSize;
       assembly {
           codeSize := extcodesize(_addr)
       }
       return codeSize > 0;
   }

   function transferFrom(address _from, address _to, uint _value) public returns (bool) {
       if (_allowances[_from][msg.sender] > 0 &&
           _value > 0 &&
           _allowances[_from][msg.sender] >= _value &&
           _balanceOf[_from] >= _value) {
           _balanceOf[_from] = _balanceOf[_from].sub(_value);
           _balanceOf[_to] = _balanceOf[_to].add(_value);
           _allowances[_from][msg.sender] = _allowances[_from][msg.sender].sub(_value);
           emit Transfer(_from, _to, _value);
           return true;
       }
       return false;
   }

   function approve(address _spender, uint _value) public returns (bool) {
       _allowances[msg.sender][_spender] = _allowances[msg.sender][_spender].add(_value);
       emit Approval(msg.sender, _spender, _value);
       return true;
   }

   function allowance(address _owner, address _spender) public constant returns (uint) {
       return _allowances[_owner][_spender];
   }
}

嘗試更改public為功能external的實現transfer(address _to, uint _value, bytes _data)。

引用自：https://ethereum.stackexchange.com/questions/51090