求c#语言的学习编程之基础总结
面向对象三大特性：封装，继承，多态面向对象（Object Oriented,缩写为OO）是现代软件技术的精髓。
从早期的SmallTalk到如日中天的Java，都渗透着面向对象思想。
OO具有三大特性：封装性、继承性和多态性。
想掌握面向对象思想，就必须深入理解 其三大特性。
这里我尽量少谈概念，只用一个生活中的例子和一段代码来解释它们。
1、封装性(Encapsulation) 所谓封装，就是将某些东西包装和隐藏起来，让外界无法直接使用，只能通过某些特定的方式才能访问。
OO将万物都视为“对象”(Object)，任何对象都具有特性和行为。
我们将其特性称为“成员变量” (MemberVarible)，将其行为称之为“成员函数(Member Function)，被封装的特性只能通过特定的行为去访问。
大家都见过旅馆里常用的一种茶叶吧，就是用纸袋把茶叶包装起来再系是一根线。
用的时候只需要将其放在水杯里泡就行。
这样的好处是不会将茶叶渣和茶垢弄的满杯子都是。
好
这就是一个封装的例子。
我们喝茶的目的是享受茶叶的香冽；所以茶叶的味道(Flavour）就是茶叶所具有的最 重要特性之一；可是我们无法直接享受它的清香，因为被外面的纸袋“封装”起来了。
唯一的办法就是“泡”(Dilute），将茶袋扔在开水中泡，它的味道就出来了，融入水中。
如果我们把袋装茶叶看作一个对象的话，它提供了成员变量Flavour和成员函数Dilute 。
并且Flavour是私有(Private）的，我们不能直接把它吞进肚子去，而只能通过成员函 数Dilute才能享受Flavour。
下面用C++代码来描述这个例子： Class CTea { Private: Cstring m_Flavour; \\\/\\\/味道 Cstring m_Color; \\\/\\\/颜色 ...... \\\/\\\/等等其它属性 Private: Void CTea(); \\\/\\\/构造函数 Void ~CTea(); \\\/\\\/析构函数 Public: Cstring Dilute（）;\\\/\\\/沏茶 ...... \\\/\\\/等等其它方法 } Cstring CTea::Dilute() { \\\/\\\/怎样泡出味道来的代码 } 这就是封装。
通过将对象的某些属性声明为Private隐藏起来，只能使用其提供的特定 方法去访问。
2、继承(Inheritance) 如果只是封装，那么非面向对象语言也能部分的做到。
比如在C中，用结构(Struct)、VB中用自定义类型（Type）也能封装一些变量。
OO最有吸引力的特性是继承。
通俗的说后代具有祖先的某些特点就叫继承，当然后代还可以具有自己独有的特征。
举个例子吧，菜刀。
菜刀(cutlery）是钢(Steel)做的，钢是一种金属(Metal)，金属则是大千世界里的一种物质(Substance)。
所以菜刀的一些特性可以追溯到物质具有的一般属性。
正是因为这个道理，MFC中所有类均从CObject继承而来。
这就是继承。
菜刀直接继承了钢的特性，钢又继承了金属的特性，......下面的代码描 述了这种复杂而有独特的继承关系： Class CSubstance { Private: int m_color; void CSubstance(); void ~CSubstance(); \\\/\\\/......(我是学文科的，具体属性说不上来） } Class CMetal:Public CSubstance { void CMetal(); void ~CMetal(); \\\/\\\/...... } Class CSteel:Public CMetal { void CSteel(); void ~CSteel(); \\\/\\\/...... } Class CCutlery:Public CSteel { private: Cstring m_Blade; void CCutlery(); void ~CCutlery(); \\\/\\\/...... Public: void Cut(); } 这里，CSubstance被称为基类(Base class)，其它被称为衍生类(Derived class)。
衍生类与基类是“Is kind of”的关系。
子类与其祖先类之间复杂的函数调用关系不在本文讨论之列。
继承是一种树状的层次关系。
子类在继承祖先类的成员变量和成员函数的同时也可以 定义自己的成员变量和成员函数。
比如，Metal 除了继承了Substance的一般特性外，还具有自己的属性诸如可延展性；CCutlery在继承CSteel的特性后还具有自己的成员诸如“刀刃”（Blade)、“锋利”（Sharpness)、行为有如“切”（Cut）等。
面向对象技术是对现实生活的抽象，你可以用生活中的经验去思考程序设计的逻辑。
3、多态性(Polymorphism) 讨论多态之前先要明白什么是“虚拟”(Virtual)。
C++\\\/MFC就是用虚拟这种方式实现多态的。
为什么“虚拟”这个概念
看下边的例子： Class Cincect \\\/\\\/昆虫类 { private: int m_foot; \\\/\\\/脚的数量 ...... \\\/\\\/其它成员变量 private: void Cincect(); void ~Cincect(); public: void Bite()\\\/\\\/咬人 { ...... \\\/\\\/怎样咬人的代码，比如张开嘴啃 } } 我把Bite(咬）这个动作在基类中定义为一般化动作。
可是，不是所有昆虫咬 人的方法都一样（况且还有的根本就不咬人呢，比如蜻蜓），比如蚊子是用嘴那个 吸管叮人而蚂蚁是用嘴去夹。
从昆虫这个类别衍生出以下两个类别：Cant(蚂蚁）、Cmosquito（蚊子）。
class Cant :public Cincect \\\/\\\/蚂蚁类 { ...... } class Cmosquito :public Cincect \\\/\\\/蚊子类 { ...... } 它们都继承了Cincect的所有成员，当然也继承了Bite()这个动作。
现在就有问题了： 同样继承自昆虫，当我们使用Bite()这个动作时怎么才能区分蚂蚁和蚊子各自的独有的咬人方式呢
方法之一是用“::”符号指明具体引用的是那一个，但这样明显失去了灵活性； 另一种方法就是“虚拟”。
使用关键字virtual将Bite()声明为虚拟函数，然后在每个 衍生类中重新定义，描述它们各自的咬人方法，调用的时候也不会都一种结果啦。
于是上边的例子可以改写为： Class Cincect \\\/\\\/昆虫类 { private: int m_foot; \\\/\\\/脚的数量 ...... \\\/\\\/其它成员变量 private: void Cincect(); void ~Cincect(); public: virtual Bite(){}\\\/\\\/咬人，但我们只声明这个成员函数， \\\/\\\/却让它什么动作都不做，让衍生类自己去定 \\\/\\\/义各自的咬人方法 } class Cant :public Cincect \\\/\\\/蚂蚁类 { ...... virtual Bite(); } Cant::Bite() { ...... \\\/\\\/蚂蚁具体的咬人方式 } class Cmosquito :public Cincect \\\/\\\/蚊子类 { ...... virtual Bite(); } Cmosquito::Bite() { ...... \\\/\\\/蚊子具体的咬人方式 } 所以，虚拟的目的是只在基类中将一般化动作声明一个成员函数的原型而不做 具体定义，让衍生类自己去定义。
这就是面向对象的特征之三：多态性。
基类的同一个成员在不同的衍生类中可以具 有不同的形态，更好地抽象和描述大千世界中的诸多“对象”。
1.了解什么是多态性 2.如何定义一个虚方法 3.如何重载一个虚方法 4.如何在程序中运用多态性 面向对象程序设计中的另外一个重要概念是多态性。
在运行时，可以通过指向基类的指针，来调用实现派生类中的方法。
可以把一组对象放到一个数组中，然后调用它们的方法，在这种场合下，多态性作用就体现出来了，这些对象不必是相同类型的对象。
当然，如果它们都继承自某个类，你可以把这些派生类，都放到一个数组中。
如果这些对象都有同名方法，就可以调用每个对象的同名方法。
本节课将向你介绍如何完成这些事情。
1.清单9-1. 带有虚方法的基类：DrawingObject.cs using System; public class DrawingObject { public virtual void Draw() { Console.WriteLine(I'm just a generic drawing object.); } } 说明 清单9-1 定义了DrawingObject类。
这是个可以让其他对象继承的基类。
该类有一个名为Draw()的方法。
Draw()方法带有一个virtual修饰符，该修饰符表明：该基类的派生类可以重载该方法。
DrawingObject类的 Draw()方法完成如下事情：输出语句I'm just a generic drawing object.到控制台。
2.清单9-2. 带有重载方法的派生类：Line.cs, Circle.cs, and Square.cs using System; public class Line : DrawingObject { public override void Draw() { Console.WriteLine(I'm a Line.); } } public class Circle : DrawingObject { public override void Draw() { Console.WriteLine(I'm a Circle.); } } public class Square : DrawingObject { public override void Draw() { Console.WriteLine(I'm a Square.); } } 说明 清单9-2定义了三个类。
这三个类都派生自DrawingObject类。
每个类都有一个同名Draw()方法，这些Draw()方法中的每一个都有一个重载修饰符。
重载修饰符可让该方法在运行时重载其基类的虚方法，实现这个功能的条件是：通过基类类型的指针变量来引用该类。
3.清单9-3. 实现多态性的程序：DrawDemo.cs using System; public class DrawDemo { public static int Main(string[] args) { DrawingObject[] dObj = new DrawingObject[4]; dObj[0] = new Line(); dObj[1] = new Circle(); dObj[2] = new Square(); dObj[3] = new DrawingObject(); foreach (DrawingObject drawObj in dObj) { drawObj.Draw(); } return 0; } } 说明 清单9-3演示了多态性的实现，该程序使用了在清单 9-1 和清单9-2中定义的类。
在DrawDemo类中的Main()方法中，创建了一个数组， 数组元素是DrawingObject 类的对象。
该数组名为dObj，是由四个DrawingObject类型的对象组成。
接下来， 初始化dObj数组， 由于Line， Circle和Square类都是DrawingObject类的派生类，所以这些类可以作为dObj数组元素的类型。
如果C#没有这种功能，你得为每个类创建一个数组。
继承的性质可以让派生对象当作基类成员一样用，这样就节省了编程工作量。
一旦数组初始化之后，接着是执行foreach循环，寻找数组中的每个元素。
在每次循环中， dObj 数组的每个元素（对象）调用其Draw()方法。
多态性体现在：在运行时，各自调用每个对象的Draw()方法。
尽管dObj 数组中的引用对象类型是DrawingObject，这并不影响派生类重载DrawingObject 类的虚方法Draw()。
在dObj 数组中，通过指向DrawingObject 基类的指针来调用派生类中的重载的Draw()方法。
输出结果是： I'm a Line. I'm a Circle. I'm a Square. I'm just a generic drawing object. 在DrawDemo 程序中，调用了每个派生类的重载的Draw()方法。
最后一行中，执行的是DrawingObject类的虚方法Draw()。
这是因为运行到最后，数组的第四个元素是DrawingObject类的对象。
小结 现在对多态性有所了解之后，你可以在派生类中，实现一个重载基类虚方法的方法。
虚方法和重载的派生类方法之间的关系就体现出C#的多态性。
程序设计总结
通过本次课程设计，对这门课程更深入的理解。
是一门实践性较强的课程，为了学好这门课程，必须在掌握理论知识的同时，加强上机实践。
一个人的力量是有限的，要想把课程设计做的更好，就要学会参考一定的资料，吸取别人的经验，让自己和别人的思想有机的结合起来，得出属于你自己的灵感。
程序的编写需要有耐心，有些事情看起来很复杂，但问题需要一点一点去解决，分析问题，把问题一个一个划分，划分成小块以后就逐个去解决。
再总体解决大的问题。
这样做起来不仅有条理也使问题得到了轻松的解决。
在这个过程中，我也曾经因为实践经验的缺乏失落过，也曾经仿真成功而热情高涨。
生活就是这样，汗水预示着结果也见证着收获。
劳动是人类生存生活永恒不变的话题。
虽然这只次的极简单的课程制作，可是平心而论，也耗费了我不少的心血，这就让我不得不佩服开发技术的前辈，才意识到老一辈对我们社会的付出，为了人们的生活更美好，他们为我们社会所付出多少心血啊
对我而言，知识上的收获重要，精神上的丰收更加可喜。
让我知道了学无止境的道理。
我们每一个人永远不能满足于现有的成就，人生就像在爬山，一座山峰的后面还有更高的山峰在等着你。
挫折是一份财富，经历是一份拥有。
这次课程设计必将成为我人生旅途上一个非常美好的回忆
通过这次的课程设计我对于专业课的学习有了更加深刻的认识，以为现在学的知识用不上就加以怠慢，等到想用的时候却发现自己的学习原来是那么的不扎实。
以后努力学好每门专业课，让自己拥有更多的知识，才能解决更多的问题
速求一份程序实训感想，比如对编程的感想，心得，学会了什么之类的。
谢谢大家了
我感觉学习计算机方面的知识应该分为以下几个阶段： 如果是学习编程语言或者是相关的知识，首先要把实用教程看一遍，掌握一下基本知识和概念。
（这里所说的实用教程是指讲解真正知识点的书，而不是那些讲空泛概念的书，该学的地方却一笔代过。
）第一遍不用太注意细节，只要把大体的内容搞懂就可以，细节在以后实践中去完善。
而第一遍看的详略也要依个人而异。
也就是说如果你有了编程基础，那么再学别的语言就可以很快的看一遍，只要与以前学的语言做比较，找到不同的地方加以注意就可以了。
如果是第一次学习编程语言，那就要仔细的看一遍了。
我建议学习面向过程的语言就用C打基础，学习面向对象的就用JAVA打基础。
学习应用软件我认为第一步就不应该看书了，而是用一定的时间去摸索该软件的各个按钮都是干什么的，试着自己不参考任何资料的情况下去完成一些简单的作品。
当然，这些作品是不要求质量的。
目的是让你熟悉软件的功能。
第二步呢，学习编程就要去实践了。
试着将书后的作业都做一遍，找一些实例代码看一看，试一试，试着自己背着写出来，最好能给源代码改进。
刚开始肯定错误百出，而且还不一定能找到错误的原因，这就要你反过来再看书，找到相关的地方，再看一遍。
比如这肯定是函数调用时数组刑参的问题，那么你就把数组和函数部分都看一遍就可以了。
这一遍一定要注意细节。
不要贪多，出现问题一定要解决。
而学习应用软件的则反而要看书了。
把书大体看一遍，把上一步实践时遇到的问题都找到相关的内容重点看一下。
第三步，编程的就要在众多实践的基础上返回来看书，当然也要配以相应的练习。
这次看书就能够找到重点了，把不会的地方和遗漏的地方都补回来，就像是吃完饭以后用馒头把盘子边上的菜汤蘸了吃一样，就是清扫垃圾的工作。
学习软件的则要开始配合实例开始练习。
尽量找一些“某某软件实例100例”之类的书，照着上边的讲解一步步的做，然后体会其中的奥秘。
总的来说，学习编程的顺序是：看书（略）→实践（同时看书查疑问）→看书（详，抓重点）→不断的练习 学习软件的顺序是：熟悉软件→看书→实践（同时看书查疑问）→不断的练习 追问： 至于下厂实习呢希望采纳
