c#方法的重载和递归 特殊的引用string,stringbuilder

一、不可变类型string

string 是特殊的引用类型
值类型 开辟的是不是一个空间，相互不影响，引用类型开辟的是同一个空间，相互影响
字符串做修改操作的时候，都会开辟一个新的空间。引用了类型比较的是 地址。值类型比较的是 数值。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace lesson05
{
   class People
   {
     public  string name;
   }

   class Program
   {
       static void Main(string[] args)
       {
           //特殊的引用类型string;
           //声明p时 栈中的p 保存的是 p 在堆去开辟的地址。
           //声明p1 时，栈中的p 保存的是 p1 在栈中 开辟的地址。
           //在比较p和p1时 比较的 也是他们两个的地址，由于p和p1在堆区的地址不同 所以他们两个不相等。
           People _p = new People();
           _p.name = "Hello";
           People _p1 = new People();
           _p1.name = "Hello";
           if (_p == _p1) //输出结果为不相等
           {
               Console.WriteLine("相等");
           }
           else
           {
               Console.WriteLine("不相等");
           }

           //这样一来 p 把它的地址赋给 p1，p 和 p1 中保存的是堆区中的同一个地址。
           //在比较地址的时候，他们的地址就相等了。
            _p1 = _p;
           if (_p ==_p1)//输出结果为相等
           {
               Console.WriteLine("相等");
           }
           else
           {
               Console.WriteLine("不相等");
           }
           //*定义两个引用类型的变量，把其中一个的值赋给另一个，改变其中一个的值，两个变量的值	都会改变
           _p.name = "Wrold";
           Console.WriteLine(_p1.name);
       }
   }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace lesson02
{
   class Program
   {
       static void Main(string[] args)
       {

           string _myClass = "Unity一班"; //注意string是引用类型
           string _yourClass = _myClass;//这时候myClass跟yourClass 代表同一个空间
           _yourClass = "Unity二班";//这时候yourClass新开了一个空间，跟myClass不是一个空间了！
           Console.WriteLine(_myClass);//Unity一班 
           Console.WriteLine(_yourClass);//Unity二班
           string s = "123";
           string s1 = "123";
           if (s == s1 )
           {
               Console.WriteLine("相等");
           }
           else
           {
               Console.WriteLine("不相等");
           }
       }
   }
}

引用类型比较的都是地址，而string类型比较特殊，比较的是值，而不是地址，当定义一个string类型的变量时 会在堆区开辟一块空间：string s = “123”;栈区的 s 保存的是堆区空间的地址，而堆区的地址保存的信息来自常量区，也就是说 栈区的s和堆区 s的空间保存的全是地址 常量区是值
当我们定义s1 = s 时 并不是把 s 的地址 赋给了 s1，而是在堆区重新开辟了一块新的空间，然后把s区的信息复制到新空间里，s1 保存的地址就是重新开辟的空间的地址，
当s 被重新赋值时，会在堆区在开辟一个新的空间，然后把这个空间的地址赋给s， 这时旧的空间地址就会被删除

字符串的访问

字符串本身是一个数组，但是 只能读不能被改写

//string str = "test";
//char x = str[2]; // x = 's';

Ordinal：比较字节
CurrentCulture, 按照当前地域的规则进行比较
CurrentCultureIgnoreCase按照当前地域的规则进行比较，并且不区分大小写
InvariantCulture, 按照国际上通用的规则进行比较
InvariantCultureIgnoreCase, 按照国际上通用的规则进行比较，并且不区分大小写
Ordinal, 不区分字符串里写的什么，比较bit是否相同
OrdinalIgnoreCas 不区分字符串里写的什么，比较bit是否相同，，并且不区分大小写
在重载方法中以 Type或 options 的大多是枚举类型。
重载：同一个方法可以有不同的参数。

Contains() — 输入一个字符串类型的参数，返回一个布尔（true/false）。
IndexOf(String) — 输入一个字符或字符串类型的值，返回它的位置。（第一个遇到的相同字符串的首字母的下标。）
int starIdex：输入一个int类型的值 x。从下标为 x 的元素向后的所有元素中，找到相同的元素，并返回它的位置。（要跳过几个元素，就输入几）
Remove(Int32, Int32) — 从第几个值开始删，删除几个值。返回一个string类型的值。删除之后返回一个新的字符串，原来的字符串没有改变。例：填1 下标值 大于等于 1的数往后全删掉， 在输入一个数表示删几个。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace lesson05
{
    class Program
    {
        static void Main(string[] args)
        {
            string _name = "HelloWorld";
            int w = _name.IndexOf("W",_name.Length);
            Console.WriteLine(w);
            int n = _name.IndexOf('r',1,9);
            
            Console.WriteLine(n);
            string q = _name.Remove(_name.Length - 2,1);
            Console.WriteLine(q);
            Console.ReadKey();
        }
    }
}

Replace(String, String) — 将前面一个字符或字符串 替换成后面的字符或字符串新旧字符串字符数量可以不一样。
Split(Char[]) — 输入一个字符或字符类型数组（必须是字符，字符串不行），在输入一个数，会把这个数之前的元素按照 给定的字符或字符类型的数组分割开。
Trim() — 默认清除 字符串前后的空白。若在参数中给出字符，也可以清除这个字符
Substring(Int32, Int32) — 从第几个开始截，截几个。
返回值类型：Contains是bool类型，IndexOf 是 int类型，Split 是 字符串数组类型 ，
其他的都是字符串类型。

作为了解的string方法：
LastIndexOf(String) — 从后往前开始索引，返回字符串中最后一个相同字符的位置。
PadLeft() — 输入一个表示字串长度的int值，返回一个新字符串，该字符串通过在原字符串左侧填充
空格来达到指定 的总长度，从而实现右对齐。
ToUpper() — 返回此字符串转换为大写形式的返回值。
ToLover — 返回此字符串转换为小写形式的返回值。

• 一般来说以 Type 和 options 结尾的为枚举类型
• string 是不可变字符串，他的所有方法返回值都是生成一个新的返回值，若想得到这个返回值需要
  重新定义一个变量来接收他，不能直接修改字符串。
• 查看string方法中的枚举类型：选中类型名，按F12建。即可跳转到编译器。

小于等于 或大于等于
——————————————————————————
默认值：值类型 默认初始值是0；boll类型 默认初始值是false；string类型默认初始值是null；
枚举类型 默认值是0（也就是枚举成员中的第一个）。

String对象是不可改变的。每次使用 System.String 类中的方法之一时，都要在内存中创建一个新的字符串对象，这就需要为该新对象分配新的空间。如果需要多次修改，String得开销是非常大滴！于是有了System.Text.StringBuilder 类。

二、可变字符串StringBuilder：

StringBuilder对象是动态对象，长度是可变的，如果需要多次修改字符串，使用StringBuilder可以大大提升效率。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace lesson05
{
    class Program
    {
        static void Main(string[] args)
        {
            //StringBuilder是可以修改的
            StringBuilder _s = new StringBuilder("abcdefg");
            _s[0] = '1';
           
            _s.Append(true);//放一个字符重复多少次
            _s.Append("AAAAAA");//拼接完成之后给一个换行符
            _s.AppendLine("wwwww");
            _s.AppendLine("aaa");
            Console.WriteLine(_s);
        }
    }
}

三、方法的重载

实现方法的重载：
首先：方法名必须相同，
其次，参数必须不同，至少是以下两种情况之一：
参数表中对应的参数类型不同；
参数表中参数个数不同；重载：方法名相同，参数不同。
参数不同分两种：1.参数类型不同 2.参数个数不同
方法的重载和返回值没有关系，返回值不同不构成重载，返回值类型不同 参数相同的重名方法， 不能构成方法的重载：

class OutPut 
 { 
 public void PrintF(int data) 
 { 
 Console.WriteLine(data); 
 } 
 public void PrintF(double data)//参数类型不同
 { 
 Console.WriteLine(data); 
 } 
 public void PrintF(int data， int p)//参数个数不同
 { 
 Console.WriteLine(data*p); 
 } 
 }

四、递归

递归： 递：将数据传过去。 归：执行完再将数据返回来
方法调用：在一个方法里调用另一个方法是一个正常调用，递归是要调用所在方法本身。核心：控制某个时间点不再调用自身 不开新栈了，就会把当前方法执行完返回回去。也就是说，当参数达到某个条件时不再调用自己了。
例：求和 从一加到五

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace lesson05
{
   class Sum
   {
       public int SumAdd(int sum)
       {
           if (sum == 1)
           {
               return 1;
           }
           else
           {
               return sum + SumAdd(sum - 1);
           }
       }
         //弊端：递归层次太深容易栈溢出递。无论是对与错都容易出

       public void Fucion()
       {
           Console.WriteLine("Fucion");
           Fucion();
       }
   }
  

   class Program
   {
       static void Main(string[] args)
       {
           Sum _sum = new Sum();
           int n = _sum.SumAdd(5);
           Console.WriteLine(n);//输出的值为15
           _sum.Fucion();
       }
   }
}

五、异常捕获

异常 例如：1.数组越界 2.除数为零
语法：
try {
觉得有异常的代码；
} catch （Exception e）{// 有异常才会执行catch，没异常不执行。
Console.WruteLine(e.GetType ()); // 打印异常
} finally {
Console.WriteLine(" 任意打印 ")； // 不管有没有报异常 都会执行。
}