小黑子—Java从入门到入土过程：第六章

Java系列第六章

1. 面向对象综合练习

1.1 文字版格斗游戏=

1.简单版
User类包

package test3;

import java.util.Random;

public class User {
    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 User() {
    }

    public User(String name, int blood, char gengder) {
        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;
    }

    //定义一个方法用于攻击别人
    //思考：谁攻击谁？
    //r1.攻击(r2)
    //方法的调用者去攻击参数
    public void attack(User user) {
        Random r = new Random();
        int index = r.nextInt(attacks_desc.length);
        String KungFu = attacks_desc[index];
        //输出一个攻击的效果
        System.out.printf(KungFu,this.getName(),user.getName());
        System.out.println();
        //计算造成的伤害
        int hurt = r.nextInt(20) + 1;

        //修改一下挨揍的人血量
        //剩余血量
        int remainBoold = user.getBlood() - hurt;
        //对剩余血量做一个验证，如果为负数了，就修改为0
        remainBoold = remainBoold < 0 ? 0 : remainBoold;
        //修改一下挨揍的人血量
        user.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],user.getName());
        }else if(remainBoold>80&&remainBoold<=90){
            System.out.printf(injureds_desc[1],user.getName());
        }else if(remainBoold>70&&remainBoold<=80){
            System.out.printf(injureds_desc[2],user.getName());
        }else if(remainBoold>60&&remainBoold<=70){
            System.out.printf(injureds_desc[3],user.getName());
        }else if(remainBoold>40&&remainBoold<=60){
            System.out.printf(injureds_desc[4],user.getName());
        }else if(remainBoold>20&&remainBoold<=40){
            System.out.printf(injureds_desc[5],user.getName());
        }else if(remainBoold>10&&remainBoold<=200){
            System.out.printf(injureds_desc[6],user.getName());
        }else{
            System.out.printf(injureds_desc[7],user.getName());
        }
        System.out.println();
    }

    public void showRoleInfo() {
        System.out.println("姓名为" + getName());
        System.out.println("血量为" + getBlood());
        System.out.println("性别为" + getGender());
        System.out.println("长相为" + getFace());

    }
}

GameTest类包

package test3;

public class GameTest {
    public static void main(String[] args) {
        // 1. 创建第一个角色
        User u1 = new User("麻瓜",100,'男');
        //2.创建第二个角色
        User u2 = new User("小老板",100,'男');

        //展示角色信息
        u1.showRoleInfo();
        System.out.println("------------------------");
        u2.showRoleInfo();
        System.out.println("------------------------");
        //3.开始格斗 回合制游戏
        while(true){
            //u1 开始攻击u2
            u1.attack(u1);
            //判断u2的剩余血量
            if(u2.getBlood()==0){
                System.out.println(u1.getName()+"K.O了"+u2.getName());
                break;
            }
            //u2开始攻击u1
            u2.attack(u1);
            if(u1.getBlood()==0){
                System.out.println(u2.getName()+"K.O了"+u1.getName());
                break;
            }
        }
    }
}

参数占位，格式化输出回顾

public static void main(String[] args) {
        //两部分参数：
        //第一部分参数:要输出的内容%s（占位)
        // 第二部分参数:填充的数据
        System.out.printf("%s你好啊%s","张三","李四");
        //但是printf没有换行效果
        System.out.println();
        System.out.printf("你好啊%s","李四");
    }

关于printf和print和println的区别

• print为一般输出，同样不能保留精度格式转化，也不能换行输出
• printf常用于格式转换，但需要注意不是换行输出，只用于精度转换
• println为换行输出，不能用于格式转换

1.2 对象数组练习

1.2.1 练习一

Goods 类包

package test4;

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;
    }
}

GoodsTest 引入执行

package test4;

public class GoodsTest {
    public static void main(String[] args) {
        //1.创建一个数组
        Goods[] arr = new Goods[3];
        //2.创建三个商品
        //快捷键 ctrl+p ：把方法所对应的参数所展示
        Goods g1 = new Goods("001","华为p40",599.0,100);
        Goods g2 = new Goods("002","保温杯",297,50);
        Goods g3 = new Goods("003","洗衣机",10000,500);

        //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());
        }
    }
}

1.2.2 练习二

Car的javabeen包

package 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;
    }
}

CarTest

package test5;

import java.util.Scanner;

public class CarTest {
    public static void main(String[] args) {
        //1.创建一个数组用来存3个汽车对象
        Car[] arr = new Car[3];
        //2.创建汽车对象，数据来自于键盘录入
        //如果把Car c =  new Car();放在循环的外面，那么对象就只有一辆车
        //此时下面循环就对同一辆车的属性进行修改，而不是创建新的属性
        //所以此创建对象的代码不能写在循环的外面，必须写在循环里面
        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());
        }
    }
}

1.2.3 练习三

Phone的javabeen包

package 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;
    }
}

PhoneTest

package test6;

public class PhoneTest {
    public static void main(String[] args) {
        //1.创建一个数组
        Phone[] arr = new Phone[3];
        //2.创建手机的对象
        Phone p1 = new Phone("xiaomi",1999,"white");
        Phone p2 = new Phone("huawei",4999,"blue");
        Phone p3 = new Phone("meizhu",2999,"red");

        //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.求平均值
        double avg = sum*1.0/arr.length;
        System.out.println(avg);
    }
}

1.2.4 练习四

GilFriend的javabeen包

package 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;
    }
}

GirlFriendTest

package test7;

public class GirlFriendTest {
    public static void main(String[] args) {
        //1.定义数组存入女朋友的对象
        GirlFriend[] arr = new GirlFriend[4];
        //2.创建女朋友的对象
        GirlFriend gf1 = new GirlFriend("小老板",22,"man","do the game");
        GirlFriend gf2 = new GirlFriend("麻瓜",24,"man","van the game");
        GirlFriend gf3 = new GirlFriend("马捞C",30,"man","乖乖站好");
        GirlFriend gf4 = new GirlFriend("阿克曼",18,"man","fk you");

        //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++) {
            GirlFriend gf = arr[i];
            //累加
            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+"个");
    }
}

1.3 键盘录入回顾

键盘录入:
第一套体系:

• nextInt();接收整数
• nextDouble();接收小数
• next();接收字符串
• 遇到空格，制表符，回车就停止接受。这些符号后面的数据就不会接受了

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");//123 123
        int num1 = sc.nextInt();//123
        System.out.println(num1);
        System.out.println("请输入第二个整数：");
        int num2 = sc.nextInt();//123
        System.out.println(num2);
    }

当next中出现空格时，可会给下一个键盘的数据接受，就不会做键盘录入

2.

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str1 = sc.next();
        System.out.println(str1);
        System.out.println("请输入第二个字符串：");
        String str2 = sc.next();
        System.out.println(str2);
    }

第二套体系:

• nextLine();接收字符串
  遇到回车才停止录入

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line1 = sc.nextLine();
        System.out.println(line1);
        System.out.println("请输入第二个字符串：");
        String line2 = sc.nextLine();
        System.out.println(line2);
    }

但是重要的是，键盘录入的两套体系不能混用
弊端：

• 先用nextInt，再用nextLine会导致下面的nextLine接受不到数据

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int num = sc.nextInt();//123+回车
        System.out.println(num);//123
        System.out.println("请输入第一个字符串：");
        String line = sc.nextLine();
        System.out.println(line);//录入不了，就结束了
    }

1.4 复杂对象数组练习

1.4.1 复杂练习一

思考要求1和2思路：

    1.创建一个长度为3的数组
    2.创建学生对象
    3.把学生对象添加到数组当中

    4.再次创建一个学生对象

    5.唯一性判断
    5.1已存在---提示重复
    5.2不存在---添加学生对象

    6.添加学生对象
    6.1老数组已经存满
     6.2老数组没有存满

Student的javabeen包：

package 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;
    }
}

Test实现要求1和2：

package test8;

public class Test {
    public static void main(String[] args) {
        //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(4,"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(arr);
            }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){
        //1 2 3 ----3是否存在
        for (int i = 0; i < arr.length; i++) {
            //依次获取到数组里面的每一个学生对象
           Student stu = arr[i];
           //如果没装满，stu获取的是null，用null调用其他的方法就会报错
           if(stu!=null){
               //获取数组学生的id
               int sid = stu.getId();
               //比较
               if(sid == id){
                   return true;
               }
           }

        }
       //当循环结束之后，还没有找到一样的，那么就表示数组中要查找的id是不存在的。
        return false;
    }
}

1.4.2 复杂练习二

Test2实现需求3和4

package test8;

public class Test2 {
    public static void main(String[] args) {
        //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());
            }
        }
    }
}

Test3实现要求5：

package test8;

public class Test3 {
    public static void main(String[] args) {
        //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());
            }
        }
    }

}

2. API:应用程序编程接口

例子：
其他的API都是存储在JDK-API帮助文档.CHM

2.1 使用帮助文档

API使用步骤

java.lang包（非常重要）使用java.lang包时，不需要import进行导入
API帮助文档网站

可以寻找关键字


API文档练习

public static void main(String[] args) {
        //1.创建对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个小数：");
        //2.接受一个小数
        double result = sc.nextDouble();
        //3.输出打印
        System.out.println(result);
    }

3. 字符串String

常见情况：

字符串概述：

注意：

总结：

3.1 创建String对象的两种方式

其有两种：
直接赋值和用new去构造一个方法

 public static void main(String[] args) {
        //直接赋值
        String a="1111";
        //空参构造
        String b=new String();
        System.out.println("1"+b+"2");
        //传递字符串（了解）
        String c=new String("abc");
        //传递字符数组
        //应用环境：修改字符串 例如把abc 改成qbc
        //abc-->{'a','b','c'}-->{'q','b','c'}-->""qbc
        char[] d={'w','s','s','b'};
        String e=new String(d);
        System.out.println(e);
        //传递字节数组
        //应用场景：在网络中传输的都是字节信息，把字节信息转换成字符串
        byte[] f={97,98,99,100};
        //这里不是把数字传递过去，而是把数字转成ASCLL表里的字符。
        String g=new String(f);
        System.out.println(g);
    }

字符串在内存中的存储方式

字符串常量池

只有直接赋值的字符串才会在这个空间中 在堆内存中

当串池中已经存在一个abc字符串时，再次给字符串变量赋值相同的值时，会直接复用之前相同字符串的地址。

每new一次，就会在堆空间创建一个新的空间，可能会造成内存的浪费
所以，还是推荐使用直接赋值创建字符串。

3.2 字符串的比较

==号比较的原理

字符串常见比较错误：

对于不同方式字符串的内容比较：

例如：
1.

public static void main(String[] args) {
        //1.创建两个字符串对象
        String s1 = new String("abc");
        String s2 = "Abc";

        //2.==号比较
        //基本数据类型：比的是数据值
        //应用数据类型：比的是地址值
        System.out.println(s1==s2);//false

        //3.比较字符串对象中的内容是否相等
        boolean result = s1.equals(s2);
        System.out.println(result);

        //4.比较字符串对象中的内容是否相等，忽略大小写
        boolean result2 = s1.equalsIgnoreCase(s2);
        System.out.println(result2);// true
    }

public static void main(String[] args) {
        //1.假设我现在键盘录入一个abc
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str1 = sc.next();//abc 是new出来的
        //2.代码中再定义一个字符串abc
        String str2 = "abc";
        //3.用==比较，这两者能一样吗？
        System.out.println(str1 == str2);//false，为什么？直接赋值的和new出来的不一样
        //结论：
        //以后只要想比较字符串的内容,就必须要用string里面的方法
    }

3.3 字符串练习

3.3.1 练习一：用户登录

public static void main(String[] args) {
        // 1.定义两个变量记录正确的用户名和密码
        String rightUsername = "zhangsan";
        String rightPassword = "123456";

        Scanner sc =new Scanner(System.in);
        //2.键盘录入用户名和密码
        for (int i = 0; i < 3; i++) {
            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+"被锁定");
                }else{
                    System.out.println("用户登录失败，用户名或密码有误，您还剩下"+(2-i)+"次机会");//
                }
            }
        }
    }

3.3.2 练习二 ctrl+alt+v 自动生成左边赋值

chcharAt()方法：返回每一个索引对应的索引值

public static void main(String[] args) {
        // 1. 键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.next();
        //2.进行遍历
        for (int i = 0; i < str.length(); i++) {
            //i 依次表示字符串的每一个索引

            //chcharAt()方法：返回每一个索引对应的索引值
            // ctrl+alt+v 自动str.charAt(i);生成左边
            char c = str.charAt(i);
            System.out.println(c);
        }

2.

   public static void main(String[] args) {
        // 1. 键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.next();
        //2.统计---计数器思想
        //定义三个计数器
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        for (int i = 0; i < str.length(); i++) {
            //i 依次表示字符串中的每一个索引
            char c = str.charAt(i);
            if(c>='a'&&c<='z'){
                //char类型的变量在参与计算的时候自动类型提升为int查询ascii码表
                smallCount++;
            }else if(c>='A'&&c<='Z'){
                bigCount++;
            }else if(c>='0'&&c<='9'){
                numberCount++;
            }
        }
        System.out.println("小写字母有："+smallCount+"个");
        System.out.println("大写字母有："+bigCount+"个");
        System.out.println("数字字母有："+numberCount+"个");
    }

3.3.3 练习三：字符串拼接和反转

 public static void main(String[] args) {
        //1.我要干嘛?---遍历数组并把数组拼接成一个字符串
        //2.我干这件事情需要什么才能完成?---数组
        //3.我干完了是否要把结果返回给调用处---返回一个拼接之后的字符串
        // 如果调用处需要继续使用,那么必须返回
        //如果调用处不需要继续使用，那么可以返回也可以不返回
        int[] arr={1,2,3};
        String str = arrToString(arr);
        System.out.println(str);//123
    }

    public static String arrToString(int[] arr){
        if(arr==null){
            return"";
        }
        if(arr.length==0){
            return "[]";
        }

        String result = "[";
        //当代码执行到这里表示什么？
        //表示数组不是null，也不是长度为0的
        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1){
                result = result+arr[i];
            }else{
                result = result+arr[i]+",";
            }
        }
        //此时拼接右括号
        result = result + "]";
        return result;
    }

2.

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        String result = reverser("cnm");
        System.out.println(result);
    }

    public static String reverser(String str){
        String result = "";
        for (int i = str.length()-1; i >=0; i--) {
            char c = str.charAt(i);
            result += c;
        }
        return result;
    }
}

3.3.4 练习四

3.3.5 练习五

3.4 StringBuilder

使用StringBuilder的场景：

• 1.字符串的拼接
• 2.字符串的反转

相当于一个字符串的工具，StringBuilder不是字符串类型！！！！

3.4.1 StringBuilder构造方法

3.4.2 StringBuilder常用方法

1.append 添加方法

public static void main(String[] args) {
        //1.创建对象
        StringBuilder sb = new StringBuilder();
        //打印
        //普及:
        //因为stringBuilder是Java已经写好的类
        // java在底层对他做了一些特殊处理。
        //打印对象不是地址值而是属性值。
        System.out.println(sb);

    }

所以它没有返回一个地址值

public static void main(String[] args) {
        //1.创建对象
        StringBuilder sb = new StringBuilder("abc");
        //2.添加元素
        sb.append(1);
        sb.append(2.3);
        sb.append(true);
        System.out.println(sb);

    }

2.reverse 反转方法

sb.reverse();

3.length 获取长度方法

        int len = sb.length();
        System.out.println(len);

4.toString

public static void main(String[] args) {
        //1.创建对象
        StringBuilder sb = new StringBuilder("abc");
        //2.添加字符串
        sb.append("aaa");
        sb.append("wwww");
        sb.append("xxxx");

        System.out.println(sb);//abcaaawwwwxxxx只是在一个容器里面
        //3.再把StringBuilder变回字符串类型
        String str = sb.toString();
        System.out.println(str);//现在的abcaaawwwwxxxx才是字符串类型
    }

3.4.3 链式编程

当我们在调用一个方法的时候，不需要用变量接收他的结果，可以继续调用其他方法
1.

public static void main(String[] args) {
       String len = getString().substring(1).replace('b','w');
       System.out.println(len);
       int len2 = len.length();
       System.out.println(len2);
    }

    public static String getString(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.next();
        return str;
    }

2.
将上方3.4.2内容的第4点：

        sb.append("aaa");
        sb.append("wwww");
        sb.append("xxxx");

可写成->一条链子，效果相同

sb.append("aaa").append("wwww").append("xxxx");

练习：
1.

equals() 方法用于比较两个字符串的内容是否相等。

package com.itheima.demo1;

import java.util.Scanner;

public class ArithmeticoperatorDemo1 {
    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("当前字符串不是对称字符串");
        }
    }
}

2.

package com.itheima.demo1;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {1, 2, 3, 4};
        //2.定义一个接受字符数组的子函数，把arr放进去
        String str = arrString(arr);
        System.out.println(str);
    }

    public static String arrString(int[] arr) {
        //3. new一个StringBuilder容器，用来存放字符串
        StringBuilder sb = new StringBuilder();
        sb.append("[");//将 [ 先加入到容器中
        //4.循环遍历分割数组
        for (int i = 0; i < arr.length; i++) {
            //5.采用判断语句，如果加入到了最后一个字时，就i=length-1,才会不打印 , 逗号
            //其他加入的时候，就带 ，逗号一加入进容器
            if (i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(",");
            }
        }
        //循环结束之后，填右边括号
        sb.append("]");
        //6.完成后返回sb的字符串类型
        return sb.toString();
    }
}

3.4.4 StringJoiner

对于有时候StringBuilder按照数组拼接字符串的时候就比较麻烦了，中间有的时候拼，有的时候不拼

StringJoiner概述：

StringJoiner对象的创建

StringJoiner的成员方法

1.add() 添加内容

delimiter：中间间隔的符号，prefix：开始的符合，suffix：结尾的符号

public static void main(String[] args) {
        StringJoiner sj = new StringJoiner("-----");
        //2.添加元素
        sj.add("aaa").add("bbbb").add("ccc");
        //3.打印结果
        System.out.println(sj);
    }

2.

public static void main(String[] args) {
        StringJoiner sj = new StringJoiner(",","[","]");
        //2.添加元素
        sj.add("aaa").add("bbbb").add("ccc");

        int len = sj.length();
        System.out.println(len);//14
        //3.打印结果
        System.out.println(sj);//容器的类型

        String str = sj.toString();
        System.out.println(str);//字符串的类型
    }

总结：

3.4.5 字符串原理

扩展底层原理1和2：字符串原理

扩展底层原理3：字符串拼接的底层原理

1.当等号的右边没有变量时：

在编译的时候，就会将"a"+ “b” +“c"拼接为"abc”

2.当等号的右边有变量时：

• 在jdk8以前：系统底层会自动创建一个StringBuilder对象，然后再调用其append方法完成拼接。
  拼接后，再调用其toString方法转换为String类型，而toString方法的底层是直接new了一个字符串对象。

• 在jdk8之后：在编译时，会先预估字符串的长度并创建一个数组，再把数组变成一个字符串，这样就消耗性能了。

面试练习题：

2.

那就采用StringBuilder 和StringJoiner 进行优化

扩展底层原理5：StringBuilder提高效率原理

stringBuilder是一个内容可变的容器，所有要拼接的内容都会往StringBuilder中放，不会创建很多无用的空间，节约内存

3、4原理小结：

扩展底层原理5:StringBuilder源码分析

总结：

ctrl + n IDEA快捷键 出现搜索界面

在所有位置里寻找，搜索界面默认在当前项目文件里找不到

--------->

ctrl + f12 ---->寻找toString

3.4.6 字符串综合练习

2.

3.

4. 集合

集合是一个容器，可以用来存储数据，和数组不同的是，集合的长度可以发生变化。当添加元素时，会自动扩容。

• 集合可以存储引用数据类型，不能直接存储基本数据类型，要把基本数据类型变成其对应的包装类才能存储。

4.1 ArrayList 集合（之一）

ArrayList集合的创建：

   public static void main(String[] args) {
        //1.创建集合的对象
        //泛型:指限定集合中存储数据的类型，就是 <里面的>
        //ArrayList<String> list = new ArrayList<String>();
        // jDK7之后:
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);

        //此时我们创建的是ArrayList的对象，
        //这个类在底层做了一些处理
        //打印对象不是地址值,而是集合中存储数据内容 也就是[]
        //在展示的时候会拿[]把所有的数据进行包裹
    }

ArrayList成员方法

• add()和remove的返回值都是布尔值，add默认返回true，不用管，而remove在删除成功时返回true，失败时返回false
  同时，remove还可以根据索引进行删除，返回值是被删除的元素
• set是修改指定索引上的值，返回被覆盖的值。
• get就是获取相应索引的元素
• size就是集合的长度，类似于length

public static void main(String[] args) {
        //1.创建集合的对象
        ArrayList<String> list = new ArrayList<>();
        //2.添加元素
        list.add("aaa");
        list.add("aaa");
        list.add("www");
        list.add("ddd");

        System.out.println("2："+list);

        //3.删除元素
        boolean result1 = list.remove("aaa");
        System.out.println("3："+result1);//当要删除的元素不存在时，就会false
        System.out.println("3："+list);

        //把被删除的元素进行返回
        String str = list.remove(2);
        System.out.println("3："+str);
        System.out.println("3："+list);

        //4.修改元素
        String res = list.set(1, "cccc");//把替换的元素进行返回
        System.out.println("4："+res);
        System.out.println("4："+list);

        //5.查询元素
        String s = list.get(0);
        System.out.println("5："+s);
        System.out.println("5："+list);
        
        //6.遍历元素 list.fori
        for (int i = 0; i < list.size(); i++) {
            //list.get(i) 元素
            String s1 = list.get(i);
            System.out.println("6："+s1);
            System.out.println("6："+list);
        }
    }

4.2 集合综合练习

4.2.1 添加字符串和整数遍历

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");

        //遍历
        System.out.print("[");
        for (int i = 0; i < list.size(); i++) {
            if(i==list.size()-1){
                System.out.print(list.get(i));
            }else{
                System.out.print(list.get(i)+",");
            }
        }
        System.out.println("]");

    }

2.

下方遍历代码一样，中间改变

ArrayList<Integer> list = new ArrayList<>();

        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

添加字符类型遍历也是同理

        ArrayList<Character> list = new ArrayList<>();

        list.add('a');
        list.add('b');
        list.add('c');
        list.add('d');

4.2.2 基本数据类型的包装类

这里的包装类实际上就是泛型里的关键字

jdk5以后int Intleger 之间是可以互相转化的

4.2.3 添加学生对象并遍历

public static void main(String[] args) {
      ArrayList<Student> list = new ArrayList<>();
      //2.创建学生对象
      Student s1 = new Student("zhangsan",23);
      Student s2 = new Student("magua",24);
      Student s3 = new Student("xiaolaoban",25);

      //3.添加元素
      list.add(s1);
      list.add(s2);
      list.add(s3);

      //4.遍历集合
      for (int i = 0; i < list.size(); i++) {
         Student stu = list.get(i);
         System.out.println(stu.getName()+","+stu.getAge());
      }
   }

2.

遍历思路：

public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        // 长度为0
        //2.键盘录入学生的信息并添加到集合当中
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            Student s = new Student();
            System.out.println("请输入学生的姓名：");
            String name = sc.next();
            System.out.println("请输入学生的年龄：");
            int age = sc.nextInt();

            //把name和age赋值给学生对象
            s.setName(name);
            s.setAge(age);
            //把学生对象添加到集合当中
            list.add(s);
        }
        //集合里面是否有学生对象
        //有？ 没有？
        System.out.println(list.size());//3
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println(stu.getName()+","+stu.getAge());
        }
    }

4.2.4 添加用户对象并判断是否存在

javabean部分：

package test10;

public class User {
    private String id;
    private String username;
    private String password;

    public User() {
    }

    public User(String id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    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;
    }
}

Test部分：

package test10;

import java.util.ArrayList;

public class test {
    public static void main(String[] args) {
        //1.创建集合
        ArrayList<User> list = new ArrayList<>();
        //2.创建三个用户对象
       User u1 = new User("magua001","zhangsan","12345");
       User u2 = new User("magua002","lisi","12345678");
       User u3 = new User("magua003","wangwu","12345asd");

       //3.把用户对象添加到集合当中
        list.add(u1);
        list.add(u2);
        list.add(u3);
        
        //4.调用方法查看id是否存在
        boolean flag = contains(list, "magua001");
        System.out.println(flag);
    }
    public static boolean contains(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)){
//              //如果找到了直接返回true
//              return true;
//          }
//        }
//        //当循环结束表示集合里面所有的元素都比较完毕还没有一样的
//        //那么就返回false
//        return false;
       return getIndex(list,id)>=0;
    }
    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;
            }
        }
        return -1;
    }
}

4.2.5 添加手机对象并返回要求的数据

phone的javabean：

package test11;

public class Phone {
    private String brand;
    private int price;

    public Phone() {
    }

    public Phone(String brand, int price) {
        this.brand = brand;
        this.price = price;
    }

    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;
    }
}

test部分：

public static void main(String[] args) {
        //1.创建集合
        ArrayList<Phone> list = new ArrayList<>();
        //2.创建三个用户对象
        Phone p1 = new Phone("xiaomi",1000);
        Phone p2 = new Phone("iphone",4000);
        Phone p3 = new Phone("cuizi",2000);

        //3.把用户对象添加到集合当中
        list.add(p1);
        list.add(p2);
        list.add(p3);
        //4.调用方法
        ArrayList<Phone> phoneInfoList  = getPhoneInfo(list);
        //5.遍历集合
        for (int i = 0; i < phoneInfoList.size(); i++) {
            Phone phone = phoneInfoList.get(i);
            System.out.println(phone.getBrand()+","+phone.getPrice());
        }
    }
    //1.我要干嘛?查询手机信息
    //2.我干这件事情,需要什么才能完成?集合
    //3.我干完了，方法的调用处是否需要继续使用结果?返回

    //技巧:
    //如果我们要返回多个数据，可以把这些数据先放到一个容器当中，再把容器返回/集合数组
    public static ArrayList<Phone> getPhoneInfo(ArrayList<Phone> list){
        //定义一个集合用于存储价格低于3000的手机对象
        ArrayList<Phone> resultList = new ArrayList<>();
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
           Phone p = list.get(i);
            int price = p.getPrice();
            //如果当前手机的价格低于3000，
            if(price<3000){
                resultList.add(p);
            }
        }
        return resultList;
        //返回的是集合，函数的返回值类型就得是集合
    }

5. 学生管理系统

学会阅读需求文档，在了解需求文档后，自己画出需求的结构流程图（业务流程图）

流程图：

Ctrl + alt + t 全选中内容后，快捷生成结构环绕方式

StudentTest第一部分：

package test1;

import java.util.ArrayList;
import java.util.Scanner;

public class StudentTest {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        while (true) {
            //不要把ArrayList<Student> list = new ArrayList<>();
            //放在循环内部，这样在添加学生到list后，再循环一次，list又变成了0，这样查询的时候就总是无法查到
            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" -> addStudnet(list);
                case "2" -> deleteStudnet(list);

                case "3" -> updateStudnet(list);

                case "4" -> queryStudnet(list);
                case "5" -> {
                    System.out.println("退出");
                    System.exit(0);//停止虚拟机运行
                }
                default -> System.out.println("没有这个选项");
            }
        }
    }

    //添加学生
    public static void addStudnet(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) {
                //true 表示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("学生信息添加成功");
        System.out.println(list.size());
    }

    //删除学生
    public static void deleteStudnet(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 updateStudnet(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("情输入修改的学生年龄：");
        String newAge = sc.next();
        stu.setName(newAge);

        System.out.println("情输入修改的学生家庭住址：");
        String newAddress = sc.next();
        stu.setName(newAddress);

        System.out.println("学生信息修改完成");
    }

    //查询学生
    public static void queryStudnet(ArrayList<Student> list) {
        System.out.println(list.size());
        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;
            }
        }
        return -1;
    }
}

swich语句不能用箭头表达式，java版本换成jdk17以上行了。

5.1 学生管理系统升级版

需求图：



流程图：

1.注册

2.登录

3.忘记密码

6. 面向对象进阶

6.1 static

6.1.1 static-静态变量

static（静态变量）（静态变量被该类所有对象共享）,是Java中的一个修饰符，可以修饰成员方法，成员变量

javabean类：

public class Student {
    private String name;
    private int age;
    private  String gender;
    public static String teacherName;

    public Student() {
    }

    public Student(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    //行为
    public void study(){
        System.out.println(name+"正在学习");
    }

    public void show(){
        System.out.println(name+","+age+","+gender+"，"+teacherName);
    }

测试类：

 public static void main(String[] args) {
        //1.创建学生对象
        Student s1 = new Student();
        s1.setName("张三");
        s1.setAge(23);
        s1.setGender("man");
        s1.teacherName = "麻瓜";

        s1.study();
        s1.show();

        //2.创建第二个学生对象
        Student s2 = new Student();
        s2.setName("李四");
        s2.setAge(25);
        s2.setGender("man");

        s2.study();
        s2.show();

    }

当这里的teacherName被赋值后，static会被Student类里所有对象共享（公共的一个属性）

静态变量是随着类的加载而加载的，优先于对象出现，被赋值是单独存储再堆内存中的静态区域

示意图：

静态区里的变量是对象共享的，在内存中只有一份，谁用谁拿，非静态的变量是每一个对象所独有的，每一个对象里的非静态的变量都是单独存放的。

判断一个变量是否是静态变量，主要就是两个字，共享
需要共享的变量就是静态变量

6.1.2 static-静态方法和工具

静态方法

工具类

工具类：帮助我们做一些事情的,但是不描述任何事物的类

目前一共学习了三种类

工具类的要求：

这里的第2个私有化构造方法就是

public class Student {
    private public Student() {
    }
}

一个类一旦被私有化构造方法后，就不能创建这个类的对象了。

练习：
1.

javabean类：

public class ArrayUtil {
    //私有化构造方法
    //目的:为了不让外界创建他的对象
    private ArrayUtil(){}

    public static String printArr(int[] arr){
        //一到字符串的拼接，就一定要想到StringBuilde
        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();
    }

    public static double getAverage(double[] arr){
        double sum =0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }
        return sum/arr.length;
    }
}

测试类：

public class TestDemo {
    public static void main(String[] args) {
        //测试工具类的两个方法是否正确
        int[] arr1 = {1, 2, 3, 4, 5};
        String str = ArrayUtil.printArr(arr1);
        System.out.println(str);

        double[] arr2 ={1.5,23.43,654.43,1.23,23.3};
        double avg = ArrayUtil.getAverage(arr2);
        System.out.println(avg);

    }
}

2.

工具类：