codecamp

第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语句三种格式：
```
语句格式一：if(条件表达式){
执行语句；
}
语句格式二：if(条件表达式){
执行语句；
}else{
执行语句；
}
语句格式三：if(条件表达式){
执行语句；
}else if (条件表达式){
执行语句；
}
……
else
{
执行语句；
}


<br> **if 语句的用语法如下： 如果布尔表达式的值为 true，则执行 if 语句中的代码块，否则执行 if 语句块后面的代码**
<br> ``` 
<br>if(布尔表达式) {
<br>//如果布尔表达式为true将执行的语句
<br>}
<br> ```
<br> **if语句代码**
<br> ```
<br>/**
<br>*if语句代码
<br>**/
<br>//定义一个Demo类
<br>public class Demo {
<br>//定义主方法
<br>public static void main(String args[]){
<br>int a = 10; //定义一个变量
<br>if( a < 100 ){
<br>System.out.print("这是 if 语句"); //输出语句
<br>}
<br>}
<br>}
<br> ```
<br> 
<br> **if...else语句：if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句块会被执行**
<br> **if…else 的用法**：
<br> ```
<br>if(布尔表达式){
<br>//如果布尔表达式的值为true
<br>}else{
<br>//如果布尔表达式的值为false
<br>}
<br> ```
<br> **if else语句代码如下：**
<br> ```
<br>/**
<br>*if else语句代码
<br>*//
<br>//定义一个Demo2类
<br>public class Demo2 {
<br>//定义一个主方法
<br>public static void main(String args[]){
<br>int b = 30; //声明一个变量并赋值
<br>if( b < 20 ){
<br>System.out.print("这是 if 语句");
<br>}else{
<br>System.out.print("这是 else 语句");
<br>}
<br>}
<br>}
<br> ```
<br>
<br> **(2)：switch 语句**
<br> switch 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支
<br> case只是用来为switch选择一个执行代码的入口，如果一旦进入一个入口之后，后面的case实际上已经失去了判断的意义，
<br> JAVA在执行的时候就会把这个case之后的case相当于删除了，所以就会一直往下执行，直到遇到break
<br> 所以读者可以发现， 每一个case后面没有{}这个符号来表示一个代码块
<br> **switch语句选择的类型只有四种**：byte、short、int 、char （java5版本之前）还支持 enum(jdk5), String(jdk7)
<br> case之间与default没有顺序，先执行第一个case，都没有匹配的case值执行default。
<br> 结束switch语句的两种情况：遇到break，switch语句执行结束
<br> 如果匹配的case或者default没有对应的break，那么程序会从第一次匹配的case语句开始继续向下执行
<br> 运行可以执行的语句，直到遇到break或者switch结束为止
<br> 
<br> **switch语法格式**：
<br> ```
<br>switch(表达式){
<br>case 表达式可能的结果值1:
<br>执行语句；
<br>break；
<br>case 表达式可能的结果值2:
<br>执行语句；
<br>break；
<br>...
<br>default:
<br>执行语句；
<br>break；
<br>}


<br> switch语句代码如下：
<br> ```
<br>/**
<br>*switch代码
<br>**/
<br>//定义一个Demo3类
<br>public class Demo3 {
<br>//定义一个主方法
<br>public static void main(String args[]){
<br>char grade = 'C';
<br>//switch语句
<br>switch(grades){
<br>case 'A' :
<br>System.out.println("优秀"); 
<br>break;
<br>case 'B' :
<br>System.out.println("良好");
<br>break;
<br>case 'C' :
<br>System.out.println("及格");
<br>case 'D' :
<br>System.out.println("你还需要努力学习");
<br>break;
<br>default :
<br>System.out.println("未知等级");
<br>}
<br>System.out.println("你的等级是 " + grade); //输出语句
<br>}
<br>}
<br> ```

3.循环结构

JAVA中有三种主要的循环结构：● while 循环 ● do…while 循环 ● for 循环
用于处理需要重复执行的操作，根据判断条件的成立与否，决定程序段落的执行次数，而这个程序段落称为循环体

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

while( 布尔表达式 ) {
//循环内容
}

while循环代码如下：

/**
*while循环
**/
//定义一个Demo4类
public class Demo4 {
//定义一个主方法
public static void main(String args[]) {c
int c = 5; //定义一个变量
// while循环体
while( c < 10 ) {
System.out.print("c的值为:" + c ); //输出c的值
c++; //计数器
System.out.print("\n"); // 输出换行
}
}
}


(2)：do…while 循环：do…while 循环和 while 循环相似，不同的是 do…while 循环至少会执行一次
do…while 循环结构：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了
如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false

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

do…while 循环代码

/**
*do…while 循环代码
**/
//定义一个Demo5类
public class Demo5 {
//定义一个主方法
public static void main(String args[]){
int d = 10; //定义一个变量
//do…while 循环体
do{
System.out.print("d的值为: " + d ); //输出d的值
d++; //计数器
System.out.print("\n");
}while( d < 20 );
}
}


(3).for循环：1, for循环里面的3个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体
然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。
2, while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就在内存中释放，而while循环使用的变量在循环结束后还可以继续使用。
3, 最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环

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

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

for循环代码

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


## 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.int x[];(不推荐使用)
2.int [] x = new int[3];
3.int x = new int[]{3,5.7};
4.int[] x; (推荐使用)
5.int[] x={3,5,7};
6.int a[5]; 非法数组，java语言声明数组的时候不能指定其长度（元素的个数）


一维数组的初始化：
JAVA中的数组必先初始化才可以使用，所谓初始化就是为数组的数组元素分配内存，并为每个数组元素赋值
数组初始化的两种方式：
1.静态初始化：初始化时由我们自己指定每个数组元素的初始值，由系统决定需要的数组长度；
格式：数组名 = new 数组类型[]{元素1,元素2,元素3...元素n}; 简化语法：数组名 = {元素1,元素2,元素3...元素n};
2.动态初始化：初始化时由我们指定数组的长度，由系统为数组元素分配初始值；
格式：数组名 = new 数组类型[数组长度];

声明二维数组：
二维数组：(其实是一个一维数组，它的每一个元素又是一个一维数组),可以看做是一张表格
在数组中再存放数组，外层数组看做是行，内层数组看做列；动态初始化，静态初始化
初始化二维数组声明方式：

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

使用 二维数组：

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.遍历数组

数组操作常见问题

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

6.方法

笔者将讲解：方法含义和定义格式，方法重载
什么是方法？一段可重复使用的代码段；程序中完成独立功能的一段代码的集合
方法的优点 ：● 1. 使程序变得更简短而清晰 ● 2. 有利于程序维护
● 3. 可以提高程序开发的效率 ● 4. 提高了代码的重用性
JAVA中定义方法的格式为：

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

方法内容介绍：
形式参数：在方法被调用时用于接收外界输入的数据
实参：调用方法时实际传给方法的数据
返回值：方法在执行完毕后返还给调用它的环境的数据
返回值类型：事先约定的返回值的数据类型，如无返回值，必须给出返回类型 void
方法签名：方法名 和 方法的参数列表(能区别方法)
java语言中调用方法：对象名.方法名（实参列表）
实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配
return 语句终止方法的运行并指定要返回的数据

方法的重载（Overload）
什么是方法的重载？：
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型或参数顺序不同即可
方法重载的特点：与返回值类型无关，只看参数列表
记住方法重载方式的小技巧：两同，一不同
同一个类中方法名相同；参数列表不同：（参数个数，参数的类型，参数顺序）

编程的命名规则：
1.必须以字母、'_'或'＄'开头

2.可以包括数字，但不能以它开头
3.方法名不能使用关键字和保留字
4.单词的首字母大写，采用驼峰式；由有实际意义的名词或名词短语构成
5.方法名规范：第一个单词的首字母小写，采用驼峰式

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

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

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

第3篇-JAVA基础
第5篇-JAVA面向对象Ⅰ
温馨提示
下载编程狮App，免费阅读超1000+编程语言教程
取消
确定
目录
第1篇-JAVA开篇
第2篇-JAVA基础
第3篇-JAVA基础
第4篇-JAVA基础
第5篇-JAVA面向对象Ⅰ
第6篇-JAVA面向对象Ⅱ
第7篇-JAVA面向对象Ⅲ
第8篇-JAVA面向对象-设计模式Ⅳ
第9篇-JAVA面向对象-常用类Ⅴ
第10篇-JAVA 集合框架-JAVA 泛型
第11篇-JAVA IO
第12篇-JAVA 多线程
第13篇-JAVA 网络编程
第14篇-JAVA GUI编程
第15篇-JAVA JDBC编程
第16篇-JAVA 类加载与反射
第17篇-JAVA Annotation 注解
第18完结篇-JAVA XML

关闭

 MIP.setData({ 'pageTheme' : getCookie('pageTheme') || {'day':true, 'night':false}, 'pageFontSize' : getCookie('pageFontSize') || 20 }); MIP.watch('pageTheme', function(newValue){ setCookie('pageTheme', JSON.stringify(newValue)) }); MIP.watch('pageFontSize', function(newValue){ setCookie('pageFontSize', newValue) }); function setCookie(name, value){ var days = 1; var exp = new Date(); exp.setTime(exp.getTime() + days*24*60*60*1000); document.cookie = name + '=' + value + ';expires=' + exp.toUTCString(); } function getCookie(name){ var reg = new RegExp('(^| )' + name + '=([^;]*)(;|$)'); return document.cookie.match(reg) ? JSON.parse(document.cookie.match(reg)[2]) : null; }