论面向对象编程思想的认识

在现代编程语言中，面向对象编程思想已经成为了事实上的标准规范。常见的编程语言：如java，C++，C#等都支撑面向对象。那么什么是面向对象呢? 在很多大学编程教课书上都有标准的定义。我不想赘述。我今天试着以大白话的方式来阐述面向对象思想。
在我们生活的这个世界上，有成千上万，不计其数的对象。比如：一部美团共享单车，一个帅哥/美女等等，都是对象。这些零零总总的对象，都有其属性和相似的行为。共享单车有品牌，颜色，重量，标识编号等属性，有能载人跑的行为。帅哥/美女们有国籍，姓名，性别，身高，体重，胸围，腰围，臀围，生日等属性，有跳舞，唱歌，弹吉他，表演节目等行为。我们可以把具有相似属性、行为的对象抽象为类。类就是对象的模板，对象是类的具体实例。在上面的例子中，我们可以抽象出共享单车类，人类，这2种类。共享单车类中封装了品牌，颜色，重量，标识编号等字段，还有一个载人跑()方法。人类中封装了身份证，姓名，性别，身高，体重，生日等字段，和跳舞()，唱歌()等方法。
public ShareBike{
private String pinpai;
private String color;
private int weight;
private String bikeNo;

public ShareBike(String pinpai_,String color_,int weight_,String bikeNo_){
this.pinpai = pinpai_;
this.color = color_;
this.weight = weight_;
this.bikeNo = bikeNo_;
}

public void run(){
System.out.println(“编号为：” + this.bikeNo_ + “的单车跑起来拉！”);
}
}

public Person{
private String idCardNo;
private String name;
private int sex;
private int birthday;
private int height;
private int weight;

public Person(String idCardNo_,String name_,int sex_,int birthday_,int height_,int weight_){
this.idCardNo = idCardNo_;
this.name = name_;
this.sex = sex_;
this.birthday = birthday_;
this.height = height_;
this.weight = weight_;
}

public void dance(){
System.out.println(this.name + “在跳舞!”);
}

public void sing(){
System.out.println(this.name + “在唱歌!”);
}
}

这就是面向对象的抽象设计，也体现了封装思想。
具体使用方式，就是用类来构造出一个实例对象，然后调用它的公共接口(方法)，就可以了。
ShareBike bike_03111140 = new ShareBike(“美团”,“黄色”,30,“03111140”);
bike_03111140.run();

接下来，我再阐述一下类继承，多态等思想。我再抽象一个类出来，比如公路上跑着各种小汽车，它们都是对象，都有品牌，颜色，重量，车牌号等属性，也有载人跑行为，还有播放音乐行为等等。我封装一个Car类:
public class Car{
private String pinpai;
private String color;
private int weight;
private String carNo;

public Car(String pinpai_,String color_,int weight_,String carNo_){
this.pinpai = pinpai_;
this.color = color_;
this.weight = weight_;
this.carNo = carNo_;
}

public void run(){
System.out.println(“编号为：” + this.carNo_ + “的小汽车跑起来拉！”);
}

public void playMusic(){
System.out.println(“编号为：” + this.carNo_ + “的小汽车播放了美妙的音乐！”);
}

}

我们仔细分析Car类，ShareBike类，我们发现：它们有共通的属性（品牌，颜色，重量），公共行为(跑)。我们可以再继续把它们的共通部分抽象出一个抽象的交通工具类，Vehicle类:
public abstract Vehicle{
protected String pinpai;
protected String color;
protected int weight;
public Vehicle(String pinpai_,String color_,int weight_){
this.pinpai = pinpai_;
this.color = color_;
this.weight = weight_;
}

public abstract void run();
}

然后，我们的Car类，ShareBike类都继承于Vehicle类。
public class Car extends Vehicle{
private String carNo;
public Car(String pinpai_,String color_,int weight_,String carNo_){
super(String pinpai_,String color_,int weight_);
this.carNo = carNo_;
}
@Override
public void run(){
System.out.println(“编号为：” + this.carNo_ + “的小汽车跑起来啦！”);
}

public void playMusic(){
System.out.println(“编号为：” + this.carNo_ + “的小汽车播放了美妙的音乐！”);
}
}

public class ShareBike extends Vehicle{
private String bikeNo;
public Car(String pinpai_,String color_,int weight_,String bikeNo_){
super(String pinpai_,String color_,int weight_);
this.bikeNo = bikeNo_;
}
@Override
public void run(){
System.out.println(“编号为：” + this.bikeNo_ + “的共享单车跑起来！”);
}
}

这就是继承思想。具体使用上，如下所示:
public class TestMainClass{
public static void main(String[] args){
Vehicle vehicleObj = new Car(“丰田”,“黑色”,2000,“川A62210”);
vehicleObj.run();
vehicleObj = new ShareBike(“美团”,“黄色”,30,“03111140”);
vehicleObj.run();
}
}

vehicleObj引用刚开始指向的是一部黑色丰田小车对象，vehicleObj.run()方法调用后，表现的是小汽车跑起来。接下来vehicleObj引用指向了一部美团单车对象，vehicleObj.run()方法调用后，表现的是共享单车跑起来。针对统一的vehicleObj.run()方法调用，前后表现了不同的行为，这就是多态思想的具体体现。

以上，我们论述了面向对象的抽象，封装，继承，多态等特性，看到了面向对象编程思想的精髓:类(含抽象类)。

最后，我们再来看看面向对象编程中最抽象的概念：接口。上面论述的类，是对对象的抽象。抽象类是对类的抽象。而接口时干什么的呢？

接口是对行为的抽象，它是把分布在各个类和抽象类中的方法做一个标准规范或标准协议。我再以上面的类Car，ShareBike来论述。它们有run(),playMusic()2个方法。其中run()是Car、ShareBike共有的，playMusic是Car独有的。我们可以抽象出2个接口:

public interface Runnable{
public void run();
}
public interface PlayMusicable{
public void playMusic();
}

然后让类Car实现Runnable接口，PlayMusicable接口。让类ShareBike实现Runnable接口。
类实现了某个接口，代表它遵循改接口的行为协议/标准。
public class Car extends Vehicle implement Runnable,PlayMusicable {
private String carNo;
public Car(String pinpai_,String color_,int weight_,String carNo_){
super(String pinpai_,String color_,int weight_);
this.carNo = carNo_;
}
@Override
public void run(){
System.out.println(“编号为：” + this.carNo_ + “的小汽车跑起来啦！”);
}
@Override
public void playMusic(){
System.out.println(“编号为：” + this.carNo_ + “的小汽车播放了美妙的音乐！”);
}
}

public class ShareBike extends Vehicle implement Runnable{
private String bikeNo;
public Car(String pinpai_,String color_,int weight_,String bikeNo_){
super(String pinpai_,String color_,int weight_);
this.bikeNo = bikeNo_;
}
@Override
public void run(){
System.out.println(“编号为：” + this.bikeNo_ + “的共享单车跑起来！”);
}
}

我们客户段代码以后，就针对接口编程：
public class TestMainClass{
public static void main(String[] args){
Car carObj = new Car(“丰田”,“黑色”,2000,“川A62210”);
Runnable runObj = (Runnable)carObj；
runObj.run();
runObj = new ShareBike(“美团”,“黄色”,30,“03111140”);
runObj.run();
PlayMusicable pmObj = (PlayMusicable)carObj；
pmOjb.playMusic();
}
}

从以上代码，我们可以看到：Car类实例对象carObj可以赋值给Runnable接口变量runObj,也可赋值给PlayMusicable接口变量pmObj，调用接口各自规范的方法。采用面向接口编程（配合Spring框架使用），可以大大降低客户端代码与服务具体实现代码的耦合度，同时也大大提高服务端实现的扩展性。如上：Runnable接口有2个类都实现了，将来还可以有更多的类实现，扩展开来。同理，PlayMusicable接口目前虽然只有一个类Car类实现，以后根据具体业务，可以扩展的。比如：再抽象一个Mp3Player类，它可以实现PlayMusicable接口的。