面向对象(九) 多态 接口

1、C# 中的访问修饰符
① public：公开的公共的；
② private:私有的，只能在当前类的内部访问；
③ protected:受保护的，只能在当前类的内部以及该类的子类中访问；
④ internal：只能在当前程序集集中访问。在同一个项目中，internal和public的权限是一样。
⑤ protected internal:

1. 、能够修饰类的访问修饰符只有两个：public、internal；
   2）、可访问不一致；
   子类的访问权限不能高于父类的访问权限，会暴露父类的成员。

2、设计模式
设计这个项目的一种方式。

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

namespace 简单工程设计
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("请输入你想要得笔记本品牌");
            string brand = Console.ReadLine();
            NoteBook nb = GetNoteBook(brand);
            nb.SayHello();
            Console.ReadKey();
        }

        /// 

        /// 简单工厂核心 根据用户的输入对象赋值给父类
        /// 
        /// 
        /// 
        public static NoteBook GetNoteBook(string brand)
        {
            NoteBook nb = null;
            switch(brand)
            {
                case "Lenovo":nb = new Lenovo();
                    break;
                case "IBM":nb = new IBM();
                    break;
                case "Acer":nb = new Acer();
                    break;
                case "Dell":nb = new Dell();
                    break;
            }
            return nb;
        }
    }

    public abstract class NoteBook
    {
        public abstract void SayHello();
    }

    public class Lenovo:NoteBook
    {
        public override void SayHello()
        {
            Console.WriteLine("我是联想笔记本，你联想也别想");
        }
    }

    public class Acer : NoteBook
    {
        public override void SayHello()
        {
            Console.WriteLine("我是鸿基笔记本");
        }
    }
    public class Dell : NoteBook
    {
        public override void SayHello()
        {
            Console.WriteLine("我是戴尔笔记本");
        }
    }
    public class IBM : NoteBook
    {
        public override void SayHello()
        {
            Console.WriteLine("我是IBM笔记本");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

3、值类型在复制的时候，传递的是这个值的本身。引用类型在复制的时候，传递的是对这个对象的引用。

4、系列化：就是将对象转换为二进制；反系列化：就是将二进制转换为对象。
作用：传输数据。

5、partial部分类
6、sealed密封类
不鞥个被其他类继承，但是可以继承于其他类。
7、接口
[public] interface I…able
{
成员;
}

接口中的成员不允许添加访问修饰符，默默认就是Public;
不允许写具有方法体的函数;

接口是一种规范。
只要一个类继承了一个接口，这个类就必须实现这个接口中所有的成员。
为了多态。接口不能被实例化。
也就是说，接口不能new(不能创建对象)

接口中的成员不能加“访问修饰符”，接口中的成员访问修饰符为Public,不能修改。
（默认为public）接口中的成员不能有任何实现（“光说不做”，只是定义了一组未实现的成员）。
接口中只能有方法、属性、索引器、事件，不能有“字段”和构造函数。
接口与接口之间可以继承，并且可以多继承。
接口并不能去继承一个类，而类可以继承接口（接口只能继承于接口，而类即可以继承接口，也可以继承类）。
实现接口的子类必须实现该接口的全部成员。
一个类可以同时继承一个类并实现多个接口，如果一个子类同时继承了父类A，并实现了接口IA，那么语法上A必须写在IA的前面。
class myClass:A,IA{},因为类是单继承的。
显示实现接口的目的，解决方法的重名问题。
什么时候显示的去实现接口：
当继承的接口中的方法和参数一模一样的时候，要是用显示的实现接口；
当一个抽象类实现接口的时候，需要子类去实现接口。

问题：
1、什么时候用虚方法来实现多态？
2、什么时候用抽象类来实现多态？
3、什么时候用接口来实现多态？