• 第七章：面向对象编程（中级部分）

    目录

    一、idea的使用

    1.创建项目：

    2.setting设置：

    3.快捷键：

    二、包

    1.创建包：

    2.包的命名规则：

    3.java中常用的包使用与导入：

    三、访问修饰符

    1.定义：

    四、封装

    1.封装步骤：

    2.案例：

    案例2：名字2-5，余额大于20，密码=6位；不符合谈提示设置默认值：

    五、继承

    1.定义：

    2.案例：大学生和小学生：

    3.继承的细节：

    4.继承的本质：

    六、super关键字 

    1.定义：

    七、方法的重写/覆盖

    1.定义:

    2.细节：

    3.重载(overload)和重写(override)的区别:

    4.案例

    八、多态

    1.定义：

    2.向上转型：

    3.向下转型：

    4.属性重写的问题

    5.java动态绑定机制：

    九、多态数组

    十、多态参数

    十一、Object的详解

    1.==运算符：        

    2.equals：

    3.重写equals方法：

    4.hashCode()方法：

    5.toString()方法：

    6.finalize()

    十二、断点调试（debug）

    1.快捷键 ：

    十三、零钱通

    1.使用其他方法实现：

    2.使用opp面向对象实现：

    本章太多了课后练习放在下一章

    一、idea的使用

    1.创建项目：

    1. new project-->java选sdk包选完下一个
    2. 一直下一步找到地址弄好就OK
    3. 新建类，右键src 

    2.setting设置：

    • appearance：设置外观

    • Color Scheme:设置外观

    • File Encodings:设置字体编码 

    3.快捷键：

    • pswm：生成主方法
    • setting-->keymap
    • setting-->Editor--->auto import
    • alt+/ ：补全代码
    • ctrl+alt+l：格式化代码
    • alt+insert：生成构造器
    • ctrl+H：查看一个类的层级关系
    • ctrl+B可以定位到方法
    • 自动分配变量名：.var (超级流批好吧)
    • file-->setting-->editor-->Live template - > 查看有哪些模板快捷键/可以自己添加模板

    二、包

    1.创建包：

            src右键-->new -->package->输入名字com.xiaoming

            同一个包不能有相同类名

    2.包的命名规则：

    • 只能由数字、字母、下划线、小圆点，但不能用数字开头，不能是关键字或保留字
    • com.12a错误，12a数字开头
    • 一般命名规则：com.公司名.项目名.业务模块名

    3.java中常用的包使用与导入：

    java.lang.*  //lang包是基本包，默认引入，不需要引入

    java.util.*   //util包系统提供的工具包，工具类，使用Scanner

    java.awt.*  //是Java的界面开发，GUI

    java.net.*  //网络包，网络开发

    导入包：import  java.lang.*  建议使用什么，导入什么  import java.util.Arrays;

    三、访问修饰符

    1.定义：

    1. 公开级别：用public修饰，对外公开
    2. 受保护级别：用protect修饰，对子类和同一个包中的类公开
    3. 默认级别：没有修饰符号，向同一个包的类公开。
    4. 私有级别:用private修饰，只有类本身可以访问，不对外公开。

    修饰符可以修饰类，但是只有默认和public可以，其他的不行。

    成员方法和成员方法的规则是一样的，

    四、封装

    1.封装步骤：

    1. 把属性私有化
    2. 提供一个公共的(public)set方法，用于对属性判断并赋值
    3. 提供一个公共的(public)get方法，用于对属性的读取

    2.案例：

            构造器搭配封装使用

            年龄，必须在1-120，年龄，工资不能直接查看，name的长度在2-6字符之间

    1. package com.user;
    2.  
    3. public class User {
    4.     public static void main(String[] args) {
    5.         Person person = new Person();
    6.         person.setAge(19);
    7.         person.setName("法外狂徒张三");
    8.         person.job="律师";
    9.         person.setSalary(12300);
    10.         System.out.println(person.toString());
    11.     }
    12. }
    13.  
    14. class Person {
    15.     private String name;
    16.     private int age;
    17.     public String job;
    18.     private double salary;
    19.  
    20.     public Person(String name, int age, String job, double salary) {
    21. //        this.name = name;
    22. //        this.age = age;
    23.         this.job = job;
    24. //        this.salary = salary;
    25.         setName(name);
    26.         setAge(age);
    27.         setSalary(salary);
    28.     }
    29.  
    30.     public String getName() {
    31.         return name;
    32.     }
    33.  
    34.     public void setName(String name) {
    35.         if (name.length() >=1&&name.length()<=6){
    36.             this.name = name;
    37.         }else {
    38.             System.out.println("名字太长了");
    39.             this.name = "无名人";
    40.         }
    41.     }
    42.  
    43.     public int getAge() {
    44.         return age;
    45.     }
    46.  
    47.     public void setAge(int age) {
    48.         if (age >= 1 && age <= 120) {
    49.             this.age = age;
    50.         }else {
    51.             System.out.println("年林不对我给你一个默认的18");
    52.             this.age = 18;
    53.         }
    54.     }
    55.  
    56.     public double getSalary() {
    57.         return salary;
    58.     }
    59.  
    60.     public void setSalary(double salary) {
    61.         this.salary = salary;
    62.     }
    63.  
    64.     @Override
    65.     public String toString() {
    66.         return "Person{" +
    67.                 "name='" + name + '\'' +
    68.                 ", age=" + age +
    69.                 ", job='" + job + '\'' +
    70.                 ", salary=" + salary +
    71.                 '}';
    72.     }
    73. }

    案例2：名字2-5，余额大于20，密码=6位；不符合谈提示设置默认值：

    1. package com.user;
    2.  
    3. public class User {
    4.     public static void main(String[] args) {
    5.         Account account = new Account("张三",10,"2123");
    6.         System.out.println(account.toString());
    7.     }
    8. }
    9.  
    10. class Account {
    11.     private String name;
    12.     private String password;
    13.     private double balance;
    14.  
    15.     public Account(){
    16.  
    17.     }
    18.  
    19.     public Account(String name,double balance,String password){
    20.         this.setBalance(balance);
    21.         this.setName(name);
    22.         this.setPassword(password);
    23.     }
    24.  
    25.     public String getName() {
    26.         return name;
    27.     }
    28.  
    29.     public void setName(String name) {
    30.         if (name.length() < 5 && name.length() >= 2) {
    31.             this.name = name;
    32.         } else {
    33.             System.out.println("姓名长度2-5");
    34.             this.name = "无名";
    35.         }
    36.     }
    37.  
    38.     public String getPassword() {
    39.         return password;
    40.     }
    41.  
    42.     public void setPassword(String password) {
    43.         if (name.length() == 6) {
    44.             this.password = password;
    45.         } else {
    46.             System.out.println("密码长度6");
    47.             this.password = "000000";
    48.         }
    49.     }
    50.  
    51.     public double getBalance() {
    52.         return balance;
    53.     }
    54.  
    55.     public void setBalance(double balance) {
    56.         if (balance > 20) {
    57.             this.balance = balance;
    58.         } else {
    59.             System.out.println("余额大于20");
    60.         }
    61.  
    62.     }
    63.  
    64.     @Override
    65.     public String toString() {
    66.         return "Account{" +
    67.                 "name='" + name + '\'' +
    68.                 ", password='" + password + '\'' +
    69.                 ", balance=" + balance +
    70.                 '}';
    71.     }
    72. }

    五、继承

    1.定义：

            方便代码的复用性；把子类的共有属性抽离为一个接口

            class 子类 extends 父类{}

    2.案例：大学生和小学生：

    1. package com.user;
    2.  
    3. public class User {
    4.     public static void main(String[] args) {
    5.         Pupil pupil = new Pupil();
    6.         pupil.name ="银角大王";
    7.         pupil.age = 11;
    8.         pupil.setScore(60);
    9.         pupil.showInfo();
    10.  
    11.         Graduate graduate = new Graduate();
    12.         graduate.name ="金角大王";
    13.         graduate.age = 20;
    14.         graduate.setScore(70);
    15.         graduate.showInfo();
    16.     }
    17. }
    18.  
    19. //是Pupil 和 Graduate的父类
    20. class Student{
    21.     public String name;
    22.     public int age;
    23.     private double score;
    24.  
    25.     public void setScore(double score){
    26.         this.score = score;
    27.     }
    28.  
    29.     public void showInfo(){
    30.         System.out.println("学生名"+name+"年龄"+age+"成绩"+score);
    31.     }
    32. }
    33.  
    34. class Pupil extends Student{
    35.     public void testing(){
    36.         System.out.println("小学生"+name+"正在考小学数学");
    37.     }
    38. }
    39.  
    40. class Graduate extends Student{
    41.     public void testing(){
    42.         System.out.println("大学生"+name+"正在考小学数学");
    43.     }
    44. }

    3.继承的细节：

    • 子类继承父类的所有属性和方法，但是私有属性和方法不能再子类直接访问，要通过公共的方法访问。
    1. package com.user;
    2.  
    3. public class User {
    4.     public static void main(String[] args) {
    5.         Student student = new Student();
    6.         student.showInfo();
    7.         student.callTest();
    8.     }
    9. }
    10.  
    11. class Person{
    12.     private String name;
    13.  
    14.     public String getName() {
    15.         return name;
    16.     }
    17.  
    18.     public void setName(String name) {
    19.         this.name = name;
    20.     }
    21.  
    22.     private void test(){
    23.         System.out.println("私有方法你来调用我");
    24.     }
    25.  
    26.     public void callTest(){
    27.         this.test();
    28.     }
    29. }
    30.  
    31. class Student extends Person{
    32.     public void showInfo(){
    33.         setName("张三");
    34.         System.out.println(getName());
    35.     }
    36. }
    • 子类必须调用父类的构造器，完成父类的初始化   //子类调用构造器，会自动调用父类的构造器(super)
    • 当子类创建对象时，不管使用子类哪个构造器，默认都会调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中使用super去指定使用父类的构造器完成对父类的初始化工作，否则编译不通过。
    1. package com.user;
    2.  
    3. public class User {
    4.     public static void main(String[] args) {
    5.         Student student = new Student("张三");
    6.         System.out.println(student.name);
    7.     }
    8. }
    9.  
    10. class Person{
    11.     public String name;
    12.  
    13.     public Person(String name) {
    14.         this.name = name;
    15.     }
    16. }
    17.  
    18. class Student extends Person{
    19.     public Student(String name) {
    20.         super(name);
    21.     }
    22. }
    • super()调用构造器的时候必须放在第一行
    • 调用父类的构造器使用super，只能在构造器中使用super
    • java的所有类的父类都是Object
    • 父类构造器的调用不限于直接父类！将一直往上追溯到Object，由最上面的父类的构造器往下执行
    • 子类最多只能继承一个父类，java是单继承机制
    • 不能滥用继承需要满足is a的关系：例如 cat is  a  animal

    4.继承的本质：

     如果子类有这个属性就返回子类的，没有往上找，找到最上面都没有就报错。private定义属性肯定继承，就是访问不了，就近原则

            案例1：看看输出什么。默认调用super

    1. public class User {
    2.     public static void main(String[] args) {
    3.         B b = new B();
    4.     }
    5. }
    6.  
    7. class A{
    8.     A(){
    9.         System.out.println("a");
    10.     }
    11.     A(String name){
    12.         System.out.println("a name");
    13.     }
    14. }
    15.  
    16. class B extends A{
    17.     B(){
    18.         this("abc");
    19.         System.out.println("b");
    20.     }
    21.     B(String name){
    22.         System.out.println("b name");
    23.     }
    24. }

    六、super关键字 

    1.定义：

            用于访问父类的属性、方法、构造器。但不能访问私有的属性

    1. package com.user;
    2.  
    3. public class User {
    4.     public static void main(String[] args) {
    5.         new B().h1();
    6.     }
    7. }
    8.  
    9. class A{
    10.     String name = "张三";
    11.     private int age = 10;
    12.  
    13.     public A(String name, int age) {
    14.         this.name = name;
    15.         this.age = age;
    16.     }
    17.  
    18.     public void show(){
    19.         System.out.println("来展示");
    20.     }
    21. }
    22.  
    23. class B extends A{
    24.     public B() {
    25.         super("李四", 19);
    26.     }
    27.  
    28.     public void h1(){
    29.         System.out.println(super.name);
    30.         super.show();
    31.     }
    32. }

    super的访问适用于就近原则A->B->C.属性的覆盖

    this与super的区别，this从子类开始找，super从父类开始找，this调用本类，super调用父类。this调用本类构造器，必须放在第一行。super调用父类构造器，必须放在第一行。

    七、方法的重写/覆盖

    1.定义:

            简单的来说：方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称，返回类型，参数一样，那么我么就说子类的方法覆盖了父类的方法。

    2.细节：

    • 子类的方法的参数、方法名称，要和父类方法的参数，方法名称完全一样
    • 子类方法的返回类型和父类方法的返回类型一样，或者父类返回类型的子类：比如父类是返回值Object，子类返回值可以是String
    • 子类方法不能缩小父类方法的访问权限
    1. public class User {
    2.     public static void main(String[] args) {
    3.         new Dog().cry();
    4.     }
    5. }
    6.  
    7. class Animal{
    8.     protected void cry(){  //父类访问权限，比子类小或者一样
    9.         System.out.println("动物叫唤");
    10.     }
    11.     public Object bb(){ 
    12.         return null;
    13.     }
    14. }
    15.  
    16. class Dog extends Animal{
    17.     public void cry(){ //public->protected->默认->private
    18.         System.out.println("小狗汪汪叫");
    19.     }
    20.  
    21.     public String bb(){//子类的返回参数，是父类返回参数的子类或者相同
    22.         return null;
    23.     }
    24. }

    3.重载(overload)和重写(override)的区别:

    重载        本类        方法名：必须一样        参数：个数，顺序至少一个不同包        返回类型：无要求        修饰符：无要求

    重写        子父类        必须一样                   相同                                              父类返回值相同，或父类子类        子类方法

    4.案例

            编写一个person类，包括属性/private(name,age),构造器，方法say(返回自我介绍的字符串)。编写一个Student类，继承Person类，增加id,score属性/private,以及构造器，定义say方法(返回自我介绍的信息)。在main中分别创建Person和Student对象，调用say方法输出自我介绍。

    1. package com.user;
    2.  
    3. public class User {
    4.     public static void main(String[] args) {
    5.         Person person = new Person("jack",10);
    6.         System.out.println(person.say());
    7.  
    8.         Student student = new Student("smith",20,123456,89);
    9.         System.out.println(student.say());
    10.     }
    11. }
    12.  
    13. class Person {
    14.     private String name;
    15.     private int age;
    16.  
    17.     public Person(String name, int age) {
    18.         this.name = name;
    19.         this.age = age;
    20.     }
    21.  
    22.     public String say() {
    23.         return "姓名" + name + "年龄" + age;
    24.     }
    25.  
    26.     public String getName() {
    27.         return name;
    28.     }
    29.  
    30.     public void setName(String name) {
    31.         this.name = name;
    32.     }
    33.  
    34.     public int getAge() {
    35.         return age;
    36.     }
    37.  
    38.     public void setAge(int age) {
    39.         this.age = age;
    40.     }
    41. }
    42.  
    43. class Student extends Person {
    44.     private int id;
    45.     private double score;
    46.  
    47.     public Student(String name, int age, int id, double score) {
    48.         super(name, age);
    49.         this.id = id;
    50.         this.score = score;
    51.     }
    52.  
    53.     public String say() {
    54.         return super.say() + "id=" + id + "score=" + score;
    55.     }
    56. }

    八、多态

    1.定义：

            一个对象的编译理性和运行类型可以不一致。编译类型在定义对象时，就确定了，不能改变。运行类型是可以变化。编译类型看定义时 = 号的左边，运行类型看 = 号的 右边

    2.向上转型：

            多态的前提是：两个对象(类)存在继承关系。多态的向上转型

            本质：父类的引用指向了子类的对象    语法： 父类类型  引用名  = new 子类类型();

            特点：编译类型看左边，运行类型看右边。可以调用父类中的所有成员(但是要遵守访问权限)，不能调用子类的特有成员。

    1. public class User {
    2.     public static void main(String[] args) {
    3.         Person person = new Student();
    4.         person.hi();//向上转型只能访问父类有的方法与属性
    5.     }
    6. }
    7.  
    8. class Person{
    9.     public void hi(){
    10.         System.out.println("你好");
    11.     }
    12. }
    13.  
    14. class Student extends Person{
    15.     public void hah(){
    16.         System.out.println("hah");
    17.     }
    18. }

    3.向下转型：

            语法：子类类型 引用名 = (子类类型)  父类引用。只能强转父类的引用，不能强转父类的对象。要求父类的引用指向的是当前目标类型的对象，可以调用子类类型中所有的成员。

    1. public class User {
    2.     public static void main(String[] args) {
    3.         Person person = new Student();
    4.         person.hi();//向上转型只能访问父类有的方法与属性
    5.  
    6.         Student student = (Student) person;
    7.         student.hah(); //向下转型就可以访问子类的方法与属性
    8.     }
    9. }
    10.  
    11. class Person {
    12.     public void hi() {
    13.         System.out.println("你好");
    14.     }
    15. }
    16.  
    17. class Student extends Person {
    18.     public void hah() {
    19.         System.out.println("hah");
    20.     }
    21. }

    4.属性重写的问题

    定义：属性没有重写之说，属性看编译类型

    instanceof比较操作符，用于判断莫某类型是不是某某类型或者是他的子类

    1. public class User {
    2.     public static void main(String[] args) {
    3.         //属性编译看左边哦
    4.         Person person = new Student();
    5.         System.out.println(person.count);
    6.     }
    7. }
    8.  
    9. class Person {
    10.     int count = 10;
    11. }
    12.  
    13. class Student extends Person {
    14.    int count = 20;
    15. }

    5.java动态绑定机制：

    定义：当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定。当调用对象属性时，没有动态绑定机制，哪里声明，那里使用

    九、多态数组

    应用实例：现有一个继承结构如下 Teacher(name,int,say())  Teacher-->teach()  Student-->study()  遍历Teacher

    使用：getClass()查看类
    主要练习向上向下转型

    1. public class User {
    2.     public static void main(String[] args) {
    3.         Person[] people = new Person[5];
    4.         people[0] = new Person("jack",20);
    5.         people[1] = new Student("mary",21,99);
    6.         people[2] = new Student("smith",19,66.5);
    7.         people[3] = new Teacher("jan",80,20000);
    8.         people[4] = new Teacher("wan",60,10000);
    9.         for (int i = 0; i < people.length; i++) {
    10.             System.out.println(people[i].toString());
    11.             if (people[i] instanceof Student) ((Student) people[i]).study();
    12.             if (people[i] instanceof Teacher) ((Teacher) people[i]).teacher();
    13.         }
    14.     }
    15. }
    16.  
    17. class Person {
    18.     public String name;
    19.     public int age;
    20.  
    21.     public Person(String name, int age) {
    22.         this.name = name;
    23.         this.age = age;
    24.     }
    25.  
    26.     @Override
    27.     public String toString() {
    28.         return "Person{" +
    29.                 "name='" + name + '\'' +
    30.                 ", age=" + age +
    31.                 '}';
    32.     }
    33. }
    34.  
    35. class Student extends Person {
    36.     double score;
    37.  
    38.     public Student(String name, int age, double score) {
    39.         super(name, age);
    40.         this.score = score;
    41.     }
    42.  
    43.     public void study(){
    44.         System.out.println("好好学习");
    45.     }
    46.  
    47.     @Override
    48.     public String toString() {
    49.         return super.toString() + "学生成绩为" + score;
    50.     }
    51. }
    52.  
    53. class Teacher extends Person {
    54.     double salary;
    55.  
    56.     public Teacher(String name, int age, double salary) {
    57.         super(name, age);
    58.         this.salary = salary;
    59.     }
    60.  
    61.     public void teacher(){
    62.         System.out.println("我要教学生");
    63.     }
    64.  
    65.     @Override
    66.     public String toString() {
    67.         return super.toString()+"老师工资为17000";
    68.     }
    69. }

    十、多态参数

    1.定义：传递多态参数，就是传递父类的参数

    1. package com.user;
    2.  
    3. public class User {
    4.     public static void main(String[] args) {
    5.         new Tools().show(new Person("张三",19));
    6.         Person person = new Student("张三",19,10);
    7.         new Tools().show(person);
    8.     }
    9. }
    10.  
    11. class Person{
    12.     String name;
    13.     int age;
    14.  
    15.     public Person(String name, int age) {
    16.         this.name = name;
    17.         this.age = age;
    18.     }
    19. }
    20.  
    21. class Student extends Person{
    22.     int id;
    23.     public Student(String name, int age,int id) {
    24.         super(name, age);
    25.         this.id = id;
    26.     }
    27. }
    28.  
    29. class Tools{
    30.     public void show(Person p){
    31.         if (p instanceof Person) System.out.println(p.name+p.age);
    32.         if (p instanceof Student) System.out.println(p.name+p.age+((Student) p).id);
    33.     }
    34. }

    十一、Object的详解

    1.==运算符：        

                    既可以判断基本类型，可以判断应用类型。如果判断基本类型，就是判断值是否相等。引用类型，判断的是地址是否相等

    2.equals：

                     只能判断引用类型，默认是判断地址是否相等，子类中往往重写该方法，用于判断内容是否相等。

    3.重写equals方法：

    1. package com.user;
    2.  
    3. import java.util.Objects;
    4.  
    5. public class User {
    6.     public static void main(String[] args) {
    7.         Person person1 = new Person("jack",10,'男');
    8.         Person person2 = new Person("jack",10,'男');
    9.         System.out.println(person2.equals(person1));
    10.     }
    11. }
    12.  
    13. class Person{
    14.     String name;
    15.     int age;
    16.     char gender;
    17.  
    18.     public Person(String name, int age, char gender) {
    19.         this.name = name;
    20.         this.age = age;
    21.         this.gender = gender;
    22.     }
    23.  
    24.     //重写equals方法
    25.     @Override
    26.     public boolean equals(Object o) {
    27.         if (this == o) return true;
    28.         if (o == null || getClass() != o.getClass()) return false;
    29.         Person person = (Person) o;
    30.         return age == person.age && gender == person.gender && Objects.equals(name, person.name);
    31.     }
    32. }

    4.hashCode()方法：

    1. 提高具有哈希结构的容器效率！

    2. 两个引用，如果指向同一个对象，则哈希值肯定是一样的！

    3. 两个引用，如果指向的是不同对象，则哈希值是不一样的

    4. 哈希值主要是根据地址号的！，不能完全将hash值等价于地址

    5. object.hashCode()。后面在集合中hashCode如果需要也会重写

    5.toString()方法：

    1.默认返回全类名+@+hash值，所以一般我们也是重写哦

    1. public class User {    public static void main(String[] args) {
    2.         Person person = new Person();
    3.         person.name ="张三";
    4.         person.age = 10;
    5.         System.out.println(person.toString());
    6.     }
    7. }
    8.  
    9. class Person{
    10.     String name;
    11.     int age;
    12.  
    13.     @Override
    14.     public String toString() {
    15.         return "Person{" +
    16.                 "name='" + name + '\'' +
    17.                 ", age=" + age +
    18.                 '}';
    19.     }
    20. }

    6.finalize()

    1.定义：这个是垃圾回收器，系统会自动回收，如果程序员需要可以自己重写  System.gc()主动调用垃圾回收，

    finalize几乎不用只是为了面试

    十二、断点调试（debug）

    1.快捷键 ：

            F7(跳入)        F8(跳出)        shift+F8(跳出)        F9(resume,执行到下一个断点)

    右键运行有个debug运行那个就可以看效果

    1. public class User {
    2.     public static void main(String[] args) {
    3.         //debug 演示
    4.         int sum = 0;
    5.         for (int i = 0; i < 10; i++) {
    6.             sum += i;
    7.             System.out.println("i = " + i);
    8.             System.out.println("sum = " + sum);
    9.         }
    10.         System.out.println("end...");
    11.  
    12.         int[] arr = new int[3];
    13.         for (int i = 0; i < 4; i++) {
    14.             arr[i] =1;
    15.         }
    16.     }
    17. }

    十三、零钱通

    1.使用其他方法实现：

    1. import java.text.SimpleDateFormat;
    2. import java.util.Date;
    3. import java.util.Scanner;
    4.  
    5. public class SmallChangeSys {
    6.  
    7.     //化繁为简
    8.     // 1.先完成菜单，并可以选择菜单，给出对应提示信息
    9.     // 2.完成零钱通明细 思路字符串
    10.     public static void main(String[] args) {
    11.         //定义相关变量
    12.         Scanner scanner = new Scanner(System.in);
    13.         boolean loop = true;
    14.         String key = "";
    15.  
    16.         //2.完成零钱通
    17.  
    18.         String details = "---------零钱通明细--------", note, choice;
    19.         //3.收益入账
    20.         //定义新的变量
    21.         double money, balance = 0;
    22.         Date date = null;
    23.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH-mm"); //格式化时间的格式
    24.         do {
    25.             System.out.println("========零钱通菜单========");
    26.             System.out.println("\t\t\t1 零钱通明细");
    27.             System.out.println("\t\t\t2 收益入账");
    28.             System.out.println("\t\t\t3 消费");
    29.             System.out.println("\t\t\t4 退   出");
    30.  
    31.             System.out.print("请选择(1-4): \t");
    32.             key = scanner.next();
    33.             switch (key) {
    34.                 case "1":
    35.                     System.out.println(details);
    36.                     break;
    37.                 case "2":
    38.                     System.out.println("收益入账金额:");
    39.                     money = scanner.nextDouble();
    40.                     //金额校验等下写
    41.                     balance += money;
    42.                     date = new Date(); //获取到当前的日期
    43.                     details += "\n收益入账\t" + money + "\t" + sdf.format(date) + "\t" + balance;
    44.                     break;
    45.                 case "3":
    46.                     System.out.print("消费金额:\t");
    47.                     money = scanner.nextDouble();
    48.                     System.out.print("消费理由:\t");
    49.                     note = scanner.next();//消费理由
    50.                     //金额校验等下写
    51.                     balance -= money;
    52.                     date = new Date(); //获取到当前的日期
    53.                     details += "\n" + note + "\t-" + money + "\t" + sdf.format(date) + "\t" + balance;
    54.                     break;
    55.                 case "4":
    56.                     System.out.print("你确定要退出吗?(y/n): \t");
    57.                     choice = scanner.next();
    58.                     if (choice.equals("n")) break;
    59.                     loop = false;
    60.                     break;
    61.                 default:
    62.                     System.out.println("选择有误，请重新选择");
    63.             }
    64.         } while (loop);
    65.         System.out.println("退出了零钱通项目");
    66.     }
    67. }

    2.使用opp面向对象实现：

    1. package com.smallchange;
    2.  
    3. import java.text.SimpleDateFormat;
    4. import java.util.Date;
    5. import java.util.Scanner;
    6.  
    7. public class SmallChangeSys {
    8.     public static void main(String[] args) {
    9.         new SmallChangeSysOOP().meau();
    10.     }
    11. }
    12.  
    13. class SmallChangeSysOOP{
    14.     boolean loop = true;
    15.     String key = "";
    16.     String details = "---------零钱通明细--------", note, choice;
    17.     double money, balance = 0;
    18.     Date date = null;
    19.     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH-mm");
    20.     Scanner scanner = new Scanner(System.in);
    21.  
    22.     public void meau(){
    23.         do {
    24.             System.out.println("========零钱通菜单========");
    25.             System.out.println("\t\t\t1 零钱通明细");
    26.             System.out.println("\t\t\t2 收益入账");
    27.             System.out.println("\t\t\t3 消费");
    28.             System.out.println("\t\t\t4 退   出");
    29.  
    30.             System.out.print("请选择(1-4): \t");
    31.             key = scanner.next();
    32.             switch (key) {
    33.                 case "1":
    34.                     this.show();
    35.                     break;
    36.                 case "2":
    37.                     this.income();
    38.                     break;
    39.                 case "3":
    40.                     this.pay();
    41.                     break;
    42.                 case "4":
    43.                     this.exit();
    44.                     break;
    45.                 default:
    46.                     System.out.println("选择有误，请重新选择");
    47.             }
    48.         } while (loop);
    49.     }
    50.  
    51.     public void show(){
    52.         System.out.println(details);
    53.     }
    54.  
    55.     public void income(){
    56.         System.out.println("收益入账金额:");
    57.         money = scanner.nextDouble();
    58.         //金额校验等下写
    59.         balance += money;
    60.         date = new Date(); //获取到当前的日期
    61.         details += "\n收益入账\t" + money + "\t" + sdf.format(date) + "\t" + balance;
    62.     }
    63.  
    64.     public void pay() {
    65.         System.out.print("消费金额:\t");
    66.         money = scanner.nextDouble();
    67.         System.out.print("消费理由:\t");
    68.         note = scanner.next();//消费理由
    69.         //金额校验等下写
    70.         balance -= money;
    71.         date = new Date(); //获取到当前的日期
    72.         details += "\n" + note + "\t-" + money + "\t" + sdf.format(date) + "\t" + balance;
    73.     }
    74.  
    75.     public void exit(){
    76.         System.out.print("你确定要退出吗?(y/n): \t");
    77.         choice = scanner.next();
    78.         if (choice.equals("y"))loop = false;
    79.     }
    80. }

    本章太多了课后练习放在下一章

  • 相关阅读:
    面试突击：Bean 作用域是啥？它有几种类型？
    ActiViz中的纹理映射
    计算机毕业设计Java超市会员积分管理系统(源码+系统+mysql数据库+lw文档)
    Heap (mathematics)
    Jenkins测试报告样式优化
    基于C#的无边框窗体动画效果的完美解决方案 - 开源研究系列文章
    Python毕业设计-基于Python实现的深圳链家租房可视化系统源码+文档说明+条形图+数据库sql+界面截图
    编程小白如何学习RPA，0基础学习RPA攻略！
    Redis笔记
    2022年Web前端开发流程和学习路线（详尽版）
  • 原文地址：https://blog.csdn.net/m0_61927991/article/details/126905540