C#类

01:在C＃中，string str = null 与 string str = “” 请尽量使用文字或图
象说明其中的区别。

string    str    =    null   是不给他分配存空间,而string    str    =    “”给它分配长度为空字符窜的内存空间.       

02:简述类和结构的相同点和不同点。并用代码举例。

不同点：

(1)类型不同：结构是一种值类型，而类是引用类型。值类型用于存储数据的值，引用类型用于存储对实际数据的引用。那么结构体就是当成值来使用的，类则通过引用来对实际数据操作。

(2)存储不同：结构使用栈存储，而类使用堆存储。栈的空间相对较小.但是存储在栈中的数据访问效率相对较高.堆的空间相对较大.但是存储在堆中的数据的访问效率相对较低。

(3)关键字不同：在类中可以使用但是在结构中限制使用的关键字有：abstract、sealed、protected；StaTIc关键字可以用在类名前面用来声明静态类，但是不能用在struct前面，不存在静态结构。

(4)作用不同：类是反映现实事物的一种抽象，而结构体的作用只是一种包含了具体不同类别数据的一种包装，结构体不具备类的继承多态特性。

(5)初始化不同：类可以在声明的时候初始化，结构不能在申明的时候初始化（不能在结构中初始化字段），否则报错。

相同点：

类和结构都可以new
 

//结构
struct Test
{
    int id=1001；
}
 
//类
public class Test
{
    
}

03:什么是拆箱和装箱?举例说明

拆箱是把“引用”类型转换成“值”类型；装箱是把“值”类型转换成“引用类型”；

int id =1001;
//装箱
object i=id;
//拆箱
int j=（int）i;

04:编程实现一个冒泡排序

int[] num = new int[4] { 1, 2, 3, 4 };
for (int i = 0; i < num.Length - 1; i++)
     {
        for (int j = i+1; j < num.Length; j++)
            {
              int c;
              if (num[i] < num[j])
              {
                c = num[i];
                num[i] = num[j];
                num[j] = c;
              }
            }
     }
 for (int i = 0;i<num.Length;i++)
 {
    Console.Write(num[i]);
 }
 Console.ReadLine();

05:编程实现一个递归方法

double demo(int n)　
{　
　　 if(n == 0 || n == 1){　
　　　　 return 1;　
　　 }else{　
　　　　 return n*demo(n-1);　
　　 }　
}　

 

06:说说目前学的集合有哪些?,每一种集合的特点以及使用场景

ArrayList,List,Hashtable,Dictionary<key,value>

特点：
ArrayList和List获取，删除元素是通过下标或对象名获取;
Hashtable,和Dictionary<key,value>获取，删除元素是通过key获取。
List和Dictionary<key,value>访问元素无须转换。

场景：

1）ArrayList:应用程序对数据有较多的随机访问

2）List:

(1) 对于需要快速插入，删除元素，应该使用LinkedList。
(2) 对于需要快速随机访问元素，应该使用ArrayList。

3）Hashtable:

（1）某些数据会被高频率查询
（2）数据量大
（3）查询字段包含字符串类型
（4）数据类型不唯一

4）Dictionary<key,value>:

创建带有索引的集合

07:变量被标记为 “const” 和readonly” 有何不同?

(1) readonly和const都是用来标示常量的。
(2) 初始化赋值不同。

const修饰的常量必须在声明的同时赋值。

public class Class1
{
    public const int MaxValue = 10;       //正确声明
    public const MInValue;                   //错误：常量字段要求提供一个值
    public Class1()
    {
        MinValue = 10;
    }
}

readonly字段可以在初始化（声明或构造函数）的过程中赋值。因此，根据所使用的构造函数，readonly字段可能具有不同的值。

public class Class1
{
    public readonly int c = 10;           //正确声明
    public readonly int z;
    public Class1()
    {
        z = 24;//正确
    }
    protected void Load()
    {
        z = 24;//错误：无法对只读的字段赋值（构造函数或变量初始值指定项中除外）
    }
}

readonly是实例成员，所以不同的实例可以有不同的常量值，这是readonly更灵活。

public readonly Color Red = new Color(255, 0, 0);
public readonly Color Green = new Color(0, 255, 0);
public readonly Color Blue = new Color(0, 0, 255);

 

(3) const字段是编译时常数，而readonly字段可用于运行时常数。

(4) const默认就是静态的，而readonly如果设置成静态的就必须显示声明。

(5) const修饰的值的类型也有限制，它只能为下列类型之一（或能够转换为下列类型）：sbyte、byte、short、ushort、int、uint、long、ulong、char、float、double、decimal、bool、string、enum类型或引用类型。注意能够声明为const的引用类型只能为string或值为null的其他引用类型。readonly可以是任何类型。

(6) object、Array（数组）和struct（结构）不能被声明为const常量。

08:“out” 和 “ref” 参数有何不同?用代码举例

1、ref 和 out 都是传递地址，都会改变具体的值，ref 是有进有出，Out 是 只出不进，

 2、ref可以把参数的数值传递进函数，

 3、out是把参数清空，就是说你无法把一个数值从out传递进去，out进去后，参数的数值为空（参数不能拿到具体数值），所以必须初始化一次！

static void Main(string[] args)
        {
            string str = "初始化赋值";
            MethodOut(out  str);
            Console.ReadKey();
        }

        /// <summary>
        /// 只出不进  原来out参数在进入方法的时候，C#会自动清空它的一切引用和指向，所以在上面的out例子中，必需先要为str参数赋值
        /// </summary>
        /// <param name="str"></param>
        public static void MethodOut(out string str)
        {

            str = "Hello World!  ---out";
            Console.WriteLine(str);
        }

 //ref参数的参数必须最先初始化，
        static void Main(string[] args)
        {
            string str = "初始化赋值";
            MethodRef(ref str);

            Console.ReadKey();
        }

        /// <summary>
        /// 是有进有出  ref参数在使用前必需初始化，而out不需要。
        /// </summary>
        /// <param name="i"></param>
        public static void MethodRef(ref string str)
        {
            str = "Hello World! --Ref";
            Console.WriteLine(str);
        }

09:“StringBuilder” 和 “String” 有何不同?

String 对象是不可改变的。每次使用 System.String 类中的方法之一时，都要在内存中创建一个新的字符串对象，这就需要为该新对象分配新的空间。 

StringBuilder 对象是动态对象，允许扩充它所封装的字符串中字符的数量，但是您可以为它可容纳的最大字符数指定一个值，当修改 StringBuilder 时，在达到容量之前，它不会为其自己重新分配空间。当达到容量时，将自动分配新的空间且容量翻倍。可以使用重载的构造函数之一来指定 StringBuilder 类的容量。

当修改字符串信息时，此时不许创建对象，可以使用stringBuilder对象。