方法和匿名方法：
funcion name(<parameter types>){public|private|internal|external}[constant][payable][<return types>)]{}
payable代表是可以接受以太币的
方法有如下几种：
external
可以被其他合约调用，也可以使用内部直接调用，如果要调用的话，要用this.f()来进行调用
public
既可以被其他合约调用，也可以被内部直接调用
internal
只能在合约和其他子类合约中使用
private
只能在自己的合约内使用，子类中也不能使用'
pragma solidity ^0.4.;
//定义两个合约
contract C1{
uint public data=;
//下面定义了两个函数
function test(string _s) external returns(bytes32){
//返回的是32位字节类型
return keccak256(_s)//加密函数
}
function test2() public returns(uint){
//定义一个函数，后面是返回什么的类型,这里是不需要传参数进去的
return ;
} } contract C2{
//合约2来调用合约1的方法 bytes32 public b32;
uint public u;//定义变量
uint public kdata;//接收c1中的data C1 c1=new C1();
function test() returns (bytes32){
b32=c1.test("a)//调用c1里面的test方法
return b32
} function test2(){
b=c1.test2()
return b//return就好了
}
一个合约可以有一个匿名函数，此函数不能有参数，也不能有任何返回值，当我们企图去之执行一个合约上没有的函数的时候，那么合约就会执行这个匿名函数
此外，当合约在只收到以太币的时候，也会调用到这个匿名函数，而且一般情况下只会消耗很少的gas，所以当你接收到以太币的时候，想要操作一些的话，可以尽可能的把你要的操作写到匿名函数里面，因为这样的成本非常低
匿名函数例子：
//匿名函数
pragma solidity ^0.4.; contract C1{
uint public data; event e(address from ,uint _u );
function () payable {
data+=
e(msg.sender,data) }
contract CallC1{
event e(bool _b);
function CallC1() payable{ } function calltest(address add) returns (bool) {
bool b=add.call(bytes4(keccak256("setmoney")))//add.call调用匿名函数
e(b);
return b
}
}
}
}
new方法：(new)
一个合约是可以通过new关键字来创建另一个合约的
pragma solidity ^0.4.;
//定义一个合约D
contract D{
uint public x;//定义无符号的整数
uint public amount; function D(uint _a)payable{//D合约里面有两个方法，payable，以太币
x=_a;
amount=msg.value;//接收到了以太币，并且把这个以太币赋值给这个amount，可以得到以太币的数量
}
}
//定义合约E
contract E{
event e(uint x,uint amount);//定义一个事件出来
D d=new D()//D合约传递参数4,创建一个d对象出来，下面直接是取出d的值出来，想到与是给D合约发送以太币
function E(uint _u)payable{//payable是可以支付以太币的情况
e(d.x(),d.amount())//获取到D合约里面的两个值出来
D d1=new D(_u)//通过new方法创建d1合约
e(d1.x().d1.amount())//在打印出d后面参数的值出来 } function createD(uint _x,uint _amount) {
D d2=(new D).value(_amount)(_x)//当成以太币的数量发送给D合约，相当于是D合约里面msg.value
e(d2.x(),d2.amount())//得到后面的两个值出来，打印出来 }
}
继承：(is)
例子：
pragma solidity ^0.4.;
contract F{
uint internal u=;
function test() returns (uint){
//定义一个函数，返回什么类型的uint
return ;
}
}
//定义一个合约F1
contract F1{
uint public fu;
function F1(uint _u){
fu=_u//赋值操作,fu被赋值_u操作
}
}
//下面子类直接继承父类，is就好了,继承父类F，F1，可以直接去里面的值
contract IsDemo is F,F1(){
uint public c1;//在赋值之前都是已经定义好的
uint public c2;
uint public c3;
function c() {
c1=F.u;
c2=F.test();
c3=F1.fu;
}
}
枚举：(enum)
pragma solidity ^0.4.;
contract Purchase {
enum State { Created, Locked, Inactive } // 枚举
}
结构：(struct)
结构：structs
pragma solidity ^0.4.; contract Ballot {
struct Voter { // 结构
uint weight;//无符号int类型
bool voted;//布尔类型
address delegate;//申明地址，20个字节长度
uint vote;//无符号整数类型
}
}
Mappings:映射
delete：初始化原来的值，并不是删除掉
event(string _s,uint _u)//定义事件
uint public x=100//定义一个无符号的数出来
uint[] public xArray=[uint(1),3,5,2,3]//定义一个数组
delete x是把x初始化了，并不是删除掉了,把x变成默认的值,最原始的值
pragma solidity ^0.4.;
contract DeleteDemo {
uint public data = ;
uint[] public dataArray = [uint(),,];
event e(string _str,uint _u);
event eArr(string _str,uint[] _u); function doDelete(){
uint x = data;
e("x",x);
delete x;
e("after x",x); e("data",data);
delete data;
e("after data",data); uint[] y = dataArray;
eArr("y",y);
delete dataArray;
eArr("after y",y);
}
}
modifier：修改器
//修改器，有些时候只有合约的创建者才可以执行
//修改器可以用来改变方法的行为，比如在方法正式执行之前，检查方法是否满足条件，如果满足条件，则执行方法，不满足则可以抛出异常
//解释一下 ，这个执行合约的过程，就是说当执行的owner不是设定的原来的时候，就会抛出异常，当时原来的时候，就会执行相对应的方法
pragma solidity ^0.4.; //注明一下，在这个合约里面定义了两个变量，一个是owner,一个是u，所以可以看到
contract modifyDemo{
address public owner;//声明一个地址账号
uint public u; function modifyDemo() {
owner=msg.sender//owner为当前消息得发送者,合约的部署者
} modifier onlyOwner{//注意modifier就是修改器，后面就跟着名称，没有括号得我
//修改器
if (msg.sender!=owner){
throw;//如果当前消息得发送者不等于owner的时候，就抛出异常
}else{
_;//固定写法
} function set(uint _u) onlyOwner{
u=_u;//符合的时候才会执行下面的方法,在合约页面的u就会被赋值_u，就是传进去的参数_u
}
}
}
selfdestory：自毁
//自毁,当执行之后发现右边不存在这个地址了，已经是销毁这个合约的状态了
pragma solidity ^0.4.; contract selfdestoryDemo{
uint internal u=;
function test() returns(uint){
return ;
} function selfdestoryDemo() payable{
//当执行这个合约的时候，可以向这个合约发送一些以太币
}
function kill(address add){
selfdestory(add)
}
}