类和接口的区别

Posted 2020-08-16 枫的救赎

类：

 类的分类有：抽象类(abstract)、密封类(sealed)、静态类(static)

抽象类(abstract)

关键字： abstract
使用目的：若所有子类拥有共同的特性，可以把这个特性放到一个抽象类中，子类继承此抽象类。 
特点：

    1.不能被实例化；ClassName en=new ClassName();//这样会报错。
    2.抽象成员必须包含在抽象类中。
    3.抽象类除了抽象成员外，还可以包含别的成员(不用关键字 abstract)。
    4.子类继承抽象父类后，必须把父类中的所有抽象成员都重写(非抽象成员不必重写)。除非子类也是个抽象类。
    5.抽象成员的访问修饰符不能是private。
    6.抽象类是有构造函数，虽然不能被实例化。
    7.abstract不能用于字段成员，可定义成属性。
    8.abstract用于方法时，方法不能定义主体(内容)。
    9.抽象类也可以实现接口，但要把接口的成员前面标记个abstract。

密封类(sealed)

关键字： sealed
使用目的：不需要子类来继承他。如 String；
特点：
    1.不能被继承，如:string ,不能被继承。
    2.子类重写后，前面加个sealed，那么子类就不能再被继承。

 静态类(static)

关键字： static
使用目的：不需要实例化，可以直接类名引用静态方法。比如 工具类。
特点：
1.相似于sealed与abstract使用。
2.静态成员在整个程序退出时才释放资源，所以尽量别写静态字段、属性。最好是静态方法。

接口：

关键字： interface
使用目的：抽象类所拥有的共性，也可以概括为：为了多态。
特点：
1.接口中只能包含方法。（方法、属性、索引器、事件）
2.接口中的方法不能有任何实现
3.接口中的成员不能有任何访问修饰符（哪怕是public）
4.接口不能被实例化
5.实现接口的类，必须实现接口的所有成员(这里跟抽象类一样)
6.类不能多继承，所以在某些情况下，只能用接口来代替。接口可以多实现（一个类可以继承多个接口，而只能继承一个类）
7.接口的主要目的就是为了实现多态
8.当一个类，同时继承了某个类，并且也实现了某些接口的时候，必须要将继承的类写在第一个(如果一个类同时继承了父类和接口的时候，要把父类写在最前面)
9.当多个类，都具有某个或某几个功能时（方法），但是这几个类型又不属于相同的系列（这几个类型没有共同的父类，就不能用抽象类。），所以这时，为了实现多态就可以考虑把这几个类型共有的方法提取到一个接口中，让这几个类型分别实现该接口
10.当父类实现接口，子类继承父类。那么 接口就可以引用子类
11.不要在一个接口中写过多的方法，避免造成接口污染。可编写多个接口，在每个接口中，分别定义方法
12.实现接口方法的时候，不要有override关键字，直接跟平常定义一样
13.接口方法的显示实现，如果多个接口里有相同的方法名。那么第一个方法名默认的引用的是排在最前面的接口，如果要使用后面接口的方法，就要显示实现：接口名.方法名。访问修饰符是private

 

 

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

namespace _20161025
{
    class Program
    {
        static void Main(string[] args)
        {
            IIBaseprogrom p = new IIBaseprogrom();
            //调用指定接口的方法
            IBaseProgrom1 p1 = p as IBaseProgrom1;
            Console.WriteLine(p1.helloword("hello"));
            //  p.helloword(1);
            //默认方法
            Console.WriteLine( p.helloword("hello"));

            pearson pearson = new pearson();
            //调用继承的抽象类的非抽象方法
            pearson.hello();
            //调用重写后的方法
            Console.WriteLine(pearson.hello("hello"));
            //调用静态类的方法
            stBaseprogrom.hello();
            Console.Read();
        }
    }


   /// <summary>
   /// 接口1
   /// </summary>
   public  interface IBaseProgrom
    {
        int helloword(int x);

        string helloword(string hello);
    }
    /// <summary>
    /// 接口2
    /// </summary>
    public interface IBaseProgrom1
    {
        string helloword(string x);
    }

    /// <summary>
    /// 类1
    /// </summary>
    public class BaseProgrom
    {
        string helloword(string x)
        {
            return "hello";
        }
    }
    /// <summary>
    /// 类2
    /// </summary>
    public class IIBaseprogrom : BaseProgrom,IBaseProgrom,IBaseProgrom1
    {
        public int helloword(int x)
        {
            return x;
        }
        int IBaseProgrom.helloword(int x)
        {
            return x;
        }
        
        //显性显示 调用指定的接口的方法
        string IBaseProgrom1.helloword(string x)
        {
            return "调用指定的接口IBaseProgrom1的方法";
        }
        //默认为最前面的接口方法
        public  string helloword(string s)
        {
            return "默认最前面的接口方法调用";
        }
    }


    /// <summary>
    /// 抽象类
    /// </summary>
    public abstract class abBaseprogrom
    {
        //非抽象成员
        public void hello()
        {
            Console.WriteLine("抽象类方法");
        }
        //抽象成员
        public abstract string hello(string str);
    }

    /// <summary>
    /// 密封类
    /// </summary>
    public sealed class pearson : abBaseprogrom
    {
        public override string hello(string str)
        {
            return "pearson 类重写方法";
        }
    }
    /// <summary>
    /// 静态类
    /// </summary>
    public static class stBaseprogrom
    {
        public static void hello()
        {
            Console.WriteLine("静态类方法调用");
        }
    }



}

具体代码如下