2010第一篇学习笔记，深入.net平台关于基础的部分知识

以下代码涉及类的封装，属性和方法的使用和区别，值类型和引用类型的区别和使用，枚举，常量，构造有参函数等，添加和使用ArrayList，使用循环阅历ArrayList元素等。

 

  public class Student

    {

 

        public int age;

        private string name;//字段，也叫属性

 

        public string idNumber;

 

 

        public void SayHi()//类的成员，介绍自己的方法

        {

            string message;

            message = string.Format("大家好，我是{0}同学。", name);

 

 

 

        }

 

    }

 

    class Program

    {

        static void Main(string[] arge)

        {

            Student mystudent = new Student();

            mystudent.age = 16;

            mystudent.idNumber = "123";

            mystudent.name = "wu";

           

        }

}

 

 

编译无法通过，因为private是受保护的级别，除非改为public。但对程序的保护不够。应该按照如下例子编写代码。

 

public class Student

    {

 

        private int age;

 

        public int Age

        {

            get { return age; }

            set

            {

                if (value < 0 && value > 100)

                {

                    value = age;

                }

                else

                {

                    age = 18;

                }

            }

        }

        //private string name;//字段，也叫属性

 

        //public string Name

        //{

        //    get { return name; }

        //    set { name = value; }

        //}

 

        //private string idNumber;

 

        //public string IdNumber

        //{

        //    get { return idNumber; }

        //    set { idNumber = value; }

        //}

 

 

        //public void SayHi()//类的成员，介绍自己的方法

        //{

        //    string message;

        //    message = string.Format("大家好，我是{0}同学。", name);

 

        //}

 

    }

 

    class Program

    {

        static void Main(string[] arge)

        {

            Student mystudent = new Student();

            mystudent.Age = -20;

            Console.WriteLine("年龄为:{0}",mystudent.Age.ToString());

            mystudent.Age = 40;

            Console.WriteLine("年龄为:{0}", mystudent.Age.ToString());

 

           

        }

    }

 

 

封装：封装字段是C#中面向对象的重要内容。是面向对象的三大特性之一。它用于内部实现，而对外只暴露其基本操作。而不会影响其他类的内部实现，类的封装为我们带来的好处是避免非法数据赋值，保证数据的完整性和避免类内部数据修改而影响了我们整个程序。

 

 

关于ref及ouT参数的传递

 

ref参数侧重于修改，out参数侧重于输出，而且out参数是必须赋值才能正常运行。

 

以下为一个简单的加法运算。类add为编写数据相加类。

    class Program

    {

        static void Main(string[] arge)

        {

           

            add a = new add();

            int pp1, pp2;//设定两个要传入的参数

            Console.WriteLine("请输入两个数字：");

            pp1 = int.Parse(Console.ReadLine());

            pp2 = int.Parse(Console.ReadLine());

            int sum = a.sum(pp1,pp2);

            Console.WriteLine("结果是{0}",sum.ToString());

           

        }

    }

class add   //这是一个加法的方法，参数p1和p2定义了两个数据相加的方法

{

    public int  sum(int p1,int p2)

{

    return p1 + p2;

   

}

 

 

现在有一个新问题，如果我们要的或许不止是单纯两个整形类型的数据相加，我们还需要两个double 或string类型的数据相加，那怎么办？是不是需要重新编写另外几个类似add类呢？我们调动的时候，还需要判断是哪种类型的数据相加，然后根据数据类型调用方法，很麻烦。所以，我们用到了重载。

 

重载粗略带过：例如在add中加入另外几个方法，类似：

public int sum(int p1,int p2)

{

Return p1+p2;

}

 

public int sum(string p1,string p2)

{

Return p1+p2;

}

 

注意：重载的方法名字必须相同，参数名称也需要相同

 

利用构造函数去创建对象

 

在创建类的时候，有一个特殊的方法是隐藏，即使不写，也存在。它就是最前面的构造函数。默认是为无参数的构造函数。这就是我们可以直接在别的类实例化，调动本类一样。例如前面的add a =new add();  ，构造函数的方法是程序执行中最先访问的方法。

 

public Student(int age, string name)

        {

            this.Age = age;

            this.Name = name;

        }

 

 

 

常量：如果一个程序中有某个值设定后就不能再修改，可采用常量在前面申明，这样有助于程序的维护，例如性别，汇率等……

关键字为：const

常出现的错误：给常量赋值会出现错误，常量无法赋值。

 

假设为stunent类增加性别字段，将其封装起来。

        const string gerder_m = "男";

        const string gerder_f = "女";

        private string gerder;

 

        public string Gerder

        {

            get { return gerder; }

            set { gerder = value; }

        }

 

然后在另外的类中实例化后为gerder赋值：

例如：mystudent.gerder = "accp";

 

编译器不会报错，因为常量属性本身就为string 类型。所以符合编译器规范。因此，我们无法有效准确的规范常量的范围。所以，我们需要用到下面提到的枚举。

 

枚举：可以为需要赋值的常量限定范围

关键字： enum

 

例如：public enum Genders //定义一个枚举

        {

            m,f

        }

        private Genders gerder;

 

        public Genders Gerder

        {

            get { return gerder; }

            set { gerder = value; }

        }

 

 

//mystudent.Gerder = "accp"; //无法通过编译，因为我已经用枚举限定了它的赋值范围。它只能为m和f赋值。

          mystudent.Gerder = Genders.m;

 

 

为枚举成员赋值：

mystudent.Gerder = Genders.m;

                int gerNum = (int)mystudent.Gerder;

                switch (gerNum)

                {

                    case 0:

                        Console.WriteLine("您输入的性别为男");

                        break;

                    case 1 :

                        Console.WriteLine("您输入的性别为女");

                        break;

                           

                }

 

 

总结枚举的好处：便于代码的维护，有助于给变量赋值的合法性。还有就是便于输入，我们每次只需要输入枚举名就能显示所有的值，提高开发效率。

 

结构：

    struct stu //定义一个结构，注意:定义结构时无法赋值

    {

        public string name;

        public int age;

 

}

 

总结结构的好处：适用于逻辑性不强的小程序，如果涉及复杂的计算，就最好使用类。

 

值类型和引用类型：

值类型本身就储存了变量本身的值，变量本身就包含了其实例化的数据，而引用类型保存的不是其实例化数据，而只是其内存引用而已。一个值类型的数据永远不会影响其他值类型数据的变量，而两个引用类型可能指向同一地址。从而使其他数据变量发生改变。

值类型的处理效率高于引用类型。在处理小对象和小数据的时候，可以使用值类型。

 

 

1 class和struct的语法基本相同，从声明到使用，都很相似。但是struct的约束要比class多，理论上，struct能做到的class都能做到，但class能做到的stuct却不一定做的到，也就是说struct都能被class所代替。

2 数据类型不一样，struct是值类型，class是引用类型，因此它们具有所有值类型和引用类型之间的差异。由于堆栈的执行效率要比堆的执行效率高，但是堆栈资源却很有限，不适合处理逻辑复杂的大对象，因此struct常用来处理作为基类型对待的小对象，而class来处理某个商业逻辑。

3 从继承性来看，struct既不能继承也不能被继承，但是可以实现接口，而Class就可以完全扩展了。内部结构有区别，struct只能添加带参的构造函数，不能使用abstract和protected等修饰符，不能初始化实例字段。

 

 

stu stu1 = new stu();//用结构实现

                stu stu2 = new stu();

                stu1.age = 18;

                stu2 = stu1;

                stu2.age = 20;

             

 

                Console.WriteLine("stu={0},stu2={1}",stu1.age,stu2.age);

 

 

Student stu1=new Student ();     //  用类实现

                Student stu2=new Student ();

                stu1.Age=18;

                stu2=stu1;

                stu2.age=20;

                Console.WriteLine("stu={0},stu2={1}",stu1.age,stu2.age);

 

 

 

索引器

//暂时忽略

 

ArrayList对象集合

 

ArrayList students = new ArrayList();

            Student a = new Student(20,"wu");

            Student b = new Student(20, "wu");

            Student c = new Student(20, "wu");

            students.Add(a);

            students.Add(b);

            students.Add(c);

 

ArrayList类似数组，但和数组的不同在于很灵活，能指定容量，而数组时固定的。ArrayList可以随时扩展和收缩。

 

添加元素ArrayList：

ArrayList students = new ArrayList();

            Student a = new Student(20, "wu");

            Student b = new Student(20, "wu");

            Student c = new Student(20, "wu");

            students.Add(a);

            students.Add(b);

            students.Add(c);

            Console.WriteLine("共包含{0}个学员",students.Count.ToString());

 

访问元素：

 

、    Student stu=(Student)students[0];

   stu.SayHi();

 

使用循环阅历ArrayList全部元素，foreach是通过对象去访问元素。

 

            foreach (object o in students)

              {

                Student s = (Student)o;

                Console.WriteLine(s.Name);

            }

 

删除ArrayList元素为有三个方法

1，   指定元素删除

2，  指定索引删除

3，  全部删除 student.clear();