OOP特性相关

面向对象编程是以程序的数据为中心 , 函数为数据服务 ( 面向过程是以函数为中心 ) , 数据是通过间接方式包含对自身操作的引用

  例如 : 不是通知 drawRectangle()函数"使用这个形状绘制矩形" , 而是要求矩形"绘制自身" 

static 方法和成员变量，只是为了那些想独立于任何实例之外的内容，提前分配内存而准备了。例如 public static void main () ^_^

继承

    a kind of : 类B是类A的一种 , 可以继承                                                                                                //这种属于继承
    a part of : 类B是类A中的一部分 , 则不准许B继承A的功能 , 而是要用A和其他东西组合出B    //这种属于合成
        例如头这个类是由 眼 , 鼻 , 口 , 耳 组成
  判断：该使用继承还是合成？利用上传：新类可以上传给基类,则用继承,是kind of关系 ,否则是 part of关系,用合成
    多数情况还是应该考虑使用合成.
    
命名约定：

　　（1）宏定义用大写字母加下划线表示，如MAX_LENGTH；

　　（2）类名首字母大写,其他小写开头,函数用小写字母开头的单词组合而成，如setName, getName ； 不适用于构造函数

　　（3）指针变量加前缀p，如*pNode ；

　　（4）BOOL 变量加前缀b，如bFlag ；  if ( bFlag )   if(!bFlag)

　　（5）int 变量加前缀i，如iWidth ；

　　（6）float 变量加前缀f，如fWidth ；

　　（7）double 变量加前缀d，如dWidth ；

　　（8）字符串变量加前缀str，如strName ；

　　（9）枚举变量加前缀e，如eDrawMode ；

　　（10）类的成员变量加前缀m_，如m_strName, m_iWidth ；

　　对于int, float, double 型的变量，如果变量名的含义十分明显，则不加前缀，避免烦琐。如用于循环的int 型变量i,j,k ；float 型的三维坐标（x,y,z）等。

以下是使用断言的几个原则：//宏, 判断非法使用

　　（1）使用断言捕捉不应该发生的非法情况。不要混淆非法情况与错误情况之间的区别，后者是必然存在的并且是一定要作出处理的。

　　（2）使用断言对函数的参数进行确认。

　　（3）在编写函数时，要进行反复的考查，并且自问：“我打算做哪些假定？”一旦确定了的
假定，就要使用断言对假定进行检查。

　　（4）一般教科书都鼓励程序员们进行防错性的程序设计，但要记住这种编程风格会隐瞒错误。当进行防错性编程时，如果“不可能发生”的事情的确发生了，则要使用断言进行报警

面向对象的主要特征:
    1.封装性    使用者不必知晓行为实现的细节,只须用设计者提供的消息来访问该对象.
                        正式由于封装的特性,才可以实现目前大量采用的,例如使用JAVA提供的class等等.
    2.继承性    面向对象可复用的真实体现( 可复用--是这可重复使用,继承的类可以不用重写父类中的方法而直接使用)
    3.多态性    对象根据所接收的消息而做出动作,例如一个add函数,它即可以做整数的加法操作,也可以做字符串的连接操作 .    ( 面向对象中,重要的center )
              多态方法调用,能让类表现出各自所独有的特点,只要这些类都是从一个基类里派生出来的就行了.
              当你通过基类的reference调用方法的时候,这些不同就会通过行为表现出来.
              需要继承的支持,其实就是上传.
              好处:当增加新的派生类时,不用增加新的代码,直接可以使用.
              如果你可以写只用一个基类,而不是具体的派生类做参数的方法,利用后绑定,在程序运行的时候根据对象的类型来决定绑定哪个对象,进尔调用哪个对象的方法.
              在OOP的设计中,绝大多数方法都是这样,只跟基类打交道.

              构造函数会从最顶层的基类到派生类逐层调用,因为派生类只能访问他自己的成员,他看不到基类的成员(因为他们通常是private的),

               只有基类的构造函数才知道怎么样初始 化基类的成员

              上传: shape s = new Circle();

              下传：继承可以确保所有的子类类具有基类的接口，且绝对不会少。那么子类除了有父类的方法，

                          也可以有自己的额外的新方法（这些方法是基类所没有的），那么一旦向上转型，就不能调用子类中的新方法，那么能不能用一种方式调用这些新方法呢？

                           当然有了，这时候就需要向下转型. ( 危险,最好先做判断 例如: instanceof )

                          总之,向下转型时，对象只能强制转换为其本身类型或者其超类类型
                 安全：因为上传时,派生类肯定是基类,即 circle肯定是个shape ,所以是安全的,但是下传时就不一定了,可能是个circle ,也可能是个square,每个子类有自己的函数,
                             究竟是那个类型的对象只有运行时才能判断出来,如果不慎调用错误是很危险的.

多态性 小例子

------ Example Start ----------------------------------------------------------

package com.moveofgod.test;

//basic class
class Bird{
    public String strName ;
    public void call(Bird a)
    {
        strName = "bird";
        System.out.println(strName);
    }    
    public void identify()
    {
        System.out.println("This is a bird ");
        
    }
}
//chicken class
class Chicken extends Bird{
    int iPrice ;
    public void call(Bird a)
    {
        strName = "chicken";
        System.out.println(strName);
    }
    public void identify(){
        iPrice = 50 ;
        System.out.println("This is a chicken ");
        System.out.println(iPrice);
    }
    //子类中的新方法,向下转型,即下传
    public void buy()
    {
        System.out.println("You can buy the Chicken");
        
    }
}
//duck class , duck class is the new class , the basic class and chicken don't be modified ...
class Duck extends Bird{
    int iPrice ;
    public void call(Bird a)
    {
        strName = "duck";
        System.out.println(strName);
    }
    public void identify(){
        iPrice = 100 ;
        System.out.println("This is a duck ");
        System.out.println(iPrice);
    }
    //子类中的新方法,向下转型,即下传
    public void buy()
    {
        System.out.println("You can buy the Duck");
        
    }
}


public class UpCastTest {
    public static void main(String args[])
    {
        Chicken rChicken = new Chicken() ;
        Duck    rDuck = new Duck() ;
        //向上转型,上传
        Bird rBird1 = new Chicken();
        Bird rBird2 = new Duck();
        
        rBird1.call(rChicken);
        rBird1.identify();
        rBird2.call(rDuck);
        rBird2.identify();
        //向下转型,下传
        if( rBird1 instanceof Chicken ){    //由于下传危险,所以最好先判断
            Chicken chicken1 = (Chicken)rBird1 ; //向下转型,强制类型转换    
            chicken1.buy();    //此方法是chicken中特有的类,基类中没有
        }
    }
}

-------Example End -----------------------------------------------------------