C#基础-⾯向对象详解
⾯向对象详解
⼀.什么是⾯向对象
1>⾯向对象是⼀种程序设计思想
2>⾯向过程和⾯向对象是什么？
例如要把⼤象放冰箱怎么做？
⾯向过程：打开冰箱门->把⼤象扔进去->关上冰箱门（如下图）
⾯向对象：两个对象，⼤象和冰箱。⼤象有⾃⼰的固有属性⾼和重量，还有两个动作分别是进冰箱和出冰箱。冰箱也有⾃⼰固有属性⾼和重量，动作也有开门和关门
区分：
1.⾯向过程是解决问题的常规思路，更加符合解决问题的想法，但是随着步骤越来越多，就很难满⾜需求了。
2.⾯向对象是把东西分拆为各个对象，每个对象完成⾃⼰的核⼼动作，分⼯合作，对象之间交互完成功能。
⼆.⾯向对象的三⼤特性
1.封装
下⾯⼏⾏代码，就是封装⼀个对象，描述的是⼀只⼤象，⼤象有⼀些特性（⾝⾼和重量）和⾏为（进冰箱或出冰箱）
1public class Elephant
2    {
3public int Height = 0;
4public int Weigth = 0;
5public void IntoFridge()
6        {
7            Console.WriteLine("进冰箱");
8        }
9public void OutFridge()
10        {
11            Console.WriteLine("出冰箱");
12        }
13    }
总结：
1>把数据和⾏为打包到class中，就叫封装
2>封装的好处有，数据安全，提供重⽤性，分⼯合作和⽅便构建⼤型复杂的项⽬
2..继承
下⾯⼏⾏代码，就是实现了继承，⼤象⼦类继承了动物⽗类，其中完全⼀样的特性（⾝⾼，体重）和⾏为（吃东西）放到⽗类中，这样做的好处是可以去掉重复代码
⼤象⼦类可以拥有动物⽗类的⼀切公开的属性和⾏为，不管⼤象是否愿意，它都必须拥有⽗类的公开东西。继承也是实现多态的，接下来会
1public class Elephant: Animal
2    {
3//public int Height = 0;
4//public int Weigth = 0;
5public void IntoFridge()
6        {
7            Console.WriteLine("进冰箱");
8        }
9public void OutFridge()
10        {
11            Console.WriteLine("出冰箱");
12        }
13//public void CanEat()
14//{
15//    Console.WriteLine("我可以吃东西");
16//}
17    }
18public class Animal
19    {
20public int Height = 0;
21public int Weigth = 0;
22public void Eat()
23        {
24            Console.WriteLine("我可以吃东西");
25        }
26    }
3.多态
1>说⽩了，可以理解为有相同的变量，相同的操作，但是不同的实现
2>多态种类包括：⽅法的重载；接⼝&&实现；抽象&&实现；继承
例如下图：都是实例化的Animal，都是调⽤的Eat⽅法，⼀个执⾏的是⼤象的吃⽅法，⼀个执⾏的是⼈的吃⽅法，这就可以理解为相同的变量，相同的操作，实现⽅式不同，这就是多态啦！是运⾏时多态（程序运⾏时，实现的多态）
1using System;
2
3namespace _002_Attributewriteline特点
4 {
5class Program
6    {
7static void Main(string[] args)
8        {
9            Animal animal = new Elephant();
10            animal.Eat();
11            Animal animal1 = new People();
12            animal1.Eat();
13            Console.Read();
14        }
15    }
16public class Elephant : Animal
17    {
18public void IntoFridge()
19        {
20            Console.WriteLine("进冰箱");
21        }
22public void OutFridge()
23        {
24            Console.WriteLine("出冰箱");
25        }
26public override void Eat()
27        {
28            Console.WriteLine("我是⼤象，我吃植物");
29        }
30    }
31public class People : Animal
32    {
33public override void Eat()
35            Console.WriteLine("我是⼈，我吃⽶饭");
36        }
37    }
38public abstract class Animal
39    {
40public int Height = 0;
41public int Weigth = 0;
42public abstract void Eat();//抽象⽅法，必须在抽象类中
43    }
44 }
View Code
4.抽象
⾯向对象说是有封装，继承，多态三⼤特性，也可以说成有四⼤特性，包括抽象，抽象也是很常见的。
1>抽象⽅法：⼦类都得有，实现⽅式不同，此时考虑⽤抽象⽅法。这⾥注意，抽象⽅法必须在抽象类中
1>抽象类：
⾸先抽象类是⽗类，⾥⾯放得都是共有的东西；
抽象类中有约束（抽象⽅法）；
抽象类是不能实例化，只能由实现抽象了的⼦类去实例化
抽象类中，放的都是共有的东西
三.怎么选择抽象类和接⼝(重点)
接⼝：约束
1>只能约束
2>特点是，多实现，更加灵活
3>语义⽅⾯有点像：can do，可以说“实现接⼝的⼦类 can do 接⼝约束”
4>有的⼦类有，有的⼦类没有的情况，就要考虑⽤接⼝
抽象类:⽗类+约束
1>可完成通⽤的实现，只能单继承
2>语义⽅⾯有点像： is a，可以说“⼦类is a ⽗类”
选择接⼝还是抽象类的原则：⼦类都⼀样的，放在⽗类；⼦类都有但是不同，放在⽗类抽象⼀下；有的⼦类有，有的⼦类没有，那就⽤接⼝⼀般情况，接⼝⽤的更多，因为接⼝更简单灵活除⾮有些共有的需要继承，下⾯是⼀个⼩例⼦：
需求：门，有材质，猫眼，门铃，开门（），关门（），烟雾报警（）；等。
请问：⽤⾯向对象的程序设计思想，怎么去封装？？（值得深思，希望能起到与⼀反三的效果）
1interface IExtend
2    {
3string CatEye { get; set; }//猫眼
4string Doorbell { get; set; }//门铃
5void SmokeAlarm();//烟雾报警
6
7    }
8public abstract class BaseDoor
9    {
10public string RawStock { get; set; }//材料
11
12//以下两个开门和关门在⽗类⽤抽象，因为开关门的⽅式会有不同，有些门⾃动开关，有些需要⼈去开关
13public abstract void Open();//开门
14public abstract void Close();//关门
15    }
四.抽象⽅法和虚⽅法的区别
1>最本质的区别：虚⽅法带有实现（⽅法体），可以被重载；抽象⽅法没有实现
2>下⾯的例⼦，详细说明了抽象⽅法和虚⽅法的⽤法，程序中做了很详细的注释，程序运⾏结果如下图：
1using System;
2
3namespace _002_Attribute
4 {
5class Program
6    {
7static void Main(string[] args)
8        {
9//虚⽅法/抽象⽅法，程序编译时候，左边遇到virtual/abstract时，做个标记，等程序运⾏的时候，判断右边是否有override，如果有，就以右边为准10
11            ParentClass parent = new Child();
12            parent.CommonMethod();//普通⽅法，⽗类为准；这个是编译时确定的，特点是：效率⾼
13            parent.VirtualMethod1();//虚⽅法，⼦类没重载，左边为准
14            parent.VirtualMethod2();//虚⽅法，⼦类有重载，右边为准；运⾏时确定，特点是为了灵活
15            parent.AbstractMethod();//抽象⽅法，右边为准；运⾏时确定，特点是为了灵活
16            Console.Read();
17        }
18    }
19public class Child : ParentClass
20    {
21public override void VirtualMethod2()//⼦类重载了⽗类的 VirtualMethod2
22        {
23            Console.WriteLine("我是⼦类，重载虚⽅法2");
24        }
25public override void AbstractMethod()
26        {
27            Console.WriteLine("我是⼦类，实现后的抽象⽅法");
28        }
29    }
30public abstract class ParentClass
31    {
32///<summary>
33///普通⽗类⽅法
34///</summary>
35public void CommonMethod()
36        {
37            Console.WriteLine("我是⽗类，普通⽅法");
38        }
39///<summary>
40///⽗类虚⽅法，必须包含实现，可以被重载
41///</summary>
42public virtual void VirtualMethod1()
43        {
44            Console.WriteLine("我是⽗类，虚⽅法1");
45        }
46public virtual void VirtualMethod2()
47        {
48            Console.WriteLine("我是⽗类，虚⽅法2");
49        }
50///<summary>
51///我是抽象⽅法
52///</summary>
53public abstract void AbstractMethod();
54    }
55
56 }

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。