C#面向对象思想——最基础讲解（图文混合讲解）

一、面向对象是什么？
二、面向对象有哪些内容？
我们带着这两个问题来阅读这篇文章

一、面向对象是什么？

先给大家看一张很有意思的图片，不知道是哪位大神所创，小蘇在此佩服佩服。
这张图片很清晰的讲解了面向对象编程中每一种方法的特点。当然了，这张图片就是给大家开开胃，细节咱们后面讲。

面向对象就是一种编码的思想，简称(oop思想)，这种编程思想可以让你在编码的过程中，对于类的使用变得更加的方便快捷，在不同的场合使用不同的类和对象，会让你的程序维护起来更加方便，让你的程序结构更加清晰。
总而言之一句话，学会它就对了！

如果你对于什么是类和对象都不太清楚，那么我推荐你先看看这篇文章，先了解一下类和对象的基础概念，再来阅读本文章。
点击了解基础的类和对象

二、面向对象有哪些内容？(三大特性)

1、封裝

理解：
你不需要了解这个方法里面写了什么代码，你只需要了解这个方法能够给你返回什么数据，比如：toString()方法，不知道怎么实现的，反正就是可以把值的类型转换为字符串类型。
优点：
其实就是把可以重复使用的代码，用方法装载起来，传入参数，返回参数；让代码更加容易维护，这样就不必每次访问这个属性的时候，还需要再写一次重复的代码。

直接上代码对比
现在的需求是：
一个书的类，书名和价格两个属性，当书的价格高于100，就要打七折
①首先是普通的写法

//这里顺便给大家普及一下构造函数
public Class Book
{
	//构造函数,跟类同名，不需要返回参数
	public Class Boook(string name,decimal price)
	{
		Name= name ;
		Price= price ;
	}
	public String Name
	public decimal Price 
}
static void Main()
{
	Book book1 = new Book
	book1.Name = "小白成长记";
	book1.Price = 12;
	if(book1 .Price > 100){
		book1.Price = book1.Price * 0.7;
	}
	Book book2 = new Book
	book2.Name = "大白初长成";
	book2.Price = 120;
	if(book2.Price > 100){
		book2.Price = book2.Price * 0.7;
	}
	//用了构造函数可以这么访问类
	Book book1 = new Book("小白成长记",12);
	if(book1 .Price > 100){
		book1.Price = book1.Price * 0.7;
	}
	Book book2 = new Book("大白初长成",120);
	if(book2 .Price > 100){
		book2.Price = book2.Price * 0.7;
	}
}

②封装思想的写法

public Class Book
{
	//构造函数,跟类同名，不需要返回参数
	public Class Boook(string name,decimal price)
	{
		Name= name ;
		Price= price ;
	}
	public String Name
	public decimal Price 
}
static void Main()
{
	Book book1 = new Book
	book1.Name = "小白成长记";
	book1.Price = BookRule(12);
	
	Book book2 = new Book
	book2.Name = "大白初长成";
	book2.Price = BookRule(120);
	
	//用了构造函数可以这么访问类
	Book book1 = new Book("小白成长记",BookRule(12));
	Book book2 = new Book("大白初长成",BookRule(120));
}
public static decimal BookRule(decimal price)
{
	if(price > 100){
		return price*0.7;
	}
	return price;
}

可以很清楚的看到，用了封装思想的代码，更加的简洁，维护起来更加方便。
比如说：现在不打7折，打5折。如果没有使用封装思想的话，就要修改4个地方，但是用了封装思想只需要修改那一个方法的里面就可以了。
这就是封装

2、继承

理解：
我们可以把它理解为父辈和后辈之间的一个关联，就比如说：你是你父亲的儿子，你的眼睛和鼻子很像你父亲，这就是继承，继承父亲的属性。
优点：
可传递的特点，你可以不用再写一遍父类的属性，就可以直接调用父类的属性(相当于父类可继承的属性就是你的属性)，一段代码多次使用，提高代码的复用性并减少代码的冗余。
缺点：
缺点也是比较明显，子类和父类有着很紧密的耦合性(也就是交叉性)，改了父类的属性，继承于它的所有子类也将全部被修改。

前菜已上，接下来咱们上代码

①简单的继承

public class Father  //父类
{
	public string eye {get;set;}//眼睛
	public string nose {get;set;}//鼻子
	private string ears {get;set;}//耳朵
}
public class Son:Father		//继承父类，用 ：父类类名
{
	
}
static void Main()
{
	//可以看到，我们Son类里面是没有添加任何代码的
	//但是我们可以通过new Son，访问到父类的属性
	//就是因为继承了父类，所以可以访问父类的所有属性和方法
	//但是如果父类中的方法设置为私有，子类就访问不到，比如耳朵
	//因为耳朵用了  private修饰符，变为了私有，所以子类无法访问
	Son son = new Son();
	string eye = son.eye;
	string nose = son.nose;
}

②抽象类(abstract)、接口(interface)

抽象类中就是像平常的类一样，只是多了一个可以约束派生类的功能；
抽象类约束派生类(子类)，就会添加抽象类，抽象类不能有方法体。
接口也是约束继承它的类，继承它的类必须实现接口中所有的方法和属性。

//接口，不能有具体的实现方式
public interface IPerson
{
    void Eat();
    string eye { get; set; }
}
//继承接口,必须实现接口的方法和属性，不然会报错
public class BadPeople : IPerson
{
    
    public void Eat(){
		Console.WriteLine("我要吃东西！");
	}
    public string eye { get; set; }
}
//抽象类
public abstract class People
{
    //抽象方法
    public abstract void Eat();
    //抽象类可以存在普通类的所有东西
    public void Sport(){
    	Console.WriteLine("我要运动！");
	}
    string eye { get; set; }
}
//继承抽象类
public class GoodPeople : People
{
	//必须实现抽象类中的抽象方法，并且要用override关键字
    public override void Eat() { 
		Console.WriteLine("我要吃东西！");
	}
    public string eye { get; set; }
}

3、多态

理解：
我们可以把它理解为：对于同一种事物，有不同的体现。
就比如说：你继承你父亲，但是你们的行为不同，你父亲习惯用左手，而你习惯用右手，你父亲喜欢吃猪肉，你喜欢吃羊肉。父类的方法是打7折，子类继承这个方法，但是你比它便宜，你打6折。同一个方法，不同的实现方式，这就是多态。
优点：
上面刚说了继承的优点，多态的优点就是更加优化了继承的优点，能够让子类改变父类的继承，能够让子类展现属于自己的特点。

①方法重载

方法重构最大的特点就是方法名相同，参数不同（同名不同参）
方法重写则是在有父类的情况下，并且重新的这个方法在父类中必须是虚方法，同时还要加上关键字override

public void Eat()
{
	Console.WriteLine("我要吃大米饭！");
}
public void Eat(string eatwhat)
{
	Console.WriteLine("我要吃炸鸡！");
}
static void Main()
{
	Eat();//这是调用了  吃大米饭 的方法
	string eatwhat = "eats";
	Eat(eatwhat); //这是调用了  吃炸鸡 的方法
}

②方法重写(虚方法(virtual))

如果要重写父类的方法，那么父类的方法就必须是虚方法(virtual)或者抽象方法(abstract)，子类就利用override关键字重写父类的方法

public class Father //父类
{
    public string eye { get; set; }//眼睛
    public string nose { get; set; }//鼻子
    public string ears { get; set; }//耳朵
    public virtual void Eat() 
    {
        Console.WriteLine("我要吃大米饭！");
    }
    public abstract void Drink();

}
public class Son : Father       //继承父类，用 ：父类类名
{
    //这个时候儿子不想吃饭，儿子要吃炸鸡，我们重写父类方法
    public override void Eat()
    {
        Console.WriteLine("我要吃炸鸡！");
    }
    //这个时候喝水必须重写，要实现这个方法
    public override void Drink()
    {
        Console.WriteLine("我要喝水！");
    }
}

堆和栈

①堆(大、慢、无序)

随意动态存取，自动动态分配内存，不会自动清空内存。
但是C#平台里面有一个自动清理机制(GC)
堆随意存取内存，不会自动清空内存，是无序的。

②栈(小、快、有序)

先进后出
比如：一个main方法里面有一个Get()方法，执行是main方法先压入栈底，Get()方法再压入栈底。
出栈时，后进先出，Get()方法先执行，然后出栈，清空所占内存。main方法再执行，然后出栈，清空所占内存。
栈是自动分配内存，自动清空内存，是有序的。

总结：

OOP面向对象思想一共有三个特性：封装、继承、多态。

封装：
把实现原理装起来，怎么实现的不展示出来，就像一把枪，你只知道装子弹然后扣动扳机，子弹自然就会射出。创建一个方法，直接调用即可，不用再研究怎么实现。

继承：
能够用你父亲愿意给你的所有东西。父类设置了public公有修饰访问符，派生类都可访问。

多态：
就是你继承你父亲的东西，继承你父亲的书店，但是你父亲打折打7折，但是你觉得不好，你买的时候你就打8折。就是同一个方法中，不同的实现方式。