C# 語法---2.類（方法、屬性、 索引器、抽象類）

什麼是類？

类是对某个对象的定义。它包含有关对象动作方式的信息，包括它的名称、方法、属性和事件。实际上它本身并不是对象，因为它不存在于内存中。当引用类的代码运行时，类的一个新的实例，即对象，就在内存中创建了。虽然只有一个类，但能从这个类在内存中创建多个相同类型的对象。

類：聲明、創建對象、繼承

• 聲明：

<access soecifier> class class_name      //accss soecifier指定類及其成員訪問規則 class後跟類名稱
{
    主體，定義行為數據
}

• 創建對象

Members object= new Member();   // 創建類的實例，傳遞該對象的引用

• 繼承

public class Students : Person   //c#中類只能直接從一個基類繼承，當時能間接繼承，

　　

• “類成員”描述

1. 字段：字段就是指在類或結構中聲明的任何類型的“變量”
2. 方法：方法就是標準的“函數”

namespace Class
{
    /*
    <Access Specifier>訪問修飾符 <Return Type> 返回類型<Method Name> 方法名稱(Parameter List)參數列表
{
    mehod body 方法主體
}
     */
    /// <summary>
    /// 按值傳遞 按引用傳遞參數 按輸出傳遞參數
    /// </summary>
    class NumberManipulator
    {
       public void swap(ref int x, ref int y)   //按引用傳遞參數   （int x, int y）按值傳遞   （out int x）按輸出傳遞   ref可以吧參數的數值傳遞進函數，out是要把參數清空，“ref有出有進，out只出不進”
       {
           int temp;               //交換x,y
           temp = x;
           x = y;
           y = temp;
       }
        static void Main(string[] args)
        {
            NumberManipulator n = new NumberManipulator();
            int a =100;    //局部定義
            int b =200;
            Console.WriteLine("在交換之前，a的值：{0}",a) ;
            Console.WriteLine("在交換之前，b的值：{0}",b) ;
             //調用交換函數  引用參數傳遞改變a,b實際值
            n.swap(ref a, ref b);
             // n.swap(a, b);  值傳遞不會改變a,b的實際值
            // n.swap(out a);  返回a的值
            Console.WriteLine("在交換之后，a的值：{0}",a) ;
            Console.WriteLine("在交換之后，b的值：{0}",b) ;
            Console.ReadLine();
        }
    }
  
}

• 關鍵字：

1. virtual---告訴子類，此方法可以被重寫
2. abstract---方法必須在非抽象的派生類中重寫（只用於抽象類）
3. override---方法重寫了一個基類方法
4. extern---方法定義在其他地方

• 屬性：屬性是一種類的成員，它的實現類視函數，作用是提供一種靈活和安全的機制來訪問、修改私有字段，必須依賴於字段

namespace Class
{
    /// <summary>
    /// 屬性的用法,訪問私有域屬性
    /// </summary>
    class Student
    {
        private string name = "";
        //聲明類型為string 的Name私有域屬性
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }
        public override string ToString()  //重寫
        {
            return Name = "+ Name +";
        }
       }
    class ExampleDemo
    {
        public static void Main1()
        {
            //創建一個student對象
            Student s = new Student();
            //設置student的name
            s.Name = "xiaoming";
            Console.WriteLine("Student Name:{0}", s);
            Console.ReadKey();
        }
    }
}

• 索引器：

1. 所有索引器都使用this關鍵字來取代方法名，class或struct 只允許定義一個索引器
2. 索引器允許類或結構的實例按照與數組相同的方式進行索引，類似于屬性，不同之處在於索引器的訪問器採用參數
3. 索引器常用於對集合的快速讀取和設計中，索引器表示法簡化了客戶端應用程序的語法，使得更容易理解

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Class
{
    /// <summary>
    /// 通過索引器訪問實例成員
    /// </summary>
    class Course
    {
        public float Chinese { set; get; }
        public float Math { set; get; }
        public float English{ set; get; }
        //聲明一個公開的float類型索引器
        public float this[int index]
        {
            //set 訪問器 賦值
            set
            {
                switch (index)
                {
                    case 0:
                        this.Chinese = value;
                        break;
                    case 1:
                        this.Math = value;
                        break;
                    case 2:
                        this.English = value;
                        break;
                    default:
                        //索引越界拋出異常
                        throw new ArgumentOutOfRangeException();
                }
            }
            //get訪問器：取值
            get
            {
                switch (index)
                {
                    case 0:
                        return this.Chinese;
                    case 1:
                        return this.Math;
                    case 2:
                        return this.English;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //聲明course類的實例
            var course = new Course();
            //使用索引器訪問實例成員
            //賦值
            course[0] = 11;
            course[1] = 22;
            course[2] = 33;
            //取值
            Console.WriteLine("語文:{0},數學:{1},英語:{2}", course[0], course[1], course[2]);
            Console.ReadKey();
        }
    }
}

• 屬性與索引器區別：

1. 屬性用于可以驗證的方式訪問私有成員變量。索引器用於以更便捷的方式訪問對象中包含的成員數組或集合
2. 屬性名可以自定義，索引器必須以this命名
3. 屬性可以為實例或靜態，索引器必須是實例的
4. 索引器有索引參數列表，而屬性沒有

• 抽象类

abstract class Abs
{
    private int age;
    public void tell(){
    }
    //  抽象方法
    public abstract void say();
}
class AbsDemo extends Abs{   //子类基层抽象类实现其中的方法
    public void say(){
    }
// 子类不能访问父类私有变量 ，这时用到属性

}
public class AbsDemo01{
    public static void main(String[] args){
        //     Abs a = new Abs();  错误！不能实例化抽象类
        AbsDemo a = new Abs Demo();
        a.say();
}
}

abstract和virtual區別：

abstract 可以修飾類，方法，屬性，然後通過繼承類的方法override來重寫修改，如果一個方法被abstract 修飾，那麼該方法所在的類必須被abstract 修飾

namespace stract
{
    abstract class BaseClass // 定義抽象類
    {
        protected int _x = 100;
        protected int _y = 150;
        public abstract void AbstractMethod(); // 抽象方法
        public abstract int X { get; }
        public abstract int Y { get; }
    }
    class DerivedClass : BaseClass  //繼承基類
    {
        public override void AbstractMethod()  //重寫方法
        {
            _x++;
            _y++;
        }
        public override int X // 重寫屬性
        {
            get
            {
                return _x + 10;
            }
        }
        public override int Y // 重寫屬性
        {
            get
            {
                return _y + 10;
            }
        }
        static void Main()
        {
            DerivedClass o = new DerivedClass();  //重寫方法后才能實例化
            o.AbstractMethod();
            Console.WriteLine("x = {0}, y = {1}", o.X, o.Y);
            Console.ReadKey();
        }
    }
}

virtual 虛擬方法是用來修改方法，屬性，然後通過繼承類的方法前綴override來修改，不能修飾類

namespace aboutvirtual
{
    class MyBaseClass
    {
        public virtual string Name { get; set; }
        // 修飾屬性
        private int num;
        public virtual int Number
        {
            get { return num; }
            set { num = value; }
        }
    }
    class MyDerivedClass : MyBaseClass
    {
        private string name;
        //繼承基類，使用override修飾重寫屬性
        public override string Name
        {
            get { return name; }
            set
                {
                    name = value;
                }
                else
                {
                    name = "Unknown";
                }
            }
        }
        static void Main(string[] args)
        {
             {
                if (value != String.Empty)
       }
    }
}

• virtual 與 abstract 區別

1. virtual 可以存在于抽象類或非抽象類，而abstract 只能存在抽象類，如果一方法被抽象化，那麼類的前面也必須加上abstract
2. virtual 可以寫方法，意思是可以定義，而abstract只能抽象方法，不能定義內容
3. 類中的virtual虛擬方法不一定需要再繼承類中重寫，而abstract類里的所有抽象方法必須全部在繼承類中重寫。
4. 從例子中可以看出，在實際操作中，如果有個類需要全部重寫定義，那麼用abstract 如果有個類需要部分繼承，那麼我們使用virtual