电脑、手机、其他的音像设备保持静音。
课堂上跟随老师进行互动,笔记、思想、行为进行互动。
在课堂上,如果真的有急事需要接听电话,直接拿起电话出了教室再接听,也无需像我请示。
在课堂上,如果真的有三急,直接出了教室,不需要像我请示。
反例:严禁上课期间,上卫生间"拉帮结派",前一个没回来,另一个需要上卫生间的不许出去(更不允许在卫生间抽烟)
在教室中,保持一个较为"优雅"的坐姿,对教室保持尊重,真的有特殊情况和我报备。
在上课期间,不允许小声的交谈,除了当前的知识之外(时间也要短,如果更长请下课说)
上课期间尽量少拿起手机去查看 社交平台,更别提在那聊天看与课堂无关的信息,没有特别情况手机收起来。
查老师一般是都会记笔记,而且会进行分小节录屏。
最终下课时,会有6个文件夹提供给大家。
上述课堂资料,每次放学前会将它们打成压缩包,然后发送给某个同学,由该同学将资料下发到QQ群或内网通共享。
内存 8G
硬盘 500G +
要开启扩展名显示
要开启隐藏文件夹显示
要关闭防火墙
显卡或一些第三方软件的快捷键,如果不常用都去掉/禁用。
首先从磁盘上做划分:
C盘就是用于系统盘
D盘就是用于软件安装(只要能自定义位置的都放在这)
大多数软件都是将安装目录默认为:
C:\Program Files\xxx
,我们未来只需要更改一下盘符即可。
E盘就是用于放一些文件资料(相对重要的资料)
F盘可以放一些娱乐类内容
如果你没有这么多磁盘,只有C或者只有C、D。
在现实生活中,我们逃脱不了三个范围:工作、学习、生活。
可以将工作、学习、生活分为三大文件夹:
Working
未处理/零散的资料 (未完成) Inbox
现在正在进行使用的资料 (正在完成)Workspace
按照所属范围建立文件夹,例如:我正在开发一个教学系统,那么这个系统的相关资料放在这个文件夹中
已经完成并且可以归档的资料 (已完成)Archive
按照所属范围来进行建立文件夹
再然后可以按照所属公司来划分,技术类也可以按照技术所对应的公司/组织来归档(如果技术较少,可以不归档在公司,直接单独列出来也可以)
按照日期来归档
Learning
Life
容灾处理:
在 d 盘新建一个文件夹,develop
,专门用于放开发类软件安装。
注意:无论怎么分类,怎么整理,路径最好不要出现中文、空格、特殊符号等。
notepad ++ / sublime text 编辑器
typora 编辑器 Markdown 语法的编辑器
# 一级标题
## 二级标题
### 三级标题
#### 四级标题
**加粗的内容**
*倾斜的内容*
- 列表内容
`简单代码关键词`
[超链接文字](超链接地址)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V9uav4Of-1613575228229)(图片地址)]
百度
[fn]
大家的电脑非常混乱(引起注意)
解决方法:
安装了大量的同类软件(全家桶安装)
解决方法:
电脑上安装有大量的游戏软件
解决方法:
压缩软件的使用问题
压缩软件的诞生:
压缩软件是使用一定的压缩算法来实现的压缩:
压缩软件还能承担解压缩的任务。
默认打开方式的程序选择找不到
生活中的程序:
计算机中的程序:
生活中的程序和计算机中的程序关联?
查老师有话说: 千万记住,开发程序绝对不能脱离现实!在遇到程序问题,多思考生活中的一些程序思路。
多思考生活中的业务逻辑,这是关键。
指令:完成某件事的每一个步骤。
生活中,指令的下达需要交给专门的人来做,计算机中,指令的下达需要交给计算机来做。
生活中下达指令,对应的人能听懂你在说啥。而计算机能听懂我们吗?
显然是不能的,计算机是识别二进制的(0,1组成,生活中我们主要使用的十进制,只包含0到9)。
我们无法和它沟通,除非你也使用二进制( 机器语言 ),显而易见,我们使用二进制是比较困难的,所以在程序发展中,出现了 汇编语言 (利用二进制写了一个程序,专门做简单的"翻译"工作,例如:我写了一个 add ,经过这个翻译官就将其翻译为对应的二进制)。
再随后,当C语言出现之后,整个程序开发(指令编写)变成了高级语言 (写的东西尽量能被人更容易的阅读),实际上高级语言想要使用,需要一个更高级的 “翻译官”(编译器)。
主流的编程语言:
一般程序员都需要掌握至少5-6种语言,语言的思想都是相通,要解决的问题也是一样的,所以如果已经掌握了一门语言再去学习会简单。
大多数人都是以一到两门语言为主,其他语言为辅。
1990年诞生,Java前身 Oak。
… 该计划"破产",计划终止,Oak被雪藏了。
1995年诞生,Java诞生。
1996年,推出开发工具包
1998年,Java 分化为了三个方向。 1.2 版本
2004年,Java新增了很多好用的特性
2009年,Oracle收购Sun公司,Java也一并归属Oracle公司
2013年中期,Java 8出现,影响深远
2019年,Oracle更改了Java使用协议,影响到了一些后续的更新使用
2020年的现在,即将发布Java 16。
JDK: 一种SDK(软件开发工具包),Java Development Kit(Java开发工具包),如果要是做Java开发必须安装此软件 ,它提供了编译、运行 Java 程序所需的各种工具和资源,包括 Java 编译器、Java 运行时环境(JRE
),以及常用的 Java类库等。
JRE: Java Runtime Environment(Java运行时环境),如果想要运行Java程序,必须要有它。
JDK 中内置了一个 JRE。
选择厂家
选择版本
你发任你发,我用 Java 8。
技术选择应该选择稳定、成熟,而不是任由自己的喜好,或者一味追求最新的。
Oracle JDK 8。
下载参考
如果电脑上已经安装过了JDK,先卸载,以免你的环境出现毛病(还得找我)。
程序员、程序猿、程序媛、码农。
DOS系统,全称Disk Operating System,磁盘操作系统,它是一种较为传统的操作系统。
没有携带可视化界面,无法使用鼠标。在DOS系统中,需要使用DOS命令来执行任务/工作(复制文件、删除…)。
我们可能在电影中看到的 “黑窗口” 就是用的DOS系统。
现今的Windows操作系统,内置了一个简易的DOS系统,为了方便开发者来使用。
进入方式: Windows
键 + R
键 -> 弹出运行窗口 -> 输入cmd
后回车 -> 进入DOS系统界面。
注意进入DOS最好采用管理员身份进入,以防止一些命令无法使用,或者权限不足。
win10一般进入都是非管理员,这时候
windows
键打开开始菜单,然后输入cmd
,再然后右键cmd程序,以管理员身份运行即可。不用在意进入DOS之后,最初的目录是在哪,只要是以管理员身份进入的即可。
进入到DOS系统后,界面上显示的包含有:
C:\Users\Administrator>
的一个内容
C:\Users\Administrator>
执行命令,输入完命令后回车即可。注意:符号之类的采用英文符号。也别少了空格
盘符名:
cd 要切换到的目录地址
cd c:\windows\system32
(绝对路径)cd Setup
(相对路径)cd ..
返回上一级目录
..
是每一个目录下都隐藏着的目录,它代表上一级目录cd \
进入对应磁盘的根目录
\
代表一个磁盘的根目录(直接进入某个磁盘后就处于它的根目录)利用Tab键可以有效的解决输错问题,它能够自动补全。
实现原理:依赖在某个目录下按名进行模糊查询实现的。
dir
(directory,目录)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AVEDGbLQ-1613575228234)(D:/HUIZONG/JAVA笔记/day02/开发第一个Java程序.assets/image-20201231145837489.png)]
cls
清理命令行的当前历史记录
在 cmd 中想运行程序:
直接输入程序的名字(需要做一些配置之后才能使用)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BnqnFBGe-1613575228235)(D:/HUIZONG/JAVA笔记/day02/开发第一个Java程序.assets/image-20201231151813369.png)]
切换到该程序的所在位置,然后在当前目录下输入程序名字
你也可以先通过 windows 系统找到改程序位置,然后在 地址栏 输入cmd,回车后可以直接打开DOS系统并切换到了当前目录下。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-peewXJZL-1613575228235)(D:/HUIZONG/JAVA笔记/day02/开发第一个Java程序.assets/image-20201231151318878.png)]
直接输入该程序的所在路径,例如:d:\develop\java\jdk1.8.0_202\bin\java.exe
环境变量(environment vaiables)一般指在操作系统中用来指定/存储操作系统运行环境的一些参数。
一般环境变量中的变量信息是操作系统中各个程序可以公用的。
path 环境变量的作用:(path,路径)(在path环境变量中存储的就是一些程序路径)
编辑环境变量的方式: 开始菜单中搜索 环境变量
,在搜索到的结果中,选择 编辑系统环境变量
。 -> 系统属性的高级选项卡中 -> 点击下方的环境变量
按钮,即可进入环境变量列表界面。根据你的需求选择某个环境变量进行编辑即可。
在系统变量列表中,我们可以找到 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系统,原有的窗口全部关掉。
我们通过Java语言的语法给计算机下达一系列的指令。
创建一个文本文档,命名为 HelloWorld
使用Sublime Text或者notepad ++打开该文档
编写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");
}
}
更改文本文档的扩展名为java
(java是Java程序文件的扩展名)
运行该程序
编译(将Java代码翻译为计算机能够识别的语言)
javac HelloWorld.java
HelloWorld.class
文件运行(运行翻译好的语言内容)
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)]
常见问题:
单词错误
不看重大小写问题
类名和文件名未保持一致
符号用的是中文
{}
、()
、;
、 “”
JAVA_HOME没配好
代码缩进问题
public class HelloWorld {
public static void main(String[] args) {
System.out.println("xxx");
}
}
{}要和对应的语句块开头对齐。
起名不注意规范,例如:HelloWorld helloworld(反例)
一般Java类名/源文件名应该遵循大驼峰命名法/帕斯卡命名法。
首字母要大写,如果有多个单词,每个单词的首字母都要大写。
不写作业
创建一个文本文档,命名为HelloWorld
然后打开文本文档,在其中编写基础语法结构
public class HelloWorld {
public static void main(String[] args) {
}
}
在语法结构中编写指令集
System.out.println("xxx");
将文本文档的扩展名转换为.java
(Java的源代码文件的扩展名是java)
利用javac
将源代码文件编译为字节码(byte code)文件.class
文件
利用java
将字节码文件运行起来
总结步骤:
// 类声明(声明一个类),因为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");
}
}
System.out.println();
利用系统输出流实现内容打印及换行操作
System.out.print();
利用系统输出流实现内容打印这些转义符号必须放在字符串中,双引号中。
转义符号 | 作用 |
---|---|
\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
在 Java 的编写过程中我们需要对一些程序进行注释,这样除了自己更方便阅读,别人也更好理解我们的程序,所以我们一定要适时的加一些注释,可以是编程思路或者是程序的作用。
前期,对大家写代码的要求,注释量不允许低于代码量的40%。
你写了10行代码,其中至少应该有4行注释。
注释有时候是一种捋清楚你思路的手段,在容易出错的代码行上反复添加注释,可以有效降低出错概率。
// 单行注释
/* 多行注释 */
/** Java Doc (文档)注释 */
/*
* 第一个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即可。
Java在当初一经推出,就火起来了!
除了它优秀的性能和简洁的语法之外,还有一个主打的优势:跨平台。(write once,run anywhere,写一次,可以到处运行)
为什么以前其他语言,C语言等没有实现跨平台呢?
原因是:编写程序要经过编写源代码、编译源程序、运行程序三个大阶段,其中编译好的源程序是对应于某个平台(某个系统:Windows、Mac、Android…)的专属版本,所以不同平台就需要准备很多份。
但是Java编写的程序编译之后,并非是直接运行在某个平台上,而是运行在JVM(Java虚拟机)上,同样也是由于JVM的原因,跨平台、垃圾回收等功能就可以使用了。
所以你只要准备好适配于不同平台的JVM就可以保证Java程序到处运行了。
Java如何实现的跨平台? [面试题]
Java不同于其他语言,直接将源代码编译为对应平台的机器码(二进制文件)。它是将源代码编译为字节码文件,然后将字节码文件运行在JVM(JVM包含在JRE中)上,由JVM在执行过程中,转换为对应平台的机器码。
所以只要在对应平台上安装好Java环境,Java程序就可以运行了,这就是Java实现跨平台的原理。
编译: 将源文件(.java)转换成字节码文件(.class)的过程称为编译。
反编译: 将字节码文件(.class)转换回源文件(.java)的过程称为反编译。(常用有Jad、FrontEnd、jd-gui)
IDE(Integrated Development Environment,集成开发环境),集成了代码编写功能、分析功能、编译功能、调试功能等一体化的开发软件服务套。
在Java开发领域有什么常用IDE:
workspace 工作空间
project 项目/工程
使用Eclipse开发第一个Java程序步骤:
切换到Java视图后。
保留了无用的空行和注释
Eclipse自动生成的 // ToDo xxx
记得写完后将自己下意识敲出来的空行删掉
public class HelloWorld{
public static void main(String[] args){
xxxx
}
}
还在src的默认package中创建类
单词的拼写问题
将程序文件存储到 ROM 上。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dEGImdKJ-1613575228239)(D:/HUIZONG/JAVA笔记/day04/变量和常量.assets/image-20210105094543881.png)]
CPU 将 ROM 上的 QQ的程序数据复制到 RAM 中, QQ 在RAM中会占据一块属于它的内存空间。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xbxmLKLK-1613575228239)(D:/HUIZONG/JAVA笔记/day04/变量和常量.assets/image-20210105095748986.png)]
有一些数据为了能够在程序内存中方便使用,会将它们定义为变量。
变量就是某些数据在对应程序内存中的一块空间表示。
变量是能表示可变状态、并且具有存储空间的抽象概念。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TzRTaiu9-1613575228240)(D:/HUIZONG/JAVA笔记/day04/变量和常量.assets/image-20210105102335512.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8xkzOjmB-1613575228240)(D:/HUIZONG/JAVA笔记/day04/变量和常量.assets/image-20210105104514611.png)]
按照数值和非数值划分:(8种基本数据类型)
'a'
、'你'
、'1'
、'男'
"查老师真好"
、"邢老师真好"
、"查老师的学生真好"
、"1"
Java中将int和double分别作为整数和小数的默认类型,意味着你在Java中写了一个10,Java会将它存储为int类型。
主要原因是,这两个类型的取值范围,已经能够满足我们绝大多数的使用场景。
变量名可以说是未来使用变量的关键,所以它也有一定命名规范。
变量名可以由字母、数字、下划线、美元符号组成,但是数字不能开头。
变量名不能使用关键字、保留字
变量名应该见名知意(为了能够区分对应变量存储数据的含义)
变量名应该遵循驼峰命名法(为了区分多个单词)
变量名可以遵循下划线连接法(蛇形命名法)
单词都小写,多个单词之间使用下划线连接。
不要将拼音和英文混合
常见的定义方式,有两种:
先声明变量,再赋值
// 数据类型 变量名;
String name;
// 赋值
// 变量名 = 变量值;
name = "小明";
声明变量的同时,赋值
// 数据类型 变量名 = 变量值;
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);
在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);
常量的命名规范:
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();
命名规范
HelloWorld
helloWorld
_
连接缩进问题
缩进是同级对齐,下级缩进
反例
// xxx
xxxx
xxxx
输入语句结合输出语句的问题
使用Scanner
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();
在 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…
=
号在各种编程语言中,不再表示相等,而是表示赋值。
只有极个别的语言,=号又表示赋值,又表示相等。
// 读法:将数字10赋值给变量num
// 将等号右侧的赋值给等号左侧的
int num = 10;
// 变量和变量之间的赋值
// 将num的值赋值给变量num2
int num2 = num;
+ 加法
- 减法
* 乘法
/ 除法
% 取余数
++ 自增
-- 自减
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
当 ++ 和 – 在单独使用时,效果上没有任何区别。
但是当 ++ 和 – 在被使用或参与计算时,效果上有不同。
++
:在使用时会先对变量自增1,然后再使用变量++
:在使用时会先使用变量,然后再对变量自增1int 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
+=
-=
*=
/=
%=
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;
…
比较运算符,可以用来做判断,比较运算符的计算结果是 布尔类型 值。
true(真) 和 false(假)
<
>=
<=
==
相等!=
不相等=号代表赋值,==才代表相等。
&&
短路与,并且||
短路或,或者!
非,取反// 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
短路与和短路或,代表的是如果前面的条件能够得到最终结果,那么后面的条件就不再进行了!
false && true
只要有一个为false,结果就为false
true || false
只要有一个为true,结果就为true还有一个 & 和 | 也可以表示逻辑关系,但是一般不用,因为它们无论是否能从前面条件得到最终结果,都要对所有条件进行计算。
所以 && 和 || 可以优化程序执行性能。
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
代码中一行注释也没有
任何一个语言编写出来的程序都包含这三种控制语句,因为它们可以让你的程序变得“丰富多彩”。
// 顺序流程语句
// 自上而下
System.out.println("我是语句1");
System.out.println("我是语句2");
System.out.println("我是语句3");
根据条件表达式,决定一部分代码是否可以正常执行。
条件表达式就是利用 关系运算符 和 逻辑运算符 来实现判断的过程,结果永远为 布尔类型:true(真、成立)、false(假、不成立)。
可以帮助我们解决重复性的工作问题。
三种流程控制语句是要结合使用,每种都有它能解决的问题。
UML
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 (条件) {
// 条件成立时执行的
} 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 (条件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 (内部条件) {
}
}
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会导致结构愈加混乱,所以使用时注意层级不要嵌套太多。否则容易出现你写的代码,你看不懂这类问题。
而且一般嵌套两层或三层,如果再多一般要考虑其他解决方案。
多重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;
}
switch中表达式只能使用 int(byte、short、char)、String(JDK1.7起支持)、枚举类型
每一个 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;
}
建议编写一个默认情况在最后,以防止一些判断未执行的情况
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);
代码不规范
{}
代码是给人看的,不是给机器看的。遵守良好的代码规范,让你在未来就业时,不至于因为代码规范问题而被"指点"。
需求理解错误
在公司内,需求理解错误,意味着你的辛苦,你的劳累都是无用的。你是在犯错而不是完成自己的工作。
看到需求,先读,先去思考过程(程序是一系列指令的集合,是为了完成某件事情的步骤、次序)
写代码思路比较传统
很长时间内,一直会出现。
如果你发现当前你写代码总是写出僵化的代码,例如:老师讲了一种案例,然后只能实现相差无几的案例,稍微复杂一点就完蛋。想不出来,或者写一大堆才能完成。
塌下来心来,承认自己当前的不足,而不是过于攀比。学习老师的思路,借鉴同学的思路,甚至将这种思路用的更好。(商业战争中,此类情况不胜枚举。你看看腾讯)
一般情况下,这种同学不一定比思路敏捷的同学混的差。
多做题,学多一种解决方法,这样你不也算会了吗?
我们上班、上学、甚至是一些回复都是循环的过程。
循环:反复地连续做某事。
周而复始,有规律性,重复的内容。
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("好好学习,天天向上,上学期间,不搞对象,关起门来都是一家人,搞对象那是乱伦。");
}
}
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 ++;
}
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("考核通过!");
我们前期用的比较多,因为它的执行思路和生活中业务大多类似。
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 + "份试卷!");
}
}
}
执行次序的区别:
应用场景:
死循环: 循环语句无法正常停止的情况,就被称为死循环。一般都是缺失了循环的出口或者循环条件存在问题。
按理说,死循环并不是一件好事,但是 “功法没有正邪之分,有正邪之分的是使用的人。” 如果被你使用正确,它可以解决很多问题。
适用的场景: 当你不确定,或是确定循环条件及出口时较为困难/麻烦时,可以采用死循环。
while (true) {
}
do {
} while (true);
for (;;) {
}
但无论是死循环也好,还是正常循环,都应该保证有相应出口。我们可以通过循环中的跳转语句,来实现循环流程的控制。
break
continue
break:中断
break 在 switch 选择结构中出现过,它当时的意思是结束某个分支。
在循环中,它表示结束当前所在循环,一般还要配合选择结构使用。
continue:继续
只能在循环中使用,它表示结束当前所在循环的本次循环(本次循环中,continue后的所有内容不再执行),跳转到下一次循环开始。
需求:实现下方图形的打印,通过一颗*
一颗*
的方式来打印。
*****
*****
*****
*****
*****
*
***
*****
*******
*********
*
***
*****
*******
*********
*****
*****
*****
单层循环无法实现稍微复杂些的需求,所以我们需要使用多重循环(嵌套循环),它是一种类似于嵌套 if 的存在。
while (外层循环条件) {
while (内层循环条件) {
}
}
do {
for (内层循环条件) {
}
for (内层循环条件) {
}
} while (外层循环条件);
不同的循环结构之间可以相互嵌套,嵌套多少层、多少个都可以。
但是一般嵌套的层数不要超过3层,因为层数过多,循环结构过于复杂,因小失大。
一般的嵌套都是两层居多,所以多重循环又被称为二重循环/双重循环。
产生循环嵌套之后,会分为外层循环和内层循环,内层循环此时其实就是外层循环的循环操作 。
外层循环执行一次,内层循环执行一遍!
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 5; j++) {
System.out.print("*");
}
System.out.println();
}
打印直角三角形:
*
***
*****
*******
*********
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 2 * i - 1; j++) {
System.out.print("*");
}
System.out.println();
}
打印等腰三角形:
*
***
*****
*******
*********
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();
}
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();
}
现在默写:类名的规范、变量名的规范、常量名的规范、注释的规范、缩进的规范。
作业见文档。
变量是一种单个值的存储方式,这种存储方式无法满足日益增多的数据需求。所以我们需要找寻一种可以同时存储多个数据的存储方式。
数组可以解决此类问题。
数组,顾名思义就是:数据的组合。它是在内存空间中开辟一连串的存储空间,可以存储多个 具有相同数据类型的数据 。
而且数组相比于变量来讲,拥有更多的"可玩性"。
类比变量来记忆。
变量的组成:
数组的组成:
数组的数据类型:数组存储的是一组相同数据类型的数据,需要做好指定。
数组名:使用数组时,也需要通过名字来使用
元素:数组中存储的每一个值,我们称之为元素
容量:长度,一个数组可以存储多少个元素( 一经定义,不可变 )
下标:索引,数组中每一个存储空间的 “序号”,从0开始计算
每一个下标空间,都有默认值。
根据数据类型不同,它的默认值分别为:
数组是存储一组具有 相同数据类型 数据的 定长 空间。
变量的定义:
数据类型 变量名 = 变量值;
数组的定义1:
// 先声明数组
数据类型[] 数组名 = new 数据类型[容量];
// 数组赋值(存入值,修改值)
数组名[下标] = 元素值;
// 数组使用
数组名[下标]
数组的定义2:
// 声明时赋值
数据类型[] 数组名 = {元素1, 元素2, 元素3, ...};
// 声明时赋值
// 后期有时候只能使用这种方式
数据类型[] 数组名 = new 数据类型[] {元素1, 元素2, 元素3, ...};
数组的定义1,结合循环优化:(动态赋值)
// 先声明数组
数据类型[] 数组名 = new 数据类型[容量];
// 使用循环动态赋值
for (int i = 0; i < 数组的容量; i++) {
数组名[i] = 输入值;
}
如果要求计算一个班的5名同学的成绩和,可以使用一维数组 + 普通循环解决。
而如果是计算三个班的各5名同学的成绩和,一维数组和普通循环实现起来不够好,所以我们才需要学习更高级的概念:多维数组。
多维数组,可以理解为嵌套数组。
二维数组:是以 一维数组 作为 数组元素 的数组,即 “数组的数组”。
多维数组的常见表现形式是二维数组、三维数组,但一般以二维数组居多。
多维数组在Java中,语法是存在的,但内存角度来看的话,只有一维数组。
// 数据类型[] 数组名 = 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];
API:Application Programming Interface 应用程序接口。
Arrays 是 Java 提供的数组操作类,提供了大量的数组操作方法。
它和 Scanner 一样,都是在 java.util
包下的,所以在使用时也需要先 import
。
如果你现在学习没有动力了,先接受我的三个提问?
1.不学这个,你能干什么?(你有没有退路?)
2.你想不想要赚钱多?(你有没有稳定的赚钱门路,谈对象提起自己的职业是否能开口)
3.没有技术傍身,你是不是能够在当前社会独立活下去且活的更好?(现在这个时代需要你有技术)
面向对象:
有难度!工作2年左右才能完全理解。
前期学习过程中,关注语法和一些理论,以及实现步骤。(照猫画虎)
不要和我来说:
1.好像明白又好像不明白???
2.老师这阶段我没学好,下个阶段不行吧???
3.老师上可能听懂,下课写不出来,好难。
过程。
将过程功能化、函数化、方法化、模块化。
将原来重复使用的内容,或者说是原来直接编写的指令改为一个个的小功能,这些小功能要求可以独立完成某个任务,还能实现复用。
例如:Scanner 中的 nextInt() 方法,就可以独立完成控制台输入整数的功能,并且可以复用。
面向对象是基于面向过程演进而来的。
对象。
将具有相似功能或者具有关联性功能,抽取到一个类中,然后下次想使用该功能时,先找到该类的对象,再使用即可。
例如:我们需要实现键盘录入,首先想到的就是 Scanner ,这个类中提供了与键盘录入有关的所有功能。
卖煎饼。
将卖煎饼转换为面向过程思路。
将卖煎饼转换为面向对象思路, 找专业的人来干专业的事儿。
项目规模必须达到一定的程度,否则面向过程可能比面向对象更实在。
无论是面向过程还是面向对象,它们都是来自于生活中的技巧和思路。
类和对象,是面向对象中非常重要的两个概念。
“万物皆对象”:你可以将生活中所有的事物、个体都看成一个个的对象。
人类的认知规律: 首先认识一个个体、把它看成是一个 对象 。然后再发现多个具有相似特征的个体之后,把它们抽取下相似特征归为一个 类别 。
例如:下面的这辆车可以看作是一个对象,然后对象的特征为:黄色的法拉利、有4个轮胎、有两个大灯、售价多少,可以前行、可以停下,可以播放音乐、可以把妹。
将特征分类:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UKb61hYo-1613575228244)(D:/HUIZONG/JAVA笔记/day15/类和对象.assets/image-20210125112112604.png)]
车类。
例如:下面这只狗。
也可以看成一个对象,对象的特征描述:
属性:
行为:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4FIWUDKX-1613575228244)(D:/HUIZONG/JAVA笔记/day15/类和对象.assets/image-20210125112629197.png)]
狗类。
生活中类和对象是无处不在的,类是从一组具有相同特征的对象中抽象而来的,所以它是一个抽象的概念,无法直接使用此概念做什么事儿。而对象则是基于类抽象概念为模板产生的个体,对象是可以直接用于干什么事儿。
所以程序中,为什么说:Scanner 想使用要先创建对象,最后用对象去调用行为。
Java 语言也是符合面向对象编程思想的。
而且在 Java 中,类是基本的组成单元,意味着想开发一个 Java 程序就是要编写一个到多个的类。
// 类声明
[访问权限修饰符] class 类名 {
// 类体
// 【属性】/成员变量/实例变量/Field
[访问权限修饰符] 数据类型 属性名;
// ...
// 行为/成员【方法】/实例方法/Method
[访问权限修饰符] [其他修饰符] 返回值类型 方法名(形式参数列表) {
// 方法体
}
// ...
}
上述语法就是 Java 中用于描述生活中类概念的语法。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t611tvI4-1613575228244)(D:/HUIZONG/JAVA笔记/day15/类和对象.assets/image-20210125120137694.png)]
在使用程序编写狗类之前,先使用类图描述好狗类:即设计狗类的类图。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TJmlbOCI-1613575228245)(D:/HUIZONG/JAVA笔记/day15/类和对象.assets/image-20210125120521913.png)]
对象是类的具体实例,也是在使用时的主体。(面向对象)
// 对象名的规范和变量名一致
类名 对象名 = new 类名(参数值);
// 属性赋值
// 描述对象的属性
对象名.属性名 = 属性值;
// 调用方法
// 描述对象的行为
对象名.方法名(参数值);
完全不用担心学不会!以后天天用!
在面向过程出现的时候,方法就出现了。在程序中要存储数据,会采用变量来存储,以方便我们复用。而方法的出现使为了存储程序中的功能代码,以方便我们复用。
例如:为了方便我们反复使用键盘录入功能,Scanner 类提供了一个 nextXX(),每次使用键盘录入直接调用该方法即可。
// 方法声明
[访问权限修饰符] [其他修饰符] 返回值类型 方法名([方法的参数列表]) {
// 方法体
// 功能代码....
[return 返回值;]
}
**访问权限修饰符:**目前先认识一个 public
,代表公共的,意味着在项目中可以被使用。
**其他修饰符:**目前先认识一个 static
,代表静态的,后面专门讲。
**返回值类型:**一个方法,一个功能在执行完之后返回的数据的类型。 例如:nextInt() : int,因为你要获取到输入的数据,所以必须定义返回值,因为要得到的返回数据是整数所以返回值类型是int。
**方法名:**为了方便下次再使用,要起名。命名规范与变量名一致。
方法参数列表: 一个方法内部要执行的功能,有些时候是要进行某些数据处理,但是要处理的数据必须由你来提供给它,所以它需要提前规范好需要什么数据。例如:Arrays.toString(数组) : String
**return:**结束方法,并将返回结果返回到调用者位置。调用者可以将结果存储为变量或者直接输出等方式来使用。
把方法理解为榨汁机。
以后学其他语言也基本是这4个分类。其他语言中可能叫函数、方法。
你们前期最害怕的事:就是不知道什么时候定义什么类型方法。建议多观察 Java 中的方法。
按照语法中是否有参数、是否有返回值来进行分类。
无参无返(没有参数、没有返回值)
一般这种方法,用于实现一些简单内容的输出或执行。
// 没有返回值,返回值类型需要定义为 void,代表空。
public void run() {
System.out.printf("%s今年%d岁,身高%.1fcm,正在跑步!\n", name, age, height);
}
使用过的该类型方法:
System.out.println();
public void println() {
newLine();
}
有参无返(有参数、没有返回值)
一般这种方法,用于实现一些需要根据条件或者一些基础数据,才能实现输出或执行的场景。
// Arrays工具类中的方法,可以实现对传入的数组的元素进行升序排序
public static void sort(int[] a) {
}
使用过的该类型方法:
System.out.println(1);
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();
}
使用过的该类型方法:
nextInt() : int
nextDouble() : double
next() : String
random() : double
length() : int
有参有返(有参数有返回值)
前期这种我们用的少,因为我们使用时一般都是用作于输出。后期用的越来越多,因为后期功能要求复杂。
// Arrays.toString() 将数组转换为字符串
public static String toString(int[] a) {
return xxx;
}
使用过的该类型方法:
toString(数组) : String
copyOf(数组, 长度) : 新数组
equals(字符串1, 字符串2) : boolean
构造方法,顾名思义就是 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");
在局部变量和成员变量出现重名时,局部变量优先级更高(优先使用局部变量)。
就近原则。
如果真重名了,可以使用 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 在当前类中,调用对象能调用的东西。
如果短期内没能理解,先掌握它什么时候使用。例如:在构造方法中用于区分成员变量和局部变量。
定义的位置:
成员变量:定义在类中,方法外(一般称为属性)
局部变量(Local Variable):定义在类中,方法内
初始值不同:
作用域不同:
变量作用域:与其直接所属的 {} 有关。
生命周期不同: (生老病死,什么时候诞生,什么时候销毁)
方法重载(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`
nextDouble() : double
next() : String
random() : double
length() : int
有参有返(有参数有返回值)
前期这种我们用的少,因为我们使用时一般都是用作于输出。后期用的越来越多,因为后期功能要求复杂。
// Arrays.toString() 将数组转换为字符串
public static String toString(int[] a) {
return xxx;
}
使用过的该类型方法:
toString(数组) : String
copyOf(数组, 长度) : 新数组
equals(字符串1, 字符串2) : boolean
构造方法,顾名思义就是 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");
在局部变量和成员变量出现重名时,局部变量优先级更高(优先使用局部变量)。
就近原则。
如果真重名了,可以使用 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 在当前类中,调用对象能调用的东西。
如果短期内没能理解,先掌握它什么时候使用。例如:在构造方法中用于区分成员变量和局部变量。
定义的位置:
成员变量:定义在类中,方法外(一般称为属性)
局部变量(Local Variable):定义在类中,方法内
初始值不同:
作用域不同:
变量作用域:与其直接所属的 {} 有关。
生命周期不同: (生老病死,什么时候诞生,什么时候销毁)
方法重载(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');
这样你就可以不需要记忆那么多的方法名,因为它们都是一样的功能。