其他分享
首页 > 其他分享> > 寒假作业

寒假作业

作者：互联网

学前准备

1. 课堂纪律

  1. 电脑、手机、其他的音像设备保持静音。

  2. 课堂上跟随老师进行互动，笔记、思想、行为进行互动。

  3. 在课堂上，如果真的有急事需要接听电话，直接拿起电话出了教室再接听，也无需像我请示。

  4. 在课堂上，如果真的有三急，直接出了教室，不需要像我请示。

    反例：严禁上课期间，上卫生间"拉帮结派"，前一个没回来，另一个需要上卫生间的不许出去（更不允许在卫生间抽烟）

  5. 在教室中，保持一个较为"优雅"的坐姿，对教室保持尊重，真的有特殊情况和我报备。

  6. 在上课期间，不允许小声的交谈，除了当前的知识之外（时间也要短，如果更长请下课说）

  7. 上课期间尽量少拿起手机去查看 社交平台，更别提在那聊天看与课堂无关的信息，没有特别情况手机收起来。

2. 上课资料相关

查老师一般是都会记笔记，而且会进行分小节录屏。

最终下课时，会有6个文件夹提供给大家。

  1. code：代码，上课的代码会放在该文件夹
  2. note：笔记，上课的笔记会放在该文件夹
  3. pic：图片，上课产生的相关重要图片（你应该好好看看的图）
  4. resource：资源，上课所需要的资源：软件、教程
  5. avi：视频，上课录制的视频
  6. answer：答案，上章节预留扩展作业参考答案

上述课堂资料，每次放学前会将它们打成压缩包，然后发送给某个同学，由该同学将资料下发到QQ群或内网通共享。

3. 电脑文件整理

内存 8G

硬盘 500G +

要开启扩展名显示

要开启隐藏文件夹显示

要关闭防火墙

显卡或一些第三方软件的快捷键，如果不常用都去掉/禁用。

首先从磁盘上做划分：

如果你没有这么多磁盘，只有C或者只有C、D。

  1. 购买移动硬盘（推荐：西部数据 1T/2T，大概3/400元左右）
  2. 为电脑加装硬盘（机械硬盘/固态硬盘SSD）

在现实生活中，我们逃脱不了三个范围：工作、学习、生活。

可以将工作、学习、生活分为三大文件夹：

  1. Working

    • 未处理/零散的资料 （未完成） Inbox

    • 现在正在进行使用的资料 （正在完成）Workspace

      按照所属范围建立文件夹，例如：我正在开发一个教学系统，那么这个系统的相关资料放在这个文件夹中

    • 已经完成并且可以归档的资料 （已完成）Archive

      按照所属范围来进行建立文件夹

      再然后可以按照所属公司来划分，技术类也可以按照技术所对应的公司/组织来归档（如果技术较少，可以不归档在公司，直接单独列出来也可以）

      ​ 按照日期来归档

  2. Learning

  3. Life

容灾处理：

在 d 盘新建一个文件夹，develop ，专门用于放开发类软件安装。

注意：无论怎么分类，怎么整理，路径最好不要出现中文、空格、特殊符号等。

4. 软件准备

基础类软件

开发类基础软件

百度

xxx

  1. Windows的常见快捷键

[fn]

初识Java

检查遇到的问题

  1. 大家的电脑非常混乱（引起注意）

    解决方法：

    • 备份好数据然后重装系统
    • 花点时间整理一下自己的电脑

  2. 安装了大量的同类软件（全家桶安装）

    • 安装了两三个压缩软件

    解决方法：

    • 从程序和功能中，卸载不需要的软件

  3. 电脑上安装有大量的游戏软件

    解决方法：

    • 适度娱乐

  4. 压缩软件的使用问题

    压缩软件的诞生：

    • 因为零散的文件，散布在计算机中，无论是传输还是保存都不太方便。传输速度会非常慢！保存时占用过多的空间。

    压缩软件是使用一定的压缩算法来实现的压缩：

    • 今天真冷。
    • 压缩算法将这些内容转换为数值型代号。 11111

    压缩软件还能承担解压缩的任务。

    • 在你需要使用压缩包中的内容时，你需要先解压缩。
    • 利用压缩算法将内容反向转换。

  5. 默认打开方式的程序选择找不到

    • 从电脑中浏览寻找对应的软件exe程序即可

1. Java概述

1.1 程序的概述

生活中的程序：

计算机中的程序：

生活中的程序和计算机中的程序关联？

查老师有话说： 千万记住，开发程序绝对不能脱离现实！在遇到程序问题，多思考生活中的一些程序思路。

多思考生活中的业务逻辑，这是关键。

1.2 编程语言概述

指令：完成某件事的每一个步骤。

生活中，指令的下达需要交给专门的人来做，计算机中，指令的下达需要交给计算机来做。

生活中下达指令，对应的人能听懂你在说啥。而计算机能听懂我们吗？

显然是不能的，计算机是识别二进制的（0，1组成，生活中我们主要使用的十进制，只包含0到9）。

我们无法和它沟通，除非你也使用二进制（ 机器语言 ），显而易见，我们使用二进制是比较困难的，所以在程序发展中，出现了 汇编语言 （利用二进制写了一个程序，专门做简单的"翻译"工作，例如：我写了一个 add ，经过这个翻译官就将其翻译为对应的二进制）。

再随后，当C语言出现之后，整个程序开发（指令编写）变成了高级语言 （写的东西尽量能被人更容易的阅读），实际上高级语言想要使用，需要一个更高级的 “翻译官”（编译器）。

主流的编程语言：

一般程序员都需要掌握至少5-6种语言，语言的思想都是相通，要解决的问题也是一样的，所以如果已经掌握了一门语言再去学习会简单。

大多数人都是以一到两门语言为主，其他语言为辅。

1.3 Java语言概述

2. 掌握Java开发环境的搭建

2.1 JDK和JRE的概述

JDK： 一种SDK（软件开发工具包），Java Development Kit（Java开发工具包），如果要是做Java开发必须安装此软件 ，它提供了编译、运行 Java 程序所需的各种工具和资源，包括 Java 编译器、Java 运行时环境（JRE），以及常用的 Java类库等。

JRE： Java Runtime Environment（Java运行时环境），如果想要运行Java程序，必须要有它。

JDK 中内置了一个 JRE。

2.2 JDK的选择

  1. 选择厂家

    • Oracle JDK
      • Oracle
    • Open JDK（Sun公司搞出来的开源版本，比正式版少一些商业特性）
      • 亚马逊
      • IBM
      • RedHat
      • 华为，毕昇JDK
      • 阿里巴巴，Drgronwell JDK
      • 腾讯，Kona JDK

  2. 选择版本

    • JDK 6
    • JDK 7
    • JDK 8
    • JDK 11
    • …

    你发任你发，我用 Java 8。

    技术选择应该选择稳定、成熟，而不是任由自己的喜好，或者一味追求最新的。

2.3 下载和安装

Oracle JDK 8。

下载参考

如果电脑上已经安装过了JDK，先卸载，以免你的环境出现毛病（还得找我）。

  1. 找到控制面板 -> 程序和功能
  2. 右键卸载即可
    • 卸载两个（如果有更多版本，全卸掉）
  3. 双击下载的exe程序

2.4 配置JAVA_HOME[非常重要]

3. 开发第一个程序

程序员、程序猿、程序媛、码农。

3.1 使用记事本开发的步骤

3.2 基础语法的认识

开发第一个Java程序

检查发现的问题分析

  1. 没有自己手动安装JDK
    • 要求：无论是家里的电脑还是学校电脑，一定自己手动操作每天内容
  2. 有些同学现在还没有做到听我指挥，指哪打哪
    • 查老师将会不喜欢你
    • 你讨厌上我的课，就学不好
    • 查老师没法保证你的学习效果，因为查老师的经验是经过检验的，大多数人有效
      • 不要做工厂里的"残次品"
  3. 有同学是使用win7系统
    • 使用win7系统的同学可能更费工夫，多百度一下

1. DOS系统

1.1 什么是DOS系统？

DOS系统，全称Disk Operating System，磁盘操作系统，它是一种较为传统的操作系统。

没有携带可视化界面，无法使用鼠标。在DOS系统中，需要使用DOS命令来执行任务/工作（复制文件、删除…）。

我们可能在电影中看到的 “黑窗口” 就是用的DOS系统。

现今的Windows操作系统，内置了一个简易的DOS系统，为了方便开发者来使用。

进入方式： Windows 键 + R键 -> 弹出运行窗口 -> 输入cmd 后回车 -> 进入DOS系统界面。

注意进入DOS最好采用管理员身份进入，以防止一些命令无法使用，或者权限不足。

win10一般进入都是非管理员，这时候 windows 键打开开始菜单，然后输入cmd，再然后右键cmd程序，以管理员身份运行即可。

不用在意进入DOS之后，最初的目录是在哪，只要是以管理员身份进入的即可。

1.2 DOS系统常见命令

进入到DOS系统后，界面上显示的包含有：

1.2.1 切换目录

执行命令，输入完命令后回车即可。注意：符号之类的采用英文符号。也别少了空格

利用Tab键可以有效的解决输错问题，它能够自动补全。

实现原理：依赖在某个目录下按名进行模糊查询实现的。

1.2.2 查看当前目录下的所有内容

dir（directory，目录）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AVEDGbLQ-1613575228234)(D:/HUIZONG/JAVA笔记/day02/开发第一个Java程序.assets/image-20201231145837489.png)]

1.2.3 清屏命令

cls 清理命令行的当前历史记录

1.2.4 运行程序

在 cmd 中想运行程序：

  1. 直接输入程序的名字（需要做一些配置之后才能使用）

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BnqnFBGe-1613575228235)(D:/HUIZONG/JAVA笔记/day02/开发第一个Java程序.assets/image-20201231151813369.png)]

  2. 切换到该程序的所在位置，然后在当前目录下输入程序名字

    • 你也可以先通过 windows 系统找到改程序位置，然后在 地址栏 输入cmd，回车后可以直接打开DOS系统并切换到了当前目录下。

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-peewXJZL-1613575228235)(D:/HUIZONG/JAVA笔记/day02/开发第一个Java程序.assets/image-20201231151318878.png)]

  3. 直接输入该程序的所在路径，例如：d:\develop\java\jdk1.8.0_202\bin\java.exe

2. 配置JAVA_HOME

2.1 环境变量是什么？

环境变量（environment vaiables）一般指在操作系统中用来指定/存储操作系统运行环境的一些参数。

一般环境变量中的变量信息是操作系统中各个程序可以公用的。

2.2 path环境变量

path 环境变量的作用：（path，路径）（在path环境变量中存储的就是一些程序路径）

编辑环境变量的方式： 开始菜单中搜索 环境变量 ，在搜索到的结果中，选择 编辑系统环境变量。 -> 系统属性的高级选项卡中 -> 点击下方的环境变量 按钮，即可进入环境变量列表界面。根据你的需求选择某个环境变量进行编辑即可。

2.3 配置JAVA_HOME

在系统变量列表中，我们可以找到 Path环境变量， 双击可以进入编辑状态。

在Path环境变量的目录列表中，可以新建一个新的程序地址，例如：我的Java.exe在d:\develop\java\jdk1.8.0_2020\bin目录下，那就把这个目录地址存储在Path环境变量中。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vPEVWFSY-1613575228235)(D:/HUIZONG/JAVA笔记/day02/开发第一个Java程序.assets/image-20201231160743981.png)]

但是仅仅如此做，后期我们安装了一些需要使用Java的程序时，它们在找Java安装位置时是找不到，可能导致它们无法运行。

我们可以在环境变量中配置一个 JAVA_HOME 然后存储Java的安装地址，这样这些程序就可以找到Java的位置了。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z5qqkmKq-1613575228236)(D:/HUIZONG/JAVA笔记/day02/开发第一个Java程序.assets/image-20201231160925643.png)]

我们发现 Path环境变量中刚配置的java.exe程序地址，和JAVA_HOME变量值仅差一个bin目录的区别，为了提升该变量的复用性，我们可以在 Path环境变量中引用 JAVA_HOME 变量。

当未来，Java安装目录更换了之后，我不需要又更改Path内的地址，又更改JAVA_HOME。

现在只需要改JAVA_HOME值即可。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dbQsNqQJ-1613575228236)(D:/HUIZONG/JAVA笔记/day02/开发第一个Java程序.assets/image-20201231161644891.png)]

配置好之后，重新打开DOS系统，原有的窗口全部关掉。

3. 开发第一个Java程序

我们通过Java语言的语法给计算机下达一系列的指令。

3.1 使用记事本开发步骤

  1. 创建一个文本文档，命名为 HelloWorld

  2. 使用Sublime Text或者notepad ++打开该文档

  3. 编写Java语言的语法指令（单词大小写不能错误），写完后按Ctrl+S保存内容

    代码里的这个类名应该和文件名保持一致。

    public class HelloWorld{
	public static void main(String[] args){
		System.out.println("Hello World");
        System.out.println("Hello World");
        System.out.println("Hello World");
	}
}

  4. 更改文本文档的扩展名为java（java是Java程序文件的扩展名）

  5. 运行该程序

    1. 编译（将Java代码翻译为计算机能够识别的语言）

      • javac.exe（java compiler，java编译器）
      • javac HelloWorld.java
      • 编译后，会产生一个HelloWorld.class文件

    2. 运行（运行翻译好的语言内容）

      • java.exe
      • java HelloWorld

      运行的时候不能写.class后缀

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PO9zrEWM-1613575228237)(D:/HUIZONG/JAVA笔记/day02/开发第一个Java程序.assets/image-20201231165505810.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SFpDUq3D-1613575228237)(D:/HUIZONG/JAVA笔记/day02/开发第一个Java程序.assets/image-20201231165623179.png)]

常见问题：

3.2 基础结构和语法

3.3 虚拟机和跨平台原理

4. 反编译

5. 作业

  1. 实现20次HelloWorld
  2. 编写一个程序，输出你的各项信息（先使用英文）

使用Eclipse编写第一个Java程序

检查问题分析

  1. 代码缩进问题

    public class HelloWorld {
    public static void main(String[] args) {
      System.out.println("xxx");  
    }
}

    {}要和对应的语句块开头对齐。

  2. 起名不注意规范，例如：HelloWorld helloworld（反例）

    一般Java类名/源文件名应该遵循大驼峰命名法/帕斯卡命名法。

    首字母要大写，如果有多个单词，每个单词的首字母都要大写。

  3. 不写作业

    • 不找理由，当场现写
    • 当场现写，不搭理你
    • 没电脑，写不了
      • 现在代码都是以背为主，所以在纸上写吧。（好记性不如烂笔头）

1. 程序开发步骤

  1. 创建一个文本文档，命名为HelloWorld

  2. 然后打开文本文档，在其中编写基础语法结构

    public class HelloWorld {
    public static void main(String[] args) {
      
    }
}

  3. 在语法结构中编写指令集

    System.out.println("xxx");

  4. 将文本文档的扩展名转换为.java（Java的源代码文件的扩展名是java）

  5. 利用javac将源代码文件编译为字节码(byte code)文件.class文件

  6. 利用java将字节码文件运行起来

总结步骤：

  1. 编写源代码
  2. 编译源代码
  3. 运行程序

2. 基本结构语法

// 类声明（声明一个类），因为Java中以类为基本单元
// class关键字后修饰的内容，我们称为类名
// 它的名字应该遵循大驼峰命名法，还应该和文件名保持一致(后续说什么时候不需要保持一致)
// public：公共的   class：类别
public class HelloWorld { 
    // 方法声明（声明一个方法），因为Java中在执行功能时需要以方法为单位
    // main方法是一个稍微特别的方法，语法固定，它是Java程序的程序入口（以它为起点来运行）
    // static：静态的  void：空、无效的  main：主要的
    // main容易写成mian，写错一点就不可以运行了，稍加注意
    public static void main(String[] args) {
      // 功能指令
      System.out.println("xxx"); 
    }
}

2.1 输出指令

这些转义符号必须放在字符串中，双引号中。

转义符号作用
\n换行
\t一个制表位（多个空格，一个Tab）
没用\t的效果
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
....
1*7=7 2*7=14 3*7=21 

用了\t之后的效果：（会自动调整一定的空格间隙，表格）
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6  3*3=9
....
1*7=7 2*7=14 3*7=21

2.2 注释

在 Java 的编写过程中我们需要对一些程序进行注释，这样除了自己更方便阅读，别人也更好理解我们的程序，所以我们一定要适时的加一些注释，可以是编程思路或者是程序的作用。

前期，对大家写代码的要求，注释量不允许低于代码量的40%。

你写了10行代码，其中至少应该有4行注释。

注释有时候是一种捋清楚你思路的手段，在容易出错的代码行上反复添加注释，可以有效降低出错概率。

/*
 * 第一个Java程序
 * @author Charles
 * @date 2021-01-04
 */
public class HelloWorld{ // 类声明
	// 程序的入口
	public static void main(String[] args) {
		// 输出内容
		System.out.print("Hello World\n");
		System.out.print("Hello World");
	}
}

你也不用担心注释写太多影响你的代码性能，因为在编译过程中，注释就已经被移除了，所以不会影响到你。

程序在CMD中运行时，需要注意中文乱码问题。CMD支持GBK编码格式，所以我们可以使用记事本的另存为功能去修改编码为ANSI即可。

3. 跨平台原理

Java在当初一经推出，就火起来了！

除了它优秀的性能和简洁的语法之外，还有一个主打的优势：跨平台。（write once，run anywhere，写一次，可以到处运行）

为什么以前其他语言，C语言等没有实现跨平台呢？

原因是：编写程序要经过编写源代码、编译源程序、运行程序三个大阶段，其中编译好的源程序是对应于某个平台（某个系统：Windows、Mac、Android…）的专属版本，所以不同平台就需要准备很多份。

但是Java编写的程序编译之后，并非是直接运行在某个平台上，而是运行在JVM（Java虚拟机）上，同样也是由于JVM的原因，跨平台、垃圾回收等功能就可以使用了。

所以你只要准备好适配于不同平台的JVM就可以保证Java程序到处运行了。

day01-3-9

Java如何实现的跨平台？ [面试题]

Java不同于其他语言，直接将源代码编译为对应平台的机器码（二进制文件）。它是将源代码编译为字节码文件，然后将字节码文件运行在JVM（JVM包含在JRE中）上，由JVM在执行过程中，转换为对应平台的机器码。

所以只要在对应平台上安装好Java环境，Java程序就可以运行了，这就是Java实现跨平台的原理。

4. 反编译

编译： 将源文件（.java）转换成字节码文件（.class）的过程称为编译。

反编译： 将字节码文件（.class）转换回源文件（.java）的过程称为反编译。（常用有Jad、FrontEnd、jd-gui）

5. Eclipse使用

5.1 IDE概述

IDE（Integrated Development Environment，集成开发环境），集成了代码编写功能、分析功能、编译功能、调试功能等一体化的开发软件服务套。

在Java开发领域有什么常用IDE：

eclipse_1_2

5.2 Eclipse

使用Eclipse开发第一个Java程序步骤：

切换到Java视图后。

  1. 新建Java工程/项目
    • File菜单 -> New -> Java Project
    • 在导航区域空白处右键 -> New -> Java Project
    • JRE System Library ：JRE的系统库，Java中定义了很多API（功能接口），直接可以使用。
    • src： source，编写Java源代码
  2. 在src下新建Java文件（类class文件）

变量和常量

检查问题分析

  1. 保留了无用的空行和注释

    • Eclipse自动生成的 // ToDo xxx

    • 记得写完后将自己下意识敲出来的空行删掉

    • public class HelloWorld{
	public static void main(String[] args){

		xxxx
	}


}

  2. 还在src的默认package中创建类

    • 包名package应该小写

  3. 单词的拼写问题

    • demo -> dome
    • main -> mian
    • hello -> hollo

1. 程序从安装到运行的原理

1.1 计算机核心硬件介绍

  1. CPU
    • 中央处理器，计算机的核心。
    • 用来处理/计算数据。
  2. RAM（内存）
    • 用来临时存储数据的
    • 程序在运行的时候，就是内存中进行数据处理
    • 速度快，空间小，价格高
  3. ROM（硬盘/磁盘…）
    • 用来持久性存储数据的
    • 程序在安装完成后，或者运行结束后应该将数据持久化到ROM
    • 速度慢（IO），空间大，价格低

1.2 程序安装的原理

将程序文件存储到 ROM 上。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dEGImdKJ-1613575228239)(D:/HUIZONG/JAVA笔记/day04/变量和常量.assets/image-20210105094543881.png)]

1.3 程序运行的原理

CPU 将 ROM 上的 QQ的程序数据复制到 RAM 中， QQ 在RAM中会占据一块属于它的内存空间。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xbxmLKLK-1613575228239)(D:/HUIZONG/JAVA笔记/day04/变量和常量.assets/image-20210105095748986.png)]

有一些数据为了能够在程序内存中方便使用，会将它们定义为变量。

变量就是某些数据在对应程序内存中的一块空间表示。

2. 变量

2.1 概述

变量是能表示可变状态、并且具有存储空间的抽象概念。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TzRTaiu9-1613575228240)(D:/HUIZONG/JAVA笔记/day04/变量和常量.assets/image-20210105102335512.png)]

2.2 变量组成

  1. 变量的数据类型
  2. 变量名
  3. 变量值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8xkzOjmB-1613575228240)(D:/HUIZONG/JAVA笔记/day04/变量和常量.assets/image-20210105104514611.png)]

2.2.1 数据类型

按照数值和非数值划分：（8种基本数据类型）

Java中将int和double分别作为整数和小数的默认类型，意味着你在Java中写了一个10，Java会将它存储为int类型。

主要原因是，这两个类型的取值范围，已经能够满足我们绝大多数的使用场景。

2.2.2 变量名

变量名可以说是未来使用变量的关键，所以它也有一定命名规范。

  1. 变量名可以由字母、数字、下划线、美元符号组成，但是数字不能开头。

    • 正例：name、name1
    • 反例：1name、xx%x

  2. 变量名不能使用关键字、保留字

    • 关键字：它们是Java中赋予了特殊含义的单词，例如：public、class
    • 保留字：它们是目前Java还没用，但是未来很有可能应用的，例如：goto、var（已经变为关键字）
    • 建议：命名时建议不要采用单个词汇，或者使用敏感词汇。 stuName

  3. 变量名应该见名知意（为了能够区分对应变量存储数据的含义）

    • 正例：存储名字，则命名为 name、mingZi
    • 反例：存储名字，命名为了 a

  4. 变量名应该遵循驼峰命名法（为了区分多个单词）

    • 小驼峰：首字母小写，如果有多个单词，后面的每个单词首字母大写
      • 正例：存储用户密码，userPassword
      • 反例：userpassword
    • 大驼峰（帕斯卡命名法）：每个单词的首字母都大写
      • 它用于类名 HelloWorld

  5. 变量名可以遵循下划线连接法（蛇形命名法）

    单词都小写，多个单词之间使用下划线连接。

    • 正例：存储用户密码，user_password

  6. 不要将拼音和英文混合

    • 反例：学生姓名，xueshengName

2.3 变量的使用

常见的定义方式，有两种：

  1. 先声明变量，再赋值

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

  2. 声明变量的同时，赋值

    // 数据类型 变量名 = 变量值;
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中提供的一个扫描器，它可以帮助我们扫描控制台输入的内容，并将其转换为你想要的类型值。

  1. 导入Scanner

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

    import java.util.Scanner;

    package demo4;

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

public class Demo1 {

	public static void main(String[] args) {

	}

}

  2. 创建Scanner对象

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

  3. 使用它的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();

常用的运算符

检查问题分析

  1. 命名规范

    • 类名：大驼峰命名法 HelloWorld
    • 变量名：小驼峰命名法 helloWorld
    • 常量名：所有的字母都大写，如果有多个单词，使用_连接
    • 包名(package)：全部小写

  2. 缩进问题

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

    • 反例

      // xxx
	xxxx
    xxxx

  3. 输入语句结合输出语句的问题

    使用Scanner

    1. 导入Scanner
    2. 创建Scanner对象
    3. 使用
      1. next() 可以输入字符串
      2. nextInt() 可以输入整数
      3. 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();
}

  4. 注释规范

    • 注释应该添加在想要解释的代码的 上方 或右侧

    • 注释的双斜线与注释内容之间有且仅有一个空格

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

1. 类型转换

在 Java 中存在自动数据类型转换和强制数据类型转换。

类型转换也不是万能的，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. 三元运算符

day02_4_5

Scanner scan = new Scanner(System.in);

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

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

选择结构

检查问题分析

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

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

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

    int num = 10;

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

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

    // 这是注释

  5. 变量乱起名（目前两人）

    • 你可以用有道词典来搜索对应的意思
    • 身高：name
    • 身高 * 身高：age2

  6. 交作业的时间非要卡在 DieLine

  7. 代码中一行注释也没有

    • 代码要包含40%以上的注释
    • 注释写代码的含义或者你的思路或者你反复也记不住的

流程控制语句

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

顺序控制语句

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

image-20210108103813740

选择控制语句

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

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

image-20210108103906726

循环控制语句

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

image-20210108103921630

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

流程图绘制

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);

System.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;
}

注意事项

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

    • byte、short、char可以自动类型转换为int

  2. 每一个 case 都要写break，否则会出现case的穿透性，穿透直到下一个break或结束为止

    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;
}

  3. 建议编写一个默认情况在最后，以防止一些判断未执行的情况

和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. 检查问题分析

  1. 代码不规范

    • 类名
    • 变量名
    • 注释
    • 缩进
    • {}
    • 包名

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

  2. 需求理解错误

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

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

  3. 写代码思路比较传统

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

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

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

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

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

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 循环至少会执行一次循环操作。

image-20210110120402723

/*
 * 思路分析：
 * 	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. 数组的组成

类比变量来记忆。

变量的组成：

  1. 数据类型
  2. 变量名
  3. 变量值

数组的组成：

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

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

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

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

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

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

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

    • byte、short、int、long：0
    • float、double：0.0
    • boolean：false
    • char：一个空格(\U0000)

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

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 返回值;]
}

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

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

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

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

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

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

把方法理解为榨汁机。

分类

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

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

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

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

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

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

    使用过的该类型方法：

    • System.out.println();

      public void println() {
    newLine();
}

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

    一般这种方法，用于实现一些需要根据条件或者一些基础数据，才能实现输出或执行的场景。

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

    使用过的该类型方法：

    • System.out.println(1);

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

    • Arrays.sort(数组);

    • …

  3. 无参有返（没有参数，有返回值）

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

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

    使用过的该类型方法：

    • nextInt() : int
    • nextDouble() : double
    • next() : String
    • random() : double
    • length() : int
    • …

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

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

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

    使用过的该类型方法：

    • toString(数组) : String
    • copyOf(数组, 长度) : 新数组
    • equals(字符串1, 字符串2) : boolean
    • …

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;
}

    使用过的该类型方法：

    • toString(数组) : String
    • copyOf(数组, 长度) : 新数组
    • equals(字符串1, 字符串2) : boolean
    • …

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');

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

标签：Java,int,System,寒假作业,println,循环,out
来源： https://blog.csdn.net/AlexmMercer/article/details/113839725