某一天，菜鸟看到有一个As 的效果，问大菜如何去做这种效果呢？菜鸟苦思了很久，也没能实现出来。大菜问：“你每天的工作在做什么？”菜鸟回答：“我就是想做这些效果出来”。大菜问：“唉，同志何苦呢？我问你一个问题，面向对象三个特性你知道吗？”
菜鸟回答：“封装性，继承性，还有多态性，不是很简单吗我能倒背如流”
大菜说：“既然你知道，你何苦不去深入一下呢。每天都总是忙于这些效果那些效果”
菜鸟：“这样没趣味的，我才不干”
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
一年后，菜鸟大学毕业去面试了，高高兴兴去面试。只是一当面试来，面试的人就说如果我们有消息我们就会通知你。一个星期，两个星期后，一切都平静下来，心理面还以为可以顺利面试成功，但是这一切都变得暗淡起来。
为什么这样呢？菜鸟一直没有想明白，他会很多效果，作品很多，但是面试过后心理面还觉得满意的。但事情却变成这样。他对大菜说：“我失业了，没有办法找到工作了”
大菜回答：“呵呵，继续做你的效果吧”
菜鸟郁闷说：“早知道应该听你的学好一下面向对象”
我们知道的答案是，他并不是没有注意到面向对象，只是领会不到面向对象的精髓所在，一味追求效果，导致了今天他这样面试失败。
注意：社会上工作，不和我们单枪匹马，需要团体上的工作，每一个人都是一个项目的组成部分，如果单是一味做效果，没有注意到这些的话，最后落得这样的结果。
面向对象的精髓在于它的可重用性，可维护性，可扩展性，通过封装，继承，多态把程序的耦合度降低。我们都知道一个项目总是没完没了的需求变更，一个客户没有满意之前是不会认可，需求变更带来的是压力是无法想像。辛苦的工作不会换取甜蜜的果实，这是何等残酷的事实。因此，学习的过程中应该把我的重点学会，效果自然出来了。无论走到那里，代码如何改变，我们也可以马上掌握。
常见任务：
OOP中的以下常见任务：
■ 定义类
■ 创建属性、方法以及 get 和 set 存取器（存取器方法）
■ 控制对类、属性、方法和存取器的访问
■ 创建静态属性和方法
■ 创建与枚举类似的结构
■ 定义和使用接口
■ 处理继承（包括覆盖类元素）
封装：
封装是把界面和代码分离，减少程序的耦合度，方便维护和扩展。
package {
public class GetArea {
private var R:Number;
public function GetCirCleArea(r:Number):Number {
R=r;
return 2 * Math.PI * R * R;//计算圆的面积
}
public function GetSquare(r:Number):Number {
R=r;
return R * R;
}
}
}
var myArea:GetArea=new GetArea();
trace(myArea.GetCirCleArea(2));// 25.132741228718345
trace(myArea.GetSquare(2));// 4
以上是通过写了一类的方式，实现计算面积的公式，把界面和代码分开。
提示：数学中一个很重要的模型f(x)=y; 我们只是需要把x的数据代入去就可以求出y，前提是在f下的规则实现。实现函数也一样，说白了封装想像套用公式一样，在实际应用中我们主要做的事情就是怎样使用它
继承
Father.as
package{
public class Father{
public function Say():String
{
return null;
}
}
}
Son.as
package {
public class Son extends Father {
private var Word:String="I am your son";
override public function Say():String {
return Word;
}
}
}
Daughter.as
package{
public class Daughter extends Father{
private var Word:String="I am your daughter";
override public function Say():String{
return Word;
}
}
}
var myFather:Father=new Father();
trace(myFather.Say());//null
var mySon:Son=new Son();
trace(mySon.Say());//I am your son
var myDaughter:Daughter=new Daughter();
trace(myDaughter.Say());//I am your daughter
继承是重用代码的一种方式，它允许程序员根据现有类创造出新类。先有的类通常称“基类”，新继承的类称为“子类”。继承的主要优势在于，允许重复使用现有的基类代码，不修改现在代码作前提。在As当中，主要使用extends关键字指明你所继承的父类。
从以上程序可以看出来儿子和女儿都继承了父亲说话的行为拥有了父亲说话的能力，但是这种行为各不一样。这样既保持了父类不被更改的前提，通过子类来扩展父类的得到不同的行为，像儿子说，I am your son，女儿说：I am your daughter 这两种不同的说法。其中一点，爸爸不会说话，但是儿子和女儿会说话。
多态：
世界上有一种声音称为”Cut”;
一个买猪肉的人听到了…..
一个演员听到了………..
一个正在手术台的医师听到了………………
买猪肉的人会把猪肉砍下一刀，演员会停止演戏，医师听到了会把病人某一部分剪下来
同一个声音，出现了不同的现象。这种不同的现象我们可以称为多态。
基类：Shape.as
package {
public class Shape {
public function GetArea():Number {
return NaN;
}
}
}
Circle.as
package {
public class Circle extends Shape {
private var R:Number=2;
override public function GetArea():Number {
return 2 * Math.PI * R * R;
}
}
}
Rectangle.as
package {
public class Rectangle extends Shape {
private var Width:Number=2;
private var Height:Number=5;
override public function GetArea():Number {
return Width * Height;
}
}
}
Triangle.as
package {
public class Triangle extends Shape {
private var Height:Number=2;
private var Bottom:Number=5;
override public function GetArea():Number {
return Bottom * Height / 2;
}
}
}
结果：
var Mycircle:Circle=new Circle();
trace(Mycircle.GetArea());//25.132741228718345
var Myrectangle:Rectangle=new Rectangle();
trace(Myrectangle.GetArea());//10
var MyTriangle:Triangle=new Triangle();
trace(MyTriangle.GetArea());//5
以上子类通过继承基类关系，通过覆盖了父类的方法实现了计算不同面积的不同方法。通过继承的关系实现了多态，实现的方式是允许子类继承和重新定义或“覆盖”基类中的方法
