5. 方法的注意事项
5.1 方法的注意事项
-
方法不能嵌套定义
-
示例代码:
public class MethodDemo { public static void main(String[] args) { } public static void methodOne() { public static void methodTwo() { // 这里会引发编译错误!!! } } }
-
-
void表示无返回值,可以省略return,也可以单独的书写return,后面不加数据
-
示例代码:
public class MethodDemo { public static void main(String[] args) { } public static void methodTwo() { //return 100; 编译错误,因为没有具体返回值类型 return; //System.out.println(100); return语句后面不能跟数据或代码 } }
-
5.2 方法的通用格式
-
格式:
public static 返回值类型 方法名(参数) { 方法体; return 数据 ; }
-
解释:
-
public static 修饰符,目前先记住这个格式
返回值类型 方法操作完毕之后返回的数据的数据类型
如果方法操作完毕,没有数据返回,这里写void,而且方法体中一般不写return
方法名 调用方法时候使用的标识
参数 由数据类型和变量名组成,多个参数之间用逗号隔开
方法体 完成功能的代码块
return 如果方法操作完毕,有数据返回,用于把数据返回给调用者
-
-
定义方法时,要做到两个明确
- 明确返回值类型:主要是明确方法操作完毕之后是否有数据返回,如果没有,写void;如果有,写对应的数据类型
- 明确参数:主要是明确参数的类型和数量
-
调用方法时的注意:
- void类型的方法,直接调用即可
- 非void类型的方法,推荐用变量接收调用
6. 方法重载
6.1 方法重载
-
方法重载概念
方法重载指同一个类中定义的多个方法之间的关系,满足下列条件的多个方法相互构成重载
- 多个方法在同一个类中
- 多个方法具有相同的方法名
- 多个方法的参数不相同,类型不同或者数量不同
-
注意:
- 重载仅对应方法的定义,与方法的调用无关,调用方式参照标准格式
- 重载仅针对同一个类中方法的名称与参数进行识别,与返回值无关,换句话说不能通过返回值来判定两个方法是否相互构成重载
-
正确范例:
public class MethodDemo { public static void fn(int a) { //方法体 } public static int fn(double a) { //方法体 } } public class MethodDemo { public static float fn(int a) { //方法体 } public static int fn(int a , int b) { //方法体 } }
-
错误范例:
public class MethodDemo { public static void fn(int a) { //方法体 } public static int fn(int a) { /*错误原因:重载与返回值无关*/ //方法体 } } public class MethodDemo01 { public static void fn(int a) { //方法体 } } public class MethodDemo02 { public static int fn(double a) { /*错误原因:这是两个类的两个fn方法*/ //方法体 } }
6.2 方法重载练习
-
需求:使用方法重载的思想,设计比较两个整数是否相同的方法,兼容全整数类型(byte,short,int,long)
-
思路:
- ①定义比较两个数字的是否相同的方法compare()方法,参数选择两个int型参数
- ②定义对应的重载方法,变更对应的参数类型,参数变更为两个long型参数
- ③定义所有的重载方法,两个byte类型与两个short类型参数
- ④完成方法的调用,测试运行结果
-
代码:
public class MethodTest { public static void main(String[] args) { //调用方法 System.out.println(compare(10, 20)); System.out.println(compare((byte) 10, (byte) 20)); System.out.println(compare((short) 10, (short) 20)); System.out.println(compare(10L, 20L)); } //int public static boolean compare(int a, int b) { System.out.println("int"); return a == b; } //byte public static boolean compare(byte a, byte b) { System.out.println("byte"); return a == b; } //short public static boolean compare(short a, short b) { System.out.println("short"); return a == b; } //long public static boolean compare(long a, long b) { System.out.println("long"); return a == b; } }
7.3 数组遍历
-
需求:设计一个方法用于数组遍历,要求遍历的结果是在一行上的。例如:[11, 22, 33, 44, 55]
-
思路:
-
①因为要求结果在一行上输出,所以这里需要在学习一个新的输出语句System.out.print(“内容”);
System.out.println(“内容”); 输出内容并换行
System.out.print(“内容”); 输出内容不换行
System.out.println(); 起到换行的作用
-
②定义一个数组,用静态初始化完成数组元素初始化
-
③定义一个方法,用数组遍历通用格式对数组进行遍历
-
④用新的输出语句修改遍历操作
-
⑤调用遍历方法
-
-
代码:
public class Test1 { public static void main(String[] args) { /* //先打印数据,再进行换行 System.out.println("aaa"); //只打印不换行 System.out.print("bbb"); System.out.print("ddd"); //不打印任何内容,只换行 System.out.println(); System.out.print("cc");*/ //设计一个方法用于数组遍历,要求遍历的结果是在一行上的。例如:[11, 22, 33, 44, 55] int[] arr = {1,2,3,4,5}; printArr(arr); } //1.我要遍历数组 //2.需要什么? 数组 //3.调用处是否需要使用方法的结果。 public static void printArr(int[] arr){ System.out.print("["); for (int i = 0; i < arr.length; i++) { if(i == arr.length - 1){ System.out.println(arr[i] + "]"); }else{ System.out.print(arr[i] + ", "); } } } }
7.4 数组最大值
-
需求:设计一个方法用于获取数组中元素的最大值
-
思路:
- ①定义一个数组,用静态初始化完成数组元素初始化
- ②定义一个方法,用来获取数组中的最大值,最值的认知和讲解我们在数组中已经讲解过了
- ③调用获取最大值方法,用变量接收返回结果
- ④把结果输出在控制台
-
代码:
public class MethodTest02 { public static void main(String[] args) { //定义一个数组,用静态初始化完成数组元素初始化 int[] arr = {12, 45, 98, 73, 60}; //调用获取最大值方法,用变量接收返回结果 int number = getMax(arr); //把结果输出在控制台 System.out.println("number:" + number); } //定义一个方法,用来获取数组中的最大值 /* 两个明确: 返回值类型: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; } }
7.6 获取索引
需求:
定义一个方法获取数字,在数组中的索引位置,将结果返回给调用处,如果有重复的,只要获取第一个即可。
代码示例:
package com.itheima.demo;
public class Test4 {
public static void main(String[] args) {
//定义一个方法获取数字,在数组中的索引位置,将结果返回给调用处
//如果有重复的,只要获取第一个即可
int[] arr = {1,2,3,4,5};
int index = contains(arr, 3);
System.out.println(index);
}
//1. 我要干嘛?判断数组中的某一个数是否存在
//2. 需要什么?数组 数字
//3. 调用处是否需要继续使用?返回
//获取number在arr中的位置
public static int contains(int[] arr, int number) {
//遍历arr得到每一个元素
for (int i = 0; i < arr.length; i++) {
//拿着每一个元素跟number比较
if(arr[i] == number){
//如果相等,表示找到了
return i;
}
}
//当循环结束之后,如果还不能返回索引,表示数组中不存在该数据
//可以返回-1
return -1;
}
}
练习一:飞机票
需求:
机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。
按照如下规则计算机票价格:旺季(5-10月)头等舱9折,经济舱8.5折,淡季(11月到来年4月)头等舱7折,经济舱6.5折。
代码示例:
package com.itheima.test;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
/* 机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。
按照如下规则计算机票价格:旺季(5-10月)头等舱9折,经济舱8.5折,淡季(11月到来年4月)头等舱7折,经济舱6.5折。*/
//分析:
//1.键盘录入机票原价、月份、头等舱或经济舱
Scanner sc = new Scanner(System.in);
System.out.println("请输入机票的原价");
int ticket = sc.nextInt();
System.out.println("请输入当前的月份");
int month = sc.nextInt();
System.out.println("请输入当前购买的舱位 0 头等舱 1 经济舱");
int seat = sc.nextInt();
//2.先判断月份是旺季还是淡季
//ctrl + alt + M 自动抽取方法
if (month >= 5 && month <= 10) {
//旺季 //3.继续判断当前机票是经济舱还是头等舱
//ticket = getPrice(ticket, seat, 0.9, 0.85);
ticket = getTicket(ticket, seat, 0.9, 0.85);
} else if ((month >= 1 && month <= 4) || (month >= 11 && month <= 12)) {
//淡季
//ticket = getPrice(ticket, seat, 0.7, 0.65);
ticket = getTicket(ticket, seat, 0.7, 0.65);
} else {
//表示键盘录入的月份是一个非法数据
System.out.println("键盘录入的月份不合法");
}
System.out.println(ticket);
}
public static int getTicket(int ticket, int seat, double v, double v2) {
if (seat == 0) {
//头等舱
ticket = (int) (ticket * v);
} else if (seat == 1) {
//经济舱
ticket = (int) (ticket * v2);
} else {
System.out.println("没有这个舱位");
}
return ticket;
}
//1.我要干嘛?根据舱位和折扣来计算最终的票价
//2.我干这件事,需要什么才能完成?原价 舱位 头等舱的折扣 经济舱的折扣
//3.方法的调用处是否需要继续使用这个结果 需要
/* public static int getPrice(int ticket, int seat, double v0, double v1) {
if (seat == 0) {
//头等舱
ticket = (int) (ticket * v0);
} else if (seat == 1) {
//经济舱
ticket = (int) (ticket * v1);
} else {
System.out.println("没有这个舱位");
}
return ticket;
}*/
}
练习二:打印素数
判断101~200之间有多少个素数,并输出所有素数。
备注:素数就是质数
代码示例:
package com.itheima.test;
public class Test2 {
public static void main(String[] args) {
//判断 101 ~ 200 之间有多少个素数,并打印所有素数
//思路一: 2 ~ 99
//定义变量i ,赋值100
//判断i是否为质数
//定义一个变量用来统计有多少个质数
int count = 0;
//外循环:遍历101~200这个范围,依次得到这个范围之内的每一个数字
for (int i = 101; i <= 200; i++) {
//i 依次表示循环中的每一个数字
//继续判断i是否为一个质数
boolean flag = true;
//内循环:判断当前数字是否为一个质数。
for (int j = 2; j < i; j++) {
//j 表示2~99之间的每一个数字
if(i % j == 0){
flag = false;
//跳出单层循环,内循环
break;
}
}
if(flag){
System.out.println("当前数字"+i+"是质数");
count++;
}
}
System.out.println("一共有" + count + "个质数");
/* int i = 7;
boolean flag = true;
for (int j = 2; j < i; j++) {
//j 表示2~99之间的每一个数字
if(i % j == 0){
flag = false;
break;
}
}
if(flag){
System.out.println("当前数字是质数");
}else{
System.out.println("当前数字不是一个质数");
}*/
}
}
练习三:验证码
需求:
定义方法实现随机产生一个5位的验证码
验证码格式:
长度为5
前四位是大写字母或者小写字母
最后一位是数字
代码示例:
package com.itheima.test;
import java.util.Random;
public class Test3 {
public static void main(String[] args) {
/* 需求:
定义方法实现随机产生一个5位的验证码
验证码格式:
长度为5
前四位是大写字母或者小写字母
最后一位是数字
*/
//方法:
//在以后如果我们要在一堆没有什么规律的数据中随机抽取
//可以先把这些数据放到数组当中
//再随机抽取一个索引
//分析:
//1.大写字母和小写字母都放到数组当中
char[] chs = new char[52];
for (int i = 0; i < chs.length; i++) {
//ASCII码表
if(i <= 25){
//添加小写字母
chs[i] = (char)(97 + i);
}else{//27
//添加大写字母
// A --- 65
chs[i] = (char)(65 + i - 26);
}
}
//定义一个字符串类型的变量,用来记录最终的结果
String result = "";
//2.随机抽取4次
//随机抽取数组中的索引
Random r = new Random();
for (int i = 0; i < 4; i++) {
int randomIndex = r.nextInt(chs.length);
//利用随机索引,获取对应的元素
//System.out.println(chs[randomIndex]);
result = result + chs[randomIndex];
}
//System.out.println(result);
//3.随机抽取一个数字0~9
int number = r.nextInt(10);
//生成最终的结果
result = result + number;
//打印最终结果
System.out.println(result);
}
}
练习四:复制数组
需求:
把一个数组中的元素复制到另一个新数组中去。
代码示例:
package com.itheima.test;
public class Test4 {
public static void main(String[] args) {
/* 需求:
把一个数组中的元素复制到另一个新数组中去。*/
//分析:
//1.定义一个老数组并存储一些元素
int[] arr = {1,2,3,4,5};
//2.定义一个新数组的长度跟老数组一致
int[] newArr = new int[arr.length];
//3.遍历老数组,得到老数组中的每一个元素,依次存入到新数组当中
for (int i = 0; i < arr.length; i++) {
//i 表示老数组中的索引。新数组中的每一个索引
//arr[i] 表示老数组中的元素
newArr[i] = arr[i];
}
//4.新数组中已经存满元素了
for (int i = 0; i < newArr.length; i++) {
System.out.println(newArr[i]);
}
}
}
练习五:评委打分
需求 :
在唱歌比赛中,有6名评委给选手打分,分数范围是[0 - 100]之间的整数。选手的最后得分为:去掉最高分、最低分后的4个评委的平均分,请完成上述过程并计算出选手的得分。
代码示例:
package com.itheima.test;
import java.util.Scanner;
public class Test5 {
public static void main(String[] args) {
//在唱歌比赛中,有6名评委给选手打分,分数范围是[0 - 100]之间的整数。
// 选手的最后得分为:去掉最高分、最低分后的4个评委的平均分,请完成上述过程并计算出选手的得分。
//分析:
//1.定义一个数组,用来存储6名评委的打分(0~100)
int[] scoreArr = getScores();
for (int i = 0; i < scoreArr.length; i++) {
System.out.println(scoreArr[i]);
}
//2.求出数组中的最大值
int max = getMax(scoreArr);
//3.求出数组中的最小值
int min = getMin(scoreArr);
//4.求出数组中6个分数的总和
int sum = getSum(scoreArr);
//5.(总和 - 最大值 - 最小值 )/4
int avg = (sum - max - min)/(scoreArr.length - 2);
//6.打印结果
System.out.println("选手的最终得分为:" + avg);
}
public static int getSum(int[] scoreArr){
int sum = 0;
for (int i = 0; i < scoreArr.length; i++) {
sum = sum + scoreArr[i];
}
return sum;
}
//求数组的最大值
public static int getMax(int[] scoreArr){
int max = scoreArr[0];
for (int i = 1; i < scoreArr.length; i++) {
if(scoreArr[i] > max){
max = scoreArr[i];
}
}
return max;
}
//求数组的最小值
public static int getMin(int[] scoreArr){
int min = scoreArr[0];
for (int i = 1; i < scoreArr.length; i++) {
if(scoreArr[i] < min){
min = scoreArr[i];
}
}
return min;
}
//1.我要干嘛?定义一个数组,用来存储6名评委的打分(0~100)
//2.我需要什么?都不需要
//3.干完了这件事情,是否需要返回?必须返回
public static int[] getScores(){
//定义数组
int[] scores = new int[6];
//使用键盘录入的形式,输入分数:0~100
Scanner sc = new Scanner(System.in);
for (int i = 0; i < scores.length; ) {
System.out.println("请输入评委的打分");
int score = sc.nextInt();//100
if(score >=0 && score<= 100){
scores[i] = score;
i++;
}else{
System.out.println("成绩超出了范围,继续录入,当前的i为:" + i);
}
}
return scores;
}
}
练习六:数字加密
需求:
某系统的数字密码(大于0),比如1983,采用加密方式进行传输。
规则如下:
先得到每位数,然后每位数都加上5 , 再对10求余,最后将所有数字反转,得到一串新数。
举例:
1 9 8 3
+5 6 14 13 8
%10 6 4 3 8
反转 8 3 4 6
加密后的结果就是:8346
代码示例:
package com.itheima.test;
public class Test6 {
public static void main(String[] args) {
/*
某系统的数字密码(大于0)。比如1983,采用加密方式进行传输,
规则如下:
每位数加上5
再对10求余,
最后将所有数字反转,
得到一串新数。
*/
//分析:
//1.把整数里面的每一位放到数组当中
int[] arr = {1, 9, 8, 3};
//2.加密
//每位数加上5
for (int i = 0; i < arr.length; i++) {
arr[i] = arr[i] + 5;
}
//再对10求余,
for (int i = 0; i < arr.length; i++) {
arr[i] = arr[i] % 10;
}
//将所有数字反转
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//8 3 4 6 --> 8346
//3.把数组里面的每一个数字进行拼接,变成加密之后的结果
int number = 0;
for (int i = 0; i < arr.length; i++) {
number = number * 10 + arr[i];
}
System.out.println(number);
}
}
练习六扩展:
package com.itheima.test;
public class Test7 {
public static void main(String[] args) {
//需求:
//把整数上的每一位都添加到数组当中
//反向推导
//1.计算出数组的长度
int number = 12345;
//定义一个变量临时记录number的值,就是为了第三步的时候再次使用
int temp = number;
//定义一个变量进行统计
int count = 0;
while(number != 0){
//每一次循环就去掉右边的一个数字
number = number / 10;
//去掉一位计数器就自增一次。
count++;
}
//2.定义数组
//动态初始化
int[] arr = new int[count];
//3.把整数上的每一位都添加到数组当中
int index = arr.length -1;
while(temp != 0){//12345
//获取temp里面的每一位数组
int ge = temp % 10;
//再去掉右边的那位数字
temp = temp / 10;
//把当前获取到的个位添加到数组当中
arr[index] = ge;
index--;
}
//验证结果 1 2 3 4 5
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
练习七:数字解密
把上一题加密之后的数据进行解密
代码示例:
package com.itheima.test;
public class Test8 {
public static void main(String[] args) {
/*某系统的数字密码(大于0)。比如1983,采用加密方式进行传输,
规则如下:
每位数加上5
再对10求余,
最后将所有数字反转,
得到一串新数。
按照以上规则进行解密:
比如1983加密之后变成8346,解密之后变成1983
*/
//1.定义数组记录解密之后的结果
int[] arr = {8, 3, 4, 6};
//2.反转
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//3.由于加密是通过对10取余的方式进行获取的
//所以在解密的时候就需要判断,0~4之间+10 5~9数字不变
for (int i = 0; i < arr.length; i++) {
if (arr[i] >= 0 && arr[i] <= 4) {
arr[i] = arr[i] + 10;
}
}
//4.每一位减5
for (int i = 0; i < arr.length; i++) {
arr[i] = arr[i] - 5;
}
//5.获取数组里面的每一位数字拼接成最终的结果
int number = 0;
for (int i = 0; i < arr.length; i++) {
number = number * 10 + arr[i];
}
System.out.println(number);
}
}
练习八:抽奖
需求:
一个大V直播抽奖,奖品是现金红包,分别有{2, 588 , 888, 1000, 10000}五个奖金。请使用代码模拟抽奖,打印出每个奖项,奖项的出现顺序要随机且不重复。打印效果如下:(随机顺序,不一定是下面的顺序)
888元的奖金被抽出
588元的奖金被抽出
10000元的奖金被抽出
1000元的奖金被抽出
2元的奖金被抽出
解法一:
package com.itheima.test;
import java.util.Random;
public class Test9 {
public static void main(String[] args) {
/* 需求:
一个大V直播抽奖,奖品是现金红包,分别有{2, 588 , 888, 1000, 10000}五个奖金。
请使用代码模拟抽奖,打印出每个奖项,奖项的出现顺序要随机且不重复。
打印效果如下:(随机顺序,不一定是下面的顺序)
888元的奖金被抽出
588元的奖金被抽出
10000元的奖金被抽出
1000元的奖金被抽出
2元的奖金被抽出
*/
//分析:
//1.定义数组表示奖池
int[] arr = {2, 588, 888, 1000, 10000};
//2.定义新数组用于存储抽奖的结果
int[] newArr = new int[arr.length];
//3.抽奖
Random r = new Random();
//因为有5个奖项,所以这里要循环5次
for (int i = 0; i < 5; ) {
//获取随机索引
int randomIndex = r.nextInt(arr.length);
//获取奖项
int prize = arr[randomIndex];
//判断当前的奖项是否存在,如果存在则重新抽取,如果不存在,就表示是有效奖项
boolean flag = contains(newArr, prize);
if(!flag){
//把当前抽取到的奖项添加到newArr当中
newArr[i] = prize;
//添加完毕之后,移动索引
i++;
}
}
//4.遍历newArr
for (int i = 0; i < newArr.length; i++) {
System.out.println(newArr[i]);
}
}
//判断prize在数组当中是否存在
//存在:true
//不存在:false
public static boolean contains(int[] arr,int prize){
for (int i = 0; i < arr.length; i++) {
if(arr[i] == prize){
return true;
}
}
return false;
}
}
解法二:
package com.itheima.test;
import java.util.Random;
public class Test10 {
public static void main(String[] args) {
/* 需求:
一个大V直播抽奖,奖品是现金红包,分别有{2, 588 , 888, 1000, 10000}五个奖金。
请使用代码模拟抽奖,打印出每个奖项,奖项的出现顺序要随机且不重复。
打印效果如下:(随机顺序,不一定是下面的顺序)
888元的奖金被抽出
588元的奖金被抽出
10000元的奖金被抽出
1000元的奖金被抽出
2元的奖金被抽出
*/
//1.把奖池里面的所有奖项打乱顺序
int[] arr = {2, 588, 888, 1000, 10000};
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
//获取随机索引
int randomIndex = r.nextInt(arr.length);
//拿着i跟随机索引randomIndex上的值进行交换
int temp = arr[i];
arr[i] = arr[randomIndex];
arr[randomIndex] = temp;
}
//2.遍历奖池,从0索引开始获取每一个奖项
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
练习九:双色球
代码示例:
package com.itheima.test;
import java.util.Random;
import java.util.Scanner;
public class Test11 {
public static void main(String[] args) {
//1.生成中奖号码
int[] arr = createNumber(); // 123456 7
System.out.println("=======================");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println("=======================");
//2.用户输入彩票号码(红球 + 蓝球)//654321
int[] userInputArr = userInputNumber();
//3.判断用户的中奖情况
//红球 蓝球
int redCount = 0;
int blueCount = 0;
//判断红球
for (int i = 0; i < userInputArr.length - 1; i++) {
int redNumber = userInputArr[i];
for (int j = 0; j < arr.length - 1; j++) {
if(redNumber == arr[j]){
redCount++;
//如果找到了,那么后面的数字就没有必要继续比较了
//跳出内循环,继续判断下一个红球号码是否中奖
break;
}
}
}
//判断蓝球
int blueNumber = userInputArr[userInputArr.length-1];
if(blueNumber == arr[arr.length - 1]){
blueCount++;
}
//根据红球的个数以及蓝球的个数来判断中奖情况
if(redCount == 6 && blueCount == 1){
System.out.println("恭喜你,中奖1000万");
}else if(redCount == 6 && blueCount == 0){
System.out.println("恭喜你,中奖500万");
}else if(redCount == 5 && blueCount == 1){
System.out.println("恭喜你,中奖3000");
}else if((redCount == 5 && blueCount == 0) || (redCount == 4 && blueCount == 1)){
System.out.println("恭喜你,中奖200");
}else if((redCount == 4 && blueCount == 0) || (redCount == 3 && blueCount == 1)){
System.out.println("恭喜你,中奖10");
}else if((redCount == 2 && blueCount == 1) || (redCount == 1 && blueCount == 1)|| (redCount == 0 && blueCount == 1)){
System.out.println("恭喜你,中奖5");
}else{
System.out.println("谢谢参与,谢谢惠顾");
}
}
public static int[] userInputNumber() {
//1.创建数组用于添加用户购买的彩票号码
//6个红球 1个蓝球 数组长度:7
int[] arr = new int[7];
//2.利用键盘录入让用输入
Scanner sc = new Scanner(System.in);
//让用户输入红球号码
for (int i = 0; i < 6; ) {
System.out.println("请输入第" + (i + 1) + "个红球号码");
int redNumber = sc.nextInt();
//redNumber 在1~33 唯一不重复
if (redNumber >= 1 && redNumber <= 33) {
boolean flag = contains(arr, redNumber);
if (!flag) {
//不存在
//有效的,可以添加到数组当中
arr[i] = redNumber;
i++;
} else {
//存在
System.out.println("当前红球号码已经存在,请重新输入");
}
} else {
System.out.println("当前红球号码超出范围");
}
}
//让用户输入篮球号码
System.out.println("请输入篮球号码");
//1~16
while (true) {
int blueNumber = sc.nextInt();
if (blueNumber >= 1 && blueNumber <= 16) {
arr[arr.length - 1] = blueNumber;
break;
} else {
System.out.println("当前篮球号码超出范围");
}
}
return arr;
}
public static int[] createNumber() {
//1.创建数组用于添加中奖号码
//6个红球 1个蓝球 数组长度:7
int[] arr = new int[7];
//2.随机生成号码并添加到数组当中
//红球:不能重复的 1 2 3 4 5 6
//蓝球:可以跟红球号码重复 5
//生成红球号码并添加到数组当中
Random r = new Random();
for (int i = 0; i < 6; ) {
//获取红球号码
int redNumber = r.nextInt(33) + 1;
boolean flag = contains(arr, redNumber);
if (!flag) {
//把红球号码添加到数组当中
arr[i] = redNumber;
i++;
}
}
//生成蓝球号码并添加到数组当中
int blueNumber = r.nextInt(16) + 1;
arr[arr.length - 1] = blueNumber;
return arr;
}
//用于判断数组在数组中是否存在
public static boolean contains(int[] arr, int number) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == number) {
return true;
}
}
return false;
}
}
1. 类和对象
1.1 类和对象的理解
客观存在的事物皆为对象 ,所以我们也常常说万物皆对象。
- 类
- 类的理解
- 类是对现实生活中一类具有共同属性和行为的事物的抽象
- 类是对象的数据类型,类是具有相同属性和行为的一组对象的集合
- 简单理解:类就是对现实事物的一种描述
- 类的组成
- 属性:指事物的特征,例如:手机事物(品牌,价格,尺寸)
- 行为:指事物能执行的操作,例如:手机事物(打电话,发短信)
- 类的理解
- 类和对象的关系
- 类:类是对现实生活中一类具有共同属性和行为的事物的抽象
- 对象:是能够看得到摸的着的真实存在的实体
- 简单理解:类是对事物的一种描述,对象则为具体存在的事物
1.2 类的定义
类的组成是由属性和行为两部分组成
- 属性:在类中通过成员变量来体现(类中方法外的变量)
- 行为:在类中通过成员方法来体现(和前面的方法相比去掉static关键字即可)
类的定义步骤:
①定义类
②编写类的成员变量
③编写类的成员方法
public class 类名 {
// 成员变量
变量1的数据类型 变量1;
变量2的数据类型 变量2;
…
// 成员方法
方法1;
方法2;
}
示例代码:
/*
手机类:
类名:
手机(Phone)
成员变量:
品牌(brand)
价格(price)
成员方法:
打电话(call)
发短信(sendMessage)
*/
public class Phone {
//成员变量
String brand;
int price;
//成员方法
public void call() {
System.out.println("打电话");
}
public void sendMessage() {
System.out.println("发短信");
}
}
1.3 对象的使用
- 创建对象的格式:
- 类名 对象名 = new 类名();
- 调用成员的格式:
- 对象名.成员变量
- 对象名.成员方法();
- 示例代码
/*
创建对象
格式:类名 对象名 = new 类名();
范例:Phone p = new Phone();
使用对象
1:使用成员变量
格式:对象名.变量名
范例:p.brand
2:使用成员方法
格式:对象名.方法名()
范例:p.call()
*/
public class PhoneDemo {
public static void main(String[] args) {
//创建对象
Phone p = new Phone();
//使用成员变量
System.out.println(p.brand);
System.out.println(p.price);
p.brand = "小米";
p.price = 2999;
System.out.println(p.brand);
System.out.println(p.price);
//使用成员方法
p.call();
p.sendMessage();
}
}
1.4 学生对象-练习
- 需求:首先定义一个学生类,然后定义一个学生测试类,在学生测试类中通过对象完成成员变量和成员方法的使用
- 分析:
- 成员变量:姓名,年龄…
- 成员方法:学习,做作业…
- 示例代码:
public class Student {
//成员变量
String name;
int age;
//成员方法
public void study() {
System.out.println("好好学习,天天向上");
}
public void doHomework() {
System.out.println("键盘敲烂,月薪过万");
}
}
/*
学生测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
//使用对象
System.out.println(s.name + "," + s.age);
s.name = "林青霞";
s.age = 30;
System.out.println(s.name + "," + s.age);
s.study();
s.doHomework();
}
}
2. 对象内存图
2.1 单个对象内存图
- 成员变量使用过程
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TWnpXVZR-1688475386637)(images\1.png)]
- 成员方法调用过程
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J1fuzBhI-1688475386640)(images\2.png)]
2.2 多个对象内存图
- 成员变量使用过程
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xCUHrrFR-1688475386642)(images\3.png)]
- 成员方法调用过程
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DntwqnHl-1688475386643)(images\4.png)]
-
总结:
多个对象在堆内存中,都有不同的内存划分,成员变量存储在各自的内存区域中,成员方法多个对象共用的一份
3. 成员变量和局部变量
3.1 成员变量和局部变量的区别
- 类中位置不同:成员变量(类中方法外)局部变量(方法内部或方法声明上)
- 内存中位置不同:成员变量(堆内存)局部变量(栈内存)
- 生命周期不同:成员变量(随着对象的存在而存在,随着对象的消失而消失)局部变量(随着方法的调用而存在,醉着方法的调用完毕而消失)
- 初始化值不同:成员变量(有默认初始化值)局部变量(没有默认初始化值,必须先定义,赋值才能使用)
4. 封装
4.1 封装思想
-
封装概述
是面向对象三大特征之一(封装,继承,多态)对象代表什么,就得封装对应的数据,并提供数据对应的行为
-
封装代码实现
将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问
成员变量private,提供对应的getXxx()/setXxx()方法
4.2 private关键字
private是一个修饰符,可以用来修饰成员(成员变量,成员方法)
-
被private修饰的成员,只能在本类进行访问,针对private修饰的成员变量,如果需要被其他类使用,提供相应的操作
- 提供“get变量名()”方法,用于获取成员变量的值,方法用public修饰
- 提供“set变量名(参数)”方法,用于设置成员变量的值,方法用public修饰
-
示例代码:
/* 学生类 */ class Student { //成员变量 String name; private int age; //提供get/set方法 public void setAge(int a) { if(a<0 || a>120) { System.out.println("你给的年龄有误"); } else { age = a; } } public int getAge() { return age; } //成员方法 public void show() { System.out.println(name + "," + age); } } /* 学生测试类 */ public class StudentDemo { public static void main(String[] args) { //创建对象 Student s = new Student(); //给成员变量赋值 s.name = "林青霞"; s.setAge(30); //调用show方法 s.show(); } }
4.3 private的使用
-
需求:定义标准的学生类,要求name和age使用private修饰,并提供set和get方法以及便于显示数据的show方法,测试类中创建对象并使用,最终控制台输出 林青霞,30
-
示例代码:
/* 学生类 */ class Student { //成员变量 private String name; private int age; //get/set方法 public void setName(String n) { name = n; } public String getName() { return name; } public void setAge(int a) { age = a; } public int getAge() { return age; } public void show() { System.out.println(name + "," + age); } } /* 学生测试类 */ public class StudentDemo { public static void main(String[] args) { //创建对象 Student s = new Student(); //使用set方法给成员变量赋值 s.setName("林青霞"); s.setAge(30); s.show(); //使用get方法获取成员变量的值 System.out.println(s.getName() + "---" + s.getAge()); System.out.println(s.getName() + "," + s.getAge()); } }
4.4 this关键字
- this修饰的变量用于指代成员变量,其主要作用是(区分局部变量和成员变量的重名问题)
- 方法的形参如果与成员变量同名,不带this修饰的变量指的是形参,而不是成员变量
- 方法的形参没有与成员变量同名,不带this修饰的变量指的是成员变量
public class Student {
private String name;
private int 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;
}
public void show() {
System.out.println(name + "," + age);
}
}
5. 构造方法
5.1 构造方法概述
构造方法是一种特殊的方法
-
作用:创建对象 Student stu = new Student();
-
格式:
public class 类名{
修饰符 类名( 参数 ) {
}
}
-
功能:主要是完成对象数据的初始化
-
示例代码:
class Student {
private String name;
private int age;
//构造方法
public Student() {
System.out.println("无参构造方法");
}
public void show() {
System.out.println(name + "," + age);
}
}
/*
测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
s.show();
}
}
5.2 构造方法的注意事项
- 构造方法的创建
如果没有定义构造方法,系统将给出一个默认的无参数构造方法
如果定义了构造方法,系统将不再提供默认的构造方法
- 构造方法的重载
如果自定义了带参构造方法,还要使用无参数构造方法,就必须再写一个无参数构造方法
- 推荐的使用方式
无论是否使用,都手工书写无参数构造方法
- 重要功能!
可以使用带参构造,为成员变量进行初始化
- 示例代码
/*
学生类
*/
class Student {
private String name;
private int age;
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);
}
}
/*
测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s1 = new Student();
s1.show();
//public Student(String name)
Student s2 = new Student("林青霞");
s2.show();
//public Student(int age)
Student s3 = new Student(30);
s3.show();
//public Student(String name,int age)
Student s4 = new Student("林青霞",30);
s4.show();
}
}
5.3 标准类制作
① 类名需要见名知意
② 成员变量使用private修饰
③ 提供至少两个构造方法
- 无参构造方法
- 带全部参数的构造方法
④ get和set方法
提供每一个成员变量对应的setXxx()/getXxx()
⑤ 如果还有其他行为,也需要写上
5.4 练习1
需求:
定义标准学生类,要求分别使用空参和有参构造方法创建对象,空参创建的对象通过setXxx赋值,有参创建的对象直接赋值,并通过show方法展示数据。
- 示例代码:
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;
}
public void show() {
System.out.println(name + "," + age);
}
}
/*
创建对象并为其成员变量赋值的两种方式
1:无参构造方法创建对象后使用setXxx()赋值
2:使用带参构造方法直接创建带有属性值的对象
*/
public class StudentDemo {
public static void main(String[] args) {
//无参构造方法创建对象后使用setXxx()赋值
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(30);
s1.show();
//使用带参构造方法直接创建带有属性值的对象
Student s2 = new Student("林青霞",30);
s2.show();
}
}
5.4 练习2
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VjYOmi6S-1688475386644)(.\images\111.jpg)]
public class User {
//1.私有化全部的成员变量
//2.空参构造
//3.带全部参数的构造
//4.针对于每一个私有化的成员变量都要提供其对应的get和set方法
//5.如果当前事物还有其他行为,那么也要写出来,比如学生的吃饭,睡觉等行为
private String username;//用户名
private String password;//密码
private String email;//邮箱
private char gender;//性别
private int age;//年龄
//空参构造方法
public User() {
}
//带全部参数的构造
public User(String username, String password, String email, char gender, int age) {
this.username = username;
this.password = password;
this.email = email;
this.gender = gender;
this.age = age;
}
//get和set
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat(){
System.out.println(username + "在吃饭");
}
}
public class Test {
public static void main(String[] args) {
//写一个标准的javabean类
//咱们在课后只要能把这个标准的javabean能自己写出来,那么就表示今天的知识点就ok了
//利用空参构造创建对象
User u1 = new User();
//如果利用空参创建对象,还想赋值只能用set方法赋值
u1.setUsername("zhangsan");
u1.setPassword("1234qwer");
u1.setEmail("itheima@itcast.cn");
u1.setGender('男');
u1.setAge(23);
//获取属性的值并打印
System.out.println(u1.getUsername() + ", " + u1.getPassword()
+ ", " + u1.getEmail() + ", " + u1.getGender() + ", " + u1.getAge());
u1.eat();
System.out.println("=============================");
//简单的办法
//利用带全部参数的构造来创建对象
//快捷键:ctrl + p
User u2 = new User("lisi","12345678","lisi@itcast.cn",'女',24);
System.out.println(u2.getUsername() + ", " + u2.getPassword()
+ ", " + u2.getEmail() + ", " + u2.getGender() + ", " + u2.getAge());
u2.eat();
}
}
练习一:文字版格斗游戏
需求:
格斗游戏,每个游戏角色的姓名,血量,都不相同,在选定人物的时候(new对象的时候),这些信息就应该被确定下来。
举例:
程序运行之后结果为:
姓名为:乔峰 血量为:100
姓名为:鸠摩智 血量为:100
乔峰举起拳头打了鸠摩智一下,造成了XX点伤害,鸠摩智还剩下XXX点血。
鸠摩智举起拳头打了鸠摩智一下,造成了XX点伤害,乔峰还剩下XXX点血。
乔峰举起拳头打了鸠摩智一下,造成了XX点伤害,鸠摩智还剩下XXX点血。
鸠摩智举起拳头打了鸠摩智一下,造成了XX点伤害,乔峰还剩下XXX点血。
乔峰K.O.了鸠摩智
代码示例:
public class GameTest {
public static void main(String[] args) {
//1.创建第一个角色
Role r1 = new Role("乔峰",100);
//2.创建第二个角色
Role r2 = new Role("鸠摩智",100);
//3.开始格斗 回合制游戏
while(true){
//r1开始攻击r2
r1.attack(r2);
//判断r2的剩余血量
if(r2.getBlood() == 0){
System.out.println(r1.getName() + " K.O了" + r2.getName());
break;
}
//r2开始攻击r1
r2.attack(r1);
if(r1.getBlood() == 0){
System.out.println(r2.getName() + " K.O了" + r1.getName());
break;
}
}
}
}
public class Role {
private String name;
private int blood;
public Role() {
}
public Role(String name, int blood) {
this.name = name;
this.blood = blood;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getBlood() {
return blood;
}
public void setBlood(int blood) {
this.blood = blood;
}
//定义一个方法用于攻击别人
//思考:谁攻击谁?
//Role r1 = new Role();
//Role r2 = new Role();
//r1.攻击(r2);
//方法的调用者去攻击参数
public void attack(Role role) {
//计算造成的伤害 1 ~ 20
Random r = new Random();
int hurt = r.nextInt(20) + 1;
//剩余血量
int remainBoold = role.getBlood() - hurt;
//对剩余血量做一个验证,如果为负数了,就修改为0
remainBoold = remainBoold < 0 ? 0 : remainBoold;
//修改一下挨揍的人的血量
role.setBlood(remainBoold);
//this表示方法的调用者
System.out.println(this.getName() + "举起拳头,打了" + role.getName() + "一下," +
"造成了" + hurt + "点伤害," + role.getName() + "还剩下了" + remainBoold + "点血");
}
}
练习二:文字版格斗游戏进阶
在上一个的基础上,我想看到人物的性别和长相,打斗的时候我想看到武功招式。
举例:
程序运行之后结果为:
姓名为:乔峰 血量为:100 性别为:男 长相为:气宇轩昂
姓名为:鸠摩智 血量为:100 性别为:男 长相为:气宇轩昂
乔峰使出了一招【背心钉】,转到对方的身后,一掌向鸠摩智背心的灵台穴拍去。给鸠摩智造成一处瘀伤。
鸠摩智使出了一招【游空探爪】,飞起身形自半空中变掌为抓锁向乔峰。结果乔峰退了半步,毫发无损。
。。。。
乔峰K.O.了鸠摩智
分析:
长相是提前定义好的,提前放在一个数组当中,程序运行之后,从数组中随机获取。
//男生长相数组
String[] boyfaces = {"风流俊雅", "气宇轩昂", "相貌英俊", "五官端正", "相貌平平", "一塌糊涂", "面目狰狞"};
//女生长相数组
String[] girlfaces = {"美奂绝伦", "沉鱼落雁", "婷婷玉立", "身材娇好", "相貌平平", "相貌简陋", "惨不忍睹"};
武功招式也是提前定义好的,提前放在一个数组当中,程序运行之后,从数组随机获取
//attack 攻击描述:
String[] attacks_desc = {
"%s使出了一招【背心钉】,转到对方的身后,一掌向%s背心的灵台穴拍去。",
"%s使出了一招【游空探爪】,飞起身形自半空中变掌为抓锁向%s。",
"%s大喝一声,身形下伏,一招【劈雷坠地】,捶向%s双腿。",
"%s运气于掌,一瞬间掌心变得血红,一式【掌心雷】,推向%s。",
"%s阴手翻起阳手跟进,一招【没遮拦】,结结实实的捶向%s。",
"%s上步抢身,招中套招,一招【劈挂连环】,连环攻向%s。"
受伤的提前也是提前定义好的,只不过不是随机了,根据剩余血量获取不同的描述
//injured 受伤描述:
String[] injureds_desc = {
"结果%s退了半步,毫发无损",
"结果给%s造成一处瘀伤",
"结果一击命中,%s痛得弯下腰",
"结果%s痛苦地闷哼了一声,显然受了点内伤",
"结果%s摇摇晃晃,一跤摔倒在地",
"结果%s脸色一下变得惨白,连退了好几步",
"结果『轰』的一声,%s口中鲜血狂喷而出",
"结果%s一声惨叫,像滩软泥般塌了下去"
其中输出语句跟以前不一样了,用的是System.out.printf();该输出语句支持%s占位符
public class Test {
public static void main(String[] args) {
//两部分参数:
//第一部分参数:要输出的内容%s(占位)
//第二部分参数:填充的数据
System.out.printf("你好啊%s","张三");//用张三填充第一个%s
System.out.println();//换行
System.out.printf("%s你好啊%s","张三","李四");//用张三填充第一个%s,李四填充第二个%s
}
}
最终代码示例:
package com.itheima.test2;
import java.util.Random;
public class Role {
private String name;
private int blood;
private char gender;
private String face;//长相是随机的
String[] boyfaces = {"风流俊雅", "气宇轩昂", "相貌英俊", "五官端正", "相貌平平", "一塌糊涂", "面目狰狞"};
String[] girlfaces = {"美奂绝伦", "沉鱼落雁", "婷婷玉立", "身材娇好", "相貌平平", "相貌简陋", "惨不忍睹"};
//attack 攻击描述:
String[] attacks_desc = {
"%s使出了一招【背心钉】,转到对方的身后,一掌向%s背心的灵台穴拍去。",
"%s使出了一招【游空探爪】,飞起身形自半空中变掌为抓锁向%s。",
"%s大喝一声,身形下伏,一招【劈雷坠地】,捶向%s双腿。",
"%s运气于掌,一瞬间掌心变得血红,一式【掌心雷】,推向%s。",
"%s阴手翻起阳手跟进,一招【没遮拦】,结结实实的捶向%s。",
"%s上步抢身,招中套招,一招【劈挂连环】,连环攻向%s。"
};
//injured 受伤描述:
String[] injureds_desc = {
"结果%s退了半步,毫发无损",
"结果给%s造成一处瘀伤",
"结果一击命中,%s痛得弯下腰",
"结果%s痛苦地闷哼了一声,显然受了点内伤",
"结果%s摇摇晃晃,一跤摔倒在地",
"结果%s脸色一下变得惨白,连退了好几步",
"结果『轰』的一声,%s口中鲜血狂喷而出",
"结果%s一声惨叫,像滩软泥般塌了下去"
};
public Role() {
}
public Role(String name, int blood, char gender) {
this.name = name;
this.blood = blood;
this.gender = gender;
//随机长相
setFace(gender);
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public String getFace() {
return face;
}
public void setFace(char gender) {
Random r = new Random();
//长相是随机的
if (gender == '男') {
//从boyfaces里面随机长相
int index = r.nextInt(boyfaces.length);
this.face = boyfaces[index];
} else if (gender == '女') {
//从girlfaces里面随机长相
int index = r.nextInt(girlfaces.length);
this.face = girlfaces[index];
} else {
this.face = "面目狰狞";
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getBlood() {
return blood;
}
public void setBlood(int blood) {
this.blood = blood;
}
//定义一个方法用于攻击别人
//思考:谁攻击谁?
//Role r1 = new Role();
//Role r2 = new Role();
//r1.攻击(r2);
//方法的调用者去攻击参数
public void attack(Role role) {
Random r = new Random();
int index = r.nextInt(attacks_desc.length);
String KungFu = attacks_desc[index];
//输出一个攻击的效果
System.out.printf(KungFu, this.getName(), role.getName());
System.out.println();
//计算造成的伤害 1 ~ 20
int hurt = r.nextInt(20) + 1;
//剩余血量
int remainBoold = role.getBlood() - hurt;
//对剩余血量做一个验证,如果为负数了,就修改为0
remainBoold = remainBoold < 0 ? 0 : remainBoold;
//修改一下挨揍的人的血量
role.setBlood(remainBoold);
//受伤的描述
//血量> 90 0索引的描述
//80 ~ 90 1索引的描述
//70 ~ 80 2索引的描述
//60 ~ 70 3索引的描述
//40 ~ 60 4索引的描述
//20 ~ 40 5索引的描述
//10 ~ 20 6索引的描述
//小于10的 7索引的描述
if (remainBoold > 90) {
System.out.printf(injureds_desc[0], role.getName());
}else if(remainBoold > 80 && remainBoold <= 90){
System.out.printf(injureds_desc[1], role.getName());
}else if(remainBoold > 70 && remainBoold <= 80){
System.out.printf(injureds_desc[2], role.getName());
}else if(remainBoold > 60 && remainBoold <= 70){
System.out.printf(injureds_desc[3], role.getName());
}else if(remainBoold > 40 && remainBoold <= 60){
System.out.printf(injureds_desc[4], role.getName());
}else if(remainBoold > 20 && remainBoold <= 40){
System.out.printf(injureds_desc[5], role.getName());
}else if(remainBoold > 10 && remainBoold <= 20){
System.out.printf(injureds_desc[6], role.getName());
}else{
System.out.printf(injureds_desc[7], role.getName());
}
System.out.println();
}
public void showRoleInfo() {
System.out.println("姓名为:" + getName());
System.out.println("血量为:" + getBlood());
System.out.println("性别为:" + getGender());
System.out.println("长相为:" + getFace());
}
}
package com.itheima.test2;
public class GameTest {
public static void main(String[] args) {
//1.创建第一个角色
Role r1 = new Role("乔峰",100,'男');
//2.创建第二个角色
Role r2 = new Role("鸠摩智",100,'男');
//展示一下角色的信息
r1.showRoleInfo();
r2.showRoleInfo();
//3.开始格斗 回合制游戏
while(true){
//r1开始攻击r2
r1.attack(r2);
//判断r2的剩余血量
if(r2.getBlood() == 0){
System.out.println(r1.getName() + " K.O了" + r2.getName());
break;
}
//r2开始攻击r1
r2.attack(r1);
if(r1.getBlood() == 0){
System.out.println(r2.getName() + " K.O了" + r1.getName());
break;
}
}
}
}
练习三:对象数组(商品)
需求:
定义数组存储3个商品对象。
商品的属性:商品的id,名字,价格,库存。
创建三个商品对象,并把商品对象存入到数组当中。
代码示例:
package com.itheima.test3;
public class Goods {
private String id;
private String name;
private double price;
private int count;
public Goods() {
}
public Goods(String id, String name, double price, int count) {
this.id = id;
this.name = name;
this.price = price;
this.count = count;
}
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 double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
}
package com.itheima.test3;
public class GoodsTest {
public static void main(String[] args) {
//1.创建一个数组
Goods[] arr = new Goods[3];
//2.创建三个商品对象
Goods g1 = new Goods("001","华为P40",5999.0,100);
Goods g2 = new Goods("002","保温杯",227.0,50);
Goods g3 = new Goods("003","枸杞",12.7,70);
//3.把商品添加到数组中
arr[0] = g1;
arr[1] = g2;
arr[2] = g3;
//4.遍历
for (int i = 0; i < arr.length; i++) {
//i 索引 arr[i] 元素
Goods goods = arr[i];
System.out.println(goods.getId() + ", " + goods.getName() + ", " + goods.getPrice() + ", " + goods.getCount());
}
}
}
练习四:对象数组(汽车)
需求:
定义数组存储3部汽车对象。
汽车的属性:品牌,价格,颜色。
创建三个汽车对象,数据通过键盘录入而来,并把数据存入到数组当中。
代码示例:
package com.itheima.test5;
public class Car {
private String brand;//品牌
private int price;//价格
private String color;//颜色
public Car() {
}
public Car(String brand, int price, String color) {
this.brand = brand;
this.price = price;
this.color = color;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
package com.itheima.test5;
import java.util.Scanner;
public class CarTest {
public static void main(String[] args) {
//1.创建一个数组用来存3个汽车对象
Car[] arr = new Car[3];
//2.创建汽车对象,数据来自于键盘录入
Scanner sc = new Scanner(System.in);
for (int i = 0; i < arr.length; i++) {
//创建汽车的对象
Car c = new Car();
//录入品牌
System.out.println("请输入汽车的品牌");
String brand = sc.next();
c.setBrand(brand);
//录入价格
System.out.println("请输入汽车的价格");
int price = sc.nextInt();
c.setPrice(price);
//录入颜色
System.out.println("请输入汽车的颜色");
String color = sc.next();
c.setColor(color);
//把汽车对象添加到数组当中
arr[i] = c;
}
//3.遍历数组
for (int i = 0; i < arr.length; i++) {
Car car = arr[i];
System.out.println(car.getBrand() + ", " + car.getPrice() + ", " + car.getColor());
}
}
}
练习五:对象数组(手机)
需求 :
定义数组存储3部手机对象。
手机的属性:品牌,价格,颜色。
要求,计算出三部手机的平均价格
代码示例:
package com.itheima.test6;
public class Phone {
private String brand;//品牌
private int price;//价格
private String color;//颜色
public Phone() {
}
public Phone(String brand, int price, String color) {
this.brand = brand;
this.price = price;
this.color = color;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
package com.itheima.test6;
import java.math.BigDecimal;
public class PhoneTest {
public static void main(String[] args) {
//1.创建一个数组
Phone[] arr = new Phone[3];
//2.创建手机的对象
Phone p1 = new Phone("小米",1999,"白色");
Phone p2 = new Phone("华为",4999,"蓝色");
Phone p3 = new Phone("魅族",3999,"红色");
//3.把手机对象添加到数组当中
arr[0] = p1;
arr[1] = p2;
arr[2] = p3;
//4.获取三部手机的平均价格
int sum = 0;
for (int i = 0; i < arr.length; i++) {
//i 索引 arr[i] 元素(手机对象)
Phone phone = arr[i];
sum = sum + phone.getPrice();
}
//5.求平均值
//数据能不写死,尽量不写死
//int avg = sum / arr.length;
double avg2 = sum * 1.0 / arr.length;
System.out.println(avg2);//3665.6666666666665
}
}
练习六:对象数组(女朋友)
需求:
定义数组存储4个女朋友的对象
女朋友的属性:姓名、年龄、性别、爱好
要求1:计算出四女朋友的平均年龄
要求2:统计年龄比平均值低的女朋友有几个?并把她们的所有信息打印出来。
代码示例:
package com.itheima.test7;
public class GirlFriend {
private String name;//姓名
private int age;//年龄
private String gender;//性别
private String hobby;//爱好
public GirlFriend() {
}
public GirlFriend(String name, int age, String gender, String hobby) {
this.name = name;
this.age = age;
this.gender = gender;
this.hobby = hobby;
}
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;
}
public String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
}
package com.itheima.test7;
public class GirlFriendTest {
public static void main(String[] args) {
//1.定义数组存入女朋友的对象
GirlFriend[] arr = new GirlFriend[4];
//2.创建女朋友对象
GirlFriend gf1 = new GirlFriend("小诗诗",18,"萌妹子","吃零食");
GirlFriend gf2 = new GirlFriend("小丹丹",19,"萌妹子","玩游戏");
GirlFriend gf3 = new GirlFriend("小惠惠",20,"萌妹子","看书,学习");
GirlFriend gf4 = new GirlFriend("小莉莉",21,"憨妹子","睡觉");
//3.把对象添加到数组当中
arr[0] = gf1;
arr[1] = gf2;
arr[2] = gf3;
arr[3] = gf4;
//4.求和
int sum = 0;
for (int i = 0; i < arr.length; i++) {
//i 索引 arr[i] 元素(女朋友对象)
GirlFriend gf = arr[i];
//累加
sum = sum + gf.getAge();
}
//5.平均值
int avg = sum / arr.length;
//6.统计年龄比平均值低的有几个,打印他们的信息
int count = 0;
for (int i = 0; i < arr.length; i++) {
GirlFriend gf = arr[i];
if(gf.getAge() < avg){
count++;
System.out.println(gf.getName() + ", " + gf.getAge() + ", " + gf.getGender() + ", " + gf.getHobby());
}
}
System.out.println(count + "个");
}
}
练习七:复杂的对象数组操作
定义一个长度为3的数组,数组存储1~3名学生对象作为初始数据,学生对象的学号,姓名各不相同。
学生的属性:学号,姓名,年龄。
要求1:再次添加一个学生对象,并在添加的时候进行学号的唯一性判断。
要求2:添加完毕之后,遍历所有学生信息。
要求3:通过id删除学生信息
如果存在,则删除,如果不存在,则提示删除失败。
要求4:删除完毕之后,遍历所有学生信息。
要求5:查询数组id为“heima002”的学生,如果存在,则将他的年龄+1岁
代码示例:
package com.itheima.test8;
public class Student {
private int id;
private String name;
private int age;
public Student() {
}
public Student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 class Test {
public static void main(String[] args) {
/*定义一个长度为3的数组,数组存储1~3名学生对象作为初始数据,学生对象的学号,姓名各不相同。
学生的属性:学号,姓名,年龄。
要求1:再次添加一个学生对象,并在添加的时候进行学号的唯一性判断。
要求2:添加完毕之后,遍历所有学生信息。
*/
//1.创建一个数组用来存储学生对象
Student[] arr = new Student[3];
//2.创建学生对象并添加到数组当中
Student stu1 = new Student(1, "zhangsan", 23);
Student stu2 = new Student(2, "lisi", 24);
//3.把学生对象添加到数组当中
arr[0] = stu1;
arr[1] = stu2;
//要求1:再次添加一个学生对象,并在添加的时候进行学号的唯一性判断。
Student stu4 = new Student(1, "zhaoliu", 26);
//唯一性判断
//已存在 --- 不用添加
//不存在 --- 就可以把学生对象添加进数组
boolean flag = contains(arr, stu4.getId());
if(flag){
//已存在 --- 不用添加
System.out.println("当前id重复,请修改id后再进行添加");
}else{
//不存在 --- 就可以把学生对象添加进数组
//把stu4添加到数组当中
//1.数组已经存满 --- 只能创建一个新的数组,新数组的长度 = 老数组 + 1
//2.数组没有存满 --- 直接添加
int count = getCount(arr);
if(count == arr.length){
//已经存满
//创建一个新的数组,长度 = 老数组的长度 + 1
//然后把老数组的元素,拷贝到新数组当中
Student[] newArr = creatNewArr(arr);
//把stu4添加进去
newArr[count] = stu4;
//要求2:添加完毕之后,遍历所有学生信息。
printArr(newArr);
}else{
//没有存满
//[stu1,stu2,null]
//getCount获取到的是2,表示数组当中已经有了2个元素
//还有一层意思:如果下一次要添加数据,就是添加到2索引的位置
arr[count] = stu4;
//要求2:添加完毕之后,遍历所有学生信息。
printArr(arr);
}
}
}
public static void printArr(Student[] arr){
for (int i = 0; i < arr.length; i++) {
Student stu = arr[i];
if(stu != null){
System.out.println(stu.getId() + ", " + stu.getName() + ", " + stu.getAge());
}
}
}
//创建一个新的数组,长度 = 老数组的长度 + 1
//然后把老数组的元素,拷贝到新数组当中
public static Student[] creatNewArr(Student[] arr){
Student[] newArr = new Student[arr.length + 1];
//循环遍历得到老数组中的每一个元素
for (int i = 0; i < arr.length; i++) {
//把老数组中的元素添加到新数组当中
newArr[i] = arr[i];
}
//把新数组返回
return newArr;
}
//定义一个方法判断数组中已经存了几个元素
public static int getCount(Student[] arr){
//定义一个计数器用来统计
int count = 0;
for (int i = 0; i < arr.length; i++) {
if(arr[i] != null){
count++;
}
}
//当循环结束之后,我就知道了数组中一共有几个元素
return count;
}
//1.我要干嘛? 唯一性判断
//2.我干这件事情,需要什么才能完成? 数组 id
//3.调用处是否需要继续使用方法的结果? 必须返回
public static boolean contains(Student[] arr, int id) {
for (int i = 0; i < arr.length; i++) {
//依次获取到数组里面的每一个学生对象
Student stu = arr[i];
if(stu != null){
//获取数组中学生对象的id
int sid = stu.getId();
//比较
if(sid == id){
return true;
}
}
}
//当循环结束之后,还没有找到一样的,那么就表示数组中要查找的id是不存在的。
return false;
}
}
package com.itheima.test8;
public class Test3 {
public static void main(String[] args) {
/*定义一个长度为3的数组,数组存储1~3名学生对象作为初始数据,学生对象的学号,姓名各不相同。
学生的属性:学号,姓名,年龄。
要求3:通过id删除学生信息
如果存在,则删除,如果不存在,则提示删除失败。
要求4:删除完毕之后,遍历所有学生信息。
*/
//1.创建一个数组用来存储学生对象
Student[] arr = new Student[3];
//2.创建学生对象并添加到数组当中
Student stu1 = new Student(1, "zhangsan", 23);
Student stu2 = new Student(2, "lisi", 24);
Student stu3 = new Student(3, "wangwu", 25);
//3.把学生对象添加到数组当中
arr[0] = stu1;
arr[1] = stu2;
arr[2] = stu3;
/*要求3:通过id删除学生信息
如果存在,则删除,如果不存在,则提示删除失败。*/
//要找到id在数组中对应的索引
int index = getIndex(arr, 2);
if (index >= 0){
//如果存在,则删除
arr[index] = null;
//遍历数组
printArr(arr);
}else{
//如果不存在,则提示删除失败
System.out.println("当前id不存在,删除失败");
}
}
//1.我要干嘛? 找到id在数组中的索引
//2.我需要什么? 数组 id
//3.调用处是否需要继续使用方法的结果? 要
public static int getIndex(Student[] arr , int id){
for (int i = 0; i < arr.length; i++) {
//依次得到每一个学生对象
Student stu = arr[i];
//对stu进行一个非空判断
if(stu != null){
int sid = stu.getId();
if(sid == id){
return i;
}
}
}
//当循环结束之后,还没有找到就表示不存在
return -1;
}
public static void printArr(Student[] arr){
for (int i = 0; i < arr.length; i++) {
Student stu = arr[i];
if(stu != null){
System.out.println(stu.getId() + ", " + stu.getName() + ", " + stu.getAge());
}
}
}
}
package com.itheima.test8;
public class Test4 {
public static void main(String[] args) {
/*定义一个长度为3的数组,数组存储1~3名学生对象作为初始数据,学生对象的学号,姓名各不相同。
学生的属性:学号,姓名,年龄。
要求5:查询数组id为“2”的学生,如果存在,则将他的年龄+1岁*/
//1.创建一个数组用来存储学生对象
Student[] arr = new Student[3];
//2.创建学生对象并添加到数组当中
Student stu1 = new Student(1, "zhangsan", 23);
Student stu2 = new Student(2, "lisi", 24);
Student stu3 = new Student(3, "wangwu", 25);
//3.把学生对象添加到数组当中
arr[0] = stu1;
arr[1] = stu2;
arr[2] = stu3;
//4.先要找到id为2的学生对于的索引
int index = getIndex(arr, 2);
//5.判断索引
if(index >= 0){
//存在, 则将他的年龄+1岁
Student stu = arr[index];
//把原来的年龄拿出来
int newAge = stu.getAge() + 1;
//把+1之后的年龄塞回去
stu.setAge(newAge);
//遍历数组
printArr(arr);
}else{
//不存在,则直接提示
System.out.println("当前id不存在,修改失败");
}
}
//1.我要干嘛? 找到id在数组中的索引
//2.我需要什么? 数组 id
//3.调用处是否需要继续使用方法的结果? 要
public static int getIndex(Student[] arr , int id){
for (int i = 0; i < arr.length; i++) {
//依次得到每一个学生对象
Student stu = arr[i];
//对stu进行一个非空判断
if(stu != null){
int sid = stu.getId();
if(sid == id){
return i;
}
}
}
//当循环结束之后,还没有找到就表示不存在
return -1;
}
public static void printArr(Student[] arr){
for (int i = 0; i < arr.length; i++) {
Student stu = arr[i];
if(stu != null){
System.out.println(stu.getId() + ", " + stu.getName() + ", " + stu.getAge());
}
}
}
}
一,键盘录入涉及到的方法如下:
next()、nextLine()、nextInt()、nextDouble()。
1)next()、nextLine():
可以接受任意数据,但是都会返回一个字符串。
比如:键盘录入abc,那么会把abc看做字符串返回。
键盘录入123,那么会把123看做字符串返回。
代码示例:
Scanner sc = new Scanner(System.in);
String s = sc.next();//录入的所有数据都会看做是字符串
System.out.println(s);
代码示例:
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();//录入的所有数据都会看做是字符串
System.out.println(s);
2)nextInt():
只能接受整数。
比如:键盘录入123,那么会把123当做int类型的整数返回。
键盘录入小数或者其他字母,就会报错。
代码示例:
Scanner sc = new Scanner(System.in);
int s = sc.nextInt();//只能录入整数
System.out.println(s);
3)nextDouble():
能接收整数和小数,但是都会看做小数返回。
录入字母会报错。
代码示例:
Scanner sc = new Scanner(System.in);
double d = sc.nextDouble();//录入的整数,小数都会看做小数。
//录入字母会报错
System.out.println(d);
二,方法底层细节 :
第一个细节:
next(),nextInt(),nextDouble()在接收数据的时候,会遇到空格,回车,制表符其中一个就会停止接收数据。
代码示例:
Scanner sc = new Scanner(System.in);
double d = sc.nextDouble();
System.out.println(d);
//键盘录入:1.1 2.2//注意录入的时候1.1和2.2之间加空格隔开。
//此时控制台打印1.1
//表示nextDouble方法在接收数据的时候,遇到空格就停止了,后面的本次不接收。
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
System.out.println(i);
//键盘录入:1 2//注意录入的时候1和2之间加空格隔开。
//此时控制台打印1
//表示nextInt方法在接收数据的时候,遇到空格就停止了,后面的本次不接收。
Scanner sc = new Scanner(System.in);
String s = sc.next();
System.out.println(s);
//键盘录入:a b//注意录入的时候a和b之间加空格隔开。
//此时控制台打印a
//表示next方法在接收数据的时候,遇到空格就停止了,后面的本次不接收。
第二个细节:
next(),nextInt(),nextDouble()在接收数据的时候,会遇到空格,回车,制表符其中一个就会停止接收数据。但是这些符号 + 后面的数据还在内存中并没有接收。如果后面还有其他键盘录入的方法,会自动将这些数据接收。
代码示例:
Scanner sc = new Scanner(System.in);
String s1 = sc.next();
String s2 = sc.next();
System.out.println(s1);
System.out.println(s2);
//此时值键盘录入一次a b(注意a和b之间用空格隔开)
//那么第一个next();会接收a,a后面是空格,那么就停止,所以打印s1是a
//但是空格+b还在内存中。
//第二个next会去掉前面的空格,只接收b
//所以第二个s2打印出来是b
第三个细节:
nextLine()方法是把一整行全部接收完毕。
代码示例:
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
System.out.println(s);
//键盘录入a b(注意a和b之间用空格隔开)
//那么nextLine不会过滤前面和后面的空格,会把这一整行数据全部接收完毕。
三、混用引起的后果
上面说的两套键盘录入不能混用,如果混用会有严重的后果。
代码示例:
Scanner sc = new Scanner(System.in);//①
int i = sc.nextInt();//②
String s = sc.nextLine();//③
System.out.println(i);//④
System.out.println(s);//⑤
当代码运行到第二行,会让我们键盘录入,此时录入123。
但是实际上我们录的是123+回车。
而nextInt是遇到空格,回车,制表符都会停止。
所以nextInt只能接受123,回车还在内存中没有被接收。
此时就被nextLine接收了。
所以,如果混用就会导致nextLine接收不到数据。
四、结论(如何使用)
键盘录入分为两套:
- next()、nextInt()、nextDouble()这三个配套使用。
如果用了这三个其中一个,就不要用nextLine()。
- nextLine()单独使用。
如果想要整数,那么先接收,再使用Integer.parseInt进行类型转换。
代码示例:
Scanner sc = new Scanner(System.in);
String s = sc.next();//键盘录入123
System.out.println("此时为字符串" + s);//此时123是字符串
int i = sc.nextInt();//键盘录入123
System.out.println("此时为整数:" + i);
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();//键盘录入123
System.out.println("此时为字符串" + s);//此时123是字符串
int i = Integer.parseInt(s);//想要整数再进行转换
System.out.println("此时为整数:" + i);
1.API
1.1API概述
-
什么是API
API (Application Programming Interface) :应用程序编程接口
-
java中的API
指的就是 JDK 中提供的各种功能的 Java类,这些类将底层的实现封装了起来,我们不需要关心这些类是如何实现的,只需要学习这些类如何使用即可,我们可以通过帮助文档来学习这些API如何使用。
2.String类
2.1String类概述
String 类代表字符串,Java 程序中的所有字符串文字(例如“abc”)都被实现为此类的实例。也就是说,Java 程序中所有的双引号字符串,都是 String 类的对象。String 类在 java.lang 包下,所以使用的时候不需要导包!
2.2String类的特点
- 字符串不可变,它们的值在创建后不能被更改
- 虽然 String 的值是不可变的,但是它们可以被共享
- 字符串效果上相当于字符数组( char[] ),但是底层原理是字节数组( byte[] )
2.3String类的构造方法
-
常用的构造方法
方法名 说明 public String() 创建一个空白字符串对象,不含有任何内容 public String(char[] chs) 根据字符数组的内容,来创建字符串对象 public String(byte[] bys) 根据字节数组的内容,来创建字符串对象 String s = “abc”; 直接赋值的方式创建字符串对象,内容就是abc -
示例代码
public class StringDemo01 { public static void main(String[] args) { //public String():创建一个空白字符串对象,不含有任何内容 String s1 = new String(); System.out.println("s1:" + s1); //public String(char[] chs):根据字符数组的内容,来创建字符串对象 char[] chs = {'a', 'b', 'c'}; String s2 = new String(chs); System.out.println("s2:" + s2); //public String(byte[] bys):根据字节数组的内容,来创建字符串对象 byte[] bys = {97, 98, 99}; String s3 = new String(bys); System.out.println("s3:" + s3); //String s = “abc”; 直接赋值的方式创建字符串对象,内容就是abc String s4 = "abc"; System.out.println("s4:" + s4); } }
2.4创建字符串对象两种方式的区别
-
通过构造方法创建
通过 new 创建的字符串对象,每一次 new 都会申请一个内存空间,虽然内容相同,但是地址值不同
-
直接赋值方式创建
以“”方式给出的字符串,只要字符序列相同(顺序和大小写),无论在程序代码中出现几次,JVM 都只会建立一个 String 对象,并在字符串池中维护
2.5字符串的比较
2.5.1==号的作用
- 比较基本数据类型:比较的是具体的值
- 比较引用数据类型:比较的是对象地址值
2.5.2equals方法的作用
-
方法介绍
public boolean equals(String s) 比较两个字符串内容是否相同、区分大小写
-
示例代码
public class StringDemo02 { public static void main(String[] args) { //构造方法的方式得到对象 char[] chs = {'a', 'b', 'c'}; String s1 = new String(chs); String s2 = new String(chs); //直接赋值的方式得到对象 String s3 = "abc"; String s4 = "abc"; //比较字符串对象地址是否相同 System.out.println(s1 == s2); System.out.println(s1 == s3); System.out.println(s3 == s4); System.out.println("--------"); //比较字符串内容是否相同 System.out.println(s1.equals(s2)); System.out.println(s1.equals(s3)); System.out.println(s3.equals(s4)); } }
2.6用户登录案例
2.6.1案例需求
已知用户名和密码,请用程序实现模拟用户登录。总共给三次机会,登录之后,给出相应的提示
2.6.2代码实现
public class Test1登录案例 {
public static void main(String[] args) {
//1.定义两个变量用来记录正确的用户名和密码
String rightUsername = "itheima";
String rightPassword = "1234qwer";
//2.键盘录入用户名和密码
//ctrl + alt + T 选择包裹方式
for (int i = 0; i < 3; i++) {//0 1 2
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名");
String username = sc.next();
System.out.println("请输入密码");
String password = sc.next();
//3.判断比较
if (username.equals(rightUsername) && password.equals(rightPassword)) {
System.out.println("登录成功");
//如果正确,循环结束
break;
} else {
//最后一次机会
if(i == 2){
System.out.println("账户" + username + "被锁定,请联系黑马程序员官方小姐姐:XXXXXXX");
}else{
//不是最后一次机会
System.out.println("用户名或密码错误,登录失败,还剩下" + (2 - i) + "次机会");//2 1 0
}
}
}
}
}
2.7遍历字符串案例
2.7.1案例需求
键盘录入一个字符串,使用程序实现在控制台遍历该字符串
2.7.2直接遍历字符串
public class Test2字符串直接遍历 {
public static void main(String[] args) {
//两个方法:
//charAt():会根据索引获取对应的字符
//length(): 会返回字符串的长度
//1.键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入字符串");
String str = sc.next();
System.out.println(str);
//2.遍历
for (int i = 0; i < str.length(); i++) {
//i 依次表示字符串的每一个索引
//索引的范围:0 ~ 长度-1
//根据索引获取字符串里面的每一个字符
//ctrl + alt + V 自动生成左边的接受变量
char c = str.charAt(i);
System.out.println(c);
}
}
}
2.8统计字符次数案例
2.8.1案例需求
键盘录入一个字符串,统计该字符串中大写字母字符,小写字母字符,数字字符出现的次数(不考虑其他字符)
2.8.2代码实现
public class Test4统计个数 {
public static void main(String[] args) {
//键盘录入一个字符串,统计大写,小写,数字出现的次数
//1.键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String str = sc.next();
//2.统计 --- 计数器count
//此时我要统计的有3样东西,所以要定义3个计数器分别进行统计
int bigCount = 0;
int smallCount = 0;
int numberCount = 0;
//得到这个字符串里面每一个字符
for (int i = 0; i < str.length(); i++) {
//i 表示字符串中的索引
//c 表示字符串中的每一个字符
char c = str.charAt(i);
//对c进行判断
if (c >= 'a' && c <= 'z') {
smallCount++;
}else if(c >= 'A' && c <= 'Z'){
bigCount++;
}else if(c >= '0' && c <= '9'){
numberCount++;
}
}
//3.当循环结束之后,三个变量记录的就是对应的个数
System.out.println("大写字符有:" + bigCount + "个");
System.out.println("小写字符有:" + smallCount + "个");
System.out.println("数字字符有:" + numberCount + "个");
}
}
2.9字符串拼接案例
2.9.1案例需求
定义一个方法,把 int 数组中的数据按照指定的格式拼接成一个字符串返回,调用该方法,
并在控制台输出结果。例如,数组为 int[] arr = {1,2,3}; ,执行方法后的输出结果为:[1, 2, 3]
2.9.2代码实现
public class Test5数组拼接成字符串 {
public static void main(String[] args) {
//定义一个方法,把 int 数组中的数据按照指定的格式拼接成一个字符串返回,调用该方法,
//并在控制台输出结果。例如,数组为 int[] arr = {1,2,3};
//执行方法后的输出结果为:[1, 2, 3]
int[] arr = {1, 2, 3, 4, 5};
String str = arrToString(arr);
System.out.println(str);
}
//作用:把一个数组变成字符串
public static String arrToString(int[] arr) {
String s = "";
//拼接左括号
s = s + "["; //此时是拿着长度为0的字符串,跟[进行拼接,产生一个新的字符串。
//把新的字符串再赋值给s,此时变量s记录的就是新的字符串"["的地址值
//下面我想得到数组里面的每一个元素并进行拼接
//那么就需要遍历数组,得到每一个元素才行
for (int i = 0; i < arr.length; i++) {
//假设第一次循环:i = 0 获取的就是0索引上的元素
//在拼接的时候:"[" + 1 + ", " 拼接完毕之后产生一个新的字符串 "[1, "
//第二次循环:i = 1 获取的就是1索引上的元素
//在拼接的时候: 此时s就是第一次循环结束后拼接完毕的结果:"[1, "
//在拼接的时候:"[1, " + 2 + ", " 拼接完毕之后产生一个新的字符串 "[1, 2, "
//...
if(i == arr.length - 1){
//如果是最后一个元素,那么不需要拼接逗号空格
s = s + arr[i];
}else{
//如果不是最后一个元素,需要拼接元素和逗号空格
s = s + arr[i] + ", ";
}
}
//等循环结束之后,再拼接最后一个右括号
s = s + "]";
return s;
}
//用来遍历数组
public static void printArr(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.print(arr[i]);
} else {
System.out.print(arr[i] + ", ");
}
}
System.out.println("]");
//[1, 2, 3, 4, 5]
//我们现在要知道,这个最终结果是怎么来的?
//从到右依次打印得来的。
}
}
2.10字符串反转案例
2.10.1案例需求
定义一个方法,实现字符串反转。键盘录入一个字符串,调用该方法后,在控制台输出结果
例如,键盘录入 abc,输出结果 cba
2.10.2代码实现
public class Test6反转字符串 {
public static void main(String[] args) {
/*定义一个方法,实现字符串反转。键盘录入一个字符串,调用该方法后,在控制台输出结果
例如,键盘录入 abc,输出结果 cba*/
//1.定义一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String str = sc.next();
//2.定义一个方法,反转字符串
//abc ---> cba
//可以把字符串倒着遍历,再拼接
String result = reverse(str);
System.out.println(result);
}
//注释:方法的作用就是反转字符串
//把传递进来的字符串进行反转
public static String reverse(String str){//abc
//核心思想:倒着遍历并进行拼接就可以了
//fori :正着遍历 forr:倒着遍历
String s = "";
for (int i = str.length() - 1; i >= 0; i--) {
//i 依次表示字符串里面的每一个索引(倒着的)
//我们就可以拿到里面的每一个字符并拼接
s = s + str.charAt(i);
}
//把倒着拼接之后的结果返回即可
return s;
}
}
2.11 金额转换
2.11.1 案例需求
把2135变成:零佰零拾零万贰仟壹佰叁拾伍元
把789变成:零佰零拾零万零仟柒佰捌拾玖元
2.11.2 代码实现
package com.itheima.stringdemo;
import java.util.Scanner;
public class StringDemo9 {
public static void main(String[] args) {
//1.键盘录入一个金额
Scanner sc = new Scanner(System.in);
int money;
while (true) {
System.out.println("请录入一个金额");
money = sc.nextInt();
if (money >= 0 && money <= 9999999) {
break;
} else {
System.out.println("金额无效");
}
}
//定义一个变量用来表示钱的大写
String moneyStr = "";
//2.得到money里面的每一位数字,再转成中文
while (true) {//2135
//从右往左获取数据,因为右侧是数据的个位
int ge = money % 10;
String capitalNumber = getCapitalNumber(ge);
//把转换之后的大写拼接到moneyStr当中
moneyStr = capitalNumber + moneyStr;
//第一次循环 : "伍" + "" = "伍"
//第二次循环 : "叁" + "伍" = "叁伍"
//去掉刚刚获取的数据
money = money / 10;
//如果数字上的每一位全部获取到了,那么money记录的就是0,此时循环结束
if (money == 0) {
break;
}
}
//3.在前面补0,补齐7位
int count = 7 - moneyStr.length();
for (int i = 0; i < count; i++) {
moneyStr = "零" + moneyStr;
}
System.out.println(moneyStr);//零零零贰壹叁伍
//4.插入单位
//定义一个数组表示单位
String[] arr = {"佰","拾","万","仟","佰","拾","元"};
// 零 零 零 贰 壹 叁 伍
//遍历moneyStr,依次得到 零 零 零 贰 壹 叁 伍
//然后把arr的单位插入进去
String result = "";
for (int i = 0; i < moneyStr.length(); i++) {
char c = moneyStr.charAt(i);
//把大写数字和单位拼接到result当中
result = result + c + arr[i];
}
//5.打印最终结果
System.out.println(result);
}
//定义一个方法把数字变成大写的中文
//1 -- 壹
public static String getCapitalNumber(int number) {
//定义数组,让数字跟大写的中文产生一个对应关系
String[] arr = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
//返回结果
return arr[number];
}
}
2.12 手机号屏蔽
需求:以字符串的形式从键盘接受一个手机号,将中间四位号码屏蔽
最终效果为:131****9468
代码实现:
public class Test8手机号屏蔽 {
public static void main(String[] args) {
/*以字符串的形式从键盘接受一个手机号,将中间四位号码屏蔽
最终效果为:131****9468*/
//1.键盘录入一个手机号码
Scanner sc = new Scanner(System.in);
System.out.println("请输入手机号码");
String phoneNumber = sc.next();//13112349408
//2.截取手机号码中的前三位
String star = phoneNumber.substring(0, 3);
//3.截取手机号码中的最后四位
//此时我用substring方法,是用1个参数的,还是两个参数的?1个参数的会更好
//因为现在我要截取到最后,所以建议使用1个参数的。
String end = phoneNumber.substring(7);
//4.拼接
String result = star + "****" + end;
System.out.println(result);
}
}
2.13 敏感词替换
需求1:键盘录入一个 字符串,如果字符串中包含(TMD),则使用***替换
public class Test9敏感词替换 {
public static void main(String[] args) {
//1.定义一个变量表示骂人的话
String talk = "后裔你玩什么啊,TMD";
//2.把这句话中的敏感词进行替换
String result = talk.replace("TMD", "***");
//3.打印
System.out.println(talk);
System.out.println(result);
}
}
需求2:如果要替换的敏感词比较多怎么办?
public class Test10多个敏感词替换 {
public static void main(String[] args) {
//实际开发中,敏感词会有很多很多
//1.先键盘录入要说的话
Scanner sc = new Scanner(System.in);
System.out.println("请输入要说的话");
String talk = sc.next();//后裔你玩什么啊,TMD,GDX,ctmd,ZZ
//2.定义一个数组用来存多个敏感词
String[] arr = {"TMD","GDX","ctmd","ZZ","lj","FW","nt"};
//3.把说的话中所有的敏感词都替换为***
for (int i = 0; i < arr.length; i++) {
//i 索引
//arr[i] 元素 --- 敏感词
talk = talk.replace(arr[i],"***");
}
//4.打印结果
System.out.println(talk);//后裔你玩什么啊,***,***,***,***
}
}
2.14 身份证信息查看
身份证的每一位都是有固定的含义:
- 1、2位:省份
- 3、4位:城市
- 5、6位:区县
- 7-14位:出生年、月、日
- 15、16位:所在地派出所
- 17位:性别(奇数男性,偶数女性)
- 18位:个人信息码(随机产生)
要求打印内容方式如下:
人物信息为:
出生年月日:XXXX年X月X日
性别为:男/女
package com.itheima.stringdemo;
public class StringDemo11 {
public static void main(String[] args) {
//1.定义一个字符串记录身份证号码
String id = "321281202001011234";
//2.获取出生年月日
String year = id.substring(6, 10);
String month = id.substring(10, 12);
String day = id.substring(12, 14);
System.out.println("人物信息为:");
System.out.println("出生年月日:" + year + "年" + month + "月" + day + "日");
//3.获取性别
char gender = id.charAt(16);//'3' ---> 3
//利用ASCII码表进行转换
//'0' ---> 48
//'1' ---> 49
//'2' ---> 50
//'3' ---> 51
//'4' ---> 52
//'5' ---> 53
//'6' ---> 54
//'7' ---> 55
//'8' ---> 56
//'9' ---> 57
int num = gender - 48;
if(num % 2 == 0){
System.out.println("性别为:女");
}else{
System.out.println("性别为:男");
}
}
}
3.StringBuilder
StringBuilder 可以看成是一个容器,创建之后里面的内容是可变的。
当我们在拼接字符串和反转字符串的时候会使用到
3.1 基本使用
public class StringBuilderDemo3 {
public static void main(String[] args) {
//1.创建对象
StringBuilder sb = new StringBuilder("abc");
//2.添加元素
/*sb.append(1);
sb.append(2.3);
sb.append(true);*/
//反转
sb.reverse();
//获取长度
int len = sb.length();
System.out.println(len);
//打印
//普及:
//因为StringBuilder是Java已经写好的类
//java在底层对他做了一些特殊处理。
//打印对象不是地址值而是属性值。
System.out.println(sb);
}
}
3.2 链式编程
public class StringBuilderDemo4 {
public static void main(String[] args) {
//1.创建对象
StringBuilder sb = new StringBuilder();
//2.添加字符串
sb.append("aaa").append("bbb").append("ccc").append("ddd");
System.out.println(sb);//aaabbbcccddd
//3.再把StringBuilder变回字符串
String str = sb.toString();
System.out.println(str);//aaabbbcccddd
}
}
3.3 练习1:对称字符串
需求:
键盘接受一个字符串,程序判断出该字符串是否是对称字符串,并在控制台打印是或不是
对称字符串:123321、111
非对称字符串:123123
代码示例:
public class StringBuilderDemo6 {
//使用StringBuilder的场景:
//1.字符串的拼接
//2.字符串的反转
public static void main(String[] args) {
//1.键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String str = sc.next();
//2.反转键盘录入的字符串
String result = new StringBuilder().append(str).reverse().toString();
//3.比较
if(str.equals(result)){
System.out.println("当前字符串是对称字符串");
}else{
System.out.println("当前字符串不是对称字符串");
}
}
}
3.4 练习2:拼接字符串
需求:定义一个方法,把 int 数组中的数据按照指定的格式拼接成一个字符串返回。
调用该方法,并在控制台输出结果。
例如:数组为int[] arr = {1,2,3};
执行方法后的输出结果为:[1, 2, 3]
代码示例:
package com.itheima.stringbuilderdemo;
public class StringBuilderDemo7 {
public static void main(String[] args) {
//1.定义数组
int[] arr = {1,2,3};
//2.调用方法把数组变成字符串
String str = arrToString(arr);
System.out.println(str);
}
public static String arrToString(int[] arr){
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
if(i == arr.length - 1){
sb.append(arr[i]);
}else{
sb.append(arr[i]).append(", ");
}
}
sb.append("]");
return sb.toString();
}
}
4. StringJoiner
- StringJoiner跟StringBuilder一样,也可以看成是一个容器,创建之后里面的内容是可变的。
- 作用:提高字符串的操作效率,而且代码编写特别简洁,但是目前市场上很少有人用。
- JDK8出现的
基本使用:
//1.创建一个对象,并指定中间的间隔符号
StringJoiner sj = new StringJoiner("---");
//2.添加元素
sj.add("aaa").add("bbb").add("ccc");
//3.打印结果
System.out.println(sj);//aaa---bbb---ccc
//1.创建对象
StringJoiner sj = new StringJoiner(", ","[","]");
//2.添加元素
sj.add("aaa").add("bbb").add("ccc");
int len = sj.length();
System.out.println(len);//15
//3.打印
System.out.println(sj);//[aaa, bbb, ccc]
String str = sj.toString();
System.out.println(str);//[aaa, bbb, ccc]
关于字符串的小扩展:
-
字符串存储的内存原理
String s = “abc”;直接赋值
特点:
此时字符串abc是存在字符串常量池中的。
先检查字符串常量池中有没有字符串abc,如果有,不会创建新的,而是直接复用。如果没有abc,才会创建一个新的。
所以,直接赋值的方式,代码简单,而且节约内存。
-
new出来的字符串
看到new关键字,一定是在堆里面开辟了一个小空间。
String s1 = new String(“abc”);
String s2 = “abc”;
s1记录的是new出来的,在堆里面的地址值。
s2是直接赋值的,所以记录的是字符串常量池中的地址值。
-
==号比较的到底是什么?
如果比较的是基本数据类型:比的是具体的数值是否相等。
如果比较的是引用数据类型:比的是地址值是否相等。
结论:==只能用于比较基本数据类型。不能比较引用数据类型。
1.ArrayList
集合和数组的优势对比:
- 长度可变
- 添加数据的时候不需要考虑索引,默认将数据添加到末尾
1.1 ArrayList类概述
-
什么是集合
提供一种存储空间可变的存储模型,存储的数据容量可以发生改变
-
ArrayList集合的特点
长度可以变化,只能存储引用数据类型。
-
泛型的使用
用于约束集合中存储元素的数据类型
1.2 ArrayList类常用方法
1.2.1 构造方法
方法名 | 说明 |
---|---|
public ArrayList() | 创建一个空的集合对象 |
1.2.2 成员方法
方法名 | 说明 |
---|---|
public boolean add(要添加的元素) | 将指定的元素追加到此集合的末尾 |
public boolean remove(要删除的元素) | 删除指定元素,返回值表示是否删除成功 |
public E remove(int index) | 删除指定索引处的元素,返回被删除的元素 |
public E set(int index,E element) | 修改指定索引处的元素,返回被修改的元素 |
public E get(int index) | 返回指定索引处的元素 |
public int size() | 返回集合中的元素的个数 |
1.2.3 示例代码
public class ArrayListDemo02 {
public static void main(String[] args) {
//创建集合
ArrayList<String> array = new ArrayList<String>();
//添加元素
array.add("hello");
array.add("world");
array.add("java");
//public boolean remove(Object o):删除指定的元素,返回删除是否成功
// System.out.println(array.remove("world"));
// System.out.println(array.remove("javaee"));
//public E remove(int index):删除指定索引处的元素,返回被删除的元素
// System.out.println(array.remove(1));
//IndexOutOfBoundsException
// System.out.println(array.remove(3));
//public E set(int index,E element):修改指定索引处的元素,返回被修改的元素
// System.out.println(array.set(1,"javaee"));
//IndexOutOfBoundsException
// System.out.println(array.set(3,"javaee"));
//public E get(int index):返回指定索引处的元素
// System.out.println(array.get(0));
// System.out.println(array.get(1));
// System.out.println(array.get(2));
//System.out.println(array.get(3)); //?????? 自己测试
//public int size():返回集合中的元素的个数
System.out.println(array.size());
//输出集合
System.out.println("array:" + array);
}
}
1.3 ArrayList存储字符串并遍历
1.3.1 案例需求
创建一个存储字符串的集合,存储3个字符串元素,使用程序实现在控制台遍历该集合
1.3.2 代码实现
public class ArrayListDemo3 {
public static void main(String[] args) {
//1.创建集合对象
ArrayList<String> list = new ArrayList<>();
//2.添加元素
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
//3.遍历
//快捷键: list.fori 正向遍历
//list.forr 倒着遍历
System.out.print("[");
for (int i = 0; i < list.size(); i++) {
//i 依次表示集合里面的每一个索引
if(i == list.size() - 1){
//最大索引
System.out.print(list.get(i));
}else{
//非最大索引
System.out.print(list.get(i) + ", ");
}
}
System.out.print("]");
}
}
1.4 ArrayList存储学生对象并遍历
1.4.1 案例需求
创建一个存储学生对象的集合,存储3个学生对象,使用程序实现在控制台遍历该集合
1.4.2 代码实现
public class ArrayListDemo4 {
public static void main(String[] args) {
//1.创建集合对象,用来存储数据
ArrayList<Student> list = new ArrayList<>();
//2.创建学生对象
Student s1 = new Student("zhangsan",16);
Student s2 = new Student("lisi",15);
Student s3 = new Student("wangwu",18);
//3.把学生对象添加到集合中
list.add(s1);
list.add(s2);
list.add(s3);
//4.遍历
for (int i = 0; i < list.size(); i++) {
//i 依次表示集合中的每一个索引
Student stu = list.get(i);
System.out.println(stu.getName() + ", " + stu.getAge());
}
}
}
1.5 查找用户的索引
需求:
1,main方法中定义一个集合,存入三个用户对象。
用户属性为:id,username,password
2,要求:定义一个方法,根据id查找对应的学生信息。
如果存在,返回索引
如果不存在,返回-1
代码示例:
public class ArrayListDemo6 {
public static void main(String[] args) {
/*需求:
1,main方法中定义一个集合,存入三个用户对象。
用户属性为:id,username,password
2,要求:定义一个方法,根据id查找对应的学生信息。
如果存在,返回索引
如果不存在,返回-1*/
//1.创建集合对象
ArrayList<User> list = new ArrayList<>();
//2.创建用户对象
User u1 = new User("heima001", "zhangsan", "123456");
User u2 = new User("heima002", "lisi", "1234");
User u3 = new User("heima003", "wangwu", "1234qwer");
//3.把用户对象添加到集合当中
list.add(u1);
list.add(u2);
list.add(u3);
//4.调用方法,通过id获取对应的索引
int index = getIndex(list, "heima001");
System.out.println(index);
}
//1.我要干嘛? 根据id查找对应的学生信息
//2.我干这件事情需要什么才能完成? 集合 id
//3.方法的调用处是否需要继续使用方法的结果?
//要用必须返回,不要用可以返回也可以不返回
//明确说明需要有返回值 int
public static int getIndex(ArrayList<User> list, String id) {
//遍历集合得到每一个元素
for (int i = 0; i < list.size(); i++) {
User u = list.get(i);
String uid = u.getId();
if(uid.equals(id)){
return i;
}
}
//因为只有当集合里面所有的元素都比较完了,才能断定id是不存在的。
return -1;
}
}
1.6 判断用户的是否存在
public class ArrayListDemo5 {
public static void main(String[] args) {
/* 需求:
1,main方法中定义一个集合,存入三个用户对象。
用户属性为:id,username,password
2,要求:定义一个方法,根据id查找对应的学生信息。
如果存在,返回true
如果不存在,返回false*/
//1.定义集合
ArrayList<User> list = new ArrayList<>();
//2.创建对象
User u1 = new User("heima001","zhangsan","123456");
User u2 = new User("heima002","lisi","12345678");
User u3 = new User("heima003","wangwu","1234qwer");
//3.把用户对象添加到集合当中
list.add(u1);
list.add(u2);
list.add(u3);
//4.调用方法,查询id是否存在
boolean result = contains(list, "heima001");
System.out.println(result);
}
//定义在测试类中的方法需要加static
//1.我要干嘛? 我要根据id查询学生是否存在
//2.我干这件事情,需要什么才能完成? 集合 id
//3.方法的调用处是否需要使用方法的结果?
//如果要用,必须返回,如果不用,可以返回也可以不返回
//但是本题明确说明需要返回
public static boolean contains(ArrayList<User> list, String id){
//循环遍历集合,得到集合里面的每一个元素
//再进行判断
for (int i = 0; i < list.size(); i++) {
//i 索引 list.get(i); 元素
User u = list.get(i);
//判断id是否存在,我是拿着谁跟谁比较
//需要把用户对象里面的id拿出来再进行比较。
String uid = u.getId();
if(id.equals(uid)){
return true;//return 关键字:作用就是结束方法。
}
}
//只有当集合里面所有的元素全部比较完毕才能认为是不存在的。
return false;
}
}
2.学生管理系统
2.1学生管理系统实现步骤
-
案例需求
针对目前我们的所学内容,完成一个综合案例:学生管理系统。该系统主要功能如下:
添加学生:通过键盘录入学生信息,添加到集合中
删除学生:通过键盘录入要删除学生的学号,将该学生对象从集合中删除
修改学生:通过键盘录入要修改学生的学号,将该学生对象其他信息进行修改
查看学生:将集合中的学生对象信息进行展示
退出系统:结束程序
-
实现步骤
-
定义学生类,包含以下成员变量
private String sid // 学生id
private String name // 学生姓名
private String age // 学生年龄
private String address // 学生所在地
-
学生管理系统主界面的搭建步骤
2.1 用输出语句完成主界面的编写
2.2 用Scanner实现键盘输入
2.3 用switch语句完成选择的功能
2.4 用循环完成功能结束后再次回到主界面 -
学生管理系统的添加学生功能实现步骤
3.1 定义一个方法,接收ArrayList集合
3.2 方法内完成添加学生的功能
①键盘录入学生信息
②根据录入的信息创建学生对象
③将学生对象添加到集合中
④提示添加成功信息
3.3 在添加学生的选项里调用添加学生的方法 -
学生管理系统的查看学生功能实现步骤
4.1 定义一个方法,接收ArrayList集合
4.2 方法内遍历集合,将学生信息进行输出
4.3 在查看所有学生选项里调用查看学生方法 -
学生管理系统的删除学生功能实现步骤
5.1 定义一个方法,接收ArrayList集合
5.2 方法中接收要删除学生的学号
5.3 遍历集合,获取每个学生对象
5.4 使用学生对象的学号和录入的要删除的学号进行比较,如果相同,则将当前学生对象从集合中删除
5.5 在删除学生选项里调用删除学生的方法 -
学生管理系统的修改学生功能实现步骤
6.1 定义一个方法,接收ArrayList集合
6.2 方法中接收要修改学生的学号
6.3 通过键盘录入学生对象所需的信息,并创建对象
6.4 遍历集合,获取每一个学生对象。并和录入的修改学生学号进行比较.如果相同,则使用新学生对象替换当前学生对象
6.5 在修改学生选项里调用修改学生的方法 -
退出系统
使用System.exit(0);退出JVM
-
2.2学生类的定义
package com.itheima.studentsystem;
public class Student {
private String id;
private String name;
private int age;
private String address;
//下面是空参,有参,get和set方法
}
2.3测试类的定义
public class StudentSystem {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
loop:
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 choose = sc.next();
switch (choose) {
case "1" -> addStudent(list);
case "2" -> deleteStudent(list);
case "3" -> updateStudent(list);
case "4" -> queryStudent(list);
case "5" -> {
System.out.println("退出");
//break loop;
System.exit(0);//停止虚拟机运行
}
default -> System.out.println("没有这个选项");
}
}
}
//添加学生
public static void addStudent(ArrayList<Student> list) {
//利用空参构造先创建学生对象
Student s = new Student();
Scanner sc = new Scanner(System.in);
String id = null;
while (true) {
System.out.println("请输入学生的id");
id = sc.next();
boolean flag = contains(list, id);
if(flag){
//表示id已经存在,需要重新录入
System.out.println("id已经存在,请重新录入");
}else{
//表示id不存在,表示可以使用
s.setId(id);
break;
}
}
System.out.println("请输入学生的姓名");
String name = sc.next();
s.setName(name);
System.out.println("请输入学生的年龄");
int age = sc.nextInt();
s.setAge(age);
System.out.println("请输入学生的家庭住址");
String address = sc.next();
s.setAddress(address);
//把学生对象添加到集合当中
list.add(s);
//提示一下用户
System.out.println("学生信息添加成功");
}
//删除学生
public static void deleteStudent(ArrayList<Student> list) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入要删除的id");
String id = sc.next();
//查询id在集合中的索引
int index = getIndex(list, id);
//对index进行判断
//如果-1,就表示不存在,结束方法,回到初始菜单
if(index >= 0){
//如果大于等于0的,表示存在,直接删除
list.remove(index);
System.out.println("id为:" + id + "的学生删除成功");
}else{
System.out.println("id不存在,删除失败");
}
}
//修改学生
public static void updateStudent(ArrayList<Student> list) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入要修改学生的id");
String id = sc.next();
int index = getIndex(list, id);
if(index == -1){
System.out.println("要修改的id" + id + "不存在,请重新输入");
return;
}
//当代码执行到这里,表示什么?表示当前id是存在的。
//获取要修改的学生对象
Student stu = list.get(index);
//输入其他的信息并修改
System.out.println("请输入要修改的学生姓名");
String newName = sc.next();
stu.setName(newName);
System.out.println("请输入要修改的学生年龄");
int newAge = sc.nextInt();
stu.setAge(newAge);
System.out.println("请输入要修改的学生家庭住址");
String newAddress = sc.next();
stu.setAddress(newAddress);
System.out.println("学生信息修改成功");
}
//查询学生
public static void queryStudent(ArrayList<Student> list) {
if (list.size() == 0) {
System.out.println("当前无学生信息,请添加后再查询");
//结束方法
return;
}
//打印表头信息
System.out.println("id\t\t姓名\t年龄\t家庭住址");
//当代码执行到这里,表示集合中是有数据的
for (int i = 0; i < list.size(); i++) {
Student stu = list.get(i);
System.out.println(stu.getId() + "\t" + stu.getName() + "\t" + stu.getAge() + "\t" + stu.getAddress());
}
}
//判断id在集合中是否存在
public static boolean contains(ArrayList<Student> list, String id) {
//循环遍历集合得到里面的每一个学生对象
/*for (int i = 0; i < list.size(); i++) {
//拿到学生对象后,获取id并进行判断
Student stu = list.get(i);
String sid = stu.getId();
if(sid.equals(id)){
//存在,true
return true;
}
}
// 不存在false
return false;*/
return getIndex(list,id) >= 0;
}
//通过id获取索引的方法
public static int getIndex(ArrayList<Student> list, String id){
//遍历集合
for (int i = 0; i < list.size(); i++) {
//得到每一个学生对象
Student stu = list.get(i);
//得到每一个学生对象的id
String sid = stu.getId();
//拿着集合中的学生id跟要查询的id进行比较
if(sid.equals(id)){
//如果一样,那么就返回索引
return i;
}
}
//当循环结束之后还没有找到,就表示不存在,返回-1.
return -1;
}
}
学生管理系统升级版
需求:
为学生管理系统书写一个登陆、注册、忘记密码的功能。
只有用户登录成功之后,才能进入到学生管理系统中进行增删改查操作。
分析:
登录界面:
System.out.println("欢迎来到学生管理系统");
System.out.println("请选择操作1登录 2注册 3忘记密码");
用户类:
属性:用户名、密码、身份证号码、手机号码
注册功能:
1,用户名需要满足以下要求:
验证要求:
用户名唯一
用户名长度必须在3~15位之间
只能是字母加数字的组合,但是不能是纯数字
2,密码键盘输入两次,两次一致才可以进行注册。
3,身份证号码需要验证。
验证要求:
长度为18位
不能以0为开头
前17位,必须都是数字
最为一位可以是数字,也可以是大写X或小写x
4,手机号验证。
验证要求:
长度为11位
不能以0为开头
必须都是数字
登录功能:
1,键盘录入用户名
2,键盘录入密码
3,键盘录入验证码
验证要求:
用户名如果未注册,直接结束方法,并提示:用户名未注册,请先注册
判断验证码是否正确,如不正确,重新输入
再判断用户名和密码是否正确,有3次机会
忘记密码:
1,键盘录入用户名,判断当前用户名是否存在,如不存在,直接结束方法,并提示:未注册
2,键盘录入身份证号码和手机号码
3,判断当前用户的身份证号码和手机号码是否一致,
如果一致,则提示输入密码,进行修改。
如果不一致,则提示:账号信息不匹配,修改失败。
验证码规则:
长度为5
由4位大写或者小写字母和1位数字组成,同一个字母可重复
数字可以出现在任意位置
比如:
aQa1K
面向对象进阶部分学习方法:
特点:
逻辑性没有那么强,但是概念会比较多。
记忆部分重要的概念,理解课堂上讲解的需要大家掌握的概念,多多练习代码。
day13
今日内容
- 复习回顾
- static关键字
- 继承
教学目标
-
能够掌握static关键字修饰的变量调用方式
-
能够掌握static关键字修饰的方法调用方式
-
知道静态代码块的格式和应用场景
-
能够写出类的继承格式
-
能够说出继承的特点
-
能够区分this和super的作用
-
能够说出方法重写的概念
-
能够说出方法重写的注意事项
第一章 复习回顾
1.1 如何定义类
类的定义格式如下:
修饰符 class 类名 {
// 1.成员变量(属性)
// 2.成员方法 (行为)
// 3.构造方法 (初始化类的对象数据的)
}
例如:
public class Student {
// 1.成员变量
public String name ;
public char sex ; // '男' '女'
public int age;
}
1.2 如何通过类创建对象
类名 对象名称 = new 类名();
例如:
Student stu = new Student();
1.3 封装
1.3.1 封装的步骤
1.使用 private
关键字来修饰成员变量。
2.使用public
修饰getter和setter方法。
1.3.2 封装的步骤实现
- private修饰成员变量
public class Student {
private String name;
private int age;
}
- public修饰getter和setter方法
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) {
if (a > 0 && a <200) {
age = a;
} else {
System.out.println("年龄非法!");
}
}
public int getAge() {
return age;
}
}
1.4 构造方法
1.4.1 构造方法的作用
在创建对象的时候,给成员变量进行初始化。
初始化即赋值的意思。
1.4.2 构造方法的格式
修饰符 类名(形参列表) {
// 构造体代码,执行代码
}
1.4.3 构造方法的应用
首先定义一个学生类,代码如下:
public class Student {
// 1.成员变量
public String name;
public int age;
// 2.构造方法
public Student() {
System.out.println("无参数构造方法被调用");
}
}
接下来通过调用构造方法得到两个学生对象。
public class CreateStu02 {
public static void main(String[] args) {
// 创建一个学生对象
// 类名 变量名称 = new 类名();
Student s1 = new Student();
// 使用对象访问成员变量,赋值
s1.name = "张三";
s1.age = 20 ;
// 使用对象访问成员变量 输出值
System.out.println(s1.name);
System.out.println(s1.age);
Student s2 = new Student();
// 使用对象访问成员变量 赋值
s2.name = "李四";
s2.age = 18 ;
System.out.println(s2.name);
System.out.println(s2.age);
}
}
1.5 this关键字的作用
1.5.1 this关键字的作用
this代表所在类的当前对象的引用(地址值),即代表当前对象。
1.5.2 this关键字的应用
1.5.2.1 用于普通的gettter与setter方法
this出现在实例方法中,谁调用这个方法(哪个对象调用这个方法),this就代表谁(this就代表哪个对象)。
public class Student {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
if (age > 0 && age < 200) {
this.age = age;
} else {
System.out.println("年龄非法!");
}
}
public int getAge() {
return age;
}
}
1.5.2.2 用于构造方法中
this出现在构造方法中,代表构造方法正在初始化的那个对象。
public class Student {
private String name;
private int age;
// 无参数构造方法
public Student() {}
// 有参数构造方法
public Student(String name,int age) {
this.name = name;
this.age = age;
}
}
第二章 static关键字
2.1 概述
以前我们定义过如下类:
public class Student {
// 成员变量
public String name;
public char sex; // '男' '女'
public int age;
// 无参数构造方法
public Student() {
}
// 有参数构造方法
public Student(String a) {
}
}
我们已经知道面向对象中,存在类和对象的概念,我们在类中定义了一些成员变量,例如name,age,sex ,结果发现这些成员变量,每个对象都存在(因为每个对象都可以访问)。
而像name ,age , sex确实是每个学生对象都应该有的属性,应该属于每个对象。
所以Java中成员(变量和方法)等是存在所属性的,Java是通过static关键字来区分的。static关键字在Java开发非常的重要,对于理解面向对象非常关键。
关于 static
关键字的使用,它可以用来修饰的成员变量和成员方法,被static修饰的成员是属于类的是放在静态区中,没有static修饰的成员变量和方法则是属于对象的。我们上面案例中的成员变量都是没有static修饰的,所以属于每个对象。
2.2 定义格式和使用
static是静态的意思。 static可以修饰成员变量或者修饰方法。
2.2.1 静态变量及其访问
有static修饰成员变量,说明这个成员变量是属于类的,这个成员变量称为类变量或者静态成员变量。 直接用 类名访问即可。因为类只有一个,所以静态成员变量在内存区域中也只存在一份。所有的对象都可以共享这个变量。
如何使用呢
例如现在我们需要定义传智全部的学生类,那么这些学生类的对象的学校属性应该都是“传智”,这个时候我们可以把这个属性定义成static修饰的静态成员变量。
定义格式
修饰符 static 数据类型 变量名 = 初始值;
举例
public class Student {
public static String schoolName = "传智播客"; // 属于类,只有一份。
// .....
}
静态成员变量的访问:
格式:类名.静态变量
public static void main(String[] args){
System.out.println(Student.schoolName); // 传智播客
Student.schoolName = "黑马程序员";
System.out.println(Student.schoolName); // 黑马程序员
}
2.2.2 实例变量及其访问
无static修饰的成员变量属于每个对象的, 这个成员变量叫实例变量,之前我们写成员变量就是实例成员变量。
需要注意的是:实例成员变量属于每个对象,必须创建类的对象才可以访问。
格式:对象.实例成员变量
2.2.3 静态方法及其访问
有static修饰成员方法,说明这个成员方法是属于类的,这个成员方法称为类方法或者静态方法**。 直接用 类名访问即可。因为类只有一个,所以静态方法在内存区域中也只存在一份。所有的对象都可以共享这个方法。
与静态成员变量一样,静态方法也是直接通过类名.方法名称即可访问。
举例
public class Student{
public static String schoolName = "传智播客"; // 属于类,只有一份。
// .....
public static void study(){
System.out.println("我们都在黑马程序员学习");
}
}
静态成员变量的访问:
格式:类名.静态方法
public static void main(String[] args){
Student.study();
}
2.2.4 实例方法及其访问
无static修饰的成员方法属于每个对象的,这个成员方法也叫做实例方法。
需要注意的是:实例方法是属于每个对象,必须创建类的对象才可以访问。
格式:对象.实例方法
示例:
public class Student {
// 实例变量
private String name ;
// 2.方法:行为
// 无 static修饰,实例方法。属于每个对象,必须创建对象调用
public void run(){
System.out.println("学生可以跑步");
}
// 无 static修饰,实例方法
public void sleep(){
System.out.println("学生睡觉");
}
public static void study(){
}
}
public static void main(String[] args){
// 创建对象
Student stu = new Student ;
stu.name = "徐干";
// Student.sleep();// 报错,必须用对象访问。
stu.sleep();
stu.run();
}
2.3 小结
1.当 static
修饰成员变量或者成员方法时,该变量称为静态变量,该方法称为静态方法。该类的每个对象都共享同一个类的静态变量和静态方法。任何对象都可以更改该静态变量的值或者访问静态方法。但是不推荐这种方式去访问。因为静态变量或者静态方法直接通过类名访问即可,完全没有必要用对象去访问。
2.无static修饰的成员变量或者成员方法,称为实例变量,实例方法,实例变量和实例方法必须创建类的对象,然后通过对象来访问。
3.static修饰的成员属于类,会存储在静态区,是随着类的加载而加载的,且只加载一次,所以只有一份,节省内存。存储于一块固定的内存区域(静态区),所以,可以直接被类名调用。它优先于对象存在,所以,可以被所有对象共享。
4.无static修饰的成员,是属于对象,对象有多少个,他们就会出现多少份。所以必须由对象调用。
第三章 继承
3.1 概述
3.1.1 引入
假如我们要定义如下类:
学生类,老师类和工人类,分析如下。
-
学生类
属性:姓名,年龄
行为:吃饭,睡觉 -
老师类
属性:姓名,年龄,薪水
行为:吃饭,睡觉,教书 -
班主任
属性:姓名,年龄,薪水
行为:吃饭,睡觉,管理
如果我们定义了这三个类去开发一个系统,那么这三个类中就存在大量重复的信息(属性:姓名,年龄。行为:吃饭,睡觉)。这样就导致了相同代码大量重复,代码显得很臃肿和冗余,那么如何解决呢?
假如多个类中存在相同属性和行为时,我们可以将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那一个类即可。如图所示:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HOPkGzcn-1688475722473)(imgs/1.jpg)]
其中,多个类可以称为子类,单独被继承的那一个类称为父类、超类(superclass)或者基类。
3.1.2 继承的含义
继承描述的是事物之间的所属关系,这种关系是:is-a
的关系。例如,兔子属于食草动物,食草动物属于动物。可见,父类更通用,子类更具体。我们通过继承,可以使多种事物之间形成一种关系体系。
继承:就是子类继承父类的属性和行为,使得子类对象可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。
3.1.3 继承的好处
- 提高代码的复用性(减少代码冗余,相同代码重复利用)。
- 使类与类之间产生了关系。
3.2 继承的格式
通过 extends
关键字,可以声明一个子类继承另外一个父类,定义格式如下:
class 父类 {
...
}
class 子类 extends 父类 {
...
}
需要注意:Java是单继承的,一个类只能继承一个直接父类,跟现实世界很像,但是Java中的子类是更加强大的。
3.3 继承案例
3.3.1 案例
请使用继承定义以下类:
- 学生类
属性:姓名,年龄
行为:吃饭,睡觉 - 老师类
属性:姓名,年龄,薪水
行为:吃饭,睡觉,教书 - 班主任
属性:姓名,年龄,薪水
行为:吃饭,睡觉,管理
3.3.2 案例图解分析
老师类,学生类,还有班主任类,实际上都是属于人类的,我们可以定义一个人类,把他们相同的属性和行为都定义在人类中,然后继承人类即可,子类特有的属性和行为就定义在子类中了。
如下图所示。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FN5PE9bw-1688475722475)(imgs/360截图20181202211331250.jpg)]
3.3.3 案例代码实现
1.父类Human类
public class Human {
// 合理隐藏
private String name ;
private int 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;
}
}
2.子类Teacher类
public class Teacher extends Human {
// 工资
private double salary ;
// 特有方法
public void teach(){
System.out.println("老师在认真教技术!");
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
3.子类Student类
public class Student extends Human{
}
4.子类BanZhuren类
public class Teacher extends Human {
// 工资
private double salary ;
// 特有方法
public void admin(){
System.out.println("班主任强调纪律问题!");
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
5.测试类
public class Test {
public static void main(String[] args) {
Teacher dlei = new Teacher();
dlei.setName("播仔");
dlei.setAge("31");
dlei.setSalary(1000.99);
System.out.println(dlei.getName());
System.out.println(dlei.getAge());
System.out.println(dlei.getSalary());
dlei.teach();
BanZhuRen linTao = new BanZhuRen();
linTao.setName("灵涛");
linTao.setAge("28");
linTao.setSalary(1000.99);
System.out.println(linTao.getName());
System.out.println(linTao.getAge());
System.out.println(linTao.getSalary());
linTao.admin();
Student xugan = new Student();
xugan.setName("播仔");
xugan.setAge("31");
//xugan.setSalary(1000.99); // xugan没有薪水属性,报错!
System.out.println(xugan.getName());
System.out.println(xugan.getAge());
}
}
3.3.4 小结
1.继承实际上是子类相同的属性和行为可以定义在父类中,子类特有的属性和行为由自己定义,这样就实现了相同属性和行为的重复利用,从而提高了代码复用。
2.子类继承父类,就可以直接得到父类的成员变量和方法。是否可以继承所有成分呢?请看下节!
3.4 子类不能继承的内容
3.4.1 引入
并不是父类的所有内容都可以给子类继承的:
子类不能继承父类的构造方法。
值得注意的是子类可以继承父类的私有成员(成员变量,方法),只是子类无法直接访问而已,可以通过getter/setter方法访问父类的private成员变量。
3.4.1 演示代码
public class Demo03 {
public static void main(String[] args) {
Zi z = new Zi();
System.out.println(z.num1);
// System.out.println(z.num2); // 私有的子类无法使用
// 通过getter/setter方法访问父类的private成员变量
System.out.println(z.getNum2());
z.show1();
// z.show2(); // 私有的子类无法使用
}
}
class Fu {
public int num1 = 10;
private int num2 = 20;
public void show1() {
System.out.println("show1");
}
private void show2() {
System.out.println("show2");
}
public int getNum2() {
return num2;
}
public void setNum2(int num2) {
this.num2 = num2;
}
}
class Zi extends Fu {
}
3.5 继承后的特点—成员变量
当类之间产生了继承关系后,其中各类中的成员变量,又产生了哪些影响呢?
3.5.1 成员变量不重名
如果子类父类中出现不重名的成员变量,这时的访问是没有影响的。代码如下:
class Fu {
// Fu中的成员变量
int num = 5;
}
class Zi extends Fu {
// Zi中的成员变量
int num2 = 6;
// Zi中的成员方法
public void show() {
// 访问父类中的num
System.out.println("Fu num="+num); // 继承而来,所以直接访问。
// 访问子类中的num2
System.out.println("Zi num2="+num2);
}
}
class Demo04 {
public static void main(String[] args) {
// 创建子类对象
Zi z = new Zi();
// 调用子类中的show方法
z.show();
}
}
演示结果:
Fu num = 5
Zi num2 = 6
3.5.2 成员变量重名
如果子类父类中出现重名的成员变量,这时的访问是有影响的。代码如下:
class Fu1 {
// Fu中的成员变量。
int num = 5;
}
class Zi1 extends Fu1 {
// Zi中的成员变量
int num = 6;
public void show() {
// 访问父类中的num
System.out.println("Fu num=" + num);
// 访问子类中的num
System.out.println("Zi num=" + num);
}
}
class Demo04 {
public static void main(String[] args) {
// 创建子类对象
Zi1 z = new Zi1();
// 调用子类中的show方法
z1.show();
}
}
演示结果:
Fu num = 6
Zi num = 6
子父类中出现了同名的成员变量时,子类会优先访问自己对象中的成员变量。如果此时想访问父类成员变量如何解决呢?我们可以使用super关键字。
3.5.3 super访问父类成员变量
子父类中出现了同名的成员变量时,在子类中需要访问父类中非私有成员变量时,需要使用super
关键字,修饰父类成员变量,类似于之前学过的 this
。
需要注意的是:super代表的是父类对象的引用,this代表的是当前对象的引用。
使用格式:
super.父类成员变量名
子类方法需要修改,代码如下:
class Fu {
// Fu中的成员变量。
int num = 5;
}
class Zi extends Fu {
// Zi中的成员变量
int num = 6;
public void show() {
int num = 1;
// 访问方法中的num
System.out.println("method num=" + num);
// 访问子类中的num
System.out.println("Zi num=" + this.num);
// 访问父类中的num
System.out.println("Fu num=" + super.num);
}
}
class Demo04 {
public static void main(String[] args) {
// 创建子类对象
Zi1 z = new Zi1();
// 调用子类中的show方法
z1.show();
}
}
演示结果:
method num=1
Zi num=6
Fu num=5
小贴士:Fu 类中的成员变量是非私有的,子类中可以直接访问。若Fu 类中的成员变量私有了,子类是不能直接访问的。通常编码时,我们遵循封装的原则,使用private修饰成员变量,那么如何访问父类的私有成员变量呢?对!可以在父类中提供公共的getXxx方法和setXxx方法。
3.6 继承后的特点—成员方法
当类之间产生了关系,其中各类中的成员方法,又产生了哪些影响呢?
3.6.1 成员方法不重名
如果子类父类中出现不重名的成员方法,这时的调用是没有影响的。对象调用方法时,会先在子类中查找有没有对应的方法,若子类中存在就会执行子类中的方法,若子类中不存在就会执行父类中相应的方法。代码如下:
class Fu {
public void show() {
System.out.println("Fu类中的show方法执行");
}
}
class Zi extends Fu {
public void show2() {
System.out.println("Zi类中的show2方法执行");
}
}
public class Demo05 {
public static void main(String[] args) {
Zi z = new Zi();
//子类中没有show方法,但是可以找到父类方法去执行
z.show();
z.show2();
}
}
3.6.2 成员方法重名
如果子类父类中出现重名的成员方法,则创建子类对象调用该方法的时候,子类对象会优先调用自己的方法。
代码如下:
class Fu {
public void show() {
System.out.println("Fu show");
}
}
class Zi extends Fu {
//子类重写了父类的show方法
public void show() {
System.out.println("Zi show");
}
}
public class ExtendsDemo05{
public static void main(String[] args) {
Zi z = new Zi();
// 子类中有show方法,只执行重写后的show方法
z.show(); // Zi show
}
}
3.7 方法重写
3.7.1 概念
方法重写 :子类中出现与父类一模一样的方法时(返回值类型,方法名和参数列表都相同),会出现覆盖效果,也称为重写或者复写。声明不变,重新实现。
3.7.2 使用场景与案例
发生在子父类之间的关系。
子类继承了父类的方法,但是子类觉得父类的这方法不足以满足自己的需求,子类重新写了一个与父类同名的方法,以便覆盖父类的该方 法。
例如:我们定义了一个动物类代码如下:
public class Animal {
public void run(){
System.out.println("动物跑的很快!");
}
public void cry(){
System.out.println("动物都可以叫~~~");
}
}
然后定义一个猫类,猫可能认为父类cry()方法不能满足自己的需求
代码如下:
public class Cat extends Animal {
public void cry(){
System.out.println("我们一起学猫叫,喵喵喵!喵的非常好听!");
}
}
public class Test {
public static void main(String[] args) {
// 创建子类对象
Cat ddm = new Cat();
// 调用父类继承而来的方法
ddm.run();
// 调用子类重写的方法
ddm.cry();
}
}
3.7.2 @Override重写注解
-
@Override:注解,重写注解校验!
-
这个注解标记的方法,就说明这个方法必须是重写父类的方法,否则编译阶段报错。
-
建议重写都加上这个注解,一方面可以提高代码的可读性,一方面可以防止重写出错!
加上后的子类代码形式如下:
public class Cat extends Animal { // 声明不变,重新实现 // 方法名称与父类全部一样,只是方法体中的功能重写写了! @Override public void cry(){ System.out.println("我们一起学猫叫,喵喵喵!喵的非常好听!"); } }
3.7.3 注意事项
- 方法重写是发生在子父类之间的关系。
- 子类方法覆盖父类方法,必须要保证权限大于等于父类权限。
- 子类方法覆盖父类方法,返回值类型、函数名和参数列表都要一模一样。
3.8 继承后的特点—构造方法
3.8.1 引入
当类之间产生了关系,其中各类中的构造方法,又产生了哪些影响呢?
首先我们要回忆两个事情,构造方法的定义格式和作用。
- 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
- 构造方法的作用是初始化对象成员变量数据的。所以子类的初始化过程中,必须先执行父类的初始化动作。子类的构造方法中默认有一个
super()
,表示调用父类的构造方法,父类成员变量初始化后,才可以给子类使用。(先有爸爸,才能有儿子)
继承后子类构方法器特点:子类所有构造方法的第一行都会默认先调用父类的无参构造方法
3.8.2 案例演示
按如下需求定义类:
- 人类
成员变量: 姓名,年龄
成员方法: 吃饭 - 学生类
成员变量: 姓名,年龄,成绩
成员方法: 吃饭
代码如下:
class Person {
private String name;
private int age;
public Person() {
System.out.println("父类无参");
}
// getter/setter省略
}
class Student extends Person {
private double score;
public Student() {
//super(); // 调用父类无参,默认就存在,可以不写,必须再第一行
System.out.println("子类无参");
}
public Student(double score) {
//super(); // 调用父类无参,默认就存在,可以不写,必须再第一行
this.score = score;
System.out.println("子类有参");
}
}
public class Demo07 {
public static void main(String[] args) {
Student s1 = new Student();
System.out.println("----------");
Student s2 = new Student(99.9);
}
}
输出结果:
父类无参
子类无参
----------
父类无参
子类有参
3.8.3 小结
- 子类构造方法执行的时候,都会在第一行默认先调用父类无参数构造方法一次。
- 子类构造方法的第一行都隐含了一个**super()**去调用父类无参数构造方法,**super()**可以省略不写。
3.9 super(…)和this(…)
3.9.1 引入
请看上节中的如下案例:
class Person {
private String name;
private int age;
public Person() {
System.out.println("父类无参");
}
// getter/setter省略
}
class Student extends Person {
private double score;
public Student() {
//super(); // 调用父类无参构造方法,默认就存在,可以不写,必须再第一行
System.out.println("子类无参");
}
public Student(double score) {
//super(); // 调用父类无参构造方法,默认就存在,可以不写,必须再第一行
this.score = score;
System.out.println("子类有参");
}
// getter/setter省略
}
public class Demo07 {
public static void main(String[] args) {
// 调用子类有参数构造方法
Student s2 = new Student(99.9);
System.out.println(s2.getScore()); // 99.9
System.out.println(s2.getName()); // 输出 null
System.out.println(s2.getAge()); // 输出 0
}
}
我们发现,子类有参数构造方法只是初始化了自己对象中的成员变量score,而父类中的成员变量name和age依然是没有数据的,怎么解决这个问题呢,我们可以借助与super(…)去调用父类构造方法,以便初始化继承自父类对象的name和age.
3.9.2 super和this的用法格式
super和this完整的用法如下,其中this,super访问成员我们已经接触过了。
this.成员变量 -- 本类的
super.成员变量 -- 父类的
this.成员方法名() -- 本类的
super.成员方法名() -- 父类的
接下来我们使用调用构造方法格式:
super(...) -- 调用父类的构造方法,根据参数匹配确认
this(...) -- 调用本类的其他构造方法,根据参数匹配确认
3.9.3 super(…)用法演示
代码如下:
class Person {
private String name ="凤姐";
private int age = 20;
public Person() {
System.out.println("父类无参");
}
public Person(String name , int age){
this.name = name ;
this.age = age ;
}
// getter/setter省略
}
class Student extends Person {
private double score = 100;
public Student() {
//super(); // 调用父类无参构造方法,默认就存在,可以不写,必须再第一行
System.out.println("子类无参");
}
public Student(String name , int age,double score) {
super(name ,age);// 调用父类有参构造方法Person(String name , int age)初始化name和age
this.score = score;
System.out.println("子类有参");
}
// getter/setter省略
}
public class Demo07 {
public static void main(String[] args) {
// 调用子类有参数构造方法
Student s2 = new Student("张三",20,99);
System.out.println(s2.getScore()); // 99
System.out.println(s2.getName()); // 输出 张三
System.out.println(s2.getAge()); // 输出 20
}
}
注意:
子类的每个构造方法中均有默认的super(),调用父类的空参构造。手动调用父类构造会覆盖默认的super()。
super() 和 this() 都必须是在构造方法的第一行,所以不能同时出现。
super(…)是根据参数去确定调用父类哪个构造方法的。
3.9.4 super(…)案例图解
父类空间优先于子类对象产生
在每次创建子类对象时,先初始化父类空间,再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间,便可以包含其父类的成员,如果父类成员非private修饰,则子类可以随意使用父类成员。代码体现在子类的构造七调用时,一定先调用父类的构造方法。理解图解如下:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-92u2uuqZ-1688475722476)(imgs/2.jpg)]
3.9.5 this(…)用法演示
this(…)
- 默认是去找本类中的其他构造方法,根据参数来确定具体调用哪一个构造方法。
- 为了借用其他构造方法的功能。
package com.itheima._08this和super调用构造方法;
/**
* this(...):
* 默认是去找本类中的其他构造方法,根据参数来确定具体调用哪一个构造方法。
* 为了借用其他构造方法的功能。
*
*/
public class ThisDemo01 {
public static void main(String[] args) {
Student xuGan = new Student();
System.out.println(xuGan.getName()); // 输出:徐干
System.out.println(xuGan.getAge());// 输出:21
System.out.println(xuGan.getSex());// 输出: 男
}
}
class Student{
private String name ;
private int age ;
private char sex ;
public Student() {
// 很弱,我的兄弟很牛逼啊,我可以调用其他构造方法:Student(String name, int age, char sex)
this("徐干",21,'男');
}
public Student(String name, int age, char sex) {
this.name = name ;
this.age = age ;
this.sex = sex ;
}
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 char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}
3.9.6 小结
-
子类的每个构造方法中均有默认的super(),调用父类的空参构造。手动调用父类构造会覆盖默认的super()。
-
super() 和 this() 都必须是在构造方法的第一行,所以不能同时出现。
-
super(…)和this(…)是根据参数去确定调用父类哪个构造方法的。
-
super(…)可以调用父类构造方法初始化继承自父类的成员变量的数据。
-
this(…)可以调用本类中的其他构造方法。
3.10 继承的特点
- Java只支持单继承,不支持多继承。
// 一个类只能有一个父类,不可以有多个父类。
class A {}
class B {}
class C1 extends A {} // ok
// class C2 extends A, B {} // error
- 一个类可以有多个子类。
// A可以有多个子类
class A {}
class C1 extends A {}
class C2 extends A {}
- 可以多层继承。
class A {}
class C1 extends A {}
class D extends C1 {}
顶层父类是Object类。所有的类默认继承Object,作为父类。
4. 关于今天知识的小结:
会写一个继承结构下的标准Javabean即可
需求:
猫:属性,姓名,年龄,颜色
狗:属性,姓名,年龄,颜色,吼叫
分享书写技巧:
1.在大脑中要区分谁是父,谁是子
2.把共性写到父类中,独有的东西写在子类中
3.开始编写标准Javabean(从上往下写)
4.在测试类中,创建对象并赋值调用
代码示例:
package com.itheima.test4;
public class Animal {
//姓名,年龄,颜色
private String name;
private int age;
private String color;
public Animal() {
}
public Animal(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
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 getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
public class Cat extends Animal{
//因为猫类中没有独有的属性。
//所以此时不需要写私有的成员变量
//空参
public Cat() {
}
//需要带子类和父类中所有的属性
public Cat(String name, int age, String color) {
super(name,age,color);
}
}
public class Dog extends Animal{
//Dog :吼叫
private String wang;
//构造
public Dog() {
}
//带参构造:带子类加父类所有的属性
public Dog(String name, int age, String color,String wang) {
//共性的属性交给父类赋值
super(name,age,color);
//独有的属性自己赋值
this.wang = wang;
}
public String getWang() {
return wang;
}
public void setWang(String wang) {
this.wang = wang;
}
}
public class Demo {
public static void main(String[] args) {
//Animal : 姓名,年龄,颜色
//Cat :
//Dog :吼叫
//创建狗的对象
Dog d = new Dog("旺财",2,"黑色","嗷呜~~");
System.out.println(d.getName()+", " + d.getAge() + ", " + d.getColor() + ", " + d.getWang());
//创建猫的对象
Cat c = new Cat("中华田园猫",3,"黄色");
System.out.println(c.getName() + ", " + c.getAge() + ", " + c.getColor());
}
}
day14
今日内容
- 多态
- 包
- final
- 权限修饰符
- 代码块
教学目标
-
能够说出使用多态的前提条件
-
理解多态的向上转型
-
理解多态的向下转型
-
能够知道多态的使用场景
-
包的作用
-
public和private权限修饰符的作用
-
描述final修饰的类的特点
-
描述final修饰的方法的特点
-
描述final修饰的变量的特点
第一章 多态
1.1 多态的形式
多态是继封装、继承之后,面向对象的第三大特性。
多态是出现在继承或者实现关系中的。
多态体现的格式:
父类类型 变量名 = new 子类/实现类构造器;
变量名.方法名();
多态的前提:有继承关系,子类对象是可以赋值给父类类型的变量。例如Animal是一个动物类型,而Cat是一个猫类型。Cat继承了Animal,Cat对象也是Animal类型,自然可以赋值给父类类型的变量。
1.2 多态的使用场景
如果没有多态,在下图中register方法只能传递学生对象,其他的Teacher和administrator对象是无法传递给register方法方法的,在这种情况下,只能定义三个不同的register方法分别接收学生,老师和管理员。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dc5PHoeZ-1688475746481)(.\img\多态的应用场景1.png)]
有了多态之后,方法的形参就可以定义为共同的父类Person。
要注意的是:
- 当一个方法的形参是一个类,我们可以传递这个类所有的子类对象。
- 当一个方法的形参是一个接口,我们可以传递这个接口所有的实现类对象(后面会学)。
- 而且多态还可以根据传递的不同对象来调用不同类中的方法。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cMCl0SGh-1688475746483)(.\img\多态的应用场景2.png)]
代码示例:
父类:
public class Person {
private String name;
private int age;
空参构造
带全部参数的构造
get和set方法
public void show(){
System.out.println(name + ", " + age);
}
}
子类1:
public class Administrator extends Person {
@Override
public void show() {
System.out.println("管理员的信息为:" + getName() + ", " + getAge());
}
}
子类2:
public class Student extends Person{
@Override
public void show() {
System.out.println("学生的信息为:" + getName() + ", " + getAge());
}
}
子类3:
public class Teacher extends Person{
@Override
public void show() {
System.out.println("老师的信息为:" + getName() + ", " + getAge());
}
}
测试类:
public class Test {
public static void main(String[] args) {
//创建三个对象,并调用register方法
Student s = new Student();
s.setName("张三");
s.setAge(18);
Teacher t = new Teacher();
t.setName("王建国");
t.setAge(30);
Administrator admin = new Administrator();
admin.setName("管理员");
admin.setAge(35);
register(s);
register(t);
register(admin);
}
//这个方法既能接收老师,又能接收学生,还能接收管理员
//只能把参数写成这三个类型的父类
public static void register(Person p){
p.show();
}
}
1.3 多态的定义和前提
多态: 是指同一行为,具有多个不同表现形式。
从上面案例可以看出,Cat和Dog都是动物,都是吃这一行为,但是出现的效果(表现形式)是不一样的。
前提【重点】
-
有继承或者实现关系
-
方法的重写【意义体现:不重写,无意义】
-
父类引用指向子类对象【格式体现】
父类类型:指子类对象继承的父类类型,或者实现的父接口类型。
1.4 多态的运行特点
调用成员变量时:编译看左边,运行看左边
调用成员方法时:编译看左边,运行看右边
代码示例:
Fu f = new Zi();
//编译看左边的父类中有没有name这个属性,没有就报错
//在实际运行的时候,把父类name属性的值打印出来
System.out.println(f.name);
//编译看左边的父类中有没有show这个方法,没有就报错
//在实际运行的时候,运行的是子类中的show方法
f.show();
1.5 多态的弊端
我们已经知道多态编译阶段是看左边父类类型的,如果子类有些独有的功能,此时多态的写法就无法访问子类独有功能了。
class Animal{
public void eat(){
System.out.println("动物吃东西!")
}
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void catchMouse() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
}
class Test{
public static void main(String[] args){
Animal a = new Cat();
a.eat();
a.catchMouse();//编译报错,编译看左边,Animal没有这个方法
}
}
1.6 引用类型转换
1.6.1 为什么要转型
多态的写法就无法访问子类独有功能了。
当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误。也就是说,不能调用子类拥有,而父类没有的方法。编译都错误,更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以,想要调用子类特有的方法,必须做向下转型。
回顾基本数据类型转换
- 自动转换: 范围小的赋值给范围大的.自动完成:double d = 5;
- 强制转换: 范围大的赋值给范围小的,强制转换:int i = (int)3.14
多态的转型分为向上转型(自动转换)与向下转型(强制转换)两种。
1.6.2 向上转型(自动转换)
- 向上转型:多态本身是子类类型向父类类型向上转换(自动转换)的过程,这个过程是默认的。
当父类引用指向一个子类对象时,便是向上转型。
使用格式:
父类类型 变量名 = new 子类类型();
如:Animal a = new Cat();
**原因是:父类类型相对与子类来说是大范围的类型,Animal是动物类,是父类类型。Cat是猫类,是子类类型。Animal类型的范围当然很大,包含一切动物。**所以子类范围小可以直接自动转型给父类类型的变量。
1.6.3 向下转型(强制转换)
- 向下转型:父类类型向子类类型向下转换的过程,这个过程是强制的。
一个已经向上转型的子类对象,将父类引用转为子类引用,可以使用强制类型转换的格式,便是向下转型。
使用格式:
子类类型 变量名 = (子类类型) 父类变量名;
如:Aniaml a = new Cat();
Cat c =(Cat) a;
1.6.4 案例演示
当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误。也就是说,不能调用子类拥有,而父类没有的方法。编译都错误,更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以,想要调用子类特有的方法,必须做向下转型。
转型演示,代码如下:
定义类:
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void catchMouse() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void watchHouse() {
System.out.println("看家");
}
}
定义测试类:
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat 的 catchMouse
}
}
1.6.5 转型的异常
转型的过程中,一不小心就会遇到这样的问题,请看如下代码:
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】
}
}
这段代码可以通过编译,但是运行时,却报出了 ClassCastException
,类型转换异常!这是因为,明明创建了Cat类型对象,运行时,当然不能转换成Dog对象的。
1.6.6 instanceof关键字
为了避免ClassCastException的发生,Java提供了 instanceof
关键字,给引用变量做类型的校验,格式如下:
变量名 instanceof 数据类型
如果变量属于该数据类型或者其子类类型,返回true。
如果变量不属于该数据类型或者其子类类型,返回false。
所以,转换前,我们最好先做一个判断,代码如下:
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
if (a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat 的 catchMouse
} else if (a instanceof Dog){
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse
}
}
}
1.6.7 instanceof新特性
JDK14的时候提出了新特性,把判断和强转合并成了一行
//新特性
//先判断a是否为Dog类型,如果是,则强转成Dog类型,转换之后变量名为d
//如果不是,则不强转,结果直接是false
if(a instanceof Dog d){
d.lookHome();
}else if(a instanceof Cat c){
c.catchMouse();
}else{
System.out.println("没有这个类型,无法转换");
}
1.7 综合练习
需求:根据需求完成代码:
1.定义狗类
属性:
年龄,颜色
行为:
eat(String something)(something表示吃的东西)
看家lookHome方法(无参数)
2.定义猫类
属性:
年龄,颜色
行为:
eat(String something)方法(something表示吃的东西)
逮老鼠catchMouse方法(无参数)
3.定义Person类//饲养员
属性:
姓名,年龄
行为:
keepPet(Dog dog,String something)方法
功能:喂养宠物狗,something表示喂养的东西
行为:
keepPet(Cat cat,String something)方法
功能:喂养宠物猫,something表示喂养的东西
生成空参有参构造,set和get方法
4.定义测试类(完成以下打印效果):
keepPet(Dog dog,String somethind)方法打印内容如下:
年龄为30岁的老王养了一只黑颜色的2岁的狗
2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
keepPet(Cat cat,String somethind)方法打印内容如下:
年龄为25岁的老李养了一只灰颜色的3岁的猫
3岁的灰颜色的猫眯着眼睛侧着头吃鱼
5.思考:
1.Dog和Cat都是Animal的子类,以上案例中针对不同的动物,定义了不同的keepPet方法,过于繁琐,能否简化,并体会简化后的好处?
2.Dog和Cat虽然都是Animal的子类,但是都有其特有方法,能否想办法在keepPet中调用特有方法?
画图分析:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KuosozKj-1688475746484)(.\img\多态练习的分析.png)]
代码示例:
//动物类(父类)
public class Animal {
private int age;
private String color;
public Animal() {
}
public Animal(int age, String color) {
this.age = age;
this.color = color;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void eat(String something){
System.out.println("动物在吃" + something);
}
}
//猫类(子类)
public class Cat extends Animal {
public Cat() {
}
public Cat(int age, String color) {
super(age, color);
}
@Override
public void eat(String something) {
System.out.println(getAge() + "岁的" + getColor() + "颜色的猫眯着眼睛侧着头吃" + something);
}
public void catchMouse(){
System.out.println("猫抓老鼠");
}
}
//狗类(子类)
public class Dog extends Animal {
public Dog() {
}
public Dog(int age, String color) {
super(age, color);
}
//行为
//eat(String something)(something表示吃的东西)
//看家lookHome方法(无参数)
@Override
public void eat(String something) {
System.out.println(getAge() + "岁的" + getColor() + "颜色的狗两只前腿死死的抱住" + something + "猛吃");
}
public void lookHome(){
System.out.println("狗在看家");
}
}
//饲养员类
public class Person {
private String name;
private int age;
public Person() {
}
public Person(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;
}
//饲养狗
/* public void keepPet(Dog dog, String something) {
System.out.println("年龄为" + age + "岁的" + name + "养了一只" + dog.getColor() + "颜色的" + dog.getAge() + "岁的狗");
dog.eat(something);
}
//饲养猫
public void keepPet(Cat cat, String something) {
System.out.println("年龄为" + age + "岁的" + name + "养了一只" + cat.getColor() + "颜色的" + cat.getAge() + "岁的猫");
cat.eat(something);
}*/
//想要一个方法,能接收所有的动物,包括猫,包括狗
//方法的形参:可以写这些类的父类 Animal
public void keepPet(Animal a, String something) {
if(a instanceof Dog d){
System.out.println("年龄为" + age + "岁的" + name + "养了一只" + a.getColor() + "颜色的" + a.getAge() + "岁的狗");
d.eat(something);
}else if(a instanceof Cat c){
System.out.println("年龄为" + age + "岁的" + name + "养了一只" + c.getColor() + "颜色的" + c.getAge() + "岁的猫");
c.eat(something);
}else{
System.out.println("没有这种动物");
}
}
}
//测试类
public class Test {
public static void main(String[] args) {
//创建对象并调用方法
/* Person p1 = new Person("老王",30);
Dog d = new Dog(2,"黑");
p1.keepPet(d,"骨头");
Person p2 = new Person("老李",25);
Cat c = new Cat(3,"灰");
p2.keepPet(c,"鱼");*/
//创建饲养员的对象
Person p = new Person("老王",30);
Dog d = new Dog(2,"黑");
Cat c = new Cat(3,"灰");
p.keepPet(d,"骨头");
p.keepPet(c,"鱼");
}
}
第二章 包
2.1 包
包在操作系统中其实就是一个文件夹。包是用来分门别类的管理技术,不同的技术类放在不同的包下,方便管理和维护。
在IDEA项目中,建包的操作如下:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TWtfovNH-1688475746485)(/img/aaa.jpg)]
包名的命名规范:
路径名.路径名.xxx.xxx
// 例如:com.itheima.oa
- 包名一般是公司域名的倒写。例如:黑马是www.itheima.com,包名就可以定义成com.itheima.技术名称。
- 包名必须用”.“连接。
- 包名的每个路径名必须是一个合法的标识符,而且不能是Java的关键字。
2.2 导包
什么时候需要导包?
情况一:在使用Java中提供的非核心包中的类时
情况二:使用自己写的其他包中的类时
什么时候不需要导包?
情况一:在使用Java核心包(java.lang)中的类时
情况二:在使用自己写的同一个包中的类时
2.3 使用不同包下的相同类怎么办?
假设demo1和demo2中都有一个Student该如何使用?
代码示例:
//使用全类名的形式即可。
//全类名:包名 + 类名
//拷贝全类名的快捷键:选中类名crtl + shift + alt + c 或者用鼠标点copy,再点击copy Reference
com.itheima.homework.demo1.Student s1 = new com.itheima.homework.demo1.Student();
com.itheima.homework.demo2.Student s2 = new com.itheima.homework.demo2.Student();
第三章 权限修饰符
3.1 权限修饰符
在Java中提供了四种访问权限,使用不同的访问权限修饰符修饰时,被修饰的内容会有不同的访问权限,我们之前已经学习过了public 和 private,接下来我们研究一下protected和默认修饰符的作用。
-
public:公共的,所有地方都可以访问。
-
protected:本类 ,本包,其他包中的子类都可以访问。
-
默认(没有修饰符):本类 ,本包可以访问。
注意:默认是空着不写,不是default
-
private:私有的,当前类可以访问。
public > protected > 默认 > private
3.2 不同权限的访问能力
public | protected | 默认 | private | |
---|---|---|---|---|
同一类中 | √ | √ | √ | √ |
同一包中的类 | √ | √ | √ | |
不同包的子类 | √ | √ | ||
不同包中的无关类 | √ |
可见,public具有最大权限。private则是最小权限。
编写代码时,如果没有特殊的考虑,建议这样使用权限:
- 成员变量使用
private
,隐藏细节。 - 构造方法使用
public
,方便创建对象。 - 成员方法使用
public
,方便调用方法。
小贴士:不加权限修饰符,就是默认权限
第四章 final关键字
4.1 概述
学习了继承后,我们知道,子类可以在父类的基础上改写父类内容,比如,方法重写。
如果有一个方法我不想别人去改写里面内容,该怎么办呢?
Java提供了final
关键字,表示修饰的内容不可变。
- final: 不可改变,最终的含义。可以用于修饰类、方法和变量。
- 类:被修饰的类,不能被继承。
- 方法:被修饰的方法,不能被重写。
- 变量:被修饰的变量,有且仅能被赋值一次。
4.2 使用方式
4.2.1 修饰类
final修饰的类,不能被继承。
格式如下:
final class 类名 {
}
代码:
final class Fu {
}
// class Zi extends Fu {} // 报错,不能继承final的类
查询API发现像 public final class String
、public final class Math
、public final class Scanner
等,很多我们学习过的类,都是被final修饰的,目的就是供我们使用,而不让我们所以改变其内容。
4.2.2 修饰方法
final修饰的方法,不能被重写。
格式如下:
修饰符 final 返回值类型 方法名(参数列表){
//方法体
}
代码:
class Fu2 {
final public void show1() {
System.out.println("Fu2 show1");
}
public void show2() {
System.out.println("Fu2 show2");
}
}
class Zi2 extends Fu2 {
// @Override
// public void show1() {
// System.out.println("Zi2 show1");
// }
@Override
public void show2() {
System.out.println("Zi2 show2");
}
}
4.2.3 修饰变量-局部变量
- 局部变量——基本类型
基本类型的局部变量,被final修饰后,只能赋值一次,不能再更改。代码如下:
public class FinalDemo1 {
public static void main(String[] args) {
// 声明变量,使用final修饰
final int a;
// 第一次赋值
a = 10;
// 第二次赋值
a = 20; // 报错,不可重新赋值
// 声明变量,直接赋值,使用final修饰
final int b = 10;
// 第二次赋值
b = 20; // 报错,不可重新赋值
}
}
思考,下面两种写法,哪种可以通过编译?
写法1:
final int c = 0;
for (int i = 0; i < 10; i++) {
c = i;
System.out.println(c);
}
写法2:
for (int i = 0; i < 10; i++) {
final int c = i;
System.out.println(c);
}
根据 final
的定义,写法1报错!写法2,为什么通过编译呢?因为每次循环,都是一次新的变量c。这也是大家需要注意的地方。
4.2.4 修饰变量-成员变量
成员变量涉及到初始化的问题,初始化方式有显示初始化和构造方法初始化,只能选择其中一个:
- 显示初始化(在定义成员变量的时候立马赋值)(常用);
public class Student {
final int num = 10;
}
-
构造方法初始化(在构造方法中赋值一次)(不常用,了解即可)。
注意:每个构造方法中都要赋值一次!
public class Student {
final int num = 10;
final int num2;
public Student() {
this.num2 = 20;
// this.num2 = 20;
}
public Student(String name) {
this.num2 = 20;
// this.num2 = 20;
}
}
被final修饰的常量名称,一般都有书写规范,所有字母都大写。
今日内容
- 抽象类
- 接口
- 内部类
教学目标
- 能够写出抽象类的格式
- 能够写出抽象方法的格式
- 能说出抽象类的应用场景
- 写出定义接口的格式
- 写出实现接口的格式
- 说出接口中成员的特点
- 能说出接口的应用场景
- 能说出接口中为什么会出现带有方法体的方法
- 能完成适配器设计模式
第一章 抽象类
1.1 概述
1.1.1 抽象类引入
父类中的方法,被它的子类们重写,子类各自的实现都不尽相同。那么父类的方法声明和方法主体,只有声明还有意义,而方法主体则没有存在的意义了(因为子类对象会调用自己重写的方法)。换句话说,父类可能知道子类应该有哪个功能,但是功能具体怎么实现父类是不清楚的(由子类自己决定),父类只需要提供一个没有方法体的定义即可,具体实现交给子类自己去实现。我们把没有方法体的方法称为抽象方法。Java语法规定,包含抽象方法的类就是抽象类。
- 抽象方法 : 没有方法体的方法。
- 抽象类:包含抽象方法的类。
1.2 abstract使用格式
abstract是抽象的意思,用于修饰方法方法和类,修饰的方法是抽象方法,修饰的类是抽象类。
1.2.1 抽象方法
使用abstract
关键字修饰方法,该方法就成了抽象方法,抽象方法只包含一个方法名,而没有方法体。
定义格式:
修饰符 abstract 返回值类型 方法名 (参数列表);
代码举例:
public abstract void run();
1.2.2 抽象类
如果一个类包含抽象方法,那么该类必须是抽象类。注意:抽象类不一定有抽象方法,但是有抽象方法的类必须定义成抽象类。
定义格式:
abstract class 类名字 {
}
代码举例:
public abstract class Animal {
public abstract void run();
}
1.2.3 抽象类的使用
要求:继承抽象类的子类必须重写父类所有的抽象方法。否则,该子类也必须声明为抽象类。
代码举例:
// 父类,抽象类
abstract class Employee {
private String id;
private String name;
private double salary;
public Employee() {
}
public Employee(String id, String name, double salary) {
this.id = id;
this.name = name;
this.salary = salary;
}
// 抽象方法
// 抽象方法必须要放在抽象类中
abstract public void work();
}
// 定义一个子类继承抽象类
class Manager extends Employee {
public Manager() {
}
public Manager(String id, String name, double salary) {
super(id, name, salary);
}
// 2.重写父类的抽象方法
@Override
public void work() {
System.out.println("管理其他人");
}
}
// 定义一个子类继承抽象类
class Cook extends Employee {
public Cook() {
}
public Cook(String id, String name, double salary) {
super(id, name, salary);
}
@Override
public void work() {
System.out.println("厨师炒菜多加点盐...");
}
}
// 测试类
public class Demo10 {
public static void main(String[] args) {
// 创建抽象类,抽象类不能创建对象
// 假设抽象类让我们创建对象,里面的抽象方法没有方法体,无法执行.所以不让我们创建对象
// Employee e = new Employee();
// e.work();
// 3.创建子类
Manager m = new Manager();
m.work();
Cook c = new Cook("ap002", "库克", 1);
c.work();
}
}
此时的方法重写,是子类对父类抽象方法的完成实现,我们将这种方法重写的操作,也叫做实现方法。
1.3 抽象类的特征
抽象类的特征总结起来可以说是 有得有失
有得:抽象类得到了拥有抽象方法的能力。
有失:抽象类失去了创建对象的能力。
其他成员(构造方法,实例方法,静态方法等)抽象类都是具备的。
1.4 抽象类的细节
不需要背,只要当idea报错之后,知道如何修改即可。
关于抽象类的使用,以下为语法上要注意的细节,虽然条目较多,但若理解了抽象的本质,无需死记硬背。
-
抽象类不能创建对象,如果创建,编译无法通过而报错。只能创建其非抽象子类的对象。
理解:假设创建了抽象类的对象,调用抽象的方法,而抽象方法没有具体的方法体,没有意义。
-
抽象类中,可以有构造方法,是供子类创建对象时,初始化父类成员使用的。
理解:子类的构造方法中,有默认的super(),需要访问父类构造方法。
-
抽象类中,不一定包含抽象方法,但是有抽象方法的类必定是抽象类。
理解:未包含抽象方法的抽象类,目的就是不想让调用者创建该类对象,通常用于某些特殊的类结构设计。
-
抽象类的子类,必须重写抽象父类中所有的抽象方法,否则子类也必须定义成抽象类,编译无法通过而报错。
理解:假设不重写所有抽象方法,则类中可能包含抽象方法。那么创建对象后,调用抽象的方法,没有意义。
-
抽象类存在的意义是为了被子类继承。
理解:抽象类中已经实现的是模板中确定的成员,抽象类不确定如何实现的定义成抽象方法,交给具体的子类去实现。
1.5 抽象类存在的意义
抽象类存在的意义是为了被子类继承,否则抽象类将毫无意义。抽象类可以强制让子类,一定要按照规定的格式进行重写。
第二章 接口
2.1 概述
我们已经学完了抽象类,抽象类中可以用抽象方法,也可以有普通方法,构造方法,成员变量等。那么什么是接口呢?接口是更加彻底的抽象,JDK7之前,包括JDK7,接口中全部是抽象方法。接口同样是不能创建对象的。
2.2 定义格式
//接口的定义格式:
interface 接口名称{
// 抽象方法
}
// 接口的声明:interface
// 接口名称:首字母大写,满足“驼峰模式”
2.3 接口成分的特点
在JDK7,包括JDK7之前,接口中的只有包含:抽象方法和常量
2.3.1.抽象方法
注意:接口中的抽象方法默认会自动加上public abstract修饰程序员无需自己手写!!
按照规范:以后接口中的抽象方法建议不要写上public abstract。因为没有必要啊,默认会加上。
2.3.2 常量
在接口中定义的成员变量默认会加上: public static final修饰。也就是说在接口中定义的成员变量实际上是一个常量。这里是使用public static final修饰后,变量值就不可被修改,并且是静态化的变量可以直接用接口名访问,所以也叫常量。常量必须要给初始值。常量命名规范建议字母全部大写,多个单词用下划线连接。
2.3.3 案例演示
public interface InterF {
// 抽象方法!
// public abstract void run();
void run();
// public abstract String getName();
String getName();
// public abstract int add(int a , int b);
int add(int a , int b);
// 它的最终写法是:
// public static final int AGE = 12 ;
int AGE = 12; //常量
String SCHOOL_NAME = "黑马程序员";
}
2.4 基本的实现
2.4.1 实现接口的概述
类与接口的关系为实现关系,即类实现接口,该类可以称为接口的实现类,也可以称为接口的子类。实现的动作类似继承,格式相仿,只是关键字不同,实现使用 implements
关键字。
2.4.2 实现接口的格式
/**接口的实现:
在Java中接口是被实现的,实现接口的类称为实现类。
实现类的格式:*/
class 类名 implements 接口1,接口2,接口3...{
}
从上面格式可以看出,接口是可以被多实现的。大家可以想一想为什么呢?
2.4.3 类实现接口的要求和意义
- 必须重写实现的全部接口中所有抽象方法。
- 如果一个类实现了接口,但是没有重写完全部接口的全部抽象方法,这个类也必须定义成抽象类。
- 意义:接口体现的是一种规范,接口对实现类是一种强制性的约束,要么全部完成接口申明的功能,要么自己也定义成抽象类。这正是一种强制性的规范。
2.4.4 类与接口基本实现案例
假如我们定义一个运动员的接口(规范),代码如下:
/**
接口:接口体现的是规范。
* */
public interface SportMan {
void run(); // 抽象方法,跑步。
void law(); // 抽象方法,遵守法律。
String compittion(String project); // 抽象方法,比赛。
}
接下来定义一个乒乓球运动员类,实现接口,实现接口的实现类代码如下:
package com.itheima._03接口的实现;
/**
* 接口的实现:
* 在Java中接口是被实现的,实现接口的类称为实现类。
* 实现类的格式:
* class 类名 implements 接口1,接口2,接口3...{
*
*
* }
* */
public class PingPongMan implements SportMan {
@Override
public void run() {
System.out.println("乒乓球运动员稍微跑一下!!");
}
@Override
public void law() {
System.out.println("乒乓球运动员守法!");
}
@Override
public String compittion(String project) {
return "参加"+project+"得金牌!";
}
}
测试代码:
public class TestMain {
public static void main(String[] args) {
// 创建实现类对象。
PingPongMan zjk = new PingPongMan();
zjk.run();
zjk.law();
System.out.println(zjk.compittion("全球乒乓球比赛"));
}
}
2.4.5 类与接口的多实现案例
类与接口之间的关系是多实现的,一个类可以同时实现多个接口。
首先我们先定义两个接口,代码如下:
/** 法律规范:接口*/
public interface Law {
void rule();
}
/** 这一个运动员的规范:接口*/
public interface SportMan {
void run();
}
然后定义一个实现类:
/**
* Java中接口是可以被多实现的:
* 一个类可以实现多个接口: Law, SportMan
*
* */
public class JumpMan implements Law ,SportMan {
@Override
public void rule() {
System.out.println("尊长守法");
}
@Override
public void run() {
System.out.println("训练跑步!");
}
}
从上面可以看出类与接口之间是可以多实现的,我们可以理解成实现多个规范,这是合理的。
2.5 接口与接口的多继承
Java中,接口与接口之间是可以多继承的:也就是一个接口可以同时继承多个接口。大家一定要注意:
类与接口是实现关系
接口与接口是继承关系
接口继承接口就是把其他接口的抽象方法与本接口进行了合并。
案例演示:
public interface Abc {
void go();
void test();
}
/** 法律规范:接口*/
public interface Law {
void rule();
void test();
}
*
* 总结:
* 接口与类之间是多实现的。
* 接口与接口之间是多继承的。
* */
public interface SportMan extends Law , Abc {
void run();
}
2.6扩展:接口的细节
不需要背,只要当idea报错之后,知道如何修改即可。
关于接口的使用,以下为语法上要注意的细节,虽然条目较多,但若理解了抽象的本质,无需死记硬背。
- 当两个接口中存在相同抽象方法的时候,该怎么办?
只要重写一次即可。此时重写的方法,既表示重写1接口的,也表示重写2接口的。
- 实现类能不能继承A类的时候,同时实现其他接口呢?
继承的父类,就好比是亲爸爸一样
实现的接口,就好比是干爹一样
可以继承一个类的同时,再实现多个接口,只不过,要把接口里面所有的抽象方法,全部实现。
- 实现类能不能继承一个抽象类的时候,同时实现其他接口呢?
实现类可以继承一个抽象类的同时,再实现其他多个接口,只不过要把里面所有的抽象方法全部重写。
- 实现类Zi,实现了一个接口,还继承了一个Fu类。假设在接口中有一个方法,父类中也有一个相同的方法。子类如何操作呢?
处理办法一:如果父类中的方法体,能满足当前业务的需求,在子类中可以不用重写。
处理办法二:如果父类中的方法体,不能满足当前业务的需求,需要在子类中重写。
- 如果一个接口中,有10个抽象方法,但是我在实现类中,只需要用其中一个,该怎么办?
可以在接口跟实现类中间,新建一个中间类(适配器类)
让这个适配器类去实现接口,对接口里面的所有的方法做空重写。
让子类继承这个适配器类,想要用到哪个方法,就重写哪个方法。
因为中间类没有什么实际的意义,所以一般会把中间类定义为抽象的,不让外界创建对象
第三章 内部类
3.1 概述
3.1.1 什么是内部类
将一个类A定义在另一个类B里面,里面的那个类A就称为内部类,B则称为外部类。可以把内部类理解成寄生,外部类理解成宿主。
3.1.2 什么时候使用内部类
一个事物内部还有一个独立的事物,内部的事物脱离外部的事物无法独立使用
- 人里面有一颗心脏。
- 汽车内部有一个发动机。
- 为了实现更好的封装性。
3.2 内部类的分类
按定义的位置来分
- 成员内部内,类定义在了成员位置 (类中方法外称为成员位置,无static修饰的内部类)
- 静态内部类,类定义在了成员位置 (类中方法外称为成员位置,有static修饰的内部类)
- 局部内部类,类定义在方法内
- 匿名内部类,没有名字的内部类,可以在方法中,也可以在类中方法外。
3.3 成员内部类
成员内部类特点:
- 无static修饰的内部类,属于外部类对象的。
- 宿主:外部类对象。
内部类的使用格式:
外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类
获取成员内部类对象的两种方式:
方式一:外部直接创建成员内部类的对象
外部类.内部类 变量 = new 外部类().new 内部类();
方式二:在外部类中定义一个方法提供内部类的对象
案例演示
方式一:
public class Test {
public static void main(String[] args) {
// 宿主:外部类对象。
// Outer out = new Outer();
// 创建内部类对象。
Outer.Inner oi = new Outer().new Inner();
oi.method();
}
}
class Outer {
// 成员内部类,属于外部类对象的。
// 拓展:成员内部类不能定义静态成员。
public class Inner{
// 这里面的东西与类是完全一样的。
public void method(){
System.out.println("内部类中的方法被调用了");
}
}
}
方式二:
public class Outer {
String name;
private class Inner{
static int a = 10;
}
public Inner getInstance(){
return new Inner();
}
}
public class Test {
public static void main(String[] args) {
Outer o = new Outer();
System.out.println(o.getInstance());
}
}
3.4 成员内部类的细节
编写成员内部类的注意点:
- 成员内部类可以被一些修饰符所修饰,比如: private,默认,protected,public,static等
- 在成员内部类里面,JDK16之前不能定义静态变量,JDK16开始才可以定义静态变量。
- 创建内部类对象时,对象中有一个隐含的Outer.this记录外部类对象的地址值。(请参见3.6节的内存图)
详解:
内部类被private修饰,外界无法直接获取内部类的对象,只能通过3.3节中的方式二获取内部类的对象
被其他权限修饰符修饰的内部类一般用3.3节中的方式一直接获取内部类的对象
内部类被static修饰是成员内部类中的特殊情况,叫做静态内部类下面单独学习。
内部类如果想要访问外部类的成员变量,外部类的变量必须用final修饰,JDK8以前必须手动写final,JDK8之后不需要手动写,JDK默认加上。
3.5 成员内部类面试题
请在?地方向上相应代码,以达到输出的内容
注意:内部类访问外部类对象的格式是:外部类名.this
public class Test {
public static void main(String[] args) {
Outer.inner oi = new Outer().new inner();
oi.method();
}
}
class Outer { // 外部类
private int a = 30;
// 在成员位置定义一个类
class inner {
private int a = 20;
public void method() {
int a = 10;
System.out.println(???); // 10 答案:a
System.out.println(???); // 20 答案:this.a
System.out.println(???); // 30 答案:Outer.this.a
}
}
}
3.6 成员内部类内存图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o5iOizRt-1688475763367)(img\内部类内存图.png)]
3.7 静态内部类
静态内部类特点:
- 静态内部类是一种特殊的成员内部类。
- 有static修饰,属于外部类本身的。
- 总结:静态内部类与其他类的用法完全一样。只是访问的时候需要加上外部类.内部类。
- 拓展1:静态内部类可以直接访问外部类的静态成员。
- 拓展2:静态内部类不可以直接访问外部类的非静态成员,如果要访问需要创建外部类的对象。
- 拓展3:静态内部类中没有银行的Outer.this。
内部类的使用格式:
外部类.内部类。
静态内部类对象的创建格式:
外部类.内部类 变量 = new 外部类.内部类构造器;
调用方法的格式:
- 调用非静态方法的格式:先创建对象,用对象调用
- 调用静态方法的格式:外部类名.内部类名.方法名();
案例演示:
// 外部类:Outer01
class Outer01{
private static String sc_name = "黑马程序";
// 内部类: Inner01
public static class Inner01{
// 这里面的东西与类是完全一样的。
private String name;
public Inner01(String name) {
this.name = name;
}
public void showName(){
System.out.println(this.name);
// 拓展:静态内部类可以直接访问外部类的静态成员。
System.out.println(sc_name);
}
}
}
public class InnerClassDemo01 {
public static void main(String[] args) {
// 创建静态内部类对象。
// 外部类.内部类 变量 = new 外部类.内部类构造器;
Outer01.Inner01 in = new Outer01.Inner01("张三");
in.showName();
}
}
3.8 局部内部类
- 局部内部类 :定义在方法中的类。
定义格式:
class 外部类名 {
数据类型 变量名;
修饰符 返回值类型 方法名(参数列表) {
// …
class 内部类 {
// 成员变量
// 成员方法
}
}
}
3.9 匿名内部类【重点】
3.9.1 概述
匿名内部类 :是内部类的简化写法。他是一个隐含了名字的内部类。开发中,最常用到的内部类就是匿名内部类了。
3.9.2 格式
new 类名或者接口名() {
重写方法;
};
包含了:
-
继承或者实现关系
-
方法重写
-
创建对象
所以从语法上来讲,这个整体其实是匿名内部类对象
3.9.2 什么时候用到匿名内部类
实际上,如果我们希望定义一个只要使用一次的类,就可考虑使用匿名内部类。匿名内部类的本质作用
是为了简化代码。
之前我们使用接口时,似乎得做如下几步操作:
- 定义子类
- 重写接口中的方法
- 创建子类对象
- 调用重写后的方法
interface Swim {
public abstract void swimming();
}
// 1. 定义接口的实现类
class Student implements Swim {
// 2. 重写抽象方法
@Override
public void swimming() {
System.out.println("狗刨式...");
}
}
public class Test {
public static void main(String[] args) {
// 3. 创建实现类对象
Student s = new Student();
// 4. 调用方法
s.swimming();
}
}
我们的目的,最终只是为了调用方法,那么能不能简化一下,把以上四步合成一步呢?匿名内部类就是做这样的快捷方式。
3.9.3 匿名内部类前提和格式
匿名内部类必须继承一个父类或者实现一个父接口。
匿名内部类格式
new 父类名或者接口名(){
// 方法重写
@Override
public void method() {
// 执行语句
}
};
3.9.4 使用方式
以接口为例,匿名内部类的使用,代码如下:
interface Swim {
public abstract void swimming();
}
public class Demo07 {
public static void main(String[] args) {
// 使用匿名内部类
new Swim() {
@Override
public void swimming() {
System.out.println("自由泳...");
}
}.swimming();
// 接口 变量 = new 实现类(); // 多态,走子类的重写方法
Swim s2 = new Swim() {
@Override
public void swimming() {
System.out.println("蛙泳...");
}
};
s2.swimming();
s2.swimming();
}
}
3.9.5 匿名内部类的特点
- 定义一个没有名字的内部类
- 这个类实现了父类,或者父类接口
- 匿名内部类会创建这个没有名字的类的对象
3.9.6 匿名内部类的使用场景
通常在方法的形式参数是接口或者抽象类时,也可以将匿名内部类作为参数传递。代码如下:
interface Swim {
public abstract void swimming();
}
public class Demo07 {
public static void main(String[] args) {
// 普通方式传入对象
// 创建实现类对象
Student s = new Student();
goSwimming(s);
// 匿名内部类使用场景:作为方法参数传递
Swim s3 = new Swim() {
@Override
public void swimming() {
System.out.println("蝶泳...");
}
};
// 传入匿名内部类
goSwimming(s3);
// 完美方案: 一步到位
goSwimming(new Swim() {
public void swimming() {
System.out.println("大学生, 蛙泳...");
}
});
goSwimming(new Swim() {
public void swimming() {
System.out.println("小学生, 自由泳...");
}
});
}
// 定义一个方法,模拟请一些人去游泳
public static void goSwimming(Swim s) {
s.swimming();
}
}