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

  例如 : 不是通知 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 classclass 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 classclass 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指向子类内,父类内存块的首地址。如图：