java编程介绍_Java编程介绍

1. 立即開始 － 编写你的第1个Java程序

检查在开发环境中是否安装了 Java Development Kit (JDK)。

让我们来编写第1个Java程序。在控制台上输出“Hello，world！”，

Hello。World。

步骤1：编写代码

选择一个文本编辑器，Windows：TextPad、NotePad++。Mac OS X：jEdit、gedit。Ubuntu：gedit。

在编辑器内输入下面代码。输入完成后保存为“Hello.Java"文件。扩展名“.java"。文件名称须要与类名一致区分大写和小写。

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

步骤2：编译源代码

执行命令“javac”编译源文件"Hello.java"，编译成功后会生成二进制文件“hello.class”。在终端中执行以下命令：

// 进入Hello.java所在文件夹

javac Hello.java

在IDEs(比如Eclispe、NetBeans)中不须要显示编译文件，由于他们支持即时编译。

步骤3：执行程序

执行"java"命令。

java Hello

Hello，World！

须要注意的是“java Hello”并没有包括“.class"扩展名。

在IDEs中，源文件右键 ＝》执行... ＝》Java Application会起到相同的作用。

编程的简要说明

/* ...... */

// ... 一直到行末尾

这都是凝视的方式，凝视会被编译器忽略不会被运行，可是凝视方便读者更好的阅读和理解程序，有两种凝视的方式：

多行凝视：以/*开头。以*/结尾。能够跨越多行。

单行凝视：以//开头，直到行尾。

public class Hello { ...... }

这个单元就是类的声明方式。类用keyword“class”进行定义，{ ..... }里面是类的主题内容。keyword"public”稍后会说明。

在Java中，源文件名称须要和类名保持一致，同一时候以“.java"为文件扩展名。

public static void main(String[] args) { ......

}

这个单元是main()方法的定义，{ ...... }方法的主体中包括了编程语句。

System.out.println("Hello,

world！");

字符串是由双引號和引號之间的文本组成，上面语句执行后，会在控制台输出Hello, world。。不包含两端的引號。

2. Java术语和语法

语句: 表示着一段程序的运行以。为结尾。

块: 一个块是由一组大括号和里面的语句组成。通常被视为一个单独的单元。

我们的程序有两个块组成。一个块包括着Hello类的主体，还有一个块包括着main()方法的主体，不须要在结束括号加入分号。

凝视：多行凝视以/*卡头。以*/结尾，单行凝视以//开头直到行尾，凝视会被变编译器忽略不会被运行，可是凝视提供了解释、使用的文档说明，所以请自由的使用凝视。

空白：空格。制表符和换行符统称为空白。一个空格标记切割，其余的空白会被忽略，可是他们会帮助你和你的读者更好的理解你的程序，所以请自由的使用空格。

区分大写和小写：Java是大写和小写敏感的，ROSE、Rose、rose是不同的变量，还有文件名称也是区分大写和小写的。

3. Java程序模板

编程中你能够使用以下的模板，在你的程序中选择一个有意义的"Classname"，在main方法体中写入编程语句，不用操心其它的项和keyword。我会在适当的时候加以解释。

public class Classname{ // 选择一个有意义的类名

public static void main(String[] args){

// 这里是你的编程语句

}

}

4. 使用System.out.println()和System.out.print()输出

你能够使用 System.out.println()和System.out.print()将文本输出到控制台上：

System.out.println(aString) 输出字符串，折行。光标位于折行开头的位置。

System.out.print(aString)输出字符串，光标位于输出文本的后面。

执行以下的代码。并解释生成的输出：

public class PrintTest{ public static void main(String[] args){ System.out.println("Hello, world!"); System.out.println(); System.out.print("Hello, world!"); System.out.println("Hello,"); System.out.print(" "); System.out.print("world!"); System.out.println("Hello, world!"); }}Hello, world!Hello, world!Hello, world!Hello, world!

练习

1. 用System.out.println()打印以下的输出语句。

* * * * * * * * * * * * * * *

* * * * * * * * *

* * * * * * * * *

* * * * * * * * *

* * * * * * * * * * *

(a) (b) (c)

5. 编写一个加法的程序

public classFiveNumberSum {

public static void main(String[] args){

int number1 = 11; // 声明5个int变量来存储5个数值

int number2 = 22;

int number3 = 33;

int number4 = 44;

int number5 = 55;

int sum; // 声明1个sum变量来存储相加之和

sum = number1 + number2 + number3 + number4 + number5;

System.out.print("The sum is ");

System.out.println(sum); // 输出相加之和

}

}

The sum is 165

int

number1 = 11;

int number2 = 22;

int number3 = 33;

int number4 = 44;

int number5 = 55;

声明了5个int型变量number1、number2、number3、number4和number5。将11、22、33、44和55利用操作符"="赋给变量。你能够在一条语句中声明多个变量。用逗号切割，比如：

int number1 = 11, number2 = 22, number3 = 33, number4 = 44, number5 = 55;

int

sum;

声明一个没有初始化的int型变量。

sum = number1 + number2 + number3 + number4 + number5;

sum存储number1到number5相加之和。操作符"+"表示加法，和数学上的一样。

System.out.print("The sum is ");

System.out.println(sum);

打印输出变量sum值。sum不加双引號，否则会直接输出"sum"。

练习

用操作符"*"改动上面的程序，并计算相乘的结果.

6. 程序是什么

程序是顺序运行的指令序列。參考以下的流程图。

样例

依据圆的半径计算周长和面积并输出。

public classCircleComputation{

public static voidmain(String[] args){

// 声明变量

doubleradius, area, circumference;

final doublePI = 3.14159265;

// 初始化圆半径

radius = 1.2;

// 计算面和周长

area = radius * radius * PI;

circumference = 2.0 * radius * PI;

// 打印输出结果

System.out.print("The radius is ");

System.out.println(radius);

System.out.print("The area is ");

System.out.println(area);

System.out.print("The circumference is ");

System.out.println(circumference);

}

}The radius is 1.2The area is 4.523893416The circumference is 7.5398223600000005

double radius, area, circumference;

声明了3个double变量radius、area和circumference，double变量存储实数。

final double PI = 3.14159265;

声明一个double型变量PI并设置了初值。PI被声明为final，意味着它的值不能被改变。

radius = 1.2;

将1.2赋值给radius。

area = radius * radius * PI;

circumference = 2.0 * radius * PI;

依据圆的半径计算面积和周长。

System.out.print("The radius is ");

System.out.println(radius);

System.out.print("The area is ");

System.out.println(area);

System.out.print("The circumference is ");

System.out.println(circumference);

打印计算结果。值得注意的是main()方法体中顺序运行的语句。

练习

參考上面的样例。编敲代码：依据长度和宽度打印输出矩形的周长和面积。

參考上面的样例，编敲代码：依据半径和高度打印输出圆柱体的表面积和体积。

7. 什么是变量

计算机操纵数据。变量存储数据。之所以叫变量由于它的值能够被改变。

变量就是一块地址，存储特定类型的值，换句话说，一个变量有一个名称，数据类型和存储该类型的值。

变量有名称，比如半径，面积，年龄，高度，变量的名称是唯一的，我们能够获取(radius*radius*3.1416)和设置(adius＝1.2)变量存储的值。

int：整数比如123和－456。

double：浮点数或者实数，比如：3.1416、－55.66、7.8e9和－1.2e3.4， 有一个可选的小数点和小数部分，也能够用科学计数法表示。

String：文本比如"Hello"，"Good Moring!"。文本字符串包括在双引號里面。

变量存储特定类型的值。值得注意的是。大多数编程语言中变量都关联着类型以及该类型的值。int变量能够存储整数比如123。但不能存储实数比如12.34，也不能存储文本比如"你好"。

早期的编程语言引入类型的概念来简化数据的理解。

下图说明了3种数据类型：int，double和String。int变量存储整数，double存储实数，字符串存储文本内容。

变量使用前须要被声明。你能够使用以下的声明方式：

varType varName; // 声明变量的类型

varType varName1, varName2,...; // 声明多个同一类型的变量

varType varName = initialValue; // 声明变量的类型并赋值

varType varName1 = initialValue1, varName2 = initialValue2,... ; // 声明多个变量并分别赋值

请注意：

声明语句以分号(;)为结尾。

声明多个变量，变量间以逗号(,)分隔。

操作符＝，用来给变量赋值。

举例：

int sum; //声明1个int型变量sum。

int number1, number2; //声明2个int型变量number1，number2以分号相隔。

double average; //声明1个double型变量average。

int height = 20; //声明1个int型变量并初始化。

变量声明后，你能够利用操作符"="给变量赋值或又一次赋值，比如：

int number; //声明1个int型变量number。

number = 99; //给变量"number"分配了一个整数99。

number = 88; //给变量"number"又一次分配了一个整数88。

number = number + 1; //计算"number + 1", 将结果赋值给"number"。

int sum = 0; //声明1个"int"变量"sum"并设置初值0。

sum = sum + number; //计算"sum + number"，将结果复制给"sum"。

int num1 = 5, num2 = 6; //一条语句中声明了两个变量并设置初值, 用逗号分隔。

double radius = 1.5; //声明1个"double"变量"radius"并设置初值1.5。

int number; // 错误: 变量"number"已经声明。

sum = 55.66; // 错误: "sum"是"int"型变量不能存储实数。

sum = "Hello"; // 错误:"sum"是"int"型变量不能存储字符串。

请注意：

每一个变量仅仅能声明一次。(没有两套房子相应着一个地址吧。)

你能够在程序内的任何位置声明。

一旦声明了某个类型的变量，它仅仅能存储该类型的值。比如一个int型变量职能存储整数比如123。不能存储浮点类型比如－2.17或者文本“Hello"。

变量声明后类型不能改变。

在上面的列子中我已经展示了两种类型：int类型存储整数。double类型存储浮点数。编程时混合使用int和double时，须要特别的小心稍后我会解释。

x=x+1?

对于赋值操作符(＝)在编程和数学中我们要差别对待。数学中"x=x+1"等式是不成立的，但在编程中意为着x＋1后的值又一次赋值给x。

x+y=1

数学中是有效，编程中无效。在编程中等式右側是计算值。等式的左側是变量，也就是说优先计算等式右側，之后赋值给等式左側。有一些编程语言使用 :=为赋值操作符，避免与等号混淆。

8. 主要的算数运算

主要的算数运算符是：

运算符

含义

样例

+

加法

x + y

-

减法

x - y

*

乘法

x * y

/

除法

x / y

%

取模(求余)

x % y

++

递增(一元)

++x or x++

--

递减(一元)

--x or x--

加法、减法、乘法、除法和取模是两个操作数二元运算，而自增和自减是一个操作数一元运算。

样例

以下的程序说明了这些运算：

/**

* 算数运算符測试

*/

public classArithmeticTest {

public static void main(String[] args){

int number1 = 98; //声明了一个int型变量number1设置初值98

int number2 = 5; //声明了一个int型变量number2设置初值5

int sum, difference, product, quotient, remainder; //声明5个变量来存储计算结果

// 运行算数运算

sum = number1 + number2;

difference = number1 - number2;

product = number1 * number2;

quotient = number1 / number2;

remainder = number1 % number2;

//打印输出结果

System.out.print(number1);

System.out.print("和");

System.out.print(number2);

System.out.print("的相加, 相减, 相乘, 相除和取模的结果分别为");

System.out.print(sum);

System.out.print(", ");

System.out.print(difference);

System.out.print(", ");

System.out.print(product);

System.out.print(", ");

System.out.print(quotient);

System.out.print(", 和");

System.out.println(remainder);

++number1; //number1自增1, 相当于"number1=number1 + 1"

--number2; //number2自减2, 相当于"number2=number2 - 1"

System.out.println("number1递增后的结果为" + number1);

System.out.println("number2递增后的结果为" + number2);

quotient = number1 / number2;

System.out.println(number1 + " 和" + number2 + "新的商为" + quotient);

}

}

98和5的相加, 相减, 相乘, 相除和取模的结果分别为103, 93, 490, 19, 和3

number1递增后的结果为99

number2递增后的结果为4

99和4新的商为24

程序剖析

int

number1 = 98;

int number2 = 5;

int sum, difference, product, quotient, remainder;为了程序的须要声明了全都是int型的变量number1、number2、 sum、difference、product、quotient和remainder。

sum

= number1 + number2;

difference = number1 - number2;

product = number1 * number2;

quotient = number1 / number2;

remainder = number1 % number2;開始运行number1和number2的运算，注意下整数相除后产生的截断整数，比如98/5 → 19, 99/4 → 24和1/2

→ 0。

System.out.print(number1); // 输出变量值

System.out.print("和");

System.out.print(number2);

System.out.print("的相加, 相减, 相乘, 相除和取模的结果分别为");

......

打印运算结果并适当的加以描写叙述，输出普通文本须要加双引號。变量不须要。

System.out.println("sum"); //输出"sum"

System.out.println(sum); //输出变量sum存储的值比如98

++number1;

--number2;

举例说明了自增和自减操作。 "++"和"--"仅仅有一个操作数(一元运符)而不像"+"、"-"、"*"、"/"和"%"有两个操作数(二元运算符)，++放在操作数之前称作预增。放在操作数之后称作后增，预增和后增的终于结果都是使操作数自增1，可是两者有所差别，我会在后面说明。

System.out.println("number1递增后的结果为" + number1);

System.out.println("number2递增后的结果为" + number2);

打印自增/自减后的结果。这里我们将文本字符串和变量通过"+"操作符联合输出，在这样的情况下"+"不运行加法操作，而是字符串连接符。

练习

使用"+"操作符使用一条println()语句打印全部的输出结果。

添加一个新int型变量number3，设置初始值为77。计算和打印三个数之和。

编程中我们使用＊来表示乘法。试着计算并打印输出结果：1的31倍加上2的17倍加上3的87倍的和。

9. 累加1000个数？使用循环

如果你想计算从1～1000累加和，依照上面的样例你要在程序中写1000行代码！只是有个更简单的方式就是使用循环。要知道计算机最擅长的就是反复性的计算。

样例

来试试以下的程序：使用循环来计算从1累加到1000的和

/*

*使用循环计算从最小值到最大值的累加和*/

public class RunningNumberSum{

public static void main(String[] args){

int lowerbound = 1; //存储最小值

int upperbound = 1000; //存储最大值

int sum = 0; //声明sum变量来存储中间的累加和

int number = lowerbound;

while (number <= upperbound) {

sum = sum + number; //将number累加到sum中

++number; //開始累加下个数

}

// 打印输出结果

System.out.println("从" + lowerbound + "到" + upperbound + "的累加之和为" + sum);

}

}

从1到1000的累加之和为500500

程序剖析

int lowerbound = 1;

int upperbound = 1000;

定义两个变量分别存储最小值和最大值。

int sum = 0;

定义一个变量来存储累加之和。

int number = lowerbound;

while (number <= upperbound) {

sum = sum + number;

++number;

}

这个我们称之为循环。一个while循环的语法例如以下：

initialization-statement;

while (test) {

loop-body;

}

next-statement;

从上面的流程图我们能够看出，首先运行初始化语句，校验test。假设为真运行方法体，每运行一次方法体后都会又一次校验test，为真继续运行，直到test为假的时候退出循环。

程序循环的总次数：upperbound-lowerbound+1，循环结束后打印输出结果。

System.out.println("从" + lowerbound + "到" + upperbound + "的累加之和为" + sum);

练习

改动上面的程序计算从9到888累加和。

改动上面的程序计算从1到1000的奇数累加和。

改动上面的程序计算从1到1000每一个数都被7除的累加和。

改动上面的程序计算从1到100每一个数平方的累加和。

改动上面的程序计算从1到10的乘积。

10. 条件(推断)

假设你想计算从1到1000的奇数之和，有非常多种方法，你能够声明两个变量：sumOdd和sumEven，使用条件语句推断奇数和偶数，之后累加到对应的变量。程序例如以下：

/*

*分别计算从最小值到最大值的奇数和偶数和*/

public class OddEvenSum{

public static void main(String[] args){

int lowerbound = 1, upperbound = 1000; //最小值, 最大值

int sumOdd = 0; //奇数累加和, 初始化为0

int sumEven = 0; //偶数累加和, 初始化为0

int number = lowerbound;

while (number <= upperbound) {

if (number % 2 == 0) { //偶数

sumEven += number; //等价于sumEven = sumEven + number

} else { //奇数

sumOdd += number; //等价于sumOdd = sumOdd + number

}

++number; //下个数值

// 打印输出结果

System.out.println("奇数和从" + lowerbound + "到" + upperbound + "为" + sumOdd);

System.out.println("偶数和从" + lowerbound + "到" + upperbound + "为" + sumEven);

System.out.println("两者之差为" + (sumOdd - sumEven));

}

}

}

奇数和从1到1000为250000

偶数和从1到1000为250500

两者之差为-500

程序剖析

int lowerbound = 1, upperbound = 1000;

声明用于循环的最小值和最大值。

int sumOdd = 0;

int sumEven = 0;

声明两个变量分别来存储累加奇数和累加偶数。

if (number % 2 == 0) {

sumEven = sumEven + number;

} else {

sumOdd = sumOdd + number;

}

这是一个条件语句。能够使用这一种条件语句：if-then活if-then-else。

// if-then

if ( test ) {

true-body;

}

// if-then-else

if ( test ) {

true-body;

} else {

false-body;

}

if-then条件语句，test为真运行true-body。if-then-else语句。test为真运行true-body，test为假运行false-body。

在我们的程序中，我们使用求余操作符(%)取2的余数来校验奇偶。

比較运算符

有6比較运算符：

操作符

含义

举例

==

等于

x == y

!=

不等于

x != y

>

大于

x > y

>=

大于等于

x >= y

<

小于

x < y

<=

小于等于

x <= y

值得注意的是双等号(==)是用来比較相等；一个等号(=)是赋值操作。

并列条件

验某个数值是否在1～100之间：1<=x<=100，这里面有条件(x>=1) 与 (x<=100)，编程中你须要用( x >= 1 ) && ( x <= 100 ) 来表示。 "&&"操作符表示"与"操作。相同校验某个数值能否够被2或3整除，你能够使用 ( x % 2 ==0 ) || ( x % 3 == 0 ) 。"||"操作符表示"或"操作。

有三个逻辑运算符

操作符

含义

举例

&&

逻辑与

(x >= 1) && (x <= 100)

||

逻辑或

(x < 1) || (x > 100)

!

逻辑非

!(x == 8)

举例：

(x >= 0) && (x <= 100) //验证x是否大于等于0小于等于100。错误的使用方法：0 <= x <= 100

(x < 0) || (x > 100) //验证x是否小于0或者大于100

!((x >= 0) && (x <= 100)) //条件非

//验证闰年：闰年要被4整除但不能被100整除，或者直接被400整除

((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)

练习

编程校验1～1000之间被13或者15或者17整除。可是不能被30整除的数都有哪些。

编程计算从公元1年到公元2010年全部的闰年。

11. 浮点类型

回忆一下。在Java中变量有名称、类型和存储该类型的值。我们之前已经使用过int类型。int型变量仅仅能存储整型。比如123和-456；它不能存储一个实数，比如12.34。编程中。真正的实数比如3.1416和-55.66称之为浮点数，它们属于类型double。你能够使用浮点数(比如1.23，－4.5)或者科学计数法(比如1.2e3，－4E5.6)当中e或E表示10的指数。

样例

/*

* 摄氏温度和华氏温度之间的转换

*/

public class h{

public static void main(String[] args){

double celsius, fahrenheit;

celsius = 37.5;

fahrenheit = celsius * 9.0 / 5.0 + 32.0;

System.out.println(celsius + " degree C is " + fahrenheit + " degree F.");

fahrenheit = 100.0;

celsius = (fahrenheit - 32.0) * 5.0 / 9.0;

System.out.println(fahrenheit + " degree F is " + celsius + " degree C.");

}

}

37.5 degree C is 99.5 degree F.

100.0 degree F is 37.77777777777778 degree C.

12. 混合使用int、double和类型转换

尽管你能够使用double存储整数(比如：double count=5.0)，可是强烈建议你使用int来存储，由于int比double更高效(执行时间、存储等)。

你的程序有时会同一时候使用int和double，比如用int来存储1～1000累加之和，用double来存储平均值，混合使用类型的场景你要格外的小心。

值得注意的是：

对于算数运算('+', '-', '*', '/')，两个int会产生一个int；相同的两个double会产生一个double，比如1/2 → 0，1.0/2.0 → 0.5。

一个int和一个double会产生一个double。比如1.0/2 → 0.5。1/2.0 → 0.5。

你能够将int赋值给double变量。int类型会自己主动转换为double类型：3 → 3.0，举例：

int i = 3;

double d;

d = i; //3 → 3.0, d = 3.0

d = 88; //88 → 88.0, d = 88.0double nought = 0; //0 → 0.0; int 0和double 0.0有些细微的区别

可是不能直接将double赋值给int变量，由于小数部分可能会丢失，编译器也会发出错误的警告，举例：

double d = 5.5;

int i;

i = d; // 错误: 丢失精度

i = 6.6; // 错误: 丢失精度

类型转换操作符

将一个double赋值给int变量。你须要显示的调用类型转换操作符来截断小数，例如以下：

(new-type)expression;

举例：

double d = 5.5;

int i;

i = (int) d; //强制的将double转换为int。d变量值不受影响

i = (int) 3.1416; //i = 3

值得注意的是强制类型转换是以(int)或(double)的形式，适用于一个操作数的运算符(一元运算符)。

类型转换是一个操作，就像自增、自减，强制转换一个特定类型的数值。

(int)3.1416返回3，(double)5返回5.0。

样例

执行以下的代码并解释输出的原因

/*

*计算从最小值到最大值的累加之和, 同一时候计算平均值*/

public class TypeCastingTest{

public static void main(String[] args){

int lowerbound = 1, upperbound = 1000;

int sum = 0; // sum为"int"

double average; // average为"double"

// 计算和(使用"int")

int number = lowerbound;

while (number <= upperbound) {

sum = sum + number;

++number;

}

System.out.println("The sum from " + lowerbound + " to " + upperbound + " is " + sum);

//计算平均值(使用"double")

average = sum / (upperbound - lowerbound + 1);

System.out.println("平均值1为" + average);

average = (double)sum / (upperbound - lowerbound + 1);

System.out.println("平均值2为" + average);

average = sum / 1000;

System.out.println("平均值3为" + average);

average = sum / 1000.0;

System.out.println("平均值4为" + average);

average = (double)(sum / 1000);

System.out.println("平均值5为" + average);

}

}

从1到1000累加和为500500

平均值1为500.0

平均值2为500.5

平均值3为500.0

平均值4为500.5

平均值5为500.0

平均值1不对。由于int/int生成int(500)。最后被转换成double(500.0)。

对于平均值2，sum首先被转换成double，随后，double/int产生一个double。

对于平局值5，int/int产生int(500)。之后被强制转换成double。

练习

创建一个类HarmonicSeriesSum来计算谐波系列1 + 1/2 + 1/3 + 1/4 + .... + 1/n的总和。当中n＝1000，sum为double类型，特别注意1/2输出0，1.0/2输出0.5。试着改变的n的值1000。5000，10000，50000，100000又一次计算。

改动上面类为GeometricSeriesSum来计算几何级数1 + 1/2 + 1/4 + 1/8 + ....的总和。当中n=1000。

13. 总结

本文介绍的编程基础知识很Java适合刚開始学习的人。

要学习编程，你须要了解编程语言的语法和功能。

你要不断的练习、练习和实践来处理你遇到的各种问题。