java基础(必会有这一篇就够了有练习)-讲解到ArrayList的内容
总复习
一.day01内容
注：如有侵权，请联系删除
1.JVM,JRE,JDK的关系
JVM: java虚拟机,用来运行java程序的,JVM本身是不夸平台的,每个操作系统都需要安装针对本操作系统的JVM
所以: java通过jvm的不夸平台实现了java的跨平台
JRE:java运行环境,包含jvm和核心类库
JDK:java开发工具包,包含开发工具和JRE
三者关系： JDK > JRE > JVM
2.常用DOS命令
| 操作 | 说明 |
|---|---|
| 盘符名称: | 盘符切换。E:回车，表示切换到E盘。 |
| dir | 查看当前路径下的内容。 |
| cd 目录 | 进入单级目录。cd itheima |
| cd 目录1\目录2… | 进入多级目录。cd itheima\JavaSE |
| cd … | 回退到上一级目录。 |
| cd \ | 回退到盘符目录。 |
| cls | 清屏。 |
| exit | 退出命令提示符窗口。 |
3.JAVA_HOME环境变量的配置
目的: 在所有目录下都可以运行java命令
题目一
系统已安装JDK，位置如下
D:\DevelopTools\Java\jdk-9.0.1
请问，环境变量JAVA_HOME的值正确配置为：
A：D:\DevelopTools\Java\jdk-9.0.1\bin
B：D:\DevelopTools\Java\jdk-9.0.1
C：D:\DevelopTools\Java
D：%JAVA_HOME%\bin
题目二
系统已正确配置环境变量JAVA_HOME，请问，将 JAVA_HOME 配置到环境变量path中的正确做法为：
A：$JAVA_HOME$; 其他配置项...
B：%JAVA_HOME%; 其他配置项...
C：%JAVA_HOME%\bin; 其他配置项...
D：$JAVA_HOME$\bin; 其他配置项...
4.程序开发步骤
Java程序开发三步骤：**编写**、**编译**、**运行**。
(1)程序员编写的java程序的文件,称为源文件,扩展名是.java
(2)必须使用javac命令编译,生产字节码文件,扩展名是.class
javac HelloWorld.java 注意编译javac命令后面带扩展名
(3)必须使用java命令运行
java HelloWorld 注意运行java命令后面不带扩展名
注意: 源文件的名称必须和类名保持一致
5.注释
概念: 解释程序中的内容,不参与编译,不影响程序的运行效率,是给程序员看的
分类:
单行注释: //
多行注释: /* ...*/
文档注释: /** ... */
6.常量
概念: 是指在Java程序中固定不变的数据。
注意:
(1)字符常量: 必须使用单引号''引起来,内部只能写一个字符,不能写多个,也不能不写
(2)字符串常量: 必须使用双引号""引起来,内部可以写多个字符(0个,1个...)
(3)布尔常量: 只能有两个true,或者false,注意不用加""
(4)整数默认为int类型,小数默认为double类型,要表示long类型后面加L,要表示float类型后面加F
7.关键字
概念: 是指在程序中，Java已经定义好的单词，具有特殊含义。
能认出java中的关键字---容易出现单选题或者多选题目
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ryb7PNvo-1582722650202)(C:\Users\hjx\Desktop\img\01_关键字.png)]
二.day02内容
1.变量
(1)概念: 常量是固定不变的数据，那么在程序中可以变化的量称为变量。
(2)数据类型:
(1)整数类型
byte类型 1个字节 -128到127
short类型 2个字节 正负3万多
int类型 4个字节 正负21亿 整数默认就是int类型
long类型 8个字节 大概19位数字
表示long类型的数据,后面建议添加L
(2)小数类型
float类型 4个字节 采用科学计数法,虽然占4个字节,但是取值范围远远超过long类型
表示float类型的数据,后面建议添加F
double类型 8个字节 小数默认就是double类型
(3)其它
char类型 2个字节
boolean类型 1个字节
目的: 每种类型的字节数不同,它的取值范围就不同,需要根据需求做出选择
(3)定义格式
格式一: 先挖坑,再种萝卜
数据类型 变量名称;(先挖坑)
变量名称 = 数据值;(再种萝卜)
格式二:挖坑的同时种萝卜
数据类型 变量名称 = 数据值;
=: 代表赋值的,把数据放到坑中
(4)变量定义的注意事项
变量名称：在同一个大括号范围内，变量的名字不可以相同。
变量赋值：定义的变量，不赋值不能使用。
定义long类 型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型，整数太大可能超出int范围。
定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型是double， double的取值范围是大于float的，类型不兼容。
2.类型转换
2.标识符
**命名规则：硬性要求`**
标识符可以包含`英文字母26个(区分大小写)`、`0-9数字` 、`$（美元符号）`和`_（下划线）`。
标识符不能以数字开头。
标识符不能是关键字。
**命名规范：`软性建议`**
类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）。
方法名规范： 首字母小写，后面每个单词首字母大写（小驼峰式）。
变量名规范：首字母小写，后面每个单词首字母大写（小驼峰式）。
3.数据类型转换
自动类型转换: 取值范围小的数据或者变量 可以 直接赋值给取值范围大的变量 (小萝卜可以直接放在大坑中)
特点:
(1)是自动完成的,不需要代码的干预
(2)byte/short/char 类型 只要参加运算,会自动转换为int类型
(3)转换规则
byte、short、char-->int-->long-->float-->double
注意:
自动类型转换,就是在数据前面按照要求补充若干字节的0
public static void main(String[] args) {
int i = 1;
byte b = 2;
// byte x = b + i; // 报错
//int类型和byte类型运算，结果是int类型
int j = b + i;
System.out.println(j);
}
强制类型转换: 取值范围大的数据或者变量,不能直接赋值给取值范围小的变量(大萝卜不能直接放入小坑中)
必须进行强制类型转换
强制类型转换格式:
转后类型 变量名称 = (转后类型)转前的数据或者变量;
注意:
强制类型转换,根据要求砍掉数据前面的若干字节,如果被砍掉的字节都是0,对数据没有影响
只要被砍掉的数据中包含1,对数据没有影响
public static void main(String[] args) {
//short类型变量，内存中2个字节
short s = 1;
/*
出现编译失败
s和1做运算的时候，1是int类型，s会被提升为int类型
s+1后的结果是int类型，将结果在赋值会short类型时发生错误
short内存2个字节，int类型4个字节
必须将int强制转成short才能完成赋值
*/
s = s + 1；//编译失败
s = (short)(s+1);//编译成功
}
4.ASCII码表
char和int是相互可以转换的
public class Demo06Convert {
public static void main(String[] args) {
char ch = 'a';
System.out.println(ch);//'a'
//char + int --> int + int --> int 如何把char类型转换为int类型呢? 查看ASCII码表
System.out.println(ch+1);//98
//如何把int类型转换为char类型呢? 查看ASCII码表
System.out.println((char)(ch+1));//'b'
System.out.println("=========================");
char ch2 = 'A';
System.out.println(ch2);//'A'
System.out.println(ch2+1);//66
System.out.println((char)(ch2+1));
//如何把char转成int呢? 查看ASCII码表
int num = ch2;
System.out.println(num);//65
}
}
5.算数运算符+,-,*,/
public class Demo07Operator {
public static void main(String[] args) {
//定义2个int变量
int a = 20;
int b = 10;
System.out.println(a + b);//20 + 10: 30
System.out.println(a - b);//20 - 10: 10
System.out.println(a * b);//20 * 10: 200
System.out.println(a / b);//20 /10: 2
System.out.println(a*1.0 / b);//2.0
}
}
6.取模运算%
/*
%:
取模运算(取余数)，两个数字相除取余数
数学中:
被除数/除数 = 商(/: 求的就是商) ..... 余数(%: 求的就是余数)
%的作用:
1.判断数字的奇偶性:
偶数: 数字%2 结果 0
奇数: 数字%2 结果 1
2.判断一个数字能否被另外一个数字整除
3.使用/和% 可以 求出某个数字的每一位上的数字
比如:
1234
个位: 4
十位: 3
百位: 2
千位: 1
*/
public class Demo08Operator {
public static void main(String[] args) {
System.out.println(6%2);//0 说明6是偶数
System.out.println(11%2);//1 说明1是奇数
System.out.println(100%25);//0 说明100可以被25整除
System.out.println(101%25);//1 说明101不可以被25整除
System.out.println("---------------------");//1 说明101不可以被25整除
//定义int变量
int num = 1234;
//个位
int ge = num%10;
//十位
//System.out.println(123%10);//如何获取123?
//System.out.println(1234/10);//123
int shi = num/10%10;
//百位
//System.out.println(1234/100);//12
//System.out.println(1234/100%10);
int bai = num/100%10;
//千位
int qian = num/1000%10;
System.out.println(ge);
System.out.println(shi);
System.out.println(bai);
System.out.println(qian);
}
}
7.+的特殊用法,字符串拼接
/*
+:
1.在数学运算中,代表的是加法运算
2.+符号在字符串中的作用在遇到字符串的时候，表示连接、拼接的含义。
*/
public class Demo09Operator {
public static void main(String[] args) {
System.out.println("HelloWorld");
System.out.println("Hello"+"World");//+: 字符串的连接
//从左向右运算
//第一步:"5+5="+5: "5+5=5"
//第二步:"5+5=5"+5 "5+5=55"
System.out.println("5+5="+5+5);//5+5=55
//先计算()中的式子的结果: 5+5 结果10
//"5+5="+10: 结果5+5=10
System.out.println("5+5="+(5+5));//5+5=10
int a = 18,b = 19;
//要求输出:18+19=37
System.out.println(a+"+"+b+"="+(a+b));
}
}
8.自增自减运算符
/*
自增(++)自减(--)运算符
1.作用:
让变量的值增加(++)或者减少(--)1
2.使用格式:
(1)可以写在变量的前面: ++a,--a
(2)可以写在变量的后面: a++,a-- 最常用的
3.使用特点:
(1)单独使用: 没有其它的运算参与
前++/-- 或者 后++/--: 作用相同,都是让变量的值增加1或者减少1
(2)混合使用: 和其它运算符(赋值/打印)一起进行运算
有重大区别
前++/--: 先给变量++/--,然后再使用变量
后++/--: 先使用变量,后给变量++/--
最常用的:
a++: a的值增加1
a--: a的值减少1
*/
public class Demo12Operator {
public static void main(String[] args) {
int a = 2;
//单独使用
a++;//a = a + 1
System.out.println(a);//3
int b = 2;
++b;//b = b + 1
System.out.println(b);
System.out.println("--------------------------");
int c = 5;
//因为++在c的后面,所以先使用c的值(5)赋值给变量d,这样d的值就是5,然后c的值再+1,c变成6
int d = c++;
System.out.println(c);//6
System.out.println(d);//5
System.out.println("--------------------------");
int e = 10;
//因为++在e的前面,所以先给e的值+1,e变成11,然后把11赋值给f,这样f的值11
int f = ++e;
System.out.println(e);//11
System.out.println(f);//11
int g = 6;
/*
从左向右计算
先计算++g: 因为++在前面,所以先给g的值+1,g变成7,在使用g的值和后面的表达式进行运算
7 + (g++):
(g++): 因为++在后面,先使用g的值(7)和前面的数字7进行运算 7+7 = 14,把14赋值给变量h ,最后g的值再+1,g变成8
*/
int h = (++g) + (g++);
System.out.println(h);//14
System.out.println(g);//8
}
}
9.赋值运算符
/*
扩展赋值运算符的特点
+=,-=,/=,*=,%=:
如果左右两侧的数据类型不一致,隐藏进行强制类型转换
byte/short/char 只要参加运算,会自动转换为int类型
*/
public class Demo11Operator {
public static void main(String[] args) {
short s = 2;
//short + int --> int + int --> int 结果int类型(4个字节) 不能直接赋值给左侧 short类型(2个字节)的变量
//s = s + 1;
//需要强制类型转换
//s = (short)(s + 1);
s += 1;//s = (short)(s + 1);
System.out.println(s);
}
}
三.day03内容
1.关系运算符
| 符号 | 说明 |
|---|---|
| == | a==b，判断a和b的值是否相等，成立为true，不成立为false |
| != | a!=b，判断a和b的值是否不相等，成立为true，不成立为false |
| > | a>b，判断a是否大于b，成立为true，不成立为false |
| >= | a>=b，判断a是否大于等于b，成立为true，不成立为false |
| < | a |
| <= | a<=b，判断a是否小于等于b，成立为true，不成立为false |
public class Demo01GuanXi {
public static void main(String[] args){
//定义2个int类型的变量
int a = 10;
int b = 20;
//定义boolean类型的变量,接收关系运算符的结果
boolean result = (a > b);
System.out.println(result);//false
System.out.println(a == b);//10 == 20 false
System.out.println(a != b);//10 != 20 true
System.out.println(a > b);//10 > 20 false
System.out.println(a >= b);//10 >= 20 false
System.out.println(a < b);//10 < 20 true
System.out.println(a <= b);//10 <= 20 true
System.out.println("-----------------------");
System.out.println(a = b);//=是赋值的操作,先把b的值赋值给a,然后再打印a的值: 20
}
}
2.逻辑运算符
注意: 逻辑表达式的最终结果为boolean类型true或者false,而且连接的表达式也必须是布尔类型的
| 符号 | 作用 | 说明 |
|---|---|---|
| & | 逻辑与 | a&b，a和b都是true，结果为true，否则为false |
| | | 逻辑或 | a|b，a和b都是false，结果为false，否则为true |
| ^ | 逻辑异或 | a^b，a和b结果不同为true，相同为false |
| ! | 逻辑非 | !a，结果和a的结果正好相反 |
/*
逻辑运算符:
用来连接布尔表达式的,最终的结果也是一个boolean类型,要么是true,要么是false
必须北京有房,而且还得有车
&【有false，则false】: 逻辑与 并且 多个条件都为true,结果才为true
北京有房也行,有车也行
|【有true，则true】: 逻辑或 或者 多个条件中只要有一个为true,结果就为true
^: 逻辑异或 相同为false,不同为true
!: 取反 !true: false !false: true
*/
public class Demo02LuoJi {
public static void main(String[] args){
//定义3个int类型变量
int a = 10,b = 20,c = 30;
System.out.println((a>b) & (a>c));//10 > 20 & 10 > 30 ==> false & false ==> false
System.out.println((a<b) & (a<c));//10 < 20 & 10 < 30 ==> true & true ==> true
System.out.println((a>b) & (a<c));//10 > 20 & 10 < 30 ==> false & true ==> false
System.out.println((a<b) & (a>c));//10 < 20 & 10 > 30 ==> true & false ==> false
System.out.println("--------------------");
System.out.println((a>b) | (a>c));//10 > 20 | 10 > 30 ==> false | false ==> false
System.out.println((a<b) | (a<c));//10 < 20 | 10 < 30 ==> true | true ==> true
System.out.println((a>b) | (a<c));//10 > 20 | 10 < 30 ==> false | true ==> true
System.out.println((a<b) | (a>c));//10 < 20 | 10 > 30 ==> true | false ==> true
System.out.println("--------------------");
System.out.println((a>b) ^ (a>c));//10 > 20 ^ 10 > 30 ==> false ^ false ==> false
System.out.println((a<b) ^ (a<c));//10 < 20 ^ 10 < 30 ==> true ^ true ==> false
System.out.println((a>b) ^ (a<c));//10 > 20 ^ 10 < 30 ==> false ^ true ==> true
System.out.println((a<b) ^ (a>c));//10 < 20 ^ 10 > 30 ==> true ^ false ==> true
System.out.println("--------------------");
boolean flag = true;
System.out.println(flag);//true
System.out.println(!flag);//false
System.out.println(!!flag);//true
}
}
| 符号 | 作用 | 说明 |
|---|---|---|
| && | 短路与 | 作用和&相同，但是有短路效果 |
| || | 短路或 | 作用和|相同，但是有短路效果 |
/*
短路逻辑运算符 以后都使用&& 和 ||
&&: 逻辑与
运算结果和 & 是一样的 但是 && 有短路的效果
特点: 左侧为false,右侧不再计算
||: 逻辑或
运算结果和 | 是一样的 但是 || 有短路的效果
特点: 左侧为true,右侧不再计算
*/
public class Demo03DuanLu {
public static void main(String[] args){
int a = 5;
int b = 6;
/*
从左向右计算
先计算: a > 6 ==> 5 > 6 --> false 左侧是false,已经决定了&&的最终结果是false
不管&&右侧的结果是true或者false,都无法影响整个表达式的最终结果
所以不需要计算右边的表达式 b++ > 5
*/
System.out.println((a > 6) && (b++ > 5));//false
System.out.println(a);//5
System.out.println(b);//6
int x = 5;
int y = 6;
/*
从左向右计算
先计算: x < 6 ==> 5 < 6 --> true 左侧是true,已经决定了||的最终结果是true
不管||右侧的结果是true或者false,都无法影响整个表达式的最终结果
所以不需要计算右边的表达式 y++ > 5
*/
System.out.println((x < 6) || (y++ > 5));//true
System.out.println(x);//5
System.out.println(y);//6
}
}
3.三元运算符
格式: 布尔表达式 ? 表达式1 : 表达式2;
执行流程:
(1)计算布尔表达式的结果看是true,还是false
(2)如果布尔表达式的结果为true,计算表达式1的结果作为三元运算符的结果
(3)如果布尔表达式的结果为false,计算表达式2的结果作为三元运算符的结果
注意: 三元运算符的结果必须被使用
/*
三元运算符
1.格式:
数据类型 变量名称 = 关系表达式1 ? 表达式2 : 表达式3;
2.执行流程:
(1)计算关系表达式1的结果,看是true还是false
(2)如果关系表达式1的结果为true,把表达式2的结果赋值给左侧的变量
(3)如果关系表达式1的结果为false,把表达式3的结果赋值给左侧的变量
3.注意:
第一个表达式: 关系表达式1,不管写的多么复杂或者多么简单,要求结果必须是true或者false
4.练习:
求两个int数据的最大值
实现步骤:
1.定义2个int变量,并进行初始化
2.使用三元运算符求出最大值,保存int变量max
3.输出结果
*/
public class Demo04SanYuan {
public static void main(String[] args){
//1.定义2个int变量,并进行初始化
int a = 30;
int b = 20;
//2.使用三元运算符求出最大值,保存int变量max
int max = a > b ? a : b;
//3.输出结果
System.out.println("最大值: "+max);
}
}
/*
需求：
一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，
请用程序实现获取这三个和尚的最高身高。
分析:
1.定义3个int变量h1,h2,h3,分别代表三个和尚的身高
2.使用三元运算符先求出h1和h2的最大值,保存int变量temp中
3.再使用三元运算符先求出temp和h3的最大值,保存int变量max中
4.最后max中的值就是3个int数据的最大值,直接打印输出
*/
public class Demo07SanYuan {
public static void main(String[] args){
//1.定义3个int变量h1,h2,h3,分别代表三个和尚的身高
int h1 = 150, h2 = 210, h3 = 165;
//2.使用三元运算符先求出h1和h2的最大值,保存int变量temp中
int temp = h1 > h2 ? h1 : h2;
//3.再使用三元运算符先求出temp和h3的最大值,保存int变量max中
int max = temp > h3 ? temp : h3;
//4.最后max中的值就是3个int数据的最大值,直接打印输出
System.out.println("最大值: "+max);
}
}
4.键盘录入Scanner
import java.util.Scanner;//只要在我们的代码中加上这句话,就可以使用Scanner类
/*
数据输入: 获取到键盘录入的数据,到程序当中
java中的键盘录入功能,被放在了java.util包中的Scanner
数据类型:
基本类型: 四类八种
引用类型: 除了基本类型,剩余的都是引用类型
Scanner也是一个引用类型
引用类型: 有自己的固有的使用的格式
Scanner使用的步骤: 目前是固定的步骤,先记住
1.导包: 告诉JVM我们要使用的东西在哪里
import 路径.类名;
import java.util.Scanner;
2.创建对象
Scanner sc = new Scanner(System.in);
3.使用
sc.nextInt()方法: 获取键盘录入的int数字
*/
public class Demo08Scanner {
public static void main(String[] args){
//2.创建对象
Scanner sc = new Scanner(System.in);
System.out.println("哥们,请您输入一个整数: ");
//3.使用: 获取用户从键盘录入的数据
int num = sc.nextInt();//10000
System.out.println("哥们您输入的数据是: "+num);
}
}
/*
需求：
一座寺庙里住着三个和尚，他们的身高要求从键盘录入，
请用程序实现获取这三个和尚的最高身高。
分析:
1.导包: import java.util.Scanner;
2.创建对象: Scanner sc = new Scanner(System.in);
3.获取键盘录入的三个int数据,并分别保存int变量h1,h2,h3中
4.使用三元运算符先求出h1和h2的最大值,保存int变量temp中
5.再使用三元运算符先求出temp和h3的最大值,保存int变量max中
6.最后max中的值就是3个int数据的最大值,直接打印输出
*/
public class Demo08SanYuan {
public static void main(String[] args){
//1.导包: import java.util.Scanner;
//2.创建对象: Scanner sc = new Scanner(System.in);
Scanner sc = new Scanner(System.in);
//3.获取键盘录入的三个int数据,并分别保存int变量h1,h2,h3中
System.out.println("请输入第一个和尚的身高: ");
int h1 = sc.nextInt();//180
System.out.println("请输入第二个和尚的身高: ");
int h2 = sc.nextInt();//210
System.out.println("请输入第三个和尚的身高: ");
int h3 = sc.nextInt();//165
//4.使用三元运算符先求出h1和h2的最大值,保存int变量temp中
int temp = h1 > h2 ? h1 : h2;//210
//5.再使用三元运算符先求出temp和h3的最大值,保存int变量max中
int max = temp > h3 ? temp : h3;//210
//6.最后max中的值就是3个int数据的最大值,直接打印输出
System.out.println("三个和尚的最大身高: "+max);
}
}
四.day04内容
1.if语句的第一种格式
package com.itheima01_fuxi;
/*
if语句的第一种格式 if: 如果
1.格式:
if(关系表达式){
语句体;
}
其它语句;
2.执行流程
(1)首先计算关系表达式的结果,看是true,还是false
(2)如果关系表达式的结果是true,执行语句体,接着继续执行其它语句
(3)如果关系表达式的结果是false,不执行语句体,直接执行其它语句
3.练习:
(1)需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
(2)需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
4.注意:
(1)if语句的第一种格式: 只适用于有一个条件的情况 理解为: 有 和 无的情况
(2)语句体要么执行,要么不执行,由()中的关系表达式的结果决定
(2){}中如果只有一条语句,那么{}可以省略 建议初学者: 保留{}
*/
public class Demo02If {
public static void main(String[] args) {
System.out.println("main...start....");
//定义2个int变量
int a = 10, b = 20;
//判断a和b的值是否相等
if(a == b){
//如果相等，就在控制台输出：a等于b
System.out.println(a+"等于"+b);
}
//定义1个int变量
int c = 10;
//判断a和c的值是否相等
if(a == c){
//如果相等，就在控制台输出：a等于c
System.out.println(a+"等于"+c);
}
System.out.println("main...end....");
}
}
2.if语句的第二种格式
/*
if语句的第二种格式:
1.格式: if: 如果 else: 否则
if(关系表达式) {
语句体1;
} else {
语句体2;
}
其它语句;
2.执行流程:
(1)首先计算关系表达式的结果,看是true,还是false
(2)如果关系表达式的结果是true,执行语句体1,继续执行其它语句
(3)如果关系表达式的结果是false,执行语句体2,继续执行其它语句
3.练习(键盘录入):
需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，否则，在控制台输出：a的值不大于b
分析:
(1)导包: import java.util.Scanner;
(2)创建: Scanner sc = new Scanner(System.in);
(3)使用: sc.nextInt()获取键盘录入的整数
(4)使用if-else 对键盘录入的两个int数字进行判断,并输出对应的结果
4.注意:
(1)if-else语句: 适用于有两个条件的情况
(2)语句体1和语句体2,只(必须)有一个会被执行
*/
public class Demo03IfElse {
public static void main(String[] args) {
System.out.println("main...start...");
//(2)创建:
Scanner sc = new Scanner(System.in);
//(3)获取键盘录入的两个整数
System.out.println("请输入第一个整数: ");
int a = sc.nextInt();//5
System.out.println("请输入第二个整数: ");
int b = sc.nextInt();//5
//(4)使用if-else 对键盘录入的两个int数字进行判断,并输出对应的结果
if(a == b) {
//true
System.out.println(a+"等于"+b);
} else {
System.out.println(a+"不等于"+b);
}
System.out.println("main...end...");
}
}
3.if语句的第三种格式
/*
if语句的第三种格式:
1.格式:
if(关系表达式1) {
语句体1;
} else if(关系表达式2) {
语句体2;
}
...
else if(关系表达式n) {
语句体n;
} else {
语句体n+1;
}
其它语句;
2.执行流程:
(1)首先计算关系表达式1的值
(2)如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
(3)如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
(4)…
(5)如果没有任何关系表达式为true，就执行语句体n+1。
3.注意:
(1)适用于有多种(2种以上)条件的情况
(2)语句体1到语句体n+1,只有一条语句会被执行
(3)最后一个else作用: 做收尾工作,如果所有的条件都不成立(false),执行最后一个else中的语句体
(4)最后一个else,是没有写if的
4.if语句第三种格式练习
需求:
键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日
输出格式:
输入 1 输出 星期一
输入 2 输出 星期二
输入 3 输出 星期三
输入 4 输出 星期四
输入 5 输出 星期五
输入 6 输出 星期六
输入 7 输出 星期日
输入 其它数字 输出 数字有误
实现步骤:
1.创建键盘录入Scanner对象(1.导包 2.创建)
2.获取键盘录入的整数,保存int变量week中
3.因为week变量中的数据有7+1种情况,所以使用if语句的第三种格式对week的值进行判断
并分别输出不同的结果
*/
public class Demo06IfElseWeek {
public static void main(String[] args) {
System.out.println("main...start...");
//1.创建键盘录入Scanner对象(1.导包 2.创建)
Scanner sc = new Scanner(System.in);
//2.获取键盘录入的整数,保存int变量week中
System.out.println("请您输入一个1到7之间的整数: ");
int week = sc.nextInt();//8
// 3.因为week变量中的数据有7+1种情况,所以使用if语句的第三种格式对week的值进行判断
// 并分别输出不同的结果
if(week ==1) {
System.out.println("星期一");
} else if(week == 2) {
System.out.println("星期二");
} else if(week == 3) {
System.out.println("星期三");
} else if(week == 4) {
System.out.println("星期四");
} else if(week == 5) {
System.out.println("星期五");
} else if(week == 6) {
System.out.println("星期六");
} else if(week == 7) {
System.out.println("星期日");
} else {
//else: 上面的所有情况都不成立,就直接执行else当中的代码
System.out.println("您输入的数据有误,火星来的吧....");
}
System.out.println("main...end...");
}
}
/*
if语句第三种格式练习题目:
需求:
小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可以控制小明的得分，
请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
奖励规则:
95~100 山地自行车一辆 包含95 和 100
90~94 游乐场玩一次 包含90 和 94
80~89 变形金刚玩具一个 包含80 和 89
80以下 胖揍一顿 不包含80
实现步骤:
1.创建键盘录入Scanner对象(1.导包 2.创建)
2.获取键盘录入的一个0到100之间的整数,保存到int变量score当中
3.因为变量score中的数据有4+1种情况,所以使用if语句的第三种格式进行判断,并输出对应的结果
*/
public class Demo07IfElseScore {
public static void main(String[] args) {
System.out.println("main...start...");
//1.创建键盘录入Scanner对象(1.导包 2.创建)
Scanner sc = new Scanner(System.in);
//2.获取键盘录入的一个0到100之间的整数,保存到int变量score当中
System.out.println("请输入一个0到100之间的整数代表考试成绩: ");
int score = sc.nextInt();//50
//3.因为变量score中的数据有4+1种情况,所以使用if语句的第三种格式进行判断,并输出对应的结果
if(score>=95 && score<=100){
//95~100 山地自行车一辆
System.out.println("山地自行车一辆");
} else if(score>=90 && score<=94){
//90~94 游乐场玩一次
System.out.println("游乐场玩一次");
} else if(score>=80 && score<=89) {
//80~89 变形金刚玩具一个
System.out.println("变形金刚玩具一个");
} else if(score<0 || score>100){
//<0 或者 >100的成绩都是非法的成绩
System.out.println("您输入的成绩是非法的.....");
} else {
//只要进入这个else必然说明创建 score<80 并且 score>=0
//80以下 胖揍一顿
System.out.println("胖揍一顿");
}
System.out.println("main...end...");
}
}
4.switch语句
注意:
(1)break: 用来结束switch语句的
(2)default: 如果所有的case后的常量值和switch()中的表达式的值都不匹配,直接执行default中的语句体
(3)switch后的()中的表达式的结果只能是以下数据类型:
基本类型: byte/short/char/int
引用类型: String类型/枚举类型
(4)case的顺序是可以颠倒的,前提,每个case后面都有break
(5)把switch后()中表达式的值: 理解为 被检测量
/*
switch语句
1.格式:
switch(表达式) {
case 常量值1:
语句体1;
break;
case 常量值2:
语句体2;
break;
...
case 常量值n;
语句体n+1;
break;
default:
语句体n+;
break;
}
其它语句;
2.执行流程:
(1)首先计算出表达式的值
(2)其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
(3)最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
3.练习:
根据不同的int数字,输出字符串
4.注意:
(1)break: 用来结束switch语句的
(2)default: 如果所有的case后的常量值和switch()中的表达式的值都不匹配,直接执行default中的语句体
(3)switch后的()中的表达式的结果只能是以下数据类型:
基本类型: byte/short/char/int
引用类型: String类型/枚举类型
(4)case的顺序是可以颠倒的,前提,每个case后面都有break
(5)把switch后()中表达式的值: 理解为 被检测量
*/
public class Demo01Switch {
public static void main(String[] args) {
System.out.println("main....start....");
int num = 1;
switch (num) {
case 1:
System.out.println("你好!!!!");
break;
case 2:
System.out.println("我好!!!!");
break;
case 3:
System.out.println("大家好才是真的好!!!!");
break;
default:
System.out.println("他好,我也好!!!!");
break;
}
System.out.println("main....end....");
}
}
case穿透
/*
switch语句练习-春夏秋冬(课后使用if语句第三种格式完成)
需求：
一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。
演示效果:
输入： 1、2、12 输出：冬季
输入： 3、4、5 输出：春季
输入： 6、7、8 输出：夏季
输入： 9、10、11 输出：秋季
输入：其它数字 输出：数字有误
实现步骤:
1.创建键盘录入Scanner对象(1.导包 2.创建)
2.获取键盘录入的整数(代表月份),保存到int变量month中
3.使用switch语句判断month中值,并输出对应的结果
发现问题:
多个case后面的代码重复,可以进行优化
解决方案:
利用case穿透的原理?
在switch语句中，如果case的后面不写break，将出现穿透现象，
也就是不会在判断下一个case的值，直接向后运行，直到
遇到break，或者整体switch结束。
1.找到case的入口处
2.后面就不再和case后面的值做匹配的操作
*/
public class Demo03SwitchMonth {
public static void main(String[] args) {
System.out.println("main....start....");
//1.创建键盘录入Scanner对象(1.导包 2.创建)
Scanner sc = new Scanner(System.in);
//2.获取键盘录入的整数(代表月份),保存到int变量month中
System.out.println("请输入一个整数(1到12之间)代表月份:");
int month = sc.nextInt();//3
//3.使用switch语句判断month中值,并输出对应的结果
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;
}
System.out.println("main....end....");
}
}
五.day05内容
1.循环的组成
/*
循环结构
1.概念: 重复的执行某段固定的代码
2.循环的组成:(手写100次HelloWorld)
(1)【初始化表达式1】准备工作:笔墨伺候,最优先唯一执行一次的操作
(2)【循环条件2】条件判断:每次书写前,判断一下,要不要写
(3)【循环体3】循环所要进行的操作:手写一个HelloWorld案例
(4)【步进表达式4】扫尾的工作:每写一次HelloWorld,计数(+1)
3.执行流程:
(1),(2),(3),(4) --> (2),(3),(4) --> ... --> 直到循环条件2的结果为false的时候,结束了循环了
4.循环分类:
(1)for循环: 最长用的
(2)while循环: 一般常用的
(3)do-while循环: 最不常用的
*/
public class Demo01Loop {
}
2.for循环语句
/*
for循环
1.格式:
for( 初始化表达式1; 布尔表达式2; 步进表达式4 ) {
循环体3;
}
其它语句;
2.执行流程:
1,2,3,4 --> 2,3,4 --> ... --> 直到布尔表达式2的结果为false,结束for循环,执行for循环后面的其它语句
3.注意:
(1)在一个for循环结构中: 初始化表达式1只会执行一次
(2)布尔表达式2: 结果必须为true或者false
(3)循环体3: 一条/多条语句
4.练习:
输出10次HelloWorld
*/
public class Demo02For {
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循环
/*
第一次:
i == 1 i<=3 1<=3 true 执行输出 执行i++ i变成2
第二次:
i<=3 ==> 2<=3 ==> true 执行输出 执行i++ i变成3
第三次:
i<=3 ==> 3<=3 ==> true 执行输出 执行i++ i变成4
第四次:
i<=3 ==> 4<=3 ==> false 结束for循环,执行for循环后面的语句 输出"main....end...."
*/
for(int i = 1; i<=3;i++){
System.out.println("HelloWorld...."+i);
}
System.out.println("main....end....");
}
}
练习: 求和
/*
练习:
求1-100之间的所有数字之和,偶数和与奇数和，并分别打印结果在控制台输出
实现步骤:
1.定义3个int类型求和变量sum(所有数字之和),sum1(奇数数字之和),sum2(偶数数字之和)初始值0
2.使用for循环获取1-100之间的数字
3.把当前数字累加到求和变量sum中,因为sum用来求所有数字之和的
4.判断如果当前数字是偶数,把当前数字累加到求和变量sum2中,因为sum2用来求所有数字偶数之和的
5.判断如果当前数字是奇数,把当前数字累加到求和变量sum1中,因为sum1用来求所有数字奇数之和的
6.打印输出
*/
public class Demo06ForSum {
public static void main(String[] args) {
//1.定义3个int类型求和变量sum(所有数字之和),sum1(奇数数字之和),sum2(偶数数字之和)初始值0
int sum = 0,sum1 = 0,sum2 = 0;
//2.使用for循环获取1-100之间的数字
for (int i = 1; i <= 100; i++) {
//3.把当前数字累加到求和变量sum中,因为sum用来求所有数字之和的
sum += i;
if (i % 2 == 0) {
//4.判断如果当前数字是偶数,把当前数字累加到求和变量sum2中,因为sum2用来求所有数字偶数之和的
sum2 += i;
} else {
//5.判断如果当前数字是奇数,把当前数字累加到求和变量sum1中,因为sum1用来求所有数字奇数之和的
sum1 += i;
}
}
//6.打印输出
System.out.println("1-100之间所有数字之和: "+sum);
System.out.println("1-100之间所有偶数数字之和: "+sum2);
System.out.println("1-100之间所有奇数数字之和: "+sum1);
}
}
练习: 水仙花数
/*
练习: 计数器的思想
统计“水仙花数”一共有多少个，并在控制台输出个数
要求:
定义一个方法,判断数字是否是水仙花数字
解释：什么是水仙花数？
水仙花数，指的是一个三位数(100到999)，个位、十位、百位的数字立方和等于原数
例如 153 3*3*3 + 5*5*5 + 1*1*1 = 27 + 125 + 1 = 153
实现步骤:
1.定义int变量count,作用是用来计数的,初始值0
2.使用for循环获取所有的三位数字
3.求出当前数字的个位,十位,百位 分别 保存到int变量 ge(个位),shi(十位),bai(百位)中
4.求出当前数字的个位,十位,百位的立方和,保存到int变量sum当中
5.判断如果前数字的个位,十位,百位的立方和sum等于该数字本身,说明是水仙花数字
5.1 计数器count加1
5.2 打印水仙花数字
6.for循环结束后,打印个数count中的内容
*/
public class Demo08ForWaterFlowers {
public static void main(String[] args) {
//1.定义int变量count,作用是用来计数的,初始值0
int count = 0;
//2.使用for循环获取所有的三位数字
for (int num = 100; num <= 999; num++) {
//3.求出当前数字的个位,十位,百位 分别 保存到int变量 ge(个位),shi(十位),bai(百位)中
int ge = num%10;
int shi = num/10%10;
int bai = num/100%10;
//4.求出当前数字的个位,十位,百位的立方和,保存到int变量sum当中
//5.判断如果前数字的个位,十位,百位的立方和sum等于该数字本身,说明是水仙花数字
if ((ge*ge*ge + shi*shi*shi + bai*bai*bai) == num) {
//5.1 计数器count加1
count++;
//5.2 打印水仙花数字
System.out.println(num);
}
}
//6.for循环结束后,打印个数count中的内容
System.out.println("以上水仙花数字总个数: "+count+" 个");
}
}
练习: 按照要求打印符合条件的数字
/*
练习:
全国计算机等级考试三级的练习题目:
1.打印所有四位数中 个位 + 千位 == 百位 + 十位 的数字
2.打印要求5个一行,中间用空格隔开
3.最后要打印符合条件的数字的总数量
实现步骤:
1.定义int变量count,初始值0
2.使用for循环获取所有的四位数字
3.获取当前四位数字的个位,十位,百位,千位,分别保存到变量ge,shi,bai,qian中
4.使用if判断当前四位数字如果满足条件(个位 + 千位 == 百位 + 十位)
4.1 计数器+1
4.2 打印该数字(不换行)
4.3 判断如果当前打印的数字是这一行的第五个数字的话 打印换行
5.for循环结束,打印计数器的值,就是符合条件的四位数的数量
*/
public class Demo05PrintNums {
public static void main(String[] args) {
//1.定义int变量count,初始值0
int count = 0;
//2.使用for循环获取所有的四位数字
for (int num = 1000; num <= 9999; num++) {
//3.获取当前四位数字的个位,十位,百位,千位,分别保存到变量ge,shi,bai,qian中
int ge = num%10;//个位
int shi = num/10%10;//十位
int bai = num/100%10;//百位
int qian = num/1000%10;//千位
//4.使用if判断当前四位数字如果满足条件(个位 + 千位 == 百位 + 十位)
if((ge + qian) == (shi + bai)) {
//4.1 计数器+1
count++;
//4.2 打印该数字(不换行)
System.out.print(num+" ");
//4.3 判断如果当前打印的数字是这一行的第五个数字的话 打印换行
if (count % 5 == 0) {
System.out.println();
}
}
}
//5.for循环结束,打印计数器的值,就是符合条件的四位数的数量
System.out.println("以上满足条件的四位数总共有 "+count+" 个");
}
}
3.while循环
/*
while循环
1.格式:
初始化表达式1;
while( 布尔表达式2 ) {
循环体3;
步进表达式4;
}
其它语句;
2.执行流程:
1,2,3,4 --> 2,3,4 --> ... --> 直到布尔表达式2的结果为false,结束while循环,执行while循环后面的其它语句
3.注意:
(1)在一个while循环结构中: 初始化表达式1只会执行一次
(2)布尔表达式2: 结果必须为true或者false
(3)循环体3: 一条/多条语句
4.练习:
while循环练习_输出10次HelloWorld
*/
public class Demo01While {
public static void main(String[] args) {
//for循环
for (int i = 1; i <= 10; i++) {
System.out.println("HelloWorld....for..."+i);
}
System.out.println("---------------------");
//while循环
int j = 1;
while(j<=3) {
System.out.println("HelloWorld....while..."+j);
j++;
}
System.out.println("main....end......");
}
}
练习: 珠穆拉玛峰案例
/*
while循环练习2：珠穆朗玛峰
需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。
请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
假设纸的高度: zh = 0.1;
折一次:
zh = zh *2;
zh *=2;
实现步骤:
1.定义double变量paper,表示纸张的厚度,初始值0.1
2.定义int变量zf,表示珠穆朗玛峰的高度,初始值8844430
3.定义int变量count,记录折叠纸的次数,初始值0
4.使用while循环进行折纸的操作: 循环条件 只要纸张的厚度 < 珠穆朗玛峰的高度 就需要再折一次
(1)折一次纸张
(2)计数器+1
5.while循环结束后,打印计数器count的值,就代表折叠纸张的次数
*/
public class Demo02While {
public static void main(String[] args) {
//1.定义double变量paper,表示纸张的厚度,初始值0.1
double paper = 0.1;
//2.定义int变量zf,表示珠穆朗玛峰的高度,初始值8844430
int zf = 8844430;
//3.定义int变量count,记录折叠纸的次数,初始值0
int count = 0;
//4.使用while循环进行折纸的操作: 循环条件 只要纸张的厚度 < 珠穆朗玛峰的高度 就需要再折一次
while(paper < zf) {
//paper > zf 或者 paper == zf: 结束while循环
//(1)折一次纸张
paper *= 2;//0.2,0.4,0.8,1.6,3.2...
//(2)计数器+1
count++;
}
//5.while循环结束后,打印计数器count的值,就代表折叠纸张的次数
System.out.println("总共折叠的次数: "+count);
System.out.println("折叠后纸张的总厚度: "+paper);
}
}
4.do-while循环
/*
do-while
1.格式:
初始化表达式1;
do {
循环体3;
步进表达式4;
} while(布尔表达式2);
其它语句;
2.执行流程:
1,3,4 --> 2,3,4 --> .... --> 直到布尔表达式2的结果为false,结束do-while循环,执行do-while后面的其它语句
3.练习:
输出10次HelloWorld
4.注意:
while的()后,必须写分号 不写报错
*/
public class Demo02DoWhile {
public static void main(String[] args) {
int count = 1;
do {
System.out.println("HelloWorld~~~~~~~"+count);
count++;//2,3,4
} while(count <=3 );//2<=3 true 回到do{}中 //3<=3 true 回到do{}中 //4<=3 false 结束do-while 执行后续其它语句
System.out.println("main.....end....");
System.out.println("count="+count);
}
}
5.三种循环的区别
/*
三种循环的区别总结
1.建议使用的顺序:for,while,do-while
2.循环次数确定的话,建议使用for,循环次数不确定建议使用while(明天猜数字游戏案例)
3.do-while循环来讲的话,至少执行一次
4.while和do-while循环而言,循环结束后,初始化条件中定义的变量可以继续使用,
但是for循环的不能使用(在for循环内部定义初始化语句)
*/
public class Demo03LoopDiff {
public static void main(String[] args) {
//for: 可以一次都不执行(第一次计算布尔表达式的结果: false)
//for循环上定义的变量i: 只在整个for循环内部有效
for(int i = 1;i>2;i++) {
System.out.println("Hello....for...."+i);
}
//System.out.println("for....end...."+i);//错误: i只能在for循环中使用
System.out.println("for....end....");
//while: 可以一次都不执行(第一次计算布尔表达式的结果: false)
int j = 1;
while (j > 2) {
System.out.println("Hello....while...."+j);
j++;
}
System.out.println("while....end...."+j);//...1
//3.do-while循环来讲的话,至少执行一次
int k = 1;
do {
System.out.println("Hello...do...while..."+k);
k++;
} while(k>5);//2>5: false
System.out.println("do...while....end....."+k);//....2
}
}
6.死循环
/*
死循环:
也就是循环中的条件永远为true，死循环的是永不结束的循环。
for循环的:
死循环格式一: for芬芬
for(;;){...}
死循环格式二: -------------------推荐使用
while(true) { ... }
*/
public class Demo04DeadLoop {
public static void main(String[] args) {
//for死循环
/* for (;;) {//如果不写布尔表达式: 默认就是true
System.out.println("Hello");
}*/
System.out.println("-----------------------");
//while死循环
while (true) {
System.out.println("Hello");
}
}
}
六.day06内容
1.循环控制语句:
(1)break: 直接结束所在的循环语句,继续执行循环语句后面的其它语句
a.不能单独使用
b. 可以使用在switch语句中
c. 可以使用在循环语句中
(2)continue: 提前结束本次循环,继续进行下次循环
a. 不能单独使用
b. 只能使用在循环语句中
/*
break的练习:
循环控制语句:
1.break: 直接结束所在的循环语句,继续执行循环语句后面的其它语句
(1) 不能单独使用
(2) 可以使用在switch语句中
(3) 可以使用在循环语句中
*/
public class Demo03Break {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
//当i的值是5时,i%5的结果是0,0==0的结果是true,执行break,
//一旦执行break,直接结束break所在的for循环,执行for循环后面的其它语句 sout("main...end...")
if (i % 5 == 0) {
break;
}
System.out.println("HelloWorld....." + i);
}
System.out.println("main....end....");
}
}
/*
循环控制语句:
1.continue: 提前结束本次循环,继续进行下次循环
(1) 不能单独使用
(3) 只能使用在循环语句中
*/
public class Demo05Continue {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
/*
当i的值是5,10 的时候,i%5==0 结果是true,执行continue
一旦执行continue,结束本次循环(本次循环循环体中continue后面的代码不再执行),
继续进行下次循环(步进表达式)
*/
if (i % 5 == 0) {
continue;
}
System.out.println("HelloWorld...." + i);
}
}
}
2.循环嵌套
/*
循环嵌套
1.概念:
是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。
总共的循环次数=外循环次数*内循环次数
2.格式:
for(...;...;...) {
for(...;...;...){
}
}
3.练习:
教练员安排运动员跑圈
教练总共安排3次,每次让运动员跑3圈
4.注意事项:
外层循环执行一次,内层循环执行完整的一遍
(1)外层循环的初始化语句 int i = 1 执行几次? 1次
(2)内层循环的初始化语句 int j = 1 执行几次? 3次
(3)内层循环的输出语句,总共执行借此?
3 * 3 = 9次
*/
public class Demo01ForFor {
public static void main(String[] args) {
/*
执行流程:
i = 1 1<=3 true
j: 1 2 3 最后j变成4,但是j<=3 ==> 4<=3 false 结束内层循环
i = 2 2<=3 true
j: 1 2 3 最后j变成4,但是j<=3 ==> 4<=3 false 结束内层循环
i = 3 3<=3 true
j: 1 2 3 最后j变成4,但是j<=3 ==> 4<=3 false 结束内层循环
i = 4 4<=3 false 结束外层循环了
*/
for(int i = 1;i<=3;i++) {
//外层循环
System.out.println("教练员第"+i+"次安排运动员跑3圈: ");
for(int j = 1;j<=3;j++) {
//内层循环
System.out.println("运动员跑第"+i+"次,第"+j+"圈");
}
}
}
}
public static void main(String[] args) {
int count = 0;
for(int i = 1;i<5;i++) {//4次
for(int j = 3;j<9;j++) {//6次
count++;//执行24次
}
}
System.out.println(count);
}
3.随机数字
/*
java.util.Random类: 是用于产生随机数字的
和Scanner一样也是一种引用类型
使用步骤和Scanner也是一样的
Scanner:
1.导包: import java.util.Scanner;
2.创建: Scanner sc = new Scanner(System.in);
3.使用:
int num = sc.nextInt();//获取键盘录入的整数
double num = sc.nextDouble();//获取键盘录入的小数
步骤:
1.导包: import java.util.Random;
2.创建: Random r = new Random();
3.使用:
int num = r.nextInt();
作用: 产生一个int范围(正负21亿)内的随机数字,赋值给int变量num
int num = r.nextInt(int n);
作用: 产生一个大于等于0并且小于等于n-1内的随机数字,赋值给int变量num
int num = r.nextInt(10);//产生0到9范围的随机数字(包含0和9的)[0,9]
[0,9) 从0到9,包含0,不包含9
4.练习:
生成3个10以内的随机整数的操作
要求: 0到10,包含0但不能包含10
r.nextInt(10)
*/
public class Demo01Random {
public static void main(String[] args) {
//创建随机数Random类的对象
Random r = new Random();
//生产int范围内的随机数字
int num = r.nextInt();
System.out.println(num);
//再产生3个 int范围内的随机数字
for (int i = 0; i < 3; i++) {
int num2 = r.nextInt();
System.out.println(num2);
}
System.out.println("-----------------------");
//生成3个10以内的随机整数的操作
//要求: 0到10,包含0但不能包含10
for (int i = 0; i < 3; i++) {
int num3 = r.nextInt(10);
System.out.println(num3);
}
}
}
练习:猜数字游戏
/*
Random练习-猜数字
1.需求：
程序自动生成一个1-100之间(包含1和100)的数字，使用程序实现猜出这个数字是多少？
2.效果：
如果猜的数字比真实数字大，提示你猜的数据大了
如果猜的数字比真实数字小，提示你猜的数据小了
如果猜的数字与真实数字相等，提示恭喜你猜中了
[1,100]
[0,99] + 1
r.nextInt(100) + 1
3.使用的知识点
(1)使用Random类
nextInt(100)+1: 产生 1-100之间(包含1和100)的数字
(2)创建键盘录入Scanner对象
nextInt(): 获取整数
(3)需要把用户输入的数字和产生的随机数字进行比较,有三种情况,使用if语句的第三种格式
(4)无法确定用户多少次可以猜测正确: 循环次数不确定 while(true)
(5)用户猜对了,停止程序运行: break
4.实现步骤:
(1)创建产生随机数的Random类的对象r(1.导包 2.创建)
(2)产生一个1到100之间的随机数字,保存到int变量guessNum中,以供用户猜测
(3)创建键盘录入Scanner类的对象
(4)获取用户从键盘录入的整数数字,保存int变量inputNum中
(5)用户输入的数字和产生的随机数字进行比较: 有3种结果,所以使用if语句的第三种格式
a.如果 用户输入的数字inputNum 大于 产生的 随机数字 guessNum: 提示"你猜的数据大了"
b.如果 用户输入的数字inputNum 小于 产生的 随机数字 guessNum: 提示"你猜的数据小了"
c.如果 用户输入的数字inputNum 等于 产生的 随机数字 guessNum: 提示"恭喜你猜中了",使用break结束循环
(6)以上步骤4-5是一个循环的过程,循环次数不确定,使用while(true)
*/
public class Demo03GuessNum {
public static void main(String[] args) {
//(1)创建产生随机数的Random类的对象r(1.导包 2.创建)
Random r = new Random();
//(2)产生一个1到100之间的随机数字,保存到int变量guessNum中,以供用户猜测
int guessNum = r.nextInt(100)+1;//[0,99]+1
//(3)创建键盘录入Scanner类的对象
Scanner sc = new Scanner(System.in);
//(6)以下步骤4-5是一个循环的过程,循环次数不确定,使用while(true)
while(true) {
//(4)获取用户从键盘录入的整数数字,保存int变量inputNum中
System.out.println("请输入您猜测的数字(1-100之间的整数):");
int inputNum = sc.nextInt();
//(5)用户输入的数字和产生的随机数字进行比较: 有3种结果,所以使用if语句的第三种格式
if (inputNum > guessNum) {
//a.如果 用户输入的数字inputNum 大于 产生的 随机数字 guessNum: 提示"你猜的数据大了"
System.out.println("您猜的数据"+inputNum+"大了");
} else if (inputNum < guessNum) {
//b.如果 用户输入的数字inputNum 小于 产生的 随机数字 guessNum: 提示"你猜的数据小了"
System.out.println("您猜的数据"+inputNum+"小了");
} else {
//不用写 if(inputNum == guessNum)
//c.如果 用户输入的数字inputNum 等于 产生的 随机数字 guessNum: 提示"恭喜你猜中了"
System.out.println("恭喜您猜对了");
break;//结束while循环
}
}
}
}
七.day07内容
1.数组变量的定义
/*
变量中,只能存储一个数据,新的数据进来,老的数据将被替换,如果要存储多个数据,需要使用容器
容器概念
容器：是将多个数据存储到一起，每个数据称为该容器的元素。
生活中的容器：水杯，衣柜，教室
数组
1.概念: java中的数组就是一个容器,可以存储多个数据,但是多个数据的类型必须保持一致
2.特点:
(1)可以存储多个数据
(2)多个数据的类型必须保持一致
(3)数组的长度(数组中可以存储元素的数量)一旦确定,就不可以发生改变
3.数组是一个引用类型,数组容器变量的定义格式: 记住
数组是一个容器,数组变量是给该容器起名字的,通过这个名字方便找到这个容器
数组理解为教室
数组变量名: 教室门牌号
格式一: 推荐使用
数据类型[] 数组名称; //理解为 教室门牌号
格式二:
数据类型 数组名称[];
*/
public class Demo01Array {
public static void main(String[] args) {
int num = 10;
System.out.println(num);
num = 10000;
System.out.println(num);
//80位同学参加考试,每个同学都有考试创建
//可以定义80个int变量保存每个同学的创建
int a = 100;
int b = 90;
int c = 50;
//...
//求总分
int sum = a + b + c;//总共80个变量
//求平均分
int avg = sum/80;//总分/学生数量
//求最大分和最小分
System.out.println("-------------------------------------");
//定义一个int类型的变量,变量名称d,里面只能存储一个整数
//数据类型 变量名称;
int d;
//System.out.println(d);
//定义一个存储int类型数据的数组变量,名称arrayA
int[] arrayA;
//定义一个存储double类型数据的数组变量,名称arrayB
double arrayB[];
}
}
2.数组的初始化方式一
/*
数组的第一种初始化方式(动态初始化: 指定长度)
1.格式:
数据类型[] 数组名称 = new 数据类型[长度];
=号左侧:
数据类型[] 数组名称; 教室的门牌号
=号右侧:
new 数据类型[长度]; 创建了一间教室
2.格式解释:
(1)左侧数据类型: 规定了数组中可以存储的数据的具体类型,数组中可以存储哪种类型的数据
(2)左侧[]: 代表是数组
(3)数组名称: 就是给数组容器起个名字,方便使用数组容器 教室的门牌号
(4)new: 就是为数组容器开辟内存空间的
(5)右侧数据类型: 和左侧保持一致
(6)右侧[]中的长度: 规定了数组容器中可以存储的数据的数量
*/
public class Demo02Array {
public static void main(String[] args) {
//1.创建一个int类型的数组,该数组名称arrayA,可以存储3个int数据
int[] arrayA = new int[3];
//2.创建一个char类型的数组,该数组名称arrayB,可以存储5个char数据
char[] arrayB = new char[5];
//3.创建一个boolean类型的数组,该数组名称arrayC,可以存储2个boolean数据
boolean[] arrayC = new boolean[2];
//4.创建一个String类型的数组,该数组名称arrayD,可以存储3个String数据
String[] arrayD = new String[3];
}
}
3.数组的初始化方式二
/*
数组的第二种初始化方式(标准格式静态初始化: 指定数组中的每个元素)
1.格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3...};
=号左侧:
数据类型[] 数组名称; 教室的门牌号
=号右侧:
new 数据类型[]{元素1,元素2,元素3...}; 创建了一间教室,并安排了多个学生
3.注意:
右侧[]中不用指定数组长度,会根据右侧{}中的数组元素计算出数组的长度
*/
public class Demo03Array {
public static void main(String[] args) {
//1.创建一个int类型的数组,该数组名称arrayA,存储int数据 100,200,300
int[] arrayA = new int[]{
100,200,300};
//2.创建一个char类型的数组,该数组名称arrayB,存储char数据 '真','的','好','想','你'
char[] arrayB = new char[]{
'真','的','好','想','你'};
//3.创建一个boolean类型的数组,该数组名称arrayC,存储2boolean数据 false,true
boolean[] arrayC = new boolean[]{
false,true};
//4.创建一个String类型的数组,该数组名称arrayD,存储String数据 "岩岩","幂幂","冰冰"
String[] arrayD = new String[]{
"岩岩","幂幂","冰冰"};
}
}
4.数组的初始化方式三
/*
数组的第三种初始化方式(简化格式静态初始化: 指定数组中的每个元素) ----推荐使用
1.格式:
数据类型[] 数组名称 = {元素1,元素2,元素3...};
=号左侧:
数据类型[] 数组名称; 教室的门牌号
=号右侧:
{元素1,元素2,元素3...}; 创建了一间教室,并安排了多个学生
3.注意:
(1)数组长度省略,根据{}中的元素计算出来
(2)虽然没有写new,但是底层仍然有new的过程
(3)动态初始化/标准格式的静态初始化数组,可以分为两步完成
(4)简化格式的静态态初始化数组,不可以分为两步完成
*/
public class Demo04Array {
public static void main(String[] args) {
//1.创建一个int类型的数组,该数组名称arrayA,存储int数据 100,200,300
int[] arrayA = {
100,200,300};
//2.创建一个char类型的数组,该数组名称arrayB,存储char数据 '真','的','好','想','你'
char[] arrayB = {
'真','的','好','想','你'};
//3.创建一个boolean类型的数组,该数组名称arrayC,存储2boolean数据 false,true
boolean[] arrayC = {
false,true};
//4.创建一个String类型的数组,该数组名称arrayD,存储String数据 "岩岩","幂幂","冰冰"
String[] arrayD = {
"岩岩","幂幂","冰冰"};
int a;//先定义变量
a = 100;//后赋值
a = 10000;//重新赋值
System.out.println("-----------------------");
//动态初始化数组,可以分为两步完成
float[] arrA;
arrA = new float[3];
arrA = new float[30];
//标准格式的静态初始化数组,可以分为两步完成
int[] arrB;
arrB = new int[]{
10,20};
arrB = new int[]{
100,200,300};
//arrB = new double[]{100,200,300};//错误的,数据类型不匹配
//简化格式的静态态初始化数组,不可以分为两步完成
int[] arrC;
//arrC = {1,2,3,5};//不允许
}
}
5.标准/简化格式静态初始化数组的使用
/*
标准/简化格式静态初始化数组的使用
1.数组名: 代表数组容器在内存空间的地址值,是一个十六进制的数据
2.数组中的每个元素都有一个唯一的编号: 称为索引,但是索引编号从0开始,索引编号的最大值(数组长度-1)
3.数组元素的访问:
数组名[索引编号];
array[2]: 数组array中索引编号为2的元素
4.获取数组的长度(数组中存储的元素的数量)
数组有个属性length,使用格式:
int size = 数组名称.length;
注意:
length是数组的属性,所以使用时后面没有()
总结:
数组元素的索引编号范围:
从0开始,到最大索引(数组长度-1: 数组名称.length)
*/
public class Demo01UseArray {
public static void main(String[] args) {
//定义int变量num,存储100
int num = 100;
System.out.println(num);//100
//创建int类型的数组,名称为array,存储int数据 10,20,30
int[] array = {
10, 20, 30};//10的编号0,20的编号1,30的编号2
System.out.println(array);//在内存空间的地址值: [I@1540e19d
//打印10
System.out.println(array[0]);//打印数组array中的索引编号为0的元素值:10
//打印20
System.out.println(array[1]);//打印数组array中的索引编号为1的元素值:20
//打印30
System.out.println(array[2]);//打印数组array中的索引编号为2的元素值:30
//把10 改成 100
array[0] = 100;//把int数字100赋值给数组array中的索引为0的元素中
//把20 改成 200
array[1] = 200;//把int数字200赋值给数组array中的索引为1的元素中
//把30 改成 300
array[2] = 300;//把int数字300赋值给数组array中的索引为2的元素中
System.out.println(array);//在内存空间的地址值: [I@1540e19d
//打印100
System.out.println(array[0]);//打印数组array中的索引编号为0的元素值:100
//打印200
System.out.println(array[1]);//打印数组array中的索引编号为1的元素值:200
//打印300
System.out.println(array[2]);//打印数组array中的索引编号为2的元素值:300
//获取数组的长度
int count = array.length;
System.out.println("数组中元素的个数: "+count);
}
}
6.动态初始化(指定数组长度)初始化数组的使用
/*
动态初始化(指定数组长度)初始化数组的使用
1.数组名: 代表数组容器在内存空间的地址值,是一个十六进制的数据
2.数组中的每个元素都有一个唯一的编号: 称为索引,但是索引编号从0开始,索引编号的最大值(数组长度-1)
3.数组元素的访问:
数组名[索引编号];
array[2]: 数组array中索引编号为2的元素
4.获取数组的长度(数组中存储的元素的数量)
数组有个属性length,使用格式:
int size = 数组名称.length;
注意:
length是数组的属性,所以使用时后面没有()
总结:
数组元素的索引编号范围:
从0开始,到最大索引(数组长度-1: 数组名称.length)
5.注意:
动态初始化数组,元素有默认值
基本类型:
整数 byte/short/int/long: 0
小数 float/double: 0.0
布尔 boolean: false
字符 char: 空白字符
引用类型:
默认值都是null
*/
public class Demo02UseArray {
public static void main(String[] args) {
//定义int类型的数组,名称array,可以存储3个int数据
int[] array = new int[3];//该数组中有3个元素,编号为0,1,2
System.out.println(array);//数组在内存空间的地址值: [I@1540e19d
System.out.println(array[0]);//打印数组array中索引编号为0的元素值,默认值: 0
System.out.println(array[1]);
System.out.println(array[2]);
//把100赋值给数组array中索引编号为0的元素中
array[0] = 100;
//把200赋值给数组array中索引编号为1的元素中
array[1] = 200;
//把300赋值给数组array中索引编号为2的元素中
array[2] = 300;
System.out.println(array);//数组在内存空间的地址值: [I@1540e19d
System.out.println(array[0]);//打印数组array中索引编号为0的元素值: 100
System.out.println(array[1]);
System.out.println(array[2]);
}
}
7.数组使用的常见问题
/*
数组使用的常见问题:
1.索引越界异常
java.lang.ArrayIndexOutOfBoundsException
(1)原因:
使用了不存在的索引,获取数组元素
索引范围: 从0开始到数组长度-1
(2)解决方案:
找到数组索引越界的地方,进行修改
2.空指针异常
java.lang.NullPointerException
(1)原因:
null是一个引用类型的常量,可以赋值给任意引用类型的变量,
但是一旦引用类型的变量的值是null,则说明该引用类型的变量不再执行堆内存中的任何空间
所以将不能再通过该引用类型变量来访问堆内存空间中的数组元素
(2)解决方案:
a.找到引用变量的值是null的地方,进行修改不让引用变量的值是null
b.不通过值为null的引用变量,访问堆内存空间的内容
*/
public class Demo01ArrayProblems {
public static void main(String[] args) {
//创建int类型数组,名称array,存储int数据 10,20,30
int[] array = {
10,20,30};
System.out.println(array);//地址值: [I@1540e19d
System.out.println(array[0]);//10
System.out.println(array[1]);//20
System.out.println(array[2]);//30
System.out.println(array[5]);//索引5,不存在,报出索引越界异常
System.out.println("main....end....");
array = null;
System.out.println(array);//null
//System.out.println(array[0]);//空指针异常
}
}
8.求数组的最大值
/*
获取数组元素的最大值
实现步骤:
1.定义长度为5的int数组,数组名array,存储5个int数据,分别代表颜值
2.假设数组中索引为0的元素是最大的,把0索引元素值保存int变量max中
3.使用for循环获取后面的(从1索引开始)所有元素
4.使用if进行判断,如果数组当前元素值>假设的最大值(max中)
把数组当前元素重新赋值给变量max
5.打印max的值
求最小值/和/平均值?
*/
public class Demo04ArrayMax {
public static void main(String[] args) {
//1.定义长度为5的int数组,数组名array,存储5个int数据,分别代表颜值
int[] array = {
5,15,2000,10000,100,4000};
//2.假设数组中索引为0的元素是最大的,把0索引元素值保存int变量max中
int max = array[0];
//3.使用for循环获取后面的(从1索引开始)所有元素
for (int i = 1; i < array.length; i++) {
//4.使用if进行判断,如果数组当前元素值>假设的最大值(max中)
if(array[i] > max) {
//把数组当前元素重新赋值给变量max
max = array[i];
}
}
//5.打印max的值
System.out.println("数组元素的最大值: "+max);
}
}
八.day08内容
1.方法详解
方法
1.概念:
将一段代码用{}括起来,起个名字,添加必要的修饰符,方便使用
2.格式(通用/详细的格式)
修饰符 返回值类型 方法名称(数据类型1 变量名称1,数据类型2 变量名称2...){
功能代码;
return 返回值;
}
注意:
(1)如果没有返回值,那么返回值类型 写 void ,后面 return ; 可以省略
(2)如果没有参数,不用写参数列表,但是必须要保留()
3.格式解释
(1)修饰符: 目前固定写法,public static
(2)返回值类型: 方法功能代码执行完毕后,返还给方法调用者的结果数据的具体类型
(3)方法名称: 给方法起个名字,方便使用,做到见名知意,必须符合标识符命名规则,建议小驼峰原则
(4)参数列表:
数据类型: 告诉方法的调用者,在调用方法时传递什么类型的数据
变量名称: 用来接收方法调用者,调用方法时传递的具体数据的
(5)功能代码: 完成具体功能的代码
(6)return 返回值:
作用1: 结束方法
作用2: 把返回值,返还给方法的调用者
4.方法的理解(工厂/机器)
生产汽车的工厂
原材料: 发动机,变速箱,轮胎 方法参数
产出物: BMW750Li, S600, ZT700 方法的返回值
榨汁机:
原材料: 水果,水,糖 方法参数
产出物: 果汁 方法的返回值
如果把生产汽车的工厂看成方法的话:
原材料是进入工厂的东西,相当于调用方法时,传递给方法的具体数据
产出物是从工厂中出来的东西,相当于调用方法后,方法返回的具体数据
5.定义方法的三要素
(1)方法名称:
(2)参数列表: 当方法需求中有不确定的因素,需要定义参数列表
(3)返回值类型: 当方法内部需求中,明确规定"打印...",不需要返回值,也就不需要返回值类型,写为void
2.定义无参无返回值方法
/*
无参数无返回值的方法练习
定义一个方法，打印该方法内部的两个数据(方法内部定义的变量)的最大值
无参数: 方法名称后()中不写内容
无返回值: 返回值类型写为void
*/
public class Demo05Method {
public static void main(String[] args) {
System.out.println("main....start....");
//调用方法
printMax();
System.out.println("main....end....");
}
//定义一个方法，打印该方法内部的两个数据(方法内部定义的变量)的最大值
public static void printMax() {
//求两个int数据的最大值
int a = 100;
int b = 200;
int max;
if (a > b) {
max = a;
} else {
max = b;
}
System.out.println("最大值: "+max);
return ;//结束方法,返回到方法的调用处,可以省略的
}
}
3.带参数无返回值的方法练习
/*
带参数无返回值的方法练习
需求:
定义一个方法用于打印两个int数中的较大数，数据来自于方法参数
参数列表: 当方法需求中有不确定的因素,需要定义参数列表
返回值类型: 当方法内部需求中,明确规定"打印...",不需要返回值,也就不需要返回值类型,写为void
三要素:
1.方法名称: printMax
2.参数列表: int a,int b
3.返回值类型: void
*/
public class Demo04MethodParams {
public static void main(String[] args) {
System.out.println("main...start...");
//调用方法: 传递常量
printMax(88,66);
//printMax(6.6,8.8);//错误,传递的实际参数和形式参数类型比匹配
//调用方法: 传递变量
int num1 = 50;
int num2 = 75;
printMax(num1,num2);
System.out.println("main...end...");
}
/*
定义一个方法用于打印两个int数中的较大数，数据来自于方法参数
三要素:
1.方法名称: printMax
2.参数列表: int a,int b
3.返回值类型: void
*/
public static void printMax(int a, int b) {
//求2个int数据的较大值
//三元运算符
int max = (a > b) ? a : b;
System.out.println("最大值: "+max);
return ;
}
}
4.有参数有返回值的方法练习
/*
带参数带返回值的方法练习
设计一个方法可以获取两个int数的较大值，数据来自于参数
参数列表: 当方法需求中有不确定的因素,需要定义参数列表
返回值类型:
当方法内部需求中,明确规定"打印...",不需要返回值,也就不需要返回值类型,写为void
当方法内部需求中,明确规定"获取/返回/判断...",需要有返回值,也就需要返回值类型
三要素:
1.方法名称: getMax
2.参数列表: int a,int b
3.返回值类型: int
*/
public class Demo03MethodReturn {
public static void main(String[] args) {
System.out.println("main...start...");
//定义2个int变量
int a = 100;
int b = 50;
//调用方法
int max = getMax(a,b);
System.out.println(a+"和"+b+"的最大值是: "+max);
System.out.println("main...end...");
}
/*
设计一个方法可以获取两个int数的较大值，数据来自于参数
三要素:
1.方法名称: getMax
2.参数列表: int a,int b
3.返回值类型: int
*/
public static int getMax(int a, int b) {
//形式参数
if (a > b) {
return a;
} else {
return b;
}
}
}
5.方法的注意事项
/*
定义方法的注意事项
1.方法不能嵌套定义(在定义的方法的内部,又定义了其它的方法)
2.方法可以嵌套调用(在定义的方法内部,可以调用其它的方法)
3.返回值类型，必须要和 return 语句返回的类型匹配，否则编译失败 。
4.不能在 return 后面写代码， return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码。
只要方法有返回值类型,那么方法内部有且仅有一条return语句会被执行
5.void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
*/
public class Demo04MethodNotice {
//定义main方法
public static void main(String[] args) {
}
//只要方法有返回值类型,那么方法内部有且仅有一条return语句会被执行
public static int getMax(int a, int b) {
if (a > b) {
return a;
}
return b;
}
//4.不能在 return 后面写代码， return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码。
public static int getNum() {
int a = 10;
return a;//方法就结束了,就返回到方法的调用处了,后面代码没有机会执行
//int b = 20;//错误,return后面不能继续写代码
}
//3.返回值类型，必须要和 return 语句返回的类型匹配，否则编译失败
public static double getDouble() {
//return 6.6;
//return 10;//int --> double
//return 8.8F;//float --> double
return 20L;//long --> double
//return true;//错误,返回结果的数据类型和返回值类型不匹配
}
//定义method方法
public static void method() {
System.out.println("method...");
/*
//错误,方法内部不能再定义方法
public static void show() {
System.out.println("show...");
return ;
}*/
//嵌套调用
a();
return ;
}
public static void a() {
System.out.println("a....");
return ;
}
}
6.参数传递
/*
基本数据类型作为方法参数
注意:
1.基本类型作为方法参数,传递的是具体的数据值
2.基本类型作为方法的形式参数时,形式参数的改变,不会影响实际参数
基本类型作为方法的形式参数时:
change方法上定义的a和b
就是形式参数
不会影响实际参数
main方法中调用change方法时,定义的变量a和b
*/
public class Demo01BaseParam {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("ms..a="+a);//10
System.out.println("ms..b="+b);//20
//调用方法
change(a,b);
System.out.println("me..a="+a);//10
System.out.println("me..b="+b);//20
}
public static void change(int a, int b) {
System.out.println("cs..a="+a);//10
System.out.println("cs..b="+b);//20
a *= 10;
b *= 10;
System.out.println("ce..a="+a);//100
System.out.println("ce..b="+b);//200
return;
}
}
/*
引用数据类型作为方法参数
注意:
1.引用类型作为方法参数,调用方法时,传递的是地址值
2.引用类型作为方法的形式参数,通过形式参数修改堆内存空间的内容,
会影响到实际参数看到的堆内存空间的内容
引用类型作为形参,形式参数的改变会影响实际参数
*/
public class Demo02RefParam {
public static void main(String[] args) {
int[] arr = new int[]{
10,20};//arr中存储的是数组的地址值,假设:0x666
System.out.println("ms..arr[0]="+arr[0]);//10
System.out.println("ms..arr[1]="+arr[1]);//20
//调用方法: change(0x666)
change(arr);
System.out.println("me..arr[0]="+arr[0]);//100
System.out.println("me..arr[1]="+arr[1]);//200
}
/*
当调用change方法时:
int[] arr = 0x666 = arr(main方法中的) = new int[]{10,20}
*/
public static void change(int[] arr) {
System.out.println("cs..arr[0]="+arr[0]);//10
System.out.println("cs..arr[1]="+arr[1]);//20
arr[0] *= 10;//arr[0] = arr[0] * 10
arr[1] *= 10;//arr[1] = arr[1] * 10
System.out.println("ce..arr[0]="+arr[0]);//100
System.out.println("ce..arr[1]="+arr[1]);//200
return ;
}
}
九.day09内容
1.方法重载概念
/*
练习:
1.定义方法,获取2个int数据之和
2.定义方法,获取3个int数据之和
3.定义方法,获取2个double数据之和
4.定义方法,获取3个double数据之和
发现问题:
以下四个方法,都是完成求和功能,功能相同,只是参数列表不同,
但是我们给每个方法起了一个非常复杂而且不相同的名字,
导致程序员学习/使用的时候太麻烦,记不住
解决方案: 方法重载
1.概念:
在同一个类中,多个功能相同,但是参数列表不同的方法,可以使用相同的名字,这种现象就叫做方法的重载
2.作用:
(1)节省命名空间
(2)减少程序员学习/使用的成本
*/
public class Demo02OverLoad {
public static void main(String[] args) {
System.out.println(getSum(10,20));
System.out.println(getSum(10,20,30));
System.out.println(getSum(10.0,20.0));
System.out.println(getSum(10.0,20.0,30.0));
}
//1.定义方法,获取2个int数据之和
public static int getSum(int a, int b) {
System.out.println("获取2个int数据之和的方法被调用了....");
return a + b;
}
//2.定义方法,获取3个int数据之和
public static int getSum(int a, int b,int c) {
System.out.println("获取3个int数据之和的方法被调用了....");
return a + b + c;
}
//3.定义方法,获取2个double数据之和
public static double getSum(double a, double b) {
System.out.println("获取2个double数据之和的方法被调用了....");
return a + b;
}
//4.定义方法,获取3个double数据之和
public static double getSum(double a, double b,double c) {
System.out.println("获取3个double数据之和的方法被调用了....");
return a + b + c;
}
}
2.参数列表不同有哪些情况
/*
方法重载中,参数列表不同有哪些情况? ----方法重载,主要关心方法的参数
1.参数数量不同
2.参数类型不同
3.多个类型,顺序不同
*/
public class Demo03OverLoad {
public static void main(String[] args) {
}
//1.有两个int参数
public static void printMax(int a, int b) {
}
//2 方法2有3个int参数,而方法1有2个int参数,参数数量不同, 可以构成重载
public static void printMax(int a, int b,int c) {
}
//3 方法3有2个double参数,而方法1有2个int参数,参数的类型不同, 可以构成重载
public static void printMax(double a, double b) {
}
//4.有1个double参数和1个int参数,而且double在前,int在后
public static void printMax(double a, int b) {
}
//5.有1个double参数和1个int参数,而且int在前,double在后 多个类型,但是顺序不同,可以构成重载
public static void printMax(int a, double b) {
}
}
3.方法重载与哪些因素无关
/*
方法重载与哪些因素无关?
1.与方法的参数名称无关
2.与返回值类型无关
3.与修饰符无关
定义方法时()中定义的变量/参数 称之为 形式参数
调用方法时()中穿度的变量/参数 称之为 实际参数
*/
public class Demo04OverLoad {
public static void main(String[] args) {
}
//1.有两个int参数,参数名称是a和b
public static void printMax(int a, int b) {
}
//2.方法2和方法1只有参数的名称不同, 无法构成重载
/*public static void printMax(int c, int d) {
}*/
//3.有2个int参数,返回值类型int
public static int getNum(int a,int b) {
return 0;
}
//4.有2个int参数,返回值类型double
//方法4和方法3,只有返回值类型不同 无法构成重载
/*public static double getNum(int a,int b) {
return 0.0;
}*/
//5.有2个int参数,返回值类型int
//方法5和方法3,只有修饰符不同 无法构成重载
/*private static int getNum(int a,int b) {
return 0;
}*/
}
十.day10内容
1.数组统计学生成绩
/*
数组统计学生成绩
需求:
1.键盘录入班级人数
2.根据录入的班级人数创建数组
3.利用随机数产生0-100的成绩(包含0和100)
4.要求:
(1)打印该班级的不及格人数
(2)打印该班级的平均分
(3)演示格式如下:
请输入班级人数:
键盘录入:100
控制台输出: 不及格人数:19
班级平均分:87
实现步骤:
1.创建键盘录入Scanner类的对象
2.获取键盘录入的整数数字(代表班级人数),保存到int变量size中
3.创建长度为size的int类型的数组array 元素都是默认值0
4.创建产生随机数的Random类的对象
5.给数组元素赋值(0到100之间,包含0和100)
6.定义int变量count,用来统计不及格的人数,初始值0
7.定义int变量sum,用来求数组元素之和,初始值0
8.使用for循环遍历数组
9.把当前元素累加到求和变量sum中
10.判断如果当前元素值小于60,计数器count的值+1
11.计算平均值
12.for循环结束打印不及格人数和所有创建的平均值
*/
public class Test02ArrayScore {
public static void main(String[] args) {
//1.创建键盘录入Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.获取键盘录入的整数数字(代表班级人数),保存到int变量size中
System.out.println("请输入一个整数(代表班级的人数): ");
int size = sc.nextInt();
//3.创建长度为size的int类型的数组array 元素都是默认值0
int[] array = new int[size];
//4.创建产生随机数的Random类的对象
Random r = new Random();
//5.给数组元素赋值(0到100之间,包含0和100)
/*array[0] = r.nextInt(101);
array[1] = r.nextInt(101);
array[2] = r.nextInt(101);
//...
array[size-1] = r.nextInt(101);*/
for (int i = 0; i < array.length; i++) {
array[i] = r.nextInt(101);
}
//6.定义int变量count,用来统计不及格的人数,初始值0
int count = 0;
//7.定义int变量sum,用来求数组元素之和,初始值0
int sum = 0;
//8.使用for循环遍历数组
for (int i = 0; i < array.length; i++) {
//9.把当前元素累加到求和变量sum中
sum += array[i];
//10.判断如果当前元素值小于60,计数器count的值+1
if (array[i] < 60) {
count++;
}
}
//11.计算平均值
int avg = sum / size;
//12.for循环结束打印不及格人数和所有创建的平均值
System.out.println("不及格人数: "+count);
System.out.println("平均分: " + avg);
}
}
2.随机抽取数组元素
/*
随机抽取数组元素
需求:
将数字1-10保存到一个长度为10的int数组arrA中
定义一个新数组arrB,长度为3,取出原来数组中随机的三个元素(不考虑是否重复)
给新数组的元素赋值
求新数组所有元素的和
注意:
元素组的长度10(length属性值),最大索引9(length属性值-1)
如何从长度为10的数组中,随机取出3个元素呢?
1.要取出数组元素,必须产生索引?产生索引的时候,不能越界?
因为源数组的索引是0到9(包含0和9)
产生的索引范围是0到9(包含0和9)
Random r = new Random();
r.nextInt(10);//而10 是数组的长度,可以使用length属性代替
r.nextInt(arrA.length): 产生0到arrA.length-1范围内的索引
2.通过随机索引获取源数组元素,存储到新数组中
实现步骤:
1.创建长度为10的int类型数组arrA
2.向arrA数组中存储1-10的数字
3.创建产生随机数的Random类的对象
4.创建长度为3的int类型数组arrB
5.使用for循环遍历数组arrB
6.产生一个int随机数字index(要获取的老数组中随机元素的索引值),范围是老数组的索引范围
7.从老数组arrA中通过索引index获取元素值,保存int变量num中
8.把num的值保存到数组arrB的当前元素中
9.定义int类型求和变量sum,初始化值0
10.遍历新数组arrB
11.把当前元素累加到求和变量sum中
12.打印求和变量sum
扩展:
如果新数组中元素不能重复,应该怎么做?
*/
public class Test03ArrayRandom {
public static void main(String[] args) {
//1.创建长度为10的int类型数组arrA
int[] arrA = new int[10];
//2.向arrA数组中存储1-10的数字
/*arrA[0] = 0+1;
arrA[1] = 1+1;
arrA[2] = 2+1;
//...
arrA[arrA.length-1] = arrA.length-1 +1;*/
for (int i = 0; i < arrA.length; i++) {
arrA[i] = i+1;
}
//3.创建产生随机数的Random类的对象
Random r = new Random();
//4.创建长度为3的int类型数组arrB
int[] arrB = new int[3];
//5.使用for循环遍历数组arrB
for (int i = 0; i < arrB.length; i++) {
//6.产生一个int随机数字index(要获取的老数组中随机元素的索引值),范围是老数组的索引范围
int index = r.nextInt(arrA.length);
//7.从老数组arrA中通过索引index获取元素值,保存int变量num中
int num = arrA[index];
//8.把num的值保存到数组arrB的当前元素中
arrB[i] = num;
}
//9.定义int类型求和变量sum,初始化值0
int sum = 0;
//10.遍历新数组arrB
for (int i = 0; i < arrB.length; i++) {
//11.把当前元素累加到求和变量sum中
sum += arrB[i];
}
//12.打印求和变量sum
System.out.println("新数组元素内容: "+ Arrays.toString(arrB)+"新数组元素和: "+sum);
}
}
3.评委打分
/*
评委打分
需求
在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100(包含0和10)的整数分(键盘录入)。
选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。
实现步骤:
1.创建长度为6的int数组array
2.创建键盘录入Scanner对象
3.通过键盘录入数据给数组array中6个元素赋值
4.定义求int数组array元素和的方法getSum
5.定义求int数组array元素最大值的方法getMax
6.定义求int数组array元素最小值的方法getMin
7.调用求数组元素和的方法getSum,获取求和结果,保存到int变量sum中
8.调用求数组元素最大值的方法getMax,获取最大值结果,保存到int变量max中
9.调用求数组元素最小值的方法getMin,获取最小值结果,保存到int变量min中
10.计算平均分: (sum - max - min)/(array.length-2)
11.打印平均分
*/
public class Demo07ArrayScore {
public static void main(String[] args) {
//调用方法,获取int数组
int[] array = getArray();
//调用方法,获取平均值
int avg = getAvg(array);
//11.打印平均分
System.out.println("数组内容: ");
printArray(array);
System.out.println("按照规则计算出来的平均分: "+avg);
}
/*
定义getAvg方法,获取方法参数int数组的平均值
*/
public static int getAvg(int[] array) {
//7.调用求数组元素和的方法getSum,获取求和结果,保存到int变量sum中
int sum = getSum(array);
//8.调用求数组元素最大值的方法getMax,获取最大值结果,保存到int变量max中
int max = getMax(array);
//9.调用求数组元素最小值的方法getMin,获取最小值结果,保存到int变量min中
int min = getMin(array);
//10.计算平均分: (sum - max - min)/(array.length-2)
int avg = (sum - max - min)/(array.length - 2);
//11.返回平均值
return avg;
}
/*
定义getArray方法,返回一个int数组
*/
public static int[] getArray() {
//步骤1-3能否封装成一个方法
//1.创建长度为6的int数组array
int[] array = new int[6];
//2.创建键盘录入Scanner对象
Scanner sc = new Scanner(System.in);
//3.通过键盘录入数据给数组array中6个元素赋值
for (int i = 0; i < array.length; i++) {
System.out.println("请输入第"+(i+1)+"个评分");
array[i] = sc.nextInt();
}
//4.返回数组array
return array;
}
//6.定义求int数组array元素最小值的方法getMin
public static int getMin(int[] array) {
//1.假设索引0对应的元素是最小的,保存到int变量min中
int min = array[0];
//2.for循环遍历数组(从索引1开始)
for (int i = 1; i < array.length; i++) {
//3.如果当前元素
if (array[i] < min) {
//4.把当前元素赋值给min
min = array[i];
}
}
//5.返回min
return min;
}
//5.定义求int数组array元素最大值的方法getMax
public static int getMax(int[] array) {
//1.假设索引0对应的元素是最大的,保存到int变量max中
int max = array[0];
//2.for循环遍历数组(从索引1开始)
for (int i = 1; i < array.length; i++) {
//3.如果当前元素>max
if (array[i] > max) {
//4.把当前元素赋值给max
max = array[i];
}
}
//5.返回max
return max;
}
//4.定义求int数组array元素和的方法getSum
public static int getSum(int[] array) {
//1.定义int类型求和变量sum,初始值0
int sum = 0;
//2.for循环遍历数组
for (int i = 0; i < array.length; i++) {
//3.把当前元素累加到求和变量sum中
sum += array[i];
}
//4.返回求和变量sum
return sum;
}
//打印数组
public static void printArray(int[] array) {
//1.打印"[",不换行
System.out.print("[");
//2.使用for循环遍历数组
for (int i = 0; i < array.length; i++) {
//2.1打印元素
System.out.print(array[i]);
//2.2如果不是最后一个元素,打印", ",不换行
if (i != array.length - 1) {
System.out.print(", ");
}
}
//3.打印"]",换行
System.out.println("]");
}
}
4.水仙花数
/*
水仙花数
案例需求
在控制台输出所有的“水仙花数”及其总个数
什么是水仙花数？
水仙花数，指的是一个三位数，个位、十位、百位的数字立方和等于原数
例如 153 3*3*3 + 5*5*5 + 1*1*1 = 27 + 125 + 1 = 153
要求: 需要定义一个判断三位数字是否是水仙花数字的方法isWaterFlowerNum
实现步骤:
1.定义判断一个三位数字是否是水仙花数字的方法isWaterFlowerNum
2.定义int变量count,用来计数,初始化值0
3.使用for循环遍历所有的三位数字
4.判断如果当前数字是水仙花数字(调用isWaterFlowerNum方法)
5.打印当前数字
6.计数器count+1
7.打印count的值
*/
public class Demo01WaterFlowers {
public static void main(String[] args) {
//2.定义int变量count,用来计数,初始化值0
int count = 0;
//3.使用for循环遍历所有的三位数字
for (int i = 100; i <= 999; i++) {
//4.判断如果当前数字是水仙花数字(调用isWaterFlowerNum方法)
/*boolean result = isWaterFlowerNum(i);
if(result == true){}*/
if(isWaterFlowerNum(i) == true) {
//5.打印当前数字
System.out.println(i);
//6.计数器count+1
count++;
}
}
//7.打印count的值
System.out.println("水仙花数字总共有"+count+"个");
}
/*
定义判断一个三位数字是否是水仙花数字的方法isWaterFlowerNum
要求:
个位、十位、百位的数字立方和等于原数
三要素:
1.方法名称: isWaterFlowerNum
2.参数列表: int num
3.返回值类型: boolean
实现步骤:
1.计算方法参数num的个位,十位,百位,分别保存int变量ge,shi,bai中
2.计算个位,十位,百位数字的立方和,保存int变量sum中
3.判断如果立方和sum等于该数字num本身,返回true
4.判断如果立方和sum不等于该数字num本身,返回false
*/
public static boolean isWaterFlowerNum(int num) {
//1.计算方法参数num的个位,十位,百位,分别保存int变量ge,shi,bai中
int ge = num%10;//个位
int shi = num/10%10;//十位
int bai = num/100%10;//百位
//2.计算个位,十位,百位数字的立方和,保存int变量sum中
int sum = ge*ge*ge + shi*shi*shi + bai*bai*bai;
/*if (sum == num) {
//3.判断如果立方和sum等于该数字num本身,返回true
return true;
} else {
//4.判断如果立方和sum不等于该数字num本身,返回false
return false;
}*/
return sum == num;
}
}
十一.day11内容
1.面向对象的特点
面向对象思想总结:
1.面向过程:当要实现一个功能时,需要亲力亲为,处理每个细节
2.面向对象:当要实现一个功能时,不关心具体的实现步骤,只关心结果,找一个具有该功能的类,帮我们做事
3.面向对象的思想
(1)面向对象是基于面向过程的编程思想.
(2)面向过程:强调的是每一个功能的步骤
(3)面向对象:强调的是对象,然后由对象去调用功能
4.特点
(1)是一种更符合我们思考习惯的思想
(2)可以将复杂的事情简单化
(3)角色发生了转换,将我们从执行者变成了指挥者
2.类和对象的关系
类：类是对现实生活中一类具有共同属性和行为的事物的抽象
类是对一类事物的描述，是抽象的。
对象：是能够看得到摸的着的真实存在的实体
对象是一类事物的实例，是具体的。
简单理解：类是对事物的一种描述，对象则为具体存在的事物
类是对象的模板，对象是类的实体。
3.类的定义
/*
定义Student类,用来模拟学生事物
分析,学生事物有两部分组成
1.属性(名词): 姓名,性别,年龄
2.行为(动词): 吃饭,睡觉,学习
对应到java的类中,也有两部分组成
1.成员变量(属性,名词):
姓名: String name
性别: String gender
年龄: int age
2.成员方法(行为,动词)
吃饭: eat()
睡觉: sleep()
学习: study()
类的定义格式:
public class 类名 {
//成员变量
//成员方法
}
注意: class是定义类的关键字,class后面的名称,叫做类名
注意:
1.成员变量: 和以前定义变量的格式相同,只是位置发生了改变,成员变量定义在类中方法外
以前在方法内部定义的变量,叫做局部变量
2.成员方法: 和以前定义方法的格式相同,只是需要去掉static关键字
*/
/*
这里定义了一个名称为Student的类,用来描述学生事物,相当于模板/模型/图纸,
不能直接使用,要想使用,必须根据模板/模型/图纸创建一个具体的对象才可以使用.
抽象:
抽取出现实事物中像的部分,相同的部分,相似的部分
*/
public class Student {
//成员变量(属性,名词)
String name;//姓名
String gender;//性别
private int age;//年龄
//
public Student() {
System.out.println("空参构造被调用了.....");
}
public Student(String name, String gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age >= 0 && age <= 100) {
this.age = age;
}
}
//成员方法
//吃饭
public void eat(){
System.out.println(age+"吃饭饭...");
}
//睡觉
public void sleep() {
System.out.println("睡觉觉...");
}
//学习
public void study() {
System.out.println("正在学习面向对象的内容...");
}
}
4.对象的使用
/*
前面定义的一个名称为Student的类,用来描述学生事物,相当于模板/模型/图纸,
不能直接使用,要想使用,必须根据模板/模型/图纸创建一个具体的对象才可以使用.
类是一种引用数据类型,使用有3个步骤
1.导包(找到要使用的类):
java.lang包下的内容可以直接使用,不需要导包
导包格式: import xxx.xxx.类名;
快捷键: alt + 回车
注意:
当前的类和要使用的类在同一个包中,不需要导包
2.创建对象:
数组对象的创建:
数据类型[] 数组名称 = new 数据类型[3];
int[] array = new int[3];
array[0],array[1],array[2]
sout(array[0]);
array[0] = 100;
类的对象的创建:
类名 对象名 = new 类名();
3.对象的使用:
(1)对象名称: 对象在内存空间的地址值
(2)成员变量的使用格式:
对象名称.成员变量名称
比如:
stu.name: 对象的name属性值
(3)成员方法的使用格式:
对象名称.成员方法名称(...);
比如:
stu.eat(): 调用对象stu的eat方法
总结:
点(.): 理解为xxx的yyy
4.注意:
对象的成员变量有默认初始化值
(1)基本类型
整数(byte/short/int/long): 0
小数(float/double): 0.0
布尔(boolean): false
字符(char): 空白字符
(2)引用类型 null
*/
public class Demo02Student {
public static void main(String[] args) {
//创建Student类的对象
Student stu = new Student();
Student stu2 = new Student("lisi", "nan", 16);
stu2.eat();
System.out.println(stu);//地址值: itheima01.Student@1540e19d
//打印成员变量的值
System.out.println(stu.name);//null,打印对象stu的name属性值,默认值: null
System.out.println(stu.gender);//null,打印对象stu的gender属性值,默认值: null
System.out.println(stu.getAge());//0,打印对象stu的age属性值,默认值: 0
//给成员变量赋值
stu.name = "小强";//把字符串"小强"赋值给对象stu的name属性
stu.gender = "男";//把字符串"男"赋值给对象stu的gender属性
stu.setAge(-8888);//把int数字赋值给对象stu的age属性
System.out.println(stu);//地址值: itheima01.Student@1540e19d
//打印成员变量的值
System.out.println(stu.name);//小强,打印对象stu的name属性值: 小强
System.out.println(stu.gender);//男,打印对象stu的gender属性值: 男
System.out.println(stu.getAge());//18,打印对象stu的age属性值: 18
//调用成员方法
stu.eat();//调用对象stu的eat方法
stu.sleep();//调用对象stu的sleep方法
stu.study();//调用对象stu的study方法
}
}
5.成员变量和局部变量区别
/*
成员变量和局部变量区别
1.初始化值的不同
成员变量：有默认值
局部变量：没有默认值。必须先定义，赋值，最后使用
局部变量: 在定义/声明方法的时候()中定义的变量,或者在方法内部定义的变量
2..在类中的位置不同
成员变量：类中，方法外
局部变量：方法中或者方法声明上(形式参数)
3.作用范围不一样
成员变量：类中
局部变量：方法中
4.在内存中的位置不同
成员变量：堆内存 局部变量：栈内存
5.生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
*/
public class Demo03VarDiff {
public static void main(String[] args) {
//int a;//在方法内部定义的变量,局部变量,不赋值,不能使用
//System.out.println(a);
Person p = new Person();
//name是在Person类中定义的成员变量
//创建对象后,有默认初始化值
System.out.println(p.name);//null
}
/*
a和b也是局部变量,在方法定义的时候定义的,
而方法不调用不执行
只要调用方法getSum,那么必须传递两个int数字分别给a和b
*/
public static int getSum(int a, int b) {
int sum = a + b;
System.out.println("和: "+sum);
return sum;
}
}
//定义Person类
public class Person {
String name;//成员变量,在整个类中都可以使用
public void show() {
//局部变量,只能在show方法内部使用
int num = 100;
System.out.println(num);
System.out.println(name+"...");
}
public void method() {
//不能使用num
//System.out.println(num);//超出了num的作用范围
System.out.println(name+"----");
}
}
十二.day12内容
1.private的含义
将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。
private是一个权限修饰符，代表最小权限。
可以修饰成员变量和成员方法。
被private修饰后的成员变量和成员方法，只在本类中才能访问。
/*
发现问题:
定义类时,规定了成员变量的含义,但是却无法保证成员变量的取值在一个合理有效的范围内;
比如年龄age: 规定0到100之间
如何解决呢?
解决方案:
使用private(私有)关键字,将需要保护的成员变量使用private修饰一把
private关键字的特点:
1.被private修饰的成员(成员变量/方法),只能在所属的类中直接使用
2.在其它类中无法直接使用(对象名.成员变量名)被private修饰的成员
出现新的问题:
其它类中不能直接访问被private修饰的成员,
但是其它类中可以间接访问被private修饰的成员
解决方案:
需要为被private修饰的成员变量提供set和get方法
set方法: 给成员变量赋值
三要素:
1.方法名称: set + 成员变量名称(第一个字母大写)
2.参数列表: 定义和成员变量相同类型的一个变量
3.返回值类型: void
注意:
可以在set方法内部添加逻辑判断,控制成员变量的取值范围
get方法: 获取成员变量的值
三要素:
1.方法名称: get + 成员变量名称(第一个字母大写)
2.参数列表: 没有参数
3.返回值类型: 要获取值的成员变量的类型
*/
public class Person02 {
//成员变量
String name;//姓名
private int age;//年龄
//成员方法
public void show() {
System.out.println("姓名: "+name+", 年龄: "+age);
}
//set成员方法,给成员变量赋值
public void setAge(int a) {
if (a > 0 && a <= 100) {
age = a;
}
}
//get成员方法,获取age的值
public int getAge() {
return age;
}
}
2.this关键字
/*
方法内部变量的访问规则
就近原则,方法内部有直接使用方法内部自己的,方法内部没有,找成员问题
局部变量和成员变量名称相同?
1.直接写变量名: 代表的是方法内部的局部变量
2.this.变量名:
代表的是成员变量
this代表谁?
哪个对象调用方法,该方法内部的this就代表那个调用方法的对象
谁调用我,我就代表谁
注意:
使用对象调用方法时,每个方法内部隐藏一个this关键字,用来接收调用该方法的对象的地址值,
如果需要使用this,你就直接用,不用就算了
*/
public class Person03 {
String name;//姓名
//打招呼
public void sayHello(String who) {
System.out.println("你好: "+who+", 我是 "+name);
}
//以上方法参数String who 不能做到见名知意
//把String who改成String name
//发现: 方法()中定义的局部变量和成员变量同名
//问题: 不能直接访问到成员变量的
public void sayHello2(String name) {
System.out.println("你好: "+name+", 我是 "+name);
}
//要在方法内部使用和局部变量同名的成员变量
//this.name: 成员变量name
public void sayHello3(String name) {
System.out.println("sayHello3....this..."+this);
System.out.println("你好: "+name+", 我是 "+this.name);
}
}
3.构造方法发
/*
创建对象的格式:
类名 对象名 = new 类名();
Student stu = new Student();
创建对象的过程: new + 调用构造方法
构造方法:
1.作用: 当使用new关键字创建对象以后,通过调用构造方法,完成对象成员的初始化
2.格式:
修饰符 类名(参数列表...) {
方法体;
return ;
}
3.特点:
(1)修饰符中没有static
(2)没有返回值类型,连void都没有
(3)构造方法名称和类名保持一模一样
(4)return ; 可以省略
4.注意:
(1)自定义类时,如果一个构造方法都不写,
编译器默认隐藏提供一个空参构造,里面什么都不做,我们看不见
(2)构造方法也是一种方法,就可以重载(方法名称相同,参数列表不同)
(3)自定义类时,只要自己定义了构造方法,编译器,将不再提供空参构造
--建议:自定义类建议手动添加空参构造方法
*/
public class Demo05Constructor {
public static void main(String[] args) {
//创建Person05类的对象: 空参构造创建对象
//对象的成员都是默认值
Person05 p = new Person05();
//调用set方法给成员变量赋值
p.setName("张三");
p.setAge(18);
//调用成员方法
p.show();
System.out.println("--------------");
//创建Person05类的对象: 满参构造创建对象
//对象创建完毕后,会立刻使用构造方法的参数,
//对对象的成员变量进行初始化
//name的值: "李四"
//age的值: 28
Person05 p2 = new Person05("李四",28);
//调用成员方法
p2.show();
}
}
public class Person05 {
private String name;//姓名
private int age;//年龄
//空参构造
public Person05() {
System.out.println("空参构造被调用了....");
//return ;//可以省略
}
//满参/全参构造
public Person05(String name, int age) {
this.name = name;
this.age = age;
}
//只给name赋值的构造方法
public Person05(String name) {
this.name = name;
}
//只给age赋值的构造方法
public Person05(int age) {
this.age = age;
}
//展示信息
public void show() {
System.out.println("姓名: "+name+", 年龄: "+age);
}
//get 和 set方法
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;
}
}
4.String类的介绍
/*
java.lang.String类: 代表字符串
1.API文档中的描述:
String 类代表字符串。Java 程序中的所有字符串字面值（常量: 如 "abc" ）都作为此类的实例实现(对象)。
字符串是常量；它们的值在创建之后不能更改(但凡是你感觉它要变化的时候,其实都是产生了一个新的字符串)。
因为字符串很常用,所以所有使用双引号""引起来的内容,都作为字符串String类的对象
2.特点:
(1)字符串不变：字符串的值在创建后不能被更改。
String s1 = "abc";
s1 += "d";//s1 = s1 + "d"; //s1 = "abcd"
System.out.println(s1); // "abcd"
// 内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。
(2)因为String对象是不可变的，所以它们可以被共享。
String s1 = "abcde";
String s2 = "abcde";
//内存中只有一个"abcde"对象被创建，同时被s1和s2共享。
(3) "abc" 等效于 char[] data = { 'a' , 'b' , 'c' }
jdk8及以前版本,String内部使用的是字符数组
查看源代码:
ctrl + n --> 输入类名 --> 回车
*/
public class Demo08String {
}
5.创建字符串对象两种方式的区别
/*
创建字符串对象两种方式的区别
1.使用new关键字创建字符串对象: 只要new就会在堆内存中开辟空间
2.使用""写的字符串常量的形式: 字符串常量在常量池中
==的使用:
1.基本类型: 比较的是变量中具体的数据是否相同
2.引用类型: 比较的地址值是否相同
如果想比较字符串的内容,需要使用equals方法
public boolean equals(Object obj): 判断调用equals方法的字符串和参数字符串的内容是否一模一样(区分大小写的)
比如:
s1.equals(s2): 比较字符串s1和s2的内容是否相同,如果相同返回true,如果不相同返回false
new String(chs):
最终是一个"abc"一个字符串,首先检查常量池中是否具有该字符串"abc"
如果没有,在常量池中创建一个字符串"abc",然后堆内存空间中保存的常量池中"abc"的地址值
如果有,不会在常量池中重新创建一个字符串"abc",直接在堆内存空间中保存的常量池中"abc"的地址值
*/
public class Demo10Diff {
public static void main(String[] args) {
char[] chs = {
'a','b','c'};
String s1 = new String(chs);//"abc"
String s2 = new String(chs);
String s3 = "abc";
String s4 = "abc";
System.out.println(s1 == s2);//false
System.out.println(s1 == s3);//false
System.out.println(s3 == s4);//true
System.out.println("-------------------------");
System.out.println(s1.equals(s2));//true
System.out.println(s1.equals(s3));//true
System.out.println(s3.equals(s4));//true
}
}
十三.day13内容
1.String类的常用方法
String类的成员方法:
1.public boolean equals(Object obj):
将此字符串(调用方法的字符串)与指定对象(方法参数指定的字符串)进行比较,
如果内容一模一样,返回true,否则,返回false(区分大小的)
举例:
s1.equals(s2): 比较s1和s2这两个字符串的内容,
是否一模一样,如果一样,返回true,如果不一样,返回false
2.public boolean equalsIgnoreCase(String str):
将此字符串(调用方法的字符串)与指定对象(方法参数指定的字符串)进行比较,
忽略大小写后,内容一样返回true,内容不一样返回false
举例:
s1.equalsIgnoreCase(s2): 比较s1和s2这两个字符串的内容,
忽略大小写后是否一模一样,如果一样,返回true,如果不一样,返回false
3.public int length(): 返回此字符串的长度(字符串中包含的字符的数量)。
比如:
s1.length(): 获取字符串s1中的字符数量
注意:
数组的长度使用length属性,用的时候后面不写()
4.String类的底层采用的是字符数组,而数组有索引,索引从0开始,到数组长度-1
所以字符串中的每个字符也有索引,从0开始,到字符串的长度-1
比如:
"abcd": 'a'--> 索引是0 'b'--> 索引是1 'c'--> 索引是2 'd'--> 索引是3
public char charAt(int index):获取调用方法的字符串中索引编号为index处对应的字符
==:
1.基本类型: 比较的是变量中的具体数据值是否相同
2.引用类型:
比较的是地址值是否相同,只要new地址值就是不相同的
2.用户登录案例
/*
String类的练习-用户登录案例
需求
已知用户名和密码，请用程序实现模拟用户登录。
总共给三次机会，登录之后，给出相应的提示
(1)用户名和密码都相同: 提示 "登录成功"
(2)用户名和密码有不相同: 提示 "登录失败",还要提示剩余xx次机会
实现步骤:
1.定义两个String变量rUsername和rPassword,表示已经注册的用户名和密码,并分别初始化
2.创建键盘录入Scanner对象
3.循环次数(总共可以登录3次)确定,所以使用for循环
3.1获取键盘录入的用户名和密码,分别保存在String变量inUsername和inPassword中
3.2 判断 如果用户输入的用户名inUsername和已经注册的用户名rUsername相同 并且
用户输入的密码inPassword和已经注册的密码rPassword也相同
3.3 提示 "登录成功" 结束for循环
3.4 否则(要么用户名不相同,要么密码不相同) 提示 "登录失败","剩余登录次数"
*/
public class Demo03StringLogin {
public static void main(String[] args) {
//1.定义两个String变量rUsername和rPassword,表示已经注册的用户名和密码,并分别初始化
String rUsername = "admin";
String rPassword = "123";
//2.创建键盘录入Scanner对象
Scanner sc = new Scanner(System.in);
//3.循环次数(总共可以登录3次)确定,所以使用for循环
for (int times = 1; times <= 3; times++) {
//3.1获取键盘录入的用户名和密码,分别保存在String变量inUsername和inPassword中
System.out.println("请输入用户名: ");
String inUsername = sc.nextLine();
System.out.println("请输入密码: ");
String inPassword = sc.nextLine();
//3.2 判断 如果用户输入的用户名inUsername和已经注册的用户名rUsername相同 并且
//用户输入的密码inPassword和已经注册的密码rPassword也相同
if (inUsername.equals(rUsername) && inPassword.equals(rPassword)) {
System.out.println("登录成功~~~~");
break;//结束循环
} else {
//3.4 否则(要么用户名不相同,要么密码不相同,要么用户名和密码都不相同)
//提示 "登录失败","剩余登录次数"
System.out.println("用户名或者密码有误,登录失败~~~");
if (times == 3) {
System.out.println("您的登录次数3次已经用完...");
} else {
System.out.println("您还剩余: "+(3-times)+" 次登录机会,请珍惜~~~~");
}
}
}
}
}
3.String类的练习-统计字符次数
/*
String类的练习-统计字符次数
需求
键盘录入一个字符串，统计该字符串中大写字母，小写字母，数字字符以及其它字符出现的次数
实现步骤:
1.创建键盘录入Scanner对象
2.获取键盘录入的字符串,保存到String变量str中
3.定义四个int类型的变量,初始化值分别为0,用来统计不同类型的字符的个数
int bigCount = 0;//统计大写字母的数量
int smallCount = 0;//统计小写字母的数量
int numCount = 0;//统计数字字符的数量
int otherCount = 0;//统计其它字符的数量
4.使用for循环遍历字符串
4.1 获取当前索引对应的字符,保存到char类型的变量ch中
4.2 判断 如果 ch中是大写字母(ch>= 'A' && ch<='Z'): bigCount++
4.3 判断 如果 ch中是小写字母(ch>= 'a' && ch<='z'): smallCount++
4.4 判断 如果 ch中是数字字符(ch>= '0' && ch<='9'): numCount++
4.5 否则(其它字符): otherCount++
5.for循环结束,打印四个计数器的值
*/
public class Demo06StringCount {
public static void main(String[] args) {
//1.创建键盘录入Scanner对象
Scanner sc = new Scanner(System.in);
//2.获取键盘录入的字符串,保存到String变量str中
System.out.println("请输入一个字符串: ");
String str = sc.nextLine();
//3.定义四个int类型的变量,初始化值分别为0,用来统计不同类型的字符的个数
int bigCount = 0;//统计大写字母的数量
int smallCount = 0;//统计小写字母的数量
int numCount = 0;//统计数字字符的数量
int otherCount = 0;//统计其它字符的数量
//4.使用for循环遍历字符串
for (int i = 0; i < str.length(); i++) {
//4.1 获取当前索引对应的字符,保存到char类型的变量ch中
char ch = str.charAt(i);
if (ch >= 'A' && ch <= 'Z') {
//4.2 判断 如果 ch中是大写字母(ch>= 'A' && ch<='Z'): bigCount++
bigCount++;
} else if (ch >= 'a' && ch <= 'z') {
//4.3 判断 如果 ch中是小写字母(ch>= 'a' && ch<='z'): smallCount++
smallCount++;
} else if (ch >= '0' && ch <= '9') {
//4.4 判断 如果 ch中是数字字符(ch>= '0' && ch<='9'): numCount++
numCount++;
} else {
//4.5 否则(其它字符): otherCount++
otherCount++;
}
}
//5.for循环结束,打印四个计数器的值
System.out.println("字符串"+str+"中大写字母数量:"+bigCount+"个");
System.out.println("字符串"+str+"中小写字母数量:"+smallCount+"个");
System.out.println("字符串"+str+"中数字字符数量:"+numCount+"个");
System.out.println("字符串"+str+"中其它字符数量:"+otherCount+"个");
}
}
4.String和StringBuilder类的区别
1.StringBuilder中的内容是可以改变的
2.String中的内容是不可以改变的
3.StringBuilder内部提供了反转的方法,而String没有
4.StringBuilder进行大量字符串的拼接时,效率高
/*
java.lang.StringBuilder类: 代表字符串缓冲区,支持可以改变的字符串
底层: 是一个默认长度为16的字符数组
构造方法:
public StringBuilder() ：构造一个空的StringBuilder容器,内部是一个长度为16的字符数组
public StringBuilder(String str) ：把构造方法参数String对象str,转换成为StringBuilder对象
打印引用变量,默认调用toString方法
StringBuilder和String的区别?
1.StringBuilder中的内容是可以改变的
2.String中的内容是不可以改变的
3.StringBuilder内部提供了反转的方法,而String没有
4.StringBuilder进行大量字符串的拼接时,效率高
*/
public class Demo05StringBuilder {
public static void main(String[] args) {
//public StringBuilder() ：构造一个空的StringBuilder容器,内部是一个长度为16的字符数组
StringBuilder sb = new StringBuilder();
System.out.println(sb);
/*String s = sb.toString();
System.out.println("hello"+s+"world");//helloworld*/
System.out.println(sb.toString());
//public StringBuilder(String str) ：把构造方法参数String对象str,转换成为StringBuilder对象
StringBuilder sb2 = new StringBuilder("HelloWorld");
System.out.println(sb2);
System.out.println(sb2.toString());
}
}
5.StringBuilder的常用方法
/*
StringBuilder的常用方法
public StringBuilder append(...) ：添加任意类型数据的字符串形式，并返回当前对象自身。做原样添加
public StringBuilder reverse() ：返回反转的字符序列
public String toString()：将当前StringBuilder对象转换为String对象。
*/
public class Demo06StringBuilder {
public static void main(String[] args) {
//创建StringBuilder对象
StringBuilder sb = new StringBuilder();
sb.append(97);
sb.append('a');
sb.append("hello");
sb.append(true);
System.out.println(sb.toString());//97ahellotrue
//public StringBuilder reverse()：返回反转的字符序列
sb.reverse();
System.out.println(sb.toString());//toString方法可以省略
//public String toString() ：将当前StringBuilder对象转换为String对象。
String str = sb.toString();
System.out.println(str);
}
}
6.StringBuilder的链式调用
/*
StringBuilder类的append方法,reverse方法有返回值,返回的就是当前调用方法的StringBuilder对象
StringBuilder支持链式编程
前提: 对象调用方法后,方法返回调用方法的对象本身
*/
public class Demo07StringBuilder {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("A");
StringBuilder sb2 = sb.append("B");
StringBuilder sb3 = sb2.append("C");
System.out.println(sb);//ABC
System.out.println(sb2);//ABC
System.out.println(sb3);//ABC
//发现结果都是true
//那么sb,sb2,sb3指向的是同一个StringBuilder对象
System.out.println(sb == sb2);//true
System.out.println(sb == sb3);//true
System.out.println(sb2 == sb3);//true
System.out.println("------------------");
StringBuilder sb4 = new StringBuilder();
sb4.append("hello").append(97).append('a').append(false).append(8.8);
System.out.println(sb4);//hello97afalse8.8
}
}
7.String和StringBuilder的相互转换
/*
StringBuilder和String相互转换
1.String --> StringBuilder
构造方法:
public StringBuilder(String str): 把构造方法String参数str,转换成StringBuilder对象
构造方法:
public StringBuilder(): 创建一个空的StringBuilder对象
再调用append()方法
2.StringBuilder --> String
成员方法:
public String toString(): 把调用toString方法的StringBuilder对象,转换成String对象
*/
public class Demo08StringBuilder {
public static void main(String[] args) {
//StringBuilder sb = "hello";//左右类型不匹配,错误的
//public StringBuilder(String str): 把构造方法String参数str,转换成StringBuilder对象
StringBuilder sb = new StringBuilder("hello");
//public StringBuilder(): 创建一个空的StringBuilder对象
StringBuilder sb2 = new StringBuilder();
//再调用append()方法
sb2.append("hello");
//public String toString(): 把调用toString方法的StringBuilder对象,转换成String对象
String s1 = sb.toString();
String s2 = sb2.toString();
System.out.println(s1);
System.out.println(s2);
}
}
十四.day14内容
1.数组和ArrayList的区别
1.数组长度不可变,集合长度可变
2.数组中可以存储任意类型数据,集合只能存储引用类型,如果存储基本类型,<>中需要写出对用的引用类型
3.数组只提供length属性,没有提供相关方法,而集合提供了大量的方法
2.ArrayList集合介绍
/*
java.util.ArrayList类:
是大小可变的数组的实现，存储在内的数据称为元素。
此类提供一些方法来操作内部存储的元素。
ArrayList 中可不断添加元素，其大小也自动增长。
注意:
1.ArrayList集合内部使用数组实现: Object[] 任意引用类型数据都可以存储到ArrayList集合内部
2.空参构造创建ArrayList集合,内部默认的数组长度是10
3.因为数组有索引,所以添加到ArrayList集合内部的元素也有索引,从0开始最大值是长度-1
4.当向ArrayList集合内部添加元素时,集合内部的数组会不断的扩容,创建新数组,把老数组的内容拷贝到新数组中,
我们可以继续向新数组中添加元素,但是至于说如何扩容的,如何拷贝数组的,我们不用关心,我们唯一要做的事情,
把数据添加到集合当中,而且还要可以从集合中获取/修改/删除元素,就OK
使用步骤:
1.导包
java.lang包下的内容不用导包
当前类和要使用的类,处于同一个包下,不用导包
import java.util.ArrayList;
2.创建对象
类名 对象名 = new 类名(...);
举例:
对象数组的创建:
Student[] stus = new Student[3];
[]: 代表的是数组
Student: 代表的是数组中存储的数据的类型(可以向数组中存储什么类型的数据)
java.util.ArrayList类:
ArrayList是集合的名字(用的到底是哪个集合),表示ArrayList集合容器中可以存储的数据的类型
举例: 创建一个ArrayList集合容器对象list,存储数据的类型String
ArrayList list = new ArrayList();
ArrayList list = new ArrayList<>();//右边<>中的内容可以省略,但是<>要保留
3.成员方法
public boolean add(E e) ： 将方法参数e添加到调用方法的集合容器的末尾处
返回值类型:
boolean: 表示是否添加成功,对于ArrayList而言永远返回true
4.注意:
(1)打印引用变量默认调用toString方法
(2)打印ArrayList集合对象默认调用toString方法,打印出ArrayList集合的内容
*/
public class Demo02ArrayList {
public static void main(String[] args) {
//创建一个ArrayList集合容器对象list2,存储数据的类型Student
//ArrayList list2 = new ArrayList<>();
//创建一个ArrayList集合容器对象list,存储数据的类型String
ArrayList<String> list = new ArrayList<String>();
System.out.println(list);//[]
System.out.println(list.toString());//[]
//public boolean add(E e) ： 将方法参数e添加到调用方法的集合容器的末尾处
list.add("aaa");//把字符串"aaa"添加到集合对象list的索引为0的元素中
System.out.println(list);//[aaa]
list.add("bbb");//把字符串"bbb"添加到集合对象list的索引为1的元素中
System.out.println(list);//[aaa, bbb]
list.add("ccc");//把字符串"ccc"添加到集合对象list的索引为2的元素中
list.add("dddd");//把字符串"ddd"添加到集合对象list的索引为3的元素中
System.out.println(list);//[aaa, bbb, ccc, dddd]
}
}
3.ArrayList集合常用方法
/*
ArrayList集合常用方法
对于元素的操作,基本体现就是增、删、改、查。
public boolean add(E e) ：将指定的元素e添加到此集合(调用方法的集合)的尾部。
public void add(int index,E element) ：在此集合中的指定位置插入指定的元素。
public boolean remove(Object o) ：删除指定的元素，返回删除是否成功
注意: 只删除第一个元素
public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
public E set(int index,E element) ：修改指定索引处的元素，返回被修改的元素。
public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。
public void clear(): 清空集合内容
注意:
add: 添加
remove: 删除 没有delete方法
get: 获取
set: 修改
数组长度: length属性
字符串长度: length()方法
集合长度(元素的个数): size()方法
*/
public class Demo03ArrayListMethods {
public static void main(String[] args) {
//创建一个ArrayList集合容器对象list,存储数据的类型String
ArrayList<String> list = new ArrayList<>();
//public boolean add(E e) ：将指定的元素e添加到此集合(调用方法的集合)的尾部。
list.add("aaa");
list.add("ccc");
System.out.println(list);//[aaa, ccc]: aaa在集合中的索引编号是0,ccc在集合中的索引编号是1
//public void add(int index,E element) ：在此集合中的指定位置插入指定的元素
//在ccc前面添加bbb
list.add(1,"bbb");
System.out.println(list);//[aaa, bbb, ccc]: aaa索引编号是0,bbb索引编号是1,ccc索引编号是2
list.add("ddd");
System.out.println(list);//[aaa, bbb, ccc, ddd]
System.out.println("集合中元素的数量: "+list.size());//4
//list.add("bbb");
//System.out.println(list);
//删除bbb
//public boolean remove(Object o) ：删除指定的元素，返回删除是否成功
boolean result = list.remove("bbb");
System.out.println("删除bbb是否成功? "+result);//true
System.out.println("删除bbb后集合内容: "+list);//[aaa, ccc, ddd]:aaa索引编号是0,ccc索引编号是1,ddd索引编号是2
//删除索引为1的元素
//public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
String whoRemoved = list.remove(1);
System.out.println("谁被删除了呢? "+whoRemoved);//ccc
System.out.println("删除索引1的元素后集合内容: "+list);//[aaa, ddd]:aaa索引编号是0,ddd索引编号是1
//public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
//获取aaa
String s = list.get(0);
System.out.println("索引0对应的元素:"+s);//aaa
//获取ddd
String s2 = list.get(1);
System.out.println("索引1对应的元素:"+s2);//ddd
System.out.println("获取0和1索引元素后集合内容: "+list);//[aaa, ddd]:aaa索引编号是0,ddd索引编号是1
//public E set(int index,E element) ：修改指定索引处的元素，返回被修改的元素。
//把aaa变成a
String whoUpdate = list.set(0, "a");
System.out.println("谁被修改了呢?"+whoUpdate);//aaa
System.out.println("修改索引0对应的元素后,集合内容: "+list);//[a, ddd]
//把ddd变成d
whoUpdate = list.set(1,"d");
System.out.println("谁被修改了呢?"+whoUpdate);//aaa
System.out.println("修改索引1对应的元素后,集合内容: "+list);//[a, d]: a索引编号是0,d索引编号是1
System.out.println("集合中元素的数量: "+list.size());//2
list.clear();//清空集合元素
System.out.println("集合中元素的数量: "+list.size());//0
System.out.println(list);//[]
}
}
4.ArrayList集合存储基本类型
/*
ArrayList集合_存储基本数据类型
ArrayList集合容器中存储基本类型数据时,创建ArrayList集合对象时,<>中必须写基本类型对应的引用类型
说白了,就是基本类型对应的类
byte Byte
short Short
int Integer 特殊记忆
long Long
float Float
double Double
char Character 特殊记忆
boolean Boolean
注意:
集合存储基本类型,只需要在创建集合对象时,<>中写出基本类型对应的引用类型
其它操作,都可以按照基本类型完成
*/
public class Demo05ArrayListBase {
public static void main(String[] args) {
//创建ArrayList集合对象,存储数据的类型是整数(byte/short/int/long)
//ArrayList list = new ArrayList();
//ArrayList list = new ArrayList();
//ArrayList list = new ArrayList();
//ArrayList list = new ArrayList();
//创建ArrayList集合对象,存储数据的类型是整数(int)
//ArrayList list = new ArrayList();//错误,<>中要写引用类型,int对应的引用类型Integer
ArrayList<Integer> list = new ArrayList<>();
//添加元素
list.add(100);
list.add(200);
list.add(300);
//遍历
for (int i = 0; i < list.size(); i++) {
//获取当前元素
int num = list.get(i);
System.out.println(num);
}
}
}
5.ArrayList集合作为方法参数
/*
ArrayList集合作为方法参数
ArrayList集合作为方法参数: 传递的是地址值
*/
public class Demo04ParamArrayList {
public static void main(String[] args) {
//1.创建ArrayList集合对象,存储数据的类型Person
ArrayList<Person> list = new ArrayList<>();
//2.创建2个Person对象
Person p1 = new Person("张三");
Person p2 = new Person("李四");
//3.把Person对象添加到ArrayList集合内部
list.add(p1);
list.add(p2);
//4.调用方法完成遍历
printArrayList(list);
}
//定义方法,遍历存储Person对象的ArrayList集合对象
public static void printArrayList(ArrayList<Person> list) {
//for循环遍历ArrayList集合
for (int i = 0; i < list.size(); i++) {
Person p = list.get(i);
System.out.println(p.getName());
}
}
}
6.ArrayList集合作为方法返回值
/*
ArrayList集合作为方法参数
ArrayList集合作为方法返回值: 返回的是集合的地址值
*/
public class Demo05ReturnArrayList {
public static void main(String[] args) {
//调用方法,获取存储多个Person对象的ArrayList集合对象
ArrayList<Person> list = getArrayList();
//遍历集合
for (int i = 0; i < list.size(); i++) {
Person p = list.get(i);
System.out.println(p.getName());
}
}
//定义方法getArrayList,获取一个存储多个Person对象的ArrayList集合对象
public static ArrayList<Person> getArrayList() {
//1.创建ArrayList集合对象,存储数据的类型Person
ArrayList<Person> list = new ArrayList<>();
//2.创建2个Person对象
Person p1 = new Person("张三");
Person p2 = new Person("李四");
//3.把Person对象添加到ArrayList集合内部
list.add(p1);
list.add(p2);
//4.返回ArrayList集合对象
return list;
}
}
System.out.println("删除bbb后集合内容: "+list);//[aaa, ccc, ddd]:aaa索引编号是0,ccc索引编号是1,ddd索引编号是2
//删除索引为1的元素
//public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
String whoRemoved = list.remove(1);
System.out.println("谁被删除了呢? "+whoRemoved);//ccc
System.out.println("删除索引1的元素后集合内容: "+list);//[aaa, ddd]:aaa索引编号是0,ddd索引编号是1
//public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
//获取aaa
String s = list.get(0);
System.out.println("索引0对应的元素:"+s);//aaa
//获取ddd
String s2 = list.get(1);
System.out.println("索引1对应的元素:"+s2);//ddd
System.out.println("获取0和1索引元素后集合内容: "+list);//[aaa, ddd]:aaa索引编号是0,ddd索引编号是1
//public E set(int index,E element) ：修改指定索引处的元素，返回被修改的元素。
//把aaa变成a
String whoUpdate = list.set(0, "a");
System.out.println("谁被修改了呢?"+whoUpdate);//aaa
System.out.println("修改索引0对应的元素后,集合内容: "+list);//[a, ddd]
//把ddd变成d
whoUpdate = list.set(1,"d");
System.out.println("谁被修改了呢?"+whoUpdate);//aaa
System.out.println("修改索引1对应的元素后,集合内容: "+list);//[a, d]: a索引编号是0,d索引编号是1
System.out.println("集合中元素的数量: "+list.size());//2
list.clear();//清空集合元素
System.out.println("集合中元素的数量: "+list.size());//0
System.out.println(list);//[]
}
}
### 4.ArrayList集合存储基本类型
```java
/*
ArrayList集合_存储基本数据类型
ArrayList集合容器中存储基本类型数据时,创建ArrayList集合对象时,<>中必须写基本类型对应的引用类型
说白了,就是基本类型对应的类
byte Byte
short Short
int Integer 特殊记忆
long Long
float Float
double Double
char Character 特殊记忆
boolean Boolean
注意:
集合存储基本类型,只需要在创建集合对象时,<>中写出基本类型对应的引用类型
其它操作,都可以按照基本类型完成
*/
public class Demo05ArrayListBase {
public static void main(String[] args) {
//创建ArrayList集合对象,存储数据的类型是整数(byte/short/int/long)
//ArrayList list = new ArrayList();
//ArrayList list = new ArrayList();
//ArrayList list = new ArrayList();
//ArrayList list = new ArrayList();
//创建ArrayList集合对象,存储数据的类型是整数(int)
//ArrayList list = new ArrayList();//错误,<>中要写引用类型,int对应的引用类型Integer
ArrayList list = new ArrayList<>();
//添加元素
list.add(100);
list.add(200);
list.add(300);
//遍历
for (int i = 0; i < list.size(); i++) {
//获取当前元素
int num = list.get(i);
System.out.println(num);
}
}
}
5.ArrayList集合作为方法参数
/*
ArrayList集合作为方法参数
ArrayList集合作为方法参数: 传递的是地址值
*/
public class Demo04ParamArrayList {
public static void main(String[] args) {
//1.创建ArrayList集合对象,存储数据的类型Person
ArrayList<Person> list = new ArrayList<>();
//2.创建2个Person对象
Person p1 = new Person("张三");
Person p2 = new Person("李四");
//3.把Person对象添加到ArrayList集合内部
list.add(p1);
list.add(p2);
//4.调用方法完成遍历
printArrayList(list);
}
//定义方法,遍历存储Person对象的ArrayList集合对象
public static void printArrayList(ArrayList<Person> list) {
//for循环遍历ArrayList集合
for (int i = 0; i < list.size(); i++) {
Person p = list.get(i);
System.out.println(p.getName());
}
}
}
6.ArrayList集合作为方法返回值
/*
ArrayList集合作为方法参数
ArrayList集合作为方法返回值: 返回的是集合的地址值
*/
public class Demo05ReturnArrayList {
public static void main(String[] args) {
//调用方法,获取存储多个Person对象的ArrayList集合对象
ArrayList<Person> list = getArrayList();
//遍历集合
for (int i = 0; i < list.size(); i++) {
Person p = list.get(i);
System.out.println(p.getName());
}
}
//定义方法getArrayList,获取一个存储多个Person对象的ArrayList集合对象
public static ArrayList<Person> getArrayList() {
//1.创建ArrayList集合对象,存储数据的类型Person
ArrayList<Person> list = new ArrayList<>();
//2.创建2个Person对象
Person p1 = new Person("张三");
Person p2 = new Person("李四");
//3.把Person对象添加到ArrayList集合内部
list.add(p1);
list.add(p2);
//4.返回ArrayList集合对象
return list;
}
}