Java中阶(1)-包、修饰符、多态

最新推荐文章于 2024-11-09 14:26:40 发布
最新推荐文章于 2024-11-09 14:26:40 发布
阅读量224 收藏
点赞数
文章标签： intellij-idea java intellij idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenchen900/article/details/121144458
版权

文章目录

IDEA使用

  • IDEA是JetBrains公司的产品，总部位于捷克的首都布拉格
  • 可用于Java、HTML、CSS、PHP、MySQL、Python等
  • 面向项目

设置字体

  • 项目字体大小：file-----settings-----Appearance&Bahavior-------Appearance------Use custom font

  • 代码字体大小：file-----settings-----Editor-------Font

  • 代码字体粗体：file-----settings-----Editor------Color Scheme-----General------Text-----Default text----Bold

  • 背景颜色：file-----settings-----Editor------Color Scheme-----Scheme

字符编码

  • file-----settings-----Editor------File Encodings(默认是UTF-8)

快捷键

  • File------settings-----Keymap-----搜一下delete 等
  • 删除当前行，ctrl + d（自己配置）
  • 复制当前行，ctrl + alt + 向下光标（自己配置）
  • 补全代码 alt + /
  • 添加注释和取消注释 ctrl + /（第一次是添加注释，第二次是取消注释）
  • 导入该行需要的类，先配置file-----settings-----Editor-----General-----Auto Import，然后使用alt + enter 即可
  • 快速格式化代码 ctrl + alt + L
  • 快速运行程序 自己定义alt + R
  • 生成构造方法等alt + insert [提高开发效率]
  • 查看一个类的层级关系 ctrl + H 【学习继承后，非常有用】
  • 将光标放在一个方法上，输入ctrl + B，可以选择定位到方法【学习继承后，非常有用】
  • 自动的分配变量名，通过 在后面加 .var

模板

  • file----settings----editor----live templates 可以查看有哪些模板快捷键，也可以增加模板

包

包的作用

  1. 区分相同名字的类
  2. 当类很多时，可以很好的管理类
  3. 控制访问范围

包的基本语法

package 包名; package 关键字，表示打包。

包的本质

​ 实际上就是创建不同的文件夹/目录来保存类文件。

在这里插入图片描述

包的命名规则和规范

规则
  • 只能包含数字、字母、下划线、小圆点，但不能用数字开头，不能是关键字或保留字。
规范
  • 一般是小写字母+小圆点一般是com.公司名.项目名.业务模块名

常用的包

  • java.lang.* 默认引用，不用再引用
  • java.util.* 工具包
  • java.net.* 网络包
  • java.awt.* 界面开发GUI

包的使用细节

  • 如何引入包：语法：import 包；引入包的主要目的就是使用该包下的类
  • 最好是需要使用什么类就导入哪个类
  • package的作用是声明当前类所在的包，需要放在类的最上面，一个类中最多只有一句package
  • import指令 位置放在package的下面，在类定义前面，可以有多句且没有顺序要求

访问修饰符

介绍

四种访问控制修饰符号，用于控制方法和属性（成员变量）的访问权限

  • 公开级别：public 修饰，对外公开
  • 受保护级别：protected 修饰，对子类和同一个包中的类公开
  • 默认级别：没有修饰符号，向同一个包的类公开
  • 私有级别：private 修饰，只有类本身可以访问，不对外公开
访问级别访问控制修饰符同类同包子类不同包
公开public√√√√
受保护protected√√√×
默认没有修饰符号√√××
私有private√×××

使用注意事项

  • 修饰符可以用来修饰类中的属性，成员方法以及类
  • 只有默认的和public才能修饰类，并且遵循上述访问权限的特点
  • 成员方法的访问规则和属性完全一样

OOP三大特征（封装，继承和多态）

封装

封装(encapsulation)就是把抽象出的数据【属性】和对数据的操作【方法】封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作【方法】，才能对数据进行操作。

(1)隐藏实现细节

(2)可以对数据进行验证，保证安全合理

实现步骤
  • 将属性进行私有化private【不能直接修改属性】
  • 提供一个公共public的set方法，用于对属性判断并赋值
  • 提供一个公共public的get方法，用于获取属性的值
  • 使用快捷键写set和get方法，alt + insert，选择Getter and Setter，然后根据要求完善代码。
  • 如果要使用快捷键运行，需要先配置一下主类，第一次run一下，后面就有了
//构造器和set结合
class Person{
    public String name;
    private int age;
    private double salary;
    public Person(){     
    }
    public Person(String name,int age,double salary){
        setName(name);//等价于this.setName(name);
        setAge(age);//等价于this.setAge(age);
        setSalary(salary);//等价于this.setSalary(salary);
    }
    public void setName(String name){};
    public void setAge(int age){};
    public void setSalary(double salary){};
    public String getName(){};
    public int getAge(){};
    public double getSalary(){};
}

如何去掉参数提示：file-----settings-----Editor-----Inlay Hints-----Java-----Parameter hints-----show parameter hints for:

继承

继承可以解决代码复用，让我们的编程更加靠近人类思维，当多个类存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可。

基本语法
  • class 子类 extends 父类{}
  1. 子类就会自动拥有父类定义的属性和方法
  2. 父类又叫超类，基类
  3. 子类又叫派生类

在这里插入图片描述

注意和细节
  • 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问
  • 子类必须调用父类的构造器，完成父类的初始化，super()先调用父类再调用子类
  • 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过。
  • 如果希望指定去调用父类的某个构造器，则显式的调用一下：super()
  • super在使用时，需要放在构造器第一行，super()只能在构造器中使用
  • super()和this()都只能放在构造器的第一行，因此这两个方法不能共存在一个构造器
  • Java所有类都是Object的子类，Object是所有类的基类
  • 父类构造器的调用不限于直接父类，将一直往上追溯直到Object类（顶级父类）
  • 子类最多只能继承一个父类（指直接继承），即Java中是单继承机制
  • 不能滥用继承，子类和父类之间必须满足is-a的逻辑关系 Person is a Music?cat is an animal
继承的本质

当子类对象创建好后，建立查找的关系

在这里插入图片描述

​ 如果利用son对象访问age这个属性，而Father类的age属性是private的，Grandpa类的age属性是非私有的，那么son在访问的时候查到Father类的age属性是私有的会直接报错，而不会继续向上查找Grandpa类的age属性。

class A{
    A(){
        System.out.println("a");
    }
    A(String name){
        System.out.println("a name");
    }
}
class B extends A{
    B(){
        this("abc");
        System.out.println("b");
    }
    B(String name){
        //这里有一个默认的函数super();
        System.out.println("b name");
    }
}

B b = new B();//输出 a换行b name换行b
//注意点：this 和 super 不能共存在一个构造器
//父类的构造器完成父类属性初始化，子类的构造器完成子类属性初始化

Super关键字

super代表父类的引用，用于访问父类的属性、方法、构造器

基本语法

  • 访问父类的属性，但不能访问父类的private属性，super.属性名
  • 访问父类的方法，但不能访问父类的private方法，super.方法名(参数列表)
  • 访问父类的构造器，super(参数列表)，只能放在构造器的第一句，只能出现一句。

细节

  • 调用父类的构造器的好处（分工明确，父类属性由父类初始化，子类的属性由子类初始化）

  • 当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super，如果没有重名，使用super、this、直接访问是一样的效果。【this、直接访问】找方法时，先找本类再找父类，如果查找方法的过程中，找到了但是不能访问就报错，如果没找到，则提示方法不存在。而【super.方法】是直接跳过找本类，从找父类开始。

  • super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员，如果多个基类（上级类）中都有同名的成员，使用super访问遵循就近原则。A->B->C

super和this的比较

No.区别点thissuper
1访问属性访问本类中的属性，如果本类没有此属性则从父类中继续查找从父类开始查找属性
2调用方法访问本类中的方法，如果本类没有此方法则从父类中继续查找从父类开始查找方法
3调用构造器调用本类构造器，必须放在构造器的首行调用父类构造器，必须放在子类构造器的首行
4特殊表示当前对象子类中访问父类对象

方法重写（overwrite）

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

注意事项

  • 子类的方法的形参列表，方法名称，要和父类方法的参数，方法名称完全一样；
  • 子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类。比如【父类】返回类型是Object，【子类】方法返回类型是String
  • 子类方法不能缩小父类方法的访问权限

方法重写和方法重载的比较

名称发生范围方法名参数列表返回类型修饰符
重载overload本类必须一样类型，个数或者顺序至少有一个不同无要求无要求
重写override父子类必须一样相同子类重写方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类子类方法不能缩小父类方法的访问权限

多态

方法或对象具有多种形态，是面向对象的第三大特征，多态是建立在封装和继承基础之上的。

具体体现

方法的多态
  • 方法重写和重载就体现多态
对象的多态
  • 一个对象的编译类型和运行类型可以不一致
  • 编译类型在定义对象时，就确定了，不能改变
  • 运行类型是可以变化的
  • 编译类型看定义时 = 号 的左边，运行类型看 = 号的 右边
public class Animal{
    public void cry(){
        System.out.println("动物在叫····");
    }
}

public class Cat extends Animal{
    public void cry(){
        System.out.println("猫在叫 喵喵喵");
    }
}

public class Dog extends Animal{
    public void cry(){
        System.out.println("狗在叫 汪汪汪");
    }
}

//主类
Animal animal = new Dog();//编译类型是Animal，运行类型是Dog
animal.cry();//因为运行时，执行到该行时，animal运行类型是Dog，所以cry就是Dog的cry
//输出狗在叫 汪汪汪
animal = new Cat();//编译类型是Animal，运行类型是Cat
animal.cry();//因为运行时，执行到该行时，animal运行类型是Cat，所以cry就是Cat的cry
//输出猫在叫 喵喵喵

喂食问题改进

public class Master{
    private String name;
    //animal的编译类型是Animal，运行类型可以是Animal子类的对象
    //food的编译类型是Food，运行类型可以是Food子类的对象
    public void feed(Animal animal,Food food){
        System.out.println("主人" + name + "给" + animal.getName() + "吃" + food.getName());
    }
}

注意事项和细节

  • 多态的前提是：两个对象（类）存在继承关系
  • 多态的向上转型
    • 本质：父类的引用指向了子类的对象
    • 语法：父类类型 引用名 = new 子类类型()
    • 编译类型看左边，运行类型看右边
      • 可以调用父类中的所有成员（需遵守访问权限）
      • 不能调用子类的特有的成员（因为在编译阶段能调用哪些成员是由编译类型决定）
      • 最终运行的效果看子类的具体实现（调用的时候先在子类中找，再在父类中找）
  • 多态的向下转型
    • 语法 子类类型 引用名 = （子类类型）父类引用
    • 只能强转父类的引用，不能强转父类的对象
    • 要求父类的引用必须指向的是当前目标类型的对象
    • 可以调用子类类型中所有的成员
  • 属性没有重写之说！属性的值看编译类型
  • instanceOf 比较操作符，用于判断对象的类型是否为××类型或××类型的子类型（运行机制）
class AA{}
class BB extends AA{}
//主函数
BB bb = new BB();
System,out.println(bb instanceof BB);//true
System,out.println(bb instanceof AA);//true
AA aa = new BB();
System,out.println(aa instanceof BB);//true
System,out.println(aa instanceof AA);//true
//说明instanceof判断的是运行类型
Object obj = new Object();
System,out.println(obj instanceof AA);//false
String str = "hello";
System,out.println(str instanceof Object);//true

class Base{
    int count = 10;
    public void display(){
        System,out.println(this.count);
    }
}
class Sub extends Base{
    int count = 20;
    public void display(){
        System,out.println(this.count);
    }
}
//主函数
Sub s = new Sub();
System,out.println(s.count);//属性看编译类型，输出20
s.display();//从运行类型即子类开始寻找方法，输出20
Base b = s;//向上转型
System,out.println(b == s);//比较的是指向对象的地址，虽然编译类型不同，但指向同一对象，输出true
System,out.println(b.count);//属性看编译类型，输出10
b.display();//从运行类型即子类开始寻找方法，输出20

Java动态绑定机制（非常非常重要）

  • 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
  • 当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用
class A{
    public int i = 10;
    public int sum(){
        return getI() + 10;//调用哪个getI(),和运行类型有关，调用B类的getI()
    }
    public int sum1(){//当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用
        return i + 10;
    }
    public int getI(){
        return i;
    }
}

class B extends A{
    public int i = 20;
    //public int sum(){
    //    return i + 20;
    //}
    //public int sum1(){
    //    return i + 10;
    //}
    public int getI(){
        return i;
    }
}

A a = new B();//向上转型
System.out.println(a.sum());//--------30
System.out.println(a.sum1());//-------20

多态数组

数组的定义类型为父类类型，里面保存的实际元素类型为子类类型

public class Person {//父类
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 say() {//返回名字和年龄
        return name + "\t" + age;
    }
}

public class Teacher extends Person {
    private double salary;
    public Teacher(String name, int age, double salary) {
        super(name, age);
        this.salary = salary;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    //写重写父类的say方法
    public String say() {
        return "老师 " + super.say() + " salary=" + salary;
    }
    //特有方法
    public void teach() {
        System.out.println("老师 " + getName() + " 正在讲java课程...");
    }
}

public class Student extends Person {
    private double score;
    public Student(String name, int age, double score) {
        super(name, age);
        this.score = score;
    }
    public double getScore() {
        return score;
    }
    public void setScore(double score) {
        this.score = score;
    }
    //重写父类say
    public String say() {
        return "学生 " + super.say() + " score=" + score;
    }
    //特有的方法
    public void study() {
        System.out.println("学生 " + getName() + " 正在学java...");
    }
}

//主函数
Person[] persons = new Person[5];
persons[0] = new Person("jack", 20);
persons[1] = new Student("mary", 18, 100);
persons[2] = new Student("smith", 19, 30.1);
persons[3] = new Teacher("scott", 30, 20000);
persons[4] = new Teacher("king", 50, 25000);

//循环遍历多态数组，调用say
for (int i = 0; i < persons.length; i++) {
    //person[i] 编译类型是 Person ,运行类型是是根据实际情况有JVM来判断
    System.out.println(persons[i].say());//动态绑定机制
    //使用 类型判断 + 向下转型.
    if(persons[i]  instanceof  Student) {//判断person[i] 的运行类型是不是Student
        Student student = (Student)persons[i];//向下转型
        student.study();
        //((Student)persons[i]).study();
    } else if(persons[i] instanceof  Teacher) {
        Teacher teacher = (Teacher)persons[i];
        teacher.teach();
    } else if(persons[i] instanceof  Person){
        //System.out.println("你的类型有误, 请自己检查...");
    } else {
        System.out.println("你的类型有误, 请自己检查...");
    }

}

多态参数

方法定义的形参类型为父类类型，实参类型允许为子类类型

public class Employee {
    private String name;
    private double salary;

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
    //得到年工资的方法
    public double getAnnual() {
        return 12 * salary;
    }
    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 class Worker extends Employee {
    public Worker(String name, double salary) {
        super(name, salary);
    }
    public void work() {
        System.out.println("普通员工 " + getName() + " is working");
    }
    public double getAnnual() { //因为普通员工没有其它收入，则直接调用父类方法
        return super.getAnnual();
    }
}

public class Manager extends Employee{

    private double bonus;

    public Manager(String name, double salary, double bonus) {
        super(name, salary);
        this.bonus = bonus;
    }
    public double getBonus() {
        return bonus;
    }
    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
    public void manage() {
        System.out.println("经理 " + getName() + " is managing");
    }
    //重写获取年薪方法
    public double getAnnual() {
        return super.getAnnual() + bonus;
    }
}

//主函数
public class PloyParameter {
    public static void main(String[] args) {
        Worker tom = new Worker("tom", 2500);
        Manager milan = new Manager("milan", 5000, 200000);
        PloyParameter ployParameter = new PloyParameter();
        ployParameter.showEmpAnnual(tom);
        ployParameter.showEmpAnnual(milan);

        ployParameter.testWork(tom);
        ployParameter.testWork(milan);

    }

    //showEmpAnnual(Employee e)
    //实现获取任何员工对象的年工资,并在main方法中调用该方法 [e.getAnnual()]
    public void showEmpAnnual(Employee e) {
        System.out.println(e.getAnnual());//动态绑定机制.
    }
    //添加一个方法，testWork,如果是普通员工，则调用work方法，如果是经理，则调用manage方法
    public void testWork(Employee e) {
        if(e instanceof  Worker) {
            ((Worker) e).work();//有向下转型操作
        } else if(e instanceof Manager) {
            ((Manager) e).manage();//有向下转型操作
        } else {
            System.out.println("不做处理...");
        }
    }
}

Object类详解，垃圾回收机制

equals方法

== 和equals的对比
  • == ：既可以判断基本类型，又可以判断引用类型
  • == ：如果判断基本类型，判断的是值是否相等
  • == ：如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象
  • equals ：是Object类中的方法，只能判断引用类型
  • 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等，比如Integer和String
Integer integer1 = new Integer(5);
Integer integer2 = new Integer(5);
System.out.println(integer1 == integer2);//false  比较的是地址，是不是同一个对象
System.out.println(integer1.equals(integer2));//true 比较的是内容
//String同

类中equals重写

public boolean equals(Person p){
    if(this == p){
        return true;
    }
    if(p instanceof Person){
        Person p1 = (Person)p;
        return this.name.equals(p.name) && this.gender == p.gender && this.age == p.age;
    }
    return false;
}

判断输出

char ch2 = 12;
char ch1 = 65;
int d = 12;
int dd = 'A';
System.out.println(d + ch2);//24
System.out.println(ch1);//A
System.out.println(dd);//65
System.out.println(12 == ch2);//true
System.out.println("hello" == new java.sql.Date());//编译报错，非同一类型且没有继承关系

hashCode方法

返回对象的哈希码值，为了提高哈希表的性能。

  1. 提高具有哈希结构的容器的效率
  2. 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
  3. 两个引用，如果指向的是不同对象，则哈希值是不一样的
  4. 哈希值主要根据地址号来的，不能完全将哈希值等价于地址
  5. 集合中hashcode如果需要的话，也会重写
AA aa1 = new AA();
AA aa2 = new AA();
AA aa3 = aa1;
System.out.println("aa1 = " + aa1.hashCode());//aa1 = 356573597
System.out.println("aa2 = " + aa2.hashCode());//aa2 = 1735600054
System.out.println("aa3 = " + aa3.hashCode());//aa3 = 356573597

toString方法

返回该对象的字符串表示，通常，toString 方法会返回一个”以文本方式表示“此对象的字符串，结果应是一个简明但易于读懂的信息表达式，建议所有子类都重写此方法。

  • 默认返回：全类名+@+哈希值的十六进制【Object的toString方法】，子类往往重写toString方法，用于返回对象的属性信息
  • 重写toString方法，打印对象或拼接对象时，都会自动调用该对象的toString形式
  • 当直接输出一个对象时，toString方法会被默认的调用
public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
}//Object的toString方法源码
//getClass().getName() 全类名，即包名+类名

//重写前
AA aa1 = new AA();
System.out.println(aa1.toString());//com.oop.objectdetail.AA@1540e19d

//重写后
Monster monster = new Monster("小妖怪", "巡山", 10.0);
System.out.println(monster.toString());//输出Monster{name='小妖怪', job='巡山', salary=10.0}
System.out.println(monster);//当直接输出一个对象时，toString方法会被默认的调用,输出同上

class Monster{
    private String name;
    private String job;
    private double salary;

    public Monster(String name, String job, double salary) {
        this.name = name;
        this.job = job;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Monster{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                ", salary=" + salary +
                '}';
    }
}

finalize方法

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

  • 当对象被回收时，系统自动调用该方法的finalize方法，子类可以重写该方法，做一些释放资源的操作
  • 什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法
  • 垃圾回收机制的调用，是由系统来决定，也可以通过System.gc()主动触发垃圾回收机制
  • 在实际开发中几乎不会运用finalize方法
Car car = new Car("大黄蜂");
car = null;//上面创建的Car对象就成了垃圾，垃圾回收器就会销毁对象
//在销毁对象前，会调用该对象的finalize方法，程序员就可以在这个方法中
//写自己的业务逻辑代码，比如释放资源等，如果程序员不重写，就会调用Object类的finalize方法，即默认处理
System.gc();//运行垃圾回收器，不一定会调用finalize方法
System.out.println("退出程序。");
//输出结果：退出程序。
//         销毁汽车大黄蜂
//         资源释放

class Car{
    private String name;

    public Car(String name) {
        this.name = name;
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("销毁汽车" + name);
        System.out.println("资源释放");
    }
}

断点调试（Debug）

  • 在断点调试过程中，是运行状态，是以对象的运行类型来执行的
  • 断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住，然后你可以一步一步往下调试，调试过程中可以看到各个变量的当前值，出错的话，调试到出错的代码行即显式错误，停下。进行分析从而找到Bug
  • 断点调试是程序员必须掌握的技能
  • 断点调试也能帮助我们查看Java底层源代码的执行过程，提高程序员的Java水平
  • 断点调试的快捷键
    • F7(跳入方法内) F8(跳过，逐行执行代码) Shift + F8(跳出方法) F9(resume，执行到下一个断点)
  • 小技巧：将光标放在某个变量上，可以看到最新的数据
  • 文件：idea debug如何进入jdk源码Setting—Build,Execution,Deployment—Debugger—Stepping

项目

public class MiniFund {
    private double balance;
    private double income;
    private double expense;
    //private String con_type;
    private String[][] bill = new String[20][3];
    private int count = 0;

    public MiniFund(double balance) {
        this.balance = balance;
        bill[count][0] = "收益入账";
        bill[count][1] = "+" + balance;
        bill[count][2] = balance + "";
    }

    public double consume(double con,String con_type){
        if(balance >= con && con > 0) {
            balance = balance - con;
            count++;
            bill[count][0] = con_type;
            bill[count][1] = "-" + con;
            bill[count][2] = balance + "";
        }else{
            System.out.println("您的余额不足或消费金额有误！");
        }
        return balance;
    }

    public double earn(double e){
        if(e > 0) {
            balance = balance + e;
            count++;
            bill[count][0] = "收益入账";
            bill[count][1] = "+" + e;
            bill[count][2] = balance + "";
        }else{
            System.out.println("您入账金额为负数！");
        }
        return balance;
    }

    public void showBill(){
        for (int i = 0; i <= count; i++) {
            System.out.println(bill[i][0] + "\t" + bill[i][1] + "\t" + "2021-10-25 17:02" + "\t" + "余额:" + bill[i][2]);
        }
    }
}

public class Use {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("---------------零钱通菜单--------------");
        System.out.println("            1.零钱通明细");
        System.out.println("            2.收益入账");
        System.out.println("            3.消费");
        System.out.println("            4.退出");
        int flag = 0;
        MiniFund my = new MiniFund(100);
        while(true){
            System.out.print("请选择(1-4)");
            flag = scanner.nextInt();
            if(flag == 1){
                System.out.println("---------------零钱通明细--------------");
                my.showBill();
            }else if(flag == 2){
                System.out.print("请输入您入账金额：");
                double ee = scanner.nextDouble();
                my.earn(ee);
            }else if(flag == 3){
                System.out.print("请输入您消费来源：");
                String c_type = scanner.next();
                System.out.print("请输入您消费金额：");
                double cc = scanner.nextDouble();
                my.consume(cc,c_type);
            }else if(flag == 4){
                System.out.println("您确定要退出吗？y/n");
                char ch = scanner.next().charAt(0);
                while(ch != 'y' && ch != 'n') {
                    System.out.println("您确定要退出吗？y/n");
                    ch = scanner.next().charAt(0);
                }
                if(ch == 'y') {
                    System.out.println("您已退出系统···");
                    break;
                }else{
                    continue;
                }
            }else{
                System.out.println("您输入的数字有误，已退出系统");
                break;
            }
        }
    }
}


//存在的问题
//1.账单用数组存储，有限数组---------老师直接字符串拼接
//2.账单输出格式有问题，上下对不齐-----------老师也没对齐
//3.时间的获取-------------新知识
//4.在判定选择的数据可以用switch

//编程思想：
//一块代码尽可能只做一件事情，耦合性比较小
//判断条件时，找出不正确的金额条件，然后给出提示退出，最好过关斩将，一关一关过，直到不通过或者通过
//把整个过程封装起来，客户只要调用就可以了
(ง •_•)ง(ง •_•)ง
关注
java学习路线图，新技术版，资源持续更新
Java帮帮
11-14 813
本学习路线图由 黑马程序员原创出品，职涯宝重新编辑发布，方便大家浏览，Java帮帮转发，遵循CC 4.0 BY-SA版权协议 声明 黑马程序员/职涯宝/Java帮帮，三者并无任何关联，后两者为分享平台。 2019 JavaEE中级程序员学习路线图，共有12大板块，涉及100多个技术，由黑马程序员技术专家和课程研究员精心打造，课程涉及服务中间件、业务解决方案、热门技术框架、分布式...
关于java中阶知识点——关键词解析——稳定更新
javadaozhu的博客
05-22 191
本文将介绍java一些关键词并进行解析，便于快速理解java里的一些知识 1、导包 import java.util.*;、 通用各类包 方便快捷 一、集合 1、键值对： key value 比如：手机通讯录中， 键：小明， 值：18685858888（小明号码），这就是所谓键值对 键：就是你存的值的编号 值：就是你要存放的数据 2、线性表：最基本、最简...
Java面向对象基础
renjingkai的博客
12-30 251
Java 继承 继承的概念 继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。 继承就是子类继承父类的特征和行为，使得子类具有父类的各种属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。 继承的特性 1.子类拥有父类非private的属性，方法和构造器。 2.子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。 3.子类可以用自己的方式实现父类的
java 的中阶 servlet
01-17 514
应该就是把java 里面的组件搞明白Servlet Servlet是一种基于web的Java组件，它由容器管理，并动态生成其内容则没有图形界面，运行在服务器端它们都有一个生存周期，包含init()和destroy()方法  不是独立的应用程序，没有main()方法与传统的CGI和许多其他类似CGI的技术相比，Java Servlet具有更高的效率，更容易使用，功能更强大，具有更好的可移
Java中阶——I/O流简介
qq_44808710的博客
12-11 543
I/O流IO含义理解数据源流按流的方向分按处理的数据单元分类按处理对象不同分类四大IO抽象类InputStream常用方法OutputStream常用方法Reader常用方法Writer常用方法Java中的IO流体系 IO含义理解 输入(Input) 指的是：可以让程序从外部系统获得数据（核心含义是“读”，读取外部数据）。常见的应用： 读取硬盘上的文件内容到程序。例如：播放器打开一个视频文件、word 打开一个 doc 文件。 读取网络上某个位置内容到程序。例如：浏览器中输入网址后，打开该网址对应
JAVA进阶-Java继承，多态，重写，修饰符以及super与this使用，Oject对象
07-23
在Java编程语言中，继承、多态、重写、修饰符以及`super`和`this`的使用是面向对象编程的核心概念。这些知识点对于理解和编写高效、可维护的代码至关重要。 1. **Java继承**： Java继承允许一个类（子类）继承另一...
java学习资料-Java继承和多态
06-14
在Java中，访问修饰符如`private`、`protected`、`public`和默认（包访问）控制了类的字段和方法的可见性。`private`是最严格的访问级别，只允许在类内部访问。 **3. getter和setter方法** getter和setter方法用于...
Java软件开发实战 Java基础与案例开发详解 6-9 继承和多态 章节练习 共4页.pdf
07-07
- `default` (无修饰符): 只能在同一包内的类中访问。 - `private`: 只能在本类内部访问。 #### 6-5 static修饰符 - **static修饰符**: 用于声明静态变量和静态方法，可以直接通过类名访问，而无需创建对象。 - *...
day01-继承&修饰符&多态&抽象类.pdf
08-23
综上所述，继承、修饰符、多态和抽象类是Java SE编程中的核心概念。继承实现了代码的复用与维护，修饰符控制了类和成员的访问权限，多态使得程序更加灵活，而抽象类为子类提供了一个共同的模板和抽象方法实现的要求...
java---多态
qq_45122557的博客
01-03 584
java多态
Java开发工程师职业发展及晋升路线图
qq_43675712的博客
05-20 8452
据相关数据统计显示，Java工程师在所有软件开发类人才中的需求量已达到60%~70%，而且Java工程师的薪水相对较高，如果你有3~5年的开发经验，你的年薪在10万+以上是很正常的，毋庸置疑Java会不可避免的继续影响新一代程序员。那么Java开发工程师的职业发展及晋升路线图是怎么样的呢？一起和合肥学码思小编来看看。 1.Java程序员 这是Java开发工程师的第一阶段了，一般是刚入门Jav...
java中阶之面向对象三大特征,封装/继承/多态
qq_51365907的博客
04-08 49
封装,继承,多态
Java进阶过程
w952470866的专栏
01-09 5207
先是JAVA基本语法、面向对象基础、JAVA高级、关系型数据库（MY SQL /ORCLE）、JDBC、网页基础（html+css+cdth）、ajax、js框架（jquery、esayui），spring+springmvc+mybatis。然后会穿插两期项目练习，还有一些比如XML、webservice、tomcat等。  （1）人工智能方向的学习路线 其实无非就是那些经典的公
Java类有个星号标记_Java中import包带*（星号）问题
weixin_34638409的博客
02-26 2270
今天发现Java中import包时，带*(星号)的一个问题。下面附上代码和截图：在我的电脑"E:\csdn\"目标下有两个java文件: Print.java和Demo.java Print.java代码如下：package util;public class Print{public static void print(Object obj){System.out.print(obj);}}De...
Java进阶--Java中 i++完全解析
有图有真相
06-08 6457
在讲 i++与++i之前先看两个在笔试面试中经常遇到的题目： 题目1//代码1 int x=2; int b=(x++)*3; System.out.println(b);/* 输出结果为：6 */题目2//代码1 int i=0; for(int j=0;j<100;j++)
IntelliJ Idea设置自定义快捷键
三毛村滴雪鱼粉的博客
11-06 399
idea自定义快捷键方法，具体为设置跳转到上层抽象方法的快捷键
在IntelliJ IDEA中创建带子模块的SpringBoot工程
baozhengw的专栏
11-08 1186
有不少人做项目是基于搭建好的SpringBoot工程，当从零搭建新的框架时会遇到各种问题，本文介绍在IntelliJ IDEA中创建带子模块的SpringBoot工程的详细过程。
新版 idea 编写 idea 插件时，启动出现 ClassNotFound
最新发布
Primary_wind的专栏
11-09 407
IntelliJ IDEA 2024.1.6 (Ultimate Edition) Build #IU-241.19072.14, built on August 8, 2024 Licensed to Sophia Tout Subscription is active until June 29, 2025. For educational use only. Runtime version: 17.0.11+1-b1207.30 amd64 Kotlin: 241.19072.14-IJ新版本idea
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值