自己怎么创建一个网站,公交建设公司的官网,南宁网页设计招聘,外贸网站开发初识Java Java背景知识
Java是美国sun公司#xff08;Stanford University Network#xff09;在1995年推出的一门计算机高级编程语言。Java早期称为Oak#xff08;橡树#xff09;#xff0c;后期改名为Java。Java之父#xff1a;詹姆斯.高斯林#xff08;James Gosl… 初识Java Java背景知识
Java是美国sun公司Stanford University Network在1995年推出的一门计算机高级编程语言。Java早期称为Oak橡树后期改名为Java。Java之父詹姆斯.高斯林James Gosling。2009年 sun公司被Oracle公司甲骨文公司收购。
sun公司在1995年年初步发布了Java语言sun公司直接把Java放到互联网上免费给大家使用。甚至连源代码也不保密也放在互联网上向所有人公开。
有了Java语言后浏览器的功能被扩大了Java程序可以直接在浏览器里运行可以直接与远程服务器交互用Java语言编程可以在互联网上像传送电子邮件一样方便地传送程序文件 1995年sun虽然推出了Java但这只是一种语言如果想开发复杂地应用程序必须要有一个强大地开发类库。因此sun在1996年年年初发布了JDK.0.这个版本包括两个部分运行环境即JRE和开发环境JDK。运行环境包括核心API、集成API、用户界面API、发布技术、Java虚拟机JVM5个部分开发环境包括编译Java程序的编译器即javac命令。
接着sun在1997年2月18日发布了JDK1.1。JDK1.1增加了JIT即时编译编译器。JIT和传统的编译器不同传统的编译器是编译一条运行完后将其扔掉而JIT会将经常用到的指令保存在内存中当下次调用时就不需要重新编译了通过这种方式让JDK在效率上有了很大提升。
1998年12月sun发布了Java历史上最重要的JDK版本JDK1.2伴随JDK1.2一同发布的还有JSP/Servlet、EJB等规范并将Java分成了J2EE、J2SE、J2ME三个版本。
J2ME主要用于控制移动设备和信息家电等有限存储设备。
J2SE整个Java技术的核心和基础它是J2ME和J2EE编程的基础。
J2EEJava技术中应用最广泛的部分J2EE提供了企业应用开发相关的完整解决方案。 不仅如此JDK1.2还把它的API分成了三大类核心API、可选API、特殊API。
核心API由sun公司制定的基本的API所有的Java平台都应该提供。这就是平常所说的Java核心类库。
可选API这就是sun公司为JDK提供的扩充API这些API因平台的不同而不同。
特殊API用于满足特殊要求的API如用于JCA和JCE的第三方加密类库。 Java技术体系Java有哪些技术平台
1.
技术体系Java SEJava Standard Edition标准版
说明Java技术的核心和基础
2.
技术体系Java EEJava Enterprise Edition企业版
说明企业级应用开发的一套解决方案
3.
技术体系Java MEJava Micro Edition小型版
说明针对移动设备应用的解决方案 JDK的选择安装和下载 搭建Java开发环境
Java的开发环境叫JDKJava Development KitJava开发者工具包必须安装JDK才能使用Java。是sun提供的一套用于开发Java应用程序的开发包它提供了编译、运行Java程序所需的各种工具和资源包括Java编译器、Java运行时环境以及常用的Java类库等。
JRE
JREJava运行时环境它的全称是Java Runtime Environment因此也被称为JRE他是运行Java程序的必需条件。
一般而言如果运行Java程序可以安装JRE无须安装JDK。
简单来说JRE包含JVM。JVM是运行Java程序的核心虚拟机而运行Java程序不仅需要核心虚拟机还需要其他的类加载器、字节码校验器以及大量的基础类库。JRE除了包含JVM之外还包含运行Java程序的其他环境支持。
注
如果需要开发Java程序则应该选择安装JDK当然安装了JDK之后就包含了JRE也是可以运行Java程序。但如果只是运行Java程序则需要在计算机上安装JRE仅安装了JVM是不够的。实际上Oracle网站上提供的就是JRE的下载并不是单独JVM的下载。
JDK的发展史
1996年JDK1.0
1998年JDK1.2
2000年JDK1.3
.......
2004年JDK-5
2009年JDKOrale收购sun
......
2014年JDK-8 LTSLTSlong-term support 长期支持版
......
(企业更在意稳定性 JDK)
如何获取JDK
百度输入Oracle
进入官网
点击products
Java
Java downloads
Java 17
Windows
如何安装JDK
傻瓜式安装直接下一步注意安装路径中不要包含中文和空格注意2所有的开发工具最好安装到统一目录
先找到下载文件 点击下一步 更改路径 路径不包含中文和空格
如何验证JDK是否成功
看Java、javac是否可用看Java、javac的版本好是否无问题
1. 打开命令行窗口
按下WinR在运行输入框中输入cmd敲回车
2. 看Java、Javac是否可用
输入Java 或 输入javac
3. 验证版本号是否正确
输入Java -version 或 输入Javac -version
如何卸载JDK
找到控制面板
程序
卸载程序
找到JDK
右击卸载确定
前置知识了解JDK中的Java、Javac的基本作用
java -- jdk ...... --- bin
说明将来我们写好的Java程序都是高级语言计算机底层是硬件 不能识别这些语言必须先通过Javac编译工具进行翻译然后再通过Java执行工具才可以驱动机器干活。
java.exe 执行工具javac.exe 编译工具
安装JDK 组件了解
Development Tools、Source Code
Development Tools
Development Tools这是JDK的核心包括编译Java程序必需的命令工具。实际上这个选项里面已经包含了运行Java程序的JRE这个JRE会安装在JDK安装目录的子目录里这也是无须安装公共JRE的原因。
公共JRE是一个独立的JRE系统会单独安装在系统的其他路径下。公共JRE会向IE浏览器和系统中注册Java运行时环境。通过这种方式系统 中任何应用程序都可以使用公共JRE。由于现在在网页上执行Applet的机会越来越少而且完全可以选择使用JDK目录下的JRE来运行Java程序因此没有太大必要安装公共JRE。
Source Code
安装这个选项将会安装Java所有核心类库 的源代码。
JDK安装路径下的文件路径
bin、db、include、jre、lib、javafx-src、src.zip、README和LICENSE等说明性文档。
bin
bin该路径下存放了JDK的各种工具命令常用的javac、Java等命令就放在该路径下。
db
db该路径是安装Java DB的路径。
include
include一些平台特定的头文件。
jre
jre该路径下安装的就是运行Java程序所需的JRE环境。
lib
lib该路径下存放的是JDK工具命令的实际执行程序。
javafx-src
javafx-src该压缩文件里存放的就是Java FX 所有核心类库的源代码。
src.zip
src.zip该压缩文件里存放的是Java所有核心类库的源代码。 掌握DOS窗口常见命令的使用 补充几个命令行窗口的常用命令
切换至D盘 输入 D:切换至E盘 输入 E:查看当前目录下的文件信息 输入dir进入单级目录 eg进入单级目录饼干呢 输入cd 饼干呢tab键可以往后补全)进入多级目录 输入 cd D:\itheima\JavaSE目录路径可以找到文件全部复制 粘贴到命令行窗口回退到上一级目录 输入cd.. 回退到盘符根目录 输入 cd /清屏 输入 cls创建目录 eg创建 team1 输入 md team1删除目录 eg删除te1 首先 先进入目录下输入 rm te1 Java程序运行机制 高级语言的运行机制
计算机高级语言按程序的执行方式可以分为编译型和解释型两种。
编译型语言
编译型语言是指使用专门的编译器针对特定平台操作系统将某种高级语言源代码一次性“翻译”成可以被该平台硬件执行的机器码包括机器指令和操作数并包装成该平台所能识别的可执行性程序的格式这个转换过程称为编译Compile。编译生成的可执行性程序可以脱离开发环境在特定的平台上独立运行。
有些程序编译结束后还可能需要对其他编译好的目标代码进行链接即组装两个以上的目标代码模块生成最终的可执行程序通过这种方式实现低层次的代码复用。
因为编译型语言是一次性地编译成机器码所以可以脱离开发环境独立运行而且通常运行效率较高但因为编译型语言地程序被编译成特定平台上地机器码因此编译生成地可执行性程序通常无法移植到其他平台上运行如果需要移植则必须将源代码复制到特定平台上针对特定平台进行修改至少也需要采用特定平台上地编译器重新编译。
现有的 C、C、ObjectiveC、Pascal等高级语言都属于编译型语言。
解释型语言
解释型语言是指使用专门的解释器对源程序逐行解释成特定平台的机器码并立即执行的语言。解释型语言通常不会进行整体性的编译和链接处理解释型语言相当于把编译型语言中的编译和解释过程混合到一起同时完成。
可以认为每次执行解释型语言的程序都需要进行一次编译因此解释型语言的程序运行效率通常较低而且不能脱离解释器独立运行。但解释型语言有一个优势跨平台比较容易只需要提供特定平台的解释器即可每个特定平台上的解释器负责将源程序解释成特定平台的机器指令即可。解释型语言可以方便地实现源程序级的移植但这是以牺牲程序执行效率为代价的。·
现有的 Ruby、Python等语言属于解释型语言。
伪编译型语言
Visual Basic它属于半编译型语言并不是真正的编译型语言。
Java程序的运行机制
Java语言比较特殊由Java语言编写的程序需要经过编译步骤但这个编译步骤并不会生成特定平台的机器码而是生成一种与平台无关的字节码也就是 * . class文件。这种字节码不是可执行性的必须使用Java解释器来解释执行。因此可以认为Java语言既是编译型语言也是解释型语言。或者说Java语言既不是纯粹的编译型语言也不是纯粹的解释型语言。Java程序的执行过程必须经过先编译、后解释两个步骤。
JVM
Java语言里负责解释执行字节码文件的是Java虚拟机即JVMJava Virtual Machine。JVM是可运行Java字节码文件的虚拟计算机。所有平台上的JVM向编译器提供相同的编程接口而编译器只需要面向虚拟机生成虚拟机能理解的代码然后由虚拟机来解释执行。在一些虚拟机的实现中还会将虚拟机代码转换成特定系统的机器码执行从而提高执行效率。
当使用Java编译器编译Java程序时生成的是与平台无关的字节码这些字节码不面向任何具体平台只面向JVM。不同平台上的JVM都是不同的但它们都提供了相同的接口。JVM是Java程序跨平台的关键部分只要为不同平台实现了相应的虚拟机编译后的安居啊字节码就可以在该平台上运行。显然相同的字节码程序需要在不同的平台上运行这几乎是“不可能的”只有通过中间的转换器才可以实现JVM就是这个转换器。
JVM是一个抽象的计算机和实际的计算机一样它具有指令集并使用不同不存储区域。它负责执行指令还管理数据、内存和寄存器。
JVM的统一标准
Oracle公司制定的Java虚拟机规范在技术上规定了JVM的统一标准具体定义了JVM的如下细节
1.指令集
2.寄存器
3.类文件的格式
4.栈
5.垃圾回收堆
6.存储区
Oracle公司制定这些规范的目的是为了提供统一的标准最终实现Java程序的平台无关性。 开发HelloWorld程序 Java程序开发的三步骤
开发Java程序需要三个步骤编写代码编译代码运行代码编写代码 HelloWorld.java源代码源文件--- 编译代码 使用javac编译 HelloWorld.class字节码文件--- 运行代码 使用Java运行
注意事项
第一个Java程序建议使用记事本书写建议代码文件名全英文首字母大写满足驼峰模式源代码文件的后缀必须是 . java Java程序严格区分大小写
编写代码
1. 新建文件 2. 在记事本中编写代码
第一个程序的代码如下
public class HelloWorld{public static void main (String[] args){System.out.println(Hello World);}
} 注意文件名称必须与代码中的类名称一致。
保存文件ctrl s
编译代码、运行代码
1.编译javac文件名.java
范例javac HelloWorld.java 2. 运行 java 类名
范例Java HelloWorld Java基础知识了解 public 表示公开的。class 表示定义一个类是关键字后面跟着类名HelloWorld 表示一个类名。public class HelloWorld 表示定义一个公开的类起名为HelloWorld。 public static void main (String[] args) Java程序的入口方法程序将从这里开始执行。System.out.println(Hello World); 向控制台打印一条语句。输出语句 Hello WorldJava程序严格区分大小写每一行执行语句必须以分号英文结束一个源文件中可以声明多个class编译后会生成一个或多个字节码文件。每一个字节码文件对应一个Java类并且字节码文件名与类名相同一个源文件中可以声明多个类但是最多只能有一个类使用public进行声明且要求声明public的类的类名与源文件名相同 常见问题解答 HelloWorld案例常见错误
1. Windows 的文件扩展名没有勾选 解决方案必须勾选文件扩展名再新建Java文件 2. 代码写对了但是忘记保存了 3. 文件名和类名不一致
4. 大小写错误单词拼写错误存在中文符号找不到main方法
5. 括号不配对
6. 编译、执行使用不当 ### 一个什么错都犯过的程序员才是真正的程序员### Java程序的执行原理、BUG介绍 计算机能认识的机器语言长什么样子
机器语言00011100 00110101 ......计算机底层都是硬件电路可以通过不通电和通电表示0、1
注 可以使用机器语言编程来实现呼吸灯效果
机器语言是由什么组成的
0和1
java程序的执行原理是什么样的
不管是什么样的高级编程语言最终都是翻译成计算机底层可以识别的机器语言。
编程语言发展历程
机器语言汇编语言高级语言 为什么学习高级编程语言
更简单使用接近人类自己的语言书写翻译器再将其翻译成计算机能理解的机器指令。
BUG
原意是臭虫或者虫子现在用来指代再电脑系统或者程序中隐藏的一些问题或者漏洞。BUG的创始人格蕾丝赫伯 JDK的组成、跨平台原理 JDK的组成
JVMjava Virtual MachineJava虚拟机真正运行Java程序的地方。核心类库Java自己写好的程序给程序员自己写的程序调用的。JREJava Runtime EnvironmentJava的运行环境JDKJava Development KitJava开发工具包包括上面所有。
JRE组成JVM 核心类库
JDK组成JVM 核心类库 开发工具Java Javac ......
JDK组成JRE 开发工具Java Javac ......
java的跨平台、工作原理
一次编译处处可用。我们程序只需要开发一次就可以在各种安装了JVM的系统平台上运行。 Path、JAVAHOME环境变量配置 Path环境变量
path环境变量用于记住程序路径方便在命令行窗口的任意目录启动程序
编译和运行Java程序必须经过两个步骤
1.将源文件编译成字节码。
2.解释执行平台无关的字节码程序。
使用命令行窗口打开qq程序
1. 打开命令行模式 cmd
2. 找到qq程序路径 3. path环境变量位置 配置qq程序path
此电脑 右键 属性 高级系统设置 高级 环境变量 ...的用户变量中path 双击 新建 复制qq程序路径 点击确定 点击确定 4.用命令行模式打开qq程序
打开新的命令行窗口 输入qq 在命令行窗口的任意一个路径都可打开qq程序 为Java、javac配置path的注意事项
目前较新的JDK安装时会自动配置java、javac程序的路径到path环境变量中去因此Java、javac可以直接使用注意以前的老版本的JDK在安装的时没用自动配置Path环境变量的此时必需要自己配置path环境变量。建议还是自己配置一下 “path”、“JAVA_HOME”
自行配置Java、javac的path环境变量
1. 找到Java程序 和 Javac程序的路径 复制路径
jdk ...... bin 2. 打开path环境变量
此电脑 右击 属性 高级系统设置 高级 环境变量 注配置在 .....的用户变量中的path 和 配置在系统变量中的path 二者均可行
注配置在 ......的用户变量中的path 只针对当前登录的系统用户有效不影响其他登录的用户
在配置之前建议把之前自动配置的C:\ProgramData\Oracle\Java\javapath删除用自己配的 2. 配置Java、javac的path环境变量
此电脑 右击 属性 高级系统设置 高级 环境变量 ...的用户变量下 双击path 新建 复制 Java程序 和 Javac程序的路径 点击确定 重新配置了环境变量以后必须检测是否配置成功
打开命令行窗口输入javac -version 及 java -version 分别看版本提示 配置Java _home 环境变量
JAVA_HOME :告诉操作系统JDK安装在哪个位置将来其他技术要通过这个环境变量找JDK。
注意较新版本的JDK只是配置了Path没用自动配置JAVA_HOME。
多学一招 推荐Path %JAVA_HOME%\bin
1. 找到jdk的位置 复制路径 2. 找到环境变量
此电脑 右击 属性 高级系统设置 高级 环境变量 3. 新建JAVA_HOME 4. Path %JAVA_HOME%\bin
...的用户变量下 双击path 新建 输入 %JAVA_HOME%\bin IntelliJ IDEA开发工具概述 之前的开发工具存在一些问题
文本编辑工具记事本、NotePad、EditPlus、sublime编写代码时没用错误提醒、没有智能代码提示、需要自己进行编译、执行功能不够强大。
集成开发环境IDEIntegrated Development Environment
把代码编写编译执行等多种功能综合到一起的开发工具可以进行代码智能提示错误提醒项目管理等等。常见的Java IDE工具有Eclipse、MyEclipse、IntelliJ IDEA、Jbuilder 、NetBeans等。
IntelliJ IDEA简介
IntelliJ IDEA一般简称 IDEA在代码错误提醒智能代码补全等多方面表现的都非常优秀是进行Java开发时很多企业首选的开发工具。
IDEA的下载、安装
1. 百度搜索 IntelliJ IDEA 进入官网 Windows UL旗舰版、 Community社区版社区版功能比旗舰版功能少旗舰版要付费 DownLoad
不建议使用最新版本IDEA
2. 找到应用 双击 3. next 更改路径 next 4. 根据情况点击启动图标 next 5. next 6. 7. 8. 根据自身情况而定 IDEA程序的卸载
找到控制面板 程序 卸载程序 找到IntelliJ IDEA 右键 卸载 是 勾选 IDEA开发HelloWorld程序 IDEA管理Java程序的结构
project项目、工程module模块package包class类
新建工程
1. 2. 3. 4. 5. 创建模块
1. 2. 3. 新建包
1. 2. 包名 按下回车 编写Java程序
1. 2. 取类名 按下回车 3.编写代码
package com.liu.hello;public class HelloWorld {//输入main直接回车public static void main(String[] args) {//输入sout 直接回车System.out.println(Hello World);}
}
4. 运行代码 运行结果 使用idea开发第一个Java程序的步骤 总结
创建工程 project空工程创建模块 Module创建包 Package创建类编写代码、并启动
使用idea开发Java程序的步骤
project module package classproject中可以创建多个modulemodule中可以创建多个packagepackage中可以创建多个class
创建的关键字 projectmodulepackageclass
idea中的Java程序是自动编译和执行的编译后的class文件在工程路径下的一个 文件里。 IDEA的配置、快捷键设置 设置IDEA的主题
file --- settings --- appearance Behavior --- appearance --- theme --- intelliJ Light --- ok
--- apply 设置字体颜色
file --- settings --- editor --- font --- size --- ok --- apply 设置代码的背景颜色
例如 file --- settings --- editor --- color scheme --- general --- text --- default text --- background --- ok --- apply IDEA 常用快捷键
组合几个键一起按下来完成某件事可以提高开发效率。 补充 快捷键
选中部分代码 CTRL ATL T 给部分代码 添加循环操作 重新建包演示一下 package com.liu.speedkey;public class SpeedKeyDemo {//输入main直接回车public static void main(String[] args) {//输入sout 直接回车System.out.println(Hello World);//直接输入 Hello World.sout 直接回车System.out.println(Hello World); //此行 按下CTRLD//CTRL D 复制当前行数据到下一行System.out.println(Hello World);System.out.println(Hello World);System.out.println(Hello World);// CTRL Y 删除所在行建议 CTRL X// CTRL X 剪切键 也可删除行// CTRL Z 撤销操作//CTRL ALT L 格式化代码// ALT SHIFT 上箭头 ALT SHIFT 下箭头 上下移动当前代码// CTRL / , CTRL SHIFT / 对代码进行注释}
} IDEA的其他操作 删除文件 修改类名称 修改模块 导入模块方法一 不建议
找到导入模块的文件路径复制路径 打开IDEA file new module from existing sources... 导入模块方法二 建议
此方法导入的模块会一直在不会从IDEA的工程中丢失
找到要导入的模块复制工程粘贴到IDEA要使用的工程固定目录下再使用方法一进行拷贝 复制路径 打开IDEA file new module from existing sources... 导入模块方法三
新建工程 找到模块 复制路径 打开IDEA 粘贴 欧克 删除模块了解 只删除了IDEA中的功能模块并没有彻底删除模块需要打开电脑中的目录文件 彻底删除了 打开工程 关闭工程 将类分页打开即同一个界面打开两个类 生成get set方法 产生构造器 idea自动导包 重写构造器 阶段总结Java概述、快速入门、IDEA使用 Java快速入门、IDEA开发工具的使用
1. Java的概述
Java事sun公司1995年推出2009年被Oracle收购Java的爸爸詹姆斯 . 高斯林Java是一门高级编程语言语言风格接近人类的自然语言写程序简单易懂Java的流行度高商业占用度很高很重要的特性可移植性Java能干什么什么都可以干但是最被市场认可的是企业级开发京东、淘宝这样的互联网系统Java的技术体系JavaSE 标准版java技术的核心和基础 JavaEE 企业版大型互联网企业级解决方案充分被市场认可 JavaME 小型版移动应用的解决方案没有被市场认可
2. Java的产品
jdk Java的开发工具包必须安装它才可以使用Java去Oracle官网下载安装时不要放在空格和中文路径我们用的是JDK 17企业中可用JDK 8LTS长期支持版JDK 8 11、、17JDK中要用的2个重要的程序Java 编译程序 Java 执行程序
JDK安装后要验证是否安装成功打开命令行窗口 Win R 回车 输入Java Java Javaversion看提示有没有问题
补充知识常用命令行命令 清理屏幕 切盘盘符 3. 开发一个Java的入门程序Hello World
1、编写代码
建议全英文名称首字母大写 后跟一定是Java结尾代码写啥
public class HelloWorld{ public static void main (String[] args){ System.out.println(Hello World); } }
2、编译代码
javac HelloWorldjava 产生class文件 HelloWorldclass
3、执行代码
java HelloWorld 输出 HelloWorld 4. Java程序的执行原理
Java程序最终会翻译解释成计算机能识别的机器语言000111这样的形式驱动机器干活BUG 代表程序出现问题或者漏洞的意思 DEBUG 解决问题的意思 5. path环境变量JAVAHOME
path的作用记住程序的路径方便在命令行窗口的任意目录驱动程序新版本的JDK安装的时候会自动配置和Java程序的路径到path环境变量中去所以和Java可以在命令行窗口中直接使用了吧重点注意老版本的JDK安装的时候是不会自动配置和Java程序的路径到path环境变量中去 6. 开发工具 J IDEA
集成开发工具IDEA工具 工程结构话管理项目有错误提醒有代码智能补全IDEA去官网下载安装傻瓜式安装
IDEA开发第一个Java程序 1、必须创建工程project 2、必须创建模块module 3、创建一个包 Java基础语法注释详解 编写程序时总是需要为程序添加一些注释用以说明 某段代码地作用或者说明某个类地用途、某个方法地功能以及该方法的参数和返回值的数据类型及4意义等。
除此之外添加注释也是调试程序的一个重要方法。如果觉得某段代码可能有问题可以先把这段代码注释起来让编译器忽略这段代码再次编译、运行如果程序可以正常执行则可以说明错误就是由这段代码引起的这样就缩小了错误所在的范围有利于排错如果依然出现相同的错误则可以说明错误不是由这段代码引起的同样也缩小了错误的范围。 什么是注释
注释是写在程序中对代码进行解释说明的文字方便自己和其他人查看以便理解程序的
注释有哪些
单行注释、多行注释、文档注释
单行注释
// 注释内容只能写一行
单行注释就是在程序中注释一行代码在Java语言中将双斜线 // 放在需要注释的内容之前就可以了。
多行注释
/*
注释内容1
注释内容2
*/
多行注释是指一次性地将多行代码注释掉在Java语言中使用 “ /* ” 和 “ * / ”将程序中需要注释地内容包含起来“ /* ” 表示注释开始而“ */ ”表示注释结束。
文档注释
文档注释文档注释的内容是可以提取到一个程序说明文档中去的
开发一个大型软件时需要定义成千上万的类而且需要很多人参与开发每个人都会开发一些类并在类里定义一些方法、成员变量提供给其他人使用但其他人怎么知道如何使用这些类和方法呢这时候就需要提供一份说明文档用于说明每个类、每个方法的用途。当其他人使用一个类或者一个方法时他无须关心这个类或方法的具体实现他只要知道这个类或方法的功能即可然后使用这个类或方法来实现具体的目的也就是通过调用应用程序接口API来编程。API文档就是用以说明这些应用程序接口的文档。对于Java语言而言API文档通过详细说明 每个类、每个方法的功能及用法等。
文档注释以斜线后紧跟两个星号/**开始以星号后紧跟一个斜线*/结束中间部分都是文档注释会被提取到API文档中。
/**
注释内容
注释内容
*/
package com.liu.note;/*** 文档注释* 调频* 同频* 忠诚* 唯一* 礼物*/
public class NoteDemo {public static void main(String[] args) {//单行注释//以下是一个打印语句是往控制台输出内容的System.out.println(我开始学习Java程序happy);//多行注释/*开心最重要你开心就好*/System.out.println(玫瑰);System.out.println(玫瑰花);}
}注释的特点
注释不影响程序的执行的javac命令进行编译产生 . class 文件写注释是一个利人利己的好习惯
快捷键进行注释
ctrl / 单行注释对当前行进行注释ctrl shift / 对选中的代码进行多行注释 Java基础语法字面量详解 字面量
计算机是用来处理数据的字面量就是告诉程序员数据在程序中的书写格式
常用数据 package com.liu.literal;public class LiteralDemo {public static void main(String[] args) {//目标掌握常见数据在程序中的书写格式//1、整数System.out.println(500);//2. 小数System.out.println(99.5);//3. 字符必须要用单引号围起来有且只能有一个字符System.out.println(a);System.out.println(0);System.out.println(中);//错误写法 中国为字符串 非字符 System.out.println(中国);//4. 空字符System.out.println( );//错误写法 单引号里面要有东西 不能什么都不写 System.out.println();//5. 特色字符// \n 代表的是换行的意思// \t 代表的是一个tabSystem.out.println(\n);//这行代码在执行的时候会换两行// \n 代表换行println代表换行System.out.println(饼);System.out.println(\n);System.out.println(干);System.out.println(\t);//6. 字符串必须用双引号围起来里面的内容其实可以随意System.out.println(我爱吃水果);System.out.println(我爱吃饼干);System.out.println();System.out.println( );//7. 布尔值true falseSystem.out.println(true);System.out.println(false);}
}Java基础语法变量详解 什么是变量
变量是用来记住程序要处理的数据的
变量的定义格式
数据类型 变量名称 数据 int age 18 ;数据类型限制盒子中只能存储某种数据形式例如int整数类型、double小数类型变量名称首字母建议小写有意义 赋值
为什么要使用变量
使用变量既要处理数据编写的代码更灵活管理代码更方便。
变量在计算机中的执行原理
变量就是内存中的一块区域可以理解成一个盒子用来装一个数据的
变量有啥特点
变量中装的数据是可以被替换的 变量有啥应用场景
写程序对数据进行处理就很方便了 package com.liu.variable;public class VariableDemo1 {public static void main(String[] args) {//目标认识变量掌握使用变量的好处变量的特点应用场景// 1. 定义一个整型变量记住一个整数//数据类型 变量名 数据 // 注意在Java中是赋值的意思从右往左看//把18这个数据赋值给左边的变量age装起来int age 18;System.out.println(age);//2.记住一个人的成绩double score 99.5;System.out.println(score);System.out.println(-----------------------------------);//3. 使用变量的好处 便于扩展和维护int number 666;System.out.println(number);System.out.println(number);System.out.println(number);System.out.println(----------------------------------);//4.变量的特点里面装的数据可以被替换int age2 20;System.out.println(age2);age2 19; //赋值从右边往左边执行System.out.println(age2);age2 age2 1;System.out.println(age2);//5. 需求钱包有9.5元收到了10元红包有发出去了5元红包请输出各阶段钱包的情况double money 9.5;System.out.println(money);//收红包10元money money 10;System.out.println(money);//发出去5元money money - 5;System.out.println(money);}
}Java基础语法变量使用时的注意事项 使用变量时有哪些注意点
变量要先声明才能使用什么类型的变量只能存储什么类型的数据变量声明后不要存储其他类型数据变量存在访问范围同一个范围内多个变量的名字不能一样变量定义时可以不给赋初始值但是在使用时变量里必须有值变量的有效范围是从 定义 开始到 截止且在同一个范围内部不能定义个同名变量
package com.liu.variable;public class VariableDemo2 {public static void main(String[] args) {//目标搞清楚使用变量的几点注意事项//1. 变量要先声明才能使用int age 18;System.out.println(age);//2. 变量是什么类型就应该用来装什么类型的数据否则报错
// age 9.8;//3.变量是从定义开始到 “ } ” 截止的范围内有效且同一个范围内定义的多个变量它们的名称不能一样{int a 19;System.out.println(a);}
// System.out.println(a);System.out.println(age);//4. 变量定义的时候可以不赋初始值但在使用时变量里必须有值否则报错int number;number 500;System.out.println(number);}
}常见的 javac 标记 常见的 javac 标记
author指定Java程序的作者
version指定源文件的版本
deprecate不推荐使用方法
param方法的参数说明信息
return方法的返回值说明信息
see“参见”用于指定交叉参考的内容
exception抛出异常的类型
throws抛出的异常和exception同义 分隔符 Java语言里面的分号、花括号、方括号【】、圆括号、空格、圆点 都具有特殊的分隔作用因此被统称为分隔符。
分号
Java语言采用分号作为语句的分隔因此每个Java语句必须使用分号作为结尾。Java程序允许一行书写多个语句每个语句之间以分号隔开即可一个语句也可以跨多行只要在最后结束的地方使用分号结束即可。
花括号
花括号的作用就是定义一个代码块一个代码块指的就是 “” 和 “” 所包含的一段代码代码块在逻辑上是一个整体。对Java语言而言类定义部分必须放在一个代码块里方法体部分也必须放在一个代码块里。除此之外条件语句中的条件执行体和循环语句中的循环体通常也放在代码块了。
花括号一般是成对出现的有一个 “” 则必然有一个 “”反之亦然。
方括号
方括号的主要作用是用于访问数组元素方括号通常紧跟数组变量名而方括号里指定希望访问的数组元素的索引。
圆括号
圆括号是一个功能非常丰富的分隔符定义方法是必须使用圆括号来包含所有的形参声明调用方法时也必须使用圆括号来传入实参值不仅如此圆括号还可以将表达式中某个部分括成一个整体保证这个部分优先计算除此之外圆括号还可以作为强制类型转换的运算符。
空格
Java语言使用空格分隔一条语句的不同部分。Java 语言时一门格式自由语言所以空格几乎可以出现在Java程序的任何地方也可以出现任意多个空格但不要使用空格把一个变量名隔开成两个这将导致程序出错。
Java语言中的空格包含空格符Space、制表符Tab和回车Enter等。
除此之外Java源程序还会使用空格来合理缩进Java代码从而提高更好的可读性。
圆点
圆点通常作为类对象和它的成员包括成员变量、方法和内部类之间的分隔符表面调用某个类或某个实例的指定成员。 Java基础语法关键字、标识符 关键字
Java语言自己用到的一些词有特殊作用的我们称之为关键字如public、class、int、double...当定义标识符时不要让标识符和关键字相同否则将引起错误。即标识符不能用关键字命名。Java中的所有关键字都是小写的TRUE、FALSE、NULL都不是关键字。注意关键字是Java用了的我们就不能用来作为类名、变量名否则会报错和const 这两个关键字也被称为保留字。 标识符
标识符就是名字我们写程序时会起一些名字如类名、变量名等等都是标识符标识符就是用于给程序中的变量、类、方法命名的符号
标识符的要求
基本组成由数字、字母、下划线_)和美元符($)等组成强制要求不能意数字开头、不能用关键字和保留字作为名字但可以包含关键字和保留字、不能包含空格、且是区分大小写的只能包含美元符不能包含、等其他特殊字符。标识符必须以字母、下划线、美元符开头后面可以跟任意数目的字母、数字、下划线和美元符。此处的字母并不局限于个英文字母 而且可以包含中文字符、日文字符等。正确的命名 bj b2 $2 中国 _2b ak47 Class HelloWorld 错误的命名 2b class #liu
标识符的建议规范
变量名称满足标识符规则同时建议用英文、有意义、首字母小写满足“驼峰模式”例如int studyNumber 500 类名称满足标识符规则建议全英文、有意义、首字母大写满足“驼峰模式”例如Hello WorldStudent Java语法变量里的数据在计算机中的存储原理 数据在计算机底层都是怎么存储的
都是采用二进制使用0、1按照逢2进1的规则表示数据来存储。
如何快速的算出一个数据的二进制形式
除二取余法
二进制
只有0、1按照逢2进1的方式表示数据 十进制转二进制的算法
除二取余法 计算机中表示数据的最小单位
计算机表示数据的最小单元一个字节byte简称B是使用8个二进制位组成的8位一组字节中的每个二进制位就称为位bit简称b1B 8b Java语法字符图片声音的存储说明 字符在计算机中是如何存储的呢
ASCII编码表即美国信息交换标准码规定了现代英语、数字字符和其他西欧字符对应的数字编号。字符 A 对应的数字是65字符 a 对应的数字是97字符 0 对应的数字是48 package com.liu.variable;public class ASCIIDemo1 {public static void main(String[] args) {//目标掌握ASCII编码表的编码特点System.out.println(a10); //9710107System.out.println(A10); //651075System.out.println(010); //481058}
}图片和音频等文件的数据是怎么存储的啊
也是采用二进制进行存储的
图片数据 - 彩色图
图片就是无数个像素点组成的每个像素点的数据用0 ~ 255 * 255 * 255 表示其颜色 声音数据 Java语法二进制、八进制、十六进制 Java中整数值有4种表示方法十进制、二进制、八进制和十六进制其中二进制的整数以0b或0B开头八进制的整数以0开头十六进制的整数以0x或者0X开头其中10~15分别以a~f此处的a~f不区分大小写来表示。
在某些时候程序需要直接使用二进制整数二进制整数更“真实”更能表达整数在内存中的存在形式。不仅如此有些程序尤其在开发一些游戏时使用二进制整数会更便捷。
所有数字在计算机底层都是以二进制形式存在的原码是直接将一个数值转算成二进制数。但计算机以补码的形式保存所有的整数。补码的计算规则正数的补码和原码完全相同负数的补码是其反码加1反码是对原码按位取反只是最高位符号位保持不变。
十进制转二进制的算法
十进制数转二进制数除二取余法 二进制转十进制数
8421法 八进制、十六进制介绍
为了便于观察和表示二进制推出了八进制和十六进制。每3位二进制作为一个单元最小数是0最大数是7共8个数字这就是八进制421 每4位二进制作为一个单元最小数是0最大数是15共16个数字依次用0~9 ABCDEF 代表就是十六进制8421 注意Java程序中支持书写二进制、八进制、十六进制的数据分别需要以0B或者0b、0、0X或者0x开头。
package com.liu.variable;public class ASCIIDemo1 {public static void main(String[] args) {//二进制、八进制、十六进制在程序中的写法int a1 0B01100001;System.out.println(a1);int a2 0141; //0开头的数据当成八进制看待System.out.println(a2);int a3 0XFA;//0X开头的数据是十六进制System.out.println(a3);}
}计算机的数据单位
计算机表示数据的最小组成单元是字节1B 8b在B的基础上计算机发展出了KB、MB、GB、TB这些数据单位。1B81 KB 1024 B1MB 1024KBGB1024MBTB1024GB Java语法数据类型 数据类型的分类
基本数据类型Primitive Type引用数据类型Reference Type
基本数据类型
4大类种基本类型包括 boolean类型 和 数值类型数值类型包括 整数类型 和 浮点类型整数类型包括 byte、short 、int、long、char字符类型浮点类型包括 float、double byte一个byte类型整数在内存里占8位
short一个short类型整数在内存里占16位
int一个int类型整数在内存里占32位
long一个long类型整数在内存里占64位
int是最常用的整数类型因此在通常情况下直接给出一个整数值默认就是int类型。除此之外有如下两种情形必须指出1.如果直接将一个较小的整数值在byte或short类型的表数范围内赋给一个byte或short变量系统会自动把这个整数值当成byte或者short类型来处理。2. 如果使用一个巨大的整数值超出了int类型的表数范围时Java不会自动把这个数值当成long类型类处理。如果希望系统把一个整数值当成long类型来处理应在这个整数值后增加英文字母l或者L作为后缀。通常推荐使用L因为英文字母l很容易跟数字1混淆。
Java的浮点类型有两种float和double。Java的浮点类型有固定的表数范围和字段长度字段长度和表数范围与机器无关。Java的浮点数遵循IEEE 754标准采用二进制数据的科学计数法来表示浮点数对于float型数值第1位是符号位接下来8位表示指数再接下开的23位表示尾数对于double类型数值第1位也是符号位接下来的11位表示指数再接下的52位表示尾数。
double类型代表双精度浮点数float类型代表单精度浮点数。一个double类型的数值占8字节、64位一个float类型的数值占4字节 、32位。
Java语言的浮点类型默认是double类型如果希望Java把一个浮点类型值当成float类型处理应该在这个浮点类型值后紧跟f或F。例如5.12代表一个double类型的值占64位的内存空间5.12f或者5.12F才表示一个float类型的值占32位的内存空间。
布尔型只有一个boolean类型用于表示逻辑上的“真”或“假”。在Java语言中boolean类型的数值只能是true或false不能用0或者非0来代表。其他基本数据类型的值也不能转换成boolean类型。
Java规范并没有强制指定boolean类型的变量所占用的内存空间虽然boolean类型的变量或者值只要1位即可保存但由于大部分计算机在分配内存时允许分配的最小内存单元式字节8位因此bit大部分时候实际上占用8位。 package com.liu.variable;public class Variabledemo2 {public static void main(String[] args) {//掌握常见的基本数据类型的使用//1. byte short int longbyte a 127;//-128~127
// byte a2 128;//越界了short s 13244;
// short s1 93244; //越界了int i 422424;// 默认//注意随便写一个整型字面量默认是int类型的// 424242444444虽然没有超过long的范围但是超过了本身int类型的范围//如果希望随便写一个整型自变量默认是long类型的需要在后面加上L/l
// long lg 424242444444; 错误写法long lg 424242444444L;//2. float double//注意随便写个小数字面量默认是double如果希望小数是float后面加上F/ffloat f 3.14F;double d 56.45;//3. char 字符型char ch a;char ch2 中;//4. booleanboolean flag true;boolean flag2 false;//拓展一种引用数据类型后面要用//String 称之为字符串类型定义的变量可以用于记住一个字符串数据。String name 张三;System.out.println(name);}
}字符型
字符型通常用于表示单个的字符字符型值必须使用单引号‘括起来。Java语言使用16位的Unicode字符集作为编码方式而Unicode被设计成支持世界上所有书面语言的字符包括中文字符因此Java程序支持各种语言字符。
字符型值有如下三种表现形式1. 直接通过单个字符来指定字符型值例如’A‘、’9‘和’0‘等 2. 通过转义字符表示特殊字符型值例如’\n‘、\t等 3.直接使用Unicode值来表示字符型值格式是’\uXXXX‘,其中XXXX代表一个十六进制的整数。
\b 退格符
\n 换行符
\t 制表符
\“ 双引号
\ 单引号
\\ 反斜杠
char类型的变量、值完全可以参与加、减、乘、除等数学运算也可以比较大小——实际上都是用该字符对应的编码参与运算。
引用数据类型
StringJava没有提供表示字符串的基本数据类型而是通过String类来表示字符串由于字符串由多个字符组成因此字符串要使用双引号括起来。引用类型包括类、接口和数组类型还有一种特殊的null类型。所谓引用数据类型就是对一个对象的引用对象包括实例和数组两种。实际上引用类型变量就是一个指针只是Java语言里不再使用指针这个说法。空类型null type就是null值的类型这种类型没有名称。因为null类型没有名称所以不可能声明一个null类型的变量或者转换到null类型。空引用null就是null类型变量唯一的值。空引用null是null类型变量唯一的值。空引用null可以转换为任何引用类型。在实际开发中程序员可以忽略null类型假定null只是引用类型的一个特殊直接量。
随便写的整数、小数字面量他们默认什么类型
23默认是int类型加上就是long类型的数据了23.8默认是double类型加上就是float类型了 Java语法自动类型转换 什么是自动类型转换为什么要进行自动类型转换
类型范围小的变量可以直接赋值给类型范围大的变量。 byte ----int 存在不同类型的变量赋值给其他类型的变量
自动类型转换在计算机的执行原理 自动类型转换的其他形式 package com.liu.type;public class TypeConversionDemo1 {public static void main(String[] args) {//目标理解自动类型转换机制byte a 12;int b a;//发生了自动类型转换System.out.println(a);System.out.println(b);int c 100;double d c;//发生了自动类型转换System.out.println(d);char ch a;//a97 --- 00000000 01100001int i ch;//发生了自动类型转换 00000000 00000000 00000000 01100001}
}Java语法表达式的自动类型转换 表达式的自动类型转换
在表达式中小范围类型的变量会自动转换成表达式中较大范围的类型再参与运算。 注意事项
表达式的最终结果类型由表达式中的最高类型决定。在表达式中byte、short、char是直接转换成int类型参与运算的。
package com.liu.type;public class TypeConversionDemo2 {public static void main(String[] args) {//目标掌握表达式的自动类型转换规则byte a 10;int b 20;int c 30;long rs a b c ;System.out.println(rs);double rs2 a b 1.0;System.out.println(rs2);byte i 10;short j 30;int rs3 i j;System.out.println(rs3);//面试笔试题byte b1 110;byte b2 80;int b3 b1 b2 ;System.out.println(b3);}
}Java语法强制类型转换 默认情况下强制类型转换
类型范围大的数据或者变量直接赋值给类型范围小的变量会报错。 强制类型转换
强行将其类型范围大的变量、数据赋值给类型范围小的变量数据类型 变量2 数据类型变量1、数据
强制类型转换在计算机中的执行原理 注意事项
强制类型转换可能造成数据丢失溢出浮点型强转成整型直接丢掉小数部分保留整数部分返回 package com.liu.type;public class TypeConversionDemo3 {public static void main(String[] args) {//目标掌握强制类型转换int a 20;byte b (byte) a;//alt 回车键System.out.println(a);System.out.println(b);int i 1500;byte j (byte) i;System.out.println(j);double d 99.5;int n (int) d; //强制类型转换System.out.println(n); //丢掉小数部分保留整数部分}
}Java语法算术运算符、符号做连接符 基本的算术运算符 “ ” 符号可以做连接符的
“ ” 符号与字符串运算的时候是用作连接符的其结果依然是一个字符串 独门秘籍
能算则算不能算就在一起。计算机很聪明
package com.liu.operator;public class OperatorDemo {public static void main(String[] args) {//目标掌握基本的算术运算符的使用int a 10;int b 2;System.out.println(a b);System.out.println(a - b);System.out.println(a * b);System.out.println(a / b);System.out.println(5 / 2);//2.5 ---2System.out.println(5.0 / 2);//2.5int i 5;int j 2;System.out.println(i / j);//2System.out.println(1.0 * i / j);//2.5System.out.println(a % b);//0System.out.println(3 % 2);//1System.out.println(------------------------------------);//目标掌握使用符号做连接符的情况int a2 5;System.out.println(abc a2);//abc5System.out.println(a2 5);//10System.out.println(liu a2 a);//liu5aSystem.out.println(a2 a liu);//597102 //102liu}
}算术运算符有哪些 - * / %
/ 需要注意什么为什么
如果两个整数做除法其结果一定是整数因为最高类型是整数 除了做基本数学运算还有哪些功能
与字符串运算时会当成连接符其结果还是字符串识别技巧能算则算不能算就在一起。计算机很聪明 Java语法自增、自减运算符 自增自减运算符 注意 -- 只能操作变量不能操作字面量。
自增自减的使用注意事项 、-- 如果不是单独使用如在表达式中或者同时有其他操作放在变量前后会存在明显的区别
放在变量的前面先对变量进行1、-1再拿变量的值进行运算放在变量的后面先拿变量的值进行运算再对变量的值进行1、-1 package com.liu.operator;public class OperatorDemo2 {public static void main(String[] args) {//目标掌握自增自减运算符的使用int a 10;a ; //a a 1System.out.println(a);a--;System.out.println(a);//a11-1//自增自减只能操作变量不能操作字面量。
// 2;
// System.out.println(2);System.out.println(---------------------------------------------);int i 10;int rs i;//先加后用System.out.println(rs);System.out.println(i);int j 10;int rs2 j;//先用后加System.out.println(rs2);System.out.println(j);}
}Java语法自增自减拓展案例 package com.liu.operator;public class OperatorDemo2 {public static void main(String[] args) {
//拓展int m 5;int n 3;int result m - --m m-- - n n-- 3;//m6 m6//--m5 m5//m--5 m4//n4 n4//n--4 n3//6-55-4439System.out.println(result); //9System.out.println(m); //4System.out.println(n); //3}
}java语法赋值运算符 基本赋值运算符
就是 “ ”从右边往左边看int a 10 ; //先看 “ 右边把数据10赋值给左边的变量a存储
扩展赋值运算符 注意
扩展的赋值运算符隐含了强制类型转换。 可以实现数据的累加把别人的数据加给自己。
package com.liu.operator;public class OperatorDemo3 {public static void main(String[] args) {//目标掌握扩展赋值运算符的使用// // 需求收红包double a 9.5;double b 520;//a (double)(a b);a b;System.out.println(a);//需求发红包double i 600;double j 520;//i (double)(i - j);i - j;System.out.println(i);int m 10;int n 10;m * n; //等价形式 m (int)(m*n)System.out.println(m);m / n; //等价形式 m (int)(m/n)System.out.println(m);m % n; //等价形式 m (int)(m%n)System.out.println(m);System.out.println(-------------);byte x 10;byte y 30;//x x y;//编译报错
// x (byte) (xy); 正确代码x y; //等价形式 x (byte) (xy);System.out.println(x);}
}Java语法关系运算符 关系运算符 判断数据是否满足条件最终会返回一个判断的结果这个结果是布尔类型的值true 或者 false。
注意
在Java中判断是否相等一定是 ” “ 千万不要把 ” “ 误写成 ” “
package com.liu.operator;public class OperatorDemo4 {public static void main(String[] args) {//目标掌握关系运算符的基本使用int a 10;int b 5;boolean rs a b ;System.out.println(rs);System.out.println(a b);//要么a大于b,要么abSystem.out.println(2 2);//trueSystem.out.println(a b);System.out.println(a b);//falseSystem.out.println(2 2);//trueSystem.out.println(a b);//falseSystem.out.println(5 5);//trueSystem.out.println(a b );//5 //注意了 判断是否相等一定用是用来赋值的System.out.println(a ! b);//trueSystem.out.println(10!10);//false}
}Java语法逻辑运算符 逻辑运算符
把多个条件放在一起运算最终返回布尔类型的值true、false. 注意
在Java中” “、” | “无论左边是 false 还是 true右边都要执行。由于 、|| 运算效率更高、在开发过程中用的更多 package com.liu.operator;public class OperatorDemo5 {public static void main(String[] args) {//目标掌握逻辑运算符的使用//需求:要求手机必须满足尺寸大于等于6.95且内存必须大于等于8double size 6.8;int storage 16;//1. 前后的条件的结果必须都是true结果才是trueboolean rs size 6.95 storage 8;System.out.println(rs);//false//需求:要求手机要么满足尺寸大于等于6.95要么内存必须大于等于8//2. | 只要多个条件中有一个是true结果就是trueboolean rs2 size 6.95 | storage 8;System.out.println(rs2);//true// 3. ! 取反的意思System.out.println(!true); //falseSystem.out.println(!false); //trueSystem.out.println(!(21)); //false//4. ^ 前后的条件结果相同时返回false,不同时返回trueSystem.out.println(true ^ true);//falseSystem.out.println(false ^ false);//falseSystem.out.println(true ^ false);//trueSystem.out.println(false ^ true);//true//5. 左边为false,右边不执行int i 10;int j 20;System.out.println( i 100 j 99);System.out.println(j);//6. || 左边为true右边就不执行int m 10;int n 30;System.out.println(m 3 || n 40);System.out.println(n);}
}Java语法三元运算符、运算符优先级 三元运算符介绍
格式条件表达式 值1 值2 执行流程首先计算关系表达式的值如果值为true返回值1如果为false返回值2
运算符优先级
在表示式中哪个运算符先执行后执行是要看优先级的例如 ” *、/ “ 的优先级高于 ” 、- “ package com.liu.operator;public class OperatorDemo6 {public static void main(String[] args) {//目标掌握三元运算符的基本使用double score 98.5;String rs score 60 ? 成绩及格:成绩不及格;System.out.println(rs);//需求找出2个整数中的较大值并输出int a 99;int b 67;int max a b ? a : b;System.out.println(max);//需求:找3个整数中的较大值int i 10;int j 45;int k 34;//找到2个整数中的最大值int temp i j ? i :j;//找出temp与k中的较大值int max2 temp k ? temp : k;System.out.println(max2);//45System.out.println(---------------------------------------);System.out.println(10 3 || 103 103);//trueSystem.out.println((10 3 || 103) 103);//false}
}Java语法API介绍、Scanner录入用户键盘输入的数据 需求
请在程序中提示用户通过键盘输入自己的姓名、年龄并能在程序中收到这些数据怎么解觉答Java已经写好了实现程序我们调用即可 APIApplication Programming Interface应用程序编程接口
Java写好的程序咱们程序员可以直接拿来调用。Java为自己写好的程序提供了相应的程序使用说明书API文档。
API文档在哪可以找到
打开百度 输入Oracle官网找到products 点击找到Java 点击点击 Download Java点击 JDK17点击 Documentation Download 文档下载找到Download 有个jdk版本文档的下载链接 点击下载同意勾选 点击下载 为什么要需学习查看API文档的方法
API是Java提供的基本编程接口当使用Java语言进行编程时不可能把所有的Java类、所有方法全部记下来当编程遇到一个不确定的地方时必须通过API文档来查看某个类、某个方法的功能和用法。因此掌握查看API文档的方法时学习Java的一个最基本的技能。读者可以尝试查阅API文档的String类来掌握String类的用法。 使用Scanner接收用户键盘输入的数据需要三个步骤
导包告诉程序去JDK的那个包中找扫描器技术抄代码代表得到键盘扫描器对象东西抄代码等待接收用户输入数据
注意
System、String在JDK中的 java.lang 包下。lang包不需要我们导包是默认的包。
package com.liu.scanner;
import java.util.Scanner;
public class ScannerDemo1 {public static void main(String[] args) {//1. 导包:一般不需要我们自己做idea工具会自动帮助我们导包的//2. 抄写代码得到一个键盘扫描器对象东西Scanner sc new Scanner(System.in);//3. 开始调用sc的功能来接收用户键盘输入的数据System.out.println(请您输入您的年龄);int age sc.nextInt();//执行到这会开始等待用户输入一个整数直到用户按下回车键才会拿到数据。System.out.println(您的年龄是 age);System.out.println(请输入您的名字);String name sc.next();//执行到这会开始等待用户输入一个字符串直到用户按下回车键才会拿到数据。System.out.println(name 欢迎您进入系统~~~);}
}阶段总结类型转换、运算符、案例知识(键盘录入技术) 类型转换
原因开发中会存在不同类型的变量或者数据赋值给其他类型的变量也存在不同类型的数据一起运算其结果类型要确定下来。自动类型转换的原理小范围类型的变量可以直接赋值给大范围类型的变量。自动类型转换的范围信息自动类型转换的形式byte a 20 ; int b a ;自动类型转换注意char ch a ; int code ch (注意这种形式是可以的)表达式的自动类型转 含义在表示式中小范围类型的变量会自动提升成大范围运算表达式的自动类型转换 结论表达式的最终结果数据类型是由表达式中的最高数据类型决定的最高数类型是什么其结果数据类型就是什么表达式的自动类型转换 注意byte 、short、char在表达式中是直接提升成 int 运算的表达式的自动类型转换 面试笔试强制类型转换 含义大范围类型的变量或者数据不能直接赋值给小范围类型的变量否则报错必须进行强制类型转换才可以。强制类型转换 格式数据类型 变量 数据类型其他类型的变量/数据强制类型转换 注意强制类型转换可能出现数据丢失int a 1500byte b (byte) a;强制类型转换 注意浮点类型的变量或者数据强制转换成整型保留整数部分返回的小数部分直接不要了 double a 99.5 ; int i (int) a ; // i 99
运算符基本运算符、自增自减、赋值、关系、逻辑
基本算术运算符 常见的: - * / %基本运算符 注意 / 两个整数相除的结果一定是整数 例10/33 1.0*10/33.333...符号做连接符 场景符号与字符一起运算时充当连接符连接后的结果还是一个字符串。符号做连接符 识别技巧能算则算不能算大家连在一起。自增自减运算符对变量进行1操作 --对变量进行-1操作。自增自减运算符 注意事项只能操作变量不能操作字面量。例如a//没毛病的 2//没有这种形式报错 --单独使用放在变量前后没有区别 例如aa --如果不是单独使用放在变量前后有明显区别在变量前面先1-1再使用变量在变量后面先使用变量再对变量1 -1赋值运算符 - * / , %赋值运算符的应用a b;等价于 aa的类型)ab赋值运算符的用处适合做数据的累加操作 int a 10 int b 5a b 自带强制转换 byte b1 2byte b2 3byte b3 byteb1b2----b1 b 关系运算符 ! 关系运算符 判断是否满足条件返回true 和 false 例如int age 19System.out.println(age 18);等价于 boolean rs age 18; System.out.println(rs);逻辑运算符 | || ^逻辑运算符 与逻辑与)且的意思必须前后都是true结果才是true 短路与且的意思必须前后都是true结果才是true与 的区别如果发现前面是false后面不执行直接返回结果性能较好用的更多。逻辑运算符 或 |逻辑或或的意思只要前后有一个true结果就一定是true||短路与或的意思只要前后有一个true结果就一定是true|逻辑或和 ||短路与的区别||如果发现前面是true后面不执行直接返回结果性能较好一点用的更多一点。逻辑运算符 取反 取反false true true false逻辑运算符 异或 ^(异或) 前后一样返回false前后不一样返回true
运算符三元运算符
三元运算符是做分支选择的关键是格式条件表达式值1 值2
运算符运算符优先级
运算符存在谁先谁后执行的情况优先级最高 * / 高于 - 优先级高于 ||
案例知识键盘录入技术
Java自己提供好的程序给程序员调用的API文档应用程序编程接口技术说明书告诉我们该怎么使用Java程序键盘录入技术1、导包自动导import java.util.Scanner。(2)、创建一个扫描器对象Scanner sc new Scanner(System.in); (3)、等待接收用户的数据int age src.nextInt(); (4)、等待接收用的数据String name sc.next(); 流程控制分支结构if、switch、switch穿透性 Java提供了两种常见的分支控制结构if语句和switch语句其中if语句使用布尔表达式或布尔值作为分支条件来进行分支控制而switch语句则用于对多个整型值进行匹配从而实现分支控制。 if分支
根据条件真或假来决定执行某段代码
if分支有三种形式 放在if之后括号里的只能是一个逻辑表达式即这个表达式的返回值只能是
true或者false。
后面的花括号括起来的多行代码被称为代码块一个代码块通常被当成一个整体来执行除非运行过程中遇到return、break、continue等关键字或者遇到了异常因此这个代码块也被称为条件执行体。
如果if、else if和else后的代码块只有一行语句时则可以省略花括号因为单行语句本身就是一个整体无须用花括号来把它们定义成一个整体。
对于任何的 if else语句表面上看起来else后没有任何条件或者else if后只有一个条件——但这不是真相因为else的含义是“否则”——else本身就是一个条件这也是把if、else后代码块统称为条件执行体的原因else的隐含条件是对前面条件取反 。 package com.liu.branch;public class IfDemo1 {public static void main(String[] args) {//目标需要掌握if分支三种形式的用法和执行流程//需求1测量用户体温发现体温高于37度就报警double t 36.9;if (t37){System.out.println(这个人的温度异常把他赶紧带着~);}//需求2 发红包你的钱包余额是99元现在要发出90元//如果钱够触发发红包的动作如果钱不够提升余额不足double money 99;if (money90){System.out.println(发红包成功了~);}else {System.out.println(余额不足~);}//需求3某个公司有一个绩效系统根据员工的打分输出对应的绩效级别// 【060)D【6080)C【8090)B【90100】Aint score 78;if (score 0 score 60){System.out.println(您的绩效级别是D);}else if(score 60 score 80){System.out.println(您的绩效级别是c);}else if(score 80 score 90){System.out.println(您的绩效级别是B);}else if(score 90 score 100){System.out.println(您的绩效级别是A);}else {System.out.println(您录入的分数有毛病~);}}
}if的第一种形式 if的第二种形式 if的第三种形式 if使用的几个常见问题
if条件{} 后不跟 “” 否则{}种的代码将不受if控制了如果if语句的{}中只有一行代码的情况{}可以省略不写但是不推荐省略。
switch分支
是通过比较值来决定执行哪条分支。 switch语句由一个控制表达式和多个case标签组成和if语句不同的是switch语句后面的控制表达式的数据类型只能是byte、short、chat、int四种整数类型枚举类型和java.lang.String类型从Java7才允许不能是boolean类型。
switch语句往往需要在case标签后紧跟一个代码块case标签作为这个代码块的标识 switch分支的执行流程
先执行表达式的值再拿着这个值去与case后的值进行匹配与哪个case后的值匹配为true就执行哪个case块的代码遇到break就跳出switch分支如果全部case后的值与之匹配都是false则执行default块的代码。
switch分支的导学案例电子备忘录 周一埋头苦干解决bug周二、请求大牛程序员帮忙周三今晚啤酒 、龙虾、小烧烤
周四:主动帮助新来的女程序解决bug周五今晚吃鸡周六与王婆介绍的小芳相亲
周日郁郁寡欢、准备上班
package com.liu.branch;public class SwitchDemo2 {public static void main(String[] args) {//目标掌握switch的写法理解其执行流程//switch分支的导学案例电子备忘录//周一埋头苦干解决bug周二、请求大牛程序员帮忙周三今晚啤酒 、龙虾、小烧烤//周四:主动帮助新来的女程序解决bug周五今晚吃鸡周六与王婆介绍的小芳相亲//周日郁郁寡欢、准备上班String week 周三;switch (week){case 周一:System.out.println(埋头苦干解决bug);break;case 周二:System.out.println(请求大牛程序员帮忙);break;case 周三:System.out.println(今晚啤酒 、龙虾、小烧烤);break;case 周四:System.out.println(主动帮助新来的女程序解决bug);break;case 周五:System.out.println(今晚吃鸡烤);break;case 周六:System.out.println(与王婆介绍的小芳相亲);break;case 周日:System.out.println(郁郁寡欢、准备上班);break;default:System.out.println(您输入的星期信息肯定是不存在的~);}}
}if、switch的比较以及各自适合什么业务场景
if在功能上远远强大于switch当前条件是与一个一个值比较的时候应该使用if分支当条件是与一个一个的值比较的时候switch分支更适合格式良好性能较好代码优雅 使用switch分支的几点注意事项
表达式类型只能是byte、short、int、charJDK5开始支持枚举JDK7开始支持String不支持double、float、longcase给出的值不允许重复且只能是字面量不能是变量正常使用switch的时候不要忘记写break否则会出现穿透现象
package com.liu.branch;public class SwitchDemo3 {public static void main(String[] args) {//目标搞清楚switch使用时的几点注意事项//1. 表达式类型只能是byte、short、int、charJDK5开始支持枚举JDK7开始支持String不支持double、float、longint a 10;double b 0.1;double b2 0.2;double c bb2;System.out.println(c);switch (a){}//2、case给出的值不允许重复且只能是字面量不能是变量int i 20;switch (i){case 20:break;
// case 20:
// break;}//3、正常使用switch的时候不要忘记写break否则会出现穿透现象String week 周三;switch (week){case 周一:System.out.println(埋头苦干解决bug);break;case 周二:System.out.println(请求大牛程序员帮忙);//break;case 周三:System.out.println(今晚啤酒 、龙虾、小烧烤);//break;case 周四:System.out.println(主动帮助新来的女程序解决bug);break;case 周五:System.out.println(今晚吃鸡烤);break;case 周六:System.out.println(与王婆介绍的小芳相亲);break;case 周日:System.out.println(郁郁寡欢、准备上班);break;default:System.out.println(您输入的星期信息肯定是不存在的~);}}
}switch穿透性在某些情况下可以简化代码
当存在多个case分支的代码相同时可以把相同的代码放到一个case块中其他的case块都通过穿透性穿透到该case块执行代码即可这样可以简化代码。案例周一埋头苦干解决bug 周二请求大牛程序员帮忙 周三请求大牛程序员帮忙 周四请求大牛程序员帮忙 周五自己整理代码周六打游戏周日打游戏
package com.liu.branch;public class SwitchDemo4 {public static void main(String[] args) {//案例周一埋头苦干解决bug // 周二请求大牛程序员帮忙 周三请求大牛程序员帮忙 周四请求大牛程序员帮忙 // 周五自己整理代码// 周六打游戏周日打游戏String week 周三;switch (week){case 周一:System.out.println(埋头苦干解决bug);break;case 周二:case 周三:case 周四:System.out.println(请求大牛程序员帮忙);break;case 周五:System.out.println(自己解决代码);break;case 周六:case 周日:System.out.println(打游戏);break;default:System.out.println(您输入的星期信息肯定是不存在的~);}}
}流程控制循环结构for循环、for循环案例 for循环
控制循环格式
for循环格式 执行流程 package com.liu.loop;public class ForDemo1 {public static void main(String[] args) {//目标需要同学们掌握for循环的书写格式并理解其执行流程//需求打印三行Hello World/*流程 首先会执行初始化int i 0 ;i 0,判断循环条件 03,返回true计算机会进入到循环中执行输出第一行 Hello World接着执行迭代语句i i 1,判断循环条件 13,返回true计算机会进入到循环中执行输出第一行 Hello World接着执行迭代语句i i 2,判断循环条件 23,返回true计算机会进入到循环中执行输出第一行 Hello World接着执行迭代语句i i 3,判断循环条件 33,不成立返回false循环立即结束。*/for (int i 0;i3;i) {// i 0 1 2System.out.println(Hello World);}System.out.println(----------------------------------------);for (int i 1; i 5;i){//i 1 2 3 4 5System.out.println(Hello World 2);}System.out.println(----------------------------------------);for (int i 1;i 10;i 2){//1 3 5 7 9System.out.println(Hello World 3);}}
}for循环在开发中的常见应用场景
减少代码的重复编写、灵活的控制程序的执行批量生成数据
package com.liu.loop;public class ForDemo2 {public static void main(String[] args) {//目标掌握使用for批量产生数据for (int i 0; i 100; i) {System.out.println(i);}System.out.println(--------------------------);//需求1-5之和// 2. 定义一个变量用于求和int sum1 0; //0 1 3 6 10 15//1.定义一个循环先产生1-5这5个数for (int i 1; i 5; i) {// i 1 2 3 4 5sum1 i; //等价 sum sum i;}System.out.println(1-5的数据和 sum1);System.out.println(-------------------------------------);//需求1-100之和// 2. 定义一个变量用于求和int sum2 0;//1.定义一个循环先产生1-5这5个数for (int i 1; i 100; i) {sum2 i; //等价 sum sum i;}System.out.println(1-100的数据和 sum2);System.out.println(----------------------------------);//2. 定义一个变量用于求和int sum3 0;//1. 定义一个循环产生1-100之间的奇数for (int i 1;i 100;i2){// i 1 3 5 7 ...sum3 i;}System.out.println(1-100之间的奇数和sum3);System.out.println(-------------------------------------);//2.定义一个变量用于累加数求和int sum4 0;//1. 定义一个循环产生1-100之间的每个奇数for (int i 1;i100;i){//i 1 2 3 4 5 6 ... 99 100//2. 使用一个if分支判断i此时记住的数据是否是奇数是奇数我们才累加给一个变量if (i % 2 1){//1 3 5 7 9 ...99sum4 i;}}System.out.println(1-100之间的奇数和sum4);}} 流程控制循环结构while循环、珠穆朗玛峰 while循环 package com.liu.loop;public class WhileDemo3 {public static void main(String[] args) {//目标掌握while循环的书写格式以及理解其执行流程//需求打印多行Hello Worldint i 0;while (i 5){// i 0 1 2 3 4System.out.println(Hello World);i ;}}
}while和for有什么区别什么时候用for什么时候用while
功能上是完全一样的for能解决的while也能解决反正亦然。使用规范知道循环几次建议使用for不知道循环几次建议使用while
案例珠穆朗玛峰
需求世界最高山峰珠穆朗玛峰高度是8848.86米8848860毫米假如我有一张足够大的纸它的厚度是0.1毫米。请问该纸张折多少次可以折成珠穆朗玛峰的高度
一开始不知道要循环多少次则使用while
分析1定义变量存储珠穆朗玛峰的高度、纸张的高度 2 使用while循环来控制纸张折叠循环条件是纸张厚度山峰高度3循环每执行一次就表示纸张折叠一次并把纸张厚度变为原来两倍4 循环外定义计数变量count循环每折叠一次纸张让count变量 1。
package com.liu.loop;public class WhileText4 {public static void main(String[] args) {//目标使用while循环解决问题并理解什么情况下使用while、for//1.定义一个变量记住珠穆朗玛峰的高度和纸张的高度double peakHeight 8848860;double paperThickness 0.1;//3. 定义一个变量count 用于记住纸张折叠了多少次int count 0;//2. 定义while循环控制纸张开始折叠while (paperThicknesspeakHeight){//把纸张进行折叠把纸张的厚度变为原来的2倍paperThickness paperThickness * 2;count ;}System.out.println(需要折叠多少次 count);System.out.println(最终纸张的厚度是 paperThickness);}
}package com.liu.loop;public class WhileText4 {public static void main(String[] args) {//目标使用while循环解决问题并理解什么情况下使用while、for//1.定义一个变量记住珠穆朗玛峰的高度和纸张的高度double peakHeight 8848860;double paperThickness 0.1;//3. 定义一个变量count 用于记住纸张折叠了多少次int count 0;//2. 定义while循环控制纸张开始折叠for (;paperThicknesspeakHeight;count ){//把纸张进行折叠把纸张的厚度变为原来的2倍paperThickness paperThickness * 2;}System.out.println(需要折叠多少次 count);System.out.println(最终纸张的厚度是 paperThickness);}
}流程控制循环结构do-while do-while循环 package com.liu.loop;public class DoWhileDemo5 {public static void main(String[] args) {//目标掌握do-while循环的书写格式执行流程特点和应用场景//需求打印多行Hello Worldint i 0;do {System.out.println(Heool World);i ;}while (i 3 );System.out.println(-----------------------------------);//特点先执行后判断do {System.out.println(Hello World 2);}while (false);}
}do-while循环的特点
先执行后判断 三种循环的区别小结 三种循环区别
for循环和while循环先判断后执行)do...while先执行后判断for循环和while循环的执行流程是一模一样的功能上无区别for能做的 while也能做反之亦然。使用规范如果已知循环次数建议使用for循环如果不清楚要循环多少次建议使用while循环。其他区别for循环中控制循环的变量只在循环中使用。while循环中控制循环的变量在循环后还可以继续使用。
package com.liu.loop;public class DoWhileDemo5 {public static void main(String[] args) {System.out.println(----------------------------------------);for (int j 0; j3 ; j){System.out.println(Hello World3);}
// System.out.println(j); j变量只能在循环内使用int m 0;while (m3){System.out.println(Hello World);m;}//m变量在循环后还可以继续使用System.out.println(m);//3}
}流程控制死循环循环嵌套 死循环
可以一种执行下去的一种循环如果没有干预不会停下来
死循环的写法 package com.liu.loop;public class EndLessLoopDemon6 {public static void main(String[] args) {//目标掌握死循环的写法//1.死循环第一种
// for (int i 0; ;i){
// System.out.println(Hello World);
// }// //2.死循环第二种
// while (true){
// System.out.println(Hello World 2);
// }//3.死循环第三种do{System.out.println(Hello World 3);}while (true);}
}
死循环的应用场景
做服务器程序 循环嵌套 循环嵌套
循环中又包含循环如果把一个循环放在另一个循环体内那么就可以形成嵌套循环嵌套混混既可以是for循环嵌套while循环也可以是while循环嵌套do while循环········即各种类型的循环都可以作为外层循环也可以作为内层循环。当程序遇到嵌套循环时如果外层循环的循环条件被允许则开始执行外层循环的循环体而内层循环将被外层循环的循环体来执行——只是内层循环需要反复执行自己的循环体而已。当内层循环的执行结束且外层循环的循环体执行结束时则再次计算外层循环的循环条件决定是否再次开始执行外层循环的循环体。 package com.liu.loop;public class LoopNestedDemo7 {public static void main(String[] args) {//目标循环嵌套的执行流程//场景假如你有对象你犯错了你对象罚你说3天每天五句我爱你//方法一
// for (int i 1;i3;i ){
// // i 1 2 3
// System.out.println(我爱你 i);
// System.out.println(我爱你 i);
// System.out.println(我爱你 i);
// System.out.println(我爱你 i);
// System.out.println(我爱你 i);
// System.out.println(--------------------------------);
//
// }//方法二for (int i 1;i3;i ){// i 1 2 3for (int j 1;j5;j){System.out.println(我爱你 i);}System.out.println(我爱你 i);System.out.println(--------------------------------);}// 打印三行 ****//方法一for (int i 1;i 3;i){// i 1 2 3System.out.println(****);}System.out.println(--------------------------------);// 打印三行 ****//方法二for (int i 1;i 3;i){// i 1 2 3//定义一个循环控制每行打印多少列*for (int j 1;j4;j) {System.out.print(*); // print 不换行}System.out.println();//换行}}}循环嵌套的特点
外部循环每循环一次内部循环会全部执行完一轮。 跳转关键字break、contine Java语言没有提供goto语句来控制程序的跳转这种做法提高了程序流程控制的可读性但降低了程序流程控制的灵活性。为了弥补这种不足Java提供了contine和break来控制循环结构。除此之外return可以结束整个方法当然也就结束了一次循环。
跳转关键字
break跳出并结束当前所在循环的执行。continue用于跳出当前循环的当次执行直接进入循环的下一次执行。
注意事项
break只能用于结束所在循环或者结束所在switch分支的执行。continue只能在循环中进行使用。
package com.liu.loop;public class BreakAndContinueDemo8 {public static void main(String[] args) {//目标掌握break和continue的作用//1. break :跳出并结束当前所在循环的执行//场景假如你又有对象了你犯错了你对象罚你说5句我爱你//说到第三句的时候心软了让你别再说了。for (int i 1;i5;i){System.out.println(我爱你i);if (i3){//说明已经说完了第三句了心软了。break;//跳出并结束当前所在循环的执行}}//2、continue跳出当前循环的当次执行直接进入循环的下一次执行//场景假如你有对象你犯错了你对象罚你洗碗5天。//第三天的时候你表现很好第三天不用洗碗但是很快不解第四天还是要继续的for (int i 1;i5;i){if(i3){//已经到了第三天第三天不用洗的。continue;}System.out.println(洗碗i);}}
}break用于完全结束一个循环跳出循环体不管事哪种循环一旦在循环体中遇到break系统将完全结束该循环开始执行循环之后的代码。break语句不仅可以结束其所在的循环还可以直接结束其外层循环。continue只是忽略本次循环剩下语句接着开始下一次循环并不会终止循环。break则是完全终止循环本身。 流程控制随机数Random、Random案例 Random
作用生成随机数
得到0~9的随机数的实现步骤 注意
nextIntn 功能 只能生成0 至 n-1 之间的随机数不包含n。 package com.liu.random;import java.util.Random;public class RandomDemo1 {public static void main(String[] args) {//目标掌握使用random生成随机数的步骤//1、导包//2、创建一个random的对象用于生成一个随机数Random r new Random();//3、调用Random提供的功能nextInt得到随机数for (int i 1;i20;i) {int data r.nextInt(10);//0~9System.out.println(data);}}
}Random生成指定区间随机数
例如要生成 1-10 之间的随机数程序怎么实现
技巧减加法 System.out.println(-----------------------------------------);//生成 1-10 之间的随机数// 1-10 》 -1 》 0-91for (int i 1;i20;i) {int data2 r.nextInt(10);System.out.println(data2);}System.out.println(--------------------------------------);// 3-17 》 -3 》0-143for (int i 1;i20;i) {int data3 r.nextInt(15)3;System.out.println(data3);} 如何生成 65 - 91 之间的随机数
65 - 91 》 -65 》 0 - 2665int number r . nextInt(27) 65 ;
猜数字游戏
需求随机生成一个 1- 100 之间的数据提示用户猜测猜大提示过大猜小提示过小直到猜中结束游戏。分析 1、先随机生成一个 1- 100 之间的数据 。2、定义一个死循环让用户可以一直猜测。 3、在死循环里每次都提示用户输入一个猜测的数字猜大提示过大猜小提示过小猜中则结束游戏。
package com.liu.random;import java.util.Random;
import java.util.Scanner;public class RandomTest2 {public static void main(String[] args) {//1、随机产生一个 1- 100 之间的数据作为中将号码Random r new Random();int luckNumber r.nextInt(100)1;//2、定义一个死循环让用户不断的猜测数据Scanner sc new Scanner(System.in);while (true){//提示用户猜测System.out.println(请您输入猜测的数据);int guestNumber sc.nextInt();//3、判断用户猜测的数字与幸运号码的大小情况if (guestNumber luckNumber){System.out.println(您猜测的数字过大);}else if (guestNumberluckNumber){System.out.println(您猜测的数字过小~);}else {System.out.println(恭喜您猜测成功了可以买单了);break;//结束死循环}}}
}阶段总结分支结构、循环结构、跳转关键字break和continue、随机数Random 程序流程控制
就是控制代码怎么去执行的。三种结构顺序结构、分支结构、循环结构分支结构if、switch
分支结构
if 的作用可以判断条件来决定执行哪个分支if 的格式switch 作用根据表达式的值来进行值匹配选择对应的分支执行switch 格式if 和 switch 的区别都是做分支操作的if的功能更强大如果是值匹配的操作建议用switch格式清晰性能较好switch 的注意事项表达式类型只能是byte、short、int、charJDK5开始支持枚举JDK7开始支持String不支持double、float、long case给出的值不允许重复且只能是字面量不能是变量 正常使用switch的时候不要忘记写break否则会出现穿透现象switch的穿透性的含义switch中没有写break遇到了case会一直往下走直到遇到break才会跳出。switch的穿透性适合做多个值对应的case块的操作是相同的可以穿透到一个位置集中处理这样可以提高开发效率降低代码重复
循环结构
循环结构的作用控制一段代码重复的执行多次for循环格式while循环格式do—while循环格式do—while突出特点一定会执行一次循环体语句再判断循环条件循环结构的区别for和while都是先判断后执行do—while第一次是先执行然后再判断for和while在功能上完全一样流程也是一样的如果一开始就知道循环几次用for如果一开始不知道循环用几次用while。死循环是一直执行下去死循环的写法
跳转关键字break和continue
break跳出并结束当前所在循环的执行。continue用于跳出当前循环的当次执行直接进入循环的下一次执行。break只能用于结束所在循环或者结束所在switch分支的执行。continue只能在循环中进行使用。
案例技术随机数Random类
作用产生一个随机数步骤导包自动做的import java.until.Random创建随机数对象Random r new Random 开始得到随机数int data r.nextInt()//0-9生产指定区间的随机数(1)、减加发1-10 》-1 》0-91 int data r.nextInt(10)1; 2、Java其实给了我们一些功能直接就能得到指定区间的随机数Random r new Random//10-30 forint i 0i100i{int data r.nextInt(10,31)System.out.println(data)} 认识数组 数组是什么
数组就是一个容器用来存储一批同类型的数据。
数组是编程语言中最常见的一种数据结构可用于存储多个数据每个数组元素存放一个数据通常可通过数组元素的索引来访问数组元素包括为数组元素赋值和取出素组元素得值。Java语言的数组则是具有其特有的特征。
Java的数组要求所有的数组元素具有相同的数据类型。因此在一个数组中数组元素的类型是唯一的即一个数组里只能存储一种数组类型的数据而不能存储多种数据类型的数据。 一旦数组的初始化完成数组在内存中所占的空间将被固定下来因此数组的长度将不可改变。 即使把某个数组元素的数据清空但它所占的空间依然被保留依然属于该数组数组的长度依然不变。
Java中的数组既可以存储基本类型的数据也可以存储引用类型的数据只要所有的数组元素具有相同的类型即可。
值得指出的是数组也是一种数据类型它本身是一种引用类型。例如int是一个基本类型但int[] (这是定义数组的一种方式) 就是一种引用类型了。 int[] 就是一种数据类型与int类型、String类型类似一样可以使用该类型来定义变量也可以使用该类型进行类型转换等。使用 int[] 类型来定义变量、进行类型转换时与使用其他普通类型没有任何区别。 int[] 类型是一种引用类型创建 int[] 类型的对象也是创建数组需要使用创建数的语法。 定义一个int数组类型的变量变量命为intArr
int[] intArr 使用静态初始化初始化数组时只指定数组元素的初始值不指定数组长度
intArr new int[] {58620}
例子 有变量为什么还用数组 数组的定义和访问 静态初始化数组
定义数组的时候直接给数组赋值。初始化时由程序员显示指定每个数组元素的初始值由系统决定数组长度。
静态初始化数组的格式 注意
“数组类型【】 数组名” 也可以写成 “数组类型 数组名【】”什么类型的数组只能存放什么类型的数据
package com.liu.define;public class ArrayDemo1 {public static void main(String[] args) {//目标掌握数组的定义方式一静态初始化数组//1. 数据类型【】 数组名 new 数据类型【】{元素1元素2元素3······}int[] ages new int[]{12,24,36};double[] scores new double[]{89.8,99.5,59.5,88};//2.简化写法//数据类型【】 数组名 {元素1元素2元素3·······}int[] ages2 {12,24,32};double[] scores2 {89.8,99.5,59.5,88};//3.数据类型【】 数组名 也可以写成 数据类型 数组名【】int[] ages3 {12,24,36};double scores3[] {89.8,99.5,59.5,88};}
}数组在计算机中的基本原理 注意
数组变量名中存储的是数组在内存中的地址数组是一种引用数据类型。
数组是一种引用类型的变量因此使用它定义一个变量时仅仅表示定义了一个引用变量也就是定义了一个指针这个引用变量还未指定任何有效的内存因此定义数组时不能指定数组的长度。而且由于定义数组只是定义了一个引用变量并未指向任何有效内存空间所有还没有内存空间来存储数组元素因此这个数组也不能使用只要对数组进行初始化后才能使用。
定义数组时不能指定数组的长度
Java语言中数组必须先初始化然后才可以使用。所谓初始化就是为数组的数组元素分配内存空间并为每个数组元素赋值初始值
不允许 只分配内存空间而不不赋初始值。一旦为数组的每个数组元素分配了内存空间每个内存空间里存储的内容就是该数组元素的值即使这个内存空间存储的内容是空这个空也是一个值null。不管以哪种方式来初始化数组只要为数组元素分配了内存空间数组元素就具有了初始值。初始值的获得有两种形式一种是由系统自动分配另一种由程序员指定。 package com.liu.define;public class ArrayDemo1 {public static void main(String[] args) {//目标掌握数组的定义方式一静态初始化数组//1. 数据类型【】 数组名 new 数据类型【】{元素1元素2元素3······}int[] ages new int[]{12,24,36};double[] scores new double[]{89.8,99.5,59.5,88};System.out.println(ages);System.out.println(scores); 数组的访问
数组最常见的用法就是访问数组元素包括对数组元素进行赋值和取出数组元素的值。访问数组元素都是通过在数组引用变量后紧跟一个方括号 [ ] 方括号里是数组元素的索引值这样就可以访问数组元素了。访问到数组元素后就可以把一个数组元素当成一个普通变量使用了包括为该变量赋值和取出该变量的值这个变量的类型就是定义数组时使用的类型。
Java语言的数组索引是从0开始的也就是说第一个数组元素的索引值为0最后一个数组元素的索引值为长度减1。
如果访问数组元素时指定的索引值小于0或者大于等于数组的长度编译程序不会出现任何错误但运行时出现异常。 数组名【索引】 数组的长度属性length 数组的最大索引
数组名.length - 1 //前提元素个数大于0 如果访问数组时使用的索引超过了最大索引会出什么问题
执行程序时会出现bug出现一个索引越界的异常提示。 package com.liu.define;public class ArrayDemo2 {public static void main(String[] args) {//目标掌握数组的访问int[] arr {12,24,36};// 0 1 2//1.访问数组的全部变量System.out.println(arr[0]);System.out.println(arr[1]);System.out.println(arr[2]);//System.out.println(arr[3]);//2. 修改数组中的数据arr[0] 66;arr[2] 100;System.out.println(arr[0]);//66System.out.println(arr[1]);//24System.out.println(arr[2]);//100//3. 访问数组元素个数数组名.lengthSystem.out.println(arr.length);//技巧获取数据的最大索引System.out.println(arr.length-1);int[] arr2 {};System.out.println(arr2.length - 1 );}
}数组的遍历 什么是数组遍历
遍历就是一个一个数据的访问 为什么要遍历数组
求和 元素搜索 找最大值、最小值 package com.liu.define;public class ArrayDemo3 {public static void main(String[] args) {//目标掌握数组的遍历int[] ages {12,24,36};//0 1 2// System.out.println(ages[0]);
// System.out.println(ages[1]);
// System.out.println(ages[2]);for (int i 0;i ages.length; i ){ //ages.fori 回车// i 0 1 2System.out.println(ages[i]);}}
}案例训练
数组遍历求和-求和
需求某部门5名员工的销售额分别是16、26、36、6、100请计算出他们部门的总销售额。
分析1.把这5个数据拿到程序中去 》使用数组 int【】 money {1626366100} 2.遍历数组中的每个数据然后再外面定义求和变量把他们累加起来。
package com.liu.define;public class ArrayTest4 {public static void main(String[] args) {//目标完成对数组的元素求和//1. 定义一个数组存储5名员工的销售额int[] money {16,26,36,6,100};//0 1 2 3 4//3.定义一个变量用于累加求和int sum 0 ;//2.遍历数组中的每个数据for (int i 0;i money.length;i){//0 1 2 3 4sum money[i];}System.out.println(员工的销售总额 sum);}
}动态初始化数组 数组的动态初始化
定义数组时先不存入具体的元素值只确定数组存储的数据类型和数组的长度初始化时程序员只指定数组长度由系统为数组元素分配初始值
数组的动态初始化格式
数据类型【】 数组名 new 数据类型【长度】
int[] arr new int[3];
//后赋值
arr[0] 10;
System.out.println(arr[0]); //10 温馨提示
静态初始化和动态初始化数组的写法时独立的不可以混用。
int[] arr new int[3]{30,40,50}; 错误写法 package com.liu.define;public class ArrayDemo5 {public static void main(String[] args) {//目标掌握定义数组的方式而动态初始化数组//1. 数据类型【】 数组名 new 数据类型【长度】int[] ages new int[3]; //ages [0,0,0]System.out.println(ages[0]);System.out.println(ages[1]);System.out.println(ages[2]);ages[0]12;ages[1]18;ages[2]32;System.out.println(ages[0]);System.out.println(ages[1]);System.out.println(ages[2]);// int[] arr new int[3]{0,20,50}; 错误写法}
}动态初始化数组元素默认值规则 char[] chars new char[3]; // [0,0,0]System.out.println((int)chars[0]); //char是字符类型 打印出来的会是底层的字符 因此可以转换成int型System.out.println((int)chars[2]);double[] score new double[80];System.out.println(score[0]);System.out.println(score[79]);boolean[] flags new boolean[100];System.out.println(flags[0]);System.out.println(flags[99]);String[] names new String[80];System.out.println(names[0]);System.out.println(names[79]); 两种数组定义的方法各自适合什场景
动态初始化适合开发不确定具体元素值只知道元素个数的业务场景。静态初始化适合一开始就知道要存入哪些元素值的业务场景。
案例训练
评委打分案例
需求某歌唱比赛需要开发一个系统可以录入6名评委的打分录入完毕后立即输出平均分做出选手得分。
分析1. 6名评委的打分是后期录入的一开始不知道具体的分数因此定义一个动态初始化的数组存分数。double[] scores new double[6]; 2.遍历数组中的每个位置每次提示用户录入一个评委的分数并存入到数组对应的位置。 3.遍历数组中的每个元素进行求和最终算出平均分打印出来即可。
package com.liu.define;import java.util.Scanner;public class ArrayTest6 {public static void main(String[] args) {//目标完成评委打分的案例//1.定义一个动态初始化的数组 负责后期存储6个评委的打分double[] scores new double[6];Scanner sc new Scanner(System.in);//2.遍历数组中的每个位置录入评委的分数存入到数组中去for (int i 0;i scores.length;i){// i 0 1 2 3 4 5System.out.println(请输入当前第(i1)个评委的分数);double score sc.nextDouble();scores[i] score;}//3.遍历数组中的每个数进行求和double sum 0 ;for (int i 0;i scores.length;i){sum scores[i];}System.out.println(选手最终得分是sum / scores.length);}
}数组在计算机的执行原理 package com.liu.memony;public class ArrayDemo1 {public static void main(String[] args) {//目标掌握普通变量数组在计算机中的执行原理Java程序在计算机中的执行过程int a 20;System.out.println(a);int[] arr new int[]{11,22,33};System.out.println(arr);System.out.println(arr[1]);arr[0]44;arr[1]55;arr[2]66;System.out.println(arr[0]);System.out.println(arr[1]);System.out.println(arr[2]);}
} Java内存分配介绍 数组在计算机中的执行原理 总结
1、运行一个Java程序主要看JVM中包含的哪几个部分
答方法区、栈内存、堆内存
2、简单说说 int a 20 ; int [] arr new int[3] 这两行代码的执行原理
答
a是变量直接放在栈中a变量中存储的数据就是20这个值
new int[3] 是创建一个数组对象会在堆内存中开辟区域存储3个整数
arr 是变量在栈中arr中存储的是数组对象在堆内存中的地址值
package com.liu.memony;public class ArrayDemo2 {public static void main(String[] args) {//目标认识多个变量面向同一个数组对象的形式并掌握其注意事项int[] arr1 {11,22,33};//把int类型的数组变量arr1赋值给int类型的数组类型变量arr2int[] arr2 arr1;System.out.println(arr1);System.out.println(arr2);arr2[1] 99;System.out.println(arr1[1]);}
}多个变量指向同一个数组 使用数组时常见的一个问题
如果某个数组变量存储的地址是null那么该变量将不再指向任何数组对象 arr2 null; //拿到的数组变量中存储的就是null
System.out.println(arr2);//System.out.println(arr2[0]); //出现报错空指针异常
//System.out.println(arr2.length); //出现报错空指针异常
总结
1、多个数组变量指向同一个数组对象的原因是什么需要什么
答
多个数组变量中存储的是同一个数组对象的地址
多个变量修改的都是同一个数组对象中的数据 2、如果某个数组变量中存储的null代表什么意思需要注意什么
答
代码这个数组变量没有指向数组对象
可以输出这个变量但是不能用这个数组变量去访问数据或者访问数组长度会报空指针异常NullPointerException 数组案例求最大值反转 求最大值
package com.liu.demo;public class Test1 {public static void main(String[] args) {// 目标掌握数组元素求最值//1. 把颜值数据拿到程序中来用数组装起来int[] faceScores {15,9000,10000,20000,9500,-5};// 0 1 2 3 4 5//2.定义一个变量用于最终记住最大值int max faceScores[0];//3.从数组的第二个位置开始遍历 ifor (int i 0;ifaceScores.length;i){// i 1 2 3 4 5//判断下一个当前遍历的这个数据是否大于最大值变量max存储的数据当前遍历的数据需要赋值maxif (faceScores[i]max){max faceScores[i];}}System.out.println(最高颜值是 max);}
}总结
求数组中的最大值我们是如何实现的
答
1. 把数据拿到程序中去用数组装起来
2. 定义一个变量max用于记录最大值max变量默认存储了第一个元素值作为参照物
3. 从第二个位置开始遍历数组的数据如果当前元素大于变量存储的数据则替换变量存储的值为该元素
4. 循环结束后输出max变量即可 数组反转
需求某个数组有5个数据1020304050请将这个数组中的数据进行反转
【1020304050】 反转后 【5040302010】
分析
数组反转操作实际上就是依次前后交换数据即可实现。 package com.liu.demo;public class Test2 {public static void main(String[] args) {//目标实现数组反转//1.准备一个数组int[] arr {10,20,30,40,50};// i j//2. 定义一个循环设计两个变量一个在前一个在后for (int i 0,j arr.length-1;i j;i,j--){//arr[i] arr[j]//交换//1.定义一个临时变量记住后一处位置的值int temp arr[j];//2.把前一个位置的值赋值给后一个位置了arr[j] arr[i];//3.把临时变量中记住的后一个位置处的值赋值给前一个位置处arr[i] temp;}//4.遍历数组中的每个数据看是否反转成功了for (int i 0; i arr.length; i) {System.out.println(arr[i] );}}
}总结
1.我们如何完成数组的反转的
答
使用for循环控制让数组的前后位置的元素依次交换 2. 数组如何实现前后元素交换的
答
定义一个临时变量记住后一个位置处的元素值
再把前一个位置处的元素值赋值给后一个位置处
最后把临时变量记住的后一个位置的值赋值给前一个位置处 Java数组随机排名debug 随机排名
需求某公司开发部5名开发人员要进行项目进展汇报演讲现在采取随机排名后进行汇报。请先依次录入5名员工的工号然后展示出一组随机的排名顺序。 分析
在程序中录入5名员工的工号存储起来 ----- 使用动态初始化数组的方式
依次遍历数组中的每个数据
每遍历一个数据都随机一个索引值出来让当前数据与该索引位置处的数据进行交换。
输出数据中的内容即可
package com.liu.demo;import java.util.Random;
import java.util.Scanner;public class Test3 {public static void main(String[] args) {//目标完成随机排名//1.定义一个动态初始化的数组用于存储5名员工的工号int[] codes new int[5];//[0,0,0,0,0]// 0 1 2 3 4//2.提示用户录入5名用户的工号Scanner sc new Scanner(System.in);for (int i 0; i codes.length; i) {// i 0 1 2 3 4System.out.println(请您输入当前第 (i 1) 员工的工号);int code sc.nextInt();codes[i] code;}//3.打乱数组中的元素顺序// [12,33,54,26,8]// i indexRandom r new Random();for (int i 0; i codes.length; i) {//code[i]//每遍历到一个数据都随机一个数组索引范围内的值然后让当前遍历的数据与该索引位置处的值交换int index r.nextInt(codes.length);//0 - 4//定义一个临时变量记住index位置的值int temp codes[index];//把i位置处的值赋值给index位置处codes[index] codes[i];//把index位置处的值赋值给i位置处codes[i] temp;}//4.遍历数组中的工号输出即可for (int i 0; i codes.length; i) {System.out.print(codes[i] );}}}随机交换排名的其他使用场景
随机发牌
Debug工具
IDEA自带的断点调试工具可以控制代码从断点开始一行一行的执行然后详细观看程序执行的情况。
Debug工具使用方法 第一步 设置断点 第二步 右击选择Debug······ 补充可以看详细的过程、 详细的代码执行过程 总结 总结数组 数组
数组的作用就是一个数据用于在程序中存储一批同种类型的数据数组的定义 静态初始化 格式1 数据类型[] 数组名称 new 数据类型[] {元素1元素2 元素3······} 数组的定义 静态初始化 格式2 数据类型[] 数组名称 new 数据类型[] {元素1元素2 元素3······]数组的定义 静态初始化 特点在定义数组的时候同时为数组确定了数据数组的定义 静态初始化 使用场景一旦确定了数据的具体值我没就用这种方式存储批量数据数组的定义 动态初始化 格式数据类型[] 数组名称 new 数据类型[长度]数组的定义 动态初始化 特点一开始值确定数组的类型和长度不确定具体存入的数据值数组的定义 动态初始化 使用场景适合一开始不能确定具体数据的情况先定数组后赋值数据进去数组的访问 格式 数组名称[索引]数组的访问 取值 int data arr[i]数组的访问 赋值arr[i] 22 数组的访问 长度arr.length[]数组的注意事项什么类型的数组只能存放什么类型的数据 数据类型[] 变量名称 可以写成 数据类型 变量名称[] ; 数组一旦定义出来程序执行的过程中长度、类型就被固定了动态初始化数组的元素存在默认值
数组的遍历
什么是遍历一个一个的访问数据为什么要遍历业务开发中都需要用到统计数据搜索数数组如何遍历
数组的案例
参见代码
数组的内存图
Java的内存分配 方法区放Class文件的 栈内存运行的方法main方法定义的变量 堆内存new出来的对象都在堆内存中
数组使用的常见问题
不要访问超过数组的最大索引否则出现数组访问越界异常空指针异常问题int[] arr null;
Debug工具的使用
找问题并解决断点调试工具基本使用步骤打断点 右键使用Debug使用 控制一行一行的往下执行 Java方法方法概述 方法是类或对象行为特征的抽象方法是类或对象最重要的组成部分。但从功能上来看方法完全类似于传统结构化程序设计里的函数。值得指出的是Java里的方法不能独立存在所有的方法都必须定义在类里。方法在逻辑上要么属于类要么属于对象。
在面向对象编程语言里类才是一等公民整个系统由一个个的类组成。因此在Java语言里方法不能独立存在方法必须属于类或对象。
因此如果需要定义方法则只能在类体内定义不能独立定义一个方法。一旦将一个方法定义在某个类的类体内如果这个方法使用了static修饰则这个方法属于这个类否则这个方法属于这个类的实例。
因此Java里的方法不能独立存在它必须属于一个类或一个对象因此方法也不能像函数那样被独立执行执行方法时必须使用类或对象来作为调用者即所有方法都必须使用“类 . 方法”或“对象 . 方法”的形式来调用。这里可能产生一个问题同一个类里不同方法之间相互调用时不就可以直接调用吗这里需要指出同一个类的一个方法调用另外一个方法时如果被调方法是普通方法则默认使用this作为调用者如果被调方法是静态方法则默认使用类作为调用者。也就是说表面上看起来某些方法可以被独立执行大实际上还是使用this或者类作为调用者。
方法是什么
方法是一种语法结构他可以把一段代码封装成一个功能以便重复调用。
方法的完整格式 package com.liu.define;public class MethodDemo1 {public static void main(String[] args) {//目标掌握定义方法的完整格式高清楚使用方法的好处//需求假如现在很多程序员都要进行2个整数的求和操作//1.李工程师int rs sum(10,20);System.out.println(rs);//2. 张工程师int rs2 sum(30,20);System.out.println(rs2);}public static int sum(int a,int b){int c a b;return c;}
}示例 方法如何执行
方法定义后必须调用才可以跑起来调用格式方法名··· 方法的调用流程Debug工具 方法定义时几个注意点 方法的修饰符暂时都使用 public static 修饰方法申明了具体的返回值类型内部必须使用 return 返回对应类型的数据形参列表可以有多个甚至可以没有如果有多个形参多个形参必须使用 ”“ 隔开且不能给初始化值。方法不能独立定义方法只能在类体里定义。从逻辑意义上来看方法要么属于该类本身要么属于该类的一个对象。永远不能独立执行方法执行方法必须使用类或对象作为调用者。
使用方法的好处
提高了代码的复用性提高了开发效率。 让程序的逻辑更清晰 使用static修饰的方法属于这个类本身使用static修饰的方法既可以使用类作为调用者来调用也可以使用对象作为调用者来调用。但值得指出的是因为使用static修饰的方法还是属于这个类的因此使用该类的任何对象来调用来调用这个方法时将会得到相同的执行结果这是由于底层依然是使用这些实例所属的类作为调用者。
没有static修饰的方法属于该类的对象不属于这个类本身。因此没有static修饰的方法只能使用对象作为调用者来调用不能使用类作为调用者来调用。使用不同对象作为调用者来调用同一个普通方法可能得到不同的结果。 Java方法方法定义的其他形式常见问题 方法的其他形式
方法定义时需要按照方法解决的实际业务需求来设计合理的方法形式解决问题。 无参数无返回值
package com.liu.define;public class MethodDemo2 {public static void main(String[] args) {//目标掌握按照方法解决的实际业务需求不同设计成合理的方法形式来解决问题//需求打印三行hello worldprintHeoolWorld();System.out.println(-----------------------------------);printHeoolWorld();}/*** 无参数无返回值的方法*/public static void printHeoolWorld(){for (int i 0; i 3; i) {System.out.println(Hello World);}}
}有参数有返回值
package com.liu.define;public class MethodDemo2 {public static void main(String[] args) {//目标掌握按照方法解决的实际业务需求不同设计成合理的方法形式来解决问题//需求打印多行hello worldprintHeoolWorld(3);System.out.println(-----------------------------------);printHeoolWorld(6);}/*** 有参数无返回值的方法*/public static void printHeoolWorld(int n){for (int i 0; i n; i) {System.out.println(Hello World);}}
}注意事项
如果方法不需要返回数据返回值类型必须申明成void无返回值申明此时方法内部不可以使用return返回数据。方法如果不需要接收数据则不需要定义形参且调用方法时也不可以传数据给方法了没有参数且没有返回值类型void申明方法称为无参数、无返回值的方法依次类推。
总结
如果方法不需要接收数据处理不需要返回数据应该怎么办要注意什么
方法不需要接收数据则形参列表可以不写方法不需要返回数据则申明返回值类型为void方法没有申明返回值类型void内部不能使用return返回数据方法如果没有形参列表调用的时候则不能传入参数值否则报错
方法使用时的常见问题
方法在类中的位置放前放后无所谓但一个方法不能定义在另一个方法里面方法的返回值类型写void无返回申明时方法内不能使用return返回数据如果方法的返回值类型写了具体类型方法内部则必须使用return返回对应类型的数据return语句的下面不能编写代码属于无效的代码执行不到这儿方法不调用就不会执行调用方法时传给方法的数据必须严格匹配方法的参数情况调用有返回值的方法有三种方式1.可以定义变量接收结果 2. 或者直接输出调用 3. 甚至直接调用调用无返回值的方法只有一种1. 只直接调用 Java方法方法的案例 设计方法的技巧主要关注三方面
方法是否需要接收数据进行处理方法是否需要返回数据方法要处理的业务编程能力 案例计算1-n的和
需求求1-n的和
分析
1.方法是否需要接收数据进行处理
需要接收n具体的值因此形参声明为int n
2.方法是否需要返回数据
需要返回1-n的求和结果因此返回值类型声明为int
3.方法内部的业务
完成求1-n的和并返回
package com.liu.define;public class MethodTest4 {public static void main(String[] args) {//目标掌握设计方法的技巧int rs add(5);System.out.println(1-5的和是 rs);int rs2 add(100);System.out.println(1-100的求和是 rs2);}public static int add(int n){int sum 0 ;for (int i 1; i n; i) {// i 1 2 3 nsum i;}return sum;}
}案例判断一个整数是奇数还是偶数
需求判断一个整数是奇数还是偶数并把判断的结果输出来
分析
1. 方法是否需要接收数据进行处理
需要接收一个整数来判断因此形参声明为int number
2. 方法是否需要返回数据
方法内部判断完后直接输出结果即可无需返回因此返回值类型声明为void
3. 方法内部的业务
通过if语句判断number是奇数还是偶数并输出结果
package com.liu.define;public class MethodTest4 {public static void main(String[] args) {//目标掌握设计方法的技巧int rs add(5);System.out.println(1-5的和是 rs);int rs2 add(100);System.out.println(1-100的求和是 rs2);System.out.println(-------------------------------);judge(10);judge(7);}public static void judge(int number){if (number % 2 0){System.out.println(number 是一个偶数);}else{System.out.println(number 是一个奇数);}}public static int add(int n){int sum 0 ;for (int i 1; i n; i) {// i 1 2 3 nsum i;}return sum;}
}总结
1.定义方法重点关注的是哪几点
方法是否需要接收数据也就是是否需要定义形参列表
方法是否需要返回数据也就是是否需要声明具体的返回值类型
2. 如何设计方法完成1-n的求和 3. 我没如何设计方法判断一个整数是奇数还是偶数的 Java方法方法在计算机中的执行 方法在计算机中的执行原理
方法被调用的时候是进入到栈内存中运行。 总结
1.方法的运行区域在哪里
栈内存
2. 栈有什么特点方法为什么要在栈中运行自己
先进先出
保证一个方法调用完另一个方法后可以回来 Java方法方法参数传递 Java的参数传递机制都是值传递
所谓值传递指的是在传输实参给方法的形参的时候传输的是实参变量中存储的值的副本实参在方法内部定义的变量形参定义方法时 “···” 中所声明的的参数
基本类型的参数传递
package com.liu.parameter;public class MethodDemo1 {public static void main(String[] args) {//目标理解方法的参数传递机制值传递int a 10;change(a); //change(10);System.out.println(main: a); //10}public static void change(int a){System.out.println(change1: a); //10a 20;System.out.println(change2: a); //20}
}引用类型的参数传递
package com.liu.parameter;public class MethodDemo2 {public static void main(String[] args) {//目标理解引用类型的传递机制int[] arrs new int[]{10,10,30};change(arrs);System.out.println(main: arrs[1]);}public static void change(int[] arrs){System.out.println(方法内1 arrs[1]);arrs[1] 222;System.out.println(方法内2 arrs[1]);}
}总结基本类型和引用类型的参数在传递的时候有什么不同
都是值传递基本类型的参数传输传输存储的数据值引用类型的参数传输存储的地址值 Java方法参数传递的案例 案例打印int类型的数组内容
需求输出一个int类型的数组内容要求输出格式为【1122334455】
分析1.方法是否需要接收数据进行处理需要接收一个ingt类型的数组因此形参声明为int[] arr 2. 方法是否需要返回数据方法内部直接输出数组内容即可无需返回因此返回值类型声明为void 3. 方法内部的业务遍历数组并输出相应的内容
package com.liu.parameter;public class MethodTest3 {public static void main(String[] args) {//目标完成打印int类型的数组你内容int[] arr new int[]{10,30,50,70};printArray(arr);}public static void printArray(int[] arr){System.out.print([);//直接遍历接到的数组元素for (int i 0; i arr.length; i) {if(i arr.length-1){System.out.print(arr[i]);}else {System.out.print(arr[i],);}}System.out.println(]);}
}package com.liu.parameter;public class MethodTest3 {public static void main(String[] args) {//目标完成打印int类型的数组你内容int[] arr new int[]{10,30,50,70};printArray(arr);}public static void printArray(int[] arr){System.out.print([);//直接遍历接到的数组元素for (int i 0; i arr.length; i) {
// if(i arr.length-1){
// System.out.print(arr[i]);
// }else {
// System.out.print(arr[i],);
// }System.out.print(i arr.length-1 ? arr[i]:arr[i] ,);}System.out.println(]);}
} package com.liu.parameter;public class MethodTest3 {public static void main(String[] args) {//目标完成打印int类型的数组你内容int[] arr new int[]{10,30,50,70};printArray(arr);int[] arr2 null;printArray(arr2);int[] arr3 {};printArray(arr3);}public static void printArray(int[] arr){if (arr null) {System.out.println(arr);//nullreturn;//跳出当前方法}System.out.print([);//直接遍历接到的数组元素for (int i 0; i arr.length; i) {
// if(i arr.length-1){
// System.out.print(arr[i]);
// }else {
// System.out.print(arr[i],);
// }System.out.print(i arr.length-1 ? arr[i]:arr[i] ,);}System.out.println(]);}
}案例比较两个int类型的数组是否一样返回true或者false
需求如果两个int类型的数组元素个数对应位置的元素内容都是一样的则认为这2个数组是一模一样的 分析1.方法是否需要接收数据进行处理需要接收两个int类型的数组因此形参声明为int[] arr1,int[] arr2 2. 方法是否需要返回数据 方法判断完后需要返回true、false因此返回值类型声明为boolean类型 3.方法内部的业务判断两个数组内容是否一样。
package com.liu.parameter;public class MethodTest4 {public static void main(String[] args) {//目标完成判断两个类型的数组是否一样
// int[] arr1 null;int[] arr1 {10,20,30,40};int[] arr2 {10,20,30};System.out.println(equals(arr1,arr2));}public static boolean equals(int[] arr1,int[] arr2) {//1.判断啊arr1和arr2是否都是nullif (arr1 null arr2 null) {return true;//相等的}//2.判断arr1是null或者arr2是nullif (arr1 null || arr2 null) {return false;//不相等}//3. 判断2个数组传递长度是否一样如果长度不一样直接返回falseif (arr1.length ! arr2.length) {return false; //不相等}//4. 两个数组的长度是一样的接着比较它们的内容是否一样//arr1 [10,20,30]//arr2 [10,20,30]for (int i 0; i arr1.length; i) {//判断当前位置2个数组的元素是否都一样不一样直接返回falseif (arr1[i] ! arr2[i]) {return false; //不相等}}return true;//两个数组是一样的}
}Java方法递归方法 方法递归
一个方法体内调用它自身被称为方法递归。方法递归包含了一种隐式的循环它会重复执行某段代码但这个重复执行无须循环控制。 Java方法方法重载return关键字 方法重载
一个类中出现多个方法的名称相同但是它们的形参列表是不同的那么这些方法就称为方法重载了。
package com.liu.overload;public class MethodOverLoadDemo1 {public static void main(String[] args) {//目标认识方法重载并掌握其应用场景test();test(100);}public static void test(){System.out.println(test1);}public static void test(int a){System.out.println(test2 a);}
}在Java程序中确定一个方法需要三个要素
调用者也就是方法的所属者既可以是类也可以是对象。方法名方法的标识。形参列表当调用方法时系统将会根据传入的实参列表匹配。
方法重载的要求就是两同一不同
同一个类中方法名相同参数列表不同。至于方法的其他部分如方法返回值类型‘修饰符等与方法重载没有任何关系。
方法重载的注意注意事项
一个类中只要一些方法的名称相同、形参列表不同那么它们就是方法重载了其它的都不管如修饰符返回值类型是否都无所谓。形参列表不同指的是形参的个数、类型、顺序不同不关心形参的名称。
方法重载的应用场景
开发中我们经常需要为处理一类业务提供多种解决方案此时用方法重载来设计是很专业的
案例导学
开发武器系统功能需求如下
1. 可以默认发一枚武器
2. 可以指定地区发射一枚武器
3. 可以指定地区发射多枚武器 package com.liu.overload;public class MethodTest2 {public static void main(String[] args) {//目标掌握方法重载的应用场景fire();fire(米国,999);}public static void fire(){fire(岛国);}public static void fire(String country){fire(country,1);}public static void fire(String country,int number){System.out.println(发射了 number 枚武器给 country);}
}return关键字在方法中单独使用
return可以用在无返回值的方法中作用是立即跳出并结束当前方法的执行 package com.liu.returnDemo;public class ReturnDemo1 {public static void main(String[] args) {//目标掌握return单独使用//return在无返回值方法中的使用跳出并立即结束当前方法的执行System.out.println(程序开始...);chu(10,0);System.out.println(程序结束...);}public static void chu(int a,int b){if (b 0){System.out.println(您的数据有问题不能除0);return;//跳出并结束当前方法的执行}int c a / b;}
}return跳出并立即结束所在方法的执行
break跳出并结束当前所在循环的执行
continue结束当前所在循环的当次继续进入下一次执行 总结方法 方法的作用封装一段代码的语法结构可以被重复调用以此提高代码的复用性提高开发效率让程序逻辑更清晰方法的完整定义格式方法的其他定义格式如果方法中没有结果数据需要返回返回值类型声明为void方法的调用必须调用方法方法才可以跑起来 有返回值类型声明的方法的调用1、赋值调用定义变量接收方法的结果2、输出调用放在输出语句中调用3、直接调用方法还是会执行的只是返回的结果我们不要了 无返回值的方法调用直接调用一下。方法的注意事项如果方法不需要返回数据返回值类型必须申明成void无返回值申明此时方法内部不可以使用return返回数据。 方法如果不需要接收数据则不需要定义形参且调用方法时也不可以传数据给方法了。 没有参数且没有返回值类型void申明方法称为无参数、无返回值的方法依次类推。方法的参数传递机制值传递 你传输实参给方法的形参传输的不是实参本身而是实参中存储的数据的值的一个副本 无论是基本数据类型还是引用数据类型的参数都是满足值的传递基本类型的参数传输的是存储的数据引用类型的参数传输的是存储的地址值。方法重载同一个类中方法名称相同形参列表必须不同才是方法重载。方法重载的好处方法名相同标记是同一个功能可读性好形参列表不同体现功能的差异话这是专业设计还可以提高开发效率。识别方法重载的技巧形参列表不同形参个数类型顺序不同。不关心形参变量的名称(int a, int b) ( int c, int d,int e )。。return跳出并立即结束当前方法的执行。 Java案例买飞机票 需求
用户购买机票时机票原价会按照淡季、旺季头等舱还是经济舱的情况进行相应的优惠优惠方案如下5-10月为旺季头等舱9折经济舱8.5折11月份到来来年4月为淡季头等舱7折经济舱6.5折请开发程序计算出用当前机票的优惠价。
分析
1. 方法是否需要接收数据需要接收机票原件、当前月份、舱位类型 2. 方法是否需要返回数据需要返回计算出的机票优惠价 3. 方法内部先使用if判断月份是旺季还是淡季然后使用switch分支判断是头等舱还是经济舱 package com.liu;public class Test1 {public static void main(String[] args) {//目标完成买飞机票的案例double price calculate(1000,8,经济舱);System.out.println(优惠价是 price);}public static double calculate(double price,int month,String type) {//1.判断当前月份是淡季还是旺季if (month 5 month 10) {//旺季//2. 判断舱位类型switch (type) {case 头等舱:price * 0.9;break;case 经济舱:price * 0.85;break;}} else {//淡季switch (type) {case 头等舱:price * 0.7;break;case 经济舱:price * 0.65;break;}}return price;}
} 总结
1.遇到需要通过判断数据在哪个区间来决定执行哪个业务应该用什么实现
应该使用 if 分支结构实现
2.遇到需要通过判断数据匹配哪个值来决定执行哪个业务应该什么实现
应该是有switch分支结构实现 Java案例开发验证码 需求
开发一个程序可以生成指定位数的验证码可以是数字、大小写字母。
分析
1. 方法是否需要接收数据需要接收一个整数控制生成验证码的位数。2. 方法是否需要返回数据需要返回生成的验证码。3.方法内部的业务使用for循环依次生成每位随机字符并使用一个String类的变量把每个字符连接起来最后返回该变量即可。
package com.liu;import java.util.Random;public class Test2 {public static void main(String[] args) {//目标完成生成验证码System.out.println(createCode(5));}public static String createCode(int n){//1.定义一个for循环用于控制产生多少位随机字符Random r new Random();//3.定义一个String类型的变量用于记住产生的每位随机字符String code ;for (int i 1; i n ; i) {//i 1 2 3 4 5//2. 为每个位置生成一个随机字符可能是数字大小写字母。//思路随机一个0 1 2 之间的数字出来0代表随机一个数字字符1、2代表随机大写字母、小写字母int type r.nextInt(3);// 0 1 2switch (type){case 0://随机一个数字字符//方便字符串拼接code r.nextInt(10); //0-9 code code 8break;case 1://随机一个大写字符 A 65 Z 6525 (0-25)65char ch1 (char) (r.nextInt(26)65);code ch1;break;case 2://随机一个小写字符 a 97 z 9725 (0-25)97char ch2 (char) (r.nextInt(26)97);code ch2;break;}}return code;}
}总结
1.定义一个for循环循环5次
2. 随机生成0 1 2 的数据依次代表当前要生成的字符是数字、大写字母、小写字母
3. 把0、1 、2 交给switch生成对应类型的随机字符
4. 在循环外定义一个String类型的变量用来连接生成的随机字符
5. 循环结束后返回String类型的变量即是生成的随机验证码 Java案例评委打分 需求
在唱歌比赛中可能有多名评委要给选手打分分数是【0-100】之间的整数。选手最后得分为去掉最高分、最低分后剩余分数的平均分请编写程序能够录入多名评委的分数并算出选手的最终得分
分析
1、方法是否需要接收数据进行处理需要接收评委的人数 2、方法是否需要返回数据需要返回计算出的选手最终得分。3、方法内部的业务定义数组录入评委的分数存入到数组中区接着我们就需要遍历数组中的分数计算出总分并找出最高峰、最低分、最后按照这些数据算出选手最终得分并返回即可。 package com.liu;import java.util.Scanner;public class Test3 {public static void main(String[] args) {//目标需要完成评委打分案例System.out.println(当前选手得分是 getAverageScore(6));}public static double getAverageScore(int number){//1、定义一个动态初始化的数组负责后期存入评委的的打分int[] scores new int[number];//6//scores {0,0,0,0,0,0}//2、遍历数组的每个位置依次录入评委的分数Scanner sc new Scanner(System.in);for (int i 0; i scores.length; i) {// i 0 1 2 3 4 5System.out.println(请您录入第(i 1)个评委的分数);int score sc.nextInt();scores[i] score;}//3、从数组中国计算出总分找出最高分、最低分int sum 0;int max scores[0]; //求最大值的int min scores[0];//求最小值的//遍历数组找出这些数据的for (int i 0; i scores.length; i) {//i 0 1 2 3 4 5int score scores[i];//求和sum score;//求最大值if (score max){max score;}//最小值if (score min){min score;}}//4、计算出平均分并返回return 1.0 * (sum - max -min) / (number - 2);}
}总结
如何实现评委打分案例
答
1、定义一个动态初始化的数组用于录入评委打分
2、提前定义三个变量用来记住数组中的最大值、最小值、总和
3、遍历数组中的每个数据依次找出最大值、最小值、总和
4、遍历结束后按照计算规则算出选手的最终得分并返回即可 Java案例数字加密 需求
某系统的数字密码是一个四位数如1983为了安全需要加密后再传输加密规则是堆密码中的每位数都加5再对10求余最后将所有数字顺序反转得到一串加密后的新数请设计出满足本需求的加密程序 分析
1、方法是否需要接收数据进行处理需要接收四位数字密码进行加密处理。2、方法是否需要返回数据需要返回加密后的结果。3、方法内部的业务将四位数字密码拆分成一个一个的数字存入到数字中遍历数组中的每个数字按照题目需求进行加密最后再把加密后的数字拼起来返回即可 package com.liu;public class Test4 {public static void main(String[] args) {//目标完成数字加密程序的开发System.out.println(加密后的结果是 encrypt(1983));}public static String encrypt(int number){//number 1983//1、把这个密码拆分成一个一个的数字才可以对其进行加密int[] numbers split(number);// number [1,9,8,3]//2、遍历数组中的每个数字对其进行加密处理for (int i 0; i numbers.length; i) {// i 0 1 2 3numbers[i] (numbers[i] 5) % 10;}//number [6,4,3,8]//3、对数组反转把对数组进行反转的操作交给一个独立的方法来完成reverse(numbers);//numbers [8,3,4,6]//4、把加密的数字拼接起来来作为加密后的结果返回即可。String data ;for (int i 0; i numbers.length; i) {data numbers[i];}return data;}public static void reverse(int[] numbers) {//反转数组// numbers [6,4,3,8]// i jfor (int i 0,j numbers.length - 1; i j;i,j--) {//交换i和j位置处的值//1、把后一个位置处的值交给一个临时变量先存起来int temp numbers[j];//2、把前一个位置处的值赋值给后一个位置处numbers[j] numbers[i];//3、把后一个位置处原来的值由临时变量记住着赋值给前一个位置numbers[i] temp;}}public static int[] split(int number) {//number 1983int[] numbers new int[4];numbers[0] number / 1000;numbers[1] (number / 100) % 10;numbers[2] (number / 10) % 10;numbers[3] number % 10;return numbers;}
}总结
1、回顾数组元素的反转、交换是如何完成的
反转数组就是对数组中的元素按照前后位置依次交换数字据。
2、如果一个方法李要做的事比较多我们再开发中一般会怎么做
一般会把多个事拆成多个方法去完成也就是独立功能独立成一个方法。 Java案例数组拷贝 需求
请把一个整型数组例如存了数据112233拷贝成一个一模一样的新数组出来。
分析
1、方法是否需要接收数据进行处理需要接收一个整型数组原数组。2、方法是否需要返回数据需要返回一个新的、一模一样的整型数组。3、方法内部的业务创建一个长度一样的整型数组做为新数组并把原数组的元素对应位置赋值给新数组最终返回新数组即可。 package com.liu;public class Test5 {public static void main(String[] args) {//目标掌握数组拷贝int[] arr {11,22,33};int[] arr2 copy(arr);printArry(arr2);//注意这个不是拷贝数值叫把数组变量赋值给另一个数组变量
// int[] arr3 arr;
// arr3[1] 666;
// System.out.println(arr[1]); //666// arr2[1] 666;
// System.out.println(arr[1]); //22}public static void printArry(int[] arr){System.out.print([);for (int i 0; i arr.length; i) {System.out.print(i arr.length - 1 ? arr[i] : arr[i] ,);}System.out.println(]);}public static int[] copy(int[] arr){//arr [11,22,33]// 0 1 2//1、创建一个长度一样的整型数组出来int[] arr2 new int[arr.length];//arr2 [0,0,0]// 0 1 2// 2、把原数组的元素值对应位置赋值给新数组for (int i 0; i arr.length; i) {// i 0 1 2arr2[i] arr[i];}return arr2;}
}总结
数组的拷贝是什么意思
答创建一个与原数组一模一样的数组 Java案例抢红包 需求
一个大V直播时发起了抢红包活到分别有9、666、188、520、99999五个红包。请模拟粉丝来抽奖按照先来先得随机抽取抽完即止注意一个红包只能被抽一次先抽后抽哪一个红包是随机的示例如下不一定是下面得顺序 分析
1、方法是否需要接收数据进行处理需要接收一个数组里面是5个金额表示5个红包。2、方法是否需要返回数据不需。3、方法内部完成本需求的是一种方案写个for循环控制抽奖5次每次抽奖都从数组中随机找出一个金额如果该金额不是0则代表抽奖中接着用0替换该位置处的金额然后继续下一个粉丝的抽奖如果抽中的金额发现是0代表该位置处的红包之前被别人抽走了则重新从数组中随机找出一个金额继续判断直至抽中的金额不是0 package com.liu;import java.util.Random;
import java.util.Scanner;public class Test6 {public static void main(String[] args) {//目标抢红包的案例开发int[] moneys {9,666,188,520,99999};start(moneys);}public static void start(int[] moneys){//moneys [9,666,188,520,99999]// 0 1 2 3 4Scanner sc new Scanner(System.in);Random r new Random();//1、定义一个for循环控制抽奖五次for (int i 1; i 5; i) {//2、提示粉丝抽奖System.out.println(请您输入任意内容进行抽奖);sc.next(); //等待用户输入内容按了回车才往下走的//3、为当前粉丝找一个随机的红包出来while (true) {int index r.nextInt(moneys.length); //0-4int money moneys[index];//4、判断这个红包是否不为0if (money ! 0){System.out.println(恭喜您您抽中了红包 money);moneys[index] 0;break;//结束这次抽奖}}}System.out.println(活到结束...);}
}Java案例找素数的三种做法 需求
判断101-200之间有多少个素数并输出所有素数
除了1和它本身以外不能被其他整数整除就叫素数。比如3、7就是素数而9、21等等不是素数。
分析
1、方法是否需要接收数据进行处理需要接收101以及200以便找该区间中的素数。2、方法是否需要返回数据需要返回找到的素数个数。3、方法内部的实现逻辑使用for循环来产生如101到200之间的每个数每拿到一个数判断该数是否是素数判断规则是从2开始遍历到该数的一半的数据看是否有数据可以整除它有则不是素数没有则是素数根据判定的结果来决定是否输出这个数据是素数则输出最后还需要统计素数的个数并返回。
package com.liu;public class Test7 {public static void main(String[] args) {//目标完成找素数System.out.println(当前素数的个数是 search(101, 200));}public static int search(int start,int end){int count 0;//start 101 end 200//1、定义一个for循环找到101到200之间的每个数据for (int i start; i end ; i) {// i 101 102 103 ... 199 200//信号位思想boolean flag true;//假设的意思默认认为当前i记住的数都是素数//2、判断当前i记住的这个数据是否是素数for (int j 2; j i / 2; j) {if (i % j 0){// i 当前记住的这个数据不是素数了flag false;break;}}//3. 根据判定的结果决定是否输出i当前记住的数据是素数才输出展示。if (flag){System.out.println(i);count;}}return count;}
} 总结
如何确定出该数是素数的具体如何实现
答定义了flag标记位。 遍历2到该数的一半的数据去判断是否有整数的数据有则改变flag标记的状态。 最终通过flag的状态判断是否是素数 package com.liu;public class Test7_2 {public static void main(String[] args) {//目标完成找素数//1、定义一个for循环找到101到200之间的每个数据int count 0;OUT://为外部循环指定标签for (int i 101;i 200 ; i) {// i 101 102 103 ... 199 200//2、拦截判断该数是否素数for (int j 2; j i / 2; j) {if (i % j 0){//这个数肯定不是素数不能打印continue OUT;//结束外部循环的当次执行}}count;System.out.println(i);}System.out.println(个数是 count);}
}package com.liu;public class Test7_3 {public static void main(String[] args) {for (int i 101; i 200 ; i) {// i 101 102 103 ... 199 200//i遍历到当前数据是否是素数是则输出不是则不输出if(check(i)){System.out.println(i);}}}public static boolean check(int data){for (int i 2; i data / 2 ; i) {if (data % i 0){return false;//不是素数}}return true;}
}Java案例打印乘法表 package com.liu;public class Test8 {public static void main(String[] args) {//1、定义一个for循环控制打印多少行for (int i 1; i 9; i) {// i 1 2 3 4 5 6 7 8 9//2、定义一个内部循环控制每行打印多少次for (int j 1; j i ; j) {// i行 j列System.out.print(j X i (i*j) \t);}System.out.println(); //换行}}
}Java案例打印三角形 package com.liu;/*** ** **** ****** ********* 本质计算机本质只能打印行所以按照换行思考* 先找规律再写程序** 行i 先打空格(n-i) 再打星星(2i-1) 换行* 1 3 1* 2 2 3* 3 1 5* 4 0 7**/public class Test9 {public static void main(String[] args) {//1、先定义一个循环控制打印多少行int n 4;for (int i 1; i n ; i) {//2、控制打印多少个空格for (int j 1; j (n-i) ; j) {System.out.print( );}//3、控制打印多少个星星for (int j 1; j (2*i - 1) ; j) {System.out.print(*);}//4、换行System.out.println();}}
}Java案例模拟双色求[拓展案例] 业务分析、用户投注一组号码 双色球业务介绍 总体实现步骤介绍 第一步用户投注一组号码 注意6个红球号码的范围是 1 - 33 之间且不能重复1个篮球号码的范围在1-16之间 package com.liu;import java.util.Scanner;public class Test10 {public static void main(String[] args) {//目标完成双色球系统的开发int[] userNumbers userSelectNumber();printArray(userNumbers);}public static void printArray(int[] arr){System.out.print([);for (int i 0; i arr.length; i) {System.out.print(i arr.length-1 ? arr[i] :arr[i],);}System.out.println(]);}//1、设计一个方法用于投注一组号码并返回前6个是红球号码后1个是蓝球号码public static int[] userSelectNumber(){//2、创建一个整型数组用于存储用户投注的7个号码前6个是红球号码最后1个是篮球号码int[] numbers new int[7];//numbers [0,0,0,0,0,0,0]// 0 1 2 3 4 5 6Scanner sc new Scanner(System.in);//3、遍历前6个位置让用户一次投注6好红球号码存入for (int i 0; i numbers.length-1; i) {//i 0 1 2 3 4 5while (true) {//4、开始让用户为当前位置投入一个红球号码1-33之间不能重复System.out.println(请您输入第(i1)个红球号码1-33之间不能重复);int number sc.nextInt();//5、判断用户输入的红球是否在1-33之间if (number 1 || number 33){System.out.println(对不起您输入的红球号码不在1-33之间请确认);}else {//号码在1-33之间接着继续判断这个号码是否重复部重复才可以使用if(exist(numbers,number)){//number当前这个红球号码是重复了System.out.println(对不起您当前输入的红球号码前面选择过了重复了请缺人);}else {//number记住的这个号码没有重复了就可以使用了numbers[i] number;break;//结束当前死循环}}}}//6、投注最后一个篮球号码while (true) {System.out.println(请您输入最后一个蓝球号码1-16);int number sc.nextInt();if (number 1 || number 16){System.out.println(对不起您输入的蓝球号码范围不对);}else {numbers[6] number;break;//蓝球号码录入成功结束循环}}return numbers;}private static boolean exist(int[] numbers, int number) {//需求判断number这个数是否在numbers数组中存在//numbers [12,25,18,0,0,0,0]//number 25for (int i 0; i numbers.length; i) {if (numbers[i] 0){break;}if (numbers[i] number){return true;}}return false;}
}总结
本次案例是如何去保证用户投注6个红球号码不重复的
答每次用户投注一个红球号码后都去调用一个方法来判断这个号码是否已经选择过如果选择过让用户重新选号。 Java案例模拟双色求[拓展案例] 随机生成一组中奖号码 第二步随机一组中奖号码出来 注意6个红球号码的范围是1-32之间且不能重复1个蓝球号码的范围在1-16之间 package com.liu;import java.util.Random;
import java.util.Scanner;public class Test10 {public static void main(String[] args) {//目标完成双色球系统的开发int[] userNumbers userSelectNumber();printArray(userNumbers);int[] luckNumbers createLuckNumbers();printArray(luckNumbers);}public static void printArray(int[] arr){System.out.print([);for (int i 0; i arr.length; i) {System.out.print(i arr.length-1 ? arr[i] :arr[i],);}System.out.println(]);}//1、设计一个方法用于投注一组号码并返回前6个是红球号码后1个是蓝球号码public static int[] userSelectNumber(){//2、创建一个整型数组用于存储用户投注的7个号码前6个是红球号码最后1个是篮球号码int[] numbers new int[7];//numbers [0,0,0,0,0,0,0]// 0 1 2 3 4 5 6Scanner sc new Scanner(System.in);//3、遍历前6个位置让用户一次投注6好红球号码存入for (int i 0; i numbers.length-1; i) {//i 0 1 2 3 4 5while (true) {//4、开始让用户为当前位置投入一个红球号码1-33之间不能重复System.out.println(请您输入第(i1)个红球号码1-33之间不能重复);int number sc.nextInt();//5、判断用户输入的红球是否在1-33之间if (number 1 || number 33){System.out.println(对不起您输入的红球号码不在1-33之间请确认);}else {//号码在1-33之间接着继续判断这个号码是否重复部重复才可以使用if(exist(numbers,number)){//number当前这个红球号码是重复了System.out.println(对不起您当前输入的红球号码前面选择过了重复了请缺人);}else {//number记住的这个号码没有重复了就可以使用了numbers[i] number;break;//结束当前死循环}}}}//6、投注最后一个篮球号码while (true) {System.out.println(请您输入最后一个蓝球号码1-16);int number sc.nextInt();if (number 1 || number 16){System.out.println(对不起您输入的蓝球号码范围不对);}else {numbers[6] number;break;//蓝球号码录入成功结束循环}}return numbers;}private static boolean exist(int[] numbers, int number) {//需求判断number这个数是否在numbers数组中存在//numbers [12,25,18,0,0,0,0]//number 25for (int i 0; i numbers.length; i) {if (numbers[i] 0){break;}if (numbers[i] number){return true;}}return false;}//2、设计一个方法随机一组中奖号码出来6个红球号码1个蓝球号码public static int[] createLuckNumbers(){//1、创建一个整型数组用于存储7个号码int[] numbers new int[7];Random r new Random();//2、遍历前6个位置处依次随机一个红球号码存入1-33不重复for (int i 0; i numbers.length - 1; i) {// i 0 1 2 3 4 5while (true) {//3、为当前这个位置随机一个红球号码出来存入:1-33 (0,32)1int number r.nextInt(33)1;//4、判断这个号码是否之前出现过红球号码不能重复if(!exist(numbers,number)) {//number不重复numbers[i] number;break; //结束死循环代表找到了当前这个位置的一个不重复的红球号码了}}}//3、录入一个蓝球号码numbers[6] r.nextInt(16)1;return numbers;}}总结
本次案例中是如何去保证随机的6个中奖的红球号码不重复的?
答每次随机一个1-33之间俺的红球号码后都去调用一个方法来判断这个号码是否已经出现过如果出现过让用户重新选号 Java案例模拟双色求[拓展案例]判断中奖情况 第三步判断用户是否中奖 package com.liu;import java.util.Random;
import java.util.Scanner;public class Test10 {public static void main(String[] args) {//目标完成双色球系统的开发int[] userNumbers userSelectNumber();System.out.println(投注的号码);printArray(userNumbers);int[] luckNumbers createLuckNumbers();System.out.println(中奖的号码);printArray(luckNumbers);judge(userNumbers,luckNumbers);}public static void printArray(int[] arr){System.out.print([);for (int i 0; i arr.length; i) {System.out.print(i arr.length-1 ? arr[i] :arr[i],);}System.out.println(]);}//1、设计一个方法用于投注一组号码并返回前6个是红球号码后1个是蓝球号码public static int[] userSelectNumber(){//2、创建一个整型数组用于存储用户投注的7个号码前6个是红球号码最后1个是篮球号码int[] numbers new int[7];//numbers [0,0,0,0,0,0,0]// 0 1 2 3 4 5 6Scanner sc new Scanner(System.in);//3、遍历前6个位置让用户一次投注6好红球号码存入for (int i 0; i numbers.length-1; i) {//i 0 1 2 3 4 5while (true) {//4、开始让用户为当前位置投入一个红球号码1-33之间不能重复System.out.println(请您输入第(i1)个红球号码1-33之间不能重复);int number sc.nextInt();//5、判断用户输入的红球是否在1-33之间if (number 1 || number 33){System.out.println(对不起您输入的红球号码不在1-33之间请确认);}else {//号码在1-33之间接着继续判断这个号码是否重复部重复才可以使用if(exist(numbers,number)){//number当前这个红球号码是重复了System.out.println(对不起您当前输入的红球号码前面选择过了重复了请缺人);}else {//number记住的这个号码没有重复了就可以使用了numbers[i] number;break;//结束当前死循环}}}}//6、投注最后一个篮球号码while (true) {System.out.println(请您输入最后一个蓝球号码1-16);int number sc.nextInt();if (number 1 || number 16){System.out.println(对不起您输入的蓝球号码范围不对);}else {numbers[6] number;break;//蓝球号码录入成功结束循环}}return numbers;}private static boolean exist(int[] numbers, int number) {//需求判断number这个数是否在numbers数组中存在//numbers [12,25,18,0,0,0,0]//number 25for (int i 0; i numbers.length; i) {if (numbers[i] 0){break;}if (numbers[i] number){return true;}}return false;}//2、设计一个方法随机一组中奖号码出来6个红球号码1个蓝球号码public static int[] createLuckNumbers(){//1、创建一个整型数组用于存储7个号码int[] numbers new int[7];Random r new Random();//2、遍历前6个位置处依次随机一个红球号码存入1-33不重复for (int i 0; i numbers.length - 1; i) {// i 0 1 2 3 4 5while (true) {//3、为当前这个位置随机一个红球号码出来存入:1-33 (0,32)1int number r.nextInt(33)1;//4、判断这个号码是否之前出现过红球号码不能重复if(!exist(numbers,number)) {//number不重复numbers[i] number;break; //结束死循环代表找到了当前这个位置的一个不重复的红球号码了}}}//3、录入一个蓝球号码numbers[6] r.nextInt(16)1;return numbers;}//3、设计一个方法用于判断用户的中奖情况public static void judge(int[] userNumbers,int[] luckNumbers){//userNumber [12,14,16,18,23,26,8]//userNumber [16,17,18,19,26,32,8]//2、分别定义2个变量用于记住红球命中几个以及蓝球命中了几个int redCount 0;int blueCout 0;//先判断红球命中的数量//遍历用户投注的号码的前6 个红球for (int i 0; i userNumbers.length; i) {//userNumber[i]//开始遍历中奖号码的前6个红球号码看用户当前选择的这个号码是否命中了for (int j 0; j luckNumbers.length; j) {if (userNumbers[i] luckNumbers[j]){redCount;break;}}}//3、判断蓝球是否命中了blueCout userNumbers[6] luckNumbers[6] ? 1:0;System.out.println(您命中的红球数量是 redCount);System.out.println(您命中的蓝球数量是 blueCout);//4、判断中奖详情并输出结果if (redCount 6 blueCout 1){System.out.println(恭喜您中奖1000万可以开始享受人生了~);}else if (redCount 6 blueCout 0){System.out.println(恭喜您中奖500万可以稍微开始享受人生了~);}else if (redCount 5 blueCout 1){System.out.println(恭喜您中奖3000元~);}else if (redCount 5 blueCout 0 || redCount 4 blueCout 1){System.out.println(恭喜您中奖200元~);}else if (redCount 4 blueCout 0 || redCount 3 blueCout 1){System.out.println(恭喜您中奖10元~);}else if (redCount 3 blueCout 1 ) {System.out.println(恭喜您中奖5元~);}else {System.out.println(感谢参与);}}
}总结
如何统计用户投注的红球的命中数量的
遍历用户选择的每个红球号码每遍历一个红球号码时都去遍历中奖号码数组中的全部红球号码看当前选的红球号码是否在中奖号码中存在存在则红球命中数量加1。 面向对象基础入门 面向对象编程快速入门
Java是面向对象的程序设计语言Java语言提供了定义类、成员变量、方法等最基本的功能。类可被认为是一种自定义的数据类型可以使用类来定义变量所有使用类定义的变量都是引用变量它们将会引用到类的对象。类用于描述客观世界里的某以类对象的共同特征而对象则是类的具体存在Java程序使用类的构造器来创建该类的对象。
Java也支持面向对象的三大特征封装、继承和多态Java提供了private、protected和public三个访问控制修饰符来实现良好的封装提供了extends关键字来让子类继承父类子类继承父类就可以继承到父类的成员变量和方法如果访问控制运行子类实例可以直接调用父类里定义的方法。继承是实现类复用的重要手段除此之外也可通过组合关系来实现这种复用从某种程度上来看继承和组合具有相同的功能。使用继承关系来实现复用时子类对象可以直接赋给父类变量这个变量具有多态性编程更加灵活而利用组合关系来实现复用时则不具备这种灵活性。
构造器用于对类实例进行初始化操作构造器支持重载如果多个重载的构造器里包含了相同的初始化代码则可以把这些初始化代码放置在普通初始化块里完成初始化块总在构造器执行之前被调用。除此之外Java还提供了一种静态初始化块静态初始化块用于初始化类在类初始化阶段被执行。如果继承数里的某一个类需要被初始化时系统将会同时初始化该类的所有父类。
Java是面向对象的程序设计语言类是面向对象的重要内容可以把类当成一种自定义类型可以使用类来定义变量这种类型的变量统称为引用变量。也就是说所有类是引用类型。
计算机是用来处理数据的 package com.liu.object;public class Student {String name;double chinese;double math;public void printTotalScore(){System.out.println(name 的总成绩是 (chinese math));}public void printAverageScore(){System.out.println(name 的平均成绩是 (chinese math)/2.0);}
}package com.liu.object;public class Test {public static void main(String[] args) {//目标面向对象编程快速入门//1、创建一个学生对象封装波妞的数据Student s1 new Student();s1.name 波妞;s1.chinese 100;s1.math 100;s1.printTotalScore();s1.printAverageScore();//2、再创建一个学生对象封装波仔的数据Student s2 new Student();s2.name 波仔;s2.chinese 59;s2.math 100;s2.printTotalScore();s2.printAverageScore();}
}面向对象的程序设计过程中有两个重要概念类class和对象object也被称为实例instance其中类是某一批对象的抽象可以把类理解成某种概念对象才是一个具体存在的实体从这个意义上来看日常所说的人其实都是人的实例而不是人类。
Java语言是面向对象的程序设计语言类和对象是面向对象的核心。Java语言提供了对创建类和创建对象简单的语法支持。 Java语言里定义类的简单语法如下
[修饰符] calss 类名 {
零个到多个构造器定义 . . .
零个到多个成员变量 . . .
零个到多个方法 . . . } 在上面的语法格式中修饰符可以是public、final、abstract或者完全省略这三个修饰符类名只要是一个合法的标识符即可但这仅仅满足的是Java的语法要求如果从程序的可读性方面来看Java类名必须是由一个或多个有意义的单词连缀而成的每个单词首字母大写其他字母全部小写单词与单词之间不要使用任何分隔符。
对一个类定义而言可以包含三种最常见的成员构造器、成员变量和方法三种成员都可以定义零个或多个如果三种成员都只定义零个就是定义了一个空类这没有太大的实际意义。
类里各成员之间的定义顺序没有任何影响各成员之间可以相互调用但需要指出的是static修饰的成员不能访问没有static修饰的成员。
成员变量用于定义该类或该类的实例所包含的状态数据方法则用于定义该类或该类的实例的行为特征或者功能实现。构造器用于构造该类的实例Java语言通过new关键字来调用构造器从而返回该类的实例。
构造器是一个类创建对象的根本途径如果一个类没有构造器这个类通常无法创建实例。因此Java程序员为一个类提供了构造器系统将不再为该类提供构造器。 面向对象编程的快速入门
开发一个一个的对象把数据交给对象再调用对象的方法来完成对数据的处理。 定义方法的语法格式如下
[修饰符] 方法返回值类型 方法名形参列表
{
//由零条到多条可执行语句组成的方法体
}
对定义方法语法格式的详细说明如下
1、修饰符修饰符可以省略也可以是public、proteced、private、static、final、abstract其中public、protected、private三个最多只能出现其中之一abstract和final最多只能出现其中之一它们可以与static组合起来修饰方法。
2、方法返回值类型返回值类型可以是Java语言允许的任何数据类型包括基本类型和引用类型如果声明了方法返回值类型则方法体内必须有一个有效的return语句该语句返回一个变量或一个表达式这个变量或者表达式的类型必须与此处声明的类型匹配。除此之外如果一个方法没有返回值则必须使用void来声明没有返回值。
3、方法名方法名的命名规则与成员变量的命名规则基本相同但由于方法用于描述该类或该类的实例的行为特征或功能实现因此通常建议方法名以英文动词开头。
4、形参列表形参列表用于定义该方法可以接受的参数形参列表由零组到多组“参数类型 形参名”组合而成多组参数之间以英文隔开形参类型和形参名之间以空格隔开。一旦在定义方法是指定了形参列表则调用该方法时必须传入对应的参数值——谁调用方法谁负责为形参赋值。
方法体里多条可执行性语句之间有严格的执行顺序排在方法体前面的语句总是先执行排在方法体后面的语句总是后执行。
static是一个特殊的关键字它可用于修饰方法、成员变量等成员。static修饰的成员表面它属于这个类本身而不属于该类的单个实例因为通常把static修饰的成员变量和方法也称类变量、类方法。不使用static修饰的普通方法、成员变量则属于该类的单个实例而不属于该类。因为通常把不使用static修饰的成员变量和方法也称为实例变量、实例方法。
由于static的英文直译就是静态的意思因此有时也把static修饰的成员变量和方法称为静态变量和静态方法把不使用static修饰的成员变量和方法称为非静态变量和非静态方法。静态成员不能直接访问非静态成员 面向对象基础深刻认识面向对象 面向对象编程的好处
万物皆对象
更加符合人类思维习惯编程更简单、更直观
程序中的对象到底是个啥
对象本质上是一种特殊的数据结构 对象是用类new出来的有了类就可以创建出对象 例 对象是怎么出来的
class也就是类也称为对象的设计图或者对象的模板)。
祖师爷认为万物皆对象谁的数据谁处理。 创建对象的根本途径是构造器通过new关键字来调用某个类的构造器即可创建这个类的实例。 面向对象基础对象在计算机中的执行原理类与对象注意事项 多个对象在计算机中的执行原理 对象在计算机中执行原理是怎么回事
Student s1 new Student
每次new Student就是在堆内存中开辟一块内存区域代表一个学生对象。
s1变量里面记住的是学生对象的地址。 如何识别引用类型的变量
Student s1 new Student
s1变量中存储的是对象的地址因此变量s1也称为引用类型的变量 类和对象的一些注意事项 package com.liu.object;public class Test2 {public static void main(String[] args) {//目标掌握类与对象的一些注意事项//成员变量存在默认值Student s new Student();System.out.println(s.name);System.out.println(s.chinese);System.out.println(s.math);//多个变量指向同一个对象就会相互影响Student s1 new Student();s1.name 张三;Student s2 s1;s2.name 李四;System.out.println(s1.name);}
}注意
当堆内存中的对象没有被任何变量引用指向时就会被判定为内存中的 “垃圾”。
Java存在自动垃圾回收机制会自动清楚掉垃圾对象程序员不用操心。 面向对象基础this关键字 Java提供了一个this关键字this关键字总是指向调用该方法的对象。根据this出现位置的不同this作为对象的默认引用有两种情形构造器中引用该构造器正在初始化的对象 在方法中引用调用该方法的对象。
this关键字最大的作用就是让类中一个方法访问该类的另一个方法或实例变量。
大部分时候一个方法访问该类中定义的其他方法、成员变量时加不加this前缀的效果是完全一样的。
this是什么
this就是一个变量可以用在方法中用来拿到当前对象。
哪个对象调用方法this就指向哪个对象也就是拿到哪个对象。
package com.liu.thisdemo;public class Student {public void printThis(){System.out.println(this);}
}package com.liu.thisdemo;public class Test {public static void main(String[] args) {//目标认识Test账务this的应用场景。Student s1 new Student();System.out.println(s1);s1.printThis();System.out.println(---------------------------------------);Student s2 new Student();System.out.println(s2);s2.printThis();}
}this的执行原理 this的应用场景
this主要用来解决变量名称冲突问题的。
package com.liu.thisdemo;public class Student {double score;public void printThis(){System.out.println(this);}public void printPass(double score){if (this.score score){System.out.println(恭喜您成功考入哈佛大学);}else{System.out.println(落选了);}}
}package com.liu.thisdemo;public class Test {public static void main(String[] args) {//目标认识Test账务this的应用场景。Student s1 new Student();System.out.println(s1);s1.printThis();System.out.println(---------------------------------------);Student s2 new Student();System.out.println(s2);s2.printThis();Student s3 new Student();s3.score 325;s3.printPass(250);}
}面向对象基础构造器 构造器是一个特殊的方法这个特殊方法用于创建实例时执行初始化。构造器时创建对象的重要途经即使 使用工厂模式、反射等方式创建对象其实实质依然是依赖于构造器因此Java类必须包含一个或一个以上的构造器。
构造器最大的用处就是在创建对象时执行初始化。如果想改变系统默认的初始化想让系统创建对象时就为该对象的实例变量显式指定初始值就可以通过构造器来实现。
构造器是什么样子 public class Student {//无参数构造器public Student(){}//有参数构造器public Student(String name,double score){}
}构造器是一个特殊的方法定义构造器的语法格式与定义方法的语法格式很像
定义构造器的语法格式如下
[构造器] 构造器名 形参列表
{
// 由零条到多条可执行性语句组成的构造器执行体
}
对定义构造器语法格式的详细说明如下
1、修饰符修饰符可以省略也可以是public、protected、private其中之一。2、构造器名构造器名必须和类名相同3、形参列表和定义方法形参列表格式完全相同值得指出的是构造器既不能定义返回值类型也不能使用void声明构造器没有返回值。如果为构造器定义了返回值类型或使用void声明构造器没有返回值编译时不会出错但Java会把这个所谓的构造器当成方法来处理——它就不再是构造器。
构造器有什么特点
创建对象时对象会去调用构造器。Student s new Student ()
构造器的常见应用场景
创建对象时同时完成对对象成员变量属性的初始化赋值。
package com.liu.constructor;public class Student {String name;double score;//无参数构造器public Student(){System.out.println(无参数构造器);}//有参数构造器public Student(String name,double score){System.out.println(有参数构造器);this.name name;this.score score;}
}package com.liu.constructor;public class Test {public static void main(String[] args) {//目标认识构造器并掌握构造器的特点、应用场景、注意事项// Student s new Student(); //无参数构造器Student s new Student(懒羊羊,500); //有参数构造器Student s1 new Student();s1.name 过期的罐头;s1.score 100;Student s2 new Student(小懒,90);System.out.println(s2.name);System.out.println(s2.score);}
}构造器的注意事项
类在设计时如果不写构造器Java时是会为类自动生成一个无参构造器的。一旦定义了有参数构造器Java就不会帮我们的类自动生成无参构造器了此时就建议自己手写一个无参数构造器出来了。
构造器重载
同一个类里具有多个构造器多个构造器的形参列表不同即被称为构造器重载。构造器重载允许Java类里包含多个初始化逻辑从而允许使用不同的构造器来初始化Java对象。
构造器重载和方法重载基本相似要求构造器的名字相同这一点无须特别要求因为构造器必须与类名相同所以同一个类的所有构造器名肯定相同。为了让系统能区分不同的构造器多个构造器的参数列表必须不同。
使用this调用另一个重载的构造器只能在构造器中使用而且必须作为构造器执行体的第一条语句。使用this调用重载构造器时系统会根据this后括号里的实参来调用形参列表与之对应的构造器 面向对象基础封装实体JavaBean 面向对象的三大特征封装、继承、多态
封装指的是将对象的状态信息隐藏在对象内部不允许外部程序直接访问对象内部信息而是通过该类所提供的方法来实现对内部信息的操作和访问。
封装是面向对象编程程序语言对客观世界的模拟在客观世界里对象的状态信息都被隐藏在对象内部外界无法直接操作和修改。
什么是封装
就是用类设计对象处理某一事物的数据时应该把要处理的数据以及处理这些数据的方法设计到一个对象中去。 封装的设计规范
合理隐藏、合理暴露
package com.liu.encapsulation;public class Student {private double score;public void setScore(double score){if (score 0 score 100 ) {this.score score;}else {System.out.println(数据非法);}}public double getScore() {return score;}public void printPass(){System.out.println(score 60 ? 成绩及格 : 成绩不合格);}
}package com.liu.constructor;import com.liu.encapsulation.Student;public class Teacher {public static void main(String[] args) {//目标掌握封装的设计规范合理隐藏合理暴露Student s1 new Student();s1.setScore(99);System.out.println(s1.getScore()); //99}
}对一个类或对象实现良好的封装可以实现以下目的
隐藏类的实现细节 让使用者只能通过实现预定的方法来访问数据从而可以在该方法里加入控制逻辑限制对成员变量的不合理访问。可进行数据检查从而有利于保证对象信息的完整性。便于修改提高代码的可维护性。
为了实现良好的封装需从两方面考虑
将对象的成员变量和实现细节隐藏起来不允许外部直接访问。把方法暴露出来让方法来控制对这些成员变量进行安全的访问和操作
因此封装实际上由两个含义把该隐藏的隐藏起来把该暴露的暴露出来。这两个方面都需要通过使用Java提供的访问控制符来实现。
代码层面如何控制对象的成员公开或隐藏
公开成员可以使用public公开进行修饰
隐藏成员使用private私有隐藏进行修饰
访问控制符级别由小到大private 》 default 》protected 》 public
private当前类访问权限
如果类里的一个成员包括成员变量、方法、和构造器等使用private访问控制符来修饰则这个成员只能在当前类的内部被访问。很显然这个访问控制符用于修饰成员变量最合适使用它来修饰成员变量就可以把成员变量隐藏在该类的内部。
default包访问权限
如果类里的一个成员包括成员变量、方法和构造器等等或者一个外部类不使用任何访问控制修饰符就称它是包访问权限的default访问控制的成员或外部类可以被相同包下的其他类访问。default并没有对应的访问控制符当不使用任何访问控制符来修饰类或类成员时系统默认使用该访问控制级别。
protected子类访问权限
如果一个成员包括成员变量、方法和构造器等使用protected访问控制修饰符那么这个成员既可以被同一个包中的其他类访问也可以被不同包中的子类访问。在通常情况下如果使protected来修饰一个方法通常是希望其子类来重写这个方法。
public公共访问权限
这是一个最宽松的访问控制级别如果一个成员包括成员变量、方法和构造器等或者一个外部类使用public访问控制符修饰那么这个成员或外部类就可以被所有类访问不管访问类和被访问类是否处于同一个包中是否具有父子继承关系。 访问控制符的使用存在如下几条基本原则
类里的绝大部分成员变量都应该使用private修饰只有一些static修饰的、类似全局变量的成员变量才可能考虑使用public修饰。除此之外有些方法只用于辅助实现该类的其他方法这些方法被称为工具方法工具方法也应该使用private修饰。如果某个类主要用作其他类的父类该类里包含的大部分方法可能仅希望被其子类重写而不想被外界直接调用则应该使用protected修饰这些方法。希望暴露出来给其他类自由调用的方法应该使用public修饰因此类的构造器通过使用public修饰从而允许在其他地方创建该类的实例。因为外部类通常都希望被其他类自由使用所以大部分外部类都使用public修饰。
实体类是什么
就是一种特殊形式的类
这个类中的成员变量都要私有并且要对外提供相应的getXxxsetXxx方法。
类中必须要有一个公共的无参的构造器。
package com.liu.javabean;public class Student {//1、必须私有成员变量并为每个成员变量都提供get、set方法private String name;private double score;//2、必须为类提供一个公开的无参数构造器public Student() {}public Student(String name, double score) {this.name name;this.score score;}public void setName(String name) {this.name name;}public void setScore(double score) {this.score score;}public String getName() {return name;}public double getScore() {return score;}}package com.liu.javabean;public class Test {public static void main(String[] args) {//目标掌握实体类的书写要求、特点、应用场景Student s1 new Student();s1.setName(懒羊羊);s1.setScore(99);System.out.println(s1.getName());System.out.println(s1.getScore());}
}实体类的应用场景
实体类只负责数据存取而对数据的处理交给其他类来完成以实现数据和数据业务处理相分离。
实体类对应的是软件开发里现在比较流行的开发方式数据和数据的业务处理相分离。
package com.liu.javabean;public class Student {//1、必须私有成员变量并为每个成员变量都提供get、set方法private String name;private double score;//2、必须为类提供一个公开的无参数构造器public Student() {}public Student(String name, double score) {this.name name;this.score score;}public void setName(String name) {this.name name;}public void setScore(double score) {this.score score;}public String getName() {return name;}public double getScore() {return score;}}package com.liu.javabean;public class StudentOperator {private Student student;public StudentOperator(Student student){this.student student;}public void printPass(){if (student.getScore() 60){System.out.println(student.getName() 学生成绩及格);}else {System.out.println(student.getName() 学生成绩不及格);}}
}package com.liu.javabean;public class Test {public static void main(String[] args) {//目标掌握实体类的书写要求、特点、应用场景Student s1 new Student();s1.setName(懒羊羊);s1.setScore(99);System.out.println(s1.getName());System.out.println(s1.getScore());StudentOperator operator new StudentOperator(s1);operator.printPass();}
}面向对象基础综合案例成员变量、局部变量区别 案例模仿电影信息系统
需求
展示系统中的全部电影每部电影展示名称、价格
运行用户根据电影编号id查询出某个电影的详细信息 目标
使用所学的面向对象编程实现以上2个需求
package com.liu.demo;public class Movie {private int id;private String name;private double price;private double score;private String director;private String actor;private String info;public Movie() {}public Movie(int id, String name, double price, double score, String director, String actor, String info) {this.id id;this.name name;this.price price;this.score score;this.director director;this.actor actor;this.info info;}public int getId() {return id;}public void setId(int id) {this.id id;}public String getName() {return name;}public void setName(String name) {this.name name;}public double getPrice() {return price;}public void setPrice(double price) {this.price price;}public double getScore() {return score;}public void setScore(double score) {this.score score;}public String getDirector() {return director;}public void setDirector(String director) {this.director director;}public String getActor() {return actor;}public void setActor(String actor) {this.actor actor;}public String getInfo() {return info;}public void setInfo(String info) {this.info info;}
}package com.liu.demo;public class MovieOperator {private Movie[] movies;public MovieOperator(Movie[] movies){this.movies movies;}//1.展示系统全部电影信息 movies 【m1m2m3 .....】public void printAllMovies(){System.out.println(-------系统全部电影信息如下---------);for (int i 0; i movies.length; i) {Movie m movies[i];System.out.println(编号 m.getId());System.out.println(名称 m.getName());System.out.println(价格 m.getPrice());System.out.println(-----------------------------------------------------------);}}//2、根据电影的编号查询出该电影的详细信息并展示public void searchMovieById(int id){for (int i 0; i movies.length; i) {Movie m movies[i];if (m.getId() id){System.out.println(该电影详细如下);System.out.println(编号 m.getId());System.out.println(名称 m.getName());System.out.println(价格 m.getPrice());System.out.println(得分 m.getScore());System.out.println(导演 m.getDirector());System.out.println(主演 m.getActor());System.out.println(其他信息 m.getInfo());return; //已经找到了电影信息没有必要再执行了}}System.out.println(没有该电影信息~);}
}package com.liu.demo;import java.util.Scanner;public class Test {public static void main(String[] args) {//1、设计一个电影类//2、设计一个电影的操作类//3、准备全部电影数据Movie[] movies new Movie[4];Movie m1 new Movie(1,水门桥,38.9,9.8,徐克,吴京,12万人想看);Movie m2 new Movie(2,出拳吧,39,7.8,唐晓白,田甫,3.5万人想看);Movie m3 new Movie(3,月球陨落,42,7.9,罗兰,贝瑞,17.9万人想看);Movie m4 new Movie(4,一点到家,35,8.7,许宏宇,刘昊然,10.5万人想看);movies[0] m1;movies[1] m2;movies[2] m3;movies[3] m4;//4、创建一个电影操作类的对象接收电影数据并对其进行业务处理MovieOperator operator new MovieOperator(movies);operator.printAllMovies();operator.searchMovieById(3);System.out.println(------------------------------------------------------);Scanner sc new Scanner(System.in);while (true) {System.out.println(电影信息系统);System.out.println(1、查询全部电影信息);System.out.println(2、根据id查询某个电影的详细信息展示);System.out.println(请您输入操作命令);int command sc.nextInt();switch (command){case 1://展示全部电影信息operator.printAllMovies();break;case 2://根据id查询某个电影的详细信息展示System.out.println(请您输入查询的电影id);int id sc.nextInt();operator.searchMovieById(id);break;default:System.out.println(您输入的命令有问题~);}}}
}成员变量和局部变量的区别 package com.liu.variable;public class Student {//成员变量对象的属性FieldString name;double score;
}package com.liu.variable;public class Test {public static void main(String[] args) {//局部变量int a 20;//局部变量必须赋值
// int b;
// System.out.println(b); 报错String name 懒羊羊;//name 从13行开始到最后一个 } 结束}
}定义成员变量的语法格式如下
[修饰符] 类型 成员变量名 [ 默认值] 对定义成员变量语法格式的详细说明如下
1、修饰符修饰符可以省略也可以是public、protected、private、static、final其中public、protected、private三个最多只能出现其中之一可以与static、final组合起来修饰成员变量。
2、类型类型可以是Java语言运行的任何数据类型包括基本类型和现在结束的引用类型。
3、成员变量名成员变量名只要是一个合法的标识符即可但这只是从语法角度来说的如果从程序可读性角度来看成员变量名应该由一个或多个有意义的单词连缀而成第一个单词首字母小写后面每个单词首字母大写其他字母全部小写单词与单词之间不要使用任何分隔符。成员变量用于描述类或对象包含的状态数据因此成员变量名建议使用英文名词。
4、默认值定义成员变量还可以指定一个可选的默认值。 总结面向对象编程oop基础部分 面向对象的思想
面向拿或者找
对象东西
面向对象编程拿或者找东西过来编程解决问题
面向对象把现实世界中的事物全部看成一个一个的对象来解决问题的。万物皆对象
面向对象编程的好处代码符号人类的思维习惯编程程序更简单看程序更容易理解吧。
类、对象
类设计图相同事物共同特征的描述
对象对象是类的具体的实例。
对象 实例
在Java中必须定义类才能得到对象
定义类来创建对象使用
定义类的格式 定义类有一些注意事项
1、类名首字母建议大写有意义满足驼峰不要用关键字合法的标识符
2、一个Java文件中可以定义多个类但是只能一个类是public修饰的而且public修饰的类名必须为Java代码的文件名称否则报错 类中具体怎么实现
定义汽车类为实例
一般名词定义成成员变量属性修饰符 数据类型 变量名称 初始值
private String name
private double price
成员变量不建议初始值存在默认值默认值的规则整型是0浮点型是0.0引用类型null布尔型是false
一般动词定义成方法行为 具体定义类的例子 创建对象
类名 对象名 new 构造器
对象怎么使用
对象名 . 成员变量 对象名 . 成员方法
构造器
作用初始化一个类的对象并返回这个对象的地址
详细格式修饰符 类名形参 { ........... } 构造器的分类 :
无参数构造器初始化一个类的对象并返回这个对象的地址里面的数据都是默认值
有参数构造器初始化一个类的对象并返回这个对象的地址并且可以同时为对象赋值
构造器如何调用
类名 对象名称 new 构造器
注意
任何类写出来自带一个无参数构造器写不写都有
如何在这个类定义了一个有参数构造器了那么无参数构造器就消失了此时如果你还要使用无参构造器你必须自己写一个。 this 关键字
this的作用代表了当前对象的地址可以访问当前对象的成员变量和成员方法 this的具体用在哪
可以用在参构造器中 可以用在方法中 封装
面向对象的三大特征封装、继承、多态 封装的基本思想决定属性和行为归属谁的问题
定义人类名称年龄吃饭睡觉
定义图类半径画圆
定义门类开门高宽
定义票类票价地址买票 如何更好的封装呢
成员变量建议private私有化只能本类访问了。
合理暴露提供成套的getter和setter方法暴露取值和赋值
封装JavaBean
是什么就是所谓的实体类学生类、老师类、汽车类、人类、票类
作用创建对象封装数据的。
标准Bean的书写要求 成员变量和局部变量
成员变量指的是在类里定义的变量局部变量指的是在方法里定义的变量。
不管是成员变量还是局部变量都应该遵循相同的命名规则从语法角度来看只要是一个合法的标识符即可但从程序可读性角度来看应该是多个有意义的单词连缀而成其中第一个单词首字母小写后面每个单词首字母大写。
局部变量和成员变量的区别 成员变量被分为类变量和实例变量两种定义成员变量时没有static修饰的就是实例变量有static修饰的就是类变量。其中类变量从类的准备阶段起开始存在直到系统完全销毁这个类类变量的作用域与这个类的生存范围相同而实例变量则从该类的实例被创建起开始存在直到系统完全销毁这个实例实例变量变量的作用域与对于实例的生存范围相同。
一个类在使用之前要经过类加载、类验证、类准备、类解析、类初始化等几个阶段。
其中类变量可以理解为类成员变量它作为类本身的一个成员与类本身共存亡实例变量则可理解为实例成员变量它作为实例的一个成员与实例共存亡。
1、只要类存在程序就可以访问该类的类变量。在程序中访问类变量通过如下语法 类 . 类变量 2、只要实例存在程序就可以访问该实例的实例变量。在程序中访问实例变量通过如下语法 实例 . 实例变量 3、类变量也可以让该类的实例来访问。通过实例来访问变量的语法如下 实例 . 类变量
成员变量无须显示初始化只要为一个类定义了类变量或实例变量系统就会在这个类的准备阶段或创建该类的实例时进行默认初始化成员变量默认初始化时的赋值规则与数组动态初始化时数组元素的赋值规则完全相同。
类变量的作用域比实例变量的作用域更大实例也可访问类变量同一个类的所有实例访问类变量时实际上访问的是该类本身的同一个变量也就是说访问了同一片内存区。
局部变量根据定义形式的不同又可以被分为如下三种
1、形参在定义方法签名时定义的变量形参的作用域在整个方法内有效。
2、方法局部变量在方法体内定义的局部变量它的作用域是从定义该变量的地方生效到该方法结束时失效。
3、代码块局部变量在代码块中定义的局部变量这个局部变量的作用域从定义该变量的地方生效到该代码块结束时失效。 在同一个类里成员变量的作用范围是整个类内有效一个类里不能定义两个同名的成员变量即使一个是类变量一个是实例变量也不行一个方法里不能定义两个同名的方法局部变量方法局部变量与形参也不能同名同一个方法中不同代码块内的代码局部变量可以同妈妈如果先定义代码块局部变量后定义方法局部变量前面定义的代码块局部变量与后面定义的方法局部变量也可以同名。 常用API课程介绍、包 为什么要学别人写好的程序
不要重复造轮子
开发效率高
Java提供了哪些API
API文档
先学习包为什么先学习包
包是分门别类管理程序的。 Java引入了包package机制提供了类的多层命名空间用于解决类的命名冲突、类文件管理等问题。
Java允许将一组功能相关的类放在同一个package下从而组成逻辑上的类库单元。如果希望把一个类放在指定的包结构下应该在Java源程序的第一个非注释行放置。
一旦在Java源文件中使用了这个package语句就意味着该源文件里定义的所有类都属于这个包。位于包中的每个类的完整类名都应该是包名和类名的组合如果其他人需要使用该包下的类也应该使用包名加类名的组合。
什么是包
包是用来分门别类的管理各种不同程序的类似于文件夹建包有利于程序的管理和维护。建包的语法格式 在自己程序中调用其他包下的程序的注意事项
如果当前程序中要调用自己所在包下的其他程序可以直接调用。同一个包下的类互相可以直接调用如果当前程序中要调用其他包下的程序则必须在当前程序中导包才可以访问导包格式import 包名 . 类名如果当前程序中要调用Java提供的程序也需要先导包才可以使用但Java . lang 包下的程序是不需要我们导包的可以直接使用。如果当前程序中要调用多个不同包下的程序而这些程序名正好一样此时默认只能导入一个程序另一个程序必须带包名访问。
idea自动导包 package com.liu.pkg;import com.liu.pkg.itcat.Demo1;
import com.liu.pkg.liu.Demo2;import java.util.Random;
import java.util.Scanner;public class Test {public static void main(String[] args) {//目标掌握如何在自己的程序中调用其他包下的程序有哪些注意//1、同一个包下的程序可以直接调用Demo d new Demo();d.print();//2、访问其他包下的程序必须导包才可以访问Demo1 d2 new Demo1();d2.print();//3、自己的程序中调用Java提供的程序也需要先导包才可以使用注意java.lang包下的程序是不需要我们导包的可以直接使用。Scanner sc new Scanner(System.in);String s 黑马;Random r new Random();//4、访问多个其他包下的程序这些程序名又一样的情况下默认只能导入一个程序另一个程序必须带包名和类名来访问。Demo2 d3 new Demo2();d3.print();com.liu.pkg.itcat.Demo2 d4 new com.liu.pkg.itcat.Demo2();d4.print();}
}package com.liu.pkg.itcat;public class Demo1 {public void print(){System.out.println(懒羊羊);}
}package com.liu.pkg.itcat;public class Demo2 {public void print(){System.out.println(itcast);}
}package com.liu.pkg.liu;public class Demo2 {public void print(){System.out.println(liu);}
}package com.liu.pkg;public class Demo {public void print(){System.out.println(Hello World);}
}Java的核心类都放在Java包以及其子包下Java扩展的许多类都放在javax包以及其子包下。这些实用类也就是API应用程序接口Oracle按这些类的功能分别放在不同的包下。
Java的常用包
java . lang 这个包下包含了Java语言的核心类如String、Math、System和Thread类等使用这个包下的类无须使用import语句导入系统会自动导入这个包下的所有类。java . util 这个包下包含了Java的大量工具类/接口和集合框架类/接口例如Arrays和List、Set等。java . net 这个包下包含了一些Java网络编程相关的类/接口。java . io 这个包下包含了一些Java输入/输出编程相关的类/接口java . text 这个包下包含了一些Java格式化相关的类java . sql : 这个包下包含了Java进行JDBC数据库编程的相关类/接口java . awt : 这个包下包含了抽象窗口工具集Abstract Window Toolkits的相关类/接口这些类主要用于构建图形用户界面GUI程序。java . swing 这个包下包含了Swing图形用户界面编程的相关类/接口这些类可用于构建平台无关的GUI程序。 常用APIString、API 为什么要学字符串的处理呢 java . lang . String 代表字符串 封装字符串数据 处理字符串的方法
1、创建你对象 2、封装字符串数据 3、调用String的方法 String创建对象封装字符串数据的方式
方式一Java程序中的所有字符串文字例如abc“都为此类的对象 方式二调用String类的构造器初始字符串对象 package com.liu.string;public class StringDemo1 {public static void main(String[] args){//目标掌握创建String对象并封装要处理的字符串的两种方式//1、直接双引号封装字符串对象封装字符串数据String name liu;System.out.println(name);//2、new String 创建字符串对象并调用构造器初始化字符串String rs1 new String();System.out.println(rs1); // ”“String rs2 new String(lang);System.out.println(rs2);char[] chars {a,c,n};String rs3 new String(chars);System.out.println(rs3);byte[] bytes {97,98,99};String rs4 new String(bytes);System.out.println(rs4);}
}总结
1、string是什么可以做什么
代表字符串可以用来创建对象封装字符串数据并对其进行处理
2、String类创建对象封装字符串数据的方式有几种
方式一直接使用双引号“...”
方式二new String类调用构造器初始化字符串对象 String提供的操作字符串数据的常用方法 为什么是快速熟悉这些方法呢 API是解决需求的
package com.liu.string;public class StringDemo2 {public static void main(String[] args) {//目标快速熟悉String提供的处理字符串的常用方法String s 喜欢的东西买了吗;//1、获取字符串的长度System.out.println(s.length());//2、提取字符串中某个索引位置处的字符char c s.charAt(1);System.out.println(c);//字符串的遍历for (int i 0; i s.length(); i) {// i 0 1 2 3 4 5char ch s.charAt(i);System.out.println(ch);}System.out.println(------------------------------------);//3、把字符串转换成字符数组在进行遍历char[] chars s.toCharArray();for (int i 0; i chars.length; i) {System.out.println(chars[i]);}//4、判断字符串内容内容一样就返回trueString s1 new String(过期的罐头);String s2 new String(过期的罐头);System.out.println(s1 s2); //falseSystem.out.println(s1.equals(s2)); //true//5、忽略大小写比较字符串内容String c1 34AeFG;String c2 34aEfg;System.out.println(c1.equals(c2)); //falseSystem.out.println(c1.equalsIgnoreCase(c2)); //true//6、截取字符串内容(包前不包后)String s3 Java是最好的编程语言之一;String rs s3.substring(0,8);System.out.println(rs);//7、从当前索引位置一直截取导字符串的末尾String rs2 s3.substring(5);System.out.println(rs2);//8、把字符串中的某个内容替换成新内容并返回新的字符串对象给我们String info 这个电脑不好看;String rs3 info.replace(好看,**);System.out.println(rs3);//9、判断字符串是否包含某个关键字String info2 java是最好的程序语言之一我爱JavaJava不爱我;System.out.println(info2.contains(Java));System.out.println(info2.contains(java));System.out.println(info2.contains(Java2));//10、判断字符串是否以某个字符串开头String rs4 张三丰;System.out.println(rs4.startsWith(张));System.out.println(rs4.startsWith(张三));System.out.println(rs4.startsWith(张三2));//11、把字符串按照某个指定内容分割成多个字符串放到一个字符串数组中返回给我们String rs5 张无忌,周芷若,殷素素,赵敏;String[] names rs5.split(,);for (int i 0; i names.length; i) {System.out.println(names[i]);}}
}常用APIString的注意事项 String使用时的注意事项
第一点String对象的内容不可改变被称为不可变字符串对象 package com.liu.string;public class StringDemo3 {public static void main(String[] args) {//目标搞清楚String使用时的几个注意事项//1、String的对象是不可变的String name 林俊杰;name 程序员;name 靓仔;System.out.println(name);}
}第二点只要是以 “” 方式写出来的字符串对象会存储到字符串常量池且相同内容的字符串只存储一份但是通过方式创建字符串对象每一次都会产生一个新的对象在堆内容中。 package com.liu.string;public class StringDemo3 {public static void main(String[] args) {//目标搞清楚String使用时的几个注意事项//1、String的对象是不可变的String name 林俊杰;name 程序员;name 靓仔;System.out.println(name);//2、只要是双引号给出的字符串对象存储在常量池中而且内容相同时只会存储一份String s1 abc;String s2 abc;System.out.println(s1 s2);//3、new String 创建字符串对象每次new出来 的都是一个新对象就在堆内存中char[] chars {a,b,c};String a1 new String(chars);String a2 new String(chars);System.out.println(a1 a2 ); }
}案例阅读程序并回答问题 常用APIString案例 案例完成用户登录
需求
系统正确的登录和密码是liu/123456请在控制台开发一个登录界面接收用户输入的登录名和密码判断用户是否登录成功登录成功后展示” 欢迎进入系统“即可停止程序注意要求最多给用户三次登录机会 步骤
1、开发登录界面提示用户通过键盘输入登录名和密码。
2、设计一个登录方法对用户的登录名和密码进行正确性认证。
3、根据登录方法返回认证结果判断用户是否登录成功。
4、使用循环控制登录界面最多显示3次
package com.liu.string;import java.util.Scanner;public class StringTest4 {public static void main(String[] args) {//目标完成用户的登录案例for (int i 0;i 3;i) {//1、开发一个登录界面Scanner sc new Scanner(System.in);System.out.println(请您输入登录名称);String loginName sc.next();System.out.println(请您输入登录密码);String password sc.next();//5、开始调用登录方法去判断调用是否成功boolean rs login(loginName,password);if (rs){System.out.println(恭喜您欢迎进入系统);break;//跳出for循环代表登录成功}else {System.out.println(登录名或者密码错误请您确认);}}}//2、开发一个登录方法接收用户的登录名和密码返回认证的结果public static boolean login(String loginName,String password){//3、准备一份正确的登录名和密码String okLoginName liu;String okPassword 123456;//4、开始正式判断用户是否登录成功
// if (okLoginName.equals(loginName) okPassword.equals(password)){
// //登录成功
// return true;
// }else {
// return false;
// }return okLoginName.equals(loginName) okPassword.equals(password);}
}总结
1、字符串的比较使用比较好吗为什么什么时候使用
不好对于字符串的比较比较的是地址容易出业务bug基本数据类型的变量或者值应该使用比较
2、开发中比较字符串推荐使用什么方法比较
使用String提供的equals方法它只关心字符串内容一样就返回true
案例使用String来开发验证码
需求
实现随机产生验证码验证码的每位可能是数字、大写字母、小写字母 分析
1、设计一个方法该方法接收一个整型参数最终要返回对应位数的随机验证码
2、方法内定义2个字符串变量1个用来记住生成的验证码1个用来记住要用到的全部字符 3、定义for循环控制生成多少位随机字符每次得到一个字符范围内的随机索引根据索引提取
字符把该字符交给code变量连接起来循环结束后在循环外返回code即可。
package com.liu.string;import java.util.Random;public class StringTest5 {public static void main(String[] args) {//目标完成随机产生验证码验证码的每位可能是数字、大写字母、小写字母System.out.println(createCode(4));System.out.println(createCode(6));}//1、设计一个方法返回指定位数的验证码public static String createCode(int n){//2、定义2个变量 一个是记住最终产生的随机验证码 一个是记住可能用到的全部字符String code ;String data abcdefghijklmnopqrstuvwsyzABCDEFGHIJKLMNOPQRSTUVWSYZ0123456789;Random r new Random();//3、开始定义一个循环产生每位随机字符for (int i 0; i n; i) {//4、随机一个字符范围内的索引int index r.nextInt(data.length());//5、根据索引去全部字符串中提取该字符code data.charAt(index); // code code 字符}//6、返回code即可return code;}
}常用APIArrayList概述使用 什么是集合
集合是一种容器用来装数据的类似于数组
有数组为啥还学习集合
数组定义完成并启动后长度就固定了集合的特点集合大小可变开发中用的更多
集合的种类很多 ArrayList集合该怎么学呢 ArrayListE
是用的最多、最常见的一种集合。 package com.liu.arraylist;import java.util.ArrayList;public class ArrayListDemo1 {public static void main(String[] args) {//目标掌握如何创建ArrayList集合的对象并熟悉ArrayList提供的常用方法//1、创建ArrayList的集合对象// ArrayList list new ArrayList();// ArrayListString list new ArrayListString();
// 从jdk1.7开始才支持的ArrayListString list new ArrayList();list.add(懒羊羊);
// list.add(500);
// list.add(99.5);list.add(小懒);list.add(Java);System.out.println(list);//2、往集合中的某个索引位置处添加一个对象list.add(1,Mysql);System.out.println(list);//3、根据索引获取集合中某个索引位置处的值String rs list.get(1);System.out.println(rs);//4、获取集合的大小返回集合中存储的元素个数System.out.println(list.size());//5、根据索引删除集合中的某个元素值返回被删除的元素值给我们System.out.println(list.remove(1));System.out.println(list);//6、直接删除某个元素值删除成功会返回true反之//若出现相同的数据默认删除第一次出现的数据System.out.println(list.remove(Java));System.out.println(list);//7、修改某个索引位置处的数据修改后会返回原来的值给我们System.out.println(list.set(1, 勇敢懒羊羊));System.out.println(list);}
}ArrayList是什么怎么使用
是集合最常用的一种ArrayList是泛型类可以约束存储的数据类型创建对象调用无参构造器初始化对象public ArrayLIst调用相应的增删改查数据的方法 常用APIArrayList的应用案例 案例掌握从容器中找出某些书并成功删除的技巧 需求
现在假如购物车中存储了如下这些商品Java入门宁夏枸杞黑枸杞人字拖特级枸杞枸杞子。现在用户不想买枸杞了选择了批量删除请完成该需求。
分析
1、后台使用ArrayList集合表示购物车存储这些商品名。
2、遍历集合中的每个数据只要这个数据包含了“ 枸杞 ”则删除它。
3、输出集合看是否已经成功删除了全部枸杞数据了。
package com.liu.arraylist;import java.util.ArrayList;public class ArrayListTest2 {public static void main(String[] args) {//目标掌握从集合容器中找数据并删除的技巧//1、创建一个ArrayList集合对象ArrayListString list new ArrayList();list.add(Java入门);list.add(宁夏枸杞);list.add(黑枸杞);list.add(人字拖);list.add(特级枸杞);list.add(枸杞子);System.out.println(list); //[Java入门, 宁夏枸杞, 黑枸杞, 人字拖, 特级枸杞, 枸杞子]//[Java入门, 宁夏枸杞, 黑枸杞, 人字拖, 特级枸杞, 枸杞子//[Java入门, 黑枸杞, 人字拖, 枸杞子//2、开始完成需求从集合中找出包含枸杞的数据 并删除它
// for (int i 0; i list.size(); i) {
// // i 0 1 2 3 4 5
// //取出当前遍历到的数据
// String ele list.get(i);
// //判断这个数据中包含枸杞
// if (ele.contains(枸杞)){
// //直接从集合中删除数据
// list.remove(ele);
// }
// }
// System.out.println(list);//[Java入门, 黑枸杞, 人字拖, 特级枸杞, 枸杞子// i//方式一每次删除一次数据就让i往左边退一步
// for (int i 0; i list.size(); i) {
// // i 0 1 2 3 4 5
// String ele list.get(i);
// //判断这个数据中包含枸杞
// if (ele.contains(枸杞)){
// //直接从集合中删除数据
// list.remove(ele);
// i--;
// }
// }
// System.out.println(list);//方式二从集合的后面倒着遍历并删除for (int i list.size()-1; i 0 ; i--) {//取出当前遍历到的数据String ele list.get(i);//判断这个数据中包含枸杞if (ele.contains(枸杞)){//直接从集合中删除该数据list.remove(ele);}}System.out.println(list);}
}从集合中遍历元素并筛选出元素删除它应该如果操作才能不出bug
方式一每次删除一个数据后索引 -1方式二从集合后面遍历然后删除可以避免漏掉元素 常用APIArrayList集合综合案例 案例ArrayList的综合案例——模仿外卖系统中的商家系统
需求
完成菜品的上架、以及菜品信息浏览功能。
目标
使用所学的ArrayList集合结合面向对象编程实现以上2个需求。
package com.liu.arraylist;import java.util.ArrayList;public class ArrayListTest3 {public static void main(String[] args) {//目标完成拓展案例商品菜品上菜操作//1、设计一个菜品类Food负责创建菜品对象封装菜品数据//2、设计一个菜品的操作类FoodOpeartor负责完成对菜品的业务实现上架浏览信息FoodOpeartor opeartor new FoodOpeartor();opeartor.start();}
}package com.liu.arraylist;public class Food {private String name;private double price;private String desc;//描述public Food() {}public Food(String name, double price, String desc) {this.name name;this.price price;this.desc desc;}public String getName() {return name;}public void setName(String name) {this.name name;}public double getPrice() {return price;}public void setPrice(double price) {this.price price;}public String getDesc() {return desc;}public void setDesc(String desc) {this.desc desc;}
}package com.liu.arraylist;//菜品操作类负责对菜品上架和浏览功能的实现import java.util.ArrayList;
import java.util.Scanner;public class FoodOpeartor {//1、定义一个ArrayList集合对象负责存储菜品信息private ArrayListFood foodList new ArrayList();//foodList []//2、开发功能上架菜品功能public void addFood(){//3、创建一个菜品对象封装上架的菜品信息Food f new Food();//4、录入菜品信息进去Scanner sc new Scanner(System.in);System.out.println(请您输入该菜品名称);String name sc.next();f.setName(name);System.out.println(请您输入该菜品价格);double price sc.nextDouble();f.setPrice(price);System.out.println(请您输入菜品描述);String desc sc.next();f.setDesc(desc);//5、把菜品对象存入到集合中去foodList.add(f);System.out.println(上架成功);}//6、展示菜品//foodList [ f1,f2,f3,......]public void showAllFood(){if (foodList.size() 0){System.out.println(什么菜品都没有先去上架);return;}for (int i 0; i foodList.size(); i) {Food f foodList.get(i);System.out.println(f.getName());System.out.println(f.getPrice());System.out.println(f.getDesc());System.out.println(____________________________________________);}}//负责展示操作界面public void start(){while (true) {System.out.println(请选择功能);System.out.println(1、上架商品);System.out.println(2、展示菜品);System.out.println(3、退出);Scanner sc new Scanner(System.in);System.out.println(请选择您的操作);String command sc.next();switch (command){case 1:addFood();break;case 2:showAllFood();break;case 3:System.out.println(下次再来);return; //干掉方法default:System.out.println(您输入的命令不存在);}}}}总结常用APIString、ArrayList使用 什么是API
1、全称应用程序编程接口就是Java自己写好的程序给程序员调用的方便完成一些功能的。
2、api文档程序使用说明书
String
1、是什么String是字符串类型它定义的变量可以指向一个字符串对象
2、String创建对象的方式方式一直接使用双引号围起来 String name ”懒羊羊“ 方式二new构造器得到字符串对象 。 3、两种方式的区别面试笔试会问到双引号给出的字符串对象存在于堆内存中的常量池中相同内容只会存储一份。new字符串对象每new一次都会在堆内存中产生一个字符串对象。 4、Sting是不可变字符串
5、String的常用方法常用API判断字符串内容。背景 判断字符串对象是判断地址的这样会引起很多业务问题。必要性判断字符串开发中更多时候希望判断内容一样就返回true不在乎地址是不是一样此时需要用equals方法。结论一之后只要是字符串进行内容比较那必须使用字符串的equals方法。结论二什么时候用 比较基本数据类型的比较那就用 其他方法 ArrayList
1、是什么是一种集合
2、集合代表的是一种容器类似于数组
3、集合的特点大小可变类型可以不固定功能更加强大适合做 元素个数不能确定同时存在怎么增删操作的业务场景。
4、如何构建ArrayList的对象代表一个集合容器存储数据。public ArrayListArryList list new ArrayList
5、ArrayList的常用方法 6、泛型集合都是支持泛型的。ArrayListE约束集合在编译阶段只能操作某种数据类型。ArrayListString list new ArrayList() ; ArrayListStudent list new ArrayList() ; ArrayListMovie list new ArrayList() ; ArrayListInteger list new ArrayList() ; 注意集合和泛型都不支持基本数据类型只能支持引用数据类型以后定义集合都应该采用泛型。问题我的集合就是要什么都存ArrayList list new ArrayList() 推荐这样写 ArrayListObject list new ArrayList()
、ArrayList遍历并删除元素从前往后边遍历边删除存在问题可能存在漏掉元素。删除元素后马上后退一步就可以了从后往前遍历边遍历边删除
8、ArrayList存储自定义类型的变量 ArrayListStudent list new ArrayList() ; ArrayListMovie list new ArrayList() ; 注意集合容器中存储的是每个对象的什么东西在堆内存中的地址 项目实战ATM项目介绍 模拟ATM系统 1、项目演示
2、项目技术分析
3、能得到哪些收获
ATM系统技术选型 完成本项目达成的能力 项目实战ATM系统架构搭建欢迎页面设计 系统架构搭建
1、定义一个账号类Account至少需要包含卡号、姓名、性别、密码、余额、每次取现额度
2、定义一个ATM类用来代表ATM系统负责提供所有的业务需求比如展示ATM的系统欢迎页、开通账号、转账 . . .
3、定义一个测试类Test负责对我们开发的ATM系统进行测试。
系统欢迎页设计
在ATM类中设计一个方法start方法里负责展示欢迎界面。 package com.liu;public class Account {private String cardId;private String userName;private char sex;private String passWord;private double money;private double limit; //限额public String getCardId() {return cardId;}public void setCardId(String cardId) {this.cardId cardId;}public String getUserName() {return userName;}public void setUserName(String userName) {this.userName userName;}public char getSex() {return sex;}public void setSex(char sex) {this.sex sex;}public String getPassWord() {return passWord;}public void setPassWord(String passWord) {this.passWord passWord;}public double getMoney() {return money;}public void setMoney(double money) {this.money money;}public double getLimit() {return limit;}public void setLimit(double limit) {this.limit limit;}
}package com.liu;import java.util.ArrayList;
import java.util.Scanner;public class ATM {private ArrayListAccount accounts new ArrayList(); //[]private Scanner sc new Scanner(System.in);//启动ATM系统展示欢迎界面public void start(){while (true) {System.out.println(欢迎您进入ATM系统);System.out.println(1、用户登录);System.out.println(2、用户开户);int command sc.nextInt();switch (command){case 1://用户登录break;case 2://用户开户break;default:System.out.println(没有该操作!);}}}
}package com.liu;import java.util.ArrayList;public class Test {public static void main(String[] args) {//创建一个ATM对象代表ATM系统ATM atm new ATM();//2、调用ATM对象的start方法启动系统atm.start();}
}ATM类中使用什么来存储系统全部用户的账户信息的
ArrayListAccount accounts new ArrayList(); 项目实战ATM开户 开户功能
就是新增一个账户也就是往系统的账户集合中添加一个账户对象。 账户的要求
用户信息包含姓名、性别、密码、每次取现额度、卡号。
注意
卡号由系统生成要求是8位的数字组成的且卡号不能重复
package com.liu;public class Account {private String cardId;private String userName;private char sex;private String passWord;private double money;private double limit; //限额public String getCardId() {return cardId;}public void setCardId(String cardId) {this.cardId cardId;}public String getUserName() {return userName (sex 男 ? 先生 : 女士);}public void setUserName(String userName) {this.userName userName;}public char getSex() {return sex;}public void setSex(char sex) {this.sex sex;}public String getPassWord() {return passWord;}public void setPassWord(String passWord) {this.passWord passWord;}public double getMoney() {return money;}public void setMoney(double money) {this.money money;}public double getLimit() {return limit;}public void setLimit(double limit) {this.limit limit;}
}package com.liu;import java.util.ArrayList;
import java.util.Scanner;public class ATM {private ArrayListAccount accounts new ArrayList(); //[]private Scanner sc new Scanner(System.in);//启动ATM系统展示欢迎界面public void start(){while (true) {System.out.println(欢迎您进入ATM系统);System.out.println(1、用户登录);System.out.println(2、用户开户);System.out.println(请选择);int command sc.nextInt();switch (command){case 1://用户登录break;case 2://用户开户createAccount();break;default:System.out.println(没有该操作!);}}}//完成用户开户操作private void createAccount(){System.out.println(系统开户操作);// 1、创建一个账号对象用于封装对象的开户信息Account acc new Account();//2、需要用户输入自己的开户信息赋值给账户对象System.out.println(请您输入您的账号名称);String name sc.next();acc.setUserName(name);while (true) {System.out.println(请您输入您的性别);char sex sc.next().charAt(0); //男if (sex男 || sex女){acc.setSex(sex);break;}else {System.out.println(您输入的性别有误只能是男或者女);}}while (true) {System.out.println(请您输入您的账户密码);String passWord sc.next();System.out.println(请你输入您的确认密码);String okPassword sc.next();//判断2次密码是否一样if (okPassword.equals(passWord)){acc.setPassWord(okPassword);break;}else {System.out.println(您输入的2次密码不一样请您确认!);}}System.out.println(请您输入您的取现额度);double limit sc.nextDouble();acc.setLimit(limit);//重点我们需要为这个账号生成一个卡号由系统自动生成8位数字表示不能与其他账户的卡号重复//3、把这个账号对象存入到账号集合中去accounts.add(acc);System.out.println(恭喜您 acc.getUserName() 开户成功您的卡号是);}
}package com.liu;import java.util.ArrayList;public class Test {public static void main(String[] args) {//创建一个ATM对象代表ATM系统ATM atm new ATM();//2、调用ATM对象的start方法启动系统atm.start();}
}开户功能的实现需要哪几步操作
1、定义一个开户方法creatAccount
2、在方法里创建Account账户对象入职封装用户的账户信息姓名、性别、密码、卡号等等
3、卡号需要由系统自动生成卡号要求是8位的数字组成且不能 重复
4、把账户对象存入到账户集合中去
5、提示开户成功
为新开的账户生成一个新卡号
新卡号要求是一个8位的数字且不能与其他账户对象的卡号重复
新卡号得到后需要赋值给当前账户对象
package com.liu;public class Account {private String cardId;private String userName;private char sex;private String passWord;private double money;private double limit; //限额public String getCardId() {return cardId;}public void setCardId(String cardId) {this.cardId cardId;}public String getUserName() {return userName (sex 男 ? 先生 : 女士);}public void setUserName(String userName) {this.userName userName;}public char getSex() {return sex;}public void setSex(char sex) {this.sex sex;}public String getPassWord() {return passWord;}public void setPassWord(String passWord) {this.passWord passWord;}public double getMoney() {return money;}public void setMoney(double money) {this.money money;}public double getLimit() {return limit;}public void setLimit(double limit) {this.limit limit;}
}package com.liu;import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;public class ATM {private ArrayListAccount accounts new ArrayList(); //[]private Scanner sc new Scanner(System.in);//启动ATM系统展示欢迎界面public void start(){while (true) {System.out.println(欢迎您进入ATM系统);System.out.println(1、用户登录);System.out.println(2、用户开户);System.out.println(请选择);int command sc.nextInt();switch (command){case 1://用户登录break;case 2://用户开户createAccount();break;default:System.out.println(没有该操作!);}}}//完成用户开户操作private void createAccount(){System.out.println(系统开户操作);// 1、创建一个账号对象用于封装对象的开户信息Account acc new Account();//2、需要用户输入自己的开户信息赋值给账户对象System.out.println(请您输入您的账号名称);String name sc.next();acc.setUserName(name);while (true) {System.out.println(请您输入您的性别);char sex sc.next().charAt(0); //男if (sex男 || sex女){acc.setSex(sex);break;}else {System.out.println(您输入的性别有误只能是男或者女);}}while (true) {System.out.println(请您输入您的账户密码);String passWord sc.next();System.out.println(请你输入您的确认密码);String okPassword sc.next();//判断2次密码是否一样if (okPassword.equals(passWord)){acc.setPassWord(okPassword);break;}else {System.out.println(您输入的2次密码不一样请您确认!);}}System.out.println(请您输入您的取现额度);double limit sc.nextDouble();acc.setLimit(limit);//重点我们需要为这个账号生成一个卡号由系统自动生成8位数字表示不能与其他账户的卡号重复String newCardId createCardId();acc.setCardId(newCardId);//3、把这个账号对象存入到账号集合中去accounts.add(acc);System.out.println(恭喜您 acc.getUserName() 开户成功您的卡号是 acc.getCardId());}//返回一个8位数字的卡号而且这个卡号不能与其他账户的卡号重复private String createCardId(){while (true) {//1、定义一个String类型的变量记住8位数字作为卡号String cardId ;//2、使用循环循环8次每次产生一个随机数给cardID连接起来Random r new Random();for (int i 0; i 8; i) {int data r.nextInt(10);cardId data;}//3、判断cardID中记住的卡号是否与其他账户的卡号重复了没有重复才可以作为一个新卡号返回。Account acc getAccountByCardId(cardId);if (acc null){//说明cardId没有找到账户对象因此cardID没有与其账户的卡号重复可以返回它做为一个新卡号return cardId;}}}//根据卡号查询账户对象返回 account [c1,c2,c3 ....]private Account getAccountByCardId(String cardId){//遍历全部的账户对象for (int i 0; i accounts.size(); i) {Account acc accounts.get(i);//判断这个账户对象acc中的卡号是否是我们要找的卡号if (acc.getCardId().equals(cardId)){return acc;}}return null; //查无此账户这个卡号不存在}}package com.liu;import java.util.ArrayList;public class Test {public static void main(String[] args) {//创建一个ATM对象代表ATM系统ATM atm new ATM();//2、调用ATM对象的start方法启动系统atm.start();}
}账户的新卡号是如何生成的
1、定义了一个方法createCardId用来返回以后不重复的新卡号。
2、方法里使用循环生成了8个随机的数字连接起来作为卡号。
3、接着判断该卡号是否与其他账户的卡号重复
4、根据该卡号去账户集合中查询账户对象如果没有查询到账户对象该卡号步重复即可返回。
5、如果查询到了账户对象则使用循环重复以上2、3、4步操作。 项目实战ATM登录登录后操作 用户登录功能 1、如果系统没有任何账户对象则不允许登录。
2、让用户输入登录的卡号先判断卡号是否正确如果不正确要给出提示。
3、如果卡号正确在让用户输入账号密码如果密码不正确要给出提示如果密码也正确则给出登录成功的提示。
package com.liu;public class Account {private String cardId;private String userName;private char sex;private String passWord;private double money;private double limit; //限额public String getCardId() {return cardId;}public void setCardId(String cardId) {this.cardId cardId;}public String getUserName() {return userName (sex 男 ? 先生 : 女士);}public void setUserName(String userName) {this.userName userName;}public char getSex() {return sex;}public void setSex(char sex) {this.sex sex;}public String getPassWord() {return passWord;}public void setPassWord(String passWord) {this.passWord passWord;}public double getMoney() {return money;}public void setMoney(double money) {this.money money;}public double getLimit() {return limit;}public void setLimit(double limit) {this.limit limit;}
}package com.liu;import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;public class ATM {private ArrayListAccount accounts new ArrayList(); //[]private Scanner sc new Scanner(System.in);//启动ATM系统展示欢迎界面public void start(){while (true) {System.out.println(欢迎您进入ATM系统);System.out.println(1、用户登录);System.out.println(2、用户开户);System.out.println(请选择);int command sc.nextInt();switch (command){case 1://用户登录login();break;case 2://用户开户createAccount();break;default:System.out.println(没有该操作!);}}}//完成用户的登录操作private void login(){System.out.println(系统登录);//1、判断系统中是否存在账号对象存在才能登录如果不存在我们直接结束登录操作if (accounts.size() 0){System.out.println(当前系统中无任何账户请先开户再来登录);return;//直接跳出登录操作}//2、系统中存在账号对象可以开始进行登录操作while (true) {System.out.println(请您输入您的登录卡号);String cardId sc.next();//3、判断卡号是否存在Account acc getAccountByCardId(cardId);if (acc null){//说明这个卡号不存在System.out.println(您输入的卡号不存在请确认);}else {while (true) {//卡号存在接着让用户输入密码System.out.println(请您输入登录密码);String passWord sc.next();//4、判断密码是否正确if (acc.getPassWord().equals(passWord)){//密码正确登陆成功System.out.println(恭喜您acc.getUserName()成功登录了系统您的卡号是acc.getCardId());}else {System.out.println(您输入的密码不正确请确认);}}}}}//完成用户开户操作private void createAccount(){System.out.println(系统开户操作);// 1、创建一个账号对象用于封装对象的开户信息Account acc new Account();//2、需要用户输入自己的开户信息赋值给账户对象System.out.println(请您输入您的账号名称);String name sc.next();acc.setUserName(name);while (true) {System.out.println(请您输入您的性别);char sex sc.next().charAt(0); //男if (sex男 || sex女){acc.setSex(sex);break;}else {System.out.println(您输入的性别有误只能是男或者女);}}while (true) {System.out.println(请您输入您的账户密码);String passWord sc.next();System.out.println(请你输入您的确认密码);String okPassword sc.next();//判断2次密码是否一样if (okPassword.equals(passWord)){acc.setPassWord(okPassword);break;}else {System.out.println(您输入的2次密码不一样请您确认!);}}System.out.println(请您输入您的取现额度);double limit sc.nextDouble();acc.setLimit(limit);//重点我们需要为这个账号生成一个卡号由系统自动生成8位数字表示不能与其他账户的卡号重复String newCardId createCardId();acc.setCardId(newCardId);//3、把这个账号对象存入到账号集合中去accounts.add(acc);System.out.println(恭喜您 acc.getUserName() 开户成功您的卡号是 acc.getCardId());}//返回一个8位数字的卡号而且这个卡号不能与其他账户的卡号重复private String createCardId(){while (true) {//1、定义一个String类型的变量记住8位数字作为卡号String cardId ;//2、使用循环循环8次每次产生一个随机数给cardID连接起来Random r new Random();for (int i 0; i 8; i) {int data r.nextInt(10);cardId data;}//3、判断cardID中记住的卡号是否与其他账户的卡号重复了没有重复才可以作为一个新卡号返回。Account acc getAccountByCardId(cardId);if (acc null){//说明cardId没有找到账户对象因此cardID没有与其账户的卡号重复可以返回它做为一个新卡号return cardId;}}}//根据卡号查询账户对象返回 account [c1,c2,c3 ....]private Account getAccountByCardId(String cardId){//遍历全部的账户对象for (int i 0; i accounts.size(); i) {Account acc accounts.get(i);//判断这个账户对象acc中的卡号是否是我们要找的卡号if (acc.getCardId().equals(cardId)){return acc;}}return null; //查无此账户这个卡号不存在}}package com.liu;import java.util.ArrayList;public class Test {public static void main(String[] args) {//创建一个ATM对象代表ATM系统ATM atm new ATM();//2、调用ATM对象的start方法启动系统atm.start();}
}登录功能如何实现的
设计一个登录方法login负责完成用户的登录。
方法里如果系统无任何账户对象直接结束登录操作。
有账户对象则让用户输入卡号根据卡号去去账户集合中查询账户对象。。
如果没有找到账户对象说明登录卡号不存在提示继续输入卡号。
如果找打了账户对象说明卡号存在继续输入密码。
如果密码不正确提示继续输入密码。
如果密码也正确则登录成功并给出相应的提示。 用户操作页设计、查询账户、退出账户功能分析 1、用户登录成功后需要进入用户操作页。
2、查询就是直接展示当前登录成功的用户的账户信息。
3、退出账户就是回到欢迎界面。
package com.liu;public class Account {private String cardId;private String userName;private char sex;private String passWord;private double money;private double limit; //限额public String getCardId() {return cardId;}public void setCardId(String cardId) {this.cardId cardId;}public String getUserName() {return userName (sex 男 ? 先生 : 女士);}public void setUserName(String userName) {this.userName userName;}public char getSex() {return sex;}public void setSex(char sex) {this.sex sex;}public String getPassWord() {return passWord;}public void setPassWord(String passWord) {this.passWord passWord;}public double getMoney() {return money;}public void setMoney(double money) {this.money money;}public double getLimit() {return limit;}public void setLimit(double limit) {this.limit limit;}
}package com.liu;import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;public class ATM {private ArrayListAccount accounts new ArrayList(); //[]private Scanner sc new Scanner(System.in);private Account loginAcc; //记录登录后的用户账户//启动ATM系统展示欢迎界面public void start(){while (true) {System.out.println(欢迎您进入ATM系统);System.out.println(1、用户登录);System.out.println(2、用户开户);System.out.println(请选择);int command sc.nextInt();switch (command){case 1://用户登录login();break;case 2://用户开户createAccount();break;default:System.out.println(没有该操作!);}}}//完成用户的登录操作private void login(){System.out.println(系统登录);//1、判断系统中是否存在账号对象存在才能登录如果不存在我们直接结束登录操作if (accounts.size() 0){System.out.println(当前系统中无任何账户请先开户再来登录);return;//直接跳出登录操作}//2、系统中存在账号对象可以开始进行登录操作while (true) {System.out.println(请您输入您的登录卡号);String cardId sc.next();//3、判断卡号是否存在Account acc getAccountByCardId(cardId);if (acc null){//说明这个卡号不存在System.out.println(您输入的卡号不存在请确认);}else {while (true) {//卡号存在接着让用户输入密码System.out.println(请您输入登录密码);String passWord sc.next();//4、判断密码是否正确if (acc.getPassWord().equals(passWord)){loginAcc acc;//密码正确登陆成功System.out.println(恭喜您acc.getUserName()成功登录了系统您的卡号是acc.getCardId());//展示登录后的操作界面了showUserCommand();return;//跳出并结束当前登录方法}else {System.out.println(您输入的密码不正确请确认);}}}}}//展示登录后的操作界面的private void showUserCommand(){while (true) {System.out.println(loginAcc.getUserName() 您可以选择如下功能进行账户的处理);System.out.println(1、查询账户);System.out.println(2、存款);System.out.println(3、取款);System.out.println(4、转账);System.out.println(5、密码修改);System.out.println(6、退出账户);System.out.println(7、注销当前账户);System.out.println(请选择);int command sc.nextInt();switch (command){case 1://查询当前账户showLoginAccountt();break;case 2://存款break;case 3://取款break;case 4://转账break;case 5://密码修改break;case 6://退出账户System.out.println(loginAcc.getUserName()您退出系统成功);return; //跳出并结束当前方法case 7://注销当前登录的账户break;default:System.out.println(您当前选择的操作是不存在的请确认);}}}//展示当前登录的账户信息private void showLoginAccountt(){System.out.println(当前用户信息如下);System.out.println(卡号loginAcc.getCardId());System.out.println(户主loginAcc.getUserName());System.out.println(性别loginAcc.getSex());System.out.println(余额loginAcc.getLimit());System.out.println(每次取现额度loginAcc.getLimit());}//完成用户开户操作private void createAccount(){System.out.println(系统开户操作);// 1、创建一个账号对象用于封装对象的开户信息Account acc new Account();//2、需要用户输入自己的开户信息赋值给账户对象System.out.println(请您输入您的账号名称);String name sc.next();acc.setUserName(name);while (true) {System.out.println(请您输入您的性别);char sex sc.next().charAt(0); //男if (sex男 || sex女){acc.setSex(sex);break;}else {System.out.println(您输入的性别有误只能是男或者女);}}while (true) {System.out.println(请您输入您的账户密码);String passWord sc.next();System.out.println(请你输入您的确认密码);String okPassword sc.next();//判断2次密码是否一样if (okPassword.equals(passWord)){acc.setPassWord(okPassword);break;}else {System.out.println(您输入的2次密码不一样请您确认!);}}System.out.println(请您输入您的取现额度);double limit sc.nextDouble();acc.setLimit(limit);//重点我们需要为这个账号生成一个卡号由系统自动生成8位数字表示不能与其他账户的卡号重复String newCardId createCardId();acc.setCardId(newCardId);//3、把这个账号对象存入到账号集合中去accounts.add(acc);System.out.println(恭喜您 acc.getUserName() 开户成功您的卡号是 acc.getCardId());}//返回一个8位数字的卡号而且这个卡号不能与其他账户的卡号重复private String createCardId(){while (true) {//1、定义一个String类型的变量记住8位数字作为卡号String cardId ;//2、使用循环循环8次每次产生一个随机数给cardID连接起来Random r new Random();for (int i 0; i 8; i) {int data r.nextInt(10);cardId data;}//3、判断cardID中记住的卡号是否与其他账户的卡号重复了没有重复才可以作为一个新卡号返回。Account acc getAccountByCardId(cardId);if (acc null){//说明cardId没有找到账户对象因此cardID没有与其账户的卡号重复可以返回它做为一个新卡号return cardId;}}}//根据卡号查询账户对象返回 account [c1,c2,c3 ....]private Account getAccountByCardId(String cardId){//遍历全部的账户对象for (int i 0; i accounts.size(); i) {Account acc accounts.get(i);//判断这个账户对象acc中的卡号是否是我们要找的卡号if (acc.getCardId().equals(cardId)){return acc;}}return null; //查无此账户这个卡号不存在}}package com.liu;import java.util.ArrayList;public class Test {public static void main(String[] args) {//创建一个ATM对象代表ATM系统ATM atm new ATM();//2、调用ATM对象的start方法启动系统atm.start();}
}项目实战ATM存款、取款 用户存款功能 就是用户位自己的账户存钱存钱后更新新账户的余额即可。
用户取款功能:
就是从自己的账户中取钱取钱的要求
1、需要先判断账户的余额是否大于100元如果够让用户输入取款金额。
2、需要判断取款金额是否超过了当次限额以及余额是否足够。
package com.liu;public class Account {private String cardId;private String userName;private char sex;private String passWord;private double money;private double limit; //限额public String getCardId() {return cardId;}public void setCardId(String cardId) {this.cardId cardId;}public String getUserName() {return userName (sex 男 ? 先生 : 女士);}public void setUserName(String userName) {this.userName userName;}public char getSex() {return sex;}public void setSex(char sex) {this.sex sex;}public String getPassWord() {return passWord;}public void setPassWord(String passWord) {this.passWord passWord;}public double getMoney() {return money;}public void setMoney(double money) {this.money money;}public double getLimit() {return limit;}public void setLimit(double limit) {this.limit limit;}
}package com.liu;import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;public class ATM {private ArrayListAccount accounts new ArrayList(); //[]private Scanner sc new Scanner(System.in);private Account loginAcc; //记录登录后的用户账户//启动ATM系统展示欢迎界面public void start(){while (true) {System.out.println(欢迎您进入ATM系统);System.out.println(1、用户登录);System.out.println(2、用户开户);System.out.println(请选择);int command sc.nextInt();switch (command){case 1://用户登录login();break;case 2://用户开户createAccount();break;default:System.out.println(没有该操作!);}}}//完成用户的登录操作private void login(){System.out.println(系统登录);//1、判断系统中是否存在账号对象存在才能登录如果不存在我们直接结束登录操作if (accounts.size() 0){System.out.println(当前系统中无任何账户请先开户再来登录);return;//直接跳出登录操作}//2、系统中存在账号对象可以开始进行登录操作while (true) {System.out.println(请您输入您的登录卡号);String cardId sc.next();//3、判断卡号是否存在Account acc getAccountByCardId(cardId);if (acc null){//说明这个卡号不存在System.out.println(您输入的卡号不存在请确认);}else {while (true) {//卡号存在接着让用户输入密码System.out.println(请您输入登录密码);String passWord sc.next();//4、判断密码是否正确if (acc.getPassWord().equals(passWord)){loginAcc acc;//密码正确登陆成功System.out.println(恭喜您acc.getUserName()成功登录了系统您的卡号是acc.getCardId());//展示登录后的操作界面了showUserCommand();return;//跳出并结束当前登录方法}else {System.out.println(您输入的密码不正确请确认);}}}}}//展示登录后的操作界面的private void showUserCommand(){while (true) {System.out.println(loginAcc.getUserName() 您可以选择如下功能进行账户的处理);System.out.println(1、查询账户);System.out.println(2、存款);System.out.println(3、取款);System.out.println(4、转账);System.out.println(5、密码修改);System.out.println(6、退出账户);System.out.println(7、注销当前账户);System.out.println(请选择);int command sc.nextInt();switch (command){case 1://查询当前账户showLoginAccountt();break;case 2://存款depositMoney();break;case 3://取款drawMoney();break;case 4://转账break;case 5://密码修改break;case 6://退出账户System.out.println(loginAcc.getUserName()您退出系统成功);return; //跳出并结束当前方法case 7://注销当前登录的账户break;default:System.out.println(您当前选择的操作是不存在的请确认);}}}private void drawMoney() {System.out.println(取钱操作);//1、判断账户余额是否达到100元如果不到100元就不让用户取钱了if (loginAcc.getMoney()100){System.out.println(您的账户余额不足100元不允许取钱);return;}//2、让用户输入取款金额while (true) {System.out.println(请您输入取款金额);double money sc.nextDouble();//3、判断用户余额是否足够if (loginAcc.getMoney()money){//账户中的余额是足够的//4、判断当前取款金额是否超过了每次限额if (money loginAcc.getLimit()){System.out.println(您当前取款金额超过了每次限额您每次最多可取loginAcc.getLimit());}else {//代表可以开始取钱了更新当前账户的余额即可loginAcc.setMoney(loginAcc.getMoney()-money);System.out.println(您取款money成功取款后您剩余loginAcc.getMoney());break;}}else {System.out.println(余额不足您的账户中的余额是loginAcc.getMoney());}}}//存钱private void depositMoney() {System.out.println(存钱操作);System.out.println(请您输入存款金额);double money sc.nextDouble();//更新当前登录账户的余额loginAcc.setMoney(loginAcc.getMoney()money);System.out.println(恭喜您您存钱money成功存钱后余额是loginAcc.getMoney());}//展示当前登录的账户信息private void showLoginAccountt(){System.out.println(当前用户信息如下);System.out.println(卡号loginAcc.getCardId());System.out.println(户主loginAcc.getUserName());System.out.println(性别loginAcc.getSex());System.out.println(余额loginAcc.getMoney());System.out.println(每次取现额度loginAcc.getLimit());}//完成用户开户操作private void createAccount(){System.out.println(系统开户操作);// 1、创建一个账号对象用于封装对象的开户信息Account acc new Account();//2、需要用户输入自己的开户信息赋值给账户对象System.out.println(请您输入您的账号名称);String name sc.next();acc.setUserName(name);while (true) {System.out.println(请您输入您的性别);char sex sc.next().charAt(0); //男if (sex男 || sex女){acc.setSex(sex);break;}else {System.out.println(您输入的性别有误只能是男或者女);}}while (true) {System.out.println(请您输入您的账户密码);String passWord sc.next();System.out.println(请你输入您的确认密码);String okPassword sc.next();//判断2次密码是否一样if (okPassword.equals(passWord)){acc.setPassWord(okPassword);break;}else {System.out.println(您输入的2次密码不一样请您确认!);}}System.out.println(请您输入您的取现额度);double limit sc.nextDouble();acc.setLimit(limit);//重点我们需要为这个账号生成一个卡号由系统自动生成8位数字表示不能与其他账户的卡号重复String newCardId createCardId();acc.setCardId(newCardId);//3、把这个账号对象存入到账号集合中去accounts.add(acc);System.out.println(恭喜您 acc.getUserName() 开户成功您的卡号是 acc.getCardId());}//返回一个8位数字的卡号而且这个卡号不能与其他账户的卡号重复private String createCardId(){while (true) {//1、定义一个String类型的变量记住8位数字作为卡号String cardId ;//2、使用循环循环8次每次产生一个随机数给cardID连接起来Random r new Random();for (int i 0; i 8; i) {int data r.nextInt(10);cardId data;}//3、判断cardID中记住的卡号是否与其他账户的卡号重复了没有重复才可以作为一个新卡号返回。Account acc getAccountByCardId(cardId);if (acc null){//说明cardId没有找到账户对象因此cardID没有与其账户的卡号重复可以返回它做为一个新卡号return cardId;}}}//根据卡号查询账户对象返回 account [c1,c2,c3 ....]private Account getAccountByCardId(String cardId){//遍历全部的账户对象for (int i 0; i accounts.size(); i) {Account acc accounts.get(i);//判断这个账户对象acc中的卡号是否是我们要找的卡号if (acc.getCardId().equals(cardId)){return acc;}}return null; //查无此账户这个卡号不存在}}package com.liu;import java.util.ArrayList;public class Test {public static void main(String[] args) {//创建一个ATM对象代表ATM系统ATM atm new ATM();//2、调用ATM对象的start方法启动系统atm.start();}
}存款、取款是如何实现账户余额更新的
调用当前账户对象的setMoney方法完成金额的修改。 项目实战ATM转账 用户转账功能 把钱转给别人转账前需要判断
1、自己账户是否有钱系统中是否有其他账户。
2、接下来让用户输入对方卡号判断对方账户是否存在账户如果存在还需要认证对方账户的户主姓氏。
package com.liu;public class Account {private String cardId;private String userName;private char sex;private String passWord;private double money;private double limit; //限额public String getCardId() {return cardId;}public void setCardId(String cardId) {this.cardId cardId;}public String getUserName() {return userName (sex 男 ? 先生 : 女士);}public void setUserName(String userName) {this.userName userName;}public char getSex() {return sex;}public void setSex(char sex) {this.sex sex;}public String getPassWord() {return passWord;}public void setPassWord(String passWord) {this.passWord passWord;}public double getMoney() {return money;}public void setMoney(double money) {this.money money;}public double getLimit() {return limit;}public void setLimit(double limit) {this.limit limit;}
}package com.liu;import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;public class ATM {private ArrayListAccount accounts new ArrayList(); //[]private Scanner sc new Scanner(System.in);private Account loginAcc; //记录登录后的用户账户//启动ATM系统展示欢迎界面public void start(){while (true) {System.out.println(欢迎您进入ATM系统);System.out.println(1、用户登录);System.out.println(2、用户开户);System.out.println(请选择);int command sc.nextInt();switch (command){case 1://用户登录login();break;case 2://用户开户createAccount();break;default:System.out.println(没有该操作!);}}}//完成用户的登录操作private void login(){System.out.println(系统登录);//1、判断系统中是否存在账号对象存在才能登录如果不存在我们直接结束登录操作if (accounts.size() 0){System.out.println(当前系统中无任何账户请先开户再来登录);return;//直接跳出登录操作}//2、系统中存在账号对象可以开始进行登录操作while (true) {System.out.println(请您输入您的登录卡号);String cardId sc.next();//3、判断卡号是否存在Account acc getAccountByCardId(cardId);if (acc null){//说明这个卡号不存在System.out.println(您输入的卡号不存在请确认);}else {while (true) {//卡号存在接着让用户输入密码System.out.println(请您输入登录密码);String passWord sc.next();//4、判断密码是否正确if (acc.getPassWord().equals(passWord)){loginAcc acc;//密码正确登陆成功System.out.println(恭喜您acc.getUserName()成功登录了系统您的卡号是acc.getCardId());//展示登录后的操作界面了showUserCommand();return;//跳出并结束当前登录方法}else {System.out.println(您输入的密码不正确请确认);}}}}}//展示登录后的操作界面的private void showUserCommand(){while (true) {System.out.println(loginAcc.getUserName() 您可以选择如下功能进行账户的处理);System.out.println(1、查询账户);System.out.println(2、存款);System.out.println(3、取款);System.out.println(4、转账);System.out.println(5、密码修改);System.out.println(6、退出账户);System.out.println(7、注销当前账户);System.out.println(请选择);int command sc.nextInt();switch (command){case 1://查询当前账户showLoginAccountt();break;case 2://存款depositMoney();break;case 3://取款drawMoney();break;case 4://转账transferMoney();break;case 5://密码修改break;case 6://退出账户System.out.println(loginAcc.getUserName()您退出系统成功);return; //跳出并结束当前方法case 7://注销当前登录的账户break;default:System.out.println(您当前选择的操作是不存在的请确认);}}}//转账private void transferMoney() {System.out.println(用户转账);//1、判断系统中是否存在其他账户if (accounts.size()2){System.out.println(当前系统中只要你一个账户无法为其他账户转账);return;}//2、判断自己的账户中是否有钱if (loginAcc.getMoney() 0){System.out.println(您自己都没钱就别转了);return;}//3、真正开始转账了while (true) {System.out.println(请您输入对方的卡号);String cardId sc.next();//4、判断这个卡号是否正确Account acc getAccountByCardId(cardId);if (acc null){System.out.println(您输入的对方的卡号不存在);}else {//对方的账户存在继续让用户认证姓氏String name * acc.getUserName().substring(1); // * 羊羊System.out.println(请您输入【 name 】姓氏);String preName sc.next();//5、判断这个姓氏是否正确啊if (acc.getUserName().startsWith(preName)){while (true) {//认证通过了真正转账了System.out.println(请您输入转账给对方的金额);double money sc.nextDouble();//6、判断金额是否没有超过自己的余额if (loginAcc.getMoney() money){//转给对方//更新自己的账户余额loginAcc.setMoney(loginAcc.getMoney() - money);//更新对方的账户余额acc.setMoney(acc.getMoney() money);System.out.println(您转账成功了);return;//直接跳出转账方法}else {System.out.println(您余额不足无法给对方转这么多钱最多个转loginAcc.getMoney());}}}else {System.out.println(对不起您认证的信息有问题);}}}}private void drawMoney() {System.out.println(取钱操作);//1、判断账户余额是否达到100元如果不到100元就不让用户取钱了if (loginAcc.getMoney()100){System.out.println(您的账户余额不足100元不允许取钱);return;}//2、让用户输入取款金额while (true) {System.out.println(请您输入取款金额);double money sc.nextDouble();//3、判断用户余额是否足够if (loginAcc.getMoney()money){//账户中的余额是足够的//4、判断当前取款金额是否超过了每次限额if (money loginAcc.getLimit()){System.out.println(您当前取款金额超过了每次限额您每次最多可取loginAcc.getLimit());}else {//代表可以开始取钱了更新当前账户的余额即可loginAcc.setMoney(loginAcc.getMoney()-money);System.out.println(您取款money成功取款后您剩余loginAcc.getMoney());break;}}else {System.out.println(余额不足您的账户中的余额是loginAcc.getMoney());}}}//存钱private void depositMoney() {System.out.println(存钱操作);System.out.println(请您输入存款金额);double money sc.nextDouble();//更新当前登录账户的余额loginAcc.setMoney(loginAcc.getMoney()money);System.out.println(恭喜您您存钱money成功存钱后余额是loginAcc.getMoney());}//展示当前登录的账户信息private void showLoginAccountt(){System.out.println(当前用户信息如下);System.out.println(卡号loginAcc.getCardId());System.out.println(户主loginAcc.getUserName());System.out.println(性别loginAcc.getSex());System.out.println(余额loginAcc.getMoney());System.out.println(每次取现额度loginAcc.getLimit());}//完成用户开户操作private void createAccount(){System.out.println(系统开户操作);// 1、创建一个账号对象用于封装对象的开户信息Account acc new Account();//2、需要用户输入自己的开户信息赋值给账户对象System.out.println(请您输入您的账号名称);String name sc.next();acc.setUserName(name);while (true) {System.out.println(请您输入您的性别);char sex sc.next().charAt(0); //男if (sex男 || sex女){acc.setSex(sex);break;}else {System.out.println(您输入的性别有误只能是男或者女);}}while (true) {System.out.println(请您输入您的账户密码);String passWord sc.next();System.out.println(请你输入您的确认密码);String okPassword sc.next();//判断2次密码是否一样if (okPassword.equals(passWord)){acc.setPassWord(okPassword);break;}else {System.out.println(您输入的2次密码不一样请您确认!);}}System.out.println(请您输入您的取现额度);double limit sc.nextDouble();acc.setLimit(limit);//重点我们需要为这个账号生成一个卡号由系统自动生成8位数字表示不能与其他账户的卡号重复String newCardId createCardId();acc.setCardId(newCardId);//3、把这个账号对象存入到账号集合中去accounts.add(acc);System.out.println(恭喜您 acc.getUserName() 开户成功您的卡号是 acc.getCardId());}//返回一个8位数字的卡号而且这个卡号不能与其他账户的卡号重复private String createCardId(){while (true) {//1、定义一个String类型的变量记住8位数字作为卡号String cardId ;//2、使用循环循环8次每次产生一个随机数给cardID连接起来Random r new Random();for (int i 0; i 8; i) {int data r.nextInt(10);cardId data;}//3、判断cardID中记住的卡号是否与其他账户的卡号重复了没有重复才可以作为一个新卡号返回。Account acc getAccountByCardId(cardId);if (acc null){//说明cardId没有找到账户对象因此cardID没有与其账户的卡号重复可以返回它做为一个新卡号return cardId;}}}//根据卡号查询账户对象返回 account [c1,c2,c3 ....]private Account getAccountByCardId(String cardId){//遍历全部的账户对象for (int i 0; i accounts.size(); i) {Account acc accounts.get(i);//判断这个账户对象acc中的卡号是否是我们要找的卡号if (acc.getCardId().equals(cardId)){return acc;}}return null; //查无此账户这个卡号不存在}}package com.liu;import java.util.ArrayList;public class Test {public static void main(String[] args) {//创建一个ATM对象代表ATM系统ATM atm new ATM();//2、调用ATM对象的start方法启动系统atm.start();}
}项目实战ATM销户、密码修改 销户操作的基本要求
销户就是从系统中删
除当前账户销户的要求
1、首先要询问用户是否确定要销户如果不确定则回到操作界面。
2、如果确定要判断用户的账户中是否有钱有则不允许销户并回到操作界面。
3、如果没钱则完成销户并回到欢迎页。
package com.liu;public class Account {private String cardId;private String userName;private char sex;private String passWord;private double money;private double limit; //限额public String getCardId() {return cardId;}public void setCardId(String cardId) {this.cardId cardId;}public String getUserName() {return userName (sex 男 ? 先生 : 女士);}public void setUserName(String userName) {this.userName userName;}public char getSex() {return sex;}public void setSex(char sex) {this.sex sex;}public String getPassWord() {return passWord;}public void setPassWord(String passWord) {this.passWord passWord;}public double getMoney() {return money;}public void setMoney(double money) {this.money money;}public double getLimit() {return limit;}public void setLimit(double limit) {this.limit limit;}
}package com.liu;import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;public class ATM {private ArrayListAccount accounts new ArrayList(); //[]private Scanner sc new Scanner(System.in);private Account loginAcc; //记录登录后的用户账户//启动ATM系统展示欢迎界面public void start(){while (true) {System.out.println(欢迎您进入ATM系统);System.out.println(1、用户登录);System.out.println(2、用户开户);System.out.println(请选择);int command sc.nextInt();switch (command){case 1://用户登录login();break;case 2://用户开户createAccount();break;default:System.out.println(没有该操作!);}}}//完成用户的登录操作private void login(){System.out.println(系统登录);//1、判断系统中是否存在账号对象存在才能登录如果不存在我们直接结束登录操作if (accounts.size() 0){System.out.println(当前系统中无任何账户请先开户再来登录);return;//直接跳出登录操作}//2、系统中存在账号对象可以开始进行登录操作while (true) {System.out.println(请您输入您的登录卡号);String cardId sc.next();//3、判断卡号是否存在Account acc getAccountByCardId(cardId);if (acc null){//说明这个卡号不存在System.out.println(您输入的卡号不存在请确认);}else {while (true) {//卡号存在接着让用户输入密码System.out.println(请您输入登录密码);String passWord sc.next();//4、判断密码是否正确if (acc.getPassWord().equals(passWord)){loginAcc acc;//密码正确登陆成功System.out.println(恭喜您acc.getUserName()成功登录了系统您的卡号是acc.getCardId());//展示登录后的操作界面了showUserCommand();return;//跳出并结束当前登录方法}else {System.out.println(您输入的密码不正确请确认);}}}}}//展示登录后的操作界面的private void showUserCommand(){while (true) {System.out.println(loginAcc.getUserName() 您可以选择如下功能进行账户的处理);System.out.println(1、查询账户);System.out.println(2、存款);System.out.println(3、取款);System.out.println(4、转账);System.out.println(5、密码修改);System.out.println(6、退出账户);System.out.println(7、注销当前账户);System.out.println(请选择);int command sc.nextInt();switch (command){case 1://查询当前账户showLoginAccountt();break;case 2://存款depositMoney();break;case 3://取款drawMoney();break;case 4://转账transferMoney();break;case 5://密码修改break;case 6://退出账户System.out.println(loginAcc.getUserName()您退出系统成功);return; //跳出并结束当前方法case 7://注销当前登录的账户if (deleteAccount()){//销户成功了回到欢迎界面return;}break;default:System.out.println(您当前选择的操作是不存在的请确认);}}}//销户操作private boolean deleteAccount() {System.out.println(进行销户操作);//1、问问用户是否确定销户System.out.println(请问您确认销户吗y/n);String command sc.next();switch (command){case y://确实销户//2、判断用户的账户中是否有钱if (loginAcc.getMoney() 0){//真的销户了accounts.remove(loginAcc);System.out.println(您好您的账户已经成功销户);return true;}else {System.out.println(对不起您的账户存在金额不允许销户);return false;}default:System.out.println(好的您的账户保留);return false;}}//转账private void transferMoney() {System.out.println(用户转账);//1、判断系统中是否存在其他账户if (accounts.size()2){System.out.println(当前系统中只要你一个账户无法为其他账户转账);return;}//2、判断自己的账户中是否有钱if (loginAcc.getMoney() 0){System.out.println(您自己都没钱就别转了);return;}//3、真正开始转账了while (true) {System.out.println(请您输入对方的卡号);String cardId sc.next();//4、判断这个卡号是否正确Account acc getAccountByCardId(cardId);if (acc null){System.out.println(您输入的对方的卡号不存在);}else {//对方的账户存在继续让用户认证姓氏String name * acc.getUserName().substring(1); // * 羊羊System.out.println(请您输入【 name 】姓氏);String preName sc.next();//5、判断这个姓氏是否正确啊if (acc.getUserName().startsWith(preName)){while (true) {//认证通过了真正转账了System.out.println(请您输入转账给对方的金额);double money sc.nextDouble();//6、判断金额是否没有超过自己的余额if (loginAcc.getMoney() money){//转给对方//更新自己的账户余额loginAcc.setMoney(loginAcc.getMoney() - money);//更新对方的账户余额acc.setMoney(acc.getMoney() money);System.out.println(您转账成功了);return;//直接跳出转账方法}else {System.out.println(您余额不足无法给对方转这么多钱最多个转loginAcc.getMoney());}}}else {System.out.println(对不起您认证的信息有问题);}}}}private void drawMoney() {System.out.println(取钱操作);//1、判断账户余额是否达到100元如果不到100元就不让用户取钱了if (loginAcc.getMoney()100){System.out.println(您的账户余额不足100元不允许取钱);return;}//2、让用户输入取款金额while (true) {System.out.println(请您输入取款金额);double money sc.nextDouble();//3、判断用户余额是否足够if (loginAcc.getMoney()money){//账户中的余额是足够的//4、判断当前取款金额是否超过了每次限额if (money loginAcc.getLimit()){System.out.println(您当前取款金额超过了每次限额您每次最多可取loginAcc.getLimit());}else {//代表可以开始取钱了更新当前账户的余额即可loginAcc.setMoney(loginAcc.getMoney()-money);System.out.println(您取款money成功取款后您剩余loginAcc.getMoney());break;}}else {System.out.println(余额不足您的账户中的余额是loginAcc.getMoney());}}}//存钱private void depositMoney() {System.out.println(存钱操作);System.out.println(请您输入存款金额);double money sc.nextDouble();//更新当前登录账户的余额loginAcc.setMoney(loginAcc.getMoney()money);System.out.println(恭喜您您存钱money成功存钱后余额是loginAcc.getMoney());}//展示当前登录的账户信息private void showLoginAccountt(){System.out.println(当前用户信息如下);System.out.println(卡号loginAcc.getCardId());System.out.println(户主loginAcc.getUserName());System.out.println(性别loginAcc.getSex());System.out.println(余额loginAcc.getMoney());System.out.println(每次取现额度loginAcc.getLimit());}//完成用户开户操作private void createAccount(){System.out.println(系统开户操作);// 1、创建一个账号对象用于封装对象的开户信息Account acc new Account();//2、需要用户输入自己的开户信息赋值给账户对象System.out.println(请您输入您的账号名称);String name sc.next();acc.setUserName(name);while (true) {System.out.println(请您输入您的性别);char sex sc.next().charAt(0); //男if (sex男 || sex女){acc.setSex(sex);break;}else {System.out.println(您输入的性别有误只能是男或者女);}}while (true) {System.out.println(请您输入您的账户密码);String passWord sc.next();System.out.println(请你输入您的确认密码);String okPassword sc.next();//判断2次密码是否一样if (okPassword.equals(passWord)){acc.setPassWord(okPassword);break;}else {System.out.println(您输入的2次密码不一样请您确认!);}}System.out.println(请您输入您的取现额度);double limit sc.nextDouble();acc.setLimit(limit);//重点我们需要为这个账号生成一个卡号由系统自动生成8位数字表示不能与其他账户的卡号重复String newCardId createCardId();acc.setCardId(newCardId);//3、把这个账号对象存入到账号集合中去accounts.add(acc);System.out.println(恭喜您 acc.getUserName() 开户成功您的卡号是 acc.getCardId());}//返回一个8位数字的卡号而且这个卡号不能与其他账户的卡号重复private String createCardId(){while (true) {//1、定义一个String类型的变量记住8位数字作为卡号String cardId ;//2、使用循环循环8次每次产生一个随机数给cardID连接起来Random r new Random();for (int i 0; i 8; i) {int data r.nextInt(10);cardId data;}//3、判断cardID中记住的卡号是否与其他账户的卡号重复了没有重复才可以作为一个新卡号返回。Account acc getAccountByCardId(cardId);if (acc null){//说明cardId没有找到账户对象因此cardID没有与其账户的卡号重复可以返回它做为一个新卡号return cardId;}}}//根据卡号查询账户对象返回 account [c1,c2,c3 ....]private Account getAccountByCardId(String cardId){//遍历全部的账户对象for (int i 0; i accounts.size(); i) {Account acc accounts.get(i);//判断这个账户对象acc中的卡号是否是我们要找的卡号if (acc.getCardId().equals(cardId)){return acc;}}return null; //查无此账户这个卡号不存在}}package com.liu;import java.util.ArrayList;public class Test {public static void main(String[] args) {//创建一个ATM对象代表ATM系统ATM atm new ATM();//2、调用ATM对象的start方法启动系统atm.start();}
}密码修改 就是更改账户的密码修改密码的要求
1、需要先认证用户当前的密码。
2、认证通过后需要让用户输入2次新密码。
3、两次密码一样则更新账户密码并回到欢迎界面。 package com.liu;public class Account {private String cardId;private String userName;private char sex;private String passWord;private double money;private double limit; //限额public String getCardId() {return cardId;}public void setCardId(String cardId) {this.cardId cardId;}public String getUserName() {return userName (sex 男 ? 先生 : 女士);}public void setUserName(String userName) {this.userName userName;}public char getSex() {return sex;}public void setSex(char sex) {this.sex sex;}public String getPassWord() {return passWord;}public void setPassWord(String passWord) {this.passWord passWord;}public double getMoney() {return money;}public void setMoney(double money) {this.money money;}public double getLimit() {return limit;}public void setLimit(double limit) {this.limit limit;}
}package com.liu;import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;public class ATM {private ArrayListAccount accounts new ArrayList(); //[]private Scanner sc new Scanner(System.in);private Account loginAcc; //记录登录后的用户账户//启动ATM系统展示欢迎界面public void start(){while (true) {System.out.println(欢迎您进入ATM系统);System.out.println(1、用户登录);System.out.println(2、用户开户);System.out.println(请选择);int command sc.nextInt();switch (command){case 1://用户登录login();break;case 2://用户开户createAccount();break;default:System.out.println(没有该操作!);}}}//完成用户的登录操作private void login(){System.out.println(系统登录);//1、判断系统中是否存在账号对象存在才能登录如果不存在我们直接结束登录操作if (accounts.size() 0){System.out.println(当前系统中无任何账户请先开户再来登录);return;//直接跳出登录操作}//2、系统中存在账号对象可以开始进行登录操作while (true) {System.out.println(请您输入您的登录卡号);String cardId sc.next();//3、判断卡号是否存在Account acc getAccountByCardId(cardId);if (acc null){//说明这个卡号不存在System.out.println(您输入的卡号不存在请确认);}else {while (true) {//卡号存在接着让用户输入密码System.out.println(请您输入登录密码);String passWord sc.next();//4、判断密码是否正确if (acc.getPassWord().equals(passWord)){loginAcc acc;//密码正确登陆成功System.out.println(恭喜您acc.getUserName()成功登录了系统您的卡号是acc.getCardId());//展示登录后的操作界面了showUserCommand();return;//跳出并结束当前登录方法}else {System.out.println(您输入的密码不正确请确认);}}}}}//展示登录后的操作界面的private void showUserCommand(){while (true) {System.out.println(loginAcc.getUserName() 您可以选择如下功能进行账户的处理);System.out.println(1、查询账户);System.out.println(2、存款);System.out.println(3、取款);System.out.println(4、转账);System.out.println(5、密码修改);System.out.println(6、退出账户);System.out.println(7、注销当前账户);System.out.println(请选择);int command sc.nextInt();switch (command){case 1://查询当前账户showLoginAccountt();break;case 2://存款depositMoney();break;case 3://取款drawMoney();break;case 4://转账transferMoney();break;case 5://密码修改updatePassword();return; //跳出并结束当前方法case 6://退出账户System.out.println(loginAcc.getUserName()您退出系统成功);return; //跳出并结束当前方法case 7://注销当前登录的账户if (deleteAccount()){//销户成功了回到欢迎界面return;}break;default:System.out.println(您当前选择的操作是不存在的请确认);}}}//账户密码修改private void updatePassword() {System.out.println(账户密码修改操作);//1、提醒用户认证当前密码while (true) {System.out.println(请您输入当前账户的密码);String passWord sc.next();//2、认证当前密码是否正确if (loginAcc.getPassWord().equals(passWord)){//认证通过while (true) {//3、真正开始修改密码了System.out.println(请您输入新密码);String newPassword sc.next();System.out.println(请您再次输入密码);String okPassword sc.next();//4、判断2次密码是否一种if (okPassword.equals(newPassword)){//可以正式修改密码了loginAcc.setPassWord(okPassword);System.out.println(恭喜您您的密码修改成功);return;}else {System.out.println(您输入的2次密码不一致);}}}else {System.out.println(您当前输入的密码不正确);}}}//销户操作private boolean deleteAccount() {System.out.println(进行销户操作);//1、问问用户是否确定销户System.out.println(请问您确认销户吗y/n);String command sc.next();switch (command){case y://确实销户//2、判断用户的账户中是否有钱if (loginAcc.getMoney() 0){//真的销户了accounts.remove(loginAcc);System.out.println(您好您的账户已经成功销户);return true;}else {System.out.println(对不起您的账户存在金额不允许销户);return false;}default:System.out.println(好的您的账户保留);return false;}}//转账private void transferMoney() {System.out.println(用户转账);//1、判断系统中是否存在其他账户if (accounts.size()2){System.out.println(当前系统中只要你一个账户无法为其他账户转账);return;}//2、判断自己的账户中是否有钱if (loginAcc.getMoney() 0){System.out.println(您自己都没钱就别转了);return;}//3、真正开始转账了while (true) {System.out.println(请您输入对方的卡号);String cardId sc.next();//4、判断这个卡号是否正确Account acc getAccountByCardId(cardId);if (acc null){System.out.println(您输入的对方的卡号不存在);}else {//对方的账户存在继续让用户认证姓氏String name * acc.getUserName().substring(1); // * 羊羊System.out.println(请您输入【 name 】姓氏);String preName sc.next();//5、判断这个姓氏是否正确啊if (acc.getUserName().startsWith(preName)){while (true) {//认证通过了真正转账了System.out.println(请您输入转账给对方的金额);double money sc.nextDouble();//6、判断金额是否没有超过自己的余额if (loginAcc.getMoney() money){//转给对方//更新自己的账户余额loginAcc.setMoney(loginAcc.getMoney() - money);//更新对方的账户余额acc.setMoney(acc.getMoney() money);System.out.println(您转账成功了);return;//直接跳出转账方法}else {System.out.println(您余额不足无法给对方转这么多钱最多个转loginAcc.getMoney());}}}else {System.out.println(对不起您认证的信息有问题);}}}}private void drawMoney() {System.out.println(取钱操作);//1、判断账户余额是否达到100元如果不到100元就不让用户取钱了if (loginAcc.getMoney()100){System.out.println(您的账户余额不足100元不允许取钱);return;}//2、让用户输入取款金额while (true) {System.out.println(请您输入取款金额);double money sc.nextDouble();//3、判断用户余额是否足够if (loginAcc.getMoney()money){//账户中的余额是足够的//4、判断当前取款金额是否超过了每次限额if (money loginAcc.getLimit()){System.out.println(您当前取款金额超过了每次限额您每次最多可取loginAcc.getLimit());}else {//代表可以开始取钱了更新当前账户的余额即可loginAcc.setMoney(loginAcc.getMoney()-money);System.out.println(您取款money成功取款后您剩余loginAcc.getMoney());break;}}else {System.out.println(余额不足您的账户中的余额是loginAcc.getMoney());}}}//存钱private void depositMoney() {System.out.println(存钱操作);System.out.println(请您输入存款金额);double money sc.nextDouble();//更新当前登录账户的余额loginAcc.setMoney(loginAcc.getMoney()money);System.out.println(恭喜您您存钱money成功存钱后余额是loginAcc.getMoney());}//展示当前登录的账户信息private void showLoginAccountt(){System.out.println(当前用户信息如下);System.out.println(卡号loginAcc.getCardId());System.out.println(户主loginAcc.getUserName());System.out.println(性别loginAcc.getSex());System.out.println(余额loginAcc.getMoney());System.out.println(每次取现额度loginAcc.getLimit());}//完成用户开户操作private void createAccount(){System.out.println(系统开户操作);// 1、创建一个账号对象用于封装对象的开户信息Account acc new Account();//2、需要用户输入自己的开户信息赋值给账户对象System.out.println(请您输入您的账号名称);String name sc.next();acc.setUserName(name);while (true) {System.out.println(请您输入您的性别);char sex sc.next().charAt(0); //男if (sex男 || sex女){acc.setSex(sex);break;}else {System.out.println(您输入的性别有误只能是男或者女);}}while (true) {System.out.println(请您输入您的账户密码);String passWord sc.next();System.out.println(请你输入您的确认密码);String okPassword sc.next();//判断2次密码是否一样if (okPassword.equals(passWord)){acc.setPassWord(okPassword);break;}else {System.out.println(您输入的2次密码不一样请您确认!);}}System.out.println(请您输入您的取现额度);double limit sc.nextDouble();acc.setLimit(limit);//重点我们需要为这个账号生成一个卡号由系统自动生成8位数字表示不能与其他账户的卡号重复String newCardId createCardId();acc.setCardId(newCardId);//3、把这个账号对象存入到账号集合中去accounts.add(acc);System.out.println(恭喜您 acc.getUserName() 开户成功您的卡号是 acc.getCardId());}//返回一个8位数字的卡号而且这个卡号不能与其他账户的卡号重复private String createCardId(){while (true) {//1、定义一个String类型的变量记住8位数字作为卡号String cardId ;//2、使用循环循环8次每次产生一个随机数给cardID连接起来Random r new Random();for (int i 0; i 8; i) {int data r.nextInt(10);cardId data;}//3、判断cardID中记住的卡号是否与其他账户的卡号重复了没有重复才可以作为一个新卡号返回。Account acc getAccountByCardId(cardId);if (acc null){//说明cardId没有找到账户对象因此cardID没有与其账户的卡号重复可以返回它做为一个新卡号return cardId;}}}//根据卡号查询账户对象返回 account [c1,c2,c3 ....]private Account getAccountByCardId(String cardId){//遍历全部的账户对象for (int i 0; i accounts.size(); i) {Account acc accounts.get(i);//判断这个账户对象acc中的卡号是否是我们要找的卡号if (acc.getCardId().equals(cardId)){return acc;}}return null; //查无此账户这个卡号不存在}}package com.liu;import java.util.ArrayList;public class Test {public static void main(String[] args) {//创建一个ATM对象代表ATM系统ATM atm new ATM();//2、调用ATM对象的start方法启动系统atm.start();}
}面向对象高级一static修饰成员变量、类变量应该场景 static
叫静态可以修饰成员变量、成员方法。
成员变量按照有无static修饰分为两种
类变量有static修饰属于类在计算机里只有一份会被类的全部对象共享。 实例变量对象的变量无static修饰属于每个对象的。实例对象属于对象每个对象中都有一份。 例 package com.liu.d1_staticdemo;public class Student {//类变量static String name;//实例变量int age;
}package com.liu.d1_staticdemo;public class Test {public static void main(String[] args) {//掌握有无static修饰成员变量的用法、特点//1、类变量的用法//类名.类变量推荐Student.name 懒羊羊;//对象.类变量不推荐Student s1 new Student();s1.name 小羊;Student s2 new Student();s2.name 小懒;System.out.println(s1.name); //小懒System.out.println(Student.name); //小懒//2、实例变量的用法属于每个对象的变量//对象.实例变量s1.age 22;s2.age 21;System.out.println(s1.age); //22// System.out.println(Student.age); //报错}
}成员变量的执行原理 类变量属于类与类一起加载一次在内存中只有一份可以被类和类的所有对象共享。 类变量的应用场景
在开发中如果某个数据只需要一份且希望能够被共享访问、修改则该数据可以定义成类变量来记住。
案例导学
系统启动后要求用户类可以记住自己创建了多少个用户对象了。 package com.liu.d1_staticdemo;public class User {//类变量public static int number;public User(){
// User.number;//注意在同一个类中访问自己类的变量才可以省略类名不写number;}
}package com.liu.d1_staticdemo;public class Test2 {public static void main(String[] args) {//目标通过案例理解类变量的应用场景User u1 new User();User u2 new User();User u3 new User();User u4 new User();System.out.println(User.number);}
}成员变量有几种各自在什么情况下定义
类变量数据只需要一份且需要被共享时访问修改实例变量每个对象都要有一份数据各不同如name、score 、age
访问自己类中的类变量是否可以省略类名不写
可以的注意在某个类中访问其他类例的类变量必须带类名访问 面向对象高级一static修饰成员变量方法 成员方法的分类
类方法有static修饰的成员方法属于类。 实例方法无static修饰的成员方法属于对象 package com.liu.d2_static_method;public class Student {double score;//类方法public static void printHelloWorld(){System.out.println(Hello World);System.out.println(Hello World);}public void printPass(){System.out.println(成绩(score 60 ? 及格:不及格));}
}package com.liu.d2_static_method;public class Test {public static void main(String[] args) {//目标掌握有无static修饰方法的用法//1、类方法的用法//类名.类方法Student.printHelloWorld();//对象.类方法不推荐Student s new Student();s.printHelloWorld();//2、实例方法的用法//对象.实例方法s.printPass();
// Student.printPass(); //报错}
}成员方法的执行原理 补充知识搞懂main方法 面对对象高级一static修饰类方法的应用场景——工具类 类方法的常见应用场景
类方法最常见的应用场景是做工具类。
工具类是什么
工具类中的方法都是一些类方法每个方法都是用来完成一个功能的工具类是给开发人员共同使用的。
使用类方法来设计工具类有啥好处
提高了代码复用调用方便提高了开发效率。 案例 优化后
package com.liu.d3_util;import java.util.Random;public class MyUtil {public static String createCode(int n){String code ;String data abvdefghijklmnopqrstuvwsyzABCDEFGHIJKLMNOPQRSTUVWSYZ;Random r new Random();//定定义一个循环产生每位随机字符for (int i 0; i n; i) {//随机一个字符范围内的索引int index r.nextInt(data.length());//根据索引去全部字符中提取该字符code data.charAt(index); //code code 字符}return code;}
}package com.liu.d3_util;public class LoginDemo {public static void main(String[] args) {System.out.println(MyUtil.createCode(4));}
}package com.liu.d3_util;public class RegisterDemo {public static void main(String[] args) {System.out.println(MyUtil.createCode(6));}
}为什么工具类中的方法要用类方法而不用实例方法
实例方法需要创建对象来调用此时对象只是为了调用方法对象占内存这样会浪费内存。类方法直接用类名调用即可调用方便也能节省内存。
多学一招
工具类没有创建对象的需求建议将工具类的构造器进行私有。 面向对象高级一static的注意事项 使用类方法、实例方法时的几点注意事项
类方法中可以直接访问类的成员不可以直接访问实例成员。实例方法中既可以直接访问类成员页可以直接访问实例成员。实例方法中可以出现this关键字类方法中不可以出现this关键字的。
package com.liu.d3_static_attention;public class Test {public static void main(String[] args) {//目标掌握使用类方法、实例方法的几点注意事项
// 类方法中可以直接访问类的成员不可以直接访问实例成员。
// 实例方法中既可以直接访问类成员页可以直接访问实例成员。
// 实例方法中可以出现this关键字类方法中不可以出现this关键字的。}
}package com.liu.d3_static_attention;public class Student {static String schoolName; //类变量double score; //实例变量//1、类方法中可以可以直接访问类的成员变量不可以直接访问实例成员public static void printHelloWorld(){//注意同一个类中访问类成员可以省略类名不写
// Student.schoolName 懒羊羊; //Student可以省略schoolName 懒羊羊;printHelloWorld2();// System.out.println(score); //报错
// printPass(); //报错// System.out.println(this); //报错的}//类方法public static void printHelloWorld2(){}//实例方法//实例方法中既可以直接访问类成员页可以直接访问实例成员。public void printPass(){schoolName 玫瑰;printHelloWorld2();System.out.println(score);
// this.printPass2(); //this可以省略printPass2();System.out.println(this);}//实例方法public void printPass2(){}
}面向对象高级一static应用——代码块 代码块概述
代码块是类的5大成分之一成员变量、构造器、方法、代码块、内部类。
代码块分为两种
静态代码块
格式static { }
特点类加载时自动执行由于类只会加载一次所以静态代码块也只会执行一次。
作用完成类的初始化例如对类变量的初始化赋值。
package com.liu.d5_block;public class Student {static int number 80;static String schoolName;//静态代码块static {System.out.println(静态代码块执行);schoolName 重要的东西眼睛是看不见的;}
}package com.liu.d5_block;public class Test {public static void main(String[] args) {//目标认识两种代码块了解他们的特点和基本作用System.out.println(Student.number);//静态代码块执行//80//静态代码块执行 只会加载一次 只会执行一次System.out.println(Student.number);//80System.out.println(Student.number);//80System.out.println(Student.schoolName); //重要的东西眼睛是看不见的}
}实例代码块
格式{ }
特点每次创建对象时执行实例代码块并在构造器前执行。
作用和构造器一样都是用来完成对象的初始化的例如对实例变量进行初始化赋值
package com.liu.d5_block;public class Student {static int number 80;static String schoolName;//静态代码块static {System.out.println(静态代码块执行);schoolName 重要的东西眼睛是看不见的;}int age;//实例代码块{System.out.println(实例代码块执行);age 18;System.out.println(有人创建了对象 this);}public Student(){System.out.println(无参构造器执行);
// System.out.println(有人创建了对象 this);}public Student(String name){System.out.println(有参构造器执行);
// System.out.println(有人创建了对象 this);}
}package com.liu.d5_block;public class Test {public static void main(String[] args) {//目标认识两种代码块了解他们的特点和基本作用System.out.println(Student.number);//静态代码块执行//80//静态代码块执行 只会加载一次 只会执行一次System.out.println(Student.number);//80System.out.println(Student.number);//80System.out.println(Student.schoolName); //重要的东西眼睛是看不见的System.out.println();Student s1 new Student();Student s2 new Student(鹦鹉);System.out.println(s1.age);System.out.println(s2.age);}
}面向对象高级一static应用——单例设计模式、饿汉式单例、懒汉式单例 什么是设计模式Design pattern
一个问题通常有n种解法其中肯定有一种解法是最优的这个最优的解法被人总结出来了称之为式设计模式。设计模式有20多种对应20多种软件开发中遇到的问题。
关于设计模式的学习主要学什么
1、解决什么问题
2、怎么写
单例设计模式
确保一个类只有一个对象。
单例写法
把类的构造器私有。定义一个类变量记住类的一个对象。定义一个类方法返回对象。
package com.liu.d6_singleInstance;public class A {//2、定义一个类变量记住类的一个对象private static A a new A();//1、必须私有类的构造器private A(){}//3、定义一个类方法返回类的对象public static A getObject(){return a;}
}package com.liu.d6_singleInstance;public class Test1 {public static void main(String[] args) {//目标掌握单例模式的写法A a1 A.getObject();A a2 A.getObject();System.out.println(a1);System.out.println(a2);}
}单例模式的应用场景和好处
1、Runtime 2、任务管理器对象、获取运行时对象
在这些业务场景下使用单例模式可以避免浪费内存。 单例设计模式的实现方式很多
饿汉式单例拿对象时对象早就创建好了。懒汉式单例拿对象时才开始创建对象。..................
懒汉式单例设计模式
拿对象时才开始创建对像。
写法
把类的构造器私有。定义一个类变量用于存储对象。提供一个类方法保证返回的是同一个对象。
package com.liu.d6_singleInstance;public class B {//2、定义一个类变量用于存储这个类的一个对象private static B b;//1、把类的构造器私有private B(){}//3、定义一个类方法这个方法要保证第一次调用时才创建一个对象后面调用时都会用这同一个对象返回public static B getInstance(){if (b null){System.out.println(第一次创建对象);b new B();}return b;}
}package com.liu.d6_singleInstance;public class Test2 {public static void main(String[] args) {B b1 B.getInstance(); //第一次拿对象B b2 B.getInstance();System.out.println(b1 b2);}
}面向对象高级一继承使用继承的好处 Java使用extends作为继承的关键字extends关键字在英文中时扩展而不是继承这个关键字很好地体现了子类和父类地关系子类时对父类地扩展子类是一种特殊地父类。从这个意义上来看使用继承来描述子类和父类地关系是错误的用扩展更恰当。
子类扩展了父类将可以获得父类的全部成员变量和方法值得指出的是Java子类不能获得父类的构造器。
什么是继承呢
Java中提供了一个关键字extends用这个关键字可以让一个类和另一个类建立起父子关系。实现继承的类被称为子类被继承的类被称为父类有的也称其为基类、超类。父类和子类的关系是一种一般与特殊的关系。 继承的特点
子类能继承父类的非私有成员成员变量、成员方法继承后对象的创建子类的对象是由子类、父类共同完成的。
package com.liu.d7_extends;//父类
public class A {//公开成员public int i ;public void print1(){System.out.println(print1);}//私有成员private int j;private void print2(){System.out.println(print2);}}package com.liu.d7_extends;//子类
public class B extends A{public int k ;private int z;//子类可以继承父类的非私有成员public void print3(){System.out.println(i);print1();// System.out.println(j); //报错
// print2(); //报错}
}package com.liu.d7_extends;public class Test {public static void main(String[] args) {//目标认识继承掌握继承的特点。B b new B();System.out.println(b.i);
// System.out.println(b.j);//报错System.out.println(b.k);
// System.out.println(b.z); //报错b.print1();
// b.print2(); //报错b.print3();}
}继承的执行原理 带继承关系的类Java会怎么创建它的对象对象创建出来后可以直接访问哪些成员
带继承关系的类Java会用类和其父类这多张设计图来一起创建类的对象。对象能直接访问什么成员是由子父类这多张设计图共同决定的这多张设计图对外暴露了什么成员对象就可以访问什么成员
使用继承有啥好处
减少重复代码的编写。
需求
黑马的员工管理系统中需要处理讲师、咨询师的数据讲师的数据有姓名、具备的技能咨询的数据有姓名、解答问题的总人数 package com.liu.d8_extends_application;public class People {private String name;public String getName() {return name;}public void setName(String name) {this.name name;}
}package com.liu.d8_extends_application;public class Teacher extends People{private String skill;public String getSkill() {return skill;}public void setSkill(String skill) {this.skill skill;}public void printInfo(){System.out.println(getName()具备的技能:skill);}
}package com.liu.d8_extends_application;public class Tets {public static void main(String[] args) {//目标高清楚继承的好处Teacher t new Teacher();t.setName(玫瑰);t.setSkill(陪伴小王子);System.out.println(t.getName());System.out.println(t.getSkill());t.printInfo();}
}面向对象高级一继承权限修饰符 什么是权限修饰符
就是用来限制类中的成员成员变量、成员方法、构造器、代码块...能够被访问的范围。
权限修饰有几种各自的作用是什么 package com.liu.d9_modifer;public class Fu {//1、私有只能在本类中访问private void privateMethod(){System.out.println(private);}//2、缺省本类同一个包下的类void method(){System.out.println(缺省);}//3、protected本类同一个包下的类任意包下的子类protected void protectedMethod(){System.out.println(protected);}//4、public本类同一个包下的类任意包下的子类任意包下的任意类public void publicMethod(){System.out.println(public);}public void test(){privateMethod();method();protectedMethod();publicMethod();}
}package com.liu.d9_modifer;public class Demo {public static void main(String[] args) {//目标掌握不同权限修饰符的作用Fu f new Fu();
// f.privateMethod();//报错f.method();f.protectedMethod();f.publicMethod();}
}package com.liu.d10_modifer;import com.liu.d9_modifer.Fu;public class Zi extends Fu {public void test(){
// privateMethod(); //报错
// method(); //报错protectedMethod();publicMethod();}}package com.liu.d10_modifer;import com.liu.d9_modifer.Fu;public class Demo2 {public static void main(String[] args) {Fu f new Fu();
// f.privateMethod();//报错
// f.method();//报错
// f.protectedMethod();//报错f.publicMethod();Zi zi new Zi();
// zi.protectedMethod();//报错}
}面向对象高级一继承单继承、Object、方法重写 Java是单继承Java中的类不支持多继承但是支持多层继承 package com.liu.d11_extends_feature;public class Test {public static void main(String[] args) {//目标掌握继承的两个注意事项//1、Java是单继承的一个类只能继承一个直接父类Java中的类不支持多继承但是支持多层继承。//2、Object类是Java中所有类的祖宗}
}class A{}
class B extends A{}//class C extends B,A{} //报错
class C extends B{}class D extends B{}
为何Java中的类不支持多继承 请看如下反证法 Object类
object类是Java所有类的祖宗类。我们写的任何一个类其实都是object的子类或子孙类
package com.liu.d11_extends_feature;public class Test {public static void main(String[] args) {//目标掌握继承的两个注意事项//1、Java是单继承的一个类只能继承一个直接父类Java中的类不支持多继承但是支持多层继承。//2、Object类是Java中所有类的祖宗A a new A();}
}class A {}
//class A extends Object{}//默认继承Object类
class B extends A{}//class C extends B,A{} //报错
class C extends B{}class D extends B{} 什么是方法重写
当子类决定父类中的某个方法不好用或者无法满足自己的需求时子类可以重写一个方法名称、参数列表一样的方法去覆盖父类的这个方法这就是方法重写。注意重写后方法的访问Java会遵循就近原则。方法的重写要遵循“两同大小一大”规则“两同”即方法名相同、形参列表相同“两小”指的是子类方法返回值类型应比父类返回值类型更小或相等子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等“一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。
package com.liu.d12_extends_override;public class A {public void print1(){System.out.println(积极向上永远时主旋律);}public void print2(int a,int b){System.out.println(希望我希望的有希望);}
}package com.liu.d12_extends_override;public class B extends A{//方法重写public void print1(){System.out.println(做真正自己喜欢的事);}//方法重写public void print2(int a,int b){System.out.println(不是因为有希望才坚持是因为坚持才有希望);}}package com.liu.d12_extends_override;public class Test {public static void main(String[] args) {//目标认识方法重写掌握方法重写的常见应用场景B b new B();b.print1();b.print2(5,500);}
}方法重写的其它注意事项
重写小技巧使用Override注解它可以指定Java编译器检查我们方法重写的格式是否正确代码可读性也会更好。建议加上注解子类重写父类方法时访问权限必须大于或者等于父类方法的权限publicprotected缺省。重写的方法返回值类型必须与被重写方法的返回值类型一样或者范围更小。私有方法、静态方法不能被重写如果重写会报错的。 方法重写在开发中的常见应用场景
子类重写Object类的toString方法以便返回对象的内容。
package com.liu.d12_extends_override;public class Student extends Object{private String name;private int age;public Student() {}public Student(String name, int age) {this.name name;this.age age;}public String getName() {return name;}public void setName(String name) {this.name name;}public int getAge() {return age;}public void setAge(int age) {this.age age;}Overridepublic String toString() {return Student{ name name \ , age age };}
}package com.liu.d12_extends_override;import java.util.ArrayList;public class Test {public static void main(String[] args) {//目标认识方法重写掌握方法重写的常见应用场景Student s new Student(懒羊羊,18);//System.out.println(args.toString()); //com.liu.d12_extends_override.Student4554617cSystem.out.println(s);//com.liu.d12_extends_override.Student4554617cArrayList list new ArrayList();list.add(立刻);System.out.println(list);}
}面向对象高级一继承子类访问成员变量的特点 1、 在子类方法中访问其他成员成员变量、成员方法是依照就近原则的。
package com.liu.d13_extends_visit;public class F {String name 治愈懒羊羊;public void print1(){System.out.println(维持关系的最好办法是分享);}
}package com.liu.d13_extends_visit;public class Z extends F{String name 小懒;public void showName(){String name 玫瑰;System.out.println(name); //局部名称System.out.println(this.name); //子类成员变量nameSystem.out.println(super.name);//父类的成员变量}Overridepublic void print1(){System.out.println(请立刻学习);}public void showMethod(){print1();//父类的super.print1();}
}package com.liu.d13_extends_visit;public class Test {public static void main(String[] args) {//目标掌握子类中访问其他成员的特点就近原则Z z new Z();z.showName();z.showMethod();}
}先子类局部范围找。然后子类成员范围找。然后父类成员范围找如果父类范围还没有找到则报错。
2、如果子类中出现了重名的成员会优先使用子类的如果此时一定要在子类中使用父类的怎么办
可以通过super关键字指定访问父类的成员super . 父类成员变量/父类成员方法 面向对象高级一继承子类构造器的特点super、this调用兄弟构造器 子类构造器的特点
子类的全部构造器都会先调用父类的构造器再执行自己。
package com.liu.d14_extends_constructor;class F{
// public F(){
// System.out.println(父类F的 无参构造器 执行了);
// }public F(String name,int age){}
}class Z extends F{public Z(){
// super();//默认存在的super(小懒,18);System.out.println(子类的 无参构造器 执行了);}public Z(String name ){// super();//默认存在的super(小懒,18);System.out.println(子类的 有参构造器 执行了);}
}public class Test {public static void main(String[] args) {//目标先认识子类构造器的特点再掌握这个特点的常见应用场景Z z new Z();Z z2 new Z(懒羊羊);}
}子类构造器是如何实现调用父类构造器的
默认情况下子类全部构造器的第一行代码都是super写不写都有它会调用父类的无参数构造器。如果父类没有无参数构造器则我们必须再子类构造器的第一行手写super...指定去调用父类的有参数构造器。
子类构造器的特点
子类的全部构造器都会先调用父类的构造器
package com.liu.d14_extends_constructor;public class Test2 {public static void main(String[] args) {//目标搞清楚子类构造器为什么要调用父类构造器有啥应用场景Teacher t new Teacher(小懒,36,java);System.out.println(t.getName());System.out.println(t.getAge());System.out.println(t.getSkill());}
}class Teacher extends People{private String skill;public Teacher(String name,int age,String skill){super(name,age);this.skill skill;}public String getSkill() {return skill;}public void setSkill(String skill) {this.skill skill;}
}class People{private String name;private int age;public People() {}public People(String name, int age) {this.name name;this.age age;}public String getName() {return name;}public void setName(String name) {this.name name;}public int getAge() {return age;}public void setAge(int age) {this.age age;}
}子类构造器调用父类构造器的常见应用场景
子类构造器可以通过调用父类构造器把对象中包含父类这部分的数据先初始化赋值再回来把对象里包含子类这部分的数据也进行初始化赋值。
补充知识this...调用兄弟构造器
任意类的构造器中是可以通过this...去调用该类的其他构造器的。
package com.liu.d14_extends_constructor;public class Test3 {public static void main(String[] args) {//目标掌握在类的构造器中通过this...调用兄弟构造器的作用Student s1 new Student(懒羊羊,18,牛津大学);//需求如果学生没有填写学校那么学校默认就是黑马程序员Student s2 new Student(玫瑰,20);System.out.println(s2.getName());System.out.println(s2.getAge());System.out.println(s2.getSchoolName());}
}class Student{private String name;private int age;private String schoolName;public Student() {}public Student(String name,int age){this(name,age,清华大学);
// super(); //this和super不能同时出现在构造器里面}public Student(String name, int age,String schoolName) {super();this.name name;this.age age;this.schoolName schoolName;}public String getName() {return name;}public void setName(String name) {this.name name;}public int getAge() {return age;}public void setAge(int age) {this.age age;}public String getSchoolName() {return schoolName;}public void setSchoolName(String schoolName) {this.schoolName schoolName;}
}1、子类构造器的特点
子类中的全部构造器都必须先调用父类的构造器在执行自己。
2、super...调用父类有参数构造器的常见应用场景是什么
为对象包含父类这部分的成员变量进行赋值。
3、this...的作用是什么
在构造器中调用本类的其他构造器。
4、this...和super...的使用需要注意什么
都必须放在构造器的第一行 面向对象高级二多态、使用多态的好处 java引用变量有两个类型一个时编译时的类型一个时运行时类型。编译时类型由声明该变量时使用的类型决定运行时类型由实际赋值给变量的对象决定。如果编译时类型和运行类型不一致就可能出现所谓的多态Polymorphism。
什么是多态
多态是在继承/实现的情况下的一种现象表现为对象多态、行为多态。
多态的具体代码体现
package com.liu.d1_polymorphism;
//父类
public class People {public String name 父类People的名称;public void run(){System.out.println(我自己就是太阳我需要找个并肩的人);}
}package com.liu.d1_polymorphism;public class Student extends People{Overridepublic void run(){System.out.println(故事的开头总是这样);}
}package com.liu.d1_polymorphism;public class Teacher extends People{Overridepublic void run(){System.out.println(如果心动了那为何不坚定呢);}
}package com.liu.d1_polymorphism;public class Test {public static void main(String[] args) {//目标认识多态对象多态行为多态//1、对象多态People p1 new Teacher();p1.run();//识别技巧编译看左边运行看右边System.out.println(p1.name);//编译看左边运行看右边People p2 new Student();p2.run();//识别技巧编译看左边运行看右边System.out.println(p2.name);//编译看左边运行看右边}
}使用多态的好处
在多态形式下右边对象是解耦合的更便于扩展和维护。 定义方法时使用父类类型的形参可以接受一切子类对象扩展性更强、更便利。
package com.liu.d2_polymorphism;
//父类
public class People {public String name 父类People的名称;public void run(){System.out.println(我自己就是太阳我需要找个并肩的人);}
}package com.liu.d2_polymorphism;public class Student extends People {public String name 子类Student的名称;Overridepublic void run(){System.out.println(故事的开头总是这样);}public void test(){System.out.println(学生需要考试);}
}package com.liu.d2_polymorphism;public class Teacher extends People {public String name 子类Teacher的名称;Overridepublic void run(){System.out.println(如果心动了那为何不坚定呢);}public void teacher(){System.out.println(老师需要教知识);}
}package com.liu.d2_polymorphism;public class Test {public static void main(String[] args) {//目标理解多态的好处//1.可以实现解耦合右边对象可以随时切换后续业务随机改变People p1 new Student();p1.run();//识别技巧编译看左边运行看右边
// p1.test();//多态下存在的问题无法直接调用子类的独有功能Student s new Student();go(s);Teacher t new Teacher();go(t);}//2、可以使用父类类型的变量作为形参可以接受一切子类对象public static void go(People p){}}多态下会产生的一个问题怎么解决
多态下不能使用子类的独有功能。
类型转换
自动类型转换父类 变量名 new 子类强制类型转换子类 变量名 new 父类变量 强制类型转换的一个注意事项
存在继承/实现关系就可以在编译阶段进行强制类型转换编译阶段不会报错。运行时如果发现对象的真实类型与强转后的类型不同就会类型转换异常CalssCastException的错误出来。 强转前Java建议
使用instanceof关键字判断当前对象的真实类型再进行强转 package com.liu.d2_polymorphism;
//父类
public class People {public String name 父类People的名称;public void run(){System.out.println(我自己就是太阳我需要找个并肩的人);}
}package com.liu.d2_polymorphism;public class Student extends People {public String name 子类Student的名称;Overridepublic void run(){System.out.println(故事的开头总是这样);}public void test(){System.out.println(学生需要考试);}
}package com.liu.d2_polymorphism;public class Teacher extends People {public String name 子类Teacher的名称;Overridepublic void run(){System.out.println(如果心动了那为何不坚定呢);}public void teach(){System.out.println(老师需要教知识);}
}package com.liu.d2_polymorphism;public class Test {public static void main(String[] args) {//目标理解多态的好处//1.可以实现解耦合右边对象可以随时切换后续业务随机改变People p1 new Student();p1.run();//识别技巧编译看左边运行看右边
// p1.test();//多态下存在的问题无法直接调用子类的独有功能//强制类型转换Student s1 (Student) p1;s1.test();//强制类型转换可能存在的问题编译阶段有继续或者实现关系就可以强制转换但是运行时可能出现类型转换异常
// Teacher t1 (Teacher)p1;if(p1 instanceof Student){Student s2 (Student) p1;s2.test();}else if (p1 instanceof Teacher){Teacher t2 (Teacher) p1;t2.teach();}Student s new Student();go(s);Teacher t new Teacher();go(t);}//2、可以使用父类类型的变量作为形参可以接受一切子类对象public static void go(People p){p.run();if (p instanceof Student){Student s (Student) p;s.test();}else if (p instanceof Teacher){Teacher t (Teacher) p;t.teach();}}} 面向对象高级二final、常量 final
final关键字是最终的意思可以修饰类、方法、变量修饰类该类称为最终类特点是不能被继承了。修饰方法该方法称为最终方法特点是不能被重写了。修饰变量该变量只能被赋值一次。
package com.liu.d3_final;public class Test {/*** 常量public static final修饰的成员变量建议名称全部大写多个单词下划线连接*/public static final String schoolName 小懒;private final String name 小羊;public static void main(String[] args) {//目标认识final作用//3、final可以修饰变量总规则只能赋值一次值//变量//1局部变量 2成员变量//成员变量1实例变量 2类变量静态成员变量final int a ;a 12;
// a 13; //第二次赋值出错了final double r 3.14;// r0.1; //第二次赋值出错了// schoolName 玫瑰; //第二次赋值出错了Test t new Test();
// t.name 总负责人;//第二次赋值出错了}public static void buy(final double z){// z0.1; //第二次赋值出错了}
}//1、final修饰类类不能被继承了
final class A{}
//class B extend A{}
//2、final修饰方法方法不能被重写了
class C{public final void test(){}
}
class D extends C{
// Override
// public void test(){}
}final修饰变量的注意
final修饰基本类型的变量变量存储的数据不能被改变final修饰引用类型的变量变量存储的地址不能被改变但地址所指向对象的内容是可以被改变的。 常量
使用了static final修饰的成员变量就被称为常量作用通常用于记录系统的配置信息 注意常量名的命名规范建议使用大写英文单词多个单词使用下划线连接起来
使用常量记录系统配置信息的优势、执行原理
代码可读性更好可维护性也更好程序编译后常量会被“宏替换”出现常量的地方全部会被替换成其记住的字面量这样可以保证使用常量和直接用字面量的性能是一样的。
package com.liu.d3_final;public class Test2 {public static final String SCHOL_NAME 阳光万里;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(SCHOL_NAME);System.out.println(SCHOL_NAME);System.out.println(SCHOL_NAME);System.out.println(SCHOL_NAME);System.out.println(SCHOL_NAME);}
}面向对象高级二抽象类——认识抽象类和其好处 什么是抽象类
在Java中有一个关键字叫abstract它就是抽象的意思可以用它修饰类、成员方法abstract修饰类这个类就是抽象类修饰方法这个方法就是抽象方法。 抽象类的注意事项、特点
抽象类不一定有抽象方法有抽象方法的类一定是抽象类。类该有的成员成员变量、方法、构造器抽象类都可以有。抽象类最主要的特点抽象类不能创建对象仅作为一种特殊的父类让子类继承并实现。一个类继承抽象类必须重写完抽象类的全部抽象方法否则这个类也必须定义成抽象类。
package com.liu.d4_abstract;//抽象类
public abstract class A {private String name;public static String schoolName;// public abstract void run(){
// }//抽象方法必须用abstract修饰只要方法签名一定不能有方法体public abstract void run();public A(){}public A(String name) {this.name name;}public String getName() {return name;}public void setName(String name) {this.name name;}public static String getSchoolName() {return schoolName;}public static void setSchoolName(String schoolName) {A.schoolName schoolName;}
}package com.liu.d4_abstract;public class Test {public static void main(String[] args) {//目标认识抽象类和其特点//注意抽象类不能创建对象
// A a new A() ; //报错}
}package com.liu.d4_abstract;//一个类继承了抽象类必须重写完抽象类的全部抽象方法否则自己也是抽象类
public class B extends A{Overridepublic void run() {}
}抽象类的场景和好处
父类知道每个子类都要做某个行为但每个子类要做的情况不一样父类就定义成抽象方法交给子类重写实现我们设计这样的抽象类就是为了更好的支持多态
案例 package com.liu.d5_abstract2;public abstract class Animal {private String name;public abstract void cry();public String getName() {return name;}public void setName(String name) {this.name name;}
}package com.liu.d5_abstract2;public class Cat extends Animal{Overridepublic void cry() {System.out.println(getName() 喵喵的叫);}
}package com.liu.d5_abstract2;public class Dog extends Animal{Overridepublic void cry() {System.out.println(getName() 汪汪的叫);}
}package com.liu.d5_abstract2;public class Test {public static void main(String[] args) {//目标掌握抽象类的好处Animal a new Cat();a.setName(小猫咪);a.cry(); //更好的支持了多态}
}面向对象高级二抽象类的应用——模板方法设计模式 模板方法设计模式解决了什么问题
解决方法中存在重复代码的问题。 模板方法设计模式的写法
1、定义一个抽象类。
2、在里面定义2个方法 一个是模板方法把相同代码放里面去。 一个是抽象方法具体实现交给子类完成。
package com.liu.d6_abstract_template;public abstract class People {//设计模板方法模式//1、定义一个模板方法出来public final void write(){System.out.println(\t\t\t\t\t我的爸爸);System.out.println(\t\t不是因为有希望才坚持是因为坚持才有希望);//2、模板方法并不清楚正文部分到底应该怎么写但是它知道子类肯定要写System.out.println(writeMain());System.out.println(不要在饿肚子的时候进超市会买错东西会把本来不想要的东西放进购物车);}//3、设计一个抽象方法写正文具体的实现交给子类来完成public abstract String writeMain();}package com.liu.d6_abstract_template;public class Student extends People{Overridepublic String writeMain() {return 我自己就是太阳我需要找个并肩的人;}
}package com.liu.d6_abstract_template;public class Teacher extends People{Overridepublic String writeMain() {return 在无人问津的地方历练在万众瞩目的地方出现;}}package com.liu.d6_abstract_template;public class Test {public static void main(String[] args) {//目标:搞清楚抽象类的应用场景之一经常用来设计模板方法模式//场景学生老师都要写一篇作文我的爸爸//第一段 是一样的//正文部分自由发挥//最后一段也是一样的Teacher t new Teacher();t.write();Student s new Student();s.write();}
}多学一招建议使用final关键字修饰模板方法为什么
模板方法是给对象直接用的不能被子类重写。一旦子类重写了模板方法模板方法就失效了。 面向对象高级二接口认识接口使用接口的好处 认识接口
Java提供了一个关键字interface用这个关键字我们可以定义出一个特殊的结构接口 注意接口不能创建对象接口是用来被类实现implements的实现接口的称为实现类。 一个类可以实现多个接口接口可以理解成干爹实现类实现多个接口必须重写完全部接口的全部抽象方法否则实现类需要定义成抽象类。
package com.liu.d7_interface;public interface A {//成员变量常量String SCHOOL_NAME 玫瑰;//成员方法抽象方法void test();}package com.liu.d7_interface;public interface B {void testB1();void testB2();
}package com.liu.d7_interface;public interface C {void test1();void test2();
}package com.liu.d7_interface;public class D implements B,C{Overridepublic void testB1() {}Overridepublic void testB2() {}Overridepublic void test1() {}Overridepublic void test2() {}
}package com.liu.d7_interface;public class Test {public static void main(String[] args) {//目标认识接口System.out.println(A.SCHOOL_NAME);// A a new A();D d new D();d.test1();}
}接口的好处重点
弥补了类单继承的不足一个类同时可以实现多个接口让程序可以面对接口编程这样程序员就可以灵活方便的切换各种业务实现。
package com.liu.d7_interfance2;import com.liu.d5_abstract2.Animal;
import com.liu.d5_abstract2.Cat;public class Test {public static void main(String[] args) {//目标搞清楚使用接口的好处Driver s new A();s.driver();Driver d new B();d.driver();Animal a new Cat();a.cry();}
}
class B implements Driver{Overridepublic void driver() {}
}class A extends Student implements Driver,Singer{Overridepublic void driver() {}Overridepublic void sing() {}
}class Student{}interface Driver{void driver();}interface Singer{void sing();}面向对象高级二接口综合案例 案例接口的应用案例班级学生信息管理模块 package com.liu.d7_interface_demo;public class Student {private String name;private char sex;public double score;public Student() {}public Student(String name, char sex, double score) {this.name name;this.sex sex;this.score score;}public String getName() {return name;}public void setName(String name) {this.name name;}public char getSex() {return sex;}public void setSex(char sex) {this.sex sex;}public double getScore() {return score;}public void setScore(double score) {this.score score;}
}package com.liu.d7_interface_demo;import java.util.ArrayList;public class ClassManager {private ArrayListStudent students new ArrayList();private StudentOPerator studentOPerator new StudentOperatorImpl1();
// private StudentOPerator studentOPerator new StudentOperatorImpl2();public ClassManager(){students.add(new Student(喜欢的东西买了吗,女,20));students.add(new Student(陌生人,女,18));students.add(new Student(玫瑰,女,21));students.add(new Student(懒羊羊,女,3));}//打印全班全部学生的全部信息public void printInfo(){studentOPerator.printAllInfo(students);}//打印全班全部学生的平均分public void printScore(){studentOPerator.printAverageScore(students);}
}package com.liu.d7_interface_demo;import java.util.ArrayList;public interface StudentOPerator {void printAllInfo(ArrayListStudent students);void printAverageScore(ArrayListStudent students);
}package com.liu.d7_interface_demo;import java.util.ArrayList;public class StudentOperatorImpl1 implements StudentOPerator{Overridepublic void printAllInfo(ArrayListStudent students) {System.out.println(---------------全班全部学生信息如下------------------------);for (int i 0; i students.size(); i) {Student s students.get(i);System.out.println(姓名s.getName()性别 s.getSex()成绩s.getScore());}System.out.println(--------------------------------------------------------);}Overridepublic void printAverageScore(ArrayListStudent students) {double allScore 0.0;for (int i 0; i students.size(); i) {Student s students.get(i);allScore s.getScore();}System.out.println(平均分(allScore)/students.size());}
}package com.liu.d7_interface_demo;import java.util.ArrayList;public class StudentOperatorImpl2 implements StudentOPerator{Overridepublic void printAllInfo(ArrayListStudent students) {System.out.println(---------------全班全部学生信息如下------------------------);int count1 0;int count2 0;for (int i 0; i students.size(); i) {Student s students.get(i);System.out.println(姓名s.getName()性别 s.getSex()成绩s.getScore());if (s.getSex() 男){count1;}else {count2;}}System.out.println(男生人数是 count1 ,女生人数是 count2);System.out.println(班级总人数是 students.size());System.out.println(--------------------------------------------------------);}Overridepublic void printAverageScore(ArrayListStudent students) {double allScore 0.0;double max students.get(0).getScore();double min students.get(0).getScore();for (int i 0; i students.size(); i) {Student s students.get(i);if (s.getScore() max) max s.getScore();if (s.getScore() min) min s.getScore();allScore s.getScore();}System.out.println(学生的最高分是 max);System.out.println(学生的最低分是 min);System.out.println(平均分 (allScore-max-min)/(students.size()-2));}
}package com.liu.d7_interface_demo;public class Test {public static void main(String[] args) {//目标完成班级学生信息管理的案例ClassManager class2 new ClassManager();class2.printInfo();class2.printScore();}
}StudentOperatorImpl1() 或 StudentOperatorImpl2()不同运行出来的结果也会不同 面向对象高级二接口JDK8开始接口新增的方法、接口的多继承、注意事项 package com.liu.d8_interface_jdk8;public interface A {//1、默认方法必须使用interface修饰默认会被public修饰//实例方法对象的方法,必须使用实现类的对象访问default void test(){System.out.println(默认方法);//私有方法的访问
// test2();}//2、私有方法必须使用private修饰(JDK9才开始支持的)
// private void test2(){
// System.out.println(私有方法);
//
// }//3、静态方法必须使用static修饰默认会被public修饰static void test3(){System.out.println(静态方法);}void test4();void test5();default void test6(){}
}package com.liu.d8_interface_jdk8;public class B implements A{Overridepublic void test4() {}Overridepublic void test5() {}
}package com.liu.d8_interface_jdk8;public class Test {public static void main(String[] args) {//目标掌握接口新增的三种方法模式B b new B();b.test();// b.test3(); //错误访问A.test3();}
}JDK开始接口新增了三种形式的方法 JDK8开始接口中为啥要新增这些方法
增强了接口的能力更便于项目的扩展和维护。
接口的多继承
一个接口可以同时继承多个接口 package com.liu.d9_interface_attention;public class Test {public static void main(String[] args) {//目标理解接口的多继承}
}interface A{void test1();
}
interface B{void test2();
}
interface C{}
//接口是多继承的
interface D extends C,B,A{}class E implements D{Overridepublic void test1() {}Overridepublic void test2() {}
}
接口多继承的作用
便于实现类的实现
接口其他注意事项了解
1、一个接口继承多个接口如果多个接口中存在方法签名冲突则此时不支持多继承
2、一个类实现多个接口如果多个接口中存在方法签名冲突则此时不支持多实现
3、一个类继承了父类又同时实现了接口父类中和接口中有同名的默认方法实现类会优先用父类的
4、一个类实现了多个接口多个接口中存在同名的默认方法可以不冲突这个类重写该方法即可。
package com.liu.d9_interface_attention;public class Test2 {public static void main(String[] args) {//目标接口其他注意事项了解)Zi zi new Zi();zi.run();}
}// 1、一个接口继承多个接口如果多个接口中存在方法签名冲突则此时不支持多继承
interface I{void test1();
}
interface J{String test1();
}
//interface K extends I,J{}// 2、一个类实现多个接口如果多个接口中存在方法签名冲突则此时不支持多实现
//class E implements I,J{}// 3、一个类继承了父类又同时实现了接口父类中和接口中有同名的默认方法实现类会优先用父类的
class Fu{public void run(){System.out.println(父类的run方法执行了);}
}
interface IT{default void run(){System.out.println(接口IT中的run方法执行了);}
}
class Zi extends Fu implements IT{}
//class Zi implements IT extends Fu{} //写法错误//4、一个类实现了多个接口多个接口中存在同名的默认方法可以不冲突这个类重写该方法即可。
interface It1{default void test1(){System.out.println(IT1);}
}
interface It2{default void test1(){System.out.println(IT2);}
}
class N implements It1,It2{Overridepublic void test1() {System.out.println(自己的);}
} 面向对象高级三内部类概述、成员内部类、静态内部类 内部类
是类中的五大成分之一成员变量、方法、构造器、内部类、代码块如果一个类定义在另一个类的内部这个类就是内部类场景当一个类的内部包含了一个完整的事物且这个事物没有必要单独设计时就可以把这个事物设计成内部类。 内部类有四种形式
1、成员内部类2、静态内部类3、局部内部类4、匿名内部类重点
成员内部类
就是类中的一个普通成员类似普通的成员变量、成员方法。 package com.liu.d1_inner_class1;public class Outer {private int age 99;public static String o;//成员内部类public class Inner{private String name;
// public static String schoolName; //JDK 才开始支持定义静态成员的private int age 88;public void test(){System.out.println(age);System.out.println(o);int age 66;System.out.println(age); //66System.out.println(this.age);//88System.out.println(Outer.this.age);//99//66//88//99}public String getName() {return name;}public void setName(String name) {this.name name;}}public void test2(){System.out.println(age);System.out.println(o);}
}package com.liu.d1_inner_class1;public class Test {public static void main(String[] args) {//目标了解成员内部类和其特点Outer.Inner in new Outer().new Inner();in.test();}
}注意
JDK16之前成员变量内部类中不能定义静态成员JDK16开始也可以定义静态成员了。
创建对象的格式
成员内部类中访问其他成员的特点
1、和前面学过的实例方法一样成员内部类的实例方法中同样可以直接访问外部的实例成员、静态成员。2、可以在成员内部类的实例方法中拿到当前外部类对象格式是外部类名 . this
什么是静态内部类
有static修饰的内部类属于外部类自己持有 package com.liu.d2_inner_class2;public class Outer {private int age;public static String schoolName;//静态内部类public static class Inner{private String name;public static int a ;public void test(){System.out.println(schoolName);
// System.out.println(age);}public String getName() {return name;}public void setName(String name) {this.name name;}}public static void test2(){System.out.println(schoolName);
// System.out.println(age);}
}package com.liu.d2_inner_class2;public class Test {public static void main(String[] args) {//目标了解静态内部类Outer.Inner in new Outer.Inner();in.test();}
}创建对象的格式
静态内部类中访问外部类成员的特点
可以直接访问外部类的静态成员不可以直接访问外部类的实例成员。 局部内部类
局部内部类是定义在方法中、代码块中、构造器等执行体中 面向对象高级三认识匿名内部类、匿名内部类的使用场景和应用场景 匿名内部类
就是一种特殊的局部内部类所谓匿名指的是程序员不需要为这个类声明名字。 package com.liu.d3_inner_class3;import jdk.nashorn.internal.ir.CatchNode;public class Test {public static void main(String[] args) {//目标认识匿名内部类并掌握其作用
// Animal a new Cat();
// a.cry();//1、把这个匿名内部类编译成子类然后它会立即创建一个子类对象出来Animal a new Animal(){Overridepublic void cry() {System.out.println(喵喵喵的叫);}};a.cry();}
}//class Cat extends Animal{
//
// Override
// public void cry() {
// System.out.println(喵喵喵的叫);
// }
//}abstract class Animal{public abstract void cry();
}特点匿名内部类本质就是一个子类并会立即创建出一个子类对象。作用用于更方便的创建一个子类对象。
匿名内部类在开发中的使用场景
通常作为一个参数传输给方法
需求
猫、狗参加游泳比赛。 package com.liu.d3_inner_class3;public class Test2 {public static void main(String[] args) {//目标掌握匿名内部类的使用场景
// Swimming s1 new Swimming(){
// Override
// public void swim() {
// System.out.println(狗游泳飞快);
// }
// };
// go(s1);go(new Swimming() {Overridepublic void swim() {System.out.println(狗游的飞快);}});}//设计一个方法可以接收swimming接口的一切实现类对象进来参加游泳比赛public static void go(Swimming s){System.out.println(开始——————————————————————————————————);s.swim();}
}//猫和狗都要参加游泳笔试
interface Swimming{void swim();
}拓展匿名内部类在开发中的使用场景
package com.liu.d5_inner_class5;import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;public class Test {public static void main(String[] args) {//拓展匿名内部类在开发中的使用场景//BUI编程//1、创建窗口JFrame win new JFrame(登录界面);JPanel panel new JPanel();win.add(panel);JButton btn new JButton(登录);panel.add(btn);//给按钮绑定单击事件监听器btn.addActionListener(new ActionListener() {Overridepublic void actionPerformed(ActionEvent e) {JOptionPane.showMessageDialog(win,登陆一下);}});//最终的核心目的是简化代码win.setSize(400,400);win.setLocationRelativeTo(null);win.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);win.setVisible(true);}
}面向对象高级三认识枚举枚举的作用和应用场景 枚举
枚举是一种特殊类。
枚举类的格式 注意
枚举类中的第一行只能写一些合法的标识符名称多个名称用逗号隔开这些名称本质是常量每个常量都会记住枚举类的一个对象。
package com.liu.d6_enum;public class Test {public static void main(String[] args) {//目标认识枚举A a1 A.X;System.out.println(a1);}
}package com.liu.d6_enum;public enum A {//注意枚举类的第一行必须罗列的是枚举对象名字X,Y,Z;private String name;public String getName() {return name;}public void setName(String name) {this.name name;}
}枚举类的特点 枚举类的第一行只能罗列一些名称这些名称都是常量并且每个常量记住的都是枚举类的一个对象。枚举类的构造器都是私有的写不写都只能是私有的对象因此枚举类对外不能创建对象。枚举都是最终类不可以被继承。枚举类中从第二行开始可以定义类的其他各自成员。编译器为枚举类新增了几个方法并且枚举类都是继承java . lang . Enum 类的从enum类也会继承到一些方法。 package com.liu.d6_enum;public class Test {public static void main(String[] args) {//目标认识枚举A a1 A.X;System.out.println(a1);//枚举类的构造器是私有的不能对外创建对象
// A a new A();//枚举类的第一行都是常量记住的是枚举类的对象A a2 A.Y;//枚举类提供一个额外的APIA[] as A.values();A a3 A.valueOf(Z);System.out.println(a3.name()); //ZSystem.out.println(a3.ordinal()); //索引System.out.println(----------------------------);B y B.Y;y.go();}
}package com.liu.d6_enum;public enum A {//注意枚举类的第一行必须罗列的是枚举对象名字X,Y,Z;private String name;public String getName() {return name;}public void setName(String name) {this.name name;}
}
package com.liu.d6_enum;//拓展抽象枚举public enum B {X(){Overridepublic void go() {}}, Y(懒羊羊){Overridepublic void go() {System.out.println(getName()在吃东西);}};private String name;B() {}B(String name) {this.name name;}public String getName() {return name;}public void setName(String name) {this.name name;}public abstract void go();
}多学一招
使用枚举类实例单路设计模式
package com.liu.d6_enum;public enum C {X; //单例}枚举的常见应用场景
用来表示一组信息然后作为参数进行传输 package com.liu.d7_enum2;public class Constant {public static final int BOY 0;public static final int GIRL 1;
}package com.liu.d7_enum2;public enum Constant2 {BOY , GIRL;
}package com.liu.d7_enum2;public class Test {public static void main(String[] args) {//目标掌握枚举的应用场景做信息标志和分类
// check(1);
// check(Constant.BOY);
// check(21);check(Constant2.BOY);}public static void check(Constant2 sex ){switch (sex){case BOY:System.out.println(展示一些游戏信息);break;case GIRL:System.out.println(展示一些电视剧);break;}}// public static void check(int sex ){
// switch (sex){
// case Constant.BOY:
// System.out.println(展示一些游戏信息);
// break;
// case Constant.GIRL:
// System.out.println(展示一些电视剧);
// break;
// }
// }
}面向对象高级三认识泛型泛型类和泛型接口 泛型
定义类、接口、方法时同时声明一个或者多个类型变量如E,称为泛型类、泛型接口泛型方法、它们统称为泛型。 作用泛型提供了在编译阶段约束所能操作的数据类型并自动进行检查的能力这样可以避免强制类型转换及其可能出现的故障。泛型的本质把具体的数据类型作为参数传给类型变量
package com.liu.d8_generices;import java.util.ArrayList;public class Test1 {public static void main(String[] args) {//目标认识泛型ArrayList list new ArrayList();list.add(java1);list.add(java2);list.add(java3);
// list.add(new Cat());for (int i 0; i list.size(); i) {String e (String) list.get(i);System.out.println(e);}System.out.println(--------------------------------);// ArrayListString list1 new ArrayListString();ArrayListString list1 new ArrayList(); //JDK1.开始后面的数据类型可以不申请list1.add(Java1);list1.add(Java2);list1.add(Java3);
// list.add(new Cat());for (int i 0; i list1.size(); i) {String e list1.get(i);System.out.println(e);}}
}
class Cat{}泛型类 注意类型变量建议用大写的英文字母常用的有E、T、K、V 等
package com.liu.d9_generics_class;public class Test {public static void main(String[] args) {//目标掌握泛型类的定义和使用MyArrayListString list new MyArrayList();list.add(java1);list.add(java2);String ele list.get(1);System.out.println(ele);MyClass2Cat,String c2 new MyClass2();MyClass3Animal c3 new MyClass3();MyClass3Dog c4 new MyClass3();}
}package com.liu.d9_generics_class;//泛型类
public class MyArrayListE {private Object[] arr new Object[10];private int size;//记录当前位置的public boolean add(E e){arr[size] e;return true;}public E get(int index){return (E) arr[index];}
}package com.liu.d9_generics_class;public class MyClass2E ,T{public void put(E e,T t){}
}package com.liu.d9_generics_class;public class MyClass3E extends Animal {
}package com.liu.d9_generics_class;public class Animal {
}package com.liu.d9_generics_class;public class Cat extends Animal{
}
package com.liu.d9_generics_class;public class Dog extends Animal{
}泛型接口 注意类型变量建议用大写的英文字母常用的有 E 、 T 、 K 、 V 等 package com.liu.d10_generics_interface;public class Test {//目标掌握泛型接口的定义和使用//场景系统需要处理学生和老师的数据需要提供2个功能保存对象数据根据名称查询数据}package com.liu.d10_generics_interface;public class Teacher {
}package com.liu.d10_generics_interface;public class Teacher {
}package com.liu.d10_generics_interface;import java.util.ArrayList;//泛型接口
public interface DataT {void add(T t);ArrayListT getByName(String name);
}package com.liu.d10_generics_interface;import java.util.ArrayList;public class TeacherData implements DataTeacher {Overridepublic void add(Teacher teacher) {}Overridepublic ArrayListTeacher getByName(String name) {return null;}
}package com.liu.d10_generics_interface;import java.util.ArrayList;public class StudentData implements DataStudent{Overridepublic void add(Student student) {}Overridepublic ArrayListStudent getByName(String name) {return null;}
}面向对象高级三泛型方法、泛型的通配符和泛型的上下限、泛型注意事项 泛型方法 package com.liu.d11_generices_method;public class Dog {
}package com.liu.d11_generices_method;public class Car {
}package com.liu.d11_generices_method;public class BENZ extends Car{
}package com.liu.d11_generices_method;public class BMW extends Car{
}package com.liu.d11_generices_method;import java.util.ArrayList;public class Test {public static void main(String[] args) {//目标掌握泛型方法的定义和使用String rs test(Java);System.out.println(rs);Dog d test(new Dog());System.out.println(d);//需求所有的汽车可以一起参加比赛ArrayListCar cars new ArrayList();cars.add(new BMW());cars.add(new BENZ());go(cars);ArrayListBMW bmws new ArrayList();bmws.add(new BMW());bmws.add(new BMW());go(bmws);ArrayListBENZ benzs new ArrayList();benzs.add(new BENZ());benzs.add(new BENZ());go(benzs);// ArrayListDog dogs new ArrayList();
// dogs.add(new Dog());
// dogs.add(new Dog());
// go(dogs);}// ? 通配符在使用泛型的时候可以代表一切类型 ? extends Car(上限) ? super Car下限public static void go(ArrayList? extends Car cars){}// public static T extends Car void go(ArrayListT cars){
//
// }//泛型方法public static T T test(T t){return t;}
}通配符
就是 “?” 可以在“使用泛型”的时候代表一切类型 E T K V 是在定义泛型的时候使用。
泛型的上下限
泛型上限: ? extends Car: ? 能接收的必须是Car或者其子类 。泛型下限 ? super Car ? 能接收的必须是Car或者其父类。
泛型的擦除问题和注意事项
泛型是工作在编译阶段的一旦程序编译成class文件class文件中就不存在泛型了这就是泛型擦除。泛型不支持基本数据类型只能支持对象类型引用数据类型。 package com.liu.d12_generics_attention;import com.liu.d6_enum.A;import java.util.ArrayList;public class Test {public static void main(String[] args) {//目标理解泛型的注意实现//1、泛型是工作在编译阶段的一旦程序编译成class文件class文件中就不存在泛型了这就是泛型擦除。ArrayListString list new ArrayList();list.add(java1);list.add(java2);list.add(java3);String rs list.get(2);System.out.println(rs);//2、泛型不支持基本数据类型只能支持对象类型引用数据类型。
// ArrayListint list1 new ArrayList();
// ArrayListdouble list2 new ArrayList();ArrayListInteger list3 new ArrayList();list3.add(12);ArrayListDouble list4 new ArrayList();list4.add(23.3);}
}
