java温故而知新（9）OOP（面向对象编程）理念

Object   Oriented   PRogramming   (面向对象的程序设计)

1、定义

2、要素

 3、要素详解

1）对象与对象引用

为便于说明，我们先定义一个简单的类：

       class Vehicle {       　　int passengers;             　　int fuelcap;       　　int mpg;                   }

有了这个模板，就可以用它来创建对象：

       Vehicle veh1 = new Vehicle();

通常把这条语句的动作称之为创建一个对象，其实，它包含了四个动作。

1）右边的“new Vehicle”，是以Vehicle类为模板，在堆空间里创建一个Vehicle类对象（也简称为Vehicle对象）。

2）末尾的()意味着，在对象创建后，立即调用Vehicle类的构造函数，对刚生成的对象进行初始化。构造函数是肯定有的。如果你没写，java会给你补上一个默认的构造函数。

3）左边的“Vehicle veh 1”创建了一个Vehicle类引用变量。所谓Vehicle类引用，就是以后可以用来指向Vehicle对象的对象引用。

4）“=”操作符使对象引用指向刚创建的那个Vehicle对象。

我们可以把这条语句拆成两部分：

Vehicle veh1;

veh1 = new Vehicle();

效果是一样的。这样写，就比较清楚了，有两个实体：一是对象引用变量，一是对象本身。

       在堆空间里创建的实体，与在数据段以及栈空间里创建的实体不同。尽管它们也是确确实实存在的实体，但是，我们看不见，也摸不着。不仅如此，

       我们仔细研究一下第二句，找找刚创建的对象叫什么名字？有人说，它叫“Vehicle”。不对，“Vehicle”是类（对象的创建模板）的名字。

       一个Vehicle类可以据此创建出无数个对象，这些对象不可能全叫“Vehicle”。

       对象连名都没有，没法直接访问它。我们只能通过对象引用来间接访问对象。

       为了形象地说明对象、引用及它们之间的关系，可以做一个或许不很妥当的比喻。对象好比是一只很大的气球，大到我们抓不住它。引用变量是一根绳， 可以用来系汽球。

       如果只执行了第一条语句，还没执行第二条，此时创建的引用变量veh1还没指向任何一个对象，它的值是null。引用变量可以指向某个对象，或者为null。

       它是一根绳，一根还没有系上任何一个汽球的绳。执行了第二句后，一只新汽球做出来了，并被系在veh1这根绳上。我们抓住这根绳，就等于抓住了那只汽球。

       再来一句：

       Vehicle veh2;

就又做了一根绳，还没系上汽球。如果再加一句：

       veh2 = veh1;

系上了。这里，发生了复制行为。但是，要说明的是，对象本身并没有被复制，被复制的只是对象引用。结果是，veh2也指向了veh1所指向的对象。两根绳系的是同一只汽球。

       如果用下句再创建一个对象：

veh2 = new Vehicle();

则引用变量veh2改指向第二个对象。

       从以上叙述再推演下去，我们可以获得以下结论：

（1）一个对象引用可以指向0个或1个对象（一根绳子可以不系汽球，也可以系一个汽球）；

（2）一个对象可以有N个引用指向它（可以有N条绳子系住一个汽球）。

       如果再来下面语句：

       veh1 = veh2;

按上面的推断，veh1也指向了第二个对象。这个没问题。问题是第一个对象呢？没有一条绳子系住它，它飞了。多数书里说，它被Java的垃圾回收机制回收了。

这不确切。正确地说，它已成为垃圾回收机制的处理对象。至于什么时候真正被回收，那要看垃圾回收机制的心情了。

       由此看来，下面的语句应该不合法吧？至少是没用的吧？

new Vehicle();

不对。它是合法的，而且可用的。譬如，如果我们仅仅为了打印而生成一个对象，就不需要用引用变量来系住它。最常见的就是打印字符串：

    System.out.println(“I am Java!”);

字符串对象“I am Java!”在打印后即被丢弃。有人把这种对象称之为临时对象。

       对象与引用的关系将持续到对象回收。

2）封装

封装从字面上来理解就是包装的意思，专业点就是信息隐藏，是指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。系统的其他对象只能通过包裹在数据外面的已经授权的操作来与这个封装的对象进行交流和交互。也就是说用户是无需知道对象内部的细节（当然也无从知道），但可以通过该对象对外的提供的接口来访问该对象。

       对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。

       使用封装有三大好处：

          1、良好的封装能够减少耦合。

          2、类内部的结构可以自由修改。

          3、可以对成员进行更精确的控制。

          4、隐藏信息，实现细节。

现在我们从程序的角度来分析封装带来的好处。如果我们不使用封装（该对象就没有setter()和getter()），那么Husband类应该这样写：

public class Husband {      public String name ;      public String sex ;      public int age ;      public Wife wife;}   

       我们应该这样来使用它：

Husband husband = new Husband();  husband.age = 30;  husband.name = "张三";  husband.sex = "男";    //貌似有点儿多余  

       但是那天如果我们需要修改Husband，例如将age修改为String类型的呢？你只有一处使用了这个类还好，如果你有几十个甚至上百个这样地方，你是不是要改到崩溃。如果使用了封装，我们完全可以不需要做任何修改，只需要稍微改变下Husband类的setAge()方法即可。

public class Husband {            /*      * 对属性的封装      * 一个人的姓名、性别、年龄、妻子都是这个人的私有属性      */      private String name ;      private String sex ;      private String age ;    /* 改成 String类型的*/      private Wife wife;            public String getAge() {          return age;      }            public void setAge(int age) {          //转换即可          this.age = String.valueOf(age);      }            /** 省略其他属性的setter、getter **/

       其他的地方依然那样引用(husband.setAge(22))保持不变。

       到了这里我们确实可以看出：封装确实可以使我们容易地修改类的内部实现，而无需修改使用了该类的客户代码。

      我们再看另一个好处：可以对成员变量进行更精确的控制。

      还是那个Husband，一般来说我们在引用这个对象的时候是不容易出错的，但是有时你迷糊了，写成了这样：

Husband husband = new Husband();  husband.age = 300;  

      也许你是因为粗心写成了，你发现了还好，如果没有发现那就麻烦大了，逼近谁见过300岁的老妖怪啊！

　　但是使用封装我们就可以避免这个问题，我们对age的访问入口做一些控制(setter)如：

public class Husband {            /*      * 对属性的封装      * 一个人的姓名、性别、年龄、妻子都是这个人的私有属性      */      private String name ;      private String sex ;      private int age ;    /* 改成 String类型的*/      private Wife wife;        public int getAge() {          return age;      }        public void setAge(int age) {          if(age > 120){              System.out.println("ERROR：error age input....");    //提示錯誤信息          }else{              this.age = age;          }                }            /** 省略其他属性的setter、getter **/        }  

      上面都是对setter方法的控制，其实通过使用封装我们也能够对对象的出口做出很好的控制。例如性别我们在数据库中一般都是已1、0方式来存储的，但是在前台我们又不能展示1、0，这里我们只需要在getter()方法里面做一些转换即可。

public String getSexName() {          if("0".equals(sex)){              sexName = "女";          }          else if("1".equals(sex)){              sexName = "男";          }          else{              sexName = "人妖???";          }          return sexName;      }  

       在使用的时候我们只需要使用sexName即可实现正确的性别显示。同理也可以用于针对不同的状态做出不同的操作。

public String getCzHTML(){          if("1".equals(zt)){              czHTML = "<a href='javascript:void(0)' onclick='qy("+id+")'>启用</a>";          } else{              czHTML = "<a href='Javascript:void(0)' onclick='jy("+id+")'>禁用</a>";          }          return czHTML;      }  

3）继承

我们可以把JAVA中的类分为以下三种：

类：使用class定义且不含有抽象方法的类。

抽象类：使用abstract class定义的类，它可以含有，也可以不含有抽象方法。

接口：使用interface定义的类。

在这三种类型之间存在下面的继承规律：

类可以继承（extends）类，可以继承（extends）抽象类，可以继承（implements）接口。

抽象类可以继承（extends）类，可以继承（extends）抽象类，可以继承（implements）接口。

接口只能继承（extends）接口。

继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。

继承是为了重用父类代码，同时为实现多态性作准备。

继承是所有OOP语言不可缺少的部分，在java中使用extends关键字来表示继承关系。当创建一个类时，总是在继承，如果没有明确指出要继承的类，就总是隐式地从根类Object进行继承。比如下面这段代码：

class Person {    public Person() {             }} class Man extends Person {    public Man() {             }}

类Man继承于Person类，这样一来的话，Person类称为父类（基类），Man类称为子类（导出类）。如果两个类存在继承关系，则子类会自动继承父类的方法和变量，在子类中可以调用父类的方法和变量。在java中，只允许单继承，也就是说 一个类最多只能显示地继承于一个父类。但是一个类却可以被多个类继承，也就是说一个类可以拥有多个子类。

　　1.子类继承父类的成员变量

　　当子类继承了某个类之后，便可以使用父类中的成员变量，但是并不是完全继承父类的所有成员变量。具体的原则如下：

　　1）能够继承父类的public和protected成员变量；不能够继承父类的private成员变量；

　　2）对于父类的包访问权限成员变量，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；

　　3）对于子类可以继承的父类成员变量，如果在子类中出现了同名称的成员变量，则会发生隐藏现象，即子类的成员变量会屏蔽掉父类的同名成员变量。如果要在子类中访问父类中同名成员变量，需要使用super关键字来进行引用。

　　2.子类继承父类的方法

　　同样地，子类也并不是完全继承父类的所有方法。

　　1）能够继承父类的public和protected成员方法；不能够继承父类的private成员方法；

　　2）对于父类的包访问权限成员方法，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；

　　3）对于子类可以继承的父类成员方法，如果在子类中出现了同名称的成员方法，则称为覆盖，即子类的成员方法会覆盖掉父类的同名成员方法。如果要在子类中访问父类中同名成员方法，需要使用super关键字来进行引用。

　　注意：隐藏和覆盖是不同的。隐藏是针对成员变量和静态方法的，而覆盖是针对普通方法的。（后面会讲到）

　　3.构造器

　　子类是不能够继承父类的构造器，但是要注意的是，如果父类的构造器都是带有参数的，则必须在子类的构造器中显示地通过super关键字调用父类的构造器并配以适当的参数列表。如果父类有无参构造器，则在子类的构造器中用super关键字调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。看下面这个例子就清楚了：

class Shape {         protected String name;         public Shape(){        name = "shape";    }         public Shape(String name) {        this.name = name;    }} class Circle extends Shape {         private double radius;         public Circle() {        radius = 0;    }         public Circle(double radius) {        this.radius = radius;    }         public Circle(double radius,String name) {        this.radius = radius;        this.name = name;    }}

这样的代码是没有问题的，如果把父类的无参构造器去掉，则下面的代码必然会出错：

改成下面这样就行了：

　　4.super

　　super主要有两种用法：

　　1）super.成员变量/super.成员方法;

　　2）super(parameter1,parameter2....)

　　第一种用法主要用来在子类中调用父类的同名成员变量或者方法；第二种主要用在子类的构造器中显示地调用父类的构造器，要注意的是，如果是用在子类构造器中，则必须是子类构造器的第一个语句。

4）多态

     方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念，原因之一是它在类的继承问题上和C++不同，后者允许多继承，这确实给其带来的非常强大的功能，但是复杂的继承关系也给C++开发者带来了更大的麻烦，为了规避风险，Java只允许单继承，派生类与基类间有IS-A的关 系（即“猫”is a “动物”）。这样做虽然保证了继承关系的简单明了，但是势必在功能上有很大的限制，所以，Java引入了多态性的概念以弥补这点的不足，此外，抽象类和接口也是解决单继承规定限制的重要手段。同时，多态也是面向对象编程的精髓所在。
     多态又分为设计时多态和运行时多态，例如重载又被称为设计时多态，而对于覆盖或继承的方法，JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。总而言之，面向对象的设计的典型特点就是继承，封装和多态，这些特点也是面向对象之所以能如此盛行的关键所在。

对于多态，可以总结它为：

    一、使用父类类型的引用指向子类的对象；该引用只能调用父类中定义的方法和变量；

    二、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）

    三、变量不能被重写（覆盖），”重写“的概念只针对方法。

重写，英文名是overriding，是指在继承情况下，子类中定义了与其基类中方法具有相同型构的新方法，就叫做子类把基类的方法重写了。这是实现多态必须的步骤。

重载，英文名是overloading，是指在同一个类中定义了一个以上具有相同名称，但是型构不同的方法。在同一个类中，是不允许定义多于一个的具有相同型构的方法的。