【学习笔记】黑马Java+AI智能辅助编程视频教程，java基础入门

一、引言部分

• 课程特色

1. 课程基于主流的AI讲解Java技术，涵盖丰富案例+大量java小项目开发，引入GUI界面编程，结合AI工具辅助代码生成与调试，降低门槛，帮助初学者入门Java学习，培养学生独立开发出各种管理系统和Java小游戏的水平。

2. 视频教学：Java基础-01-day05介绍-面向对象编程入门_哔哩哔哩_bilibili

• 课程面向学习对象

Java入门初学者、Java求职面试

二、课程内容概览

• Java基础模块
  • 核心语法与面向对象编程
  • 集合框架与多线程实战
• AI辅助工具应用
  • 代码自动生成工具（IDEA2023+Lingma）
  • AI调试与优化技巧
• 综合项目实战
  • 结合AI的Java项目案例解析

三、学习详情

1.IDEA工具基础

使用idea开发java程序的步骤是什么？

● project -> module -> package -> class

●一个project中可以创建多个module

一个module中可以创建多个package

●一个package中可以创建多个class

创建都是用哪个关键字？

New project->module->package->class

编译后的class文件放在"out"

快捷键

2.基础概念

字面量

规范数据在程序中的书写格式

字符（单引号''）字符串（双引号""）

变量：格式： 数据类型 变量名称 = 数据; int age = 18;

package com.itheima.variabledemo;

public class veriable {
    public static void main(String[] args) {
        //目标：认识变量
        printVariable();
    }
    public static void printVariable() {
        //定义变量的使用，提高数据灵活性和维护性
        int a = 10;
        System.out.println(a);
        //定义小数变量，存储学生成绩
        double score = 89.5;
        System.out.println(score);
        //定义字符变量，存储姓名
        char name = '中';
        System.out.println(name);

        //研究变量的特点，可替换性
        int a1 = 10;
        a1=a1+1;
        System.out.println(a1);
    }
}

**存储数据原理：**二进制-字符的存储ascll码字符集；进制转换

**数据类型：**基本数据类型

引用数据类型（后期学习）

关键字&标识符：(类名、变量名...都是标识符)

package com.itheima.variabledemo;

public class veriabledemo02 {
    public static void main(String[] args) {
        //掌握8中基本数据类型定义变量
        printVariable();
    }
    //请帮我设计一个方法，打印出8中基本数据类型定义的变量
    public static void printVariable() {
        //1.整型
        byte b=10;
        short s=20;
        int i=30;
        //注意：随便写一个整数字面量默认是int类型的，123456788877643274超过了int类型的范围，所以需要加上L
        long l1=123456788877643274L;
        long l=40;

        //2.浮点型
        //注意：随便写一个浮点数字面量默认是double类型的，如果希望1.1是float类型的，必须加上f
        //float f=1.1;
        float f=1.1f;
        double d=2.2;

        //3.字符型
        char c='a';

        //4.布尔型
        boolean bool=true;

        //5.字符串型
        String str="hello world";

        System.out.println(b);
        System.out.println(s);
        System.out.println(i);
        System.out.println(l);
        System.out.println(f);
        System.out.println(d);
        System.out.println(c);
        System.out.println(bool);
        System.out.println(str);
    }


}

3.方法

1.基本格式

示例：

package com.ithei.method;

public class methoddemo1 {
    public static void main(String[] args){
        //调用方法
        int sum = getSum(10,20);
        System.out.println("和是: " + sum);

        System.out.println("---------------------------------");
        int sum2 = getSum(100,200);
        System.out.println("和是: " + sum2);
        System.out.println("---------------------------------");
    }
    //定义一个方法，求任意两整数的和
    public static int getSum(int a,int b){
        return a + b;
    }
}

static关键字：表示该方法属于类本身，而不是类的实例

void返回值：表示这个方法不返回任何值

方法定义 ：getSum是一个自定义方法，它接收两个整数参数a和b

2.其他形式：是否接受/返回数据

package com.ithei.method;

public class methoddemo3 {
    public static void main(String[] args){
        //定义无返回值方法
        printHelloWorld();//调用方法,无返回值,×System.out.println("HelloWorld");
        //调用getCode方法，有返回值
        System.out.println(getCode(4));
    }
    //打印3行helloworld，不需要参数，也不需要返回值
    //注意：如果方法没有返回结果，返回值类型必须声明void
    public static void printHelloWorld(){
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
    }
    //获取一个指定位置的验证码返回，无须参数，有返回值
    //需要接受位数 int len
    //需要返回验证码 String
    public static String getCode(int len){
        String code = "";
        for (int i = 0; i < len; i++) {
            int number = (int)(Math.random()*10);
            code += number;
        }
        return code;
    }
}

3.方法重载

方法重载只关心方法名称相同，形参列表不同（类型/个数/顺序不同），其他随意。

意义：为执行相似操作的方法提供一个统一的名称，让API更易于使用和记忆。

package com.ithei.method;

public class methoddemo2 {
    public static void main(String[] args) {
        //目标：认识方法重载
    }
    //定义一个方法，打印一个整数
    public static void print(int a){
        System.out.println(a);
    }
    //定义一个重载的方法（方法名仍为print），打印一个字符串
    public static void print(String str){
        System.out.println(str);
    }
    //注意，方法重载只关心方法名称相同，形参列表不同（类型/个数/顺序不同）
    /*重复的方法（示例：形参类型/个数/顺序相同），冲突
    public static void print(int a,String str){
        System.out.println(a+str);
    }
    public static void print(int a,String str){
        System.out.println(str+a);
    }
    */
    //重载意义，实战示例
    //发射导弹
    public static void fire (int x, int y){
        System.out.println("发射导弹,坐标："+x+","+y);
    }
    //定义一个重载方法
    public static void fire (int x, int y,String location){
        System.out.println("发射导弹,坐标："+x+","+y+", "+location);
    }
}

4.类型转换

• 自动类型转换：类型范围小的变量，可以直接赋值给类型范围大的变量。（如下左图）

在计算机中的执行原理：（如下右图）

• 强制类型转换：类型范围大的变量-->类型范围小的变量，需要强制类型转换

代码示例：

package com.itheima.type;

public class typedemo1 {
    public static void main(String[] args) {
        //认识自动类型转换，强制类型转换
        byte a = 10;//一个字节
        print( a);//自动类型转换a -> int（小范围-> 大范围）

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

        int i = 20;
        //print2( i);//自动类型转换 i -> byte（大范围-> 小范围）报错
        print2((byte)i);//强制类型转换 i -> byte
        System.out.println("----------------");

        int i2 = 1500;
        byte j2 = (byte)i2;
        System.out.println(j2);//j数值超出byte[0,127]范围之内,输出-36（补码）
        System.out.println("----------------");

        double k = 10.5;
        print((int)k);//浮点型转换成整数，直接去掉小数部分

    }
    //自动类型转换
    public static void print(int b){
        System.out.println(b);
    }
    //强制类型转换
    public static void print2(byte j){ //j数值大小在[0,127]范围之内
        System.out.println(j);
    }
}

• 表达式的自动类型提升：

●在表达式中，小范围类型的变量，会自动转换成表达式中较大范围的类型，再参与运算。

●表达式的最终结果类型由表达式中的最高类型决定。

●在表达式中，byte、short、char是直接转换成int类型参与运算的。

package com.itheima.type;

public class typedemo2 {
    public static void main(String[] args) {
        //目标：理解表达式的自动类型转换
    }
    //接受各种类型的数据运算
    public static double calc(int a,int b,double c,char r){
        return a+b+c+r;
    }
    //byte自动转int，如需返回byte类型需要强制类型转换
    public static byte calc2(byte a,byte b){
        return (byte)(a+b);
    }
    //byte自动转int
    public static int calc3(byte a,byte b){
        return a+b;
    }
}

5.输入输出

●输入：程序读取用户键盘输入的数据。

package com.itheima.scanner;
//1.导包,告诉本机程序，去jdk哪里找Scanner
import java.util.Scanner;
public class scannerdemo1 {
    public static void main(String[] args) {
    }
    //需求：我是一个零基础小白，帮我写一个程序，可以让用户键盘输入用户名和年龄，然后打印输出
    public static void printUserInfo() {

        //2.创建键盘输入对象（抄写此行）
        Scanner sc = new Scanner(System.in);
        //创建一个扫描器对象，用于接收键盘输入.sc为扫描器对象

        //3.接收数据
        System.out.println("请输入用户名：");
        String name = sc.next();
        //让程序在此行暂停，等待用户输入数据回车后继续执行
        System.out.println("请输入年龄：");
        int age = sc.nextInt();

        //4.打印输出;
        System.out.println("用户名："+name+"，年龄："+age);
    }
}

●输出：把程序中的数据展示出来。

6.运算符

• 算术运算符+-*/%

package com.itheima.operator;

public class operator {
    public static void main(String[] args) {
        // 算数运算符
        print(10,20);
    }
    public static void print(int a,int b) {
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);
        System.out.println(a % b);
    }

    //研究+符号是连接符还是运算符
    public static void print2() {
        int a = 5;
        int b = 10;
        System.out.println(a + b);
        System.out.println("hello" + "world");// helloworld
        System.out.println("itheima" + a);// itheima5
    }
}

• 自增自减运算符：

表达式	名称	执行顺序	表达式的值	变量最终值
i++	后自增	先使用，后加1	增加前的值	i + 1
++i	前自增	先加1，后使用	增加后的值	i + 1
i--	后自减	先使用，后减1	减少前的值	i - 1
--i	前自减	先减1，后使用	减少后的值	i - 1

package com.itheima.operator;

public class operatordemo2 {
    public static void main(String[] args) {
        //理解自增自减运算符
        print();
        System.out.println("==================");
        print2(10);
    }
    public static void print() {
        int a = 10;
        System.out.println(a++);//a=a+1,a=11
        System.out.println(++a);//a=a+1,a=12
        System.out.println(a);
    }
    //设计一个方法，用于理解自增和自减在变量前后的区别
    public static void print2(int a) {
        int b=a++;//先用后加
        System.out.println(a);//11,a=10+1
        System.out.println(b);

        int c=++a;//先加后用
        System.out.println(a); //12,a=11+1
        System.out.println(c);//12
    }
}

• 赋值运算符

符号	用法	作用	示例
=	a = b	将右边的值赋给左边	int a = 10; // 把10赋值给变量a
+=	a += b	加后赋值	a += 5; // 等价于 a = a + 5
-=	a -= b	减后赋值	a -= 3; // 等价于 a = a - 3
*=	a *= b	乘后赋值	a *= 2; // 等价于 a = a * 2
/=	a /= b	除后赋值	a /= 4; // 等价于 a = a / 4
%=	a %= b	取余后赋值	a %= 3; // 等价于 a = a % 3

• 扩展运算符：

注意：扩展赋值运算符自带强制类型转换

package com.itheima.operator;

public class operatordemo3 {
    public static void main(String[] args) {
        //掌握扩展的赋值运算符
    }
    //收红包
    public static void receive(int money) {
        int bonus =100;
        money += bonus;//等价于money = （a的类型）money + bonus;
        System.out.println("收红包成功，红包金额："+money);

        byte a1=10;
        byte b1=20;
        a1+=b1;//扩展赋值运算符自带强制类型转换
        //byte c1=(byte)(a1+b1);
        System.out.println(a1);
    }
    
    //再演示其他几个扩展赋值运算符
    public static void print() {
        int a = 10;
        a *= 5;//a = a * 5;
        System.out.println(a);
        a /= 5;//a = a / 5;
        System.out.println(a);
        a %= 5;//a = a % 5;
        System.out.println(a);
    }
}

• 关系运算符&三目运算符：

判断数据是否满足条件，最终会返回一个判断的结果，这个结果是布尔类型的值：true或者false
注意：在java中判断是否相等一定是"="，千方不要把"=="误写成"="。

符号	例子	作用	结果
>	a > b	判断a是否大于b	成立返回true，不成立返回false
>=	a >= b	判断a是否大于或者等于b	成立返回true，不成立返回false
<	a < b	判断a是否小于b	成立返回true，不成立返回false
<=	a <= b	判断a是否小于或者等于b	成立返回true，不成立返回false
==	a == b	判断a是否等于b	成立返回true，不成立返回false
!=	a != b	判断a是否不等于b	成立返回true，不成立返回false

package com.itheima.operator;

public class operatordemo4 {
    public static void main(String[] args) {
        //关系运算符
        print(10,2);
        System.out.println("==================");
        //三元运算符
        print2(10,20);
        System.out.println("==================");
        print3(60);
    }
    //关系运算符
    public static void print(int a,int b)
    {
        System.out.println(a>b);//true
        System.out.println(a<b);//
        System.out.println(a==b);//false
        System.out.println(a>b && a<b);//false
        System.out.println(a>b || a<b);// true
        System.out.println(!(a>b));// true
    }
    //三元运算符
    public static void print2(int a,int b){
        System.out.println(a > b ? a : b);//输出最大值,表达式含义：若a>b,则输出a,否则输出b
    }
    public static void print3(int score){
        String result = score>60?"通过":"未通过";
        System.out.println(result);
    }
}

• 逻辑运算符：

符号	名称	例子	运算规则	结果说明
&	逻辑与	2 > 1 & 3 > 2	两个条件都为true，结果才为true	true & true → true
|	逻辑或	2 > 1 | 3 < 5	两个条件有一个为true，结果就为true	true | true → true
!	逻辑非	!(2 > 1)	取反操作，true变false，false变true	!true → false
^	逻辑异或	2 > 1 ^ 3 > 1	两个条件不同时结果为true，相同时为false	true ^ true → false
&&	短路与	2>10&&3> 2	判断结果与"&"一样，过程不同：左为false则不执行右边。
||	短路或	2>1||3<5	判断结果与"|"一样，过程不同：左边为true，则不执行右边

package com.itheima.operator;

public class operatordemo5 {
    public static void main(String[] args) {
        //逻辑运算符（多条件判断）
        System.out.println(isGoods(120,'M',1));
        System.out.println("==================");
        print();
    }
    //判断某商品是否符合顾客要求(使用与运算)
    public static boolean isGoods(int price,int size,int color){
        boolean flag = (price >= 100 & size == 'M' & color == 1);
        return flag;
    }
    //判断&& ||与& |的区别
    public static void print(){
        int a=120;
        int b=2;
        System.out.println(a>100 && ++b>1);//1110>100 && 2>1,左边为true,继续计算,b=b+1,b=3
        System.out.println(b);//3
        System.out.println(a > 100 & ++b > 1);//1110>100 & 2>1,true & 继续计算,b=b+1,b=4
        System.out.println(b);//4

        int i=10;
        int j=20;
        System.out.println(i>0 || ++j>10);//true || 继续计算,j=20
        System.out.println(j);//20
        System.out.println(i>0 | ++j>10);//true | 不再继续计算,j=j+1,j=21
        System.out.println(j);//21
    }
}

7.综合实战

●开发一个简单的健康计算器应用程序，它可以接受用户的输入（如年龄、性别、体重、身高），并计算出用户的BMI（身体质量指数）和基础代谢率（BMR）。

●文件路径：day02-basic\src\com\itheima\demo1\AITest.java

【其他】 Scanner：Java中常用的输入工具，位于java.util包中，用于从不同输入源（如键盘、文件或字符串）读取数据。

Scanner sc = new Scanner(System.in);的快捷输入：https://live.csdn.net/v/494099

package com.itheima.demo1;

import java.util.Scanner;

public class AITest {
    public static void main(String[] args) {
        //设计一个健康计算器
        Scanner sc = new Scanner(System.in);
        //1.先让用户输入个人的信息：身高、体重、年龄
        System.out.println("请输入身高：");
        double height = sc.nextDouble();

        System.out.println("请输入体重：");
        double weight = sc.nextDouble();

        System.out.println("请输入性别：");
        String sex = sc.next();

        System.out.println("请输入年龄：");
        int age = sc.nextInt();

        double bmi = getBMI(height,weight);
        System.out.println("您的BMI："+bmi);

        double bmr = getBMR(height,weight,age,sex);
        System.out.println("您的BMR："+bmr);

    }
    //2.根据个人信息，计算BMI值（把数据交给一个独立的方法计算并返回这个结果)
    public static double getBMI(double height,double weight){
        return weight/(height*height);
    }
    //3.根据个人信息，计算BMR值（把数据交给一个独立方法计算并返回这个结果）
    public static double getBMR(double height,double weight,int age,String sex){
        double bmr=0.0;
        if("男".equals(sex)){
            bmr=66 + (13.7 * weight) + (5 * height) - (6.8 * age);
        }else{
            bmr = 655 + (9.6 * weight) + (1.8 * height) - (4.7 * age);
        }
        return bmr;
    }
}

4.程序流程控制

三种执行顺序：

结构类别	概念	语句	应用
顺序结构	自上而下的程序		计算圆的面积
分支结构	根据条件，选择对应的代码执行	if、switch	判断成绩等级、根据数字输出星期几
循环结构	控制某段代码重复的执行	for、while、do-while	计算1到100的累加和、菜单选择（至少执行一次）

1. if 分支结构（根据条件选择执行）

package com.itheima.branch;

import java.util.Scanner;

public class ifdemo {
    public static void main(String[] args){
        //认识if语句,搞清楚其写法和应用场景（独立功能及方法）
        test1();
        test2();
        test3();
    }
    public static void test1(){
        int age = 10;
        if (age >= 18){
            System.out.println("可以投票");
        }
        System.out.println("程序结束");
    }
    public static void test2(){
        //需求：钱包余额90，现要求转出80，用if分支实现
        //要求钱够提示转账成功，否则提示余额不足
        int money = 90;
        if (money >= 80){
            System.out.println("转账成功");
        }else{
            System.out.println("余额不足");
        }
    }
    public static void test3(){
        //需求：绩效系统，每月由主管给员工打分
        //输出当月绩效级别:A、B、C、D
        //级别的区间情况：90-100:A，80-90:B，70-80:C，60-70:D
        System.out.println("请输入员工当月的分数：");
        Scanner sc = new Scanner(System.in);
        int score = sc.nextInt();
        if (score >= 90 && score <= 100){
            System.out.println("A");
        }else if (score >= 80 && score <= 90){
            System.out.println("B");
        }else if (score >= 70 && score <= 80){
            System.out.println("C");
        }else if (score >= 60 && score <= 70){
            System.out.println("D");
        }else{
            System.out.println("E");
        }

    }
}

实战案例：自动汽车驾驶程序

package com.itheima.branch;

public class iftest2 {
    public static void main(String[] args) {
        //目标：完成自动驾驶汽车程序的书写，根据红绿灯状态判断是否可以行驶
        test1();
    }
    public static void test1(){
        //1.假设收到三种灯的状态信息
        boolean red = false;
        boolean green = true;
        boolean yellow = false;

        //2.使用if语句判断红灯亮则停止，黄灯亮则等待，绿灯亮则行驶
        if(red){
            System.out.println("停止");
        }else if( yellow){
            System.out.println("等待");
        }else if(green){
            System.out.println("行驶");
        }else{
            System.out.println("交通信号故障，注意行人！");
        }
    }
}

2. switch分支结构（比较值是否相等，决定是否执行）

package com.itheima.branch;

import java.util.Scanner;

public class switchdemo3 {
    public static void main(String[] args) {
        //目标：掌握switch分支结构的应用和写法，理解执行流程
        test1();
    }
    //需求：根据男女性别不同，推荐不同的书本信息供客户参考
    public static void test1(){
        //1.让用户输入自己的性别
        System.out.println("请输入你的性别：");
        Scanner sc = new Scanner(System.in);
        String sex = sc.next();
        //2.根据性别进行判断
        switch (sex){
            case "男":
                System.out.println("推荐《Java从入门到精通》");
                break;
            case "女":
                System.out.println("推荐《Python从入门到精通》");
                break;
            default:
                System.out.println("请输入正确的性别！");
                break;
        }
    }
}

3. 循环结构

• for循环（控制一段代码反复执行多次，减少重复代码的编写）

package com.itheima.loop;

public class fordemo2 {
    public static void main(String[] args) {
        //需求：求1-100的数字和
        System.out.println("求1-100的数字和");
        System.out.println(sum());
        System.out.println("===============================");
        //需求：求计数和
        System.out.println("求求1-100的奇数和：");
        System.out.println(sum2());
    }
    public static int sum() {
        //1.初始化一个变量，保存和
        int sum = 0;
        //2.循环变量i，从1开始，每次加1，循环100次
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
    //求奇数和（只遍历奇数，累加）
    public static int sum2() {
        int sum = 0;
        for (int i = 1; i <= 100; i += 2) {
            sum += i;
        }
        return sum;
    }
}

• while循环（不知道循环次数）

案例演示：复利计算，问几年后本金翻倍；计算折叠次数，问折叠几次超过目标高度

package com.itheima.loop;

public class whiledemo5 {
    public static void main(String[] args) {
        //目标：完成while循环的需求：复利计算
        System.out.println("需要多少年：" + calc());
        //目标：完成while循环的需求：计算折叠次数
        System.out.println("折叠次数：" + calc2());
    }
    //复利计算：本金100000元，复利为1.7%，问多少年后实现本金翻倍
    public static int calc(){
        //1.初始化变量
        double money=100000;
        int year=0;
        double rate=0.017;//年利率
        //2.循环
        while(money<=200000){
            money=money*(1+rate);
            year++;
        }
        return year;
    }
    public static int calc2() {
        //1.初始化变量，厚度为0.1
        double thick=0.1;//厚度
        int count=0;//折叠次数
        //2.循环
        while(thick<=8848860){
            thick=thick*2;
            count++;
        }
        return count;
    }
}

4.综合案例

• 简易计算器开发

package com.itheima.demo;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //目标流程:简易计算器开发
        //1.键盘输入两个数字
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数字1：");
        double num1 = sc.nextDouble();

        System.out.println("请输入数字2：");
        double num2 = sc.nextDouble();

        //2.键盘输入运算符
        System.out.println("请输入运算符(+ _ * /)：");
        String op = sc.next();
        //3.根据运算符进行计算
        double result = print(num1,num2,op);
        System.out.println("计算结果为："+result);
    }
    public static double print(double num1,double num2,String op){
        double result = 0;
        switch (op){
            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;
    }
}

• 猜数字游戏

初始化目标数字的两种方法：

//方式一

Math.random()返回0-1之间的随机数

int target = (int)(Math.random()*100+1);

//方式二

Random random = new Random();//得到随机数对象

int target = random.nextInt(100)+1;//[0,99]+1

Random生成随机数步骤：

●导包:import java.util.Random;

●Random r= new Random():

●int number =r.nextint(10);

如何生成65-91之间的随机数？

● 65 - 91 => -65=> (0-26) +65

●int number =r.nextInt(27) +65;

package com.itheima.demo;

import java.util.Random;
import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) {
        //完成一个猜数字小游戏。随机生成1-100之间的数据，提示用户猜测，猜大提示过大，猜小提示过小，直到猜中游戏
        Test2 test2 = new Test2();
        test2.gess();
    }
    //1.初始化目标数字
    //方式一
    //Math.random()返回0-1之间的随机数
    //int target = (int)(Math.random()*100+1);
    //方式二
    Random random = new Random();//得到随机数对象
    int target = random.nextInt(100)+1;//[0,99]+1
    //2.开始游戏（定义一个死循环让用户一直猜测，直到猜中为止）
    public void gess(){
        while(true){
            //3.获取用户输入的数字
            System.out.println("请输入数字：");
            Scanner sc = new Scanner(System.in);
            int num = sc.nextInt();
            //4.判断用户输入的数字是否正确
            if(num == target){
                System.out.println("恭喜你，猜对了！");
                break;
            }else if(num > target){
                System.out.println("你猜的数字太大了！");
            }else{
                System.out.println("你猜的数字太小了！");
            }
        }
    }
}

• 验证码

实现逻辑：

①定义一个for循环，循环5次。

②随机生成0|1|2的数据，依次代表当前要生成的字符是：数字、大写字母、小写字母。

③把0、1、2交给switch生成对应类型的随机字符。

在循环外定义一个String类型的变量用来连接生成的随机字符。

循环结束后，返回String类型的变量即是生成的随机验证码。

package com.itheima.demo;

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
            //4.w为当前位置随机生成一个数字或者大写字母或小写字母，数字0/大写1/小写2
            //随机一个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，然后拼接
                    int num1 = (int)(Math.random()*26);//[0,25]
                    char ch = (char)('A' + num1);//得到大写字母的随机编号，转成大写字母
                    code += ch;//拼接大写字母
                    break;
                case 2:
                    //8.如果当前位置是小写字母，则随机生成一个小写字母a-z，然后拼接
                    int num2 = (int)(Math.random()*26);
                    char ch1 = (char)('a' + num2);
                    code += ch1;//拼接小写字母
                    break;
            }
        }
        return code;
    }
}

• 找素数

package com.itheima.demo;

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 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
            //2.每遍历一个数字，判断是否是素数
            if(isPrime(i)){
                System.out.println(i);
                count++;
            }
        }
        System.out.println("素数的个数为：" + count+ "个");
    }
    public static boolean isPrime(int num){
        //1.定义一个循环从2开始找该数的一半，只要发现有一个数字能整除，则num不是素数
        //若未找到，则num是素数
        for (int i = 2; i < num/2; i++) {
            //2.判断num是否被i整除
            if(num % i == 0){
                //3.如果能被整除，则num不是素数
                return false;
            }
        }
        return true;//4.循环结束，num是素数
    }

}

5.数组

1.数组概念

数组是一个容器，用来存储一批同类型的元素集合

• 静态初始化数组，定义时已确定数据

//完整格式

"数据类型[] 数组名" 也可以写成 "数据类型 数组名"

• 数组访问：数组名[索引]
• 获取数组长度(元素个数)：

2.一维数组

（1）动态初始化

定义数组时先不存入具体的元素值，只确定数组存储的数据类型和数组的长度

动态初始化数组元素默认规则：

数据类型	明细	默认值
基本类型	byte、short、char、int、long	0
基本类型	float\double	0.0
基本类型	Boolean	false
引用类型	类、接口、String	null

（2）求最值案例

package com.itheima;

import java.util.Scanner;

public class ArrayDemo2 {
    public static void main(String[] args) {
        //目标：掌握数组的另一种定义方式，动态初始化数组
        inputScore();
    }
    //设计一个方法录入学生成绩
    public static void inputScore() {
        //1. 需要一个数组用于存储8个学生的成绩
        double[] scores = new double[8];
        //score = {0.0 , 0.0 , 0.0 , 0.0, 0.0 , 0.0 , 0.0 , 0.0};
        //         0      1    2     3    4     5     6    7

        //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 sum = scores[0];
        double max = scores[0];
        double min = scores[0];
        for (int i = 1; i < scores.length; i++) {
            double score = scores[i];
            sum += score;
            //找出最值
            if (score > max) {
                max = score;
            } else if (score < min) {
                min = score;
            }
        }

        //4. 输出结果
        System.out.println("总分是：" + sum);
        System.out.println("平均分是：" + sum / scores.length);
        System.out.println("最高分是：" + max);
        System.out.println("最低分是：" + min);
    }
}

（3）斗地主游戏

开发一个简易版的斗地主游戏，要求只完成做牌（存储54张牌、洗牌）

可以动态初始化一个数组，再存入54张牌到数组中，方便处理。

package com.itheima;

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    2...

        //2.准备4种花色，还有点数，在开始做牌存入数组中去
        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.存入数组
                poker[index] = colors[j] + numbers[i];//每遍历一张牌，将对应索引的元素赋给poker[index]
                index++;
            }
        }
        //4.将大小王存入数组中
        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张牌打乱
        for (int i = 0; i < poker.length; i++) {
            //生成一个随机索引
            int index1 = (int)(Math.random() * poker.length);
            //获取随机索引对应的元素
            int index2 = (int)(Math.random() * poker.length);
            //拿着index1索引对应的牌，和index2索引对应的牌进行交换
            String temp = poker[index1];
            poker[index1] = poker[index2];
            poker[index2] = temp;
        }
        System.out.println("洗牌后：");
        for (int i = 0; i < poker.length; i++) {
            System.out.print(poker[i] + "\t");
        }
    }
}

3.二维数组

（1）概述、定义

• 定义：数组中的 每个元素 都是一个一维数组，这个数组就是二维数组。

• 静态初始化

• 动态初始化

• 【插曲】循环遍历输入快捷键：数组名.fori

package com.itheima;

public class ArrayDemo5 {
    public static void main(String[] args) {
        //认识二维数组的定义、初始化、赋值、访问
        printArray();
        print();
    }
    public static void printArray() {
        //初始化二维数组存储学生姓名
        //静态初始化数组
        String[][] names = {
                {"张无忌", "赵敏", "周芷若"},           // 第一排
                {"张三丰", "宋远桥", "殷梨亭"},         // 第二排
                {"灭绝", "陈昆", "玄冥二老", "金毛狮王"}, // 第三排
                {"杨通", "纪晓笑"}
        };
        //访问：数组名[行索引]
        String[] seat = names[2];
        for (int i = 0; i < names.length; i++) {
            System.out.println(seat[i]+ "\t");//输出第3排的元素
        }
        System.out.println("==========================");
        //访问：数组名[行索引][列索引]
        System.out.println(names[1][1]);
        System.out.println(names[0][1]);
        System.out.println("==========================");
        //长度：数组名.length
        System.out.println(names.length);//4
        System.out.println(names[3].length);//2

        //动态初始化数组
        int[][] arr = new int[3][];//创建一个3行，列数不确定的二维数组
    }
    
    
    //遍历二维数组
    //方式一：
    public static void print() {
        String[][] names = {
                {"张无忌", "赵敏", "周芷若"},           // 第一排
                {"张三丰", "宋远桥", "殷梨亭"},         // 第二排
                {"灭绝", "陈昆", "玄冥二老", "金毛狮王"}, // 第三排
                {"杨通", "纪晓笑"}
        };
        for (int i = 0; i < names.length; i++) {
            //i = 0 1 2 3
            String[] name = names[i];
            for (int j = 0; j < name.length; j++) {
                System.out.print(name[j] + "\t");
            }
            System.out.println();
        }
        //方式2
        System.out.println("=============另一种方式===============");
        for (int i = 0; i < names.length; i++) {
            for (int j = 0; j < names[i].length; j++) {
                System.out.print(names[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

（2）石头迷阵游戏

package com.itheima;

public class ArrayTest6 {
    public static void main(String[] args) {
        //完成数字容华道的初始化和随即乱序
        start(5);

    }
    public static void start(int  n) {
        //1.定义一个二维数组存储数字列表
        int[][] arr = new int[n][n];

        //2.遍历二维数组，给二维数组赋值
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = count++;
            }
        }
        printArray(arr);//打印数组
        System.out.println("--------------------");
        //3.遍历二维数组，将数字列表进行随机乱序
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                //当前数据：arr[i][j]
                //随即索引位置处：m(随机的行) p(随机的列)
                int m = (int) (Math.random()*arr.length);
                int p = (int) (Math.random()*arr.length);

                //临时变量存储m p处的数据
                int temp = arr[m][ p];
                arr[m][p] = arr[i][j];
                arr[i][j] = temp;
            }
        }
        printArray(arr);

    }
    //调用printArray方法,按行列输出数组
    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();
        }
    }
}

（3）学生座位随机排序

package com.itheima;

public class ArrayTest7 {
    public static void main(String[] args) {
        //目标：对学生座位进行随机分配
        String[][] names = {
                {"张无忌", "赵敏", "周芷若"},           // 第一排
                {"张三丰", "宋远桥", "殷梨亭"},         // 第二排
                {"灭绝", "陈昆", "玄冥二老", "金毛狮王"}, // 第三排
                {"杨通", "纪晓笑"}
        };
        printArray( names);
        System.out.println("===================");
        start(names);
    }
    public static void start(String[][] arr) {
        //3.遍历二维数组，将数字列表进行随机乱序
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                //当前数据：arr[i][j]
                //随即索引位置处：m(随机的行) p(随机的列)
                int m = (int) (Math.random()*arr.length);
                int p = (int) (Math.random()*arr[m].length);//获取m行数据长度，随机列索引


                //临时变量存储m p处的数据
                String temp = arr[m][p];
                arr[m][p] = arr[i][j];
                arr[i][j] = temp;
            }
        }
        printArray(arr);
    }
    //调用printArray方法,按行列输出数组
    public static void printArray(String[][] 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+AI基础（第一部分）

1. 基础语法： 变量定义、数据类型（如int、double、String）、输入输出（Scanner类）以及注释等

2. 运算符： 算术运算符（+、-、*、/）、关系运算符（>、==）、逻辑运算符（&&、||）和赋值运算符（=、+=）。重点掌握运算符优先级和类型转换机制。

3. 程序流程控制：

（1）分支结构：通过if-else和switch-case实现条件判断，注意break在switch中的使用。

（2）循环结构：熟练使用for、while和do-while循环，理解循环控制语句（break、continue）的应用场景。

4.数组：

（1）一维数组：学习声明、初始化和遍历数组，例如：

int[] arr = {1, 2, 3};

for (int num : arr) {

System.out.println(num);

}

（2）二维数组：理解多维数组的存储逻辑，掌握嵌套循环遍历方式，例如：

int[][] matrix = {{1, 2}, {3, 4}};

• 下篇预告------Java的核心技术（面向对象）

第二部分将深入面向对象编程（OOP），包括类与对象、封装、继承、多态等核心概念，以及常用类库和异常处理机制。通过实际案例深化对Java设计思想的理解。