判断java5或是java6_Java基础语法

Java基础语法

Java语法的组成

1、关键字

关键字的定义和特点

定义：被Java语言赋予了特殊含义的单词

特点：关键字中所有字母都为小写

注意事项：

1) true、false、null 不是关键字！是字面量。

2) main 不是关键字！是一个特殊单词，可以被 JVM 识别，主函数是固定格式，作为程序的入口

2、标识符：给类、方法、变量起的名字。

定义合法标识符规则：

1) 必须以字母或下划线或 $ 符号开始，其余字符可以是字母、数字、$ 符号和下划线。

2) 只能包含两个特殊字符，即下划线 _ 和美元符号 $ 。不允许有任何其他特殊字符。

3) 数字不可以开头。

4) 不可以使用Java中的关键字。

5) Java中严格区分大小写。

6) 标识符不能包含空格。

* 使用驼峰命名法，为了提高阅读性，见名知意。Java中的名称规范：[参照：阿里巴巴Java开发手册.pdf]

常用的命令规范：

1) 包名(package)：多单词组成时所有字母都小写。xxxyyyzzz2) 类名接口名：多单词组成时，所有单词的首字母大写。XxxYyyZzz

3) 变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。xxxYyyZzz

4) 常量名：所有字母都大写。多单词时每个单词用下划线连接。XXX_YYY_ZZZ

3、注释：用于注解说明解释程序的文字就是注释。注释的好处：提高了代码的阅读性。Java中的注释格式[三种]：

> 对于单行和多行注释，被注释的文字，不会被JVM(java虚拟机)解释执行。[查看源文件的属性大小作比较比较直观的了解]

> 对于文档注释，是java特有的注释，其中注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，在用代码去体现。因为代码仅仅是思想的一种体现形式而已。

4、常量和变量

常量：在程序运行过程中，其值不可以改变的量。4.1 Java中常量的分类

1) 整数常量：所有整数

2) 小数常量：所有小数

3) 布尔(boolean)型常量：较为特有，只有两个数值。true false。

4) 字符常量。将一个数字字母或者符号用单引号( ' ' )标识。

5) 字符串常量。将一个或者多个字符用双引号(" ")标识。

6) null常量。只有一个数值就是:null.

4.2 对于整数：有四种表现形式。

二进制：0,1 ，满2进1

八进制：0-7 ，满8进1. 用0开头表示。

十进制：0-9 ，满10进1.

十六进制：0-9，A-F，满16进1. 用0x开头表示。(数字0，并不是字母O)

变量(Variable)：内存中一块存储空间，可保存当前数据。在程序运行过程中，其值是可以改变的。1) 必须声明并且初始化以后使用(在同一个作用域中不能重复声明变量)！

2) 变量必须有明确类型(Java 是强类型语言)。

3) 变量有作用域(变量在声明的地方开始，到块｛｝结束)。变量作用域越小越好。

4) 局部变量在使用前一定要初始化！成员变量在对象被创建后有默认值，可直接用。

5) 在方法中定义的局部变量是在该方法被加载时创建。

局部变量：在方法内部定义的变量，称为局部变量(代码块里面变量).

局部变量的特点：局部变量必须先定义后使用；局部变量的内存在栈中分配。

为什么要定义变量：用来不断的存放同一类型的常量，并可以重复使用

使用变量注意：

1、变量的作用域(一对{ }之间有效)

2、定义变量的格式：数据类型 变量名 = 初始化值   => int x=3;

3、局部变量的命名规范：首字符小写，如果是多个单词构成，从第二个单词开始每个单词的首字符大写。

4、终态变量的命名规范：所有字符全部大写，多个单词构成，使用下划线分隔。

注：格式是固定的，记住格式，以不变应万变。辅助理解：变量就如同数学中的未知数。

* 变量内存分析图

注意事项：1) 字面量、常量和变量的运算机制不同，字面量、常量由编译器计算，变量由运算器处理，目的是为了提高效率。2) 不管是常量还是变量，必须先定义，才能够使用。即先在内存中开辟存储空间，才能够往里面放入数据。3) 不管是常量还是变量，其存储空间是有数据类型的差别的，即有些变量的存储空间用于存储整数，有些变量的存储空间用于存储小数。

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

Java引用数据类型：复合数据类型、复杂数据类型

3个引用数据类型：

类： class

接口：interface

数组：[]

数据的具体类型有2种指定的方式：显式指定，隐式指定(通常是针对字面值。由编译器默认指定)

数据类型的作用：

1) 决定了占用内存空间的大小。

2) 底层的存储的格式

3) 决定了最终显式的形式。

字符类型

char 类型：可以当作整数来对待。 无符号的短整型。没有负数.取值范围 [0-65535]

字符集：字符的集合。字符集合中的每一个字符都对应着一个唯一的整数。

1) ASCII：单字节字符集。只用到了一个字节的后7位。128个字符。

2) ISO8859-1：西欧使用的字符集，单字节字符集。256个字符。兼容了ASCII。

3) GB2312：双字节字符集。兼容了ASCII。主要收录了中文简体。

4) GBK：兼容了 gb2312.增加了繁体中文，还有各个少数民族的符号。

5) UTF-8：三字节的字符集。兼容了 ASCII。

6) Unicode：万国码。java 使用的字符集。jvm 使用的。保证所有的国家的符号都能识别。example[常用的基本数据类型]

1 packagecom.boom.test;2 /**

3 * 整数默认：int4 * 小数：double 双精度5 * @project_name testJava6 * @class_name Test017 *@authorDilraba8 */

9 public classTest01 {10 public static voidmain(String[] args) {11 //数据类型 变量名 = 初始化值

12 byte b=3;13 System.out.println("输出byte类型=>b="+b);14 short s=4000;15 System.out.println("输出short类型=>s="+s);16 int i=12;17 System.out.println("输出int类型=>i="+i);18 long l=12345678;19 System.out.println("输出long类型=>l="+l);20 long l2=541646465464465564l;/*数值较大取值末尾+l*/

21 System.out.println("输出long类型=>l2="+l2);22 //float f= 2.3;/*报错：单精度*/

23 float f2=2.3f;/*强制转换f*/

24 System.out.println("输出float类型=>f2="+f2);25 double d=2.5;26 System.out.println("输出double类型=>d="+d);27 char ch='C';28 System.out.println("输出char类型=>ch="+ch);29 boolean b1=true;30 b1=false;31 System.out.println(b1);32 }33 }

常用的基本数据类型

转义字符(7种常用的转义字符)

\t： 水平制表符 对应着键盘上的Tab键。

作用： \t占用的半角的个数为[1-8]。从\t包括之前的输出的内容。总共占用的半角的位数必须是8的倍数。\t用来补齐8个半角位的倍数的。

\b：退格符： 对应着键盘上的 Backspace 键。

\r： 回车符：让光标回到当前行的行首，后续的输出从行首输出。

\n：换行符：让光标去下一行。

Enter 键对应两个字符：\r\n 让光标去到下一行的行首。

\' ： 字符单引号。

\" ：字符双引号。

\\ ：字符反斜杠

6、运算符

算术运算符

概念：

1、操作数：参与运算的数据 称为操作数。

2、表达式：运算符和操作数的整体 称为表达式。单独的一个操作数也可以看作一个最简单的表达式。 int age = 1+1;

3、返回值：操作数 或者是 表达式 参与 运算的结果。

4、一元运算符：只需要一个操作数的运算符。也叫做 单目运算符。

5、二元运算符：需要两个操作数的运算符。也叫做 双目运算符。

6、三元运算符：需要三个操作数的运算符。也叫做 三目运算符。

注意：参与所有运算的数据，都是操作数 或者 表达式的 返回值 参与的。

e-image && code：

/ 和 % 的应用 [ 求随机数的千位、百位、十位、个位 ]

1 packagecom.boom.test;2

3 importjava.util.Scanner;4

5 /**

6 * @project_name testJava7 * @class_name Test018 *@authorDilraba9 */

10 public classTest01 {11 public static voidmain(String[] args) {12 //任意四位数

13 Scanner scanner = newScanner(System.in);14 System.out.print("请输入任意四位数：");15 int num =scanner.nextInt();16 int unit = num % 10;//个位

17 int decade = num / 10 % 10; //十位

18 int hundred = num / 100 % 10;//百位

19 int Thousands = num / 1000 % 10;//千位

20 System.out.println("千位：" + Thousands + "\n百位：" + hundred + "\n十位：" + decade + "\n个位：" +unit);21 }22 }

个位、十位、百位、千位

i++和++i的异同之处

共同点：

1、i++ 和 ++i 都是变量自增+1，都等价于i=i+1

2、如果i++，++i是一条单独的语句，两者没有任何区别。

3、i++和++i的使用仅仅针对变量。5++和++5会报错，因为5不是变量。

不同点：

如果i++，++i 不是一条单独的语句，他们就有很大的区别。

i++ ：先运算后 +1

++i ： 先+1 后运算

赋值运算符

符号：  =    符合赋值运算符：[Java中：+=、-=、*=、/=、%=] => 类型自动提升

复合赋值运算符特点：

1，生成的字节码文件要稍微小一点点(内存消耗小)。

2，隐含一个强制类型的转换。强制转换的类型为 左边变量的类型

* 左值 的类型 要和 右值表达式的返回值的类型 要兼容，不然会出现精度丢失。

示例：int a,b,c;  a = b = c =3;

int a = 3; a += 5;  => a+=5 <==> a=a+5example

1 packagecom.boom.test;2

3 importjava.util.Scanner;4

5 /**

6 * 赋值运算符 = += -= *= /= %=7 * @project_name testJava8 * @class_name Test019 *@authorDilraba10 */

11 public classTest01 {12 public static voidmain(String[] args) {13 int num = 3;14 num += 2; //num = num +3 =5

15 System.out.println("num=" + num);//5

16

17 short s = 5;18 s += 2;//自动类型提升 s=s+2

19 /*

20 * s=s+4;//丢失精度 *报错 改成下面代码 强制转换 s=(short)+(s+4);21 */

22 System.out.println("s=" +s);23 }24 }

赋值运算符 = += -= *= /= %=

比较运算符(关系运算符)1、>、=、<= ：只适用于 数值型包括 char 类型的数据。

2、==  != 适用于 java支持的所有的数据类型。

example

逻辑运算符逻辑运算符：参与逻辑运算的操作数必须是 boolean 类型的数据。逻辑表达式的 返回值 也是 boolean 类型。在Java中不可以写成33 & x<6

短路与( && ) 、条件与 (  & )区别：&&：如果表达式左边为真，表达式右边参与运算；如果左边为假，那么右边不参与运算，直接返回整个逻辑表达式的结果为false 。

& ：表达式左边运算结果无论真假，右边都进行运算。

* 短路与的效率往往高于逻辑与，通常使用短路与  &&

短路或( || ) 、 条件或 (  | )区别：|： 无论左边运算结果是什么，右边参与运算；

||：当左边为true时，右边不参与运算；直接返回整个逻辑表达式的值 为  true

异或( ^ )与或( | )的不同之处是：只有表达式左右都为true时，结果为false，当两边都为false，结果也为false

位运算符按位与( & )：二元运算符。

规则：低位对齐，进行按位与。 对应的位 有0则0  全1则1.

1：可以将某个整数的某些二进制位设置为0。

2：可以得到某一个数的制定区间的二进制表示的数据。

按位或( | )：二元运算符。规则：低位对齐，进行按位或。对应的位，有1则1，全0则0如果两个操作数 对应的位上没有全1 的，那么进行按位或和加的效果一致

按位异或( ^ )：二元运算符。

规则：对应的位上 相异为1，相同为0

特点：一个数先后和同一个数据异或两次，结果是它自身

异或简单加密应用

按位取反( ~ ) ：一元运算符。

规则：所有的二进制位0--->1 1--->0

System.out.println(~0);//-1

移位运算符

<< 左移 ：高位被移走，包括符号位。低位补0.

>> :带符号右移  ：低位被移走，高位空出来的补符号位，正数补0 负数补1.

三元运算符( 条件运算符 )Java 中唯一的三目运算符。 需要三个操作数。可以是java 支持的任意的表达式。两个表达式的返回值的类型 需要兼容。

格式：条件表达式 ? 表达式1 : 表达式2

1)条件表达式为true，返回表达式1；

2)条件表达式为false，返回表达式2；

示例：Example

两值互换的几种方法：

1、定义第三方变量进行互换

2、数值直接运算   缺：数值过大超过int取值范围，出现强制转换，数据发生变化

3、异或：一个数异或同一个数两次，结果还是这个数(阅读性差)

运算符的优先级

1：乘除取余 大于 加减。

2：一元运算符 大于 二元运算符 的优先级。

3：二元运算符的优先级高于三元运算符的优先级。

4：赋值运算符优先级最低。

5：配合小括号使用。

附加：random随机数

1、Math.random();返回值是一个随机的double 值

语句：Math.random() * (MAX-MIN) + MIN

取整：int value = (int)(Math.random() * (MAX-MIN) + MIN);

2、导入import java.util.Random产生随机数

位移运算符：一条语句产生随机数：int value = (random.nextInt()>>>1)%(MAX-MIN)+MIN;

练习：随机数+三目运算符应用[ 求三个数的最大值 ]

1 //获得随机数

2 importjava.util.Random;3 public classRandomNumber{4 public static voidmain(String[] args){5 //定义随机数区间

6 final int MIN = 1,MAX = 100;7 Random random = newRandom();8 int num1 = (random.nextInt()>>>1)%(MAX-MIN)+MIN;9 int num2 = (random.nextInt()>>>1)%(MAX-MIN)+MIN;10 int num3 = (random.nextInt()>>>1)%(MAX-MIN)+MIN;11

12 //int num1 = (int)(Math.random()*(MAX-MIN)+MIN);13 //int num2 = (int)(Math.random()*(MAX-MIN)+MIN);14 //int num3 = (int)(Math.random()*(MAX-MIN)+MIN);

15

16

17 int max = num1 > num2 ?num1:num2;18 max = max > num3 ?max:num3;19 System.out.print("num1 = "+num1+"\tnum2 = "+num2+"\tnum3 = "+num3+"\tmax=>"+max);20

21 }22 }

View Code

7、基本数据类型转换

方式：自动类型转换(也叫隐式类型转换)， 强制类型转换(也叫显式类型转换)

类型转换：java 不支持 不同类型之间的运算。如果有不同类型之间的数据做运算的话，那么首先第一步做同类型转换。编译器来完成这种转换的。自动的完成的。

转换的规则

1：所有的 byte、short、char的值将被提升到int型。

2：如果一个操作数是long型，计算结果就是long型；

3：如果一个操作数是float型，计算结果就是float型；

4：如果一个操作数是double型，计算结果就是double型。System.out.println(6 % 123456L);// 2.0上述的转换都是 编译器 来完成的。自动完成的。在编译期完成类型的转换，也就是将小类型的数据 当作大类型的数据来使用(如果需要)。

注意：1 和 2 自动转换 是 绝对安全的。 3、4 有可能存在精度的损失。java 语法上这样是允许的

自动类型提升

强制类型转换。语法：(强制转换为的类型)(被转换的数据);

example[ 类型自动提升 && 强制类型转换 ]

1 /*类型提升&强制转换*/

2 classVarDemo23 {4 public static voidmain(String[] args)5 {6

7 int x=2;8 byte b=1;9 x=x+b;//占用较小的自动提升为int型

10 System.out.println("x="+x);//x=3

11

12 byte b1=2;13 b1=(byte)(b1+5);//强制类型转换

14 System.out.println("b1="+b1);15 //a=65+1=66 =>b

16 System.out.println("转换后输出字符:"+(char)('a'+1));//强制转换为char 输出b

17

18

19 byte b2=3;20 byte b3=7;21 int s;/*强制转换*/

22 s=b2+b3;//s=10

23 System.out.println("s="+s);24

25 //Integer.MIX_VALUE int类型最大最小值

26 int max=Integer.MAX_VALUE;27 int min=Integer.MIN_VALUE;28 System.out.println("int_MAX="+max+"\n"+"int_MIN="+min);29 }30 }

View Code

&& 得到一个随机字符[A-Z]or[a-z](大小写也随机)

1 //得到一个随机字符[A-Z]or[a-z](大小写也随机)

2 importjava.util.Random;3 public classRandomCharTest{4 public static voidmain(String[] args){5 final int MAX = 'Z'+1;6 final int MIN = 'A';7 //得到随机大写字符

8 char ranChar =(char)(Math.random()*(MAX - MIN)+MIN);9 System.out.println("随机大写字符："+ranChar);10

11 Random random = newRandom();12 //大小写随机 三目运算符进行判断

13 boolean isUpperCase =random.nextBoolean();14 ranChar = isUpperCase ? ranChar : (char)(ranChar+32);15 System.out.println("得到随机字符："+ranChar);16

17 }18 }

View Code

8、Java流程控制[ 顺序、分支、循环]if 单分支

条件：必须是一个 boolean 表达式。返回值为 boolean 值的表达式。

if 代码块：一个使用 一对花括号{ } 封闭的代码块。代码块组成可以是java 支持的任意行数的代码。

执行过程：

1：首先计算条件 的返回值。如果是 返回值 为 true。那么执行 if 代码块中所有的内容。

2：如果条件的返回值 为 false。那么就跳过所有的 if 代码块中的内容。

&& IfTest小练习

1 //求两个随机数的最大值 范围[0-20].2 //需求：产生一个随机数，范围[0-20]. 来代表一个年龄 age，3 //使用if 语句，如果 age [0-3] 输出 还没有上学 [4-6] 幼儿园小朋友 [7-12] 小学生 [13-15] 中学生 [16-18] 高中生 [19-22] 大学生。

4 importjava.util.Random;5 public classIfTest {6 public static voidmain(String[] args) {7 //定义最大最小值

8 final int MAX = 21;9 final int MIN = 0;10 //产生两个随机数

11 int num1 = (int)(Math.random()*(MAX - MIN)+MIN);12 int num2 = (int)(Math.random()*(MAX - MIN)+MIN);13 System.out.println("num1=" +num1 +"\nnum2=" +num2);14

15 //求两个随机数的最大值16 //最大值赋值给num1

17 int max =num1;18 if(num1

23 System.out.println();24

25 //产生一个随机的年龄

26 int age = (int)(Math.random()*(MAX-MIN)+MIN);27 System.out.println("age="+age);28 if(age >=0 && age <=3) {29 System.out.println("还没有上学！");30 }31 if(age >=4 && age <=6) {32 System.out.println("幼儿园小朋友！");33 }34 if(age >=13 && age <=15) {35 System.out.println("初中生！");36 }37 if(age >=7 && age <=12) {38 System.out.println("小学生！");39 }40 if(age >=16 && age <=18) {41 System.out.println("高中生！");42 }43 if(age >=19 && age <=22) {44 System.out.println("大学生！！");45 }46

47 }48 }

View Code

if-else 双分支

执行过程：

1：如果if 后的条件成立   true 那么就执行 if 代码块中的内容。 不执行 else 中的内容。

2：如果if 后的条件不成立 false ，那么不会执行 if 代码块中的内容， 执行 else 中的内容。

注意：

1：else 代码块不能单独存在。

2：如果 if 代码块 或者是 else 代码块中的内容为一条java 语句，那么两个大括号都可以省略。建议大括号添加。

3：if else 两个代码块 执行且必须要执行某一个代码块中的内容。 条件互斥的。

当 if else运算后有具体的结果，可简化三元运算符

&& if-else小练习

1 /**

2 需求：模拟一次打斗 随机产生一个人的生命值hp[50-100],然后打印。3 然后才随机产生一个伤害值[30-60],暴击的概率为30%，1.8倍伤害.然后将伤害值也打印4 如果出现暴击的话，要提示。5 然后根据此次的伤害和生命值，最后输出 人 是否被 over掉。 如果没有over，输出 最后的血量 hp。6 */

7 public classIfElse{8 public static voidmain(String[] args){9 //定义最大最小值血量

10 final int MAX_HP = 101;11 final int MIN_HP = 50;12

13 //定义最大最小值伤害

14 final int MIN_DAM = 30;15 final int MAX_DAM = 61;16

17 //暴击百分比概率

18 final double CRITICAL_PERCENT = 0.3;19 //产生1.8倍的伤害

20 final double CRITICAL_DAM = 1.8;21

22 //得到随机生命值

23 int hp = (int)(Math.random()*(MAX_HP - MIN_HP)+MIN_HP);24 System.out.println("hp = "+hp);25

26 //随机伤害值

27 int damage = (int)(Math.random()*(MAX_DAM - MIN_DAM)+MIN_DAM);28 System.out.println("damage = "+damage);29

30 //计算是否产生了暴击31 //Math.random [0 - 1.0 ]32 //定义随机数

33 double random =Math.random();34 System.out.println("random ="+random);35

36 /**定变量是否产生了暴击,用产生的random去比较。37 random<0.3 true[ 产生暴击 ]38 random>0.3 false[ 没有被暴击 ]39

40 */

41 //定义变量来表示 是否产生了暴击

42 boolean isCritical = random

44 true ：产生暴击45 false：没有产生暴击46 */

47 System.out.println(isCritical);48 if(isCritical){//出现暴击

49 damage *=CRITICAL_DAM;50 System.out.println("本次攻击为【~~暴击~~】。产生：["+damage+"] 点伤害");51 }else{//no

52 System.out.println("本次没有被暴击。产生：["+damage+"] 点伤害");53 }54

55 hp -=damage;56 if(hp <= 0){57 hp = 0;58 System.out.println("Over……");59 }else{60 System.out.println("活着 剩余血量为："+hp);61 }62 }63 }

View Code

if-else if-else 多分支

执行过程：

1：首先判断 条件-1 成立 true 执行代码块-1.后面所有的代码块都将被跳过。

2：如果第一个条件不成了 false 。那么跳过 代码块-1 继续判断 条件-2.如果成立，执行 代码块-2 跳过后面所有的，不成立，跳过代码块-2，继续判断下一个条件。

3：如果所有的条件都不成立。那么执行 else 后的最后的代码块

注意：

1：else 的数量应该是小于等于 if 的个数的。 else 和 它前面的离它最近的if 配对。

2：if 后的若干个条件应该是条件互斥的。

3：这个多分支的选择语句，执行且仅执行其中的一个代码块。

4：最后的else 可以没有。如果没有最后else 以及代码块的话，那么这么多的分支有可能一个都不成立。

5：if else if else 可以嵌套使用，不建议嵌套太深。一般不要超过三层。&& if-else if-else

1 //随机得到一个整数 [0-100] ，定义分数变量 score 用来存储该随机数。打印当前分数2 //然后，如果score在[90-100] 打印 成绩为A级。 在[80-89] 打印为B级 [60-79] C 级 剩余部分 为 D级。3 //使用if else if else 实现。

4 public classIfElseIfElse{5 public static voidmain(String[] args){6 final int MIN = 0;7 final int MAX = 101;8

9 int score = (int)(Math.random()*(MAX-MIN)+MIN);10 System.out.println("score = "+score);11

12 if(score >= 90){13 System.out.println("A");14 }else if(score >= 80){15 System.out.println("B");16 }else if(score >= 60){17 System.out.println("C");18 }else{19 System.out.println("D");20 }21 }22 }

View Code

&& if-else if-else   和  多个if 的区别

switch 多分支选择结构

switch语句特点：

1：switch语句条件变量取值类型类型(JDK1.5之前)：byte short int char enum(jdk1.5以后) String(jdk1.7以后)

2：case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。

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

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

if语句和switch区别：

if：

1、对具体的值进行判断；

2、对区间判断；

3、对运算结果是boolean类型的表达式进行判断；

switch：

1、对具体值进行判断；

2、值的个数通常固定的；

3、对于几个固定值得判断，使用switch语句，switch将具体的值加载内存，效率相对高；

&& SwitchDemo

1 public classSwitchDemo2 {3 public static voidmain(String[] args)4 {5 int x=3;6 switch (x)//byte,short,int,char

7 {8 case 4:9 System.out.println("a");10 break;11 case 3:12 System.out.println("b");13 break;14 default:15 System.out.println("d");16 }17

18

19 //switch char类型演示

20 int a=3,b=9;21 char opr='+';22 switch(opr)23 {24 case '+':25 System.out.println(a+b);26 break;27 case '-':28 System.out.println(a-b);29 break;30 case '*':31 System.out.println(+a*b);32 break;33 case '/':34 System.out.println(a/b);35 break;36 default:37 System.out.println("此功能为开发！！！");38 }39 }40 }

View Code

&& SwitchTest

1 classSwitchTest2 {3 public static voidmain(String[] args)4 {5 //用户输入数据对应的星期

6 int week=1;7 switch(week)8 {9 case 1:10 System.out.println("星期一");11 break;12 case 2:13 System.out.println("星期二");14 break;15 //以此类推

16 }17

18 //19

20 int month=8;21 switch(month)22 {23 case 3:24 case 4:25 case 5:26 System.out.println(month+"月是春季");27 break;28 case 6:29 case 7:30 case 8:31 System.out.println(month+"月是夏季");32 break;33 case 9:34 case 10:35 case 11:36 System.out.println(month+"月是秋季");37 break;38 case 12:39 case 1:40 case 2:41 System.out.println(month+"月是冬季");42 break;43 default:44 System.out.println(month+"月无对应的季节！！！");45 }46 }47 }

View Code

9、java循环[while 、 do-while 、 for 、jdk1.5 for-each ]   循环三要素：A．循环变量初值 B．循环条件 C．循环变量增量循环的构成：

1：循环控制部分

1)循环条件初始化

2)循环条件

3)迭代 改变循环条件的

2：循环体

解释：

1：循环条件： 一个 boolean 表达式

2：循环体： java 的任何的代码。

执行过程：

1：先判断循环条件是否成立 true ，如果成立，那么就执行循环体，然后继续判断循环条件，依此类推 。

2：直到 循环条件 变成 false，立即结束整个while 循环。

注意：

1：循环体 如果是一句 代码，大括号可以省略(不建议省略)。

2：不要在循环条件后 添加分号。

3： while 循环有可能一次循环体都不执行，如果 一开始 条件就是 false。

4：一般在循环体中 去改变循环条件，来达到结束循环的目的。

&& 两种形式写1-100 奇数之和

&& 奇数之和

&& whileTest

do while 循环

执行的过程：

1：先会执行一次循环体。

2：然后再判断循环条件，条件成立，继续执行循环体，反复 判断执行，不成立就直接退出循环

while 和 do while 的区别

1)语法不同

2)do while 无论条件是否满足，循环体至少执行一次； while 有可能一次循环体都不能执行。

&& do while 小练习

综合练习：小游戏[ 石头、剪子、布 ]

1 //和计算机 石头 剪刀 布，1，石头，2，剪刀，3，布。5局3胜。循环实现。

2 /**

3 常量：石头，剪刀，布 最大胜利的次数。4 变量：计算机随机值，玩家选择的，电脑胜利的场数，玩家胜利的场数，总局数。5 */

6 importjava.util.Scanner;7 public classGameTest{8 public static voidmain(String[] args){9 //定义石头剪子布的终态常量

10 final int STONE = 1; //石头

11 final int SCISSORS = 2; //剪刀

12 final int CLOTH = 3; //布13

14 //定义最大胜利的次数

15 final int MAX_WIN_CONUT = 3;16

17 //定义电脑、玩家的随机数字，初始化为0

18 int computerNumber = 0;19 int playerNumber = 0;20

21 //定义电脑、玩家的胜利次数

22 int computerWinCount = 0;23 int playerWinCount = 0;24

25 //定义总得局数

26 int counter = 1;27

28 //产生随机数，创建扫描器进行随机数的产生

29 Scanner scanner = newScanner(System.in);30

31 /**while循环判断32 电脑胜利总次数、玩家胜利总次数小于最大总次数33 */

34

35 while(computerWinCount < MAX_WIN_CONUT && playerWinCount

37 System.out.println("******第[ "+counter+"]局开始了******");38 /**

39 保证玩家输入一个正确的数字40 玩家输入的是不是一个数字 如果不是数字。用接收字符串的方式去接收。41 如果是数字，是否在范围内。42 */

43 while(true){44 //玩家输入选择

45 System.out.println("请选择：[ 1-->石头 ][ 2-->剪刀 ][ 3-->布 ]");46 boolean isInputInt =scanner.hasNextInt();47 if(isInputInt){48 playerNumber = scanner.nextInt();//输入的是正数

49 if(playerNumber < STONE || playerNumber > CLOTH){//错误数据区间

50 System.out.println("输入出错。。。请重新输入！");51 }else{52 //输入了正确的内容，跳出循环继续后续的内容

53 break;54 }55 }else{56 scanner.next();57 System.out.println("输入了非法的内容~~~请重新输入！");58 }59 }60

61 //电脑随机选择

62 computerNumber = (int)(Math.random()*(CLOTH-STONE)+STONE);63 //打印选择和随机的结果[电脑 or 玩家]64

65 //打印电脑随机的选择[if else]

66 if(computerNumber ==STONE){67 System.out.println("[电脑]选择的是[石头]");68 }else if(computerNumber ==SCISSORS){69 System.out.println("[电脑]选择的是[剪刀]");70 }else{71 System.out.println("[电脑]选择的是[ 布]");72 }73

74 //打印玩家的选择[switch] 通过scanner接收参数进行选择

75 switch(playerNumber){76 caseSTONE:77 System.out.println("[玩家]选择的是[石头]");78 break;79 caseSCISSORS:80 System.out.println("[玩家]选择的是[剪刀]");81 break;82 caseCLOTH:83 System.out.println("[玩家]选择的是[ 布]");84 break;85 }86

87 //电脑和玩家进行比较，并输出结果

88 switch(playerNumber){89 case STONE://玩家石头

90 if(computerNumber ==STONE){91 System.out.println("------ 平局 ------");92 }else if(computerNumber ==SCISSORS){93 System.out.println("------ [玩家]胜利！------");94 playerWinCount++;95 }else{96 System.out.println("------ [电脑]胜利！------");97 computerWinCount++;98 }99 break;100

101 case SCISSORS://玩家剪刀

102 if(computerNumber ==STONE){103 System.out.println("------ [电脑]胜利！------");104 computerWinCount++;105 }else if(computerNumber ==SCISSORS){106 System.out.println("------ 平局 ------");107 }else{108 System.out.println("------ [玩家]胜利！------");109 playerWinCount++;110 }111 break;112

113 case CLOTH://玩家布

114 if(computerNumber ==STONE){115 System.out.println("------ [玩家]胜利！------");116 playerWinCount++;117 }else if(computerNumber ==SCISSORS){118 System.out.println("------ [电脑]胜利！------");119 computerWinCount++;120 }else{121 System.out.println("------ 平局 ------");122 }123 break;124 }125 //打印当前总比分

126 System.out.println("[电脑]vs[玩家] "+computerWinCount + " vs " +playerWinCount);127 System.out.println("------ 第["+ counter++ +"]局结束了------ \n");128

129 }130 //总得结果

131 if(computerWinCount ==MAX_WIN_CONUT){132 System.out.println("\n 最后[电脑胜利]了！总比分[电脑]vs[玩家] "+computerWinCount + " vs " +playerWinCount);133 }else{134 System.out.println("\n 最后[玩家胜利]了！总比分[玩家]vs[电脑] "+playerWinCount + " vs " +computerWinCount);135 }136

137 }138 }

View Code

for 循环

执行过程：

1：循环条件初始化部分，最先执行，而且仅执行一次。

2：接下来进行循环条件的判断部分。成立 true，执行循环体。循环体执行完毕之后，执行 迭代部分。然后再进行循环条件的判断。

3：循环条件一旦不成立，false，循环立马结束。

注意：

1：只有在for 循环中 一般使用单字符的 局部变量， int i; i的作用域只在for 循环内。

2：for 循环 小括号中的三部分，都可以没有。但是，两个分号必须要有。

3：while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。

4：最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。

       

&& 水仙花数：在100-999之间：每一位的三次幂之和等于其本身

1 /**

2 水仙花数：在100-999之间：每一位的三次幂之和等于其本身3 */

4 public classDemo {5 public static voidmain(String[] args) {6 for(int i = 100; i<= 999; i++) {7 int hundred = i/100%10;8 int decade = i/10%10;9 int util = i%10;10 int num = (hundred*hundred*hundred)+(decade*decade*decade)+(util*util*util);11 if(num ==i ) {12 System.out.println(num);13 }14 }15 }16 }

View Code

流程跳转语句[ break   continue ]

break语句：应用范围：选择结构和循环结构。

当break语句单独存在时，下面不要定义其他语句，因为执行不到。

标号的出现，可以让这两个语句作用于指定的范围

continue语句：应用于循环结构，结束本次循环继续下次循环。

当continue语句单独存在时，下面不要定义其他语句，因为执行不到

for 循环的嵌套

&& 百钱买鸡小案例

1 //鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？

2 public classDoubleLoopTest{3

4 public static voidmain(String[] args){5

6 for(int i=0;i<=20;i++){//公鸡的数量

7 for(int j=0;j<=33;j++){//母鸡的数量

8 for(int k=0;k<=300;k+=3){//小鸡的数量

9 if(i+j+k == 100 && i*5 + j*3 +k/3 == 100){10 System.out.println("公鸡:"+i+"\t母鸡:"+j+"\t小鸡:"+k);11 }12 }13 }14 }15 System.out.println("");16 //效率相对较高的

17 for(int i=0;i<=20;i++){//公鸡的数量

18 for(int j=0;j<=33;j++){//母鸡的数量

19 int k = 100 -i -j;//小鸡的数量

20 if(i*5 + j*3 +k/3 == 100 && k % 3 == 0){21 System.out.println("公鸡:"+i+"\t母鸡:"+j+"\t小鸡:"+k);22 }23 }24 }25

26

27 }28 }

View Code

Example

不同形状的输出 双重For循环

正三角

倒三角

数字正倒着

乘法表test

三层For循环

10、方法method(函数 function = 功能) y=f(x)1)方法的主要三要素：方法名、参数列表、返回值。

2)什么是方法：一个算法逻辑功能的封装，是一般完成一个业务功能，如：登录系统，创建联系人，简单说：方法是动作，是动词。

3)方法名：一般按照方法实现的功能定名，一般使用动词定义，一般使用小写字母开头，第二个单词开始，单词首字母大写。如：createContact()

4)参数列表：是方法的前提条件，是方法执行依据，是数据。如：login(String id, String pwd) ，参数的传递看定义的类型及顺序，不看参数名。

5)方法返回值：功能执行的结果，方法必须定义返回值，并且方法中必须使用 return 语句返回数据；如果无返回值则定义为 void，此时 return 语句可写可不写；        返回结果只能有一个，若返回多个结果，要用数组返回(返回多个值)。

注意事项：

递归调用：方法中调用了方法本身，用递归解决问题比较简练，只需考虑一层逻辑即可！但是需要有经验。一定要有结束条件！如：f(1)=1; 递归层次不能太深。总之：慎用递归！

方法给我们带来的好处：

1：减少了代码的冗余性。将功能代码进行封装，提高了代码的复用。

2：功能模块化了。更利于代码后期的修改维护。

a：方法的修饰符 static public  可以让方法具有一些特殊的属性

b：方法的返回类型：可以是java 支持的任意类型(8+3)+ void

c：方法的返回值的类型：

1.如果方法的返回类型不是void：代表该方法的功能执行完毕之后，必须有一个结果返回。方法的返回类型处写我们需要得到的结果的类型

2.如果一个方法的功能只是执行了某些代码，而不需要得到一个执行的结果的值，那么在方法的返回类型处 添加 void 即可

d：方法名：一种标识符。一定要见名知意思。 通过方法的名字来反映 方法实现的功能

e：参数列表(又称形参列表)：

f：方法体：一堆花括号return：使用的范围：只能在方法体中使用

用法：

1：方法的返回类型不是 void 的。必须保证使用return 关键字返回一个与方法返回类型兼容的值

2：方法类型是 void 。直接使用 return ; 来结束方法

方法中只能调用方法，不可以在方法内部定义方法

变量值互换内存解析图

局部变量的回收：

方法内定义的都是局部变量，局部变量在栈中分配空间。方法一旦返回，结束，那么在栈中对方法中的局部变量分配的内存全部回收

方法重载： overload

在一个类的内部，方法的名字相同，参数列表不同的方法。就称为方法的重载，与方法的返回类型无关

1 //方法的重载

2 public classTemp {3 public static voidmain(String[] args) {4

5 int value1 = add(12,23);6 double value2 = add(1.5,2.3);7 int value3 = add(12,23,12);8 System.out.println("value1 = " +value1);9 System.out.println("value2 = " +value2);10 System.out.println("value3 = " +value3);11 }12 //两个数int型相加

13 public static int add(int num1,intnum2){14 return num1+num2;15 }16 //两个double类相加

17 public static double add(double num1,doublenum2){18 return num1+num2;19 }20 //三个int型相加

21 public static int add(int num1,int num2,intnum3){22 //相同类型重载num1+num2功能

23 return add(num1,num2)+num3;24

25 }26

27 }

View Code