类中的特性、函数实现

类中的特性与函数实现

关于特性

特性定义方法

1. 修饰符 数据类型 变量名；

利用属性来访问特性

1. 为什么需要属性？通常我们把特性设置为私有变量，一般可以通过函数来进行修改和读取，需要一个函数来读取，一个函数来写。但这样太麻烦了。
   因此有了属性，属性本质上也是函数，但是可以用 对象.属性名 进行访问。
2. 语法：

public 类型 属性名
			{
			get{return ..}
           set{..=value}
           }

5. 实例：年龄约束在0-150，这个范围外都认为错误

 class Test
    {
        private int age;
        public int Age
        {
            get
            { return age; }
            set
            {
                if (value > 0 || value < 150)
                    age = value;
                else
                    Console.WriteLine("Age的范围是0-150");
            }
        }
    }
    class 使用属性
    {
        static void Main(string[] args)
        {
            Test test = new Test();
            test.Age = -2;
            test.Age = 3;
            Console.WriteLine(test.Age);
        } 
    }

关于函数属性

构造函数与析构函数

1. 函数	调用时间	返回类型
构造函数	创建对象时调用	无返回类型
析构函数	被垃圾回收机制回收时调用	无返回类型

一般的对象在程序结束时才释放对象

2. 语法
   （1）public 类名（参数）
   （2）public ~类名（参数）

函数重载

要求函数名相同，参数的类型、数目、顺序不同。
注意仅返回类型不同，不叫重载，属于一种错误。

函数参数类型

类型	效果	关键字	调用方法
值类型	不会改变原本变量内容	默认就是这种类型，不需要关键字 类型 变量名	函数名（参数）
引用类型	会改变原本变量的内容	ref 类型 变量名	函数名（ref 变量名）
输出类型	参数可以没有初值，用来改变原本变量的内容	out 类型变量名	函数名（out 变量名）

2. 实例

    class Canshu
    {
        public void ZhiChuanDi(int a ,int b)//不会修改
        {
            a += 1;
            b += 1;
        }
        public void YinYongChuanDi(ref int a,ref int b)//会修改
        {
            a += 1;
            b += 1;
        }
        public void ShuChuCanShu(out int c , out int  d)//会赋值
        {
            c = 10;
            d = 20; 

        }
    }
    class 函数参数类型
    {
        static void Main1(string[] args)
        {
            Canshu test = new Canshu();
            int a = 0, b = 0;
            test.ZhiChuanDi(a, b);//值传递
            Console.WriteLine("{0},{1}", a, b);
            test.YinYongChuanDi(ref a,ref b);//引用传递必须加ref
            Console.WriteLine("{0},{1}", a, b);
            test.ShuChuCanShu(out a, out b);//输出传递，可以给已经有值的变量赋值
            Console.WriteLine("{0},{1}", a, b);
            int c, d;
            test.ShuChuCanShu(out c, out d);//输出传递最显著的特点:可以传递未赋值的变量
            Console.WriteLine("{0},{1}", c, d);
            Console.ReadLine();
        }
    }

泛型函数，泛型类

背景：我们在创建函数时候需要指定参数的类型，比如要写一个函数传入三个参数，可以在屏幕上输出它，对于不同的数据类型，都需要这个函数名起作用，这样就会非常的麻烦，要做许多重载函数。
但是我们模糊的把他们当作一个不确定数据类型，只要三个数据类型满足某些特定的规则就可以用一个函数对各种情况起作用。泛型就是这样的作用。
（实际上，可以把参数类型设置为object，所有类型的参数都可以传入）
1.泛型函数：在创建函数时指定一种未知的数据类型名字为。。函数内部就可以使用这种类型
（1）函数创建时：修饰符 返回类型 函数名<泛型>(泛型或特定数据类型 参数)
（2）函数调用时：函数<指定类型>（参数）
2.泛型类：在创建类的时候指定，类内部就可以使用这种类型
（1）类创建时：修饰符 class 类名<泛型>{}
（2）用类创建实例时:类名 <指定类型>=new 类名 <指定类型>（构造函数的参数）
3.实例：实现各种数据类型的打印，泛型类和泛型函数可以结合使用

class Fanxing<X_type, Y_type>
    {
        public X_type x;
        public Y_type y;

        public Fanxing(X_type x, Y_type y)//此处的构造函数就用了泛型
        {
            this.x = x;
            this.y = y;
        }
        public void FanXingFunc<Z_type>(X_type x, Y_type y, Z_type z)//泛型函数
       {
            Console.WriteLine("{0},{1},{2}", x, y, z);
        }
    }
    class 泛型类
    {
        static void Main1(string[] args)
        {
            //两种不同类型的泛型类对象。
            Fanxing<int, int> test1 = new Fanxing<int, int>(1, 3);
            //泛型类在创建实例的时候指定类型
            Console.WriteLine(test1.x+ test1.y);
            Fanxing<double, int> test2 = new Fanxing<double,int>(1.2, 3);
            Console.WriteLine(test2.x+test2.y);
            test1.FanXingFunc<int>(1, 3, 2);
            //泛型函数在使用函数时指定类型
        }
    }

索引器

如何自制一个索引器

1.语法：内部需要像属性一样设置

public 返回的数据类型 this[index]
				{
				get
				{return ...}
				set
				{...=value}
				}

本质是一个函数，只不过可以用 对象名[索引] 来调用
2.实例：利用索引器实现对象内部数据修改

 class SuoYinQi
    {
        private int[] nums;
        public SuoYinQi(int num1, int num2, int num3)//构造函数
        {
            nums = new int[3] { num1, num2, num3 };//初始化数组
        }
        public int this[int index]//必须用属性访问
        {
            get
            {
                return nums[index];
            }
            set
            {
                nums[index] = value;
            }
        }
        
    }
    class 索引器
    { 
        static void Main(string[] args)
    {
        SuoYinQi test = new SuoYinQi(1, 2, 3);
        Console.WriteLine("{0} {1} [2]",test[0], test[1], test[2]);
        test[0] = 3;//修改了第一个元素
        Console.WriteLine("{0} {1} [2]",test[0], test[1], test[2]);
    }

内置索引器

1.介绍：与java的列表相似，可以直接用对象[索引]访问。并且内置了许多函数可以直接调用
2.语法：
（1）创建时：List <类型> 列表名=new List<类型> （）
（2）使用：列表.函数
3.实例

static void Main1(string[] args)
        {
            List<string> names = new List<string>();
            names.Add("Daming");
            names.Add("LiLi");
            names.Add("Sam");
            int n = names.IndexOf("LiLi");//显示特定元素的索引
            Console.WriteLine(n);
            for (int i = 0; i < names.Count; i++)//有多少个元素
            {
                Console.WriteLine(names[i]);
            }
            Console.ReadLine();//结束
        }