1// 数据类型 变量名 = 变量值;
2String name = "小红";
3
4
其实还有别的定义方式,例如:String name1,name2,name3 = “小明”;
在定义完变量之后,可以用于输出、计算等行为。
1// 将数据存储到变量中
2// 存储姓名
3String name;
4name = "野猪佩奇";
5
6// 存储年龄
7int age = 2;
8
9// System.out.println(name);
10// System.out.println(age);
11
12// System.out.println("我的名字是:name");
13// System.out.println("我的年龄是:age");
14
15// 拼接
16// 拼接为什么使用 + 号?
17// println是在输出一个字符串内容,但是现在我们想输出的内容不仅仅是字符串,还需要加上一个不确定类型的变量。
18// 其他类型数据(包含字符串类型)如果要和字符串拼接在一起,需要 + 号,拼接完的结果会变为一个整体字符串
19System.out.println("我的名字是:" + name);
20System.out.println("我的年龄是:" + age);
21
22System.out.println("我的名字是:" + name + ",我的年龄是:" + age);
23
24
3. 常量
在Java中,其值不能改变的变量被称为常量。常量被final修饰,被final修饰则无法二次修改值。
π:3.14
final:最终
1// 计算圆的面积 π * r * r
2// 圆的半径为 2
3
4// 定义变量存储半径
5double r = 2;
6
7// 定义变量存储π
8final double pi = 3.14;
9// 不小心改动了该值(重新赋值)
10// pi = 3;
11
12// 计算结果并存储到变量
13double area = pi * r * r;
14
15System.out.println("圆的面积为:" + area);
16
17
常量的命名规范:
4. 程序交互
Scanner 使用。
Scanner 是Java中提供的一个扫描器,它可以帮助我们扫描控制台输入的内容,并将其转换为你想要的类型值。
导入Scanner
在你想使用Scanner的类中,添加一行导入代码
import java.util.Scanner;
1package demo4;
2
3import java.util.Scanner; // 加在类声明和包声明之间
4
5public class Demo1 {
6
7 public static void main(String[] args) {
8
9 }
10
11}
12
13
14
创建Scanner对象
1// 创建对象,名字是自定义的,常见名:scan、input
2Scanner scan = new Scanner(System.in);
3
4
使用它的API(功能)
1// 想输入年龄
2int age = scan.nextInt();
3// 想输入余额
4double money = scan.nextDouble();
5// 想输入姓名
6String name = scan.next();
7
8
可以添加一些输出语句来辅助输入。
1// 想输入年龄
2System.out.print("请输入您的年龄:");
3int age = scan.nextInt();
4// 想输入余额
5System.out.print("请输入您的余额:");
6double money = scan.nextDouble();
7// 想输入姓名
8System.out.print("请输入您的姓名:");
9String name = scan.next();
10
11
常用的运算符检查问题分析
命名规范
缩进问题
缩进是同级对齐,下级缩进
1// xxx
2 xxxx
3 xxxx
4
5
使用Scanner
导入Scanner
创建Scanner对象使用
next() 可以输入字符串1. nextInt() 可以输入整数1. nextDouble() 可以输入小数
1package demo1;
2
3import java.util.Scanner;
4
5public class HelloWorld {
6 Scanner scan = new Scanner(System.in);
7
8 // 请输入您的年龄:18
9 System.out.print("请输入您的年龄:");
10 int age = scan.nextInt();
11 System.out.print("请输入您的姓名:");
12 String name = scan.next();
13}
14
15
注释规范
1// 创建对象
2Scanner scan = new Scanner(System.in);
3input.nextInt();
4
5
1. 类型转换
在 Java 中存在自动数据类型转换和强制数据类型转换。
double num = 10;
int num = (int)10.5
类型转换也不是万能的,Java 前期可以转换的就是 byte、short、int、long、float、double、char这些。
自动转换例如:
byte b = 10;
int num = b;
强制转换例如:
int num = 10;
byte b = num;
字符的秘密
1// 自动类型转换
2char alpha = 'a';
3int num = alpha;
4System.out.println("num:" + num); // 97
5
6// 强制类型转换
7int num1 = 99;
8char alpha1 = (char) num1;
9System.out.println("alpha1:" + alpha1); // c
10
11
它们的转换遵循了相应的码表,例如:ASCII码表。a是97、A是65…
2. 赋值运算符
= 号在各种编程语言中,不再表示相等,而是表示赋值。
只有极个别的语言,=号又表示赋值,又表示相等。
1// 读法:将数字10赋值给变量num
2// 将等号右侧的赋值给等号左侧的
3int num = 10;
4
5// 变量和变量之间的赋值
6// 将num的值赋值给变量num2
7int num2 = num;
8
9
3. 算术运算符
1+ 加法
2- 减法
3* 乘法
4/ 除法
5% 取余数
6++ 自增
7-- 自减
8
9
四则运算
1int num1 = 11;
2int num2 = 2;
3System.out.println(num1 / num2); // 5
4
5
在 Java 中进行数学计算时,有时候会出现与传统数学观念不符的情况,例如: 11 / 2 应该等于 5.5,但结果为 5。
是由于 11 和 2 都是整数,那么在计算的时候,对于结果的类型也是采用整数。(在计算的时候,计算结果的类型是由计算的值中取值范围最大的类型)
如果真的想得到 5.5,需要如下做:
1int num1 = 11;
2int num2 = 2;
3System.out.println(num1 * 1.0 / num2); // 5.5
4
5
自增和自减
++ 自增1
– 自减1
1int num1 = 10;
2// ++ num1;
3// num1 ++; 抽象理解为: num1 = num1 + 1
4
5// num1 --;
6-- num1; // 抽象理解为:num1 = num1 - 1
7// System.out.println(num1); // 11
8System.out.println(num1); // 9
9
10
当 ++ 和 – 在单独使用时,效果上没有任何区别。
但是当 ++ 和 – 在被使用或参与计算时,效果上有不同。
1int num1 = 10;
2
3// int num2 = num1 ++ - 2;
4
5// System.out.println(num1 ++); // 10
6// System.out.println(num1); // 11
7
8System.out.println(++ num1); // 11
9System.out.println(num1); // 11
10
11
字符的秘密
字符是可以和数值转换的。
1char alpha1 = 'a';
2alpha1 ++; // 理解为:alpha1 = alpha1 + 1
3System.out.println(alpha1); // b
4
5char alpha2 = 'b';
6// 在计算时,结果的类型是取值范围大的类型
7System.out.println(alpha2 + 1); // 99
8
9
4. 复合赋值运算符
1int num1 = 10;
2num1 += 2; // 理解为: num1 = num1 + 2
3System.out.println(num1); // 12
4
5int num2 = 12;
6num2 -= 3; // 理解为:num2 = num2 - 3
7System.out.println(num2); // 9
8
9
以后可以利用 += 和 -= 做累加运算。
例如:求1到10的和。
int num = 1;
num += 2; // num = num1 + 2
num += 3; //
num += 4;
…
5. 关系运算符
比较运算符,可以用来做判断,比较运算符的计算结果是 布尔类型 值。
true(真) 和 false(假)
=号代表赋值,==才代表相等。
6. 逻辑运算符
1// System.out.println(!true);
2// System.out.println(!false);
3
4double javaScore = 59;
5// 判断是否>=60
6System.out.println(javaScore >= 60);
7// 判断是否<60
8System.out.println(javaScore < 60);
9System.out.println(!(javaScore >= 60));
10
11
短路
1// 将数字7赋值给变量num1
2int num1 = 7;
3// 右边在做逻辑运算
4// false && true
5boolean flag2 = false && (++ num1 == 8);
6System.out.println(flag2); // false
7System.out.println(num1); // 7
8
9
短路与和短路或,代表的是如果前面的条件能够得到最终结果,那么后面的条件就不再进行了!
还有一个 & 和 | 也可以表示逻辑关系,但是一般不用,因为它们无论是否能从前面条件得到最终结果,都要对所有条件进行计算。
所以 && 和 || 可以优化程序执行性能。
7. 三元运算符
1Scanner scan = new Scanner(System.in);
2
3System.out.print("请输入您的年龄:");
4int age = scan.nextInt();
5
6String result = (age >= 18) ? "快来玩啊!" : "小屁孩给爷爪巴!";
7System.out.println(result);
8
9
选择结构检查问题分析
类名采用了小驼峰(目前只有一个)
包名采用了大写(目前只有一个)
运算符左右没留空格(目前很多)
int num = 10;
System.out.println("我的年龄是:" + num);
注释的//和注释内容之间没有留空格(目前2 - 3人)
// 这是注释
变量乱起名(目前两人)
交作业的时间非要卡在 DieLine
代码中一行注释也没有
代码要包含40%以上的注释
流程控制语句
任何一个语言编写出来的程序都包含这三种控制语句,因为它们可以让你的程序变得“丰富多彩”。
顺序控制语句
1// 顺序流程语句
2// 自上而下
3System.out.println("我是语句1");
4System.out.println("我是语句2");
5System.out.println("我是语句3");
6
7
选择控制语句
根据条件表达式,决定一部分代码是否可以正常执行。
条件表达式就是利用 关系运算符 和 逻辑运算符 来实现判断的过程,结果永远为 布尔类型:true(真、成立)、false(假、不成立)。
循环控制语句
可以帮助我们解决重复性的工作问题。
三种流程控制语句是要结合使用,每种都有它能解决的问题。
流程图绘制
UML
if系列选择结构基础if
if:如果
1if (条件表达式) {
2 // 条件成立时执行的代码段
3}
4
5
1Scanner scan = new Scanner(System.in);
2
3System.out.print("请输入您的年龄:");
4int age = scan.nextInt();
5
6// 判断
7// 如果你的年龄是大于等于18的
8if (age >= 18) {
9 // 那么就提示你可以进入网吧了
10 System.out.println("可以进入网吧啦!");
11}
12
13
复杂条件的情况,因为业务需要,经常要结合逻辑运算符来实现条件表达式。
1Scanner input = new Scanner(System.in);
2
3System.out.print("请输入乔治的Java成绩:");
4double javaScore = input.nextDouble();
5System.out.print("请输入乔治的音乐成绩:");
6double musicScore = input.nextDouble();
7
8if ((javaScore > 90 && musicScore > 80) ||
9 (javaScore == 100 && musicScore > 70)) {
10 System.out.println("查老师会奖励他一顿棒子'炖'肉!");
11}
12
13
可读性非常高,边读边写都可以。
互斥if
1if (条件) {
2 // 条件成立时执行的
3} else {
4 // 条件不成立时执行的
5}
6
7
如果用基础if来实现一些互斥效果内容,效果如下:
1Scanner input = new Scanner(System.in);
2
3System.out.print("请输入乔治的Java成绩:");
4double javaScore = input.nextDouble();
5System.out.print("请输入乔治的音乐成绩:");
6double musicScore = input.nextDouble();
7
8if ((javaScore > 90 && musicScore > 80) ||
9 (javaScore == 100 && musicScore > 70)) {
10 System.out.println("查老师会奖励他一顿棒子'炖'肉!");
11}
12
13if (!((javaScore > 90 && musicScore > 80) ||
14 (javaScore == 100 && musicScore > 70))) {
15 System.out.println("查老师会奖励他给查老师买一个 iPhone 11!");
16}
17
18
1Scanner input = new Scanner(System.in);
2
3System.out.print("请输入您的年龄:");
4int age = input.nextInt();
5
6// 判断
7if (age >= 18) {
8 System.out.println("网管:可以进来啦!");
9}
10
11if (age < 18) {
12 System.out.println("网管:滚");
13}
14
15
互斥if写法:
1Scanner input = new Scanner(System.in);
2
3System.out.print("请输入您的年龄:");
4int age = input.nextInt();
5
6// 判断
7if (age >= 18) {
8 System.out.println("网管:可以进来啦!");
9} else {
10 System.out.println("网管:滚");
11}
12
13
多重if
多分支的判断,按照自上而下的执行判断,只要有一个满足就不再向后执行其他的条件判断。
1if (条件1) {
2 // 条件1成立时执行的代码段
3} else if (条件2) {
4 // 条件2成立时执行的代码段
5} else if (..略..) {
6 // ...略...
7} else {
8 // 上方条件都不满足时执行的代码段
9}
10
11
1// 选择:基础if
2Scanner input = new Scanner(System.in);
3
4System.out.print("请输入佩奇的Java成绩:");
5double score = input.nextDouble();
6
7// 判断
8if (score >= 80) {
9 System.out.println("奖励她一部 OnePlus 8 Pro");
10}
11
12// 60 <= score < 80
13if (score >= 60 && score < 80) {
14 System.out.println("奖励她一部一加云耳");
15}
16
17if (score < 60){
18 System.out.println("奖励她给查老师买一部 iPhone 11 Pro");
19}
20
21
1// 选择:基础if
2Scanner input = new Scanner(System.in);
3
4System.out.print("请输入佩奇的Java成绩:");
5double score = input.nextDouble();
6
7// 判断
8if (score >= 80) {
9 System.out.println("奖励她一部 OnePlus 8 Pro");
10} else if (score >= 60) {
11 System.out.println("奖励她一部一加云耳");
12} else {
13 System.out.println("奖励她给查老师买一部 iPhone 11 Pro");
14}
15
16
多重if在编写条件判断时,注意不要胡乱放置条件,越容易满足或者范围越大的条件应该尽可能放下面。
在做范围型多条件判断时,多重if拥有非常好的优势。
嵌套if
它不是什么特别技术,就是前面的几个if的延伸而已。
1// 外部条件不成立,内部条件是不会执行的
2if (外部条件) {
3 if (内部条件) {
4
5 }
6}
7
8
1Scanner input = new Scanner(System.in);
2
3System.out.print("请输入您百米赛跑的成绩:");
4double score = input.nextDouble();
5
6// 判断是否能进入决赛
7if (score <= 10) {
8 System.out.println("恭喜您进入决赛!");
9
10 // 根据性别分组
11 System.out.print("请输入您的性别:");
12 String gender = input.next();
13 // equals:等于、相等
14 // 字符串.equals(字符串) 可以用来判断两个字符串内容是否相同
15 if (gender.equals("男")) {
16 System.out.println("男子组欢迎你!");
17 } else {
18 System.out.println("女子组欢迎你!");
19 }
20
21} else {
22 System.out.println("很遗憾!下次继续!");
23}
24
25
由于嵌套if会导致结构愈加混乱,所以使用时注意层级不要嵌套太多。否则容易出现你写的代码,你看不懂这类问题。
而且一般嵌套两层或三层,如果再多一般要考虑其他解决方案。
switch选择结构
多重if在做范围型的多条件判断比较有优势,而做等值判断并没有太优异的表现。
1Scanner input = new Scanner(System.in);
2
3System.out.print("请输入小杨的最终名次:");
4int level = input.nextInt();
5
6// 使用多重if判断
7if (level == 1) {
8 System.out.println("诛仙女猪脚!");
9} else if (level == 2) {
10 System.out.println("斗罗大陆女猪脚!");
11} else if (level == 3) {
12 System.out.println("永夜女猪脚!");
13} else {
14 System.out.println("还想演戏?先拜拜自己吧!");
15}
16
17
而switch选择结构则恰恰弥补了此问题。
1// switch:切换
2// case:情况、场景
3// break:中断
4// default:缺省的,默认的
5switch (表达式) {
6 case 常量值:
7 // 代码段
8 break;
9 case 常量值:
10 // 代码段
11 break;
12 ....
13 default:
14 // 默认处理
15 break;
16}
17
18
1Scanner input = new Scanner(System.in);
2
3System.out.print("请输入小杨的最终名次:");
4int level = input.nextInt();
5
6switch (level) {
7 case 1: // level == 1
8 System.out.println("诛仙女猪脚!");
9 break;
10 case 2: // level == 2
11 System.out.println("斗罗大陆女猪脚!");
12 break;
13 case 3: // level == 3
14 System.out.println("永夜女猪脚!");
15 break;
16 default: // level == 4
17 System.out.println("还想演戏?先拜拜自己吧!");
18 break;
19}
20
21
注意事项
switch中表达式只能使用 int(byte、short、char)、String(JDK1.7起支持)、枚举类型
1Scanner input = new Scanner(System.in);
2
3System.out.print("小度小度,今天星期几?");
4int dayOfWeek = input.nextInt();
5
6switch (dayOfWeek) {
7 case 1:
8 case 2:
9 case 3:
10 case 4:
11 case 5:
12 System.out.println("好好工作");
13 break;
14 case 6:
15 case 7:
16 System.out.println("好好休息!");
17 break;
18}
19
20
和if的区别随机数的获取
Math.random() 可以获取到[0.0, 1.0)之间的随机小数。(>=0.0 并且 < 1.0)
1// [0.0, 1.0)
2// double num = Math.random();
3// System.out.println(num);
4
5// [5, 10) 随机整数
6// 【公式】(int)(Math.random() * (最大值 - 最小值) ) + 最小值
7// [0.0, 1.0) -> [0.0, 5.0) -> [0, 5) -> [5, 10)
8int num = (int)(Math.random() * 5) + 5;
9System.out.println(num);
10
11
循环结构1. 检查问题分析
代码不规范
代码是给人看的,不是给机器看的。遵守良好的代码规范,让你在未来就业时,不至于因为代码规范问题而被"指点"。
在公司内,需求理解错误,意味着你的辛苦,你的劳累都是无用的。你是在犯错而不是完成自己的工作。
看到需求,先读,先去思考过程(程序是一系列指令的集合,是为了完成某件事情的步骤、次序)
很长时间内,一直会出现。
如果你发现当前你写代码总是写出僵化的代码,例如:老师讲了一种案例,然后只能实现相差无几的案例,稍微复杂一点就完蛋。想不出来,或者写一大堆才能完成。
塌下来心来,承认自己当前的不足,而不是过于攀比。学习老师的思路,借鉴同学的思路,甚至将这种思路用的更好。(商业战争中,此类情况不胜枚举。你看看腾讯)
一般情况下,这种同学不一定比思路敏捷的同学混的差。
多做题,学多一种解决方法,这样你不也算会了吗?
2. 什么是循环?2.1 生活
我们上班、上学、甚至是一些回复都是循环的过程。
循环:反复地连续做某事。
周而复始,有规律性,重复的内容。
2.2 程序
1public class Demo1 {
2
3 public static void main(String[] args) {
4 System.out.println("好好学习,天天向上,上学期间,不搞对象,关起门来都是一家人,搞对象那是乱伦。");
5 System.out.println("好好学习,天天向上,上学期间,不搞对象,关起门来都是一家人,搞对象那是乱伦。");
6 System.out.println("好好学习,天天向上,上学期间,不搞对象,关起门来都是一家人,搞对象那是乱伦。");
7 System.out.println("好好学习,天天向上,上学期间,不搞对象,关起门来都是一家人,搞对象那是乱伦。");
8 System.out.println("好好学习,天天向上,上学期间,不搞对象,关起门来都是一家人,搞对象那是乱伦。");
9 System.out.println("好好学习,天天向上,上学期间,不搞对象,关起门来都是一家人,搞对象那是乱伦。");
10 System.out.println("好好学习,天天向上,上学期间,不搞对象,关起门来都是一家人,搞对象那是乱伦。");
11 System.out.println("好好学习,天天向上,上学期间,不搞对象,关起门来都是一家人,搞对象那是乱伦。");
12 System.out.println("好好学习,天天向上,上学期间,不搞对象,关起门来都是一家人,搞对象那是乱伦。");
13 System.out.println("好好学习,天天向上,上学期间,不搞对象,关起门来都是一家人,搞对象那是乱伦。");
14 System.out.println("好好学习,天天向上,上学期间,不搞对象,关起门来都是一家人,搞对象那是乱伦。");
15 System.out.println("好好学习,天天向上,上学期间,不搞对象,关起门来都是一家人,搞对象那是乱伦。");
16 }
17
18}
19
20
3. while循环
while:当、在…期间、在…时候、直到…
很多语言中,见到while想到的就是循环。
1while (循环条件) {
2 循环体/循环操作
3}
4---
5if (条件表达式) {
6 条件成立时执行的内容
7}
8
9
1// 使用循环来实现输出内容10次
2/*
3 * 思路分析:
4 * 1.根据需求可知需要采用 while 循环
5 * 2.分析循环的要素
6 * (什么时候可以执行循环操作)循环条件:输出的次数 <= 10
7 * (要循环执行什么内容)循环操作:输出内容
8 * 3.套入 while 语法
9 * 1.初始化 循环变量
10 * 2.循环条件
11 * 3.循环操作
12 * 4.循环出口(更新循环变量)
13 * 4.检查循环是否能正常结束
14 */
15
16// 1.初始化 循环变量
17int i = 1;
18
19// 2.循环条件
20while (i <= 1000) {
21 // 3.循环操作
22 System.out.println("第" + i + "遍:好好学习,天天向上");
23 // 4.循环出口(更新循环变量)
24 // i ++; // i = i + 1
25 i += 1;
26}
27
28
1// 打印50份试卷
2/*
3 * 思路分析:
4 * 1.要采用循环
5 * 2.分析循环的要素
6 * 循环条件: <= 50
7 * 循环操作:打印每份试卷
8 * 3.套入 while 语法
9 * 4.检查循环是否能够正常结束
10 */
11// 1.初始化 循环变量
12int i = 1;
13
14// 2.循环条件
15while (i <= 50) {
16 // 3.循环操作
17 System.out.println("正在打印第" + i + "份试卷");
18 // 4.循环出口(更新循环变量)
19 i ++;
20}
21
22
4. do-while循环
do:做…事
1do {
2 循环体/循环操作
3} while (循环条件);
4
5
do-while 循环至少会执行一次循环操作。
1/*
2 * 思路分析:
3 * 1.应该采用循环
4 * 2.分析循环的要素
5 * 循环条件:检测不合格
6 * 循环操作:进行理论学习,进行上机编程
7 * 3.套用do-while语法
8 * 1.初始化 循环变量
9 * 2.循环操作
10 * 3.循环出口
11 * 4.循环条件
12 * 4.检查是否能正常结束循环
13 */
14
15// 1.初始化 循环变量
16String result;
17
18Scanner input = new Scanner(System.in);
19do {
20 // 2.循环操作
21 System.out.println("进行理论学习!");
22 System.out.println("进行上机编程!");
23
24 // 3.循环出口(更新循环变量)
25 System.out.print("老师检测是否合格(y/n):");
26 result = input.next();
27} while ("n".equals(result)); // 4.循环条件
28
29System.out.println("考核通过!");
30
31
我们前期用的比较多,因为它的执行思路和生活中业务大多类似。
5. for循环
for 循环非常简洁,它的结构与 while 和 do-while不同,它是直接将循环4要素都安排好了位置,可以避免遗失出口等问题。
for 循环只能用于固定次数的循环场景。
在后期,用的非常多!基于它还有一个变种:增强for循环(foreach)
1for (1.初始化循环变量; 2.循环条件; 3.循环出口) {
2 4.循环操作
3}
4
5
语法中 ; 号是必须的。
1// 使用for循环改造打印50份试卷
2public class Demo1 {
3
4 public static void main(String[] args) {
5 // for循环只能用于固定次数的循环场景
6 // 循环条件:<= 50
7 // 循环操作:打印每份试卷
8 for (int i = 1; i <= 50; i++) {
9 System.out.println("正在打印第" + i + "份试卷!");
10 }
11 }
12
13}
14
15
6. 三者区别
执行次序的区别:
应用场景:
多重循环1. 死循环
死循环: 循环语句无法正常停止的情况,就被称为死循环。一般都是缺失了循环的出口或者循环条件存在问题。
按理说,死循环并不是一件好事,但是 “功法没有正邪之分,有正邪之分的是使用的人。” 如果被你使用正确,它可以解决很多问题。
适用的场景: 当你不确定,或是确定循环条件及出口时较为困难/麻烦时,可以采用死循环。
1while (true) {
2
3}
4
5
1do {
2
3} while (true);
4
5
1for (;;) {
2
3}
4
5
但无论是死循环也好,还是正常循环,都应该保证有相应出口。我们可以通过循环中的跳转语句,来实现循环流程的控制。
break
break:中断
break 在 switch 选择结构中出现过,它当时的意思是结束某个分支。
在循环中,它表示结束当前所在循环,一般还要配合选择结构使用。
continue
continue:继续
只能在循环中使用,它表示结束当前所在循环的本次循环(本次循环中,continue后的所有内容不再执行),跳转到下一次循环开始。
2. 多重循环概述
需求:实现下方图形的打印,通过一颗*一颗*的方式来打印。
1*****
2*****
3*****
4*****
5*****
6
7
1*
2***
3*****
4*******
5*********
6
7
1 *
2 ***
3 *****
4 *******
5*********
6
7
1 *****
2 *****
3*****
4
5
单层循环无法实现稍微复杂些的需求,所以我们需要使用多重循环(嵌套循环),它是一种类似于嵌套 if 的存在。
1while (外层循环条件) {
2 while (内层循环条件) {
3
4 }
5}
6
7
1do {
2 for (内层循环条件) {
3
4 }
5 for (内层循环条件) {
6
7 }
8} while (外层循环条件);
9
10
不同的循环结构之间可以相互嵌套,嵌套多少层、多少个都可以。
但是一般嵌套的层数不要超过3层,因为层数过多,循环结构过于复杂,因小失大。
一般的嵌套都是两层居多,所以多重循环又被称为二重循环/双重循环。
产生循环嵌套之后,会分为外层循环和内层循环,内层循环此时其实就是外层循环的循环操作 。
外层循环执行一次,内层循环执行一遍!
3. 案例实现3.1 打印矩形图形
1for (int i = 1; i <= 5; i++) {
2 for (int j = 1; j <= 5; j++) {
3 System.out.print("*");
4 }
5 System.out.println();
6}
7
8
3.2 打印三角形
打印直角三角形:
1*
2***
3*****
4*******
5*********
6
7
1for (int i = 1; i <= 5; i++) {
2 for (int j = 1; j <= 2 * i - 1; j++) {
3 System.out.print("*");
4 }
5 System.out.println();
6}
7
8
打印等腰三角形:
1 *
2 ***
3 *****
4 *******
5*********
6
7
3.3 打印平行四边形
1for (int i = 1; i <= 3; i++) {
2 for (int k = 1; k <= 3 - i; k++) {
3 System.out.print(" ");
4 }
5 for (int j = 1; j <= 5; j++) {
6 System.out.print("*");
7 }
8 System.out.println();
9}
10
11
3.4 打印九九乘法表
11*1=1
21*2=2 2*2=4
31*3=3 2*3=6 3*3=9
4....
51*9=9 2*9=18 3*9=27 ....
6
7
1for (int i = 1; i <= 9; i++) {
2 for (int j = 1; j <= i; j++) {
3 System.out.print(j + "*" + i + "=" + (j * i) + "\t");
4 }
5 System.out.println();
6}
7
8
4. 作业
现在默写:类名的规范、变量名的规范、常量名的规范、注释的规范、缩进的规范。
作业见文档。
一维数组
变量是一种单个值的存储方式,这种存储方式无法满足日益增多的数据需求。所以我们需要找寻一种可以同时存储多个数据的存储方式。
数组可以解决此类问题。
1. 什么是数组?
数组,顾名思义就是:数据的组合。它是在内存空间中开辟一连串的存储空间,可以存储多个 具有相同数据类型的数据 。
而且数组相比于变量来讲,拥有更多的"可玩性"。
2. 数组的组成
类比变量来记忆。
变量的组成:
数据类型变量名变量值
数组的组成:
数组的数据类型:数组存储的是一组相同数据类型的数据,需要做好指定。
数组名:使用数组时,也需要通过名字来使用
元素:数组中存储的每一个值,我们称之为元素
容量:长度,一个数组可以存储多少个元素( 一经定义,不可变 )
下标:索引,数组中每一个存储空间的 “序号”,从0开始计算
每一个下标空间,都有默认值。
根据数据类型不同,它的默认值分别为:
数组是存储一组具有 相同数据类型 数据的 定长 空间。
3. 数组定义
变量的定义:
1数据类型 变量名 = 变量值;
2
3
数组的定义1:
1// 先声明数组
2数据类型[] 数组名 = new 数据类型[容量];
3// 数组赋值(存入值,修改值)
4数组名[下标] = 元素值;
5// 数组使用
6数组名[下标]
7
8
数组的定义2:
1// 声明时赋值
2数据类型[] 数组名 = {元素1, 元素2, 元素3, ...};
3
4
1// 声明时赋值
2// 后期有时候只能使用这种方式
3数据类型[] 数组名 = new 数据类型[] {元素1, 元素2, 元素3, ...};
4
5
数组的定义1,结合循环优化:(动态赋值)
1// 先声明数组
2数据类型[] 数组名 = new 数据类型[容量];
3
4// 使用循环动态赋值
5for (int i = 0; i < 数组的容量; i++) {
6 数组名[i] = 输入值;
7}
8
9
4. 数组的使用4.1 计算最高分多维数组1. Why?
如果要求计算一个班的5名同学的成绩和,可以使用一维数组 + 普通循环解决。
而如果是计算三个班的各5名同学的成绩和,一维数组和普通循环实现起来不够好,所以我们才需要学习更高级的概念:多维数组。
2. 概念
多维数组,可以理解为嵌套数组。
二维数组:是以 一维数组 作为 数组元素 的数组,即 “数组的数组”。
多维数组的常见表现形式是二维数组、三维数组,但一般以二维数组居多。
多维数组在Java中,语法是存在的,但内存角度来看的话,只有一维数组。
3. 定义方式一
1// 数据类型[] 数组名 = new 数据类型[容量/长度];
2// 存储一个班5名同学的成绩
3// 成绩的数据类型:double
4// 数组的容量:5
5double[] scores = new double[5];
6
7scores[0] = 90;
8scores[1] = 80;
9scores[2] = 70;
10scores[3] = 60;
11scores[4] = 50;
12
13
1// 数据类型[][] 数组名 = new 数据类型[外维数组的容量][内维数组的容量];
2// 存储三个班各5名同学的成绩
3// 外维数组:存储的是3个班的成绩
4// 内维数组:每个班的5名同学成绩
5// 外维数组的数据类型:double[]
6// 内维数组的数据类型:double
7double[][] scores = new double[3][5];
8
9// 存储第一个班成绩
10scores[0][0] = 90; // 第一个班的第一个学生
11scores[0][1] = 80;
12scores[0][2] = 80;
13scores[0][3] = 80;
14scores[0][4] = 80;
15// 存储第二个班成绩
16scores[1][0] = 80;
17scores[1][1] = 80;
18scores[1][2] = 80;
19scores[1][3] = 80;
20scores[1][4] = 80;
21// 存储第三个班成绩
22scores[2][0] = 80;
23scores[2][1] = 80;
24scores[2][2] = 80;
25scores[2][3] = 80;
26scores[2][4] = 80;
27
28
数组也是一种数据类型 ,但是它不是普通的数据类型(int、double),数组存储的是一组相同数据类型的数据。 int[]、double[]。
二维数组:int[][]
三维数组:int[][][]
方式二
直接赋值
1// 存储1个班5名同学成绩
2double[] scores = {90, 80, 70, 60, 50};
3double[] scores = new double[] {90, 80, 70, 60, 50};
4
5
1// 存储3个班的各2名同学成绩
2// 把{}看做是一个一维数组
3double[][] scores = {{90, 80}, {80, 80}, {70, 70}};
4double[][] scores = new double[][] {{90, 80}, {80, 80}, {70, 70}};
5
6
动态赋值
1// 定义二维数组,用来存储3个班的各5名同学成绩
2double[][] scores = new double[3][5];
3
4Scanner input = new Scanner(System.in);
5// 动态录入
6// 循环外维数组
7for (int i = 0; i < scores.length; i++) {
8 System.out.println("开始录入第" + (i+1) +"班的成绩:");
9 // 循环内维数组
10 for (int j = 0; j < scores[i].length; j++) {
11 System.out.print((i+1) + "班的第" + (j+1) + "个学生的成绩是:");
12 scores[i][j] = input.nextDouble();
13 }
14}
15
16System.out.println("第1个班的第2名同学成绩:" + scores[0][1]);
17
18
方式三
二维数组,定义时其实只需要指定好一维数组的容量即可。
1// 存储3个班的成绩,1班3人,2班2人,3班3人
2double[][] scores = new double[3][];
3scores[0] = new double[3];
4scores[1] = new double[2];
5scores[2] = new double[3];
6
7
4. 使用5. Arrays工具类
API:Application Programming Interface 应用程序接口。
Arrays 是 Java 提供的数组操作类,提供了大量的数组操作方法。
它和 Scanner 一样,都是在 java.util 包下的,所以在使用时也需要先 import。
类和对象
如果你现在学习没有动力了,先接受我的三个提问?
1.不学这个,你能干什么?(你有没有退路?)
2.你想不想要赚钱多?(你有没有稳定的赚钱门路,谈对象提起自己的职业是否能开口)
3.没有技术傍身,你是不是能够在当前社会独立活下去且活的更好?(现在这个时代需要你有技术)
面向对象:
有难度!工作2年左右才能完全理解。
前期学习过程中,关注语法和一些理论,以及实现步骤。(照猫画虎)
不要和我来说:
1.好像明白又好像不明白???
2.老师这阶段我没学好,下个阶段不行吧???
3.老师上可能听懂,下课写不出来,好难。
1. 软件开发思想演变1.1 面向过程编程思想
过程。
将过程功能化、函数化、方法化、模块化。
将原来重复使用的内容,或者说是原来直接编写的指令改为一个个的小功能,这些小功能要求可以独立完成某个任务,还能实现复用。
例如:Scanner 中的 nextInt() 方法,就可以独立完成控制台输入整数的功能,并且可以复用。
1.2 面向对象编程思想
面向对象是基于面向过程演进而来的。
对象。
将具有相似功能或者具有关联性功能,抽取到一个类中,然后下次想使用该功能时,先找到该类的对象,再使用即可。
例如:我们需要实现键盘录入,首先想到的就是 Scanner ,这个类中提供了与键盘录入有关的所有功能。
1.3 如何理解面向过程和面向对象?
卖煎饼。
将卖煎饼转换为面向过程思路。
将卖煎饼转换为面向对象思路, 找专业的人来干专业的事儿。
项目规模必须达到一定的程度,否则面向过程可能比面向对象更实在。
2. 生活中的类和对象
无论是面向过程还是面向对象,它们都是来自于生活中的技巧和思路。
类和对象,是面向对象中非常重要的两个概念。
“万物皆对象”:你可以将生活中所有的事物、个体都看成一个个的对象。
人类的认知规律: 首先认识一个个体、把它看成是一个 对象 。然后再发现多个具有相似特征的个体之后,把它们抽取下相似特征归为一个 类别 。
例如:下面的这辆车可以看作是一个对象,然后对象的特征为:黄色的法拉利、有4个轮胎、有两个大灯、售价多少,可以前行、可以停下,可以播放音乐、可以把妹。
将特征分类:
行为
前行
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UKb61hYo-1613575228244)(D:/HUIZONG/JAVA笔记/day15/类和对象.assets/image-20210125112112604.png)]
车类。
例如:下面这只狗。
也可以看成一个对象,对象的特征描述:
行为:
可以跑
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4FIWUDKX-1613575228244)(D:/HUIZONG/JAVA笔记/day15/类和对象.assets/image-20210125112629197.png)]
狗类。
生活中类和对象是无处不在的,类是从一组具有相同特征的对象中抽象而来的,所以它是一个抽象的概念,无法直接使用此概念做什么事儿。而对象则是基于类抽象概念为模板产生的个体,对象是可以直接用于干什么事儿。
所以程序中,为什么说:Scanner 想使用要先创建对象,最后用对象去调用行为。
3. 程序中的类和对象3.1 类概念
Java 语言也是符合面向对象编程思想的。
而且在 Java 中,类是基本的组成单元,意味着想开发一个 Java 程序就是要编写一个到多个的类。
1// 类声明
2[访问权限修饰符] class 类名 {
3 // 类体
4 // 【属性】/成员变量/实例变量/Field
5 [访问权限修饰符] 数据类型 属性名;
6 // ...
7
8 // 行为/成员【方法】/实例方法/Method
9 [访问权限修饰符] [其他修饰符] 返回值类型 方法名(形式参数列表) {
10 // 方法体
11 }
12 // ...
13}
14
15
上述语法就是 Java 中用于描述生活中类概念的语法。
3.2 类图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t611tvI4-1613575228244)(D:/HUIZONG/JAVA笔记/day15/类和对象.assets/image-20210125120137694.png)]
在使用程序编写狗类之前,先使用类图描述好狗类:即设计狗类的类图。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TJmlbOCI-1613575228245)(D:/HUIZONG/JAVA笔记/day15/类和对象.assets/image-20210125120521913.png)]
3.3 对象概念
对象是类的具体实例,也是在使用时的主体。(面向对象)
1// 对象名的规范和变量名一致
2类名 对象名 = new 类名(参数值);
3
4
1// 属性赋值
2// 描述对象的属性
3对象名.属性名 = 属性值;
4
5
1// 调用方法
2// 描述对象的行为
3对象名.方法名(参数值);
4
5
方法和方法重载
完全不用担心学不会!以后天天用!
1. 方法概述
在面向过程出现的时候,方法就出现了。在程序中要存储数据,会采用变量来存储,以方便我们复用。而方法的出现使为了存储程序中的功能代码,以方便我们复用。
例如:为了方便我们反复使用键盘录入功能,Scanner 类提供了一个 nextXX(),每次使用键盘录入直接调用该方法即可。
2. 方法的语法和分类语法
1// 方法声明
2[访问权限修饰符] [其他修饰符] 返回值类型 方法名([方法的参数列表]) {
3 // 方法体
4 // 功能代码....
5 [return 返回值;]
6}
7
8
**访问权限修饰符:**目前先认识一个 publicASP 变量,代表公共的,意味着在项目中可以被使用。
**其他修饰符:**目前先认识一个 static ,代表静态的,后面专门讲。
**返回值类型:**一个方法,一个功能在执行完之后返回的数据的类型。 例如:nextInt() : int,因为你要获取到输入的数据,所以必须定义返回值,因为要得到的返回数据是整数所以返回值类型是int。
**方法名:**为了方便下次再使用,要起名。命名规范与变量名一致。
方法参数列表: 一个方法内部要执行的功能,有些时候是要进行某些数据处理,但是要处理的数据必须由你来提供给它,所以它需要提前规范好需要什么数据。例如:Arrays.toString(数组) : String
**return:**结束方法,并将返回结果返回到调用者位置。调用者可以将结果存储为变量或者直接输出等方式来使用。
把方法理解为榨汁机。
分类
以后学其他语言也基本是这4个分类。其他语言中可能叫函数、方法。
你们前期最害怕的事:就是不知道什么时候定义什么类型方法。建议多观察 Java 中的方法。
按照语法中是否有参数、是否有返回值来进行分类。
无参无返(没有参数、没有返回值)
一般这种方法,用于实现一些简单内容的输出或执行。
1// 没有返回值,返回值类型需要定义为 void,代表空。
2public void run() {
3 System.out.printf("%s今年%d岁,身高%.1fcm,正在跑步!\n", name, age, height);
4}
5
6
使用过的该类型方法:
1public void println() {
2 newLine();
3}
4
5
一般这种方法,用于实现一些需要根据条件或者一些基础数据,才能实现输出或执行的场景。
1// Arrays工具类中的方法,可以实现对传入的数组的元素进行升序排序
2public static void sort(int[] a) {
3
4}
5
6
使用过的该类型方法:
1public void println(int x) {
2 synchronized (this) {
3 print(x);
4 newLine();
5 }
6}
7
8
1* Arrays.sort(数组);
2
3* …
4
一般这种方法,适合于一些功能执行完可以返回一个结果的情况。因为没有参数,往往这类方法缺少灵活性、扩展性。
1// Math.random() 生成[0.0, 1.0)
2public static double random() {
3 return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
4}
5
6
使用过的该类型方法:
有参有返(有参数有返回值)
前期这种我们用的少,因为我们使用时一般都是用作于输出。后期用的越来越多,因为后期功能要求复杂。
1// Arrays.toString() 将数组转换为字符串
2public static String toString(int[] a) {
3 return xxx;
4}
5
6
使用过的该类型方法:
3. 构造方法概述
构造方法,顾名思义就是 Java 中用于对象创建/实例创建的方法。
每个类都有一个默认的构造方法:无参构造方法,你不写也会有。
如果你写了任意一个构造方法,默认的无参构造将不再提供。(建议每个类都自己写个无参,以防止未来定义有参构造之后,无参没有了)
语法
1[访问权限修饰符] 方法名([方法参数列表]) {
2
3}
4
5
构造方法只有有参和无参两种,因为构造方法的作用就是为了创建该类型的对象,那也就没有必要写上返回值类型了。
构造方法的方法名必须和类名一致,意味着 Student 类的构造方法就是 Student()。
带参构造的用处
使用带参构造方法可以用于属性快速赋值。
1public class Student {
2
3 public String name;
4 public int age;
5 public String classId;
6
7 // 无参构造方法
8 public Student() {
9 System.out.println("呵呵呵?");
10 }
11
12 // 带/有参构造方法
13 // 方法参数列表中的名字无所谓,随便写,主要重点在于类型
14 // 因为外界关注的是这个方法需要什么类型的参数,而不是参数名
15 public Student(String stuName, int stuAge, String stuClassId) {
16 name = stuName;
17 age = stuAge;
18 classId = stuClassId;
19 }
20
21}
22
23
1// 使用传统方式来创建对象并赋值
2Student student = new Student();
3student.name = "小明";
4student.age = 18;
5student.classId = "353";
6
7// 通过带参构造方法来创建对象并赋值
8Student student2 = new Student("小红", 17, "349");
9
10
4. this关键字
在局部变量和成员变量出现重名时,局部变量优先级更高(优先使用局部变量)。
就近原则。
如果真重名了,可以使用 this 关键字区分。
this 关键字: 单词含义:这个。
1public class Student{
2 public String name;
3 public Student(String name) {
4 // 此刻 this 代表的就是xiaoMing对象
5 this.name = name;
6 }
7
8 public void printInfo() {
9 // 此刻 this 代表的就是xiaoMing对象
10 Sout("我的名字叫;" + this.name);
11 }
12}
13
14main() {
15 Student xiaoMing = new Student("小明");
16 xiaoMing.printInfo();
17
18 Student xiaoHong = new Student("小红");
19}
20
21
可以使用 this 在当前类中,调用对象能调用的东西。
如果短期内没能理解,先掌握它什么时候使用。例如:在构造方法中用于区分成员变量和局部变量。
5. 成员变量和局部变量区别
定义的位置:
初始值不同:
作用域不同:
变量作用域:与其直接所属的 {} 有关。
生命周期不同: (生老病死,什么时候诞生,什么时候销毁)
6. 方法重载现象
方法重载(Overload):在一个类中出现的方法名相同,参数列表不同的情况就被称为方法重载。与返回值类型、访问权限修饰符等无关!!!(例如:nextInt())
如果没有方法重载的支持,多个方法的方法名相同显然是不可能的。
例如:下方的四行输出语句,其实调用的不是一个方法,而是四个方法。
1// println(String x) : void
2System.out.println("xxx");
3// println(int x) : void
4System.out.println(111);
5// println(double x) : void
6System.out.println(12.5);
7// println(char x) : void
8System.out.println('x');
9
10
xtInt() : int
1`
有参有返(有参数有返回值)
前期这种我们用的少,因为我们使用时一般都是用作于输出。后期用的越来越多,因为后期功能要求复杂。
1// Arrays.toString() 将数组转换为字符串
2public static String toString(int[] a) {
3 return xxx;
4}
5
6
使用过的该类型方法:
3. 构造方法概述
构造方法,顾名思义就是 Java 中用于对象创建/实例创建的方法。
每个类都有一个默认的构造方法:无参构造方法,你不写也会有。
如果你写了任意一个构造方法,默认的无参构造将不再提供。(建议每个类都自己写个无参,以防止未来定义有参构造之后,无参没有了)
语法
1[访问权限修饰符] 方法名([方法参数列表]) {
2
3}
4
5
构造方法只有有参和无参两种,因为构造方法的作用就是为了创建该类型的对象,那也就没有必要写上返回值类型了。
构造方法的方法名必须和类名一致,意味着 Student 类的构造方法就是 Student()。
带参构造的用处
使用带参构造方法可以用于属性快速赋值。
1public class Student {
2
3 public String name;
4 public int age;
5 public String classId;
6
7 // 无参构造方法
8 public Student() {
9 System.out.println("呵呵呵?");
10 }
11
12 // 带/有参构造方法
13 // 方法参数列表中的名字无所谓,随便写,主要重点在于类型
14 // 因为外界关注的是这个方法需要什么类型的参数,而不是参数名
15 public Student(String stuName, int stuAge, String stuClassId) {
16 name = stuName;
17 age = stuAge;
18 classId = stuClassId;
19 }
20
21}
22
23
1// 使用传统方式来创建对象并赋值
2Student student = new Student();
3student.name = "小明";
4student.age = 18;
5student.classId = "353";
6
7// 通过带参构造方法来创建对象并赋值
8Student student2 = new Student("小红", 17, "349");
9
10
4. this关键字
在局部变量和成员变量出现重名时,局部变量优先级更高(优先使用局部变量)。
就近原则。
如果真重名了,可以使用 this 关键字区分。
this 关键字: 单词含义:这个。
1public class Student{
2 public String name;
3 public Student(String name) {
4 // 此刻 this 代表的就是xiaoMing对象
5 this.name = name;
6 }
7
8 public void printInfo() {
9 // 此刻 this 代表的就是xiaoMing对象
10 Sout("我的名字叫;" + this.name);
11 }
12}
13
14main() {
15 Student xiaoMing = new Student("小明");
16 xiaoMing.printInfo();
17
18 Student xiaoHong = new Student("小红");
19}
20
21
可以使用 this 在当前类中,调用对象能调用的东西。
如果短期内没能理解,先掌握它什么时候使用。例如:在构造方法中用于区分成员变量和局部变量。
5. 成员变量和局部变量区别
定义的位置:
初始值不同:
作用域不同:
变量作用域:与其直接所属的 {} 有关。
生命周期不同: (生老病死,什么时候诞生,什么时候销毁)
6. 方法重载现象
方法重载(Overload):在一个类中出现的方法名相同,参数列表不同的情况就被称为方法重载。与返回值类型、访问权限修饰符等无关!!!(例如:nextInt())
如果没有方法重载的支持,多个方法的方法名相同显然是不可能的。
例如:下方的四行输出语句,其实调用的不是一个方法,而是四个方法。
1// println(String x) : void
2System.out.println("xxx");
3// println(int x) : void
4System.out.println(111);
5// println(double x) : void
6System.out.println(12.5);
7// println(char x) : void
8System.out.println('x');
9
10
这样你就可以不需要记忆那么多的方法名,因为它们都是一样的功能。
(编辑:威海站长网)
【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!
|