Java入门到精通(干就完了)|电子爱好者

admin管理员组
文章数量:1579935

文章目录

1、Java语言概述
2、Java开发环境的准备:JDK简介、安装、常用命令
3、Java入门程序
- 3.1、Hello World
- 3.2 常见问题
- 3.3 Java程序的执行原理
- 3.4 JDK组成、跨平台原理
- 3.5 JDK安装后Path和Java_home环境变量
4、IDEA开发工具：简介、下载、安装
- 4.1 简介
- 4.2 下载
- 4.3 IDEA开发工具：开发第一个程序
- 4.4 IDEA字体、主题、背景色设置
- 4.5 常用快捷键介绍
- 4.6 IDEA工程、模块常用操作
5、Java基础语法
- 5.1 注释
- 5.2 字面量
- 5.3 变量
- 5.4 变量在计算机中的底层原理
- 5.5 进制转换，八进制、十六进制
- 5.6 数据类型
- 5.7 关键字、标识符
6、关于Java语言基础知识我们需要学会什么？
7、类型转换
- 7.1 自动类型转换
- 7.2 表达式的自动类型转换
- 7.3 强制类型转换
8、运算符
- 8.1 基本算数运算符
- 8.2 +符号做连接符
- 8.3 自增自减运算符
- 8.4 赋值运算符
- 8.5 关系运算符
- 8.6 逻辑运算符
- 8.7 三元运算符
- 8.8 运算符优先级
9、API介绍、案例技术：键盘录入
10、程序流程控制
- 10.1 分支结构
- - 10.1.1 if分支
  - 10.1.2 switch分支
- 10.2 循环结构
- - 10.2.1 for循环
  - 10.2.2 while循环
  - 10.2.3 do-while循环
  - 10.2.4 死循环
  - 10.2.5 嵌套循环
  - 10.2.6 跳转关键字：break、continue
11、随机数Random
12、数组
- 12.1 概述
- 12.2 定义方式一、访问、注意事项
- 12.3 定义方式二、元素默认值规则
- 12.4 数组遍历
- 12.5 数组案例
- - 12.5.1 元素求和
  - 12.5.2 数组求最值
  - 12.5.3 猜数字游戏
  - 12.5.4 随机排名
  - 12.5.5 数组排序
- 12.6 数组内存图、常见使用问题
- 12.7 Debug工具
13、方法
- 13.1 概述
- 13.2 方法定义格式、常见问题
- 13.3 方法案例
- - 13.3.1 求和
  - 13.3.2 判断奇偶数
  - 13.3.3 求最值
- 13.4 方法的内存原理
- 13.5 方法参数传递机制
- 13.6 方法参数传递的案例
- - 13.6.1 打印数组的内容
  - 13.6.2 从数组中查询元素分索引返回
  - 13.6.3 比较两个数组内容是否相等
- 13.7 方法重载、return关键字
14 编程训练
- 14.1 买飞机票
- 14.2 找素数
- 14.3 验证码
- 14.4 数组的复制
- 14.5 评委打分
- 14.6 数字加密
- 14.7 双色球系统开发
15 面向对象
- 15.1 概述
- 15.2 面向对象、注意事项
- 15.3 内存机制
- 15.4 面向对象实战
- 15.5 构造器、this
- 15.6 封装
- 15.7 标准JavaBean
- 15.8 成员变量、局部变量区别
- 15.9 面向对象综合案例
16 常用API（String、ArrayList）
- 16.1 String
- - 16.1.1 概述
  - 16.1.2 对象创建的原理
  - 16.1.3 String类常见面试题
  - 16.1.4 Stirng类常用API
  - 16.1.5 String案例：验证码、登录、隐私号码
- 16.2 ArrayList
- - 16.2.1 集合概述
  - 16.2.2 ArrayList集合快速入门
  - 16.2.3 ArrayList对于泛型的支持
  - 16.2.4 ArrayList常用API、遍历
  - 16.2.5 ArrayList集合案例
17 ATM系统
18、static静态关键字
- 18.1 static是什么、修饰成员变量的用法
- 18.2 static修饰成员变量的内存原理
- 18.3 static修饰成员方法的基本用法
- 18.4 static修饰成员方法的内存原理
- 18.5 static注意事项
- 18.6 工具类
- 18.7 代码块
- 18.9 单例模式
19 继承
- 19.1 概述、案例
- 19.2 特点、访问特点、方法重写
- 19.3 构造器特点、this、super小结
20、语法
- 20.1 包
- 20.2 权限修饰符
- 20.3 final的语法
- 20.4 常量、常量在开发中的作用
- 20.5 枚举、枚举作用
21、抽象类
- 21.1 概述
- 21.2 案例
- 21.3 特点
- 21.4 模板方法模式
22、接口
- 22.1 概述
- 22.2 多实现
- 22.3 多继承
- 22.4 JKD8后接口新增方法
- 22.5 注意事项
23、多态
- 23.1 概述
- 23.2 优势
- 23.3 类型转换问题
- 23.4 综合案例
24、内部类
- 24.1 静态内部类
- 24.2 成员内部类
- 24.3 局部内部类
- 24.4 匿名内部类
25、常用API
- 25.1 Object
- 25.2 Objects
- 25.3 StringBuilder
- 25.4 Math
- 25.5 System
- 25.6 BigDecimal
26、日期与时间
- 26.1 Date
- 26.2 SimpleDateFormat
- 26.3 Calendar
27、JDK8开始新增日期API
- 27.1 LocalTime、LocalDate、LocalDateTime
- 27.2 Instant
- 27.3 DateTimeFormatter
- 27.4 Duration、Period
- 27.5 ChronoUnit
28、包装类
29、正则表达式
- 29.1 概述、初体验
- 29.2 匹配规则
- 29.3 常见案例
- 29.4 在方法中的应用
- 29.5 爬取信息
30、Arrays类
31、常见算法
- 31.1 选择排序
- 31.2 二分查找
32、Lambda表达式
- 32.1 概述
- 32.2 实战-简化常见函数式接口
- 32.3 表达式的省略规则
33、集合
- 33.1 概述
- 33.2 collection集合的体系特点
- 33.3 Collection集合常用API
- 33.4 collection集合的遍历方式
- 33.5 Collection集合存储自定义类型的对象
- 33.6 常见数据结构
- - 33.6.1 概述、栈、队列
  - 33.6.2 数组
  - 33.6.3 链表
  - 33.6.4 二叉树、二叉查找树
  - 33.6.5 平衡二叉树
  - 33.6.6 红黑树
- 33.7 List系列集合
- - 33.7.1 List集合特点、特有API
  - 33.8.2 List集合的遍历方式小结
  - 33.8.3 ArrayList集合的底层原理
  - 33.8.4 LinkedList集合的底层原理
- 33.8 补充知识:集合的并发修改异常问题
- 33.9 补充知识:泛型深入
- - 33.9.1 泛型的概述和优势
  - 33.9.2 自定义泛型类
  - 33.9.3 自定义泛型方法
  - 33.9.4 自定义泛型接口
  - 33.9.5 泛型通配符、上下限
- 33.10 Set系列集合
- - 33.10.1 Set系列集系概述
  - 33.10.2 HashSet元素无序的底层原理:哈希表
  - 33.10.3HashSet元素去重复的底层原理
  - 33.10.4 实现类: LinkedHashset
  - 33.10.5 实现类:TreeSet
- 33.11 Collection体系的特点、使用场景总结补充知识:可变参数
- 33.12 补充知识:集合工具类Collections
- 33.13 Collection体系的综合案例
- 33.14 Map集合体系
- - 33.14.1 Map集合的概述
  - 33.14.2 Map集合体系特点
  - 33.14.3 Map集合常用API
  - 33.14.4 Map集合的遍历方式一:键找值
  - 33.14.5 Map集合的遍历方式二:键值对
  - 33.14.6 Map集合的遍历方式三: lambda表达式
  - 33.14.7 Map集合的实现类HashMap
  - 33.14.8 Map集合的实现类LinkedHashMap
  - 33.14.9 Map集合的实现类TreeMap
- 33.15 补充知识:集合的嵌套
34、创建不可变集合
35、Stream流
- 35.1 Stream流的概述
- 35.2 Stream流的获取
- 35.3 stream流的常用方法API
- 35.4 Stream流的综合应用
- 35.5 收集Stream流
36、异常处理
- 36.1 异常概述、体系
- 36.1 常见运行时异常
- 36.1 常见编译时异常
- 36.1 异常的默认处理流程
- 36.1 编译时异常的处理机制
- 36.1 运行时异常的处理机制
- 36.1 异常处理使代码更稳健的案例
- 36.1 自定义异常
37、日志框架
- 37.1 日志技术的概述
- 37.2 日志技术体系结构
- 37.3 Logback概述
- 37.4 Logback快速入门
- 37.5 Logback配置详解-输出位置、格式设置
- 37.6 Logback配置详解-日志级别设置
38、阶段项目实战
- 38.1 电影购票系统简介、项目功能演示
- 38.2 日志框架搭建、系统角色分析
- 38.3 首页设计、登录、商家界面、用户界面实现
- 38.4 商家-详情页设计、影片上架、退出
- 38.5 商家-影片下架、影片修改
- 38.6 用户-展示全部影片
- 38.7 用户-购票功能
- 38.8 用户-评分功能
39、File类
- 39.1 创建File对象
- 39.2 常用方法:判断文件类型、获取文件信息
- 39.3 常用方法:创建文件、删除文件功能
- 39.4 常用方法:遍历文件夹
40、补充知识:方法递归、字符集
- 40.1 方法递归的形式
- 40.2 方法递归的应用、执行流程、递归算法的三个核心要素
- 40.3 方法递归的经典案例
- 40.4 其他形式的方法递归案例
- 40.5 常见字符集介绍
- 40.6 字符集的编码、解码操作
41、IO流
- 41.1 概述
- 41.2 字节流
- 41.3 资源释放的方式

1、Java语言概述

Java知识背景

为什么用Java
1、世界上最流行的编程语言之一，在国内使用最为广泛的编程语言。
2、可移植性、安全可靠、性能较好。
3、开发社区最完善，功能最丰富。
Java能做什么

Java技术体系

技术体系	说明
Java SE(Java Standard Edition):标准版	Java技术的核心和基础
Java EE(Java Enterprise Edition):企业版	企业级应用开发的一套解决方案
Java ME(Java Micro Edition):小型版	针对移动设备应用的解决方案

总结
1、Java是是一门高级编程语言
2、Java是sun公司研发的，现在属于Oracle公司
3、Java之父是詹姆斯·高斯林
4、Java基本上什么都可以干，主要做互联网系统的开发
5、Java技术平台：JavaSE(标准版)、JavaEE(企业版)、JavaME(小型版)

2、Java开发环境的准备:JDK简介、安装、常用命令

JDK下载
Oracle官网：http://www.oracle/java/technologies/downloads/
如何验证JDK安装成功
java.exe与javac.exe能正常运行即可
Javac和Java介绍

将来我们写好的Java程序都是高级语言，计算机底层是硬件不能识别这些语言。
必须通过Javac编译工具进行翻译，然后再通过Java执行工具执行才可以驱动机器干活。
命令行窗口的常用命令

常用命令	作用
盘符：	切换到某个盘下：D：，C：
dir	查看当前路径下的文件信息
cd	进入单级目录：cd itheima 进入多级目录：cd D:\itheima\JavaSE\第一天回退到上一级目录：cd .. 回退到盘符根目录：cd \ （注意：按Table可以补全目录）
cls	清屏

3、Java入门程序

3.1、Hello World

3.2 常见问题

1、windows的文件扩展名没有勾选

2、代码写了，但是忘记保存了

3、文件名和类名不一致。

4、大小写错误，单词拼写错误，存在中文符号，找不到Main方法。

5、括号不配对.

6、编译或执行工具使用不当.

7、…

3.3 Java程序的执行原理

不管是什么样的高级编程语言，最终都是翻译成计算机底层可以识别的机器语言(0和1)

3.4 JDK组成、跨平台原理

3.5 JDK安装后Path和Java_home环境变量

开始配置

4、IDEA开发工具：简介、下载、安装

4.1 简介

4.2 下载

下载UItimate旗舰版: https://www.jetbrains/idea/
安装:傻瓜式安装，建议修改安装路径（不要安装在有空格和中文的路径下)。

4.3 IDEA开发工具：开发第一个程序

① 创建project空工程

② 创建module模块

找到你下载JDK的路径位置，添加JDK

③创建package包

④创建class类

⑤在类中编写代码

⑥完成编译运行

4.4 IDEA字体、主题、背景色设置

4.5 常用快捷键介绍

Ctrl + Alt + T 分支、循环快捷键

4.6 IDEA工程、模块常用操作

1、删除类文件

2、修改类名称

3、修改模块

4、导入模块

关联导入：原路径模块删除，此模块也会删除

建议新建一个模块，名称就是导入模块的名称，将代码拷贝进去，避免原路径删除导致模块丢失

5、删除模块

方法1：Remove Module，此方法只是在IDEA界面中删除，源文件并没有删除

方法2：到整个项目路径下找到要删除的文件，直接删除

方法3：在IDEA中点击模块，顶部显示模块名称后右键，delete。

当然方法3也有bug，不能删除干净，源文件还会复原，但是IDEA界面上不显示出来，如下操作做完再重启IDEA，即可删除

建议使用方法1 + 方法2，出问题重启IDEA

6、打开工程

7、关闭工程

或者直接X掉，关闭IDEA

5、Java基础语法

5.1 注释

什么是注释

注释是写在程序中对代码进行解释说明的文字，方便自己和其他人查看，以便理解程序的。

注释有哪些

注释的特点

注释不影响程序的执行

多学一招

5.2 字面量

计算机是用来处理数据的，字面量就是告诉程序员∶数据在程序中的书写格式。

常用数据

5.3 变量

什么是变量

变量就是用来存储一一个数据的内存区域(可以理解成盒子)，且里面存储的数据可以变化。
1、必须以字母、下划线、或者美元符$开头；

以美元符$ 开头命名的变量虽然能够编译通过但是不建议使用；

中文也可以作为命名开头且编译也能通过，但是不建议使用。

2、除开头外后面的部分可以有字母、下划线、美元符$以及数字组成；

3、虽然变量名不限制长度，但能表达清楚命名的含义即可；

4、变量名不可以和java的关键字冲突；

5、再命名中大小写是又区别的，即使由同一个单词命名但是有个别字母的大小写的区别，产生的就是两个不同的变量。

变量使用注意事项

5.4 变量在计算机中的底层原理

5.5 进制转换，八进制、十六进制

5.6 数据类型

5.7 关键字、标识符

6、关于Java语言基础知识我们需要学会什么？

7、类型转换

7.1 自动类型转换

7.2 表达式的自动类型转换

面试题

咋一看 i 和 j 都是byte变量，但是两者相加的值需要 int 类型承接。
因为 i 和 j 在运算时默认是 int 类型进行运算。同时，如果i=120，j=100，两者都不超过byte类型范围，但是相加得到的值就不一定了。
索性当成int类型计算能保证能赋值。

7.3 强制类型转换

8、运算符

8.1 基本算数运算符

数值拆分案例

8.2 +符号做连接符

8.3 自增自减运算符

面试案例

8.4 赋值运算符

8.5 关系运算符

8.6 逻辑运算符

8.7 三元运算符

8.8 运算符优先级

9、API介绍、案例技术：键盘录入

10、程序流程控制

10.1 分支结构

10.1.1 if分支

根据判定的结果( 真或假)决定执行某个分支的代码，适合做区间匹配

10.1.2 switch分支

switch使用的注意事项

不支持浮点数原因是https://www.jb51/article/231618.htm

10.2 循环结构

10.2.1 for循环

10.2.2 while循环

10.2.3 do-while循环

10.2.4 死循环

10.2.5 嵌套循环

10.2.6 跳转关键字：break、continue

11、随机数Random

当然也可以指定随机区间 Random rm = new Random(); rm.nextInt(10,30);

12、数组

12.1 概述

12.2 定义方式一、访问、注意事项

12.3 定义方式二、元素默认值规则

12.4 数组遍历

快捷写法数组变量.for初始化变量，例如：ages.fori，就会弹出提示

12.5 数组案例

12.5.1 元素求和

12.5.2 数组求最值

12.5.3 猜数字游戏

12.5.4 随机排名

12.5.5 数组排序

12.6 数组内存图、常见使用问题

12.7 Debug工具

13、方法

13.1 概述

13.2 方法定义格式、常见问题

用static修饰符，表示是该类的方法，不是实例的方法，可以在static修饰的方法中调用static修饰的方法。
不用static修饰符，则需要new类的实例，来调用方法

13.3 方法案例

13.3.1 求和

13.3.2 判断奇偶数

13.3.3 求最值

13.4 方法的内存原理

详细动画看这里https://editor.csdn/md/?articleId=127215629

13.5 方法参数传递机制

13.6 方法参数传递的案例

13.6.1 打印数组的内容

13.6.2 从数组中查询元素分索引返回

13.6.3 比较两个数组内容是否相等

13.7 方法重载、return关键字

14 编程训练

14.1 买飞机票

package com.itheima.demo;
import java.util.Scanner;

public class Test1 {
   
	public static void main(String[] args) {
   
		//目标:完成买飞机票的价格计算。
		// 1、让用户输入机票原价，月份，仓位类型
		Scanner sc = new Scanner(System.in);
		
		System. out. println("请您输入机票原价: ");
		double money = sc. nextDouble() ;
		
		System. out. println("请您输入机票的月份(1-12) : ");
		int month = sc. nextInt();
		
		System. out. printLn("请您选择仓位类型: ");
		String type = sc.next();
		// 4.调用方法，统计结果.
		System . out . printLn("机票优惠后的价格是: + calc(money, month, type));

	}
	public static doubLe calc(doubLe money, int month， String type] {
   
		// 3.判断用户选择的信息情况
		if (month >= 5 && money <= 10) {
   
			//旺季
			switch (type) {
   
				case "头等舱":
					money *= 0.9; // money = money★0.9;
					break;
				case "经济舱":
					money *= 0.85; // money = money * 0.85;
					break;
				default:
					System.out.printLn("您输入的仓位类型有误~~");
					money = -1; //表示当前无法计算价格!
		}else if(month == 11 II month == 12 II month >= 1 & month <= 4){
    
			//淡季
			switch (type) {
   
				case "头等舱":
					money *= 0.7; // money = money★0.9;
					break;
				case "经济舱":
					money *= 0.65; // money = money * 0.85;
					break;
				default:
					System.out.printLn("您输入的仓位类型有误~~");
					money = -1; //表示当前无法计算价格!
		}else {
   
			System.out.println("对不起，您输入的月份有问题~~");
			money = -1; //表示当前无法计算价格!
		}
	}
	return money; //最终价格
}

14.2 找素数

14.3 验证码

14.4 数组的复制

14.5 评委打分

14.6 数字加密

14.7 双色球系统开发

15 面向对象

15.1 概述

15.2 面向对象、注意事项

15.3 内存机制

垃圾回收

注意:当堆内存中的对象，没有被任何变量引用(指向)时，就会被判定为内存中的“垃圾”。

Java存在自动垃圾回收器，会定期进行清理。

15.4 面向对象实战

Goods类

package com.itheima.demo;

public class Goods {
   
	int id; //编号
	String name; //名称
	double price; //价格
	int buyNumber; // 购买数量
}

测试模块

package com.itheima.demo;

import java.util.Scanner;

/**
目标:面向对象编程训练:购物车模块模拟。
*/

public class ShopCarTest {
   
	public static void main(String[] args) {
   
		// 1.定义商品类，用于后期创建商品对象
		// 2.定义购物车对象:使用一 个数组对象表示。
		Goods[] shopCar = new Goods[100]; // [null, null， ...]
		// 3.搭建操作架构
		while(true){
   
			System. out . println("请您选择如下命令进行操作: "); .
			System. out. printLn("添加商品到购物车: add");
			System. out. println("查询购物车商品展示: query");
			System. out. printLn("修改商品购买数量: update");
			System. out . println("结算购买商品的金额: pay");
			Scanner sc = new Scanner(System.in);
			System. out . printLn("请您输入命令: ");
			String command = sc.next();
			switch (command){
   
				case "add" :
					//添加商品到购物车
					addGoods(shopCar,sc);
					break;
				case "query":
					//查询购物车商品展示
					queryGoods(shopCar);
					break;
				case "update":
					//修改商品购买数量
					updateGoods (shopCar,sc);
					break;
				case "pay":
					//结算购买商品的金额
					pay(shopCar);
					break;
				default :
					System. out. print1n("没有该功能! ");
			}
		}
	}
	
	/**
	查询购物车中的商品对象信息，并展示出来
	*/
	public static void queryGoods (Goods[] shopCar) {
   
		System. out. printLn("===========查询购物车信息如下============");
		System. out. println("编号\t\t名称\t\t\t价格\t\t\t购买数量");
		// shopCar = [g1， g2, g3, null, null， ...]
		for (int i =日; i < shopCar.length; i++) {
   
			Goods g = shopCar[i];
			if(g != null){
   
				//展示这个商品对象
				System. out. println(g.id +"\t\t" + g.name+"\t\t\t" + g.price +"\t\t\t" + g.buyNumber);
			}else {
   
				//遍历结束
				break;
			}
		}
	}

	public static void updateGoods (Goods[] shopCar ，Scanner sc) {
   
		//让用户输入要修改商品的id,根据id查询出要修改的商品对象。
		while (true) {
   
			System. out . printLn("请您输入要修改的商品id:");
			int id = sc.nextInt();
			Goods g = getGoodsById(shopCar， id);
			if(g == null){
   
				//没有该商品.
				System . out . printIn("对不起，没有购买商品! ");
			}else {
   
				//说明存在该商品对象，可以修改它了
				System. out. println("请您输入:”+ g.name +" 商品最新购买数量: ");
				int buyNumber = sc.nextInt();
				g. buyNumber = buyNumber;
				System. out. println("修改完成! ");
				queryGoods(shopCar);
				break;
			}
		}
	}

	public static Goods getGoodsById(Goods[] shopCar ，int id){
   
		// shopCar = [g1, g2, g3，null， null， ...] .
		for (int i = 0; i < shopCar .length; i++) {
   
			Goods g = shopCar[i];
			if(g != null){
   
				//判断这个商品对象的id是否是我们要找的
				if(g.id == id){
   
					return g;
				}
			}else {
   
				return null; //找完了全面存在的商品，都没有找到!
			}
		}
		return null; //代表找完了100个商品都没有找到id - -样的商品
	}

	public static void pay(Goods[] shopCar) {
   
		query6oods(shopCar);
		//1.定义一个求和变量累加金额
		double money =日;
		// 2、遍历购物车数组中的全部商品对象，累加单价*数量
		// [g1, g2, null， ...1
		for (int i = 0; i < shopCar.length; i++) {
   
			Goods g = shopCar[i];
			if(g != null){
   
				money += (g.price * g. buyNumber);
			}else {
   
				break;
			}
		}
		System . out . println("订单总金额:"+ money);
	}

	/**
	完成商品添加到购物车的功能
	*/
	public static void addGoods(Goods[] shopCar ，Scanner sc) {
   
		// 1.录入用户输入的购买商品的信息。
		System. out.println("请您输入购买商品的编号(不重复) : ");
		int id = sc.nextInt();
		System. out.println("请您输入购买商品的名称: ");
		String name = sc.next();
		System. out . println("请您输入购买商品的数量: ");
		int buyNumber = sc.nextInt();
		System. out. println("请您输入购买商品的价格: ");
		doubLe price = sc.nextDouble();
		// 2、把这个购买商品的信息封装成一 个商品对象
		Goods g = new Goods();
		gl.id = id;
		g.name = name;
		g. buyNumber = buyNumber;
		g.price = price;
		
		// 3、把这个商品对象添加到购物车数组中去。
		// shopCar = [a， a2, null， ........]
		//						i
		for (int i = 0; i < shopCar.length; i++) {
   
			if(shopCar[i] == null){
   
				//说明此位置没有元素存入，把我们新买的商品添加到此处即可
				shopCar[i] I g;
				break; //结束，因为商品已经成功存入了，不需要继续找位置了
			}
		}
		System. out. println("您的商品:”+ g.name +" 添加到购物车完成! ");
	}
}

15.5 构造器、this

this调用本类中的其他方法：指在普通成员方法中使用this调用另一个成员方法
this调用本类中的其他构造方法，调用时要放在构造方法的首行。

15.6 封装

15.7 标准JavaBean

15.8 成员变量、局部变量区别

15.9 面向对象综合案例

16 常用API（String、ArrayList）

16.1 String

16.1.1 概述

16.1.2 对象创建的原理

16.1.3 String类常见面试题

16.1.4 Stirng类常用API

String的equals比较，如果a.equals(b)的a是null会报空指针异常

public boolean contains(CharSequence s)：判断传入字符串是否包含其中。
public boolean startsWith(String prefix)：判断是否由传入字符串开头
public String[] split(String s):按照某个内容把字符串分割成字符串数组返回。

16.1.5 String案例：验证码、登录、隐私号码

public class StringExec6 {
   
	public static void main(String[] args) {
   
		// 1、定义可能出现的字符信息
		String datas = "abcdefghijkLmnopqrstuwxyZABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
		// 2、循环5次，每次生成- - 个随机的索引，提取对应的字符连接起来即可
		String code =“";
		Random r = new Random();
		for(inti=日;i<5;i++){
   
			//随机一个索引
			int index = r.nextInt (datas . Length());
			char C = datas. charAt(index);
			code += c;
		}
		// 3.输出宇符串变量即可
		System. out. println(code);
}

	// 1、定义正确的登录名称和密码
	String okLoginName =” admin";
	String okPassword = " itheima";
	// 2、定义一个循环，循环3次，让用户登录
	Scanner sc = new Scanner(System.in);
		for(inti=1;i<=3;i++){
   
			System. out. println("请您输入登录名称: ");
			String loginName = sc.next();
			System. out. println("请您输入登录密码: ");
			String password = sc.next();
			// 3、判断登录是否成功! 
			if (okLoginName . equals (loginName)){
   
				// 4、判断密码是否正确
				if(okPassword . equals(password)){
   
					System . out. printLn("登录成功!欢迎进入系统随意浏览~~~~");
					break;
				}else {
   
					//密码错误了
					System. out . println("您的密码不正确!您还剩余"+ (3 - i) +"次机会登录机会!");
				}
			}else {
   
				System. out. println("您的登录名称不正确!您还剩余"+ (3 - i) +"次机会登录机会!");
			}
	}

public class StringExec8 {
   

	public static void main(String[] args) {
   
		// 1、键盘录入一个手机号码
		Scanner sc = new Scanner(System. in);
		System. out. println("请您输入您的手机号码: ");
		String tel = sc.next();
		// 2、截取号码的前三位， 后四位 18665666520
		String before = tel. substring(0, 3); //日1 2
		String after = tel. substring(7); // 从索引7开始截取到手机号码的末尾
		String s = before + "****" + after;
		System. out . printLn(s);
	}
}

16.2 ArrayList

16.2.1 集合概述

数组变量输出是地址
集合变量输出是数据

16.2.2 ArrayList集合快速入门

16.2.3 ArrayList对于泛型的支持

16.2.4 ArrayList常用API、遍历

// 3、完成集合的遍历
for (int i =0; i < list.size(); i++) {
   
	System. out. println(list.get(i));
}

16.2.5 ArrayList集合案例

public class ArrayListTest4 {
   
	public static void main(String[] args) {
   
		//目标:学习遍历并删除元素的正确方案。
		// 1、创建一个ArrayList集合存储- -个班级学生的成绩
		ArrayList<Integer> scores = new ArrayList<>();
		scores . add(98);
		scores . add(77);
		scores. add(66);
		scores . add(89);
		scores . add(79);
		scores . add(50);
		scores . add(100);
		System . out . printLn(scores);
		
		// 2、把低于80分的成绩从集合中去掉。
		// scores = [98, 77, 66, 89，79， 50， 100]]
		// scores = [98, 66， 89， 50，100]
		// 									i
		// 有毛病的代码!
		// for (int i =日; i < scores.size(); i++) {
   
		// 	   int score = scores.get(i);
		//	   if(score < 80){
   
		//		      这个分数必须删除
		//			  scores. remove(i);
		//		}
		//	}
		//	System. out. printIn(scores);
		
		// 完关的方案之一
		for (int i = 0; i < scores.size(); i++) {
   
			int score = scores. get(i);
			if(score < 80){
   
				//这个分数必须删除
				scores. remove(i);
				i--; //删除成功后，必须退一步，这样可以保证下次回到这个位置，如此则不会跳过数据

			}
		}
		System . out . println(scores);

		// 完美的方案之二
		// 从后面倒着遍历再删除就可以。
		for (int i = scores.size() - 1; i >= 0;i--) {
   
			int score = scores.get(i);
			if(score < 80){
   
				scores. remove(i);
			}
		}
		System . out . println(scores); .

	}
}

17 ATM系统

ATMSystme

package com.itheima;
 
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
 
/**
    ATM系统的入口类。
 */
public class ATMSystem {
   
    public static void main(String[] args) {
   
        // 1、定义账户类
        // 2、定义一个集合容器，负责以后存储全部的账户对象，进行相关的业务操作。
        ArrayList<Account> accounts = new ArrayList<>();
        Scanner sc = new Scanner(System.in);
        // 3、展示系统的首页
        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(accounts, sc);
                    break;
                case 2:
                    // 用户账户开户(ALT + ENTER)
                    register(accounts,sc);
                    break;
                default:
                    System.out.println("您输入的操作命令不存在~~");
            }
        }
    }
 
    /**
     * 登录功能
     * @param accounts 全部账户对象的集合
     * @param sc 扫描器
     */
    private static void login(ArrayList<Account> accounts, Scanner sc) {
   
        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, accounts);
            if(acc != null){
   
                while (true) {
   
                    // 卡号存在的
                    // 4、让用户输入密码，认证密码
                    System.out.println("请您输入登录密码：");
                    String passWord = sc.next();
                    // 判断当前账户对象的密码是否与用户输入的密码一致
                    if(acc.getPassWord().equals(passWord)) {
   
                        // 登录成功了
                        System.out.println("恭喜您，" + acc.getUserName() +"先生/女生进入系统，您的卡号是：" + acc.getCardId());
                        // .... 查询 转账 取款 ....
                        // 展示登录后的操作页。
                        showUserCommand(sc, acc, accounts);
                        return; // 干掉登录方法
                    }else {
   
                        System.out.println("对不起，您输入的密码有误~~");
                    }
                }
            }else {
   
                System.out.println("对不起，系统中不存在该账户卡号~~");
            }
        }
 
    }
 
    /**
      展示登录后的操作页
     */
    private static void showUserCommand(Scanner sc, Account acc, ArrayList<Account> accounts) {
   
        while (true) {
   
            System.out.println("===============用户操作页===================");
            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:
                    // 查询账户(展示当前登录的账户信息)
                    showAccount(acc);
                    break;
                case 2:
                    // 存款
                    depositMoney(acc, sc);
                    break;
                case 3:
                    // 取款
                    drawMoney(acc, sc);
                    break;
                case 4:
                    // 转账
                    transferMoney(sc, acc, accounts);
                    break;
                case 5:
                    // 修改密码
                    updatePassWord(sc, acc);
                    return; // 让当前方法停止执行，跳出去
                case 6:
                    // 退出
                    System.out.println("退出成功，欢迎下次光临");
                    return; // 让当前方法停止执行，跳出去
                case 7:
                    // 注销账户
                    if(deleteAccount(acc,sc,accounts)){
   
                        // 销户成功了，回到首页
                        return; // 让当前方法停止执行，跳出去
                    }else {
   
                        // 没有销户成功， 还是在操作页玩
                        break;
                    }
                default:
                    System.out.println("您输入的操作命令不正确~~");
            }
        }
    }
 
    /**
     * 销户功能
     * @param acc
     * @param sc
     * @param accounts
     */
    private static boolean deleteAccount(Account acc, Scanner sc, ArrayList<Account> accounts) {
   
        System.out.println("===================用户销户========================");
        System.out.println("您真的要销户？y/n");
        String rs = sc.next();
        switch (rs) {
   
            case "y":
                // 真正的销户
                // 从当前账户集合中，删除当前账户对象，销毁就完成了。
                if(acc.getMoney() > 0){
   
                    System.out.println("您账户中还有钱没有取完，不允许销户~");
                }else {
   
                    accounts.remove(acc);
                    System.out.println("您的账户销户完成~~");
                    return true; // 销户成功
                }
                break;
            default:
                System.out.println("好的，当前账户继续保留~");
        }
        return false;
    }
 
    /**
     * 修改密码
     * @param sc 扫描器
     * @param acc 当前登录成功的账户对象。
     */
    private static void updatePassWord(Scanner sc, Account acc) {
   
        System.out.println("===================用户密码修改========================");
        while (true) {
   
            System.out.println("请您输入当前密码：");
            String passWord = sc.next();
            // 1、判断这个密码是否正确
            if(acc.getPassWord().equals(passWord)){
   
                while (true) {
   
                    // 密码正确
                    // 2、输入新密码。
                    System.out.println("请您输入新密码：");
                    String newPassWord = sc.next();
 
                    System.out.println("请您确认新密码：");
                    String okPassWord = sc.next();
 
                    if(newPassWord.equals(okPassWord)) {
   
                        // 2次密码一致，可以修改了
                        acc.setPassWord(newPassWord);
                        System.out.println("恭喜您，您密码修改成功了~~");
                        return;
                    }else {
   
                        System.out.println("您输入的2次密码不一致~~");
                    }
                }
            }else {
   
                System.out.println("您输入的密码不正确~");
            }
        }
    }
 
    /**
     * 转账功能
     * @param sc 扫描器
     * @param acc  自己的账户对象
     * @param accounts 全部账户的集合。
     */
    private static void transferMoney(Scanner sc, Account acc, ArrayList<Account> accounts) {
   
        System.out.println("===================用户转账操作===&

本文标签：入门 Java

版权声明：本文标题：Java入门到精通(干就完了) 内容由热心网友自发贡献，该文观点仅代表作者本人，转载请联系作者并注明出处：https://www.elefans.com/xitong/1727863794a1134240.html，本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。

电子爱好者 - 最新技术资讯及电子产品介绍！

Java入门到精通(干就完了)