C#属性-索引器-里氏替换-多态-虚方法-抽象-接口-泛型-

1.属性

//属性的2种写法
public class person
{
    private string _name;
    public string Name
    {
        get
        {
            return _name;
        }
        set
        {
            _name=value;
        }
    }
    public int Age
    {
        get;
        set;
    }
} 

 2.索引器

//外部调用
person p=new person;
sting str=p[]
public class person
{
    private string _name;
    public string Name
    {
        get
        {
            return _name;
        }
        set
        {
            _name=value;
        }
    }
    public int Age
    {
        get;
        set;
    }
        public string Email
    {
        get;
        set;
    }
//也可以用 sting 键值,也可以多个参数
//可以重载,PS:public string this[int index],public string this[string key]
    public string this[int index]
    {
        get
        {
            string result="";
            switch(index)
            {
                :
                result=this.Name;
                break;
                :
                result=this.Age;
                break;
                :
                result=this.Email;
                break;
            }
            return result;
        }
    }
} 

 3.方法重写/重载

方法重写(子类重写父类)

父类中的方法子类要想重写需要将父类方法标记为virtual

子类重写父类方法时,使用的关键字override

方法重载(一个类中的多个重名的方法)

4.多态

①里氏替换原则

//需要一个父类类型对象,可以赋值一个子类类型对象,叫做"里氏替换",反过来不成立!
Person p = new Chinese();
public class Person
{
}
public class Chinese:Person
{
}

②多态

实现多态的方法

方法1虚方法virtual子类重写父类中的方法

方法2 抽象类abstract 子类重写父类中的方法

方法3 接口 实现接口的类,将接口中的方法实现

方法1虚方法

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

namespace _10通过继承实现多态
{
    class Program
    {
        static void Main(string[] args)
        {
            Chinese cn1 = new Chinese("中国人");
            Person[] pers = { cn1 };

            ; i < pers.Length; i++)
            {
                //实现了多态
                pers[i].ShowNationality();
            }
            Console.ReadKey();
        }

    }
    public class Person
    {
        public string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public string Email
        {
            get;
            set;
        }
        //父类中的方法子类要想重写需要将父类方法标记为virtual.
        //虚方法，子类可以重写也可以不重写。
        public virtual void ShowNationality()
        {
            Console.WriteLine("......");
        }
        public override string ToString()
        {
            return this.Name;
        }
    }

    public class Chinese : Person
    {
        public Chinese(string name)
        {
            this.Name = name;
        }

        public string HuKou
        {
            get;
            set;
        }
        public void Say()
        {
            Console.WriteLine("我是中国人.");
        }

        //子类重写父类方法时，使用的关键字是override
        public override void ShowNationality()
        {
            Console.WriteLine("【中国】");
        }
    }
}

方法2抽象

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

namespace _15通过抽象类来实现多态2
{
    class Program
    {
        static void Main(string[] args)
        {
            Person p = new Japanese();
            p.Name = "mamm";
            p.Say();
            Console.WriteLine(p.Name);
            Console.ReadKey();
        }
    }

    //抽象类的特点:
    //1.抽象类不能被实例化。
    //2.抽象类中可以有实例成员，也可以有抽象成员。
    public abstract class Person
    {
        public abstract string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public string Email
        {
            get;
            set;
        }

        //1.将virtual关键字变为abstract。
        //2.抽象成员不能有任何实现代码
        //3.抽象成员只能出现在抽象类中。所以要把当前类也标记为abstract
        //4.与虚方法不同，抽象方法子类必须重写（除非子类也是抽象类）
        public abstract void Say();

    }

    public class Chinese : Person
    {
        public override void Say()
        {
            Console.WriteLine("Chinese中的Say");
        }

        public override string Name
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }
    }

    public class Japanese : Person
    {

        public override void Say()
        {
            Console.WriteLine("Japanese中的Say方法。");
        }

        public override string Name
        {
            get
            {
                return "aaa";
            }
            set
            {

            }
        }
    }
}

方法3.接口

//1.接口中只能包含方法（属性、事件、索引器也都是方法）
//2.接口中的成员都不能有任何实现。

//3.接口不能被实例化。

//4.接口中的成员不能有任何访问修饰符。（默认为public）

//5.实现接口的子类必须将接口中的所有成员全都实现。

//6.子类实现接口的方法时，不需要任何关键字，直接实现即可。

//7.接口存在的意义就是为了多态。

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

namespace _05接口1
{
    class Program
    {
        static void Main(string[] args)
        {
            //1.接口解决了多继承的问题。（抽象类不行。）

            //2.当不同类型要实现多态时，无法抽象出公共的父类，这时可以考虑使用接口（比如：鸟和飞机都能飞，但是无法抽象出共同的父类。）
            IShow ren = new Japanese();//new Chinese();
            ren.Show();
            Console.ReadKey();
        }
    }

    public class Person
    {
        public string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public string Email
        {
            get;
            set;
        }
    }

    public interface IShow
    {
        //显示国籍。
        void Show();
    }

    public class Chinese : Person, IShow
    {
        #region IShow 成员

        public void Show()
        {
            Console.WriteLine("中国");
        }

        #endregion
    }

    public class Japanese : Person, IShow
    {

        #region IShow 成员

        public void Show()
        {
            Console.WriteLine("日本");
        }

        #endregion
    }
}

public interface ISupperMan
{
   // 1.接口里面只能包含方法(事件、属性、索引器)
    //2.接口中的成员不能有访问修饰符默认是public
    void Fly();

    void Fight();
}

//实现接口的类必须把接口中的所有成员都实现。
public class Person : ISupperMan
{
    public string Name
    {
        get;
        set;
    }
    public int Age
    {
        get;
        set;
    }
    public string Email
    {
        get;
        set;
    }

    #region ISupperMan 成员

    public void Fly()
    {

    }

    public void Fight()
    {

    }

    #endregion
}