idea的快捷键
java学习中，idea的快捷键
模块的操作方式
修改模块
下一步
最后修改自己想要取的名字
导入模块
先把别人的模块复制进来
再点击下面的目录
点击需要添加的包，之后下一步就可以添加进去了
while循环案例
代码：
java
package com.itheima.loop;
/**
* ClassName: WhileTest5
* Package: com.itheima.loop
* Description:
*
* @Author: start
* @Create 2026-04-23 12:15
* @Version: 1.0
*/
public class WhileTest5 {
public static void main(String[] args) {
// 目标:完成while循环的需求:复利计算。
System.out.println("复利计算结果是:"+calc());
System.out.println("折叠次数:"+calc2());
}
// 复利计算：我们本金是10万，复利是1.7%，请问多少年后本金翻倍。
public static int calc(){
double money = 100000;
double rate = 0.017;
int year = 0; // 要存多少的意思
//2、控制循环，只要发现本金还是小于目标金额200000时，就需要继续存一年。
while(money < 200000){
year++;
money = money * (1 + rate);
}
return year;
}
// 需求:珠穆朗玛峰高度是8848860，纸张厚度是0.1，折叠多少次可以达到山峰高度。
// 不知道循环几次的话，就用while，直到满足条件。
public static int calc2(){
// 1、把数据拿到程序中来。
double height = 8848860;
double thickness = 0.1;
int count = 0;
//2、控制循环，只要纸张厚度还没有达到珠穆朗玛峰高度，就需要继续折叠。
//3、计算折叠次数。
while(thickness < height){
//3、计算折叠次数。
count++;
//thickness = thickness * 2;
//4、计算纸张厚度。
thickness *= 2;
}
//5、返回折叠次数。
return count;
}
}
循环案例：
简单计算器
代码：
java
package com.itheima.demo;
import java.util.Scanner;
/**
* ClassName: Test1
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-23 13:55
* @Version: 1.0
*/
public class Test1 {
public static void main(String[] args) {
// 目标：简易版计算器开发
// 1、键盘录入两个整数，以及运算符。
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数字：");
double num1 = sc.nextDouble();
System.out.println("请输入第二个数字：");
double num2 = sc.nextDouble();
System.out.println("请输入运算符(+、-、*、/)：");
String operator = sc.next();
// 2、把这个数据交给一个独立的计算方法，帮我计算结果并返回给我。
double result = calc(num1, num2, operator);
System.out.println("计算结果是：" + result);
}
public static double calc(double num1, double num2, String operator){
double result = 0; // 定义一个double类型的变量记录本次运算的结果，方便返回!!
switch (operator){
case "+":
result = num1 + num2;
break;
case "-":
result = num1 - num2;
break;
case "*":
result = num1 * num2;
break;
case "/":
result = num1 / num2;
break;
default:
System.out.println("输入的运算符有误！");
}
return result;
}
}猜数字小游戏
java
package com.itheima.demo;
import java.util.Random;
import java.util.Scanner;
/**
* ClassName: Test2
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-23 14:26
* @Version: 1.0
*/
public class Test2 {
public static void main(String[] args) {
// 目标: 猜数字游戏
guess();
}
public static void guess() {
// 1.生成一个随机数： 1-100之间
// 方式一：
// Math.random() 返回[0,1)的随机小数
// (int)Math.random()* 100 ==> [O,100)的整数 => [0,99]+1=> [1,100]
//int num = (int)(Math.random() * 100) + 1;
// 方式二
Random r = new Random(); // 得到一个随机数对象
int luckNumber = r.nextInt(100) + 1; // [0, 99] + 1 ==> [1, 100]
// 2、定义一个死循环让用户一直猜测，直到猜中才结束循环。
// 2、循环让用户猜测
Scanner sc = new Scanner(System.in);
while(true){
// 3、获取用户输入的猜测的数字
System.out.print("请输入你猜测的数字（1-100）：");
int guessNumber = sc.nextInt();
//count++;
// 4、判断猜测的数字和随机数是否一致
if(guessNumber > luckNumber){
System.out.println("过大！请继续猜测~");
}else if(guessNumber < luckNumber){
System.out.println("过小！请继续猜测~");
}else{
System.out.println("恭喜你，猜对了！答案就是：" + luckNumber);
//System.out.println("你总共猜了 " + count + " 次");
break; // 猜中了，结束循环
}
}
}
}开发验证码
相关代码：
java
package com.itheima.demo;
/**
* ClassName: Test3
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-23 14:59
* @Version: 1.0
*/
public class Test3 {
public static void main(String[] args) {
//目标:开发验证码。
//1、调用一个方法返回执行位数的验证码，每位只能是数字或者大写字母或者小写字母，
System.out.println(getCode(4));
System.out.println(getCode(6));
}
public static String getCode(int n) {
// 2、定义一个字符串变量用于记录生产的验证码。
String code = "";
//3、循环n次，每次生成一个验证码。
for (int i = 0; i < n; i++) {
// i = 0 1 2 3
// 4、为当前位置随机生成一个数字或者大写字母或者小写字母。数字/大写/小写
// 随机一个 0 或者 1 或者 2 表示当前位置随机的字符类型
int type = (int)(Math.random() * 3); // [0,1) * 3 => 0 1 2
// 5、使用switch判断当前位置随机的字符类型
switch (type) {
case 0:
// 6、如果当前位置是数字，则随机生成一个数字0-9，然后拼接。
int num = (int)(Math.random() * 10);
code += num;
break;
case 1:
// 7、如果当前位置是大写字母，则随机生成一个大写字母A-Z，然后拼接。 'A' 65 'Z' 65+26
int num1 = (int)(Math.random() * 26); // [0,25]
char ch = (char)(65 + num1); // 得到大写字母的随机编号，转成大写字母
code += ch;
break;
case 2:
// 8、如果当前位置是小写字母，则随机生成一个小写字母a-z，然后拼接。 'a' 97 'z' 97+26
int num2 = (int)(Math.random() * 26); // [0, 25]
char ch1 = (char)(97 + num2);
code += ch1;
break;
}
}
return code;
}
}素数查找
代码：
java
package com.itheima.demo;
/**
* ClassName: Test4
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-23 16:03
* @Version: 1.0
*/
public class Test4 {
public static void main(String[] args) {
// 目标：找出101-200之间的全部素数
int count = 0;
// 1、遍历101-200
for(int i = 101; i <= 200; i++) {
// i = 101 102 103 ... 200
// 2、每遍历到一个数字，判断这个数字是否是素数，是则输出（独立功能独立成方法）
if(isPrime(i)){
System.out.println(i);
count++;
}
}
System.out.println("素数的个数是：" + count);
}
public static boolean isPrime(int num) {
// num = 101 / 102
// 定义一个循环从2开始找到该数的一半，只要发现有一个数字能整数num这个数，num就不是素数
//如果都没有找到，那么num就是素数
for(int i = 2; i <= num / 2; i++) {
// i = 2 3 4 5 ... num / 2
// 2、判断num是否能被i整除，能返回false，不能则返回true
if(num % i == 0) {
return false;
}
}
return true; // 是素数
}
}一维数组，二维数组
随机点名小程序
代码
java
package com.itheima;
/**
ClassName: ${NAME}
Package: com.itheima
Description:
@Author: start
@Create 2026-04-23 16:41
@Version: 1.0
*/
//TIP 要<b>运行</b>代码，请按 <shortcut actionId="Run"/> 或
// 点击装订区域中的 <icon src="AllIcons.Actions.Execute"/> 图标。
public class ArrayDemo1 {
public static void main(String[] args) {
//目标:认识使用数组的好处，数组的定义，访问。
System.out.println("==========随机点名系统==========");
randomName();
}
// 我是一名Java初学者，请帮我开发一个随机点名的方法，假设有15名学生。
/**
* 随机点名方法
*/
public static void randomName(){
// 1、定义一个数组存储15名学生的姓名
//String[] names = {"张三", "李四", "王五", "赵六", "孙七",
// "周八", "吴九", "郑十", "陈十一", "刘十二",
// "杨十三", "黄十四", "林十五", "何十六", "高十七"};
String[] names = new String[]{"张三", "李四", "王五", "赵六", "孙七",
"周八", "吴九", "郑十", "陈十一", "刘十二",
"杨十三", "黄十四", "林十五", "何十六", "高十七"};
// 索引 0 1 2 3 ...
//String names[] = new String[]{"张三", "李四", "王五", "赵六", "孙七",
// "周八", "吴九", "郑十", "陈十一", "刘十二",
// "杨十三", "黄十四", "林十五", "何十六", "高十七"};
System.out.println(names);
// 2、生成一个随机索引（0到14）
// Math.random():[0 - 1)之间的小数
// names.length: 元素个数:15
int index = (int)(Math.random() * names.length); // [0 - 15) - [0 - 14]
// 3、根据索引获取被点到的学生姓名
// 根据索引值，获取数组中的元素:数组名[索引值]
String selectedName = names[index];
// 4、输出结果
System.out.println("本次被点到的同学是：" + selectedName);
System.out.println("索引位置：" + index);
}
}成绩平均分，最高分，最低分
代码：
java
package com.itheima;
import java.util.Scanner;
/**
* ClassName: ArrayDemo2
* Package: com.itheima
* Description:
*
* @Author: start
* @Create 2026-04-23 17:11
* @Version: 1.0
*/
public class ArrayDemo2 {
public static void main(String[] args) {
// 目标:掌握数组的另一种定义方式:动态初始化数组。
inputScore();
}
// 设计一个方法录入学生成绩
public static void inputScore(){
//1、你需要一个数组来存储8名学生的成绩。
// 动态初始化数组，只确定数组的类型和存储数据的容量。不事先存入具体的数据。
// 数据类型[] 数组名=new 数据类型[长度];
double[] scores = new double[8];
//scores = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
// 0
// 2、录入8名学生的成绩，存入到数组中去
Scanner sc = new Scanner(System.in);
for(int i = 0; i < scores.length; i++){
// i = 0 1 2 3 4 5 6 7
System.out.println("请输入第" + (i + 1) + "个学生的成绩:");
scores[i] = sc.nextDouble();
}
// 3、遍历数组，统计总分，统计最高愤怒，统计最低分
double allScore = scores[0];
double maxScore = scores[0];
double minScore = scores[0];
for (int i = 1; i < scores.length; i++) {
double score = scores[i];
// 4、累加当前遍历到的这个分数
allScore += score;
// 5、判断当前分数是否是最高
if(score > maxScore){
maxScore = score;
}
// 6、判断当前分数是否是最低
if(score < minScore){
minScore = score;
}
}
System.out.println("平均分：" + allScore / scores.length);
System.out.println("最高分：" + maxScore);
System.out.println("最低分：" + minScore);
}
}求最值
java
package com.itheima;
/**
* ClassName: ArrayDemo3
* Package: com.itheima
* Description:
*
* @Author: start
* @Create 2026-04-23 17:45
* @Version: 1.0
*/
public class ArrayDemo3 {
public static void main(String[] args) {
// 目标：完成数组求最值
int[] scores = {15, 9000, 10000, 20000, 9500, -5};
int max = getMax(scores);
System.out.println("最大值是:"+max);
}
// 设计一个方法，求数组的最大值返回
public static int getMax(int[] arr){
// arr = {15, 9000, 10000, 20000, 9500, -5}
// 1、定义一个变量用于记录当前最大值，建议用第一个数据作为参照物
int max = arr[0];
// 2、从数组的第二个位置开始遍历
for (int i = 1; i < arr.length; i++) {
// 3、获取当前位置的元素，并与max进行比较，如果当前元素比max大，则将当前元素赋给max
// 这样写的效率更高，因为不需要去数组中找这个值，而是直接定义一个变量
int data = arr[i];
if(data > max){
max = data;
}
}
// 4、返回最大值
return max;
}
}斗地主游戏
java
package com.itheima;
/**
* ClassName: ArrayTest4
* Package: com.itheima
* Description:
*
* @Author: start
* @Create 2026-04-23 18:07
* @Version: 1.0
*/
public class ArrayTest4 {
public static void main(String[] args) {
// 目标：完成斗地主游戏的做牌和洗牌
start();
}
public static void start(){
// 1、做牌：创建一个动态初始化的数组存储54张牌
String[] poker = new String[54];
// poker = [null, null, null, ......]
// 0 1 3
// 2、准备四种花色，还有点数，再开始做牌存入数组中去
String[] colors = {"♠","♥","♣","♦"};
String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
// 3、遍历点数，再遍历花色
int index = 0; // 定义一个变量记录牌存储的索引位置
for (int i = 0; i < numbers.length; i++) {
// 当前点数：numbers[i]
for (int j = 0; j < colors.length; j++){
// 4、将牌存入数组中去
// 先用一下这个索引0，之后再+1
poker[index++] = colors[j] + numbers[i];
}
}
// 5、存入大小王
poker[index++] = "🏠";
poker[index] = "🌫️";
// 5、打印牌
System.out.println("新牌：");
for (int i = 0; i < poker.length; i++) {
System.out.print(poker[i]+"\t");
}
System.out.println(); // 换行
// 6、洗牌：把54张牌的数组poker中的牌顺序打乱
// poker = [♠3 ♥3 ♣3 ♦3 ♠4 ♥4 ♣4 ♦4 ♠5 ♥5 ♣5 ♦5 ♠6 ♥6 ♣6 ♦6 ......]
for (int i = 0; i < poker.length; i++){
// 随机获取一个索引
int index1 = (int)(Math.random()*poker.length); // [0, 54) => [0, 53]
// 随机获取另一个索引
int index2 = (int)(Math.random()*poker.length); // [0, 54) => [0, 53]
// 拿着index1索引对应的牌，和index2索引对应的牌进行交换。
// 每次一次都需要让index1和index2这两个索引位置处的数据进行交换
// 1、定义一个临时变量，存储index2索引位置的数据。
String temp = poker[index1];
// 2、把index2索引位置的数据，赋给index1索引位置。
poker[index1] = poker[index2];
// 3、将临时变量，赋值给index2索引位置。
poker[index2] = temp;
}
System.out.println("新牌：");
for (int i = 0; i < poker.length; i++) {
System.out.print(poker[i]+"\t");
}
}
}座位信息
java
package com.itheima;
/**
* ClassName: ArrayDemo5
* Package: com.itheima
* Description:
*
* @Author: start
* @Create 2026-04-23 19:23
* @Version: 1.0
*/
public class ArrayDemo5 {
public static void main(String[] args) {
// 目标：二位数组的认识
printArray();
printArray2();
}
public static void printArray() {
// 初始化二维数组存储学生姓名，考虑到座位不规则，直接定义每排的座位
// 静态初始化数组
String[][] classroom = {
{"张无忌", "赵敏", "周芷若"}, // 0 第一排
{"张三丰", "宋远桥", "殷梨亭"}, // 1 第二排
{"灭绝", "陈昆", "玄冥二老", "金毛狮王"}, // 2 第三排
{"杨逍", "纪晓芙"} // 3 第四排
};
// 访问:数组名[行索引]
String[] names = classroom[2];
for(int i = 0; i < names.length; i++){
System.out.println(names[i]);
}
// 访问2:数组名[行索引][列索引]
System.out.println(classroom[1][1]);
System.out.println(classroom[2][2]);
System.out.println(classroom.length); // 4
System.out.println(classroom[3].length); // 2
// 动态初始化数组
int[][] arr = new int[3][5]; // 3行5列
}
// 遍历二维数组
public static void printArray2(){
String[][] classroom = {
{"张无忌", "赵敏", "周芷若"}, // 0 第一排
{"张三丰", "宋远桥", "殷梨亭"}, // 1 第二排
{"灭绝", "陈昆", "玄冥二老", "金毛狮王"}, // 2 第三排
{"杨逍", "纪晓芙"} // 3 第四排
};
for(int i = 0; i < classroom.length; i++){
// i = 0 1 2 3
String[] names = classroom[i];
for(int j = 0; j < names.length; j++){
System.out.print(names[j] + "\t");
}
System.out.println();
}
System.out.println("=========另一种遍历方式==========");
for(int i = 0; i < classroom.length; i++) {
for (int j = 0; j < classroom[i].length; j++) {
System.out.print(classroom[i][j] + "\t");
}
System.out.println();
}
}
}石头迷阵游戏
java
package com.itheima;
/**
* ClassName: ArrayTest6
* Package: com.itheima
* Description:
*
* @Author: start
* @Create 2026-04-23 20:55
* @Version: 1.0
*/
public class ArrayTest6 {
public static void main(String[] args) {
// 目标:完成数字华容道的初始化和随机乱序。
start(4);
}
public static void start(int n){
// 1、创建一个二维数组，模拟华容道游戏
int[][] arr = new int[n][n];
// 2、初始化二维数组，模拟华容道游戏
int count = 1;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
arr[i][j] = count++;
}
}
printArray(arr);
// 3、打乱二维数组中的元素顺序
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
int index1 = (int)(Math.random()*arr.length);
int index2 = (int)(Math.random()*arr.length);
int temp = arr[i][j];
arr[i][j] = arr[index1][index2];
arr[index1][index2] = temp;
}
}
System.out.println("----------------------------------");
printArray(arr);
}
public static void printArray(int[][] arr){
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
}
}静态方法，实例方法访问相关的几点注意事项
java
package com.itheima.staticmethod;
/**
* ClassName: Test4
* Package: com.itheima.staticmethod
* Description:
*
* @Author: start
* @Create 2026-04-25 14:32
* @Version: 1.0
*/
public class Test4 {
// 静态变量
public static int count = 100;
// 静态方法
public static void printHelloWorld2() {
System.out.println("Hello World!");
}
//实例变量: 属于对象的
private String name;
// 实例方法：属于对象的
public void run() {
}
public static void main(String[] args) {
// 目标:搞清楚静态方法，实例方法访问的几点注意事项。
printHelloWorld();
}
//1、静态方法中可以直接访问静态成员，不可以直接访问实例成员。
public static void printHelloWorld() {
System.out.println(count);
printHelloWorld2();
//System.out.println(name); // 报错
//run(); // 报错
//System.out.println(this); // 报错，this代表的是对象
}
//2、实例方法中既可以直接访问静态成员，也可以直接访问实例成员。
//3、实例方法中可以出现this关键字，静态方法中不可以出现this关键字的。
public void go() {
System.out.println(count);
printHelloWorld2();
System.out.println(name);
run();
System.out.println(this);
}
}验证码工具类封装
java
package com.itheima.staticmethod;
/**
* ClassName: VerifyCodeUtil
* Package: com.itheima.staticmethod
* Description:
*
* @Author: start
* @Create 2026-04-25 14:16
* @Version: 1.0
*/
// 静态方法设计工具类
public class VerifyCodeUtil {
// 工具类没有创建对象的必要性，所以建议私有化构造器
private VerifyCodeUtil() {
}
public static String getCode(int n) {
// 2、定义一个字符串变量用于记录生产的验证码。
String code = "";
//3、循环n次，每次生成一个验证码。
for (int i = 0; i < n; i++) {
// i = 0 1 2 3
// 4、为当前位置随机生成一个数字或者大写字母或者小写字母。数字/大写/小写
// 随机一个 0 或者 1 或者 2 表示当前位置随机的字符类型
int type = (int)(Math.random() * 3); // [0,1) * 3 => 0 1 2
// 5、使用switch判断当前位置随机的字符类型
switch (type) {
case 0:
// 6、如果当前位置是数字，则随机生成一个数字0-9，然后拼接。
int num = (int)(Math.random() * 10);
code += num;
break;
case 1:
// 7、如果当前位置是大写字母，则随机生成一个大写字母A-Z，然后拼接。 'A' 65 'Z' 65+26
int num1 = (int)(Math.random() * 26); // [0,25]
char ch = (char)(65 + num1); // 得到大写字母的随机编号，转成大写字母
code += ch;
break;
case 2:
// 8、如果当前位置是小写字母，则随机生成一个小写字母a-z，然后拼接。 'a' 97 'z' 97+26
int num2 = (int)(Math.random() * 26); // [0, 25]
char ch1 = (char)(97 + num2);
code += ch1;
break;
}
}
return code;
}
}面向对象
简易版电影信息展示系统
电影操作类
java
package com.itheima.demo;
import java.util.Scanner;
/**
* ClassName: MovieOperator
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-25 15:09
* @Version: 1.0
*/
// 电影操作类
public class MovieOperator {
private Movie[] movies; // 记住一个电影对象的数组
public MovieOperator(Movie[] movies) {
this.movies = movies;
}
// 打印全部电影信息
public void printAllMovies() {
System.out.println("===============打印全部电影信息==============");
for(int i = 0; i < movies.length; i++) {
// i : 0 1 2 3 4 5
Movie m = movies[i];
System.out.println(m.getId() + "\t" +m.getName() + "\t" + m.getPrice() + "\t" + m.getActor()+ "\t");
}
}
// 根据id查询电影
public void searchMovieById() {
System.out.println("请输入要查询的电影id:");
Scanner sc = new Scanner(System.in);
int id = sc.nextInt();
// 遍历每个电影对象
for(int i = 0; i < movies.length; i++) {
// 拿到当前遍历到的电影对象
Movie m = movies[i];
// 判断当前电影对象的id是否和输入的id一致，是打印出该信息并立即结束方法
if (m.getId() == id){
System.out.println(m.getId() + "\t" +m.getName() + "\t" + m.getPrice() + "\t" + m.getActor()+ "\t");
return;
}
}
System.out.println("没有找到该id对应的电影信息！");
}
}电影类
java
package com.itheima.demo;
/**
* ClassName: Movie
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-25 14:57
* @Version: 1.0
*/
public class Movie {
private int id; // 编号
private String name;
private double price;
private String actor;
public Movie() {
}
public Movie(int id, String name, double price, String actor) {
this.id = id;
this.name = name;
this.price = price;
this.actor = actor;
}
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 double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getActor() {
return actor;
}
public void setActor(String actor) {
this.actor = actor;
}
}测试
java
package com.itheima.demo;
/**
* ClassName: Test
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-25 14:55
* @Version: 1.0
*/
public class Test {
public static void main(String[] args) {
// 目标：完成面向对象的综合小案例
// 1、设计电影类Movie，以便创建电影对象，封装电影数据。
// 2、封装系统中的全部电影数据，（自己造一些数据）
Movie[] movies = new Movie[6];
// movies = [null, null, null, null, null, null]
// 0 1 2 3 4 5
movies[0] = new Movie(1, "星际穿越", 9.6, "安妮海蔷薇");
movies[1] = new Movie(2, "唐顿庄园", 9.5, "维维SOURCE");
movies[2] = new Movie(3, "唐顿庄园2", 9.4, "维维SOURCE");
movies[3] = new Movie(4, "唐顿庄园3", 9.3, "维维SOURCE");
movies[4] = new Movie(5, "唐顿庄园4", 9.2, "维维SOURCE");
movies[5] = new Movie(6, "唐顿庄园5", 9.1, "维维SOURCE");
// 3、创建电影操作对象出来，专门负责电影数据的业务操作。
MovieOperator mo = new MovieOperator(movies);
mo.printAllMovies();
mo.searchMovieById();
}
}加油站支付小模块
卡
java
package com.itheima.demo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* ClassName: Card
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-26 08:08
* @Version: 1.0
*/
// Lombok技术可以实现为类自动添加getter setter方法 无参数构造器，toString方法等。
@Data // @Data注解可以自动生成getter setter方法无参构造器 toString方法等
@NoArgsConstructor
@AllArgsConstructor
public class Card {
private String carId; // 车牌号码
private String name;
private String phone;
private double money; // 余额
// 预存金额
public void deposit(double money) {
this.money += money;
System.out.println("预存成功，余额为：" + this.money);
}
// 消费金额
public void consume(double money){
this.money -= money;
}
}金卡
java
package com.itheima.demo;
/**
* ClassName: GoldCard
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-26 08:20
* @Version: 1.0
*/
public class GoldCard extends Card {
public GoldCard(String card, String name, String phone, int money) {
super(card, name, phone, money);
}
@Override
public void consume(double money){
System.out.println("您当前金卡消费：" + money);
System.out.println("优惠后的价格：" + money*0.8);
if(getMoney() < money * 0.8){
System.out.println("您余额是：" + getMoney() + "，当前余额不足！请存钱！");
return; // 干掉方法
}
// 更新金卡的账户余额。
setMoney(getMoney()-money*0.8);
System.out.println("您当前余额是：" + getMoney());
// 判断消费如果大于200，调用一个独有的功能，打印洗车票。
if(money * 0.8 >= 200){
printTicket();
}else {
System.out.println("您没有消费200元以上，没有打印洗车票");
}
}
// 打印洗车票。
public void printTicket() {
System.out.println("您消费了，请打印洗车票");
}
}银卡
java
package com.itheima.demo;
/**
* ClassName: SliverCard
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-26 08:33
* @Version: 1.0
*/
public class SliverCard extends Card{
public SliverCard(String card, String name, String phone, int money) {
super(card, name, phone, money);
}
@Override
public void consume(double money){
System.out.println("您当前银卡消费：" + money);
System.out.println("优惠后的价格：" + money*0.9);
if(getMoney() < money * 0.9){
System.out.println("您余额是：" + getMoney() + "，当前余额不足！请存钱！");
return; // 干掉方法
}
// 更新金卡的账户余额。
setMoney(getMoney()-money*0.9);
System.out.println("您当前余额是：" + getMoney());
}
}测试
java
package com.itheima.demo;
import java.util.Scanner;
/**
* ClassName: Test
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-26 08:07
* @Version: 1.0
*/
public class Test {
public static void main(String[] args) {
//目标:加油站支付小程序。
//1、创建卡片类，以便创建金卡或者银卡对象，封装车主的数据。
//2、定义一个卡片父类:Card
//3、定义一个金卡类，金卡必须重写消费方法(8折优惠)
//3、定义一个银卡类，继承Card类:银卡必须重写消费方法(9折优惠)
// 4、办一张金卡:创建金卡对象。交给一个独立的业务(支付机)来完成:存款，消费。
GoldCard goldCard = new GoldCard("鄂A86OMM", "dlei", "18665616520", 5000);
goldCard.deposit(100); // 再存100元
pay(goldCard);
// 4、办一张银卡:创建银卡对象。交给一个独立的业务(支付机)来完成:存款，消费。
SliverCard sliverCard = new SliverCard("粤A86OMM", "dlei", "13455556666", 2000);
pay(sliverCard);
}
// 支付机:用一个方法来刷卡。
public static void pay(Card c) {
System.out.println("请刷卡,请您输入当前消费的金额：");
Scanner sc = new Scanner(System.in);
double money = sc.nextDouble();
c.consume(money);
}
}接口的应用案例
java
package com.itheima.interface3;
/**
* ClassName: ClassDataInter
* Package: com.itheima.interface3
* Description:
*
* @Author: start
* @Create 2026-04-26 15:56
* @Version: 1.0
*/
public interface ClassDataInter {
void printAllStudentInfos();
void printAverageScore();
}
java
package com.itheima.interface3;
/**
* ClassName: ClassDataInterImpl1
* Package: com.itheima.interface3
* Description:
*
* @Author: start
* @Create 2026-04-26 15:59
* @Version: 1.0
*/
public class ClassDataInterImpl1 implements ClassDataInter {
private Student[] students;
public ClassDataInterImpl1(Student[] students) {
this.students = students;
}
@Override
public void printAllStudentInfos() {
System.out.println("全班学生信息如下：");
for(int i = 0; i < students.length; i++){
Student s = students[i];
System.out.println(s.getName() + " " + s.getSex() + " " + s.getScore());
}
}
@Override
public void printAverageScore() {
double sum = 0;
for(int i = 0; i < students.length; i++){
Student s = students[i];
sum += s.getScore();
}
System.out.println("全班平均分是：" + sum / students.length);
}
}
java
package com.itheima.interface3;
/**
* ClassName: ClassDataInterImpl2
* Package: com.itheima.interface3
* Description:
*
* @Author: start
* @Create 2026-04-26 16:01
* @Version: 1.0
*/
// -- 定义第二套实现类，实现接口:实现打印学生信息(男女人数)，实现打印平均分(去掉最高分和最低分)
public class ClassDataInterImpl2 implements ClassDataInter {
private Student[] students; // 记住送来的全班学生对象信息
public ClassDataInterImpl2(Student[] students) {
this.students = students;
}
@Override
public void printAllStudentInfos() {
int maleCount = 0;
System.out.println("全班学生信息如下：");
for(int i = 0; i < students.length; i++){
System.out.println(students[i].getName() + " " + students[i].getSex() + " " + students[i].getScore() );
if(students[i].getSex() == '男'){
maleCount++;
}
}
System.out.println("全班共有" + maleCount + "个男生");
System.out.println("全班共有" + (students.length - maleCount) + "个女生" );
}
// 实现打印平均分(去掉最高分和最低分)
@Override
public void printAverageScore() {
System.out.println("全班平均分是：");
Student s1 = students[0];
double sum = s1.getScore();
double max = s1.getScore();
double min = s1.getScore();
for(int i = 1; i < students.length; i++){
Student s = students[i];
sum += s.getScore();
if(s.getScore() > max){
max = s.getScore();
}
if(s.getScore() < min){
min = s.getScore();
}
}
System.out.println("最高分：" + max);
System.out.println("最低分：" + min);
System.out.println("平均分是：" + (sum - max - min) / (students.length - 2));
}
}
java
package com.itheima.interface3;
import jdk.jfr.DataAmount;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* ClassName: Student
* Package: com.itheima.interface3
* Description:
*
* @Author: start
* @Create 2026-04-26 15:41
* @Version: 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
private String name;
private char sex;
private double score;
}
java
package com.itheima.interface3;
/**
* ClassName: Test
* Package: com.itheima.interface3
* Description:
*
* @Author: start
* @Create 2026-04-26 15:41
* @Version: 1.0
*/
public class Test {
public static void main(String[] args) {
// 目标:完成接口的小案例。
// 1、定义学生类，创建学生对象，封装学生数据，才能交给别人处理学生的数据
// 2、准备学生数据，目前我们自己造一些测试数据
Student[] allStudents = new Student[10];
allStudents[0] = new Student("小王",'男', 18);
allStudents[1] = new Student("小张",'女', 19);
allStudents[2] = new Student("小李",'男', 20);
allStudents[3] = new Student("小赵",'女', 17);
allStudents[4] = new Student("小孙",'男', 16);
allStudents[5] = new Student("小周",'女', 15);
allStudents[6] = new Student("小吴",'男', 14);
allStudents[7] = new Student("小郑",'女', 13);
allStudents[8] = new Student("小王",'男', 12);
allStudents[9] = new Student("小王",'女', 11);
// 3、提供两套业务实现方案，支持灵活切换(解耦合)：面向接口编程
// -- 定义一个接口(规范思想):必须完成打印全班学生信息，打印平均分。(ClassDataInter)
// -- 定义第一套实现类，实现接口:实现打印学生信息，实现打印平均分。
// -- 定义第二套实现类，实现接口:实现打印学生信息(男女人数)，实现打印平均分(去掉最高分和最低分
ClassDataInter cdi = new ClassDataInterImpl2(allStudents);
cdi.printAllStudentInfos();
cdi.printAverageScore();
}
}抽象类、接口的区别对比
相同点： 1、多是抽象形式，都可以有抽象方法，都不能创建对象。 2、都是派生子类形式:抽象类是被子类继承使用，接口是被实现类实现。 3、一个类继承抽象类，或者实现接口，都必须重写完他们的抽象方法，否则自己要成为抽象类或者报错! 4、都能支持的多态，都能够实现解耦合。 不同点： 1、抽象类中可以定义类的全部普通成员，接口只能定义常量，抽象方法(JDK8新增的三种方式) 2、抽象类只能被类单继承，接口可以被类多实现。 3、一个类继承抽象类就不能再继承其他类，一个类实现了接口(还可以继承其他类或者实现其他接口)。 4、抽象类体现模板思想:更利于做父类，实现代码的复用性。 最佳实践 5、接口更适合做功能的解耦合:解耦合性更强更灵活。 最佳实践
java
package com.itheima.demo;
/**
* ClassName: Air
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-26 17:53
* @Version: 1.0
*/
// 空调
public class Air extends JD{
public Air(String name, boolean status) {
super(name, status);
}
}
java
package com.itheima.demo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* ClassName: JD
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-26 17:45
* @Version: 1.0
*/
// 家电
@Data
@NoArgsConstructor
@AllArgsConstructor
public class JD implements Switch {
private String name;
// 状态：true-开，false-关
private boolean status; // false 默认是关闭
@Override
public void press() {
// 控制当前设备开和关
status = !status;
}
}
java
package com.itheima.demo;
/**
* ClassName: Lamp
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-26 17:49
* @Version: 1.0
*/
// 灯
public class Lamp extends JD{
public Lamp(String name, boolean status) {
super(name, status);
}
}
java
package com.itheima.demo;
/**
* ClassName: SmartHomeControl
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-26 18:14
* @Version: 1.0
*/
// 智能控制系统
public class SmartHomeControl {
private static final SmartHomeControl smartHomeControl = new SmartHomeControl();
private SmartHomeControl(){}
public static SmartHomeControl getInstance(){
return smartHomeControl;
}
// 多态
public void control(JD jd) {
System.out.println("开始您的操作");
System.out.println(jd.getName() + "状态目前是：" + (jd.isStatus() ? "开着" : "关闭"));
System.out.println("开始您的操作。。。。");
jd.press(); // 按下开关
System.out.println(jd.getName() + "状态已经是：" + (jd.isStatus() ? "开着" : "关闭"));
}
public void printAllStatus(JD[] jds) {
// 使用for循环，根据索引遍历每个设备
for(int i = 0; i < jds.length; i++){
JD jd = jds[i];
System.out.println((i+1) + "," +jd.getName() + "状态目前是：" + (jd.isStatus() ? "开着" : "关闭"));
}
}
}
java
package com.itheima.demo;
/**
* ClassName: Switch
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-26 18:08
* @Version: 1.0
*/
public interface Switch {
void press(); // 按压
}
java
package com.itheima.demo;
import java.util.Scanner;
/**
* ClassName: Test
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-26 17:39
* @Version: 1.0
*/
public class Test {
public static void main(String[] args) {
// 目标:面向对象编程实现智能家居控制系统。
// 角色:设备(吊灯，电视机，洗衣机，落地窗，.
// 具备的功能:开和关。
// 谁控制他们:智能控制系统(单例对象)，控制调用设备的开和关
// 1、定义设备类:创建设备对象代表家里的设备。
// 2、准备这些设备对象，放到数组中，代表整个家庭的设备。
JD[] jds = new JD[4];
jds[0] = new TV("小米电视", true);
jds[1] = new WashMachine("美的洗衣机", false);
jds[2] = new Lamp("欧灯", true);
jds[3] = new Air("美的空调", false);
// 3、为每个设备制定一个开和关的功能。定义一个接口，让JD实现开关功能。
// 4、创建智能控制系统对象，控制设备开和关。
SmartHomeControl smartHomeControl = SmartHomeControl.getInstance();
// 5、控制电视机
//smartHomeControl.control(jds[0]);
//6、提示用户操作，a、展示全部设备的当前情况。b、让用户选择哪一个操作。
//打印全部设备的开和关的现状。
while(true) {
smartHomeControl.printAllStatus(jds);
System.out.println("请选择要控制的设备：");
Scanner sc = new Scanner(System.in);
String command = sc.next();
switch (command) {
case "1":
smartHomeControl.control(jds[0]);
break;
case "2":
smartHomeControl.control(jds[1]);
break;
case "3":
smartHomeControl.control(jds[2]);
break;
case "4":
smartHomeControl.control(jds[3]);
break;
case "exit":
System.out.println("退出App");
return;
default:
System.out.println("输入错误！");
}
}
}
}
java
package com.itheima.demo;
/**
* ClassName: TV
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-26 17:53
* @Version: 1.0
*/
// 家电
public class TV extends JD{
public TV(String name, boolean status) {
super(name, status);
}
}
java
package com.itheima.demo;
/**
* ClassName: WashMachine
* Package: com.itheima.demo
* Description:
*
* @Author: start
* @Create 2026-04-26 17:52
* @Version: 1.0
*/
// 洗衣机
public class WashMachine extends JD {
public WashMachine(String name, boolean status) {
super(name, status);
}
}匿名内部类
java
package com.itheima.innerclass3;
import java.util.Arrays;
import java.util.Comparator;
/**
* ClassName: Test4
* Package: com.itheima.innerclass3
* Description:
*
* @Author: start
* @Create 2026-04-27 10:03
* @Version: 1.0
*/
public class Test4 {
// 目标:完成给数组排序，理解其中匿名内部类的用法。
//准备一个学生类型的数组，存放6个学生对象。
public static void main(String[] args) {
Student[] students = new Student[6];
students[0] = new Student("殷素素", 35, 171.5, '女');
students[1] = new Student("张三", 18, 180.5, '男');
students[2] = new Student("李四", 19, 185.5, '男');
students[3] = new Student("王五", 20, 169.5, '女');
students[4] = new Student("赵六", 21, 178.5, '男');
students[5] = new Student("小七", 22, 175.5, '女');
// 需求：按钮年龄升序排序。可以调用sun公司写好的API直接对数组进行排序。
// public static void sort(int[] a)
// public static void sort(T[] a, Comparator<T> c)
// 参数一: 需要排序的数组
// 参数二: 需要给sort声明一个Comparator比较器对象(指定排序的规则)
// sort方法会调用匿名内部类对象的compare方法，对数组中的学生对象进行两两比较，从而实现排序。
Arrays.sort(students, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
// 指定排序规则。
// 如果你认为左边对象 大于 右边对象 那么返回正整数。
// 如果你认为左边对象 小于右边对象 那么返回负整数。
// 如果两边相等那么返回0。
//if(o1.getAge() > o2.getAge()){
// return 1;
//}else if(o1.getAge() < o2.getAge()){
// return -1;
//}
//return 0;
//return o1.getAge() - o2.getAge(); // 按照年龄升序
return o2.getAge() - o1.getAge(); // 按照年龄降序
}
});
// 遍历数组中的学生对象并输出
for(int i = 0; i < students.length; i++){
Student s = students[i];
System.out.println(s);
}
}
}
java
package com.itheima.innerclass3;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
ClassName: Student
Package: com.itheima.innerclass3
Description:
@Author: start
@Create 2026-04-27 10:10
@Version: 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
// 姓名 年龄 身高 性别
private String name;
private int age;
private double height;
private char sex;
}
java
package com.itheima.gui2;
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
/**
* ClassName: LoginFrame
* Package: com.itheima.gui2
* Description:
*
* @Author: start
* @Create 2026-04-27 15:33
* @Version: 1.0
*/
// 自定义的登录界面：认JFrame做爸爸
public class LoginFrame extends JFrame implements ActionListener {
public LoginFrame() {
// 1.设置窗口的标题
this.setTitle("登录界面");
// 2.设置窗口的大小
this.setSize(400, 300);
// 3.设置窗口的位置
this.setLocationRelativeTo(null);
// 4.设置窗口的关闭模式
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// 5.设置窗口是否可见
//this.setVisible(true);
init(); // 初始化这个窗口上的组件
}
public void init() {
// 添加一个登录按钮
JButton btn = new JButton("登录");
btn.addActionListener(this);
JPanel panel = new JPanel();
this.add(panel);
panel.add(btn);
}
@Override
public void actionPerformed(ActionEvent e) {
JOptionPane.showConfirmDialog(this, "我被点击了~！");
}
}
java
package com.itheima.gui2;
import javax.swing.*;
/**
* ClassName: Test3
* Package: com.itheima.gui2
* Description:
*
* @Author: start
* @Create 2026-04-27 15:32
* @Version: 1.0
*/
public class Test3 {
public static void main(String[] args) {
// 目标：自定义一个登录界面，让界面对象本身也是时间监听器对象
LoginFrame lf = new LoginFrame(); // 登录界面
lf.setVisible(true); // 显示界面
}
}效果：
