【Java零基础入门篇】第 ② 期 - Java语言基础（四）
博主：命运之光
专栏：Java零基础入门
学习目标
掌握变量、常量、表达式的概念，数据类型及变量的定义方法；
掌握常用运算符的使用；
掌握程序的顺序结构、选择结构和循环结构的使用；
掌握数组的定义及使用方法；
掌握基本的输入输出方法；
流程控制语句
- 顺序结构
- 选择结构
- 循环结构
这三种不同的结构有一个共同点，就是它们都只有一个入口，也只有一个出口。程序中使用了上面这些结构到底有什么好处呢？这些单一入、出口可以让程序易读、好维护，也可以减少调试的时间。
顺序结构
程序至上而下逐行执行，一条语句执行完之后继续执行下一条语句，一直到程序的末尾。
选择（分支）结构
根据条件的成立与否，再决定要执行哪些语句的一种结构。
这种结构可以依据判断条件的结构，来决定要执行的语句。当判断条件的值为真时，就运行“语句1”；当判断条件的值为假，则执行“语句2”。不论执行哪一个语句，最后都会再回到“语句3”继续执行。
🍓 if 语句 ： 如果
- if语法：
if (布尔表达式) {
条件满足时执行的程序 ;
}
- if…else语法：
if (布尔表达式) {
条件满足时执行的程序 ;
} else {
条件不满足时执行的程序 ;
}
- if…else if…else语法：
if (布尔表达式1) {
条件满足时执行的程序 ;
} else if (布尔表达式2) {
条件满足时执行的程序 ;
} ... else {
所有条件都不满足时执行的程序 ;
}
🍓🍓例1：使用if语句判断。
public class text1 {
public static void main(String args[]) {
double score = 90.0; // 定义变量
if (score > 60.0) { // 设置判断条件
System.out.println("及格了！");
}
}
}
🍓🍓例2：使用if…else语句判断。
public class text1 {
public static void main(String args[]) {
double score = 30.0; // 定义变量
if (score > 60.0) { // 条件判断满足
System.out.println("及格了！");
} else { // 条件判断不满足
System.out.println("小白的成绩！");
}
}
}
🍓🍓例3：使用if…else if…else语句判断。
public class text1 {
public static void main(String args[]) {
double score = 91.0; // 定义变量
if (score < 60.0) { // 条件判断
System.out.println("小白的成绩！") ;
} else if (score >= 60 && score <= 90) {// 条件判断
System.out.println("中等成绩") ;
} else if (score > 90 && score <= 100) {// 条件判断
System.out.println("优秀成绩") ;
} else { // 条件判断都不满足
System.out.println("你家的考试成绩这么怪异！") ;
}
}
}
🍓switch语句
对于多条件判断使用if…else if…else是可以判断布尔条件的，如果是多数值判断，可以通过switch完成，语法格式如右所示：
switch(整数 | 字符 | 枚举 | String) {
case 内容 : {
内容满足时执行 ;
[break ;]
}
case 内容 : {
内容满足时执行 ;
[break ;]
}
case 内容 : {
内容满足时执行 ;
[break ;]
} ...
[default : {
内容都不满足时执行 ;
[break ;]
}]
}
🍓🍓例1：使用switch语句判断。
public class text1 {
public static void main(String args[]) {
int ch = 1;
switch (ch) { // 判断的是数字
case 2: { // 判断内容是否是2
System.out.println("内容是2");
break;
}
case 1: { // 判断内容是否是1
System.out.println("内容是1");
break;
}
case 3: { // 判断内容是否是3
System.out.println("内容是3");
break;
}
default: { // 判断都不满足
System.out.println("没有匹配内容");
break;
}
}
}
}
- case子句中的值必须是常量，不能是变量名或不确定的表达式值；
- 同一个switch语句，所有case子句中的常量值互不相同；
- break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾；
- default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，执行default。
🍓🍓例2：使用字符串判断。
public class text1 {
public static void main(String args[]) {
String str = "HELLO";
switch (str) { // 判断的是字符串
case "HELLO": {
System.out.println("内容是HELLO");
break;
}
case "hello": {
System.out.println("内容是hello");
break;
}
case "mldn": {
System.out.println("内容是mldn");
break;
}
default: {
System.out.println("没有匹配内容");
break;
}
}
}
}
从JDK 1.7开始switch支持字符串的直接判断，即：可以利用switch判断是否是某一个字符串内容。但是在字符串的判断中是严格区分字母大小写的。
循环结构
循环，即事物周而复始的变化。 循环结构，使一部分代码按照次数或一定的条件反复执行的一种代码结构。对于循环结构有三种循环：while循环、for循环和do-while循环。
循环语句的四个组成部分：
- 循环初值(init_statement)
- 循环条件部分(test_exp)
- 循环体部分(body_statement)
- （修改循环条件）迭代部分(alter_statement)
while循环：
while (循环条件) {
循环语句 ;
修改循环结束条件 ;
}
do…while循环：
do {
循环语句 ;
修改循环结束条件 ;
} while (循环条件) ;
🍓🍓例1：使用while语句实现求解1~100的累加和。
public class text1 {
public static void main(String args[]) {
int sum = 0; // 保存总和
int current = 1; // 循环的初始化条件
while (current <= 100) { // 循环结束条件
sum += current; // 累加
current++; // 改变循环条件
}
System.out.println(sum);
}
}
🍓🍓例2：使用do-while语句实现求解1~100的累加和。
public class text1 {
public static void main(String args[]) {
int sum = 0; // 保存总和
int current = 1; // 循环的初始化条件
do { // 循环结束条件
sum += current; // 累加
current++; // 改变循环条件
} while (current <= 100); // 循环结束判断
System.out.println(sum);
}
}
for循环：已经明确的知道了循环次数，语法如下：
for ( ① 循环初始化条件; ②循环条件; ④迭代部分) {
③循环语句 ;
}
执行过程：
①-②-③-④-②-③-④-②-③-④-…-②
说明：
②循环条件部分为boolean类型表达式，当值为false时，退出循环；
①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔；
④可以有多个变量更新，用逗号分隔。
for循环执行演示
🍓🍓例3：使用for语句实现求解1~100的累加和。
public class text1 {
public static void main(String args[]) {
int sum = 0; // 保存总和
// 设置循环初始化条件current，同时此变量作为累加操作使用
// 每次执行循环体前都要进行循环判断（current <= 100）
// 循环体执行完毕后会自动执行“current++”改变循环条件
for (int current = 1; current <= 100; current++) {
sum += current; // 循环体中实现累加操作
}
System.out.println(sum);
}
}
🍓🍓例4：输出乘法口诀表（循环嵌套）。
public class text1 {
public static void main(String args[]) {
for (int x = 1; x <= 9; x++) { // 控制循环的行数
for (int y = 1; y <= x; y++) {// 控制列数
System.out.print(x + "*" + y + "=" + (x * y) + "\t");
}
System.out.println();// 换行
}
}
}
跳转语句
🍓🍓正常情况下只要执行了循环，那么只要循环条件满足，循环体的代码就会一直执行，但是在程序之中也提供有两个循环停止的控制语句：continue（退出本次循环）、break（退出整个循环）。此类的语句在使用时往往要结合分支语句进行判断。
🍓🍓例： 观察break语句。
public class text1 {
public static void main(String args[]) {
for (int x = 0; x < 10; x++) {
if (x == 3) {
break; // 退出整个循环
}
System.out.print("x = " + x + "、");
}
}
}
🍓🍓例： 观察continue语句。
public class text1 {
public static void main(String args[]) {
for (int x = 0; x < 10; x++) {
if (x == 3) {
continue; // 之后的代码不执行，直接结束本次循环
}
System.out.print("x = " + x + "、");
}
}
}
数组
数组概述
为什么需要数组？
如果说现在要想定义100个整型变量，按照传统的思路，可能这样定义：
int i1,i2 ,… i100，一共写100个变量。
以上的形式的确可以满足技术要求，但是有一个问题，这100多个变量没有任何的逻辑的控制关系，完全独立，就会出现对象不方便管理的情况，那么在这种情况下就可以利用数组来解决此类问题。
为了存储多个数据值
什么是数组（Array）？
数组是用来存储同一种数据类型多个元素的容器。
容器：比如教室、衣柜、纸箱等，可以存放多个事物。
- 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
- 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
- 数组的长度一旦确定，就不能修改。
- 可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。
- 数组的分类：
- 按照维度：一维数组、二维数组、三维数组、…
- 按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)
一维数组
数组的声明：
🍓🍓例如：
- int[ ] array ;
- double b[ ];
- String[ ] str;
注意：Java语言中声明数组时 不能指定其长度(数组中元素的数)， 例如： int a[5]; //非法
数据类型[ ] 数组名;
或 数据类型 数组名[ ];
数据类型：即数组中存储元素的数据类型，可以是基本数据类型，也可以是引用数据类型;
[ ] ：表示数组;
数组名： 数组的变量名，遵循标识符命名规范;
静态初始化：在 定义数组的 同时就为数组元素 分配空间并 赋值。
例如： int[ ] array = new int[ ]{3, 9, 8};
或int[ ] array = {3, 9, 8}; （简化写法）
给出初始化值，由系统决定数组长度。
例如：
String names[ ] = new String[ ] {“李四光”, “茅以升”, “华罗庚”}；
或String names[ ] = {“李四光”, “茅以升”, “华罗庚”}；
new：创建数组的关键字，通过new开辟内存空间;
动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行。
数组元素的引用
定义并用new为数组分配空间后，才可以引用数组中的每个元素；
数组元素的引用方式：数组名[数组元素下标]
- 数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
- 数组元素下标从0开始；长度为n的数组,合法下标取值范围: 0 —>n-1;
如int a[ ]=new int[3]; 可引用的数组元素为a[0]、a[1]、a[2] - 每个数组都有一个属性length指明它的长度;
例如：a.length 指明数组a的长度(元素个数) - 数组一旦初始化，其长度是不可变的;
数组元素的默认初始值
数组是引用类型，数组一经分配空间，其中的每个元素就被隐式初始化(默认值)。
内存的简化结构
二维数组
动态初始化：数据类型 数组名称[ ][ ] = new 数据类型[行的个数][列的个数]；
例如：int[ ][ ] arr = new int[3][2];
- 定义了名称为arr的二维数组；
- 二维数组中有3个一维数组；
- 每一个一维数组中有2个元素；
- 一维数组的名称分别为arr[0], arr[1], arr[2]；
- 给第一个一维数组，索引为1的元素，赋值78的写法是：arr[0][1] = 78 ；
注意： 若定义二维数组int[][] arr = new int[3][];
- 二维数组中有3个一维数组；
- 每个一维数组都是默认初始化值null （数组本身为引用类型）；
- 可以对这三个一维数组分别进行初始化：
arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2] ；- int[][] arr = new int[][3]; //非法，声明时可以省略列数，不能省略行数
静态初始化：数据类型 数组名称[ ][ ] = new 数据类型[ ][ ] { {值,值,值…},{值,值,值…},… }
例如：int[ ][ ] arr = new int[ ][ ]{ {3,8,2} , {2,7} , {9,0,1,6} };
- 定义一个名称为arr的二维数组，二维数组中有三个一维数组;
- 每一个一维数组中具体元素也都已初始化; 第一个一维数组 arr[0] = {3,8,2}; 第二个一维数组 arr[1] = {2,7}; 第三个一维数组 arr[2] = {9,0,1,6} ;
- 第三个一维数组的长度表示方式：arr[2].length ;
- 二维数组的长度（行的个数）表示方式：arr.length;
数组使用中常见异常
- 数组索引值越界异常
- 空指针异常
Java标准输入输出
🍓标准输出流System.out
System.out是进行屏幕输出的操作对象，是一个PrintStream类的实例化对象，向标准输出设备输出数据，有2个常用的成员方法：
public void print(参数)：输出各种常见数据类型;
public void println(参数) ：输出各种常见数据类型，并回车换行;
🍓标准输入流System.in （了解）
读取标准输入设备数据（一般是键盘），是InputStream类的实例化对象，常用的成员方法：
int read():从输入流中读取数据的一个字节，返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1，说明没有读取到任何字节，读取结束。
System.in读入数据并不方便，我们通常使用java.util.Scanner类通过封装System.in实现读入数据，能够很方便的读入不同的数据类型。
🍓Scanner类——如何从键盘获取不同类型的变量
具体实现步骤：
1、导包 ： import java.util.Scanner;
2、Scanner的实例化：Scanner scan = new
Scanner(System.in);3、调用Scanner类的相关方法，来获取指定类型的变量；
Scanner类提供了以下常用方法用于读取数据：
boolean nextBoolean():读取下一个boolean数据;
byte nextByte()：读取下一个byte数据 ;
short nextShort()：读取下一个short数据 ;
int nextInt() ：读取下一个double数据 ;
long nextLong() ：读取下一个long数据 ;
float nextFloat() ：读取下一个double数据;
double nextDouble() ：读取下一个double数据;
String next() ：读取下一个字符串数据 ;
String nextLine() ：读取下一行数据;
void close():关闭Scanner;
扫一扫
1638
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
