JavaSE基础--笔记总结

Day1:01--13

01-Java背景介绍

• Java 是1995年, 在Sun公司, 由詹姆斯 高斯林主导研发

• 詹姆斯高斯林被誉为Java之父

• 由于Sun的管理不善, 被Oracle收购

• 今后下载Java相关的资源, 就要到 www.oracle.com 进行下载

02-Java的三个平台

• Java SE : Java语言的标准版, 可以用于桌面应用的开发

• 目的 : 为了今后要从事的JavaEE开发, 打基础

• Java ME : 不学了

• Java EE : 可以用于web方向的网站开发

• 网页 : 用于数据展示

• 网站 : 网页 + 后台服务器

项目 :

1. 传统项目

XXX人员管理系统 -> 黑马程序员订制的项目 -> 用户并发访问量不大

XXXOA办公系统

2. 互联网项目

淘宝

京东

...

03-Java的跨平台性和工作原理

• 平台 : 这里的平台指的是操作系统

• Windows

• MacOS

• Linux

• 跨平台 : Java程序可以移植到任意操作系统中运行

• 原理 : 在不同的操作系统中, 安装一个与之对应版本的 JVM 虚拟机即可

• 注意 : 允许跨平台的是 Java 程序, 不是JVM虚拟机

04-JDK-JRE-JVM

• JVM : Java 虚拟机, 运行Java程序的平台 (载体)

• JRE : Java 运行时环境 , 内部包含了 JVM 虚拟机, 还有核心类库

• 核心类库 : Java已经写好的代码, 我们自己写代码的时候, 要用到这里面的东西.

• JDK : 提供给程序员使用的开发工具, 内部包含了 JRE, 还有开发工具

• javac.exe 编译工具

• java.exe 运行工具

• 关系 : 包含关系

• JDK -> JRE -> JVM

• 需要了解的JDK版本

• JDK5 : 里程碑性质的版本

• JDK8 : 国内市场用的最多的版本

• JDK11 : 国外市场用的最多的版本

• JDK17 : 课程中使用的版本

LTS : 如果JDK带有LTS的标识, 表示是长期维护版本

05-HelloWorld程序

• Java程序开发的三个步骤

• 编写代码

• 扩展 : 了解java 文件名.java

• JDK12版本开始, 允许测试性质的运行

ctrl + shift + K : 笔记软件的快捷键

新建一个.java文件 (源文件) 将代码写到源文件中

public class HelloWorld {

public static void main(String[] args){

System.out.println("HelloWorld");

}

}

编译代码

运行代码

06-JAVA_HOME的环境变量配置

• 高版本的 JDK 在安装完毕后, 会有一份默认的配置

• 基础班使用没问题

• 就业班使用的时候, 就会出现问题

• 解决 : 删除默认配置, 改进为 JAVA_HOME 的配置方式

• JAVA_HOME的配置方式 :

• 详情参见文档

07-IDEA工具 (重点)

• 详情参见文档

08-注释

• 介绍 : 在程序的指定位置, 添加的一些说明性信息

• 简单记 : 对代码的一种解释

• 注释的分类 :// 注释信息

• 单行注释

• 多行注释

• 注意事项 :

• 被注释掉的内容, 不会参与程序的编译和运行

• IDEA工具, 对于注释有特殊支持// TODO: 描述一些待完成的任务

• 使用注释对HelloWorld代码做解释

/*

注意信息

*/

/** 注意信息 */

• 文档注释 : 后期会使用文档注释, 配合工具, 制作API帮助文档

// 通过class关键字创建了一个类, 类名叫做HelloWorld // public 起到限制作用, 限制文件名和类名称保持一致 public class HelloWorld { /* main方法(主方法) 程序执行时的入口 如果没有编写主方法, 程序将无法运行 */ public static void main(String[] args){ // 打印语句 (输出语句) 可以打印 () 中所包裹的内容 System.out.println("HelloWorld"); } }

09-关键字

• 介绍 : 被 Java 赋予了特定涵义的英文单词

• 注意 : 关键字已经被Java赋予了特定的涵义, 我们就不允许再使用了

今天认识的关键字 : class : 定义类 public : 起到限制作用, 限制文件名和类名称保持一致 (暂时理解) true : 布尔类型数据(真) false : 布尔类型数据(假) int : 整数的数据类型

10-字面量 (常量)

• 目标 : 学习 Java 中有哪些数据我们可以使用

1. 字符串 : 被双引号所包裹的数据 2. 整数 : 所有整数 3. 小数 : 所有小数 4. 字符 : 被单引号所包裹的数据, 内部只能存放单个字符 5. 布尔 : true, false - 单独打印没有意义, 为了配合day02要学习的运算符, 一起使用 - System.out.println(10 > 20); // false 6. 空 : null - 不允许做打印 - day04讲解到引用数据类型的时候, 详细介绍public class ConstantTest { /* 需求: 将自己的个人信息打印在控制台 (姓名, 年龄, 性别, 身高, 婚姻状况) 姓名: 字符串 年龄: 整数 性别: 字符 身高: 小数 婚姻状况: 布尔 */ public static void main(String[] args) { System.out.println("郝以绅"); System.out.println(18); System.out.println('男'); System.out.println(180.1); System.out.println(false); } }

11-变量

• 介绍 : 内存中的存储空间, 空间中记录着经常发生改变的数据

• 变量的定义格式 :

数据类型 变量名 = 数据值; 数据类型: 整数: int

• 变量的使用 : 根据变量名进行使用

public class VariableDemo1 { /* 变量的介绍 : 变量是内存中的存储空间, 空间中记录着经常发生改变的数据 变量的定义格式 : 数据类型 变量名 = 数据值; 数据类型: 整数: int 使用变量的思路: 根据变量名进行使用 */ public static void main(String[] args) { int salary = 12000; System.out.println(salary); salary = 15000; System.out.println(salary); int age = 18; System.out.println(age); // 步骤1: 定义一个整数类型的变量, 名字叫做 num1, 记录数值100 int num1 = 100; // 步骤2: 定义一个整数类型的变量, 名字叫做 num2, 记录数值200 int num2 = 200; // 步骤3: 定义一个整数类型的变量, 名字叫做 result, 记录数值 num1 + num2 的结果; int result = num1 + num2; // 步骤4: 展示3个变量各自记录的数值. System.out.println(num1); System.out.println(num2); System.out.println(result); } }

12-Debug工具

• 简单理解 : 看做为程序的另外一种运行模式, 在这种运行模式下, 程序每一步的执行都是听指挥的

• 通过查看程序的每一步执行过程, 分析问题, 找到问题, 解决问题

1. 加断点 : 告诉Debug从哪一行代码开始, 听我指挥 2. 选择以Debug方式, 运行程序 3. 点哪里? Step Over : 让程序向下执行一步 4. 看哪里? Debugger : Frames : 可以看到程序中, 有哪些方法正在执行 Variables : 可以看到程序中有哪些变量, 和变量的变化过程 Console : 控制台, 可以看到程序打印出来的数据

13-变量的注意事项

• 变量名不允许重复定义 :

int a = 10; int a = 20; // 编译错误

• 一条语句可以定义出多个变量, 中间需要使用逗号分隔

int a = 10, b = 20, c = 30;

• 变量使用之前必须赋值

int num; System.out.println(num); // 编译错误

• 变量的作用域

注意:

• 变量命名规则:1.可以包含字母,数字,下划线,美元符2.不能以数字开头3.不能是关键字保留字4.true, false, null 字面量常量除外

Day2:14--27

14-标识符

• 介绍 : 给类, 方法, 变量...起名字的符号

• 简单记 : 自己起的名字都是标识符

• 命名规则:

• 数字 0 ~ 9

• 字母 a ~ z A~Z

• _ $

• 不能以数字开头

• 不能是Java中的关键字

• 严格区分大小写

• 命名规范 (江湖规矩) :

小驼峰命名法 : 变量

如果是一个单词, 所有字母小写 age name

如果是多个单词, 从第二个单词开始, 首字母大写 maxAge firstName

大驼峰命名法 : 类

如果是一个单词, 首字母大写 Student

如果是多个单词, 每个单词首字母大写 GoodStudent OperatorDemo ScannerTest

15-数据类型

• 基本数据类型

整数 :

byte 1个字节 -128~127

short 2个字节

int 4个字节

long 8个字节

小数 :

float 4个字节

double 8个字节

字符 :

char 2个字节

布尔 :

boolean 1个字节

使用选择 :

1. 整数类型 : 首先int, 发现int装不下了, 换成long类型, 定义long类型变量需要加入 L 标识

2. 小数类型 : 首选double, 非要用float类型, 需要加入F标识

细节 :

所有整数默认都是 int

System.out.println(10);

所有小数默认都是 double

System.out.println(12.3);

char 类型的取值范围是 0 ~ 65535

在计算机中存储 'a' ---> 字节 ---> 二进制 ---> 01100001 ---> 97

结论: 字符在底层都有一份数值的表示形式

char c = 97;

System.out.println(c); // a

• 引用数据类型

• 字符串 : String

package com.itheima.test;

public class DataTypeTest1 {

/*

需求: 请将自己的个人信息, 定义出变量, 并展示在控制台

(姓名, 年龄, 身高, 性别, 婚姻状况)

姓名 : 字符串 --> String

年龄 : 整数 --> int

身高 : 小数 --> double

性别 : 字符 --> char

婚姻状况 : 布尔 --> boolean

*/

public static void main(String[] args) {

// 数据类型 变量名 = 数据值;

String name = "张三";

int age = 23;

double height = 180.1;

char gender = '男';

boolean flag = false;

System.out.println(name);

System.out.println(age);

System.out.println(height);

System.out.println(gender);

System.out.println(flag);

}

}

16-Scanner键盘录入 (必掌握)

• 三个步骤

• 找符咒

• 召唤精灵

• 指挥精灵干活

1. 找符咒

代码: import java.util.Scanner;

位置: 必须写在class的上面

2. 召唤精灵

代码: Scanner sc = new Scanner(System.in);

涵义: 将符咒中的精灵召唤出来

位置: main方法里面

3. 指挥精灵干活

代码:

int age = sc.nextInt(); 从键盘录入整数

String name = sc.next(); 从键盘录入字符串

------------------------------------------------------

double height = sc.nextDouble(); 从键盘接收小数

boolean flag = sc.nextBoolean(); 从键盘接收布尔类型

17-算数运算符

• 分类

+

-

*

--------------------------------------

/ : 整数相除, 结果只能得到整数, 如果想要带有小数的结果,需要有小数参与运算

% : 取模, 得到的是除法之后, 剩下的余数

package com.itheima.test;

import java.util.Scanner;

public class OperatorTest1 {

/*

需求: 键盘录入一个三位数, 将其拆分出个位, 十位, 百位, 打印在控制台

个位: 数值 % 10;

十位: 数值 / 10 % 10;

百位: 数值 / 10 / 10 % 10;

千位: 数值 / 10 / 10 / 10 % 10;

万位: 数值 / 10 / 10 / 10 / 10 % 10;

...

简化算法: 针对于数值的最高位, 可以做简化

123 / 100 ---> 1

4567 / 1000 ---> 4

45678 / 10000 ---> 4

*/

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("请输入一个三位数: ");

int num = sc.nextInt();

int ge = num % 10;

int shi = num / 10 % 10;

int bai = num / 100;

System.out.println("整数" + num + "的个位为:" + ge);

System.out.println("整数" + num + "的十位为:" + shi);

System.out.println("整数" + num + "的百位为:" + bai);

}

}

18-字符串拼接操作

• 当 + 号操作过程中, 遇到了双引号字符串, + 号就是字符串连接符, 而不是算数运算了

System.out.println("itheima" + 666); // itheima666

需求: 定义两个变量, 记录3和4, 要求控制台打印的结果是 3 + 4 = 7

int a = 3;

int b = 4;

System.out.println(a + "+" + b + "=" + (a + b));

19-自增自减运算符

• 符号 : ++ , --

++ : 让变量自身的值 +1

-- : 让变量自身的值 -1

• 使用

1. 单独使用 (推荐)

int a = 10;

a++;

++a;

++在前, 在后没有任何区别.

2. 参与运算使用 (面试喜欢问)

++在前 : 先自增, 再操作

int a = 10;

int b = ++a; // a = 11, b = 11

System.out.println(a); // 11

System.out.println(b); // 11

++在后 : 先操作, 再自增

int a = 10;

int b = a++; // b = 10, a = 11

System.out.println(a); // 11

System.out.println(b); // 10

package com.itheima.test;

public class OperatorTest2 {

/*

不用自己写, 看程序说结果

*/

public static void main(String[] args) {

int a = 10;

int b = ++a;

int c = b++;

System.out.println("a=" + a);

System.out.println("b=" + b);

System.out.println("c=" + c);

System.out.println("------------------------");

int x = 3;

int y = (++x) + (x++) + (x * 10);

System.out.println("x=" + x);

System.out.println("y=" + y);

}

}

• 注意事项 :

• 自增自减运算符, 只能操作变量, 不能操作常量

20-赋值运算符

• 基本赋值运算符

= : 将符号右边的数据, 赋值给左侧的变量

int a = 10;

• 扩展赋值运算符

+= : 将符号左右两边的数据, 做加法运算, 将结果赋值给左边

int a = 10;

a += 20;

System.out.pritnln(a); // 30

-= :

*= :

/= :

%= :

• 注意事项 : 扩展赋值运算符, 自带强转效果

double a = 12.3;

int b = 10;

b += a;

System.out.println(b); // 22

21-关系运算符

• 小名 : 比较运算符

>

<

>=

<=

==

!=

• 结论 : 让数据之间作比较, 返回true, false的结果

• 注意 : 不要把 = 号误写成 ==

22-逻辑运算符

• 代码层面 : 连接boolean类型的表达式或者是值

• 理解层面 : 整合多个条件, 为一段整体的逻辑

if(score >= 90 && score <= 100){

}

• 分类 :

&(与) : 并且, 遇false则false

|(或) : 或者, 遇true则true

!(非) : 取反

^(异或) : 相同为false, 不同为true

23-短路逻辑运算符(常用)

& : 没有短路效果, 无论符号左边是true,false, 右边都要继续执行

&& : 具有短路效果, 当符号左边为false的时候, 右边就不执行了

如果左边为true, 右边要继续执行

| : 没有短路效果, 无论符号左边是true,false, 右边都要继续执行

|| : 具有短路效果, 当符号左边为true的时候, 右边不执行了

如果左边为false, 右边要继续执行

结论: 今后常用的逻辑运算符

&& || !

24-三元运算符

• 三目运算符

• 效果 : 根据一个判断条件, 从两个数据值, 二者选其一

• 格式 : 判断条件 ? 值1 : 值2;

1. 执行判断条件, 看其返回结果是true, false

2. true : 值1就是最终结果

3. false : 值2就是最终结果

-------------------------------------------------------

int a = 10;

int b = 20;

int max = a > b ? a : b;

package com.itheima.test;

import java.util.Scanner;

public class OperatorTest3 {

/*

需求: 键盘录入3个整数, 求出最大值, 最小值, 中间值

按照从小到大的顺序, 依次打印

中间值 : num1 + num2 + num3 - max - min;

*/

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("请输入三个整数 :");

int num1 = sc.nextInt();

int num2 = sc.nextInt();

int num3 = sc.nextInt();

// 1. 求三个整数的最大值

int tempMax = num1 > num2 ? num1 : num2;

int max = tempMax > num3 ? tempMax : num3;

// 2. 求三个整数的最小值

int tempMin = num1 < num2 ? num1 : num2;

int min = tempMin < num3 ? tempMin : num3;

// 3. 求中间值

int mid = num1 + num2 + num3 - max - min;

System.out.println("最小值为:" + min);

System.out.println("中间值为:" + mid);

System.out.println("最大值为:" + max);

}

}

25-运算符的优先级

• 熟练掌握 () 的使用

• 常识概念 : && 的优先级是 大于 ||

26-流程控制语句

• 介绍 : 通过一些语句, 来控制程序的执行流程

• 分类 :

• 顺序结构

• Java 程序默认的执行流程, 没有特定的语法

• 分支结构

• if

• switch

• 循环结构

• for

• while

• do...while

27-if语句

• 格式1 :

if (判断条件) {

语句体;

}

执行流程 :

1. 执行判断条件, 看其返回结果是true,false

2. true : 执行 {} 中的语句体

3. false : 不执行 {} 中的语句体

注意事项 :

1. if语句 () 和 {} 之间不要写分号

2. if语句 {} 中, 如果只有一条语句, {} 可以省略不写, 不建议省略

3. if语句 () 中, 无论简单还是复杂, 只要是boolean类型的数据, 就符合语法要求

• 格式2 :

if (判断条件) {

语句体1;

} else {

语句体2;

}

执行流程:

1. 执行判断条件, 看其返回结果是true, false

2. true : 执行语句体1

3. false : 执行语句体2

public class IfTest1 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("请输入您的密码:");

int password = sc.nextInt();

if (password == 111111) {

System.out.println("密码正确");

} else {

System.out.println("密码错误");

}

}

}

• 格式3 :

if (判断条件1) {

语句体1;

} else if(判断条件2) {

语句体2;

} else if(判断条件3) {

语句体3;

}

...

else {

语句体n+1;

}

执行流程:

1. 执行判断条件1, 看其返回结果是true, false

true : 执行语句体1, 然后结束掉整个的if语句

false : 执行第二步

2. 执行判断条件2, 看其返回结果是true, false

true : 执行语句体2, 然后结束掉整个的if语句

false : ...

3. 如果所有的判断条件都不成立, 将会执行最后的else

package com.itheima.test;

import java.util.Scanner;

public class IfTest2 {

/*

需求：键盘录入考试成绩，根据成绩所在的区间，程序打印出不同的奖励机制

95 ~ 100 : 自行车一辆

90 ~ 94 : 游乐场玩一次

80 ~ 89 : 变形金刚一个

80 以下 : 挨揍

健壮性判断 : 考虑到一些边界值

*/

public static void main(String[] args) {

// 1. 键盘录入学生成绩

Scanner sc = new Scanner(System.in);

System.out.println("请输入您的成绩:");

int score = sc.nextInt();

// 2. 加入if判断, 看成绩在哪一段范围

if (score < 0 || score > 100) {

System.out.println("您的成绩输入有误!");

} else if (score >= 95 && score <= 100) {

System.out.println("自行车一辆");

} else if (score >= 90 && score <= 94) {

System.out.println("游乐场玩一次");

} else if (score >= 80 && score <= 89) {

System.out.println("变形金刚一个");

} else {

System.out.println("挨揍");

}

}

}

package com.itheima.test;

import java.util.Scanner;

public class IfTest3 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("请输入您的成绩:");

int score = sc.nextInt();

if (score >= 0 && score <= 100) {

// 成绩是正确的

// 代码进入到这个大括号, 说明成绩肯定是0~100之间, 只需要关心, 给什么奖励即可

if (score >= 95 && score <= 100) {

System.out.println("自行车一辆");

} else if (score >= 90 && score <= 94) {

System.out.println("游乐场玩一次");

} else if (score >= 80 && score <= 89) {

System.out.println("变形金刚一个");

} else {

System.out.println("挨揍");

}

} else {

System.out.println("您的成绩输入有误, 请检查是否是0~100分之间");

}

}

}

Day3:28--34

28-switch语句

• 格式 :

switch (表达式) {

case 值1:

语句体1;

break;

case 值2:

语句体2;

break;

...

default:

语句体n+1;

break;

}

• 执行流程 :

• 拿着 () 中将要匹配的值, 跟case给出的选项, 逐个进行匹配, 匹配成功, 就执行对应的语句体

• 随后由break, 结束整个switch语句

• 如果给出的所有case, 都匹配失败, 将会执行最后 default

• 注意事项 :

1. case后面的值只能是常量, 不能是变量

2. case后面的值不允许重复

3. switch语句 () 中可以接收的类型 :

A.基本数据类型 : byte short char int

B.引用数据类型 :

JDK5开始, 可以写枚举

JDK7可以, 可以写String字符串

4. 如果省略了break语句, 将会开启case穿透现象

package com.itheima.mswitch;

import java.util.Scanner;

public class SwitchDemo2 {

/*

需求: 键盘录入数值 1~5 , 程序输出工作日

6~7 , 程序输出休息日

*/

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("请输入:");

int week = sc.nextInt();

switch (week) {

case 1:

case 2:

case 3:

case 4:

case 5:

System.out.println("工作日");

break;

case 6:

case 7:

System.out.println("休息日");

break;

default:

System.out.println("您的输入有误!");

break;

}

}

}

package com.itheima.mswitch;

import java.util.Scanner;

public class SwitchDemo2 {

/*

JDK14版本开始, case后面允许编写多个值, 中间需要使用逗号分隔

*/

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("请输入:");

int week = sc.nextInt();

switch (week) {

case 1, 2, 3, 4, 5:

System.out.println("工作日");

break;

case 6, 7:

System.out.println("休息日");

break;

default:

System.out.println("您的输入有误!");

break;

}

}

}

if : 适用于范围性的判断

switch : 适用于固定值的匹配

29-for循环

• 目标 : 为什么要学习循环语句 ?

• 回答 : 需要将一段代码重复的执行很多次, 就可以使用循环语句

• for 循环语句格式 :

for(初始化语句; 判断条件; 条件控制语句){

循环体语句;

}

初始化语句 : 定义变量, 使用这个变量来控制循环

判断条件 : 根据这个判断条件, 决定循环是否要继续

循环体语句 : 要重复执行的代码

条件控制语句 : 改变控制循环的那个变量

• for 循环的执行流程 :

1. 执行初始化语句, 在整个循环过程中, 只执行一次

2. 执行判断条件, 看其返回结果是true,还是false

false : 循环结束

true : 进入第三步

3. 执行循环体语句

4. 执行条件控制语句

5. 回到2继续

..

for(int i = 1; i <= 3; i++){

System.out.println("HelloWorld");

}

package com.itheima.test;

public class ForTest1 {

/*

需求: 在控制台打印数字 1~3 和 3~1

积累思路:

1. 用于控制循环的变量, 可以在循环中, 作为一份数据, 继续使用的.

2. 循环的条件控制语句, 不要局限的认为只能是++

*/

public static void main(String[] args) {

for (int i = 1; i <= 3; i++) {

System.out.println(i);

}

System.out.println("----------------");

for (int i = 3; i >= 1; i--) {

System.out.println(i);

}

System.out.println("----------------");

for (int i = 10; i >= 1; i--) {

System.out.println("干饭倒计时:" + i + "秒");

}

System.out.println("终于等到了饭点, 干饭人干饭时间!");

}

}

package com.itheima.test;

public class ForTest2 {

/*

需求：求1-100之间的偶数和，并把求和结果在控制台输出

分析：

定义求和变量 sum，准备记录累加的结果

使用 for 循环，分别获取数据 1 – 100

循环使用 if 语句，筛选出偶数数据

将每一个偶数数据，和 sum 变量进行累加

循环结束后，打印求和后的结果

积累思路: 今后需求中, 只要是涉及求和, 就要联想到求和变量

*/

public static void main(String[] args) {

// 1. 定义求和变量 sum，准备记录累加的结果

int sum = 0;

// 2. 使用 for 循环，分别获取数据 1 – 100

for (int i = 1; i <= 100; i++) {

// i : 代表1~100之间的每一个数字

// 3. 循环使用 if 语句，筛选出偶数数据

if (i % 2 == 0) {

// 4. 将每一个偶数数据，和 sum 变量进行累加

sum += i;

}

}

// 5. 循环结束后，打印求和后的结果

System.out.println("1~100之间偶数和为:" + sum);

System.out.println("---------------------");

int result = 0;

for (int i = 2; i <= 100; i += 2) {

result += i;

}

System.out.println("1~100之间偶数和为:" + result);

}

}

package com.itheima.test;

public class ForTest5 {

/*

需求: 在控制台打印出所有的水仙花数, 要求一行, 展示两个水仙花数

153 370

371 407

打印语句的区别 :

System.out.println(); 打印数据后, 有换行效果

System.out.print(); 打印数据后, 没有换行效果

*/

public static void main(String[] args) {

// 定义计数器变量, 准备统计, 已经打印了几个水仙花数

int count = 0;

for (int i = 100; i <= 999; i++) {

int ge = i % 10;

int shi = i / 10 % 10;

int bai = i / 100;

if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {

System.out.print(i + " ");

// 每打印一个水仙花数, 计数器增长

count++;

// 判断是否增长到了偶数, 是的话, 换行

if(count % 2 == 0){

System.out.println();

}

}

}

}

}

for循环的注意事项 :

• for 循环 () 和 {} 之间不要写分号

• for 循环 {} 中定义的变量, 在每一轮循环结束, 都会从内存中释放掉

• for 循环 () 中定义的变量, 在整个循环结束后, 从内存中释放

• 因为马虎造成了无限循环 (死循环)

循环的嵌套 :

阅读循环嵌套 :

• 先看懂内循环, 再看外循环

for(int i = 1; i <= 5; i++){

for(int j = 1; j <= 3; j++){

System.out.println("Java");

}

// 内循环单独拿出来, 可以打印3次java

// 整个内循环, 又被循环了5次, 所以程序执行起来, 是15次Java的打印

}

编写循环嵌套 :

• 先将大问题, 拆解为小问题实现

• 需求 : 在控制台使用 * 打印4行5列的矩形

• 打印了1行5列的

for(int j = 1; j <= 5; j++){

System.out.print("*");

}

System.out.println();

• 然后改进为循环嵌套

for(int j = 1; j <= 5; j++){

System.out.print("*");

}

System.out.println();

for(int j = 1; j <= 5; j++){

System.out.print("*");

}

System.out.println();

for(int j = 1; j <= 5; j++){

System.out.print("*");

}

System.out.println();

for(int j = 1; j <= 5; j++){

System.out.print("*");

}

System.out.println();

-------------------------------------------------

for(int i = 1; i <= 4; i++){

for(int j = 1; j <= 5; j++){

System.out.print("*");

}

System.out.println();

}

package com.itheima.test;

public class ForTest6 {

/*

演示循环嵌套的代码 :

需求1 : 使用 * 在控制台打印4行5列的矩形

*****

*****

*****

*****

需求2 : 使用 * 在控制台打印5行的直角三角形

*

**

***

****

*****

*****

****

***

**

*

*/

public static void main(String[] args) {

// 外循环: 控制行数

for(int i = 1; i <= 5; i++){

// 内循环: 控制列数

for(int j = 1; j <= i; j++){

System.out.print("*");

}

System.out.println();

}

System.out.println("--------------------");

// 外循环: 控制行数

for(int i = 5; i >= 1; i--){

// 内循环: 控制列数

for(int j = 1; j <= i; j++){

System.out.print("*");

}

System.out.println();

}

}

}

package com.itheima.test;

public class ForTest7 {

/*

1*1=1

1*2=2 2*2=4

1*3=3 2*3=6 3*3=9

1*4=4 2*4=8 3*4=12 4*4=16

1*5=5 2*5=10 3*5=15 4*5=20 5*5=25

...

1. 打印9行9列的矩形

2. 改进9行的直角三角形

3. 改进为99乘法表

------------------------------------------------------------

*号左侧数据 : 每一行中, 都是从1开始, 逐个+1进行增长 j

*号右侧数据 : 每一行中, 右侧的数据, 都是不变的 i

\t : tab键 (制表符)

*/

public static void main(String[] args) {

for(int i = 1; i <= 9; i++){

for(int j = 1; j <= i; j++){

System.out.print(j + "*" + i + "=" + j*i + "\t");

}

System.out.println();

}

}

}

30-while循环

• 格式 :

初始化语句;

while (判断条件) {

循环体语句;

条件控制语句;

}

• 执行流程 :

1. 执行初始化语句, 在整个循环过程中, 只执行一次

2. 执行判断条件, 看其返回结果是true,还是false

false : 循环结束

true : 进入第三步

3. 执行循环体语句

4. 执行条件控制语句

5. 回到2继续

..

int i = 1;

while(i <= 5){

System.out.println("HelloWorld");

i++; // 写while循环, 不要忘记i++操作

}

31-do...while循环 (了解)

• 格式

初始化语句;

do {

循环体语句;

条件控制语句;

}while(判断条件);

int i = 1;

do {

System.out.println("HelloWorld");

i++;

}while(i <= 5);

• 特点 : 无论判断条件是否满足, 都至少执行一次循环体.

32-三种循环的区别

• for, while : 先判断, 后执行

• do...while : 先执行, 后判断

重点理解 : for循环和while循环的区别

- 两者本质来讲, 没有区别, for循环能够实现的, while都能实现, 反之也是一样.

33-跳转控制语句

• break : 结束 (终止) 循环, switch

• 只能在循环和switch语句中使用

• continue : 跳过某一次循环, 继续下一次

• 只能在循环中使用

• 两种共同的注意事项 : 语句下面不允许写代码, 因为执行不到, 属于无效的代码

• 细节 :

• 如果涉及到了循环的嵌套, break, continue, 默认只能操作到自己所在的那一层

• 如果想要精准的操作到某一层循环, 可以使用标号技术

package com.itheima.test;

import java.util.Scanner;

public class MenuTest {

/*

积累思路: 今后如果不明确循环次数, 可以选择无限循环, 再设计一个出口, 结束无限循环.

*/

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("欢迎来到学生管理系统");

lo:

while (true) {

System.out.println("请输入您的选择: 1. 添加学生 2. 删除学生 3. 修改学生 4. 查看学生 5. 退出");

int choice = sc.nextInt();

switch (choice) {

case 1:

System.out.println("添加学生");

break;

case 2:

System.out.println("删除学生");

break;

case 3:

System.out.println("修改学生");

break;

case 4:

System.out.println("查看学生");

break;

case 5:

System.out.println("感谢您的使用, 告辞!");

break lo;

default:

System.out.println("您的输入有误, 请检查是否是1~5的数字");

break;

}

}

}

}

34-Random产生随机数

• 找符咒

• 召唤精灵

• 指挥精灵产生随机数

import java.util.Random;

public class Test {

public static void main(Stirng[] args){

Random r = new Random();

int num1 = r.nextInt(100) + 1; // 1~100之间的随机数

int num2 = r.nextInt(61) + 20; // 20~80之间的随机数

}

}

package com.itheima.test;

import java.util.Random;

import java.util.Scanner;

public class RandomTest {

/*

需求: 实现猜数字小游戏

分析:

1. 指挥Random产生一个1~100之间的随机数

int randomNumber;

2. 创建Scanner键盘录入精灵, 录入用户所猜的数据

int scNumber;

3. 比较

猜大了

猜小了

猜对了

*/

public static void main(String[] args) {

Random r = new Random();

Scanner sc = new Scanner(System.in);

// 1. 指挥Random产生一个1~100之间的随机数

int randomNumber = r.nextInt(100) + 1;

while (true) {

// 2. 指挥Scanner录入用户所猜的数据

System.out.println("请输入:");

int scNumber = sc.nextInt();

// 3. 比较

if (scNumber > randomNumber) {

System.out.println("猜大了");

} else if (scNumber < randomNumber) {

System.out.println("猜小了");

} else {

System.out.println("猜对了!");

break;

}

}

System.out.println("感谢您的使用!");

}

}

Day4:35--46

35-数组介绍

• 介绍 : 数组指的是一种容器, 可以存储同种数据类型的多个值

• 同种数据类型 : 要结合着隐式转换去考虑

• 建议 : 尽量保证存储的数据, 是同一种类型.

double[] arr1 = {11.1, 22.2, 33};

System.out.println(arr1[2]); // 33.0

int[] arr = {10, 20, 'a'};

System.out.println(arr[2]); // 97

• 使用场景 :

• 发现要操作的数据有多个, 并且这多个数据属于同一组数据, 就可以考虑使用数组容器进行维护.

36-数组的定义格式

• 数据类型[] 数组名;

int[] arr;

• 数据类型 数组名[];

double arr[];

• 注意 : 以上这两种定义格式, 定义出来的, 仅仅是数组类型的变量而已

• 并没有将数组容器真正的创建出来

37-数组的静态初始化

• 初始化 : 在内存中, 为数组容器开辟空间, 并将数据存入容器的过程

• 完整格式 :

• 数据类型[] 数组名 = new 数据类型[] {元素1, 元素2, 元素3...};

int[] arr = new int[]{11,22,33};

int[] arr = new int[3]{11,22,33}; // 编译错误, 语法错误

• 简化格式 : 推荐

• 数据类型[] 数组名 = new 数据类型[] {元素1, 元素2, 元素3...};

int[] arr = {11,22,33};

细节: 简化格式, 简化的只是书写格式, 在运行的时候, 还是会按照完整格式运行.

• 细节补充 (了解) :

• 打印数组名, 会看到数组的内存地址

[I@233ac41

@ : 分隔符

[ : 当前空间是一个数组类型的空间, 几个中括号, 就是几维数组

I : 当前数组的数据类型, 是int类型

233ac41 : 十六进制内存地址

38-数组的元素访问

• 格式 :

• 数组名[索引];

• 注意 : 根据这个访问格式, 拿到的是真实的数据

• 索引介绍 : 又称之为角标, 下标

• 数组容器中, 空间所对应的编号, 编号从0开始, 逐个+1增长

39-数组的遍历操作

• 数组遍历 : 将数组中每一个元素都取出来, 进行使用

40-数组的动态初始化

• 介绍 : 在初始化数组的时候, 只需要手动指定长度, 系统就会自动分配默认初始化值.

• 格式 : 数据类型[] 数组名 = new 数据类型[长度];

int[] arr = new int[3];

理解: 创建了一个数组容器, 这个数组, 可以存储3个int类型的整数

虽然系统会分配默认初始化值 ---> 0

对于程序员来说, 这些初始化值是没有什么意义的, 所以大家可以将这个动态初始化的数组, 看做为是一个空的数组的容器.

• 默认初始化值的分类 :

• 整数 : 0

• 小数 : 0.0

• 布尔 : false

• 字符 : '\u0000' -- Unicode字符 --> 常见的体现是空白字符

• 引用数据类型 : null

• 引用数据类型 :

• 数组

• 类

• 接口

41-两种初始化的区别

区别 :

• 静态初始化 : 手动指定元素, 系统会根据元素的个数, 自动计算出长度

int[] arr = {11,22,33};

• 动态初始化 : 手动指定长度, 系统分配默认值

int[] arr = new int[3];

System.out.println(arr[0]); // 0

场景 :

• 静态初始化 : 要操作的数据, 需求中已经明确告知了, 直接静态初始化

• 需求 : 已知班级学生成绩为 100 90 80 100 20 30

int[] arr = {100,90,80,100,20,30};

• 动态初始化 : 只知道要存储几个元素, 但是不知道具体数值

42-数组内存图 (重点)

43-数组的常见问题

• 数组索引越界异常 :

• ArrayIndexOutOfBoundsException : 访问了不存在的索引

• 空指针异常 :

• NullPointerException : 当引用数据类型的变量, 被赋值为 null, 意味着和堆内存的连接被切断了

• 这时候已经找不到堆内存的的数据了, 还非要让他去访问, 就会出现空指针异常

int[] arr = {11,22,33}; // arr = [I@233ac123

arr = null;

System.out.println(arr[0]); // 引发空指针异常

44-二维数组介绍

• 介绍 : 二维数组也是一种容器, 容器中存储的都是一维数组

• 简单理解 : 容器的嵌套 (数组中存储数组)

• 二维数组的使用场景 :

• 发现要操作的数据有多组, 这多组数据还属于一个整体, 就可以考虑使用二维数组进行存储.

• 举例:

第一季度：22,66,44

第二季度：77,33,88

第三季度：25,45,65

第四季度：11,66,99

int[] arr = {22,66,44,77,33,88,25,数据...}; // 一维数组的弊端 : 需要人为的做分类了

int[][] data = {

{22, 66, 44},

{77, 33, 88},

{25, 45, 65},

{11, 66, 99}

};

45-二维数组静态初始化

• 完整格式 :

数据类型[][] 数组名 = new 数据类型[][]{ {一维数组1}, {一维数组2}... };

• 简化格式 :

数据类型[][] 数组名 = { {一维数组1}, {一维数组2}... };

• 二维数组的元素访问 :

数组名[m索引][n索引];

m索引 : 指定访问哪一个一维数组

n索引 : 指定访问一维数组中的哪一个元素

System.out.println(data[2][1]); // 45

46-二维数组的遍历操作

• 思路 :

• 先遍历二维数组, 获取每一个一维数组

• 继续遍历一维数组, 获取内部的元素

int[][] data = {

{22, 66, 44},

{77, 33, 88},

{25, 45, 65},

{11, 66, 99}

};

for(int i = 0; i < data.length; i++){

// data[i] : 每一个一维数组

for(int j = 0; j < data[i].length; j++){

System.out.println(data[i][j]);

}

}

Day5:47--53

47-二维数组的动态初始化

• 格式 :

数据类型[][] 数组名 = new 数据类型[m][n];

//能够存储两个一维数组, 每一个一维数组中可以存储3个元素

int[][] arr = new int[2][3];

48-方法介绍

• 介绍 : 方法 | 函数 (method) : 一段具有独立功能的代码块, 不调用就不执行

• 方法的好处 :

• 提高了代码的可阅读性

• 将原本挤在一起的臃肿代码, 按照功能进行分类管理

• 提高了代码的复用性

• 写好了一个方法之后, 可以对方法进行多次调用

• 问题 : 方法是否可以提高程序的执行效率 ?

• 不可以 !

49-方法的通用定义格式

public static 返回值类型 方法名 (参数列表) {

方法体;

return 结果;

}

public static : 修饰符, 目前暂时记忆

返回值类型 : 跟方法返回的结果有关系

方法名 : 见名知意, 小驼峰命名法

参数列表 : 方法运行之前所需要的材料

方法体 : 方法中真正执行的逻辑代码

return :

1). 结束方法

2). 用于将结果返还给调用者

• 设计方法的使用思路 :

1. 参数

问题: 自己这个方法中, 使用的数据, 是否有灵活性的要求 (有没有不确定性数据)

举例1: 设计一个方法, 在控制台打印10次黑马程序员 (不要)

举例2: 设计一个方法, 能够从三个小数中找出最小值 (要参数)

问题: 要参数的话, 要几个? 要什么类型的?

举例1: 设计一个方法, 能够从三个小数中找出最小值

数量: 3个 类型: double

举例2: 设计一个方法, 对数组进行求和操作(要参数)

数量: 1个 类型: int[]

2. 返回值

步骤1: 正常编写代码逻辑

步骤2: 观察自己这个方法, 是否有结果产生

没有结果 : 返回值类型写void

有结果 : 通过return语句返回, 并修改返回值类型.

50-方法的调用格式

• 带返回值方法的调用 :

1. 单独调用(不推荐)

getMax(10,20);

不推荐的原因: 方法的返回值没有接收, 数据丢失

2. 赋值调用(推荐)

int max = getMax(10,20);

推荐原因: 能够拿到真实的数据, 使用起来比较灵活

3. 输出调用(偶尔用)

System.out.println(getMax(10,20));

场景: 测试代码逻辑是否正确

• 不带返回值方法的调用 (void) :

只能单独调用!!!

51-方法的常见问题

• 方法不调用就不执行

• 方法与方法之间是平级关系, 不能嵌套定义

• 方法的编写顺序和执行顺序无关, 要想梳理执行顺序, 就看调用顺序

• 方法的返回值类型为void, 表示此方法没有返回值的, 可以省略return语句不写

• 非要写的话, 只能写成 return;

• return语句后面不能写代码, 因为执行不到, 属于无效代码

• 如果一个方法有明确的返回值, 一定要通过return语句带回结果, 无论什么情况下

public static int getMax(int a, int b) {

if (a > b) {

return a;

} else if (b > a) {

return b;

}

// 编译错误, 编译器认为, 代码中的两个return语句, 都被条件所控制

// 如果条件都不成立, 此方法将没有return可以执行.

}

52-方法重载 (Overload)

• 介绍 : 方法与方法之间的一种关系

• 目标1 : 能够独立识别出, 方法与方法之间, 是否是正确的重载关系

在同一个类中, 方法名相同, 参数不同, 与返回值无关

参数不同:

1. 个数不同

2. 类型不同

3. 顺序不同

• 目标2 : 能够理解方法重载带来的好处

- 不需要记忆过多繁琐的方法名字了

- 假设没有方法重载

printInt(10);

printDouble(12.3);

printString("abc");

- 有方法重载

println(10);

println(12.3);

println("abc");

在调用方法的时候, JVM虚拟机会根据实际参数的类型, 自动进行匹配

53-方法面试题

方法的参数传递问题 :

基本数据类型 : 传递的是数据值

引用数据类型 : 传递的是地址值

方法内存图:

Day7:54--62

54-面向对象介绍

面向对象并非是一个技术, 而是一种编程的思想

这种思想可以指导我们以什么思路解决问题, 以什么思路来组织代码

问题 : 为什么要学习这种思想 ?

因为这套思想, 来源于生活, 生活中解决问题, 就是一系列的对象, 在一起打交道, 从而将问题解决.

所以我们希望写代码解决问题的时候, 也能按照生活中的这种思想

这样的话, 编程就会更加贴切于生活, 程序也会更加便于让人理解.

举例1: 解决随机数的问题 ---> Random对象

举例2: 解决键盘录入的问题 ---> Scanner对象

举例3: 封装学生数据 ---> Student对象

面向对象我们学什么 ?

学习自己如何设计对象

学习已有的对象如何使用 (API章节)

万物皆对象

生活中的任何一种事物, 都可以通过代码, 将其描述为对象

55-类和对象

• 前提 : Java中想要创建对象, 必须现有类的存在

• 类的介绍 :

• 一组相关属性和行为的集合, 将其理解为是对象的一张设计图

• 对象的介绍 :

• 对象是根据类 (设计图), 创建出来的实体

• 类和对象的关系 :

• 依赖关系 : 需要根据类, 创建对象

• 数量关系 : 根据一个类, 可以创建出多个对象

• 类的组成 :

属性 : 在代码中使用成员变量表示, 成员变量跟之前定义变量的格式一样, 只不过位置发生了改变 (类中方法外)

行为 : 在代码中使用成员方法表示, 成员方法跟之前定义方法的格式一样, 只不过去掉了 static 关键字

• 类的设计

• 知道什么设计为属性, 什么设计为行为

- 描述事物的一些[名词], 设计为属性

- 描述事物的一些[动词], 设计为行为

举例1: 我有一个{学生}叫做<张三>, 今年<23岁>, <180的身高>, 平时没什么特殊爱好, 就喜欢(吃饭)和(学习).

举例2: 前阵子我买了一台<白色>的<海尔>{洗衣机}, 花了<1999块钱>, (洗衣服)和(甩干)确实方便.

• 对象的创建和使用

• 思路 : 当对象创建完毕后, 调用内部的成员, 都是拿着对象名 . 出来的

创建对象的格式 : 类名 对象名 = new 类名();

Student stu = new Student();

System.out.println(stu); // com.itheima.oop.Student@233ac477

使用对象成员变量的格式 : 对象名.变量名;

stu.name = "张三";

stu.age = 23;

System.out.println(stu.name);

System.out.println(stu.age);

使用对象成员方法的格式 : 对象名.方法名();

stu.eat();

stu.study();

• 细节补充 :

1. 我们在定义类的时候, 成员变量通常不赋值.

(等对象创建完毕后, 再给成员变量赋值)

2. 成员变量没有赋值, 也可以直接使用, 使用的是默认值

56-对象的内存图

单个对象内存图

两个对象内存图

两个引用指向相同内存图

57-成员变量和局部变量的区别

• 类中位置不同 :

• 成员变量 : 方法外

• 局部变量 : 方法内

• 初始化值不同 :

• 成员变量 : 有默认初始化值

• 局部变量 : 没有默认初始化值, 使用之前必须完成赋值

• 内存位置不同 :

• 成员变量 : 堆内存

• 局部变量 : 栈内存

• 生命周期不同 :

• 成员变量 : 随着对象的创建而存在, 随着对象的消失而消失

• 局部变量 : 随着方法的调用而存在, 随着方法的运行结束而消失

• 作用域 :

• 都在自己所属的大括号中有效

58-this关键字

• 情况 : 当局部变量和成员变量重名

• Java会根据就近原则, 优先使用局部变量

• 问题 : 非要使用成员变量, 怎么办 ?

• 回答 : 使用this关键字进行区分

class Student {

int num = 10;

public void show(){

int num = 20;

System.out.println(num); // 20

System.out.println(this.num); // 10

}

}

• this可以解决的问题 : 区分局部变量和成员变量的重名问题

• this的作用 :

this可以调用自己本类的成员

this.本类成员变量;

this.本类成员方法();

-------------------------------------------------

省略规则 :

this.本类成员方法() : this.可以直接省略

this.本类成员变量 : 如果局部变量和成员变量没有重名, this.可以省略不写

class Student {

int num = 10;

public void show(){

System.out.println(this.num); // 10

this.print();

}

public void print(){

...

}

}

59-构造方法

• 介绍 : 构造方法又名构造器

• 构建, 创造一个对象要调用的方法

• 简单记 : 构造方法就是用于创建对象的方法

• 格式 :

1. 方法名与类名相同, 大小写也要一致

2. 没有返回值类型, 连 void 都没有

3. 没有具体的返回值 (不能通过 return 语句带回结果数据)

public class Student {

public Student(){

System.out.println("我是Student类的空参数构造方法");

}

}

• 构造方法的执行时机 :

• 在创建对象的时候, 被调用执行

• 每创建一次对象, 就会执行一次构造方法

• 构造方法的作用 :

• 本质作用 : 用来创建对象

• 结合执行时机 : 在创建对象的时候, 给成员变量初始化

public class Student {

String name;

int age;

public Student(String name, int age){

this.name = name;

this.age = age;

}

}

Student stu = new Student("张三", 23);

• 构造方法的注意事项 :

• 如果一个类中没写构造方法, 系统将会给出一个 [默认的] [无参数的] 构造方法

• 如果手动编写了构造方法, 系统就不会给出那个默认的无参构造了

• 建议 : 无参构造, 带参构造, 全部手动给出.

• 构造方法不允许手动调用

• stu.Student(); 错误调用

60-封装思想(重点)

• 面向对象有三大特征 :

• 封装

• 继承

• 多态

• 封装思想介绍 :

• 隐藏实现细节, 仅对外暴露公共的访问方式

• 结合插线板理解

• 封装在代码中常见的体现 :

• 将属性抽取到类中, 是对数据做了封装

使用封装前 : 维护一个用户信息, 定义了5个变量, 数据过于零散

String id = "001";

String name = "张三";

int age = 23;

String tel = "156****1234";

String address = "北京";

----------------------------------------------------------

使用封装后 : 5个零散的数据, 就被封装到了一个整体的对象中

public class User {

String id;

String name;

int age;

String tel;

String address;

// 假设我写了带参数构造方法

}

User u1 = new User("001","张三",23,"156****1234", "北京");

User u2 = new User("002","李四",23,"156****1244", "北京");

• 将代码抽取到方法中, 是对代码功能进行了封装

程序员A : 编写了一个遍历打印数组的方法

public void printArray(int[] arr){

...

}

程序员B : 无需关心方法内部实现, 只要知道怎么调用即可.

以上过程, 就是程序员A, 将遍历打印数组这个功能代码, 封装到了printArray方法中.

61-权限修饰符

• private : 同一个类中

• (defualt) : 同一个类中, 同一个包中

• protected : 就业班

• public : 任意位置

62-标准JavaBean(重点)

• 所有成员变量 private 私有

• 提供空参\带参构造方法

• 对于私有的成员变量, 提供对应的setXxx和getXxx方法

package com.itheima.test;

/*

标准 JavaBean :

1. 成员变量全部private私有

2. 提供空参\带参构造方法

3. 提供对应的setXxx和getXxx方法

*/

public class Student {

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;

}

}

package com.itheima.test;

public class StudentTest {

public static void main(String[] args) {

// 1. 空参构造创建对象, 通过setXxx方法完成赋值

Student stu1 = new Student();

stu1.setName("张三");

stu1.setAge(23);

System.out.println(stu1.getName() + "---" + stu1.getAge());

// 2. 带参构造方法创建对象, 在创建的时候直接赋值

Student stu2 = new Student("李四", 24);

System.out.println(stu2.getName() + "---" + stu2.getAge());

// 重点强调: getXxx方法, 能够得到的是真实的数据, 使用方式, 不要局限在打印语句上

for(int i = 1; i <= stu2.getAge(); i++){

System.out.println("祝福" + stu2.getName() + "生日快乐!");

}

}

}

Day8:63--72

63-API介绍

API帮助文档的使用流程 :

1. 在索引位置搜索自己要查看的类

问题: 我怎么知道该搜哪一个类?

回答: 常用的类, 在课程中都会讲解到.

2. 看包

目的: 看使用的类, 是否在java.lang包 (核心包)

在 : 不需要编写import导包代码

不在 : 必须编写import导包代码

3. 看该类的介绍

目的: 知道这个类能够解决什么问题.

4. 看该类的构造方法

目的: 能够根据构造方法, 将对象创建出来

5. 看该类的成员方法(方法摘要)

① 方法名

② 参数

③ 返回值

④ 介绍

64-String类的特点

1. Java程序中, 所有双引号字符串, 都是String这个类的对象

- String类, 多了一种创建对象的方式

2. String字符串, 一旦被创建, 就[不可改变]

- 不可改变: 字符串内容不能改变, 要想做修改, 只能使用新的对象做替换.

String s = "abc";

s = "def";

System.out.println(s); // def

3. 字符串虽然不可改变, 但是其内容可以被共享

- 字符串常量池: 当使用双引号创建字符串对象的时候, 会检查常量池中是否存在该数据

没有 : 创建

有 : 复用

String s1 = "abc";

String s2 = "abc";

System.out.println(s1 == s2); // true

4. 字符串和字符数组之间允许相互转换

char[] chs = {'a','b','c'}; <-----------> String s = "abc";

字符串数组转换字符串

String s = new String(chs);

字符串拆分为字符数组

char[] chs = s.toCharArray();

65-String类的常用构造方法

1. public String() : 创建一个空白的字符串对象

2. public String(char[] chs) : 根据传入的字符数组, 来创建字符串对象

3. public String(String s) : 根据传入的字符串, 来创建字符串对象

细节: 打印字符串对象, 为什么没有地址值?

- TODO: 就业班 (继承, 方法重写, Object, toString())

- 请先暂时记住, 打印字符串对象名, 直接展示内容, 并非地址值.

想法: 这三种创建方式, 都没有双引号直接创建, 来的方便

String s = "abc";

66-创建字符串对象, 两种方式的区别

内存图

注意

字符串常量池:

jdk8前:在方法区中

jdk8后:在堆内存中

67-字符串面试题

package com.itheima.test;

public class StringTest1 {

/*

String常见面试题 (看程序, 说结果, 并说明原因)

*/

public static void main(String[] args) {

String s1 = "abc";

String s2 = "a" + "b" + "c";

System.out.println(s1 == s2);

}

private static void method3() {

String s1 = "abc";

String s2 = "ab";

String s3 = s2 + "c";

System.out.println(s1 == s3);

}

private static void method2() {

String s1 = "abc";

String s2 = new String("abc");

System.out.println(s1 == s2);

}

private static void method1() {

String s1 = "abc";

String s2 = "abc";

System.out.println(s1 == s2);

}

}

68-String类成员方法

字符串中用于比较的方法 :

public boolean equals(String anObject) :

字符串之间进行内容的比较, 返回true, false

public boolean equalsIgnoreCase(String anotherString) :

字符串之间进行内容的比较, 返回true, false (不考虑大小写)

public boolean isEmpty():

判断字符串是否为空字符串

public boolean startsWith(String):

是否以指定前缀开头

public boolean endsWith(String):

是否以指定后缀结尾

字符串转字符数组的方法 :

public char[] toCharArray() :

将此字符串转换为一个新的字符数组

public byte[] getBytes():

返回字符串的字节数组

字符串用于遍历方法 :

public char charAt(int index) :

根据索引找字符

public int length() :

返回字符串的长度(字符的个数)

public int indexOf(String):

从左到右获取第一次出现的指定字符的下标位置,-1表示没有该字符串

public int indexOf(String,int):

从指定位置开始,从左到右获取第一次出现的....

public int lastIndexOf(String):

从右到左获取....

字符串用于截取方法 :

public String substring(int beginIndex) :

根据传入的索引, 截取字符串, 截取到字符串的末尾, 返回新的字符串

public String substring(int beginIndex, int endIndex) :

根据传入的开始和结束索引, 截取字符串 (包含头, 不包含尾), 返回新的字符串

字符串用于替换方法 :

public String replace(String target, String replacement) :

参数1: 旧值

参数2: 新值

字符串用于切割的方法 :

public String[] split(String regex) :

根据传入的字符串作为规则, 切割当前字符串, 并返回字符串数组.

注意: 指定切割规则的时候, 如果没有按照预想的切割出数据

可以在规则前面, 加入 \\

字符串中用于拼接的方法:

String.join(String 连接符,String... ):连接字符串

public String concat(String):

字符串拼接

字符串中用于处理乱码的方法:

new String(name.getBytes("ISO8859-1"), "UTF-8");

处理乱码

public String toLowerCase():

全转小写

public String toUpperCase():

全转大写

public String trim():

左右去空格

69-StringBuilder的介绍

• 问题 : 为什么要学习StringBuilder ?

• 回答 : 因为StringBuilder可以大幅度提升字符串的操作效率

• 场景 : 如果今后涉及到字符串的拼接操作, 拼接次数过于频繁, 请一定要使用StringBuilder

• 介绍 :

• StringBuilder是可变的字符序列

• StringBuilder又叫做字符串缓冲区 (容器), 这个容器可以存储任意数据类型

• 但是数据只要进入这个容器, 全部变成字符串.

70-StringBuilder的常用构造方法

public StringBuilder() :

创建一个空白的字符串缓冲区, 其初始容量为16个字符

public StringBuilder(String str) :

创建一个字符串缓冲区 (容器), 容器在被创建出来的时候, 就会带有参数数据.

71-StringBuilder的常用成员方法

public StringBuilder append(任意类型) :

向缓冲区中, 添加数据, 返回自己这个对象本身

链式编程: 如果一个方法调用结束, 返回的结果是对象, 就可以继续向下调用方法.

sb.append("红色").append("绿色").append("蓝色");

public StringBuilder reverse() :

将缓冲区中的内容进行反转, 返回自己这个对象本身

public int length() :

返回字符的个数

public String toString() :

将缓冲区中的内容转换为字符串, 并返回

public StringBuilder delete(int from,int end):

删除指定范围字符串,不包含end

public StringBuilder deleteCharAt(index):

删除指定下标的字符串

public StringBuilder insert(int,String):

指定位置插入字符串

72-String和StringBuilder的转换

1. String ---> StringBuilder

场景: 手里的数据是一个String, 但是我要调用的方法, String没有, StringBuilder有, 转换后再调用 !!

1). 使用StringBuilder的空参构造方法, 创建对象, 调用append方法完成添加

String s = "abc";

StringBuilder sb = new StringBuilder();

sb.append(s);

2). 使用StringBuilder的带参构造方法

String s = "abc";

StringBuilder sb = new StringBuilder(s);

2. StringBuilder ---> String

场景: 手里的数据是一个StringBuilder, 但是我要调用的方法, StringBuilder没有, String有, 转换后再调用 !!

1). 调用toString方法

StringBuilder sb = new StringBuilder();

String s = sb.toString();

Day9:73--76

73-集合介绍

什么是集合?

集合就是一种容器 ,类似于数组

问题 : 和数组有什么区别 ?

长度 :

数组的长度是固定的

集合的长度是可变的

存储 :

数组可以存储基本数据类型, 也可以存储引用数据类型.

集合只能存储引用数据类型, 如果想要存储基本数据类型, 需要使用对应的包装类

包装类:

byte Byte

short Short

int Integer ***

long Long

float Float

double Double

char Character ***

boolean Boolean

什么时候使用集合容器 ?

如果要存储数据的个数, 是经常发生改变的, 推荐使用集合容器.

74-集合容器的创建与添加

创建集合

ArrayList<String> list = new ArrayList<>();

<> : 泛型, 目前对于泛型的理解, 可以对集合中存储的数据类型进行限制

- 泛型类, 泛型方法, 泛型接口, 泛型通配符, 泛型的上下限定..

向集合中添加元素

public boolean add(元素) :

向集合的尾部添加元素, 返回是否添加成功的状态 (返回一般来说, 都不接收)

public void add(int index, 元素);

在指定的索引位置添加对应的元素 (插队添加)

打印集合的名字, 不会出现内存地址, 而是会看到元素的内容

ArrayList<String> list = new ArrayList<>();

list.add("abc");

list.add("123");

System.out.println(list);

// [abc, 123]

75-ArrayList常用的增删改查方法

增:

public boolean add(E e) :

向集合的尾部添加元素, 并返回是否添加成功的状态.

public boolean add(int index, E element) :

可以在指定的索引位置, 添加对应的元素 (插队)

删:

public E remove(int index) :

根据传入的索引, 删除集合中元素, 返回被删除的那个元素.

public boolean remove(Object o) :

根据元素删除, 返回是否删除成功的状态

改:

public E set(int index, E element) : 修改指定索引位置, 为对应的元素.

返回被覆盖掉的元素.

以上方法虽然存在返回值, 但返回的结果对我们来说, 意义不大, 可以不做接收.

查:

public int size() :

返回集合中元素的个数

public E get(int index) :

根据索引, 获取集合中的元素

76-集合内存运行图