函数一般形式
function (<parameter types>) {private|internal|external|public} [pure|constant|view|payable] [returns (<return types>)]

1、函数重载

和java中函数重载概念是一样的

函数的名字相同
函数的参数不同——类型，数量
不考虑函数的返回值是否相同

2、函数命名参数

pragma solidity >=0.4.22 <0.6.0;

contract functionTest{
    
    uint  public num;
    string public  name;

   function  setParam(uint _num,string _name) public  {
        num = _num;
        name = _name;
    }
    
    
    function test1(){
        setParam(10,"kzhang");
    }
    
     function test2(){
        setParam({_name:"kzhang",_num:20});
    }
    
}

3、返回值特性

除了常规的返回值以后，还有以下特性

//函数可以有多个返回值，同时返回值有名称，可以直接参数计算
  function returnTest1(uint a,uint b) view returns(uint add,uint mul){
        add = a+b;
        mul = a*b;
    }
    
  //函数可以有多个返回值，直接return(param list) 参数列表
     function returnTest2(uint a,uint b) view returns(uint add,uint mul){
       return (a+b,a*b);
    }
    
    
    //可以直接把入参交换
     function returnTest3(uint a,uint b) view returns(uint add,uint mul){
        return (b,a);
    }

4、权限修饰详解

public修饰的变量和函数，任何用户或者合约都能调用和访问；可以被继承；
private修饰的变量和函数，只能在其所在的合约中调用和访问；
即使是其子合约也没有权限访问；不能被继承
internal 和 private 类似，不过，如果某个合约继承自其父合约，这个合约即可以访问父合约中定义的“内部”函数；可以被继承
external 与public 类似，只不过这些函数只能在合约之外调用，它们不能被合约内的其他函数调用；
可以间接的在合约内部调用，输入this. 来调用，this相当于合约地址，这就相当于是外部调用了；
还有一种方法，在另一个合约内创建或引用合约的地址来调用—“地址.”（this.）
可以被继承，但是如果强行调用，通过 “地址.”（this.）这种方法

contract external Test{
  father f = new father(); //father是一个contract
  function externTest() returns(string){
        return f.dahan()；//dahan()函数在father中是以 external 修饰的
  }
}

5、废弃的constant静态修饰

constant 常量

函数内部的constant 关键字，在4.0版本中和view是等价的，在5.0版本中将会废弃掉constant关键字
全局变量有constant 属性，局部变量是没有这个属性的
全局变量加上了constant属性后，就不能被修改

6、构造函数

和合约名称相同（这个已经过时了，新版本改成了constructor了，见下面）
合约部署时就会调用
构造函数只能有一个（下面两个构造函数只能有一个）


     constructor(uint _num,string _name) public {
        num = _num;
        name = _name;
     }
    
    function functionTest(uint _num,string _name) public{
        num = _num;
        name = _name;
    }

7、modifier函数修改器

可以用来改变一个函数的行为，控制函数的逻辑。修改器是一种合约属性，可以被继承和重写。
对于函数修改器，下划线代表函数体，当执行到下划线;这一行的时候，就跳到函数体，执行函数体内的语句，执行完函数体内语句其实还要回到函数修改器，执行下划线_;后面的语句

modifier，对于有相同判断逻辑的语句，可以提出来，减少代码量，增加代码的重用性和拓展性

pragma solidity ^0.4.0;

contract processFlow{
    mapping(bool => uint) public mapp;

    modifier A(mapping(bool => uint) mapp){
        if(mapp[true] == 0){
          //当调用函数f()时，
          //1、先执行这一步
            mapp[true] = 1; 
            _;
         //3、最后执行这一步
            mapp[true] = 3;
        }
    }
    //修改器可以有参数
    function f() A(mapp) returns(uint){
       //2、其次执行这一步
        mapp[true] = 2;
        return mapp[true];
    }
}

多重modifier执行顺序

 uint public a = 0 ;
    
    modifier mod1{
        a=1;
        _;
        a=2;
    }
    
     modifier mod2{
        a=3;
        _;
        a=4;
    }
    
//执行顺序  a=1, a=3, a= 100, a= 4 ,a=2
    function testModifier() mod1 mod2 {
        a = 100;
    }

8、合约继承 is

可以同时继承多个父合约，多个父合约之间以逗号“，”分隔

pragma solidity >=0.4.22 <0.5.0;

contract father{
    
    uint public money = 10000;
    
    function dahan() public view returns(string){
        return "dahan";
    }
    
}

// son 这个合约继承了father这个合约
contract son is father{
    
   function getMoney() returns(uint){
//继承了father的money 属性
       return money;
   }
   
   function test() returns(string){
//继承了father的dahan()函数
       return dahan();
   }
    
}

9、合约的销毁 selfdestruct

pragma solidity >=0.4.22 <0.5.0;

contract destoryContract{
    
    address owner;
    
    uint public num = 0;
    
    constructor() public {
        owner = msg.sender;
    }
    
    
    function increment()  public returns(uint){
        return num++;
    }
    
    
    function destory() public {
        //只有合约的拥有者才能销毁
        if(msg.sender == owner){
            selfdestruct(owner);
        }
    }
    
}

总结

pure 不会读取全局变量，更不会修改全局变量，一个固定的输入就会有一个固定的输出，不消耗gas
view 只读取全局变量的值，不修改它，不消耗gas
payable 转账的时候必须要加的关键字

solidity智能合约开发四：面向对象