第01天 java基础知识
今日内容介绍
Java概述、helloworld案例
工具安装 、配置环境变量、注释、关键字
常量、变量、数据类型、标识符
第1章Java概述
1.1Java语言发展史和平台概述
A:Java语言发展史
詹姆斯·高斯林（James Gosling）1977年获得了加拿大卡尔加里大学计算机科学学士学位，1983年获得了美国卡内基梅隆大学计算机科学博士学位，毕业后到IBM工作，设计IBM第一代工作站NeWS系统，但不受重视。后来转至Sun公司，1990年，与Patrick，Naughton和Mike Sheridan等人合作“绿色计划”，后来发展一套语言叫做“Oak”，后改名为Java。
SUN(Stanford University Network，斯坦福大学网络公司)
B:Java语言版本
* JDK 1.1.4 Sparkler 宝石 1997-09-12
* JDK 1.1.5 Pumpkin 南瓜 1997-12-13
* JDK 1.1.6 Abigail 阿比盖尔–女子名 1998-04-24
* JDK 1.1.7 Brutus 布鲁图–古罗马政治家和将军 1998-09-28
* JDK 1.1.8 Chelsea 切尔西–城市名 1999-04-08
* J2SE 1.2 Playground 运动场 1998-12-04
* J2SE 1.2.1 none 无 1999-03-30
* J2SE 1.2.2 Cricket 蟋蟀 1999-07-08
* J2SE 1.3 Kestrel 美洲红隼(sǔn) 2000-05-08
* J2SE 1.3.1 Ladybird 瓢虫 2001-05-17
* J2SE 1.4.0 Merlin 灰背隼 2002-02-13
* J2SE 1.4.1 grasshopper 蚱蜢 2002-09-16
* J2SE 1.4.2 Mantis 螳螂 2003-06-26
* JAVASE 5.0 (1.5.0) Tiger 老虎
* JAVASE 5.1 (1.5.1) Dragonfly 蜻蜓
* JAVASE 6.0 (1.6.0) Mustang 野马
* JAVASE 7.0 (1.7.0) Dolphin 海豚
1.2JVM,JRE,JDK的概述
1.2.1什么是跨平台?
平台：指的是操作系统(Windows，Linux，Mac)
跨平台：Java程序可以在任意操作系统上运行，一次编写到处运行
原理：实现跨平台需要依赖Java的虚拟机 JVM （Java Virtual Machine）
1.2.2JVM JRE JDK说明
A:什么是JVM
JVM是java虚拟机(JVM Java Virtual Machine)，java程序需要运行在虚拟机上，不同平台有自己的虚拟机，因此java语言可以跨平台
B:什么是JRE
包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。
JRE:JVM+类库。
C:什么是JDK
JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。所以安装了JDK，就不用在单独安装JRE了。
其中的开发工具：编译工具(javac.exe) 打包工具(jar.exe)等
JDK:JRE+JAVA的开发工具。
D:为什么JDK中包含一个JRE
为什么JDK中包含一个JRE呢？
开发完的程序，需要运行一下看看效果。
E:JDK,JRE,JVM的作用和关系
JDK包含JRE 和开发工具包
JRE 包含 核心类库和JVM
1.3常用dos命令
1.3.1打开控制台
–win + R，然后cmd回车
1.3.2常用命令
–d: 回车 盘符切换
–dir(directory):列出当前目录下的文件以及文件夹
–cd (change directory)改变指定目录(进入指定目录)
•进入 cd 目录；cd 多级目录
•回退 cd… ；cd
–cls : (clear screen)清屏
–exit : 退出dos命令行
1.4下载安装JDK
请参考《JDK下载安装文档.doc》安装步骤
1.5helloworld案例
1.5.1执行流程
1.5.2编写代码步骤
首先定义一个类
public class 类名
在类定义后加上一对大括号
{}
在大括号中间添加一个主(main)方法/函数
public static void main(String [] args){ }
在主方法的大括号中间添加一行输出语句
System.out.println(“HelloWorld”);
1.5.3案例代码一
public class HelloWorld {
public static void main(String[] args) {
System.out.println(“HelloWorld”);
}
}
运行代码步骤：
•在命令行模式中，输入javac命令对源代码进行编译，生成字节码文件
–javac 源文件名.java
•编译完成后，如果没有报错信息，输入java命令对class字节码文件进行解释运行,执行时不需要添加.class扩展名
–java HelloWorld
1.5.4HelloWorld案例常见问题
A:找不到文件(都演示一下，让学生看看出现的都是什么问题)
a:文件扩展名隐藏导致编译失败
b:文件名写错了
B:单词拼写问题(都演示一下，让学生看看出现的都是什么问题)
a:class写成Class
b:String写成string
c:System写成system
d:main写成mian
C:括号匹配问题(都演示一下，让学生看看出现的都是什么问题)
a:把类体的那对大括号弄掉一个
b:把方法体的那对大括号弄掉一个
c:把输出语句的那对小括号弄掉一个
D:中英文问题(都演示一下，让学生看看出现的都是什么问题)
a:提示信息：错误: 非法字符: ???的格式
注意：java编程中需要的基本上都是英文字符
第2章环境配置
2.1工具安装
2.1.1Notepad软件的安装和配置
为了让我们写的程序错误看起来更直接，我们安装一款高级记事本软件。
Notepad软件的安装和配置
设置 – 首选项 – 新建 – 默认语言和编码
2.2环境变量配置
2.2.1案例说明
为什么要配置
–程序的编译和执行需要使用到javac和java命令，所以只能在bin目录下写程序
–实际开发中，不可能把程序写到bin目录下，所以我们必须让javac和java命令在任意目录下能够访问
如何配置
–创建新的变量名称：JAVA_HOME
计算机-右键属性-高级系统设置-高级-环境变量-系统变量
–为JAVA_HOME添加变量值：JDK安装目录
–在path环境变量最前面添加如下内容
%JAVA_HOME%\bin;
2.3注释
2.3.1注释概述
A: 什么是注释
–用于解释说明程序的文字
B: Java中注释分类
单行注释
–格式： //注释文字
多行注释
–格式： /* 注释文字 /
文档注释
–格式：/* 注释文字 /
C: 注释的作用
a:解释说明程序
b:帮助我们调试错误
2.3.2案例代码二
/
注释：用于解释说明程序的文字
分类：
单行
多行
作用：解释说明程序，提高程序的阅读性
*/
//这是我的HelloWorld案例
public class HelloWorld {
/*
这是main方法
main是程序的入口方法
所有代码的执行都是从main方法开始的
/
public static void main(String[] args) {
//这是输出语句
System.out.println(“HelloWorld”);
}
}
2.4关键字
2.4.1关键字概述
–被Java语言赋予特定含义的单词
2.4.2关键字特点
–组成关键字的字母全部小写
–常用的代码编辑器,针对关键字有特殊的颜色标记，非常直观，所以我们不需要去死记硬背，在今后的学习中重要的关键字也会不断的出来。
2.4.3案例代码三:
/
关键字：被Java语言赋予特定含义的单词
特点：
A:组成关键字的字母全部小写
B:常见的代码编辑器,针对关键字有特殊的颜色标记
*/
public class HelloWorld {
public static void main(String[] args) {
System.out.println(“HelloWorld”);
}
}
关键字举例:
第3章语法格式
3.1常量
3.1.1常量概述
–在程序执行的过程中，其值不可以发生改变的量
3.1.2常量分类
–字符串常量 用双引号括起来的内容(“HelloWorld”)
–整数常量 所有整数(12,-23)
–小数常量 所有小数(12.34)
–字符常量 用单引号括起来的内容(‘a’,’A’,’0’)
–布尔常量 较为特有，只有true和false
–空常量 null(数组部分讲解)
3.1.3案例代码四:
/*
常量：在程序执行的过程中，其值不可以发生改变的量
常量分类：
A:字符串常量 "HelloWorld"
B:整数常量 12,-23
C:小数常量 12.34
D:字符常量 'a','0'
E:布尔常量 true,false
F:空常量 null(后面讲解)
*/
public class ChangLiang {
public static void main(String[] args) {
//字符串常量
System.out.println(“HelloWorld”);
//整数常量
System.out.println(12);
System.out.println(-23);
//小数常量
System.out.println(12.34);
//字符常量
System.out.println('a');
System.out.println('0');
//布尔常量
System.out.println(true);
System.out.println(false);
}
}
3.2变量
3.2.1变量概述
–在程序执行的过程中，在某个范围内其值可以发生改变的量
–从本质上讲，变量其实是内存中的一小块区域
3.2.2变量定义格式
–数据类型 变量名 = 初始化值;
–注意：格式是固定的，记住格式，以不变应万变
3.2.3变量图解
3.3数据类型
3.3.1计算机存储单元
变量是内存中的小容器，用来存储数据。那么计算机内存是怎么存储数据的呢？无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位（bit）”，我们又称之为“比特位”，通常用小写的字母b表示。而计算机最小的存储单元叫“字节（byte）”，通常用大写字母B表示，字节是由连续的8个位组成。
除了字节外还有一些常用的存储单位，大家可能比较熟悉，我们一起来看看：
–1B（字节） = 8bit
–1KB = 1024B
–1MB = 1024KB
–1GB = 1024MB
–1TB = 1024GB
3.3.2数据类型概述和分类
A:为什么有数据类型
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间
B:Java中数据类型的分类
基本数据类型
引用数据类型
面向对象部分讲解
3.4标识符
3.4.1标识符概述
A 作用
–给包,类,方法,变量等起名字
B 组成规则
–由字符，下划线_，美元符$组成
•这里的字符采用的是unicode字符集，所以包括英文大小写字母，中文字符，数字字符等。
–注意事项
–不能以数字开头
–不能是Java中的关键字
C : 命名原则:见名知意
a包
最好是域名倒过来,要求所有的字母小写
b类或者接口
如果是一个单词首字母大写
如果是多个单词每个单词首字母大写(驼峰标识)
c方法或者变量
如果是一个单词全部小写
如果是多个单词,从第二个单词首字母大写
d常量
如果是一个单词,所有字母大写
如果是多个单词,所有的单词大写,用下划线区分每个单词
3.4.2案例代码五
/*
标识符：就是给包,类,方法,变量起名字的符号。
组成规则：
A:unicode字符
数字字符,英文大小写,汉字(不建议使用汉字)
B:下划线_
C:美元符$
注意事项
A:不能以数字开头
B:不能是java中的关键字
常见命名规则：
A:基本要求
见名知意
B:常见的命名
a:包(其实就是文件夹,用于对类进行管理)
全部小写,多级包用.隔开
举例：com，com.itheima
b:类
一个单词首字母大写
举例：Student,Car
多个单词每个单词的首字母大写
举例：HelloWorld
c:方法和变量
一个单词首字母小写
举例：age,show()
多个单词从第二个单词开始每个单词的首字母大写
举例：maxAge,getAge()
*/
public class BiaoZhiFu {
public static void main(String[] args) {
//定义变量
//数据类型 变量名 = 初始化值;
int a = 10;
//正确
int b2 = 20;
//错误
//int 2b = 30;
//不能是java中的关键字
//错误
//int public = 40;
}
}
3.5定义变量
3.5.1基本数据类型变量的定义和使用
变量的定义格式：
数据类型 变量名 = 初始化值;
基本数据类型：
byte,short,int,long,float,double,char,boolean
注意：
整数默认是int类型，定义long类型的数据时，要在数据后面加L。
浮点数默认是double类型，定义float类型的数据时，要在数据后面加F。
3.5.2案例代码六
public class VariableDemo {
public static void main(String[] args) {
//定义byte类型的变量
byte b = 10;
System.out.println(10);
System.out.println(b);
//定义short类型的变量
short s = 100;
System.out.println(s);
//定义int类型的变量
int i = 10000;
System.out.println(i);
//定义long类型的变量
long l = 1000000000000000L;
System.out.println(l);
//定义float类型的变量
float f = 12.34F;
System.out.println(f);
//定义double类型的变量
double d = 12.34;
System.out.println(d);
//定义char类型的变量
char c = 'a';
System.out.println(c);
//定义boolean类型的变量
boolean bb = false;
System.out.println(bb);
}
}
3.5.3变量定义的注意事项
•变量未赋值,不能直接使用
–引出变量的第二种使用格式
•变量只在它所属的范围内有效。
–变量在哪对大括号内，变量就属于哪对大括号
•一行上可以定义多个变量，但是不建议
3.5.4案例代码七
/*
变量定义注意事项：
1:变量未赋值,不能直接使用
2:变量只在它所属的范围内有效
变量属于它所在的那对大括号
3:一行上可以定义多个变量,但是不建议
*/
public class VariableDemo2 {
public static void main(String[] args) {
//定义变量
int a = 10;
System.out.println(a);
int b;
b = 20; //变量在使用前赋值都是可以的
System.out.println(b);
{
int c = 100;
System.out.println(c);
}
//System.out.println(c);
/*
int aa,bb,cc;
aa = 10;
bb = 20;
cc = 30;
*/
/*
int aa = 10;
int bb = 20;
int cc = 30;
*/
int aa=10,bb=20,cc=30;
}
}
3.6数据类型转换
3.6.1隐式数据类型转换
取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算
3.6.2案例代码八
/*
+:是一个运算符，做加法运算的。
我们在做运算的时候，一般要求参与运算的数据类型必须一致。
类型转换：
隐式转换
强制转换
隐式转换
byte,short,char -- int -- long -- float -- double
*/
public class TypeCastDemo {
public static void main(String[] args) {
//直接输出了运算的结果
System.out.println(3 + 4);
//定义两个int类型的变量
int a = 3;
int b = 4;
int c = a + b;
System.out.println(c);
//定义一个byte类型,定义一个int类型
byte bb = 2;
int cc = 5;
System.out.println(bb + cc);
//我能不能不直接输出，用一个变量接受呢?
//用变量接受，这个变量应该有类型
//可能损失精度
//byte dd = bb + cc;
int dd = bb + cc;
System.out.println(dd);
}
}
3.6.3强制类型数据转换
强制转换的格式
* b = (byte)(a + b);
强制转换的注意事项
* 如果超出了被赋值的数据类型的取值范围得到的结果会与你期望的结果不同
3.6.4案例代码九
/*
强制转换：
目标类型 变量名 = (目标类型) (被转换的数据);
不建议强制转换，因为会有精度的损失。
*/
public class TypeCastDemo2 {
public static void main(String[] args) {
int a = 3;
byte b = 4;
int c = a + b;
//byte d = a + b;
byte d = (byte) (a + b);
}
}
第02天 java基础知识
今日内容介绍
Eclipse的安装、配置及使用
运算符
键盘录入
第4章Eclipse开发工具
4.1Eclipse概述和安装
Eclipse是一个IDE(集成开发环境)IDE(Integrated Development Environment)
集成了代码编写功能，分析功能，编译功能，调试功能等一体化的开发软件。
Eclipse的特点描述：免费、纯Java语言编写、免安装、扩展性强
下载和安装、下载 http://eclipse.org/
安装：绿色版、解压就可以使用(Eclipse)
4.2Eclipse的基本使用
4.2.1Eclipse基本操作
选择工作空间
工作空间 其实就是我们写的源代码所在的目录
用Eclipse来完成一个HelloWorld案例
A:创建Java项目：点击File或者在最左侧空白处，选择Java项目，在界面中写一个项目名称，然后Finish即可。
B:创建包：展开项目，在源包src下建立一个包com.itheima
C:创建类：在com.ithiema包下建立一个类HelloWorld
在界面中写一个类名：HelloWorld，然后finish即可。
D:编写代码：在HelloWorld类写main方法，在main方法中写
一条输出语句：我是黑马程序员，我骄傲，我自豪。
E:编译：自动编译，在保存的那一刻帮你做好了
F:运行 选择要运行的文件或者在要运行的文件内容中
右键 – Run as - Java Application即可
4.2.2代码案例一
package com.itheima;
public class HelloWorld {
public static void main(String[] args) {
System.out.println(“我是黑马程序员,我骄傲,我自豪”);
}
}
4.3Eclipse工作空间的基本配置
A:行号的显示和隐藏
显示：在代码区域的最左边的空白区域，右键 – Show Line Numbers即可。
隐藏：把上面的动作再做一次。
B:字体大小及颜色
a:Java代码区域的字体大小和颜色：
window – Preferences – General – Appearance – Colors And Fonts – Java – Java Edit Text Font
b:控制台
window – Preferences – General – Appearance – Colors And Fonts – Debug – Console font
c:其他文件
window – Preferences – General – Appearance – Colors And Fonts – Basic – Text Font
C:窗体给弄乱了，怎么办?
window – Perspective – Reset Perspective
D:控制台找不到了，怎么办?
Window–Show View—Console
4.4Eclipse中辅助键和快捷键的使用
4.4.1常用辅助键和快捷键概述
内容辅助键 alt+/
main 然后alt+/
syso 然后alt+/
快捷键
注释
单行 选中内容，ctrl+/, 再来一次取消
多行 选中内容，ctrl+shift+/, ctrl+shift+
格式化 ctrl+shift+f
4.4.2代码案例二
package com.itheima_02;
/*
- 内容辅助键：alt+/
-
A:main方法 -
main,然后alt+/,回车 -
B:输出语句 -
syso,然后然后alt+/,回车 - 快捷键：
-
A:注释 -
单行 选中内容，ctrl+/,再来一次就是取消 -
多行 选择内容，ctrl+shift+/,ctrl+shift+\ -
B:格式化 -
ctrl+shift+f
*/
public class HelloWorld {
public static void main(String[] args) {
System.out.println(“HelloWorld1”);
System.out.println(“HelloWorld2”);
System.out.println(“HelloWorld3”);
System.out.println(“HelloWorld4”);
System.out.println(“HelloWorld5”);
}
}
4.5Eclipse中项目的删除和导入
A:删除项目
选中项目 – 右键 – 删除
从项目区域中删除
从硬盘上删除
B:导入项目
在项目区域右键找到import
找到General，展开，并找到
Existing Projects into Workspace
点击next,然后选择你要导入的项目
注意：这里选择的是项目名称
第5章运算符
5.1算数运算符
•运算符
对常量和变量进行操作的符号称为运算符
•表达式
用运算符把常量或者变量连接起来符号java语法的式子就可以称为表达式。不同运算符连接的式子体现的是不同类型的表达式。
定义两个int类型的变量a,b，做加法(a + b)
•常用运算符
算术运算符
赋值运算符
关系运算符
逻辑运算符
三元运算符
5.1.1算数运算符的基本用法
5.1.2算数运算符概述
A:什么是运算符
就是对常量和变量进行操作的符号。
B:算数运算符有哪些
* +,-,,/,%,++,–
5.1.3代码案例三
package com.itheima_01;
/
- 运算符：对常量和变量进行操作的符号
- 表达式：用运算符连接起来的符合java语法的式子。不同类型的运算符连接起来的式子是不同的表达式。
-
举例：定义两个int类型的变量a,b, -
a + b - 运算符分类：
-
算术运算符，赋值运算符，关系运算符，逻辑运算符，三元运算符。 - 算术运算符：
-
+，-，*，/的基本使用
*/
public class OperatorDemo {
public static void main(String[] args) {
// 定义两个变量
int a = 3;
int b = 4;
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / b);
// 整数相除只能得到整数，要想得到小数，就必须有浮点数参与运算
System.out.println(3 / 4.0);
System.out.println(3.0 / 4);
}
}
5.1.4算数运算符取余和除法的区别
%：取余运算符。得到的是两个相除数据的余数。
/:除法运算符。得到是两个相除数据的商。
使用场景： %：判断两个数据是否整除。
5.1.5代码案例四
public class OperatorDemo2 {
public static void main(String[] args) {
int a = 5;
int b = 3;
System.out.println(a / b);
System.out.println(a % b);
}
}
5.1.6字符和字符串参与加法操作
字符参与运算
其实是拿该字符对应的数值来操作
‘a’ 97
‘A’ 65
‘0’ 48
字符串参与运算
这里其实做的不是加法运算，而是字符串拼接。
字符串和其他类型的数据做拼接，结果是字符串类型的。
5.1.7代码案例五
package com.itheima_01;
/*
- 整数的加法。
- 字符参与加法操作。拿字符在计算机中底层存储对应的数据值来参与运算的。
-
'0' 48 -
'a' 97 -
'A' 65 - 字符串参与加法操作。
-
这里的+其实不是加法，而是字符串连接符。
*/
public class OperatorDemo3 {
public static void main(String[] args) {
// 整数加法
int a = 10;
int b = 20;
System.out.println(a + b);
System.out.println("------------------");
// 字符参与加法操作
char c = '0';
char c2 = 'a';
System.out.println(a + c);
System.out.println(a + c2);
System.out.println("------------------");
// 字符串参与加法操作
System.out.println("hello" + a);
System.out.println("hello" + a + b); // "hello"+10,然后再和b进行拼接
System.out.println(a + b + "hello");
}
}
5.1.8算数运算符++和- - 的用法
++,–运算符：对变量做加1或者减1的操作。
++或者–既可以放在变量的后面，也可以放在变量的前面。
单独使用的时候，++或者–无论是放在变量的前面还是后面，结果是一样的。
参与操作的时候：
如果++或者–在变量的后面，先拿变量参与操作，后变量做++或者–
如果++或者–在变量的前面，先变量做++或者–，后拿变量参与操作
5.1.9代码案例六
public class OperatorDemo4 {
public static void main(String[] args) {
int a = 10;
System.out.println(“a:” + a);
// 单独使用
// a++;
// ++a;
// System.out.println("a:" + a);
// 参与操作使用
// int b = a++;
int b = ++a;
System.out.println("a:" + a);
System.out.println("b:" + b);
}
}
5.2赋值运算符
5.2.1赋值运算符分类
基本的赋值运算符：=
扩展的赋值运算符：+=,-=,=,/=,%=
+=: a+=20;相当于a = (a的数据类型)(a + 20);
5.2.2代码案例七
package com.itheima_02;
/
- 赋值运算符：
-
A:基本 = -
B:扩展 +=,-=,*=,... - +=:
-
a+=20; -
相当于 -
a = (a的数据类型)(a + 20);
*/
public class OperatorDemo {
public static void main(String[] args) {
// 把10赋值给int类型的变量a
int a = 10;
// += 把左边和右边的数据进行运算，最后赋值给左边。左边的只能是变量
a += 10;// 相当于a = a + 10
System.out.println("a:" + a);
System.out.println("----------------------");
short s = 10;
// s += 20; // 相当于 s = s + 20;
s = (short) (s + 20);
System.out.println("s:" + s);
}
}
5.3关系运算符
5.3.1基本使用及注意事项
关系运算符包含以下内容:
,!=,>,>=,<,<=
关系运算符的结果都是boolean型，也就是要么是true，要么是false。
注意事项:
关系运算符“”不能误写成“=”。
5.3.2代码案例八
package com.itheima_03;
/*
- 关系运算符：
-
==,!=,>,>=,<,<= -
关系运算符的结果是boolean类型。 - 注意：
-
千万不要把==写成=
*/
public class OperatorDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 10;
System.out.println(a == b);
System.out.println(a == c);
System.out.println("-----------------");
System.out.println(a != b);
System.out.println(a != c);
System.out.println("-----------------");
System.out.println(a > b);
System.out.println(a > c);
System.out.println("-----------------");
System.out.println(a >= b);
System.out.println(a >= c);
System.out.println("-----------------");
int x = 3;
int y = 4;
// System.out.println(x == y);
// System.out.println(x = y);// 把y赋值给x，把x的值输出
boolean bb = (x == y);
// 报错
// boolean cc = (x = y);
int cc = (x = y);
}
}
5.4逻辑运算符
5.4.1逻辑运算符概述
A:逻辑运算符有哪些
&,|,^,!
&&,||
B:案例演示
逻辑运算符的基本用法
C:注意事项：
a:逻辑运算符一般用于连接boolean类型的表达式或者值。
b:表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
算术表达式：a + b
比较表达式：a == b(条件表达式)
D:结论：
&逻辑与:有false则false。
|逻辑或:有true则true。
^逻辑异或:相同为false，不同为true。
!逻辑非:非false则true，非true则false。
特点：偶数个不改变本身。
5.4.2代码案例九
package com.itheima_04;
/*
-
逻辑运算符：用于连接关系表达式。
-
&,|,^,!
-
&&,||
-
与：& 有false则false
-
或：| 有true则true
-
异或：^ 相同则false,不同则true。(男女朋友)
-
非：! true则false,false则true
*/
public class OperatorDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30;System.out.println((a > b) & (a > c));// false & false System.out.println((a < b) & (a > c)); // true & false System.out.println((a > b) & (a < c)); // false & true System.out.println((a < b) & (a < c)); // true & true System.out.println("---------------"); System.out.println((a > b) | (a > c));// false | false System.out.println((a < b) | (a > c)); // true | false System.out.println((a > b) | (a < c)); // false | true System.out.println((a < b) | (a < c)); // true | true System.out.println("---------------"); System.out.println((a > b) ^ (a > c));// false ^ false System.out.println((a < b) ^ (a > c)); // true ^ false System.out.println((a > b) ^ (a < c)); // false ^ true System.out.println((a < b) ^ (a < c)); // true ^ true System.out.println("---------------"); System.out.println((a > b)); // false System.out.println(!(a > b)); // !false System.out.println(!!(a > b)); // !!false}
}
5.4.3逻辑运算符&&与&的区别
A:&&和&的区别?
a:最终结果一样。
b:&&具有短路效果。左边是false，右边不执行。
&是无论左边是false还是true,右边都会执行
B:||和|的区别?
a:最终结果一样
b:||具有短路效果.左边是true,右边不执行
|是无论左边是false还是true,右边都会执行
5.4.4代码案例十:
package com.itheima_04;
/*
- &&和&的结果一样
- ||和|的结果一样
- &&和&的区别：
-
&&如果左边是false，右边不执行。 -
&无论左边是true还是false，右边都会执行。
*/
public class OperatorDemo2 {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30;
System.out.println((a > b) && (a > c));// false && false
System.out.println((a < b) && (a > c)); // true && false
System.out.println((a > b) && (a < c)); // false && true
System.out.println((a < b) && (a < c)); // true && true
System.out.println("---------------");
System.out.println((a > b) || (a > c));// false || false
System.out.println((a < b) || (a > c)); // true || false
System.out.println((a > b) || (a < c)); // false || true
System.out.println((a < b) || (a < c)); // true || true
System.out.println("---------------");
int x = 3;
int y = 4;
// System.out.println((x++ > 4) & (y++ > 5)); // false & false
System.out.println((x++ > 4) && (y++ > 5)); // false && false
System.out.println("x:" + x);
System.out.println("y:" + y);
}
}
5.5三元运算符
5.5.1三元运算符概述
A:格式
(关系表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
B:示例：
获取两个数中大数。
int x=3,y=4,z;
z = (x>y)?x:y;//z变量存储的就是两个数的大数
5.5.2代码案例十一
package com.itheima_05;
/*
- 三元运算符：
- 格式：
-
(关系表达式)?表达式1:表达式2; - 执行流程:
-
A:计算关系表达式的值，看是true还是false -
B:如果是true,表达式1就是运算结果 -
如果是false,表达式2就是运算结果
*/
public class OperatorDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = (a > b) ? a : b;
System.out.println("c:" + c);
}
}
5.5.3代码案例十二(比较两个数是否相同)
package com.itheima_05;
/*
-
三元运算符的练习
-
比较两个整数是否相同
*/
public class OperatorTest {
public static void main(String[] args) {
// 定义两个int类型的变量
int a = 10;
int b = 20;boolean flag = (a == b) ? true : false; // boolean flag = (a == b); System.out.println(flag);}
}
5.5.4代码案例十三(获取三个数中的最大值)
package com.itheima_05;
/*
-
获取三个整数中的最大值
*/
public class OperatorTest2 {
public static void main(String[] args) {
// 定义三个int类型的变量
int a = 10;
int b = 30;
int c = 20;// 先比较两个整数的大值 int temp = ((a > b) ? a : b); int max = ((temp > c) ? temp : c); System.out.println("max:" + max);}
}
第6章键盘录入
6.1键盘录入的基本步骤
6.1.1键盘录入数据概述
我们目前在写程序的时候，数据值都是固定的，但是实际开发中，数据值肯定是变化的，所以，把数据改进为键盘录入，提高程序的灵活性。
键盘录入数据的步骤:
A:导包(位置放到class定义的上面)
import java.util.Scanner;
B:创建对象
Scanner sc = new Scanner(System.in);
C:接收数据
int x = sc.nextInt();
6.1.2代码案例十四
package com.itheima;
import java.util.Scanner;
/*
- 为了提高程序的灵活性，我们就把数据改进为键盘录入。
- 如何实现键盘录入呢?目前我们只能使用JDK提供的类Scanner。
- 这个使用的步骤，目前大家记住就可以了。
- 使用步骤：
-
A:导包 -
import java.util.Scanner; -
类中的顺序：package > import > class -
B:创建对象 -
Scanner sc = new Scanner(System.in); -
C:接收数据 -
int i = sc.nextInt();
*/
public class ScannerDemo {
public static void main(String[] args) {
//创建键盘录入数据的对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请录入一个整数：");
int i = sc.nextInt();
//输出数据
System.out.println("i:"+i);
}
}
6.2键盘录入的练习
6.2.1键盘录入两个数据并求和
键盘录入两个数据，并对这两个数据求和，输出其结果
键盘录入：
A:导包
B:创建对象
C:接收数据
6.2.2代码案例十五
package com.itheima;
import java.util.Scanner;
public class ScannerTest {
public static void main(String[] args) {
// 创建对象
Scanner sc = new Scanner(System.in);
// 接收数据
System.out.println("请输入第一个数据：");
int a = sc.nextInt();
System.out.println("请输入第二个数据：");
int b = sc.nextInt();
// 对数据进行求和
int sum = a + b;
System.out.println("sum:" + sum);
}
}
6.2.3键盘录入两个数据比较是否相等
键盘录入两个数据，比较这两个数据是否相等
6.2.4代码案例十六
package com.itheima;
import java.util.Scanner;
/*
-
键盘录入两个数据，比较这两个数据是否相等
*/
public class ScannerTest2 {
public static void main(String[] args) {
// 创建对象
Scanner sc = new Scanner(System.in);// 接收数据 System.out.println("请输入第一个数据："); int a = sc.nextInt(); System.out.println("请输入第二个数据："); int b = sc.nextInt(); // 比较两个数据是否相等 // boolean flag = ((a == b) ? true : false); boolean flag = (a == b); System.out.println("flag:" + flag);}
}
6.2.5键盘录入三个数据获取最大值
键盘录入三个数据，获取这三个数据中的最大值
6.2.6代码案例十七
package com.itheima;
import java.util.Scanner;
/*
-
键盘录入三个数据，获取这三个数据中的最大值
*/
public class ScannerTest3 {
public static void main(String[] args) {
// 创建对象
Scanner sc = new Scanner(System.in);// 接收数据 System.out.println("请输入第一个数据："); int a = sc.nextInt(); System.out.println("请输入第二个数据："); int b = sc.nextInt(); System.out.println("请输入第三个数据："); int c = sc.nextInt(); // 如何获取三个数据的最大值 int temp = (a > b ? a : b); int max = (temp > c ? temp : c); System.out.println("max:" + max);}
}
第03天 java基础知识
今日内容介绍
选择流程控制语句
循环流程控制语句
控制循环语句
第7章选择流程控制语句
7.1顺序结构的基本使用
7.1.1顺序结构概述
是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的
7.1.2顺序流程流程图
7.1.3代码案例一
package com.itheima_01;
/*
- 顺序结构：从上往下，依次执行
*/
public class OrderDemo {
public static void main(String[] args) {
System.out.println(“开始”);
System.out.println(“语句A”);
System.out.println(“语句B”);
System.out.println(“语句C”);
System.out.println(“结束”);
}
}
7.2If语句的格式
7.2.1If语句格式1及执行流程
if语句第一种格式：
if(关系表达式) {
语句体
}
执行流程:
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体
如果是false就不执行语句体
7.2.2if语句格式1执行流程图
7.2.3代码案例二
package com.itheima_02;
/*
- if语句有三种格式。
- if语句格式1：
-
if(关系表达式) { -
语句体; -
} - 执行流程：
-
A:首先判断关系表达式看其结果是true还是false -
B:如果是true,就执行语句体 -
C:如果是false,就不执行语句体
*/
public class IfDemo {
public static void main(String[] args) {
System.out.println(“开始”);
// 定义两个变量
int a = 10;
int b = 20;
if (a == b) {
System.out.println("a等于b");
}
int c = 10;
if (a == c) {
System.out.println("a等于c");
}
System.out.println("结束");
}
}
7.2.4If语句格式2及执行流程
if语句第二种格式：
if(关系表达式) {
语句体1;
}else {
语句体2;
}
执行流程
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体1
如果是false就执行语句体2
7.2.5if语句格式2执行流程图
7.2.6代码案例三
package com.itheima_02;
/*
- if语句格式2：
-
if(关系表达式) { -
语句体1; -
}else { -
语句体2; -
} - 执行流程：
-
A:判断关系表达式的值是true还是false -
B:如果是true，就执行语句体1 -
C:如果是false，就执行语句体2
*/
public class IfDemo2 {
public static void main(String[] args) {
System.out.println(“开始”);
// 判断给定的数据是奇数还是偶数
// 定义变量
int a = 100;
// 给a重新赋值
a = 99;
if (a % 2 == 0) {
System.out.println("a是偶数");
} else {
System.out.println("a是奇数");
}
System.out.println("结束");
}
}
7.2.7If语句格式3及执行流程
if语句第三种格式：
if(关系表达式1) {
语句体1;
}else if (关系表达式2) {
语句体2;
}
…
else {
语句体n+1;
}
执行流程
首先判断关系表达式1看其结果是true还是false
如果是true就执行语句体1
如果是false就继续判断关系表达式2看其结果是true还是false
如果是true就执行语句体2
如果是false就继续判断关系表达式…看其结果是true还是false
…
如果没有任何关系表达式为true，就执行语句体n+1
7.2.8if语句格式3执行流程图
7.2.9代码案例四
package com.itheima_02;
/*
- if语句格式3：
-
if(关系表达式1) { -
语句体1; -
}else if(关系表达式2) { -
语句体2; -
}else if(关系表达式3) { -
语句体3; -
} -
... -
else { -
语句体n+1; -
} - 执行流程：
-
A:首先判断关系表达式1看其结果是true还是false -
B:如果是true，就执行语句体1 -
如果是false，就继续进行关系表达式2的判断看其结果是true还是false -
C:如果是true，就执行语句体2 -
如果是false，就继续进行关系表达式...的判断看其结果是true还是false -
... -
D:如果没有一个为true的，就执行语句体n+1 - if语句的三种格式：
-
第一种格式适合做一种情况的判断 -
第二种格式适合做二种情况的判断 -
第三种格式适合做多种情况的判断
*/
public class IfDemo3 {
public static void main(String[] args) {
// x和y的关系满足如下：
// x>=3 y = 2x + 1;
// -1<=x<3 y = 2x;
// x<=-1 y = 2x – 1;
// 根据给定的x的值，计算出y的值并输出。
// 定义变量
int x = 5;
/*
int y;
if (x >= 3) {
y = 2 * x + 1;
} else if (x >= -1 && x < 3) {
y = 2 * x;
} else if (x <= -1) {
y = 2 * x - 1;
}else {
y = 0;
}
*/
int y = 0;
if (x >= 3) {
y = 2 * x + 1;
} else if (x >= -1 && x < 3) {
y = 2 * x;
} else if (x <= -1) {
y = 2 * x - 1;
}
System.out.println("y的值是："+y);
}
}
7.3If语句的练习
7.3.1if语句实现获取两个数据较大值
7.3.2代码案例五
package com.itheima_02;
import java.util.Scanner;
/*
- 键盘录入两个数据，获取这两个数据的较大值
- 分析：
-
A:看到键盘录入，我们就应该想到键盘录入的三步骤 -
导包，创建对象，接收数据 -
B:获取这两个数据的较大值，其实就是判断两个数据谁大，把大的输出就可以了。 - 导包：
-
A:手动导包 -
import java.util.Scanner; -
B:鼠标点击红色叉叉，自动生成 -
C:快捷键(推荐) -
ctrl+shift+o
*/
public class IfTest {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请输入第一个数据：");
int a = sc.nextInt();
System.out.println("请输入第二个数据：");
int b = sc.nextInt();
//采用if语句格式2实现
/*
if(a>b){
System.out.println("较大的值是："+a);
}else {
System.out.println("较大的值是："+b);
}
*/
//拿到较大的值之后，我未必想直接输出，所以我们定义变量接收这个较大的值
int max;
if(a>b){
max = a;
}else {
max = b;
}
//可能做其他的操作
//max += 100;
System.out.println("较大的值是："+max);
}
}
7.3.3if语句实现判断学生等级
7.3.4代码案例六
package com.itheima_02;
import java.util.Scanner;
/*
- 键盘录入学生考试成绩，请根据成绩判断该学生属于哪个级别
- 90-100 优秀
- 80-90 好
- 70-80 良
- 60-70 及格
- 60以下 不及格
- 分析：
-
A:键盘录入学生考试成绩 -
三步骤 -
B:通过简单的分析，我们决定采用if语句格式3来实现 - 程序一定要考虑周全了。
-
安全数据 -
边界数据 -
错误数据
*/
public class IfTest2 {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请输入学生的考试成绩：");
int score = sc.nextInt();
//if语句格式3
/*
if(score>=90 && score<=100){
System.out.println("你的成绩属于优秀");
}else if(score>=80 && score<90){
System.out.println("你的成绩属于好");
}else if(score>=70 && score<80){
System.out.println("你的成绩属于良");
}else if(score>=60 && score<70){
System.out.println("你的成绩属于及格");
}else {
System.out.println("你的成绩属于不及格");
}
*/
//我们发现程序不够健壮,加入错误数据的判断
if(score<0 || score>100){
System.out.println("你的成绩是错误的");
}else if(score>=90 && score<=100){
System.out.println("你的成绩属于优秀");
}else if(score>=80 && score<90){
System.out.println("你的成绩属于好");
}else if(score>=70 && score<80){
System.out.println("你的成绩属于良");
}else if(score>=60 && score<70){
System.out.println("你的成绩属于及格");
}else {
System.out.println("你的成绩属于不及格");
}
}
}
7.4switch语句的格式及执行流程
7.4.1格式解释:
switch表示这是switch语句
表达式的取值：byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是String
case后面跟的是要和表达式进行比较的值
语句体部分可以是一条或多条语句
break表示中断，结束的意思，可以结束switch语句
default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
7.4.2执行流程
首先计算出表达式的值
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
7.4.3switch语句执行流程图
7.5switch语句的练习
7.5.1switch语句实现根据数字输出对应星期
7.5.2代码案例七
package com.itheima_03;
import java.util.Scanner;
/*
- switch语句格式：
- switch(表达式) {
-
case 值1: -
语句体1; -
break; -
case 值2: -
语句体2; -
break; -
... -
default: -
语句体n+1; -
break; - }
- 格式解释：
-
表达式:byte,short,int,char -
JDK5以后可以是枚举 -
JDK7以后可以是字符串 -
case:就是要和表达式进行比较的值 -
break:表示中断,结束的意思。 -
default:表示所有的情况都不匹配的时候，就执行语句体n+1。和if语句的else相似。 - 执行流程：
-
A:计算出表达式的值 -
B:拿计算出来的值和case后面的值依次比较，一旦有对应的值，就执行该处的语句，在执行过程中，遇到 break，就结束。 -
C:如果所有的case都不匹配，就会执行default控制的语句，然后结束。 - 需求：
-
根据键盘录入的数值1，2，3，…7输出对应的星期一，星期二，星期三…星期日。
*/
public class SwitchDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请输入一个数字(1-7)：");
int weekday = sc.nextInt();
//switch语句实现选择
switch(weekday) {
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;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("你输入的数字有误");
break;
}
}
}
第8章循环流程控制语句
8.1for循环的格式及基本使用
8.1.1for循环语句格式：
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
8.1.2执行流程
A:执行初始化语句
B:执行判断条件语句，看其结果是true还是false
如果是false，循环结束。
如果是true，继续执行。
C:执行循环体语句
D:执行控制条件语句
E:回到B继续
8.1.3for循环的执行流程图
8.1.4代码案例八
package com.itheima_04;
/*
- for循环语句格式：
-
for(初始化语句;判断条件语句;控制条件语句) { -
循环体语句; -
} -
执行流程： -
A:执行初始化语句 -
B:执行判断条件语句，看结果是true还是false -
如果是true，就继续执行 -
如果是false，就结束循环 -
C:执行循环体语句 -
D:执行控制条件语句 -
E:回到B继续 - 需求：
-
在控制台输出10次”HelloWorld”的案例。
*/
public class ForDemo {
public static void main(String[] args) {
//原始写法
System.out.println(“HelloWorld”);
System.out.println(“HelloWorld”);
System.out.println(“HelloWorld”);
System.out.println(“HelloWorld”);
System.out.println(“HelloWorld”);
System.out.println(“HelloWorld”);
System.out.println(“HelloWorld”);
System.out.println(“HelloWorld”);
System.out.println(“HelloWorld”);
System.out.println(“HelloWorld”);
System.out.println("-------------------------");
//用循环改进
for(int x=1; x<=10; x++) {
System.out.println("HelloWorld");
}
}
}
8.2for循环的练习
8.2.1for循环实现获取指定范围数据
8.2.2代码案例九
package com.itheima_04;
/*
-
需求：获取数据1-5和5-1
*/
public class ForTest {
public static void main(String[] args) {
//原始做法
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
System.out.println("-------------");//用循环改进 for(int x=1; x<=5; x++) { System.out.println(x); } System.out.println("-------------"); //1-5的数据我们获取到了，如何获取5-1呢? for(int x=5; x>=1; x--){ System.out.println(x); }}
}
8.2.3for循环实现1-5之间数据求和
8.2.4代码案例十
package com.itheima_04;
/* -
需求：求出1-5之间数据之和
-
分析：
-
A:定义求和变量，初始化值是0 -
B:获取1-5之间的数据，用for循环实现 -
C:把每一次获取到的数据，累加起来就可以了 -
D:输出求和变量即可
*/
public class ForTest2 {
public static void main(String[] args) {
//定义求和变量，初始化值是0
int sum = 0;
//获取1-5之间的数据，用for循环实现
for(int x=1; x<=5; x++) {
//把每一次获取到的数据，累加起来就可以了
//sum = sum + x;
/*
* 第一次：sum = 0 + 1 = 1
* 第二次：sum = 1 + 2 = 3
* 第三次：sum = 3 + 3 = 6
* 第四次：sum = 6 + 4 = 10
* 第五次：sum = 10 + 5 = 15
*/
sum += x;
}
//输出求和结果
System.out.println("sum:"+sum);
}
}
8.2.5for循环实现1-100之间偶数和
8.2.6代码案例十一
package com.itheima_04;
/*
- 需求：求出1-100之间偶数和
- 分析：
-
A:定义求和变量，初始化值是0 -
B:获取1-100之间的数据，用for循环实现 -
C:把获取到的数据进行判断，看是否是偶数 -
如果是，就累加 -
D:输出求和结果
*/
public class ForTest3 {
public static void main(String[] args) {
//定义求和变量，初始化值是0
int sum = 0;
//获取1-100之间的数据，用for循环实现
for(int x=1; x<=100; x++) {
//把获取到的数据进行判断，看是否是偶数
if(x%2 ==0) {
sum += x;
}
}
//输出求和结果
System.out.println("sum:"+sum);
}
}
8.2.7for循环实现在控制台打印水仙花数
8.2.8代码案例十二
package com.itheima_04;
/*
- 需求：在控制台输出所有的”水仙花数”
- 分析：
-
什么是水仙花数呢? -
所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。 -
举例：153就是一个水仙花数。 -
153 = 1*1*1 + 5*5*5 + 3*3*3 -
A:三位数其实就告诉了我们水仙花数的范围 -
100-999 -
B:如何获取一个数据的每一个位上的数呢? -
举例：我有一个数据153，请问如何获取到个位，十位，百位 -
个位：153%10 = 3; -
十位：153/10%10 = 5; -
百位：153/10/10%10 = 1; -
千位：... -
万位：... -
C:让每个位上的立方和相加，并和该数据进行比较，如果相等，就说明该数据是水仙花数，在控制台输出
*/
public class ForTest4 {
public static void main(String[] args) {
//通过循环获取到每一个三位数
for(int x=100; x<1000; x++) {
//获取个位，十位，百位
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
//让每个位上的立方和相加，并和该数据进行比较，如果相等，就说明该数据是水仙花数，在控制台输出
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
System.out.println(x);
}
}
}
}
8.2.9for循环实现统计水仙花的个数
8.2.10代码案例十三
package com.itheima_04;
/*
- 需求：统计”水仙花数”共有多少个
- 分析：
-
A:定义统计变量，初始化值是0 -
B:获取三位数，用for循环实现 -
C:获取三位数的个位，十位，百位 -
D:判断这个三位数是否是水仙花数，如果是，统计变量++ -
E:输出统计结果就可以了
*/
public class ForTest5 {
public static void main(String[] args) {
//定义统计变量，初始化值是0
int count = 0;
//获取三位数，用for循环实现
for(int x=100; x<1000; x++) {
//获取三位数的个位，十位，百位
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
//判断这个三位数是否是水仙花数，如果是，统计变量++
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
count++;
}
}
//输出统计结果就可以了
System.out.println("水仙花数共有："+count+"个");
}
}
8.3while循环的格式及基本使用
8.3.1while循环语句格式
基本格式
while(判断条件语句) {
循环体语句;
}
扩展格式
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
8.3.2执行流程图
8.3.3代码案例十四
package com.itheima_05;
/*
- while循环语句的基本格式：
-
while(判断条件语句) { -
循环体语句; -
} - 扩展格式：
-
初始化语句; -
while(判断条件语句) { -
循环体语句; -
控制条件语句; -
} - 回顾for循环的语句格式：
-
for(初始化语句;判断条件语句;控制条件语句) { -
循环体语句; -
}
/
public class WhileDemo {
public static void main(String[] args) {
//输出10次HelloWorld
/
for(int x=1; x<=10; x++) {
System.out.println(“HellloWorld”);
}
*/
//while循环实现
int x=1;
while(x<=10) {
System.out.println("HellloWorld");
x++;
}
}
}
8.4while循环的练习
8.4.1while循环实现1-100之间数据求和
8.4.2代码案例十五
package com.itheima_05;
/*
-
求1-100之和。
-
练习：统计水仙花个数。
*/
public class WhileTest {
public static void main(String[] args) {
//回顾for循环实现/* //定义求和变量 int sum = 0; //获取1-100之间的数据 for(int x=1; x<=100; x++) { //累加 sum += x; } System.out.println("1-100的和是："+sum); */ //while循环实现 //定义求和变量 int sum = 0; int x = 1; while(x<=100) { sum += x; x++; } System.out.println("1-100的和是："+sum);}
}
8.5do…while循环的格式及基本使用
8.5.1do…while循环语句格式
基本格式
do {
循环体语句;
}while((判断条件语句);
扩展格式
初始化语句;
do {
循环体语句;
控制条件语句;
} while((判断条件语句);
8.5.2执行流程图
8.5.3代码案例十六
package com.itheima_06;
/*
- do…while循环的基本格式：
-
do { -
循环体语句; -
}while(判断条件语句); - 扩展格式：
-
初始化语句; -
do { -
循环体语句; -
控制条件语句; -
}while(判断条件语句); - 执行流程：
-
A:执行初始化语句; -
B:执行循环体语句; -
C:执行控制条件语句; -
D:执行判断条件语句，看是true还是false -
如果是true，回到B继续 -
如果是false，就结束 - 练习：
-
求和案例 -
统计水仙花个数
/
public class DoWhileDemo {
public static void main(String[] args) {
//输出10次 HelloWorld
/
for(int x=1; x<=10; x++) {
System.out.println(“HelloWorld”);
}
*/
//do...while改写
int x=1;
do {
System.out.println("HelloWorld");
x++;
}while(x<=10);
}
}
8.6三种循环的区别
8.6.1区别概述
虽然可以完成同样的功能，但是还是有小区别：
do…while循环至少会执行一次循环体。
for循环和while循环只有在条件成立的时候才会去执行循环体
for循环语句和while循环语句的小区别：
使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
8.6.2代码案例十七
package com.itheima_06;
/*
- 三种循环的区别：
-
A:do...while至少执行一次循环体 -
B:for,while循环先判断条件是否成立，然后决定是否执行循环体 - for和while的小区别：
-
for循环的初始化变量，在循环结束后，不可以被访问。而while循环的初始化变量，是可以被继续使用的。 -
如果初始化变量，后面还要继续访问，就使用while，否则，推荐使用for。 - 循环的使用推荐：
-
for -- while -- do...while
/
public class DoWhileDemo2 {
public static void main(String[] args) {
/
int x = 3;
while(x<3) {
System.out.println(“我爱林青霞”);
x++;
}
System.out.println("--------------");
int y = 3;
do {
System.out.println(“我爱林青霞”);
y++;
}while(y<3);
*/
for(int x=1; x<=10; x++){
System.out.println("爱生活，爱Java");
}
//这里的x无法继续访问
//System.out.println(x);
System.out.println("-----------------");
int y = 1;
while(y<=10) {
System.out.println("爱生活，爱Java");
y++;
}
System.out.println(y);
}
}
第9章控制循环语句
9.1控制跳转语句break
9.1.1Break的使用场景和作用
break的使用场景：
在选择结构switch语句中
在循环语句中
离开使用场景的存在是没有意义的
break的作用：
跳出单层循环
9.1.2代码案例十八
package com.itheima_07;
/*
- break:中断的意思
- 使用场景：
-
A:switch语句中 -
B:循环中 - 注意：
-
离开使用场景是没有意义的。 - 作用：
-
跳出循环，让循环提前结束
*/
public class BreakDemo {
public static void main(String[] args) {
//break;
for(int x=1; x<=10; x++) {
if(x == 3) {
break;
}
System.out.println("HelloWorld");
}
}
}
9.2控制跳转语句continue
9.2.1continue的使用场景：
在循环语句中
离开使用场景的存在是没有意义的
continue的作用：
单层循环对比break，然后总结两个的区别
break 退出当前循环
continue 退出本次循环
9.2.2代码案例十九
package com.itheima_07;
/*
- continue:继续的意思
- 使用场景：
-
循环中 - 注意：
-
离开使用场景是没有意义的 - 作用：
-
结束一次循环，继续下一次的循环 - 区别：
-
break:退出循环 -
continue:结束一次循环，继续下一次的循环
*/
public class ContinueDemo {
public static void main(String[] args) {
//continue;
for(int x=1; x<=10; x++) {
if(x == 3) {
//break;
continue;
}
System.out.println("HelloWorld");
}
}
}
9.3控制跳转语句练习
9.3.1练习需求:
按要求分析结果，并验证
for(int x=1; x<=10; x++) {
if(x%3==0) {
//分别写break，continue，说说输出几次
}
System.out.println(“我爱林青霞”);
}
9.3.2代码案例二十
package com.itheima_07;
/*
-
按要求分析结果，并验证
-
break：输出2次
-
continue:输出7次
*/
public class BreakAndContinueDemo {
public static void main(String[] args) {for (int x = 1; x <= 10; x++) { if (x % 3 == 0) { // 分别写break，continue，说说输出几次 //break; continue; } System.out.println("我爱林青霞"); }}
}
第04天 java基础语法
今日内容介绍
Random
数组
第10章Random
10.1产生整数随机数
10.1.1Random的使用步骤
我们想产生1~100(包含1和100)的随机数该怎么办呢? 我们不需要自己去写算法,因为Java已经为我们提供好了产生随机数的类—Random:
作用：
–用于产生一个随机数
•使用步骤(和Scanner类似)
–导包
•import java.util.Random;
–创建对象
•Random r = new Random();
–获取随机数
•int number = r.nextInt(10);
•产生的数据在0到10之间，包括0，不包括10。
•括号里面的10是可以变化的，如果是100，就是0-100之间的数据
10.1.2案例代码一:
package com.itheima;
import java.util.Random;
/*
-
Random:用于产生随机数
-
使用步骤：
-
A:导包 -
import java.util.Random -
B:创建对象 -
Random r = new Random(); -
C:获取随机数 -
int number = r.nextInt(10); -
获取的是0-10之间的随机数，包括0，不包括10 -
需求：如何获取到一个1-100之间的随机数呢?
*/
public class RandomDemo {
public static void main(String[] args) {
// 创建对象
Random r = new Random();for (int x = 0; x < 10; x++) { // 获取随机数 int number = r.nextInt(10); // 输出随机数 System.out.println("number:" + number); } System.out.println("--------------------"); // 如何获取到一个1-100之间的随机数呢? int i = r.nextInt(100) + 1; System.out.println("i:" + i);}
}
10.2猜数字小游戏案例:
10.2.1 系统产生一个1-100之间的随机数，请猜出这个数据是多少。
10.2.2案例代码二:
package com.itheima;
import java.util.Random;
import java.util.Scanner;
/*
- 猜数字小游戏案例
-
系统产生一个1-100之间的随机数，请猜出这个数据是多少。 - 分析：
-
A:系统产生一个随机数1-100之间的。 -
int number = r.nextInt(100) + 1; -
B:键盘录入我们要猜的数据 -
用Scanner实现 -
C:比较这两个数据(用if语句) -
大了：给出提示大了 -
小了：给出提示小了 -
猜中了：给出提示，恭喜你，猜中了 -
D:多次猜数据，而我们不知道要猜多少次，怎么办呢? -
while(true) {循环的内容}
*/
public class RandomTest {
public static void main(String[] args) {
// 系统产生一个随机数1-100之间的。
Random r = new Random();
int number = r.nextInt(100) + 1;
while(true){
// 键盘录入我们要猜的数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要猜的数字(1-100)：");
int guessNumber = sc.nextInt();
// 比较这两个数据(用if语句)
if (guessNumber > number) {
System.out.println("你猜的数据" + guessNumber + "大了");
} else if (guessNumber < number) {
System.out.println("你猜的数据" + guessNumber + "小了");
} else {
System.out.println("恭喜你,猜中了");
break;
}
}
}
}
第11章数组
11.1数组概述
需求：现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工，用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦。为了解决这种问题，Java就提供了数组供我们使用。
那么数组到底是什么呢?有什么特点呢?通过上面的分析：我们可以得到如下两句话：
数组是存储多个变量(元素)的东西(容器)
这多个变量的数据类型要一致
11.2数组的定义格式
11.2.1数组概念
数组是存储同一种数据类型多个元素的容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
11.2.2数组的定义格式
格式1：数据类型[] 数组名;
格式2：数据类型 数组名[];
注意：这两种定义做完了，数组中是没有元素值的。
11.3数组的初始化
11.3.1数组初始化概述：
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
11.3.2数组的初始化方式
11.3.2.1动态初始化:初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例：
int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。
11.3.2.2案例代码三:
package com.itheima_01;
/*
- 数组：存储同一种数据类型的多个元素的容器。
- 定义格式：
-
A:数据类型[] 数组名; -
B:数据类型 数组名[]; - 举例：
-
A:int[] a; 定义一个int类型的数组，数组名是a -
B:int a[]; 定义一个int类型的变量，变量名是a数组 - 数组初始化：
-
A:所谓初始化，就是为数组开辟内存空间，并为数组中的每个元素赋予初始值 -
B:我们有两种方式对数组进行初始化 -
a:动态初始化 只指定长度，由系统给出初始化值 -
b:静态初始化 给出初始化值，由系统决定长度 - 动态初始化：
-
数据类型[] 数组名 = new 数据类型[数组长度];
/
public class ArrayDemo {
public static void main(String[] args) {
//数据类型[] 数组名 = new 数据类型[数组长度];
int[] arr = new int[3];
/
* 左边：
* int:说明数组中的元素的数据类型是int类型
* []:说明这是一个数组
* arr:是数组的名称
* 右边：
* new:为数组分配内存空间
* int:说明数组中的元素的数据类型是int类型
* []:说明这是一个数组
* 3:数组的长度，其实就是数组中的元素个数
*/
}
}
11.3.2.3静态初始化:初始化时指定每个数组元素的初始值，由系统决定数组长度
11.3.2.4案例代码四:
package com.itheima_01;
/*
- 静态初始化的格式：
-
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...}; -
简化格式： -
数据类型[] 数组名 = {元素1,元素2,...}; -
举例： -
int[] arr = new int[]{1,2,3}; -
简化后： -
int[] arr = {1,2,3};
*/
public class ArrayDemo2 {
public static void main(String[] args) {
//定义数组
int[] arr = {1,2,3};
//输出数组名和元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
11.4数组的内存分配
11.4.1JVM内存划分
Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈 存储局部变量
堆 存储new出来的东西
方法区 (面向对象进阶讲)
本地方法区 (和系统相关)
寄存器 (给CPU使用)
11.4.2一个数组的内存图
定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素
11.4.2.1案例代码五:
package com.itheima_01;
/*
-
需求：定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。
*/
public class ArrayTest {
public static void main(String[] args) {
//定义一个数组
int[] arr = new int[3];//输出数组名及元素 System.out.println(arr); System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); //给数组中的元素赋值 arr[0] = 100; arr[2] = 200; //再次输出数组名及元素 System.out.println(arr); System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]);}
}
11.4.2.2代码内存图解:
11.4.3两个数组的内存图
定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素
11.4.3.1案例代码六:
package com.itheima_01;
/*
-
需求：定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。
*/
public class ArrayTest2 {
public static void main(String[] args) {
//定义两个数组
int[] arr = new int[2];
int[] arr2 = new int[3];//分别输出数组名及元素 System.out.println(arr); System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr2); System.out.println(arr2[0]); System.out.println(arr2[1]); System.out.println(arr2[2]); //然后分别给数组中的元素赋值 arr[1] = 100; arr2[0] = 200; arr2[2] = 300; //再次输出数组名及元素 System.out.println(arr); System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr2); System.out.println(arr2[0]); System.out.println(arr2[1]); System.out.println(arr2[2]);}
}
11.4.3.2代码内存图解:
11.4.4两个数组指向同一个地址的内存图
定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值，再次输出两个数组的名及元素
11.4.4.1案例代码七:
/*
-
需求：定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
-
然后给第二个数组赋值，再次输出两个数组的名及元素。
*/
public class ArrayTest3 {
public static void main(String[] args) {
// 先定义一个数组，赋值，输出
int[] arr = new int[3];
arr[0] = 100;
arr[1] = 200;
arr[2] = 300;
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);// 然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组 int[] arr2 = arr; // 然后给第二个数组赋值 arr2[0] = 111; arr2[1] = 222; arr2[2] = 333; // 再次输出两个数组的名及元素 System.out.println(arr); System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); System.out.println(arr2); System.out.println(arr2[0]); System.out.println(arr2[1]); System.out.println(arr2[2]);}
}
11.4.4.2代码内存图解:
11.5数组的使用
11.5.1数组的元素访问
11.5.1.1案例代码八:
package com.itheima_01;
/*
- 数组：存储同一种数据类型的多个元素的容器。
- 定义格式：
-
A:数据类型[] 数组名; -
B:数据类型 数组名[]; - 举例：
-
A:int[] a; 定义一个int类型的数组，数组名是a -
B:int a[]; 定义一个int类型的变量，变量名是a数组 - 数组初始化：
-
A:所谓初始化，就是为数组开辟内存空间，并为数组中的每个元素赋予初始值 -
B:我们有两种方式对数组进行初始化 -
a:动态初始化 只指定长度，由系统给出初始化值 -
b:静态初始化 给出初始化值，由系统决定长度 - 动态初始化：
-
数据类型[] 数组名 = new 数据类型[数组长度];
/
public class ArrayDemo {
public static void main(String[] args) {
//数据类型[] 数组名 = new 数据类型[数组长度];
int[] arr = new int[3];
/
* 左边：
* int:说明数组中的元素的数据类型是int类型
* []:说明这是一个数组
* arr:是数组的名称
* 右边：
* new:为数组分配内存空间
* int:说明数组中的元素的数据类型是int类型
* []:说明这是一个数组
* 3:数组的长度，其实就是数组中的元素个数
*/`
System.out.println(arr); //[I@3fa5ac,地址值
//我们获取到地址值没有意义，我要的是数组中的数据值，该怎么办呢?
//不用担心，java已经帮你想好了
//其实数组中的每个元素都是有编号的，编号是从0开始的，最大的编号就是数组的长度-1
//用数组名和编号的配合我们就可以获取数组中的指定编号的元素
//这个编号的专业叫法：索引
//格式：数组名[编号] -- 数组名[索引]
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
11.5.2数组使用的两个小问题
11.5.2.1案例代码九:
package com.itheima_02;
/*
- 两个常见小问题：
-
A:java.lang.ArrayIndexOutOfBoundsException -
数组越界异常 -
产生的原因：就是你访问了不存在的索引元素。 -
B:java.lang.NullPointerException -
空指针异常 -
产生的原因：数组已经不指向堆内存的数据了，你还使用数组名去访问元素。 - 为什么我们要记住这样的小问题呢?
-
编程不仅仅是把代码写出来，还得在出现问题的时候能够快速的解决问题。
*/
public class ArrayDemo {
public static void main(String[] args) {
// 定义数组
int[] arr = { 1, 2, 3 };
//System.out.println(arr[3]);
//引用类型：类,接口,数组
//常量：空常量 null，是可以赋值给引用类型的
//arr = null;
System.out.println(arr[1]);
}
}
11.6一维数组练习
11.6.1一维数组遍历
11.6.1.1案例代码十:
package com.itheima_03;
/*
-
需求：数组遍历(依次输出数组中的每一个元素)
-
获取数组中元素的个数：数组名.length
*/
public class ArrayTest {
public static void main(String[] args) {
// 定义数组
int[] arr = { 11, 22, 33, 44, 55 };
// 原始做法
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
System.out.println("--------------------");// 用for循环改进 for (int x = 0; x < 5; x++) { System.out.println(arr[x]); } System.out.println("--------------------"); //为了解决我们去数数组中元素个数的问题，数组就提供了一个属性：length //用于获取数组的长度 //格式：数组名.length System.out.println("数组共有："+arr.length+"个"); System.out.println("--------------------"); for(int x=0; x<arr.length; x++) { System.out.println(arr[x]); }}
}
11.6.2数组操作之获取最值:
11.6.2.1案例代码十一:
package com.itheima_03;
/*
-
需求：数组获取最值(获取数组中的最大值最小值)
*/
public class ArrayTest2 {
public static void main(String[] args) {
//定义数组
int[] arr = {12,98,45,73,60};//定义参照物 int max = arr[0]; //遍历数组，获取除了0以外的所有元素，进行比较 for(int x=1; x<arr.length; x++) { if(arr[x] > max) { max = arr[x]; } } System.out.println("数组中的最大值是："+max);}
}
11.7二维数组
11.7.1二维数组概述
我们黑马程序员的Java基础班每个班有很多个学生，所以，可以用数组来存储，而我们又同时有很多个Java基础班。这个也应该用一个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用。
由此可见：其实二维数组其实就是一个元素为一维数组的数组。
11.7.2二维数组格式
定义格式
数据类型[][] 数组名;
数据类型 数组名[][]; 不推荐
数据类型[] 数组名[]; 不推荐
初始化方式
数据类型[][] 变量名 = new 数据类型[m][n];
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
11.7.2.1案例代码十二:
package com.itheima_04;
/*
- 二维数组：就是元素为一维数组的数组。
- 定义格式：
-
A:数据类型[][] 数组名; -
B:数据类型 数组名[][]; 不推荐 -
C:数据类型[] 数组名[]; 不推荐 - 如何初始化呢?
-
A:动态初始化 -
数据类型[][] 数组名 = new 数据类型[m][n]; -
m表示这个二维数组有多少个一维数组 -
n表示每一个一维数组的元素有多少个 -
B:静态初始化 -
数据类型[][] 数组名 = new 数据类型[][]{{元素...},{元素...},{元素...},...}; -
简化格式： -
数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};
*/
public class ArrayArrayDemo {
public static void main(String[] args) {
// 数据类型[][] 数组名 = {{元素…},{元素…},{元素…},…};
int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
System.out.println(arr); // [[I@104c575
System.out.println(arr.length); // 二维数组中的一维数组的个数
System.out.println(arr[0]);// [I@3fa5ac
System.out.println(arr[0].length);
System.out.println(arr[1]);// [I@95cfbe
System.out.println(arr[2]);// [I@179dce4
//我如何获取到一个二维数组的元素呢?
System.out.println(arr[0][0]);
System.out.println(arr[1][1]);
System.out.println(arr[2][0]);
}
}
11.7.3二维数组的遍历
遍历思想:首先使用循环遍历出二维数组中存储的每个一维数组,然后针对每个遍历到的一维数组在使用循环遍历该一维数组中的元素
11.7.3.1案例代码十三:
package com.itheima_04;
/*
-
二维数组遍历
-
System.out.println():输出内容并换行
-
System.out.print():输出内容
-
System.out.println():换行
*/
public class ArrayArrayTest {
public static void main(String[] args) {
// 定义二维数组
int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };// 二维数组中的一维数组名称：二维数组名[索引] // arr[0] 其实就是二维数组中的第一个一维数组的名称 // arr[1] 其实就是二维数组中的第二个一维数组的名称 // arr[2] 其实就是二维数组中的第三个一维数组的名称 // for (int x = 0; x < arr[0].length; x++) { // System.out.println(arr[0][x]); // } // System.out.println("hello"); // System.out.println("world"); // System.out.print("hello"); // System.out.print("world"); /* // 第一个一维数组的元素 for (int x = 0; x < arr[0].length; x++) { System.out.print(arr[0][x] + " "); } System.out.println(); // 第二个一维数组的元素 for (int x = 0; x < arr[1].length; x++) { System.out.print(arr[1][x] + " "); } System.out.println(); // 第三个一维数组的元素 for (int x = 0; x < arr[2].length; x++) { System.out.print(arr[2][x] + " "); } System.out.println(); */
// for(int y=0; y<3; y++) {
// for (int x = 0; x < arr[y].length; x++) {
// System.out.print(arr[y][x] + " ");
// }
// System.out.println();
// }
for(int y=0; y<arr.length; y++) {
for (int x = 0; x < arr[y].length; x++) {
System.out.print(arr[y][x] + " ");
}
System.out.println();
}
}
}
第05天 java基础知识
今日内容介绍
方法的概述及基本使用
方法的练习及注意事项
方法的重载及参数传递
方法的操作数组的练习
第12章方法的概述及基本使用
12.1方法定义格式及格式解释
12.1.1方法的概述
假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹(植物大战僵尸)。发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很臃肿，可读性也非常差。为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，程序在需要发射炮弹时调用该方法即可
简单的说：方法就是完成特定功能的代码块
在很多语言里面都有函数的定义 , 函数在Java中被称为方法
12.1.2方法格式
修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
方法体;
return 返回值;
}
12.1.3方法格式解释
修饰符 目前记住 public static
返回值类型 用于限定返回值的数据类型
方法名 一个名字，为了方便我们调用方法
参数类型 用于接收调用方法时传入的数据的类型
参数名 用于接收调用方法时传入的数据的变量
方法体 完成功能的代码
return 结束方法，把返回值带给调用者
12.1.4案例代码一
package com.itheima_01;
/*
- 方法：就是完成特定功能的代码块。
- 定义格式：
-
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) { -
方法体; -
return 返回值; -
} - 格式解释：
-
A:修饰符 目前记住 public static -
B:返回值类型 用于限定返回值的数据类型 -
C:方法名 一个名字，为了方便我们调用方法 -
D:参数类型 用于接收调用方法时传入的数据的类型 -
E:参数名 用于接收调用方法时传入的数据的变量 -
F:方法体 完成功能的代码 -
G:return 结束方法，把返回值带给调用者 - 方法的两个明确：
-
A:返回值类型 明确功能结果的数据类型 -
B:参数列表 明确有几个参数，以及参数的类型 - 案例：
-
求两个数和的案例。
*/
public class MethodDemo {
}
12.2求和方法的编写
12.2.1定义方法注意事项
写一个方法首先有两点需要明确
返回值类型 明确功能结果的数据类型
参数列表 明确有几个参数，以及参数的类型
按照格式和两个明确来完成如下功能
12.2.2案例代码二
/ *
- 方法的两个明确：
-
A:返回值类型 明确功能结果的数据类型 -
B:参数列表 明确有几个参数，以及参数的类型 - 案例：
-
求两个数和的案例。
/
public class MethodDemo {
/
* 写一个方法，用于求和。 两个明确： 返回值类型 int 参数列表 int a,int b
*/
public static int sum(int a, int b) {
// int c = a + b;
// return c;
return a + b;
}
public static void main(String[] args) {
}
}
12.3求和方法的调用
有明确返回值的方法调用：
单独调用，没有意义
输出调用，有意义，但是不够好，因为我不一定非要把结果输出
赋值调用，推荐方式
12.3.1案例代码三
package com.itheima_01;
/*
- 有明确返回值的方法的调用：
-
A:单独调用,没有什么意义。 -
B:输出调用,有意义,但是不够好，因为我可能需要对求和的结果进行进一步的操作 -
C:赋值调用
*/
public class MethodDemo2 {
// 求和的方法
public static int sum(int a, int b) {
return a + b;
}
public static void main(String[] args) {
// 单独调用
// sum(10,20);
// 输出调用
// System.out.println(sum(10,20));
// 赋值调用
int s = sum(10, 20);
// s+=100;
System.out.println("s:"+s);
}
}
12.4求和方法的调用图解
12.4.1方法调用流程图
第13章方法的练习及注意事项
13.1方法的练习
13.1.1方法练习之获取两个数据中的较大
13.1.2案例代码四
package com.itheima_01;
import java.util.Scanner;
/*
- 需求：键盘录入两个数据，返回两个数中的较大值
- 两个明确：
-
返回值类型：int -
参数列表：int a,int b
*/
public class MethodTest {
// 返回两个数中的较大值
public static int getMax(int a, int b) {
if (a > b) {
return a;
} else {
return b;
}
}
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请输入第一个数据：");
int x = sc.nextInt();
System.out.println("请输入第二个数据：");
int y = sc.nextInt();
//调用方法
int max = getMax(x,y);
System.out.println("max:"+max);
}
}
13.1.3方法练习之比较两个数据是否相等
13.1.4案例代码五
package com.itheima_01;
import java.util.Scanner;
/*
- 需求：键盘录入两个数据，比较两个数是否相等
- 两个明确：
-
返回值类型：boolean -
参数列表：int a,int b
*/
public class MethodTest2 {
//比较两个数是否相等
public static boolean compare(int a,int b){
if(a==b){
return true;
}else {
return false;
}
}
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请输入第一个数据:");
int a = sc.nextInt();
System.out.println("请输入第二个数据:");
int b = sc.nextInt();
//调用方法
boolean flag = compare(a,b);
System.out.println("flag:"+flag);
}
}
13.1.5方法练习之获取三个数据中的较大值
13.1.6案例代码六
package com.itheima_01;
import java.util.Scanner;
/*
- 需求：键盘录入三个数据，返回三个数中的最大值
- 两个明确：
-
返回值类型：int -
参数列表：int a,int b,int c
*/
public class MethodTest3 {
// 返回三个数中的最大值
public static int getMax(int a, int b, int c) {
if (a > b) {
if (a > c) {
return a;
} else {
return c;
}
} else {
if (b > c) {
return b;
} else {
return c;
}
}
}
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请输入第一个数据：");
int a = sc.nextInt();
System.out.println("请输入第二个数据：");
int b = sc.nextInt();
System.out.println("请输入第三个数据：");
int c = sc.nextInt();
//调用方法
int max = getMax(a,b,c);
System.out.println("max:"+max);
}
}
13.1.7void修饰的方法的调用
写一个方法，在控制台输出10次HelloWorld案例。
没有明确返回值的函数调用：
其实就是void类型方法的调用
只能单独调用
13.1.8案例代码七
package com.itheima_02;
/*
- 需求：写一个方法，在控制台输出10次HelloWorld案例。
- 两个明确：
-
返回值类型：void -
参数列表：无参数 - 如果一个方法没有明确的返回值类型，java提供了void进行修饰。
- void修饰的方法的调用：
-
A:单独调用
*/
public class MethodDemo {
//在控制台输出10次HelloWorld案例。
public static void printHelloWorld() {
for(int x=1; x<=10; x++) {
System.out.println(“HelloWorld”);
}
}
public static void main(String[] args) {
//单独调用
printHelloWorld();
//输出调用
//System.out.println(printHelloWorld());
//System.out.println(void);
//赋值调用
//void v = printHelloWorld();
}
}
13.1.9打印1到n之间的数据
13.1.10案例代码八
package com.itheima_02;
/*
- 需求：写一个方法，传递一个整数(大于1)，在控制台打印1到该数据的值。
- 两个明确：
-
返回值类型：void -
参数列表：int n
*/
public class MethodTest {
//在控制台打印1到该数据n的值
public static void printNumber(int n) {
for(int x=1; x<=n; x++) {
System.out.println(x);
}
}
public static void main(String[] args) {
printNumber(10);
System.out.println("-------------------");
printNumber(100);
}
}
13.1.11打印所有的水仙花数
13.1.12案例代码九
package com.itheima_02;
/*
- 写一个方法，把所有的水仙花数打印在控制台
- 两个明确：
-
返回值类型：void -
参数列表：无参数
*/
public class MethodTest2 {
//把所有的水仙花数打印在控制台
public static void printFlower() {
for(int x=100; x<1000; x++) {
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x){
System.out.println(x);
}
}
}
public static void main(String[] args) {
printFlower();
}
}
第14章方法的重载及参数传递
14.1方法重载的概述和基本使用
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
方法重载特点
与返回值类型无关，只看方法名和参数列表
在调用时，虚拟机通过参数列表的不同来区分同名方法
14.1.1案例代码十
package com.itheima_03;
/*
- 方法重载：在同一个类中，出现了方法名相同的方法，这就是方法重载。
- 方法重载特点：
-
方法名相同，参数列表不同。与返回值无关。 -
参数列表不同： -
参数的个数不同。 -
参数对应的类型不同。 - 注意：
-
在调用方法的时候，java虚拟机会通过参数列表的不同来区分同名的方法。
*/
public class MethodDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
// 求和
int result = sum(a, b);
System.out.println("result:" + result);
int c = 30;
// 求和
//int result2 = sum2(a,b,c);
//System.out.println("result2:"+result2);
result = sum(a,b,c);
System.out.println("result:"+result);
}
//两个float类型的数据求和
public static float sum(float a,float b) {
return a + b;
}
// 三个整数的求和
public static int sum(int a,int b,int c) {
return a + b + c;
}
/*
public static int sum2(int a, int b, int c) {
return a + b + c;
}
*/
// 两个整数的求和
public static int sum(int a, int b) {
return a + b;
}
}
14.2方法重载练习
14.2.1方法重载练习之比较数据是否相等
14.2.2代码案例十一
package com.itheima_03;
/*
- 需求：比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，
-
并在main方法中进行测试
*/
public class MethodTest {
public static void main(String[] args) {
// 调用
System.out.println(compare(10, 20));
System.out.println("-------------");
System.out.println(compare((byte)10, (byte)20));
System.out.println("-------------");
System.out.println(compare((short)10, (short)20));
System.out.println("-------------");
//System.out.println(compare((long)10, (long)20));
System.out.println(compare(10L, 20L));
}
// 两个byte类型的
public static boolean compare(byte a, byte b) {
System.out.println("byte");
// 第一种写法
// boolean flag = a==b?true:false;
// return flag;
// 第二种写法
// boolean flag = a == b;
// return flag;
// 第三种写法
return a == b;
}
// 两个short类型的
public static boolean compare(short a, short b) {
System.out.println("short");
return a == b;
}
// 两个int类型的
public static boolean compare(int a, int b) {
System.out.println("int");
return a == b;
}
// 两个long类型的
public static boolean compare(long a, long b) {
System.out.println("long");
return a == b;
}
}
14.3方法中参数传递
14.3.1方法的形式参数为基本数据类型
方法的参数是基本类型的时候：
形式参数的改变不影响实际参数。
形式参数：用于接收实际数据的变量
实际参数：实际参与运算的变量
14.3.2代码案例十二
public class ArgsDemo {
public static void main(String[] args) {
// 定义变量
int a = 10;
int b = 20;
System.out.println(“a:” + a + “,b:” + b);// a:10,b:20
change(a, b);
System.out.println(“a:” + a + “,b:” + b);// a:10,b:20
}
public static void change(int a, int b) { // a=10,b=20
System.out.println("a:" + a + ",b:" + b);// a:10,b:20
a = b; // a=20;
b = a + b;// b=40;
System.out.println("a:" + a + ",b:" + b);// a:20,b:40
}
}
14.3.3方法的形式参数是基本类型图解
14.3.4方法的形式参数为引用数据类型
14.3.5代码案例十三
package com.itheima_04;
/*
- 方法的参数是引用类型：
-
形式参数的改变直接影响实际参数
*/
public class ArgsDemo2 {
public static void main(String[] args) {
// 定义数组
int[] arr = { 1, 2, 3, 4, 5 };
// 遍历数组
for (int x = 0; x < arr.length; x++) {
System.out.println(arr[x]);
}
System.out.println("----------------");
change(arr);
for (int x = 0; x < arr.length; x++) {
System.out.println(arr[x]);
}
}
public static void change(int[] arr) {
for (int x = 0; x < arr.length; x++) {
// 如果元素是偶数，值就变为以前的2倍
if (arr[x] % 2 == 0) {
arr[x] *= 2;
}
}
}
}
14.3.6方法的形式参数是引用类型图
第15章方法的操作数组的练习
15.1方法操作数组练习
15.1.1方法的练习之数组遍历
需求：把遍历数组改进为方法实现，并调用方法
15.1.2代码案例十四
package com.itheima_05;
/*
-
需求：把遍历数组改进为方法实现，并调用方法
*/
public class MethodTest {
public static void main(String[] args) {
// 定义数组
int[] arr = { 11, 22, 33, 44, 55 };// 遍历 // for (int x = 0; x < arr.length; x++) { // System.out.println(arr[x]); // } //用方法改进 //printArray(arr); //这一次虽然可以，但是我觉得格式不好看，能不能打印成下面的格式呢? //[元素1, 元素2, 元素3, ...] printArray(arr);}
public static void printArray(int[] arr) {
System.out.print("[");
for(int x=0; x<arr.length; x++){
if(x==arr.length-1){
System.out.println(arr[x]+"]");
}else {
System.out.print(arr[x]+", ");
}
}
}/*
- 两个明确：
-
返回值类型：void -
参数列表：int[] arr
*/
// public static void printArray(int[] arr) {
// for(int x=0; x<arr.length; x++){
// System.out.println(arr[x]);
// }
// }
}
15.1.3方法的练习之数组获取最值
需求：把获取数组最值改进为方法实现，并调用方法
15.1.4代码案例十五
/*
-
需求：把获取数组最值改进为方法实现，并调用方法
*/
public class MethodTest2 {
public static void main(String[] args) {
// 定义数组
int[] arr = { 34, 67, 10, 28, 59 };//获取数组中的最大值 // //定义参照物 // int max = arr[0]; // //遍历，依次比较，大的留下来 // for(int x=1; x<arr.length; x++) { // if(arr[x] > max) { // max = arr[x]; // } // } //用方法改进 int max = getMax(arr); System.out.println("max:"+max); //获取数组中的最小值，用方法实现 int min = getMin(arr); System.out.println("min:"+min);}
//获取数组中的最小值的方法
public static int getMin(int[] arr) {
int min = arr[0];for(int x=1; x<arr.length; x++) { if(arr[x] < min) { min = arr[x]; } } return min;}
/*
- 两个明确：
-
返回值类型：int -
参数列表：int[] arr
*/
public static int getMax(int[] arr) {
int max = arr[0];for(int x=1; x<arr.length; x++) { if(arr[x] > max) { max = arr[x]; } } return max;}
}
15.1.5方法的练习之数组元素求和
需求：写一个方法，用于对数组进行求和，并调用方法。
15.1.6代码案例十六
package com.itheima_05;
/*
-
需求：写一个方法，用于对数组进行求和，并调用方法。
*/
public class MethodTest3 {
public static void main(String[] args) {
// 定义数组
int[] arr = { 1, 2, 3, 4, 5 };// //定义求和变量 // int sum = 0; // //获取数组中的每一个元素 // for(int x=0; x<arr.length; x++) { // sum += arr[x]; // } //用方法改进 int sum = sum(arr); System.out.println("sum:"+sum);}
/*
- 两个明确：
-
返回值类型：int -
参数列表：int[] arr
*/
public static int sum(int[] arr) {
int sum = 0;for(int x=0; x<arr.length; x++) { sum += arr[x]; } return sum;}
}
第06天 java基础语法
今日内容介绍
Eclipse断点调试
基础语法的练习
第16章Eclipse断点调试
16.1Eclipse断点调试概述
Eclipse的断点调试可以查看程序的执行流程和解决程序中的bug
16.2Eclipse断点调试常用操作:
A:什么是断点：
就是一个标记，从哪里开始。
B:如何设置断点：
你想看哪里的程序，你就在那个有效程序的左边双击即可。
C:在哪里设置断点：
哪里不会点哪里。
目前：我们就在每个方法的第一条有效语句上都加。
D:如何运行设置断点后的程序：
右键 – Debug as – Java Application
E:看哪些地方：
Debug：断点测试的地方
在这个地方，记住F6，或者点击也可以。一次看一行的执行过程。
Variables：查看程序的变量变化
ForDemo：被查看的源文件
Console：控制台
F:如何去断点：
再次双击即可
找到Debug视图，Variables界面，找到Breakpoints，并点击，然后看到所有的断点，最后点击那个双叉。
16.2.1案例代码一:
package com.itheima;
/*
- 断点调试：
-
A:查看程序的执行流程 -
B:调试程序 - 断点：
-
其实就是一个标记 - 在哪里加呢?
-
想加哪里就加哪里，一般是加在我们看不懂的地方 - 如何加呢?
-
在代码区域的最左边双击即可 - 如何运行加断点的程序呢?
-
代码区域 -- 右键 -- Debug as -- Java Application -
会弹出一个页面让我们选择是否进入debug模式，选择yes。 - 如何让程序往下执行呢?
-
Step Over 执行下一步 -
F6 - 看那些区域呢?
-
代码区域：看程序的执行步骤 -
Debug区域：看程序的执行步骤 -
Variables：看变量的创建，赋值，销毁等 -
Console：看程序的输入和输出 - 如何去除断点：
-
A:把加断点的动作再来一遍 -
B:在debug视图中，找到Breakpoints，选中断点，点击双x即可
*/
public class DebugDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = a + b;
System.out.println©;
}
}
16.3断点调试练习
16.3.1案例代码二:
package com.itheima;
/*
-
需求：看循环的执行流程(1-5求和案例)
*/
public class DebugTest {
public static void main(String[] args) {
// 定义求和变量
int sum = 0;// 循环获取每一个数据 for (int x = 1; x <= 5; x++) { sum += x; } System.out.println("sum:" + sum);}
}
16.3.2案例代码三:
package com.itheima;
import java.util.Scanner;
/*
-
需求：看方法的调用流程
-
有方法调用的时候，要想看到完整的流程，每个方法都要加断点，建议方法进入的第一条有效语句加断点
*/
public class DebugTest2 {
public static void main(String[] args) {
// 创建对象
Scanner sc = new Scanner(System.in);// 接收数据 System.out.println("请输入第一个数据："); int a = sc.nextInt(); System.out.println("请输入第二个数据："); int b = sc.nextInt(); // 调用方法 int result = sum(a, b); // 输出结果 System.out.println("result:" + result);}
// 求和方法
public static int sum(int a, int b) {
return a + b;
}
}
16.3.3案例代码四:
package com.itheima;
/*
- 参数是基本数据类型：
-
形式参数的改变不影响实际参数。
*/
public class DebugTest3 {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println(“a:” + a + “,b:” + b);
change(a, b);
System.out.println(“a:” + a + “,b:” + b);
}
public static void change(int a, int b) {
System.out.println("a:" + a + ",b:" + b);
a = b;
b = a + b;
System.out.println("a:" + a + ",b:" + b);
}
}
16.3.4案例代码五:
package com.itheima;
/*
- 参数是基本数据类型：
-
形式参数的改变不影响实际参数。
*/
public class DebugTest3 {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println(“a:” + a + “,b:” + b);
change(a, b);
System.out.println(“a:” + a + “,b:” + b);
}
public static void change(int a, int b) {
System.out.println(“a:” + a + “,b:” + b);
a = b;
b = a + b;
System.out.println(“a:” + a + “,b:” + b);
}
}
第17章基础语法的练习
17.1循环,if和switch练习
17.1.1键盘录入月份，输出对应的季节(if…else或switch实现)
17.1.1.1案例代码六:
package com.itheima;
import java.util.Scanner;
/*
- 需求：键盘录入一个月份，输出该月份对应的季节。
-
一年有四季 -
3,4,5 春季 -
6,7,8 夏季 -
9,10,11 秋季 -
12,1,2 冬季 - 分析：
-
A:键盘录入一个月份,用Scanner实现 -
B:判断该月份是几月，根据月份输出对应的季节 -
if -
switch
*/
public class Test {
public static void main(String[] args) {
// 键盘录入一个月份,用Scanner实现
Scanner sc = new Scanner(System.in);
// 接收数据
System.out.println("请输入一个月份(1-12)：");
int month = sc.nextInt();
// 判断该月份是几月，根据月份输出对应的季节
/*
if (month == 1) {
System.out.println("冬季");
} else if (month == 2) {
System.out.println("冬季");
} else if (month == 3) {
System.out.println("春季");
} else if (month == 4) {
System.out.println("春季");
} else if (month == 5) {
System.out.println("春季");
} else if (month == 6) {
System.out.println("夏季");
} else if (month == 7) {
System.out.println("夏季");
} else if (month == 8) {
System.out.println("夏季");
} else if (month == 9) {
System.out.println("秋季");
} else if (month == 10) {
System.out.println("秋季");
} else if (month == 11) {
System.out.println("秋季");
} else if (month == 12) {
System.out.println("冬季");
} else {
System.out.println("你输入的月份有误");
}
*/
//代码太长了，能不能简单一些呢?
//能，如何简单一些呢?
//我们可以把相同季节的月份放到一起来判断
//(month==3 || month==4 || month==5)
if(month==1 || month==2 || month==12) {
System.out.println("冬季");
}else if(month==3 || month==4 || month==5) {
System.out.println("春季");
}else if(month==6 || month==7|| month==8) {
System.out.println("夏季");
}else if(month==9 || month==10 || month==11) {
System.out.println("秋季");
}else {
System.out.println("你输入的月份有误");
}
}
}
17.1.1.2案例代码七:
package com.itheima;
import java.util.Scanner;
/*
-
需求：键盘录入一个月份，输出该月份对应的季节。
-
一年有四季 -
3,4,5 春季 -
6,7,8 夏季 -
9,10,11 秋季 -
12,1,2 冬季 -
分析：
-
A:键盘录入一个月份,用Scanner实现 -
B:判断该月份是几月，根据月份输出对应的季节 -
if -
switch -
case穿透。
*/
public class Test2 {
public static void main(String[] args) {
// 键盘录入一个月份,用Scanner实现
Scanner sc = new Scanner(System.in);// 接收数据 System.out.println("请输入月份(1-12)："); int month = sc.nextInt(); // 用switch语句实现 /* switch (month) { 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; case 6: System.out.println("夏季"); break; case 7: System.out.println("夏季"); break; case 8: System.out.println("夏季"); break; case 9: System.out.println("秋季"); break; case 10: System.out.println("秋季"); break; case 11: System.out.println("秋季"); break; case 12: System.out.println("冬季"); break; default: System.out.println("你输入的月份有误"); break; } */ //case 穿透 /* switch(month) { case 1: System.out.println("hello"); //break; case 2: System.out.println("world"); break; default: System.out.println("over"); break; } */ //通过case穿透现象改进代码 switch(month) { case 1: case 2: case 12: System.out.println("冬季"); break; case 3: case 4: case 5: System.out.println("春季"); break; case 6: case 7: case 8: System.out.println("夏季"); break; case 9: case 10: case 11: System.out.println("秋季"); break; default: System.out.println("你输入的月份有误"); break; }}
}
17.1.2打印5位数中所有的回文数
17.1.2.1案例代码八:
package com.itheima;
/*
- 需求：打印5位数中的所有回文数。
-
什么是回文数呢?举例：12321是回文数，个位与万位相同，十位与千位相同。 - 分析：
-
A:5位数告诉了我们数据的范围，用for循环实现 -
B:获取每一个5位数，然后得到它的个位，十位，千位，万位 -
假设x是一个5位数： -
个位：x%10 -
十位：x/10%10 -
千位：x/10/10/10%10 -
万位：x/10/10/10/10%10 -
C:把满足条件的数据输出即可
*/
public class Test3 {
public static void main(String[] args) {
//5位数告诉了我们数据的范围，用for循环实现
for(int x=10000; x<100000; x++) {
//获取每一个5位数，然后得到它的个位，十位，千位，万位
int ge = x%10;
int shi = x/10%10;
int qian = x/10/10/10%10;
int wan = x/10/10/10/10%10;
//把满足条件的数据输出即可
if((ge==wan) && (shi==qian)) {
System.out.println(x);
}
}
}
}
17.2数组练习
17.2.1不死神兔问题
17.2.1.1案例代码九
package com.itheima;
/*
- 需求：
-
有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子， -
假如兔子都不死，问第二十个月的兔子对数为多少？ - 规律：
-
第一个月：1 -
第二个月：1 -
第三个月：2 -
第四个月：3 -
第五个月：5 -
... -
规律：从第三个月开始，每个月的兔子对数是前两个月的兔子对数之和。 -
第一个月和第二个月的兔子对数是1 - 分析：
-
int[] arr = new int[20]; -
arr[0] = 1; -
arr[1] = 1; -
arr[2] = arr[0] + arr[1]; -
arr[3] = arr[1] + arr[2]; -
arr[4] = arr[2] + arr[3]; -
...
*/
public class Test4 {
public static void main(String[] args) {
//定义数组
int[] arr = new int[20];
//初始化第一个月和第二个月的兔子对数c
arr[0] = 1;
arr[1] = 1;
for(int x=2; x<arr.length; x++) {
arr[x] = arr[x-2] + arr[x-1];
}
System.out.println("第二十个月的时候的兔子对数是："+arr[19]);
}
}
17.2.2求数组中满足要求的元素和
17.2.2.1案例代码十:
package com.itheima;
/*
- 需求：
- (1)定义一个int类型的一维数组，内容为{171,72,19,16,118,51,210,7,18}
- (2)求出该数组中满足要求的元素和。
-
要求：求和的元素的个位和十位不能包含7,并且只能为偶数。 - 分析：
-
A:定义一个int类型的一维数组 -
B:定义一个求和变量 -
C:遍历数组，获取到数组中的每一个元素 -
D:判断该元素是否满足如下要求，如果是就累加，否则，不搭理它 -
x%2==0 -
x%10 != 7 -
x/10%10 !=7 -
E:输出结果
*/
public class Test5 {
public static void main(String[] args) {
//定义一个int类型的一维数组
int[] arr = {171,72,19,16,118,51,210,7,18};
//定义一个求和变量
int sum = 0;
//遍历数组，获取到数组中的每一个元素
for(int x=0; x<arr.length; x++) {
if((arr[x]%10 != 7) && (arr[x]/10%10 != 7) && (arr[x]%2 == 0)) {
sum += arr[x];
}
}
System.out.println("sum:"+sum);
}
}
17.2.3裁判评分
17.2.3.1案例代码十一:
package com.itheima;
import java.util.Scanner;
/*
- 需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
- 选手的最后得分为：去掉一个最高分和一个最低分后 其余4个选手的平均值。
- 请写代码实现。(不考虑小数部分)
- 分析：
-
A:定义一个长度为6的数组。 -
B:通过键盘录入的方式给出评委的分数 -
C:写方法实现获取数组中的最大值，最小值 -
D:写方法实现数组元素的求和 -
E:平均分： (和-最高分-最低分)/(arr.length-2) -
F:输出分数即可
*/
public class Test6 {
public static void main(String[] args) {
//定义一个长度为6的数组
int[] arr = new int[6];
//通过键盘录入的方式给出评委的分数
Scanner sc = new Scanner(System.in);
for(int x=0; x<arr.length; x++) {
// arr[x] = sc.nextInt();
System.out.println("请给出第"+(x+1)+"个评委的分数(0-100)：");
int number = sc.nextInt();
arr[x] = number;
}
//写方法实现获取数组中的最大值，最小值
int max = getMax(arr);
int min = getMin(arr);
//写方法实现数组元素的求和
int sum = sum(arr);
// (和-最高分-最低分)/(arr.length-2)
int avg = (sum-max-min)/(arr.length-2);
//输出分数即可
System.out.println("该选手的最终得分是："+avg);
}
//数组元素求和
public static int sum(int[] arr) {
int sum = 0;
for(int x=0; x<arr.length; x++) {
sum += arr[x];
}
return sum;
}
//数组中的最小值
public static int getMin(int[] arr) {
int min = arr[0];
for(int x=1; x<arr.length; x++) {
if(arr[x] < min) {
min = arr[x];
}
}
return min;
}
//数组中的最大值
public static int getMax(int[] arr) {
int max = arr[0];
for(int x=1; x<arr.length; x++) {
if(arr[x] > max) {
max = arr[x];
}
}
return max;
}
}
17.2.4数组反转
17.2.4.1案例代码十二:
package com.itheima;
import java.util.Scanner;
/*
- 需求：
- (1)键盘录入5个int类型的数据存储数组arr中
- (2)定义方法将arr数组中的内容反转
- (3)定义方法对反转后的数组进行遍历
- 分析：
-
A:定义一个长度为5的数组 -
B:通过键盘录入数据给数组中的元素赋值 -
C:定义方法将arr数组中的内容反转 -
什么是反转?如何反转? -
D:定义方法遍历数组
*/
public class Test7 {
public static void main(String[] args) {
// 定义一个长度为5的数组
int[] arr = new int[5];
// 通过键盘录入数据给数组中的元素赋值
Scanner sc = new Scanner(System.in);
for (int x = 0; x < arr.length; x++) {
System.out.println("请给出第" + (x + 1) + "个元素");
arr[x] = sc.nextInt();
}
System.out.println("反转前的数组元素：");
printArray(arr);
// 定义方法将arr数组中的内容反转
reverse(arr);
System.out.println("反转后的数组元素：");
//定义方法遍历数组
printArray(arr);
}
//遍历数组
public static void printArray(int[] arr) {
System.out.print("[");
for(int x=0;x<arr.length; x++){
if(x == arr.length-1) {
System.out.println(arr[x]+"]");
}else {
System.out.print(arr[x]+", ");
}
}
}
/*
* 两个明确： 返回值类型：void 参数列表：int[] arr
*/
public static void reverse(int[] arr) {
for(int startIndex=0,endIndex=arr.length-1;startIndex<=endIndex;startIndex++,endIndex--) {
int temp = arr[startIndex];
arr[startIndex] = arr[endIndex];
arr[endIndex] = temp;
}
}
}
17.2.5数组基本查找
17.2.5.1案例代码十三:
package com.itheima;
import java.util.Scanner;
/*
*需求：数组元素查找(查找指定元素第一次在数组中出现的索引)
*(1)给定数组int[] arr = {5,7,3,2,5};
*(2)要查询的元素通过键盘录入的方式确定
*(3)定义一个查找数组元素第一次出现位置的方法(注,要查找的元素就是键盘录入的数据)
*
*分析：
-
A:给定数组int[] arr = {5,7,3,2,5}; -
B:要查询的元素通过键盘录入的方式确定 -
C:定义一个查找数组元素第一次出现位置的方法 -
遍历数组，获取到每一个元素，进行比较，如果想等，就直接把该处的索引返回。 -
D:调用方法，输出结果
*/
public class Test8 {
public static void main(String[] args) {
// 给定数组int[] arr = {5,7,3,2,5};
int[] arr = { 5, 7, 3, 2, 5 };
//要查询的元素通过键盘录入的方式确定
Scanner sc = new Scanner(System.in);
System.out.println("请输入要查找的元素：");
int number = sc.nextInt();
//定义一个查找数组元素第一次出现位置的方法
//调用方法
int index =getIndex(arr, number);
System.out.println("index:"+index);
}
/*
* 两个明确：
* 返回值类型：int
* 参数列表：int[] arr,int value
*/
public static int getIndex(int[] arr,int value) {
//遍历数组，获取到每一个元素，进行比较，如果想等，就直接把该处的索引返回。
/*
for(int x=0; x<arr.length; x++) {
if(arr[x] == value) {
return x;
}
}
return -1;
*/
int index = -1;
for(int x=0; x<arr.length; x++) {
if(arr[x] == value) {
index = x;
break;
}
}
return index;
}
}
17.2.6数据加密
17.2.6.1案例代码十四:
package com.itheima;
import java.util.Scanner;
/*
- 需求：键盘录入数据,要求数据是四位的整数,现需要对数据进行加密,加密规则如下:
- 每位数字都加上5,然后除以10的余数代替该数字,
- 再将第一位和第四位交换,第二位和第三位交换,
- 请把加密后的数据输出到控制台
- 分析：
-
A:键盘录入一个四位数 -
B:对数据进行加密 -
举例： -
4567 -
把这个四位数分成个，十，百，千存储到数组中 -
int[] arr = {4,5,6,7}; -
每位数字都加上5： -
arr[x] += 5; {9,10,11,12} -
然后除以10的余数代替该数字： -
arr[x] %= 10; {9,0,1,2} -
再将第一位和第四位交换,第二位和第三位交换： -
{9,0,1,2} {2,1,0,9} -
C:输出加密后的数据
*/
public class Test9 {
public static void main(String[] args) {
//键盘录入一个四位数
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请输入一个四位数：");
int number = sc.nextInt();
//分别得到该数据的每一个位上的数据
int ge = number%10;
int shi = number/10%10;
int bai = number/10/10%10;
int qian = number/10/10/10%10;
//定义一个数组
int[] arr = new int[4];
arr[0] = qian;
arr[1] = bai;
arr[2] = shi;
arr[3] = ge;
//加密规则
//每位数字都加上5,然后除以10的余数代替该数字
for(int x=0; x<arr.length; x++) {
arr[x] += 5;
arr[x] %= 10;
}
//再将第一位和第四位交换,第二位和第三位交换
int temp = arr[0];
arr[0] = arr[3];
arr[3] = temp;
int temp2 = arr[1];
arr[1] = arr[2];
arr[2] = temp2;
//输出加密后的数据
for(int x=0; x<arr.length; x++) {
System.out.print(arr[x]);
}
System.out.println();
}
}
第07天 面向对象基础
今日内容介绍
面向对象概述
面向对象特性之封装
面向对象之构造方法
类名作为形参和返回值案例
第18章面向对象概述
18.1面向对象思想
18.1.1面向过程思想与面向对象思想
A:什么是面向过程
面向过程，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
例如:吃煎饼果子利用面向过程的思想:
1.学习摊煎饼的技术
2.买材料鸡蛋,油,葱等等
3.开始摊
4.吃
5.收拾
B:什么是面向对象
面向对象思想就是不断的创建对象，使用对象，指挥对象做事情。（如果有对象，直接用对象，对我们直接提供服务）
例如:吃煎饼果子利用面向对象的思想
1.找会摊煎饼的大妈(创建一个摊煎饼大妈的对象)
2.调用其摊煎饼的技能(功能),传递进去钱参数
3.返回给我们一个煎饼
4.吃
18.1.2面向过程特点与面向对象特点
A:面向过程：
强调的是过程，所有事情都需要自己完成
B:面向对象:
是一种更符合我们思想习惯的思想(懒人思想，我把事情自己不做，交给别人去做)
可以将复杂的事情简单化（对使用者来说简单了，对象里面还是很复杂的）
将我们从执行者变成了指挥者角色发生了转换
18.1.2.1案例代码一:
package com.itheima_01;
/*
- 面向对象思想：
-
面向对象是基于面向过程的编程思想。 -
面向过程：强调的是每一个功能的步骤 -
面向对象：强调的是对象，然后由对象去调用功能 - 面向对象的思想特点：
-
A:是一种更符合我们思考习惯的思想 -
B:可以将复杂的事情简单化 -
C:将我们从执行者变成了指挥者 - 举例：
-
买电脑： -
面向过程：我要买电脑--我要明确买电脑的意义--上网查对应的参数信息--去中关村买电脑--讨价还价--买回电脑 -
面向对象：我要买电脑--班长去给我买电脑--买回电脑 -
洗衣服： -
面向过程：把衣服脱下来--找一个盆--放点洗衣粉--加点水--浸泡10分钟--揉一揉--清洗衣服--拧干--晾起来 -
面向对象：把衣服脱下来--打开全自动洗衣机--扔衣服--按钮--晾起来
*/
public class Demo {
}
18.2类与对象及其使用:
18.2.1类与对象概述:
A:我们学习编程是为了什么
为了把我们日常生活中实物用学习语言描述出来
B:我们如何描述现实世界事物
属性 就是该事物的描述信息(事物身上的名词)
行为 就是该事物能够做什么(事物身上的动词)
C:Java中最基本的单位是类,Java中用class描述事物也是如此
成员变量 就是事物的属性
成员方法 就是事物的行为
D:定义类其实就是定义类的成员(成员变量和成员方法)
a:成员变量 和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
b:成员方法 和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
E:类和对象的概念
a:类：是一组相关的属性和行为的集合（我们班所有的同学都具备相同的属性和行为，比如：姓名，年龄，学习，这样就把所有的学生成为学生类）
b:对象：是该类事物的具体体现（说某个同学时，他都具备自己特有的属性和行为）
c:举例：
类 学生
对象 具体的某个学生就是一个对象
比如：车是一个类，具体的开的奔驰、宝马，就是对象
18.2.1.1案例代码二:
package com.itheima_01;
/*
- 我们学习编程语言，其实就是为了把现实世界的事物模拟出来，实现信息化。
- 我们是如何表示现实世界的事物的呢?
-
A:属性 就是事物的描述信息 -
B:行为 就是事物能够做什么 -
举例：学生 - Java语言最基本的单位是类，所以，我们在后面的学习过程中，是通过类来体现现实世界事物的。
- 类：是一组相关的属性和行为的集合
- 对象：就是该事物的具体体现
-
举例： -
类 学生 -
对象 班长
*/
public class Demo2 {
}
18.2.2类与对象案例:
18.2.2.1学生类案例
18.2.2.1.1案例代码三:
package com.itheima_02;
/*
- 类的定义：
-
类是用来描述现实世界的事物的 - 事物：
-
属性 事物的描述信息 -
行为 事物能够做什么 - 类是如何和事物进行对应的呢?
-
类： -
成员变量 -
成员方法 - 需求：写一个学生类
- 学生事物：
-
属性：姓名，年龄... -
行为：学习，吃饭... - 学生类：
-
成员变量：姓名,年龄 -
成员方法：学习,吃饭 - 成员变量：和我们前面学习过的变量的定义是一样的。
-
位置不同：类中，方法外 -
初始化值：不需要给初始化值 - 成员方法：和我们前面学习过的方法的定义是一样的。
-
去掉static关键字
*/
public class Student {
//成员变量
//姓名
String name;
//年龄
int age;
//成员方法
//学习的方法
public void study() {
System.out.println("好好学习，天天向上");
}
//吃饭的方法
public void eat() {
System.out.println("学习饿了要吃饭");
}
}
package com.itheima_02;
/*
- Student是一个学生事物描述类，main方法不适合放在它里面。
- 使用一个类，其实就是使用该类的成员。(成员变量和成员方法)
- 而我们要想使用一个类的成员，就必须首先拥有该类的对象。
- 我们如何拥有一个类的对象呢?
-
创建对象就可以了? - 我们如何创建对象呢?
-
格式：类名 对象名 = new 类名(); - 对象如何访问成员呢?
-
成员变量：对象名.变量名 -
成员方法：对象名.方法名(...)
*/
public class StudentDemo {
public static void main(String[] args) {
//格式：类名 对象名 = new 类名();
Student s = new Student();
//System.out.println(“s:”+s); //com.itheima_02.Student@193c0cf
//直接输出成员变量值
System.out.println("姓名："+s.name); //null
System.out.println("年龄："+s.age); //0
System.out.println("----------");
//给成员变量赋值
s.name = "林青霞";
s.age = 28;
//再次输出成员变量的值
System.out.println("姓名："+s.name); //林青霞
System.out.println("年龄："+s.age); //28
System.out.println("----------");
//调用成员方法
s.study();
s.eat();
}
}
18.2.2.2手机类案例
18.2.2.2.1案例代码四:
package com.itheima_02;
/*
- 手机类：
-
成员变量：品牌，价格，颜色... -
成员方法：打电话，发短信...
*/
public class Phone {
//品牌
String brand;
//价格
int price;
//颜色
String color;
//打电话
public void call(String name) {
System.out.println("给"+name+"打电话");
}
//发短信
public void sendMessage() {
System.out.println("群发短信");
}
}
package com.itheima_02;
/*
-
手机类的测试类
*/
public class PhoneDemo {
public static void main(String[] args) {
//创建对象
Phone p = new Phone();//输出成员变量值 System.out.println("品牌："+p.brand);//null System.out.println("价格："+p.price);//0 System.out.println("颜色："+p.color);//null System.out.println("------------"); //给成员变量赋值 p.brand = "锤子"; p.price = 2999; p.color = "棕色"; //再次输出成员变量值 System.out.println("品牌："+p.brand);//锤子 System.out.println("价格："+p.price);//2999 System.out.println("颜色："+p.color);//棕色 System.out.println("------------"); //调用成员方法 p.call("林青霞"); p.sendMessage();}
}
18.3对象的内存图
18.3.1一个对象的内存图:
18.3.2方法公用内存图:
18.3.2.1案例代码五:
package com.itheima_03;
/*
-
手机类的测试类
*/
public class PhoneDemo2 {
public static void main(String[] args) {
Phone p = new Phone();
p.brand = “小米5s”;
p.price = 1999;
p.color = “银色”;
System.out.println(p.brand+"—"+p.price+"—"+p.color);
p.call(“林青霞”);
p.sendMessage();Phone p2 = new Phone(); p2.brand = "IPhone7S"; p2.price = 7999; p2.color = "土豪金"; System.out.println(p2.brand+"---"+p2.price+"---"+p2.color); p2.call("张曼玉"); p2.sendMessage();}
}
18.3.3两个引用指向同一个对象内存图:
18.3.3.1案例代码六:
package com.itheima_03;
/*
-
手机类的测试类
*/
public class PhoneDemo3 {
public static void main(String[] args) {
Phone p = new Phone();
p.brand = “OPPO”;
p.price = 2999;
p.color = “白色”;
System.out.println(p.brand+"—"+p.price+"—"+p.color);Phone p2 = p; p2.brand = "魅族"; p2.price = 1999; p2.color = "蓝色"; System.out.println(p.brand+"---"+p.price+"---"+p.color); System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);}
}
18.4成员变量和局部变量区别:
18.4.1案例代码七:
package com.itheima_04;
/* -
成员变量和局部变量的区别：
-
A:在类中的位置不同 -
成员变量：类中，方法外 -
局部变量：方法中或者方法声明上(形式参数) -
B:在内存中的位置不同 -
成员变量：堆内存 -
局部变量：栈内存 -
C:生命周期不同 -
成员变量：随着对象的创建而存在，随着对象的消失而消失 -
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失 -
D:初始化值的问题 -
成员变量：有默认值 -
局部变量：没有默认值。必须先定义，赋值，最后使用
*/
public class Variable {
int x;
public void show() {
int y = 0;
System.out.println(x);
System.out.println(y);
}
}
第19章面向对象特性之封装
19.1 封装与私有关键字
19.1.1private关键字
A:private关键字：
a:是一个权限修饰符。
b:可以修饰成员(成员变量和成员方法)
c:被private修饰的成员只在本类中才能访问。
19.1.1.1案例代码八:
package com.itheima_05;
/*
-
学生类
-
通过对象直接访问成员变量，会存在数据安全问题
-
这个时候，我们就想能不能不让外界的对象直接访问成员变量呢?
-
能。
-
如何实现呢?
-
private关键字 -
private:
-
是一个修饰符 -
可以修饰成员变量，也可以修饰成员方法 -
被private修饰的成员只能在本类中被访问 -
针对private修饰的成员变量，我们会相应的提供getXxx()和setXxx()用于获取和设置成员变量的值,方法用public修饰
*/
public class Student {
String name;
//int age;
private int age;public void setAge(int a) {
if(a<0 || a>200) {
System.out.println(“你给的年龄有误”);
}else {
age = a;
}
}public int getAge() {
return age;
}public void show() {
System.out.println(“姓名是：”+name+",年龄是："+age);
}
}
package com.itheima_05;
/*
-
学生类的测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
s.show();s.name = "林青霞"; //s.age = 28; //s.age = -28; //s.setAge(-28); s.setAge(28); s.show();}
}
19.1.2private最常见应用
A:把成员变量用private修饰
B:提供对应的getXxx()/setXxx()方法
19.1.2.1案例代码九:
package com.itheima_06;
/*
-
学生类
*/
public class Student {
private String name;
private int age;public void setName(String n) {
name = n;
}public String getName() {
return name;
}public void setAge(int a) {
age = a;
}public int getAge() {
return age;
}
}
package com.itheima_06;
/*
-
学生类的测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
System.out.println(s.getName()+"—"+s.getAge());s.setName("林青霞"); s.setAge(28); System.out.println(s.getName()+"---"+s.getAge());}
}
19.1.3封装的概述和好处:
A:封装概述
是面向对象三大特征之一
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。
B:封装原则：
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
成员变量private，提供对应的getXxx()/setXxx()方法
C:好处：
通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性
19.2this关键字
19.2.1this关键字由来和使用:
A:this:代表所在类的对象引用
方法被哪个对象调用，this就代表那个对象
B:什么时候使用this呢
局部变量和成员变量重名
19.2.1.1案例代码十:
package com.itheima_07;
/*
- 学生类
- 起名字我们要求做到见名知意。
- 而我们现在的代码中的n和a就没有做到见名知意，所以我要改进。
- 如果有局部变量名和成员变量名相同，在局部使用的时候，采用的是就近的原则。
- 我们有没有办法把局部变量的name赋值给成员变量的name呢?
- 有。
- 什么办法呢?
-
用this关键字就可以解决这个问题 - this:代表所在类的对象引用
-
方法被哪个对象调用，this就代表那个对象 - 使用场景：
-
局部变量隐藏成员变量
*/
public class Student {
private String name;
private int age;
public void setName(String name) { //"林青霞"
//name = name;
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
//age = age;
this.age = age;
}
public int getAge() {
return age;
}
}
package com.itheima_07;
/*
-
学生类的测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
System.out.println(s.getName()+"—"+s.getAge());s.setName("林青霞"); s.setAge(28); System.out.println(s.getName()+"---"+s.getAge());}
}
第20章面向对象之构造方法
20.1构造方法:
主要用来给对象的数据进行初始化
20.1.1构造方法格式:
A:构造方法格式
a:方法名与类名相同
b:没有返回值类型，连void都没有
c:没有具体的返回值
20.1.1.1案例代码十一:
package com.itheima_08;
/* -
构造方法：
-
给对象的数据进行初始化 -
格式：
-
方法名和类名相同 -
没有返回值类型，连void都不能写 -
没有具体的返回值
*/
public class Student {
public Student() {
System.out.println(“这是构造方法”);
}
}
package com.itheima_08;
public class StudentDemo {
public static void main(String[] args) {
//如何调用构造方法呢?
//通过new关键字调用
//格式：类名 对象名 = new 构造方法(…);
Student s = new Student();
}
}
20.1.2构造方法注意事项与重载
如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的,重载条件和普通方法相同
20.1.2.1案例代码十二:
package com.itheima_08;
/*
- 构造方法：
-
给对象的数据进行初始化 - 格式：
-
方法名和类名相同 -
没有返回值类型，连void都不能写 -
没有具体的返回值 - 构造方法的注意事项：
-
A:如果我们没有给出构造方法，系统将会提供一个默认的无参构造方法供我们使用。 -
B:如果我们给出了构造方法，系统将不在提供默认的无参构造方法供我们使用。 -
这个时候，如果我们想使用无参构造方法，就必须自己提供。 -
推荐：自己给无参构造方法 -
C:构造方法也是可以重载的 - 成员变量赋值：
-
A:setXxx()方法 -
B:带参构造方法
*/
public class Student {
private String name;
private int age;
/*
public Student() {
System.out.println("这是构造方法");
}
*/
public Student() {}
public Student(String name) {
this.name = name;
}
public Student(int age) {
this.age = age;
}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public void show() {
System.out.println(name+"---"+age);
}
}
package com.itheima_08;
public class StudentDemo {
public static void main(String[] args) {
//如何调用构造方法呢?
//通过new关键字调用
//格式：类名 对象名 = new 构造方法(…);
Student s = new Student();
s.show();
//public Student(String name)
Student s2 = new Student("林青霞");
s2.show();
//public Student(int age)
Student s3 = new Student(28);
s3.show();
//public Student(String name,int age)
Student s4 = new Student("林青霞",28);
s4.show();
}
}
20.1.3包含private,无参,有参构造的标准学生类代码:
A:类:
a:成员变量
b:构造方法
无参构造方法
带参构造方法
c:成员方法
getXxx()
setXxx()
B:给成员变量赋值的方式
a:无参构造方法+setXxx()
b:带参构造方法
20.1.3.1案例代码十三:
package com.itheima_09;
/*
-
学生类
*/
public class Student {
//成员变量
private String name;
private int age;//构造方法
public Student() {}public Student(String name,int age) {
this.name = name;
this.age = age;
}//成员方法
public void setName(String name) {
this.name = name;
}public String getName() {
return name;
}public void setAge(int age) {
this.age = age;
}public int getAge() {
return age;
}
}
package com.itheima_09;
/*
-
学生类的测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//无参+setXxx()
Student s = new Student();
s.setName(“林青霞”);
s.setAge(28);
System.out.println(s.getName()+"—"+s.getAge());//带参构造 Student s2 = new Student("林青霞",28); System.out.println(s2.getName()+"---"+s2.getAge());}
}
第21章类名作为形参和返回值
21.1类名作为方法的形式参数
21.1.1案例代码十四:
package com.itheima_10;
public class Student {
public void study() {
System.out.println(“好好学习,天天向上”);
}
}
package com.itheima_10;
public class Teacher {
public void test(Student s) {//接收传递过来的Student对象的地址值
s.study();
}
}
package com.itheima_10;
//需求： 调用Teacher的test方法
//类名作为形式参数：其实这里需要的是该类对象。
public class Test {
public static void main(String[] args) {
Teacher t = new Teacher();
Student s = new Student();
t.test(s);
}
}
21.2类名作为返回值案例
21.2.1案例代码十五:
package com.itheima_11;
public class Student {
public void study() {
System.out.println(“好好学习,天天向上”);
}
}
package com.itheima_11;
public class Teacher {
public Student getStudent() {
Student s = new Student();
return s;//返回的是Student对象的地址值
}
}
package com.itheima_11;
//需求： 通过Teacher得到Student对象，然后调用Student类的方法
//如果方法的返回值是类名：其实返回的是该类的对象
public class Test {
public static void main(String[] args) {
Teacher t = new Teacher();
Student s = t.getStudent();
s.study();
}
}
第08天 常用API
今日内容介绍
API概述
Scanner类与String类
StringBuilder类
第22章API概述
22.1API概念
API(Application Programming Interface) : 应用程序编程接口
编写一个机器人程序去控制机器人踢足球，程序就需要向机器人发出向前跑、向后跑、射门、抢球等各种命令，没有编过程序的人很难想象这样的程序如何编写。但是对于有经验的开发人员来说，知道机器人厂商一定会提供一些用于控制机器人的Java类，这些类中定义好了操作机器人各种动作的方法。其实，这些Java类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为API。本章涉及的Java API指的就是JDK中提供的各种功能的Java类
22.2快速使用API步骤:
A:打开帮助文档
B:点击显示，找到索引，看到输入框
C:你要学习什么内容，你就在框框里面输入什么内容
举例：Random
D:看包
java.lang包下的类在使用的时候是不需要导包的
E:看类的描述
Random类是用于生成随机数的类
F:看构造方法
Random():无参构造方法
Random r = new Random();
G:看成员方法
public int nextInt(int n):产生的是一个[0,n)范围内的随机数
调用方法：
看返回值类型：人家返回什么类型，你就用什么类型接收
看方法名：名字不要写错了
看形式参数：人家要几个参数，你就给几个，人家要什么数据类型的，你就给什么数据类型的
int number = r.nextInt(100);
第23章Scanner类 与 String类
23.1Scanner类
23.1.1Scanner类作用
用Scanner类的方法可以完成接收键盘录入的数据
23.1.2Scanner类接受键盘录入的字符串
23.1.2.1案例代码一:
package com.itheima_01;
import java.util.Scanner;
/*
-
Scanner:用于获取键盘录入的数据。(基本数据类型，字符串数据)
-
public String nextLine():获取键盘录入的字符串数据
*/
public class ScannerDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println(“请输入一个字符串数据：”);
String s = sc.nextLine();//输出结果 System.out.println("s:"+s);}
}
23.2String类
23.2.1String类概述
通过JDK提供的API，查看String类的说明
A:"abc"是String类的一个实例,或者成为String类的一个对象
B:字符串字面值"abc"也可以看成是一个字符串对象
C:字符串是常量，一旦被赋值，就不能被改变
D:字符串本质是一个字符数组
23.2.2String类的构造方法
String(String original):把字符串数据封装成字符串对象
String(char[] value):把字符数组的数据封装成字符串对象
String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象
23.2.2.1常用构造方法演示
23.2.2.1.1案例代码二:
package com.itheima_02;
/* -
String:字符串类
-
由多个字符组成的一串数据 -
字符串其本质是一个字符数组 -
构造方法：
-
String(String original):把字符串数据封装成字符串对象 -
String(char[] value):把字符数组的数据封装成字符串对象 -
String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象 -
注意：字符串是一种比较特殊的引用数据类型，直接输出字符串对象输出的是该对象中的数据。
*/
public class StringDemo {
public static void main(String[] args) {
//方式1
//String(String original):把字符串数据封装成字符串对象
String s1 = new String(“hello”);
System.out.println(“s1:”+s1);
System.out.println("---------");//方式2 //String(char[] value):把字符数组的数据封装成字符串对象 char[] chs = {'h','e','l','l','o'}; String s2 = new String(chs); System.out.println("s2:"+s2); System.out.println("---------"); //方式3 //String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象 //String s3 = new String(chs,0,chs.length); String s3 = new String(chs,1,3); System.out.println("s3:"+s3); System.out.println("---------"); //方式4 String s4 = "hello"; System.out.println("s4:"+s4);}
}
23.2.2.2创建字符串对象两种方式的区别
23.2.2.2.1案例代码三:
package com.itheima_02;
/*
- 通过构造方法创建的字符串对象和直接赋值方式创建的字符串对象有什么区别呢?
-
通过构造方法创建字符串对象是在堆内存。 -
直接赋值方式创建对象是在方法区的常量池。 - ==:
-
基本数据类型：比较的是基本数据类型的值是否相同 -
引用数据类型：比较的是引用数据类型的地址值是否相同
*/
public class StringDemo2 {
public static void main(String[] args) {
String s1 = new String(“hello”);
String s2 = “hello”;
System.out.println("s1:"+s1);
System.out.println("s2:"+s2);
System.out.println("s1==s2:"+(s1==s2)); //false
String s3 = "hello";
System.out.println("s1==s3:"+(s1==s3)); //false
System.out.println("s2==s3:"+(s2==s3)); //true
}
}
23.2.3String类的判断功能
boolean equals(Object obj):比较字符串的内容是否相同
boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
boolean startsWith(String str):判断字符串对象是否以指定的str开头
boolean endsWith(String str):判断字符串对象是否以指定的str结尾
23.2.3.1判断方法演示
23.2.3.1.1案例代码四:
package com.itheima_03;
/*
-
Object:是类层次结构中的根类，所有的类都直接或者间接的继承自该类。
-
如果一个方法的形式参数是Object，那么这里我们就可以传递它的任意的子类对象。
-
String类的判断功能：
-
boolean equals(Object obj):比较字符串的内容是否相同
-
boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
-
boolean startsWith(String str):判断字符串对象是否以指定的str开头
-
boolean endsWith(String str):判断字符串对象是否以指定的str结尾
*/
public class StringDemo {
public static void main(String[] args) {
//创建字符串对象
String s1 = “hello”;
String s2 = “hello”;
String s3 = “Hello”;//boolean equals(Object obj):比较字符串的内容是否相同 System.out.println(s1.equals(s2)); System.out.println(s1.equals(s3)); System.out.println("-----------"); //boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写 System.out.println(s1.equalsIgnoreCase(s2)); System.out.println(s1.equalsIgnoreCase(s3)); System.out.println("-----------"); //boolean startsWith(String str):判断字符串对象是否以指定的str开头 System.out.println(s1.startsWith("he")); System.out.println(s1.startsWith("ll"));}
}
23.2.3.2判断功能案例
需求:模拟登录,给三次机会,并提示还有几次
23.2.3.2.1案例代码五:
package com.itheima_03;
import java.util.Scanner;
/*
- 模拟登录,给三次机会,并提示还有几次。
- 分析：
-
A:定义两个字符串对象，用于存储已经存在的用户名和密码 -
B:键盘录入用户名和密码 -
C:拿键盘录入的用户名和密码和已经存在的用户名和密码进行比较 -
如果内容相同，提示登录成功 -
如果内容不同，提示登录失败，并提示还有几次机会
*/
public class StringTest {
public static void main(String[] args) {
//定义两个字符串对象，用于存储已经存在的用户名和密码
String username = “admin”;
String password = “admin”;
//给三次机会，用for循环实现
for(int x=0; x<3; x++) {
//键盘录入用户名和密码
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名：");
String name = sc.nextLine();
System.out.println("请输入密码：");
String pwd = sc.nextLine();
//拿键盘录入的用户名和密码和已经存在的用户名和密码进行比较
if(username.equals(name) && password.equals(pwd)) {
System.out.println("登录成功");
break;
}else {
if((2-x) ==0) {
System.out.println("用户名和密码被锁定,请与管理员联系");
}else {
System.out.println("登录失败,你还有"+(2-x)+"次机会"); //2,1,0
}
}
}
}
}
23.2.4String类的获取功能
23.2.4.1获取方法演示
package com.itheima_04;
/*
-
String类的获取功能：
-
int length():获取字符串的长度，其实也就是字符个数
-
char charAt(int index):获取指定索引处的字符
-
int indexOf(String str):获取str在字符串对象中第一次出现的索引
-
String substring(int start):从start开始截取字符串
-
String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end
*/
public class StringDemo {
public static void main(String[] args) {
//创建字符串对象
String s = “helloworld”;//int length():获取字符串的长度，其实也就是字符个数 System.out.println(s.length()); System.out.println("--------"); //char charAt(int index):获取指定索引处的字符 System.out.println(s.charAt(0)); System.out.println(s.charAt(1)); System.out.println("--------"); //int indexOf(String str):获取str在字符串对象中第一次出现的索引 System.out.println(s.indexOf("l")); System.out.println(s.indexOf("owo")); System.out.println(s.indexOf("ak")); System.out.println("--------"); //String substring(int start):从start开始截取字符串 System.out.println(s.substring(0)); System.out.println(s.substring(5)); System.out.println("--------"); //String substring(int start,int end):从start开始，到end结束截取字符串 System.out.println(s.substring(0, s.length())); System.out.println(s.substring(3,8));}
}
23.2.4.2获取功能案例
23.2.4.2.1 案例代码六:
package com.itheima_04;
/* -
遍历字符串(获取字符串中的每一个字符)
*/
public class StringTest {
public static void main(String[] args) {
//创建一个字符串对象
String s = “abcde”;//原始做法 System.out.println(s.charAt(0)); System.out.println(s.charAt(1)); System.out.println(s.charAt(2)); System.out.println(s.charAt(3)); System.out.println(s.charAt(4)); System.out.println("---------"); //用for循环改进 for(int x=0; x<5; x++) { System.out.println(s.charAt(x)); } System.out.println("---------"); //用length()方法获取字符串的长度 for(int x=0; x<s.length(); x++) { System.out.println(s.charAt(x)); }}
}
23.2.4.2.2 案例代码七:
package com.itheima_04;
import java.util.Scanner;
/*
- 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
- 分析：
-
A:键盘录入一个字符串数据 -
B:定义三个统计变量，初始化值都是0 -
C:遍历字符串，得到每一个字符 -
D:拿字符进行判断 -
假如ch是一个字符。 -
大写：ch>='A' && ch<='Z' -
小写：ch>='a' && ch<='z' -
数字：ch>='0' && ch<='9' -
E:输出结果
*/
public class StringTest2 {
public static void main(String[] args) {
//键盘录入一个字符串数据
Scanner sc = new Scanner(System.in);
System.out.println(“请输入一个字符串数据：”);
String s = sc.nextLine();
//定义三个统计变量，初始化值都是0
int bigCount = 0;
int smallCount = 0;
int numberCount = 0;
//遍历字符串，得到每一个字符
for(int x=0; x<s.length(); x++) {
char ch = s.charAt(x);
//拿字符进行判断
if(ch>='A' && ch<='Z') {
bigCount++;
}else if(ch>='a' && ch<='z') {
smallCount++;
}else if(ch>='0' && ch<='9') {
numberCount++;
}else {
System.out.println("该字符"+ch+"非法");
}
}
//输出结果
System.out.println("大写字符："+bigCount+"个");
System.out.println("小写字符："+smallCount+"个");
System.out.println("数字字符："+numberCount+"个");
}
}
23.2.5String类的转换功能
23.2.5.1转换方法演示
char[] toCharArray():把字符串转换为字符数组
String toLowerCase():把字符串转换为小写字符串
String toUpperCase():把字符串转换为大写字符串
23.2.5.1.1 案例代码八:
package com.itheima_05;
/*
- String类的转换功能：
- char[] toCharArray():把字符串转换为字符数组
- String toLowerCase():把字符串转换为小写字符串
- String toUpperCase():把字符串转换为大写字符串
- 字符串的遍历：
-
A:length()加上charAt() -
B:把字符串转换为字符数组，然后遍历数组
*/
public class StringDemo {
public static void main(String[] args) {
//创建字符串对象
String s = “abcde”;
//char[] toCharArray():把字符串转换为字符数组
char[] chs = s.toCharArray();
for(int x=0; x<chs.length; x++) {
System.out.println(chs[x]);
}
System.out.println("-----------");
//String toLowerCase():把字符串转换为小写字符串
System.out.println("HelloWorld".toLowerCase());
//String toUpperCase():把字符串转换为大写字符串
System.out.println("HelloWorld".toUpperCase());
}
}
23.2.5.2转换功能案例
23.2.5.2.1 案例代码九:
package com.itheima_05;
import java.util.Scanner;
/*
- 键盘录入一个字符串，把该字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
- 分析：
-
A:键盘录入一个字符串 -
B:截取首字母 -
C:截取除了首字母以外的字符串 -
D:B转大写+C转小写 -
E:输出即可
*/
public class StringTest {
public static void main(String[] args) {
//键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println(“请输入一个字符串：”);
String s = sc.nextLine();
//截取首字母
String s1 = s.substring(0, 1);
//截取除了首字母以外的字符串
String s2 = s.substring(1);
//B转大写+C转小写
String s3 = s1.toUpperCase()+s2.toLowerCase();
//输出即可
System.out.println("s3:"+s3);
}
}
23.2.6String类的其它功能
23.2.6.1其它方法演示
23.2.6.1.1 案例代码十:
package com.itheima_06;
/*
- 去除字符串两端空格
-
String trim() - 按照指定符号分割字符串
-
String[] split(String str)
*/
public class StringDemo {
public static void main(String[] args) {
//创建字符串对象
String s1 = “helloworld”;
String s2 = " helloworld “;
String s3 = " hello world “;
System.out.println(”—”+s1+"—");
System.out.println("—"+s1.trim()+"—");
System.out.println("—"+s2+"—");
System.out.println("—"+s2.trim()+"—");
System.out.println("—"+s3+"—");
System.out.println("—"+s3.trim()+"—");
System.out.println("-------------------");
//String[] split(String str)
//创建字符串对象
String s4 = "aa,bb,cc";
String[] strArray = s4.split(",");
for(int x=0; x<strArray.length; x++) {
System.out.println(strArray[x]);
}
}
}
23.2.7String类的其它案例
23.2.7.1 案例代码十一:
package com.itheima_07;
/*
- 把数组中的数据按照指定个格式拼接成一个字符串
- 举例：int[] arr = {1,2,3};
- 输出结果：[1, 2, 3]
- 分析：
-
A:定义一个int类型的数组 -
B:写方法实现把数组中的元素按照指定的格式拼接成一个字符串 -
C:调用方法 -
D:输出结果
*/
public class StringTest {
public static void main(String[] args) {
//定义一个int类型的数组
int[] arr = {1,2,3};
//写方法实现把数组中的元素按照指定的格式拼接成一个字符串
//调用方法
String s = arrayToString(arr);
//输出结果
System.out.println("s:"+s);
}
/*
* 两个明确：
* 返回值类型：String
* 参数列表：int[] arr
*/
public static String arrayToString(int[] arr) {
String s = "";
//[1, 2, 3]
s += "[";
for(int x=0; x<arr.length; x++) {
if(x==arr.length-1) {
s += arr[x];
}else {
s += arr[x];
s += ", ";
}
}
s += "]";
return s;
}
}
23.2.7.2 案例代码十二:
package com.itheima_07;
import java.util.Scanner;
/*
- 字符串反转
- 举例：键盘录入”abc”
- 输出结果：”cba”
- 分析：
-
A:键盘录入一个字符串 -
B:写方法实现字符串的反转 -
a:把字符串倒着遍历，得到的每一个字符拼接成字符串。 -
b:把字符串转换为字符数组，然后对字符数组进行反转，最后在把字符数组转换为字符串 -
C:调用方法 -
D:输出结果
*/
public class StringTest2 {
public static void main(String[] args) {
//键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println(“请输入一个字符串：”);
String s = sc.nextLine();
//写方法实现字符串的反转
//调用方法
String result = reverse(s);
//输出结果
System.out.println("result:"+result);
}
/*
* 把字符串倒着遍历，得到的每一个字符拼接成字符串。
*
* 两个明确：
* 返回值类型：String
* 参数列表：String s
*/
/*
public static String reverse(String s) {
String ss = "";
for(int x=s.length()-1; x>=0; x--) {
ss += s.charAt(x);
}
return ss;
}
*/
//把字符串转换为字符数组，然后对字符数组进行反转，最后在把字符数组转换为字符串
public static String reverse(String s) {
//把字符串转换为字符数组
char[] chs = s.toCharArray();
//对字符数组进行反转
for(int start=0,end=chs.length-1; start<=end; start++,end--) {
char temp = chs[start];
chs[start] = chs[end];
chs[end] = temp;
}
//最后在把字符数组转换为字符串
String ss = new String(chs);
return ss;
}
}
第24章StringBuilder类
24.1StringBuilder类概述
StringBuilder:是一个可变的字符串。字符串缓冲区类。
String和StringBuilder的区别：
String的内容是固定的
StringBuilder的内容是可变的
24.1.1+=拼接字符串耗费内存原因:
每次拼接都会产生新的字符串对象,而利用StringBuilder来拼接字符串自始至终用的都是同一个StringBuilder容器
24.2StringBuilder类的常用方法
A:构造方法:
StringBuilder()
B:成员方法:
public int capacity():返回当前容量 (理论值)
public int length():返回长度(已经存储的字符个数)
public StringBuilder append(任意类型):添加数据，并返回自身对象
public StringBuilder reverse():反转功能
24.2.1案例代码十三:
package com.itheima_01;
/*
- StringBuilder:是一个可变的字符串。字符串缓冲区类。
- String和StringBuilder的区别：
-
String的内容是固定的。 -
StringBuilder的内容是可变的。 - 构造方法：
-
StringBuilder() - 成员方法：
-
public int capacity():返回当前容量 -
public int length():返回长度（字符数） -
容量：理论值 -
长度：实际值
/
public class StringBuilderDemo {
public static void main(String[] args) {
//创建对象
StringBuilder sb = new StringBuilder();
System.out.println(“sb:”+sb);
System.out.println(“sb.capacity():”+sb.capacity());
System.out.println(“sb.length():”+sb.length());
}
}
24.2.2案例代码十四:
package com.itheima_02;
/
- 添加功能
-
public StringBuilder append(任意类型):添加数据，并返回自身对象 - 反转功能
-
public StringBuilder reverse()
*/
public class StringBuilderDemo {
public static void main(String[] args) {
//创建对象
StringBuilder sb = new StringBuilder();
//public StringBuilder append(任意类型)
//StringBuilder sb2 = sb.append("hello");
/*
System.out.println("sb:"+sb);
System.out.println("sb2:"+sb2);
System.out.println(sb == sb2); //true
*/
/*
sb.append("hello");
sb.append("world");
sb.append(true);
sb.append(100);
*/
//链式编程
sb.append("hello").append("world").append(true).append(100);
System.out.println("sb:"+sb);
//public StringBuilder reverse()
sb.reverse();
System.out.println("sb:"+sb);
}
}
24.3StringBuilder案例
24.3.1案例一需求:
StringBuilder和String通过方法完成相互转换
24.3.1.1案例代码十五:
package com.itheima_03;
/*
- StringBuilder和String的相互转换
- StringBuilder – String
-
public String toString():通过toString()就可以实现把StringBuilder转成String - String – StringBuilder
-
StringBuilder(String str):通过构造方法就可以实现把String转成StringBuilder
/
public class StringBuilderTest {
public static void main(String[] args) {
//StringBuilder – String
/
StringBuilder sb = new StringBuilder();
sb.append(“hello”).append(“world”);
String s = sb.toString();
System.out.println(s);
*/
//String -- StringBuilder
String s = "helloworld";
StringBuilder sb = new StringBuilder(s);
System.out.println(sb);
}
}
24.3.2案例二需求:
利用StringBuilder把数组拼接成一个字符串
举例：
int[] arr = {1,2,3};
结果：
[1, 2, 3]
24.3.2.1案例代码十六:
package com.itheima_03;
/*
- 把数组拼接成一个字符串
- 举例：
-
int[] arr = {1,2,3}; - 结果：
-
[1, 2, 3]
*/
public class StringBuilderTest2 {
public static void main(String[] args) {
//定义一个数组
int[] arr = {1,2,3};
//写方法实现拼接
//调用方法
String s = arrayToString(arr);
//输出结果
System.out.println("s:"+s);
}
/*
* 两个明确：
* 返回值类型：String
* 参数列表：int[] arr
*/
public static String arrayToString(int[] arr) {
StringBuilder sb = new StringBuilder();
//[1, 2, 3]
sb.append("[");
for(int x=0; x<arr.length; x++) {
if(x==arr.length-1) {
sb.append(arr[x]);
}else {
sb.append(arr[x]).append(", ");
}
}
sb.append("]");
String result = sb.toString();
return result;
}
}
24.3.3案例三需求:
利用StringBuilder完成字符串反转
24.3.3.1案例代码十七:
package com.itheima_03;
import java.util.Scanner;
/*
- 把字符串反转
- 分析：
-
A:键盘录入一个字符串 -
B:写方法实现反转 -
String -- StringBuilder -- reverse() -- String -
C:调用方法 -
D:输出结果
*/
public class StringBuilderTest3 {
public static void main(String[] args) {
//键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println(“请输入一个字符串：”);
String s = sc.nextLine();
//写方法实现反转
//调用方法
String result = myReverse(s);
//输出结果
System.out.println("result:"+result);
}
/*
* 两个明确：
* 返回值类型：String
* 参数列表：String
*/
public static String myReverse(String s) {
//String -- StringBuilder -- reverse() -- String
StringBuilder sb = new StringBuilder(s);
sb.reverse();
String result = sb.toString();
return result;
}
}
24.3.4案例四需求:
判断一个字符串是否是对称字符串
例如"abc"不是对称字符串，“aba”、“abba”、“aaa”、"mnanm"是对称字符串
24.3.4.1案例代码十八:
package com.itheima_03;
import java.util.Scanner;
/*
- 判断一个字符串是否是对称字符串
- 例如"abc"不是对称字符串，“aba”、“abba”、“aaa”、"mnanm"是对称字符串
- 分析：
-
A:键盘录入一个字符串 -
B:写方法实现判断一个字符串是否是对称字符串 -
把字符串反转，和反转前的字符串进行比较，如果内容相同，就说明是对称字符串 -
C:调用方法 -
D:输出结果
*/
public class StringBuilderTest4 {
public static void main(String[] args) {
//键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println(“请输入一个字符串：”);
String s = sc.nextLine();
//写方法实现判断一个字符串是否是对称字符串
//调用方法
boolean b = isSymmetry(s);
//输出结果
System.out.println("b:"+b);
}
/*
* 两个明确：
* 返回值类型：boolean
* 参数列表：String s
*/
public static boolean isSymmetry(String s) {
//把字符串反转，和反转前的字符串进行比较，如果内容相同，就说明是对称字符串
StringBuilder sb = new StringBuilder(s);
sb.reverse();
String result = sb.toString();
return result.equals(s);
}
}
第09天 java集合
今日内容介绍
对象数组
集合类之ArrayList
学生管理系统案例
第25章对象数组
25.1对象数组概述
A:基本类型的数组:存储的元素为基本类型
int[] arr={1,2,3,4}
B:对象数组:存储的元素为引用类型
Student[] stus=new Student[3];
Student代表一个自定义类
Stus数组中stus[0],stus[1],stus[2]的元素数据类型为Student,
都可以指向一个Student对象
25.2对象数组案例:
创建一个学生数组，存储三个学生对象并遍历
25.2.1 案例代码一:
package com.itheima;
/*
- 自动生成构造方法：
-
代码区域右键 -- Source -- Generate Constructors from Superclass... 无参构造方法 -
代码区域右键 -- Source -- Generate Constructor using Fields... 带参构造方法 - 自动生成getXxx()/setXxx():
-
代码区域右键 -- Source -- Generate Getters and Setters...
*/
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;
/*
- 创建一个学生数组，存储三个学生对象并遍历
- 分析：
-
A:定义学生类 -
B:创建学生数组 -
C:创建学生对象 -
D:把学生对象作为元素赋值给学生数组 -
E:遍历学生数组
*/
public class StudentDemo {
public static void main(String[] args) {
//创建学生数组
Student[] students = new Student[3];
//创建学生对象
Student s1 = new Student("曹操",40);
Student s2 = new Student("刘备",35);
Student s3 = new Student("孙权",30);
//把学生对象作为元素赋值给学生数组
students[0] = s1;
students[1] = s2;
students[2] = s3;
//遍历学生数组
for(int x=0; x<students.length; x++) {
Student s = students[x];
//System.out.println(s);
System.out.println(s.getName()+"---"+s.getAge());
}
}
}
25.3对象数组的内存图
第26章集合类之ArrayList
26.1集合概述
A:我们学习的是面向对象编程语言，而面向对象编程语言对事物的描述都是通过对象来体现的。
为了方便对多个对象进行操作，我们就必须对这多个对象进行存储，而要想对多个对象进行存储， 就不能是一个基本的变量，而应该是一个容器类型的变量。
B:到目前为止，我们学习过了哪些容器类型的数据呢？
StringBuilder,数组。
StringBuilder的结果只能是一个字符串类型，不一定满足我们的需求。
所以，我们目前只能选择数组了，也就是我们前面学习过的对象数组。
但是，数组的长度是固定的， 如果有时候元素的个数不确定的,我们无法定义出数组的长度,这个时候，java就提供了集合类供我们使用。
26.2ArrayList集合
26.2.1ArrayList添加新元素
26.2.1.1案例代码二:
package com.itheima_01;
import java.util.ArrayList;
/*
- 为什么会出现集合类：
-
我们学习的是面向对象编程语言，而面向对象编程语言对事物的描述都是通过对象来体现的。 -
为了方便对多个对象进行操作，我们就必须对这多个对象进行存储，而要想对多个对象进行存储， -
就不能是一个基本的变量，而应该是一个容器类型的变量。 -
到目前为止，我们学习过了哪些容器类型的数据呢？StringBuilder,数组。 -
StringBuilder的结果只能是一个字符串类型，不一定满足我们的需求。 -
所以，我们目前只能选择数组了，也就是我们前面学习过的对象数组。 -
但是，数组的长度是固定的，适应不了变化的需求，那么，我们该如何选择呢? -
这个时候，java就提供了集合类供我们使用。 - 集合类的特点：
-
长度可变。 - ArrayList:
-
大小可变数组的实现 -
<E>:是一种特殊的数据类型，泛型。 -
怎么用呢? -
在出现E的地方我们使用引用数据类型替换即可 -
举例：ArrayList<String>,ArrayList<Student> - 构造方法：
-
ArrayList() - 添加元素：
-
public boolean add(E e):添加元素 -
public void add(int index,E element):在指定的索引处添加一个元素
*/
public class ArrayListDemo {
public static void main(String[] args) {
//创建集合对象
ArrayList array = new ArrayList();
//add(E e):添加元素
array.add("hello");
array.add("world");
array.add("java");
//add(int index,E element):在指定的索引处添加一个元素
//array.add(1, "android");
System.out.println("array:"+array);
}
}
26.2.2ArrayList删改查方法
A:获取元素
public E get(int index):返回指定索引处的元素
B:集合长度
public int size():返回集合中的元素的个数
C:删除元素
public boolean remove(Object o):删除指定的元素，返回删除是否成功
public E remove(int index):删除指定索引处的元素，返回被删除的元素
D:修改元素
public E set(int index,E element):修改指定索引处的元素，返回被修改的元素
26.2.2.1案例代码三:
package com.itheima_01;
import java.util.ArrayList;
/*
- 获取元素
-
public E get(int index):返回指定索引处的元素 - 集合长度
-
public int size():返回集合中的元素的个数 - 删除元素
-
public boolean remove(Object o):删除指定的元素，返回删除是否成功 -
public E remove(int index):删除指定索引处的元素，返回被删除的元素 - 修改元素
-
public E set(int index,E element):修改指定索引处的元素，返回被修改的元素
*/
public class ArrayListDemo2 {
public static void main(String[] args) {
//创建集合对象
ArrayList array = new ArrayList();
//添加元素
array.add("hello");
array.add("world");
array.add("java");
//public E get(int index):返回指定索引处的元素
//System.out.println("get:"+array.get(0));
//System.out.println("get:"+array.get(1));
//System.out.println("get:"+array.get(2));
//public int size():返回集合中的元素的个数
//System.out.println("size:"+array.size());
//public boolean remove(Object o):删除指定的元素，返回删除是否成功
//System.out.println("remove:"+array.remove("world"));//true
//System.out.println("remove:"+array.remove("world"));//false
//public E remove(int index):删除指定索引处的元素，返回被删除的元素
//System.out.println("remove:"+array.remove(0));
//public E set(int index,E element):修改指定索引处的元素，返回被修改的元素
System.out.println("set:"+array.set(1, "android"));
//输出
System.out.println("array:"+array);
}
}
26.2.3ArrayList遍历
集合的遍历思想和数组的遍历思想相同
循环遍历容器,依次取出里面的元素即可
26.2.3.1案例代码四:
package com.itheima_01;
import java.util.ArrayList;
/*
- ArrayList集合的遍历
-
通过size()和get()配合实现的
*/
public class ArrayListDemo3 {
public static void main(String[] args) {
//创建集合对象
ArrayList array = new ArrayList();
//添加元素
array.add("hello");
array.add("world");
array.add("java");
//获取元素
//原始做法
System.out.println(array.get(0));
System.out.println(array.get(1));
System.out.println(array.get(2));
System.out.println("----------");
for(int x=0; x<3; x++) {
System.out.println(array.get(x));
}
System.out.println("----------");
//如何知道集合中元素的个数呢?size()
for(int x=0; x<array.size(); x++) {
System.out.println(array.get(x));
}
System.out.println("----------");
//最标准的用法
for(int x=0; x<array.size(); x++) {
String s = array.get(x);
System.out.println(s);
}
}
}
26.3ArrayList集合案例
26.3.1ArrayList练习之存储字符串并遍历
向集合中添加任意四个字符串,遍历集合,依次打印取出的字符串
26.3.1.1案例代码五:
package com.itheima_02;
import java.util.ArrayList;
/*
- 存储字符串并遍历
- 分析：
-
A:创建集合对象 -
B:添加字符串元素 -
C:遍历集合
*/
public class ArrayListTest {
public static void main(String[] args) {
//创建集合对象
ArrayList array = new ArrayList();
//添加字符串元素
array.add("向问天");
array.add("刘正风");
array.add("左冷禅");
array.add("风清扬");
//遍历集合
for(int x=0; x<array.size(); x++) {
String s = array.get(x);
System.out.println(s);
}
}
}
26.3.2ArrayList练习之获取满足要求的元素
给定一个字符串数组：{“张三丰”,“宋远桥”,“张无忌”,“殷梨亭”“张翠山”,“莫声谷”}，将数组中的元素添加到集合中，并把所有姓张的人员打印到控制台上
26.3.2.1案例代码六:
package com.itheima_02;
import java.util.ArrayList;
/*
- 给定一个字符串数组：{“张三丰”,“宋远桥”,“张无忌”,“殷梨亭”,“张翠山”,“莫声谷”}，将数组中的元素添加到集合中，并把所有姓张的人员打印到控制台上。
- 分析：
-
A:定义字符串数组 -
B:创建集合对象 -
C:遍历字符串数组，获取到每一个字符串元素 -
D:把获取到的字符串元素添加到集合 -
E:遍历集合 -
要判断每一个字符串元素是否以"张"开头，如果是，就输出在控制台
*/
public class ArrayListTest2 {
public static void main(String[] args) {
//定义字符串数组
String[] strArray = {“张三丰”,“宋远桥”,“张无忌”,“殷梨亭”,“张翠山”,“莫声谷”};
//创建集合对象
ArrayList<String> array = new ArrayList<String>();
//遍历字符串数组，获取到每一个字符串元素
for(int x=0; x<strArray.length; x++) {
//把获取到的字符串元素添加到集合
array.add(strArray[x]);
}
//遍历集合
for(int x=0; x<array.size(); x++) {
String s = array.get(x);
//要判断每一个字符串元素是否以"张"开头，如果是，就输出在控制台
if(s.startsWith("张")) {
System.out.println(s);
}
}
}
}
26.3.3ArrayList练习之存储自定义对象并遍历
A:自定义一个学生类,学生中有姓名和年龄属性,生成满参构造与空参构造
生成属性对应的getter/setter方法
B:在测试类中使用满参构造创建三个学生对象,然后将每个学生对象均添加到ArrayList集合中
C:遍历这个ArrayList集合,依次打印出每个学生的姓名和年龄
26.3.3.1案例代码七:
package com.itheima_02;
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_02;
import java.util.ArrayList;
/*
- 存储自定义对象并遍历
- 分析：
-
A:定义学生类 -
B:创建集合对象 -
C:创建学生对象 -
D:把学生对象作为元素添加到集合中 -
E:遍历集合
*/
public class ArrayListTest3 {
public static void main(String[] args) {
//创建集合对象
ArrayList array = new ArrayList();
//创建学生对象
Student s1 = new Student("林青霞",28);
Student s2 = new Student("张曼玉",30);
Student s3 = new Student("景甜",25);
Student s4 = new Student("柳岩",18);
//把学生对象作为元素添加到集合中
array.add(s1);
array.add(s2);
array.add(s3);
array.add(s4);
//遍历集合
for(int x=0; x<array.size(); x++) {
Student s = array.get(x);
System.out.println(s.getName()+"---"+s.getAge());
}
}
}
26.3.4ArrayList练习之键盘录入数据存储并遍历
创建一个Student类包含姓名和年龄属性
创建一个ArrayList集合
向集合中添加三个Student对象Student对象中姓名和年龄的数据均来自与键盘录入
最终遍历这个集合,取出Student对象以及里面属性的值
26.3.4.1案例代码八:
package com.itheima_03;
public class Student {
private String name;
private String age;
public Student() {
}
public Student(String name, String age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
}
package com.itheima_03;
import java.util.ArrayList;
import java.util.Scanner;
/*
- 创建一个集合，存储学生对象，学生对象的数据来自于键盘录入，最后，遍历集合
- 注意：为了方便使用，我把学生类中的所有成员定义为String类型
- 分析：
-
A:定义学生类 -
B:创建集合对象 -
C:键盘录入数据,创建学生对象,把键盘录入的数据赋值给学生对象的成员变量 -
D:把学生对象作为元素存储到集合中 -
E:遍历集合
*/
public class StudentDemo {
public static void main(String[] args) {
//创建集合对象
ArrayList array = new ArrayList();
/*
//键盘录入数据,创建学生对象,把键盘录入的数据赋值给学生对象的成员变量
Scanner sc = new Scanner(System.in);
System.out.println("请输入学生姓名：");
String name = sc.nextLine();
System.out.println("请输入学生年龄：");
String age = sc.nextLine();
Student s = new Student();
s.setName(name);
s.setAge(age);
//把学生对象作为元素存储到集合中
array.add(s);
*/
//为了提高代码的复用性，我把键盘录入数据给学生对象，并存储到集合中的动作用一个方法来实现
//调用方法
addStudent(array);
addStudent(array);
addStudent(array);
//遍历集合
for(int x=0; x<array.size(); x++) {
Student s = array.get(x);
System.out.println(s.getName()+"---"+s.getAge());
}
}
/*
* 两个明确：
* 返回值类型：void
* 参数列表：ArrayList<Student> array
*/
public static void addStudent(ArrayList<Student> array) {
//键盘录入数据,创建学生对象,把键盘录入的数据赋值给学生对象的成员变量
Scanner sc = new Scanner(System.in);
System.out.println("请输入学生姓名：");
String name = sc.nextLine();
System.out.println("请输入学生年龄：");
String age = sc.nextLine();
Student s = new Student();
s.setName(name);
s.setAge(age);
//把学生对象作为元素存储到集合中
array.add(s);
}
}
第27章学生管理系统案例
27.1学生管理系统案例需求
利用集合完成对学生的增删改查四个功能
27.2学生管理系统案例实现
27.2.1创建学生类:
27.2.1.1案例代码九:
package com.itheima;
/*
-
这是我的学生类
*/
public class Student {
//学号
private String id;
//姓名
private String name;
//年龄
private String age;
//居住地
private String address;public Student() {
}
public Student(String id, String name, String age, String address) {
this.id = id;
this.name = name;
this.age = age;
this.address = address;
}public String getId() {
return id;
}public void setId(String id) {
this.id = id;
}public String getName() {
return name;
}public void setName(String name) {
this.name = name;
}public String getAge() {
return age;
}public void setAge(String age) {
this.age = age;
}public String getAddress() {
return address;
}public void setAddress(String address) {
this.address = address;
}
}
27.2.2学生管理系统界面实现:
27.2.2.1案例代码十:
package com.itheima;
import java.util.ArrayList;
import java.util.Scanner;
/*
-
这是我的学生管理系统的主类
-
步骤如下：
-
A:定义学生类
-
B:学生管理系统的主界面的代码编写
-
C:学生管理系统的查看所有学生的代码编写
-
D:学生管理系统的添加学生的代码编写
-
E:学生管理系统的删除学生的代码编写
-
F:学生管理系统的修改学生的代码编写
*/
public class StudentManagerTest {
public static void main(String[] args) {
// 创建集合对象，用于存储学生数据
ArrayList array = new ArrayList();// 为了让程序能够回到这里来，我们使用循环 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("请输入你的选择："); // 创建键盘录入对象 Scanner sc = new Scanner(System.in); String choiceString = sc.nextLine(); // 用switch语句实现选择 switch (choiceString) { case "1": // 查看所有学生 break; case "2": // 添加学生 break; case "3": // 删除学生 break; case "4": // 修改学生 break; case "5": // 退出 // System.out.println("谢谢你的使用"); // break; default: System.out.println("谢谢你的使用"); System.exit(0); // JVM退出 break; } }}
}
27.2.3学生管理系统之查询所有学生功能
27.2.3.1案例代码十一:
package com.itheima.test;
import java.util.ArrayList;
import java.util.Scanner;
/*
-
这是我的学生管理系统的主类
-
步骤如下：
-
A:定义学生类
-
B:学生管理系统的主界面的代码编写
-
C:学生管理系统的查看所有学生的代码编写
-
D:学生管理系统的添加学生的代码编写
-
E:学生管理系统的删除学生的代码编写
-
F:学生管理系统的修改学生的代码编写
*/
public class StudentManagerTest {
public static void main(String[] args) {
//创建集合对象，用于存储学生数据
ArrayList array = new ArrayList();//为了让程序能够回到这里来，我们使用循环 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("请输入你的选择："); //创建键盘录入对象 Scanner sc = new Scanner(System.in); String choiceString = sc.nextLine(); //用switch语句实现选择 switch(choiceString) { case "1": //查看所有学生 findAllStudent(array); break; case "2": //添加学生 break; case "3": //删除学生 break; case "4": //修改学生 break; case "5": //退出 //System.out.println("谢谢你的使用"); //break; default: System.out.println("谢谢你的使用"); System.exit(0); //JVM退出 break; } }}
//查看所有学生
public static void findAllStudent(ArrayList array) {
//首先来判断集合中是否有数据，如果没有数据，就给出提示，并让该方法不继续往下执行
if(array.size() == 0) {
System.out.println(“不好意思,目前没有学生信息可供查询,请回去重新选择你的操作”);
return;
}//\t 其实就是一个tab键的位置 System.out.println("学号\t\t姓名\t年龄\t居住地"); for(int x=0; x<array.size(); x++) { Student s = array.get(x); System.out.println(s.getId()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getAddress()); }}
}
27.2.4学生管理系统之添加学生功能
27.2.4.1案例代码十二:
package com.itheima;
import java.util.ArrayList;
import java.util.Scanner;
/*
-
这是我的学生管理系统的主类
-
步骤如下：
-
A:定义学生类
-
B:学生管理系统的主界面的代码编写
-
C:学生管理系统的查看所有学生的代码编写
-
D:学生管理系统的添加学生的代码编写
-
E:学生管理系统的删除学生的代码编写
-
F:学生管理系统的修改学生的代码编写
*/
public class StudentManagerTest {
public static void main(String[] args) {
//创建集合对象，用于存储学生数据
ArrayList array = new ArrayList();//为了让程序能够回到这里来，我们使用循环 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("请输入你的选择："); //创建键盘录入对象 Scanner sc = new Scanner(System.in); String choiceString = sc.nextLine(); //用switch语句实现选择 switch(choiceString) { case "1": //查看所有学生 break; case "2": //添加学生 addStudent(array); break; case "3": //删除学生 break; case "4": //修改学生 break; case "5": //退出 //System.out.println("谢谢你的使用"); //break; default: System.out.println("谢谢你的使用"); System.exit(0); //JVM退出 break; } }}
/*
//添加学生
public static void addStudent(ArrayList array) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);System.out.println("请输入学生学号："); String id = sc.nextLine(); System.out.println("请输入学生姓名："); String name = sc.nextLine(); System.out.println("请输入学生年龄："); String age = sc.nextLine(); System.out.println("请输入学生居住地："); String address = sc.nextLine(); //创建学生对象 Student s = new Student(); s.setId(id); s.setName(name); s.setAge(age); s.setAddress(address); //把学生对象作为元素添加到集合 array.add(s); //给出提示 System.out.println("添加学生成功");}
*/
//添加学生
public static void addStudent(ArrayList array) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);//为了让id能够被访问到，我们就把id定义在了循环的外面 String id; //为了让代码能够回到这里，用循环 while(true) { System.out.println("请输入学生学号："); //String id = sc.nextLine(); id = sc.nextLine(); //判断学号有没有被人占用 //定义标记 boolean flag = false; //遍历集合，得到每一个学生 for(int x=0; x<array.size(); x++) { Student s = array.get(x); //获取该学生的学号，和键盘录入的学号进行比较 if(s.getId().equals(id)) { flag = true; //说明学号被占用了 break; } } if(flag) { System.out.println("你输入的学号已经被占用,请重新输入"); }else { break; //结束循环 } } System.out.println("请输入学生姓名："); String name = sc.nextLine(); System.out.println("请输入学生年龄："); String age = sc.nextLine(); System.out.println("请输入学生居住地："); String address = sc.nextLine(); //创建学生对象 Student s = new Student(); s.setId(id); s.setName(name); s.setAge(age); s.setAddress(address); //把学生对象作为元素添加到集合 array.add(s); //给出提示 System.out.println("添加学生成功");}
}
27.2.5学生管理系统之删除学生功能
27.2.5.1案例代码十三:
package com.itheima;
import java.util.ArrayList;
import java.util.Scanner;
/*
-
这是我的学生管理系统的主类
-
步骤如下：
-
A:定义学生类
-
B:学生管理系统的主界面的代码编写
-
C:学生管理系统的查看所有学生的代码编写
-
D:学生管理系统的添加学生的代码编写
-
E:学生管理系统的删除学生的代码编写
-
F:学生管理系统的修改学生的代码编写
*/
public class StudentManagerTest {
public static void main(String[] args) {
//创建集合对象，用于存储学生数据
ArrayList array = new ArrayList();//为了让程序能够回到这里来，我们使用循环 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("请输入你的选择："); //创建键盘录入对象 Scanner sc = new Scanner(System.in); String choiceString = sc.nextLine(); //用switch语句实现选择 switch(choiceString) { case "1": //查看所有学生 break; case "2": //添加学生 break; case "3": //删除学生 deleteStudent(array); break; case "4": //修改学生 break; case "5": //退出 //System.out.println("谢谢你的使用"); //break; default: System.out.println("谢谢你的使用"); System.exit(0); //JVM退出 break; } }}
//删除学生
public static void deleteStudent(ArrayList array) {
//删除学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就删除该学生
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println(“请输入你要删除的学生的学号：”);
String id = sc.nextLine();/* //遍历集合 for(int x=0; x<array.size(); x++) { //获取到每一个学生对象 Student s = array.get(x); //拿这个学生对象的学号和键盘录入的学号进行比较 if(s.getId().equals(id)) { array.remove(x); //根据索引删除 break; } } //给出提示 System.out.println("删除学生成功"); */ //我们必须给出学号不存在的时候的提示 //定义一个索引 int index = -1; //遍历集合 for(int x=0; x<array.size(); x++) { //获取到每一个学生对象 Student s = array.get(x); //拿这个学生对象的学号和键盘录入的学号进行比较 if(s.getId().equals(id)) { index = x; break; } } if(index == -1) { System.out.println("不好意思,你要删除的学号对应的学生信息不存在,请回去重新你的选择"); }else { array.remove(index); System.out.println("删除学生成功"); }}
}
27.2.6学生管理系统之修改学生功能
27.2.6.1案例代码十四:
package com.itheima;
import java.util.ArrayList;
import java.util.Scanner;
/*
-
这是我的学生管理系统的主类
-
步骤如下：
-
A:定义学生类
-
B:学生管理系统的主界面的代码编写
-
C:学生管理系统的查看所有学生的代码编写
-
D:学生管理系统的添加学生的代码编写
-
E:学生管理系统的删除学生的代码编写
-
F:学生管理系统的修改学生的代码编写
*/
public class StudentManagerTest {
public static void main(String[] args) {
//创建集合对象，用于存储学生数据
ArrayList array = new ArrayList();//为了让程序能够回到这里来，我们使用循环 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("请输入你的选择："); //创建键盘录入对象 Scanner sc = new Scanner(System.in); String choiceString = sc.nextLine(); //用switch语句实现选择 switch(choiceString) { case "1": //查看所有学生 break; case "2": //添加学生 break; case "3": //删除学生 break; case "4": //修改学生 updateStudent(array); break; case "5": //退出 //System.out.println("谢谢你的使用"); //break; default: System.out.println("谢谢你的使用"); System.exit(0); //JVM退出 break; } }}
//修改学生
public static void updateStudent(ArrayList array) {
//修改学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就修改该学生
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println(“请输入你要修改的学生的学号：”);
String id = sc.nextLine();//定义一个索引 int index = -1; //遍历集合 for(int x=0; x<array.size(); x++) { //获取每一个学生对象 Student s = array.get(x); //拿学生对象的学号和键盘录入的学号进行比较 if(s.getId().equals(id)) { index = x; break; } } if(index == -1) { System.out.println("不好意思,你要修改的学号对应的学生信息不存在,请回去重新你的选择"); }else { System.out.println("请输入学生新姓名："); String name = sc.nextLine(); System.out.println("请输入学生新年龄："); String age = sc.nextLine(); System.out.println("请输入学生新居住地："); String address = sc.nextLine(); //创建学生对象 Student s = new Student(); s.setId(id); s.setName(name); s.setAge(age); s.setAddress(address); //修改集合中的学生对象 array.set(index, s); //给出提示 System.out.println("修改学生成功"); }}
}
第10天 IO
今日内容介绍
IO流概述及FileWriter类使用
FileReader类使用
缓冲流介绍和使用
IO流相关案例
第28章IO流概述及FileWriter类使用
28.1IO流概述及分类
IO流用来处理设备之间的数据传输
Java对数据的操作是通过流的方式
Java用于操作流的类都在IO包中
流按流向分为两种：输入流，输出流
28.2FileWriter类使用
A:打开帮助文档
B:点击显示，找到索引，看到输入框
C:你要学习什么内容，你就在框框里面输入什么内容
举例：Random
D:看包
java.lang包下的类在使用的时候是不需要导包的
E:看类的描述
Random类是用于生成随机数的类
F:看构造方法
Random():无参构造方法
Random r = new Random();
G:看成员方法
public int nextInt(int n):产生的是一个[0,n)范围内的随机数
调用方法：
看返回值类型：人家返回什么类型，你就用什么类型接收
看方法名：名字不要写错了
看形式参数：人家要几个参数，你就给几个，人家要什么数据类型的，你就给什么数据类型的
int number = r.nextInt(100);
28.2.1FileWriter向文件中写数据
A:FileWriter向文件中写数据操作步骤:
a:使用FileWriter流关联文件
b:利用FileWriter的写方法写数据
c:利用FileWriter的刷新方法将数据从内存刷到硬盘上
d:利用FileWriter的关流方法将释放占用的系统底层资源
B:FileWriter方法:
构造方法
FileWriter(String fileName) 传入一个文件的路径
成员方法
void write(String str) 向文件中写str
void flush() 将内存中的数据刷新到文件中
void close() 关流释放系统底层资源
28.2.1.1案例代码一:
package com.itheima_01;
import java.io.FileWriter;
import java.io.IOException;
/*
- 需求：往文件中写数据
-
写数据--输出流--FileWriter - FileWriter:
-
FileWriter(String fileName):传递一个文件名称 - 输出流写数据的步骤：
-
A:创建输出流对象 -
B:调用输出流对象的写数据的方法 -
C:释放资源
/
public class FileWriterDemo {
public static void main(String[] args) throws IOException {
//创建输出流对象
FileWriter fw = new FileWriter(“d:\a.txt”);
/
* 创建输出流对象做了哪些事情:
* A:调用系统资源创建了一个文件
* B:创建输出流对象
* C:把输出流对象指向文件
*/
//调用输出流对象的写数据的方法
//写一个字符串数据
fw.write("IO流你好");
//数据没有直接写到文件，其实是写到了内存缓冲区
fw.flush();
//释放资源
//通知系统释放和该文件相关的资源
fw.close();
//while(true) {}
}
}
28.2.2FileWriter注意事项
28.2.2.1案例代码二:
package com.itheima_01;
import java.io.FileWriter;
import java.io.IOException;
/*
- 输出流写数据的步骤：
-
A:创建输出流对象 -
B:调用输出流对象的写数据方法，并刷新缓冲区 -
C:释放资源 - 相对路径：相对当前项目而言的，在项目的根目录下(a.txt)
- 绝对路径：以盘符开始的路径(d:\a.txt)
- close()和flush()方法的区别：
-
flush():刷新缓冲区。流对象还可以继续使用。 -
close():先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。
*/
public class FileWriterDemo2 {
public static void main(String[] args) throws IOException {
//创建输出流对象
//FileWriter fw = new FileWriter(“d:\a.txt”);
FileWriter fw = new FileWriter(“a.txt”);
//调用输出流对象的写数据方法，并刷新缓冲区
fw.write("helloworld");
fw.flush();
fw.write("java");
fw.flush();
//释放资源
fw.close();
//Stream closed
//fw.write("javaee");
//fw.flush();
}
}
28.2.3FileWriter其它写方法
void write(String str):写一个字符串数据
void write(String str,int index,int len):写一个字符串中的一部分数据
void write(int ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据，也可以写char对应的int类型的值。‘a’,97
void write(char[] chs):写一个字符数组数据
void write(char[] chs,int index,int len):写一个字符数组的一部分数据
28.2.3.1案例代码三:
package com.itheima_01;
import java.io.FileWriter;
import java.io.IOException;
/*
-
void write(String str):写一个字符串数据
-
void write(String str,int index,int len):写一个字符串中的一部分数据
-
void write(int ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据，也可以写char对应的int类型的值。‘a’,97
-
void write(char[] chs):写一个字符数组数据
-
void write(char[] chs,int index,int len):写一个字符数组的一部分数据
*/
public class FileWriterDemo3 {
public static void main(String[] args) throws IOException {
//创建输出流对象
FileWriter fw = new FileWriter(“b.txt”);//void write(String str):写一个字符串数据 //fw.write("abcde"); //void write(String str,int index,int len):写一个字符串中的一部分数据 //fw.write("abcde",0,5); //fw.write("abcde",1,3); //void write(int ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据，也可以写char对应的int类型的值。'a',97 //fw.write('a'); //fw.write(97); //void write(char[] chs):写一个字符数组数据 char[] chs = {'a','b','c','d','e'}; //fw.write(chs); //void write(char[] chs,int index,int len):写一个字符数组的一部分数据 //fw.write(chs,0,5); fw.write(chs,2,3); //释放资源 fw.close();}
}
28.2.4FileWriter写入换行以及向文本末尾追加
28.2.4.1案例代码四:
package com.itheima_01;
import java.io.FileWriter;
import java.io.IOException;
/*
- 如何实现数据的换行?
-
\n可以实现换行，但是windows系统自带的记事本打开并没有换行，这是为什么呢?因为windows识别的换行不是\n，而是\r\n -
windows:\r\n -
linux:\n -
mac:\r - 如何实现数据的追加写入?
-
FileWriter(String fileName, boolean append)
*/
public class FileWriterDemo4 {
public static void main(String[] args) throws IOException {
//创建输出流对象
//FileWriter fw = new FileWriter(“c.txt”);
FileWriter fw = new FileWriter(“c.txt”,true); //表示追加写入，默认是false
for(int x=0; x<10; x++) {
fw.write("hello"+x);
fw.write("\r\n");
}
//释放资源
fw.close();
}
}
FileReader类使用
FileReader类使用
第29章FileReader类使用
29.1FileReader读数据一次读取一个字符
29.1.1案例代码五:
package com.itheima_02;
import java.io.FileReader;
import java.io.IOException;
/*
-
需求：从文件中读数据并显示到控制台
-
读数据--输入流--FileReader -
FileReader:
-
FileReader(String fileName):传递文件名称 -
输入流读文件的步骤：
-
A:创建输入流对象 -
B:调用输入流对象的读数据方法 -
C:释放资源 -
java.io.FileNotFoundException: fr.txt (系统找不到指定的文件。)
*/
public class FileReaderDemo {
public static void main(String[] args) throws IOException {
//创建输入流对象
// FileReader fr = new FileReader(“fr.txt”);
FileReader fr = new FileReader(“FileWriterDemo.java”);//调用输入流对象的读数据方法 //int read():一次读取一个字符 /* //第一次读数据 int ch = fr.read(); System.out.println(ch); System.out.println((char)ch); //第二次读数据 ch = fr.read(); System.out.println(ch); System.out.println((char)ch); //第三次读数据 ch = fr.read(); System.out.println(ch); System.out.println((char)ch); //这是时候，我们发现代码的重复度很高，想用循环改进，但是不知道循环的结束条件是什么 ch = fr.read(); System.out.println(ch); ch = fr.read(); System.out.println(ch); //通过测试，我们知道，如果读取数据的返回值是-1的时候，就说明没有数据了，这也是我们循环的结束条件 */ int ch; //1:fr.read() //2:ch=fr.read() //3:ch != -1 while((ch=fr.read())!=-1) { //System.out.println(ch); //System.out.println((char)ch); System.out.print((char)ch); } //释放资源 fr.close();}
}
29.2利用FileReader和FileWriter完成文件复制
29.2.1读一次写一次
29.2.1.1案例代码六:
package com.itheima_03;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
- 需求：
-
把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中 - 文件复制也是有规律可循的，也就是说有套路。
- 数据源：
-
FileWriterDemo.java -- 读数据 -- FileReader - 目的地：
-
Copy.java -- 写数据 -- FileWriter
*/
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
//创建输入流对象
FileReader fr = new FileReader(“FileWriterDemo.java”);
//创建输出流对象
FileWriter fw = new FileWriter(“Copy.java”);
//读写数据
int ch;
while((ch=fr.read())!=-1) {
fw.write(ch);
}
//释放资源
fw.close();
fr.close();
}
}
29.2.2利用字符数组拷贝文件
29.2.2.1案例代码七:
package com.itheima_03;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
- 需求：
-
把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中 - 数据源：
-
FileWriterDemo.java -- 读数据 -- FileReader - 目的地：
-
Copy.java -- 写数据 -- FileWriter
*/
public class CopyFileDemo2 {
public static void main(String[] args) throws IOException {
//创建输入流对象
FileReader fr = new FileReader(“FileWriterDemo.java”);
//创建输出流对象
FileWriter fw = new FileWriter(“Copy.java”);
//读写数据
char[] chs = new char[1024];
int len;
while((len=fr.read(chs))!=-1) {
fw.write(chs, 0, len);
}
//释放资源
fw.close();
fr.close();
}
}
29.2.3拷贝文件的两种方式图解
第30章缓冲流介绍和使用
30.1缓冲流的基本使用
30.1.1案例代码八:
package com.itheima_04;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/*
-
BufferedWriter:将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
-
BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
/
public class BufferedStreamDemo {
public static void main(String[] args) throws IOException {
//创建输出缓冲流对象
/
BufferedWriter bw = new BufferedWriter(new FileWriter(“bw.txt”));
bw.write(“hello”);
//bw.flush();
bw.close();
*///创建输入缓冲流对象 BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java")); /* //一次读写一个字符 int ch; while((ch=br.read())!=-1){ System.out.print((char)ch); } */ //一次读写一个字符数组 char[] chs = new char[1024]; int len; while((len=br.read(chs))!=-1) { System.out.print(new String(chs,0,len)); } //释放资源 br.close();}
}
30.2缓冲流复制文本文件的两种方式
利用缓冲流把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中
第一种方式:使用缓冲流不使用字符数组
第二种方式:使用缓冲流使用字符数组
30.2.1案例代码九:
package com.itheima_04;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
- 需求：
-
把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中 - 数据源：
-
FileWriterDemo.java -- 读数据 -- FileReader -- 高效的读数据 -- BufferedReader - 目的地：
-
Copy.java -- 写数据 -- FileWriter -- 高效的写数据 -- BufferedWriter
*/
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
//创建输入缓冲流对象
BufferedReader br = new BufferedReader(new FileReader(“FileWriterDemo.java”));
//创建输出缓冲流对象
BufferedWriter bw = new BufferedWriter(new FileWriter(“Copy.java”));
//读写数据
/*
//一次读写一个字符
int ch;
while((ch=br.read())!=-1) {
bw.write(ch);
}
*/
//一次读写一个字符数组
char[] chs = new char[1024];
int len;
while((len=br.read(chs))!=-1) {
bw.write(chs,0,len);
}
//释放资源
bw.close();
br.close();
}
}
30.3缓冲流的特有方法使用
BufferedWriter
void newLine():写一个换行符，这个换行符由系统决定,不同的操作系统newLine()方法使用的换行符不同
windows:\r\n
linux:\n
mac:\r
BufferedReader
String readLine():一次读取一行数据，但是不读取换行符
30.3.1案例代码十:
package com.itheima_05;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/*
- 缓冲流的特殊功能：
- BufferedWriter
-
void newLine():写一个换行符，这个换行符由系统决定 - BufferedReader
-
String readLine():一次读取一行数据，但是不读取换行符
/
public class BufferedStreamDemo {
public static void main(String[] args) throws IOException {
/
BufferedWriter bw = new BufferedWriter(new FileWriter(“bw2.txt”));
for(int x=0; x<10; x++) {
bw.write(“hello”+x);
//bw.write("\r\n");
bw.newLine();
bw.flush();
}
bw.close();
*/
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
/*
String line = br.readLine();
System.out.println(line);
line = br.readLine();
System.out.println(line);
line = br.readLine();
System.out.println(line);
line = br.readLine();
System.out.println(line);
*/
String line;
//1:br.readLine()
//2:line=br.readLine()
//3:line != null
while((line=br.readLine())!=null) {
System.out.println(line);
}
br.close();
}
}
30.4缓冲流的特有方法复制文件
30.4.1案例代码十一:
package com.itheima_05;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
- 需求：
-
把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中 - 数据源：
-
FileWriterDemo.java -- 读数据 -- FileReader -- 高效的读数据 -- BufferedReader - 目的地：
-
Copy.java -- 写数据 -- FileWriter -- 高效的写数据 -- BufferedWriter
*/
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
//创建输入缓冲流对象
BufferedReader br = new BufferedReader(new FileReader(“FileWriterDemo.java”));
//创建输出缓冲流对象
BufferedWriter bw = new BufferedWriter(new FileWriter(“Copy.java”));
//读写数据
String line;
while((line=br.readLine())!=null) {
bw.write(line);
bw.newLine();
bw.flush();
}
//释放资源
bw.close();
br.close();
}
}
第31章IO流相关案例
31.1复制文本文件的5种方式
A:利用基本流一次读写一个字符
B:利用基本流一次读写一个字符数组
C:利用缓冲流一次读写一个字符
D:利用缓冲流一次读写一个字符数组
E:利用缓冲流的特有方法一次读写一个字符串
31.1.1案例代码十二:
package com.itheima_06;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
- 复制文本文件(5种方式)
- 数据源：
-
FileWriterDemo.java - 目的地：
-
Copy.java
/
public class CopyFileTest {
public static void main(String[] args) throws IOException {
/
method1(“FileWriterDemo.java”,“Copy.java”);
method2(“FileWriterDemo.java”,“Copy.java”);
method3(“FileWriterDemo.java”,“Copy.java”);
method4(“FileWriterDemo.java”,“Copy.java”);
method5(“FileWriterDemo.java”,“Copy.java”);
*/
String srcFileName = "FileWriterDemo.java";
String destFileName = "Copy.java";
// method1(srcFileName,destFileName);
// method2(srcFileName,destFileName);
method3(srcFileName,destFileName);
// method4(srcFileName,destFileName);
// method5(srcFileName,destFileName);
}
//缓冲流一次读写一个字符串
public static void method5(String srcFileName,String destFileName) throws IOException {
//创建输入缓冲流对象
BufferedReader br = new BufferedReader(new FileReader(srcFileName));
//创建输出缓冲流对象
BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
//一次读写一个字符串
String line;
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
//释放资源
bw.close();
br.close();
}
//缓冲流一次读写一个字符数组
public static void method4(String srcFileName,String destFileName) throws IOException {
//创建输入缓冲流对象
BufferedReader br = new BufferedReader(new FileReader(srcFileName));
//创建输出缓冲流对象
BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
//一次读写一个字符数组
char[] chs = new char[1024];
int len;
while((len=br.read(chs))!=-1) {
bw.write(chs,0,len);
}
//释放资源
bw.close();
br.close();
}
//缓冲流一次读写一个字符
public static void method3(String srcFileName,String destFileName) throws IOException {
//创建输入缓冲流对象
BufferedReader br = new BufferedReader(new FileReader(srcFileName));
//创建输出缓冲流对象
BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
//一次读写一个字符
int ch;
while((ch=br.read())!=-1) {
bw.write(ch);
}
//释放资源
bw.close();
br.close();
}
//基本流一次读写一个字符数组
public static void method2(String srcFileName,String destFileName) throws IOException {
//创建输入流对象
FileReader fr = new FileReader(srcFileName);
//创建输出流对象
FileWriter fw = new FileWriter(destFileName);
//一次读写一个字符数组
char[] chs = new char[1024];
int len;
while((len=fr.read(chs))!=-1) {
fw.write(chs,0,len);
}
//释放资源
fw.close();
fr.close();
}
//基本流一次读写一个字符
public static void method1(String srcFileName,String destFileName) throws IOException {
//创建输入流对象
FileReader fr = new FileReader(srcFileName);
//创建输出流对象
FileWriter fw = new FileWriter(destFileName);
//一次读写一个字符
int ch;
while((ch=fr.read())!=-1) {
fw.write(ch);
}
//释放资源
fw.close();
fr.close();
}
}
31.2把集合中的数据写到文本文件
把ArrayList集合中的字符串数据存储到文本文件项目根目下的array.txt中
每一个字符串元素作为文件中的一行数据
31.2.1案例代码十三:
package com.itheima_06;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
/*
- 把ArrayList集合中的字符串数据存储到文本文件
- 每一个字符串元素作为文件中的一行数据
- 分析：
-
A:创建集合对象 -
B:往集合中添加字符串元素 -
C:创建输出缓冲流对象 -
D:遍历集合，得到每一个字符串元素，然后把该字符串元素作为数据写到文本文件 -
E:释放资源
*/
public class ArrayListToFileTest {
public static void main(String[] args) throws IOException {
//创建集合对象
ArrayList array = new ArrayList();
//往集合中添加字符串元素
array.add("hello");
array.add("world");
array.add("java");
//创建输出缓冲流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("array.txt"));
//遍历集合，得到每一个字符串元素，然后把该字符串元素作为数据写到文本文件
for(int x=0; x<array.size(); x++) {
String s = array.get(x);
bw.write(s);
bw.newLine();
bw.flush();
}
//释放资源
bw.close();
}
}
31.3把文本文件中的数据读取到集合
从项目根目录下的array.txt文本文件中读取数据到ArrayList集合中，并遍历集合,每一行数据作为一个字符串元素
31.3.1案例代码十四:
package com.itheima_06;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
/*
- 从文本文件中读取数据到ArrayList集合中，并遍历集合
- 每一行数据作为一个字符串元素
- 分析：
-
A:创建输入缓冲流对象 -
B:创建集合对象 -
C:读取数据，每次读取一行数据，把该行数据作为一个元素存储到集合中 -
D:释放资源 -
E:遍历集合
*/
public class FileToArrayListTest {
public static void main(String[] args) throws IOException {
//创建输入缓冲流对象
BufferedReader br = new BufferedReader(new FileReader(“array.txt”));
//创建集合对象
ArrayList<String> array = new ArrayList<String>();
//读取数据，每次读取一行数据，把该行数据作为一个元素存储到集合中
String line;
while((line=br.readLine())!=null) {
array.add(line);
}
//释放资源
br.close();
//遍历集合
for(int x=0; x<array.size(); x++) {
String s = array.get(x);
System.out.println(s);
}
}
}
第11天 综合练习
今日内容介绍
综合练习
第32章综合练习
32.1综合练习一
A:键盘录入3个学生信息(学号,姓名,年龄,居住地)存入集合,要求学生信息的学号不能重复
B:遍历集合把每一个学生信息存入文本文件
C:每一个学生信息为一行数据,每行学生的学号,姓名,年龄和居住地在文件中均以逗号分隔
32.1.1案例代码一:
package com.itheima;
/*
-
标准的学生类
*/
public class Student {
//学号
private String id;
//姓名
private String name;
//年龄
private String age;
//居住地
private String address;public Student() {
}
public Student(String id, String name, String age, String address) {
this.id = id;
this.name = name;
this.age = age;
this.address = address;
}public String getId() {
return id;
}public void setId(String id) {
this.id = id;
}public String getName() {
return name;
}public void setName(String name) {
this.name = name;
}public String getAge() {
return age;
}public void setAge(String age) {
this.age = age;
}public String getAddress() {
return address;
}public void setAddress(String address) {
this.address = address;
}
}
package com.itheima;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;
/*
- 键盘录入3个学生信息(学号,姓名,年龄,居住地)存入集合。然后遍历集合把每一个学生信息存入文本文件(每一个学生信息为一行数据，自己定义分割标记)
- 分析：
-
A:定义学生类 -
B:创建集合对象 -
C:写方法实现键盘录入学生信息，并把学生对象作为元素添加到集合 -
D:创建输出缓冲流对象 -
E:遍历集合,得到每一个学生信息，并把学生信息按照一定的格式写入文本文件 -
举例：heima001,向问天,30,北京 -
F:释放资源
*/
public class ArrayListToFileTest {
public static void main(String[] args) throws IOException {
//创建集合对象
ArrayList array = new ArrayList();
//写方法实现键盘录入学生信息，并把学生对象作为元素添加到集合
addStudent(array);
addStudent(array);
addStudent(array);
//创建输出缓冲流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("array.txt"));
//遍历集合,得到每一个学生信息，并把学生信息按照一定的格式写入文本文件
for(int x=0; x<array.size(); x++) {
Student s = array.get(x);
//heima001,向问天,30,北京
StringBuilder sb = new StringBuilder();
sb.append(s.getId()).append(",").append(s.getName()).append(",").append(s.getAge()).append(",").append(s.getAddress());
bw.write(sb.toString());
bw.newLine();
bw.flush();
}
//释放资源
bw.close();
}
//添加学生
public static void addStudent(ArrayList<Student> array) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//为了让id能够被访问到，我们就把id定义在了循环的外面
String id;
//为了让代码能够回到这里，用循环
while(true) {
System.out.println("请输入学生学号：");
//String id = sc.nextLine();
id = sc.nextLine();
//判断学号有没有被人占用
//定义标记
boolean flag = false;
//遍历集合，得到每一个学生
for(int x=0; x<array.size(); x++) {
Student s = array.get(x);
//获取该学生的学号，和键盘录入的学号进行比较
if(s.getId().equals(id)) {
flag = true; //说明学号被占用了
break;
}
}
if(flag) {
System.out.println("你输入的学号已经被占用,请重新输入");
}else {
break; //结束循环
}
}
System.out.println("请输入学生姓名：");
String name = sc.nextLine();
System.out.println("请输入学生年龄：");
String age = sc.nextLine();
System.out.println("请输入学生居住地：");
String address = sc.nextLine();
//创建学生对象
Student s = new Student();
s.setId(id);
s.setName(name);
s.setAge(age);
s.setAddress(address);
//把学生对象作为元素添加到集合
array.add(s);
//给出提示
System.out.println("添加学生成功");
}
}
32.2综合练习二:
把上一案例的array.txt文本文件中的学生信息读取出来存储到集合中，然后遍历集合，在控制台输出
32.2.1案例代码二:
package com.itheima;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
/*
- 把上一题的文本文件中的学生信息读取出来存储到集合中，然后遍历集合，在控制台输出
- 分析：
-
A:定义学生类 -
B:创建输入缓冲流对象 -
C:创建集合对象 -
D:读取文件数据，并把数据按照一定的格式进行分割赋值给学生对象，然后把学生对象作为元素存储到集合 -
heima001,向問天,30,北京 -
E:释放资源 -
F:遍历集合
*/
public class FileToArrayListTest {
public static void main(String[] args) throws IOException {
//创建输入缓冲流对象
BufferedReader br = new BufferedReader(new FileReader(“array.txt”));
//创建集合对象
ArrayList<Student> array = new ArrayList<Student>();
//读取文件数据，并把数据按照一定的格式进行分割赋值给学生对象，然后把学生对象作为元素存储到集合
String line;
while((line=br.readLine())!=null) {
//分割字符串
String[] strArray = line.split(",");
//创建学生对象并赋值
Student s = new Student();
s.setId(strArray[0]);
s.setName(strArray[1]);
s.setAge(strArray[2]);
s.setAddress(strArray[3]);
//把学生对象作为元素存储到集合
array.add(s);
}
//释放资源
br.close();
//遍历集合
System.out.println("学号\t\t姓名\t年龄\t居住地");
for(int x=0; x<array.size(); x++) {
Student s = array.get(x);
System.out.println(s.getId()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getAddress());
}
}
}
package com.itheima;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
/*
- 把上一题的文本文件中的学生信息读取出来存储到集合中，然后遍历集合，在控制台输出
- 分析：
-
A:定义学生类 -
B:创建输入缓冲流对象 -
C:创建集合对象 -
D:读取文件数据，并把数据按照一定的格式进行分割赋值给学生对象，然后把学生对象作为元素存储到集合 -
heima001,向問天,30,北京 -
E:释放资源 -
F:遍历集合
*/
public class FileToArrayListTest {
public static void main(String[] args) throws IOException {
//创建输入缓冲流对象
BufferedReader br = new BufferedReader(new FileReader(“array.txt”));
//创建集合对象
ArrayList<Student> array = new ArrayList<Student>();
//读取文件数据，并把数据按照一定的格式进行分割赋值给学生对象，然后把学生对象作为元素存储到集合
String line;
while((line=br.readLine())!=null) {
//分割字符串
String[] strArray = line.split(",");
//创建学生对象并赋值
Student s = new Student();
s.setId(strArray[0]);
s.setName(strArray[1]);
s.setAge(strArray[2]);
s.setAddress(strArray[3]);
//把学生对象作为元素存储到集合
array.add(s);
}
//释放资源
br.close();
//遍历集合
System.out.println("学号\t\t姓名\t年龄\t居住地");
for(int x=0; x<array.size(); x++) {
Student s = array.get(x);
System.out.println(s.getId()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getAddress());
}
}
}
32.3综合案例三:
学生管理系统IO版:
A:在第九天学生管理系统案例的基础上,添加新需求
B:查看所有的学生的数据需要从students.txt(提供好的)中读取出来
C:增删改都需要先从students.txt中读出学生的数据然后再把改后的学生数据重新写回students.txt
32.3.1原有的集合版学生管理系统:
32.3.1.1案例代码三:
package com.itheima;
import java.util.ArrayList;
import java.util.Scanner;
/*
-
这是我的学生管理系统的主类
-
步骤如下：
-
A:定义学生类
-
B:学生管理系统的主界面的代码编写
-
C:学生管理系统的查看所有学生的代码编写
-
D:学生管理系统的添加学生的代码编写
-
E:学生管理系统的删除学生的代码编写
-
F:学生管理系统的修改学生的代码编写
*/
public class StudentManagerTest {
public static void main(String[] args) {
//创建集合对象，用于存储学生数据
ArrayList array = new ArrayList();//为了让程序能够回到这里来，我们使用循环 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("请输入你的选择："); //创建键盘录入对象 Scanner sc = new Scanner(System.in); String choiceString = sc.nextLine(); //用switch语句实现选择 switch(choiceString) { case "1": //查看所有学生 findAllStudent(array); break; case "2": //添加学生 addStudent(array); break; case "3": //删除学生 deleteStudent(array); break; case "4": //修改学生 updateStudent(array); break; case "5": //退出 //System.out.println("谢谢你的使用"); //break; default: System.out.println("谢谢你的使用"); System.exit(0); //JVM退出 break; } }}
//修改学生
public static void updateStudent(ArrayList array) {
//修改学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就修改该学生
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println(“请输入你要修改的学生的学号：”);
String id = sc.nextLine();//定义一个索引 int index = -1; //遍历集合 for(int x=0; x<array.size(); x++) { //获取每一个学生对象 Student s = array.get(x); //拿学生对象的学号和键盘录入的学号进行比较 if(s.getId().equals(id)) { index = x; break; } } if(index == -1) { System.out.println("不好意思,你要修改的学号对应的学生信息不存在,请回去重新你的选择"); }else { System.out.println("请输入学生新姓名："); String name = sc.nextLine(); System.out.println("请输入学生新年龄："); String age = sc.nextLine(); System.out.println("请输入学生新居住地："); String address = sc.nextLine(); //创建学生对象 Student s = new Student(); s.setId(id); s.setName(name); s.setAge(age); s.setAddress(address); //修改集合中的学生对象 array.set(index, s); //给出提示 System.out.println("修改学生成功"); }}
//删除学生
public static void deleteStudent(ArrayList array) {
//删除学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就删除该学生
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println(“请输入你要删除的学生的学号：”);
String id = sc.nextLine();//定义一个索引 int index = -1; //遍历集合 for(int x=0; x<array.size(); x++) { //获取到每一个学生对象 Student s = array.get(x); //拿这个学生对象的学号和键盘录入的学号进行比较 if(s.getId().equals(id)) { index = x; break; } } if(index == -1) { System.out.println("不好意思,你要删除的学号对应的学生信息不存在,请回去重新你的选择"); }else { array.remove(index); System.out.println("删除学生成功"); }}
//添加学生
public static void addStudent(ArrayList array) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);//为了让id能够被访问到，我们就把id定义在了循环的外面 String id; //为了让代码能够回到这里，用循环 while(true) { System.out.println("请输入学生学号："); //String id = sc.nextLine(); id = sc.nextLine(); //判断学号有没有被人占用 //定义标记 boolean flag = false; //遍历集合，得到每一个学生 for(int x=0; x<array.size(); x++) { Student s = array.get(x); //获取该学生的学号，和键盘录入的学号进行比较 if(s.getId().equals(id)) { flag = true; //说明学号被占用了 break; } } if(flag) { System.out.println("你输入的学号已经被占用,请重新输入"); }else { break; //结束循环 } } System.out.println("请输入学生姓名："); String name = sc.nextLine(); System.out.println("请输入学生年龄："); String age = sc.nextLine(); System.out.println("请输入学生居住地："); String address = sc.nextLine(); //创建学生对象 Student s = new Student(); s.setId(id); s.setName(name); s.setAge(age); s.setAddress(address); //把学生对象作为元素添加到集合 array.add(s); //给出提示 System.out.println("添加学生成功");}
//查看所有学生
public static void findAllStudent(ArrayList array) {
//首先来判断集合中是否有数据，如果没有数据，就给出提示，并让该方法不继续往下执行
if(array.size() == 0) {
System.out.println(“不好意思,目前没有学生信息可供查询,请回去重新选择你的操作”);
return;
}//\t 其实就是一个tab键的位置 System.out.println("学号\t\t姓名\t年龄\t居住地"); for(int x=0; x<array.size(); x++) { Student s = array.get(x); System.out.println(s.getId()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getAddress()); }}
}
32.3.2对文本文件进行读写操作:
32.3.2.1案例代码四:
public static void readData(String fileName,ArrayList array):从fileName的文件中读取学生的数据,并把学生的数据封装到array集合中
public static void writeData(String fileName,ArrayList array):
将array中的每个元素中包含的数据写入到fileName的文件中
// 从文件中读数据到集合
public static void readData(String fileName, ArrayList array)
throws IOException {
// 创建输入缓冲流对象
BufferedReader br = new BufferedReader(new FileReader(fileName));
String line;
while ((line = br.readLine()) != null) {
String[] datas = line.split(",");
Student s = new Student();
s.setId(datas[0]);
s.setName(datas[1]);
s.setAge(datas[2]);
s.setAddress(datas[3]);
array.add(s);
}
br.close();
}
// 把集合中的数据写入文件
public static void writeData(String fileName, ArrayList<Student> array)
throws IOException {
// 创建输出缓冲流对象
BufferedWriter bw = new BufferedWriter(new FileWriter(fileName));
for (int x = 0; x < array.size(); x++) {
Student s = array.get(x);
StringBuilder sb = new StringBuilder();
sb.append(s.getId()).append(",").append(s.getName()).append(",")
.append(s.getAge()).append(",").append(s.getAddress());
bw.write(sb.toString());
bw.newLine();
bw.flush();
}
bw.close();
}
32.3.3增删改查功能调用读写文件方法:
32.3.3.1案例代码五:
package com.itheima;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;
/*
-
这是我的学生管理系统的主类
-
步骤如下：
-
A:定义学生类
-
B:学生管理系统的主界面的代码编写
-
C:学生管理系统的查看所有学生的代码编写
-
D:学生管理系统的添加学生的代码编写
-
E:学生管理系统的删除学生的代码编写
-
F:学生管理系统的修改学生的代码编写
*/
public class StudentManagerTest {
public static void main(String[] args) throws IOException{
//定义文件路径
String fileName = “students.txt”;//为了让程序能够回到这里来，我们使用循环 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("请输入你的选择："); //创建键盘录入对象 Scanner sc = new Scanner(System.in); String choiceString = sc.nextLine(); //用switch语句实现选择 switch(choiceString) { case "1": //查看所有学生 findAllStudent(fileName); break; case "2": //添加学生 addStudent(fileName); break; case "3": //删除学生 deleteStudent(fileName); break; case "4": //修改学生 updateStudent(fileName); break; case "5": default: System.out.println("谢谢你的使用"); System.exit(0); //JVM退出 break; } }}
// 从文件中读数据到集合
public static void readData(String fileName, ArrayList array)
throws IOException {
// 创建输入缓冲流对象
BufferedReader br = new BufferedReader(new FileReader(fileName));String line; while ((line = br.readLine()) != null) { String[] datas = line.split(","); Student s = new Student(); s.setId(datas[0]); s.setName(datas[1]); s.setAge(datas[2]); s.setAddress(datas[3]); array.add(s); } br.close();}
// 把集合中的数据写入文件
public static void writeData(String fileName, ArrayList array)
throws IOException {
// 创建输出缓冲流对象
BufferedWriter bw = new BufferedWriter(new FileWriter(fileName));for (int x = 0; x < array.size(); x++) { Student s = array.get(x); StringBuilder sb = new StringBuilder(); sb.append(s.getId()).append(",").append(s.getName()).append(",") .append(s.getAge()).append(",").append(s.getAddress()); bw.write(sb.toString()); bw.newLine(); bw.flush(); } bw.close();}
//修改学生
public static void updateStudent(String fileName) throws IOException {
//创建集合对象
ArrayList array = new ArrayList();
//从文件中把数据读取到集合中
readData(fileName, array);//修改学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就修改该学生 //创建键盘录入对象 Scanner sc = new Scanner(System.in); System.out.println("请输入你要修改的学生的学号："); String id = sc.nextLine(); //定义一个索引 int index = -1; //遍历集合 for(int x=0; x<array.size(); x++) { //获取每一个学生对象 Student s = array.get(x); //拿学生对象的学号和键盘录入的学号进行比较 if(s.getId().equals(id)) { index = x; break; } } if(index == -1) { System.out.println("不好意思,你要修改的学号对应的学生信息不存在,请回去重新你的选择"); }else { System.out.println("请输入学生新姓名："); String name = sc.nextLine(); System.out.println("请输入学生新年龄："); String age = sc.nextLine(); System.out.println("请输入学生新居住地："); String address = sc.nextLine(); //创建学生对象 Student s = new Student(); s.setId(id); s.setName(name); s.setAge(age); s.setAddress(address); //修改集合中的学生对象 array.set(index, s); //把集合中的数据重新写回到文件 writeData(fileName, array); //给出提示 System.out.println("修改学生成功"); }}
//删除学生
public static void deleteStudent(String fileName) throws IOException {
//创建集合对象
ArrayList array = new ArrayList();
//从文件中把数据读取到集合中
readData(fileName, array);//删除学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就删除该学生 //创建键盘录入对象 Scanner sc = new Scanner(System.in); System.out.println("请输入你要删除的学生的学号："); String id = sc.nextLine(); //我们必须给出学号不存在的时候的提示 //定义一个索引 int index = -1; //遍历集合 for(int x=0; x<array.size(); x++) { //获取到每一个学生对象 Student s = array.get(x); //拿这个学生对象的学号和键盘录入的学号进行比较 if(s.getId().equals(id)) { index = x; break; } } if(index == -1) { System.out.println("不好意思,你要删除的学号对应的学生信息不存在,请回去重新你的选择"); }else { array.remove(index); //把集合中的数据重新写回到文件 writeData(fileName, array); System.out.println("删除学生成功"); }}
//添加学生
public static void addStudent(String fileName) throws IOException {
//创建集合对象
ArrayList array = new ArrayList();
//从文件中把数据读取到集合中
readData(fileName, array);//创建键盘录入对象 Scanner sc = new Scanner(System.in); //为了让id能够被访问到，我们就把id定义在了循环的外面 String id; //为了让代码能够回到这里，用循环 while(true) { System.out.println("请输入学生学号："); //String id = sc.nextLine(); id = sc.nextLine(); //判断学号有没有被人占用 //定义标记 boolean flag = false; //遍历集合，得到每一个学生 for(int x=0; x<array.size(); x++) { Student s = array.get(x); //获取该学生的学号，和键盘录入的学号进行比较 if(s.getId().equals(id)) { flag = true; //说明学号被占用了 break; } } if(flag) { System.out.println("你输入的学号已经被占用,请重新输入"); }else { break; //结束循环 } } System.out.println("请输入学生姓名："); String name = sc.nextLine(); System.out.println("请输入学生年龄："); String age = sc.nextLine(); System.out.println("请输入学生居住地："); String address = sc.nextLine(); //创建学生对象 Student s = new Student(); s.setId(id); s.setName(name); s.setAge(age); s.setAddress(address); //把学生对象作为元素添加到集合 array.add(s); //把集合中的数据重新写回到文件 writeData(fileName, array); //给出提示 System.out.println("添加学生成功");}
//查看所有学生
public static void findAllStudent(String fileName) throws IOException {
//创建集合对象
ArrayList array = new ArrayList();
//从文件中把数据读取到集合中
readData(fileName, array);//首先来判断集合中是否有数据，如果没有数据，就给出提示，并让该方法不继续往下执行 if(array.size() == 0) { System.out.println("不好意思,目前没有学生信息可供查询,请回去重新选择你的操作"); return; } //\t 其实就是一个tab键的位置 System.out.println("学号\t\t姓名\t年龄\t居住地"); for(int x=0; x<array.size(); x++) { Student s = array.get(x); System.out.println(s.getId()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getAddress()); }}
}
第01天 java面向对象
今日内容介绍
知识回顾
static静态关键字
代码块
第33章知识回顾
33.1方法的回顾
33.1.1案例代码一:
package com.itheima_01;
/* -
需求：定义一个方法求两个数的和,并在主方法中调用
-
方法：类中的一段具有特定功能的程序，提高了代码的复用性和可维护性
-
定义格式：
-
public static 返回值类型（没有返回值写void） 方法名(参数类型 参数名,参数类型 参数名2) {//形参 -
方法体; -
} -
调用方式：
-
有明确返回值类型： -
赋值调用，将方法的返回值赋值给一个变量 -
输出调用，使用输出语句直接输出方法的返回值 -
直接调用，没法获取方法的返回值 -
没有明确返回值类型： -
直接调用 -
方法重载：在一个类中有多个重名的方法，这些方法参数不同，和返回值无关
-
注意：
-
形参：方法声明的变量，只能是变量，接收方法调用时传递进来的数据 -
实参：调用方法时传递的数据，可以是常量也可以是变量
*/
public class MethoDemo {
public static void main(String[] args) {
//赋值调用
//int sum = sum(10,20);//实参
//System.out.println(sum);
//输出调用
int a = 10;
int b = 20;
System.out.println(sum(a,b));
}
public static int sum(int a,int b) {
/* //使用变量接收求和结果并返回
int sum = a + b;
return sum;*/
//直接返回求和结果
return a + b;
}
}
33.2数组的回顾
33.2.1案例代码二:
package com.itheima_02;
/*
- 需求：定义一个元素类型为int的数组，遍历数组并求和
- 数组：用于存储多个元素的一种容器
- 数组的特点:
-
元素类型必须一致 -
元素有整数索引 -
一旦定义好长度则无法改变 -
可以存储基本数据类型 -
也可以存储引用数据类型 - 定义格式：
-
动态初始化 -
元素类型[] 数组名 = new 元素类型[10]; -
静态初始化 -
元素类型[] 数组名 = {元素1,元素2,元素3}; -
元素类型[] 数组名 = new 元素类型[]{元素1,元素2,元素3};
*/
public class ArrayDemo {
public static void main(String[] args) {
//使用静态初始化定义数组
int[] arr = {1,2,3,4,5};
//定义一个变量用于存储求和结果
int sum = 0;
//遍历数组
for(int x = 0;x < arr.length;x++) {
sum += arr[x];
}
System.out.println(sum);
}
}
33.3标准类定义和使用回顾
33.3.1案例代码三:
package com.itheima_03;
/*
- 定义一个标准的学生类，在主方法中创建对象并调用
-
姓名，年龄，性别3个成员变量 -
无参，有参两个构造方法 -
为每个成员变量定义getter/setter方法 -
定义一个show方法，输出成员变量
*/
public class Student {
private String name;//姓名
private int age;//年龄
private String gender;//性别
/*//无参构造
public Student() {}
//有参构造
public Student(String name,int age,String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
//name
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//age
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//gender
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}*/
//show：用于输出所有的成员变量
public void show() {
System.out.println(name + "," + age + "," + gender);
}
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age, String gender) {
super();
this.name = name;
this.age = age;
this.gender = gender;
}
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 getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
package com.itheima_03;
public class StudentTest {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
//为成员变量进行赋值
s.setName(“张三”);
s.setAge(18);
s.setGender(“男”);
s.show();
System.out.println("----------");
Student s2 = new Student("李四",20,"其他");
//s2.show();
System.out.println(s2.getName());
}
}
第34章static静态关键字
34.1静态的概述
当在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。可是不创建对象，方法又调用不了，这时就会想，那么我们能不能不创建对象，就可以调用方法呢？
可以的，我们可以通过static关键字来实现。static它是静态修饰符，一般用来修饰类中的成员。
34.2静态的特点
A: 被static修饰的成员变量属于类，不属于这个类的某个对象。（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）
B: 被static修饰的成员可以并且建议通过类名直接访问
访问静态成员的格式:
类名.静态成员变量名
类名.静态成员方法名(参数)
C: 静态的加载优先于对象,随着类的加载而加载
34.2.1案例代码四
package com.itheima_01;
/*
- static:是一个关键字，用于修饰成员变量和成员方法
- static的特点：
-
被所有的对象所共享 -
可以使用类名调用 -
静态的加载优先于对象 -
随着类的加载而加载
*/
public class StaticDemo {
public static void main(String[] args) {
Person.graduateFrom = “传智学院”;
Person p = new Person();
p.name = "小苍同学";
p.age = 18;
//p.graduateFrom = "传智学院";
p.speak();
Person p2 = new Person();
p2.name = "小波同学";
p2.age = 20;
//p2.graduateFrom = "传智学院";
p2.speak();
}
}
class Person {
String name;
int age;
static String graduateFrom;//毕业院校
public void speak() {
System.out.println(name + "---" + graduateFrom);
}
}
34.3静态的注意事项
A:静态成员只能直接访问静态成员
B:非静态成员既可以访问非静态成员也可以访问静态成员
34.3.1案例代码五
package com.itheima_01;
/*
- static的注意事项：
-
静态方法： -
可以调用静态的成员变量 -
可以调用静态的成员方法 -
不可以调用非静态成员变量 -
不可以调用非静态成员方法 -
静态方法只能调用静态的成员 -
非静态方法： -
可以调用静态的成员变量 -
可以调用静态的成员方法 -
可以调用非静态的成员变量 -
可以调用非静态的成员方法 - 静态的方法中是否有this这个对象？没有的
*/
public class StaticDemo2 {
public static void main(String[] args) {
Student.graduateFrom = “传智学院”;
Student.study();
}
}
class Student {
String name;
int age;
static String graduateFrom;//毕业院校
public static void study() {
///System.out.println(graduateFrom);
//sleep();
//System.out.println(name);
//eat();
}
public static void sleep() {
System.out.println("sleep");
}
public void eat() {
System.out.println("eat");
System.out.println(graduateFrom);
sleep();
}
}
34.4静态的优缺点
A:静态优点:
对对象的共享数据提供单独空间的存储，节省空间，没有必要每一个对象都存储一份
可以直接被类名调用,不用在堆内存创建对象
静态成员可以通过类名直接访问,相对创建对象访问成员方便
B:静态弊端:
访问出现局限性。（静态虽好，但只能访问静态）
34.5静态应用
34.5.1Math类使用
A:Math 类包含用于执行基本数学运算的方法。数学操作常用的类。
B:Math类的构造方法被private,无法创建对象,也就无法通过对象来访问Math类中的成员
C:Math类中所有的成员都被静态修饰,因此我们可以直接通过类名访问
34.5.1.1案例代码三:
package com.itheima_02;
public class MathDemo {
public static void main(String[] args) {
//Math:包含了一些基本的数学运算方法
//static double PI
//System.out.println(Math.PI);
//static double abs(double a) :返回绝对值
//System.out.println(Math.abs(15));
//System.out.println(Math.abs(-10));
//static double ceil(double a) 天花板 向上取整
//System.out.println(Math.ceil(1.2));
//System.out.println(Math.ceil(1.6));
//static double floor(double a) 地板 向下取整
//System.out.println(Math.floor(1.2));
//System.out.println(Math.floor(1.6));
//static long round(double a) ：四舍五入
//System.out.println(Math.round(1.2));
//System.out.println(Math.round(1.6));
//static double max(double a, double b)
//System.out.println(Math.max(3, 4));
//static double pow(double a, double b) :返回第一个参数的第二个参数次幂
//System.out.println(Math.pow(3, 2));
//static double random() :返回一个随机数，大于零且小于一
System.out.println(Math.random());
}
}
34.5.2自定义工具类
A:需求:自定义一个专门对数组操作的工具类,具有的功能如下
1.定义一个方法,该方法可以返回数组中最大元素
2.定义一个方法,该方法根据指定的值去数组中查找是否存在该值
存在,返回该值在数组中的索引
不存在,返回-1
34.5.2.1案例代码四:
package com.itheima_03;
public class MyArrays {
private MyArrays() {}
/*
* 返回数组中最大的元素
*
*/
public static int getMax(int[] arr) {
int max = 0;//参照物
//遍历数组
for(int x = 0;x < arr.length;x++) {
if(arr[x] > max) {
max = arr[x];//替换参照物
}
}
return max;
}
/*
* 返回数组中指定参数的索引
*
*/
public static int getIndex(int[] arr,int a) {
//遍历数组
for(int x = 0;x < arr.length;x++) {
if(arr[x] == a) {
return x;
}
}
return -1;//如果查不到制定的参数，则返回-1
}
}
package com.itheima_03;
public class MyArraysDemo {
public static void main(String[] args) {
int[] arr = {3,5,8,10,1};
int max = MyArrays.getMax(arr);
System.out.println(max);
int index = MyArrays.getIndex(arr, 8);
System.out.println(index);
}
}
34.6类变量与实例变量辨析
A:类变量:其实就是静态变量
定义位置:定义在类中方法外
所在内存区域:方法区
生命周期:随着类的加载而加载
特点:无论创建多少对象,类变量仅在方法区中,并且只有一份
B:实例变量:其实就是非静态变量
定义位置:定义在类中方法外
所在内存区域:堆
生命周期:随着对象的创建而加载
特点:每创建一个对象,堆中的对象中就有一份实例变量
第35章代码块
35.1局部代码块
局部代码块是定义在方法或语句中
35.1.1案例代码六:
public class BlockDemo {
public static void main(String[] args) {
//局部代码块：存在于方法中，控制变量的生命周期（作用域）
{
for(int x = 0;x < 10;x++) {
System.out.println("我爱Java");
}
int num = 10;
}
//System.out.println(num);//无法访问num,超出num的作用域范围
}
}
35.2构造代码块
构造代码块是定义在类中成员位置的代码块
35.2.1案例代码七:
package com.itheima_04;
class Teacher {
String name;
int age;
{
for(int x = 0;x < 10;x++) {
System.out.println("我爱Java");
}
System.out.println("我爱Java");
}
public Teacher() {
System.out.println("我是无参空构造");
}
public Teacher(String name,int age) {
System.out.println("我是有参构造");
this.name = name;
this.age = age;
}
}
35.3静态代码块
A:静态代码块是定义在成员位置，使用static修饰的代码块
35.3.1案例代码八:
class Teacher {
String name;
int age;
//静态代码块：随着类的加载而加载，只加载一次，加载类时需要做的一些初始化，比如加载驱动
static {
System.out.println("我爱Java");
}
public Teacher() {
System.out.println("我是无参空构造");
}
public Teacher(String name,int age) {
System.out.println("我是有参构造");
this.name = name;
this.age = age;
}
}
35.4每种代码块特点:
35.4.1局部代码块:
以”{}”划定的代码区域，此时只需要关注作用域的不同即可
方法和类都是以代码块的方式划定边界的
35.4.2构造代码块
优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作
每创建一个对象均会执行一次构造代码块。
35.4.3静态代码块
它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。
该类不管创建多少对象，静态代码块只执行一次。
可用于给静态变量赋值，用来给类进行初始化。
35.4.4案例代码九:
package com.itheima_04;
/*
- Coder静态代码块执行 — Coder构造代码块执行 — Coder无参空构造执行
- BlockTest静态代码块执行 — BlockTest的主函数执行了 — Coder静态代码块执行 — Coder构造代码块执行 — Coder无参空构造执行
- Coder构造代码块执行 — Coder无参空构造执行
*/
public class BlockTest {
static {
System.out.println(“BlockTest静态代码块执行”);
}
{
System.out.println("BlockTest构造代码块执行");
}
public BlockTest(){
System.out.println("BlockTest无参构造执行了");
}
public static void main(String[] args) {
System.out.println("BlockTest的主函数执行了");
Coder c = new Coder();
Coder c2 = new Coder();
}
}
class Coder {
static {
System.out.println("Coder静态代码块执行");
}
{
System.out.println("Coder构造代码块执行");
}
public Coder() {
System.out.println("Coder无参空构造执行");
}
}
第01天 java面向对象
今日内容介绍
继承
抽象类
第36章继承
36.1继承的概述
在现实生活中，继承一般指的是子女继承父辈的财产。在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。
36.2继承的格式&使用
在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。
格式：
class 子类 extends 父类 {}
36.2.1案例代码一:
package com.itheima_01;
/*
- 继承：多个类有共同的成员变量和成员方法，抽取到另外一个类中（父类），在让多个类去继承这个父类，我们的多个类就可以获取到父类中的成员了。
- extends
*/
public class ExtendsDemo {
public static void main(String[] args) {
DotA1 d = new DotA1();
d.start();
LOL1 l = new LOL1();
l.start();
}
}
class Game1 {
String name;
double version;//版本号
String agent;//代理商
public void start() {
System.out.println("游戏启动了");
}
public void stop() {
System.out.println("游戏关闭了");
}
}
class DotA1 extends Game1 {
/*String name;
double version;//版本号
String agent;//代理商
public void start() {
System.out.println("游戏启动了");
}
public void stop() {
System.out.println("游戏关闭了");
}*/
}
class LOL1 extends Game1 {
/*String name;
double version;//版本号
String agent;//代理商
public void start() {
System.out.println("游戏启动了");
}
public void stop() {
System.out.println("游戏关闭了");
}*/
}
36.3继承的特点
在类的继承中，需要注意一些问题，具体如下：
1、在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类，例如下面这种情况是不合法的。
class A{}
class B{}
class C extends A,B{} // C类不可以同时继承A类和B类
2、多个类可以继承一个父类，例如下面这种情况是允许的。
class A{}
class B extends A{}
class C extends A{} // 类B和类C都可以继承类A
3、在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如C类继承自B类，而B类又可以去继承A类，这时，C类也可称作A类的子类。下面这种情况是允许的。
class A{}
class B extends A{} // 类B继承类A，类B是类A的子类
class C extends B{} // 类C继承类B，类C是类B的子类，同时也是类A的子类
4、在Java中，子类和父类是一种相对概念，也就是说一个类是某个类父类的同时，也可以是另一个类的子类。例如上面的这种情况中，B类是A类的子类，同时又是C类的父类
36.3.1案例代码二
package com.itheima_01;
/*
- Java中继承的特点：
-
Java语言只支持单一继承，只能继承一个父类（一个儿子只能有一个亲爹） -
Java语言支持多层继承（一个儿子可以有一个亲爹，还可以有一个亲爷爷）
*/
public class ExtendsDemo2 {
public static void main(String[] args) {
LOL l = new LOL();
l.update();
l.start();
}
}
class Game {
public void start() {
System.out.println(“游戏启动了”);
}
}
class PCGame extends Game {
public void update() {
System.out.println(“PCGame更新了”);
}
}
class MobileGame extends Game {
public void update() {
System.out.println(“MobileGame更新了”);
}
}
class LOL extends PCGame {
}
36.4继承中成员变量的特点
A:子类只能获取父类非私有成员
子父类中成员变量的名字不一样直接获取父类的成员变量
子父类中成员变量名字是一样的获取的是子类的成员变量
B:就近原则：谁离我近我 就用谁
如果有局部变量就使用局部变量
如果没有局部变量，有子类的成员变量就使用子类的成员变量
如果没有局部变量和子类的成员变量，有父类的成员变量就使用父类的成员变量
C: super:可以获取父类的成员变量和成员方法,用法和this是相似的
36.4.1案例代码三
package com.itheima_01;
/*
- 继承中成员变量的特点
-
子类只能获取父类非私有成员 -
子父类中成员变量的名字不一样直接获取父类的成员变量 -
子父类中成员变量名字是一样的获取的是子类的成员变量 - 就近原则：谁离我近我就用谁
-
如果有局部变量就使用局部变量 -
如果没有局部变量，有子类的成员变量就使用子类的成员变量 -
如果没有局部变量和子类的成员变量，有父类的成员变量就使用父类的成员变量 -
啥都没有，出错了！！！ - super:可以获取父类的成员变量和成员方法,用法和this是相似的
*/
public class ExtendsDemo3 {
public static void main(String[] args) {
Kid3 k = new Kid3();
k.show();
}
}
class Dad3 {
String name = “建霖”;
}
class Kid3 extends Dad3 {
String name = “四葱”;
public void show() {
String name = "五葱";
System.out.println(super.name);
System.out.println(this.name);
System.out.println(name);
}
}
36.5继承中成员方法的特点&方法重写
36.5.1案例代码四
A:子类中没有这个方法,调用父类的
package com.itheima_01;
/*
- 继承中成员方法的特点
-
子类中没有这个方法，调用父类的
*/
public class ExtendsDemo4 {
public static void main(String[] args) {
Kid4 k = new Kid4();
k.eat();
}
}
class Dad4 {
public void eat() {
System.out.println(“小酌两口”);
System.out.println(“去睡觉了”);
}
}
class Kid4 extends Dad4 {
}
36.5.2案例代码五
B: 子类中重写了这个方法，调用子类的
方法的重写：在子父类当中，子类的方法和父类的完全一样，子类重写了父类的方法（覆盖），当子类重写了父类的方法之后，使用子类对象调用的就是子类的方法
package com.itheima_01;
/*
- 继承中成员方法的特点
-
子类中没有这个方法，调用父类的 -
子类中重写了这个方法，调用子类的 - 方法的重写：在子父类当中，子类的方法和父类的完全一样，子类重写了父类的方法（覆盖），当子类重写了父类的方法之后，使用子类对象调用的就是子类的方法
方法的重载：在一个类中，有多个重名的方法，但是其参数不一样（参数的个数，参数的类型，参数的顺序），和返回值无关
*/
public class ExtendsDemo4 {
public static void main(String[] args) {
Kid4 k = new Kid4();
k.eat();
}
}
class Dad4 {
public void eat() {
System.out.println(“小酌两口”);
System.out.println(“去睡觉了”);
}
}
class Kid4 extends Dad4 {
public void eat() {
System.out.println(“好好吃饭”);
}
}
36.6方法重写的应用场景&注意事项
方法重写的应用场景：当父类的方法不能完全满足子类使用的时候，既可以保留父类的功能（沿袭、传承），还可以有自己特有的功能
方法重写的注意事项：
不可以重写父类私有的成员方法，压根就看不到父类的私有成员
子类重写父类方法，权限必须大于等于父类方法的权限
注解
@Override：方法重写，说明下面的方法是重写父类的方法
36.6.1.1案例代码六
package com.itheima_03;
/*
- 方法重写的应用场景：当父类的方法不能完全满足子类使用，这个时候子类重写父类的方法，
-
并可以在方法中使用关键字super调用父类的方法，这样做即可以保有父类的功能，也可以拥有子类特有的功能 - 方法重写的注意事项：
-
不能重写父类私有的方法 -
权限必须大于等于父类方法的权限 - 注解：@
*/
public class ExtendsDemo5 {
public static void main(String[] args) {
NewPhone np = new NewPhone();
np.call();
}
}
class Phone {
void call() {
System.out.println(“打电话”);
}
}
class NewPhone extends Phone {
@Override
public void call() {
System.out.println("录音");
//System.out.println("打电话");
//super.call();
}
}
36.7继承中构造方法的执行顺序
A:super(实参列表);语句 在子类的构造方法中使用,用来调用父类中的构造方法(具体哪一个由传递的参数决定),并且只能在构造方法第一行使用
B:this(实参列表); 语句 在类的构造方法中使用,用来调用本类中的其它构造方法(具体哪一个由传递的参数决定),并且只能在构造方法的第一行使用
36.7.1案例代码七
package com.itheima_01;
/*
- 继承中构造方法的执行顺序
-
在子父类中，创建子类对象，调用子类的构造方法， -
在子类的构造方法的第一行代码如果没有调用父类的构造或者没有调用子类的其他构造，则默认调用父类无参构造 - 为什么要调用父类构造？
-
因为需要给父类的成员变量初始化 - 肯定会先把父类的构造执行完毕，在去执行子类构造中的其他代码
- 我是父类无参构造 — 我是子类有参构造 — 我是子类无参构造
*/
public class ExtendsDemo6 {
public static void main(String[] args) {
//Die d = new Die();
Zi6 z = new Zi6();
}
}
class Die6 {
public Die6() {
System.out.println(“我是父类无参构造”);
}
public Die6(int num) {
System.out.println("我是父类有参构造");
}
}
class Zi6 extends Die6 {
public Zi6() {
//super(1);
//super();
this(1);//不会再调用父类的无参构造了
System.out.println("我是子类无参构造");
}
public Zi6(int num) {
//会默认调用父类无参构造
System.out.println("我是子类有参构造");
}
}
36.8this与super区别
36.8.1案例代码八:
package com.itheima_01;
/*
- this和super的区别
this:当前对象的引用
调用子类的成员变量
调用子类的成员方法
在子类的构造方法第一行调用子类其他构造方法
super:子类对象的父类引用
调用父类的成员变量
调用父类的成员方法
在子类的构造方法第一行调用父类的构造方法
*/
public class ExtendsDemo7 {
public static void main(String[] args) {
Zi z = new Zi();
z.function();
}
}
class Die {
int num = 10;
public Die() {
System.out.println("我是父类无参构造");
}
public Die(int num) {
System.out.println("我是父类有参构造");
}
public void method() {
System.out.println("我是父类的方法");
}
}
class Zi extends Die {
//int num = 30;
public Zi() {
//this(1);//第一行不调用子类其他构造或者是父类构造，默认调用父类无参构造
super();
System.out.println("我是子类无参构造");
}
public Zi(int num) {
System.out.println("我是子类有参构造");
}
public void method() {
System.out.println("我是子类的方法");
}
public void function() {
//this.num = 50;
//System.out.println(num);
//this.method();
//super.num = 40;
//super.method();
System.out.println(this.num);
}
}
36.9继承优缺点
A:优点
提高了代码的复用性
提高了代码的可维护性
B:缺点：
类的耦合性增强了
开发的原则：高内聚低耦合
内聚：就是自己完成某件事情的能力
耦合：类与类的关系
第37章抽象类
37.1抽象类概述
当编写一个类时，我们往往会为该类定义一些方法，这些方法是用来描述该类的功能具体实现方式，那么这些方法都有具体的方法体。
但是有的时候，某个父类只是知道子类应该包含怎么样的方法，但是无法准确知道子类如何实现这些方法。比如一个图形类应该有一个求周长的方法，但是不同的图形求周长的算法不一样。那该怎么办呢？
分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是方法功能声明相同，但方法功能主体不同。那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。
37.1.1案例代码九:
package com.itheima_01;
/*
- abstract:关键字，用于修饰方法和类
- 抽象方法：不同类的方法是相似，但是具体内容又不太一样，所以我们只能抽取他的声明，没有具体的方法体，没有具体方法体的方法就是抽象方法
- 抽象类：有抽象方法的类必须是抽象类
- 注意：一个类继承了抽象类需要重写他所有的抽象方法,否则这个类就得是抽象类
*/
public class AbstractDemo {
}
abstract class Animal1 {
public abstract void eat();
//非抽象方法子类可以不重写
public void run() {
}
}
class Cat1 extends Animal1 {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
/*public void eat() {
System.out.println("猫吃鱼");
}*/
}
abstract class Dog1 extends Animal1 {
/public void eat() {
System.out.println(“狗吃屎”);
}/
}
37.2抽象类的特点
抽象类的特点：
抽象方法只能在抽象类里面
抽象类和抽象方法必须被abstract修饰
抽象类不能创建对象（不能实例化）
抽象类中可以有非抽象的方法
抽象类和类的关系也是继承
一个类继承了抽象类要么重写所有的抽象方法，要么他自己是抽象类
37.2.1案例代码十
package com.itheima_01;
/*
- 抽象类的特点：
-
抽象方法只能在抽象类里面 -
抽象类和抽象方法必须被abstract修饰 -
抽象类不能创建对象（不能实例化） -
抽象类中可以有非抽象的方法 -
抽象类和类的关系也是继承 -
一个类继承了抽象类要么重写所有的抽象方法，要么他自己是抽象类
*/
public class AbstractDemo2 {
public static void main(String[] args) {
//Animal a = new Animal();
}
}
abstract class Animal2 {
public abstract void eat();
public void run() {
}
}
class Cat2 extends Animal2 {
@Override
public void eat() {
// TODO Auto-generated method stub
}
}
37.3抽象类的成员的特点
A:抽象类的成员特点：
成员变量
可以有成员变量
可以有常量
成员方法
可以有抽象方法
可以有非抽象方法
构造方法
可以有构造方法的，需要对抽象类的成员变量进行初始化
37.3.1案例代码十一
package com.itheima_01;
/*
- 抽象类的成员特点：
-
成员变量 -
可以有成员变量 -
可以有常量 -
成员方法 -
可以有抽象方法 -
可以有非抽象方法 -
构造方法 -
可以有构造方法的，需要对抽象类的成员变量进行初始化 - final:修饰类、成员变量、成员方法
*/
public class AbstractDemo3 {
public static void main(String[] args) {
Dog d = new Dog();
d.barking();
}
}
abstract class Animal {
String name = “哮天犬”;
final int num = 10;
public Animal() {
System.out.println("我是抽象类的构造方法");
}
public abstract void eat();
public void run() {}
}
class Dog extends Animal {
public void barking() {
System.out.println(name);
System.out.println(num);
}
@Override
public void eat() {
// TODO Auto-generated method stub
}
}
37.4抽象类案例
37.4.1老师案例:
老师类:
属性:姓名,年龄,性别
行为:讲课
基础班老师:
属性:姓名,年龄,性别
行为:讲基础班课程
就业班老师:
属性:姓名,年龄,性别
行为:讲就业班课程
37.4.1.1案例代码十二
package com.itheima_02;
/*
- 基础班老湿，就业班老湿
- 共性：
-
属性 姓名，年龄，性别 -
行为 讲课，唱歌
*/
public class AbstractTest {
public static void main(String[] args) {
BasicTeacher bt = new BasicTeacher();
bt.name = “风清扬”;
bt.teach();
JobTeacher jt = new JobTeacher();
jt.name = "苍老师";
jt.teach();
}
}
abstract class Teacher {
String name;//姓名
int age;//年龄
String gender;//性别
//讲课
public abstract void teach();
}
class BasicTeacher extends Teacher {
@Override
public void teach() {
System.out.println(name + "讲基础班课程");
}
}
class JobTeacher extends Teacher {
@Override
public void teach() {
System.out.println(name + "讲就业班课程");
}
}
37.4.2雇员案例
雇员类:
属性:姓名,编号,薪水
行为:工作
程序员:
属性:姓名,编号,薪水
行为:写代码工作
经理:
属性:姓名,编号,薪水,奖金
行为:盯着程序员写代码工作
37.4.2.1案例代码十三
package com.itheima_02;
/*
-
雇员(Employee)示例：
需求：
公司中
程序员(programmer)有姓名(name)，工号(id)，薪水(pay)，工作内容(work)。
项目经理(Manager)除了有姓名(name)，工号(id)，薪水(pay)，还有奖金(bonus)，工作内容(work)员工：
属性 name，id，pay
行为 work
*/
public class AbstractTest2 {
public static void main(String[] args) {
Programmer p = new Programmer();
p.work();Manager m = new Manager(); m.work();}
}
abstract class Employee {
String name;//姓名
String id;//id
double pay;//薪水
//工作
public abstract void work();
}
class Programmer extends Employee {
@Override
public void work() {
System.out.println("写代码");
}
}
class Manager extends Employee {
byte bonus;
@Override
public void work() {
System.out.println("盯着程序员写代码");
}
}
37.4.3技师案例
技师:
属性:姓名,年龄
行为:服务
足疗技师:
属性:姓名,年龄
行为:按按脚揉揉肩
其它技师:
属性:姓名,年龄
行为:你懂的
37.4.3.1案例代码十四
package com.itheima_02;
/*
- 足疗店
-
技师 -
足疗技师 -
其他技师 - 共性：
-
属性 姓名，年龄 -
行为 服务
*/
public class AbstractTest3 {
public static void main(String[] args) {
足疗技师 zl = new 足疗技师();
zl.service();
其他技师 qt = new 其他技师();
qt.service();
}
}
abstract class 技师 {
String name;//姓名
int age;//年龄
//服务
public abstract void service();
}
class 足疗技师 extends 技师 {
@Override
public void service() {
System.out.println("按按脚揉揉肩");
}
}
class 其他技师 extends 技师 {
@Override
public void service() {
System.out.println("你懂的");
}
}
37.5抽象类的细节
A:抽象类关键字abstract可以和哪些关键字共存?
1.private：
私有的方法子类是无法继承到的，也不存在覆盖，而abstract和private一起使用修饰方法，abstract既要子类去实现这个方法，而private修饰子类根本无法得到父类这个方法。互相矛盾。
2.final:
抽象类不能和final共存,因为抽象类自身无法创建对象,我们需要通过子类创建对象,一旦抽象类使用final关键字,那么抽象类就没有子类
抽象方法不能和final共存,因为抽象方法后期需要被子类重写,一旦加final无法重写
3.static:
抽象方法不能和static关键字共存,因为一旦加static我们就可以通过类名直接访问抽象方法,由于抽象方法没有方法体,没有任何意义,也不允许这样做
B:抽象类中是否可以不定义抽象方法?
是可以的，那这个抽象类的存在到底有什么意义呢？不让该类创建对象,方法可以直接让子类去使用
C:抽象类是否有构造函数?
有,抽象类的构造函数,是由子类的super语句来调用,用于给抽象类中的成员初始化
第01天 java面向对象
今日内容介绍
接口
匿名对象&final
多态
第38章接口
38.1接口的概述
接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。
接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。
38.2接口的格式&使用
38.2.1接口的格式
与定义类的class不同，接口定义时需要使用interface关键字。
定义接口所在的仍为.java文件，虽然声明时使用的为interface关键字的编译后仍然会产生.class文件。这点可以让我们将接口看做是一种只包含了功能声明的特殊类。
定义格式：
public interface 接口名 {
抽象方法1;
抽象方法2;
抽象方法3;
}
38.2.2接口的使用
接口中的方法全是抽象方法,直接new接口来调用方法没有意义,Java也不允许这样干
类与接口的关系为实现关系，即类实现接口。实现的动作类似继承，只是关键字不同，实现使用implements
其他类(实现类)实现接口后，就相当于声明：”我应该具备这个接口中的功能”。实现类仍然需要重写方法以实现具体的功能。
格式：
class 类 implements 接口 {
重写接口中方法
}
在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法，完成具体的逻辑。
38.2.3案例代码一:
package com.itheima_01;
/*
- Java语言的继承是单一继承，一个子类只能有一个父类（一个儿子只能有一个亲爹）
- Java语言给我们提供了一种机制，用于处理继承单一的局限性的，接口
- 接口：接口是一个比抽象类还抽象的类，接口里所有的方法全是抽象方法，接口和类的关系是实现，implements
- interface
- 格式：
-
interface 接口名 { -
}
*/
public class InterfaceDemo {
public static void main(String[] args) {
BillGates gates = new BillGates();
gates.code();
}
}
class Boss {
public void manage() {
System.out.println(“管理公司”);
}
}
class Programmer {
public void code() {
System.out.println(“敲代码”);
}
}
//比尔盖茨
class BillGates extends Programmer {
}
38.3接口中成员的特点
1、接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。后面我们会讲解fnal关键字
2、接口中可以定义方法，方法也有固定的修饰符，public abstract
3、接口不可以创建对象。
4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。
38.3.1案例代码二:
package com.itheima_01;
/*
- 接口的成员特点：
-
只能有抽象方法 -
只能有常量 -
默认使用public&abstract修饰方法 -
只能使用public&abstract修饰方法 -
默认使用public static final来修饰成员变量 - 建议：建议大家手动的给上默认修饰符
- 注意：
-
接口不能创建对象（不能实例化） -
类与接口的关系是实现关系，一个类实现一个接口必须实现它所有的方法
*/
public class InterfaceDemo2 {
public static void main(String[] args) {
//Animal a = new Animal();
//Animal.num;
}
}
interface Animal {
public static final int num = 10;
public abstract void eat();
}
class Cat implements Animal {
public void eat() {
}
}
38.4接口和类的关系
A:类与类之间:继承关系,一个类只能直接继承一个父类,但是支持多重继承
B:类与接口之间:只有实现关系,一个类可以实现多个接口
C:接口与接口之间:只有继承关系,一个接口可以继承多个接口
38.4.1案例代码三:
package com.itheima_01;
/*
*
-
类与类：继承关系，单一继承，多层继承
-
类与接口：实现关系，多实现
-
接口与接口的关系：继承关系，多继承
*/
public class InterfaceDemo3 {
public static void main(String[] args) {}
}
interface InterA extends InterB {
public abstract void method();
}
interface InterB {
public abstract void function();
}
interface InterC extends InterA {
}
class Demo implements InterC {
@Override
public void method() {
// TODO Auto-generated method stub
}
@Override
public void function() {
// TODO Auto-generated method stub
}
}
38.5接口的思想
前面学习了接口的代码体现，现在来学习接口的思想，接下里从生活中的例子进行说明。
举例：我们都知道电脑上留有很多个插口，而这些插口可以插入相应的设备，这些设备为什么能插在上面呢？主要原因是这些设备在生产的时候符合了这个插口的使用规则，否则将无法插入接口中，更无法使用。发现这个插口的出现让我们使用更多的设备。
接口的出现方便后期使用和维护，一方是在使用接口（如电脑），一方在实现接口（插在插口上的设备）。例如：笔记本使用这个规则（接口），电脑外围设备实现这个规则（接口）。
集合体系中大量使用接口
Collection接口
List接口
ArrayList实现类
LinkedList实现类
Set接口
38.6接口优点
1.类与接口的关系，实现关系，而且是多实现，一个类可以实现多个接口，类与类之间是继承关系，java中的继承是单一继承，一个类只能有一个父类，打破了继承的局限性。
2.对外提供规则（USB接口）
3.降低了程序的耦合性（可以实现模块化开发，定义好规则，每个人实现自己的模块，提高了开发的效率）
38.7接口和抽象类的区别
1.共性：
不断的进行抽取，抽取出抽象的，没有具体实现的方法,都不能实例化（不能创建对象）
2.区别1: 与类的关系
(1)类与接口是实现关系，而且是多实现，一个类可以实现多个接口，类与抽象类是继承关系，Java中的继承是单一继承，多层继承，一个类只能继承一个父类，但是可以有爷爷类
(2)区别2： 成员
a.成员变量
抽象类可以有成员变量，也可以有常量
接口只能有常量，默认修饰符public static final
b.成员方法
抽象类可以有抽象方法，也可以有非抽象方法
接口只能有抽象方法，默认修饰符 public abstract
c.构造方法
抽象类有构造方法，为子类提供
接口没有构造方法
38.8运动员案例
38.8.1案例代码四:
package com.itheima_02;
/*
-
篮球运动员和教练
乒乓球运动员和教练
现在篮球运动员和教练要出国访问,需要学习英语
请根据你所学的知识,分析出来哪些是类,哪些是抽象类,哪些是接口
*/
public class InterfaceTest {
public static void main(String[] args) {
//创建篮球运动员对象
BasketBallPlayer bbp = new BasketBallPlayer();
bbp.name = “女兆月日”;
bbp.age = 35;
bbp.gender = “男”;
bbp.sleep();
bbp.study();
bbp.speak();
System.out.println("-------------");
//创建乒乓球教练对象
PingpangCoach ppc = new PingpangCoach();
ppc.name = “刘胖子”;
ppc.age = 40;
ppc.gender = “男”;
ppc.sleep();
ppc.teach();
//ppc.speak();}
}
class Person {
String name;//姓名
int age;//年龄
String gender;//性别
//无参构造
public Person() {}
//有参构造
public Person(String name,int age,String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
//吃
public void eat() {
System.out.println("吃饭");
}
//睡
public void sleep() {
System.out.println("睡觉");
}
}
//学习说英语
interface SpeakEnglish {
public abstract void speak();
}
//运动员
abstract class Player extends Person {
//学习
public abstract void study();
}
//教练
abstract class Coach extends Person {
//教
public abstract void teach();
}
//篮球运动员
class BasketBallPlayer extends Player implements SpeakEnglish{
@Override
public void study() {
System.out.println("学扣篮");
}
@Override
public void speak() {
System.out.println("说英语");
}
}
//乒乓球运动员
class PingpangPlayer extends Player {
@Override
public void study() {
System.out.println("学抽球");
}
}
//篮球教练
class BasketBallCoach extends Coach implements SpeakEnglish {
@Override
public void teach() {
System.out.println("教扣篮");
}
@Override
public void speak() {
System.out.println("说英语");
}
}
//乒乓球教练
class PingpangCoach extends Coach {
@Override
public void teach() {
System.out.println("教抽球");
}
}
第39章匿名对象&final
39.1匿名对象定义&使用
匿名对象即无名对象,直接使用new关键字来创建对象
39.1.1案例代码五:
package com.itheima_01;
/*
- 匿名对象:没有名字的对象
- 匿名对象的应用场景：
-
当方法只调用一次的时候可以使用匿名对象 -
可以当作参数进行传递，但是无法在传参之前做其他的事情 - 注意：匿名对象可以调用成员变量并赋值，但是赋值并没有意义
*/
public class AnonymousObejctDemo {
public static void main(String[] args) {
//Student s = new Student();
//s.study();
//s.study();
//s.study();
//new Student();//匿名对象，没有变量引用的对象
//new Student().study();
//new Student().study();
//new Student().study();
//new Student().age = 18;
//System.out.println(new Student().age);
//Student s = new Student();
//s.age = 18;
//s.name = "张三";
//method(s);
method(new Student());
}
public static void method(Student s) {
}
}
class Student {
String name;
int age;
public void study() {
System.out.println("好好学习，高薪就业");
}
}
39.2final关键字
final： 修饰符，可以用于修饰类、成员方法和成员变量
final所修饰的类：不能被继承，不能有子类
final所修饰的方法:不能被重写
final所修饰的变量：是不可以修改的，是常量
39.2.1案例代码六:
package com.itheima_01;
/*
- final： 修饰符，可以用于修饰类、成员方法和成员变量
- final所修饰的类：不能被继承，不能有子类
- final所修饰的方法:不能被重写
- final所修饰的变量：是不可以修改的，是常量
- 常量：
-
字面值常量：1,2,3 -
自定义常量：被final所修饰的成员变量，一旦初始化则不可改变 - 注意：自定义常量必须初始化，可以选择显示初始化或者构造初始化
*/
public class FinalDemo {
public static void main(String[] args) {
//Animal a = new Animal();
//a.eat();
Dog d = new Dog();
//d.eat();
//d.num = 20;
System.out.println(d.NUM);
}
}
/final/ class Animal {
public final void eat() {
System.out.println(“吃东西”);
}
}
class Dog extends Animal {
/public void eat() {}/
final int NUM;
public Dog() {
NUM = 10;
}
}
第40章多态
40.1多态概述
多态是继封装、继承之后，面向对象的第三大特性。
现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。
Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。
40.2多态的定义与使用格式
多态的定义格式：就是父类的引用变量指向子类对象
父类类型 变量名 = new 子类类型();
变量名.方法名();
A:普通类多态定义的格式
父类 变量名 = new 子类();
如： class Fu {}
class Zi extends Fu {}
//类的多态使用
Fu f = new Zi();
B:抽象类多态定义的格式
抽象类 变量名 = new 抽象类子类();
如： abstract class Fu {
public abstract void method();
}
class Zi extends Fu {
public void method(){
System.out.println(“重写父类抽象方法”);
}
}
//类的多态使用
Fu fu= new Zi();
C:接口多态定义的格式
接口 变量名 = new 接口实现类();
如： interface Fu {
public abstract void method();
}
class Zi implements Fu {
public void method(){
System.out.println(“重写接口抽象方法”);
}
}
//接口的多态使用
Fu fu = new Zi();
40.2.1案例代码七:
package com.itheima_01;
/*
- 多态的前提：
- 子父类的继承关系
- 方法的重写
- 父类引用指向子类对象
- 动态绑定：运行期间调用的方法，是根据其具体的类型
*/
public class PoymorphicDemo {
public static void main(String[] args) {
/Cat c = new Cat();
c.eat();/
//父类引用 Animal a
//指向 =
//子类对象 new Cat()
Animal a = new Cat();
a.eat();
}
}
class Animal {
public void eat() {
System.out.println(“吃东西”);
}
}
class Cat extends Animal {
public void eat() {
System.out.println(“猫吃鱼”);
}
}
40.3多态成员的特点
A:多态成员变量
当子父类中出现同名的成员变量时，多态调用该变量时：
编译时期：参考的是引用型变量所属的类中是否有被调用的成员变量。没有，编译失败。
运行时期：也是调用引用型变量所属的类中的成员变量。
简单记：编译和运行都参考等号的左边。编译运行看左边。
B:多态成员方法
编译时期：参考引用变量所属的类，如果没有类中没有调用的方法，编译失败。
运行时期：参考引用变量所指的对象所属的类，并运行对象所属类中的成员方法。
简而言之：编译看左边，运行看右边
40.3.1案例代码八:
package com.itheima_01;
/*
*
- 多态的成员特点:
-
成员变量 编译时看的是左边，运行时看的左边 -
成员方法 编译时看的是左边，运行时看右边 -
静态方法 编译时看的是左边，运行时看的也是左边 - 编译时看的都是左边，运行时成员方法看的是右边，其他（成员变量和静态的方法）看的都是左边
*/
public class PoymorphicDemo2 {
public static void main(String[] args) {
Dad d = new Kid();
//System.out.println(d.num);
//d.method();
d.function();//使用变量去调用静态方法，其实相当于用变量类型的类名去调用
}
}
class Dad {
int num = 20;
public void method() {
System.out.println("我是父类方法");
}
public static void function() {
System.out.println("我是父类静态方法");
}
}
class Kid extends Dad {
int num = 10;
public void method() {
System.out.println("我是子类方法");
}
public static void function() {
System.out.println("我是子类静态方法");
}
}
40.4多态中向上转型与向下转型
多态的转型分为向上转型与向下转型两种：
A:向上转型：当有子类对象赋值给一个父类引用时，便是向上转型，多态本身就是向上转型的过程。
使用格式：
父类类型 变量名 = new 子类类型();
如：Person p = new Student();
B:向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程是向下转型。如果是直接创建父类对象，是无法向下转型的
使用格式：
子类类型 变量名 = (子类类型) 父类类型的变量;
如:Student stu = (Student) p; //变量p 实际上指向Student对象
40.4.1案例代码九:
package com.itheima_01;
/*
*
- 多态中的向上转型和向下转型:
- 引用类型之间的转换
-
向上转型 -
由小到大(子类型转换成父类型) -
向下转型 -
由大到小 - 基本数据类型的转换
-
自动类型转换 -
由小到大 -
byte short char --- int --- long --- float --- double -
强制类型转换 -
由大到小
*/
public class PoymorphicDemo3 {
public static void main(String[] args) {
Animal2 a = new Dog();//向上转型
//a.eat();
Dog d = (Dog)a;//向下转型
d.swim();
}
}
class Animal2 {
public void eat() {
System.out.println(“吃东西”);
}
}
class Dog extends Animal2 {
public void eat() {
System.out.println(“啃骨头”);
}
public void swim() {
System.out.println("狗刨");
}
}
40.5多态的优缺点
40.5.1案例代码十:
package com.itheima_01;
/*
*
- 多态的优缺点
-
优点：可以提高可维护性（多态前提所保证的），提高代码的可扩展性 缺点：无法直接访问子类特有的成员
*/
public class PoymorphicDemo4 {
public static void main(String[] args) {
MiFactory factory = new MiFactory();
factory.createPhone(new MiNote());
factory.createPhone(new RedMi());
}
}
class MiFactory {
/*public void createPhone(MiNote mi) {
mi.call();
}
public void createPhone(RedMi mi) {
mi.call();
}*/
public void createPhone(Phone p) {
p.call();
}
}
interface Phone {
public void call();
}
//小米Note
class MiNote implements Phone{
public void call() {
System.out.println(“小米Note打电话”);
}
}
//红米
class RedMi implements Phone {
public void call() {
System.out.println(“红米打电话”);
}
}
第41章包和权限修饰符
41.1包的概述
java的包，其实就是我们电脑系统中的文件夹，包里存放的是类文件。
当类文件很多的时候，通常我们会采用多个包进行存放管理他们，这种方式称为分包管理。
在项目中，我们将相同功能的类放到一个包中，方便管理。并且日常项目的分工也是以包作为边界。
41.2包的声明格式
通常使用公司网址反写，可以有多层包，包名采用全部小写字母，多层包之间用”.”连接
类中包的声明格式：
package 包名.包名.包名…;
如：黑马程序员网址itheima.com那么网址反写就为com.itheima
传智播客 itcast.cn 那么网址反写就为 cn.itcast
注意：声明包的语句，必须写在程序有效代码的第一行（注释不算）
代码演示：
package com.itheima_01;
/*
- 包的特点：
-
可以有多层 -
不同包下的文件名可以重复 -
包的声明必须是第一行代码
*/
public class PackageDemo {
}
41.3包之间互相访问
在访问类时，为了能够找到该类，必须使用含有包名的类全名（包名.类名）。
包名.包名….类名
如： java.util.Scanner
java.util.Random
cn.itcast.Demo
带有包的类，创建对象格式：包名.类名 变量名 = new包名.类名();
cn.itcast.Demo d = new cn.itcast.Demo();
前提：包的访问与访问权限密切相关，这里以一般情况来说，即类用public修饰的情况。
类的简化访问
当我们要使用一个类时，这个类与当前程序在同一个包中（即同一个文件夹中），或者这个类是java.lang包中的类时通常可以省略掉包名，直接使用该类。
我们每次使用类时，都需要写很长的包名。很麻烦，我们可以通过import导包的方式来简化。
可以通过导包的方式使用该类，可以避免使用全类名编写（即，包类.类名）。
导包的格式：
import 包名.类名;
41.3.1案例代码一:
package com.itheima_01;
import java.util.ArrayList;
/*
*
- 不同包之间的互相访问
-
使用类的全名 -
使用关键字import将类导入 - 注意：*代表的是通配符，代表导入了这个包下所有的类，并没有导入子包下的类
- 类的全名：包名.类名
*/
public class PackageDemo2 {
public static void main(String[] args) {
//相同包下的类可以直接访问，不需要做其他的操作
//PackageDemo pd = new PackageDemo();
java.util.ArrayList list = new java.util.ArrayList();
ArrayList list2 = new ArrayList();
}
}
41.4权限修饰符
在Java中提供了四种访问权限，使用不同的访问权限时，被修饰的内容会有不同的访问权限，以下表来说明不同权限的访问能力：
public protected default private
同一类中 √ √ √ √
同一包中(子类与无关类) √ √ √
不同包的子类 √ √
不同包中的无关类 √
归纳一下：在日常开发过程中，编写的类、方法、成员变量的访问
A:要想仅能在本类中访问使用private修饰
B:要想本包中的类都可以访问除了private修饰符,其它都可以
C:要想本包中的类与其他包中的子类可以访问使用protected修饰
D:要想所有包中的所有类都可以访问使用public修饰。
注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
41.4.1案例代码二:
package com.itheima_02;
/*
-
权限修饰符：
public 当前类，相同包下不同的类,不同包下的类
default 当前类，相同包下不同的类
private 当前类
protected 当前类，相同包下不同的类default:当前包下使用 protected:让子类对象使用
*/
public class PermissionsDemo {
public void publicMethod() {
System.out.println("publicMethod");
}
void defaultMethod() {
System.out.println("defaultMethod");
}
private void privateMethod() {
System.out.println("privateMethod");
}
protected void protectedMethod() {
System.out.println("protectedMethod");
}
public static void main(String[] args) {
PermissionsDemo pd = new PermissionsDemo();
pd.publicMethod();
pd.defaultMethod();
pd.privateMethod();
pd.protectedMethod();
}
}
package com.itheima_02;
public class PermissionsDemo2 {
public static void main(String[] args) {
PermissionsDemo pd = new PermissionsDemo();
pd.publicMethod();
pd.defaultMethod();
//pd.privateMethod();
pd.protectedMethod();
}
}
package com.itheima_03;
import com.itheima_02.PermissionsDemo;
public class PermissionsDemo3 {
public static void main(String[] args) {
PermissionsDemo pd = new PermissionsDemo();
pd.publicMethod();
//pd.defaultMethod();
//pd.privateMethod();
//pd.protectedMethod();
}
}
package com.itheima_03;
import com.itheima_02.PermissionsDemo;
public class PermissionsDemo4 extends PermissionsDemo {
public void function() {
super.publicMethod();
super.protectedMethod();
}
public static void main(String[] args) {
}
}
41.5修饰符总结
修饰符总结
修饰符 类 成员变量 成员方法 构造方法
public Y Y Y Y
default Y Y Y Y
protected Y Y Y
private Y Y Y
abstract Y Y
static Y Y
final Y Y Y
第42章内部类
42.1内部类概述
A:什么是内部类
将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。
B:什么时候使用内部类
在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。
class 汽车 { //外部类
class 发动机 { //内部类
}
}
42.2成员内部类
成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问
A:定义格式
class 外部类 {
修饰符 class 内部类 {
//其他代码
}
}
B:访问方式
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
42.2.1案例代码三
package com.itheima_01;
/*
- 成员内部类：
-
在类的成员位置，和成员变量以及成员方法所在的位置是一样的 -
在内部类当中，可以直接访问外部类的成员，包括私有成员
*/
public class InnerDemo {
public static void main(String[] args) {
//Outer o = new Outer();
//o.method();
Outer.Inner i = new Outer().new Inner();
i.function();
}
}
class Outer {
private int num = 10;
public void method() {
Inner i = new Inner();
i.function();
}
class Inner {
public void function() {
System.out.println(num);
}
}
}
成员内部类
成员内部类可以使用的修饰符:private,public,procted,final,static,abstract
42.2.2案例代码四
package com.itheima_01;
/*
-
成员内部类的修饰符：
-
我们可以使用权限修饰符修饰成员内部类，但是如果使用私有来修饰，则无法在其他类中访问 -
我们可以使用static修饰成员内部类，不用再创建外部类的对象了 -
我们可以使用abstract,final修饰成员内部类
*/
public class InnerDemo2 {
public static void main(String[] args) {
//Outer2.Inner2 i;//Outer2.Inner2 i = new Outer2.Inner2(); //i.function(); Outer2.Inner2.function();}
}
class Outer2 {
public void method() {
Inner2 i = new Inner2();
}
static class Inner2 {
public static void function() {
System.out.println(“function”);
}
}
}
42.3局部内部类
局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问
A:定义格式
class 外部类 {
修饰符 返回值类型 方法名(参数) {
class 内部类 {
//其他代码
}
}
}
B:访问方式
在外部类方法中，创建内部类对象，进行访问
42.3.1案例代码五:
package com.itheima_02;
/*
- 局部内部类
-
在方法内，出了方法之后就无法使用
*/
public class InnerDemo3 {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
class Outer {
public void method() {
int num = 10;
class Inner {
public void function() {
System.out.println("function");
}
}
Inner i = new Inner();
i.function();
}
public void test() {
//Inner i = new Inner();
//System.out.println(num);
}
}
42.4匿名内部类
A:作用：匿名内部类是创建某个类型子类对象的快捷方式。
B:格式：
new 父类或接口(){
//进行方法重写
};
代码演示
//已经存在的父类：
public abstract class Person{
public abstract void eat();
}
//定义并创建该父类的子类对象，并用多态的方式赋值给父类引用变量
Person p = new Person(){
public void eat() {
System.out.println(“我吃了”);
}
};
//调用eat方法
p.eat();
使用匿名对象的方式，将定义子类与创建子类对象两个步骤由一个格式一次完成，。虽然是两个步骤，但是两个步骤是连在一起完成的。
匿名内部类如果不定义变量引用，则也是匿名对象。代码如下：
new Person(){
public void eat() {
System.out.println(“我吃了”);
}
}.eat();
42.4.1案例代码六:
package com.itheima_03;
/*
- 匿名内部类:
-
可以把匿名内部类看成是一个没有名字的局部内部类 -
定义在方法当中 -
必须在定义匿名内部类的时候创建他的对象 - 格式：
-
new 类/接口(){ -
如果是创建了继承这个类的子类对象，我们可以重写父类的方法 -
如果是创建了实现这个接口的子类对象，我们必须要实现该接口的所有方法 -
}; - 原理：而是创建了继承这个类的子类对象或者是创建了实现这个接口的子类对象
*/
public class InnerDemo4 {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
interface Inner {
public void function();
}
class Outer {
public void method() {
/*new Inner() {
@Override
public void function() {
System.out.println("function");
}
}.function();;*/
Inner i = new Inner() {
@Override
public void function() {
System.out.println("function");
}
};
i.function();
i.function();
}
}
42.4.2案例代码七:
匿名内部类作为参数传递
package com.itheima_04;
public interface Animal {
public abstract void eat();
}
package com.itheima_04;
public class Cat implements Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
package com.itheima_04;
public class Dog implements Animal {
@Override
public void eat() {
System.out.println("狗啃骨头");
}
}
package com.itheima_04;
/*
- 匿名内部类的应用场景:
-
作为参数进行传递
*/
public class InnerDemo5 {
public static void main(String[] args) {
//method(new Dog());
//method(new Cat());
method(
new Animal() {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
);
}
public static void method(Animal a) {
a.eat();
}
}
第05天 API
今日内容介绍
Object类 & System类
日期相关类
包装类&正则表达式
第43章Object类 & System类
43.1Object类
43.1.1概述
Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。所有类在创建对象的时候，最终找的父类就是Object。
在Object类众多方法中，我们先学习equals方法与toString方法，其他方法后面课程中会陆续学到。
43.1.2toString()方法
由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。
43.1.2.1案例代码一:
package com.itheima_01;
/*
- String toString() : 返回该对象的字符串表示
-
return getClass().getName() + "@" + Integer.toHexString(hashCode()); -
getClass():返回一个字节码对象 -
Integer.toHexString():返回指定参数的十六进制字符串形式 -
hashCode()：返回该对象的哈希码值（内部地址） - boolean equals(Object obj)
*/
public class ObjectDemo {
public static void main(String[] args) {
Student s = new Student();
s.name = “zhangsan”;
s.age = 18;
System.out.println(s.toString());//com.itheima_01.Student@737951b0
System.out.println(s);//说明我们输出一个对象就是默认输出这个对象的toString()方法
}
}
class Student extends Object {
String name;
int age;
/*
public String toString() {
return name + “@” + age;
}
*/
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
43.1.3equals()方法
equals方法，用于比较两个对象是否相同，它其实就是使用两个对象的内存地址在比较。Object类中的equals方法内部使用的就是==比较运算符。
在开发中要比较两个对象是否相同，经常会根据对象中的属性值进行比较，也就是在开发经常需要子类重写equals方法根据对象的属性值进行比较。
43.1.3.1案例代码二:
package com.itheima_01;
import java.util.ArrayList;
/*
- boolean equals(Object obj)
-
使用==来比较两个对象是否相等，则比较地址值是否相等
*/
public class ObjectDemo2 {
public static void main(String[] args) {
Person p = new Person(“zhangsan”,18);
Person p2 = new Person(“zhangsan”,19);
//boolean flag = p.equals(p2);
boolean flag = p.equals(new ArrayList());
System.out.println(flag);
}
}
class Person {
String name;
int age;
public Person(String name,int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object obj) {
//提高效率
if (this == obj)
return true;
if (obj == null)
return false;
//提高健壮性
if (getClass() != obj.getClass())
return false;
//向下转型
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
/*@Override
public boolean equals(Object o) {
//提高效率 当前对象和传递进来的对象地址值一样，则不用比较成员
if(this == o) {
return true;
}
//提高代码的健壮性
if(this.getClass() != o.getClass()) {
return false;
}
//向下转型
Person other = (Person) o;
if(!this.name.equals(other.name)) {
return false;
}
if(this.age != other.age) {
return false;
}
return true;
}*/
}
43.2System类
System 类包含一些有用的类字段和方法。它不能被实例化。
43.2.1成员方法
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) :
从src源数组的srcPos索引开始,复制length个元素
从destPost位置开始将这些元素放至到dest数组中
static long currentTimeMillis()
返回以毫秒为单位的当前时间
static void exit(int status)
终止当前正在运行的 Java 虚拟机
static void gc()
运行垃圾回收器
43.2.2案例代码三:
package com.itheima_02;
/*
- System:包含一些有用的类字段和方法。它不能被实例化
- static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
- static long currentTimeMillis()
- static void exit(int status)
static void gc()
*/
public class SystemDemo {
public static void main(String[] args) {
//method();
//method2();
//method3();
//static void gc()
//Demo d = new Demo();
new Demo();
System.gc();
}
private static void method3() {
//static void exit(int status) :终止虚拟机
for (int i = 0; i < 100000; i++) {
System.out.println(i);
if(i == 100) {
System.exit(0);
}
}
}
private static void method2() {
/*
* static long currentTimeMillis() :以毫秒值返回当前系统时间
* 这个毫秒的时间是相对时间，相对于1970-1-1 00:00:00 ： 0
* 1970-1-1 00:00:01 : 1000
* 1970-1-1 00:01:00: 1000 * 60
* 1970-1-1 01:00:00: 1000 * 60 * 60
* 1000毫秒 = 1秒
*
*/
//System.out.println(System.currentTimeMillis());
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
System.out.println(i);
}
long end = System.currentTimeMillis();
System.out.println(end - start);
}
private static void method() {
/*
* static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
* 复制数组
* 参数1：源数组
* 参数2：源数组的起始索引位置
* 参数3：目标数组
* 参数4：目标数组的起始索引位置
* 参数5：指定接受的元素个数
*/
int[] src = {1,2,3,4,5};
int[] dest = new int[5];
System.arraycopy(src, 2, dest, 4, 3);
for (int i = 0; i < dest.length; i++) {
System.out.print(dest[i]);
}
}
}
class Demo {
@Override
protected void finalize() throws Throwable {
System.out.println(“我被回收了”);
}
}
第44章日期相关类
44.1Date类
Date: 表示特定的瞬间，精确到毫秒，他可以通过方法来设定自己所表示的时间，可以表示任意的时间
44.1.1Date类的构造方法
Date() ：创建的是一个表示当前系统时间的Date对象
Date(long date) ：根据"指定时间"创建Date对象
44.1.2案例代码四:
package com.itheima_03;
import java.util.Date;
/*
- Date: 表示特定的瞬间，精确到毫秒，他可以通过方法来设定自己所表示的时间，可以表示任意的时间
- System.currentTimeMillis():返回的是当前系统时间，1970-1-1至今的毫秒数
- 构造方法：
-
Date() ：创建的是一个表示当前系统时间的Date对象 Date(long date) ：根据"指定时间"创建Date对象
*/
public class DateDemo {
public static void main(String[] args) {
//Date()
//Date d = new Date();
//System.out.println(d);//Thu Aug 26 14:17:28 CST 2049
//System.out.println(d.toLocaleString());
//Date(long date)
Date d2 = new Date(1000 * 60 * 60 * 24);//时区 有时差
System.out.println(d2.toLocaleString());
}
}
44.1.3Date类常用方法
void setTime(long time)
long getTime()
44.1.4案例代码五:
package com.itheima_03;
import java.util.Date;
/*
-
Date的常用用方法
毫秒值 — Date
设置
返回值是void，参数long
void setTime(long time)
Date(long date)
Date — 毫秒值
获取
返回long，无参数
long getTime()
*/
public class DateDemo2 {
public static void main(String[] args) {
Date d = new Date();//默认当前系统时间
//d.setTime(1000 * 60 * 60 * 24 * 2);
System.out.println(d.toLocaleString());
System.out.println(d.getTime());//172800000d.setTime(172800000L); System.out.println(d.toLocaleString());}
}
44.2DateFormat类 & SimpleDateFormat
DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。日期/时间格式化子类（如 SimpleDateFormat类）允许进行格式化（也就是日期 -> 文本）、解析（文本-> 日期）和标准化。
我们通过这个类可以帮我们完成日期和文本之间的转换。
继续阅读API，DateFormat 可帮助进行格式化并解析任何语言环境的日期。对于月、星期，甚至日历格式（阴历和阳历），其代码可完全与语言环境的约定无关。
44.2.1DateFormat&SimpleDateFormat的常用方法
要格式化一个当前语言环境下的日期也就是日期 -> 文本），要通过下面的方法来完成。DateFormat是抽象类，我们需要使用其子类SimpleDateFormat来创建对象。
A:SimpleDateFormat构造方法
B:DateFormat类方法
44.2.2案例代码六:
package com.itheima_04;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
- SimpleDateFormat:
-
格式化： -
Date --- String -
2049-8-26 2049年8月26日 -
String format(Date date) -
解析： -
String --- Date -
"2049-8-26" -
Date parse(String source) - 构造方法：
-
SimpleDateFormat() ：使用默认的模式进行对象的构建 -
SimpleDateFormat(String pattern) ：使用的指定的模式进行对象的构建 - 注意：Exception in thread “main” java.text.ParseException: Unparseable date: “49年9月26日 下午1:29”
-
解析的字符串，模式必须和构建对象的模式一样
*/
public class SimpleDateFormatDemo {
public static void main(String[] args) throws ParseException {
//method();
//method2();
//使用指定的模式进行对象的构建
//1999年9月1日 10:10:10
//4个小姨2个大美眉和2个小弟弟
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日 HH:mm:ss”);
//格式化
Date date = new Date();
String s = sdf.format(date);
System.out.println(s);//2049年08月26日 13:39:12
//解析
Date d = sdf.parse("2049年08月26日 13:39:12");
System.out.println(d.toLocaleString());
}
private static void method2() throws ParseException {
//使用指定的模式进行对象的构建
//1999年9月1日
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
//格式化
Date date = new Date();
String s = sdf.format(date);
System.out.println(s);//2049年08月26日
//解析
Date d = sdf.parse("2049年08月26日");
System.out.println(d.toLocaleString());
}
private static void method() throws ParseException {
//使用默认模式进行对象的构建
SimpleDateFormat sdf = new SimpleDateFormat();
//创建日期对象
Date date = new Date();
//格式化 把日期对象转换成字符串
String s = sdf.format(date);
System.out.println(s);//49-8-26 下午1:29
//解析 把字符串转换成日期对象
Date d = sdf.parse("49年9月26日 下午1:29");
System.out.println(d.toLocaleString());
}
}
44.3Calendar类
44.3.1Calendar类概述
Calendar是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。
Calendar为抽象类，由于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，将语言敏感内容处理好，再返回子类对象，如下：
Calendar类静态方法
Calendar c = Calendar.getInstance(); //返回当前时间
44.3.2Calendar类常用方法
44.3.3案例代码七:
package com.itheima_05;
import java.util.Calendar;
/*
- Calendar：日历，提供了一些操作年月日时的方法
- 获取
- 修改
- 添加
*/
public class CalendarDemo {
public static void main(String[] args) {
//static Calendar getInstance()
Calendar c = Calendar.getInstance();
//void set(int field, int value) ：把指定的字段修改成指定的值
//c.set(Calendar.DAY_OF_MONTH, 20);
//void add(int field, int amount): 在指定的字段上加上指定的值
c.add(Calendar.DAY_OF_MONTH, -1);
//int get(int field) // 返回给定日历字段的值
//public static final int YEAR 1
//System.out.println(Calendar.YEAR);
//int year = c.get(1);
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1;
int day = c.get(Calendar.DAY_OF_MONTH);
System.out.println(year + "年" + month + "月" + day + "日");
}
}
第45章包装类&正则表达式
45.1包装类
在实际程序使用中，程序界面上用户输入的数据都是以字符串类型进行存储的。而程序开发中，我们需要把字符串数据，根据需求转换成指定的基本数据类型，如年龄需要转换成int类型，考试成绩需要转换成double类型等。那么，想实现字符串与基本数据之间转换怎么办呢？
Java中提供了相应的对象来解决该问题，基本数据类型对象包装类：java将基本数据类型值封装成了对象。封装成对象有什么好处？可以提供更多的操作基本数值的功能。
8种基本类型对应的包装类如下：
其中需要注意int对应的是Integer，char对应的Character，其他6个都是基本类型首字母大写即可。
45.2包装类的常用方法
A:构造方法:
B:成员方法:
45.2.1案例代码八:
package com.itheima_06;
/*
- 需求：判断一个数是否符合int类型的范围
- 由于基本数据类型只能做一些简单的操作和运算，所以Java为我们封装了基本数据类型，为每种基本数据类型提供了包装类
- 包装类就是封装了基本数据类型的类，为我们提供了更多复杂的方法和一些变量
- byte Byte
- short Short
- char Character
- int Integer
- long Long
- float Float
- double Double
- boolean Boolean
- Integer:
-
String --- int -
方式1：int intValue() -
方式2： static int parseInt(String s) -
int --- String -
方式1： + "" -
方式2：String toString() - 构造方法：
-
Integer(int value) -
Integer(String s)
*/
public class IntegerDemo {
public static void main(String[] args) {
/int n = 10;
if(n >= Math.pow(-2, 31) && n <= Math.pow(2, 31) -1) {
System.out.println(“符合”);
}
else {
System.out.println(“不符合”);
}/
Integer i = new Integer("10");
System.out.println(i);
int a = i.intValue();
System.out.println(a + 10 );
int b = Integer.parseInt("20");
System.out.println(b + 30);
Integer i2 = new Integer(40);
String s = i2.toString();
System.out.println(s);
String s2 = Integer.toString(50);
System.out.println(s2);
}
}
45.3包装类的自动装箱与拆箱
在需要的情况下，基本类型与包装类型可以通用。有些时候我们必须使用引用数据类型时，可以传入基本数据类型。
比如：
基本类型可以使用运算符直接进行计算，但是引用类型不可以。而基本类型包装类作为引用类型的一种却可以计算，原因在于，Java”偷偷地”自动地进行了对象向基本数据类型的转换。
相对应的，引用数据类型变量的值必须是new出来的内存空间地址值，而我们可以将一个基本类型的值赋值给一个基本类型包装类的引用。原因同样在于Java又”偷偷地”自动地进行了基本数据类型向对象的转换。
自动拆箱：对象转成基本数值
自动装箱：基本数值转成对象
45.3.1案例代码九:
package com.itheima_06;
import java.util.ArrayList;
/*
- JDK1.5特性：自动装箱和拆箱
*/
public class IntegerDemo2 {
public static void main(String[] args) {
//Integer i = new Integer(10);
//自动装箱
//相当于： Integer i = new Integer(10);
//Integer i = 10;
//自动拆箱
//相当于 int a = i.intValue();
//Integer i = 10;
//int a = i;
Integer i = 10;
Integer i2 = 20;
Integer i3 = i + i2;
/*
* Integer i3 = new Integer(i.intValue() + i2.intValue());
*
*/
ArrayList list = new ArrayList();
list.add(1);//自动装箱，list.add(new Integer(1));
}
}
45.4正则表达式
45.4.1正则表达式概述
正则表达式是专门解决字符串规则匹配的工具。
正则表达式也是一个字符串，用来定义匹配规则。
参照帮助文档，在Pattern类中有简单的规则定义，可以结合字符串类的方法使用。
45.4.2正则表达式匹配规则
参照帮助文档，在Pattern类中有正则表达式的的规则定义，正则表达式中明确区分大小写字母。我们来学习语法规则。
正则表达式的语法规则：
字符：x
含义：代表的是字符x
例如：匹配规则为 “a”，那么需要匹配的字符串内容就是 ”a”
字符：\
含义：代表的是反斜线字符’’
例如：匹配规则为"\" ，那么需要匹配的字符串内容就是 ”\”
字符类：[abc]
含义：代表的是字符a、b 或 c
例如：匹配规则为"[abc]" ，那么需要匹配的内容就是字符a，或者字符b，或字符c的一个
字符类：[^abc]
含义：代表的是除了 a、b 或 c以外的任何字符
例如：匹配规则为"[^abc]"，那么需要匹配的内容就是不是字符a，或者不是字符b，或不是字符c的任意一个字符
字符类：[a-zA-Z]
含义：代表的是a 到 z 或 A 到 Z，两头的字母包括在内
例如：匹配规则为"[a-zA-Z]"，那么需要匹配的是一个大写或者小写字母
字符类：[0-9]
含义：代表的是 0到9数字，两头的数字包括在内
例如：匹配规则为"[0-9]"，那么需要匹配的是一个数字
字符类：[a-zA-Z_0-9]
含义：代表的字母或者数字或者下划线(即单词字符)
例如：匹配规则为" [a-zA-Z_0-9] "，那么需要匹配的是一个字母或者是一个数字或一个下滑线
预定义字符类：.
含义：代表的是任何字符
例如：匹配规则为" . “，那么需要匹配的是一个任意字符。如果，就想使用 . 的话，使用匹配规则”\."来实现
预定义字符类：\d [0-9]
含义：代表的是 0到9数字，两头的数字包括在内，相当于[0-9]
例如：匹配规则为"\d "，那么需要匹配的是一个数字
预定义字符类：\w [a-zA-Z_0-9]
含义：代表的字母或者数字或者下划线(即单词字符)，相当于[a-zA-Z_0-9]
例如：匹配规则为"\w “，，那么需要匹配的是一个字母或者是一个数字或一个下滑线
数量词：X?
含义：代表的是X出现一次或一次也没有
例如：匹配规则为"a?”，那么需要匹配的内容是一个字符a，或者一个a都没有
数量词：X*
含义：代表的是X出现零次或多次
例如：匹配规则为"a*" ，那么需要匹配的内容是多个字符a，或者一个a都没有
数量词：X+
含义：代表的是X出现一次或多次
例如：匹配规则为"a+"，那么需要匹配的内容是多个字符a，或者一个a
数量词：X{n}
含义：代表的是X出现恰好 n 次
例如：匹配规则为"a{5}"，那么需要匹配的内容是5个字符a
数量词：X{n,}
含义：代表的是X出现至少 n 次
例如：匹配规则为"a{5, }"，那么需要匹配的内容是最少有5个字符a
数量词：X{n,m}
含义：代表的是X出现至少 n 次，但是不超过 m 次
例如：匹配规则为"a{5,8}"，那么需要匹配的内容是有5个字符a 到 8个字符a之间
45.4.3案例代码十:
package com.itheima_07;
/*
-
校验qq号码
-
要求必须是5-15位 -
0不能开头 -
必须都是数字正则表达式：就是一套规则，可以用于匹配字符串
boolean matches(String regex) ：判断当前字符串是否匹配指定的正则表达式，如果匹配则返回true，否则返回false
*/
public class RegexDemo {
public static void main(String[] args) {
String qq = “12a345”;
/boolean flag = checkQQ(qq);
System.out.println(flag);/
boolean flag = qq.matches("[1-9][0-9]{4,14}");
System.out.println(flag);
}
public static boolean checkQQ(String qq) {
int length = qq.length();
//要求必须是5-15位
if(length < 5 || length > 15) {
return false;
}
//0不能开头
if(qq.startsWith("0")) {
return false;
}
//必须都是数字
for (int i = 0; i < length; i++) {
//得到参数的每一个字符
char c = qq.charAt(i);
if(c < '0' || c > '9') {
return false;
}
}
return true;//符合要求
}
}
第06天 集合
今日内容介绍
集合&迭代器
增强for & 泛型
常见数据结构
List子体系
第46章集合&迭代器
46.1集合体系结构
46.1.1集合体系图
在最顶层的父接口Collection中一定定义了所有子类集合的共同属性和方法,因此我们首先需要学习Collection中共性方法,然后再去针对每个子类集合学习它的特有方法
46.1.2案例代码一:
package com.itheima_01;
import java.util.ArrayList;
/*
-
ArrayList
-
集合的体系结构：
-
由于不同的数据结构（数据的组织，存储方式），所以Java为我们提供了不同的集合， -
但是不同的集合他们的功能都是相似，不断的向上提取，将共性抽取出来，这就是集合体系结构形成的原因 -
体系结构：
-
怎么学习?最顶层开始学习，因为最顶层包含了所有的共性 -
怎么使用？使用最底层，因为最底层就是具体的实现 -
Collection
-
List
-
ArrayList
*/
public class CollectionDemo {
public static void main(String[] args) {
//创建集合对象
ArrayList al = new ArrayList();
//添加元素
al.add(“hello”);
al.add(“world”);
al.add(“java”);
//遍历集合
for(int x = 0;x < al.size();x++) {
System.out.println(al.get(x));
}}
}
46.2Collection中的常用功能
boolean add(Object e): 向集合中添加元素
void clear():清空集合中所有元素
boolean contains(Object o):判断集合中是否包含某个元素
boolean isEmpty():判断集合中的元素是否为空
boolean remove(Object o):根据元素的内容来删除某个元素
int size():获取集合的长度
Object[] toArray():能够将集合转换成数组并把集合中的元素存储到数组中
46.2.1案例代码二:
package com.itheima_01;
import java.util.ArrayList;
import java.util.Collection;
/*
-
Collection
-
boolean add(E e) -
void clear() -
boolean contains(Object o) -
boolean isEmpty() -
boolean remove(Object o) -
int size() -
Object[] toArray() -
Iterator iterator()
*/
public class CollectionDemo2 {
public static void main(String[] args) {
//创建集合对象
//Collection c = new Collection();//Collection是接口，不能实例化
Collection c = new ArrayList();//多态，父类引用指向子类对象
//boolean add(E e)
System.out.println(c.add("hello"));//永远可以添加成功，因为ArrayList他允许重复
System.out.println(c.add("world"));
//void clear()：清空集合
//c.clear();
//boolean contains(Object o) :判断集合中是否包含指定元素
//System.out.println(c.contains("java"));
//boolean isEmpty() :是否为空
//System.out.println(c.isEmpty());
//boolean remove(Object o) :删除元素
//System.out.println(c.remove("java"));
//int size() :返回集合中的元素个数
//System.out.println(c.size());
//Object[] toArray() :将集合转换成一个Object类型的数组
Object[] objs = c.toArray();
for (int i = 0; i < objs.length; i++) {
System.out.println(objs[i]);
}
System.out.println(c);
}
}
46.3迭代器
java中提供了很多个集合，它们在存储元素时，采用的存储方式不同。我们要取出这些集合中的元素，可通过一种通用的获取方式来完成。
Collection集合元素的通用获取方式：在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
集合中把这种取元素的方式描述在Iterator接口中。Iterator接口的常用方法如下
hasNext（）方法：判断集合中是否有元素可以迭代
next（）方法：用来返回迭代的下一个元素，并把指针向后移动一位。
46.3.1案例代码三:
package com.itheima_02;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
- 集合的遍历方式：
-
1.toArray(),可以把集合转换成数组，然后遍历数组即可 -
2.iterator(),可以返回一个迭代器对象，我们可以通过迭代器对象来迭代集合 - Iterator：可以用于遍历集合
- E next() :返回下一个元素
- boolean hasNext() ：判断是否有元素可以获取
- 注意：Exception in thread “main” java.util.NoSuchElementException
-
使用next方法获取下一个元素，如果没有元素可以获取，则出现NoSuchElementException
*/
public class IteratorDemo {
public static void main(String[] args) {
//method();
//创建集合对象
Collection c = new ArrayList();
//添加元素
c.add(“hello”);
c.add(“world”);
c.add(“java”);
//获取迭代器对象
Iterator it = c.iterator();
//Object next() :返回下一个元素
//boolean hasNext() ：判断是否有元素可以获取
/*if(it.hasNext())
System.out.println(it.next());
if(it.hasNext())
System.out.println(it.next());
if(it.hasNext())
System.out.println(it.next());
if(it.hasNext())
System.out.println(it.next());*/
while(it.hasNext()) {
System.out.println(it.next());
}
}
private static void method() {
//创建集合对象
Collection c = new ArrayList();
//添加元素
c.add("hello");
c.add("world");
c.add("java");
//获取数组
Object[] objs = c.toArray();
//遍历数组
for (int i = 0; i < objs.length; i++) {
System.out.println(objs[i]);
}
}
}
46.4并发修改异常:
并发修改异常产生原因:
当使用迭代器遍历集合的时候,使用了集合中的 增加/删除 方法,导致并发修改异常产
46.4.1案例代码四:
package com.itheima_02;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/*
- 需求：判断集合中是否包含元素java，如果有则添加元素android
- Exception in thread “main” java.util.ConcurrentModificationException:并发修改异常
- 迭代器是依赖于集合的，相当于集合的一个副本，当迭代器在操作的时候，如果发现和集合不一样，则抛出异常
- 解决方案:
-
你就别使用迭代器 -
在使用迭代器进行遍历的时候使用迭代器来进行修改
*/
public class IteratorDemo3 {
public static void main(String[] args) {
//method();
//创建集合对象
//Collection c = new ArrayList();
List c = new ArrayList();
//添加元素
c.add("hello");
c.add("world");
c.add("java");
//我们可以通过遍历来获取集合中的每一个元素，然后进行比较即可
/*Iterator it = c.iterator();
while(it.hasNext()) {
String s = (String)it.next();
if(s.equals("java")) {
c.add("android");
}
}*/
ListIterator lit = c.listIterator();
while(lit.hasNext()) {
String s = (String)lit.next();
if(s.equals("java")) {
lit.add("android");
}
}
System.out.println(c);
}
private static void method() {
//创建集合对象
Collection c = new ArrayList();
//添加元素
c.add("hello");
c.add("world");
c.add("java");
//判断集合中是否包含元素java
if(c.contains("java")) {
c.add("android");
}
System.out.println(c);
}
}
并发修改异常解决方案:
A:不使用迭代器遍历集合,就可以在遍历的时候使用集合的方法进行增加或删除
B:依然使用迭代器遍历,那么就需要使用Iterator的子接口ListIterator来实现向集合中添加
第47章增强for&泛型
47.1泛型
47.1.1泛型的引入
在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换
47.1.1.1案例代码五:
package com.itheima_03;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
- 使用集合存储自定义对象并遍历
- 由于集合可以存储任意类型的对象，当我们存储了不同类型的对象，就有可能在转换的时候出现类型转换异常，
- 所以java为了解决这个问题，给我们提供了一种机制，叫做泛型
-
*/
public class GenericDemo {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();
//创建元素对象
Student s = new Student(“zhangsan”,18);
Student s2 = new Student(“lisi”,19);
//添加元素对象
c.add(s);
c.add(s2);
//遍历集合对象
Iterator it = c.iterator();
while(it.hasNext()) {
String str = (String)it.next();
System.out.println(str);
}
}
}
class Student {
String name;
int age;
public Student(String name,int age) {
this.name = name;
this.age = age;
}
}
以上代码会发生强制转换异常,原因就是String str = (String)it.next() ,存入集合的是Student,而强转为String,String与Student之间没有任何子父关系不能强转,未使用泛型前有可能发声强制转换异常的问题
47.1.2泛型的使用
当类上定义<>的时候就可以使用泛型,例如ArrayList类的定义:
class ArrayList,那么我们在创建ArrayList对象的时候就可以指定<>中E的类型
ArrayList al=new ArrayList(),那么String就把E替换掉了
47.1.2.1案例代码六:
package com.itheima_03;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
- 使用集合存储自定义对象并遍历
- 由于集合可以存储任意类型的对象，当我们存储了不同类型的对象，就有可能在转换的时候出现类型转换异常，
- 所以java为了解决这个问题，给我们提供了一种机制，叫做泛型
- 泛型：是一种广泛的类型，把明确数据类型的工作提前到了编译时期，借鉴了数组的特点
- 泛型好处：
-
避免了类型转换的问题 -
可以减少黄色警告线 -
可以简化我们代码的书写 - 什么时候可以使用泛型？
-
问API，当我们看到<E>，就可以使用泛型了
*/
public class GenericDemo {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();
//创建元素对象
Student s = new Student(“zhangsan”,18);
Student s2 = new Student(“lisi”,19);
//添加元素对象
c.add(s);
c.add(s2);
//遍历集合对象
Iterator<Student> it = c.iterator();
while(it.hasNext()) {
//String str = (String)it.next();
//System.out.println(str);
Student stu = it.next();
System.out.println(stu.name);
}
}
}
class Student {
String name;
int age;
public Student(String name,int age) {
this.name = name;
this.age = age;
}
}
47.2增强for
增强for循环是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
格式：
for(元素的数据类型 变量 : Collection集合or数组){
}
它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。
47.2.1案例代码七:
package com.itheima_04;
import java.util.ArrayList;
import java.util.Collection;
/*
-
foreach:增强for循环，一般用于遍历集合或者数组
-
格式：
-
for(元素的类型 变量 : 集合或者数组对象) { -
可以直接使用变量; -
}注意：在增强for循环中不能修改集合，否则会出现并发修改异常。
public interface Iterable
实现这个接口允许对象成为 “foreach” 语句的目标。
*/
public class ForEachDemo {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();
//添加元素
c.add(“hello”);
c.add(“world”);
c.add(“java”);
//增强for循环遍历集合
/*for(Object obj : c) {
System.out.println(obj);
}*/
/*for(String s : c) {
System.out.println(s.toUpperCase());
}*/
for (String string : c) {
c.add("android");
System.out.println(string);
}
}
}
第48章常见数据结构
48.1数组
数组，采用该结构的集合，对元素的存取有如下的特点：
查找元素快：通过索引，可以快速访问指定位置的元素
增删元素慢 ,每次添加元素需要移动大量元素或这创建新的数组
48.2链表
链表，采用该结构的集合，对元素的存取有如下的特点：
A:多个节点之间，通过地址进行连接。例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。
B:查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素
C:增删元素快：
增加元素：只需要修改连接下个元素的地址即可。
删除元素：只需要修改连接下个元素的地址即可
48.3栈&队列
A:堆栈，采用该结构的集合，对元素的存取有如下的特点：
先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。
B:队列，采用该结构的集合，对元素的存取有如下的特点：
先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如，安检。排成一列，每个人依次检查，只有前面的人全部检查完毕后，才能排到当前的人进行检查。
第49章List子体系
49.1List子体系特点
A:有序的（存储和读取的顺序是一致的）
B:有整数索引
C:允许重复的
49.2List的特有功能
void add(int index, E element) :将元素添加到index索引位置上
E get(int index) :根据index索引获取元素
E remove(int index) :根据index索引删除元素
E set(int index, E element):将index索引位置的的元素设置为element
49.2.1案例代码八:
package com.itheima_05;
import java.util.ArrayList;
import java.util.List;
/*
-
List:
-
有序的（存储和读取的顺序是一致的） -
有整数索引 -
允许重复的 -
List的特有功能：
-
void add(int index, E element) -
E get(int index) -
E remove(int index) -
E set(int index, E element) -
增删改查
*/
public class ListDemo {
public static void main(String[] args) {
//创建的列表对象
List list = new ArrayList();
//void add(int index, E element) : 在指定索引位置添加指定元素
list.add(0, "hello");
list.add(0, "world");
list.add(1, "java");
//E get(int index) :根据索引返回元素
/*System.out.println(list.get(0));
System.out.println(list.get(1));
System.out.println(list.get(2));*/
//System.out.println(list.get(3));
/*for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}*/
//E remove(int index) : 删除指定元素并返回
//System.out.println(list.remove(5));
//E set(int index, E element) : 将指定索引位置的元素替换为指定元素，并将原先的元素返回
System.out.println(list.set(0, "android"));
System.out.println(list);
}
}
49.3LinkedList特有功能
LinkedList底层使用的是链表结构,因此增删快,查询相对ArrayList较慢
void addFirst(E e) :向链表的头部添加元素
void addLast(E e):向链表的尾部添加元素
E getFirst():获取链头的元素,不删除元素
E getLast():获取链尾的元素,不删除元素
E removeFirst():返回链头的元素并删除链头的元素
E removeLast():返回链尾的元素并删除链尾的元素
49.3.1案例代码九:
package com.itheima_06;
import java.util.LinkedList;
/*
- List的常用子类：
-
ArrayList -
底层是数组结构，查询快，增删慢 -
LinkedList -
底层结构是链表，查询慢，增删快 - 如何选择使用不同的集合？
-
如果查询多，增删少，则使用ArrayList -
如果查询少，增删多，则使用LinkedList -
如果你不知道使用什么，则使用ArrayList - LinkedList的特有功能：
-
void addFirst(E e) -
void addLast(E e) E getFirst() E getLast() E removeFirst() E removeLast()
*/
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.add(“hello”);
list.add(“world”);
//void addFirst(E e) :将元素添加到索引为0的位置
//void addLast(E e) ：将元素添加到索引为size()-1的位置
list.addFirst("java");
list.addLast("android");
//E getFirst() :获取索引为0的元素
//E getLast() ：获取索引为size()-1的元素
//System.out.println(list.getFirst());
//System.out.println(list.getLast());
//E removeFirst() :删除索引为0的元素并返回
//E removeLast() ：删除索引为size()-1的元素并返回
System.out.println(list.removeFirst());
System.out.println(list.removeLast());
System.out.println(list);
}
}
49.4案例代码九
package com.itheima_07;
import java.util.ArrayList;
import java.util.List;
/*
- 需求：定义一个方法，返回指定列表中指定元素的索引位置
- 判断元素是否存在
*/
public class ListTest {
public static void main(String[] args) {
List list = new ArrayList();
list.add(“hello”);
list.add(“world”);
list.add(“java”);
//int index = index(list,"php");
//System.out.println(index);
//boolean flag = contains(list, "php");
//System.out.println(flag);
boolean flag = list.contains("php");
System.out.println(flag);
}
public static int index(List list,Object other) {
for(int x = 0;x < list.size();x++) {
//获取列表中的元素
Object obj = list.get(x);
//使用列表中的元素和指定的元素进行比较
if(obj.equals(other)) {
return x;
}
}
//查找不到指定的元素
return -1;
}
public static boolean contains(List list,Object other) {
//获取指定元素在指定列表中的索引位置
int index = index(list,other);
//如果索引位置大于等于0，则认为元素存在，否则不存在
if(index >= 0) {
return true;
}
else {
return false;
}
}
}
第07天 集合
今日内容介绍
HashSet集合
HashMap集合
第50章HashSet集合
50.1Set接口的特点
Set体系的集合:
A:存入集合的顺序和取出集合的顺序不一致
B:没有索引
C:存入集合的元素没有重复
50.2HashSet使用&唯一性原理
50.2.1HashSet的使用
50.2.1.1案例代码一:
public class HashSetDemo2 {
public static void main(String[] args) {
//创建集合对象
HashSet hs = new HashSet();
//创建元素对象
Student s = new Student(“zhangsan”,18);
Student s2 = new Student(“lisi”,19);
Student s3 = new Student(“lisi”,19);
//添加元素对象
hs.add(s);
hs.add(s2);
hs.add(s3);
//遍历集合对象
for (Student student : hs) {
System.out.println(student);
}
}
}
50.2.2HashSet唯一性原理
规则:新添加到HashSet集合的元素都会与集合中已有的元素一一比较
首先比较哈希值(每个元素都会调用hashCode()产生一个哈希值)
如果新添加的元素与集合中已有的元素的哈希值都不同,新添加的元素存入集合
如果新添加的元素与集合中已有的某个元素哈希值相同,此时还需要调用equals(Object obj)比较
如果equals(Object obj)方法返回true,说明新添加的元素与集合中已有的某个元素的属性值相同,那么新添加的元素不存入集合
如果equals(Object obj)方法返回false, 说明新添加的元素与集合中已有的元素的属性值都不同, 那么新添加的元素存入集合
50.2.2.1案例代码二:
package com.itheima_01;
import java.util.HashSet;
/*
- 使用HashSet存储自定义对象并遍历
- 通过查看源码发现：
-
HashSet的add()方法，首先会使用当前集合中的每一个元素和新添加的元素进行hash值比较， -
如果hash值不一样，则直接添加新的元素 -
如果hash值一样，比较地址值或者使用equals方法进行比较 -
比较结果一样，则认为是重复不添加 -
所有的比较结果都不一样则添加
*/
public class HashSetDemo2 {
public static void main(String[] args) {
//创建集合对象
HashSet hs = new HashSet();
//创建元素对象
Student s = new Student(“zhangsan”,18);
Student s2 = new Student(“lisi”,19);
Student s3 = new Student(“lisi”,19);
//添加元素对象
hs.add(s);
hs.add(s2);
hs.add(s3);
//遍历集合对象
for (Student student : hs) {
System.out.println(student);
}
}
}
class Student {
String name;
int age;
public Student(String name,int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
@Override
public boolean equals(Object obj) {
//System.out.println("-------------------");
Student s = (Student)obj;//向下转型，可以获取子类特有成员
//比较年龄是否相等，如果不等则返回false
if(this.age != s.age) {
return false;
}
//比较姓名是否相等，如果不等则返回false
if(!this.name.equals(s.name)) {
return false;
}
//默认返回true，说明两个学生是相等的
return true;
}
@Override
public int hashCode() {
return 1;
}
}
50.2.2.2hashCode方法优化:
如果让hashCode()方法返回一个固定值,那么每个新添加的元素都要调用equals(Object obj)方法比较,那么效率较低
只需要让不同属性的值的元素产生不同的哈希值,那么就可以不再调用equals方法比较提高效率
50.2.2.3案例代码三:
package com.itheima_02;
public class Person {
String name;
int age;
public Person(String name,int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
/*
@Override
public int hashCode() {
* 我们发现当hashCode方法永远返回整数1时，所有对象的hash值都是一样的，
* 有一些对象他的成员变量完全不同，但是他们还需要进行hash和equals方法的比较，
* 如果我们可以让成员变量不同的对象，他们的hash值也不同，这就可以减少一部分equals方法的比较
* 从而可以提高我们程序的效率
*
* 可以尝试着让hashCode方法的返回值和对象的成员变量有关
* 可以让hashCode方法返回所有成员变量之和，
* 让基本数据类型直接想加，然后引用数据类型获取hashCode方法返回值后再相加（boolean不可以参与运算）
*
//return age;
return age + name.hashCode();
}
@Override
public boolean equals(Object obj) {
System.out.println("-------------");
//提高效率
if(this == obj) {
return true;
}
//提高健壮性
if(this.getClass() != obj.getClass()) {
return false;
}
//向下转型
Person p = (Person)obj;
if(!this.name.equals(p.name)) {
return false;
}
if(this.age != p.age) {
return false;
}
return true;
}*/
}
package com.itheima_02;
import java.util.HashSet;
public class HashSetDemo3 {
public static void main(String[] args) {
//创建集合对象
HashSet hs = new HashSet();
//创建元素对象
Person p = new Person(“zhangsan”,18);
Person p2 = new Person(“lisi”,18);
Person p3 = new Person(“lisi”,18);
//添加元素对象
hs.add(p);
hs.add(p2);
hs.add(p3);
//遍历集合对象
for (Person person : hs) {
System.out.println(person);
}
}
}
50.3Collections中的方法
50.3.1案例代码四:
package com.itheima_03;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/*
- Collections：
- 面试题：Collection和Collections有什么区别？
-
Collection是集合体系的最顶层，包含了集合体系的共性 -
Collections是一个工具类，方法都是用于操作Collection
*/
public class CollectionsDemo {
public static void main(String[] args) {
//static void swap(List list, int i, int j) :将指定列表中的两个索引进行位置互换
List list = new ArrayList();
list.add(1);
list.add(4);
Collections.swap(list, 0, 1);
System.out.println(list);
}
private static void method6() {
//static void sort(List<T> list) :按照列表中元素的自然顺序进行排序
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(4);
list.add(3);
list.add(2);
Collections.sort(list);
System.out.println(list);
}
private static void method5() {
//static void shuffle(List list):傻否，随机置换
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Collections.shuffle(list);
System.out.println(list);
}
private static void method4() {
//static void reverse(List list) :反转
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Collections.reverse(list);
System.out.println(list);
}
private static void method3() {
//static void fill(List list, Object obj) :使用指定的对象填充指定列表的所有元素
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("java");
System.out.println(list);
Collections.fill(list, "android");
System.out.println(list);
}
private static void method2() {
//static void copy(List dest, List src) :是把源列表中的数据覆盖到目标列表
//注意：目标列表的长度至少等于源列表的长度
//创建源列表
List<String> src = new ArrayList<String>();
src.add("hello");
src.add("world");
src.add("java");
//创建目标列表
List<String> dest = new ArrayList<String>();
dest.add("java");
dest.add("java");
dest.add("java");
dest.add("java");
Collections.copy(dest, src);
System.out.println(dest);
}
private static void method() {
//static int binarySearch(List list, Object key) 使用二分查找法查找指定元素在指定列表的索引位置
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
int index = Collections.binarySearch(list, 4);
System.out.println(index);
}
}
50.4斗地主案例
具体规则：
1. 组装54张扑克牌
2. 将54张牌顺序打乱
3. 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
4. 查看三人各自手中的牌、底牌
50.4.1案例代码五:
package com.itheima_03;
import java.util.ArrayList;
import java.util.Collections;
/*
-
模拟斗地主发牌
买牌
洗牌
发牌
*/
public class CollectionsTest {
public static void main(String[] args) {
//买牌
String[] arr = {“黑桃”,“红桃”,“方片”,“梅花”};
String[] arr2 = {“A”,“2”,“3”,“4”,“5”,“6”,“7”,“8”,“9”,“10”,“J”,“Q”,“K”};
ArrayList<String> box = new ArrayList<String>();
//添加每张牌
for (int i = 0; i < arr.length; i++) {
//获取每一个花色
for (int j = 0; j < arr2.length; j++) {
//获取每一个数
box.add(arr[i] + arr2[j]);
}
}
box.add("大王");
box.add("小王");
//System.out.println(box.size());
//洗牌
Collections.shuffle(box);
//System.out.println(box);
//发牌
ArrayList<String> 林志玲 = new ArrayList<String>();
ArrayList<String> 林心如 = new ArrayList<String>();
ArrayList<String> 舒淇 = new ArrayList<String>();
//留三张底牌给地主
for (int i = 0; i < box.size() - 3; i++) {
/*
* i = 0;i % 3 = 0;
* i = 1;i % 3 = 1;
* i = 2;i % 3 = 2;
* i = 3;i % 3 = 0;
* i = 4;i % 4 = 1;
* i = 5;i % 5 = 2;
*/
if(i % 3 == 0) {
林志玲.add(box.get(i));
}
else if(i % 3 == 1) {
林心如.add(box.get(i));
}
else if(i % 3 == 2) {
舒淇.add(box.get(i));
}
}
System.out.println("林志玲：" + 林志玲);
System.out.println("林心如：" + 林心如);
System.out.println("舒淇：" + 舒淇);
System.out.println("底牌：");
/* System.out.println(box.get(box.size() - 1));
System.out.println(box.get(box.size() - 2));
System.out.println(box.get(box.size() - 3));*/
for (int i = box.size() - 3; i < box.size(); i++) {
System.out.println(box.get(i));
}
}
}
第51章HashMap集合
51.1Map接口概述
我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下图。
A:Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储
B:Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。
C:Collection中的集合称为单列集合，Map中的集合称为双列集合。
需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
51.2Map常用功能
A:映射功能：
V put(K key, V value) :以键=值的方式存入Map集合
B:获取功能：
V get(Object key):根据键获取值
int size():返回Map中键值对的个数
C:判断功能：
boolean containsKey(Object key):判断Map集合中是否包含键为key的键值对
boolean containsValue(Object value):判断Map集合中是否包含值为value键值对
boolean isEmpty():判断Map集合中是否没有任何键值对
D:删除功能：
void clear():清空Map集合中所有的键值对
V remove(Object key):根据键值删除Map中键值对
E:遍历功能：
Set<Map.Entry<K,V>> entrySet():将每个键值对封装到一个个Entry对象中,再把所有Entry的对象封装到Set集合中返回
Set keySet() :将Map中所有的键装到Set集合中返回
Collection values():返回集合中所有的value的值的集合
51.2.1案例代码四:
package com.itheima_01;
import java.util.HashMap;
import java.util.Map;
/*
-
Map的常用功能：
-
映射功能： -
V put(K key, V value) -
获取功能： -
V get(Object key) -
int size() -
判断功能： -
boolean containsKey(Object key) boolean containsValue(Object value) boolean isEmpty() -
删除功能： -
void clear() -
V remove(Object key) -
遍历功能： -
Set<Map.Entry<K,V>> entrySet() -
Set<K> keySet() -
Collection<V> values()
*/
public class MapDemo2 {
public static void main(String[] args) {
//创建Map对象
Map<String,String> map = new HashMap<String,String>();
//V put(K key, V value) ：就是将key映射到value，如果key存在，则覆盖value，并将原来的value返回
System.out.println(map.put("ITCAST001", "张三"));
System.out.println(map.put("ITCAST002", "李四"));
System.out.println(map.put("ITCAST001", "王五"));
//void clear() : 清空所有的对应关系
//map.clear();
//V remove(Object key) :根据指定的key删除对应关系，并返回key所对应的值，如果没有删除成功则返回null
//System.out.println(map.remove("ITCAST005"));
//boolean containsKey(Object key) : 判断指定key是否存在
//System.out.println(map.containsKey("ITCAST003"));
//boolean containsValue(Object value)：判断指定的value是否存在
//System.out.println(map.containsValue("王五"));
//boolean isEmpty() : 判断是否有对应关系
//System.out.println(map.isEmpty());
//int size() : 返回对应关系的个数
//System.out.println(map.size());
//V get(Object key) : 根据指定的key返回对应的value
System.out.println(map.get("ITCAST002"));
System.out.println(map);
}
}
51.2.2案例代码五:
package com.itheima_01;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
-
Set keySet()
-
Collection values()
*/
public class MapDemo3 {
public static void main(String[] args) {
//创建Map对象
Map<String,String> map = new HashMap<String,String>();
//添加映射关系
map.put(“ITCAST001”, “张三”);
map.put(“ITCAST002”, “李四”);
map.put(“ITCAST005”, “李四”);//Set<K> keySet() : 以Set的形式获返回所有的key Set<String> keys = map.keySet(); for (String key : keys) { System.out.println(key); } System.out.println("-----------"); //Collection<V> values() : Collection<String> values = map.values(); for (String value : values) { System.out.println(value); }}
}
51.3Map的两种遍历方式
51.3.1利用keySet()方法遍历
package com.itheima_01;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
- Map的第一种遍历方式：
-
首先召集所有的丈夫 -
遍历所有的丈夫 -
获取每一个丈夫 -
让每一个丈夫去找他自己的媳妇
*/
public class MapDemo4 {
public static void main(String[] args) {
//创建Map对象
Map<String,String> map = new HashMap<String,String>();
//添加映射关系
map.put(“谢婷疯”, “张箔纸”);
map.put(“陈关西”, “钟欣桶”);
map.put(“李亚碰”, “王飞”);
//遍历Map对象
//首先召集所有的丈夫
Set<String> keys = map.keySet();
//遍历所有的丈夫
for (String key : keys) {
//让每个丈夫去找他自己的媳妇就可以了
String value = map.get(key);
System.out.println("丈夫：" + key + "---" + "媳妇：" + value);
}
}
}
51.3.2利用entrySet()方法遍历
package com.itheima_01;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
- Map的第二种遍历方式：
-
通过结婚证对象来获取丈夫和媳妇 - class 结婚证<K,V> {
-
K 丈夫; -
V 媳妇; -
public 结婚证(K 丈夫，V 媳妇) { -
this.丈夫 = 丈夫; -
this.媳妇 = 媳妇; -
} -
public K get丈夫() { -
return 丈夫; -
} -
public V get媳妇() { -
return 媳妇; -
} - }
- class Entry<K,V> {
-
K key; -
V value; -
public Entry(K key，V value) { -
this.key = key; -
this.value = value; -
} -
public K getKey() { -
return key; -
} -
public V getValue() { -
return value; -
} - }
- Set<Map.Entry<K,V>> entrySet()
*/
public class MapDemo5 {
public static void main(String[] args) {
//创建Map对象
Map<String,String> map = new HashMap<String,String>();
//添加映射关系
map.put(“尹志平”, “小龙女”);
map.put(“令狐冲”, “东方菇凉”);
map.put(“玄慈”, “叶二娘”);
//获取所有的结婚证对象
Set<Map.Entry<String,String>> entrys = map.entrySet();
//遍历包含了结婚证对象的集合
for (Map.Entry<String, String> entry : entrys) {
//获取每个单独的结婚证对象
//通过结婚证对象获取丈夫和媳妇
String key = entry.getKey();
String value = entry.getValue();
System.out.println(“丈夫：” + key + “—” + “媳妇:” + value);
}
}
}
51.3.3练习:
A:以key为学号字符串,value为学生姓名存入HashMap集合,分别以两种方式遍历集合
51.3.3.1案例代码一:
package com.itheima_02;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
*
- 使用HashMap存储数据并遍历（字符串作为key）
*/
public class HashMapDemo {
public static void main(String[] args) {
//创建Map对象
HashMap<String,String> hm = new HashMap<String,String>();
//添加映射关系
hm.put(“ITCAST001”, “张三”);
hm.put(“ITCAST002”, “李四”);
hm.put(“ITCAST003”, “王五”);
hm.put(“ITCAST003”, “赵六”);
//遍历Map对象
//方式1 获取所有的key，通过key来获取value
Set<String> keys = hm.keySet();
for (String key : keys) {
String value = hm.get(key);
System.out.println(key + "=" + value);
}
System.out.println("------------------");
//方式2：获取所有的结婚证对象，然后通过结婚证对象获取丈夫和媳妇
Set<Map.Entry<String, String>> entrys = hm.entrySet();
for (Map.Entry<String, String> entry : entrys) {
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "=" + value);
}
}
}
B: 定义一个学生类,学生类中有name和age两个属性,创建三个学生对象,分别对name和age赋值,然后以key为学生对象,value为学生的学号的方式存入HashMap集合,利用两种方式遍历这个Map
51.3.3.2案例代码二:
package com.itheima_02;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/*
*
- 使用HashMap存储数据并遍历（自定义对象作为key）
*/
public class HashMapDemo2 {
public static void main(String[] args) {
//创建Map对象
HashMap<Student,String> hm = new HashMap<Student,String>();
//创建key对象
Student s = new Student(“zhangsan”,18);
Student s2 = new Student(“lisi”,20);
Student s3 = new Student(“lisi”,20);
//添加映射关系
hm.put(s, "ITCAST001");
hm.put(s2, "ITCAST002");
hm.put(s3, "ITCAST002");
//遍历Map对象
//方式1： 获取所有的key，通过key来获取value
Set<Student> keys = hm.keySet();
for (Student key : keys) {
String value = hm.get(key);
System.out.println(key + "=" + value);
}
System.out.println("-----");
//方式2：获取所有结婚证对象，通过结婚证对象获取丈夫和媳妇
Set<Map.Entry<Student, String>> entrys = hm.entrySet();
for (Entry<Student, String> entry : entrys) {
Student key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "=" + value);
}
}
}
第08天 异常
今日内容介绍
异常体系&异常处理
Throwable常用方法&自定义异常
递归
第52章异常产生&异常处理
52.1异常概述
什么是异常？Java代码在运行时期发生的问题就是异常。
在Java中，把异常信息封装成了一个类。当出现了问题时，就会创建异常类对象并抛出异常相关的信息（如异常出现的位置、原因等）。
在Java中使用Exception类来描述异常。
查看API中Exception的描述，Exception 类及其子类是 Throwable 的一种形式，它用来表示java程序中可能会产生的异常，并要求对产生的异常进行合理的异常处理。
继续观察，我们可以发现Exception有继承关系，它的父类是Throwable。Throwable是Java 语言中所有错误或异常的超类，即祖宗类。
另外，在异常Exception类中，有一个子类要特殊说明一下，RuntimeException子类，RuntimeException及其它的子类只能在Java程序运行过程中出现。
我们再来观察Throwable类，能够发现与异常Exception平级的有一个Error，它是Throwable的子类，它用来表示java程序中可能会产生的严重错误。解决办法只有一个，修改代码避免Error错误的产生。
52.1.1案例代码一:
package com.itheima_01;
import java.io.FileWriter;
/*
-
Exception in thread “main” java.lang.ArithmeticException: / by zero
at com.itheima_01.ExceptionDemo.main(ExceptionDemo.java:5)
我们在写代码的时候，经常的出现一些小问题，那么为了方便我们处理这些问题，java为我们提供了异常机制异常包含了错误的类型、原因以及位置
异常：不正常，我们在代码的时候出现的编译或者运行时的错误
异常的体系结构：
Throwable（最顶层）
Error:出现的不能够处理的严重问题
Exception:可以处理的问题电脑坏了：
系统中毒：重装系统就可以了
主板坏了：买一台新的
*/
public class ExceptionDemo {
public static void main(String[] args) {
//int a = 10 / 0;
//System.out.println(a);
//FileWriter fw = new FileWriter("a.txt");
}
}
52.2异常处理
52.2.1JVM默认处理方式
如果出现异常我们没有处理，jvm会帮我们进行处理，他会把异常的类型，原因还有位置显示在命令行并且还终止了程序，异常后面的代码将不在执行
52.2.1.1案例代码二:
package com.itheima_01;
import java.io.FileWriter;
import java.io.IOException;
/*
-
异常的处理方式：
-
jvm处理异常的方式：
-
如果出现异常我们没有处理，jvm会帮我们进行处理，他会把异常的类型，原因还有位置显示在命令行 -
并且还终止了程序，异常后面的代码将不在执行
*/
public class ExceptionDemo2 {
public static void main(String[] args) throws Exception {
System.out.println(2/0);
System.out.println(“hello”);
}
}
52.2.2try…catch方式处理异常
捕获：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理捕获异常格式：
try {
//需要被检测的语句。
}
catch(异常类 变量) { //参数。
//异常的处理语句。
}
finally {
//一定会被执行的语句。
}
try：该代码块中编写可能产生异常的代码。
catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。
52.2.2.1案例代码三:
package com.itheima_01;
import java.io.FileWriter;
import java.io.IOException;
/*
-
异常的处理方式：
-
捕获处理 -
try...catch语句 -
try { -
有可能出现问题的代码; -
} catch(ArithmeticException ae) { -
处理异常; -
} -
try...catch的执行顺序： -
首先执行try语句 -
如果发现异常，异常下面的代码不在执行，直接跳入catch语句中，catch语句结束后，整个try...catch结束 -
如果没有发现异常，try语句执行结束后，try...catch直接结束， 不在执行catch语句 -
jvm处理异常的方式：
-
如果出现异常我们没有处理，jvm会帮我们进行处理，他会把异常的类型，原因还有位置显示在命令行 -
并且还终止了程序，异常后面的代码将不在执行
*/
public class ExceptionDemo2 {
public static void main(String[] args) throws Exception {
try {
System.out.println(1);
//System.out.println(2 / 0);
System.out.println(2);
} catch(ArithmeticException ae) {
System.out.println(“除数不能为0”);
}
System.out.println(3);
}
}
52.2.3throws方式处理异常
A:throws使用:
权限修饰符 返回值类型 方法名(形参列表) throws 异常类型1,异常类型2….{
}
52.2.3.1案例代码四:
package com.itheima_01;
import java.io.FileWriter;
import java.io.IOException;
/*
-
异常的处理方式：
-
捕获处理 -
try...catch语句 -
try { -
有可能出现问题的代码; -
} catch(ArithmeticException ae) { -
处理异常; -
} -
try...catch的执行顺序： -
首先执行try语句 -
如果发现异常，异常下面的代码不在执行，直接跳入catch语句中，catch语句结束后，整个try...catch结束 -
如果没有发现异常，try语句执行结束后，try...catch直接结束， 不在执行catch语句 -
抛出去 -
当我们不想处理异常，或者没有能力处理的时候，我们可以选择抛出异常，谁调用方法谁处理异常 -
使用关键字throws在方法的声明出抛出异常 -
jvm处理异常的方式：
-
如果出现异常我们没有处理，jvm会帮我们进行处理，他会把异常的类型，原因还有位置显示在命令行 -
并且还终止了程序，异常后面的代码将不在执行
*/
public class ExceptionDemo2 {
public static void main(String[] args) throws Exception {
//method();
function();
}
public static void function() throws Exception {
FileWriter fw = new FileWriter("a.txt");
}
private static void method() {
try {
System.out.println(1);
//System.out.println(2 / 0);
System.out.println(2);
} catch(ArithmeticException ae) {
System.out.println("除数不能为0");
}
System.out.println(3);
}
}
52.2.4多异常处理
A:对代码进行异常检测，并对检测的异常传递给catch处理。对每种异常信息进行不同的捕获处理。
void show(){ //不用throws
try{
throw new Exception();//产生异常，直接捕获处理
}catch(XxxException e){
//处理方式
}catch(YyyException e){
//处理方式
}catch(ZzzException e){
//处理方式
}
}
注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。
52.2.4.1案例代码五:
package com.itheima_01;
/*
- 如何处理多个异常：
-
可以使用多个try...catch语句 -
使用一个try和多个catch - 多个catch之间的顺序：
-
多个catch之间可以有子父类 -
平级之间没有顺序关系 -
如果有子父类，父类异常必须放在后面
*/
public class ExceptionDemo3 {
public static void main(String[] args) {
try {
String s = null;
System.out.println(s.length());
//int[] arr = new int[5];
//System.out.println(arr[8]);
//System.out.println(2 / 0);
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println("出现数组越界了");
}
catch(NullPointerException e) {
System.out.println("出现空指针了");
}
catch(Exception e) {
System.out.println("出现异常了");
}
/*try {
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("出现数组越界了");
}*/
}
private static void method() {
try {
String s = null;
System.out.println(s.length());
} catch(NullPointerException e) {
System.out.println("出现空指针了");
}
try {
int[] arr = new int[5];
System.out.println(arr[8]);
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("出现数组越界了");
}
}
}
第53章Throwable常用方法&自定义异常
53.1Throwable常用方法
String getMessage() 返回此 throwable 的详细消息字符串
String toString() 返回此 throwable 的简短描述
void printStackTrace() 打印异常的堆栈的跟踪信息
53.1.1案例代码六:
package com.itheima_01;
/*
- Throwable的常用方法：
String getMessage()
String toString()
void printStackTrace()
*/
public class ExceptionDemo4 {
public static void main(String[] args) {
try {
System.out.println(2 / 0);
} catch (ArithmeticException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private static void method() {
try {
System.out.println(2 / 0);
} catch(ArithmeticException e) {
//String getMessage() : 原因
//System.out.println(e.getMessage());
//String toString() 类型和原因
//System.out.println(e.toString());
//void printStackTrace():类型原因和位置
e.printStackTrace();
}
//System.out.println("hello");
}
}
53.2finally的概述和应用场景
finally使用格式:
try{
}catch(异常类型 异常变量){
}finally{
//释放资源的代码
}
53.2.1案例代码七:
package com.itheima_01;
import java.io.FileWriter;
import java.io.IOException;
/*
- finally:组合try…catch使用，用于释放资源等收尾工作，无论try…catch语句如何执行，finally的代码一定会执行
- try {
-
有可能出现问题的代码; - } catch(异常对象) {
-
处理异常; - } finally {
-
释放资源; -
清理垃圾; - }
*/
public class ExceptionDemo5 {
public static void main(String[] args) {
//method();
FileWriter fw = null;
try {
System.out.println(2 / 0);
fw = new FileWriter("a.txt");
fw.write("hello");
fw.write("world");
//System.out.println(2 / 0);
fw.write("java");
//fw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
//释放资源
try {
if(fw != null) {
fw.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
private static void method() {
try {
System.out.println(2 / 1);
} catch(ArithmeticException e) {
System.out.println("除数不能为0");
} finally {
System.out.println("清理垃圾");
}
}
}
53.3编译时异常&运行时异常
A: 编译时期异常:是Exception的子类，非RuntimeExcpetion的子类，在编译时期必须处理
B:RuntimeException和他的所有子类异常,都属于运行时期异常。NullPointerException,ArrayIndexOutOfBoundsException等都属于运行时期异常.
运行时期异常的特点:
方法中抛出运行时期异常,方法定义中无需throws声明,调用者也无需处理此异常
运行时期异常一旦发生,需要程序人员修改源代码.
53.3.1案例代码八:
package com.itheima_01;
import java.io.FileWriter;
import java.io.IOException;
/*
- 异常的分类：
运行时期异常:RuntimeException的子类就是运行时期异常，在编译时期可以自由选择处理或者不处理
编译时期异常:是Exception的子类，非RuntimeExcpetion的子类，在编译时期必须处理
*/
public class ExceptionDemo6 {
public static void main(String[] args) {
//System.out.println(2 / 0);
//String s = null;
//System.out.println(s.length());
try {
FileWriter fw = new FileWriter("a.txt");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
53.4自定义异常
需求：写一个方法，接受考试成绩，如果考试成绩的范围在0-100之间则属于正常，否则属于异常
53.4.1案例代码九:
当成绩不在0~100范围内,抛出一个运行时异常或者编译时异常,阻止程序继续向下执行
package com.itheima_01;
/*
-
需求：写一个方法，接受考试成绩，如果考试成绩的范围在0-100之间则属于正常，否则属于异常
-
throws:处理异常的一种方式，把异常抛出，由调用者来处理
-
throw:制造异常的方式,并且结束方法
-
注意：如果抛出（throw）的是编译时期异常，必须在方法声明处抛出（throws）
-
如何自定义一个异常类呢？
-
非常简单，写一个类去继承Exception或者RuntimeException，然后实现多个构造即可 -
*/
public class ExceptionDemo7 {
public static void main(String[] args) {
/boolean flag = checkScore(-10);
System.out.println(flag);/try { checkScore(110); } catch (Exception e) { //System.out.println(e.getMessage()); e.printStackTrace(); } //checkScore(110);}
/* public static boolean checkScore(int score) {
//判断考试成绩是否符合范围，如果不符合则返回false
if(score < 0 || score > 100) {
return false;
}
//符合
re
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
