【第一个JAVA程序】

书写hello world，书写中排除常见的错误。★★★★★

1 class Demo  //类名：书写时每一个单词的首字母大写
2 {
3 　　public static void main(String[] args)
4 　　{
5 　　　　System.out.println("heloo world");
6　　 }
7 }

Javac： 编译命令：

功能是将Java的源文件编译成class文件。在编译的过程中会进行语法检查，

如果有语法错误错误，这时编译无法通过，不会生成对应的class文件

Java ：运行Java程序命令

首先会启动Jvm，JVM加载对应的class文件。接下来查找当前的这个class文件中是否有main主方法

Java严格区分大小写。一个Java文件中可以有多个类，但要是类经过public修饰，类名必须与文件名保持一致。.Java为源文件，源文件经过Javac编译后生成.class文件此文件被虚拟机调用。

常见的错误

1、缺少分号；  这个错误在编译时发生

2、括号不配对这个错误在编译时发生

3、主方法名字写错mian发生在运行时

4、编译器找不到文件

解决办法：

查看当前目录下有没有1234.Java这个文件。如果没有话，切换到1234.Java所在的目录从新执行Javac

如果当前目录下面有，使用dir命令查看当前文件具体的扩展名是什么。

5、找不到class文件    E:\JavaSE1115\code\day01>Java Demo

错误: 找不到或无法加载主类 Demo

前提是，配置的了classpath：JVM会在classpath配置的目录中查找，如果没有找到，会报上面的错误

如果没有配置classpath，当前目录下面没有Demo.class这个文件。

【Java语法格式】

如何定义Java中的类:

Java代码都定义在类中,类用 class来定义,区分public class和class

main方法的作用:main方法是程序的入口;保证程序的独立运行;被JVM调用。

【注释】

注释用来解释说明Java代码用的，注释不属于Java代码的运行部分，但是Java代码的一部分，注释的另一功能是调试代码。

Java中的三种注释：

1、 单行注释 ：eg：// 注释内容

　　a) 注意：单行注释可以嵌套单行注释

2、 多行注释 ：eg：/* 注释内容 */

　　a) 注意：多行注释不可以嵌套多行注释，但可以嵌套单行注释

3、文档注释 ：eg：/**  注释内容 */

　　a) Java中特有的注释，这种注释提供给Javadoc命令，将代码中的注释部分提取出来，形成一个html文档即API文档。注释使用在类上面，主要将这个信息通过Javadoc命令提取。

【Java 关键字 保留字 标示符】

【关键字】

关键字：被Java语言赋予了特定含义的单词。

特点： 关键字所有字母都为小写，好比汉语中的专有名词。

【保留字】

保留字：goto 和 const是java的保留字。现在未被使用。

【标示符】

标示符可简单理解为Java程序中为了提高阅读性自定义的名称。Eg：类名，方法名，变量名。

标示符组成：

　　a） 标示符由数字、字母、下划线、$符组成，数字不能开头。（字母还可以是中文，日文等）

　　b） 标示符大小写敏感 ；

　　c） 标示符不能使用 Java中的关键字和保留字；

　　d） 名字不能用空格隔开

　　e） 别用JavaAPI里面的类名作为自己的类名。

注意：在取名时，只要标示符不是关键字就可以，但为了提高阅读性经常用有意义的单词作为标示符。

【标示符书写规范】

包名：多单词组成时所有字母都小写，eg：xxxyyyzzz

　　（包：用于把同名的文件放到不同的目录下，多级包用.隔开 eg：cn.itcast(可用域名反写作包名)）

类名接口名：所有单词的首字母大写，eg：XxxYyyZzz

变量名函数名：多单词组成时，第一个单词首字母小写，其余单词首字母大写

   　　Eg：xxxYyyZzz

常量名：所有单词字母都大写，多单词时单词间用下划线连接,eg:XX_YY_ZZ

【进制和常量】

【进制】

十进制可以用8个二进制位表示。八进制是每三个二进制位表示一位，不够的补零，十六进制是每四个二进制位表示一位。

【常量】

常量：在程序中固定不变的值。

　　Eg：整数1,4,6 小数3.14 一星期有7天等

【常量分类】

常量的分类：（字面值常量 ，自定义常量）

 　　整数常量：所有整数

 　　小数常量：所有小数

 　　布尔型常量：两个值，true false

 　　字符串常量：将一个或多个字符用双引号标识

 　　字符常量：将一个字母或数字或者符号用单引号标识

　　 null常量：只有一个值null

【变量】

概念：变量表示内存中的一个存储区域，该区域用来不断的存放同一类型的常量数据，并可以重复使用该区域并且这个区域有自己的名称和类型。

理解：变量就好比数学中的未知数；

格式：数据类型 变量名 = 初始化值;

  　　 数据类型 变量名; 变量名 = 初始化值;

注意：变量在使用前，一定要赋值。

取名：变量表示内存中的一个存储区域，必须给该区域取个名字才能使用，当给变量取名时，同样需要见名知意。Eg：String name;

【数据类型：】

Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。

   【数据类型分类：】

　　基本数据类型：4类8种。

　　引用数据类型：类、接口、数组

注意：整数默认是int类型，long类型整数需要加后缀名l或L；

 　　  浮点数默是double类型，float浮点数需要加后缀名F或f。

Java里只有浮点型的变量才可以接受科学计算式结果：int  num = 314E2; //×  num为int类型，不可以使用科学计数法

解析：

布尔型boolean

boolean类型通常用于逻辑运算和程序流程控制，只允许取值true或false（不可使用0或非0的数代替，区分于C语言）。

字符型char (A:65, a:97, 0:48)

char类型数据用来表示通常意义上的“字符”，char占用2个字节，取值范围[0,65535],但是前256个表示特殊字符，字符常量为用单引号括起来的单个字符。单引号中必须要有字符，否则会报错。

Eg：char c = ‘A‘; char  c2 = ‘传‘;  char c3=97;

java中的char类型是否可以存储一个中文，为什么?

可以。原因是java采用的unicode编码方法，这个编码用两个字节表示一个字符。

转义字符

   有部分符号在Java中有特殊含义，当需要使用符号自身原有的意思时，可以通过转移字符表示。

　　Eg：键盘上的制表符tab键，可以使用‘\t’表示。

 如双引号，在java中使用双引号表示字符串，若想使用双引号，可使用‘\”’,\会把后面的内容转义掉。

String类型

String不属于基本数据类型;但和字符有一定的联系。String是一个类，表示字符串; 就是一串字符，也就是多个字符连接在一起；字符串都得使用 "" 括起来的，连接字符串使用 + ;（String不属于基本数据类型）eg：System.out.println(‘a’+1+”hello”);//98hello 先运算

 System.out.println(“hello”+’a’+1);//helloa1

【类型转换】

　　在参与运算的过程中，要求运算符两端的数据类型一致。

【隐式类型转换】

隐式类型转换：（自动转换，从小到大 boolean类型不参与）：

Eg：byte b = 2; //会把int类型的2转换为byte类型存放到b空间中。

当把一个int类型的数据存放到char类型空间时也会发生隐式类型转换：

Eg：char ch = 65; //这里会用int类型65，到编码表中查找对应的字符，然后将字符存放在ch空间中

char ch2 = ‘A‘;//直接将A字符存放在ch2空间中

注意：当把超过byte和short范围的数据给他们开辟空间存放会发生编译时错误，同样把无法在编码表中查找到对应字符的数据存放到char空间也会发生报错。

 整型、字符型、浮点型的数据在混合运算中相互转换，转换时遵循以下原则：

 容量小的类型可自动转换为容量大的数据类型（类型自动提升）

　　byte,short,char → int → long → float → double

为什么long可以到float?

　　因为浮点数的存储和整数不太一样。

　　浮点数的存储只存储有效数字，和次幂数字等。

　　23456.123;

　　2.34E3 * 10 ^ 4

    不管怎么说，long能够表示的数据的值是小于float的。

所以，这种转换是可以的。

long  2^63

float 10^38 > 8^38 = 2^3^38 = 2^114 > 2^63

byte，short，char之间不会相互转换，他们在计算时首先会转换为int类型。

【强制转换】（从大到小）

这种做法不推荐。因为可能有数据精度的损失。

格式：

目标数据类型 变量名 = (目标数据类型) (被强制转换的数据);

Eg：byte b = (byte) (100 + 200);

思考：

byte b1 = 3,b2 = 4,b;

b = b1+b2;  //b1,b2为变量，数值都不确定相加的值可能超出范围。编译失败

b = 3+4; // 3，4 为常量计算结果在byte内，编译通过

【运算符】

【算术运算】

特殊符号：

　　+: 加法，正号，字符串连接符。

　　　　System.out.println(10+‘a‘+"hello");//107hello

　　　　System.out.println("hello"+‘a‘ + 10);//helloa10

　　/： 整数相除，结果只能是整数。当两侧数据类型一致，结果仍为运算过后保持一致

　　　　Eg：4321/1000*1000=4000；

　　%： 取得余数。

　　如果左边小于右边，结果是左边。

　　如果左边等于右边，结果是0。

　　如果左边大于右边，结果是余数。

　　符号只和左边有关。

　　自加自减

　　++  自加。对原来的数据进行+1；

　　--  自减。对原来的数据进行-1；

　　如果单独使用：

　　符号在前后结果一致。

　　如果参与运算使用：

　　前：先++或者--，后运算。

　　后：先运算，后++或者--。

　　　　当在一个运算表达式中包含自加运算时，当自加符号在变量右侧时，需要先将变量临时存储，然后给变量空间加1，接着用临时变量空间中的值去给其他运算符进行运算。当自加符号在变量左侧时，需　　　要先给变量空间加1，然后把加1后的值和其他运算符进行运算。

　　Eg：int i =4; i=i++; System.out.println(i);//4;

【赋值运算符(=,+=,-=,*=,/=,%=)】

赋值号的功能就是讲赋值号右侧的结果存储到左侧的变量空间中。

Eg：int a = 3;//将3 存储到左侧a空间中

int b,c,d;

b=c=d=a;//将a空间中的值分别存储到d,c,b空间中。

= 把右边的赋值给左边的变量。

+= 把左右两边的结果赋值给左边。

注意：

左边只能是变量，不能是常量。

呵呵：下面那个有问题，并说明。

short s = 1;

s = s + 1;//编译失败，因为s会被提升为int类型，运算后的结果还是int类型，无法赋值给short类型 左边 = (左边数据类型)(左边操作右边);

 s += 1;//编译通过，因为+=运算符在给s赋值时，会自动完成强转操作。

【比较运算符（>,< ,>=,<=,==,!=,instanceof）】

比较运算符用来判断数据的大小。

>大于 >=大于等于 <小于 <=小于等于 ==相等 !=不等

instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。

比较运算符，运算完的结果要么是true，要么是false，根据比较的结果做出相应的逻辑判断。

注：比较运算符“==”不能误写成“=”

【逻辑运算符(&,|,^,!,&&,||。部分可用于位运算)】

& : 与  有false 则false

| ：或  有true则true      

^ : 异或。两边相同为false，两边不同为true

！：非。 非真为假，非假为真

&& 短路与  如果左侧为真右边参与运算，如果左侧为假，右侧不参与运算

||  短路或  左侧为真右侧不参与运算。

【位运算(&,|,~,<<,>>,>>>)】

位运算：主要是说的是 二进制数位运算。(为方便记忆0为false，1为true)

1,运算符符号

& 按位与运算。规则：相同二进制位上数值都为1，结果为1；否则为0。

Eg：

  3 & 5   先把 3和5以二进制表示，再进行按位于运算：

十进制              二进制                         结果(十进制)

   3 00000000_00000000_00000000_00000011

   5 00000000_00000000_00000000_00000101

  -------------------------------------------------------------------------------------------------

   & :    00000000_00000000_00000000_00000001     = 1

 | 按位或运算。规则：相同二进制位上数值都为0，结果为0；否则为1.

Eg：

3 | 5   先把 3和5以二进制表示，再进行按位于运算：

十进制           二进制                         结果(十进制)

   3 00000000_00000000_00000000_00000011

   5 00000000_00000000_00000000_00000101

-----------------------------------------------------------------------------------------

  | :   00000000_00000000_00000000_00000111     7

 ^ 按位异或。规则：参与运算的两个对应位相同结果为0；否则为1。

Eg：

十进制           二进制                        结果(十进制)

   3 00000000_00000000_00000000_00000011

   5 00000000_00000000_00000000_00000101

-----------------------------------------------------------------------------------------

  ^ :   00000000_00000000_00000000_00000110 6

 ~ 按位 取反。 规则：二进制位上的0变1；1变0。

Eg：  十进制           二进制                        结果(十进制)

      5 00000000_00000000_00000000_00000101

-----------------------------------------------------------------------------------------

 补码： ~ :   11111111_11111111_11111111_1111010 -6

反码：　　　　11111111 _11111111 11111111_1111001

源码： 10000000 00000000  00000000 0000110

左右移 运算

左移操作“<<”：将运算数的二进制码整体左移指定位数，左移之后的空使用“0”来补充，移出去的二进制数忽略不计。

9 << 2 :

十进制           二进制                        结果(十进制)

   9 00000000_00000000_00000000_00001001

-----------------------------------------------------------------------------------------

     00000000_00000000_00000000_0000100100 36

所以9<<2等于 36.

规律：<<：相当于给原数乘以2的倍数

右移操作“>>”：将运算数的二进制码整体右移指定位数，右移之后的空使用“符号位”来补充。移出去的二进制数忽略不计。若是正数使用“0”补充；若是负数使用“1”补充；

9 >>2 :

十进制           二进制                        结果(十进制)

     9 00000000_00000000_00000000_00001001

-----------------------------------------------------------------------------------------

       0000000000_00000000_00000000_00001001    2

所以9>>2等于 2.

规律：>>：相当于给原数除以2的倍数

-6 >> 2:

十进制           二进制                        结果(十进制)

   -6    11111111_11111111_11111111_1111010

-----------------------------------------------------------------------------------------

         1111111111_11111111_11111111_1111010

所以-6>>2等于 -2.

无符号右移">>>"：将运算数的二进制码整体右移指定位数，右移之后的空使用“0”来补充

      面试题：最高效求2*8？   2<<3;

【三元运算符】

 三元运算符，也称为三目运算符或则问号冒号运算符。即有三个表达式参与的运算表达式。既然是个运算符，运算完必须有运算结果。

 格式：(表达式1)?表达式2:表达式3;

 运算原则：表达式1运算结果必须为boolean类型的值。

   表达式1的结果为true时，表达式2的运算结果为整个三元运算符的结果。

   表达式1的结果为false时，表达式3的运算结果为整个三元运算符的结果。

   Eg： int x = 3,y ;

y = x < 10 ? 100 : 200;//

System.out.println("y="+y);

   Eg:求三个数中的最大值

int a = 1,b = 2,c = 3;

int max = a > b ? (a>c?a:b):(b>c?b:c);

(int temp = a>b?a:b;

int max = temp>c?temp:c;)

1.位运算应用

需求1：最有效率运算2乘以8。 → 通过位移运算 2<<3.

需求2： 完成两个整数变量的数值呼唤（不使用第三方变量）

//1.通过第三方变量的形式进行置换。

int a = 3, b = 7;

int temp = a;

a = b;

b = temp;

//2.通过和的形式。有个弊端，两个数据较大，可能会超出int范围。

a = a + b;//a = 3 + 7;

b = a - b;//b = 3 + 7 - 7； b = 3;

a = a - b;//a = 3 + 7 - 3;  a = 7;

//3.技巧。异或。（左边：a,b,a; 右边：a^b;）

a = a ^ b;// a = 3 ^ 7;

b = a ^ b;// b = 3 ^ 7 ^ 7;

a = a ^ b;// a = 3 ^ 7 ^ 3;

【算符的优先级】

 运算符的优先级决定了表达式的执行顺序，表达式的运算通常是按照运算符的优先级由高到低依次执行的。

流程语句

【程序运行流程&顺序结构】

 （程序的流程：代码的执行顺序）

说明：当在DOS命令行中输入java Demo（假设有Demo.class文件）回车后。首先会加载JVM，JVM

  会去加载当前Demo这个class文件，并执行其中的main方法，当程序执行main方法的时候会从第一行开始往下执行，直到整个代码全部执行完成。像这样的执行流程就是常见的顺序执行结构。

【语法结构：】

【判断结构（if）】

if是java中的关键字，当程序在执行过程中遇到if关键字，JVM会在此进行判断，根据判断结果需要处理相应的代码。

【if 判断第一种格式：】

if(条件表达式)

{

执行语句;

}

格式说明：if关键字后面是一对小括号（后面没有分号），小括号中的表达式运算完的结果必须是boolean 类型的值。

执行说明：JVM在执行代码时，遇到if关键字，首先运算if括号中的表达式，当if中表达式的值为true时，就会执行if后面大括号中的语句。当if中表达式的值为false时，就会条多if后面大括号中的语句，继续执行大括号下面的其他语句。

【if判断语句第二种格式：】

if(条件表达式)

{

执行语句;

}

else

{

执行语句;

}

执行说明：当if条件表达式为true时，执行if后面大括号中的语句，当if条件表达式为false时，执行else后面大括号里面的语句。if-else格式，要么执行if后面的语句，要么执行else后面的语句。切记，else后面的语句要能够执行，if中的条件表达式结果必须为false。

三元运算符可以简化成if-else格式：

 1 Eg：int a =4,b=5,max;
 2 
 3 if(a>b)
 4 {
 5     max = a;
 6 }
 7 else
 8 {
 9     max = b;
10 }

可以使用三元运算简化为：max = a > b ? a: b;

三元运算符是简写的if-else格式，简写是有弊端的：三元运算符运算完必须要有结果，而if-else语句不一定有运算结果。

【if判断第三种格式：】

if(条件表达式)

{

执行语句；

}

else if (条件表达式)

{

执行语句；

}

……

else

{

执行语句；

}

if 练习：根据提供数值，输出对应的星期。

class IfTest

{

　　public static void main(String[] args)

{

//1，定义变量。记录数据。

int week = 9;

//2，通过判断结构语句if对该变量进行判断。

if(week == 1)

//3，根据不同的条件，通过输出语句显示不同的结果。

 1 System.out.println(week+"对应的是星期一");
 2 
 3 else if(week == 2)
 4 
 5 System.out.println(week+"对应的是星期二");
 6 
 7 else if(week == 3)
 8 
 9 System.out.println(week+"对应的是星期三");
10 
11 else if(week == 4)
12 
13 System.out.println(week+"对应的是星期四");
14 
15 else if(week == 5)
16 
17 System.out.println(week+"对应的是星期五");
18 
19 else if(week == 6)
20 
21 System.out.println(week+"对应的是星期六");
22 
23 else if(week == 7)
24 
25 System.out.println(week+"对应的是星期日");
26 
27 else
28 
29 System.out.println(week+"没有对应的星期");
30 
31 }
32 
33 }

注意：条件表达式必须为boolean类型；if语句{}前加”;”,编译能通关，但不再做判断；当if控制的执行语句只有一行时，{}可以省略（if只控制离它最近的一条语句）

【键盘录入数据：】

键盘数据录入数据有三种：

　　1． main方法中的args字符串数组接受。

　　2． 使用IO流中的技术。

　　3． JDK5 以后的新的键盘录入。

　　使用Scanner类的方法

怎么使用：

a) 导包：import java.util.Scanner;

b) 创建对象：Scanner sc = new Scanner(System.in);

c) 使用： int num = sc.nextInt();// nextInt ();(方法)

【switch 多分支结构：】

格式：

switch(表达式)

{

case 取值1:

执行语句；

break；

case 取值2:

执行语句；

break；

…...

default:

执行语句；

break；

}

执行说明：当程序执行时，遇到switch关键字，首先会计算表达式的值，然后根据计算的值和case后面的值做比较，当case后面的值和switch表达式的值相同时，就执行case身后的所有语句，若case身后没有和switch表达式匹配的值，程序会执行default后面的语句。

注意：

switch语句选择的类型只有四种：byte,short,int,char(JDK5之前)。还支持enum(JDK5),String(JDK7)。

case 与 default 写法上没有先后顺序，执行上有顺序（先执行case，没匹配的才执行default）。

结束switch语句的两种情况：遇到break，执行到switch语句结束。

break：可以省略，但可能对结果造成影响，建议不省略。

如果匹配的case或者default没有对应的break，程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch语句结束。

switch练习：

根据用户的给定的数值，显示该数值对应的星期。如：2，星期二。

 1 class SwitchTest {
 2     public static void main(String[] args) {
 3         int week = 9;
 4         switch (week) {
 5             case 1:
 6                 System.out.println(week + "对应的是星期一");
 7                 break;
 8             case 2:
 9                 System.out.println(week + "对应的是星期二");
10                 break;
11             case 3:
12                 System.out.println(week + "对应的是星期三");
13                 break;
14             case 4:
15                 System.out.println(week + "对应的是星期四");
16                 break;
17             case 5:
18                 System.out.println(week + "对应的是星期五");
19                 break;
20             case 6:
21                 System.out.println(week + "对应的是星期六");
22                 break;
23             case 7:
24                 System.out.println(week + "对应的是星期日");
25                 break;
26             default:
27                 System.out.println(week + "没有对应的星期");
28                 break;
29         }
30     }
31 }

if和switch的区别：

if可以用于判断数值，也可以判断区间，只要运算结果是boolean类型，都可以进行判断。

switch用于对固定的几个值，进行判断。判断的值的类型有限。

【循环结构（while&do-while）】

 循环结构：根据程序的需求，可以将某些代码重复的操作，java中的循环结构有三种：

while：事先不需要知道循环执行多少次；

do-while:同上，只是至少要执行一次（先执行一次，后判断）

for：需要知道循环次数

【while 循环】

格式：

while(条件表达式)

{

执行语句;

}

执行顺序：当程序执行到while关键字，JVM首先会运算while后面的条件表达式，当条件表达式结果为true，就会执行while的执行语句，当执行完执行语句后，会又回到while的条件表达式再次判断，如果为true，就继续执行，知道条件表达式结果为false时，才会跳过循环继续往下执行。

 Eg：

int i = 1;

while( i < 10 )

{

System.out.println("i"+i);

i++; // 让i不断的更新，最后使循环可以结束

}

System.out.println("over");

  while 练习：

需求：运算1-10的和。（累加思想）

思路：

    1+2+3+4+...+10

    每次加的和是确定的吗？不确定。需要变量记录和值。

每次和值需要加的下一个数是确定的吗？不确定，需要变量。

求和和+下一个数在重复，说明需要执行多次，用循环。

下一个数，是有规律的。自增。

步骤；

1，定义变量。一个记录和，一个记录下一个数。

2，需要循环结构。

    3，循环中需要进行和+下一个数的运算。并让下一个数自增。

//1，定义变量。一个记录和，一个记录下一个数。

int i = 1;

int sum = 0;

//2，需要循环结构。

while(i<=10)

{

//3，循环中需要进行和+下一个数的运算。并让下一个数自增。

sum = sum + i;

i++;

}

System.out.println("sum="+sum);

 注意：while循环的括号中的表达式记过必须为boolean类型的值；while循环的括号中不能直接写false常量；while循环的括号后面不能写分号，循环控制的语句的代码用大括号括起；while循环控制的条件变量一定要更新，保证循环能够正常结束。

【do-while 循环】

 格式：

  do {

执行语句;

}while(条件表达式);

  执行顺序：先执行do句，后面的语句，当执行完后在进入条件表达式进行判断，若条件表达式结果为true继续执行do后面的语句，直到条件表达式结果为false，循环结束。

  do-while 特点是无论条件是否满足，循环至少执行一次。

 【for 循环】

 格式：

for(初始化表达式;条件表达式;增量表达式)

{ 循环体; }

 初始化表达式：定义对次数的起始变量；

 条件表达式：用来限定循环次数；

 增量表达式：对起始变量进行改变；

 循环体：需要被执行的语句。

 执行流程：

a) 首先看初始化表达式；

b) 接着看条件表达式，如果为true执行循环体；

  如果为false结束循环；

c) 当循环体执行完毕，执行增量表达式；

d) 返回b，直到条件不满足。

   注意：初始化表达式：只执行一次；条件表达式至少执行一次，增量表达式执行0次或多次。

【for循环嵌套】

所谓for循环嵌套就是for语句中还有for语句。

Eg：在控制台打印九九乘法表

 1 class NineDemo {
 2 public static void main(String[] args) {
 3 for (int i = 1; i <= 9; i++)//外循环控制行数
 4 {
 5 //外循环执行一次，内循环执行一遍。
 6 for (int j = 1; j <= i; j++)//内循环控制列数
 7 {
 8 System.out.print(j + "*" + i + "=" + i * j + "\t");
 9 }
10 System.out.println();//用作换行。
11 }
12 }
13 }

【for和while的区别(变量的生命周期不同)】

for(int x = 1; x<3; x++)

{

System.out.println("x="+x);

}

//System.out.println("x......"+x);

int y = 1;

while(y<3)

{

System.out.println("y="+y);

y++;

}

System.out.println("y....."+y);

    for (int x=0; x<3 ;x++ ){
        if(x==1){
            break;
        }
        System.out.println("x="+x);
    }
//    continue是结束本次循环，继续下次循环。循环是不会结束的。
    for (int x=0; x<10 ;x++ )
    {
        if(x%2==0)
            continue;

        System.out.println("x="+x);
    }

 1 class FlowerDemo {
 2     public static void main(String[] args) {
 3         //用循环实现获取100-999
 4         for (int x = 100; x < 1000; x++) {
 5 
 6             int ge = x % 10;
 7 
 8             int shi = x / 10 % 10;
 9 
10             int bai = x / 10 / 10 % 10;
11             if ((ge * ge * ge + shi * shi * shi + bai * bai * bai) == x) {
12                 System.out.println(x);
13             }
14         }
15     }
16 }