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

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

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

              上传: shape s = new Circle();

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

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

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

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

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中特有的类,基类中没有
        }
    }
}

oop目的

  1. 正式由于oop的特性( 封装，继承，多态 ) 才实现了软件开发的 可靠 , 高效 ,可复用 , 易扩展.

  2. java种继承类的内存分配问题. 首先继承的子类会分配父类的所有内存( static 除外 ) 包括 private 成员 ,

      因为当 父类中的public 方法调用自己的private成员时,(子类调用父类的public方法)

      如果没有分配内存,就不知道从哪掉,另外会分配两个指针，一个this，一个super，

      this指向子类对象内存首地址，super指向子类内,父类内存块的首地址。如图：