关于texbox 分享《菜鸟》

＾陪妳ソ看日落

[mw_shl_code=csharp,true]C#里面的小技巧
1、假如在TexBox中输入123那么默认为字符串形式，想要转化为十进制数字Convert.int32(texbox1.tex);这样就把texbox1中的字符串转换为十进制形式。
2、文本框中假如要输出多行数据首先要将文本框属性Mutiline属性设置为True；假如要输出一系列数据如1,2,3,4,5；因为该文本框中的内容是一个整体，所以要在每一个字符后面进行回车   换行，texbox1.text="1"+"\r\n"+"2"+"\r\n"+"3"+"\r\n"+"4"+"\r\n"+"5"+"\r\n";值得注意的是，文本框中的回车换行是\r\n一起用。
3、在窗体上添加一个按钮，当双击按钮时关闭窗体，可以在button_click事件中添加this.close()；
4、在文本框中如果想要实现为空时触发，敲回车等非可见字符也不是空，因为那样也算文本框中有内容，只有将判断条件设置为长度为0才可以，因为回车不算长度；
5、怎么将窗体变成与前面学的类结合起来，在窗体中添加现有项可以将以前写好的一些常用的类添加到窗体中，然后引用，比方说在一个
    private void button1_Click(object sender, EventArgs e)
        {
            student stu = new student("张三","00001");//这是利用已有的类student 有一个两个参数的构造函数，和两个属性一个是num的_num,和name的_Name;
            textBox1.Text = stu._num;
            textBox2.Text = stu._Name;
           OpenFileDialog ofd = new OpenFileDialog();//这下面是如何获得打开本地目录的地址，在Form.Text上显示；
            if (ofd.ShowDialog() == DialogResult.OK)
            {
                string filename = ofd.FileName;
                this.Text = filename;
            }
        }
6、索引函数：每个类中只能有一个索引函数，索引函数作用就是用索引下标方便的访问一个集合中的某个元素；下面这个例子中在主函数中先创建ClassmateList的对象clist，然后直接对象   +下标内部就会寻找类中的索引函数，clist[0]就表示索引函数中的classmates[0],也就是看索引函数中当满足某索引值时get和set中的的值，那么对象加下标就表示的是谁就像主函数中   clist[0]其实表示的是classmates[0],clist[1]表示的是clist[1];
   例： public class ClassmateList
    {
        private string title;
        private Student[] classmates;
        public Student this[int index]
        {
            get
            {
                return classmates[index];
            }
            set
            {
                classmates[index] = value;
            }
        }
        public ClassmateList(string title)
        {
            this.title = title;
            classmates = new Student[100];
        }
     }
    主函数
            ClassmateList clist = new ClassmateList("我的大学同学录");
            clist [0] = new Student("张茂林");
            clist[1] = new Student("杨坤");
           
            for (int i = 0; i <= 1; i++)
            {
                Console.WriteLine(clist[i]._Name);
            }
7、一个类Animal 创建一个cat1对象，其中cat1.age=10； Animal cat2=cat1，cat2.age++；那么此时cat1.age和cat2.age都是11，为什么呢，因为当cat2=cat1时，这两个对象其实就已经指   向了同一个内存空间，都指向同一个age变量，所以任意一个改变两个都变。

8、如何判断任意一个数是升序数：
    先将该数转化为字符串型，string s=Convert.Tostring(data);
    判断函数for(int i=0;i<s.Length-1;i++)
       {
      if((s[i]>=s[i+1])/
        return false;
    }
    if(i>=s.Length-1)
      return true;/这里是s[i]和s[i+1]都是数字的字符形式,但是当比较大小时会用asscll码比较；字符‘5’的asscll码小于‘6’；
9、值类型和引用类型，值类型有一般数据类型，枚举类型，结构体类型，引用类型有类，委托，接口，等，以下面两个例子说明引用类型和值类型不同
   struct ComplexNumber
  {
     public double a;
     public double b;
  }
   ComplexNumber c1 = new ComplexNumber();
   c1.a = 2.5;
   c1.b = 5;
   ComplexNumber c2 = c1;
   c2.b = 10;
   结构体类型的变量c1在创建时会申请一个内存空间c1，c2=c1，这样创建c2也会申请一个内存空间，只是初始的c2=c1，档c2.b=10时只修改了内存空间c2中b的值而没有修改c1中b的值
   class ComplexNumber
  {
    public double a;
    public double b;
  }  
  ComplexNumber c1 = new ComplexNumber();
   c1.a = 2.5;
   c1.b = 5;
   ComplexNumber c2 = c1;
   c2.b = 10;
   类属于引用类型，在创建第一个c1对象时会申请一个内存空间，然后对其中的值a，b赋值，创建第二个对象c2=c1，这样c2同样指向c1内存空间，其中的a，b都是同一个内存空间的值，修    改任何一个c1或者c2，a，b的值都会修改。
10、C#中位操作符，&（两个操作数各位相与），|（两个操作数各位相或),^(两个操作数各位异或），~（对一个操作数非），>>右移操作，如果是正数，右边移走的舍弃，左边补0，如果是    负数，以补码进行操作，移位左边补1，右边右移舍弃。<<左移操作类似。
11、protected变量只能在本类或派生类中使用，internal变量只能在一个程序集中使用，什么叫一个程序集呢，一个命名空间，在写的类中新加项-类，这个新加的类跟原来的类命名空间是     相同的所以是同一个程序集。

＾陪妳ソ看日落

[mw_shl_code=csharp,true]12、static静态变量是所有类的对象共用的一个变量，只在内存中申请一块内存，而其他变量每创建一个对象都会申请一个内存空间，修改静态变量只能由类修改，修改后所有对象引用该变 量都已经改变。Const常量在初始必须赋值，以后不能改变，且只能由类引用而不能由对象使用 class Circle{ public const double PI = 3.14;}main(){Console.WriteLine (Circle.PI);},readonly也是定义只读常量，但是只能由对象使用
public class Circle
{
public double r;
public readonly double PI = 3.14;
}
Circle c1 = new Circle();
Console.WriteLine(c1.r);
c1.r = 10;
Console.WriteLine(c1.PI);
13、值传递和引用传递不同
public void Swap(int x, int y)
{
int z = x;
x = y;
y = z;
}
int a = 10;
int b = 20;
Swap(a, b);
这样调用函数后a，b的值不会交换，因为只是方法中的x，y交换而并未影响到a，b，调用时只是将a，b的值分别复制给了x，y；
public void Swap(ref int x, ref int y)
{
int z = x;
x = y;
y = z;
}
int a = 10;
int b = 20;
Swap(a, b);
这样是引用型调用，使用函数时，是将a，b的内存单元的地址给了x，y，x和y交换就是将a，b的地址交换，再使用a，b时，a其实是指向b单元的地址了，而b是指向刚才a单元的地址 了。所以此时a，b的值交换了
14、数组型参数：需要传递的参数个数不确定时，可以采用params关键字，其后一般跟一个数组。数组型参数params可与其它类型的参数合用，但params参数必须是参数列表中的最后一个方 法的参数列表中params参数不能超过1个

public int Sum(params int[] x)
{
int s = 0;
for(int i=0; i<x.Length; i++)
s += x[i];
return s;
}
int[] x = {1, 3, 5, 7, 9};
int s1 = Sum(x);
int s2 = Sum(2, 4, 6, 8, 10);
15、构造函数两个作用，初始化变量，为对象申请内存空间。如果没有定义构造函数系统会默认类中包含一个无参构造函数，可以再创建对象时使用，而如果定义了带参的构造函数，C#就不 再提供无参缺省构造函数，此时再以无参创建对象就会出错。
16、私有构造函数是一种特殊的实例构造函数。 它通常用在只包含静态成员的类中。 如果类具有一个或多个私有构造函数而没有公共构造函数，则其他类（除嵌套类外）无法创建该类的实 例。 总结：如果该类中全是static变量则不能由对象调用，那么直接定义一个私有构造函数，干脆不能创建实例，也就省了以后不能引用static变量而白白创建一个对象浪费内存。
17、静态构造函数既没有访问修饰符，也没有参数。在创建第一个实例或引用任何静态成员之前，将自动调用静态构造函数来初始化类。 无法直接调用静态构造函数。在程序中，用户无法控 制何时执行静态构造函数。静态构造函数在创建第一个对象或首次使用静态变量时出发。
public class Bus {
// Static constructor:
static Bus() {
System.Console.WriteLine("The static constructor invoked.");
}
public static void Drive() { System.Console.WriteLine("The Drive method invoked.");
} }
class TestBus {
static void Main() {
Bus.Drive();
} }
输出：
The static constructor invoked.
The Drive method invoked
18、如果一个类中有另一个类的对象，那么常常在该类的构造函数中对其进行实例化，或者如果该类中包含的是另一个类的对象数组那么常常在构造函数中对其进行对象数组的个数确定。

public class Student
{
private string name;
public string MyName
{
get {return name; }
set {name = value;}
}
private Address address;//Address是一个类。
public Address getaddress
{ get{ return address;}}
public Student(string n)
{ name=n;
address = new Address();//用构造函数将对象实例化。
}
}
public class School
{ private string title;
private Student[] students;//Student是一个类，定义一个对象数组但是没有个数。
public Student this[int index]//索引函数，一个类中只能有一个索引函数，在使用时，用对象+标，就会自动找到该类中的索引函数
{
get { return students[index]; }
set { students[index] = value; }
}
public School(string t)
{
title=t;
students = new Student[100];用构造函数确定对象数组的个数。
}
}
School glass = new School(“南京农业大学”);
glass[0] = new Student(“一一”);//对象+下标，这样glass[0]就代表students[0]。
glass[1] = new Student(“二二”);
for(int i=0;i<2;i++)
{
Console.WriteLine(glass[i].MyName);
}
19、DateTime t=new DateTime(2012,6,10);
DateTime t=DateTime.Now;
Console.WriteLine(t);//2012/6/10/11:04:21;
Console.WriteLine(t.ToShortDateString());//2012/6/10
Console.WriteLine(t.ToLongDateString());//2012/6/10,星期天
Console.WriteLine(t.ToShortTimeString());//11:05
Console.WriteLine(t.ToLongTimeString());//11:05:21
20、Random r=new Random();
r.Next(10);//产生10以内的大于等于0的正整数；
r.NextDouble();//产生双精度浮点数
21、类中不定义构造函数则默认包含一个无参构造函数，派生类不能继承构造函数，但是需要用base（参数）如果不写 base(str)，则默认是base()，此时基类必须定义无参数构造函数；
class baseclass
{
public baseclass()
{
Console.WriteLine("基类构造函数被调用");
}
}
class Sonclass
{
public Sonclass()
{
Console.WriteLine("派生类构造函数被调用");
}
}
main()
{
Sonclass son=new();//输出结果：基类构造函数被调用
派生类构造函数被调用
}
解析：派生类构造函数如果没有base（str）默认调用base（），也就是不含参数的基类构造函数，如果派生类构造函数声明base（str）则调用基类的对应的参数个数的构造函数， 如果不声明base（str），而基类中又定义了包含参数的构造函数，而没有定义不包含参数的构造函数，那么就会编译出错，因为，派生类默认调用基类不含参数的构造函数，而每个类如 果自己不定义构造函数那么默认包含一个不含参数构造函数，而一旦自己定义了构造函数那么默认的构造函数讲不存在；派生类中构造函数通过base（str）可以确定调用基类中的哪一个 构造函数 。派生类调用构造函数的顺序是基类-》自己，析构函数是先调用自己的在调用基类的。
如果基类中有带参数的构造函数，那么一定要在派生类中被继承，必须有派生类中的必须实现将参数传递给基类构造函数的途径，以保证基类构造函数初始化时有数据。但是如果不 继承而在基类中定义不含参数的构造函数，那么编译时也不会报错，只不过基类中的变量肯能缺少初始化的数据。
21、抽象方法只有方法名没有实现，是空方法，隐式为虚方法必须被覆盖。抽象类是包含抽象方法的类，抽象类不能创建对象，只能被继承，而且其中的抽象方法要么被实现，要么也是抽象 方法。
22、overload：重载是指一个类中，同名方法（普通方法、构造方法、静态方法、运算符、索引）不同参数签名。
override：覆盖是指子类/派生类对父类/基类中虚函数或抽象函数的“覆盖”。
方法的覆盖和重载的区别是：
覆盖肯定是方法名、方法的返回值、方法的形参要相等。
而重载方法的名同样一定相等，但方法的形参类型、个数肯定不相等！
23、public class Animal
{
public int nicai;
public virtual void Eat()
{
Console.WriteLine("Eat something");
}
}
public class Cat : Animal
{
public string kao;
public override void Eat()
{
Console.WriteLine("Eat mouse !");
}
}
在创建对象时可以Animal a=new Cat();Cat c=new Cat(); Animal b=c；Cat c1=new Cat();但是通过第一、三种方法创建的对象只能访问Animal中的量，也就是只能访问nicai，和Eat（ ），不能访问Cat中的东西。但是通过第一、三种方法创建的a和b对象其类型都是Cat型的。

＾陪妳ソ看日落

[C#] 纯文本查看 复制代码

24、C#中接口和抽象类的区别，一个类只能继承一个抽象类，但可以继承多个接口，接口是比抽象类更抽象的层次，没有任何实现，当继承的多个接口中有形同的方法名时用显示接口实现，
接口定义时方法没有访问修饰符，但是interface关键字前可以加修饰符
interface ICarnivore //接口的定义。
{
bool IsHungry { get; }
Animal Hunt();
void Eat(Animal victim);
}
public class Lion: ICarnivore //接口的继承实现。
{
private bool hungry;
public bool IsHungry {
get { return hungry; }
}
public Animal Hunt (){
…
}
}
public interface IPictManip
{
void ApplyAlpha();
} 这两个接口是包含同样方法的接口，下面介绍怎样进行显示接口实现。
public interface IPict
{
void ApplyAlpha();
}
public class MyImages : BaseIO, IPict, IPictManip
{
public int DeleteImage()
{
Console.WriteLine(“DeleteImage 实现！");
return(5);
}
public void ApplyAlpha()
{
Console.WriteLine(“ApplyAlpha 实现！");
}
void IPict.DisplayImage()
{
Console.WriteLine(“DisplayImage 的 IPict 实现");
}
void IPictManip.DisplayImage()
{
Console.WriteLine(“DisplayImage 的 IPictManip 实现");
}
}
static void Main(string[] args)
{
MyImages objM = new MyImages();
IPict Pict = objM; //IPict 引用
Pict.DisplayImage();
IPictManip PictManip = objM; //IPictManip 引用
PictManip.DisplayImage();
}
25、自创保留小数点后固定位数浮点数。
假如三个浮点数93 94 96求三个数的平均数94.3333333333，假如想保留小数点两位怎么做呢，方法，string str=Convert.Tostring(average);//将平局数先转化为字符串
然后int j=str.IndexOf('.');//找到小数点的位置。j=j+3;//由保留小数点后长度+1+j(自己可以验证一下）；str=str.Substring(0,j);//获得从第0个字符j长度的子串，
此时str就是小数点后保留两位了。此时并没有四舍五入。字符串中的每个字符不能+1等因为是直读的，可以将str每个字符都复制到一个字符数组中，char[]c=str.ToCharArry();
j=str.IndexOf('.');j=j+3(这是小数点后第三位的位置）；if(c[j]>='5'){c[j-1]=c[j-1]+1;},然后将字符数组的从第0个开始长度为j的组合成为字符串，str=new string(c,0,j);
此时的str就是四舍五入的精确到小数点后两位的浮点数了；
26、C#中关于String类型的常用方法 2010-09-10 22:28:00| 分类： 默认分类 | 标签： |字号大中小 订阅 .

Equals(string value)

返回一个BOOL型,比较是否相等,和"=="类似

Compareto(string value)

判断大小,大返回1 小返回-1 相等返回0


IndexOf(string value)

在当前字符串里找到这个字符,从第一个开始找,找到就返回第一次找到所在的索引,如果找不到返回-1

例: 1123 如果找1的话 返回0



LastIndexOf(string value)

和上面一样,不过是从后往前找,返回第一次所找到的索引

例:1123 如果找1的话 返回1
Join(string value,string[] string,int statindex,int count) //后面两个参数一个是开始的索引,一个是
作用的数量
这个方法和其他方法不一样,调用的时候是从String调用出来,作用就是把数组通过一个字符串连接起来返回一个字符串
string[] ary={"a","b","c"};
string result=String.Join("_",ary);
最后result的值为 a_b_c 通过"_"连接起来了
Split(char value)

将一个string类型用char分开.

例:

string[] ary;

string str2;

string str1="a_b_c_d";

ary=str1.Split('_'); //注意方法的参数是一个Char类型,返回的是一个数组

foreach(string s in ary)

{

str2+=s;

}

最后str2的值为abcd
SubString(int index,int length)

从指定的位置截取指定长度的字符串

String str1="abcdefg";

str1.SubString(1,2);

str1的结果就是bc
str1.SubString(2,3);
就是cde 2表示索引位置,3表示长度
ToLower();
全部转换为小写
ToUper();
全部转换为大写
Trim();
去掉前后空格
27、在窗体程序假如一个显示学生信息的窗体，每增加一个学生要统计学生的个数，可以再program.cs中添加一个静态类，里面只有一个静态变量
如下，这样在Form.cs中直接用Count.Count1++就可以显示个数了。
public static class Count
{
private static int count = 0;
public static int Count1
{
get
{
return count;
}
set
{
count = value;
}
}
}

[/mw_shl_code][/mw_shl_code]

＾陪妳ソ看日落

[C#] 纯文本查看 复制代码

1、假如在TexBox中输入123那么默认为字符串形式，想要转化为十进制数字Convert.int32(texbox1.tex);这样就把texbox1中的字符串转换为十进制形式。
2、文本框中假如要输出多行数据首先要将文本框属性Mutiline属性设置为True；假如要输出一系列数据如1,2,3,4,5；因为该文本框中的内容是一个整体，所以要在每一个字符后面进行回车   换行，texbox1.text="1"+"\r\n"+"2"+"\r\n"+"3"+"\r\n"+"4"+"\r\n"+"5"+"\r\n";值得注意的是，文本框中的回车换行是\r\n一起用。
3、在窗体上添加一个按钮，当双击按钮时关闭窗体，可以在button_click事件中添加this.close()；
4、在文本框中如果想要实现为空时触发，敲回车等非可见字符也不是空，因为那样也算文本框中有内容，只有将判断条件设置为长度为0才可以，因为回车不算长度；
5、怎么将窗体变成与前面学的类结合起来，在窗体中添加现有项可以将以前写好的一些常用的类添加到窗体中，然后引用，比方说在一个
    private void button1_Click(object sender, EventArgs e)
        {
            student stu = new student("张三","00001");//这是利用已有的类student 有一个两个参数的构造函数，和两个属性一个是num的_num,和name的_Name;
            textBox1.Text = stu._num;
            textBox2.Text = stu._Name;
           OpenFileDialog ofd = new OpenFileDialog();//这下面是如何获得打开本地目录的地址，在Form.Text上显示；
            if (ofd.ShowDialog() == DialogResult.OK)
            {
                string filename = ofd.FileName;
                this.Text = filename;
            }
        }
6、索引函数：每个类中只能有一个索引函数，索引函数作用就是用索引下标方便的访问一个集合中的某个元素；下面这个例子中在主函数中先创建ClassmateList的对象clist，然后直接对象   +下标内部就会寻找类中的索引函数，clist[0]就表示索引函数中的classmates[0],也就是看索引函数中当满足某索引值时get和set中的的值，那么对象加下标就表示的是谁就像主函数中   clist[0]其实表示的是classmates[0],clist[1]表示的是clist[1];
   例： public class ClassmateList
    {
        private string title;
        private Student[] classmates;
        public Student this[int index]
        {
            get
            {
                return classmates[index];
            }
            set
            {
                classmates[index] = value;
            }
        }
        public ClassmateList(string title)
        {
            this.title = title;
            classmates = new Student[100];
        }
     }
    主函数
            ClassmateList clist = new ClassmateList("我的大学同学录");
            clist [0] = new Student("张茂林");
            clist[1] = new Student("杨坤");
           
            for (int i = 0; i <= 1; i++)
            {
                Console.WriteLine(clist[i]._Name);
            }
7、一个类Animal 创建一个cat1对象，其中cat1.age=10； Animal cat2=cat1，cat2.age++；那么此时cat1.age和cat2.age都是11，为什么呢，因为当cat2=cat1时，这两个对象其实就已经指   向了同一个内存空间，都指向同一个age变量，所以任意一个改变两个都变。

8、如何判断任意一个数是升序数：
    先将该数转化为字符串型，string s=Convert.Tostring(data);
    判断函数for(int i=0;i<s.Length-1;i++)
       {
      if((s[i]>=s[i+1])/
        return false;
    }
    if(i>=s.Length-1)
      return true;/这里是s[i]和s[i+1]都是数字的字符形式,但是当比较大小时会用asscll码比较；字符‘5’的asscll码小于‘6’；

＾陪妳ソ看日落

[C#] 纯文本查看 复制代码

9、值类型和引用类型，值类型有一般数据类型，枚举类型，结构体类型，引用类型有类，委托，接口，等，以下面两个例子说明引用类型和值类型不同
   struct ComplexNumber
  {
     public double a;
     public double b;
  }
   ComplexNumber c1 = new ComplexNumber();
   c1.a = 2.5;
   c1.b = 5;
   ComplexNumber c2 = c1;
   c2.b = 10;
   结构体类型的变量c1在创建时会申请一个内存空间c1，c2=c1，这样创建c2也会申请一个内存空间，只是初始的c2=c1，档c2.b=10时只修改了内存空间c2中b的值而没有修改c1中b的值
   class ComplexNumber
  {
    public double a;
    public double b;
  }  
  ComplexNumber c1 = new ComplexNumber();
   c1.a = 2.5;
   c1.b = 5;
   ComplexNumber c2 = c1;
   c2.b = 10;
   类属于引用类型，在创建第一个c1对象时会申请一个内存空间，然后对其中的值a，b赋值，创建第二个对象c2=c1，这样c2同样指向c1内存空间，其中的a，b都是同一个内存空间的值，修    改任何一个c1或者c2，a，b的值都会修改。
10、C#中位操作符，&（两个操作数各位相与），|（两个操作数各位相或),^(两个操作数各位异或），~（对一个操作数非），>>右移操作，如果是正数，右边移走的舍弃，左边补0，如果是    负数，以补码进行操作，移位左边补1，右边右移舍弃。<<左移操作类似。
11、protected变量只能在本类或派生类中使用，internal变量只能在一个程序集中使用，什么叫一个程序集呢，一个命名空间，在写的类中新加项-类，这个新加的类跟原来的类命名空间是     相同的所以是同一个程序集。
12、static静态变量是所有类的对象共用的一个变量，只在内存中申请一块内存，而其他变量每创建一个对象都会申请一个内存空间，修改静态变量只能由类修改，修改后所有对象引用该变    量都已经改变。Const常量在初始必须赋值，以后不能改变，且只能由类引用而不能由对象使用 class Circle{ public const double PI = 3.14;}main(){Console.WriteLine      (Circle.PI);},readonly也是定义只读常量，但是只能由对象使用
    public class Circle
   {
      public double r;
      public readonly double PI = 3.14;
    }
      Circle c1 = new Circle();
      Console.WriteLine(c1.r);
     c1.r = 10;
     Console.WriteLine(c1.PI);
13、值传递和引用传递不同
    public void Swap(int x, int y)
    {
      int z = x;
       x = y;
       y = z;
    }
    int a = 10;
    int b = 20;
    Swap(a, b);
    这样调用函数后a，b的值不会交换，因为只是方法中的x，y交换而并未影响到a，b，调用时只是将a，b的值分别复制给了x，y；
    public void Swap(ref int x, ref int y)
    {
      int z = x;
      x = y;
      y = z;
    }
    int a = 10;
    int b = 20;
    Swap(a, b);
    这样是引用型调用，使用函数时，是将a，b的内存单元的地址给了x，y，x和y交换就是将a，b的地址交换，再使用a，b时，a其实是指向b单元的地址了，而b是指向刚才a单元的地址            了。所以此时a，b的值交换了
14、数组型参数：需要传递的参数个数不确定时，可以采用params关键字，其后一般跟一个数组。数组型参数params可与其它类型的参数合用，但params参数必须是参数列表中的最后一个方    法的参数列表中params参数不能超过1个

    public int Sum(params int[] x)
   {
       int s = 0;
       for(int i=0; i<x.Length; i++)
       s += x[i];
       return s;
    }
    int[] x = {1, 3, 5, 7, 9};
    int s1 = Sum(x);
      int s2 = Sum(2, 4, 6, 8, 10);
15、构造函数两个作用，初始化变量，为对象申请内存空间。如果没有定义构造函数系统会默认类中包含一个无参构造函数，可以再创建对象时使用，而如果定义了带参的构造函数，C#就不    再提供无参缺省构造函数，此时再以无参创建对象就会出错。
16、私有构造函数是一种特殊的实例构造函数。 它通常用在只包含静态成员的类中。 如果类具有一个或多个私有构造函数而没有公共构造函数，则其他类（除嵌套类外）无法创建该类的实    例。 总结：如果该类中全是static变量则不能由对象调用，那么直接定义一个私有构造函数，干脆不能创建实例，也就省了以后不能引用static变量而白白创建一个对象浪费内存。
17、静态构造函数既没有访问修饰符，也没有参数。在创建第一个实例或引用任何静态成员之前，将自动调用静态构造函数来初始化类。 无法直接调用静态构造函数。在程序中，用户无法控    制何时执行静态构造函数。静态构造函数在创建第一个对象或首次使用静态变量时出发。
    public class Bus {
    // Static constructor:
    static Bus() {
        System.Console.WriteLine("The static constructor invoked.");
    }
    public static void Drive() {     System.Console.WriteLine("The Drive method invoked.");
    } }
    class TestBus {
    static void Main() {
        Bus.Drive();
    } }
   输出：
     The static constructor invoked.
      The Drive method invoked

＾陪妳ソ看日落

[C#] 纯文本查看 复制代码

18、如果一个类中有另一个类的对象，那么常常在该类的构造函数中对其进行实例化，或者如果该类中包含的是另一个类的对象数组那么常常在构造函数中对其进行对象数组的个数确定。

  public class Student
  {
    private string name;
    public string MyName
   {
     get {return name; }
     set {name = value;}
   }
    private Address address;//Address是一个类。
    public Address getaddress
   { get{ return address;}}
    public Student(string n)
   { name=n;
    address = new Address();//用构造函数将对象实例化。
    }
  }
   public class School
  { private string title;
  private Student[] students;//Student是一个类，定义一个对象数组但是没有个数。
  public Student this[int index]//索引函数，一个类中只能有一个索引函数，在使用时，用对象+标，就会自动找到该类中的索引函数
  {
    get { return students[index]; }
    set { students[index] = value; }
  }
  public School(string t)
  {
    title=t;
    students = new Student[100];用构造函数确定对象数组的个数。
  }
}
  School glass = new School(“南京农业大学”);
  glass[0] = new Student(“一一”);//对象+下标，这样glass[0]就代表students[0]。
  glass[1] = new Student(“二二”);
  for(int i=0;i<2;i++)
  {
      Console.WriteLine(glass[i].MyName);
   }
19、DateTime t=new DateTime(2012,6,10);
    DateTime t=DateTime.Now;
    Console.WriteLine(t);//2012/6/10/11:04:21;
    Console.WriteLine(t.ToShortDateString());//2012/6/10
    Console.WriteLine(t.ToLongDateString());//2012/6/10,星期天
    Console.WriteLine(t.ToShortTimeString());//11:05
    Console.WriteLine(t.ToLongTimeString());//11:05:21
20、Random r=new Random();
    r.Next(10);//产生10以内的大于等于0的正整数；
    r.NextDouble();//产生双精度浮点数
21、类中不定义构造函数则默认包含一个无参构造函数，派生类不能继承构造函数，但是需要用base（参数）如果不写 base(str)，则默认是base()，此时基类必须定义无参数构造函数；
    class baseclass
    {
    public baseclass()
    {
         Console.WriteLine("基类构造函数被调用");
    }
     }
     class Sonclass
     {
    public Sonclass()
    {
       Console.WriteLine("派生类构造函数被调用");
    }
      }
    main()
    {
        Sonclass son=new();//输出结果：基类构造函数被调用
                       派生类构造函数被调用
    }
    解析：派生类构造函数如果没有base（str）默认调用base（），也就是不含参数的基类构造函数，如果派生类构造函数声明base（str）则调用基类的对应的参数个数的构造函数，    如果不声明base（str），而基类中又定义了包含参数的构造函数，而没有定义不包含参数的构造函数，那么就会编译出错，因为，派生类默认调用基类不含参数的构造函数，而每个类如   果自己不定义构造函数那么默认包含一个不含参数构造函数，而一旦自己定义了构造函数那么默认的构造函数讲不存在；派生类中构造函数通过base（str）可以确定调用基类中的哪一个   构造函数   。派生类调用构造函数的顺序是基类-》自己，析构函数是先调用自己的在调用基类的。
    如果基类中有带参数的构造函数，那么一定要在派生类中被继承，必须有派生类中的必须实现将参数传递给基类构造函数的途径，以保证基类构造函数初始化时有数据。但是如果不        继承而在基类中定义不含参数的构造函数，那么编译时也不会报错，只不过基类中的变量肯能缺少初始化的数据。
21、抽象方法只有方法名没有实现，是空方法，隐式为虚方法必须被覆盖。抽象类是包含抽象方法的类，抽象类不能创建对象，只能被继承，而且其中的抽象方法要么被实现，要么也是抽象     方法。
22、overload：重载是指一个类中，同名方法（普通方法、构造方法、静态方法、运算符、索引）不同参数签名。
    override：覆盖是指子类/派生类对父类/基类中虚函数或抽象函数的“覆盖”。
   方法的覆盖和重载的区别是：
   覆盖肯定是方法名、方法的返回值、方法的形参要相等。
   而重载方法的名同样一定相等，但方法的形参类型、个数肯定不相等！
23、public class Animal
  {
      public int nicai;
      public virtual void Eat()
    {
        Console.WriteLine("Eat something");
    }
  }
   public class Cat : Animal
  {
    public string kao;
    public override void Eat()
    {
        Console.WriteLine("Eat mouse !");
    }
   }
   在创建对象时可以Animal a=new Cat();Cat c=new Cat(); Animal b=c；Cat c1=new Cat();但是通过第一、三种方法创建的对象只能访问Animal中的量，也就是只能访问nicai，和Eat（    ），不能访问Cat中的东西。但是通过第一、三种方法创建的a和b对象其类型都是Cat型的。

＾陪妳ソ看日落

转载的................................

站长苏飞

有效果没有

＾陪妳ソ看日落

这段代码是关于  textBox的  没有效果