JavaSE复习之一 基础知识：Java的基础语法
2018-03-18 15:06
686 查看
[align=left]本文系转载，因为原文写的实在太好了，所以就偷懒一下，转载一下(。・∀・)ノ[/align]
原文地址：JavaSE复习之一 基础知识：Java的基础语法 http://blog.csdn.net/ggf123456789/article/details/41467483
Java的基础语法
1.数据类型 Java是面向对象的语言，也是强类型语言，变量在使用前需先定义后使用。在Java中共有八种基本类型，包括四种整型、两种
浮点数类型、一种字符类型、一种布尔类型，这八种类型不是对象。除基本类型之外的都叫做对象类型或引用类型。
1.1.整型 用于表示没有小数部分的数值，可以是负数。Java提供了四种整型数：整型（int）、短整型（short）、长整型（long）、
字节型（byte）。
1.2.浮点数类型
用于表示有小数部分的数值。Java提供两种浮点类型：单精度（float）、双精度（double）。其中单精度浮点数占用4个字节，
多精度浮点数占用8个字节。
[java] view plain copy print?float f1 = 5.0F;
double d1 = -3.45;
Java提供字符类型char，用于表示单个字符。对于字符Java采用Unicode字符编码（字符编码是指用一串二进制数据来表示特定
的字符）。常见的字符编码包括：
1) ASCII字符编码
美国信息互换标准代码（American Standard Code for Information Interchange）。
ASCII编码一共能表示128（二的七次方）个字符，是最通用的单字节编码系统。
2) ISO-8859-1字符编码
又称Latin-1，是国际标准化组织（ISO）为西欧语言的字符制定的编码，用一个字节来为字符编码。
3) GB2312字符编码
包括了对中文字符的编码，收录了7445个字符，其中汉字6763个，其他符号682个。
4) GBK字符编码
GBK是对GB2312字符编码的扩展，收录了21886个字符，分为汉字区和图形符号区。汉字区包括21003个字符。
5) Unicode字符编码
由国际Unicode协会（www.unicode.org）编制，收录了全世界所有语言文字中的字符，是一种跨平台的字符编码。
6) UTF字符编码
UTF（UCS Transformation Format）字符编码能够把Unicode字符编码转换为操作系统支持的编码。
1.4.布尔类型 任何一种高级编程语言都会使用布尔类型（boolean），用来进行逻辑判断。布尔类型的变量取值只能是true或false，表示逻辑
上的真和假。
Java虚拟机对布尔类型的处理：当编译器把Java源代码编译为字节码时，会用int或byte来表示boolean。在JVM中，用整数零来
表示false，用任意一个非零整数来表示true。但在为布尔类型变量赋值时，只能使用true或false。
1.5.数组
Java把数组当成对象，数组变量相当于对象的引用。
数组元素的默认值：布尔类型，默认值是false；字符型，默认值是'\u0000'；数值型，默认值是0或0.0；引用类型，默认值null
数组在使用中经常抛出的异常是：ArrayIndexOutOfBoundsException(数组下标越界异常)；
java.lang.NullPointerException(空指针异常)；
关于数组的工具类：java.util.Arrays(提供让我们对数组进行操作的方法，比如查找、排序);system.arraycppy(实现数组的拷贝)。
数组声明，实例化，赋初值的方法：
[java] view plain copy print?int a[] = new int[5]; // 形式一
a[0] = 10; a[1] = 8;
int[] b = new int[5]; // 形式二
int[][]c; intc[][]; // 形式三：多维数组
1.6.字符串
字符串（java.lang.String）对象是public final class的，也叫做断子绝孙类。
1.7.类 类是一组具有相同属性和行为的对象的抽象。
[java] view plain copy print?public abstract class 中国人 { // 抽象类不能被实例化
public abstract void 善良(); // 包含抽象方法的类一定是抽象类，抽象方法没有方法体；继承了抽象类的子类若未实现父类的抽象方法，
// 则一定也是抽象类，而非普通类。换句话，普通类继承抽象类，必须实现其抽象方法。
// 再换句话说：所有抽象方法都执行子类中重写后的方法。
public abstract void 勤劳(); //
public void 乐于助人(){}; // 抽象类中可以包含非抽象方法
}
public class 小明 extends 中国人 {
@Override
public void 善良() {
System.out.println("善良"); //
}
@Override
public void 勤劳() {
System.out.println("勤劳"); //
}
}
1.8.接口 接口是对类的抽象。
[java] view plain copy print?public interface 农村孩子 {
public static final String HP ="豌豆"; // 接口中的成员变量默认是public static final类型的，必须被显式初始化
public abstract void 憨厚(); // 接口中的方法默认都是public abstract类型的
public abstract void 老实(); // 接口中只能包含public static final类型的成员变量和public abstract类型的成员方法
public abstract void 肯吃苦(); // 接口没有有构造方法，不能被实例化；一个接口不能实现另一个接口，可以继承多个其他接口
// 普通类实现接口，必须实现接口的抽象方法；抽象类implements一个接口可以不实现其抽象方法
}
2.变量 每个变量都是有类型的，需满足先声明后使用的原则。声明变量：变量类型 变量名;变量名必须是一个以字母开头的由字母或数字构成的序列。字母包括'A'~'Z'、'a' ~'z'、'_'。
2.1.初始化及默认值
变量的默认值：
Boolean false
Char '\u0000' =>null
byte 0
short 0
int 0
long 0L
float 0.0f
double 0.0d
[java] view plain copy print?public class VarTest {
/**
* @param args
*/
private String ss = "aaa"; // 若ss未赋初始值，则在testVar()方法中打印出的是其默认值null
private int ii; // JVM会给ii赋值0，从而进行初始化
public String testVar(){
int t = 1;
String str; // 此处未赋值，而又不属于类的成员变量，JVM不会为其进行初始化。所以，在此方法内部使用时编译器会报错
System.out.println(t);
System.out.println(str); //编译器会报错，提示local variable may not initialized
System.out.println(ss);
System.out.println(ii);
return "suc";
}
public static void main(String args[]){
VarTest vt = new VarTest();
vt.testVar();
}
}
2.2.变量赋值和类型转换
下面的例子只涉及基本类型的类型转换：
[java] view plain copy print? int a;
a = 10; // 变量赋值
String arrayStr[] = {"a","b","c","d"}; //数组赋值
double d = a; //自动类型转换（）
double diu = 4.007; // 变量赋值
int aiu = (int)diu; //强制类型转换
System.out.println(aiu); // 打印出的aiu值为4，小数部分丢失
2.3.变量的作用域和生命周期
成员变量和局部变量
3.运算符 Java语言中的运算符可分为以下几种：算术运算符、赋值运算符、比较运算符、逻辑运算符、位运算符、类型相关运算符。
3.1.运算符
算术运算符：加（+）、减（-）、乘（＊）、除（／）、求余（%）、自增（++）、自减（--）；赋值运算符：Java使用=作为赋值运算符；
位运算符：与（&）、或（｜）、非（～）、异或（^）、左移运算符（<<）、右移运算符（>>）、无符号右移（>>>）；
比较运算符：大于（>）、大于等于（>=）、小于（<）、小于等于（<=）、等于（==）、不等于（！=）；
逻辑运算符：与（&&）、或（||）、非（!）、异或（^）、不短路与（&）、不短路或（|）；
三目运算符： （表达式）？语句1（表达式为true时执行）：语句2（表达式为false时执行）
运算符的优先级：
3.2.数学函数及常量 进行乘方、开方等复杂的数学运算，可使用java.lang.Math类提供的工具完成。
4.流程控制 编程语言常见的三种流程结构：顺序结构、分支结构（选择结构）、循环结构。
4.1.顺序结构
顺序结构是最常见的程序结构，指程序由上而下逐行执行直至结束。
4.2.分支结构
用于实现根据判断条件来选择性地执行某段代码。
分支控制结构使部分程序代码有条件的执行。即满足条件才执行，不满足则不执行。
if...else 语句
[java] view plain copy print?public void ifelse(){
if ( condition ){ // 形式一
execute statement
}
if ( condition ){ // 形式二
execute statement1
}else{
execute statement2
}
if ( condition1 ){ // 形式三
statement1
}else if ( condition2 ){ // 可以有零个或多个else if语句
statement2
}else{ // 此处的else语句可以省略
statement3
}
}
switch 语句 由一个控制表达式和多个case标签组成。switch语句后面的控制表达式的数据类型只能是byte、short、char、int四个整数类型和
枚举类型，不能是boolean类型。Java7中允许switch语句中的控制表达式为String类型。
[java] view plain copy print?public void TestSwitch(){
String condition = "str"; // Java7支持使用String作为表达式的数据类型
int a =1;
switch ( a ){
case 0: {System.out.println(a); break; }
case 1: {System.out.println(a); break; }
case 2: {System.out.println(a); break; }
case 3: {System.out.println(a); break; }
default:{System.out.println("default"); }
}
}
4.3.循环结构
用于实现根据循环条件重复执行某段代码。
循环控制结构使部分程序代码反复、重复执行，直到不满足循环条件为止才退出循环。
while (循环条件) {循环体}
[java] view plain copy print?public void TestWhile(){
int count = 10; // 循环的初始化条件
while (count > 0){ // 当count小于10时，执行循环体
System.out.print(count+" "); // 迭代语句
count--;
}
}
public static void main(String args[]){
FlowCo fc = new FlowCo();
fc.TestWhile();
}
// 输出：10 9 8 7 6 5 4 3 2 1
int coo = 10;
do{
System.out.print(coo+" "); // 循环语句
coo--;
}while (coo > 0); // 判断条件，即跳出循环的条件
}
public static void main(String args[]){
FlowCo fc = new FlowCo();
fc.TestDoWhile();
}
// 输出：10 9 8 7 6 5 4 3 2 1
for(初始化部分;循环条件;迭代部分){循环体}
[java] view plain copy print?public void TestFor(){
for(int cc=1;cc<10;cc++){ // for(初始条件;循环条件;步进)
System.out.println(cc); // 循环语句块
}
}
For Each循环：for(变量：集合) 循环语句[java] view plain copy print?public void TestForEach(){
List<String> list = new ArrayList<String>();
list.add("zhaobenshan");
list.add("zhaobenshui");
list.add("zhaosi");
for (String s:list){ //
System.out.println(s);
}
}
public static void main(String args[]){
FlowCo fc = new FlowCo();
fc.TestForEach();
}
控制程序执行顺序。
break ：从switch语句、循环语句或标号标识的代码块中退出。break不仅可以结束其所在的循环，还可以结束其外层循环。
continue ：跳出本次循环，执行下一次循环，或执行标号标识的循环体。
return ：退出本方法，跳到上一层。
5.数组
5.1.数组的初始化
静态初始化：
[java] view plain copy print?String[] strA = {"kali","ubuntu","fedora","centos","suse"};
for(int i=0;i<strA.length;i++){ System.out.println(strA[i]); }
动态初始化：
[java] view plain copy print?String[] strB = new String[10];
for(int i=0;i<10;i++){
strB[i] = i+"";
}
for(int i=0;i<strB.length;i++){ System.out.println(strB[i]); }
5.2 数组的操作
修订：
参考：
注：
原文地址：JavaSE复习之一 基础知识：Java的基础语法 http://blog.csdn.net/ggf123456789/article/details/41467483
Java的基础语法
1.数据类型 Java是面向对象的语言，也是强类型语言，变量在使用前需先定义后使用。在Java中共有八种基本类型，包括四种整型、两种
浮点数类型、一种字符类型、一种布尔类型，这八种类型不是对象。除基本类型之外的都叫做对象类型或引用类型。
1.1.整型 用于表示没有小数部分的数值，可以是负数。Java提供了四种整型数：整型（int）、短整型（short）、长整型（long）、
字节型（byte）。
1.2.浮点数类型
用于表示有小数部分的数值。Java提供两种浮点类型：单精度（float）、双精度（double）。其中单精度浮点数占用4个字节，
多精度浮点数占用8个字节。
[java] view plain copy print?float f1 = 5.0F;
double d1 = -3.45;
float f1 = 5.0F; double d1 = -3.45;1.3.字符类型
Java提供字符类型char，用于表示单个字符。对于字符Java采用Unicode字符编码（字符编码是指用一串二进制数据来表示特定
的字符）。常见的字符编码包括：
1) ASCII字符编码
美国信息互换标准代码（American Standard Code for Information Interchange）。
ASCII编码一共能表示128（二的七次方）个字符，是最通用的单字节编码系统。
2) ISO-8859-1字符编码
又称Latin-1，是国际标准化组织（ISO）为西欧语言的字符制定的编码，用一个字节来为字符编码。
3) GB2312字符编码
包括了对中文字符的编码，收录了7445个字符，其中汉字6763个，其他符号682个。
4) GBK字符编码
GBK是对GB2312字符编码的扩展，收录了21886个字符，分为汉字区和图形符号区。汉字区包括21003个字符。
5) Unicode字符编码
由国际Unicode协会（www.unicode.org）编制，收录了全世界所有语言文字中的字符，是一种跨平台的字符编码。
6) UTF字符编码
UTF（UCS Transformation Format）字符编码能够把Unicode字符编码转换为操作系统支持的编码。
1.4.布尔类型 任何一种高级编程语言都会使用布尔类型（boolean），用来进行逻辑判断。布尔类型的变量取值只能是true或false，表示逻辑
上的真和假。
Java虚拟机对布尔类型的处理：当编译器把Java源代码编译为字节码时，会用int或byte来表示boolean。在JVM中，用整数零来
表示false，用任意一个非零整数来表示true。但在为布尔类型变量赋值时，只能使用true或false。
1.5.数组
Java把数组当成对象，数组变量相当于对象的引用。
数组元素的默认值：布尔类型，默认值是false；字符型，默认值是'\u0000'；数值型，默认值是0或0.0；引用类型，默认值null
数组在使用中经常抛出的异常是：ArrayIndexOutOfBoundsException(数组下标越界异常)；
java.lang.NullPointerException(空指针异常)；
关于数组的工具类：java.util.Arrays(提供让我们对数组进行操作的方法，比如查找、排序);system.arraycppy(实现数组的拷贝)。
数组声明，实例化，赋初值的方法：
[java] view plain copy print?int a[] = new int[5]; // 形式一
a[0] = 10; a[1] = 8;
int[] b = new int[5]; // 形式二
int[][]c; intc[][]; // 形式三：多维数组
int a[] = new int[5]; // 形式一 a[0] = 10; a[1] = 8; int[] b = new int[5]; // 形式二 int[][]c; intc[][]; // 形式三：多维数组
1.6.字符串
字符串（java.lang.String）对象是public final class的，也叫做断子绝孙类。
1.7.类 类是一组具有相同属性和行为的对象的抽象。
[java] view plain copy print?public abstract class 中国人 { // 抽象类不能被实例化
public abstract void 善良(); // 包含抽象方法的类一定是抽象类，抽象方法没有方法体；继承了抽象类的子类若未实现父类的抽象方法，
// 则一定也是抽象类，而非普通类。换句话，普通类继承抽象类，必须实现其抽象方法。
// 再换句话说：所有抽象方法都执行子类中重写后的方法。
public abstract void 勤劳(); //
public void 乐于助人(){}; // 抽象类中可以包含非抽象方法
}
public class 小明 extends 中国人 {
@Override
public void 善良() {
System.out.println("善良"); //
}
@Override
public void 勤劳() {
System.out.println("勤劳"); //
}
}
public abstract class 中国人 { // 抽象类不能被实例化
public abstract void 善良(); // 包含抽象方法的类一定是抽象类，抽象方法没有方法体；继承了抽象类的子类若未实现父类的抽象方法，
// 则一定也是抽象类，而非普通类。换句话，普通类继承抽象类，必须实现其抽象方法。
// 再换句话说：所有抽象方法都执行子类中重写后的方法。
public abstract void 勤劳(); //
public void 乐于助人(){}; // 抽象类中可以包含非抽象方法
}
public class 小明 extends 中国人 {
@Override
public void 善良() {
System.out.println("善良"); //
}
@Override
public void 勤劳() {
System.out.println("勤劳"); //
}
}1.8.接口 接口是对类的抽象。
[java] view plain copy print?public interface 农村孩子 {
public static final String HP ="豌豆"; // 接口中的成员变量默认是public static final类型的，必须被显式初始化
public abstract void 憨厚(); // 接口中的方法默认都是public abstract类型的
public abstract void 老实(); // 接口中只能包含public static final类型的成员变量和public abstract类型的成员方法
public abstract void 肯吃苦(); // 接口没有有构造方法，不能被实例化；一个接口不能实现另一个接口，可以继承多个其他接口
// 普通类实现接口，必须实现接口的抽象方法；抽象类implements一个接口可以不实现其抽象方法
}
public interface 农村孩子 {
public static final String HP ="豌豆"; // 接口中的成员变量默认是public static final类型的，必须被显式初始化
public abstract void 憨厚(); // 接口中的方法默认都是public abstract类型的
public abstract void 老实(); // 接口中只能包含public static final类型的成员变量和public abstract类型的成员方法
public abstract void 肯吃苦(); // 接口没有有构造方法，不能被实例化；一个接口不能实现另一个接口，可以继承多个其他接口
// 普通类实现接口，必须实现接口的抽象方法；抽象类implements一个接口可以不实现其抽象方法
}2.变量 每个变量都是有类型的，需满足先声明后使用的原则。声明变量：变量类型 变量名;变量名必须是一个以字母开头的由字母或数字构成的序列。字母包括'A'~'Z'、'a' ~'z'、'_'。
2.1.初始化及默认值
变量的默认值：
Boolean false
Char '\u0000' =>null
byte 0
short 0
int 0
long 0L
float 0.0f
double 0.0d
[java] view plain copy print?public class VarTest {
/**
* @param args
*/
private String ss = "aaa"; // 若ss未赋初始值，则在testVar()方法中打印出的是其默认值null
private int ii; // JVM会给ii赋值0，从而进行初始化
public String testVar(){
int t = 1;
String str; // 此处未赋值，而又不属于类的成员变量，JVM不会为其进行初始化。所以，在此方法内部使用时编译器会报错
System.out.println(t);
System.out.println(str); //编译器会报错，提示local variable may not initialized
System.out.println(ss);
System.out.println(ii);
return "suc";
}
public static void main(String args[]){
VarTest vt = new VarTest();
vt.testVar();
}
}
public class VarTest {
/**
* @param args
*/
private String ss = "aaa"; // 若ss未赋初始值，则在testVar()方法中打印出的是其默认值null
private int ii; // JVM会给ii赋值0，从而进行初始化
public String testVar(){
int t = 1;
String str; // 此处未赋值，而又不属于类的成员变量，JVM不会为其进行初始化。所以，在此方法内部使用时编译器会报错
System.out.println(t);
System.out.println(str); //编译器会报错，提示local variable may not initialized
System.out.println(ss);
System.out.println(ii);
return "suc";
}
public static void main(String args[]){
VarTest vt = new VarTest();
vt.testVar();
}
}2.2.变量赋值和类型转换
下面的例子只涉及基本类型的类型转换：
[java] view plain copy print? int a;
a = 10; // 变量赋值
String arrayStr[] = {"a","b","c","d"}; //数组赋值
double d = a; //自动类型转换（）
double diu = 4.007; // 变量赋值
int aiu = (int)diu; //强制类型转换
System.out.println(aiu); // 打印出的aiu值为4，小数部分丢失
int a;
a = 10; // 变量赋值
String arrayStr[] = {"a","b","c","d"}; //数组赋值
double d = a; //自动类型转换（）
double diu = 4.007; // 变量赋值
int aiu = (int)diu; //强制类型转换
System.out.println(aiu); // 打印出的aiu值为4，小数部分丢失引用类型的类型转换（多态）及基本类型与引用类型的转换（自动装箱）在后面写。2.3.变量的作用域和生命周期
成员变量和局部变量
3.运算符 Java语言中的运算符可分为以下几种：算术运算符、赋值运算符、比较运算符、逻辑运算符、位运算符、类型相关运算符。
3.1.运算符
算术运算符：加（+）、减（-）、乘（＊）、除（／）、求余（%）、自增（++）、自减（--）；赋值运算符：Java使用=作为赋值运算符；
位运算符：与（&）、或（｜）、非（～）、异或（^）、左移运算符（<<）、右移运算符（>>）、无符号右移（>>>）；
比较运算符：大于（>）、大于等于（>=）、小于（<）、小于等于（<=）、等于（==）、不等于（！=）；
逻辑运算符：与（&&）、或（||）、非（!）、异或（^）、不短路与（&）、不短路或（|）；
三目运算符： （表达式）？语句1（表达式为true时执行）：语句2（表达式为false时执行）
运算符的优先级：
3.2.数学函数及常量 进行乘方、开方等复杂的数学运算，可使用java.lang.Math类提供的工具完成。
4.流程控制 编程语言常见的三种流程结构：顺序结构、分支结构（选择结构）、循环结构。
4.1.顺序结构
顺序结构是最常见的程序结构，指程序由上而下逐行执行直至结束。
4.2.分支结构
用于实现根据判断条件来选择性地执行某段代码。
分支控制结构使部分程序代码有条件的执行。即满足条件才执行，不满足则不执行。
if...else 语句
[java] view plain copy print?public void ifelse(){
if ( condition ){ // 形式一
execute statement
}
if ( condition ){ // 形式二
execute statement1
}else{
execute statement2
}
if ( condition1 ){ // 形式三
statement1
}else if ( condition2 ){ // 可以有零个或多个else if语句
statement2
}else{ // 此处的else语句可以省略
statement3
}
}
public void ifelse(){
if ( condition ){ // 形式一
execute statement
}
if ( condition ){ // 形式二
execute statement1
}else{
execute statement2
}
if ( condition1 ){ // 形式三
statement1
}else if ( condition2 ){ // 可以有零个或多个else if语句
statement2
}else{ // 此处的else语句可以省略
statement3
}
}switch 语句 由一个控制表达式和多个case标签组成。switch语句后面的控制表达式的数据类型只能是byte、short、char、int四个整数类型和
枚举类型，不能是boolean类型。Java7中允许switch语句中的控制表达式为String类型。
[java] view plain copy print?public void TestSwitch(){
String condition = "str"; // Java7支持使用String作为表达式的数据类型
int a =1;
switch ( a ){
case 0: {System.out.println(a); break; }
case 1: {System.out.println(a); break; }
case 2: {System.out.println(a); break; }
case 3: {System.out.println(a); break; }
default:{System.out.println("default"); }
}
}
public void TestSwitch(){
String condition = "str"; // Java7支持使用String作为表达式的数据类型
int a =1;
switch ( a ){
case 0: {System.out.println(a); break; }
case 1: {System.out.println(a); break; }
case 2: {System.out.println(a); break; }
case 3: {System.out.println(a); break; }
default:{System.out.println("default"); }
}
}4.3.循环结构
用于实现根据循环条件重复执行某段代码。
循环控制结构使部分程序代码反复、重复执行，直到不满足循环条件为止才退出循环。
while (循环条件) {循环体}
[java] view plain copy print?public void TestWhile(){
int count = 10; // 循环的初始化条件
while (count > 0){ // 当count小于10时，执行循环体
System.out.print(count+" "); // 迭代语句
count--;
}
}
public static void main(String args[]){
FlowCo fc = new FlowCo();
fc.TestWhile();
}
// 输出：10 9 8 7 6 5 4 3 2 1
public void TestWhile(){
int count = 10; // 循环的初始化条件
while (count > 0){ // 当count小于10时，执行循环体
System.out.print(count+" "); // 迭代语句
count--;
}
}
public static void main(String args[]){
FlowCo fc = new FlowCo();
fc.TestWhile();
}
// 输出：10 9 8 7 6 5 4 3 2 1do{循环体}while(循环条件)[java] view plain copy print?public void TestDoWhile(){ int coo = 10;
do{
System.out.print(coo+" "); // 循环语句
coo--;
}while (coo > 0); // 判断条件，即跳出循环的条件
}
public static void main(String args[]){
FlowCo fc = new FlowCo();
fc.TestDoWhile();
}
// 输出：10 9 8 7 6 5 4 3 2 1
public void TestDoWhile(){
int coo = 10;
do{
System.out.print(coo+" "); // 循环语句
coo--;
}while (coo > 0); // 判断条件，即跳出循环的条件
}
public static void main(String args[]){
FlowCo fc = new FlowCo();
fc.TestDoWhile();
}
// 输出：10 9 8 7 6 5 4 3 2 1for(初始化部分;循环条件;迭代部分){循环体}
[java] view plain copy print?public void TestFor(){
for(int cc=1;cc<10;cc++){ // for(初始条件;循环条件;步进)
System.out.println(cc); // 循环语句块
}
}
public void TestFor(){
for(int cc=1;cc<10;cc++){ // for(初始条件;循环条件;步进)
System.out.println(cc); // 循环语句块
}
}For Each循环：for(变量：集合) 循环语句[java] view plain copy print?public void TestForEach(){
List<String> list = new ArrayList<String>();
list.add("zhaobenshan");
list.add("zhaobenshui");
list.add("zhaosi");
for (String s:list){ //
System.out.println(s);
}
}
public static void main(String args[]){
FlowCo fc = new FlowCo();
fc.TestForEach();
}
public void TestForEach(){
List<String> list = new ArrayList<String>();
list.add("zhaobenshan");
list.add("zhaobenshui");
list.add("zhaosi");
for (String s:list){ //
System.out.println(s);
}
}
public static void main(String args[]){
FlowCo fc = new FlowCo();
fc.TestForEach();
}4.4.流程跳转控制程序执行顺序。
break ：从switch语句、循环语句或标号标识的代码块中退出。break不仅可以结束其所在的循环，还可以结束其外层循环。
continue ：跳出本次循环，执行下一次循环，或执行标号标识的循环体。
return ：退出本方法，跳到上一层。
5.数组
5.1.数组的初始化
静态初始化：
[java] view plain copy print?String[] strA = {"kali","ubuntu","fedora","centos","suse"};
for(int i=0;i<strA.length;i++){ System.out.println(strA[i]); }
String[] strA = {"kali","ubuntu","fedora","centos","suse"};
for(int i=0;i<strA.length;i++){ System.out.println(strA[i]); }动态初始化：
[java] view plain copy print?String[] strB = new String[10];
for(int i=0;i<10;i++){
strB[i] = i+"";
}
for(int i=0;i<strB.length;i++){ System.out.println(strB[i]); }
String[] strB = new String[10];
for(int i=0;i<10;i++){
strB[i] = i+"";
}
for(int i=0;i<strB.length;i++){ System.out.println(strB[i]); }5.2 数组的操作
修订：
参考：
注：
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- JavaSE复习之一 基础知识：Java的基础语法 补充（2）
- JavaSE复习之一 基础知识：Java的基础语法 补充（3）
- JavaSE复习之一 基础知识：Java的基础语法
- JavaSE复习之一 基础知识：Java的基础语法 补充（4）
- JavaSE复习之一 基础知识：Java的基础语法 补充（6）
- 【Java笔记】Week02 -- JavaSE基础语法、OOP基础知识
- JavaSE(1):java基础知识及基础语法
- java面试题----就当作是复习下基础知识啦
- JavaSE复习之四 基础知识：集合
- JavaSE 03 Java基础语法（二）
- java基础知识记录--类相关语法 （摘自张孝祥整理java面试题）
- JavaSe总结-02--Java基础语法(1)
- JavaSe总结-04--Java基础语法(3)
- JavaSE基础第二部分：Java基础语法之流程控制语句
- Java基础知识复习（一）
- 黑马程序员---------java 基础知识复习（foreach、Arrays、String、StringBuffer、容器类）
- 黑马程序员学习log第一篇基础知识：java概述及基础语法总结
- java基础知识复习
- javaSE_8系列博客——Java语言的特性（二）--高级语言的基础知识（7）-- 流程控制语句
- Java基础知识复习(一)