Java 变量 运算符 程序控制结构

目录

第二章笔记

IDE简介

注释

关键字

保留字

标识符

变量

数据类型

基本数据类型转换

运算符

表达式的运算顺序

控制台输入Scanner

程序控制结构

分支控制 if-else

单分支

多分支

循环语句

break & continue

方法与return语句

第二章笔记

IDE简介

ide集成开发环境 ,所有开发工具的总称.

java主流的开发工具有很多，包括常见的有eclipse开源的、、idea ——> 最常用的Java开发工具 收费 主流个人使用时可破解 无限重置使用30天

安装 破解 创建项目 创建一个文件夹,专门放项目 为了防止误删除，在idea中想删除项目时，需要去在硬盘上删除

注释

使用特定的符号,标注内容, 对代码功能进行说明，不会被当作代码去运行

// 单行注释 只对某行进行注释 ctrl+/ 添加单行注释和取消单行注释

/*

多行注释 ctrl+shift+/

*/

/**

文档注释 用于为类,属性,方法进行功能注释,在其他地方使用时可以提示出来

后期我们再讲配置文档注释模板,以及生成文档

*/

如：

关键字

被语言赋予特殊含义的单词, public class int

用来修饰包,类,变量,方法......

关键字所有的字母都是小写的

分布在后面的章节中学习

保留字

java现有的版本中并为用来作为关键字的单词,以后可能会成为关键字，所以现在不允许用来当做标识符使用

自己命名标记符时要避免使用这些保留字 例如 goto 、const

标识符

语言中用来命名的字符---标识符 自己能定义的名字的字符，如（包、类、变量、方法）

标识符命名规则:

语法强制规范

允许使用大小写字母,数字,下划线,$

不允许数字开头,不允许使用关键字,保留字

不能有空格,严格区分大小写 长度不限制

约定俗成

见名知意 userName age

● 包名：多单词组成时所有字母都小写：xxxyyyzzz

● 类名、接口名：多单词组成时，所有单词的首字母大写：

XxxYyyZzz

● 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个

单词开始每个单词首字母大写：xxxYyyZzz

● 常量名：所有字母都大写。多单词时每个单词用下划线连接：

XXX_YYY_ZZZ

变量

可以变的量，是一个最基本的存储单元，程序执行中数值是可变的

本质上是，内存中的一块空间 使用变量名来访问这块区域，因此，

每一个变量使用前必须要先申请（声明），然后必须进行赋值（填充内容）， 才能使用

其要素包括变量名，变量类型

声明变量的语法——>数据类型(必须明确类型) [修饰符] 变量名 = 值;

数据类型

程序中所有的数据,都需要明确数据类型, 不同的类型存储空间不同,运算规则不同.

数据类型可分为两大类

一、 基本数据类型 共有8种,使用8个关键字修饰, 结构简单 .

基本数据类型细分为三类 ①数值型 byte(1byte 为 8个bit位 最大范围-128 ~~ +127) short int long

数值型中又能细分为两类有

1. 整数 有四种类型如下图 Java中整数默认字面量是int 若 声明一个long类型 需要在字面量后面添加L或l

2.浮点数: float 4 字节 double 8字节 整体大小不同，小数位精度不同 默认字面量是double 若要声明float 需在字面量后面添加F/f

②字符型 必须只能是一个字符 用单引号表示

char a = 'a'; 97

char a = '中'; 20013 ' ' 单引号表示一个字符

上述这些字符示例 ------> 看似是一个字符,本质上是一个整数(编码表中的编号) ---> Java中默认使用Unicode编码(万国码 包含全球所有的语言文字) ------> 十进制编号

char 可以进行运算 字符--->当做对应编码表的整数 ---> int 运算 牵扯到下一个问题 : 数据类型之间的转换

③布尔型 true false 表示真假，不能用0或非0

二、 引用数据类型 面向对象章节讲

基本数据类型转换

8种基本数据类型之间除了布尔型不可以与其他7种之间转换

其他byte short int long float double char （都是数值类型） 所以之间可以相互转换

由于数据间需要传递, 那么就可能会出现类型不一致,所以不同类型间需要相互转换

int a 转换 byte b

转换规则

默认转换:容量小的类型默认转换为容量大的数据类型

byte,short,char--->int--->long(8字节)--->float(4字节)--->double

float型在内存中占用的是4个字节的空间，而long型占用的是8个字节的空间

可是为什么4个字节的float型的最大值会大于long型的最大值呢？

答：float和long 由于小数在底层存储结构与整数不同,所以4byte的float 大于 8byte的long

（了解）详细解释 ：因为 long 是整型数，在内存中占用8个字节共64位，它表示的数值有2的64次方，平

分正负，数值范围是负2的63次方到正2的63次方-1。而 float是浮点型，在内存中占4个字节，共32位，但是浮点数在内存中是这样的

V = (-1)^S* M*2^E

浮点数的32位不是简单的直接表示大小，而是按照一定的标准分配的

其中第1位，符号位，即S。

接下来的8位，指数域，即E。

剩下的23位，小数域，即M。

也就是说，浮点数在内存中的二进制值不是直接转换为十进制数值的，而是

按照上述公式计算而来，通过这个公式 V = (-1)^S* M*2^E 虽然只用到了4个字节，但是浮点数却比长整型的最大值要大。

容量小转容量大大 默认转换

大转小 则需要 加强制转换符 但可能出现问题? 装不下 数据溢出 浮点-->整数 精度降低

例：

int a = 258;byte b = (byte)a;System.out.println(b);//2​float c = 10.55f;long d = (long)c;System.out.println(d);//10

有多种类型的数据混合运算时，系统首先自动的将所有数据转换成容量最大的那一种数据类型，然后再进行计算

例：int z = 220023

long b = 10L+z 此时可以运算，默认先将z转换成long型

int m = 10L+z 此时会报错因为已经默认将数据转换为大容量long类型了，所以此时不能用int表示

byte cc=11;byte bb = 120;short dd = (short)(cc+bb); //byte,short,char 在运算时默认都上升为int类型，若不加强制转换符则会报错

运算符

算数运算符：+，-，*，/，%，++，--

※（特殊）字符串连接运算符： + 两种用法

+ 加法运算 数值 + 数值 包含 数值 + char + 字符串连接 字符串+字符串 / 数值+字符串而 - * / % ++ -- 只能进行算数运算

比较运算符： >，<，>=，<=，==，!=

注意 == != 除了基本类型比较以外,还可以用作引用类型比较

例：

String s = "abc";String s1 = "abc";System.out.println(s==s1); //== != 除了基本类型比较以外,还可以用作引用类型比较System.out.println(s!=s1);

赋值运算符： =， +=， -= ，*=， /= ，%=，

使用= 把右边的值赋给左边 注意数据类型是否满足左边所声明的数据类型

当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理

+= ， -= ，*=， /= ，%=，运算时会加(隐式的强制数据类型转换)

例：

short s = 3;

s = s+2; //s = short+int-->int 默认会先转换成int，所以此时报错

s += 2; //short s = (short)(s+3 int) += 中进行了一个隐式的强制数据类型转换System.out.println(s);

逻辑运算符（6个）：● & —逻辑与 | —逻辑或 ！—逻辑非

● && —短路与 || —短路或 ^ —逻辑异或

& 两边都是true 结果为true

| 两边都是false,结果为false

! 为true 结果false

^ 相同结果为false

&& 两边都是true 结果为true

|| 两边都是false,结果为false

& ，| ，! ，^ ，&& ，|| 逻辑运算要求 运算符左右两边都是布尔值

! ，& ，| ^，(不仅可以逻辑运算,还可以位运算) false && true||(逻辑运算 短路)

其中 '' ! ''在参与为运算时样子变成'' ~ ''

“&”和“&&”的区别：

单&时，左边无论真假，右边都进行运算；

双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算

“ |” 和 “||” 的区别同理，||表示：当左边为真，右边不参与运算。

例：

int a = 10;int b = 5;int c = 7;​// & 当前面的表达式返回false 还会继续执行后面的表达式System.out.println(a<b & ++b<c); //false & true = falseSystem.out.println(b); //6 继续执行了++b//&& 当前面的表达式返回false 发生短路 后面的表达式不会执行System.out.println((a<b) && (++b<c)); //false && true && true = falseSystem.out.println(b); //5 发生短路所以++b并未执行​// | 当前面有返回true, 还会继续执行后面的表达式// || 当前面有返回true, 短路 不会执行后面的表达式所以逻辑运算时优先使用&& 和 || 有错误当即停止，不会再继续运算，提高了效率

条件运算符 语法:

(条件表达式)?表达式1 ：表达式2；

条件表达式结果为true，运算后的结果是表达式1；为false，运算后的结果是表达式2；

最终返回一个 与前面声明类型相同的数据

例： int a = 10;

int b = 5;

int max = (a>b)?a:b;

System.out.println(max);//10

位运算符(了解) 位--->指的是二进制bit位 bit位运算 更底层

<< 左移>> 右移>>> 无符号右移& 与| 或^ 异或~ 非

'' ~ ''实际就是 '' ！'' 非

例：

int a = 4;/*0000 0000 0000 0000 0000 0000 0000 0100 ---->40000 0000 0000 0000 0000 0000 0000 1000 ---->8*/System.out.println(a<<1);//8/*0000 0000 0000 0000 0000 0000 0000 0100 ---->40000 0000 0000 0000 0000 0000 0000 0010 ---->2 有符号右移0000 0000 0000 0000 0000 0000 0000 0010 ---->2 无符号右移*/System.out.println(a>>1);//2 有符号右移System.out.println(a>>>1); //2 无符号右移，都是正数，所以没差别​int b = -6;/*1111 1111 1111 1111 1111 1111 1111 1010 ---> -61111 1111 1111 1111 1111 1111 1111 1101 ----> -3有符号右移 负数 移动后 符号不变*/System.out.println(b>>1);//-3/*1111 1111 1111 1111 1111 1111 1111 1010 ----> -60111 1111 1111 1111 1111 1111 1111 1101 ----> 2147483645 无符号右移 不管前面符号位是什么,移动后统一补0*/System.out.println(b>>>1);//2147483645

& 与 | 或 ^ 异或 ~ 非 进行位运算

例：

int a = 4;int b = 3;​/*0000 01000000 00110000 0000 结果为0 每一位bit位进行 与 运算*/System.out.println(a&b);/*0000 01000000 00110000 0111 结果为7 每一位bit位进行 或 运算*/System.out.println(a|b);​/*0000 01000000 00110000 0111 结果为7 每一位bit位进行 异或 运算 口诀： 相同为假 不同为真*///System.out.println(a^b);// 若两个变量交换值 则可以使用^运算a = a^b;//0000 0111 结果a为 7b = a^b; // 7^3=4 结果b为4a = a^b; //7^4 = 3 结果a为3System.out.println(a);System.out.println(b);最终导致原本的两数值，进行了交换a变成了3，b变成了4若用a+b-a a+b-b 这样的方式来交换数值，可能会有a+b数值溢出这样的的问题，但^运算就不会有这种问题/*0000 01001111 1011 结果为-4*/System.out.println(~a);

表达式的运算顺序

控制台输入Scanner

为什么需要控制台输入? 需要用户与程序实现交互式数据输入,但是我们的程序现在还没有操作界面(UI)

所以java中前期 提供了一个类(Scanner类),通过此类,可以让用户在控制台中输入数据,并将数据读取到程序中.

Scanner 是java中提供的 一个可以读取控制台输入的内容 交互式的向程序输入数据

//导入java.util包下的Scanner类, 这样才可以使用

import java.util.Scanner;

类不能直接使用，使用类中的方法，需先声明变量并创建Scanner对象，调用构造方法（输入流）

int a = s.nextInt(); //scanner对象会去进行数据（整数）读取功能,程序运行到此行时会阻塞.(程序一直运行，等待用户输入) 当用户输入完成后,按下回车键时结束输入

String str = s.next();//输入一个字符串

程序控制结构

程序流程控制介绍

在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。

1) 顺序控制

2) 分支控制

3) 循环控制

顺序控制

分支控制 if-else

分支控制 if-else 介绍 ：让程序有选择的的执行,分支控制有三种

1) 单分支 if

2) 双分支 if-else

3) 多分支 if-else if -....-else

单分支

对特别说明的示例 if(true){System.out.println("true");}结果为trueif(false)//此处省略了{}，虽可以省略{ } 但是不建议，若省略，则默认代表{ }的控制范围只是单行语句System.out.println("true1"); //因此此行代码在if的控制范围中，但因为false所以不执行System.out.println("true2"); //而此行代码不再if的控制范围内，所以继续执行结果只有true2

双分支

多分支

多分支的流程图(重要!)

//课堂练习import java.util.Scanner;public class If03 {//编写一个 main 方法public static void main(String[] args) {/*输入保国同志的芝麻信用分：如果：信用分为 100 分时，输出 信用极好；信用分为(80，99]时，输出 信用优秀；信用分为[60,80]时，输出 信用一般；其它情况 ，输出 信用 不及格请从键盘输入保国的芝麻信用分，并加以判断假定信用分数为 int*/Scanner myScanner = new Scanner(System.in);//接收用户输入System.out.println("请输入信用分(1-100):");//请思考：如果小伙伴输入的不是整数，而是 hello.. //==>这里我们后面可以使用异常处理机制搞定-》老师点一下int grade = myScanner.nextInt();//先对输入的信用分，进行一个范围的有效判断 1-100, 否则提示输入错误if(grade >=1 && grade <= 100) {//因为有 4 种情况，所以使用多分支if(grade == 100) {System.out.println("信用极好");} else if (grade > 80 && grade <= 99) { //信用分为(80，99]时，输出 信用优秀；System.out.println("信用优秀");} else if (grade >= 60 && grade <= 80) {//信用分为[60,80]时，输出 信用一般System.out.println("信用一般");} else {//其它情况 ，输出 信用 不及格System.out.println("信用不及格");}} else {System.out.println("信用分需要在 1-100,请重新输入:)");}}}

嵌套分支

5.5.1基本介绍在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。老师建议: 不要超过 3 层 （可读性不好）

5.5.2基本语法

import java.util.Scanner;public class NestedIf {//编写一个 main 方法public static void main(String[] args) {/*参加歌手比赛，如果初赛成绩大于 8.0 进入决赛，否则提示淘汰。并且根据性别提示进入男子组决赛或女子组决赛。【可以让学员先练习下】, 输入成绩和性别，进行判断和输出信息。[NestedIf.java]提示: double score; char gender;接收字符: char gender = scanner.next().charAt(0)*///思路分析//1. 创建 Scanner 对象，接收用户输入//2. 接收 成绩保存到 double score//3. 使用 if-else 判断 如果初赛成绩大于 8.0 进入决赛，否则提示淘汰//4. 如果进入到 决赛，再接收 char gender, 使用 if-else 输出信息//代码实现 => 思路 --> java 代码Scanner myScanner = new Scanner(System.in);System.out.println("请输入该歌手的成绩");double score = myScanner.nextDouble();if( score > 8.0 ) {System.out.println("请输入性别");char gender = myScanner.next().charAt(0);if( gender == '男' ) {System.out.println("进入男子组决赛");} else if(gender == '女') {System.out.println("进入女子组决赛");} else {System.out.println("你的性别有误，不能参加决赛~");}} else {System.out.println("sorry ,你被淘汰了~");}}}

switch语句

多分支选择语句，根据表达式的值，来执行多个操作中的一个。

switch能够实现的功能, if语句都可以实现, 而if能实现的功能,switch不一定能实现

if(各种条件表达式)switch(表达式 变量) 表达式与case后面的值进行匹配

一般用于固定的选项选择 一周7天,一年12月

基本语法：

switch(表达式){

case 1 常量1 ： //当......

语句块1；// 不能重复

break; //结束语句

case 2 常量2 ;

语句块2；

break;

.....

case n 常量3 ;

break;

default:

default 语句块 （默认表达式）；

break；

}

流程图

switch注意事项和细节讨论

表达式可以是byte、short、int、char、枚举类型。JDK 7以后，可以使用String类 型；

switch 和 if 的比较

1) 如果判断的具体数值不多，而且符合 byte、 short 、int、 char, enum[枚举], String 这 6 种类型。虽然两个语句都可以使用，建议使用 swtich 语句。

2) 其他情况：对区间判断，对结果为 boolean 类型判断，使用 if，if 的使用范围更广

例题：

//对学生成绩大于 60 分的，输出"合格"。低于 60 分的，//输出"不合格"。(注：输入的成绩不能大于 100), 提示 成绩/60//思路分析//1. 这道题，可以使用 分支来完成， 但是要求使用 switch//2. 这里我们需要进行一个转换, 编程思路 :// 如果成绩在 [60,100] , (int)(成绩/60) = 1// 如果成绩在 [0,60) , (int)(成绩/60) = 0//代码实现double score = 1.1;//使用 if-else 保证输入的成绩有有效的 0-100//看了当老师的分析和代码演示后，自己一定要独立完成if( score >= 0 && score <= 100) {switch ((int)(score / 60)) {case 0 :System.out.println("不合格");break;case 1 :System.out.println("合格");break;// default :// System.out.println("输入有误");}} else {System.out.println("输入的成绩在 0-100");}

例：穿透现象的例题

//根据用于指定月份，//打印该月份所属的季节。//3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季//[课堂练习, 提示 使用穿透 ]////思路分析//1. 创建 Scanner 对象， 接收用户输入//2. 使用 int month 接收//3. 使用 switch 来匹配 ,使用穿透来完成，比较简洁Scanner myScanner = new Scanner(System.in);System.out.println("输入月份");int month = myScanner.nextInt();switch(month) {case 3:case 4:case 5:System.out.println("这是春季");break;case 6:case 7:case 8:System.out.println("这是夏季");break;case 9:case 10:case 11:System.out.println("这是秋季");break;case 1:case 2:case 12:System.out.println("这是冬季");break;default :System.out.println("你输入的月份不对(1-12)");}}}

循环语句

循环语句功能

在某些条件满足的情况下，反复执行特定代码的功能

For循环

基本语法

\1. for 关键字，表示循环控制

\2. for 有四要素: (1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代

\3. 循环操作 , 这里可以有多条语句，也就是我们要循环执行的代码

\4. 如果 循环操作(语句) 只有一条语句，可以省略 {}

注意事项和细节说明

1) 循环条件是返回一个布尔值的表达式

2) for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。

3) 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代 语句，中间用逗号隔开。

for 循环练习题1) 打印 1~100 之间所有是 9 的倍数的整数，统计个数 及 总和.[化繁为简,先死后活]public class ForExercise {//编写一个 main 方法public static void main(String[] args) {//打印 1~100 之间所有是 9 的倍数的整数，统计个数 及 总和.[化繁为简,先死后活]//两个编程思想(技巧)//1. 化繁为简 : 即将复杂的需求，拆解成简单的需求，逐步完成 编程 = 思想 --练习-> 代码//2. 先死后活 : 先考虑固定的值，然后转成可以灵活变化的值////思路分析//打印 1~100 之间所有是 9 的倍数的整数，统计个数 及 总和//化繁为简//(1) 完成 输出 1-100 的值//(2) 在输出的过程中，进行过滤，只输出 9 的倍数 i % 9 ==0//(3) 统计个数 定义一个变量 int count = 0; 当 条件满足时 count++;//(4) 总和 , 定义一个变量 int sum = 0; 当条件满足时累积 sum += i;//先死后活//(1) 为了适应更好的需求，把范围的开始的值和结束的值，做出变量//(2) 还可以更进一步 9 倍数也做成变量 int t = 9;int count = 0; //统计 9 的倍数个数 变量int sum = 0; //总和int start = 10;int end = 200;int t = 5; // 倍数for(int i = start; i <= end; i++) {if( i % t == 0) {System.out.println("i=" + i);count++;sum += i;//累积}}System.out.println("count=" + count);System.out.println("sum=" + sum);}}

while循环

基本语法

while循环执行流程分析

注意事项和细节说明

1) 循环条件是返回一个布尔值的表达式

2) while 循环是先判断再执行语句

例题：public class WhileExercise {//编写一个 main 方法public static void main(String[] args) {// 打印 1—100 之间所有能被 3 整除的数 [使用 while, 老师评讲 ]// 化繁为简, 先死后活int i = 1;int endNum = 100;while( i <= endNum) {if( i % 3 == 0) {System.out.println("i=" + i);}i++;//变量自增// 打印 40—200 之间所有的偶数 [使用 while, 课后练习]// 化繁为简, 先死后活(利于思考)//System.out.println("========");int j = 40; //变量初始化while ( j <= 200) {//判断if( j % 2 == 0) {System.out.println("j=" + j);}j++;//循环变量的迭代}}}

do..while 循环控制

基本语法

循环变量初始化；

do{

循环体(语句);

循环变量迭代

}while(循环条件);

\1. do while 是关键字

\1. 也有循环四要素, 只是位置不一样

\2. 先执行，再判断，也就是说，一定会至少执行一次

\3. 最后 有一个 分号 ;

\4. while 和 do..while 区别举例: 要账

do...while 循环执行流程分析

注意事项和细节说明

1) 循环条件是返回一个布尔值的表达式

2) do..while 循环是先执行，再判断， 因此它至少执行一次

public class DoWhileExercise01 {//编写一个 main 方法public static void main(String[] args) {//统计 1---200 之间能被 5 整除但不能被 3 整除的 个数//化繁为简//(1) 使用 do-while 输出 1-200//(2) 过滤 能被 5 整除但不能被 3 整除的数 %//(3) 统计满足条件的个数 int count = 0;//先死后活//(1) 范围的值 1-200 你可以做出变量//(2) 能被 5 整除但不能被 3 整除的 , 5 和 3 可以改成变量int i = 1;int count = 0; //统计满足条件的个数do {if( i % 5 == 0 && i % 3 != 0 ) {System.out.println("i=" + i);count++;}i++;}while(i <= 200);System.out.println("count=" + count);}}

例题：要帐还钱

//编写一个 main 方法public static void main(String[] args) {//如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为//[System.out.println("老韩问：还钱吗？y/n")] do...while .. ////化繁为简//(1) 不停的问还钱吗?//(2) 使用 char answer 接收回答, 定义一个 Scanner 对象//(3) 在 do-while 的 while 判断如果是 y 就不在循环//一定自己动脑筋.. Scanner myScanner = new Scanner(System.in);char answer = ' ';do {System.out.println("老韩使出五连鞭~");System.out.println("老韩问：还钱吗？y/n");answer = myScanner.next().charAt(0);System.out.println("他的回答是" + answer);}while(answer != 'y');//判断条件很关键System.out.println("李三还钱了");}}

多重循环控制(难点! 重点!)

将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环和内层循环。

实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。

例如：

public static void main(String[] args) {for (int i = 1; i <=4 ; i++) {//外层循环控制行数 4行for (int j =1; j <=4; j++) {//内层循环控制每行元素的数量 每行有4个元素 System.out.print("j="+j);}System.out.println("i="+i);// println---> 与print相比除了打印还有换行的作用}}

结果：j=1j=2j=3j=4i=1 j=1j=2j=3j=4i=2 j=1j=2j=3j=4i=3 j=1j=2j=3j=4i=4

例题：经典的打印金字塔

使用 for 循环完成下面的案例

请编写一个程序，可以接收一个整数,表示层数（totalLevel），打印出金字塔。

public class Stars {//编写一个 main 方法public static void main(String[] args) {/*** ** ************思路分析化繁为简1. 先打印一个矩形*************************2. 打印半个金字塔* //第 1 层 有 1 个*** //第 2 层 有 2 个**** //第 3 层 有 3 个***** //第 4 层 有 4 个****** //第 5 层 有 5 个*3. 打印整个金字塔* //第 1 层 有 1 个* 2 * 1 -1 有 4=(总层数-1)个空格*** //第 2 层 有 3 个* 2 * 2 -1 有 3=(总层数-2)个空格***** //第 3 层 有 5 个* 2 * 3 -1 有 2=(总层数-3)个空格******* //第 4 层 有 7 个* 2 * 4 -1 有 1=(总层数-4)个空格********* //第 5 层 有 9 个* 2 * 5 -1 有 0=(总层数-5)个空格4. 打印空心的金字塔 [最难的]* //第 1 层 有 1 个* 当前行的第一个位置是*,最后一个位置也是** * //第 2 层 有 2 个* 当前行的第一个位置是*,最后一个位置也是** * //第 3 层 有 2 个* 当前行的第一个位置是*,最后一个位置也是*** //第 4 层 有 2 个* 当前行的第一个位置是*,最后一个位置也是********** //第 5 层 有 9 个* 全部输出*先死后活5 层数做成变量 int totalLevel = 5;//小伙伴 技术到位，就可以很快的把代码写出*/int totalLevel = 20; //层数for(int i = 1; i <= totalLevel; i++) { //i 表示层数//在输出*之前，还有输出 对应空格 = 总层数-当前层for(int k = 1; k <= totalLevel - i; k++ ) {System.out.print(" ");}//控制打印每层的*个数for(int j = 1;j <= 2 * i - 1;j++) {//当前行的第一个位置是*,最后一个位置也是*, 最后一层全部 *if(j == 1 || j == 2 * i - 1 || i == totalLevel) {System.out.print("*");} else { //其他情况输出空格System.out.print(" ");}}//每打印完一层的*后，就换行 println 本身会换行System.out.println("");}}}

经典例题：

import java.util.Scanner;public class MulForExercise01 {//编写一个 main 方法public static void main(String[] args) {//统计 3 个班成绩情况，每个班有 5 名同学，//求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。//统计三个班及格人数，每个班有 5 名同学。////思路分析://化繁为简//(1) 先计算一个班 , 5 个学生的成绩和平均分 , 使用 for//1.1 创建 Scanner 对象然后，接收用户输入//1.2 得到该班级的平均分 , 定义一个 doubel sum 把该班级 5 个学生的成绩累积//(2) 统计 3 个班(每个班 5 个学生) 平均分//(3) 所有班级的平均分//3.1 定义一个变量，double totalScore 累积所有学生的成绩//3.2 当多重循环结束后，totalScore / (3 * 5)//(4) 统计三个班及格人数//4.1 定义变量 int passNum = 0; 当有一个学生成绩>=60, passNum++//4.2 如果 >= 60 passNum++//(5) 可以优化[效率，可读性, 结构]//创建 Scanner 对象Scanner myScanner = new Scanner(System.in);double totalScore = 0; //累积所有学生的成绩int passNum = 0;//累积 及格人数int classNum = 3; //班级个数int stuNum = 5;//学生个数for( int i = 1; i <= classNum; i++) {//i 表示班级double sum = 0; //一个班级的总分for( int j = 1; j <= stuNum; j++) {//j 表示学生System.out.println("请数第"+i+"个班的第"+j+"个学生的成绩");double score = myScanner.nextDouble();//当有一个学生成绩>=60, passNum++if(score >= 60) {passNum++;}sum += score; //累积System.out.println("成绩为" + score);}//因为 sum 是 5 个学生的总成绩System.out.println("sum=" + sum + " 平均分=" + (sum / stuNum));//把 sum 累积到 totalScoretotalScore += sum;}System.out.println("三个班总分="+ totalScore+ " 平均分=" + totalScore / (classNum*stuNum));System.out.println("及格人数=" + passNum);}}

break & continue

break基本介绍：

break 语句用于终止某个语句块的执行。用在 循环语句体中，可以强行退出循环；

快速入门:

注意事项和细节说明：

例如：

public static void main(String[] args) { //break 终止整个循环. continue 跳过 continue语句后面的循环内容, 继续执行下一次循环 for (int i = 0; i < 10; i++) {if(i==5){// break;continue;}System.out.print(i);}}

结果：若是break 则是 0 1 2 3 4 若是continue，则是012346789，，跳过了5

例如：

public static void main(String[]args) {//先写循环标签(名字自定义)outloop:for (int i = 1; i <=4 ; i++) {//外层循环控制行数for (int j =1; j <=4; j++) {//内层循环控制元素的数量if(j==3){break outloop; //break加循环标签名，在多层循环嵌套中,在内层循环中,想把整个的循环结束掉}System.out.prit("j="+j);}System.out.println("i="+i);//换行}}

结果：j=1 j=2 为什么没有i=1，是因为使用break outloop 使得在内层循环中整个循环直接被中止，而不是外层的当次循环结束，所以不会执行外层循环的语句

continue基本介绍：

continue 语句用在循环语句体中，用于终止某次循环过程，跳过循环体中 continue 语句下面未执行的循环，开始下一次循环过程

continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环 , 这个和前面的标签的使用的规则一样.

while 使用 continue 为例,画出示意图

快速入门案例

方法与return语句

•Java的方法类似于其它语言的函数，方法是解决一类问题的步骤的有序组合,方法包含于类或对象中.

• 方法在程序中被创建，声明格式： [访问权限修饰符 修饰符…] [返回值类型] 方法名(形式参数类型 参数名){Java语句；… … … [return 返回值;] } •修饰符：这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

• 形式参数： 在方法被调用时用于接收外界输入的数据。 • 实参：调用方法时实际传给方法的数据。 • 返回值：方法在执行完毕后返还给调用它的环境的数据。 • 返回值类型：事先约定的返回值的数据类型，如无返回值，必须给出返回值类型void。

• Java语言中使用下述形式调用方法：对象名.方法名(实参列表) • 实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配， • return 语句终止方法的运行并指定要返回的数据

public class Demo2 {/*类的基本构成:变量方法(函数) 做什么 行为 主方法中调用即可 重复使用面向对象的语言-->方法 */ int age;//属性 变量 存储数据 //主函数： public static void main(String[] args) {int a = 10; int b = 5; //调用show方法 Demo2.show(); ※※ 因为是static，所以不用新创建对象就能调用方法，直接用类名！！！int m = Demo2.max(a,b); System.out.println(m); //打印输出传过来的参数中的最大值Demo2.max1();} //自定义的方法 ----->自定义了一个名为show的无参成员方法 //public 访问权限修饰符 公共的 void 表示方法没有返回值 show方法名 ()参数列表 // static 类方法 静态的 有static修饰则此时可通过类名调用 public static void show(){ System.out.println("showshow"); } /* 定义了一个有参数,有返回值的方法 注意参数以及返回值的数据类型 */ /*return语句return语句用于从当前执行的方法中退出, 返回到调用该方法的语句处继续执行。有两种格式:return 表达式; //将表达式的值返回return; //不返回任何值，当方法说明中用void声明无返回值时, 可以使用这种格式，此类return语句有时可省略*/public static int max(int m,int n){int max = (m>n)?m:n;//判断返回两个整数中大的那一个return max;//通过return 关键字 返回结果 } public static void max1(){ int max = 10;if(max==11){return;// 在void方法中，起 "终止方法" 的这个作用（并不是终止整个循环） ， 但return后面不能加任何表达式 ，否则会与void冲突，会报错 } System.out.println("max"+max); }}结果是：showshow10max10