加入收藏 | 设为首页 | 会员中心 | 我要投稿 威海站长网 (https://www.0631zz.cn/)- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置: 首页 > 站长学院 > Asp教程 > 正文

ASP 变量 寒假作业

发布时间:2022-10-16 18:06:52 所属栏目:Asp教程 来源:互联网
导读: 1// 数据类型 变量名 = 变量值;
2String name = "小红";
3
4

其实还有别的定义方式,例如:String name1,name2,name3 = “小明”;
在定义完变量之后,可以用于输出、计算等行为。
1// 将数

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

这样你就可以不需要记忆那么多的方法名,因为它们都是一样的功能。

(编辑:威海站长网)

【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!