Java基础语法
Java基础语法java
Java语法的组成
一、关键字
关键字的定义和特色
定义：被Java语言赋予了特殊含义的单词
特色：关键字中全部字母都为小写
注意事项：
1) true、false、null 不是关键字！是字面量。
2) main 不是关键字！是一个特殊单词，能够被 JVM 识别，主函数是固定格式，做为程序的入口程序员
二、标识符：给类、方法、变量起的名字。
定义合法标识符规则：
1) 必须以字母或下划线或 $ 符号开始，其他字符能够是字母、数字、$ 符号和下划线。
2) 只能包含两个特殊字符，即下划线 _ 和美圆符号 $ 。不容许有任何其余特殊字符。
3) 数字不能够开头。
4) 不可使用Java中的关键字。
5) Java中严格区分大小写。
6) 标识符不能包含空格。
* 使用驼峰命名法，为了提升阅读性，见名知意。Java中的名称规范：[参照：阿里巴巴Java开发手册.pdf]
经常使用的命令规范：
1) 包名(package)：多单词组成时全部字母都小写。xxxyyyzzz
2) 类名接口名：多单词组成时，全部单词的首字母大写。XxxYyyZzz
3) 变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每一个单词首字母大写。xxxYyyZzz
4) 常量名：全部字母都大写。多单词时每一个单词用下划线链接。XXX_YYY_ZZZ
三、注释：用于注解说明解释程序的文字就是注释。注释的好处：提升了代码的阅读性。
Java中的注释格式[三种]：
> 对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行。[查看源文件的属性大小做比较比较直观的了解]
> 对于文档注释，是java特有的注释，其中注释内容能够被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。注释是一个程序员必需要具备的良好编程习惯。将本身的思想经过注释先整理出来，在用代码去体现。由于代码仅仅是思想的一种体现形式而已。
四、常量和变量
常量：在程序运行过程当中，其值不能够改变的量。
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) 在方法中定义的局部变量是在该方法被加载时建立。
局部变量：在方法内部定义的变量，称为局部变量(代码块里面变量).
局部变量的特色：局部变量必须先定义后使用；局部变量的内存在栈中分配。
为何要定义变量：用来不断的存放同一类型的常量，并能够重复使用
使用变量注意：
一、变量的做用域（一对{ }之间有效）
二、定义变量的格式：数据类型 变量名 = 初始化值 => int x=3;
三、局部变量的命名规范：首字符小写，若是是多个单词构成，从第二个单词开始每一个单词的首字符大写。
四、终态变量的命名规范：全部字符所有大写，多个单词构成，使用下划线分隔。
注：格式是固定的，记住格式，以不变应万变。辅助理解：变量就如同数学中的未知数。算法
* 变量内存分析图
编程
注意事项：
1) 字面量、常量和变量的运算机制不一样，字面量、常量由编译器计算，变量由运算器处理，目的是为了提升效率。
2) 无论是常量仍是变量，必须先定义，才可以使用。即先在内存中开辟存储空间，才可以往里面放入数据。
3) 无论是常量仍是变量，其存储空间是有数据类型的差异的，即有些变量的存储空间用于存储整数，有些变量的存储空间用于存储小数。数组
五、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[经常使用的基本数据类型]
dom
1 package com.boom.test; 2 /** 3 * 整数默认：int 4 * 小数：double 双精度 5 * @project_name testJava 6 * @class_name Test01 7 * @author Dilraba 8 */ 9 public class Test01 { 10 public static void main(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 让光标去到下一行的行首。jvm
\' ： 字符单引号。
\" ：字符双引号。
\\ ：字符反斜杠ide
六、运算符
算术运算符
概念：
一、操做数：参与运算的数据 称为操做数。
二、表达式：运算符和操做数的总体 称为表达式。单独的一个操做数也能够看做一个最简单的表达式。 int age = 1+1;
三、返回值：操做数 或者是 表达式 参与 运算的结果。
四、一元运算符：只须要一个操做数的运算符。也叫作 单目运算符。
五、二元运算符：须要两个操做数的运算符。也叫作 双目运算符。
六、三元运算符：须要三个操做数的运算符。也叫作 三目运算符。
注意：参与全部运算的数据，都是操做数 或者 表达式的 返回值 参与的。模块化
e-image && code：
/ 和 % 的应用 [ 求随机数的千位、百位、十位、个位 ]
1 package com.boom.test; 2 3 import java.util.Scanner; 4 5 /** 6 * @project_name testJava 7 * @class_name Test01 8 * @author Dilraba 9 */ 10 public class Test01 { 11 public static void main(String[] args) { 12 // 任意四位数 13 Scanner scanner = new Scanner(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的异同之处
共同点：
一、i++ 和 ++i 都是变量自增+1，都等价于i=i+1
二、若是i++，++i是一条单独的语句，二者没有任何区别。
三、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+5
example
1 package com.boom.test; 2 3 import java.util.Scanner; 4 5 /** 6 * 赋值运算符 = += -= *= /= %= 7 * @project_name testJava 8 * @class_name Test01 9 * @author Dilraba 10 */ 11 public class Test01 { 12 public static void main(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 }
比较运算符(关系运算符)
一、>、<、>=、<= ：只适用于 数值型包括 char 类型的数据。
二、== != 适用于 java支持的全部的数据类型。
example
逻辑运算符
逻辑运算符：参与逻辑运算的操做数必须是 boolean 类型的数据。逻辑表达式的 返回值 也是 boolean 类型。在Java中不能够写成3<x<6，应该写成x>3 & 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
两值互换的几种方法：
一、定义第三方变量进行互换
二、数值直接运算 缺：数值过大超过int取值范围，出现强制转换，数据发生变化
三、异或：一个数异或同一个数两次，结果仍是这个数(阅读性差)
运算符的优先级
1：乘除取余 大于 加减。
2：一元运算符 大于 二元运算符 的优先级。
3：二元运算符的优先级高于三元运算符的优先级。
4：赋值运算符优先级最低。
5：配合小括号使用。
附加：random随机数
一、Math.random();返回值是一个随机的double 值
语句：Math.random() * (MAX-MIN) + MIN
取整：int value = (int)(Math.random() * (MAX-MIN) + MIN);
二、导入import java.util.Random产生随机数
位移运算符：一条语句产生随机数：int value = (random.nextInt()>>>1)%(MAX-MIN)+MIN;
练习：随机数+三目运算符应用[ 求三个数的最大值 ]
1 // 得到随机数 2 import java.util.Random; 3 public class RandomNumber{ 4 public static void main(String[] args){ 5 // 定义随机数区间 6 final int MIN = 1,MAX = 100; 7 Random random = new Random(); 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 }
七、基本数据类型转换
方式：自动类型转换（也叫隐式类型转换）， 强制类型转换（也叫显式类型转换）
类型转换：java 不支持 不一样类型之间的运算。若是有不一样类型之间的数据作运算的话，那么首先第一步作同类型转换。编译器来完成这种转换的。自动的完成的。
转换的规则
1：全部的 byte、short、char 的值将被提高到int型。
2：若是一个操做数是long型，计算结果就是long型；
3：若是一个操做数是float型，计算结果就是float型；
4：若是一个操做数是double型，计算结果就是double型。System.out.println(6 % 123456L);// 2.0
上述的转换都是 编译器 来完成的。自动完成的。在编译期完成类型的转换，也就是将小类型的数据 看成大类型的数据来使用（若是须要）。
注意：1 和 2 自动转换 是 绝对安全的。 三、4 有可能存在精度的损失。java 语法上这样是容许的
自动类型提高
强制类型转换。语法：(强制转换为的类型)(被转换的数据);
example[ 类型自动提高 && 强制类型转换 ]
1 /*类型提高&强制转换*/ 2 class VarDemo2 3 { 4 public static void main(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 }
&& 获得一个随机字符[A-Z]or[a-z](大小写也随机)
1 // 获得一个随机字符[A-Z]or[a-z](大小写也随机) 2 import java.util.Random; 3 public class RandomCharTest{ 4 public static void main(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 = new Random(); 12 // 大小写随机 三目运算符进行判断 13 boolean isUpperCase = random.nextBoolean(); 14 ranChar = isUpperCase ? ranChar : (char)(ranChar+32); 15 System.out.println("获得随机字符："+ranChar); 16 17 } 18 }
八、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 import java.util.Random; 5 public class IfTest { 6 public static void main(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 < num2) { 19 max = num2; 20 } 21 System.out.println("max="+max); 22 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 }
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 class IfElse{ 8 public static void main(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 <CRITICAL_PERCENT; 43 /** 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 }
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 class IfElseIfElse{ 5 public static void main(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 }
&& 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：
一、对具体的值进行判断；
二、对区间判断；
三、对运算结果是boolean类型的表达式进行判断；
switch：
一、对具体值进行判断；
二、值的个数一般固定的；
三、对于几个固定值得判断，使用switch语句，switch将具体的值加载内存，效率相对高；
&& SwitchDemo
1 public class SwitchDemo 2 { 3 public static void main(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 }
&& SwitchTest
1 class SwitchTest 2 { 3 public static void main(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 }
九、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 import java.util.Scanner; 7 public class GameTest{ 8 public static void main(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 = new Scanner(System.in); 30 31 /** while循环判断 32 电脑胜利总次数、玩家胜利总次数小于最大总次数 33 */ 34 35 while(computerWinCount < MAX_WIN_CONUT && playerWinCount < MAX_WIN_CONUT){ 36 // 显示每次开始的局数 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 case STONE: 77 System.out.println("[玩家]选择的是[石头]"); 78 break; 79 case SCISSORS: 80 System.out.println("[玩家]选择的是[剪刀]"); 81 break; 82 case CLOTH: 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 }
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 class Demo { 5 public static void main(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 }
流程跳转语句[ break continue ]
break语句：应用范围：选择结构和循环结构。
当break语句单独存在时，下面不要定义其余语句，由于执行不到。
标号的出现，可让这两个语句做用于指定的范围
continue语句：应用于循环结构，结束本次循环继续下次循环。
当continue语句单独存在时，下面不要定义其余语句，由于执行不到
for 循环的嵌套
&& 百钱买鸡小案例
1 // 鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？ 2 public class DoubleLoopTest{ 3 4 public static void main(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 }
Example
不一样形状的输出 双重For循环
正三角
倒三角
数字正倒着
乘法表test
三层For循环
十、方法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 class Temp { 3 public static void main(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,int num2){ 14 return num1+num2; 15 } 16 // 两个double类相加 17 public static double add(double num1,double num2){ 18 return num1+num2; 19 } 20 // 三个int型相加 21 public static int add(int num1,int num2,int num3){ 22 // 相同类型重载num1+num2功能 23 return add(num1,num2)+num3; 24 25 } 26 27 }
- 1. Java基础——基础语法
- 2. Java 基础语法
- 3. java基础语法
- 4. java 基础语法
- 5. Java基础语法
- 6. java语法基础
- 7. Java语法基础
- 8. JAVA基础语法
- 9. Java——基础语法
- 10. java--基础语法
- 更多相关文章...
- • Kotlin 基础语法 - Kotlin 教程
- • Scala 基础语法 - Scala教程
- • Kotlin学习（一）基本语法
- • ☆基于Java Instrument的Agent实现
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Java基础——基础语法
- 2. Java 基础语法
- 3. java基础语法
- 4. java 基础语法
- 5. Java基础语法
- 6. java语法基础
- 7. Java语法基础
- 8. JAVA基础语法
- 9. Java——基础语法
- 10. java--基础语法