ASP 变量寒假作业

发布时间：2023-02-14 13:18:27 所属栏目：Asp教程来源：

导读：　　// 数据类型变量名 = 变量值;
　　String name = "小红";

　　其实还有别的定义方式，例如：String name1,name2,name3 = “小明”;

　　在定义完变量之后，可以用于输出、计算等行为。

　　// 数据类型变量名 = 变量值;
　　String name = "小红";

　　其实还有别的定义方式，例如：String name1,name2,name3 = “小明”;

　　在定义完变量之后，可以用于输出、计算等行为。

　　// 将数据存储到变量中
　　// 存储姓名
　　String name;
　　name = "野猪佩奇";

　　// 存储年龄
　　int age = 2;

　　// System.out.println(name);
　　// System.out.println(age);

　　// System.out.println("我的名字是：name");
　　// System.out.println("我的年龄是：age");

　　// 拼接
　　// 拼接为什么使用 + 号？
　　// println是在输出一个字符串内容，但是现在我们想输出的内容不仅仅是字符串，还需要加上一个不确定类型的变量。
　　// 其他类型数据(包含字符串类型)如果要和字符串拼接在一起，需要 + 号，拼接完的结果会变为一个整体字符串
　　System.out.println("我的名字是：" + name);
　　System.out.println("我的年龄是：" + age);
　　System.out.println("我的名字是：" + name + "，我的年龄是：" + age);

　　3. 常量

　　在Java中，其值不能改变的变量被称为常量。常量被final修饰，被final修饰则无法二次修改值。

　　π：3.14

　　final：最终

　　// 计算圆的面积   π * r * r
　　// 圆的半径为 2

　　// 定义变量存储半径
　　double r = 2;

　　// 定义变量存储π
　　final double pi = 3.14;
　　// 不小心改动了该值（重新赋值）
　　// pi = 3;

　　// 计算结果并存储到变量
　　double area = pi * r * r;

　　System.out.println("圆的面积为：" + area);

　　常量的命名规范：

　　4. 程序交互

　　Scanner 使用。

　　Scanner 是Java中提供的一个扫描器，它可以帮助我们扫描控制台输入的内容，并将其转换为你想要的类型值。

　　导入Scanner

　　在你想使用Scanner的类中，添加一行导入代码

　　import java.util.Scanner;

　　package demo4;

　　import java.util.Scanner; // 加在类声明和包声明之间

　　public class Demo1 {

　　 public static void main(String[] args) {

　　 }

　　}

　　创建Scanner对象

　　// 创建对象，名字是自定义的，常见名：scan、input
　　Scanner scan = new Scanner(System.in);

　　使用它的API（功能）

　　// 想输入年龄
　　int age = scan.nextInt();
　　// 想输入余额
　　double money = scan.nextDouble();
　　// 想输入姓名
　　String name = scan.next();

　　可以添加一些输出语句来辅助输入。

　　// 想输入年龄
　　System.out.print("请输入您的年龄：");
　　int age = scan.nextInt();
　　// 想输入余额
　　System.out.print("请输入您的余额：");
　　double money = scan.nextDouble();
　　// 想输入姓名
　　System.out.print("请输入您的姓名：");
　　String name = scan.next();

　　常用的运算符检查问题分析

　　命名规范

　　缩进问题

　　缩进是同级对齐，下级缩进

　　// xxx
　　 xxxx
　　    xxxx

　　使用Scanner

　　导入Scanner

　　创建Scanner对象使用

　　next() 可以输入字符串1. nextInt() 可以输入整数1. nextDouble() 可以输入小数

　　package demo1;

　　import java.util.Scanner;

　　public class HelloWorld {
　　    Scanner scan = new Scanner(System.in);
　　
　　    // 请输入您的年龄：18
　　    System.out.print("请输入您的年龄：");
　　    int age = scan.nextInt();
　　    System.out.print("请输入您的姓名：");
　　    String name = scan.next();
　　}

　　注释规范

　　// 创建对象
　　Scanner scan = new Scanner(System.in);
　　input.nextInt();

　　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;

　　字符的秘密

　　// 自动类型转换
　　char alpha = 'a';
　　int num = alpha;
　　System.out.println("num：" + num); // 97

　　// 强制类型转换
　　int num1 = 99;
　　char alpha1 = (char) num1;
　　System.out.println("alpha1：" + alpha1); // c

　　它们的转换遵循了相应的码表，例如：ASCII码表。a是97、A是65…

　　2. 赋值运算符

　　= 号在各种编程语言中，不再表示相等，而是表示赋值。

　　只有极个别的语言，=号又表示赋值，又表示相等。

　　// 读法：将数字10赋值给变量num
　　// 将等号右侧的赋值给等号左侧的
　　int num = 10;

　　// 变量和变量之间的赋值
　　// 将num的值赋值给变量num2
　　int num2 = num;

　　3. 算术运算符

　　+ 加法
　　- 减法
　　* 乘法
　　/ 除法
　　% 取余数
　　++ 自增
　　-- 自减

　　四则运算

　　int num1 = 11;
　　int num2 = 2;
　　System.out.println(num1 / num2); // 5

　　在 Java 中进行数学计算时，有时候会出现与传统数学观念不符的情况，例如： 11 / 2 应该等于 5.5，但结果为 5。

　　是由于 11 和 2 都是整数，那么在计算的时候，对于结果的类型也是采用整数。（在计算的时候，计算结果的类型是由计算的值中取值范围最大的类型）

　　如果真的想得到 5.5，需要如下做：

　　int num1 = 11;
　　int num2 = 2;
　　System.out.println(num1 * 1.0 / num2); // 5.5

　　自增和自减

　　++ 自增1

　　– 自减1

　　int num1 = 10;
　　// ++ num1;
　　// num1 ++;   抽象理解为： num1 = num1 + 1

　　// num1 --;
　　-- num1; // 抽象理解为：num1 = num1 - 1
　　// System.out.println(num1); // 11
　　System.out.println(num1); // 9

　　当 ++ 和 – 在单独使用时，效果上没有任何区别。

　　但是当 ++ 和 – 在被使用或参与计算时，效果上有不同。

　　int num1 = 10;

　　// int num2 = num1 ++ - 2;

　　// System.out.println(num1 ++); // 10
　　// System.out.println(num1); // 11

　　System.out.println(++ num1); // 11
　　System.out.println(num1); // 11

　　字符的秘密
　　字符是可以和数值转换的。
　　char alpha1 = 'a';
　　alpha1 ++; // 理解为：alpha1 = alpha1 + 1
　　System.out.println(alpha1); // b
　　char alpha2 = 'b';
　　// 在计算时，结果的类型是取值范围大的类型
　　System.out.println(alpha2 + 1); // 99

　　4. 复合赋值运算符

　　int num1 = 10;
　　num1 += 2; // 理解为： num1 = num1 + 2
　　System.out.println(num1); // 12

　　int num2 = 12;
　　num2 -= 3; // 理解为：num2 = num2 - 3
　　System.out.println(num2); // 9

　　以后可以利用 += 和 -= 做累加运算。

　　例如：求1到10的和。

　　int num = 1;

　　num += 2; // num = num1 + 2

　　num += 3; //

　　num += 4;

　　…

　　5. 关系运算符

　　比较运算符，可以用来做判断，比较运算符的计算结果是布尔类型值。

　　true（真）和 false（假）

　　=号代表赋值，==才代表相等。

　　6. 逻辑运算符

　　// System.out.println(!true);
　　// System.out.println(!false);

　　double javaScore = 59;
　　// 判断是否>=60
　　System.out.println(javaScore >= 60);
　　// 判断是否<60
　　System.out.println(javaScore < 60);
　　System.out.println(!(javaScore >= 60));

　　短路

　　// 将数字7赋值给变量num1
　　int num1 = 7;
　　// 右边在做逻辑运算
　　// false && true
　　boolean flag2 = false && (++ num1 == 8);
　　System.out.println(flag2); // false
　　System.out.println(num1); // 7

　　短路与和短路或，代表的是如果前面的条件能够得到最终结果，那么后面的条件就不再进行了！

　　还有一个 & 和 | 也可以表示逻辑关系，但是一般不用，因为它们无论是否能从前面条件得到最终结果，都要对所有条件进行计算。

　　所以 && 和 || 可以优化程序执行性能。

　　7. 三元运算符

　　Scanner scan = new Scanner(System.in);

　　System.out.print("请输入您的年龄：");
　　int age = scan.nextInt();

　　String result = (age >= 18) ? "快来玩啊！" : "小屁孩给爷爪巴！";
　　System.out.println(result);

　　选择结构检查问题分析

　　类名采用了小驼峰（目前只有一个）

　　包名采用了大写（目前只有一个）

　　运算符左右没留空格（目前很多）

　　int num = 10;

　　System.out.println("我的年龄是：" + num);

　　注释的//和注释内容之间没有留空格（目前2 - 3人）

　　// 这是注释

　　变量乱起名（目前两人）

　　交作业的时间非要卡在 DieLine

　　代码中一行注释也没有

　　代码要包含40%以上的注释

　　流程控制语句

　　任何一个语言编写出来的程序都包含这三种控制语句，因为它们可以让你的程序变得“丰富多彩”。

　　顺序控制语句

　　// 顺序流程语句
　　// 自上而下
　　System.out.println("我是语句1");
　　System.out.println("我是语句2");
　　System.out.println("我是语句3");

　　选择控制语句

　　根据条件表达式，决定一部分代码是否可以正常执行。

　　条件表达式就是利用关系运算符和逻辑运算符来实现判断的过程，结果永远为布尔类型：true（真、成立）、false（假、不成立）。

　　循环控制语句

　　可以帮助我们解决重复性的工作问题。

　　三种流程控制语句是要结合使用，每种都有它能解决的问题。

　　流程图绘制

　　UML

　　if系列选择结构基础if

　　if：如果

　　if (条件表达式) {
　　    // 条件成立时执行的代码段
　　}

　　Scanner scan = new Scanner(System.in);
　　
　　System.out.print("请输入您的年龄：");
　　int age = scan.nextInt();

　　// 判断
　　// 如果你的年龄是大于等于18的
　　if (age >= 18) {
　　    // 那么就提示你可以进入网吧了
　　    System.out.println("可以进入网吧啦！");
　　}
　　复杂条件的情况，因为业务需要，经常要结合逻辑运算符来实现条件表达式。
　　Scanner input = new Scanner(System.in);
　　System.out.print("请输入乔治的Java成绩：");
　　double javaScore = input.nextDouble();
　　System.out.print("请输入乔治的音乐成绩：");
　　double musicScore = input.nextDouble();

　　if ((javaScore > 90 && musicScore > 80) ||
　　    (javaScore == 100 && musicScore > 70)) {
　　    System.out.println("查老师会奖励他一顿棒子'炖'肉！");
　　}

　　可读性非常高，边读边写都可以。

　　互斥if

　　if (条件) {
　　    // 条件成立时执行的
　　} else {
　　    // 条件不成立时执行的
　　}
　　如果用基础if来实现一些互斥效果内容，效果如下：
　　Scanner input = new Scanner(System.in);
　　System.out.print("请输入乔治的Java成绩：");
　　double javaScore = input.nextDouble();
　　System.out.print("请输入乔治的音乐成绩：");
　　double musicScore = input.nextDouble();

　　if ((javaScore > 90 && musicScore > 80) ||
　　    (javaScore == 100 && musicScore > 70)) {
　　    System.out.println("查老师会奖励他一顿棒子'炖'肉！");
　　}

　　if (!((javaScore > 90 && musicScore > 80) ||
　　      (javaScore == 100 && musicScore > 70))) {
　　    System.out.println("查老师会奖励他给查老师买一个 iPhone 11！");
　　}

　　Scanner input = new Scanner(System.in);
　　System.out.print("请输入您的年龄：");
　　int age = input.nextInt();

　　// 判断
　　if (age >= 18) {
　　    System.out.println("网管：可以进来啦！");
　　}

　　if (age < 18) {
　　    System.out.println("网管：滚");
　　}

　　互斥if写法：

　　Scanner input = new Scanner(System.in);

　　System.out.print("请输入您的年龄：");
　　int age = input.nextInt();

　　// 判断
　　if (age >= 18) {
　　    System.out.println("网管：可以进来啦！");
　　} else {
　　    System.out.println("网管：滚");
　　}

　　多重if

　　多分支的判断，按照自上而下的执行判断，只要有一个满足就不再向后执行其他的条件判断。

　　if (条件1) {
　　    // 条件1成立时执行的代码段
　　} else if (条件2) {
　　 // 条件2成立时执行的代码段
　　} else if (..略..) {
　　    // ...略...
　　} else {
　　    // 上方条件都不满足时执行的代码段
　　}

　　// 选择：基础if
　　Scanner input = new Scanner(System.in);

　　System.out.print("请输入佩奇的Java成绩：");
　　double score = input.nextDouble();

　　// 判断
　　if (score >= 80) {
　　    System.out.println("奖励她一部 OnePlus 8 Pro");
　　}

　　// 60 <= score < 80
　　if (score >= 60 && score < 80) {
　　    System.out.println("奖励她一部一加云耳");
　　}

　　if (score < 60){
　　    System.out.println("奖励她给查老师买一部 iPhone 11 Pro");
　　}

　　// 选择：基础if
　　Scanner input = new Scanner(System.in);

　　System.out.print("请输入佩奇的Java成绩：");
　　double score = input.nextDouble();

　　// 判断
　　if (score >= 80) {
　　    System.out.println("奖励她一部 OnePlus 8 Pro");
　　} else if (score >= 60) {
　　    System.out.println("奖励她一部一加云耳");
　　} else {
　　    System.out.println("奖励她给查老师买一部 iPhone 11 Pro");
　　}

　　多重if在编写条件判断时，注意不要胡乱放置条件，越容易满足或者范围越大的条件应该尽可能放下面。

　　在做范围型多条件判断时，多重if拥有非常好的优势。

　　嵌套if

　　它不是什么特别技术，就是前面的几个if的延伸而已。

　　// 外部条件不成立，内部条件是不会执行的
　　if (外部条件) {
　　    if (内部条件) {
　　
　　    }
　　}

　　Scanner input = new Scanner(System.in);

　　System.out.print("请输入您百米赛跑的成绩：");
　　double score = input.nextDouble();

　　// 判断是否能进入决赛
　　if (score <= 10) {
　　    System.out.println("恭喜您进入决赛！");

　　    // 根据性别分组
　　    System.out.print("请输入您的性别：");
　　    String gender = input.next();
　　    // equals：等于、相等
　　    // 字符串.equals(字符串) 可以用来判断两个字符串内容是否相同
　　    if (gender.equals("男")) {
　　        System.out.println("男子组欢迎你！");
　　    } else {
　　        System.out.println("女子组欢迎你！");
　　    }

　　} else {
　　    System.out.println("很遗憾！下次继续！");
　　}

　　由于嵌套if会导致结构愈加混乱，所以使用时注意层级不要嵌套太多。否则容易出现你写的代码，你看不懂这类问题。

　　而且一般嵌套两层或三层，如果再多一般要考虑其他解决方案。

　　switch选择结构

　　多重if在做范围型的多条件判断比较有优势，而做等值判断并没有太优异的表现。

　　Scanner input = new Scanner(System.in);

　　System.out.print("请输入小杨的最终名次：");
　　int level = input.nextInt();

　　// 使用多重if判断
　　if (level == 1) {
　　    System.out.println("诛仙女猪脚！");
　　} else if (level == 2) {
　　    System.out.println("斗罗大陆女猪脚！");
　　} else if (level == 3) {
　　    System.out.println("永夜女猪脚！");
　　} else {
　　    System.out.println("还想演戏？先拜拜自己吧！");
　　}

　　而switch选择结构则恰恰弥补了此问题。

　　// switch：切换
　　// case：情况、场景
　　// break：中断
　　// default：缺省的，默认的
　　switch (表达式) {
　　    case 常量值:
　　        // 代码段
　　        break;
　　    case 常量值:
　　        // 代码段
　　        break;
　　    ....
　　    default:
　　        // 默认处理
　　        break;
　　}

　　Scanner input = new Scanner(System.in);
　　Sstem.out.print("请输入小杨的最终名次：");
　　int level = input.nextInt();
　　switch (level) {
　　    case 1: // level == 1
　　        System.out.println("诛仙女猪脚！");
　　        break;
　　    case 2: // level == 2
　　        System.out.println("斗罗大陆女猪脚！");
　　        break;
　　    case 3: // level == 3
　　        System.out.println("永夜女猪脚！");
　　        break;
　　    default: // level == 4
　　        System.out.println("还想演戏？先拜拜自己吧！");
　　        break;
　　}

　　注意事项

　　switch中表达式只能使用 int（byte、short、char）、String（JDK1.7起支持）、枚举类型

　　Scanner input = new Scanner(System.in);

　　System.out.print("小度小度，今天星期几？");
　　int dayOfWeek = input.nextInt();

　　switch (dayOfWeek) {
　　    case 1:
　　    case 2:
　　    case 3:
　　    case 4:
　　    case 5:
　　        System.out.println("好好工作");
　　        break;
　　    case 6:
　　    case 7:
　　        System.out.println("好好休息！");
　　        break;
　　}

　　和if的区别随机数的获取

　　Math.random() 可以获取到[0.0, 1.0)之间的随机小数。（>=0.0 并且 < 1.0）

　　// [0.0, 1.0)
　　// double num = Math.random();
　　// System.out.println(num);

　　// [5, 10) 随机整数
　　// 【公式】(int)(Math.random() * (最大值 - 最小值) ) + 最小值
　　// [0.0, 1.0) -> [0.0, 5.0) -> [0, 5) -> [5, 10)
　　int num = (int)(Math.random() * 5) + 5;
　　System.out.println(num);

　　循环结构1. 检查问题分析

　　代码不规范

　　代码是给人看的，不是给机器看的。遵守良好的代码规范，让你在未来就业时，不至于因为代码规范问题而被"指点"。

　　在公司内，需求理解错误，意味着你的辛苦，你的劳累都是无用的。你是在犯错而不是完成自己的工作。

　　看到需求，先读，先去思考过程（程序是一系列指令的集合，是为了完成某件事情的步骤、次序）

　　很长时间内，一直会出现。

　　如果你发现当前你写代码总是写出僵化的代码，例如：老师讲了一种案例，然后只能实现相差无几的案例，稍微复杂一点就完蛋。想不出来，或者写一大堆才能完成。

　　塌下来心来，承认自己当前的不足，而不是过于攀比。学习老师的思路，借鉴同学的思路，甚至将这种思路用的更好。（商业战争中，此类情况不胜枚举。你看看腾讯）

　　一般情况下，这种同学不一定比思路敏捷的同学混的差。

　　多做题，学多一种解决方法，这样你不也算会了吗？

　　2. 什么是循环？2.1 生活

　　我们上班、上学、甚至是一些回复都是循环的过程。

　　循环：反复地连续做某事。

　　周而复始，有规律性，重复的内容。

　　2.2 程序

　　public class Demo1 {

　　 public static void main(String[] args) {
　　 System.out.println("好好学习，天天向上，上学期间，不搞对象，关起门来都是一家人，搞对象那是乱伦。");
　　 System.out.println("好好学习，天天向上，上学期间，不搞对象，关起门来都是一家人，搞对象那是乱伦。");
　　 System.out.println("好好学习，天天向上，上学期间，不搞对象，关起门来都是一家人，搞对象那是乱伦。");
　　 System.out.println("好好学习，天天向上，上学期间，不搞对象，关起门来都是一家人，搞对象那是乱伦。");
　　 System.out.println("好好学习，天天向上，上学期间，不搞对象，关起门来都是一家人，搞对象那是乱伦。");
　　 System.out.println("好好学习，天天向上，上学期间，不搞对象，关起门来都是一家人，搞对象那是乱伦。");
　　 System.out.println("好好学习，天天向上，上学期间，不搞对象，关起门来都是一家人，搞对象那是乱伦。");
　　 System.out.println("好好学习，天天向上，上学期间，不搞对象，关起门来都是一家人，搞对象那是乱伦。");
　　 System.out.println("好好学习，天天向上，上学期间，不搞对象，关起门来都是一家人，搞对象那是乱伦。");
　　 System.out.println("好好学习，天天向上，上学期间，不搞对象，关起门来都是一家人，搞对象那是乱伦。");
　　 System.out.println("好好学习，天天向上，上学期间，不搞对象，关起门来都是一家人，搞对象那是乱伦。");
　　 System.out.println("好好学习，天天向上，上学期间，不搞对象，关起门来都是一家人，搞对象那是乱伦。");
　　 }

　　}

　　3. while循环

　　while：当、在…期间、在…时候、直到…

　　很多语言中，见到while想到的就是循环。

　　while (循环条件) {
　　    循环体/循环操作
　　}
　　---
　　if (条件表达式) {
　　    条件成立时执行的内容
　　}

　　// 使用循环来实现输出内容10次
　　/*
　　 * 思路分析：
　　 *   1.根据需求可知需要采用 while 循环
　　 *   2.分析循环的要素
　　 *       (什么时候可以执行循环操作)循环条件：输出的次数 <= 10
　　 *       (要循环执行什么内容)循环操作：输出内容
　　 *   3.套入 while 语法
　　 *    1.初始化循环变量
　　 *      2.循环条件
　　 *      3.循环操作
　　 *      4.循环出口(更新循环变量)
　　 *   4.检查循环是否能正常结束
　　 */

　　// 1.初始化循环变量
　　int i = 1;

　　// 2.循环条件
　　while (i <= 1000) {
　　    // 3.循环操作
　　    System.out.println("第" + i + "遍：好好学习，天天向上");
　　    // 4.循环出口(更新循环变量)
　　    // i ++; // i = i + 1
　　    i += 1;
　　}
　　// 打印50份试卷
　　/*
　　 * 思路分析：
　　 *   1.要采用循环
　　 *   2.分析循环的要素
　　 *    循环条件： <= 50
　　 *    循环操作：打印每份试卷
　　 *   3.套入 while 语法
　　 *   4.检查循环是否能够正常结束
　　 */
　　// 1.初始化循环变量
　　int i = 1;

　　// 2.循环条件
　　while (i <= 50) {
　　 // 3.循环操作
　　 System.out.println("正在打印第" + i + "份试卷");
　　 // 4.循环出口(更新循环变量)
　　 i ++;
　　}

　　4. do-while循环

　　do：做…事

　　do {
　　    循环体/循环操作
　　} while (循环条件);

　　do-while 循环至少会执行一次循环操作。

　　/*
　　 * 思路分析：
　　 * 1.应该采用循环
　　 * 2.分析循环的要素
　　 * 循环条件：检测不合格
　　 * 循环操作：进行理论学习，进行上机编程
　　 * 3.套用do-while语法
　　 * 1.初始化循环变量
　　 * 2.循环操作
　　 * 3.循环出口
　　 * 4.循环条件
　　 * 4.检查是否能正常结束循环
　　 */

　　// 1.初始化循环变量
　　String result;

　　Scanner input = new Scanner(System.in);
　　do {
　　 // 2.循环操作
　　 System.out.println("进行理论学习！");
　　 System.out.println("进行上机编程！");
　　
　　 // 3.循环出口(更新循环变量)
　　 System.out.print("老师检测是否合格(y/n)：");
　　 result = input.next();
　　} while ("n".equals(result)); // 4.循环条件

　　System.out.println("考核通过！");

　　我们前期用的比较多，因为它的执行思路和生活中业务大多类似。

　　5. for循环

　　for 循环非常简洁，它的结构与 while 和 do-while不同，它是直接将循环4要素都安排好了位置，可以避免遗失出口等问题。

　　for 循环只能用于固定次数的循环场景。

　　在后期，用的非常多！基于它还有一个变种：增强for循环（foreach）

　　for (1.初始化循环变量; 2.循环条件; 3.循环出口) {
　　    4.循环操作
　　}

　　语法中 ; 号是必须的。

　　// 使用for循环改造打印50份试卷
　　public class Demo1 {

　　 public static void main(String[] args) {
　　 // for循环只能用于固定次数的循环场景
　　 // 循环条件：<= 50
　　 // 循环操作：打印每份试卷
　　 for (int i = 1; i <= 50; i++) {
　　 System.out.println("正在打印第" + i + "份试卷！");
　　 }
　　 }
　　}

　　6. 三者区别

　　执行次序的区别：

　　应用场景：

　　多重循环1. 死循环

　　死循环：循环语句无法正常停止的情况，就被称为死循环。一般都是缺失了循环的出口或者循环条件存在问题。

　　按理说，死循环并不是一件好事，但是 “功法没有正邪之分，有正邪之分的是使用的人。” 如果被你使用正确，它可以解决很多问题。

　　适用的场景：当你不确定，或是确定循环条件及出口时较为困难/麻烦时，可以采用死循环。

　　while (true) {
　　
　　}

　　do {
　　
　　} while (true);

　　for (;;) {
　　
　　}

　　但无论是死循环也好，还是正常循环，都应该保证有相应出口。我们可以通过循环中的跳转语句，来实现循环流程的控制。

　　break

　　break：中断

　　break 在 switch 选择结构中出现过，它当时的意思是结束某个分支。

　　在循环中，它表示结束当前所在循环，一般还要配合选择结构使用。

　　continue

　　continue：继续

　　只能在循环中使用，它表示结束当前所在循环的本次循环（本次循环中，continue后的所有内容不再执行），跳转到下一次循环开始。

　　2. 多重循环概述

　　需求：实现下方图形的打印，通过一颗*一颗*的方式来打印。

　　*****
　　*****
　　*****
　　*****
　　*****

　　*
　　***
　　*****
　　*******
　　*********
　　    *
　　   ***
　　 *****
　　 *******
　　*********
　　 *****
　　 *****
　　*****

　　单层循环无法实现稍微复杂些的需求，所以我们需要使用多重循环（嵌套循环），它是一种类似于嵌套 if 的存在。

　　while (外层循环条件) {
　　    while (内层循环条件) {
　　
　　    }
　　}

　　do {
　　    for (内层循环条件) {
　　
　　    }
　　    for (内层循环条件) {
　　
　　    }
　　} while (外层循环条件);

　　不同的循环结构之间可以相互嵌套，嵌套多少层、多少个都可以。

　　但是一般嵌套的层数不要超过3层，因为层数过多，循环结构过于复杂，因小失大。

　　一般的嵌套都是两层居多，所以多重循环又被称为二重循环/双重循环。

　　产生循环嵌套之后，会分为外层循环和内层循环，内层循环此时其实就是外层循环的循环操作。

　　外层循环执行一次，内层循环执行一遍！

　　3. 案例实现3.1 打印矩形图形

　　for (int i = 1; i <= 5; i++) {
　　    for (int j = 1; j <= 5; j++) {
　　        System.out.print("*");
　　    }
　　    System.out.println();
　　}

　　3.2 打印三角形

　　打印直角三角形：

　　*
　　***
　　*****
　　*******
　　*********
　　for (int i = 1; i <= 5; i++) {
　　    for (int j = 1; j <= 2 * i - 1; j++) {
　　        System.out.print("*");
　　    }
　　    System.out.println();
　　}

　　打印等腰三角形：

　　    *
　　   ***
　　 *****
　　 *******
　　*********

　　3.3 打印平行四边形

　　for (int i = 1; i <= 3; i++) {
　　    for (int k = 1; k <= 3 - i; k++) {
　　        System.out.print(" ");
　　    }
　　    for (int j = 1; j <= 5; j++) {
　　        System.out.print("*");
　　    }
　　    System.out.println();
　　}

　　3.4 打印九九乘法表

　　1*1=1
　　1*2=2 2*2=4
　　1*3=3 2*3=6 3*3=9
　　....
　　1*9=9 2*9=18 3*9=27 ....

　　for (int i = 1; i <= 9; i++) {
　　    for (int j = 1; j <= i; j++) {
　　        System.out.print(j + "*" + i + "=" + (j * i) + "\t");
　　    }
　　    System.out.println();
　　}

　　4. 作业

　　现在默写：类名的规范、变量名的规范、常量名的规范、注释的规范、缩进的规范。

　　作业见文档。

　　一维数组

　　变量是一种单个值的存储方式，这种存储方式无法满足日益增多的数据需求。所以我们需要找寻一种可以同时存储多个数据的存储方式。

　　数组可以解决此类问题。

　　1. 什么是数组？

　　数组，顾名思义就是：数据的组合。它是在内存空间中开辟一连串的存储空间，可以存储多个具有相同数据类型的数据。

　　而且数组相比于变量来讲，拥有更多的"可玩性"。

　　2. 数组的组成

　　类比变量来记忆。

　　变量的组成：

　　数据类型变量名变量值

　　数组的组成：

　　数组的数据类型：数组存储的是一组相同数据类型的数据，需要做好指定。

　　数组名：使用数组时，也需要通过名字来使用

　　元素：数组中存储的每一个值，我们称之为元素

　　容量：长度，一个数组可以存储多少个元素（一经定义，不可变）

　　下标：索引，数组中每一个存储空间的 “序号”，从0开始计算

　　每一个下标空间，都有默认值。

　　根据数据类型不同，它的默认值分别为：

　　数组是存储一组具有相同数据类型数据的定长空间。

　　3. 数组定义

　　变量的定义：

　　数据类型变量名 = 变量值;

　　数组的定义1：

　　// 先声明数组
　　数据类型[] 数组名 = new 数据类型[容量];
　　// 数组赋值（存入值，修改值）
　　数组名[下标] = 元素值;
　　// 数组使用
　　数组名[下标]

　　数组的定义2：

　　// 声明时赋值
　　数据类型[] 数组名 = {元素1, 元素2, 元素3, ...};

　　// 声明时赋值
　　// 后期有时候只能使用这种方式
　　数据类型[] 数组名 = new 数据类型[] {元素1, 元素2, 元素3, ...};

　　数组的定义1，结合循环优化：（动态赋值）

　　// 先声明数组
　　数据类型[] 数组名 = new 数据类型[容量];

　　// 使用循环动态赋值
　　for (int i = 0; i < 数组的容量; i++) {
　　    数组名[i] = 输入值;
　　}

　　4. 数组的使用4.1 计算最高分多维数组1. Why？

　　如果要求计算一个班的5名同学的成绩和，可以使用一维数组 + 普通循环解决。

　　而如果是计算三个班的各5名同学的成绩和，一维数组和普通循环实现起来不够好，所以我们才需要学习更高级的概念：多维数组。

　　2. 概念

　　多维数组，可以理解为嵌套数组。

　　二维数组：是以一维数组作为数组元素的数组，即 “数组的数组”。

　　多维数组的常见表现形式是二维数组、三维数组，但一般以二维数组居多。

　　多维数组在Java中，语法是存在的，但内存角度来看的话，只有一维数组。

　　3. 定义方式一

　　// 数据类型[] 数组名 = new 数据类型[容量/长度];
　　// 存储一个班5名同学的成绩
　　// 成绩的数据类型：double
　　//      数组的容量：5
　　double[] scores = new double[5];

　　scores[0] = 90;
　　scores[1] = 80;
　　scores[2] = 70;
　　scores[3] = 60;
　　scores[4] = 50;

　　// 数据类型[][] 数组名 = new 数据类型[外维数组的容量][内维数组的容量];
　　// 存储三个班各5名同学的成绩
　　//      外维数组：存储的是3个班的成绩
　　//      内维数组：每个班的5名同学成绩
　　// 外维数组的数据类型：double[]
　　//      内维数组的数据类型：double
　　double[][] scores = new double[3][5];

　　// 存储第一个班成绩
　　scores[0][0] = 90; // 第一个班的第一个学生
　　scores[0][1] = 80;
　　scores[0][2] = 80;
　　scores[0][3] = 80;
　　scores[0][4] = 80;
　　// 存储第二个班成绩
　　scores[1][0] = 80;
　　scores[1][1] = 80;
　　scores[1][2] = 80;
　　scores[1][3] = 80;
　　scores[1][4] = 80;
　　// 存储第三个班成绩
　　scores[2][0] = 80;
　　scores[2][1] = 80;
　　scores[2][2] = 80;
　　scores[2][3] = 80;
　　scores[2][4] = 80;

　　数组也是一种数据类型，但是它不是普通的数据类型（int、double），数组存储的是一组相同数据类型的数据。 int[]、double[]。

　　二维数组：int[][]

　　三维数组：int[][][]

　　方式二

　　直接赋值

　　// 存储1个班5名同学成绩
　　double[] scores = {90, 80, 70, 60, 50};
　　double[] scores = new double[] {90, 80, 70, 60, 50};

　　// 存储3个班的各2名同学成绩
　　// 把{}看做是一个一维数组
　　double[][] scores = {{90, 80}, {80, 80}, {70, 70}};
　　double[][] scores = new double[][] {{90, 80}, {80, 80}, {70, 70}};

　　动态赋值

　　// 定义二维数组，用来存储3个班的各5名同学成绩
　　double[][] scores = new double[3][5];

　　Scanner input = new Scanner(System.in);
　　// 动态录入
　　// 循环外维数组
　　for (int i = 0; i < scores.length; i++) {
　　    System.out.println("开始录入第" + (i+1) +"班的成绩：");
　　    // 循环内维数组
　　    for (int j = 0; j < scores[i].length; j++) {
　　        System.out.print((i+1) + "班的第" + (j+1) + "个学生的成绩是：");
　　        scores[i][j] = input.nextDouble();
　　    }
　　}

　　System.out.println("第1个班的第2名同学成绩：" + scores[0][1]);

　　方式三

　　二维数组，定义时其实只需要指定好一维数组的容量即可。

　　// 存储3个班的成绩，1班3人，2班2人，3班3人
　　double[][] scores = new double[3][];
　　scores[0] = new double[3];
　　scores[1] = new double[2];
　　scores[2] = new double[3];

　　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 程序就是要编写一个到多个的类。

　　// 类声明
　　[访问权限修饰符] class 类名 {
　　    // 类体
　　    // 【属性】/成员变量/实例变量/Field
　　    [访问权限修饰符] 数据类型属性名;
　　    // ...
　　
　　    // 行为/成员【方法】/实例方法/Method
　　    [访问权限修饰符] [其他修饰符] 返回值类型方法名(形式参数列表) {
　　        // 方法体
　　    }
　　    // ...
　　}

　　上述语法就是 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 对象概念

　　对象是类的具体实例，也是在使用时的主体。（面向对象）

　　// 对象名的规范和变量名一致
　　类名对象名 = new 类名(参数值);

　　// 属性赋值
　　// 描述对象的属性
　　对象名.属性名 = 属性值;

　　// 调用方法
　　// 描述对象的行为
　　对象名.方法名(参数值);

　　方法和方法重载

　　完全不用担心学不会！以后天天用！

　　1. 方法概述

　　在面向过程出现的时候，方法就出现了。在程序中要存储数据，会采用变量来存储，以方便我们复用。而方法的出现使为了存储程序中的功能代码，以方便我们复用。

　　例如：为了方便我们反复使用键盘录入功能，Scanner 类提供了一个 nextXX()，每次使用键盘录入直接调用该方法即可。

　　2. 方法的语法和分类语法

　　// 方法声明
　　[访问权限修饰符] [其他修饰符] 返回值类型方法名([方法的参数列表]) {
　　    // 方法体
　　    // 功能代码....
　　    [return 返回值;]
　　}

　　**访问权限修饰符：**目前先认识一个 publicASP 变量，代表公共的，意味着在项目中可以被使用。

　　**其他修饰符：**目前先认识一个 static ，代表静态的，后面专门讲。

　　**返回值类型：**一个方法，一个功能在执行完之后返回的数据的类型。例如：nextInt() : int，因为你要获取到输入的数据，所以必须定义返回值，因为要得到的返回数据是整数所以返回值类型是int。

　　**方法名：**为了方便下次再使用，要起名。命名规范与变量名一致。

　　方法参数列表：一个方法内部要执行的功能，有些时候是要进行某些数据处理，但是要处理的数据必须由你来提供给它，所以它需要提前规范好需要什么数据。例如：Arrays.toString(数组) : String

　　**return：**结束方法，并将返回结果返回到调用者位置。调用者可以将结果存储为变量或者直接输出等方式来使用。

　　把方法理解为榨汁机。

　　分类

　　以后学其他语言也基本是这4个分类。其他语言中可能叫函数、方法。

　　你们前期最害怕的事：就是不知道什么时候定义什么类型方法。建议多观察 Java 中的方法。

　　按照语法中是否有参数、是否有返回值来进行分类。

　　无参无返（没有参数、没有返回值）

　　一般这种方法，用于实现一些简单内容的输出或执行。

　　// 没有返回值，返回值类型需要定义为 void，代表空。
　　public void run() {
　　 System.out.printf("%s今年%d岁，身高%.1fcm，正在跑步！\n", name, age, height);
　　}

　　使用过的该类型方法：

　　public void println() {
　　    newLine();
　　}
　　一般这种方法，用于实现一些需要根据条件或者一些基础数据，才能实现输出或执行的场景。

　　// Arrays工具类中的方法，可以实现对传入的数组的元素进行升序排序
　　public static void sort(int[] a) {
　　
　　}

　　使用过的该类型方法：

　　public void println(int x) {
　　    synchronized (this) {
　　        print(x);
　　        newLine();
　　    }
　　}

　　* Arrays.sort(数组);

　　* …

　　一般这种方法，适合于一些功能执行完可以返回一个结果的情况。因为没有参数，往往这类方法缺少灵活性、扩展性。

　　// Math.random() 生成[0.0, 1.0)
　　public static double random() {
　　   return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
　　}

　　使用过的该类型方法：

　　有参有返（有参数有返回值）

　　前期这种我们用的少，因为我们使用时一般都是用作于输出。后期用的越来越多，因为后期功能要求复杂。

　　// Arrays.toString() 将数组转换为字符串
　　public static String toString(int[] a) {
　　     return xxx;
　　}

　　使用过的该类型方法：

　　3. 构造方法概述

　　构造方法，顾名思义就是 Java 中用于对象创建/实例创建的方法。

　　每个类都有一个默认的构造方法：无参构造方法，你不写也会有。

　　如果你写了任意一个构造方法，默认的无参构造将不再提供。（建议每个类都自己写个无参，以防止未来定义有参构造之后，无参没有了）

　　语法

　　[访问权限修饰符] 方法名([方法参数列表]) {
　　
　　}

　　构造方法只有有参和无参两种，因为构造方法的作用就是为了创建该类型的对象，那也就没有必要写上返回值类型了。

　　构造方法的方法名必须和类名一致，意味着 Student 类的构造方法就是 Student()。

　　带参构造的用处

　　使用带参构造方法可以用于属性快速赋值。

　　public class Student {

　　 public String name;
　　 public int age;
　　 public String classId;
　　
　　 // 无参构造方法
　　 public Student() {
　　 System.out.println("呵呵呵？");
　　 }
　　
　　 // 带/有参构造方法
　　 // 方法参数列表中的名字无所谓，随便写，主要重点在于类型
　　 // 因为外界关注的是这个方法需要什么类型的参数，而不是参数名
　　 public Student(String stuName, int stuAge, String stuClassId) {
　　 name = stuName;
　　 age = stuAge;
　　 classId = stuClassId;
　　 }
　　
　　}

　　// 使用传统方式来创建对象并赋值
　　Student student = new Student();
　　student.name = "小明";
　　student.age = 18;
　　student.classId = "353";

　　// 通过带参构造方法来创建对象并赋值
　　Student student2 = new Student("小红", 17, "349");

　　4. this关键字

　　在局部变量和成员变量出现重名时，局部变量优先级更高（优先使用局部变量）。

　　就近原则。

　　如果真重名了，可以使用 this 关键字区分。

　　this 关键字：单词含义：这个。

　　public class Student{
　　    public String name;
　　    public Student(String name) {
　　        // 此刻 this 代表的就是xiaoMing对象
　　        this.name = name;
　　    }
　　
　　    public void printInfo() {
　　        // 此刻 this 代表的就是xiaoMing对象
　　        Sout("我的名字叫；" + this.name);
　　    }
　　}

　　main() {
　　    Student xiaoMing = new Student("小明");
　　    xiaoMing.printInfo();
　　
　　    Student xiaoHong = new Student("小红");
　　}

　　可以使用 this 在当前类中，调用对象能调用的东西。

　　如果短期内没能理解，先掌握它什么时候使用。例如：在构造方法中用于区分成员变量和局部变量。

　　5. 成员变量和局部变量区别

　　变量作用域：与其直接所属的 {} 有关。

　　生命周期不同：（生老病死，什么时候诞生，什么时候销毁）

　　6. 方法重载现象

　　方法重载（Overload）：在一个类中出现的方法名相同，参数列表不同的情况就被称为方法重载。与返回值类型、访问权限修饰符等无关！！！（例如：nextInt()）

　　如果没有方法重载的支持，多个方法的方法名相同显然是不可能的。

　　例如：下方的四行输出语句，其实调用的不是一个方法，而是四个方法。

　　// println(String x) : void
　　System.out.println("xxx");
　　// println(int x) : void
　　System.out.println(111);
　　// println(double x) : void
　　System.out.println(12.5);
　　// println(char x) : void
　　System.out.println('x');

　　xtInt() : int

　　1`

　　有参有返（有参数有返回值）

　　前期这种我们用的少，因为我们使用时一般都是用作于输出。后期用的越来越多，因为后期功能要求复杂。

　　// Arrays.toString() 将数组转换为字符串
　　public static String toString(int[] a) {
　　     return xxx;
　　}

　　使用过的该类型方法：

　　3. 构造方法概述

　　构造方法，顾名思义就是 Java 中用于对象创建/实例创建的方法。

　　每个类都有一个默认的构造方法：无参构造方法，你不写也会有。

　　如果你写了任意一个构造方法，默认的无参构造将不再提供。（建议每个类都自己写个无参，以防止未来定义有参构造之后，无参没有了）

　　语法

　　[访问权限修饰符] 方法名([方法参数列表]) {
　　
　　}

　　构造方法只有有参和无参两种，因为构造方法的作用就是为了创建该类型的对象，那也就没有必要写上返回值类型了。

　　构造方法的方法名必须和类名一致，意味着 Student 类的构造方法就是 Student()。

　　带参构造的用处

　　使用带参构造方法可以用于属性快速赋值。

　　public class Student {

　　 public String name;
　　 public int age;
　　 public String classId;
　　
　　 // 无参构造方法
　　 public Student() {
　　 System.out.println("呵呵呵？");
　　 }
　　
　　 // 带/有参构造方法
　　 // 方法参数列表中的名字无所谓，随便写，主要重点在于类型
　　 // 因为外界关注的是这个方法需要什么类型的参数，而不是参数名
　　 public Student(String stuName, int stuAge, String stuClassId) {
　　 name = stuName;
　　 age = stuAge;
　　 classId = stuClassId;
　　 }
　　
　　}

　　// 使用传统方式来创建对象并赋值
　　Student student = new Student();
　　student.name = "小明";
　　student.age = 18;
　　student.classId = "353";

　　// 通过带参构造方法来创建对象并赋值
　　Student student2 = new Student("小红", 17, "349");

　　4. this关键字

　　在局部变量和成员变量出现重名时，局部变量优先级更高（优先使用局部变量）。

　　就近原则。

　　如果真重名了，可以使用 this 关键字区分。

　　this 关键字：单词含义：这个。

　　public class Student{
　　    public String name;
　　    public Student(String name) {
　　        // 此刻 this 代表的就是xiaoMing对象
　　        this.name = name;
　　    }
　　
　　    public void printInfo() {
　　        // 此刻 this 代表的就是xiaoMing对象
　　        Sout("我的名字叫；" + this.name);
　　    }
　　}

　　main() {
　　    Student xiaoMing = new Student("小明");
　　    xiaoMing.printInfo();
　　
　　    Student xiaoHong = new Student("小红");
　　}

　　可以使用 this 在当前类中，调用对象能调用的东西。

　　如果短期内没能理解，先掌握它什么时候使用。例如：在构造方法中用于区分成员变量和局部变量。

　　5. 成员变量和局部变量区别

　　变量作用域：与其直接所属的 {} 有关。

　　生命周期不同：（生老病死，什么时候诞生，什么时候销毁）

　　6. 方法重载现象

　　方法重载（Overload）：在一个类中出现的方法名相同，参数列表不同的情况就被称为方法重载。与返回值类型、访问权限修饰符等无关！！！（例如：nextInt()）

　　如果没有方法重载的支持，多个方法的方法名相同显然是不可能的。

　　例如：下方的四行输出语句，其实调用的不是一个方法，而是四个方法。

　　// println(String x) : void
　　System.out.println("xxx");
　　// println(int x) : void
　　System.out.println(111);
　　// println(double x) : void
　　System.out.println(12.5);
　　// println(char x) : void
　　System.out.println('x');

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

（编辑：我爱资讯网）

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

ASP 变量 寒假 作业

ASP 变量寒假作业