Java基础阶段 - 知识总结及重点案例
day01 Java环境搭建及入门
(一).Java语言发展史(了解)
- 简介
Java是1995年由SUN公司推出的计算机语言
公认的Java之父是詹姆斯高士林
ork橡树 -> 被注册了 -> Java是[爪哇]音译 -> 爪哇岛是印度尼西亚的一座岛 -> 盛产咖啡豆
(二).跨平台原理(了解)
常见的平台有Windows Mac Linux
不同平台的厂商提供对应的JVM(翻译官),去翻译相同的一份java文件
(三).JDK和JRE及程序开发的三个步骤(掌握)
JDK:java开发工具包
JRE:java运行环境
JVM:java虚拟机
JDK包含JRE包含JVM -> 在JDK8以后我们只需要安装JDK就拥有了其他两个
1.编码:编写正确的代码
2.编译:使用javac对java文件进行翻译,如果翻译成功,会生成对应的.class文件
3.运行:使用java直接运行即可(java后面跟类名,不带后缀)
(四).常用DOS命令(以 D:\Tencent\WeChat\Documents 为例)
- 切换磁盘 d: 盘符名+ :号
D: - 进入该磁盘的单级目录 cd + 目录
如:D:\Tencent - 进入该磁盘的多级目录
cd 目录\下一级目录\下下一级目录
如:cd Tencent\WeChat\Documents
D:\Tencent\WeChat\Documents - 回退到上一级目录 cd +… (两个点)
输入与cd… （ 由 D:\Tencent\WeChat\Documents> 变为 D:\Tencent\WeChat>） - 回退到根目录 cd \ （此时变为 D:>）
- 查看当前目录下的所有内容
(1).dir 如下所示
驱动器 D 中的卷是 软件
卷的序列号是 0D14-188F
D:\Tencent\WeChat\Documents 的目录
2022/01/01 16:03 <DIR> .
2022/01/01 16:03 <DIR> ..
2022/01/02 13:31 <DIR> WeChat Files
0 个文件 0 字节
3 个目录 58,342,916,096 可用字节
(2).dir /B 只显示文件名 输入命令后如下图所展示：
D:\>dir /B
Bandizip
HMdevelop
Tencent
(3).dir /p 分页显示
(4).dir /B >1.txt 将显示出来的文件名输出到 1.txt 文件中
- 建立文件夹
（1）建立单级目录 ：md a
（2）建立多级目录：md a\ab\abc\abcd - 删除目录 rd 目录名
如:rd a - 清空该屏幕所有内容
cls 命令
(五).JDK下载安装及其配置(掌握)
- 下载地址
https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html - 安装jdk，修改路径为你的软件安装目录，保留后两个文件夹名
- 环境变量配置(掌握)
我的电脑属性 - 高级系统设置 - 环境变量
(1).新建变量名JAVA_HOME,值是当前计算机JDK的安装路径,在Path中新建%JAVA_HOME%\bin(常用)
(2).在Path中直接新建JDK中bin目录的绝对路径即可
(3).配置完测试，在DOS直接输入java或者javac，弹出一堆命令符提示为成功
(4).其他常用命令
查看当前使用的jdk版本 java -version
查看本机中java.exe的所有位置 where java
(六).入门案例(helloword编写)
入门案例HelloWorld 详解(掌握)
入门案例HelloWorld 常见问题(掌握)
public class HelloWorld{
public static void main(String[] args){
System.out.println();
}
}
(七).高级记事本安装及使用(掌握)
初始配置 - 设置 - 首选项 - 左边选择新建 - 默认语言Java - 编码ANSI
(八).注释:对代码进行解释说明的文字信息,注释不参与编译(了解)
单行 //内容
多行 /* 内容 */
文档 /** 内容 */
(九).关键字:被java赋予了特殊含义的英文单词(了解)
特点是小写/高亮
(十)常量:程序运行过程中,其值不会发生改变的量(了解)
1.整数
2.小数
3.字符:单引号引起来的单个内容
4.字符串:双引号引起来的任意内容
5.布尔:值有true和false
6.空:null不能直接打印
(十一).基本数据类型(掌握)
Java中数据分为两大类
1.基本数据类型(四类八种)
整型 byte short int(默认) long
浮点型 float double(默认)
字符 char
布尔 boolean
2.引用数据类型(今天用到的String字符串)
(十二).变量、变量的定义使用及注意(掌握)
数据类型 变量名 = 变量值; //变量值一定要和数据类型匹配
int age = 18;
sout(age); //使用变量使用的是变量名!
String name = "张三";
sout(name); //使用变量使用的是变量名!
(十三).键盘录入(掌握) 固定步骤先记住
1.导包 import java.util.Scanner;
2.创建对象 Scanner sc = new Scanner(System.in);
控制台提示 输出语句("提示内容");
3.调用方法,接收数据 int a = sc.nextInt(); //该方法只能接收整数
//扩展
double d = sc.nextDouble(); //接收小数
String s = sc.next(); //nextLine()也可以接收String
除了没有接收char的,其他都有
(十四).标识符:给变量,类,方法等起名字的符号(暂时不做要求,基础班毕业肯定会起名字!)
1.由数字/字母/_/$组成
2.不能以数字开头
3.不能是java的关键字
4.区分大小写(小驼峰,大驼峰)
day02 运算符
（一）.类型转换(了解)
隐式转换(自动转换) -> 从小到大 -> 计算机自己完成的
强制转换 -> 从大到小 -> 需要手动给格式 ->由于强转可能会造成数据精度的丢失所以不推荐使用
算数运算符(能认识能用)
+ - * / %
除:两个整数相除,只取商
取余:两个整数取余,只取余数
字符+操作(能认识能用)
Ascll表中提供了字符 -> 数值的对应关系(使用的是表中对应的10进制的值)
两个字符相加,本质是阿斯克码表中,对应的10进制的值,在相加(结果是int)
字符串+操作(能认识能用)
当+号遇到字符串,它就是字符串连接符!
连接符可以将任意类型和字符串拼接(串联)
案例_数值拆分 -> 固定写法(掌握)
int ge = a % 10;
int shi = a / 10 % 10;
int bai = a / 100;
自增自减运算符(能认识能用)
++ –
情况1:变量独自使用,在前在后都一样(常用) -> 计数器count++; for循环的控制语句i++
情况2:变量参与操作
在前,先将变量+1或者-1,然后再将变量参与操作
在后,先拿变量参与操作,然后让变量自己+1或者-1
赋值运算符(能认识能用)
基本的:=
扩展的:+=(累加的意思,比较常用) -= *= /= %=
关系运算符(能认识能用)
== != > >= < <=
包含关系运算符的表达式,是关系表达式 -> 关系表达式的结果一定是boolean类型!
逻辑运算符(能认识能用)
&与 -> 常用
或| ->
非!
异或^
短路逻辑运算符(掌握)
短路的意思就是停止! 短路逻辑运算符可以提升代码的效率! -> 以后推荐使用短路逻辑运算符
&&遇false则短路(符号右边就不用判断了,因为左边的结果可以定最终的结果)
||遇true则短路(原因同上)
三元运算符(掌握)
对应的数据类型 变量名 = 关系表达式 ? 位置1 : 位置2;
int max = a > b ? a : b; //对max进行后续操作
案例_三个和尚(掌握)
案例分析:
流程控制语句的三种结构(都要学,都是重点掌握)
1.顺序结构
2.分支结构 -> if语句,switch语句
3.循环结构 -> for循环,while循环,do…while循环
分支语句_if语句(掌握)
案例_考试奖励(掌握)
案例分析:
day03 循环
分支语句_switch语句(记住)
switch(要匹配的值){
case 常量1:
语句体1;
break;
case 常量2:
语句体2;
break;
...
default:
一般我们做错误提示;
break;
}
案例_减肥计划
案例分析:
switch语句的case穿透(了解)
当case中省略了break,那么久开启了穿透
后续的case就不具备匹配效果(一直朝下走)
1.遇到下一个break停止 2.switch语句所有代码执行完毕
循环语句_for循环(掌握)
for(初始化语句; 判断语句; 控制语句){
循环体;
}
初始化语句只会执行1次,初始化完成后,执行判断语句
1.结果为true,循环体执行,执行控制语句
2.结果为false,循环结束
案例_打印1-5和5-1的整数
案例分析:
案例_求1-5数据和
案例分析:
案例_求1-100的偶数和
案例分析:
案例_水仙花数
案例分析:
案例_每行打印两个水仙花数
案例分析:
循环语句_while循环(了解)
初始化语句;
while(判断语句){
循环体;
控制语句;
}
案例_珠峰折纸案例
案例分析:
循环语句_do…while循环 -> 从上到下依次执行,所以会先执行一次循环体,然后再判断
初始化语句;
do{
循环体;
控制语句;
}while(判断语句); //无论判断语句结果如何,都会至少执行一次循环体
三种循环的区别(理解)
do…while循环无论判断语句结果如何,都会至少执行一次循环体(先执行后判断)
for和while循环,先判断,如果判断条件成立,才会执行循环体(先判断后执行)
for循环的初始化语句定义的i,在for循环结束后,就不能使用(i还可以再次被定义)
while循环的初始化语句定义的i,本质是在main方法中,所以main方法弹栈(结束),i在内存中才会被释放
应用场景
1.当我们知道循环次数的情况下,我们使用for
2.我们不知道循环次数,推荐使用while循环 -> 关心它的继续条件(判断条件)
三种死循环格式 -> 如果使用死循环,一定要考虑程序的出口(一般加判断停止循环即可)
for(;;){
}
while(true){
}
do{
}while(true)
跳转控制语句break和continue
break:可用于循环和switch语句,作用是结束
continue:仅用于循环,作用跳过
循环标号(day09)
Random基本使用(掌握,过了基础班就见不到了)
1.导包 import java.util.Random; //使用idea后自动导包
2.创建对象 Random r = new Random(); //使用空参构造创建对象
3.调用方法,接收数据 int num = r.nextInt(范围);
案例_猜数字小游戏
案例分析:
day04 IDEA&数组
IDEA的安装及破解 -> b站搜
IDEA的工程目录结构
从大到小
项目Project - 1.项目名 2.SDK 3.语言等级(小于等于JDK版本) 4.output自动编译后的class文件位置
模块Module - 自动带一个src根目录
包Package - 域名去掉www的反写,点代表层级
类Class - 遵循大驼峰命名法
IDEA的第一个代码
IDEA的常用快捷键
IDEA的基本操作
IDEA的常用配置
数组概述(容器): 用来存储多个相同类型数的容器
数组的两种定义格式
数据类型[] 变量名 int[] arr -> 常用
数据类型 变量名[] int arr[] -> 识别
数组动态初始化(指定长度) //没有初始化系统会给默认初始值 int 是0,
数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[6]; //通过new关键字创建了一个int型的数组容器
数组元素访问
使用索引 数组名[索引] arr[0]
初始化修改数组中的值: 数组名[1]=1;
Java内存图_一个数组
Java内存图_两个数组
Java内存图_多个数组指向相同
数组静态初始化(指定元素)
1.完整格式
int[] arr = new int[]{1,2,3,4,5};
2.简化格式 -> 简化了new int[]的书写,计算机会补上 -> 常用
int[] arr = {1,2,3,4,5};
使用场景
1.动态初始化;只明确元素个数,但不明确具体数据(给长度未知具体数据)
2.静态初始化:需求中已经明确具体数据
如:统计某班级学生数学成绩的平均值
数组操作常见异常 -> 使用数组过程中,先自己碰到几次错误 -> 讲解总结
数组遍历(数组操作的基础)
for(int i = 开始索引; i < 数组长度; i++){
// i代表每一个索引
// arr[i]代表每一个元素
// 遍历是将所有数据获取到,做后续操作,不要狭隘的理解为打印(打印,判断,计算…)
}
静态 数组的定义:(已知具体元素)
int [ ] arr = new int [ ] {元素1,元素2,元素3....};
int[] arr ={元素1,元素2,元素3....};
动态数组定义:(未知具体数值,但已知元素个数)
int[] arr = new int[2];
数组遍历 (正向反向)
遍历:将容器中的元素一个一个的获取到,做后续操作(打印,判断,计算)
1.快捷键(正向遍历):arr.fori
//遍历并打印
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
2.快捷键(反向遍历):arr.forr
//遍历并打印
for (int i = arr.length - 1; i >= 0; i--) {
System.out.print(arr[i]+" ");
}
打印数组元素以及最大值
1.定义max最大值(默认数组第一个元素为最大值)
2.遍历数组(for循环)
3.判断大小(判断最大值) if条件语句
注意:
1.打印数组内的所有值,放在for循环内
2.最大值打印需要放在for循环外打印,否则多次打印最大值
int[] arr = {124, 232, 43, 456, 667};
//1.定义max最大值(默认数组第一个元素为最大值)
int max = arr[0];
//2.遍历数组
for (int i = 0; i < arr.length; i++) {
//判断大小(判断最大值)
if (arr[i] > max) {
max = arr[i];
}
System.out.print(arr[i]+" "); //打印数组内的所有值,放在for循环内
}
System.out.println();
System.out.print("max:"+max); //最大值打印需要放在for循环外打印,否则多次打印最大值
}
在一个数组中,查找一个指定的元素
1.存在则打印元素的索引
2.不存在打印-1
步骤:
1.定义数组
2.获取要查找的元素
3.定义一个变量,用于记录索引
4.遍历数组(for)
5.判断数组中是否有该数
6.判断 index的最终结果值 为-1则该数组中没有找到,若为其他,则为其数的索引
综合案例:6个评委给1名选手打分,分数是[1-100]之间的整数
将分数装入一个合适的容器中
要求去掉最高分,去掉最低分,计算选手平均值
步骤:
1.创建键盘对象
2.定义数组并动态初始化
3.遍历数组(for )
4.提示用户并从键盘接受数据(打分)
5.对评委录入的分数做健壮性的判断(score<0||score>100 数据输入有误 )
6.求最大值
7.求最小值
8.求数组元素和
9.计算平均值: 要求去掉最高分,去掉最低分,计算选手平均值
10.打印结果
遍历总结
public static void main(String[] args) {
// 遍历整数: 1-5
for (int i = 1; i <= 5; i++) {
// 当前的i代表数值本身
System.out.println(i);
}
// 遍历整数: 5-1
for (int i = 5; i >= 1; i--) {
// 当前的i代表数值本身
System.out.println(i);
}
// 遍历数组
int[] arr = {11, 22, 33, 44, 55};
for (int i = 0; i < arr.length; i++) {
// 当前的i代表索引!
System.out.println(arr[i]);
}
// 遍历字符串: 方式1
String s = "黑马程序员";
for (int i = 0; i < s.length() ; i++) {
// 通过charAt(索引)获取每一个[字符]
char c = s.charAt(i);
System.out.println(c);
}
// 遍历字符串: 方式2
String ss = "传智专修学院";
// 将字符串转为[字符数组]
char[] crr = ss.toCharArray();
// 遍历[字符数组]即可
for (int i = 0; i < crr.length; i++) {
System.out.println(crr[i]);
}
//s.length().fori -> 先敲出来长度,在.fori
}
案例_求数组元素最值
案例分析:
=====================================
案例_求数组元素和
案例分析:
案例_数组元素的基本查找
案例分析:
案例_评委打分案例
案例分析:
day05 方法
方法概述
一段具有独立功能的代码块，方法需要先定义，再调用
方法的定义和使用(无返回值无参数)
public static void method(){
方法体;
//可以省略return不写,如果要写,只能写return;
}
方法三种调用(理解)
1.直接调用: 只能调用没有返回值的方法,才有意义
2.赋值调用: 常用于调用带返回值的方法,这里进行赋值,做[后续操作]
3.打印调用: 常用于调用带返回值的方法,这里直接打印[返回值]
方法调用过程
栈内存:方法首先加载到栈内存, 特点:先进后出
案例_判断奇偶数(应用)
public static void method(int num){ //形式参数:num,作用是接收实参
if(num % 2 == 0){
sout("偶数");
}else{
sout("奇数");
}
}
带参数方法的定义和使用(应用)
形参和实参(理解)
1.形式参数: 方法定义时的参数(作用是接收实参) 定义方法时的参数 方法名(形参){ }
2.实际参数: 方法调用时的参数(本质就是参与运算的数据) 调用方法时的参数 方法名(实参); a(10);
案例_打印n-m之间所有奇数(应用)
public static void method(int n,int m){
//如果n大于m,那么错误提示,并且停止方法
if(n > m){
sout("错误提示");
return; //结束方法
}
for(int i = n; i <= m; i++){
if(i % 2 != 0){
sout(i);
}
}
}
带返回值的方法定义和使用(应用)
案例_求两个数中的较大值(应用)
public static int method(int a,int b){
return a > b ? a : b;
}
方法定义的通用格式(必须掌握)
public static 返回值类型 方法名(参数列表){
方法体; //完成功能的主要逻辑
return 返回值; //return的 作用1:返回返回值 作用2:结束方法
}
return 的作用:1:返回返回值
2:结束方法
方法使用注意事项(理解)
1.方法不能嵌套定义
2.如果方法有返回值,返回值类型和返回值要匹配
3.return下一行不能再写代码,因为return不但可以返回结果,而且结束了方法
4.return 一次只能返回一个值,如果要返回多个数,可以将其放入容器(数组),然后返回一个数组,然后再主方法重新定义一个数组接收数组
方法重载(识别)
在同一个类中,方法名相同,参数列表序列不同(数量,类型,顺序),这些方法就构成了重载关系
方法重载和返回值类型没有关系(识别的时候不用看返回值类型)
方法参数传递_传递基本类型和引用类型的区别(了解)
1.方法参数如果传递的是[基本类型],传递的是[具体数值] -> 形参的改变不会影响实参
2.方法参数如果传递的是[引用类型],传递的是[地址值] -> 形参的改变会影响实参 -> 两个人住一个房子
案例_定义方法，完成数组遍历
案例_定义方法，获取数组最大值
案例_定义方法，同时获取数组最大值和最小值
day06 进制&二维数组
debug介绍与基本操作流程(掌握)
打断点 - 哪里不会点哪里
右键 - debug模式 - 看窗口
一个窗口看变量,一个窗口看运行结果(录入数据)
下一步 - 向下箭头
红色方框停止控制台 - 去除断点
debug查看循环求偶数和、查看方法参数传递
进制的介绍和书写格式(计算器)
二进制 0 1
八进制 0 1 2 3 4 5 6 7
十进制 0 2 3 4 5 6 7 8 9
十六进制 0 2 3 4 5 6 7 8 9 a b c d e f
任意进制到十进制(计算器)
系数*基数的权次幂 相加
系数:每一位上的数字
基数:几进制转基数就是几
权:从右向左的编号,从0开始
十进制到任意进制(计算器)
除基取余法
除到商为0,将余数倒着拼接
快速进制转换法
8421码 -> 玩的是二进制 -> 10101…套入8421,0对应的不取,1对应的取出来相加
原反补
原码 -> 给人看的 -> 套入8421就可以看到具体数值
反码 -> 转换的桥梁
补码 -> 数据在计算机中运算,是以二进制补码的形式存在
正数的原反补相同
-> 推算
基本位运算符
位移运算符
案例_数据交换
方式1:使用第三方变量
int temp = a;
a = b;
b = temp;
方式2:异或运算符的特点 -> 一个数被另一个数异或两次,该数字本身不变
a = a ^ b; //把这里的a看成一个整体的式子
b = a ^ b; //b就会被改变
a = a ^ b;
案例_数组翻转
使用两个指针指向头和尾,然后两指针进行数据交换(头指针 < 尾指针)
for(int start = 0,end = arr.length - 1; start < end ; start++,end–){
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
二维数组概述: 装着一维数组的容器
二维数组动态初始化
int[][] arr = new int[二位数组长度][一维数组长度];
注:可以先创建一个一维数组,然后在放入二维数组中
如:int[] arr1 ={1,2};
int[] arr2 ={3,4};
int[][] arr3 ={arr1,arr2};
二维数组静态初始化
完整格式: int[][] arr = new int[][]{一维数组1,一维数组2…};
简化格式: int[][] arr = {一维数组1,一维数组2…};
案例_遍历二维数组
需求:
已知一个一维数组 arr ={{11,12,13},{21,22,23}};
遍历该数组,取出所有元素并打印
步骤:
1.遍历二维数组,取出里面每一个一维数组
2.在遍历的过程中,对每一个一维数组继续完成遍历,获取内部存储的每一个元素
案例_求二维数组元素和
int sum = 0;
for(int i = 0; i < arr.length; i++){
// arr[i]代表一维数组
for(int j = 0; j < arr[i].length;j++){
sum += arr[i][j];
}
}
day07 面向对象基础
面向过程和面向对象思想的对比
面向过程(c语言):关注点在过程,需要我们一步一步的实现功能
面向对象(java):关注点在对象,我们只需要指挥对象(通过类创建)完成一些功能
面向对象是基于面向过程的,我们是站在巨人的肩膀上编程的
类和对象的关系
类:一类具有相同属性和行为的事物的描述 -> 理解为设计图
对象:客观存在的事物 -> 根据设计图可以创建多个对象
标准类的定义
1.成员变量: 必须使用private关键字私有
2.构造方法: 提供空参和带参,用户选择哪一种都行 -> 快捷键生成
3.成员方法: 必须提供成员变量对应的getXxx和setXxx方法 -> 快捷键生成
对象的创建和使用
数据类型 对象名 = new 数据类型(); //空参构造
数据类型 对象名 = new 数据类型(属性1,属性2…); //带参构造
使用对象,其实就是使用对象名(调用它的方法)
单个对象内存图
1.栈内存 -> 方法进栈
2.堆内存 -> new出来的东西进堆
3.方法区 -> 字节码文件
两个对象内存图
两个对象指向相同内存图
成员变量和局部变量的区别
1.类中位置:成员变量在类中方法外;局部变量在方法上
2.内存中位置:成员变量在堆内存(跟着对象走);局部变量在栈内存(跟着方法走)
3.生命周期:成员变量就是对象的生命周期;局部变量就是方法的生命周期
4.初始化值:成员变量进堆,所以有默认的初始化值;局部变量没有,需要先定义赋值,才能使用
private关键字的使用
private关键字是权限修饰符(java中有四种权限)
private关键字可以修饰成员(成员变量和成员方法)
被private修饰的成员,只能在本类中访问(出了本类就访问不到了! -> 有问题! -> 提供对应公共的访问方式)
成员变量必须使用private修饰符修饰,使用后只能在该类中访问,如果要在其他类中访问该成员变量,则需要使用get和set方法,进行设值和取值
private 只能在当前类中使用,如果要在其他类中使用
get变量名() 获取成员变量值,方法用public修饰 //set 有参无返回
set变量名() 设置成员变量值,方法用public修饰 // get 无参有返回
格式:
1.设值 set成员变量名 -->无返回值(void) 有参数(type 参数名) 将参数赋值给成员变量
public void set变量名(参数1,参数2…){
变量名 = 参数;
}
1.取值 get成员变量名 -->有返回值(4种8类) 无参 有返回值(return 返回值;)
public void get变量名(){
return 返回值名 ;
}
this关键字的内存原理
this关键字代表当前类,对象的引用(地址)
this可以调用本类的成员
我们使用this区分局部变量和成员变量重名问题
封装概述
java中面向对象的三大特征:封装,继承,多态
封装:隐藏实现细节,仅对外提供对应公共的访问方式
体现1:私有成员变量,提供对应的getXxx和setXxx方法(安全性)
体现2:方法的定义,将代码封装在方法中(复用性)
体现3:将数据封装在类中
好处:
1.提高了代码的安全性
2.提高了代码的安全性
构造方法的格式和执行时机
空参:public/private 类名和方法名一致(){}
带参:public/private 类名和方法名一致(属性1,属性2…){
this.属性1 = 属性1;
this.属性2 = 属性2;
…
}
构造方法的作用
本质的作用是创建对象
其他作用,借助了构造方法加载的时机,完成对象的赋值(带参构造)
构造方法的注意事项
1.如果我们不提供构造,系统会提供一个默认的空参
2.如果我们提供了带参,系统就不会给我们空参了
3.总结:两种都提供
public class User {
// 成员变量
private String name;
private int age;
// 构造方法
public User() {
}
public User(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;
}
}
day08 String
API介绍和帮助文档的使用
1.索引 - 搜索类名
2.先看包 - 需要不要导包
3.再看构造 - 创建对象
4.创建对象 - 调用方法
键盘录入字符串
next(); 遇到空字符停止 -> 常用
nextLine(); 遇到回车停止
具体说明:
如果要同时键入数字和字符,键入数字使用sc.nextInt() 字符使用sc.next() 不能使用nextLine(), 因为nextLine()遇到回车就停止了 在使用next()方法键入数字时,不仅仅键入了数字,还键入了回车(保存在内存中)而nextLine()方法首先扫描缓冲区,发现之前还有一个回车存在内存中,所以nextLine()方法结束
next()方法的结束标志是空格或tab键
如:键盘键入 张三 李四 王五
此时只能接受张三 ,因为张三后面有一个空格,而next()遇到空格结束该方法(录入数据不完整) ----->仅供学习使用,实际应用中用不到
String概述
String在lang包下,使用不需要导包
String创建出来内容就不能改变了(底层被final关键修饰)
java中所有双引号引起来的内容,都是String类的对象
注意:字符串是常量,其值在创建后就不能更改
如要修改只能是对象的替换.(new就是创建对象(类的实例化))—>String类具有局限性–>使用StringBuilder类可以实现自由更改
eg:
String s1 = “abc”
s1 = “aabc123”
等价于Student stu new Student(“张三”);
stu = new Student(“李四”)
String类的常用方法
length() 计算字符串的长度(个数)
String类的常见构造方法
1.空参 public String() —>不常用
2.带参 public String(char[] chs) 将字符数组的内容串起来,串成字符串(类似串羊肉串) —>常用
3.带参 public String(字符串对象如:“abc”)根据传入的字符串内容创建字符串(创建了俩对象)
4.String = “abc” —.最常用
区别:
1.空参 String s1 = new String() -> 因为是new出来的,所以进堆
2.带参 String s2 = new String(char[] chs)(字符数组) -> 因为是new出来的,所以进堆
3.带参 String s3 = new String(String original)(“字符串”) -> 因为是new出来的,所以进堆
4.String = “abc” 双引号直接赋值 -> 没有通过new,存储在字符串常量池
" "给出的字符串,只要字符序列相同,无论在程序中出现几次,JVM只会建立一个String 对象,并且在字符串常量池中维护
不存在: 创建
存在: 直接复用
注意:String类比较特殊,打印其对象名时,不会出现内存地址,而是记录该对象所记录的真实内容
字符串常量池规则:
先找有没有字符序列一样的字符串
有,拿来复用
没有,创建新的
String类创建对象的区别对比
String特点及常见面试题
字符串的+操作,底层是通过StringBuilder完成的
底层会自动创建StringBuilder的对象,使用append(任意类型)方法完成拼接
最后再将sb转为String
总结:有一个+号底层会创建两个对象,不效率的!!!
案例_字符串的比较
使用==作比较
基本数据类型:比较的是数据值是否相同
引用类型: 比较的是地址值是否相同
字符串比较内容是通过调用方法实现的 s1.equals(s2)
public boolean equals(object and object)
eg:
String s1 = “abc”
String s1 = “ABC”
String s1 = “abc”
System.out.println(s1.equals(s2)) //false
System.out.println(s1.equals(s3)) //true
比较内容时需要忽略大小写使用:s1.equalsIgnoreCase(s2)
案例_用户登录案例
需求:已知用户名和用户密码,请使用程序模拟用户登录,总共有三次机会,登录之后给出相应提示
思路:1. 已知用户名和密码 定义两个字符串即可
2. 键盘录入要登录的用户名和密码,使用Scanner
3. 将将键盘录入的用户名和密码与已知的用户名和密码进行字符串的比较,字符串内容的比较使用equals()方法实现
4. 使用循环实现三次机会的录入使用for循环,登录成功使用break跳出循环
源代码:
public static void main(String[] args) {
//设置初始密码
String username = "王东义";
String password = "123456";
//创建Scanner对象
Scanner sc = new Scanner(System.in);
for (int i = 1; i <=3; i++) {
//提示用户
System.out.print("请输入用户名:");
String uname =sc.next();
System.out.print("请输入密码:");
String psw = sc.next();
//已知密码与输入的密码进行比较
if(username.equals(uname)&&password.equals(psw)){
System.out.println("登录成功!");
break;
//如果输入次数为三次,则结束循环
}else if(i==3){
System.out.println("您当日输入次数已用完,请明天再来");
}else{
System.out.println("用户名或密码输入错误,您还有"+(3-i)+"机会");//重新输入
}
}
}
案例_字符串遍历的两种方式
遍历:基础操作
1.遍历整数(i代表数字本身)
2.遍历数组(i代表数组索引)
3.遍历字符串(i代表字符串的索引)
4.遍历集合[i代表集合的索引]
需求:键盘录入一个字符串,使用程序实现在控制台遍历该字符串
思路一
1.键盘录入一个字符串,用Scaner实现
2.遍历字符串,首先要能够获取到字符串中的每一个字符
public char charAt(int index):返回值指定索引处的char值,字符串的索引也是从0开始的
3.遍历字符串,其次要获取字符串长度
public int length():返回此字符串的长度
数组的长度:数组名.length
字符串的长度:字符串对象.length()
4.遍历
for(int i = 0; i<length();i++){
s.charAt(i)
}
代码:
// 遍历字符串: 方式1
String s = "黑马程序员";
for (int i = 0; i < s.length() ; i++) {
// 通过charAt(索引)获取每一个[字符]
char c = s.charAt(i);
System.out.println(c);
}
思路二:
1.使用Scanner
2. 将字符串拆分为字符数组并返回
public char[] toCharArray()
3.遍历字符数组
代码:
// 遍历字符串: 方式2
String ss = "传智专修学院";
// 将字符串转为[字符数组]
char[] crr = ss.toCharArray();
// 遍历[字符数组]即可
for (int i = 0; i < crr.length; i++) {
System.out.println(crr[i]);
}
案例_统计字符出现次数
需求;键入一段字符包含数字 大写 小写 统计各个个数
1.Scanner
2.定义三个计数器变量
3.遍历字符串,将字符串
4.判断该字符,然后对应类型计数器变量加1,
大写字母:ch >=‘A’&&ch <=‘Z’
小写字母:ch >=‘a’&&ch <=‘z’
数字:ch >= ‘0’&&ch<=‘9’
5.输出
案例_手机号屏蔽
String substring(int index) 从该索引到结尾全部截取
String substring(int index1,index2) 截取索引1到索引2之间的字符
串
代码:
public static void main(String[] args) {
// 提示用户录入电话并接收
System.out.println("请输入电话:");
String tel = new Scanner(System.in).next();
// 截取前三位
String start = tel.substring(0, 3);//0 1 2左包含右不包含
// 截取后四位
String end = tel.substring(7);
// 拼接打印结果
System.out.println(start + "****" + end);
}
案例_敏感词替换
思路:
1.键盘录入
2.替换敏感词
String replace(旧值,新值)
public static void main(String[] args) {
// 提示用户录入一段对话，包含敏感词汇
System.out.println("请输入字符串：");
String s = new Scanner(System.in).next();
// 替换敏感词，接收返回的新字符串
String result = s.replace("TMD", "***");
// 打印结果
System.out.println(result);
}
案例_切割字符串
需求:以字符串的形式录入学生信息,例如 “张三,22,西安”
思路:
1.编写Student类,用于封装数据
2.键盘录入字符串
3.根据逗号切割,得到 (张三) (22) (西安)
String[] split(“,”);
4.取出元素,通过Student 类的有参构造封装为对象
5.调用getXxx()方法,取出数据并打印
代码;
public static void main(String[] args) {
// 定义字符串
String s = "张三,18,西安,13888888888";
// 通过逗号切割 -> 这个标识是提前约定好的,统一使用一样的标识
String[] arr = s.split(",");
// 定义学生类 -> 属性有name、age、address、tel，都是String类型
// 封装学生对象
Student stu = new Student(arr[0], arr[1], arr[2], arr[3]);
// 打印所有属性
System.out.println("姓名:" + stu.getName() + ",年龄:" +
stu.getAge() + ",住址:" + stu.getAddress() + ",电话:" + stu.getTel());
}
String类方法小结
boolean equals(字符串对象); 比较内容
boolean equalsIgnoreCase()(字符串对象); 比较内容,忽略大小写
int length(); 返回字符串长度
int charAt(索引); 返回指定索引处的字符(遍历拆分)
char[] toCharArray(); 将字符串转为字符数组(遍历)
String substring(索引); 从指定索引截取到末位,返回新的字符串(截取)
String substring(索引1,索引2); 左包含右不包含的截取,返回新的字符串(截取)
String replace(旧值,新值); 使用新值替换旧值,返回新的字符串(替换)
String[] split(“标识”); 通过标识切割字符串,返回一个字符串数组(切割)
StringBuilder概述 (String 创建的字符串不可改变–>StringBuilder())
可变的字符串容器,用来操作String
操作String的效率非常高
提高操作字符串的效率
扩展:System.currentTimeMills();获取1970年1月1日0时0分0秒
StringBuilder构造方法(空参和带参)
StringBuilder sb = new StringBuilder();
StringBuilder sb = new StringBuilder(“要操作的字符串”)
StringBuilder常用方法
reverse(); 翻转
append(任意类型); 拼接
toString(); 将sb转为String
StringBuilder提高效率的原理
底层只会创建一个sb对象,完成所有的append拼接
如果使用+号,一个+号底层就有两个对象
案例_判断字符串是否对称
案例_按照格式打印数组元素
day09 ArrayList集合&学生管理系统
集合和数组
集合类的特点:提供一种存储空间可变的存储模型,存储的数据容量可以发生改变,可以自动扩容(先使用再了解底层)
数组的特点:存储空间一经定义,大小不可变,如果需要改变只能重新创建数组
集合和数组的区别
相同点:都是存储数据的容器
不同点:数组的容量是固定的,集合的容量是可变的
集合
创建集合容器对象
ArrayList //String 类型的数据
ArrayList //Sudent 类型的数据
完整格式:
数据类型 <泛型> 变量名 = new 数据类型<>();
ArrayList list = new ArrayList<>();
注意:
1.集合如果没有加入<>,就可以存储任意数据类型
2.(泛型) : 对集合容器存储数据类型进行限定
泛型只能使用引用类型,不能使用基本数据类型,如果非要存储基本数据类型,则需要使用基本数据类型的包装类,如int类型的是Integer
基本数据类型的包装类(引用类型) -->四类八种
byte --> Byte
short–> Short
* int --> Integer
long --> Long
float --> Float
double --> Double
* char -->Character
boolean --> Boolean
注意:直接打印集合变量名,出现的是集合存储的元素,而不是地址 //sout(list)
ArrayList集合的构造方法
Arraylist() 构造一个初始容量为10的空列表
空参构造 : ArrayList<泛型> list = new ArrayList<>();
ArrayList集合的增删改查方法
增: add(); add(索引,元素);
删: remove(元素); remove(索引)
改: set(索引,新元素);
查: get(索引);
长度: size();
打印变量名总结
1.一维数组: 地址值 //int[] arr = {1,2,3};
2.二维数组: 地址值 //int[][] brr = {{1,2,3}{4,5,6}{7,8,9}};
3.打印自定义的对象: 地址值(全类名+地址值) //Student stu = new Student();
4.字符串: 内容 //String s = “你好”;
5.StringBuider对象: 内容 //StringBuider sb = new String(“hello”);
6.集合: 内容 //ArrayList list = new ArrayList<>();=
案例_存储学生对象并遍历
步骤:1.定义学生类
2.创建集合对象
3.创建学生对象
4.添加学生对象到集合
5.遍历集合
代码:
public static void main(String[] args){
ArrayList list = new ArrayList<>();
Student stu1 = new Student(张三
}
案例_键盘录入学生信息到集合
学管开发步骤:
搭建学生信息管理系统界面
删除元素的注意事项
案例_集合中数据筛选
案例_学管项目演示
案例_学管实现步骤分析及学生类的编写
案例_学管菜单搭建
案例_学管的增删改查功能实现
案例_学管的代码优化
487
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
