OOP面向对象
一、面向过程
我们是怎么思考和解决上面的问题的呢?
答案是：我们自己的思维一直按照步骤来处理这个问题，这是我们常规思维，这就是所谓的面向过程pop编程
二、面向过程pop为什么转换为面向对象oop
面向过程想的思想步骤越多，变化越多，是无法掌控的，所以有时候非常复杂，就比如我们拿起来手机玩游戏如果按照pop编程则代码如下：
namespace oop
{
/// <summary>
/// oop 面向对象编程 object oriented programming
/// </summary>
class program
{
static void main(string[] args)
{
console.writeline("我要玩手机游戏了");
console.writeline("手机开机");
console.writeline("打开游戏");
console.writeline("正在打游戏");
console.writeline("游戏结束");
}
}
}
但是出现不同手机，不同的玩法，不同的游戏，那么又要重新写类似的东西，所以面向过程虽然更更符合人的思考方式，但是及其不方便扩展管理，不能够重复使用，尤其是项目复杂的情况下，会使编程不好维护
但是怎么从pop转换为oop呢？
我们通过手机玩游戏，可以转换一下思想，我们把对象进行分析，可以把手机，玩家，游戏分别定义为一个对象，可以参考如下：
1.玩家类
/// <summary>
/// 玩家类
/// </summary>
public class player
{
/// <summary>
/// 玩家id
/// </summary>
public int id { get; set; }
/// <summary>
/// 玩家名字
/// </summary>
public string name { get; set; }
/// <summary>
/// 玩手机方法
/// </summary>
/// <param name="phone"></param>
public void payerphone(phone phone)
{
//玩手机需要先开机
phone.open();
//玩手机游戏
phone.playgame();
}
}
2.手机类
/// <summary>
/// 手机类
/// </summary>
public class phone
{
/// <summary>
/// 手机id
/// </summary>
public int id { set; get; }
/// <summary>
/// 手机name
/// </summary>
public string name { set; get; }
public void playgame()
{
game game = new game();
game.start();
game.paly();
game.over();
}
/// <summary>
/// 手机开机
/// </summary>
public void open()
{
console.writeline($"{this.gettype().name}手机开机");
}
/// <summary>
/// 手机关机
/// </summary>
public void close()
{
console.writeline($"{this.gettype().name}手机关机");
}
}
3.游戏类
/// <summary>
/// 游戏类
/// </summary>
public class game
{
/// <summary>
/// 开始
/// </summary>
public void start()
{
console.writeline($"{this.gettype().name}游戏开始");
}
/// <summary>
/// 正在进行
/// </summary>
public void paly()
{
console.writeline($"{this.gettype().name}玩游戏");
}
/// <summary>
/// 结束
/// </summary>
public void over()
{
console.writeline($"{this.gettype().name}游戏结束");
}
}
4.代码调用
/// <summary>
/// oop 面向对象编程 object oriented programming
/// </summary>
class program
{
static void main(string[] args)
{
//实例化一个玩家
player player = new player()
{
id = 1,
name="小明"
};
//小明想玩手机，首先得需要一部手机
phone phone = new phone() {
id = 1,
name = "努比亚"
};
//小明开始玩手手机
player.payerphone(phone);
}
}
我们按照对象划分，就是所谓得万物皆对象，然后我们把对象定义好封装好，然后把对象属性和动作都归结一起，这就所谓得画格子，每个格子自成体系，内部任意改动不会影响到别人，然后每个格子之间相互交互！虽然我们使思路更加复杂化，但是以后极其容易扩展。
总的来说面向对象就是把以前按照步骤考虑得然后划为对象，然后对象之间交互组成宫嗯那个，功能与宫嗯那个之间组成系统，系统与系统之间组成平台，比如：一块块砖砌成墙，然后墙与墙之间组成房间，房间与房间之间组成一个大厦
三、面向对象的好处，特点【封装，继承，多态】
1.封装的好处
a：最主要的好处是：隔离，即是外部不用关系内部怎么实现，只要接口不变，内部可以随意扩展
b：安全 private protect等数据结构，只能通过公开方法来访问，而不能随意修改致于保证数据的安全
c：降低耦合，提高重要性，经理隐藏更多的东西
2.继承的好处：就是为了代码重用，通过继承然后子类拥有父类的一切属性和行为，但只能单继承；重载（参数不一致，跟返回没有任何关系）
3.多态：意味着有多重形式。在面向对象编程范式中，堕胎往往表现为“一个接口，多个功能”。
4.多态的表现分为以下几种
a：多态性可以是静态或者动态的，在静态多态中，函数响应是在编译时发生。在动态多态中，函数的响应是在运行时发生的。
b：接口多态
c：继承多态
下面的代码能够体现出来封装、继承、多态
/// <summary>
/// 父类
/// </summary>
public abstract class parentclass
{
public parentclass()
{
console.writeline($"(parentclass)无参构造函数");
}
public void commonmethod()
{
console.writeline($"(parentclass)父类普通方法");
}
public virtual void virturalmethod()
{
console.writeline($"(parentclass)父类virturalmethod()");
}
public virtual void virturalmethod(int id)
{
console.writeline($"(parentclass)virturalmethod(int id)");
}
public abstract void abstractmethod();
}
//子类
public class childclass : parentclass
{
/// <summary>
/// 实例化子类的时候，是先完成父类的实例化
/// </summary>
public childclass()
{
console.writeline($"(childclass)无参构造函数");
}
/// <summary>
/// new 隐藏基类方法，new 加不加一样的效果
/// </summary>
public new void commonmethod()
{
console.writeline($"(childclass)普通方法");
}
public override void virturalmethod()
{
console.writeline($"(childclass)virturalmethod");
//base.virturalmethod(); //调用的父类的方法
}
public sealed override void abstractmethod()
{
console.writeline("(childclass)子类抽象方法");
}
}
public class grandclass : childclass
{
/// <summary>
/// 可以重复覆写，如果不喜欢被重写，可以添加一个sealed
/// </summary>
//public override void abstractmethod()
//{
// throw new notimplementedexception();
//}
public override void virturalmethod()
{
base.virturalmethod(); //调用的父类的方法
}
public override void virturalmethod(int i)
{
base.virturalmethod(i); //调用的父类的方法
}
}
然后再调用的时候会出现以下结果
static void main(string[] args)
{
parentclass parentclass = new childclass();
parentclass.commonmethod(); //调用的父类的方法 普通方法由编译时决定-能够提高效率（由声明时决定）
parentclass.virturalmethod(); //调用的子类方法 虚方法由运行时决定的-多态灵活 （虚方法既可以覆写，也可以不覆写）
parentclass.abstractmethod(); //调用的子类的方法
childclass childclass = new grandclass();
//virturalmethod(int i) 里面有一句 base.virturalmethod(int i)
//为什么显示 (parentclass)virturalmethod(int id)
//原因是父类 childclass 没有重写parentclass 的 virturalmethod(int i)方法
childclass.virturalmethod(1);
console.readline();
}
四、说下抽象类和抽象接口的区别
1.抽象类和接口都不能直接被实例化。要是梨花，涉及到多态。抽象类要实例化，抽象类定义的变量必须指定一个子类变量，这个子类继承并实现了抽象类的所有抽象方法。接口要实例化，接口定义的变量必须只想一个子类变量，这个子类变量继承并实现接口的所有方法。
2.抽象要被子类继承，接口要被子类实现。
3.接口里只能对方法进行声明，抽象里既可以对方法进行声明也，又可以实现。
4.抽象类里面的抽象方法被子类实现，如果子类不能全部实现，子类必须也是抽象类。接口里面的方法必须被子类实现，如果子类不能全部实现，子类必须是抽象类
5.接口里面的方法不能具体的实现，这说明接口是设计的结果，而抽象类是重构的结果。
6.抽象类里面可以没有抽象方法，如果一个类里面有抽象方法，那么这个类一定是抽象类。
7.抽象类中的抽象方法都要被实现，所以抽象方法不能是静态的static，也不能是私有的private。
8.接口可以继承接口，甚至可以击沉多个接口；类可以实现多个接口，只能继承一个类。
9.抽象类主要用来抽象类别，接口主要用来抽象方法功能。关注事务的本质，用抽象类；关注一种操作，用接口
接口可以定义一下内容
/// <summary>
/// 接口一般以大写i开头
/// </summary>
public interface iextend
{
/// <summary>
/// 属性可以，字段不行
/// </summary>
int tag { set; get; }
/// <summary>
/// 方法
/// </summary>
void play();
//string remark = null; //不能声明
//class test { } //不能声明
//delegate void noaction(); //不能声明
/// <summary>
/// 索引器
/// </summary>
/// <param name="i"></param>
/// <returns></returns>
int this[int i]
{
get;
}
/// <summary>
/// 事件
/// </summary>
event action donothindhandler;
}
五、如何选择抽象类和接口的区别
1：抽象类必须是一个父类，然后再方法不同的时候使用抽象实现，主要是为了代码重用 is a，所以抽象类可以说成是父类+约束，而且是单继承
2：接口：仅仅是为了约束，告诉实现者一定要有某个功能 can do
所以如果需要约束，一般选择接口，因为接口可以多实现并且多继承，除非项目中有代码需要重用，这样可以选择抽象类
但是目前的大部分项目会选择基类和接口联合使用，比如有通用的属性等使用基类来创建，如果需要约束功能的话一般使用接口来约束，所以接口和抽象类可以相辅相成！