复习.Net基础

理解全局变量和局部变量的区别：①作用域②存储方式③生命周期④使用方式

第一、全局变量的作用域为整个程序，局部变量为当前函数或循环等；

第二、全局变量存储在全局数据区中，局部变量存储在栈区；

第三、全局变量和主程序的生命周期一样，随程序的销毁而销毁，局部变量在函数或循环内部，随函数或循环的退出而销毁；

第四、全局变量在声明之后程序的各个部分都可以使用，但局部变量只能在局部使用，函数内部会优先使用局部变量再使用全局变量。

 

常见问题：对于int,double,float等数组，没有赋值的元素初始化为0；对于string等类型初始化为null。

 

递归：①阶乘②斐波那契数列

递归实现：

 

//阶乘：5！=5*4*3*2*1

static int JieCheng(int n)
{
    if(n<0)
    {
        Console.WriteLine("输入不能为负数,必须为正整数");
    }
    else if(n == 1)
    {
        return 1;
    }
    else
    {
        return n*JieCheng(n-1);
    }
}

 

// 斐波那契数列

static int Fb(int n)
{
    if (n<0)
    {
        Console.WriteLine("输入不能为负数！")；
    }
    if(n==0 || n==1)
    {
        return 1;
    }
    else
    {
        return Fb(n-1)+Fb(n-2);
    }

非递归实现：

// 阶乘

static int JieCheng(int n)
{
    if(n<0)
    {
        Console.WriteLine("输入不能为负数");
    }
    else
    {
        int result = 1;
        for(int i=1;i<=n;i++)
        {
            result = result*i;
        }
        return result;
    }
}

static int Fb(int n)
{
    if(n<0)
    {
        Console.WriteLine("输入不能为负数");
    }
    if(n==1 || n==0)
    {
        return 1;
    }
    else
    {
        int[] nums = new int[n];
        nums[0]=1;
        nums[1]=1;
        for(int i=2;i<n;i++)
        {
            nums[i]=nums[i-1]+nums[i-2];
        }
        return nums[n-1];
    }
}

“洗牌算法”：

int[] nums = new int[100];
for(int i=0;i<nums.Length;i++)
{
    nums[i]=i+1;
}
Random rand = new Random();
for(int i=0;i<nums.Length;i++)
{
    int index1 = rand.Next(0,nums.Length);
    int index2 = rand.Next(0,nums.Length);

    int temp = nums[index1];
    nums[index1] = nums[index2];
    nums[index2] = temp;
}

 

关于Null 与 值类型：值类型（int float long boll 结构体 枚举）不能为null，因为其赋值过程是拷贝传递。

 

最简单、最实用的“饿汉式”单例模式：

class SingleInstance
{
  private static readonly SingleInstance singleinstance = new SingleInstance();
  private SingleInstance()
   {}
  public static SingleInstance GetInstance()
  {
    return singleinstance;
  }
}

关于static静态构造函数：

第一、静态构造函数无访问修饰符；

第二、静态构造函数不能被继承；

第三、一个类中只能有一个静态构造函数，且只运行一次。

 

对“多态”的理解：父类变量可以指向子类对象，父类变量可以执行那些方法取决于父类有那些方法，具体执行则由子类去实现。

自定义异常类：

public class MyException:Exception
{
  public MyException(string msg):base(msg)
   {
    }
}

 

流（Stream）：所谓的“流”就是读一点操作一点。

写文件：

using(Stream s = new FileStream(@"F:\1.txt",FileMode.Append))
{
  byte[] bytes = Encoding.UTF8.GetBytes("Hello World!");
  s.Write(bytes,0,bytes.Length);
}

读文件：

using(FileStream fs = new FileStream(@"F:\1.txt",FileMode.Open))
{
  byte bytes = new byte[4];
  int len;
  while(len = fs.Read(bytes,0,bytes.Length)>0)
  {
      string s = Encoding.UTF8.GetString(bytes,0,len);
      Console.WriteLine(s);
   }
}

考虑到中文字符的编码问题，应使用StreamReader、StreamWriter。

写数据：

static void MyStreamWriter(string path,string content)
{
  using(Stream inStream = new FileStream(path,FileMode.Create))
  using(StreamWriter writer = new StreamWriter(inStream))
  {
      writer.WriteLine(content);
   }
}

读数据：

static string MyStreamReader(string path)
{
  StringBuilder sb = StringBuilder();
   using(Stream outStream = new FileStream(path,FileMode.Open))
   using(StreamReader reader = new StreamReader(outStream,Encoding.Default)) 
   {
      while(reader.Peek()>-1)
      {
         sb.AppendLine(reader.ReadLine());//不能使用while(reader.ReadLine()!=null)不然会出现异常
      }
   }
    return sb.ToString();
}    

泛型容器

List<int> list = new List<int>();
list.Add(1);
list.Add(2);
list.AddRange(new int[]{1,2,3});
list.AddRange(list);

//List泛型集合可以转换为数组
int[] nums = list.ToArray();
List<string> listStr = new List<string>;
string[] strs = listStr.ToArray();

泛型字典

Dictionary<string,string> dict = new Dictionary<string,string>;
dict.Add("zs","张三");
dict.Add("ls","李四");
dict.Add("ww",王五");
dict["ls"] = "小赵";
string s = dict["ww"];
dict.ContainKey("zs");

关于foreach，只有实现了IEnumrable接口都可使用foreach遍历。