C#入门记录09

面向对象高级编程
    接口的概念和声明
    接口是一种用来定义程序的协议，它描述可属于任何类或结构的一组相关行为。接口可由方法、属性、事件和索引器 这4种成员类型任何组合构成
        但不能包含字段
接口具有以下特征：
    1.接口类似于抽象基类：继承接口的任何非抽象类型都必须为实现接口的所有成员
    2.不能直接实例化接口
    3.接口可以包含事件、索引器、方法和属性
    4.接口不包含方法的实现
    5.类和结构可从多个接口继承
    6.接口自身可从多个接口继承

接口的定义：  除了interface 和 接口名称外 其他的都是可选项
    修饰符 interface 接口名称 ： 继承接口列表{ 接口内容}

抽象类和接口的区别主要有以下几点：
1.他们的派生类只能继承一个基类，即只能直接继承一个抽象类，但可以继承任意多个接口
2.抽象类中可以定义成员的实现，但接口中不可以
3.抽象类中可以包含字段、构造函数、析构函数、静态成员或常量，接口中不可以
4.抽象类中的成员可以是私有的、受保护的、内部的或者受保护的内部成员，接口中的成员必须是公共的。

抽象类主要用作对象系列的基类，共享某些主要特性，例如共同的目的和结构
接口主要用作类

示例代码如下：

/*
2020年3月6日15:48:13
面向对象高级编程
    接口的概念和声明
    接口是一种用来定义程序的协议，它描述可属于任何类或结构的一组相关行为。接口可由方法、属性、事件和索引器 这4种成员类型任何组合构成
        但不能包含字段
接口具有以下特征：
    1.接口类似于抽象基类：继承接口的任何非抽象类型都必须为实现接口的所有成员
    2.不能直接实例化接口
    3.接口可以包含事件、索引器、方法和属性
    4.接口不包含方法的实现
    5.类和结构可从多个接口继承
    6.接口自身可从多个接口继承

接口的定义：  除了interface 和 接口名称外 其他的都是可选项
    修饰符 interface 接口名称 ： 继承接口列表{ 接口内容}

抽象类和接口的区别主要有以下几点：
1.他们的派生类只能继承一个基类，即只能直接继承一个抽象类，但可以继承任意多个接口
2.抽象类中可以定义成员的实现，但接口中不可以
3.抽象类中可以包含字段、构造函数、析构函数、静态成员或常量，接口中不可以
4.抽象类中的成员可以是私有的、受保护的、内部的或者受保护的内部成员，接口中的成员必须是公共的。

抽象类主要用作对象系列的基类，共享某些主要特性，例如共同的目的和结构
接口主要用作类
*/

using System;
using James_Interface;
using James_Abstract;

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

            //testInterfaceFunc();

            //testInterfaceFunc2();

            testAbstractClass();

            Console.ReadKey();
            //Console.WriteLine("Hello World!");
        }

        static void testInterfaceFunc()
        {
            TestInterface demo = new TestInterface();
            myInterface obj = demo; //用派生类对象 实例化接口 myInterface

            obj.ID = "9527";
            obj.Name = "JamesWu";
            obj.ShowInfo();
        }

        //测试多接口继承
        static void testInterfaceFunc2()
        {
            TestInterface2 demo = new TestInterface2();
            ITeacher iteacher = demo;
            iteacher.Name = "JamesWu";
            iteacher.Sex = "男";
            iteacher.teach();

            IStudent istudent = demo;
            istudent.Name = "C#";
            istudent.Sex = "男";
            istudent.study();

            myClass test = new myClass();
            Interface1 myinterface1 = test;
            Interface2 myinterface2 = test;
            Console.WriteLine(myinterface1.Add());
            Console.WriteLine(myinterface2.Add());

        }

        //测试抽象类的使用
        static void testAbstractClass()
        {
            //实例化派生类
            testClass obj = new testClass();
            myAbstractClass demo = obj;
            demo.ID = "9527";
            demo.Name = "JamesWu";
            demo.ShowInfo();        //使用抽象类的对象 调用 派生类中的方法
        }

    }
}

namespace James_Interface
{
    interface myInterface
    {
        string ID   //可读可写
        {
            get;
            set;
        }

        string Name    //可读可写
        {
            get;
            set;
        }

        void ShowInfo() //显示定义的编号和姓名
        {
            Console.WriteLine("编号\t 姓名");
            Console.WriteLine(ID + "\t" + Name);
        }
    }

    class TestInterface : myInterface
    {
        private string id = "";
        private string name = "";
        public string ID
        {
            get { return id; }
            set { id = value; }
        }

        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public void ShowInfo() //显示定义的编号和姓名
        {
            Console.WriteLine("编号\t 姓名");
            Console.WriteLine(ID + "\t" + Name);
        }
    }

    interface IPhone
    {
        string Name { get; set; }
        string Sex { get; set; }
    }

    interface ITeacher : IPhone
    {
        void teach();
    }

    interface IStudent : IPhone
    {
        void study();
    }

    class TestInterface2 : IPhone,ITeacher,IStudent     //多接口继承
    {
        string name = "";
        string sex = "";
        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public string Sex
        {
            get { return sex; }
            set { sex = value; }
        }

        public void teach()
        {
            Console.WriteLine(Name + "" + Sex + "教师");
        }

        public void study()
        {
            Console.WriteLine(Name + "" + Sex + "学生");
        }
    }

    //显式接口成员实现
    interface Interface1
    {
        int Add();
    }

    interface Interface2
    {
        int Add();
    }

    class myClass : Interface1, Interface2
    {
        //显式接口实现需要注意的两个知识点
        //1.显式接口成员实现中不能包含访问修饰符
        //2.显式接口成员属于接口成员，而不是类的成员。因此，不能使用类对象直接访问，只能通过接口对象来访问
        int Interface1.Add()    //显式声明
        {
            int x = 3;
            int y = 5;
            return x + y;
        }

        int Interface2.Add()
        {
            int x = 3;
            int y = 5;
            int z = 7;
            return x + y + z;
        }

        
    }
}

namespace James_Abstract
{
    //介绍关于抽象类的基本概念
    /*
     1.抽象类不能直接实例化
     2.抽象类中可以包含抽象成员，但非抽象类中不可以
     3.抽象类不能被密封

    定义方式：
        访问修饰符 abstract 类名 ： 基类或接口{ 类成员}
     */

    public abstract class myClass
    {
        //抽象方法必须在声明的抽象类中
        //声明抽象的方法时，不能使用virtual static private 修饰符
        //抽象方法 不提供任何实际实现
        public int i;
        public void method();
    }

    //抽象类 和 抽象方法的使用 实例
    public abstract class myAbstractClass
    {
        private string id = "";
        private string name = "";
        public string ID { get { return id; } set { id = value; } }
        public string Name { get { return name; } set { name = value; } }

        public abstract void ShowInfo();
    }

    public class testClass : myAbstractClass
    {
        public override void ShowInfo()
        {
            Console.WriteLine(ID + " " + Name);
        }
    }
}