第4篇-JAVA基础

第4篇-JAVA基础

• 每篇一句 ：世界上本没有完美，但是我们从未放弃追求完美
• 初学心得： 乐于挥霍的时间，都不能算作浪费
• (笔者：JEEP/711)[JAVA笔记 | 时间:2017-04-01| JAVA基础 Ⅳ]

程序运行流程

(1) 顺序结构 

(2) 分支结构 

(3) 循环结构 

(4) break 与 continue关键字 

(5) 数组 

(6) 方法

1.顺序结构

如果代码里没有流程控制，程序是至上而下一行一行执行的 

一条语句执行完之后继续执行下一条语句，直到程序的最后

2.分支结构

顺序结构只能顺序执行，不能进行判断和选择，因此需要分支结构 

JAVA有两种分支结构：● if 语句 ● switch 语句 

(1)：if 语句，一个 if 语句包含一个布尔表达式和一条或多条语句 

if语句三种格式：

1.语句格式一：if(条件表达式){
2.        执行语句；
3.    }
4.语句格式二：if(条件表达式){
5.        执行语句；
6.    }else{
7.        执行语句；
8.    }
9.语句格式三：if(条件表达式){
10.        执行语句；
11.    }else if (条件表达式){
12.        执行语句；
13.    }
14.    ……
15.    else
16.    {
17.        执行语句；
18.    }      

if 语句的用语法如下： 如果布尔表达式的值为 true，则执行 if 语句中的代码块，否则执行 if 语句块后面的代码

1. if(布尔表达式) {
2.//如果布尔表达式为true将执行的语句
3. }      

if语句代码

1. /**
2. *if语句代码
3. **/
4. //定义一个Demo类
5.public class Demo {
6.//定义主方法
7.   public static void main(String args[]){
8.      int a = 10; //定义一个变量
9.      if( a < 100 ){
10.         System.out.print("这是 if 语句"); //输出语句
11.      }
12.   }
13.}      

if…else语句：if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句块会被执行 

if…else 的用法：

1. if(布尔表达式){
2. //如果布尔表达式的值为true
3.}else{
4. //如果布尔表达式的值为false
5. }      

if else语句代码如下：

1./**
2.*if else语句代码
3.*//
4.//定义一个Demo2类
5.public class Demo2 {
6.//定义一个主方法
7.   public static void main(String args[]){
8.      int b = 30; //声明一个变量并赋值
9.      if( b < 20 ){
10.         System.out.print("这是 if 语句");
11.      }else{
12.         System.out.print("这是 else 语句");
13.      }
14.   }
15.}      

(2)：switch 语句 

switch 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支 

case只是用来为switch选择一个执行代码的入口，如果一旦进入一个入口之后，后面的case实际上已经失去了判断的意义， 

JAVA在执行的时候就会把这个case之后的case相当于删除了，所以就会一直往下执行，直到遇到break 

所以读者可以发现， 每一个case后面没有{}这个符号来表示一个代码块 

switch语句选择的类型只有四种：byte、short、int 、char （java5版本之前）还支持 enum(jdk5), String(jdk7) 

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

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

如果匹配的case或者default没有对应的break，那么程序会从第一次匹配的case语句开始继续向下执行 

运行可以执行的语句，直到遇到break或者switch结束为止

switch语法格式：

1.switch(表达式){
2.    case 表达式可能的结果值1:
3.            执行语句；
4.    break；
5.    case 表达式可能的结果值2:
6.            执行语句；
7.    break；
8.        ...
9.    default:
10.            执行语句；
11.    break；
12.}      

switch语句代码如下：

1./**
2.*switch代码
3.**/
4.//定义一个Demo3类
5.public class Demo3 {
6.//定义一个主方法
7.   public static void main(String args[]){
8.      char grade = 'C';
9.      //switch语句
10.        switch(grades){
11.         case 'A' :
12.            System.out.println("优秀"); 
13.            break;
14.         case 'B' :
15.            System.out.println("良好");
16.            break;
17.         case 'C' :
18.            System.out.println("及格");
19.         case 'D' :
20.            System.out.println("你还需要努力学习");
21.            break;
22.         default :
23.            System.out.println("未知等级");
24.      }
25.      System.out.println("你的等级是 " + grade); //输出语句
26.   }
27.}      

3.循环结构

JAVA中有三种主要的循环结构：● while 循环 ● do…while 循环 ● for 循环 

用于处理需要重复执行的操作，根据判断条件的成立与否，决定程序段落的执行次数，而这个程序段落称为循环体

(1)：while 循环，只要布尔表达式为 true，循环体会一直执行下去，while是最基本的循环，它的结构为：

1.while( 布尔表达式 ) {
2.  //循环内容
3.}      

while循环代码如下：

1./**
2.*while循环
3.**/
4.//定义一个Demo4类
5.public class Demo4 {
6.//定义一个主方法
7.   public static void main(String args[]) {
8.      int c = 5; //定义一个变量
9.      // while循环体
10.      while( c < 10 ) {
11.         System.out.print("c的值为:" + c ); //输出c的值
12.         x++; //计数器
13.         System.out.print("\n"); // 输出换行
14.      }
15.   }
16.}      

(2)：do…while 循环：do…while 循环和 while 循环相似，不同的是 do…while 循环至少会执行一次 

do…while 循环结构：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了 

如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false

1.do {
2.  //代码语句
3.}while(布尔表达式);      

do…while 循环代码

1./**
2.*do…while 循环代码
3.**/
4.//定义一个Demo5类
5.public class Demo5 {
6.//定义一个主方法
7.public static void main(String args[]){
8.   int d = 10; //定义一个变量
9.   //do…while 循环体
10.     do{
11.         System.out.print("d的值为: " + d ); //输出d的值
12.         d++; //计数器
13.         System.out.print("\n");
14.      }while( d < 20 );
15.   }
16.}      

(3).for循环：1, for循环里面的3个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体 

然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。 

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

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

for循环执行的次数是在执行前就确定的，语法格式如下：

1.for(初始化表达式（1）；循环条件表达式（2）；循环后的操作表达式（3）){
2.        执行语句；（4）
3.}
4.for循环执行顺序：(1) → (2) → (4) → (3) → (2) → (4) → (3)      

for循环代码

1./**
2.*for循环代码
3.*//
4.//定义一个Demo6类
5.public class Demo6 {
6.//定义一个主方法
7.   public static void main(String args[]) {
8.   //for循环体
9.  for(int e = 10; e < 20; e++) {
10.         System.out.print("e的值为 : " + e);//输出e的值
11.         System.out.print("\n"); //输出换行
12.      }
13.   }
14.}      

4.break 与 continue关键字

break语句；break：终止该层循环 

continue语句；continue：跳过该层循环 

①：若这两个语句离开应用范围，存在是没有意义的。 

②：这个两个语句后面都能有语句，因为执行不到。 

③：continue语句是跳过本次循环，继续下次循环。 

④：标签的出现，可以让这两个语句作用于指定的循环

break 关键字：break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块 

break 跳出最里层的循环，并且继续执行该循环下面的语句 

break 的用法很简单，就是循环结构中的一条语句：break;

continue 关键字:continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代 

在 for 循环中，continue 语句使程序立即跳转到更新语句 

在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句 

continue 就是循环体中一条简单的语句：continue;

5.数组

笔者将讲解JAVA数组的声明、创建和初始化，并给出其对应的代码 

数组概念：一组能够储存相同数据类型值得变量的集合 

数组的好处：数组里的每个元素都有编号，编号从0开始；依次递增，方便操作这些元素 

使用Java数组：必须先声明数组，再给该数组分配内存， JAVA语言中提供数组是用来存储固定大小的同类型元素

声明一维数组 

一维数组：可以理解为一列多行、类型相同的数据，其中每个数据被称为数组元素 

一维数组的声明方式：

1.1.int x[];(不推荐使用)
2.2.int [] x = new int[3];
3.3.int x = new int[]{3,5.7}; 
4.4.int[] x; (推荐使用)
5.5.int[] x={3,5,7};
6.6.int a[5]; 非法数组，java语言声明数组的时候不能指定其长度（元素的个数）      

一维数组的初始化： 

JAVA中的数组必先初始化才可以使用，所谓初始化就是为数组的数组元素分配内存，并为每个数组元素赋值 

数组初始化的两种方式： 

1.静态初始化：初始化时由我们自己指定每个数组元素的初始值，由系统决定需要的数组长度； 

格式：数组名 = new 数组类型[]{元素1,元素2,元素3…元素n}; 简化语法：数组名 = {元素1,元素2,元素3…元素n}; 

2.动态初始化：初始化时由我们指定数组的长度，由系统为数组元素分配初始值； 

格式：数组名 = new 数组类型[数组长度];

声明二维数组： 

二维数组：(其实是一个一维数组，它的每一个元素又是一个一维数组),可以看做是一张表格 

在数组中再存放数组，外层数组看做是行，内层数组看做列；动态初始化，静态初始化 

初始化二维数组声明方式：

1.//动态初始化，定义了一个二维数组，其中有3个一维数组，每一个一维数组中有2个元素
2.int[][] a = new int[3][2];
3.//静态初始化
4.int[][] a = new int[][]{{1,2},{3,4},{5,6}}; 
5.int[][] a = {{1,2},{3,4},{5,6}};      

使用 二维数组：

1.int[] []  arr = {{3,1,5},{2,6},{8}};      

元素值5的表示方式为：arr[0][2] = 5; 

第二个一维数组的长度表示方式：int len = arr[1].length; 

对二维数组的遍历使用for的嵌套循环。 

对于其他多维数组，几维就用几层for嵌套，但通常情况数组最多用到三维，因为效率已经大大降低了

使用数组常见操作： 

JAVA语言的数组索引是从0开始的，也就是说数组里的第一个元素的索引是0,第二个元素的索引是1 

1.给数组元素赋值 

2.数组名[索引] = 数组类型的值 ; 

3.访问数组元素 

4.数组类型 变量 = 数组名[索引]; 

5.得到数组的长度 

6.int len = 数组名.length; //length是数组的属性 

7.遍历数组

数组操作常见问题

1.（ArrayIndexOutOfBoundsException）表示数组脚标越界异常
2.（NullPointerException）表示空引用异常      

6.方法

笔者将讲解：方法含义和定义格式，方法重载 

什么是方法？一段可重复使用的代码段；程序中完成独立功能的一段代码的集合 

方法的优点 ：● 1. 使程序变得更简短而清晰 ● 2. 有利于程序维护 

● 3. 可以提高程序开发的效率 ● 4. 提高了代码的重用性 

JAVA中定义方法的格式为：

1.[修饰符] 返回值类型 方法名([参数类型 形式参数1，参数类型 形式参数2，……]){    
2.    执行语句;   [return 返回值;]
3.}
4.参数列表（参数的类型 ，参数的个数，参数的顺序）      

方法内容介绍： 

形式参数：在方法被调用时用于接收外界输入的数据 

实参：调用方法时实际传给方法的数据 

返回值：方法在执行完毕后返还给调用它的环境的数据 

返回值类型：事先约定的返回值的数据类型，如无返回值，必须给出返回类型 void 

方法签名：方法名 和 方法的参数列表(能区别方法) 

java语言中调用方法：对象名.方法名（实参列表） 

实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配 

return 语句终止方法的运行并指定要返回的数据

方法的重载（Overload） 

什么是方法的重载？： 

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型或参数顺序不同即可 

方法重载的特点：与返回值类型无关，只看参数列表 

记住方法重载方式的小技巧：两同，一不同 

同一个类中方法名相同；参数列表不同：（参数个数，参数的类型，参数顺序）

编程的命名规则： 

1.必须以字母、’_’或’＄’开头 

2.可以包括数字，但不能以它开头 

3.方法名不能使用关键字和保留字 

4.单词的首字母大写，采用驼峰式；由有实际意义的名词或名词短语构成 

5.方法名规范：第一个单词的首字母小写，采用驼峰式

初学基础Ⅲ难点: ★★★★★

希望每一篇文章都能够对读者们提供帮助与提升，这乃是每一位笔者的初衷

感谢您的阅读 欢迎您的留言与建议

• 新浪官方微博: @中國熱點影視傳媒
• Github博客: https://github.com/jeep711/jeep711.github.io
• Blog Garden：http://www.cnblogs.com/JEEP711/
• W3C/Blog：http://www.w3cschool.cn/jeep711blog/
• CSDN/Blog：http://blog.csdn.net/jeep911
• 51CTO/Blog：http://jeep711.blog.51cto.com/