抽象和接口

抽象类和抽象方法

抽象方法：1 带抽象方法的类必须是抽象类,若不是要在类加abstract修饰符

　　　　　2 描述抽象方法时必须只是一个方法体，无需后面的大括号及内容

　　　　　3 抽象方法必须在子类中重写

　　　　　4 静态方法和抽象方法不能是一个方法

 

抽象类：   1 抽象类不能被实例化

　　　　　2 抽象类和最终类不能使同一个类,因为抽象类本身不能实例化，必须被继承才有意义

　　　　　3 抽象类的非抽象子类必须包含抽象类的所有方法和成员,其中抽象方法需要重载

//抽象类
    public abstract class Abstract_test
    {   //计算面积
        public abstract double Area();  //抽象方法
    }

    public class Circle : Abstract_test
    {
        private double pi = 3.14;
        public double r = 0;

        public Circle(){}
        public Circle(double r){this.r = r;}22         
        public  override double Area()  //继承抽象方法时必须重载
        {
            return this.pi * this.r * this.r;
        }

若父类中已重写过部分的抽象方法，子类只需重写未重写的方法（也可全部重载）

        public abstract class Abstract
        {
            public abstract void test1();
            public abstract void test2();
        }

        public abstract class Test1:Abstract
        {
            public override void test1()
            {
                Console.WriteLine("test1");
            }
        }

        public class Test2:Test1
        {
            public override void test2()
            {
                Console.WriteLine("test2");
            }
        }

 接口

规则：

1 接口可定义方法,带参数属性，事件,不能定义字段，静态变量等

2 接口成员不能有修饰符

3 接口可以被多个类继承，一个类也可以继承多个接口

4 接口不能随便修改

5 可用new隐藏从基接口继承的成员

public interface  IClass1  //interface为接口
    {
        void test1();
        void test2();
    }

    public interface IClass2
    {   //接口中只能定义以下三种类型
        string testString { get; set; }  //属性
        void test3();               //方法
        event EventHandler testEvent;  //事件
    }

    public interface IClass3 : IClass1  //接口的继承,子接口中自动继承了父接口所有的方法
    {
        void test5();
    }

    public class Class3 : IClass2, IClass3   //接口可多继承,必须把继承接口中的方法属性补全
    {
        string IClass2.testString { get ; set ; }
        event EventHandler IClass2.testEvent
        {
            add => throw new NotImplementedException();
            remove => throw new Not ImplementedException();41         }
        void IClass1.test1()
        {
            throw new NotImplementedException();
        }
        void IClass1.test2()
        {
            throw new NotImplementedException();
        }
        void IClass2.test3()
        {
            throw new NotImplementedException();
        }
        void IClass3.test5()
        {
            throw new NotImplementedException();
        }
    }

接口和抽象类都可作为类型声明变量,并利用多态性进行筛选操作

接口和抽象的区别

1 修饰符不同

2 抽象类是类,类只能被类单继承;而接口可以被多继承

3 接口只能定义属性方法和事件;而抽象可以定义几乎所有

4 抽象类中可以有非抽象方法,即普通方法；而接口中只能有签名

5 接口不能使用访问修饰符,隐式为公共;抽象成员不可以抽象的，但可以是私有、保护、内部或者受保护的内部成员