【Unity学习笔记-----C#学习】

已经有了c++和java的基础，就做一个小记录不同的地方这里。

1.数据类型，变量，常量，数组

1. sbyte类型就是8位有符号整数类型，byte是8位无符号整数类型。
2. 值类型存储在栈中，引用类型引用的数据存储在堆中。
3. object是最终的父类型，string类型表示0或更多Unicode字符组成的序列。
4. 变量命名时，可以定义string @char; 通过前缀@可以命名关键字的变量。
5. object objNum = (object)intNum; // 将值类型转换为引用类型也可以使用Convert.Toxxxx的强制类型转换方法。
6. 引用类型转换为值类型：

            object objA = 15;
            int intGetObjA = (int)objA; //方法1
            int intGetObjA1 = Convert.ToInt32(objA); //方法2， 强制类型转换

7. 装箱：把值类型包装成引用类型的处理过程；拆箱：把值类型转换成引用类型。注意：装箱可以隐性转换，但拆箱必须强制类型转换
8. 定义变量：

            long l = 32L;
            uint unitA = 10u;
            int intA = 0x10;

9. 单问号作为基本数据类型声明变量的标识符int? i = null;
10. var mm = "hello; 类似于C++的auto
11. 整型数组定义int[6] arrayHere;,也可以定义为：int[] intScore={1,2,3,4,5};数据存储在堆当中。

数组扩容
数组缩容也是同样的道理。

int[] arrS = new int[4] {1,2,3,4};
int[] tmp = new int[arrS.Length + 1];
for (int i=0;i<arrS.Length;i++){
tmp[i] = arrS[i];
}
arrS = tmp;

2.ArrayList

1. 首先需要using System.Collections引用集合的命名空间

            ArrayList arrayList = new ArrayList();
            arrayList.Add(1);
            arrayList.Add(20);
            arrayList.Add(3);
            arrayList.Add(10);
            Console.WriteLine("数组的容量是：" + arrayList.Capacity); //输出数组可包含的数量
            Console.WriteLine("数组的实际大小" + arrayList.Count);
            // 输出ArrayList元素时，有一个装箱的操作，每个放到ArrayList里的数组的元素都会转换为object类型存放
            foreach(object o in arrayList)
            {
                Console.WriteLine(o);
            }
            arrayList.Sort(); // 排序操作
            arrayList.Insert(0, 20); // 插入操作
            arrayList.Remove(1); // 删除值为1的元素
            arrayList.RemoveAt(0); // 删除索引为0的元素

3.字符串

            string strA = "ac";
            string strB = "bc";
            int intResult = strA.CompareTo(strB); // 按照字典排序规则，判断两个字符串相对大小 
            Console.WriteLine(intResult);

            // 查找子字符串的位置
            string strHello = "hello";
            int index = strHello.IndexOf('e'); // 也可以查找字串'llo' 类似的还有StartWith、EndWith方法

            string strFormat = string.Format("位置1:{0},位置2:{1}", 1, 2); // 格式化字符串
            Console.WriteLine(strFormat);

            //字符串的替换方法
            strHello = strHello.Replace('e', 'a');
            // 字符串转为大写或小写
            strHello.ToLower();
            strHello.ToUpper();

            // 连接字符串
            string str1 = "hello";
            string str2 = "world";
            string strNew = string.Concat(str1, str2);
            string strNew2 = string.Join(str1, str2,new char[] { '-' });
            string strN = str1 + str2; // 字符串拼接

            // 分裂字符串
            string strTest = "hell world my name is C#";
            string strTest2 = "张三,-李四=，王五";
            string[] strArrays = strTest.Split(' ');
            string[] strArrays2 = strTest.Split(new char[] { ',', '-', '=' }) ;

            //清空字符串里的空格Trim方法，清空字符串里全部空格
            string strT = "       aaa   ";
            strT.Trim(); //strT变成了"aaa"
            strT.TrimStart(); // strT变成了"aaa     ",同理还有TrimEnd()
            string.IsNullOrEmpty(strT); // 判断字符串是否为空


            // 日期操作
            DateTime dtime = DateTime.Now;
            string strTime = dtime.ToString("yyyy年MM月dd日 HH时mm分ss秒");

4.Class类

首先定义一个Student类

 public class Student
    {
        public string name;
        public int stuno;
        public int age;
        // 无参构造函数
        public Student()
        {

        }
        // 有参构造函数
        public Student(string _name,int _stuno,int _age)
        {
            this.name = _name;
            this.stuno = _stuno;
            this.age = _age;
        }

        // 方法
        public string Say()
        {
            string strResult = "这是说话方法的返回值";
            return strResult;
        }

        public string DoWork(string jobname)
        {
            string str = "我做的工作是:" + jobname;
            return str;
        }

        public void Do()
        {
            Console.WriteLine("这是student的do方法");
        }
    }

在main函数当中

            Student stu = new Student();
            Student stu2 = new Student("张三", 10010, 18);
            stu2.Say();
            stu2.Do();
            stu2.DoWork("eat");

方法中的参数的四种类型

1. 值参数，不含任何修饰符
2. 引用型参数，以ref修饰符声明
3. 输出参数，以out修饰符声明
4. 数组型参数，以params修饰符声明
5. ref与out的区别是，前者在使用前必须赋值，后者修饰的参数可以赋值也可以不赋值

方法定义：

    class Person
    {
        public void ChangeAge( int age) // 值传递
        {
            age = age + 10;
        }
        public void ChangeAge2 (ref int age) // 引用传递
        {
            age += 10;
        }

        public void ChangeWeight(out double weight)
        {
            weight = 120;
        }
        public void ShowInfo(params int[] showages) // params表示是一个可变数组
        {
            foreach(int i in showages)
            {
                Console.WriteLine(i);
            }
        }
    }

方法引用：

            int age = 10;
            double weight;
            Person p = new Person();
            p.ChangeAge(age);
            p.ChangeAge2(ref age);
            p.ChangeWeight(out weight);
            int[] a = { 1, 2, 3, 4, 5 };
            p.ShowInfo(a);

== 静态字段和静态方法==

实例化的方法，可以访问静态字段，静态方法，也可以访问静态字段，静态类中不允许出现实例化的字段或方法

public static class OperatorMethod
{


}


  public static string Country;
        public static void ChangeCountry()
        {
            Person.Country = "美国";
        }
Person.ChangeCountry();

方法重载
就不说了

internal访问
internal表示能够在同一命名空间中访问.