学习hadoop---Java初级快速入门指导（2）

阅读本文可以带着下面问题：

1.你是否了解Java产生？

2.Java语言有什么特点？

3.Java为何健壮性更强，你对Java线程的理解什么？

4.Java的数据类型都是什么？

5.Java开发工具如何使用？

6.MyEclipse该如何创建Java程序，如何编译Java程序？

6.如果不使用开发工具，该如何编译Java程序？

阅读完本文推荐阅读：

学习hadoop----java零基础学习线路指导视频(1)

1.何为java-c？

很多java初学者都有c的基础，但对java的博大精深还有所听闻，所以笔者专门分出一章叫java-c，c的读者会觉得非常轻松，所有的知识都在c中学过。这样会在刚接触java时，有一种自然的亲近感。接着作者再献出两章叫java-c++（上），java-c++（下），对于有c++基础的同学（一般国内大学都开这课），也是个福利，这样java就可以轻松入门。

2.java好处

1）现在很多的大型网站，大数据分析等都是用java的架构搭建的，（比如Spring，Struts， hadoop）。
2）当前最火的安卓（android）手机的编程是用java，够了吧！你有足够理由爱上java。
3）网页特效Ajax，jquery，ext，当前很多互联网公司和我书中后台也用java。
4）java职位和工程师最炙手可热，薪资高。

3.java历史

1991年，Sun公司自行开发一种新的语言名为“Oak”。 1995年1月，Oak被更名为Java。这个名字来自于印度尼西亚有一个盛产咖啡的岛屿，中文名叫爪哇，意为世人端上一杯热咖啡。许多程序设计师从所钟爱的热腾腾的香浓咖啡中得到的灵感，因而热腾腾的香浓咖啡也就成为Java语言的标志。

1995年5月23日Java正式公布，以后人们对Java的兴趣和重视证明了这项技术将是主宰网络计算的未来：

4.Java语言的特点

Java到底是一种什么样的语言呢？Java是一种简单的面象对象的分布式解释的健壮的安全的结构中立的可移植的性能很优异的多线程的动态的语言。

面向对象

单从面向对象的特性来看，Java类似于c++。

分布式

Java包括一个支持HTTP和FTP等基于TCP/IP协议的子库。因此，Java应用程序可凭借URL打开并访问网络上的对象，其访问方式与访问本地文件系统几乎完全相同。为分布环境尤其是Internethuoqu获取动态内容无疑是一项非常宏伟的任务，但Java的语法特性却使我们很容易地实现这项目标。

健壮

Java致力于检查程序在编译和运行时的错误。

结构中立

另外，为了建立Java作为网络的一个整体，Java将它的程序编译成一种结构中立的中间文件格式。只要有Java运行系统的机器都能执行这种中间代码。现在，Java运行系统有Solaris2.4(SPARC),Win32系统(Windows95和Windows NT)等. Java源程序被编译成一种高层次的与机器无关的byte-code格式语言，这种语言被设计在虚拟机上运行，由机器相关的运行调试器实现执行。

安全

在Java语言里，象指针和释放内存等C++功能被删除，避免了非法内存操作。

可移植

同体系结构无关的特性使得Java应用程序可以在配备了Java解释器和运行环境的任何计算机系统上运行，这成为Java应用软件便于移植的良好基础。通过定义独立于平台的基本数据类型及其运算，Java数据得以在任何硬件平台上保持一致。

多线程

Java的多线程功能使得在一个程序里可同时执行多个小任务。线程－－有时也称小进程－－是一个大进程里分出来的小的独立的进程。因为Java实现的多线程技术，所以比C和C++更键壮。多线程带来的更大的好处是更好的交互性能和实时控制性能。

5.Java程序的编译

Java程序的编译程序是javac.exe。javac命令将Java程序编译成字节码，然后你可用java解释器java命令来解释执行这字节码。Java程序源码必须存放在后缀为.java的文件里。Java程序里的每一个类，javac都将生成与类相同名称但后缀为.class文件。编译器把.class文件放在.java文件的同一个目录里，除非你用了-d选项。

　
6.计算机语言按执行方式可分为两种类型:

编译型语言: 是指使用专门的编译器、针对特定平台（操作系统）将某种高级语言源程序一次性“翻译”成可被该平台硬件运行的机器码（包括指令和数据），并包装成该平台的操作系统所能识别和运行的格式。这一过程称为“编译”。最后生成的程序（可执行文件）可以脱离开发环境在特定平台上独立执行。
解释型语言: 是指使用专门的解释器将某种高级语言源程序逐条解释成特定平台的机器码指令并立即执行，解释一句执行一句，这类似于会场中的“同声翻译”，而不进行整体性的编译和链接处理。解释型语言相当于把编译型语言相对独立的编译和执行过程混合到一起，而且每一次执行时都要重复进行“编译”，因而执行的效率较低。且不能脱离解释器独自执行。

Java语言根据自身的实际需要采用了一种灵活的机制----编译和解释型的结合。先采用通用的Java编译器将Java源程序编译成为仍然是平台无关的中间产物----字节码文件，然后采用一种虚拟计算机技术，称为Java虚拟机（JVM----Java Virtual Machine），JVM运行特定的平台之上，再由JVM对字节码文件进行解释执行。

【轻松一刻】

【催泪的夫妻对话】一对結婚多年的夫妻，出外旅行过小年，夜宿民居。睡到半夜，先生突然紧紧抱住太太，然后说：这辈子实在太短了！太太醒了过來，听到先生这句話，感动地掉下热泪。先生接着說：我他妈都盖不到脚。。。

第二节 HelloWorld实验

1.用MyEclipse开发第一个java程序:
　　我们先看看一个具体例子，给你们有个先入为主的感觉。
步骤一：在Eclipse开发工具中我们New一个java项目, 如图2_1

图2_1

步骤二；给定一个项目名称Ch1Ex1如图2_2

图2_2

步骤三；点击finish结束（如图2_3），建立一个java项目叫Ch1Ex1

图2_3

步骤四；在你新建Ch1Ex1当中new 一个class如图2_4

图2_4

步骤五；建立一个类叫MyFirstApp，如图2_5

图2_5

步骤六；新生成的类如图2_6

图2_6

我们敲入代码如:  \ch1\MyFirstApp.java:

public class MyFirstApp
{
  public static void main(String args[ ])
  {
System.out.println("This is my first");
  }
}

截图如图2_7

图2_7

我们右击程序运行如图2_8

图2_8

运行结果如图2_9

图2_9

2.用java自带jdk开发第一个java程序:
MyFirstApp.java

　
public class MyFirstApp
{
  public static void main(String args[ ])
  {
System.out.println("This is my first Java Application!");
  }
}
编译过程是：
F:\java教程\JiaXing\ch1>javac MyFirstApp.java

这个程序的输出为：
F:\java教程\JiaXing\ch1>java MyFirstApp
This is my first Java Application!

3.用eclipse3.62开发第一个java程序:
我们书中(spring架构，ajax， android)都用eclipse3.62，所以我们还要说明在eclipse中运行helloworld! 在eclipse3.62中：
new/project/Java Project.
右击项目：new Class
(注意写完程序以后一定要存一下，有一次没存，怎么都运行不出来)

【轻松一刻】
昨天我发现楼下小摊有5块钱一个的高仿iPhone5S模型，于是买了一个然后在一个人多的广场河边假装打电话:"给劳资滚，我永远不会原谅你的，分手吧，.......！”然后我潇洒的把手机模型扔到了河里，拿出一根烟，故作忧郁的在那里摆了个销魂的姿势站着，旁边好多妹子用那花痴的表情看着我。当我正装备得瑟一下时！一个小盆友上来拍了拍我的肩膀，大声的对我说:"哥哥，你的手机浮上来了..

第三节 Java-C语法

1.序

很多java初学者都有c的基础，所以笔者专门分出一节叫java-c，c的读者会觉得非常轻松，所有的知识都在c中学过。

2.JAVA的注释

//注释内容所有从//到行末的字符将被忽略
/* 注释内容简介*/ 所有/* 和 */中的字符将被忽略，这些注释能扩展到多行
/** 注释内容简介*/ 所有在/** 和 */中的字符将被忽略，它们将被javadoc工具用于建立自动文档。

3.变量
　　你可以在程序中使用变量来容纳数据。这一小节将数据类型、怎样初始化变量以及怎样在代码块中引用变量。实际上，对象是存储它的状态在变量中的。它的具体定义为：变量是用标识符命名的数据项。
　　你必须清楚地为你想在程序中使用地每一个变量提供一个名字和类型。这个变量的名字必须是一个合法的标识符：以字母开头的一串Unicode字符。你可以使用变量名来引用变量包含的数据。这个变量的类型决定了什么类型的数值可以容纳以及什么的操作可以对它进行操作。为了得到一个变量、类型和名字，你必须编写变量声明，如下：
type name
int a;
除了名字和类型你还要给变量一个作用域。变量的作用域是由变量声明位置决定的。

4.数据类型
　　每一个变量必须有一个数据类型。一个变量的数据类型决定了变量能容纳的数值和操作符。整型只能容纳整型数（可以是正数也可以是负数）。你可以完成算术操作，比如，整型变量的加法等等。
　　例如，一个整型数值是一个32位数据。
　　下面表格所有的JAVA支持的所有原始数据类型，还给出了它们的大小和格式以及简短的描述。

关键字	描述	大小/格式
整型
boolean	布尔	1位
byte	字节长度整型	8位
Short	短整型	16位
int	整型	32位
long	长整型	64位
实数
Float	单精度浮点型	32位
Double	双精度浮点型	64位
其它类型
Char	单个字符	16位(it is alleged that if it reads english character, it is smart enough to read only one byte. if it is chinese letter, it read two bytes. )

　　你可以在你的代码中直接为原始变量设置数值。比如，如果你需要为一个整型变量设置为4，你可以编写以下代码：
int anInt = 4;
数字4就是一个整型数值。下面是各种原始数值举例：

数值	类型
178	Int
8864L	Long
37.266	Double(mark：based on weiqiu's ppt,1.23 is double instead of float)
37.266D	Double
87.363F	float
' c '	char

十进制       八进制       十六进制
0             0             0x0
4             04             0X4
631          0771          0x3F1
带有小数的十进制数，用标准小数点或科学记数法表示。
如： 3.1415, 0.1, .3, 6.022e23, 2.997E8, 1.602e-19

单精度以32位存放，双精度以64位存放。
单精度 f/F后缀、双精度 d/D后缀表示。
如：3.1415f, 6.022e23D, 2.98F, 1.602e-19d

字符型常量包含在单引号‘’中的字符；不可显示或存在意义冲突的字符用 \ 来表示。
字符串是双引号引起的字符的集合。

换行             NL(LF)    \n
水平制表符       HT       \t
退格符          BS       \b
回车符          CR       \r
Java语言中还允许使用转义字符‘\’来将其后的字符转变为其它的含义，例如，如果需要在java中使用一个绝对路径：c:\tsinghua\java，如果直接在程序中写String path = “c:\tsinghua\java”，则不会得到你期望的结果，因为java将“\”当成转义符了，所以，这时候应该这样来写：
String path = “c:\\tsinghua\\java”;

4.1 JAVA字符集

JAVA采用的Unicode字符集，它将ASCII码的8位字节扩展为16位，并扩充了ASCII字符集，使之增加许多非拉丁语字符。

Java中使用的是统一码(Unicode)。

Unicode（统一码、万国码、单一码）是一种在计算机上使用的字符编码。它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。1990年开始研发，1994年正式公布。
Unicode用16位表示，比ASCII码字符集要大的多。
Unicode是16比特的字符编码，其支持当前世界上绝大多数的语言
Unicode给每个字符提供了一个唯一的编码表示，不论是什么平台、程序或语言
Windows系统(Windows 2000版本)、JAVA、XML、LDAP等已支持Unicode
Unicode实现了ISO/IEC 10646标准
安装附加的语言开始 > 设置 > 控制面板 > 区域选项
字体(font)

public class PrimitivesInAction{
  public static void main(String[] args) {
byte aByte = 25;
short aShort = 50;
int anInteger = 100;
long aLong = 1000L;
float aFloat = 1.34F; // remember the ‘F’!
double aDouble = 1.34;
boolean aBoolean = true;
System.out.println("Byte: " + aByte);
System.out.println("Short: " + aShort);
System.out.println("Integer: " + anInteger);
System.out.println("Long: " + aLong);
System.out.println("Float: " + aFloat);
System.out.println("Double: " + aDouble);
System.out.println("Boolean: " + aBoolean);
  }
}


the result is :
Byte: 25
Short: 50
Integer: 100
Long: 1000
Float: 1.34
Double: 1.34
Boolean: true

　　总得说来，没有小数点的数就是整型。你可以通过在数字后面加一个'L' 或者'l'指定为一个长整型。一般使用'L'而不使用'l'，因为'l'很容易与数字'1'混起来。
　　数组、类以及接口是引用的类型。
4.2 变量名
程序是用变量名来引用变量数值的。在JAVA编程语言中，对于变量名有下面的必须满足：

它必须是一个合法的标识符。一个标识符是以字母开头的一串Unicode字符。标识符必须以字母或下划线或 $ 符号开始,不能数字开始。其余字符可以是字母、数字、$ 符号和下划线。
标识符只能包含两个特殊字符，即下划线 (_) 和美元符号 ($)。不允许有任何其他特殊字符。标识符不能包含空格。
它必须不是一个关键字、布尔型字符（true或者false）或者保留字NULL。
它必须在作用域中是唯一的。在不同的作用域才允许存在相同名字的变量。 for example:
下面是一些无效的变量名：
2count
high-temp
Not/ok

这里有个约定：变量名是以小写字母开头，而类名是以一个大写字母开头的。如果变量名包含了多个单词，而每个单词要组合在一起，则在每个单词的第一个字母大写，比如IsVisible。而下划线（_）可以处在变量的任何地方，但是一般地它只用在常数中分离单词，因为常数名都是用大写字母的，利用下划线可以看得更清除。

4.3 变量初始化
当地变量和成员变量可以利用一个赋值语句来初始化。变量的数据类型必须与赋给它的数值的数据类型相匹配。下面程序中的当地变量声明，其初始化如下：
type indentifier [=value][,indentifier[=value]…];
int a, b, c;
int d=3, e, f=9;
double pi = 3.14159;
char x = ‘a’;
char aChar = 'S';
boolean aBoolean = true;

4.4 final变量
你可以在任何作用域声明一个变量。final变量的数值不能在初始化之后进行改变（你希望a=3，有很多用到a的场合，你当然不能在程序中就用3来代替a）。这样的变量跟其它语言中的常量很相似。
为了声明一个final变量，你可以在类型之前的变量声明使用final关键字，比如：
final int aFinalVar = 0;
前面的语句声明了一个final变量并一起对它进行了初始化。如果你在后面还想给aFinalVar赋其它的值的话，就会导致一个编译错误。在必要的时候，你可以推迟对一个final本地变量进行初始化。你可以先定义，然后在之后再初始化，如下：
final int blankfinal;
. . .
blankfinal = 0;
已经声明了但是还没有初始化的final本地变量称为空白final。同时，一旦final本地变量被初始化，它就不能再设置了。并且之后的任何对blankfinal赋值的操作都将导致一个编译错误。
4.5 Number Type Casting（数字类型强转）
Implicit（隐式） casting(from small to big)
byte a = 100;
int b = a;
Explicit（显式） casting(from big to small)
int a = 1000;
byte b = (byte)a;

5.操作符
　　一个操作符利用一个、两个或者三个运算对象来执行了一个函数。只需要一个运算对象的操作符称为单元运算符。例如++是一个单元操作符，它是对运算对象自增1。需要两个运算对象的操作符号称为双元操纵符。比如等于号（=）就是一个双元操作符，它指定右边的运算对象给左边的运算对象。最后，三元操作符需要三个运算对象。JAVA编程语言有一个三元运算符？：，它是一个简要的if-else语句。
public class Ternary{
  public static void main(String[] args){
int i, k;
i = 10;
k = i < 0 ? -i : i; // get absolute value of i
System.out.print("Absolute value of ");
System.out.println(i + " is " + k);

i = -10;
k = i < 0 ? -i : i; // get absolute value of i
System.out.print("Absolute value of ");
System.out.println(i + " is " + k);
  }
}

result is:
Absolute value of 10 is 10
Absolute value of -10 is 10

class TernaryOp
{
  public static void main(String args[])
  {
int salary,daysPresent = 30;
salary = (daysPresent == 20) ? 2000 : 3000;
System.out.println("您本月薪资为 $"+salary);
  }
}

result is:
您本月薪资为 $3000

我们可以将操作符分成以下几类：
算术运算符
关系和条件运算符
移位和逻辑运算符
赋值运算符
其它的运算符
下面我们逐个介绍。

5.1 算术操作符
　　JAVA编程语言为所有的浮点型和整型数支持多种算术运算符。这些运算符为+(加)、-（减）、*（乘）、/（除）以及%(模)。下面的表总结了双元算术运算符。

运算符	使用	描述
+	op1 + op2	op1 加上op2
-	op1 - op2	op1 减去op2
*	op1 * op2	op1乘以op2
/	op1 / op2	op1 除以op2
%	op1 % op2	op1 除以op2的余数

　　这里注意，当一个整数和一个浮点数用为运算符来执行单一算术操作的时候，结果为浮点型。整型数是在操作之前转换为一个浮点型数的。
　　另外两个简练的算术操作符为++和--。++是完成自加1的作用；而—是完成自减的作用。不管是++还是—都可能出现在运算对象的前面（前缀）或者后面（后缀），但是它们的作用是不一样的。前缀的格式为：++op或--op，它实现了在加/减之后才计算运算对象的数值；而后缀的格式为：op++或op--，它实现了在加/减之前就计算运算对象的数值。

5.2 算术操作符
下面的表格总结自增/自减运算符：

运算符	用法	描述
++	op++	自增1；它是在自增之前计算op的数值的。
++	++op	自增1；它是在自增之后计算op的数值的。
--	op--	自减1；它是在自减之前计算op的数值的。
--	--op	自减1；它是在自减之后计算op的数值的。

5.3 Bitwise Operators（位运算符）
~
&
|
>>
<<

int a = 3; // 0 + 2 + 1 or 0011 in binary
int b = 6; // 4 + 2 + 0 or 0110 in binary
int c = a | b;//c=0111
int d = a & b;//d=0010
5.4 关系运算符
关系运算符是比较两个数值并决定它们的关系。比如!=在如果两个运算对象不相等的情况下返回true。以下这个表格总结了关系运算符：

运算符	用法	在什么情况下返回true
>	op1 > op2	op1大于op2的时候
>=	op1 >= op2	op1大于等于op2的时候
<	op1 < op2	op1小于op2的时候
<=	op1 <= op2	op1小于等于op2的时候
==	op1 == op2	op1等于op2的时候
!=	op1 != op2	op1不等于op2的时候

5.5 条件运算符
　　关系运算符经常用在条件运算符中来构造更复杂的判断表达式。JAVA变成语言支持六种条件运算符：五个双元运算符和一个单元运算符，如下表所示；

运算符	用法	什么情况返回true
&&	op1 && op2	Short-circuit（短路） AND, op1 和 op2都是true，有条件地计算op2
\|\|	op1 \|\| op2	op1 或者 op2是true，有条件地计算op2
!	! op	op为false
&	op1 & op2	op1 和 op2都是true，总是计算op1和op2
\|	op1 \| op2	op1 或者 op2是true，总是计算op1和op2

　　这里注意在一些实例中，第二个运算对象可能不用运算，因为如果第一个运算对象是false，则结果就一个是false，因此不用在计算第二个运算对象了。你看看以下的代码：
(numChars < LIMIT) && (...)
　　&&运算符只有在两个运算对象都为true的时候，才返回true。因此，如果numChars大于等于LIMIT的时候，&&左边的运算对象就为false，这时就不用在计算右边的运算对象就返回了数值false。在这个例子中，编译器将不会计算右边的运算对象。如果右边运算对象有副效应的的话（比如读一个流、更新一个数值或者进行一个计算）这个有重要的含义。
　　当两边的运算对象都是boolean（布尔型），运算符号&跟&&执行相同运算。但是，&总是要计算两边的运算对象然后再在两个运算对象同为true的时候才返回true。同样地，当运算对象都为boolean（布尔型）的时候，|执行与操作符号||一样的功能。这个|运算符总是要计算两边的运算对象然后在最少有一边为true的时候才返回true。
public class Ternary{
  static boolean doThing()
  {
System.out.println("in doThing");
return true;
  }
  public static void main(String[] args){
if((2>3)& doThing()) {
      System.out.println("ok");
}

  }
}
result is:
in doThing

public class Ternary{
  static boolean doThing()
  {
System.out.println("in doThing");
return true;
  }
  public static void main(String[] args){
if((2>3)&& doThing()) {
      System.out.println("ok");
}

  }
}

result is:
什么结果也没有。

5.6 赋值运算符
　　JAVA编程语言同样提供了几个简洁的赋值运算符以进行算术、移位或者按位操作或者赋值操作。假如你想为一个变量增加一个数并将结果指定给该变量，你可以这样做：
i = i + 2;
当然你还可以这样来进行简化，主要是用了+=运算符：
i += 2;
上面的两行是等价的。
下面的表列出了所有的赋值运算符和它们的等价形式：

运算符	用法	等价形式
+=	op1 += op2	op1 = op1 + op2
-=	op1 -= op2	op1 = op1 - op2
*=	op1 *= op2	op1 = op1 * op2
/=	op1 /= op2	op1 = op1 / op2
%=	op1 %= op2	op1 = op1 % op2

the following example is omitted. *****
public class OperatorPrecedence{
  public static void main(String[] args){
int a=1;
int b=2;
int c=3;

a += b += c;
// a=a+(b=b+c);
System.out.println(a);
System.out.println(b);
System.out.println(c);
  }
}

the result is:
6
5
3
6.控制流程　
6.1 if-else statement
Syntax(语法)
if(expression){
statements
}else if(){
statements
}else{
Statements
}

public class IfElseTest{
  public static void main(String[] args){
int number = 5;
int mod = number %2;
if (number ==0)
      System.out.println(number + "是零");
else if (mod != 0)
      System.out.println(number + "是一个奇数");
else
      System.out.println(number + "是一个偶数");
  }
}
result is:
5是一个奇数

6.2 switch结构：
switch( variable ) {
case value_1:
statements
break;
case value_2:
statements
break;
...
default:
default statements
}

variable can be:(mark: tried, can not be long)
char/int/short/byte

switch(表达式){
case '常量值 1':
语句(组);
break;
case '常量值 2':
语句(组);
break;
case '常量值 N':
语句(组);
break;
default:
语句(组);
}

public class MathOp{
  public static void main(String[] args){
double d1=0.0, d2=0.0;
d1 = 10;
d2 = 20;
char op = '+';
switch(op){
   case '+':
         System.out.println(d1+d2);
         break;
   case '-':
         System.out.println(d1-d2);
         break;
   case '*':
         System.out.println(d1*d2);
         break;
   case '/':
         System.out.println(d1/d2);
}
  }
}
result is:
30.0　

6.3 循环

6.3.1 while 循环
while(条件)
{ 语句组; }

while (expression) {
// statements
}

public class WhileLoop{
  public static void main(String[] args){
int limit = 4;
int sum = 0;
int i = 1;
while(i<=limit){
      sum =sum + i;
      i++;
}
System.out.println("sum = " + sum);

int j = 1;
while(j<=4){
      System.out.println("j=" + j);
      j++;
}
System.out.println(j);
  }
}

result:
sum = 10
j=1
j=2
j=3
j=4
5
6.3.2 do-while循环
do
{ 语句组; }
while(条件);

6.3.3 for循环
for(变量初始化; 条件; 递增或递减变量的值)
{语句组; }

（1）无标号break语句：其功能是从该语句所在的switch分支或循环中跳转出来，执行其后继语句。

（2）带标号的break语句：
格式：break 标号名；
要求：对应的标号名应标识在某语句块前。其功能是终
止并跳出标号所标识的语句块，执行该语句块的后继语句。

break 语句在循环中用于立即从当前循环终止控制。
遇到 break 语句时，将跳出当前循环。
continue 语句则是从其调用处跳至循环的开始处。
continue 语句之后的语句将不再执行。
（1）无标号continue语句：其功能是终止当前这一轮循
环，即跳过continue语句后面剩余的语句，并计算和判断循
环条件，决定是否进入下一轮循环。

（2）带标号的continue语句：
格式：continue 标号名；
要求：对应的标号名应标识在外层循环语句前。其作用
是使程序的流程转入标号所标识的循环层次，继续执行。
(demo, also add in single step debug.)
public class ForLoop1{
  public static void main(String[] args){
int limit = 4;
int sum = 0;

for(int i=1; i<=limit; i++){
      sum += i;
}
System.out.println("sum = " + sum);
  }
}
the result is:
sum = 10

public class ForLoop3{
  public static void main(String[] args){

for(int i=20; i>0; i -= 2){
      System.out.println("The number is " + i);
}

for(int i=20; i<100; i *= 2){
      System.out.println("The number is " + i);
}
/*
for(int i=10; i>0; i++){
System.out.println("无限循环");
}*/
  }
}

the result is:
The number is 20
The number is 18
The number is 16
The number is 14
The number is 12
The number is 10
The number is 8
The number is 6
The number is 4
The number is 2
The number is 20
The number is 40
The number is 80

public class Factorial{
public static void main(String[] args){
      int limit = 4;
      long factorial;

      for (int i=1;i<=limit;i++){
         factorial = 1;
         for (int j=2; j<=i;j++){
            factorial = factorial*j;
         }
         System.out.println(i + "!" + " is " + factorial);
      }
}
}
the result is:
1! is 1
2! is 2
3! is 6
4! is 24

public class Continue{
public static void main(String[] args){
      for(int i=1;i<=10;i++){
         if(i==4 || i==7){
            continue;
         }
         System.out.println("i=" + i);
      }
}
}

result is:
i=1
i=2
i=3
i=5
i=6
i=8
i=9
i=10

7.方法（method）

for example: int add(int x, int y){
return x+y;
}

for example:
int result = add(5,3);
7.1 Variable Scope（变量范围）

Class（类） scope
Available to all methods in the class
Block（块） scope
Available only with the block it is declared to, or within nested blocks
Method（方法） scope
Available to a method which the variable is declared within

public class VariableScope{
static int i = 10;
public static void main(String[] args){
      int j = 20;
      int r = cube(i);
      System.out.println(r);
      r = cube(j);
      System.out.println(r);
      {
         int k = 30;
         r = cube(k);
         System.out.println(r);
      }
//r = cube(k);there is an error here.
}
static int cube(int n){
      return n*n*n;
}
}
result is:
1000
8000
27000

上一篇

学习hadoop----java零基础学习线路指导视频(1)
下一篇
hadoop开发方式总结及操作指导

更多资料
java百G内容下载：包含自学，入门，高级应用，案例等

黑马25天Java视频分享

来自群组: Hadoop技术组