一，入门基础和环境准备
java面向对象的程序设计的重点是类的设计；类的设计 ，就是类成员的设计
1，java入门
代码相关说明
//1.public class Hello 表示Hello是一个类，是一个public公有的类
//2.Hello{ }表示一个类的·开始和结束
//3.public static void main(String[] args)表示一个主方法，即程序的入口
//4.main（）{ } 表示方法的开始和结束
//5.System.out.println("XXX");表示输出XXX到屏幕上
//6.；表示语句结束
public class Hello{
//编写一个main的方法
public static void main(string[] args){
system.out.println("hello,world~");
}
}二，基本数据类型
1，标识符和关键字
（1）标识符
标识符 是为方法、变量或其他用户定义项所定义的名称。
标识符可以有一个或多个字符。
【1】在 Java 语言中，标识符的构成规则如下。
标识符由数字（0~9）和字母（A~Z 和 a~z）、美元符号（$）、下划线（_）以及 Unicode 字符集中符号大于 0xC0 的所有符号组合构成（各符号之间没有空格）。
标识符的第一个符号不能为数字，可以为字母、下划线和美元符号，后面可以是任何字母、数字、美元符号或下划线。
标识符不能是关键字
标识符不能是true，false，null（尽管其不是标识符）
（Java 区分大小写，标识符可以包含关键字，但不能与关键字重名。）
（2）关键字
【1】50个关键字
Java 语言目前定义了 50个关键字，这些关键字不能作为变量名、类名和方法名来使用。以下对这些关键字进行了分类。
数据类型：boolean、int、long、short、byte、float、double、char、class、interface。
流程控制：if、else、do、while、for、switch、case、default、break、continue、return、try、catch、finally。
修饰符：public、protected、private、final、void、static、strict、abstract、transient、synchronized、volatile、native。
动作：package、import、throw、throws、extends、implements、this、super、instanceof、new。
保留字：true、false、null、goto、const。
（3）Unicode字符集
Unicode字符集 目前国际通用的字符集叫Unicode（又叫万国码、统一码），全世界所有民族地区的文字基本都包含在里面。它的出现是为了解决世界各地用不同的一套字符集，然后计算机软件无法兼容共用的问题，造福了软件开发者，也方便了用户。
2，常量和变量
（1）常量的定义和分类
常量值 又称为字面常量，（它是通过数据直接表示的，因此有很多种数据类型，像整型和字符串型等。）
【1】常量的分类
*1*整型常量值
Java 的整型常量值主要有如下 4 种形式。
十进制数形式：如 54、-67、0。
二进制数形式：以数字0和字母B或者b作为前缀
八进制数形式：Java 中的八进制常数的表示以 0 开头，如 0125 表示十进制数 85，-013 表示十进制数 -11。
十六进制数形式：Java 中的十六进制常数的表示以 0x 或 0X 开头，如 0x100 表示十进制数 256，-0x16 表示十进制数 -22。
*2*实型常量值
Java 的实型常量值主要有如下2种形式。
十进制数形式：由数字和小数点组成，且必须有小数点，如 12.34、-98.0。
科学记数法形式：如 1.75e5 或 32&E3，其中 e 或 E 之前必须有数字，且 e 或 E 之后的数字必须为整数。
*3*布尔型常量值boolean
Java 的布尔型常量只有两个值，即 false（假）和 true（真）。
*4*字符型和字符串常量值
Java 的字符型常量值是用单引号引起来的一个字符，如 'e'、E'。需要注意的是，Java 字符串常量值中的单引号和双引号不可混用。双引号用来表示字符串，像 "11"、"d" 等都是表示单个字符的字符串。
*5*转义字符
Java 还允许使用一种特殊形式的字符常量值来表示一些难以用一般字符表示的字符，这种特殊形式的字符是以开头的字符序列，称为转义字符。
转义字符 | 说明 |
\ddd | 1~3 位八进制数所表示的字符 |
\uxxxx | 1~4 位十六进制数所表示的字符 |
\' | 单引号字符 |
\" | 双引号字符 |
\\ | 双斜杠字符 |
\r | 回车 |
\n | 换行 |
\b | 退格 |
\t | 横向跳格 |
【2】定义常量
常量有三种类型：静态常量、成员常量和局部常量。
Java 语言使用 final 关键字来定义一个常量，final 关键字表示最终的，它可以修改很多元素，修饰变量就变成了常量其语法 如下所示：
final dataType variableName = value；
关键字 数据类型 变量名称 =初始值；
final 是定义常量的关键字，
dataType 指明常量的数据类型，
variableName 是变量的名称，
value 是初始值。在定义常量时，需要注意如下内容：
在定义常量时就需要对该常量进行初始化。
final 关键字不仅可以用来修饰基本数据类型的常量，还可以用来修饰对象的引用或者方法。
为了与变量区别，常量取名一般都用大写字符。
当常量被设定后，一般情况下不允许再进行更改，如果更改其值将提示错误
public class HelloWorld {
// 静态常量
public static final double PI = 3.14;
// 声明成员常量
final int y = 10;
public static void main(String[] args) {
// 声明局部常量
final double x = 3.3;
}
}
代码第 3 行的是声明静态常量，使用在 final 之前 public static 修饰。public static 修饰的常量作用域是全局的，不需要创建对象就可以访问它，在类外部访问形式为 HelloWorld. PI。这种常量在编程中使用很多。
代码第 5 行声明成员常量，作用域类似于成员变量，但不能修改。代码第 9 行声明局部常量，作用域类似于局部变量，但不能修改。(2)变量的声明，赋值和作用域
java是强类型（Strongly Typed）语言，强类型包含以下两方面的含义：
所有的变量必须先声明、后使用。
指定类型的变量只能接受类型与之匹配的值。
【1】变量的声明
在 java 中可以通过指定数据类型和标识符来声明变量，其基本语法如下所示：
DataType identifier;
或
DataType identifier=value;上述语法代码中涉及 3 个内容：DataType、 identifier 和 value，其具体说明如下：
DataType：变量类型，如 int、string、 char 和 double 等。
identifier：标识符，也叫变量名称。
value：声明变量时的值。
（变量标识符的命名规范如下：
首字符必须不能是数字，可以是字母、下划线（―）、美元符号（$）或者人民币符号（¥）。
标识符由数字（0~9）、大写字母（A~Z）、小写字母（a~z）、下划线（―）、美元符号（$）、人民币符号（¥）以及所有在十六进制 0xc0 前的 ASCII 码组成。
不能把关键字、保留字（true，false，null）作为标识符。
标识符的长度没有限制。
标识符区分大小写。）
String employee; // String 类型的变量
boolean isSave; // boolean 类型的变量
int create_at; // int 类型的变量【2】变量的赋值
初始化变量是指为变量指定一个明确的初始值。初始化变量有两种方式：一种是声明时直接赋值，一种是先声明、后赋值。如下代码分别使用两种方式对变量进行了初始化。
char usersex='女'; // 直接赋值
或者
String username; // 先声明
username ="琪琪"; // 后赋值Java 中初始化变量时需要注意以下事项：
变量是类或者结构中的字段，如果没有显式地初始化，默认状态下创建变量并默认初始值为 0。
方法中的变量必须显式地初始化，否则在使用该变量时就会出错。
另外，多个同类型的变量可以同时定义或者初始化，但是多个变量中间要使用逗号分隔，声明结束时用分号分隔。
String username,address,phone,tel; // 声明多个变量
int num1=12,num2=23,result=35; // 声明并初始化多个变量【3】变量的作用域
定义在方法体和语句块之外，不属于任何一个方法，作用域是整个类。
名称 | 修饰 | 访问 | 生命周期 |
全局变量（实例变量） | 无 static 修饰 | 对象名.变量名 | 只要对象被当作引用，实例变量就将存在 |
静态变量（类变量） | 用 static 修饰 | 类名.变量名或对象名.变量名 | 其生命周期取决于类的生命周期。类被垃圾回收机制彻底回收时才会被销毁 |
public class DataClass {
String name; // 成员变量、实例变量
int age; // 成员变量、实例变量
static final String website = "C语言中文网"; // 成员变量、静态变量(类变量)
static String URL = "http://c.biancheng.net"; // 成员变量、静态变量(类变量)
}*1*局部变量
局部变量是指在方法或者方法代码块中定义的变量，其作用域是其所在的代码块。可分为以下三种：
方法参数变量（形参）：在整个方法内有效。
方法局部变量（方法内定义）： 从定义这个变量开始到方法结束这一段时间内有效。
代码块局部变量（代码块内定义）：从定义这个变量开始到代码块结束这一段时间内有效。
局部变量在使用前必须被程序员主动初始化值。
【4】变量的作用域
*1*方法局部变量
声明两个局部变量并输出其值，其实现代码如下：
public class Test2 {
public static void main(String[] args) {
int a = 7;//局部变星a，int 类型的 a 的作用域是整个 main() 方法，
if (5 > 3) {
int s = 3;// 声明一个 int 类型的局部变量s的作用域是 if 语句的代码块内
System.out.println("s=" + s);
System.out.println("a=" + a);
}
System.out.println("a=" + a);
}
}*2*方法参数变量
作为方法参数声明的变量的作用域是整个方法。
声明一个方法参数变量，实现代码如下：
public class Test3 {
public static void testFun(int n) {
System.out.println("n=" + n);
}
public static void main(String[] args) {
testFun(3);
}
}（3）代码块局部变量
代码块局部变量常用于 try catch 代码块中，成为异常处理参数变量。
public class Test4 {
public static void test() {
try {
System.out.println("Hello!Exception!");
} catch (Exception e) { // 异常处理块，参数为 Exception 类型
e.printStackTrace();
}
}
public static void main(String[] args) {
test();
}
}3，基本数据类型
基本数据类型 包括 boolean（布尔型）、float（单精度浮点型）、char（字符型）、byte（字节型）、short（短整型）、int（整型）、long（长整型）和 double （双精度浮点型）共 8 种，
字节型 | byte | 1 字节 |
短整型 | short | 2 字节 |
整型 | int | 4 字节 |
长整型 | long | 8 字节 |
单精度浮点型 | float | 4 字节 |
双精度浮点型 | double | 8 字节 |
字符型 | char | 2 字节 |
布尔型 | boolean | 1 字节 |
提示：char 代表字符型，实际上字符型也是一种整数类型，相当于无符号整数类型。
基本数据类型又可分为 4 大类，即整数类型（包括 byte、short，int 和 long）、浮点类型（包括 float 和 double）、布尔类型和字符类型（char）
public static void main(String[] args) {
byte a = 20; // 声明一个byte类型的变量并赋予初始值为20
short b = 10; // 声明一个short类型的变量并赋予初始值为10
int c = 30; // 声明一个int类型的变量并赋予初始值为30
long d = 40; // 声明一个long类型的变量并赋予初始值为40
long sum = a + b + c + d;
System.out.println("20+10+30+40=" + sum);
}（1）整数类型
ava 定义了 4 种整数类型变量：字节型（byte）、短整型（short）、整型（int）和长整型（long）。这些都是有符号的值，正数或负数。具体说明表 2 所示：
表 2 Java整数类型变量说明
名称 | 说明 |
字节型（byte） | byte 类型是最小的整数类型。当用户从网络或文件中处理数据流时，或者处理可能与 Java 的其他内置类型不直接兼容的未加工的二进制数据时，该类型非常有用。 |
短整型（short） | short 类型限制数据的存储为先高字节，后低字节，这样在某些机器中会出错，因此该类型很少被使用。 |
整型（int） | int 类型是最常使用的一种整数类型。 |
长整型（long） | 对于大型程序常会遇到很大的整数，当超出 int 类型所表示的范围时就要使用 long 类型。 |
（2）浮点类型
浮点类型是带有小数部分的数据类型，也叫实型。浮点型数据包括单精度浮点型（float）和双精度浮点型（double），代表有小数精度要求的数字。
（一个值要能被真正看作 float，它必须以 f（或 F）后缓结束；否则，会被当作 double 值。对 double 值来说，d（或 D）后缓是可选的。）
（3）布尔类型
布尔类型（boolean） Java 中用保留字 true 和 false 来代表逻辑运算中的“真”和“假”。（一个 boolean 类型的变量或表达式只能是取 true 和 false 这两个值中的一个。）
（在 Java 语言中，布尔类型的值不能转换成任何数据类型，true 常量不等于 1，而 false 常量也不等于 0。这两个值只能赋给声明为 boolean 类型的变量，或者用于布尔运算表达式中。）
（4）字符类型
一般计算机语言使用 ASCII 编码，用一个字节表示一个字符。字符型变量的类型为 char，用来表示单个的字符。
Unicode 字符通常用十六进制表示。例如“\u0000”~“\u00ff”表示 ASCII 码集。“\u”表示转义字符，它用来表示其后 4 个十六进制数字是 Unicode 码。
（ASCII 码是 Unicode 码的一个子集，用 Unicode 表示 ASCII 码时，其高字节为 0，它是其前 255 个字符。）
（5）Java引用数据类型
引用数据类型建立在基本数据类型的基础上，包括数组、类和接口。引用数据类型是由用户自定义，用来限制其他数据的类型（Java 语言中不支持 C++ 中的指针类型、结构类型、联合类型和枚举类型。）
引用类型还有一种特殊的 null 类型。所谓引用数据类型就是对一个对象的引用，对象包括实例和数组两种。（引用类型变量就是一个指针，只是 Java 语言里不再使用指针这个说法）
空类型（null type）就是 null 值的类型，这种类型没有名称。因为 null 类型没有名称，所以不可能声明一个 null 类型的变量或者转换到 null 类型。
空引用（null）是 null 类型变量唯一的值。空引用（null）可以转换为任何引用类型。
在实际开发中，程序员可以忽略 null 类型，假定 null 只是引用类型的一个特殊直接量。
（注意：空引用（null）只能被转换成引用类型，不能转换成基本类型，因此不要把一个 null 值赋给基本数据类型的变量。）
4，数据类型转换
（1）算术运算符
表 1 一元算术运算
运 算 符 | 名 称 | 说 明 | 例 子 |
- | 取反符号 | 取反运算 | b=-a |
++ | 自加一 | 先取值再加一，或先加一再取值 | a++ 或 ++a |
-- | 自减一 | 先取值再减一，或先减一再取值 | a-- 或 --a |
运算符 | 含义 | 实例 | 结果 |
i++ | 将 i 的值先使用再加 1 赋值给 i 变量本身 | int i=1; int j=i++; | i=2 j=1 |
++i | 将 i 的值先加 1 赋值给变量 i 本身后再使用 | int i=1; int j=++i; | i=2 j=2 |
自增/自减只能作用于变量。（不允许对常量、表达式或其他类型的变量进行操作。常见的错误是试图将自增或自减运算符用于非简单变量表达式中）
自增/自减运算可以用于整数类型 byte、short、int、long，浮点类型 float、double，以及字符串类型 char。
表 2 二元算术运算
运 算 符 | 名 称 | 说 明 | 例 子 |
+ | 加 | 求 a 加 b 的和，还可用于 String 类型，进行字符串连接操作 | a + b |
- | 减 | 求 a 减 b 的差 | a - b |
* | 乘 | 求 a 乘以 b 的积 | a * b |
/ | 除 | 求 a 除以 b 的商 | a / b |
% | 取余 | 求 a 除以 b 的余数 | a % b |
表 3 算术赋值运算
运 算 符 | 名 称 | 例 子 |
+= | 加赋值 | a += b、a += b+3 |
-= | 减赋值 | a -= b即a=a-b |
*= | 乘赋值 | a *= b即a=a*b |
/= | 除赋值 | a /= b即a=a/b |
%= | 取余赋值 | a %= b |
（2）赋值运算符
变量名称=表达式内容
赋值运算符是指为变量或常量指定数值的符号。赋值运算符的符号为“=”，它是双目运算符，左边的操作数必须是变量，不能是常量或表达式。
(3)逻辑运算符
表 1 逻辑运算符的用法、含义及实例
运算符 | 用法 | 含义 | 说明 | 实例 | 结果 |
&& | a&&b | 短路与 | ab 全为 true 时，计算结果为 true，否则为 false。 | 2>1&&3<4 | true |
|| | a||b | 短路或 | ab 全为 false 时，计算结果为 false，否则为 true。 | 2<1||3>4 | false |
! | !a | 逻辑非 | a 为 true 时，值为 false，a 为 false 时，值为 true | !(2>4) | true |
| | a|b | 逻辑或 | ab 全为 false 时，计算结果为 false，否则为 true | 1>2|3>5 | false |
& | a&b | 逻辑与 | ab 全为 true 时，计算结果为 true，否则为 false | 1<2&3<5 | true |
&& 与 & 区别：
使用&运算符，必须两侧的都是true，结果为真。使用&&运算符，重点看第一个表达式，第一个表达式为false，后面的表达式就不计算（因为有短路功能），如果第一个表达式是true，后面就会继续进行计算，直到后面全部都为true，才为真。
boolean resultOne = 1==3 & 1==1 & 2==2; //使用 &
boolean resultTwo = 1==3 && 1==1 && 2==2; //使用 &&
System.out.println(resultOne); //resultOne = false
System.out.println(resultTwo); //resultTwo = false
//当使用 & 时，要进行 1==3 & 1==1 & 2==2 的判断
//当使用 && 时，因为 1==3 为 false，所以进行了短路的操作，后面的1==1 && 2==2 不用执行。
|| 与 | 区别：都是表示“或”，区别是||只要满足第一个条件，后面的条件就不再判断，而|要对所有的条件进行判断。
注意：短路与（&&）和短路或（||）能够采用最优化的计算方式，从而提高效率。在实际编程时，应该优先考虑使用短路与和短路或。
逻辑运算符的优先级为：！运算级别最高，&& 运算高于 || 运算。！运算符的优先级高于算术运算符，而 && 和 || 运算则低于关系运算符。结合方向是：逻辑非（单目运算符）具有右结合性，逻辑与和逻辑或（双目运算符）具有左结合性。
（4）关系运算符
关系运算符（relational operators）也可以称为“比较运算符”，用于用来比较判断两个变量或常量的大小。关系运算符是二元运算符，运算结果是 boolean 型。当运算符对应的关系成立时，运算结果是 true，否则是 false。
表 1 比较运算符的含义及其实例应用
运算符 | 含义 | 说明 | 实例 | 结果 |
> | 大于运算符 | 两边操作数必是数值类型。如果前面值大， 则返回 true。 | 2>3 | false |
>= | 大于或等于运算符 | 两边操作数是数值类型。如果前面值大于等于后者， 则返回 true。 | 4>=2 | true |
< | 小于运算符 | 两边操作数是数值类型。如果前面值小，则返回 true。 | 2<3 | true |
<= | 小于或等于运算符 | 两边操作数是数值类型。如果前面值小于等于后者， 则返回 true。 | 4<=2 | false |
== | 相等运算符 | 如果比较的两个操作数都是数值类型，无论它们的数据类型是否相同，只要它们的值相等，也都将返回 true。 如果两个操作数都是引用类型，只有当两个引用变量的类型具有父子关系时才可以比较，只要两个引用指向的不是同一个对象就会返回 true。 Java 也支持两个 boolean 类型的值进行比较。 | 4==4 97=='a' 5.0==5 true==false | true true true false |
!= | 不相等运算符 | 如果进行比较的两个操作数都是数值类型，与它们的数据类型是否相同无关，只要它们的值不相等，也都将返回 true。 如果两个操作数都是引用类型，只有当两个引用变量的类型具有父子关系时才可以比较，只要两个引用指向的不是同一个对象就会返回 true。 | 4!=2 | true |
【1】不能使用==的情况：
基本类型的变量、值不能和引用类型的变量、值使用 == 进行比较
boolean 类型的变量、值不能与其他任意类型的变量、值使用 == 进行比较
如果两个引用类型之间没有父子继承关系，那么它们的变量也不能使用 == 进行比较
（== 和 != 可以分别应用于基本数据类型和引用类型之间的比较。当用于引用类型比较时，比较的是两个引用是否指向同一个对象。（但当时实际开发过程多数情况下，只是比较对象的内容是否相当，不需要比较是否为同一个对象））
【2】关系运算符的优先符：
关系运算符的优先级为：>、<、>=、<= 具有相同的优先级，并且高于具有相同优先级的 !=、==
算术运算符>关系运算符>赋值运算符
结合方向是自左向右
【3】注意：
运算符 >=、==、！=、<= 是两个字符构成的一个运算符，用空格从中分开写就会产生语法错误（在运算符的两侧增加空格会提高可读性）
将运算符写反，例如 =>、=<、=! 等形式会产生语法错误
浮点数进行 ==（相等）或 !=（不相等）的比较，易产生错误，应该尽量避免（计算机内存放的实数与实际的实数存在着一定的误差）
“==”是比较，而“=”是赋值
（5）位运算符
位逻辑运算符包含 4 个 ： &（与）、|（或）、~（非）和 ^（异或）
除了 ~（即位取反）为单目运算符外，其余都为双目运算符。
表 1 位逻辑运算符
运算符 | 含义 | 实例 | 结果 |
& 双目 | 按位进行与运算（AND） | 4 & 5 | 4 |
| 双目 | 按位进行或运算（OR） | 4 | 5 | 5 |
^ 双目 | 按位进行异或运算（XOR） | 4 ^ 5 | 1 |
~ 单目 | 按位进行取反运算（NOT） | ~ 4 | -5 |
【1】为运算符&
参与运算的数字，低位对齐，高位不足的补零，如果对应的二进制位同时为 1，那么计算结果才为 1，否则为 0
int x = 5,y = 12; // 创建整型变量保存两个数
int z = x&y; // 对这两个数进行位与运算，结果保存到z，z为4
【2】位或运算符|
参与运算的数字，低位对齐，高位不足的补零。只有对应的二进制位都为 0，结果才为 0，否则为1（如果对应的二进制位只要有一个为 1，那么结果就为 1）
int x=11,y=7;
int z=x|y; //z为15
【3】位异或运算符^
参与运算的数字，低位对齐，高位不足的补零，如果对应的二进制位相同时，结果为0，否则为 1（两者都同时为 0 或同时为 1时结果为0）
注：在有的高级语言中，将运算符^作为求幂运算符，要注意区分
int x=11,y=7;
int z=x^y;//z为12
【4】位取反运算符～
只对一个操作数进行运算，将操作数二进制中的 1 改为 0，0 改为 1（除开表示正负的最高位。
一个二进制数占8个字节
int x=10;
System。out.printf（“%d \n",~x);// ~x为二进制65525,但由于输出%d为十进制所以输出11
【5】位移运算符
（6）条件运算符
result = <expression> ? <statement1> : <statement3>;
（7）运算符优先级
优先级 | 运算符 | 结合性 |
1 | ()、[]、{} | 从左向右 |
2 | !、+、-、~、++、-- | 从右向左 |
3 | *、/、% | 从左向右 |
4 | +、- | 从左向右 |
5 | «、»、>>> | 从左向右 |
6 | <、<=、>、>=、instanceof | 从左向右 |
7 | ==、!= | 从左向右 |
8 | & | 从左向右 |
9 | ^ | 从左向右 |
10 | | | 从左向右 |
11 | && | 从左向右 |
12 | || | 从左向右 |
13 | ?: | 从右向左 |
14 | =、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>= | 从右向左 |
（8）直接量的赋值
int a = 5;
char c = 'a';
boolean b = true;
float f = 5.12f;
double d = 4.12;
String name = "C语言中文网";5,输入与输出
（1） 输入语句
在Java中，输入需要依赖Scanner类，Scanner是JDK 1.5新增的一个类，可以使用该类创建一个对象：
Scanner reader = new Scanner(System.in); |
reader对象调用下列方法，读取用户在命令行输入的各种基本类型数据：
nextBoolean()：输入布尔值
nextByte()：输入字节
nextShort()：输入短整数
nextInt()：输入整数
nextLong()：输入长整数
nextFloat()：输入单精度浮点数
nextDouble()：输入双精度浮点数
（2） 输出语句
Java常用的输出语句有三种：
1）System.out.println();
换行打印，输出后会自动换行。
2）System.out.print();
不换行打印。
3）System.out.printf();
按格式输出。
常见的格式控制符如下：
格式控制符 | 说明 |
%d | 输出int型数据 |
%c | 输出char型数据 |
%f | 输出浮点型数据，小数部分最多保留6位 |
%s | 输出字符串数据 |
%md | 输出的int型数据占m列 |
%m.nf | 输出的浮点型数据占m列，小数点保留n位 |
在使用System.out.println()或System.out.print()输出字符串常量时，不能出现“回车”，例如：
System.out.println(“你好， 很高兴认识你”); //该写法无法通过编译 |
如果需要输出较长的字符串，我们可以将字符串分解成几部分，然后使用并置符号+将它们首尾相连，例如：
System.out.println(“你好，”+ “很高兴认识你”); //该写法为正确写法 |
三，流程控制语句
1，顺序结构语句
1，空语句
；//一个分号2，表达式语句
一般表达式语句应该能完成一个操作，如修改变量的值或者作为函数参数等
pi = 3.141;
output(pi); // 将pi的值传递到output()函数中作为参数
printf("%f",sum); // 将sum的值传递到printf()函数输出
temp = x*y*z-y+(20-x); // 将表达式的值保存到temp变量中3，复合语句
如果语句块是空的，控制转到语句块的结束点。
如果语句块不是空的，控制转到语句列表。当控制到达语句列表的结束点时，控制转到语句的结束点。
{
statement-list // 语句列表
}2，选择结构
1，foreach
“类型”为集合元素的类型，“变量名”表示集合中的每一个元素，“集合”是被遍历的集合对象或数组
for(类型type 变量名x:集合obj) {
含x的语句块;
}从上面程序可以看出，使用 foreach 循环遍历数组元素时无须获得数组长度，也无须根据索引来访问数组元素。foreach 循环和普通循环不同的是，它无须循环条件，无须循环迭代语句，这些部分都由系统来完成，foreach 循环自动迭代数组的每个元素，当每个元素都被迭代一次后，foreach 循环自动结束。
当使用 foreach 循环来迭代输出数组元素或集合元素时，通常不要对循环变量进行赋值，虽然这种赋值在语法上是允许的，但没有太大的实际意义，而且极容易引起错误。例如下面程序。
String[] urls = { "http://c.biancheng.net/java", "http://c.biancheng.net/c", "http://c.biancheng.net/golang/" };
// 使用foreach循环来遍历数组元素
// 其中book将会自动迭代每个数组元素
for (String url : urls) {
System.out.println(url);
}7，2，if else结构（可以嵌套）
if(表达式1) {
语句块1;
} else if(表达式2) {
语句块2;
...
} else if(表达式n) {
语句块n;
} else {
语句块n+1;
}3，switch
switch(表达式) {
case 值1:
语句块1;
break;
case 值2:
语句块2;
break;
…
case 值n:
语句块n;
break;
default:
语句块n+1;
break;
}4，do while
do {
语句块;
}while(条件表达式);while(条件表达式) {
语句块;
}5，for
for(条件表达式1;条件表达式2;条件表达式3) {
语句块;
}6，return
return 与方法相同类型的变量;7，break
可以使用 break 语句强行退出循环，忽略循环体中的任何其他语句和循环的条件判断。在循环中遇到 break 语句时，循环被终止，在循环后面的语句重新开始。
8，continue
而是中止当前迭代的循环，进入下一次的迭代。简单来讲，continue 是忽略循环语句的当次循环。注意：continue 语句只能用在 while 语句、for 语句或者 foreach 语句的循环体之中，在这之外的任何地方使用它都会引起语法错误。
四，字符串
1，字符串定义
直接定义字符串是指使用双引号表示字符串中的内容。
String str = "Hello Java";
扫一扫
7287
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
