2.　大脑袋
　　
　　"All the kids make fun of me," the boy cried to his mother. "They say I have a big head."
　　
　　"Don't listen to them," his mother consoled. "You have a beautiful head. Now stop crying and go to the store for ten pounds of potatoes."
　　
　　"Where's the shopping bag?"
　　
　　"I haven't got one, use you hat."

3.我可以回家了
　　
　　One day after school the teacher said to his students, "Tomorrow morning, if any one of you can answer my first question, I will permit him or her to go home earlier."
　　
　　The next day, when the teacher came into the classroom, he found the blackboard daubed（乱画）. He was very angry and asked, "Who did it? Please stand up!"
　　
　　"It's me," said Bob, "Now, I can go home. Good-bye, Sir."

4.你知道我是干什么的吗
　　
　　One night a hotel caught fire, and the people who were staying in it ran out in their night clothes.
　　
　　Two men stood outside and looked at the fire.
　　
　　“Before I came out,” said one,“I ran into some of the rooms and found a lot of money.People don't think of money when they're afraid. When anyone leaves paper money in a fire, the fire burns it. So I took all the bills that I could find. No one will be poorer because I took them.”
　　
　　“You don't know my work,” said the other.
　　
　　“What is your work？”
　　
　　“I'm a policeman.
　　
　　“Oh！” cried the first man. He thought quickly and said,“And do you know my work？”“No,”said the policeman.
　　
　　“I'm a writer. I'm always telling stories about things that never happened.”

5.那你当时在干什么
　　
　　A policeman comes upon a traffic accident. The driver and passenger had been killed. As the policeman look over the crashed car, a small monkey came out and hopped around the crashed car.
　　
　　The policeman looked down at the money and said, “I wish you could talk.”
　　
　　The monkey shook his head up and down.
　　
　　“You can understand what I say? ” asked the surprised policeman.
　　
　　Again, the monkey shook his head up and down.
　　
　　“Well, did you see the accident? ”
　　
　　“Yes,” motioned the monkey.
　　
　　“What happened? ”
　　
　　The monkey pretended to have a can in his hand and turned it up by his mouth.
　　
　　“They drank? ” Asked the policeman.
　　
　　“Yes.”
　　
　　“What else?”
　　
　　The monkey pinches his two fingers together and holds them by his mouth.
　　
　　“They were smoking? ”
　　
　　“Yes.”
　　
　　“Now, just wait a minute. You say that they were smoking and doing drugs just before the accident? ”
　　
　　“Yes.”
　　
　　“What did you do all the time? ”
　　
　　“Driving,” motioned the monkey.

6.我老婆的照片
　　
　　A businessman enters a tavern（酒馆）, sits down at bar,orders a double martini on the rocks.
　　
　　After he finishes the drink, he peeks inside his shirt pocket, then orders the bartender to prepare another double martini.
　　
　　After he finishes that, he again peeks inside his shirt pocket before orders the bartender to bring another double martini.
　　
　　The bartender says, "Look, buddy, I'll bring ya' martinis all night long - but you gotta tell me why you look inside your shirt pocket before you order refill."
　　
　　The customer replies, "I'm peeking at the photo of my wife. When she starts to look good, I know it's time to go home."

a boy buys toy in toy shop ,when boss askes the money is fake,the boy says that :your toy is also fake

2.Catch a cold 得感冒
During the fight, the boxer swiped the air furiously, but could not hit his opponent.

"How am I doing?" he asked the coach at the end of the round.

"Well, if you keep this up," replied the coach, "he might feel the wind and catch a cold."

3.Second language
A mother mouse was out for a stroll with her babies when she spotted a cat crouched behind a bush. She watched the cat, and the cat watched the mice.

Mother mouse barked fiercely, "Woof, woof, woof!" The cat was so terrified that it ran for it's life.

Mother mouse turned to her babies and said, "Now, do you understand the value of a second language?"

一只母老鼠带着孩子出来散步，突然她看见一只猫正在灌木丛中虎视耽耽。

母老鼠向着猫叫道：“汪，汪，汪”，猫听了非常害怕，拼命跑走了。

母老鼠回过头洋洋自得的对孩子说：“现在你知道外语的重要性了吧。”

4.这钟准吗？”
Dan was the doorman of a club in a big city. Everyday, thousands of people passed his door, and a lot of them stopped and asked him, "What's the time, please?"

After a few months, Dan said to himself, "I'm not going to answer all those stupid people any more. I'm going to buy a big clock and put it upon the wall here." Then he did so.

“Now people aren't going to stop and ask me the time," he thought happily.

But after that, a lot of people stopped, looked at the clock and then asked Dan, "Is that clock right?”

5.我已经反着铺了！”

A woman said to her husband, “dear, look at our sheet! It's too dirty. Would you like to wash it now?”

The man looked at the sheet and then thought for a while and then said, “I don't think it's necessary. We can turn the sheet over. Is that all right?”

His wife was very angry at this. “How lazy you are!” She shouted, “To tell you the truth, I turned it over last week.”

Hello,my friends,
These humors are collected from internet. Just for pleasure!

下载QQ

在派生类中要必须使用virtual关键字来实现抽象类中的抽象方法
如果没有实现抽象类中的方法,则派生类还是抽象类,并且一定要以abstract关键字声明
也就是说:抽象类的子类必须覆盖所有的抽象方法后才能被实例化，否则这个子类还是个抽象类

        string a = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
        string b = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });        //未开辟新内存空间,使用的还是a的内存空间,相当于a对象,它们两个在堆中使用的是一个内存空间.当建立b时，先在堆中查找有没有 所需要的内容，有的话，就直接指向，没有的话就新建一个
         Console.WriteLine (a==b);                                                //输出true,
        Console.WriteLine (a.Equals(b));                                           //输出true,

         object c = new object();
        object d = new object();      //在堆中开辟新的内存空间，对象内容与c是不同的，与字符串对象不同，这样的对象建立的时间，不用在堆中查找有没有相同的内容，直接在堆内存中开辟一块新的内存空间.
        Console.WriteLine(c == d);            //输出false,因为cd它们两个在栈中的内容不一样
        Console.WriteLine(c.Equals(d));      //输出false,因为虽然建立cd时所用的语法是一样的，但终究它们不是相同的对象，只有用object d=c;这样才是相同的对象

　　　object e = new object();
        　object f = e;                     新建立对象f，这时把已经有的对象赋给f，这样f就不会在堆内存中开辟新的内存空间，而是直接把,e的引用传给f，也就是把e在栈中的引用值，传到f在栈中的内存中.这样它们就同时指向了相同的椎内存.
        Console.WriteLine(c == d);
        Console.WriteLine(c.Equals(d));

}
说明equals比较的是堆中的内容,也就是两个对象的内容;
而==比较的是值，也就是栈中的内容.

总结，用string 建立新对象时，会在内存中查找有没有相同的内容，有的话，直接把新建立的对象指过去，没有的话，就在堆中开辟新的内存空间．这个string对象还是比较特殊的.
而用其它类新建立的对象，就没有在堆中查找的步骤，直接在堆内存中开辟一块新的内存空间．当然不包括下面这种形式：　　　
object e = new object();
object f = e;
把新建立的对象以原有的对象赋值，这样就不会在堆内存中开辟新的空间．

以上内容是操作中得到的，正确与否，有待进一步考察．
(在java中好像以下是建立不相同的对象,也就是说在堆中的不共用内存,当然在栈内存中保留的引用也不相同,但彼此的堆内容是相同的,都是字符串"abc".       
string a = new string("abc");
string b = new string("abc")

一个方法声明中如果加上abstract修饰符，我们称该方法为抽象方法(abstract method)。

如果一个方法被声明也是抽象的，那么该方法默认也是一个虚方法。事实上，抽象方法是一个新的虚方法，它不提供具体的方法实现代码。我们知道，非虚的派生类要求通过重载为继承的虚方法提供自己的实现，而抽象方法则不包含具体的实现内容，所以方法声明的执行体中只有一个分号“；”。

只能在抽象类中声明抽象方法。对抽象方法，不能再使用static或virtual修饰符，而且方法不能有任何可执行代码，哪怕只是一对大括号中间加一个分号“{;}”都不允许出现，只需要给出方法的原型就可以了。本文发表于www.bianceng.cn

“交通工具”的“鸣笛”这个方法实际上是没有什么意义的，接下来我们利用抽象方法的概念继续改写汽车类的例子：

程序清单14-6:

using System;
abstruct class Vehicle //定义汽车类
{
  public int wheels; //公有成员：轮子个数
  protected float weight; //保护成员：重量
  public Vehicle(int w,float g){
     wheels=w;
     weight=g;
  }
 public abstract void Speak();
};

class Car:Vehicle //定义轿车类
{
  int passenger; //私有成员：乘客数
  public Car(int w,float g,int p):base(w,g)
  {
    wheels=w;
    weight=g;
    passengers=p;
  }
  public override void Speak(){
    Console.WriteLine("The car is speaking:Di-di!");
   }
}

class Truck:Vehicle //定义卡车类
{
  int passengers; //私有成员：乘客数
  float load; //私有成员：载重量
  public Truck(int w,float g,int p,float l):base(w,g)
  {
   wheels=w;
   weight=g;
   passengers=p;
   load=l;
  }
  public override void Speak(){
    Console.WriteLine("The truck is speaking:Ba-ba!");
   }
}

还要注意，抽象方法在派生类中不能使用base关键字来进行访问。例如，下面的代码在编译时会发生错误：

class A
{
public abstract void F();
}

class B:A
{
public override void F(){
base.F(); //错误，base.F是抽象方法
}
}
我们还可以利用抽象方法来重载基类的虚方法，这时基类中虚方法的执行代码就被“拦截”了。下面的例子说明了这一点：

class A
{
 public virtual void F(){
    Console.WriteLine("A.F");
 }
}

abstract class B:A
{
 public abstract override void F();
}

class C:B
{
 public override void F(){
  Console.WriteLine("C.F");
 }
}

类A声明了一个虚方法F，派生类B使用抽象方法重载了F，这样B的派生类C就可以重载F并提供自己的实现。

            //while (current != null)
            //{
            //    Console.Write(current.Data);
            //    current = current.Next;
            //}
            bool myBool = true;
            int myInt = 123;
            int myInt2 = 235;
            List list = new List();
            list.InsetAtFront(myBool);
            list.InsertAtBack(myInt);
            list.InsertAtBack(myInt2);
           
            list.Print();
        }
    }

    class ListNode
    {
        private object data;
        private ListNode next;
        public ListNode(object dataValue)
            :this(dataValue,null)
        {
        }
        public ListNode(object dataValue, ListNode nextNode)
        {
            data = dataValue; //存储本结点值
            next = nextNode;   //关联下一结点,next称为链
        }
        public ListNode Next   //自引用类,产生
        {
            get
            {
                return next;
            }
             set
            {
                next = value;
            }
        }
        public object Data
        {
            get
            {
                return data;
            }

        }
       
    }
    public class List
    {
        private ListNode firstNode;
        private ListNode lastNode;
        private string name;
        public List(string listName)
        {
            name = listName;
            firstNode = lastNode = null;
        }
        public List()
            : this("list")
        {
        }
        public void InsetAtFront(object insertItem)
        {
            if (IsEmpty())
                firstNode = lastNode = new ListNode(insertItem);
            else
                firstNode = new ListNode(insertItem,firstNode);

        }
        public void InsertAtBack(object insertItem)
        {
            if (IsEmpty())
                firstNode = lastNode = new ListNode(insertItem);
            else
                lastNode = lastNode.Next = new ListNode(insertItem);
        }
        public bool IsEmpty()
        {
            return firstNode == null;
        }
        public void Print()
        {
            if(IsEmpty())
            {return;
            }
        ListNode current = lastNode;
        while (current != null)
        {
            Console.WriteLine(current.Data);
            current=current.Next;
        }

        }
    }

        }
    }
    interface aa
    {
        void fun();
    }
    public abstract class aaa : aa
    {
        public void fun()
        {

        }
    }

DataReader是对数据一次性前向只读的数据阅读器，用来接受XXXcommand的EcexuteReader方法查询数据库的结果，EcexuteReader只返回数据。
DataAdapter和XXXcommand比较相似，有一个SQL语句和连接对象构成。其调用fill方法将查询数据库的结果保存在dataset中的datatable中，fill方法检索数据，并且检索模式，也就是每个字段的字段名，数据类型，最大长度及其他属性.

        }
        public string NameIn
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
                myEvent("gf");
            }
        }
    }

    class eventClass
    {
        public void willEvent(string str)
        {
            Console.WriteLine("事件被触发,名字被修改为"+str);
        }

    }

    class Program
    {   
        static void Main(string[] args)
        {
            eventClass modifyevent = new eventClass();

            myClass myclass = new myClass();
            myclass.myEvent += new myClass.delegateControl(modifyevent.willEvent);
            myclass.NameIn = "gf";
        }

    }

++++++++++++++++++++++++++++++

如何理解委托？

答:据说相当于函数指针,定义了委托就可以在不调用原方法名称的情况下调用那个方法.

msdn2005中是这样解释的:

委托具有以下特点：

委托类似于 C++ 函数指针，但它是类型安全的。

委托允许将方法作为参数进行传递。

委托可用于定义回调方法。

委托可以链接在一起；例如，可以对一个事件调用多个方法。

方法不需要与委托签名精确匹配。有关更多信息，请参见协变和逆变。

C# 2.0 版引入了匿名方法的概念，此类方法允许将代码块作为参数传递，以代替单独定义的方法。

        }
    }

        }
    }

       }
    }

public abstract class myclass
{
    public abstract void fun();
    public void fun2()
    {
        Console.WriteLine("我是抽象类中的函数");
    }
}
public class class1:myclass
{
    public override void fun()
    {
        Console.WriteLine("我是抽象类产生的");
    }
}
public class class2 : myclass
{
    public override void fun()
    {
        Console.WriteLine("我是抽象类产生的第二个类");
    }
}

interface myinterface            //这里不用加什么修饰符,接口本来就是用来继承的,只能是public
{
          void fun(string a);        //接口中的函数定义不能声明访问修饰符(否则会提示修饰符无效),可以带参数
}
public class classinter1:myinterface
{
    public void fun(string a)
    {
        Console.WriteLine("我是接口产生的类一");
    }
}
public class classinter2:myinterface
{
    public void fun(string a)
    {
        Console.WriteLine("我是接口产生的类二");
    }
}