面向对象概念精解

1。面向对象，
2。抽象，
3。问题领域，
4。对象，属性，状态，方法，行为，实现
5。类，类型，
6。封装，透明，
7。继承，扩展，重载，覆盖，
8。多态，动态绑定，组合，
9。接口，
10。消息，服务，

面向对象编程的3个原则：封装(encapsulation)、继承(inheritance)、多态性(polymorephism)

封装：将代码及其处理的数据捆绑在一起的一种机制；
继承：一个对象获得另一个对象的属性的过程；
多态性：一个接口，多种方法。

 
===========================================

一。面向对象

1.面向机器：
    早期计算机中运行的程序大都是为特定的硬件系统专门设计的，称为面向机器的程序。开发这类程序的语言称为机器语言，也叫作低级语言或二进制代码语言。
    这类程序和运行速度和效率都非常高，但是可读性和可种植性及差，随着软件开发规模的扩大，这类面向机器和程序逐渐被以Fortran,C等为代表的面向过程的程序所取代。

2.面向过程：
    其中心思想是用计算机能够理解的逻辑来描述和表达待解决的问题及其具体的解决过程。数据结构、算法是面向过程问题求解的核心组成。其中数据结构利用计算机的离散逻辑来量化表达需要解决的问题，而算法则研究如何快捷、高效地组织解决问题的具体过各。
    面向过程遵循面向过程的问题求解方法。可以精确、完备地描述具体的求解过程(这里的过程通常是指操作)，但却不足以把一个包含了多个相互关联的过程的复杂系统表述清楚。

3.面向对象：
    面向对象的实质设计思想——是要让计算机逻辑来模拟现实世界的物理存在，即让计算机世界向现实世界靠拢。
    就是使我们分析、设计、实现一个系统的方法尽可能地接近我们认识一个系统的方法。很好地解决面向过程不能清楚表述的复杂系统。面向对象的问题求解包括：
    a.面向对象的分析(OOA，Object-Oriented Analysis)
    b.面向对象的设计(OOD，Object-Oriented Design)
    c.面向对象的编程(OOP，Object-Oriented Programming)，简单地说就是描述对象之间的相互作用。

    面向过程与面向对象区别：

    面向过程，先确定算法再确定数据结构；习惯于建立数据结构存放数据，并定义函数(方法)来操作数据；应用程序单一，即所有功能都包含在几个代码模块中(常常是一个代码模块)；面向过程不允许自身定义数据类型，只能使用程序中内置的数据类型。
    面向对象，先确定数据结构再确定算法；习惯于构造一个对象模型，将数据与方法组织在一起；常常要使用很多模块，每个模块都提供特定的功能，每个模块都是孤立的，甚至与其他模块完全独立。由类，对象，抽象，封装，继承，多态等特征构成，可以自定义数据类型。

    掌握OOP的难点，在于思想的转换。我们习惯于考虑解决问题的方法，而不是考虑将问题抽象成模型再解决它。


二。抽象
   
    抽象是科学研究中常用的一种思维方法，即指从特定角度出发，从研究的事物中抽取与研究主旨有关的实质性内容或我们所关注的特性，形成一个新的事物的思维过程。
   
    1.面向过程语言中的过程抽象：是将整个系统的功能划分为若干部分，强调功能完成的过程和步骤。
    2.面向对象语言中的数据抽象：是把系统中要处理的数据和这些数据的操作结合在一起，根据功能、性质、作用等因素抽象成不同的抽象数据类型。每个抽象数据类型既包含了数据，也包含了数据的操作，更为严格、合理。

    抽象是一种由具体到抽象、由复杂到简结的思维方式。
    1。从问题领域的事物到软件模型中对象的抽象；
       在建立对象模型时，分析问题领域中的实体，把它抽象为对象。(关注相关的属性与功能)
    2。从对象到类的抽象；在建立对象模型时，把具有相同属性和功能的对象抽象为类。
    3。从子类到父类的抽象；当一些类之间具有相同的属性和功能时，把这部分属性和功能抽象到一个父类中。

    在Java中，抽象有两种意思：
    ·当抽象作为动词时，就是指上述的抽象思维过程。
    ·当抽象作为形容词时，可以用来修饰类和方法。
      若一个类被abstract修饰，则表明这个类不能被实例化，为抽象类；
      若一个方法被abstract修饰，则表明这个方法没有具体的实现，为抽象方法。


三。问题领域

    问题领域，是指软件系统所模拟的真实世界中的系统。
    随着计算机技术的发展和普入，软件系统渗透到社会的各个方面，几乎可用来模拟任意一种问题领域。
    如学校、医院、商场、电影摄制组和太阳系等。
        ----《孙卫琴·Java面向对象编程》


四。对象--面向对象技术的核心所在。

    对象是对问题领域中事物的抽象！
    对象具有如下特征：
    1。万物皆为对象；
        问题领域中的实体和概念都可以抽象为对象。
    2。每个对象都是唯一的；
        对象的惟一性来自于真实世界中事物的惟一性。
    3。对象具有属性和行为；
        对象的行为包括具有的功能及具体的实现。
           在建立对象模型时，只关注对象有什么样的功能，而不需要考虑如何实现这些功能。
           对象的属性用成员变量表示，对象的行为用成员方法表示。
    4。对象具有状态；
        状态是指某个瞬间对象的各个属性的取值。
           对象的某些行为往往会改变对象自身的状态，即属性的取值。
    5。对象都属于某个类，每个对象都是某个类的实例。
        ----《孙卫琴·Java面向对象编程》

    以面向对象的观点看来，所有的面向对象的程序都是由对象来组成的，这些对象首先是自治的、自恰的，同时它们还可以互相通信、协调和配合，从而共同完成整个程序的任务和功能。
    更确切地，面向对象技术中的对象就是现实世界中某个具体的物理实体在计算机逻辑中的映射和体现。


五。类--简单地说，类是同种对象的集合与抽象。

    类是一组具有相同属性和行为的对象的抽象，或集合。
    类及类的关系构成了对象模型的主要内容。面向对象编程的主要任务就是定义对象模型中的各个类。

    类是对象的篮图或模型，对象是类的实例。实例化一个类就是为该类创建一个对象。
    同一个类的所有实例具有相同属性；
    同一个类的所有实例包括类本身的所有实例及其子类的所有实例。
    对象从类中产生出来!从类中创建出来的对象就拥有该类集成的所有属性与方法。

    对象模型中的类实际上就是一种抽象的数据类型，是由程序员自定义的数据类型。是拥有相关的属性与方法的类型。
    故可以使用类名称来声明对象变量，声明对象变量必须使用new来创建对象，然后才能使用它。
    实际上，简单数据类型如char，int等都有它自己的属性与方法。

    类是面向对象程序中最基本的程序单元。
    定义类的最终目的是要使用它，像使用系统类一样，程序也可以继承用户自定义的类或创建并使用自定义类的对象。
    创建对象的过程，就叫作实例化。

    类之间的关系:
　　    use-a：依赖关系
　　    has-a：聚合关系　　
    is-a ：继承关系--例:A类继承了B类,此时A类不仅有了B类的方法,还有其自己的方法(个性存在于共性中)。
   
   
六。封装

    封装是指隐藏对象的属性和实现细节，仅仅对外公开接口。这是面向对象的基本思想之一！

    使用封装的优点：
    1。便于使用者正确，方便地理解和使用系统，防止使用者错误修改系统的属性。
    2。有助于建立各个系统之间的松耦合关系，提高系统的独立性。
    3。提高软件的可重用性，每个系统都是一个相对独立的整体，可以在多种环境中得到重用。
    4。降低了构建大型系统的风险，即使整个系统不成功，个别的独立子系统有可能依旧是有价值。
   
    一个设计良好的系统会封装所有的实现细节，把它的接口与实现清晰地隔离开来，系统之间只通过接口
    进行通信。面向对象的编程语言主要通过访问控制机制来进行封装，这种机制能控制对象的属性和方法
    的可访问性。在Java语言中提供了以下4种访问控制级别。
    ·public：对外公开，访问级别最高；
    ·protected：只对同一个包中的类或者子类公开；
    ·默认：只对同一个包中的类公开；
    ·private：不对外公开，只能在对象内部访问，访问级别最低。

    哪些属性和方法该公开，哪些该隐藏呢？
    封装的两个大致原则：
    1。把尽可能多的东西藏起来，对外提供简捷的接口。
       系统的封装程度越高，那么它的相对独立性就越高，使用就更方便。
    2。把所有属性藏起来。

    透明：对象封装实现细节，也就意味着对象的实现细节对使用者是透明的。
    透明在此处应该理解为"看不见"。正如透明的玻璃窗让人感觉不到它的存在一个道理。
   
   
七。继承

    在父类和子类之间同时存在着继承和扩展关系。
    子类继承了父类的属性和方法，同时，子类中还可以扩展出新的属性和方法，并且还可以覆盖父类中方法的实现方式。
    覆盖是指在子类中重新实现父类中的方法。
    方法重载(Overload)：
    方法覆盖(Override)：


八。多态

    1。多态的实质：
    当系统A访问系统B的服务时，系统B可以通过多种实现方式来提供服务，而这一切对系统A是透明的。
    抽象机制，是开发人员在开发过程中使用 的机制；
    动态绑定机制，是Java虚拟机运行时提供的机制。
    抽象机制和动态绑定机制能共同提高系统之间的松耦合性。

    2。组合是一种用多个简单子系统来组装出复杂系统的有效手段。
    积塔木是个形象的比喻。

    3。动态绑定


九。接口

    在Java语言中，接口有两种意思：一是指概念性的接口；二是指程序中的接口类型。

    1。概念性的接口：
    即指系统对外提供的所有服务，在对象中表现为Public类型的方法的声明。
    既然每个对象都是服务提供者，如何对外提供服务呢？对象通过接口对外提供服务。
    在现实世界中，接口也是实体，比如电源插口，电灯的开关等。而在面向对象范畴中，接口是一个抽象
    的概念，是指系统对外提供的所有服务。系统的接口描述系统能够提供哪些服务，但是不包含服务的实
    现细节。这里的系统既可以指整个软件系统，也可以指一个子系统。对象是最小的子系统，每个对象都
    是服务提供者，因此每个对象都有接口。
    站在作用者的角度，对象中所有向使用者公开的方法的声明构成了对象的接口。使用者调用对象的公开
    方法来获得服务。使用者在获得服务时，不必关心对象到底是如何实现服务的。
    (使用者，如果系统A访问系统B的服务，那么系统A就是使用者，系统B就是服务提供者，或有时称为系统
    A是系统B的客户程序。)
    接口是提高系统之间松耦合的有力手段；接口也提高了系统的可扩展性。

    2。接口类型：（。。。。）
    指用interface关键字定义的实实在在的接口，它用于明确地描述系统对外提供的所有服务，它能够更加清晰地把系统的实现细节与接口分离。
   


十。消息，服务

    软件系统的复杂功能是由各种对象协同工作来共同完成的。
    每个对象都具有特定的功能，相对于其他对象而言，它的功能就是为其他对象提供的服务。
    一个对象为了获得另一个对象的服务，需要向那对象提出获得特定服务的请求，提出请求的过程被称为
    发送消息。对象提供的服务是由对象的方法来实现的，因此发送消息实际上也就是调用一个对象的方法。
    从使用者角度出发，整个软件系统就是一个服务提供者。操作软件系统的用户是系统的边界。
    在UML语言中，系统边界被称为角色(Actor)。在系统内部，每个子系统(对象或对象的组合)也都是服务
    提供者，它们为其他子系统提供服务，子系统之间通过发送消息来互相获得服务。一个孤立的不对外提
    供任何服务的系统是没的任何意义的。
        ----《孙卫琴·Java面向对象编程》



===========================================

面向对象编程概述

简单的说，面向对象编程（Object Oriented Programming，简称OOP）描述的是对象之间的相互作用。
面向对象编程与面向过程编程的区别：
          过程化程序设计先确定算法，再确定数据结构；面向对象编程先确定数据结构，再确定运算。
            面向过程编程的程序员，习惯于建立数据结构存放数据并定义方法（函数）来操作数据；面向对象编程的程序员则构造一个对象模型，将数据与方法组织在一起


对象  对象的状态  对象的行为

我们可以把现实世界的事物抽象成对象。
对象一般都有两个特征：状态（state）和行为（behavior）。
软件的对象概念是由现实世界对象抽象而来 。把现实世界对象的状态保存在软件对象的变量中；现实世界对象的行为通过软件对象的方法（函数）来实现。


类和对象

把相似的对象划归成一个类。
在软件中，类，就是一个模板，它定义了通用于一个特定种类的所有对象的状态（变量）和行为（方法）。
类是创建对象的模板，对象是类的实例。


面向对象程序设计

从程序设计的角度看，类是面向对象程序中最基本的程序单元。类实质上定义的是一种数据类型，这种数据类型就是对象类型 。所以我们可以使用类名称来声明对象变量。
声明对象变量之后，还不能使用对象。必须用运算符new创建对象实体之后，才能使用对象。


面向对象编程的难点

掌握面向对象的困难之处在于思路的转换。
    我们通常习惯于考虑解决问题的方法，而不是考虑将问题抽象成对象再去解决它。


一个简单的例子：

编写一个驾驶汽车的方法
面向过程的程序设计：
        编写一个方法，void drivecar();
面向对象的程序设计：
        将一辆汽车看成一个对象，将所有汽车对象的共性抽取出来，设计一个类Car，类中有一个方法void drive()，用Car这个类实例化一个具体的对象car，调用：car.drive()。


类的构造方法

构造方法的名字和类名相同，并且没有返回值。
构造方法主要用于为类的对象定义初始化状态。
我们不能直接调用构造方法，必须通过new关键字来自动调用，从而创建类的实例。
Java的类都要求有构造方法，如果没有定义构造方法，Java编译器会为我们提供一个缺省的构造方法，也就是不带参数的构造方法。


new关键字的作用

为对象分配内存空间。
引起对象构造方法的调用。
为对象返回一个引用。


缺省构造方法

当我们用缺省的构造方法初始化对象时，系统用默认值初始化对象的成员变量。
各种数据类型的默认值为：
数值型            0
boolean            false
char            ‘\0’
对象            null


方法的重载(overload)

重载构成的条件：方法的名称相同，但参数类型或参数个数不同，才能构成方法的重载。


特殊变量this

this变量代表对象本身
当类中有两个同名变量，一个属于类（类的成员变量），而另一个属于某个特定的方法（方法中的局部变量），使用this区分成员变量和局部变量。
使用this简化构造函数的调用。

关键字static

静态方法和静态变量是属于某一个类，而不属于类的对象。
静态方法和静态变量的引用直接通过类名引用。
在静态方法中不能调用非静态的方法和引用非静态的成员变量。反之，则可以。
可以用类的对象obj去调用静态的方法method()，如：obj.method()。


常量的定义

使用关键字final定义常量，例如：
    final double PI=3.1415926;
作为一种约定，在定义常量时，通常采用大写形式。
final常量可以在声明的同时赋初值，也可以在构造函数中赋初值。
为了节省内存，我们通常将常量声明为静态的（static）。

类的继承

理解继承是理解面向对象程序设计的关键。
在Java中，通过关键字extends继承一个已有的类，被继承的类称为父类（超类，基类），新的类称为子类（派生类）。
在Java中，不允许多继承。


方法的覆盖（override）

在子类中定义一个与父类同名、返回类型、参数类型均相同一个方法，称为方法的覆盖。
覆盖发生在子类与父类之间。


方法的覆盖（override）

在子类中定义一个与父类同名、返回类型、参数类型均相同一个方法，称为方法的覆盖。
覆盖发生在子类与父类之间。


特殊变量super

特殊变量super，提供了对父类的访问。
可以使用super访问父类被子类隐藏的变量或覆盖的方法。
每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。


多态性

通过覆盖父类的方法来实现，在运行时根据传递的对象引用，来调用相应的方法。


面向对象的程序设计

问题：求一个长方形的周长和面积。
以面向过程的程序设计方式思考：
     1、确定长方形周长和面积的算法。
     2、编写两个方法（函数）分别计算长方形的周长和面积。
     3、求周长的方法（函数）和求面积的方法（函数）需要两个参数，分别是长方形的长和宽。


面向过程的程序设计代码：
class Rectangle
{
    static int perimeter(int length,int width)
    {
        return 2*(length+width);
    }
    static int area(int length,int width)
    {
        return length*width;
    }
    public static void main(String[] args)
    {
        System.out.println("perimeter = “ + Rectangle.perimeter(5,4));
        System.out.println("area = “ + Rectangle.area(5,4));
    }
}


面向对象的程序设计

问题：求一个长方形的周长和面积。
以面向对象的程序设计方式思考：
     1、一个长方形可以看成一个长方形对象。
     2、一个长方形对象有两个状态（长和宽）和两个行为（求周长和求面积）。
     3、将所有长方形的共性抽取出来，设计一个长方形类。
     4、通过长方形对象的行为，就可以求出某个具体的长方形对象的周长和面积。

                 -----选自《孙鑫Java教程》