从"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的场。

作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！
 
 
标签: Java
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/Leo_wl/p/2958821.html