Java-基础篇【面向对象基础、String、集合】
1：设计类
2：定义类的注意事项
package com.itheima.createobject; public class Car { // 属性（成员变量） String name; // 名称 double price; // 价格 // 行为（方法） public void start(){ System.out.println(name + " 价格是：" + price +", 启动成功！"); } public void run(){ System.out.println(name + " 价格是：" + price +", 跑的很快！"); } }
package com.itheima.createobject; /** 目标：学习定义类的一些注意事项。 成员变量修饰符暂时不写 实际开发中一个代码文件不建议定义多个类：分开定义 */ public class Student { // 修饰符 数据类型 变量名称 = 初始化值; String name; // 修饰符暂时不写,初始值暂时不给 double height; } class Animal{ // 不能public修饰 } class Cat{ }
package com.itheima.createobject; /** 目标：掌握自己设计类，并获得对象 类名 对象名 = new 类名() */ public class Test { public static void main(String[] args) { // 如何去获取汽车的对象。 Car c1 = new Car(); System.out.println(c1); c1.name = "宝马X3"; c1.price = 37.89; System.out.println(c1.name); System.out.println(c1.price); c1.start(); c1.run(); System.out.println("-------------------"); Car c2 = new Car(); c2.name = "奔驰GLC"; c2.price = 39.89; System.out.println(c2.name); System.out.println(c2.price); c2.start(); c2.run(); } }
package com.itheima.createobject; public class Test2 { public static void main(String[] args) { Student s1 = new Student(); // 创建学生对象 System.out.println(s1.name); // 整数默认值：0 double类型默认值：0.0 引用数据类型默认值：null System.out.println(s1.height); Student s2 = new Student(); System.out.println(s2.name); System.out.println(s2.height); } }
package com.itheima.createobject; public class test_ywt { public static void main(String[] args) { System.out.printf("hello"); } public static void printArray(int[] arr){ for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } System.out.println(); } }
3：成员变量默认值
4：多个对象的内存图
1：对象到底是放在哪个位置的？ 堆内存中 2： Car c = new Car(); c变量名中存储的是什么？ 存储的是对象在堆内存中的地址。 3： 成员变量（name、price）的数据放在哪里，存在于哪个位置？ 对象中，存在于堆内存中。
package com.itheima.memory; public class Student { String name; char sex; String hobby; public void study(){ System.out.println("姓名：" + name +"，性别是：" + sex + "，爱好是：" + hobby + "的学生在好好学习，天天向上！"); } }
package com.itheima.memory; /** 对象内存图 方法都是加载到栈里运行的，运行完了再退出去 1：Test.class 和 Car.class 文件的 代码方法和类加载到 方法区域 2：main函数加载到栈内存 运行 3：栈内存生成 s1这个 引用类型变量【对象变量】 4：new Student()在堆内存分配一块区域，对象区域，对象分配对象的属性空间name和price【成员变量空间】 一开始默认数据NULL和0 存储对象的行为方法 方法不会之间加载到堆内存区域，因为浪费空间，方法直接放在 class文件加载的方法区就行，堆内存中存在一份 对象能够找到方法，说明堆内存里还是存储一个 成员方法引用地址 ，指向方法区的地址以便能够调用 对象也有一个在堆内存地址，赋值给栈内存里 s1这个变量指向，s1指向这个对象 5：s1变量存储的对象地址找到对象，去操作对象里的属性和方法【赋值 打印】 6：s1.study() s1找到 对象，然后根据 对象里 方法引用地址 找到方法区域的 study这个方法 study方法加载到栈里运行，s1调用的study方法，方法再访问s1相应的内部的成员变量执行 study方法 对象是存储在堆内存里的，成员变量也是存储在对象里的 s1 和 s2这些对象变量 存储的是对象在堆内存中的地址 两个变量指向同一个对象内存图： 垃圾回收： 注意：当堆内存中的对象【类对象，数组对象】，没有被任何变量引用（指向）时，就会被判定为内存中的“垃圾” 下面的代码：有一个学生对象 由 s1 和s2指向， s1=null取消指向 s2=null也取消指向，指向学生对象的两条线都掐断，这样内存中的学生对象变成垃圾对象，会被java垃圾回收机制定期清除【自动清除】 */ public class Test { public static void main(String[] args) { // 目标：掌握2个变量指向同一个对象的形式 Student s1 = new Student(); s1.name = "小明"; s1.sex = '男'; s1.hobby = "睡觉、游戏、听课"; s1.study(); // 关键：把s1赋值给学生类型的变量s2 Student s2 = s1; // s1 和 s2指向同一个变量 System.out.println(s1); System.out.println(s2); s2.hobby = "爱提问"; System.out.println(s2.name); System.out.println(s2.sex); System.out.println(s1.hobby); s2.study(); // s1 = null; // s2 = null; // System.out.println(s1.name); } }
5：两个变量指向同一个对象内存解析
6：垃圾回收机制
垃圾回收：
注意：当堆内存中的对象，没有被任何变量引用（指向）时，就会被判定为内存中的“垃圾”。
7：面向对象之——构造器
package com.itheima.constructor; public class Car { String name; double price; public Car(){ // 无参数构造器(默认存在的) System.out.println("无参数构造器被触发执行~~~"); } public Car(String n, double p){ // 有参数构造器 System.out.println("有参数构造器被触发执行~~~"); name = n; // 当前成员变量的name 赋值成 外面类实例化传参过来的参数 n price = p; } }
package com.itheima.constructor; /** 目标：明白构造器的作用和分类。(开发的人，理解能力好) */ public class ConstructorDemo { public static void main(String[] args) { Car c = new Car(); // 调用无参数构造器(默认存在的) // c.name = ""; // c.price System.out.println(c.name); // 访问属性使用的默认值 System.out.println(c.price); // 访问属性使用的默认值 Car c2 = new Car("奔驰GLC", 39.78); // 调用有参数构造器 System.out.println(c2.name); System.out.println(c2.price); } }
8：this关键字
package com.itheima.thisdemo; public class Car { String name; double price; public void goWith(String name){ System.out.println(this.name +"正在和：" + name +"比赛！"); } public Car(){ // 无参数构造器(默认存在的) System.out.println("无参数构造器被触发执行~~~"); } // public Car(String name, double price){ // name = name; // price = price; // // 这样写不可以，name=name，等号前面的name访问传参name，等号后面的name还是访问的传参name，
//不会修改对象变量String name【自己值给自己赋值】【没有给当前成员变量赋值，采用 this】 // } // public Car(String a, double b){ // name = a; // price = b; // // 这样写才可以赋值，采用不同的变量名字，标准还是使用this // } public Car(String name, double price){ // 有参数构造器 System.out.println("有参数构造器被触发执行~~~"); System.out.println(this); this.name = name; // name赋值给当前对象成员变量的name this.price = price; // price赋值给当前对象成员变量的price } }
package com.itheima.thisdemo; /** 目标：说出this关键字的作用，并学会其使用。 */ public class ThisDemo { public static void main(String[] args) { Car c = new Car("宝马X3", 37.89); System.out.println(c); System.out.println(c.name); System.out.println(c.price); c.goWith("奔驰GLC"); } }
9：封装
10：封装的常见手段 private关键字的使用
package com.itheima.encapsulation; public class Student { // private私有的成员变量，只能在本类访问。 private int age; public int getAge(){ return age; } public void setAge(int age){ if(age >= 0 && age <= 200){ this.age = age; }else { System.out.println("年龄数据有问题，应该不是人的年龄！"); } } }
package com.itheima.encapsulation; /** 目标：学会面向对象的三大特征：封装的形式、作用。 */ public class Test { public static void main(String[] args) { Student s = new Student(); // s.age = -23; s.setAge(-23); System.out.println(s.getAge()); } }
11：JavaBean标准编程
package com.itheima.javabean; public class User { private double height; // 1：成员变量私有化，使用 private修饰 private String name; private double salary; private String address; private String phone; public User() { // 3：无参数构造器，默认自带的 // 鼠标右键——>Generate——>Construct——>select None一个都不选——>点击ok自动生成无参数构造器 } public User(double height, String name, double salary, String address, String phone) { // 有参数构造器 // 鼠标右键——>Generate——>Construct——>shift全选所有的private私有成员变量——>点击ok自动生成有参数构造器 this.height = height; this.name = name; this.salary = salary; this.address = address; this.phone = phone; } // 2：提供成员变量的 set get方法 // 鼠标右键——>Generate——>Getter and Setter——>shift全选所有的private私有成员变量——>点击ok自动生成Getter and Setter方法 // 自动生成的 方法没有安全校验的，比如身高需要 1-2米，这里面没有校验 public double getHeight() { return height; } public void setHeight(double height) { this.height = height; } public String getName() { return name; } public void setName(String name) { this.name = name; } public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } public String getPhone() { return phone; } public void setPhone(String phone) { this.phone = phone; } }
package com.itheima.javabean; /** JavaBean 也可以称为实体类【现实生活中有个体的】，其对象可以用于在程序中封装数据 学生类，汽车类，用户类：实体类 测试类不是：非实体类 new 一个学生对象就可以封装学生的数据 标准JavaBean【实体类】须满足如下书写要求 成员变量使用 private 修饰。 提供成员变量对应的 setXxx() / getXxx()方法。 必须提供一个无参构造器；有参数构造器是可写可不写的 满足这 3 个要求就可以认为是一个标准的 JavaBean【java实体类】 */ public class Test { public static void main(String[] args) { User user = new User(); // 无参数构造器 user.setName("二狗"); user.setHeight(163); user.setSalary(50000); user.setAddress("中国"); user.setPhone("13141314520"); // String name = user.getName(); // System.out.println(name); System.out.println(user.getName()); System.out.println(user.getHeight()); System.out.println(user.getSalary()); System.out.println(user.getAddress()); System.out.println(user.getPhone()); System.out.println("--------------------"); User user1 = new User(176, "黑马吴彦祖", 30000, "黑马", "110"); // 有 // 参数构造器 System.out.println(user1.getName()); System.out.println(user1.getHeight()); System.out.println(user1.getSalary()); System.out.println(user1.getAddress()); System.out.println(user1.getPhone()); } }
package com.itheima.javabean2; /** private String name; 私有成员变量，外部无法通过对象 a.name 访问了。只能通过 getName 方法访问 */ public class Article { // 商品对象 private String name; // 名称 private double price; // 价格 private int buyNumber; // 购买数量 public Article() { } public Article(int id, String name, double price, int buyNumber) { this.name = name; this.price = price; this.buyNumber = buyNumber; } 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 getBuyNumber() { return buyNumber; } public void setBuyNumber(int buyNumber) { this.buyNumber = buyNumber; } }
package com.itheima.javabean2; import java.util.Scanner; public class Test { public static void main(String[] args) { Article[] shopCar = new Article[10]; // a、定义一个数组存储商品对象的，代表购物车对象。 // Article：引用类型，商品类型的数组，里面存储商品对象。长度10，这里存储的还是商品的地址，默认值为null // b、让用户选择功能 while (true) { Scanner sc = new Scanner(System.in); System.out.println("添加商品：add"); System.out.println("查看商品：query"); System.out.println("修改数量：update"); System.out.println("结算价格：pay"); System.out.println("请您选择要操作的功能："); String command = sc.next(); switch (command) { case "add": addArticle(shopCar); // 把商品加入到购物车中去，参数是 shopCar 购物车去添加商品 alt + 回车 ：快捷生成方法 break; case "query": queryArticle(shopCar); // 查看购物车中的商品信息 break; case "update": updateArticle(shopCar); // 修改商品的购买数量 break; case "pay": calcPayMoney(shopCar); // 查结算金额 break; default: // 输入命令有问题走这个 System.out.println("当前命令输入有误！"); } String q = "QQ"; System.out.println(command == q ); // if(command == "Q"){ // System.out.println("等于啊"); // } if(command.equals("Q")){ break; } } } private static void calcPayMoney(Article[] shopCar) { queryArticle(shopCar); double money = 0; // 准备一个double类型的变量统计总金额 for (int i = 0; i < shopCar.length; i++) { Article a = shopCar[i]; if(a != null){ money += (a.getPrice() * a.getBuyNumber()); }else { break; } } System.out.println("本次商品购买的总价为：" + money); } public static void updateArticle(Article[] shopCar) { Scanner sc = new Scanner(System.in); while (true) { System.out.println("请您输入要修改数量的商品名称："); String name = sc.next(); Article a = getArticleByName(name , shopCar ); // 返回根据商品名称找到的商品对象，也可能返回null if(a != null){ // 找到了商品对象 System.out.println("请您输入修改后购买的数量："); int buyNumber = sc.nextInt(); a.setBuyNumber(buyNumber); // 更新修改数量 System.out.println("该商品的购买数量修改了！"); break; // 商品修改完成break }else { // 没有找到商品对象，继续输入，找到为止 System.out.println("购物车中没有该商品信息"); } } } public static Article getArticleByName(String name , Article[] shopCar){ // 查根据名字返回商品对象：Article for (int i = 0; i < shopCar.length; i++) { Article a = shopCar[i]; // 商品不为null if(a != null && a.getName().equals(name) ){ return a; } } return null; } public static void queryArticle(Article[] shopCar) { System.out.println("============查询购物车信息=========================="); System.out.println("商品名称\t商品价格\t商品的购买数量"); // 展示购物车的商品信息 for (int i = 0; i < shopCar.length; i++) { Article a = shopCar[i]; // 接受商品变量，a指向商品变量的地址 if(a != null){ // 不为null 说明有数据可以展示商品对象 System.out.println(a.getName() +"\t" + a.getPrice() + "\t" + a.getBuyNumber()); }else { // 为null说明循环遍历结束了 return; // break; 也可以 } } } public static void addArticle(Article[] shopCar) { // 参数接受一个商品数组购物车 Scanner sc = new Scanner(System.in); // 1：录入用户输入的商品信息 System.out.println("请您输入商品的名称："); String name = sc.next(); System.out.println("请您输入商品的价格："); double price = sc.nextDouble(); System.out.println("请您输入购买商品的数量："); int buyNumber = sc.nextInt(); Article a = new Article(); a.setName(name); a.setPrice(price); a.setBuyNumber(buyNumber); for (int i = 0; i < shopCar.length; i++) { if(shopCar[i] == null){ shopCar[i] = a; break; } } System.out.println("添加成功！"); } }
//package com.itheima.javabean2; // //import java.util.Scanner; // //public class TestArticle { // public static void main(String[] args) { // Article[] shopCar = new Article[10]; // a、定义一个数组存储商品对象的，代表购物车对象。 // // Article：引用类型，商品类型的数组，里面存储商品对象。长度10，这里存储的还是商品的地址，默认值为null // // b、让用户选择功能 // while (true) { // Scanner sc = new Scanner(System.in); // System.out.println("添加商品：add"); // System.out.println("查看商品：query"); // System.out.println("修改数量：update"); // System.out.println("结算价格：pay"); // System.out.println("请您选择要操作的功能："); // String command = sc.next(); // switch (command) { // case "add": // addArticle(shopCar); // 把商品加入到购物车中去，参数是 shopCar 购物车去添加商品 alt + 回车 ：快捷生成方法 // break; // case "query": // queryArticle(shopCar); // 查看购物车中的商品信息 // break; // case "update": // updateArticle(shopCar); // 修改商品的购买数量 // break; // case "pay": // calcPayMoney(shopCar); // 查结算金额 // break; // case "Q": // break; // default: // 输入命令有问题走这个 // System.out.println("当前命令输入有误！"); // } // break; // } // } // // private static void calcPayMoney(com.itheima.demo.Article[] shopCar) { // queryArticle(shopCar); // double money = 0; // 准备一个double类型的变量统计总金额 // for (int i = 0; i < shopCar.length; i++) { // com.itheima.demo.Article a = shopCar[i]; // if(a != null){ // money += (a.price * a.buyNumber); // }else { // break; // } // } // System.out.println("本次商品购买的总价为：" + money); // } // // public static void updateArticle(com.itheima.demo.Article[] shopCar) { // Scanner sc = new Scanner(System.in); // while (true) { // System.out.println("请您输入要修改数量的商品名称："); // String name = sc.next(); // com.itheima.demo.Article a = getArticleByName(name , shopCar ); // 返回根据商品名称找到的商品对象，也可能返回null // if(a != null){ // 找到了商品对象 // System.out.println("请您输入修改后购买的数量："); // int buyNumber = sc.nextInt(); // a.buyNumber = buyNumber; // 更新修改数量 // System.out.println("该商品的购买数量修改了！"); // break; // 商品修改完成break // }else { // 没有找到商品对象，继续输入，找到为止 // System.out.println("购物车中没有该商品信息"); // } // } // } // // public static com.itheima.demo.Article getArticleByName(String name , com.itheima.demo.Article[] shopCar){ // // 查根据名字返回商品对象：Article // for (int i = 0; i < shopCar.length; i++) { // com.itheima.demo.Article a = shopCar[i]; // 商品不为null // if(a != null && a.name.equals(name) ){ // return a; // a.name.equals(name) 判断 a这个商品的name字段等于我们预期传递来的参数name，是不是我们要找的 // } // } // return null; // 循环了 100 个了，还没有找到，就返回 null // } // // public static void queryArticle(com.itheima.demo.Article[] shopCar) { // System.out.println("============查询购物车信息=========================="); // System.out.println("商品名称\t商品价格\t商品的购买数量"); // // 展示购物车的商品信息 // for (int i = 0; i < shopCar.length; i++) { // com.itheima.demo.Article a = shopCar[i]; // 接受商品变量，a指向商品变量的地址 // if(a != null){ // 不为null 说明有数据可以展示商品对象 // System.out.println(a.name +"\t" + a.price + "\t" + a.buyNumber); // }else { // 为null说明循环遍历结束了 // return; // break; 也可以 // } // } // } // // public static void addArticle(com.itheima.demo.Article[] shopCar) { // 参数接受一个商品数组购物车 // Scanner sc = new Scanner(System.in); // 1：录入用户输入的商品信息 // System.out.println("请您输入商品的名称："); // String name = sc.next(); // System.out.println("请您输入商品的价格："); // double price = sc.nextDouble(); // System.out.println("请您输入购买商品的数量："); // int buyNumber = sc.nextInt(); // // // 2：创建一个商品对象，封装这些商品信息 // Article a = new Article(); // a.setName(name); // a.setPrice(price); // a.setBuyNumber(buyNumber); // // // 3：添加商品：遍历这个购物车数组对象，看哪个位置是null,如果是null ,把商品对象添加进去 // for (int i = 0; i < shopCar.length; i++) { // if(shopCar[i] == null){ // == null 说明 这个位置没有元素，就把商品对象添加到购物车里这个位置，存储的商品对象的地址 // shopCar[i] = a; // 把商品对象添加到这个位置了，商品对象添加到购物车数组中去 // break; // } // } // System.out.println("添加成功！"); // } //}
12：成员变量和局部变量的区别
13：面向对象综合案例
14：面向对象之综合案例——购物车
package com.itheima.demo; public class Article { // 商品对象 int id; // 商品编号 String name; // 名称 double price; // 价格 int buyNumber; // 购买数量 }
package com.itheima.demo; import java.util.Scanner; /** 需求：模拟购物车的功能。 1、定义一个商品类：Article(属性：名称、价格) 2、定义一个数组容器存储商品对象的，代表购物车对象。数组对象，容器，存储商品 3：界面架构，用户选择操作功能 */ public class Test { public static void main(String[] args) { Article[] shopCar = new Article[10]; // a、定义一个数组存储商品对象的，代表购物车对象。 // Article：引用类型，商品类型的数组，里面存储商品对象。长度10，这里存储的还是商品的地址，默认值为null // b、让用户选择功能 while (true) { Scanner sc = new Scanner(System.in); System.out.println("添加商品：add"); System.out.println("查看商品：query"); System.out.println("修改数量：update"); System.out.println("结算价格：pay"); System.out.println("请您选择要操作的功能："); String command = sc.next(); switch (command) { case "add": addArticle(shopCar); // 把商品加入到购物车中去，参数是 shopCar 购物车去添加商品 alt + 回车 ：快捷生成方法 break; case "query": queryArticle(shopCar); // 查看购物车中的商品信息 break; case "update": updateArticle(shopCar); // 修改商品的购买数量 break; case "pay": calcPayMoney(shopCar); // 查结算金额 break; case "Q": break; default: // 输入命令有问题走这个 System.out.println("当前命令输入有误！"); } break; } } private static void calcPayMoney(Article[] shopCar) { queryArticle(shopCar); double money = 0; // 准备一个double类型的变量统计总金额 for (int i = 0; i < shopCar.length; i++) { Article a = shopCar[i]; if(a != null){ money += (a.price * a.buyNumber); }else { break; } } System.out.println("本次商品购买的总价为：" + money); } public static void updateArticle(Article[] shopCar) { Scanner sc = new Scanner(System.in); while (true) { System.out.println("请您输入要修改数量的商品名称："); String name = sc.next(); Article a = getArticleByName(name , shopCar ); // 返回根据商品名称找到的商品对象，也可能返回null if(a != null){ // 找到了商品对象 System.out.println("请您输入修改后购买的数量："); int buyNumber = sc.nextInt(); a.buyNumber = buyNumber; // 更新修改数量 System.out.println("该商品的购买数量修改了！"); break; // 商品修改完成break }else { // 没有找到商品对象，继续输入，找到为止 System.out.println("购物车中没有该商品信息"); } } } public static Article getArticleByName(String name , Article[] shopCar){ // 查根据名字返回商品对象：Article for (int i = 0; i < shopCar.length; i++) { Article a = shopCar[i]; // 商品不为null if(a != null && a.name.equals(name) ){ return a; // a.name.equals(name) 判断 a这个商品的name字段等于我们预期传递来的参数name，是不是我们要找的 } } return null; // 循环了 100 个了，还没有找到，就返回 null } public static void queryArticle(Article[] shopCar) { System.out.println("============查询购物车信息=========================="); System.out.println("商品名称\t商品价格\t商品的购买数量"); // 展示购物车的商品信息 for (int i = 0; i < shopCar.length; i++) { Article a = shopCar[i]; // 接受商品变量，a指向商品变量的地址 if(a != null){ // 不为null 说明有数据可以展示商品对象 System.out.println(a.name +"\t" + a.price + "\t" + a.buyNumber); }else { // 为null说明循环遍历结束了 return; // break; 也可以 } } } public static void addArticle(Article[] shopCar) { // 参数接受一个商品数组购物车 Scanner sc = new Scanner(System.in); // 1：录入用户输入的商品信息 System.out.println("请您输入商品的名称："); String name = sc.next(); System.out.println("请您输入商品的价格："); double price = sc.nextDouble(); System.out.println("请您输入购买商品的数量："); int buyNumber = sc.nextInt(); // 2：创建一个商品对象，封装这些商品信息 Article a = new Article(); a.name = name; // 对象里面的成员变量赋值 a.price = price; a.buyNumber = buyNumber; // 3：添加商品：遍历这个购物车数组对象，看哪个位置是null,如果是null ,把商品对象添加进去 for (int i = 0; i < shopCar.length; i++) { if(shopCar[i] == null){ // == null 说明 这个位置没有元素，就把商品对象添加到购物车里这个位置，存储的商品对象的地址 shopCar[i] = a; // 把商品对象添加到这个位置了，商品对象添加到购物车数组中去 break; } } System.out.println("添加成功！"); } }
15：String类概述
16：String对象的内存概述——之 字符串常量池
String是不可变字符串的原因？
String变量每次的修改其实都是产生并指向了新的字符串对象。
原来的字符串对象都是没有改变的，所以称不可变字符串
17：String字符串——之内容比较 equals 和 equalsIgnoreCase
String引用数据类型字符串的内容比较不适合用“==”比较
基本数据类型比较时使用 == 比较
package com.itheima.string; import java.util.Scanner; /** == 判断的还是 值相等，基本数据类型变量存储的就是本身的值，可以使用 == 来进行比较 引用数据类型【string 这些类】，存储的放的是地址，可能内容一样，地址不一样，不适合使用 == 来进行比较，使用String提供的equals方法 */ public class StringAPIEqualsDemo4 { public static void main(String[] args) { // 1、正确登录名和密码 String okName = "itheima"; String okPassword = "123456"; // 2、请您输入登录名称和密码 Scanner sc = new Scanner(System.in); System.out.println("登录名称："); String name = sc.next(); System.out.println("登录密码："); String password = sc.next(); if(name == okName && okPassword==password){ // 使用 == 判断是否相等 System.out.println("==判断 name和 okName是相等的"); } // 当前无法使用 == 判断，因为 == 在这里比较的是地址 okName指向的地址是常量池 name接受用户输入信息创建的，放在堆内存里的 指向的地址不一致 else { System.out.println("==判断 name和 okName是不相等的"); } // 3、判断用户输入的登录名称和密码与正确的内容是否相等。 if(okName.equals(name ) && okPassword.equals(password)){ System.out.println("登录成功！"); }else { System.out.println("用户名或者密码错误了！"); } // 4、忽略大小写比较内容的Api: 一般用于比较验证码这样的业务逻辑 String sysCode = "23AdFh"; String code1 = "23aDfH"; System.out.println(sysCode.equals(code1)); // false System.out.println(sysCode.equalsIgnoreCase(code1)); // true equalsIgnoreCase忽略大小写比较内容 } }
18：String字符串——之 遍历，替换，截取，分割操作
package com.itheima.string; /** 目标：了解String类的特点：String类不可变的原理 java.lang.String 类代表字符串，String类定义的变量可以用于指向字符串对象，然后操作该字符串 Java 程序中的所有字符串文字（例如“abc”）都为此类的对象
双引号标起来的都可以说是字符串对象 String类的特点详解 String其实常被称为不可变字符串类型，它的对象在创建后不能被更改 以“”方式给出的字符串对象，在字符串常量池中存储【堆内存】 "传智"字符串存储在堆内存字符串常量池，name这个变量指向字符串地址空间 name存储的是地址：那么System.out.println(name);为什么打印的是字符串内容 这个 String 类的特殊改发，通过地址把内容输出了【继承里体现】存储的本质还是地址 字符串常量池中存储： "传智" "教育" "中心" name一开始指向 "传智" 然后 "传智" + "教育" 连接成一个新的字符串对象 运算出来的对象存储在 堆内存中 然后name指向最新的 "传智" + "教育" 本质上创建的字符串对象 "传智" "教育" "中心" 没有改变，一直存储在 字符串常量池中 string类型变量name从 指向 "传智" 变成了指向 "传智教育" ，【原来的对象 "传智" 没有改变】 【所以 string 对象是不可变的对象】【下面的中心运算和上面的类似】 */ public class StringDemo1 { public static void main(String[] args) { String name = "传智"; name += "教育"; // name = name + "教育" name这个对象被覆盖重写指向一个新的 String了，name指向的变量变化了 name += "中心"; System.out.println(name); } }
package com.itheima.string; /** 目标：掌握String常用的其他API。 */ public class StringAPIOtherDemo5 { public static void main(String[] args) { // 1、public int length(): 获取字符串的长度 String name = "我爱你中国love"; System.out.println(name.length()); // 2、public char charAt(int index): 获取某个索引位置处的字符 char c = name.charAt(1); // 返回一个字符 System.out.println(c); System.out.println("------------遍历字符串中的每个字符--------------"); for (int i = 0; i < name.length(); i++) { char ch = name.charAt(i); // ctrl + alt+ v System.out.println(ch); } // 3、public char[] toCharArray()：: 把字符串转换成字符数组 char[] chars = name.toCharArray(); // 字符串转化成一个字符数组 for (int i = 0; i < chars.length; i++) { char ch = chars[i]; System.out.println(ch); } // 4、public String substring(int beginIndex, int endIndex) ：截取内容，(包前不包后的) String name2 = "Java是最厉害的编程语言！"; // 01234567 89 String rs = name2.substring(0, 9); // 包前不包后 System.out.println(rs); String rs1 = name2.substring(4, 9); System.out.println(rs1); // 5、public String substring(int beginIndex):从当前索引一直截取到末尾 String rs2 = name2.substring(4); // 从4位置截取到尾 System.out.println(rs2); // 6、public String replace(CharSequence target, CharSequence replacement) 敏感词替换：replace String name3 = "金三胖是最厉害的80后，金三胖棒棒的！我好爱金三胖"; String rs3 = name3.replace("金三胖", "***"); // 返回的是一个新的内容，原来的name3内容不替换的 System.out.println(rs3); // 7、public boolean contains(CharSequence s) 包含 System.out.println(name3.contains("金三胖")); // true System.out.println(name3.contains("金二胖")); // false // 8、public boolean startsWith(String prefix) 以什么开始 System.out.println(name3.startsWith("金三胖")); System.out.println(name3.startsWith("金三胖是最厉害的")); System.out.println(name3.startsWith("金三胖是最厉害的2")); // 9、public String[] split(String s): 按照某个内容把字符串分割成字符串数组返回。 String name4 = "王宝强,贾乃亮,陈羽凡"; String[] names = name4.split(","); for (int i = 0; i < names.length; i++) { System.out.println("选择了：" + names[i]); } } }
18：String简单案例
package com.itheima.string; import java.util.Random; /** 练习题：使用String完成随机生成5位的验证码。 */ public class StringExec6 { public static void main(String[] args) { // 1、定义可能出现的字符信息 String datas = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; // 2、循环5次，每次生成一个随机的索引，提取对应的字符连接起来即可 String code = ""; Random r = new Random(); // 随机数对象 for (int i = 0; i < 5; i++) { // 随机一个索引 int index = r.nextInt(datas.length()); char c = datas.charAt(index); code += c; } // 3、输出字符串变量即可 System.out.println(code); } }
package com.itheima.string; import java.util.Random; import java.util.Scanner; /** 练习题：模拟用户登录，3次登录机会、 */ public class StringExec7 { public static void main(String[] args) { // 1、定义正确的登录名称和密码 String okLoginName = "admin"; String okPassword = "itheima"; // 2、定义一个循环，循环3次，让用户登录 Scanner sc = new Scanner(System.in); for (int i = 1; i <= 3; i++) { System.out.println("请您输入登录名称："); String loginName = sc.next(); System.out.println("请您输入登录密码："); String password = sc.next(); if(okLoginName.equals(loginName)){ // 3、先判断登录是否成功！ if(okPassword.equals(password)){ // 4、再判断密码是否正确 System.out.println("登录成功！欢迎进入系统随意浏览~~~~"); break; }else { // 密码错误了 System.out.println("您的密码不正确！您还剩余" + (3 - i) +"次机会登录！"); } }else { System.out.println("您的登录名称不正确！您还剩余" + (3 - i) +"次机会登录！"); } } } }
package com.itheima.string; import java.util.Scanner; /** 练习题：手机号码屏蔽 键盘录入一个手机号，将中间四位号码屏蔽，最终效果为： 分析 键盘录入一个字符串。 调用字符串对象的截取API，截取字符串前三位、后四位。 将前三位 连接“****”然后继续连接后四位，输出最终结果即可 */ public class StringExec8 { public static void main(String[] args) { // 1、键盘录入一个手机号码 Scanner sc = new Scanner(System.in); System.out.println("请您输入您的手机号码："); String tel = sc.next(); // 2、截取号码的前三位，后四位 18665666520 String before = tel.substring(0, 3); // 0 1 2 String after = tel.substring(7); // 从索引7开始截取到手机号码的末尾 String s = before + "****" + after; System.out.println(s); } }
19：String创建字符串对象的 2 种方式
package com.itheima.string; /** 目标：String类创建字符串对象的2种方式 方式一：直接使用“”定义。（推荐方式） 方式二：通过String类的构造器创建对象 以“”方式给出的字符串对象，在字符串常量池中存储，而且相同内容只会在其中存储一份。【节省内存资源】 比如 a = "中国" 在一个项目中可能出现几百上千次，"中国"这个对象内容一致不可变，所以 出现几千次存储一份就行了 通过构造器new对象，每new一次都会产生一个新对象，放在堆内存中 */ public class StringDemo2 { public static void main(String[] args) { // 方式一：直接使用双引号得到字符串对象 String name = "我爱你中国"; System.out.println(name); // 特殊优化，本身 name存储的是地址，但是这里打印还是根据地址打印了地址存储的内容 // 方式二： // 1、public String(): 创建一个空白字符串对象，不含有任何内容 （几乎不用） String s1 = new String(); // s1 = "" System.out.println(s1); // 2、public String(String): 根据传入的字符串内容，来创建字符串对象（几乎不用） String s2 = new String("我是中国人"); System.out.println(s2); // 3、public String(char[] c): 根据字符数组的内容，来创建字符串对象 char[] chars = {'a' , 'b' , '中', '国'}; // 【字符数组】 String s3 = new String(chars); // 把字符数组里的内容拼接起来 System.out.println(s3); // 4、public String(byte[] b): 根据字节数组的内容，来创建字符串对象 -128-127【字节数组】 byte[] bytes = {97, 98, 99, 65, 66, 67}; String s4 = new String(bytes); // 把字节数组里的整数全部转化成字符 内容再拼接成一个字符串 System.out.println(s4); System.out.println("---------------------------------------"); String ss1 = "abc"; String ss2 = "abc"; System.out.println(ss1 == ss2); // == 比较两个字符串变量存储的地址 // == 比较的是ss1的值和ss2的值，也就是两个变量指向的字符串的内容地址 // 【因为以“”方式给出的字符串对象，在字符串常量池中存储，而且相同内容只会在其中存储一份】 所以这里返回 true char[] chars1 = {'a' , 'b' , 'c'}; String ss3 = new String(chars1); String ss4 = new String(chars1); System.out.println(ss3 == ss4); // 通过构造器new对象，每new一次都会产生一个新对象，放在堆内存中 // 每次 new一下在堆内存中产生不同的对象，所以这里返回 false } }
20：Java存在编译优化机制，程序在编译时： “a” + “b” + “c” 会直接转成 "abc"
package com.itheima.string; public class StringDemo3 { public static void main(String[] args) { String s1 = "abc"; String s2 = "a" + "b" + "c"; System.out.println(s1 == s2); System.out.println("----------------------"); ms1(); System.out.println("----------------------"); ms2(); System.out.println("----------------------"); ms3(); } public static void ms1() { String s2 = new String("abc"); // 字符串常量池 存储 "abc" + 堆内存中new 存储一个 "abc"，s2指向堆内存的 "abc" String s1 = "abc"; // 发生 字符串常量池中有 "abc" 那么 这里s1直接指向常量池中的 "abc"，不创建了 System.out.println(s1 == s2); // s1 和s2 指向不同 // } public static void ms2() { String s1 = "abc"; // 字符串常量池 存储 "abc"，s1指向常量池的 "abc" String s2 = "ab"; // 字符串常量池 存储 "ab" String s3 = s2 + "c"; // 计算出来的等同 new创建，堆内存中再存储一个 "abc"，s3是运算出来的，s3指向堆内存中的 "abc" System.out.println(s1 == s3); // false // 这里没有 编译优化机制，因为需要代码跑起来才知道 s2等于啥，跑起来才知道 s2指向"ab"的 // 变量和字面量的区别 } public static void ms3() { String s1 = "abc"; String s2 = "a" + "b" + "c"; System.out.println(s1 == s2); // true // Java存在编译优化机制，程序在编译时： “a” + “b” + “c” 会直接转成 "abc" // 编译把代码先 翻译成 class文件，翻译成class文件的时候 s2已经等于 "abc" 了 // java代码运行的时候 s1 和s2 都指向 常量池的 "abc"，返回 true // 假设不这样优化，需要常量池产生 3个对象 "a" "b" "c"，然后new运算在堆内存中再生成一个 "abc" ——>浪费性能和内存【不存储那么多数据，少+ 和new两步运算】 } }
21：集合的概念 ArryList
package com.itheima.arraylist; import java.util.ArrayList; /** 目标: 创建ArrayList对象，代表集合容器，往里面添加元素。 引用类型变量 list 存储的是集合对象的地址 打印的时候会去获取 集合地址里存储的内容【改进】 add 方法 会有一个布尔类型的返回值，添加成功返回真，添加失败返回假，ArrayList集合一般不会添加元素失败 */ public class ArrayListDemo1 { public static void main(String[] args) { ArrayList list = new ArrayList(); // 1、创建ArrayList集合的对象【调用 ArrayList 的无参构造器】 // 2、添加数据 list.add("Java"); list.add("Java"); list.add("MySQL"); list.add("黑马"); list.add(23); list.add(23.5); list.add(false); System.out.println(list.add('中')); System.out.println(list); // 3、给指定索引位置插入元素，插入后 后面的元素自动往后移动一位 list.add(1, "赵敏"); System.out.println(list); } }
22：ArryList集合——泛型概念【ArryList<E>】
package com.itheima.arraylist; import java.util.ArrayList; /** 目标: 能够使用泛型约束ArrayList集合操作的数据类型 ArrayList 容器默认能够存储任意类型的元素，实际开发不建议这样做，因为java是强类型的语言 最好需要能够确定数据的类型，比如存分数 泛型概述 ArrayList<E>：其实就是一个泛型类，可以在编译阶段约束集合对象只能操作某种数据类型 ArrayList<String> ：此集合只能操作字符串类型的元素。 ArrayList<Integer>：此集合只能操作整数类型的元素。 泛型只能支持引用数据类型，不支持基本数据类型，里面存储的都是一个对象，整数的引用类型 Integer 泛型定义集合就是一直规范和标准 ArrayList list = new ArrayList(); 默认是就可以存储任意类型的集合 但是一般不这样写 ArrayList<object> list = new ArrayList<object>(); 这样使用Object泛型来定义，标准化，这样也可以存储任意数据类型--标准 定义集合都要采用泛型 */ public class ArrayListDemo2 { public static void main(String[] args) { // ArrayList<String> list = new ArrayList<String>(); ArrayList<String> list = new ArrayList<>(); // JDK 1.7开始，泛型后面的类型申明可以不写 list.add("Java"); list.add("MySQL"); // list.add(23); // list.add(23.5); ArrayList<Integer> list2 = new ArrayList<>(); list2.add(23); list2.add(100); // list2.add("Java"); } }
23：ArryList集合——>之遍历，遍历并删除元素，存储自定义类型，元素搜索
package com.itheima.arraylist; import java.util.ArrayList; /** 目标：掌握ArrayList集合的常用API */ public class ArrayListDemo3 { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); list.add("Java"); list.add("Java"); list.add("MySQL"); list.add("MyBatis"); list.add("HTML"); // 1、public E get(int index)：获取某个索引位置处的元素值 String e = list.get(3); System.out.println(e); // 2、public int size()：获取集合的大小（元素个数） System.out.println(list.size()); // 3、完成集合的遍历 for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } // 4、public E remove(int index)：删除某个索引位置处的元素值,并返回被删除的元素值 System.out.println(list); // [Java, Java, MySQL, MyBatis, HTML] String e2 = list.remove(2); // 删除某个索引位置处的元素值,并返回被删除的元素值 System.out.println(e2); System.out.println(list); // 5、public boolean remove(Object o):直接删除元素值，删除成功返回true，删除失败返回false System.out.println(list.remove("MyBatis")); // 删除的值 集合里有多个，只会默认删除前面的 第一个数据 System.out.println(list); ArrayList<String> list1 = new ArrayList<>(); list1.add("Java"); list1.add("王宝强"); list1.add("Java"); list1.add("MySQL"); System.out.println(list1); // 只会删除第一次出现的这个元素值，后面的不删除 System.out.println(list1.remove("Java")); System.out.println(list1); // 6、public E set(int index,E element)：修改某个索引位置处的元素值。 String e3 = list1.set(0 , "贾乃亮"); // 返回修改前的值 System.out.println(e3); System.out.println(list1); } }
24：ArryList集合里存储的数据内存分析
25：ArryList集合简单案例
package com.itheima.arraylist; import java.util.ArrayList; /** 案例：从集合中遍历元素且删除。 ArrayList<Integer> scores = new ArrayList<>(); 存储整数引用类型 ArrayList<Double> scores = new ArrayList<>(); 存储 小数引用类型 边遍历 边删除 操作需要各位注意 */ public class ArrayListTest4 { public static void main(String[] args) { // 1、创建集合对象：存入学生成绩(98,77,66,89,79,50,100) ArrayList<Integer> scores = new ArrayList<>(); scores.add(98); scores.add(77); scores.add(66); scores.add(89); scores.add(79); scores.add(50); scores.add(100); System.out.println(scores); // [98, 77, 66, 89, 79, 50, 100] // [98, 66, 89, 50, 100] // i // 1、遍历集合中的每个元素 // for (int i = 0; i < scores.size(); i++) { // int score = scores.get(i); // // 2、判断这个分数是否低于80分，如果低于则从集合中删除它 // if(score < 80){ // scores.remove(i); // } // } // System.out.println(scores); // 这样写 有 bug，无法删除 80分的数据 // i=0 一开始在98 的位置 不低于80，不删除 // i=1 在77的位置，77小于80把77删除，77删除了66往前移动了到 i=1的位置了 // i=2 到了89的位置了，不删除 // for循环执行的时候会一直调用()里的代码，scores.size()一直获取 scores的长度，因为要一直判断条件是否还满足 // 删除元素之后后面的元素往前移动导致跳位了 // [98, 77, 66, 89, 79, 50, 100] // [98, 89, 100] // i // 解决方案一：每删除成功一个数据，i往后退一步，保证下次回到位置，这样不会跳过数据 // 解决方案二：从后面倒着遍历删除就可以 i在100最后面的位置，起始索引集合大小-1，i往前走最终走到0这个位置所以 i >= 0 ，小于0就走完了 // 从后往前走需要 i-- // 倒着删除，删除一个数据后经过扫描的数据往前提，所有的前面的数据都能扫描到，不会跳数据 for (int i = scores.size() - 1; i >= 0 ; i--) { int score = scores.get(i); // 提取数据 // 2、判断这个分数是否低于80分，如果低于则从集合中删除它 if(score < 80){ scores.remove(i); } } System.out.println(scores); } }
package com.itheima.arraylist; import java.util.ArrayList; /** 案例：集合存储自定义元素并遍历。 需求：定义电影类（名称，分值，演员），创建3个电影对象，代表三部影片，存入集合中并遍历。 《肖生克的救赎》, 9.7 , 罗宾斯 《霸王别姬》, 9.6 , 张国荣、张丰毅 《阿甘正传》, 9.5 , 汤姆.汉克斯 */ public class ArrayListTest5{ public static void main(String[] args) { // 1、定义一个电影类：Movie ArrayList<Movie> movies = new ArrayList<>(); // 2、定义一个ArrayList集合存储这些影片对象。 // 3、创建影片对象封装电影数据，把对象加入到集合中去。 // Movie m1 = new Movie("《肖生克的救赎》", 9.7 , "罗宾斯"); // movies.add(m1); movies.add(new Movie("《肖生克的救赎》", 9.7 , "罗宾斯")); movies.add(new Movie("《霸王别姬》", 9.6 , "张国荣、张丰毅")); movies.add(new Movie("《阿甘正传》", 9.5 , "汤姆.汉克斯")); System.out.println(movies); // 打印：[com.itheima.arraylist.Movie@776ec8df, com.itheima.arraylist.Movie@4eec7777, com.itheima.arraylist.Movie@3b07d329] // 打印集合里的内容，因为这里的Movie类没特殊处理，打印的还是集合里存储的对象的地址，Movie不像String做了特殊处理，集合里存储的就是对象的地址 // 4、遍历集合中的影片对象并展示出来 for (int i = 0; i < movies.size(); i++) { Movie movie = movies.get(i); // movies.get(i)取值的是 影片对象的地址 System.out.println("片名：" + movie.getName()); System.out.println("评分：" + movie.getScore()); System.out.println("主演：" + movie.getActor()); } } }
package com.itheima.arraylist; import java.util.ArrayList; import java.util.Scanner; /** 案例：学生信息系统：展示数据，并按照学号完成搜索 学生类信息（学号，姓名，性别，班级） 测试数据： "20180302","叶孤城",23,"护理一班" "20180303","东方不败",23,"推拿二班" "20180304","西门吹雪",26,"中药学四班" "20180305","梅超风",26,"神经科2班" */ public class ArrayListTest6 { public static void main(String[] args) { // 1、定义一个学生类，后期用于创建对象封装学生数据 // 2、定义一个集合对象用于装学生对象 ArrayList<Student> students = new ArrayList<>(); students.add(new Student("20180302","叶孤城",23,"护理一班")); students.add(new Student("20180303","东方不败",23,"推拿二班")); students.add(new Student( "20180304","西门吹雪",26,"中药学四班")); students.add(new Student( "20180305","梅超风",26,"神经科2班")); System.out.println("学号\t\t名称\t\t年龄\t\t班级"); // 3、遍历集合中的每个学生对象并展示其数据 for (int i = 0; i < students.size(); i++) { Student s = students.get(i); System.out.println(s.getStudyId() +"\t\t" + s.getName()+"\t\t" + s.getAge() +"\t\t" + s.getClassName()); } // 4、让用户不断的输入学号，可以搜索出该学生对象信息并展示出来（独立成方法） Scanner sc = new Scanner(System.in); while (true) { System.out.println("请您输入要查询的学生的学号："); String id = sc.next(); Student s = getStudentByStudyId(students, id); // 判断学号是否存在 if(s == null){ System.out.println("查无此人！"); }else { // 找到了该学生对象了，信息如下 System.out.println(s.getStudyId() +"\t\t" + s.getName()+"\t\t" + s.getAge() +"\t\t" + s.getClassName()); } } } /** 根据学号，去集合中找出学生对象并返回。 * @param students * @param studyId * @return */ public static Student getStudentByStudyId(ArrayList<Student> students, String studyId){ // 返回学生对象 for (int i = 0; i < students.size(); i++) { // 遍历集合中的学生对象 Student s = students.get(i); if(s.getStudyId().equals(studyId)){ // 判断学生id是不是等于传入的id，找到了返回s学生对象 return s; } } return null; // 查无此学号！可能循环找完了都没有匹配到学生对象，返回null } }
package com.itheima.arraylist; public class Movie { private String name; // 电影名字 private double score; // 电影评分 private String actor; // 电影主演 public Movie() { // 无参构造器 } public Movie(String name, double score, String actor) { // 有参构造器 this.name = name; this.score = score; this.actor = actor; } public String getName() { return name; } public void setName(String name) { this.name = name; } public double getScore() { return score; } public void setScore(double score) { this.score = score; } public String getActor() { return actor; } public void setActor(String actor) { this.actor = actor; } }
package com.itheima.arraylist; public class Student { private String studyId; private String name; private int age; private String className; public Student() { } public Student(String studyId, String name, int age, String className) { this.studyId = studyId; this.name = name; this.age = age; this.className = className; } public String getStudyId() { return studyId; } public void setStudyId(String studyId) { this.studyId = studyId; } 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 getClassName() { return className; } public void setClassName(String className) { this.className = className; } }
26：第一阶段综合案例 ——>ATM取款系统
package com.itheima; /** 账户类：创建账户信息 */ public class Account { /** 成员变量，私有 */ private String cardId; // 卡号 private String userName; // 用户名 private String passWord; // 密码 private double money; // 账户余额 private double quotaMoney; // 每次取现额度 // 默认有无参构造器，这里不写了 public String getCardId() { return cardId; } public void setCardId(String cardId) { this.cardId = cardId; } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } public String getPassWord() { return passWord; } public void setPassWord(String passWord) { this.passWord = passWord; } public double getMoney() { return money; } public void setMoney(double money) { this.money = money; } public double getQuotaMoney() { return quotaMoney; } public void setQuotaMoney(double quotaMoney) { this.quotaMoney = quotaMoney; } }
package com.itheima; import java.util.ArrayList; import java.util.Random; import java.util.Scanner; /** ATM系统的入口类 private static void login：private修饰的方法表示只能本地访问 */ public class ATMSystem { public static void main(String[] args) { // 1、定义账户类 Account // 2、定义一个集合容器，负责以后存储全部的账户对象，进行相关的业务操作。 ArrayList<Account> accounts = new ArrayList<>(); // 3、展示系统的首页 Scanner sc = new Scanner(System.in); while (true) { System.out.println("===============ATM系统================="); System.out.println("1、账户登录"); System.out.println("2、账户开户"); System.out.println("请您选择操作："); int command = sc.nextInt(); // 接受整型，switch分支 switch (command){ case 1: login(accounts, sc); // 用户登录操作 break; case 2: register(accounts,sc); // 用户账户开户(ALT + ENTER快捷生成方法) break; default: System.out.println("您输入的操作命令不存在~~"); } } } /** * 登录功能 * @param accounts 全部账户对象的集合 * @param sc 扫描器 */ private static void login(ArrayList<Account> accounts, Scanner sc) { System.out.println("===================系统登录操作========================"); // 1、判断账户集合中是否存在账户，如果不存在账户，登录功能不能进行。 if(accounts.size() == 0) { System.out.println("对不起，当前系统中，无任何账户，请先开户，再来登录~~"); return; // 卫语言风格，结束方法的执行。 } // 2、正式进入登录操作 while (true) { System.out.println("请您输入登录卡号："); String cardId = sc.next(); Account acc = getAccountByCardId(cardId, accounts); // 3、判断卡号是否存在：根据卡号去账户集合中查询账户对象 if(acc != null){ // 卡号存在的 while (true) { System.out.println("请您输入登录密码："); String passWord = sc.next(); // 4、让用户输入密码，认证密码 if(acc.getPassWord().equals(passWord)) { // 判断当前账户对象的密码是否与用户输入的密码一致 // 登录成功了 System.out.println("恭喜您，" + acc.getUserName() +"先生/女生进入系统，您的卡号是：" + acc.getCardId()); // .... 查询 转账 取款 .... showUserCommand(sc, acc, accounts); // 展示登录后的操作页。 return; // 干掉登录方法 }else { // 密码有问题，再次输入继续认证 System.out.println("对不起，您输入的密码有误~~"); } } }else { // 卡号不存在 System.out.println("对不起，系统中不存在该账户卡号~~"); } } } /** 展示登录后的操作页 */ private static void showUserCommand(Scanner sc, Account acc, ArrayList<Account> accounts) { while (true) { System.out.println("===============用户操作页==================="); System.out.println("1、查询账户"); System.out.println("2、存款"); System.out.println("3、取款"); System.out.println("4、转账"); System.out.println("5、修改密码"); System.out.println("6、退出"); System.out.println("7、注销账户"); System.out.println("请选择："); int command = sc.nextInt(); switch (command) { case 1: showAccount(acc); // 查询账户(展示当前登录的账户信息) break; case 2: depositMoney(acc, sc); // 存款 break; case 3: drawMoney(acc, sc); // 取款 break; case 4: transferMoney(sc, acc, accounts); // 转账 break; case 5: updatePassWord(sc, acc); // 修改密码 return; // 让当前方法停止执行，跳出去 case 6: System.out.println("退出成功，欢迎下次光临"); // 退出 return; // 让当前方法停止执行，跳出去 干掉当前方法的执行， case 7: if(deleteAccount(acc,sc,accounts)){ // 注销账户 // 销户成功了，回到首页 return; // 让当前方法停止执行，跳出去 }else { // 没有销户成功， 还是在操作页玩 break; } default: System.out.println("您输入的操作命令不正确~~"); } } } /** * 销户功能 * @param acc * @param sc * @param accounts */ private static boolean deleteAccount(Account acc, Scanner sc, ArrayList<Account> accounts) { System.out.println("===================用户销户========================"); System.out.println("您真的要销户？y/n"); String rs = sc.next(); switch (rs) { case "y": // 真正的销户 // 从当前账户集合中，删除当前账户对象，销毁就完成了。 if(acc.getMoney() > 0){ System.out.println("您账户中还有钱没有取完，不允许销户~"); }else { accounts.remove(acc); System.out.println("您的账户销户完成~~"); return true; // 销户成功 } break; default: System.out.println("好的，当前账户继续保留~"); } return false; } /** * 修改密码 * @param sc 扫描器 * @param acc 当前登录成功的账户对象。 */ private static void updatePassWord(Scanner sc, Account acc) { System.out.println("===================用户密码修改========================"); while (true) { System.out.println("请您输入当前密码："); String passWord = sc.next(); if(acc.getPassWord().equals(passWord)){ // 1、判断这个密码是否正确 while (true) { // 密码正确 // 2、输入新密码。 System.out.println("请您输入新密码："); String newPassWord = sc.next(); System.out.println("请您确认新密码："); String okPassWord = sc.next(); if(newPassWord.equals(okPassWord)) { // 2次密码一致，可以修改了 acc.setPassWord(newPassWord); System.out.println("恭喜您，您密码修改成功了~~"); return; }else { System.out.println("您输入的2次密码不一致~~"); } } }else { System.out.println("您输入的密码不正确~"); } } } /** * 转账功能 * @param sc 扫描器 * @param acc 自己的账户对象 * @param accounts 全部账户的集合。 */ private static void transferMoney(Scanner sc, Account acc, ArrayList<Account> accounts) { System.out.println("===================用户转账操作========================"); if(accounts.size() < 2){ // 1、判断是否足够2个账户 System.out.println("当前系统中，不足2个账户，不能进行转账，请去开户吧~~"); return; // 不能转账那么 return 结束当前方法 } if(acc.getMoney() == 0) { // 2、判断自己的账户是否有钱 System.out.println("对不起，您自己都都没钱，就别转了吧~~"); return; // 没有前那么 结束当前转账方法 } while (true) { // 有两个账户并且 账号有钱，真正转账逻辑 // 3、真正开始转账 System.out.println("请您输入对方账户的卡号："); String cardId = sc.next(); if(cardId.equals(acc.getCardId())){ // 这个卡号不能是自己的卡号 System.out.println("对不起，您不可以给自己进行转账~~"); continue; // 结束当次执行，死循环进入下一次 } Account account = getAccountByCardId(cardId, accounts); // 判断这个卡号是存在的：根据这个卡号去查询对方账户对象。 if(account == null){ // 卡号不存在 System.out.println("对不起，您输入对方的这个账号不存在~~"); }else { // 这个账户对象存在了：继续认证他的姓氏 String userName = account.getUserName(); // 黑马周芷若 获取的全名 String tip = "*" + userName.substring(1); // userName.substring(1); 从 第1 个位置开始截 System.out.println("请您输入["+ tip +"]的姓氏"); String preName = sc.next(); // 接受姓氏 if(userName.startsWith(preName)) { // 认证姓氏是否输入正确。 while (true) { // 认证通过，真正开始转账了 System.out.println("请您输入转账金额："); double money = sc.nextDouble(); if(money > acc.getMoney()) { // 判断余额是否足够 System.out.println("对不起，您余额不足，您最多可以转账：" + acc.getMoney()); }else { // 余额足够，可以转了 acc.setMoney(acc.getMoney() - money); account.setMoney(account.getMoney() + money); System.out.println("转账成功！您的账户还剩余：" + acc.getMoney()); return; // 直接干掉转账方法 } } }else { // 认证姓氏 错误 System.out.println("对不起，您输入的信息有误~~"); } } } } /** * 取钱功能 * @param acc 当前账户对象 * @param sc 扫描器 */ private static void drawMoney(Account acc, Scanner sc) { System.out.println("===================用户取钱操作========================"); if(acc.getMoney() < 100) { // 1、判断是否足够100元 System.out.println("对不起，当前账户中不够100元，不能取钱~"); return; } while (true) { System.out.println("请您输入取款金额："); // 2、提示用户输入取钱金额 double money = sc.nextDouble(); if(money > acc.getQuotaMoney()) { // 3、判断这个金额是否满足要求。 System.out.println("对不起，您当前取款金额超过每次限额，每次最多可取：" + acc.getQuotaMoney()); }else { // 没有超过当次限额。 if(money > acc.getMoney()){ // 4、判断是否超过了账户的总余额。 System.out.println("余额不足，您账户目前总余额是：" + acc.getMoney()); }else { // 可以取钱了。 System.out.println("恭喜您，取钱" + money +"元，成功！"); acc.setMoney(acc.getMoney() - money); // 更新余额 showAccount(acc); // 取钱结束了。 return; // 取钱取完了，那么干掉取钱方法 } } } } /** * 存钱 * @param acc 当前账户对象 * @param sc 扫描器 */ private static void depositMoney(Account acc, Scanner sc) { System.out.println("===================用户存钱操作========================"); System.out.println("请您输入存款金额："); double money = sc.nextDouble(); // 更新账户余额：原来的钱 + 新存入的钱 acc.setMoney(acc.getMoney() + money); System.out.println("恭喜您，存钱成功，当前账户信息如下："); showAccount(acc); } /** * 展示账户信息 * @param acc */ private static void showAccount(Account acc) { System.out.println("===================当前账户信息如下========================"); System.out.println("卡号：" + acc.getCardId()); System.out.println("户主：" + acc.getUserName()); System.out.println("余额：" + acc.getMoney()); System.out.println("限额：" + acc.getQuotaMoney()); } /** * 用户开户功能的实现 这是一个标准注释 * @param accounts 接收的账户集合。 */ private static void register(ArrayList<Account> accounts, Scanner sc) { System.out.println("===================系统开户操作========================"); Account account = new Account(); // 1、创建一个账户对象，用于后期封装账户信息 System.out.println("请您输入账户用户名："); // 2、录入当前这个账户的信息，注入到账户对象中去 String userName = sc.next(); // 接受用户名并且属性放到类里 account.setUserName(userName); while (true) { System.out.println("请您输入账户密码："); String passWord = sc.next(); System.out.println("请您输入确认密码："); String okPassWord = sc.next(); if(okPassWord.equals(passWord)){ // 密码认证通过，可以注入给账户对象 account.setPassWord(okPassWord); break; // 密码已经录入成功了，死循环没有必要继续了！ }else { System.out.println("对不起，您输入的2次密码不一致，请重新确认~~"); } } System.out.println("请您输入账户当次限额："); double quotaMoney = sc.nextDouble(); // 限额 account.setQuotaMoney(quotaMoney); // 为账户随机一个8位且与其他账户的卡号不重复的号码。(独立功能，独立成方法)。 String cardId = getRandomCardId(accounts); account.setCardId(cardId); accounts.add(account); // 3、把账户对象添加到账户集合中去 System.out.println("恭喜您，" + userName + "先生/女生，您开户成功，您的卡号是：" + cardId + "，请您妥善保管卡号" ); } /** * 为账户生成8位与其他账户卡号不同的号码。 * @return */ private static String getRandomCardId(ArrayList<Account> accounts) { Random r = new Random(); while (true) { // 1、先生成8位数字 String cardId = ""; // 03442522 for (int i = 0; i < 8; i++) { // 8位 cardId += r.nextInt(10); // 生成0-9的数字 } // 2、判断这个8位的卡号是否与其他账户的卡号重复了 Account acc = getAccountByCardId(cardId, accounts); // 根据这个卡号去查询账户的对象 if(acc == null){ // 说明cardId 此时没有重复，这个卡号是一个新卡号了，可以使用这个卡号作为新注册账户的卡号了 return cardId; } } } /** * 根据卡号查询出一个账户对象出来 * @param cardId 卡号 * @param accounts 全部账户的集合 * @return 账户对象 | null */ private static Account getAccountByCardId(String cardId,ArrayList<Account> accounts){ for (int i = 0; i < accounts.size(); i++) { // 遍历每个账户 Account acc = accounts.get(i); // 集合根据索引取当前对象的地址 if(acc.getCardId().equals(cardId)){ // 卡号存在，返回acc账户对象 return acc; } } return null; // 查无此账户，返回 null } }
