从"Hello World!"到面向对象

从"Hello World!"到面向对象

作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！

最近在看Java。Java是完全面向对象的语言。通过虚拟机的运行机制，它打造了“跨平台”的理念，吸引了许多程序员加入Java阵营。近年来，Android开发为Java的流行助力不少。这里类似于一份快速的总结清单。目标读者是有一些语言基础，并且想迅速了解Java的程序员。

"Hello World!"

我们先来看一个HelloWorld.java程序:

public class HelloWorld
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}

上面的程序定义了一个类(class)HelloWorld，然后定义了该类的一个方法(method)main。main方法中有一个语句:

System.out.println("Hello World!");

它的功能是向终端输出字符串"Hello World!"。注意，Java中的语句要以;结尾 (与C/C++相同)。

使用javac来编译:

$javac HelloWorld.java

当前路径下将HelloWorld.class文件生成。

使用java命令来运行，java后面的参数为与文件同名的类名(HelloWorld)。Java会搜寻该类中的main方法，并运行。

$java HelloWorld

变量

变量(variable)在内存中占据一定的空间，并在该空间中存储某个类型的值。Java中的变量如下：

存储大小 例值 注释

byte 1byte 3 字节

int 4bytes 3 整数

short 2bytes 3 短整数

long 8bytes 3 长整数

float 4bytes 1.2 单精度浮点数

double 8bytes 1.2 双精度浮点数

char 2bytes 'a' 字符

boolean 1bit true 布尔值

在Java中，变量需要先声明(declare)才能使用。你可以在程序中的任意位置声明变量。 比如:

public class Test
{
public static void main(String[] args)
{
System.out.println("Declare in the middle:");
int a;
a = 5;
System.out.println(a);  // print an integer
}
}

在Java中，可以用//引领注释。可以在声明变量的同时给变量赋值，比如 int a = 5;

Java中有数组(array)。数组包含相同类型的多个值。我们用下面方法来声明一个整数数组:

int[] a;

注意该写法与C数组的区别。

在声明数组时，数组所需的空间并没有真正分配给数组。我们可以在声明的同时，用new来创建数组所需空间:

int[] a = new int[100];

还可以在声明的同时，给数组赋值(数组的大小也同时确定)。

int[] a = new int[] {1, 3, 5, 7, 9};

我们使用int[i]来调用数组的i下标元素。i从0开始。

其他类型的数组与整数数组相似。

表达式

表达式是变量、常量和运算符的组合，它等于一个新的值。1 + 1是常见的表达式。比如:

public class Test
{
public static void main(String[] args)
{
System.out.println("Declare in the middle:");
int a;
a = 5 + 1;
System.out.println(a);  // print an integer
}
}

数学表达式，返回一个数值

1 + 2 加法

4 - 3.4 减法

7 * 1.5 乘法

3.5 / 7 除法

7 % 2 求余数

关系表达式，返回一个boolean值

a > 4.2 大于

3.4 >= b 大于等于

1.5 < 9 小于

6 <= 1 小于等于

2 == 2 等于

2 != 2 不等于

布林表达式，返回一个boolean值

true && false and

(3 > 1) || (2 == 1) or

!true not

位运算，对整数的二进制形式逐位进行逻辑运算，返回整数

& and

| or

^ xor

~ not

5 << 3 0b101 left shift 3 bits

6 >> 1 0b110 right shift 1 bit

还有下列在C中常见的运算符，我会在用到的时候进一步解释:

m++ 变量m加1

n-- 变量n减1

condition ? x1 : x2 condition为一个boolean值。根据condition，取x1或x2的值

控制结构

Java中控制结构(control flow)的语法与C类似。它们都使用{}来表达隶属关系。

选择 (if)

if (conditon1) {

statements;

}

else if (condition2) {

statements;

}

else {

statements;

}

循环 (while)

while (condition) {

statements;

}

循环 (do... while)

do {

statements;

} while(condition); // 注意结尾的;

循环 (for)

for (initial; condition; update) {

statements;

}

在循环中，可以使用

break; // 跳出循环

continue; // 直接进入下一环

选择 (switch)

switch(expression) {

case 1:

statements;

break;

case 2:

statements;

break;

...

default:

statements;

break;

}

面向对象

“对象”是计算机抽象世界的一种方式。“面向对象”可以有多种理解方式，下面是我的理解：

1. 世界上的每一个事物都可以称为一个对象(object)，比如张三

2. 对象有一些属性。有的是数值相关的场(field)，比如身高；有的是动作相关的方法(method)，比如呼吸。

3. 拥有共同属性的对象可以归为同一类(class)，比如张三和李四都属于“人”类，张三被称为“人”类的一个实例(instance)。“人”类都拥有身高场和呼吸这个方法。

4. 类可以细分为子类(child class), 比如“男人”类和“女人”类。子类继承(inherit)父类所有的属性，比如“身高”和“呼吸”。并可能有额外的属性。比如“女人”类有生育这个方法。



类与对象

面向对象编程(OOP, object-oriented programming)利用上述概念，特别是类和继承的概念，来提高代码的可重复利用性。

定义类的语法:

class Woman [extends Human]

{

...

}

Woman为类名，Human为woman所继承的父类。我们使用extends来表达继承关系。在Java中，一个子类只能有一个父类。在类的前面，可以有额外的关键字，我们暂时不加解释。

{}中包含有类的具体定义，特别是场和方法。

我们先定义human类:

class Human
{
public void breath()
{
System.out.println("hu...hu...");
}

private int height;
}

在{}范围内，Human类定义了一个方法breath，还定义了一个变量height，也就是一个场。

方法代表了对象所能进行的动作，也就是计算机所能进行的操作。OOP中的方法对应面向过程中的函数。方法可以接受参数，并能返回值。

在breath的定义中，breath后面的()中为参数列表，所以breath()不接受参数。在breath之前的void为返回值的类型，说明breath不返回值。

现在转向方法和场前面的public和private关键字。public表示任何类的对象都可以调用该方法或场，而private表示只有该类(Human)的对象可以调用该方法或场。

现在，我们创建对象aPerson，并调用对象的方法breath:

public class Test
{
public static void main(String[] args)
{
Human aPerson = new Human();
aPerson.breath();
}

}

class Human
{
public void breath()
{
System.out.println("hu...hu...");
}

private int height;
}

我们在main方法中，使用new关键字为对象分配所需的内存。Human aPerson声明了aPerson所属于的类。

我们使用 对象.方法() 的方式来调用方法。

然而，如果我们从main中调用height场:

public class Test
{
public static void main(String[] args)
{
Human aPerson = new Human();
System.out.println(aPerson.height);
}

}

class Human
{
public void breath()
{
System.out.println("hu...hu...");
}

private int height;
}

将会有如下错误提示：

Test.java:6: height has private access in Human
System.out.println(aPerson.height);
^
1 error

这就是我们之前提到的，一个被说明为private的属性，不能被其他类调用。注意，main方法属于Test类，而不是Human类。

尽管可以把height设置为public，但Java通常将包含有数据的场设置成private，以保护数据。为了查看类的场，类应提供相关的查看方法(accessor):

public class Test
{
public static void main(String[] args)
{
Human aPerson = new Human();
System.out.println(aPerson.getHeight());
}

}

class Human
{
public void breath()
{
System.out.println("hu...hu...");
}

/**
* accessor
*/
public int getHeight()
{
return this.height;
}

private int height;
}

我们新增了getHeight方法。这个方法有一个int类型的返回值，并使用return来说明具体的返回值。注意this，它用来指代对象实例。当我们创建一个张三实例的时候，这个this就代表了张三这个对象。this.height就是指张三的height。

我们还看到了/** comments */的添加注释的方法。

然而，我们的输出是0。这是理所当然的：我们从来没有给height赋过值。由于height是private的，所以我们必须有一个public的方法来修改height。一个方式是定义一个setHeight的方法(想一下如何定义)，然后调用该方法。

另一个方式是定义一个与类同名的方法。这样的方法叫做创建方法(constructor)。当类创建实例的时候，比如main方法中new Human()时，会自动调用该方法。该方法不用声明返回值类型:

public class Test
{
public static void main(String[] args)
{
Human aPerson = new Human(175);
System.out.println(aPerson.getHeight());
}

}

class Human
{
/**
* constructor
*/
public Human(int h)
{
this.height = h;
}

public void breath()
{
System.out.println("hu...hu...");
}

/**
* accessor
*/
public int getHeight()
{
return this.height;
}

private int height;
}

在Java中，方法传递参数时，需要说明参数的类型，比如我们在Human方法中，说明h的类型为int。

在创建实例(new Human(175))的时候，需要传递相应的参数。

注意到，我们的Test类之前也有一个public关键字。在上面的程序中，我们实际上有两个类。每个程序文件中只能有一个public类。文件名必须与public类的名字相符。所以我们的文件名必须是Test.java。

总结

Java的许多语法形式与C/C++类似，但在细节和具体实现上又有不少的差别，需要小心。

Java是完全面向对象的语言。

Java不鼓励public的场。