Sunspl

# re: [oop] 面向对象由浅入深  回复  更多评论   

一种语言是面向对象的究竟意味着什么呢?如果一种编程语言是真正的面向对象的语言,它必须支持以下的特点:

封装--隐藏实现细节
多态--将同一个消息发送给不同的对象并使各个对象以预定的方式对消息做出响应的能力
继承--拓展现存的类来生成专有类继承原来类的状态和行为的能力
动态绑定--在编程时不必知道对象的具体类型就能向它们发送消息的能力

让我们考察一下Java是如何支持这些功能的以及它又如何提供了附加的功能来使得从过程化的程序设计到面向对象的开发的转变过程相对容易.


Java中面向对象的特点
Java是由Sun Microsystems公司在九十年代中期发布的面向对象(OOP)的编程语言.你可以从Sun公司的网站上下载最新的Java开发包(JDK).Java是一种解释性的语言,这意味着其源程序首先被编译成中间代码的形式,然后在每次运行之前都要经过虚拟机的解释,它是彻头彻尾的面向对象的编程语言.

Java对程式员隐藏了许多传统的面向对象编程语言--比方说C++和Object Pascal--的复杂性和让人容易混淆的地方.例如,Java中没有了指针,Java会为程序员自动的清除引用类型,而且所有变量将被自动初始化成适当的缺省值.除了原始数据类型以外,Java中的所有东西都是对象,必要的时候,甚至可以为原始数据类型也提供封装机制.


对象简介
对象是代表现实生活中的实物的软件编程实体,比如说银行帐号,计算机用户,用户介面上的按钮,窗口菜单等等.对象是由它们的状态和行为定义的.例如,一个银行帐号拥有一种状态,诸如当前的收支状况,账户的所有人,允许的最小交易额,等等,而它的行为则包括提取,存入,收支平衡等.

一个对象的状态是由只有对象自己知道的变量定义的.Java把这些变量称为数据域或者成员变量.数据域对对象来说是私有的除非显式的使用关键字来定义它们的作用域,使它们对其它类可见.我们将在以后讨论变量作用域的问题.

一个对象的行为是由它上面的操作定义的.在Java中,这些操作被叫做方法.方法可以改变一个对象的状态,创建新对象,实现实用的功能等.


类
类是一个实体,它定义了一个对象的运行方式以及在对象被创建或者说实例化的时候所包含的数据.类的作用就象一个模板,一个或者多个对象可以依照它来创建.下面是使用Java面向对象的概念申明HelloWorld应用程序的例子:

public class HelloWorld
{
private String helloMsg = "Hello World!";
public static void main(String[] args)
{
HelloWorld hw = new HelloWorld();
}

public HelloWorld()
{
// 显示我们的"Hello World"消息
System.out.println(helloMsg);
}
}

上面的例子定义了一个模板,真实的HelloWorld对象可以从这个模板创建.你还会注意到从public static void main(String[] args)这一行开始的一段奇怪的代码.这一段代码定义的是一个特殊的方法main,它其实就是我们这个HelloWorld程序的入口点,上面的程序是一个典型的演示所有的Java应用程序如何定义它们的入口点.注意到即使是这个main入口点也被封装在类里面.对于这个例子,我们就是将它封装在HelloWorld类里.上面的程序展示了如何定义一个类,HelloWorld,以及其中的一个数据域,helloMsg和两个方法main和HelloWorld.HelloWorld方法是一种特殊的方法,这种方法被称做构造函数.我们将在后面的文章里讨论常规方法,构造函数和静态成员函数的细节和区别.

在Java中,所有与一个特殊的类有关的源代码都写在一个与类同名的拥有后缀名.java的文件里.Java编译器读取源文件并将它们翻译成平台无关的,二进制格式的代码,成为字节代码,然后将这些代码分类保存在与类同名的但是后缀为.class的文件里.你最终会为每一个类得到一个class文件.


编译并运行我们的例子程序
一旦你已经从Sun的Web站点上下载了JDK并在你的机器上安装了它,你就可以开始编译并运行Java程序了.要编译并运行我们的例子程序,将HelloWorld类的代码粘贴到你最喜欢的文档编辑器里,将文件保存为HelloWorld.java,然后,在命令提示符下,将当前路径改变到包含了这个文件的路径里.现在你就可以在命令行提示符下键入下面的命令来编译程序了:

Windows:
<你的JDK所在目录>\bin\javac HelloWorld.java

UNIX or Linux:
<你的JDK所在目录>/bin/javac HelloWorld.java

这个命令将在同一个目录里产生一个新的文件,叫做HelloWorld.class.要运行这个程序,请在命令提示符下键入下面的命令:

Windows:
<你的JDK所在目录>\bin\java HelloWorld

UNIX or Linux:
<你的JDK所在目录>/bin/java HelloWorld

你应该可以看到屏幕上显示Hello World!

总结
我们已经接触到了使用Java程序设计语言进行面向对象的编程的一些皮毛知识.下次,我们将剖析我们的例子程序,给它添加更多的功能,并讨论更多的有关对象,类和其它面向对象编程的基本概念以及用Java如何实现它们.

# re: [oop] 面向对象由浅入深  回复  更多评论   

对象详论
使用对象的一个关键是当你在浏览系统分析文档或者设计文档的时候如何来确定它们.因为对象一般代表人,地方或者事物,所以一个确定对象的基本的方法就是找出句子中所使用的名词.这里有一个简单的例子.在句子"一个顾客可以拥有多于一个的银行帐号",我们就确定了两个对象,客户和帐号.在句子"小猫喵喵叫"中,我们能够确定一个对象,猫.

类详论
前面,我们学习了一个类是定义了对象如何动作以及当对象创建或者说实例化的时候应该包含些什么的实体.在对动物的讨论中,我们可以说,"狗儿汪汪叫,猫喵喵叫,鸭子嘎嘎叫."确定句子中的对象我们就得到了狗,猫和鸭子.至于汪汪叫,喵喵叫,嘎嘎叫,那都是我们对象发出的行为动作.

要实现这些对象,我们需要创建三个对象分别叫Dog,Cat和Duck.要实现它们的行为,我们可以为每一个这些对象创建代表每个对象发出的声音的方法,而且我们把这个方法叫做speak或者,如果我们发挥想象力的话还可以把这个方法叫做sayHello.

在程序的上下文中为了演示这些概念,让我们修改上篇文章中的HelloWorld程序,添加这三个新对象并给它们中的每一个添加sayHello方法,如下所示:

public class HelloWorld
{
public static void main(String[] args)
{
Dog animal1 = new Dog();
Cat animal2 = new Cat();
Duck animal3 = new Duck();
animal1.sayHello();
animal2.sayHello();
animal3.sayHello();
}
}

class Dog
{
public void sayHello()
{
System.out.println("Bark");
}
}

class Cat
{
public void sayHello()
{
System.out.println("Meow");
}
}

class Duck
{
public void sayHello()
{
System.out.println("Quack");
}
}

在编译并运行了这个程序以后,输出应该如下:
Bark
Meow
Quack

看看我们的程序,我们马上就注意到了一些事情:每个对象代表了一种动物,而每个对象实现了一个相同的方法,sayHello.假设我们想要给对象更多的功能以及用来代表对象所指的动物的方法和属性.比方说,我们可以添加一个方法来确定一个动物是不是哺乳类的,或者我们添加一个方法来确定一个动物是不是肉食性的.我们可以通过给每一个对象添加这两种方法来实现或者我们也能够使用OOP的两个最强大的功能:继承和多态.

因为所有的对象都代表一个对象,所以我们将创建一个被称为"基类"或是"超类"的类,它的名字是Animal.我们然后可以让我们的对象从Animal类继承相同的特点并强制每个对象只实现与Animal类不同的功能.

Java用extends关键字指明一个类从另一个继承.让我们利用继承和多态的概念获得代码重用的好处来重建我们的程序并使得每个对象只实现与基类Animal不同的功能:

public class HelloWorld
{
public static void main(String[] args)
{
Dog animal1 = new Dog();
Cat animal2 = new Cat();
Duck animal3 = new Duck();
System.out.println("A dog says " +animal1.getHello()
+", is carnivorous: " +animal1.isCarnivorous()
+", is a mammal: " +animal1.isAMammal());

System.out.println("A cat says " +animal2.getHello()
+", is carnivorous: " +animal2.isCarnivorous()
+", is a mammal: " +animal2.isAMammal());

System.out.println("A duck says " +animal3.getHello()
+", is carnivorous: " +animal3.isCarnivorous()
+", is a mammal: " +animal3.isAMammal());
}
}

abstract class Animal
{
public boolean isAMammal()
{
return(true);
}

public boolean isCarnivorous()
{
return(true);
}

abstract public String getHello();
}

class Dog extends Animal
{
public String getHello()
{
return("Bark");
}
}

class Cat extends Animal
{
public String getHello()
{
return("Meow");
}
}

class Duck extends Animal
{
public boolean isAMammal()
{
return(false);
}

public boolean isCarnivorous()
{
return(false);
}

public String getHello()
{
return("Quack");
}
}

在编译并运行我们的程序以后,输出应该如下:
A dog says Bark, is carnivorous: true, is a mammal: true
A cat says Meow, is carnivorous: true, is a mammal: true
A duck says Quack, is carnivorous: false, is a mammal: false

看看我们的例子,你将发现我们定义了一个叫做Animal的新类,它定义了三个方法:isAMammal, isCarnivorous, 和 getHello.你一概还注意到了,我们在每个现存的类申明的前面都添加了extends Animal这个语句.这个语句告诉编译器这些对象是Animal类的子类.

因为方法isAMammal 和 isCarnivorous 都返回 true,所以Dog和Cat类用不着重新实现--即"重载"这两个方法.但是鸭子既不是哺乳动物又不是肉食性的,所以Duck类需要重载这两种方法来返回正确的值.我们所有的对象都以自己独特的方式说"hello",所以它们都需要重载getHello方法.因为每种动物说"hello"的方式都不同,所以我们在基类中将getHello方法申明为抽象的,而且我们没有给这个方法一个函数体.这就迫使Animal的每一个子类重载getHello方法并根据每一个特定动物的需要来定义它.

因为我们将getHello方法申明为虚拟的,我们就不能直接实例化Animal对象.因此,我们需要将Animal类也申明为抽象的.我们通过在Animal类定义的开始行添加abstract关键字来实现这一点.子类重载它们基类的方法的能力就是多态.多态使得子类能够使用基类的方法或是在这些方法不足的时候重载它们.这就实现了代码重用,加快了代码的实现过程,而且它还隔离和程序中的bug,使得程序的维护更容易.

总结
在本文中,我们学习了如何确定潜在的对象.我们还学习了如何使用继承和多态来加快我们的代码实现过程并隔离错误,这使得代码的维护过程更加容易.下一次,我们将展开讨论多态和继承的概念并开始我们对动态绑定的讨论.

# re: [oop] 面向对象由浅入深  回复  更多评论   

深入继承性
一些面向对象的语言提供叫做"多重继承"的特点,当一个对象需要从多于一个的基类继承行为和属性的时候这是有价值的.多重继承在有些情况下是复杂的.例如,假设我们需要定义一个基类,Animal,然后是Animal的两个子类,LandAnimal 和 WaterAnimal.现在我们想要定义一个类来代表青蛙.青蛙是两栖动物,所以我们自然会想到定义Frog类从LandAnimal和WaterAnimal类继承.这使得Frog类能够同时从LandAnimal 和WaterAnimal类继承所需的行为和属性.

初看起来这是相当简单的;但是,让我们为Animal添加一个叫做LivingEnvironment的属性,并用方法getLivingEnvironment来返回它.我们假设LandAnimal 和 WaterAnimal类都重载了这个方法来实现特殊的功能.LandAnimal将返回Land作为它的LivingEnvironment属性的值,而WaterAnimal将返回Water作为它的LivingEnvironment属性的值.现在,当我们将Frog类作为LandAnimal 和 WaterAnimal 子类实现的时候,想要得到Frog的LivingEnvironment属性值,这时将遇到一个麻烦:Frog类的getLivingEnvironment方法是返回Land值呢还是Water值?答案取决于编译器如何处理多重继承.

我在前面的文章里就已经说过,Java不支持多重继承.但它确实允许一个对象通过使用叫做"接口"的功能拥有多个特性.下面的例子显示了定义LandAnimal的接口的可能的定义代码:
public interface LandAnimal
{
public int getNumberOfLegs();
public boolean hasATail();
}

一个使用接口的类在类定义语句的开始添加implements+接口名.例如,在Java中,我们会以下面的方式定义Frog类:


public class Frog extends Animal implements LandAnimal, WaterAnimal

接口并没有什么实际的功能;相反,它的作用是联系使用者和实现了这个接口的对象.接口保证了对象实现接口定义的方法.而且,一个实现接口的对象能够在运行时被强制转换成接口类型.例如,使用上面的Frog定义,并且假设LandAnimal类定义了一个叫做getNumberOfLegs的方法而WaterAnimal定义了一个叫做hasGills的方法,那么一个Frog类的实例可以在运行时被强制转换成LandAnimal或WaterAnimal对象:


Frog aFrog = new Frog();
int legCount = ((LandAnimal)aFrog).getNumberOfLegs();
Boolean gillFlag = ((WaterAnimal)aFrog).hasGills();


注意Forg为什么能够被强制转换成一个LandAnimal对象即使实际的LandAnimal对象并没有被创建.这使得我们能够在运行时以其带有的任何"身份"调用一个对象,这就是所谓的"动态绑定"或"运行时绑定".

# re: [oop] 面向对象由浅入深  回复  更多评论   

虽然Java只支持从一个父类继承,但它使用接口的方式支持多重继承.
接口实现了多态,使得我们能够给与对象不同特性以满足不同的需要.
你可以使用多态机制让完成相似功能的不同的方法拥有相同的名字但是拥有不同的参数列表.
动态/运行时的绑定机制允许一个对象在运行时被强制转化成你所需要的对象类型,前提是这个对象实现了必需的接口或者括展了特定的父类.

下面我们将讨论通过限制对对象属性和方法的访问来强制实现对多重接口实现和父类拓展的正确使用的目的和实用性.


黑箱方法:封装
一个基本的面向对象的概念就是封装--将表示一个对象状态的数据与其它对象隔离开来.这一点是通过一个通常叫做作用域的概念来实现的.作用域指的是编程语言的一种能力,这种能力被用来实现一些限制对类或者结构体成员变量的访问的规则.大多数面向对象的语言支持作用域机制,这些机制通常是通过诸如public, protected, 和 private之类的特殊关键字来实现的.

Java提供了四种不同的作用范围:public, package, protected, 和 private.任何类,方法或者成员变量都能通过使用public, protected, 和 private关键字来显式的加以保护.任何类,方法,或者成员变量如果没有使用上面的关键字都将被隐式的给与package的作用范围.所有这些就构成了Java中命名空间的概念.


命名空间和软件包
一个命名空间可以被看成是在一个给定的上下文中一组相关的名字或是标识符.命名空间避免了拥有相同名字或标识符的实体存在于同一个上下文里.这里隐含的意思是只要实体是存在于不同的命名空间中,那么拥有相同名字或者标识符的实体就能够呆在一块儿.Java使用软件包的概念来实现命名空间和作用范围控制.

软件包是一个在统一的名字下的类和接口的集合.每一个类或者接口都必须存在于用package关键字构成的软件包申明语句定义的命名空间中.例如,下面的申明语句:

package com.mycompany.apps.HelloWorld;

它申明了一个存在于com.mycompany.apps软件包中的名叫HelloWorld的类或者接口.软件包申明总是放在包含了类或者接口定义的文件的顶部.

在java开发界,目前对软件包的命名有一个建议,就是使用公司或组织的域名(以相反的顺序),作为你的软件包的第一部分.因为域名是全球唯一的,所以使用你的域名来命名你的软件包也能使你软件包的名字全球唯一.

如果一个Java类或者接口没有包含一个软件包申明,那么它就属于"unamed package,"也就是没有名字的软件包.无名的软件包应该只用来测试程序或是代码原型等等.

# re: [oop] 面向对象由浅入深  回复  更多评论   

class Cup

{

Cup(int marker)

{

System.out.println("Cup(" + marker + ")");

}

void f(int marker)

{

System.out.println("f(" + marker + ")");

}

}



class Cups

{

static Cup c1=new Cup(1);

Cup c3=new Cup(3);

static Cup c2= new Cup(2);

Cups()

{

System.out.println("Cups()");

}

Cup c4=new Cup(4);

}



public class ExplicitStatic

{

Cups c=new Cups();

{

System.out.println("Hello");

}

public static void main(String[] args)

{

System.out.println("Inside main()");

Cups.c1.f(99);

ExplicitStatic x=new ExplicitStatic();

}

static Cups x = new Cups();

}

大家可以手动执行一下这个程序，考虑一下结果是什么，然后参照下面的答案对照一下，看看是否正确：



Cup(1)

Cup(2)

Cup(3)

Cup(4)

Cups()

Inside main()

f(99)

Cup(3)

Cup(4)

Cups()

Hello

我总结了四个初始化的要点，如下：

1、 如果有static，即静态成员定义，首先初始化static的变量，如，在类Cups中c3在c2前面，可是在输出的结果中，你可以发现，c2是在c3前执行的，这就是因为，所有的static都在第一时间被初始化。

2、 Static只初始化一次，在第二次创建类的对象的时候，就不会去执行static的语句，如，在第二次执行new Cups（）的时候，就只输出了Cup（3）和Cup（4），显然，static的两个创建对象的语句没有做。

3、 变量的初始化在方法前。如，在Cups类中，方法Cups（）在语句Cup c4=new Cup(4)之前，可是输出结果的时候，打印的Cups()却在Cup(4)之后。

4、 在含有main的类中执行顺序是先做static，然后就是main，而不是像其它类一样，除了static就按顺序做下来。如，在main函数中，如果去掉语句ExplicitStatic x=new ExplicitStatic()，则Cups c=new Cups()和System.out.println("hello")都不会执行。另外，留个小问题，如果去掉了System.out.println("hello")外的括号会怎么样呢？