什么是object指向？

按照上次的约定，本讲我们将要学习有关object指向的知识了。
光名字都听不懂啊。
可能听起来比较难懂，但学起来却是很简单的。
.
1.     类与实例
首先让我们从类与实例学起吧。
类好像在哪里听说过。
小尼克糊涂了吧。到目前为止咱们学的程序的开头都有“类”不是吗？
啊！是 吗～
恩。我们一直在使用类，本讲就要对类进行一下说明了。
1.1.       类
首先要说明一下所谓的类就是程序里类似设计图的东西。以设计图为基准来生成实例。
呃???
用简单易懂的车的例子来说明一下。车有设计图晓得吧。
恩。根据设计图把车制造出来。
不错。也就是说，类相当于设计图，而实例相当于制作完成的车。
从类(设计书)生成
实例（车）。
博士，在类里面具体都写些什么呀？
类里面定义了要制作实例的结构和动作。我们以车为例来学习object指向。下面先看车的类。
类 Car{
int number;//制造编号
String name;//名称
String maker;//厂家
String color;//颜色
}
车类里有制造编号、名称、厂家以及车颜色一系列的实例变量。
是的。上面的程序只是定义了车固有的数据，对其进行改良后就成为下面定义车的操作的方法。
类 Car{
int number;//制造编号
String name;//名称
String maker;//厂家
String color;//颜色
/**
* 行走
**/
void run(){
//行走处理
???
}
/**
* 转换方向
**/
void turn(int angle){
//转向处理
???
}
}
增加了run()和turn()方法。
恩。就是在车类里面多了“行走”和“转换方向”的操作。
1.2.       实例化
根据类这个设计图制作实例被称为实例化。下面就让我们来看一下使用车类来制作车实例的例子。实例化利用下面的编码进行。
类名 实例名＝new 类名;
以前学的模板的source code也用上了。
不错。对车类进行实例化按下面这样书写就可以了。
Car car = new Car();
这个车类的实例变量和方法怎么用呢？
要使用“.”。
实例名.变量名
实例名.方法名
下面的程序是访问实例的方法的sample。车的行走处理和车的转向处理就是在message panel里显示字符串的东西。
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;
/**
* 车sample programme
*/
public 类 CarApp extends MIDlet {
/**
* 开始处理
*/
protected void startApp() throws MIDletStateChangeException {
//实例化
Car car = new Car();
//设定实例变量
car.number = 6684;
car.name = "";
car.maker = "NEC";
car.color = "blue";
//调用方法
car.run();
car.turn();
}
protected void pauseApp() {}
protected void destroyApp(boolean arg0) throws MIDletStateChangeException {}
}
类 Car{
int number;//制造编号
String name;//名称
String maker;//厂家
String color;//颜色
/**
* 行走
**/
void run(){
//行走处理
System.out.println(name + " is running!");
}
/**
* 转换方向
**/
void turn(){
//转向处理
System.out.println(name + " is turning.");
}
}
运行程序，如下所示。
2.     封装
2.1.       public interface
这么说来，模板程序里面的“public”和“private”是带有类、实例变量和方法的定义部分？这是什么意思呢？
哦，问的好啊。使用“public”和“private”是为了进行封装。
封装…？
就举车类的例子来看，要生成实例就要设定制造编号、名称、厂家和车颜色。这样生成的实例也是可以更改实例变量的。
是这样的。
但是，制造编号、名称以及厂家在车子被制造出来那一刻就是确定的，之后是不能变更的或者说不容易变更的。
制造编号是用来进行车的管理的，如果途中随便更改会增添麻烦。但是，只要制造者自己确定不变更的话就没关系吧。
恩。也许吧。但是，如果programme规模大的话，就有可能涉及多人开发。这时若有人错误的随便更改制造编码，就会给别人造成大的麻烦。这样的事情也是有的。
我没有考虑到许多人一起做的情况。这么说“public”和“private”可以防止这样的事情发生是吗？
没错。使用“private”就禁止了从类外面访问实例变量或方法。与之相反，若使用“public”则可以从类外面访问实例变量和方法。使用“public”可以从类外面访问的实例变量和方法被称为public interface。车类的实例变量中只有颜色是后来可以变更的。
车可以被制造出来之后再涂颜色是吧。
2.2.       构造器
生成实例时，要使用进行初始化的构造器方法。
啊！以前用过啊。就是和类名相同名称的方法吧。
对呀对呀。如下所示进行定义。当然作为public interface，为了能从外面访问要加上“public”。
/**
* 构造器
*/
public 类名(){
//初始化处理
???
}
车类的构造器如下方式书写。
/**
* 构造器
*/
public Car(int number,String name,String maker,String color){
this.number = number;
this.name = name;
this.maker = maker;
this.color = color;
}
2.3.       accessory method
但是，对实例变量使用“private”，那不就是不能看到实例变量了？如果想要使用变量值时怎么办呢？
是啊。进行private定义后，就不能看到值了。
正因为有这样的不方便，所以就出现了解决方法，能看到值的accessory method。也就是可以访问private变量的方法。车类的accessory method如下所示。
/*******************************************
* accessory method
*******************************************/
/**
* 取得颜色
*/
public String getColor() {
return color;
}
/**
* 取得厂家
*/
public String getMaker() {
return maker;
}
/**
* 取得名称
*/
public String getName() {
return name;
}
/**
* 取得制造编号
*/
public int getNumber() {
return number;
}
/**
* 设定颜色
*/
public void setColor(String string) {
color = string;
}
真不错！使用public interface就可以看到“private”的实例变量了。
不错。下面的程序是封装的类以及使用它的sample程序。
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;
/**
* 车sample pragramme
*/
public 类 CarApp extends MIDlet {
/**
* 开始处理
*/
protected void startApp() throws MIDletStateChangeException {
//实例化
Car car = new Car(6684,"java","NEC","blue");
//调用方法
car.run();
car.turn();
//涂颜色
System.out.println(car.getName() + "‘s color is " + car.getColor());
car.setColor("Red");//涂颜色
System.out.println(car.getName() + "‘s color is " + car.getColor());
}
protected void pauseApp() {}
protected void destroyApp(boolean arg0) throws MIDletStateChangeException {}
}
类 Car{
private int number;//制造编号
private String name;//名称
private String maker;//厂家
private String color;//颜色
/**
* 构造器
*/
public Car(int number,String name,String maker,String color){
this.number = number;
this.name = name;
this.maker = maker;
this.color = color;
}
/**
* 行走
**/
public void run(){
//行走处理
System.out.println(name + " is running!");
}
/**
* 转换方向
**/
public void turn(){
//转向处理
System.out.println(name + " is turning.");
}
/*******************************************
* accessory method
*******************************************/
/**
* 取得颜色
*/
public String getColor() {
return color;
}
/**
* 取得厂家
*/
public String getMaker() {
return maker;
}
/**
* 取得名称
*/
public String getName() {
return name;
}
/**
* 取得制造编号
*/
public int getNumber() {
return number;
}
/**
* 设定颜色
*/
public void setColor(String string) {
color = string;
}
}
程序运行后结果如下。
3.     继承
下面我们就对object指向编程中重要的继承进行说明。所谓的继承，就是以某个类为基础定义新的类。
什么意思啊…
确实继承是object指向中比较难的概念之一。但是学会了就很简单了。还以车为例进行说明吧。
刚才的车类吗。
恩。这次我们来用卡车作为新例子吧。卡车也有“制造编号”“名称”“厂家”这些变量。
与车一样啊。
除此之外为了对卡车运输的物品进行管理，又加入了“负荷”这个变量。
 
程序写出来是这样的。
类 Trailer{
private int number;//制造编号
private String color;//颜色
private String maker;//厂家
private String name;//名称
private String cargo;//负荷
/**
* 构造器
*/
public Trailer(int number,String name,String maker,String color,String cargo){
this.number = number;
this.name = name;
this.maker = maker;
this.color = color;
this.cargo = cargo;
}
/**
* 行走
**/
public void run(){
//行走处理
System.out.println(name + " is running!");
}
/**
* 转换方向
**/
public void turn(){
//转向处理
System.out.println(name + " is turning.");
}
/*******************************************
* accessory method
*******************************************/
/**
* 取得颜色
*/
public String getColor() {
return color;
}
/**
* 取得厂家
*/
public String getMaker() {
return maker;
}
/**
* 取得名称
*/
public String getName() {
return name;
}
/**
* 取得制造编号
*/
public int getNumber() {
return number;
}
/**
* 设定颜色
*/
public void setColor(String string) {
color = string;
}
/**
* 取得负荷
*/
public String getCargo(){
return cargo;
}
/**
* 设定负荷
*/
public void setCargo(String cargo){
this.cargo = cargo;
}
}
卡车类和车类感觉一样啊，是因为卡车是车的一种吗？
观察的不错啊。当然，卡车是车的一种。换一种说法，也就是把卡车进行抽象化就是车。
抽选象化是指把类抽象化吗？
差不多的意思吧。这个程序里面，车类和卡车类只是source code，并没有表示“卡车抽象化之后就是车”这个概念。
恩，确实只看source code的话，并看不出来车与卡车的关系。
这就用到了“继承”。以车类为基础制作卡车类，就表示“卡车类的抽象概念即为车类”。继承车类的卡车类的source code如下所示。继承，需要使用构造器调用继承之类的构造器 method。也就是下面第九行的super()。
类 Trailer extends Car{
private String cargo;//负荷
/**
* 构造器
*/
public Trailer(int number,String name,String maker,String color,String cargo){
super(number,name,maker,color);//调用继承之类的构造器．
this.cargo = cargo;
}
/*******************************************
* accessory method
*******************************************/
/**
* 取得负荷
*/
public String getCargo(){
return cargo;
}
/**
* 積荷を設定する设定负荷
*/
public void setCargo(String cargo){
this.cargo = cargo;
}
}
呃？博士，卡车类里面只有负荷的实例变量吗？其他的实例变量和方法是不是忘了？
呵，呵，呵。事实上，继承类后，继承的类的实例变量和方法就不需要再定义就可以使用了。
呃？也就是说虽然上面的程序里面没有写，但是卡车类里也具有车类里面的制造编号和名称等变量？
不错，就是这样，很方便吧。下面就是使用了继承车类的卡车类的sample programme。
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;
/**
* 车sample programme
*/
public 类 CarApp extends MIDlet {
/**
* 开始处理
*/
protected void startApp() throws MIDletStateChangeException {
//实例化
Trailer trailer = new Trailer(6684,"java-Trailer","NEC","blue","N820");
//调用方法
trailer.run();
trailer.turn();
//改变负荷
trailer.setCargo("N800");
System.out.println(trailer.getName() + "‘s cargo is " + trailer.getCargo());
}
protected void pauseApp() {}
protected void destroyApp(boolean arg0) throws MIDletStateChangeException {}
}
类 Trailer extends Car{
private String cargo;//负荷
/**
* 构造器
*/
public Trailer(int number,String name,String maker,String color,String cargo){
super(number,name,maker,color);
this.cargo = cargo;
}
/*******************************************
* accessory method
*******************************************/
/**
* 取得负荷
*/
public String getCargo(){
return cargo;
}
/**
* 设定负荷
*/
public void setCargo(String cargo){
this.cargo = cargo;
}
}
类 Car{
private int number;//制造编号
private String name;//名称
private String maker;//厂家
private String color;//颜色
/**
* 构造者
*/
public Car(int number,String name,String maker,String color){
this.number = number;
this.name = name;
this.maker = maker;
this.color = color;
}
/**
* 行走
**/
public void run(){
//行走处理
System.out.println(name + " is running!");
}
/**
* 转换方向
**/
public void turn(){
//转向处理
System.out.println(name + " is turning.");
}
/*******************************************
* accessory method
*******************************************/
/**
* 取得颜色
*/
public String getColor() {
return color;
}
/**
* 取得厂家
*/
public String getMaker() {
return maker;
}
/**
* 取得名称
*/
public String getName() {
return name;
}
/**
* 取得制造编号
*/
public int getNumber() {
return number;
}
/**
* 设定颜色
*/
public void setColor(String string) {
color = string;
}
}
这样，谁看到source code都不会把程序弄错了。これだと、誰がソースコードを見ても間違えずにプログラムできそうですね。
呵呵。明白Object指向多重要了吧。
上面程序运行后的结果如下。
4.     下一讲
本讲讲座几乎没有涉及Java技术。觉得怎么样？
恩，对object了解一些了。但继承有点难。
本讲讲的东西是object指向最基础的东西。事实上，我们今后还要进行更深入的学习。
明白了，下一讲我们学什么呢？
下一讲我们讲动画。学习怎样使图像在画面上移动。
这可是制作游戏必须的呀。好期待…