目录
第二章笔记
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 = false
System.out.println(b); //6 继续执行了++b
//&& 当前面的表达式返回false 发生短路 后面的表达式不会执行
System.out.println((a<b) && (++b<c)); //false && true && true = false
System.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 ---->4 0000 0000 0000 0000 0000 0000 0000 1000 ---->8 */ System.out.println(a<<1);//8 /* 0000 0000 0000 0000 0000 0000 0000 0100 ---->4 0000 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 ---> -6 1111 1111 1111 1111 1111 1111 1111 1101 ----> -3有符号右移 负数 移动后 符号不变 */ System.out.println(b>>1);//-3 /* 1111 1111 1111 1111 1111 1111 1111 1010 ----> -6 0111 1111 1111 1111 1111 1111 1111 1101 ----> 2147483645 无符号右移 不管前面符号位是什么,移动后统一补0 */ System.out.println(b>>>1);//2147483645
& 与 | 或 ^ 异或 ~ 非 进行位运算
例：
int a = 4; int b = 3; /* 0000 0100 0000 0011 0000 0000 结果为0 每一位bit位进行 与 运算 */ System.out.println(a&b); /* 0000 0100 0000 0011 0000 0111 结果为7 每一位bit位进行 或 运算 */ System.out.println(a|b); /* 0000 0100 0000 0011 0000 0111 结果为7 每一位bit位进行 异或 运算 口诀： 相同为假 不同为真 */ //System.out.println(a^b); // 若两个变量交换值 则可以使用^运算 a = a^b;//0000 0111 结果a为 7 b = a^b; // 7^3=4 结果b为4 a = a^b; //7^4 = 3 结果a为3 System.out.println(a); System.out.println(b); 最终导致原本的两数值，进行了交换a变成了3，b变成了4 若用a+b-a a+b-b 这样的方式来交换数值，可能会有a+b数值溢出这样的的问题，但^运算就不会有这种问题 /* 0000 0100 1111 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");
}
结果为true
if(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 累积到 totalScore
totalScore += 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);
}
}
结果是：
showshow
10
max10
927
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
