Java学习笔记2.0
文章目录
1.IDEA快捷键
Ctrl+H 查看类的继承关系
2.模板/自定义模板
main, sout, fori
3. 包
3.1 包的作用(本质就是创建不同的文件夹/目录保存类文件)
- 区分名字相同的类
- 当类很多的时候，可以更好的管理类
- 控制访问范围
3.2 包的访问语法
声明当前类所在的包：package 包名，需要放在类的最上面，一个类中最多只有一句package。
导入对应包的类：import 包名.类名，放在package的下面，在类定义的前面，可以有多句。
比如包名：com.xiaoming 的意思是创建一个com目录的xiaoming目录的包
命名规则：只能包含数字 字符 下划线 小圆点 。 不能用数字开头，也不能是关键字或者是保留字
命名规范：com.公司名.业务名.业务模块名 （小写字母）
3.3 常用的包
一个包下包含很多的类,java 中常用的包有:
- java.lang.* //lang 包是基本包，默认引入，不需要再引入 比如Math类 System类等等
- java.util.* //util 包，系统提供的工具包, 工具类，使用 Scanner
- java.net.* //网络包，网络开发
- java.awt.* //是做 java 的界面开发，GU
4.访问修饰符
java 提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限（范围）:
-
公开级别：用 public 修饰，对外公开 。
-
受保护级别：用protected修饰，对子类和同一个包中的类公开 。
-
默认级别：没有修饰符号，向同一个包的类公开。
-
私有级别：用 private 修饰，只有类本身可以访问,不对外公。
- 在同一个类中 可以访问public protected 默认 private修饰的属性或方法
- 在同一个包中 可以访问public protected 默认 修饰的属性或方法
- 在同一个子类中 可以访问public protected 修饰的属性或方法
- 在不同的包中 可以访问public 修饰的属性或方法
修饰符可以用来修饰类中的属性，成员方法以及类
只有默认的以及public才能修饰类，并遵循上述的访问权限的特点
5.封装继承和多态
5.1 封装 encapsulation
5.1.1 封装的定义
封装就是把抽象出来的数据【属性】和对数据的操作【方法】封装在一起。数据被保护在内部，程序的其他部分只有通过被授权的操作【方法】，才能对数据进行操作。
5.1.2 封装的作用
- 隐藏实现的细节： 方法（连接数据库） <---- 调用（传入参数…）
- 可以对数据进行验证，保证安全合理
5.1.3 封装实现的三步
5.1.4 封装案例
使用快捷键alt+insert
5.2 继承 extends
5.2.1 继承的定义
继承可以解决代码复用，让我们的编程更加靠近人类思维。
当多个类存在相同的属性(变量)和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过 extends 来 声明继承父类即可。
5.2.2 继承的基本语法
创建类的时候：
class 子类 extends 父类{
}
5.2.3 继承的10个基本细节
-
🔴子类继承了所有的属性和方法。访问使用的时候：非私有的属性和方法可以在子类直接访问，但是私有属性和方法（private）不能在子类直接访问，要通过父类提供公共的方法去访问
-
子类必须调用父类的构造器，完成父类的初始化（默认会调用父类的无参构造器super（）)
-
当创建子类对象的时候，不管使用使用的是子类的哪一个构造器，默认情况下总会调用父类的无参构造器。如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的那一个构造器完成对父类的初始化工作。否则编译不通过。
比如父类的构造器只有public Father(int a){}，那么在子类构造器定义的时候就必须加入super(2)去指定父类的有参构造器完成对父类的初始化工作
-
如果希望指定去调用父类的某个构造器，则显式的调用一下即可。
super(参数列表) -
super使用的时候，只能在构造器中使用，且必须放在子类构造器的最前面
-
super()和this()都只能放在构造器的第一行，所以super()和this()不能在同一个构造器中存在
-
java的所有类都是Object的子类，Object类是所有类的爹
-
父类构造器的调用不限于直接父类，将一直向上追溯直到Object类（顶级父类）
-
子类最多只能继承一个父类，就是java中是单继承机制（只能一个人只能有一个爹）
-
不能滥用继承，子类和父类必须满足“is a”的关系
-
继承的基本思想：父类构造器完成父类属性的初始化，子类构造器完成子类属性初始化
5.2.4 继承的本质
子类对象创建好之后，建立查找的关系
在创建子类的过程中，首先先在方法区加载类（先加载爷爷类，再加载父类，最后加载子类）。之后在堆里分配空间，从爷爷类开始分配，字符串就存地址内容存在方法区的常量池，其他的就直接存。最后将son对象的地址返回给主方法的对象引用。
当用son这个对象引用访问属性或方法的时候，这时要按照查找关系来返回数据：
- 首先看子类（本类）是否有该属性（或方法），
- 如果有并且可以访问，则返回信息（或者调用方法）。
- 如果子类没有这个属性（或方法），就看父类有没有这个属性（或方法）
- 如果父类有，并且可以访问，则返回信息（或者调用方法）
- 如果没有就继续找上一级父类…直到Object，实在找不到了就报错
- 如果找到了，但是不能访问，也会报错
tips：如果在父类有一个private的age，爷爷类有一个public的age。
此时先找子类没有age，到父类找到了age但是他是private无法访问就报错，不会再去爷爷类找了
5.2.5 super关键字
super代表父类的引用，用于访问父类的属性、方法、构造器。
1 访问父类的属性
访问父类的属性，但不能访问父类的private属性， super.属性名
2 访问父类的方法
访问父类的方法，但不能访问父类的private方法， super.方法名(参数列表)
3 访问父类的构造器
访问父类的构造器，只能放在构造器的第一句，且只能出现一句，super()或者super(参数列表)
作用：
- 调用父类构造器好处：分工明确，父类的属性由父类的构造器初始化，子类的属性由子类的构造器初始化。
- 当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super。
- 如果没有重名，使用super，this，或者直接访问的效果一样。
- **注意：**使用
super.属性或者super.方法()的时候就直接不看子类有没有要找的属性或方法了，作用就是直接跳过本类，去寻找父类及以上，然后就找啊找，遵循就近原则，找到为止。
4 super和this的比较
5.3 方法重写/覆盖 override
5.3.1 方法重写/覆盖定义
子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么就说子类的这个方法覆盖了父类的方法
5.3.2 方法重写/覆盖需要满足的条件（3个）
-
子类方法的形参列表、方法名称，要和父类方法的形参列表、方法名称完全一样；
-
子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类
如父类public String m1(){} 和 子类public String m1(){} —— 子类的返回类型和父类返回类型一样🆗
如父类public Object m1(){} 和 子类public String m1(){} —— 子类的返回类型是父类返回类型的子类🆗
-
子类方法不能缩小父类方法的访问权限
父类是void sayOK() 子类是public void sayOK() —— 子类并没有缩小父类的访问权限🆗
父类是void sayOK() 子类是private void sayOK() —— 子类缩小父类的访问权限⛔️
5.3.2 方法重写override 和 方法重载OverLoad的比较
| 名称 | 发生范围 | 方法名 | 形参列表 | 返回类型 | 修饰符 |
|---|---|---|---|---|---|
| 重载overload | 本类 | 必须一样 | 类型、个数、顺序至少有一个不同 | 无要求 | 无要求 |
| 重写override | 父子类 | 必须一样 | 相同 | 子类重写的方法 返回的类型和父类返回的类型一致，或者是其子类 | 子类方法不能缩小父类方法的访问范围 |
5.4 多态 polymorphic
提高代码复用性
5.4.1 多态的定义
方法或对象具有多种形态，是面向对象的第三大特征，多态是建立在封装和继承基础上的。
5.4.2 方法的多态
方法的重写和重载就体现多态
package com.hspedu.poly_;
public class PloyMethod {
public static void main(String[] args) {
//【1】方法重载体现多态
A a = new A();
//这里我们传入不同的参数，就会调用不同 sum 方法，就体现多态
System.out.println(a.sum(10, 20));
System.out.println(a.sum(10, 20, 30));
//【2】方法重写体现多态
B b = new B();
a.say();
b.say();
}
}
class B { //父类
public void say() {
System.out.println("B say() 方法被调用...");
}
}
class A extends B {//子类
public int sum(int n1, int n2){//和下面 sum 构成重载
return n1 + n2;
}
public int sum(int n1, int n2, int n3){
return n1 + n2 + n3;
}
public void say() {
System.out.println("A say() 方法被调用...");
}
}
5.4.3 对象的多态
举个例子来说，假设有一个父类Animal和一个子类 Dog，并且有一个变量 Animal animal = new Dog()。在编译时，编译器会将变量 animal 的编译时类型确定为 Animal，因为它是通过 Animal 类型声明的。但是在运行时，实际引用的对象是Dog类型的，所以它的运行时类型是 Dog。这意味着在编译时，只能使用Animal类型的方法和操作，但在运行时，可以使用Dog类型的方法和操作。
总结起来，编译类型是在编译阶段确定的静态类型，而运行类型是在程序运行时确定的实际类型。
🔴核心【重要】
-
一个对象的编译类型和运行类型可以不一致
Animal animal = new Dog()：Dog类是Animal类的子类，可以把一个子类对象赋给父类的对象引用，即**🔴可以用一个父类的引用 指向 子类的一个对象**。【animal编译类型是Animal，运行类型是Dog】Animal animal = new Animal()：【编译类型和运行类型当然也可以一致】 -
编译类型在定义对象的时候就确定了，不能改变
Animal animal = new Dog()：【编译类型Animal在定义对象的时候就确定了，不能改变】 -
运行类型可以变化
animal = new Cat()【animal的运行类型就变成了Cat，编译类型仍然是Animal】 -
编译类型看定义时候的**=号的左边**，运行类型看定义时候的**=号的右边**
public class PolyObject {
public static void main(String[] args) {
// 体验对象多态的特点
// animal 编译类型确定为Animal ，可以指向Animal所有的子类对象，运行类型就是Dog
Animal animal = new Dog();
animal.cry(); // 运行时，在执行到该行时，animal的运行类型是Dog，所以cry就是Dog的cry
// animal 编译类型确定为Animal，可以指向Animal所有的子类对象，运行类型是Cat
animal = new Cat();
animal.cry(); // 运行时，在执行到该行时，animal的运行类型是Cat，所以cry就是Cat的cry
}
}
输出：
>>>Dog cry() 小狗汪汪叫
>>>Cat cry() 小猫喵喵叫
🔴多态的细节 （向上转型&向下转型）
-
多态的前提
两个对象（类）存在继承关系；
-
多态的向上转型
-
本质：父类的引用指向了子类的对象!!!
-
语法：
父类类型 引用名 = new 子类类型( ) -
可以调用父类的所有成员（需要遵守访问权限，比如父类里面有个private方法，那照样是调用不了的）
-
不能调用子类中特有成员
因为在编译阶段，能调用哪些成员[属性&方法]，是由编译类型 [也就是父类类型] 来决定的，所以找不到子类中的特有方法
-
最终的运行效果看的是子类的具体实现，即调用方法时从子类开始查找方法然后调用。
比如父类Animal里有eat方法，子类Dog里也有eat方法，那么使用Animal animal = new Dog（），animal.eat() 优先调用的是子类的eat方法
🖐🖐🖐 编译阶段看父类有没有这个方法，运行阶段从子类看，子类没有向上找父类 \textcolor{red}{编译阶段看父类有没有这个方法，运行阶段从子类看，子类没有向上找父类} 编译阶段看父类有没有这个方法，运行阶段从子类看，子类没有向上找父类
-
-
多态的向下转型
- 本质：将父类引用强制转化为子类引用
- 语法：
子类类型 引用名 = (子类类型) 父类引用 - 只能强转父类的引用，不能强转父类的对象【对象是改变不了的哦，创建出来是什么就是什么】
- 要求父类的引用必须指向的是当前目标类型的对象
- 当向下转型后，就可以调用子类类型中的所有成员[属性&方法]
-
🖐🖐🖐** 属性没有重写之说，属性的值直接看编译类型即可 \textcolor{red}{属性没有重写之说，属性的值直接看编译类型即可} 属性没有重写之说，属性的值直接看编译类型即可*
定义了Animal类，里面有sleep() run() eat() show()方法
定义了Cat类，里面有 eat() 和 catCatch() 方法
public class PolyDetail {
public static void main(String[] args) {
// 【多态的向上转型】父类的引用可以指向子类对象.
// 语法：父类类型 引用名 = new 子类类型( )
Animal animal= new Cat();
// 此时animal的编译类型是Animal 运行类型是Cat
// 可以调用父类的所有成员（遵循访问权限
// 但是不能调用子类的特有成员，catchMouse()
// 最终的运行效果看的是子类的实现 不是父类（这里父类的eat方法就没有被执行
System.out.println(animal.age);
System.out.println(animal.name);
animal.eat(); // 最终的运行效果看的是子类的实现 不是父类（这里父类的eat方法就没有被执行 猫吃鱼
animal.run();
animal.show();
animal.sleep();
// 【多态的向下转型】希望调用Cat的catchMouse方法（子类的特有方法）
// 用法： 子类类型 引用名 = (子类类型) 父类引用
Cat cat = (Cat) animal;
// 此时cat的编译类型是Cat，运行类型是Cat
// 要求父类的引用必须指向的是当前目标类型的对象[也就是要求animal原先指向的就是Cat这个对象]
Dog dog = (Dog) animal; // 不能这样，会报错，因为animal原先指向的是猫，不是狗
cat.catchMouse(); // 这时候就能调用Cat的catchMouse方法
}
}
5.instanceof 比较操作符
instanceof 比较操作符：用于判断对象的运行类型 是否为 ：某某类型 或者某某类型的子类型
public class PolyDetail02 {
public static void main(String[] args) {
BB bb = new BB(); // bb的编译类型是BB，运行类型是BB
System.out.println(bb instanceof BB); // 对象bb的运行类型 为 BB 类型 true
System.out.println(bb instanceof AA); // 对象bb的运行类型 为 BB 类型 true
AA aa = new BB(); // 向上转型：父类的引用指向子类的对象 aa的编译类型是AA，运行类型是BB
System.out.println(aa instanceof AA); // 对象aa的运行类型为BB类型，是AA的子类型 true
System.out.println(aa instanceof BB); // 对象aa的运行类型为BB类型 true
}
}
class AA{} // 父类
class BB extends AA{} // 子类
🔴5.4.4 java的动态绑定机制
0314_韩顺平Java_动态绑定机制_哔哩哔哩_bilibili
- 当调用对象方法的时候，该方法会和该对象的内存地址（也就是运行类型）绑定
- 当调用对象属性的时候，没有动态绑定机制，哪里声明，哪里实用
【说白了调用方法就看最开始的运行类型】
5.4.5 多态的应用
1.多态数组
数组的定义类型为父类类型，里面保存的实际元素类型为子类类型
// 要求创建一个Person对象，2个student对象，2个Teacher对象，统一放在一个数组中，并调用每个对象的say方法
创建了Person类，Student类，Teacher类，都包含say()方法，Student有特有方法study()，Teacher有特有方法teach()。
public class PolyArray {
public static void main(String[] args) {
Person[] person = new Person[5];
// 父类的引用可以指向子类的对象
person[0] = new Person("jack",20);
person[1] = new Student("jack",18,100);
person[2] = new Student("smith",20,60);
person[3] = new Teacher("scott",30, 25000);
person[4] = new Teacher("king",50, 55000);
// 循环遍历多态数组，调用say()
for(int i = 0; i < 5; i++){
System.out.println(person[i].say());
// 动态绑定机制，person[i]的运行类型是变化的，根据实际情况由JVM判断，编译类型就是Person
// person[0]的运行类型是Person，所以调用say()方法的时候调用的是Person类的say()
// person[1]的运行类型是Student，所以调用say()方法的时候调用的是Student类的say()
// 要调用子类的特有方法
// 先用instanceof判断对象的运行类型是否为某某类型或者某某类型的子类型
if(person[i] instanceof Student){
((Student) person[i]).study();
// 向下转型，判断确认当前person[i]的运行类型是Student类型之后，
// 强转person类型为Student类型，再就可以调用Student类独有的study()方法了
} else if (person[i] instanceof Teacher){
((Teacher) person[i]).teach();
} else {
System.out.println("类型有误请自己检测");
}
}
}
}
2.多态参数
🔺 方法定义的形参类型为父类类型，实参类型允许为子类类型
public class PloyParameter {
public static void main(String[] args) {
// 创建不同的对象
Employee dagou = new Employee(333, "dagou");
Worker xiaoming = new Worker(300, "xiaoming");
// xiaoming对象的编译类型是Worker 运行类型是Worker
Manager ppp = new Manager(1000, "ppp",100);
// 创建PloyParameter类的对象并调用后面写的showEmpAnnual()方法
PloyParameter ployParameter = new PloyParameter();
// 传入的xiaoming的运行类型是Worker，因此调用方法时该方法会和Worker类型绑定
ployParameter.showEmpAnnual(xiaoming);
ployParameter.testWork(xiaoming);
ployParameter.testWork(ppp);
}
// showEmpAnnual()方法 【形参为父类类型，传入的实参是子类类型】————实现获取任何员工对象的年工资
public void showEmpAnnual(Employee e){
System.out.println(e.getAnnual()); // 【动态绑定机制】，该方法会和Worker类型绑定
}
// testWork()方法，如果是普通员工就调用work方法，如果是经理就调用manage方法【即要调用子类的特有方法】
public void testWork(Employee e){
if(e instanceof Worker){
((Worker) e).work(); // 【向下转型】
} else if (e instanceof Manager){
((Manager) e).manage(); // 【向下转型】
}
}
}
5.4.6 Object类（根类）详解
因为Object类是所有类的根类，所以其他的类都可以使用Object中的方法
【1】equals()方法 ： 判断引用类型是否相等
❓== 和 equals方法的对比：
==：是一个比较运算符，既可以判断基本类型（值是否相等），又可以判断引用类型（地址是否相等，即判断是否指向同一个对象）
equals：是Object类中的一个方法，只能判断引用类型（数组、类、字符串巴拉巴拉）。默认是判断两个对象的地址是否相等，但是在子类（比如String、Integer）中往往重写该方法以判断内容是否相等。
a .重写equals()方法举例
package com.hspedu.object_;
import com.sun.org.apache.xpath.internal.functions.FuncFalse;
public class EqualsExercise {
public static void main(String[] args) {
Person person1 = new Person("lmx", 12, '男'); // 新建Person1对象
Person person2 = new Person("lmx", 12, '男'); // 新建Person2对象
System.out.println(person1 == person2); // false
System.out.println(person1.equals(person2)); // 重写equals后为true
// 没有重写equals方法之前，Object类的equals方法默认是比较两个对象是否是一个对象, 所以返回false
}
}
class Person{ // 默认继承了Object类，所以可以使用Object类的方法
private String name;
private int age;
private char gender;
public Person(String name, int age, char gender) { // 构造器
this.name = name;
this.age = age;
this.gender = gender;
}
@Override // 【在子类Person中重写Object的equals方法】
public boolean equals(Object obj) {
// 判断如果比较的两个对象是同一个对象，则直接返回true
if(this == obj) return true;
// 类型判断:类型是Person才比较
if(obj instanceof Person){
// 进行类型转化 向下转型: 因为需要得到obj的各个属性，不然拿不到属性(private)
Person p = (Person) obj;
return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
}
// 如果不是Person对象 则直接返回false
return false;
}
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 char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
}
b .重写equals()方法分析案例
【2】hashCode()方法：返回对象的哈希码值，为了提高哈希表的性能
a.hashCode()方法小结
- 提高具有哈希结构的容器的效率；
- 两个引用，如果指向的是同一个对象，则哈希值肯定一样；
- 两个引用，如果指向的是不同的对象，则哈希值一定不一样；
- 哈希值根据地址号来，因此不能完全将哈希值等价于地址；
- hashCode需要的话也会重写。
b.hashCode()方法举例
public class hashCode_ {
public static void main(String[] args) {
AAA aaa = new AAA();
AAA aaa1 = new AAA();
AAA aaa2 = aaa;
AAA aaa3 = new BBB();
System.out.println(aaa.hashCode()); //1163157884
System.out.println(aaa1.hashCode());//1956725890
System.out.println(aaa2.hashCode());//1163157884
System.out.println(aaa3.hashCode());//356573597
}
}
class AAA{}
class BBB extends AAA{}
【3】toString() 方法：返回对象的字符串表示
当使用System.out.println()打印一个对象时，它会自动调用对象的toString()方法来获取字符串表示形式，并将其打印到控制台上。因此，我们可以直接使用System.out.println(person)来打印对象的字符串表示形式，而不需要显式地调用toString()方法。
a. 默认返回：
全类名 + @ + 哈希值的十六进制，（其中全类名 = （包名+类名））
package com.hspedu.object_;
public class ToString_ {
public static void main(String[] args) {
Monster monster = new Monster("小妖怪", "巡山", 1000);
System.out.println(monster.toString()); // 默认调用父类Object的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;
}
}
>>>输出： com.hspedu.object_.Monster@4554617c
b. 重写toString()：打印对象或拼接对象的属性
使用alt+insert —— toString
package com.hspedu.object_;
public class ToString_ {
public static void main(String[] args) {
Monster monster = new Monster("小妖怪", "巡山", 1000);
System.out.println(monster.toString()); // 默认调用父类Object的toString 方法
// System.out.println(monster); 也是一样的哦，sout会自动调用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 // 重写Object中的toString方法，默认是去输出对象属性值
public String toString() {
return "Monster{" +
"name='" + name + '\'' +
", job='" + job + '\'' +
", salary=" + salary +
'}';
}
}
>>>输出：Monster{name='小妖怪', job='巡山', salary=1000.0}
c.直接输出一个对象的时候，toString()方法会被默认调用
比如输出一个对象System.out.println(monster) >>> toString方法会被默认调用 monster.toString（）
【4】finalize()方法：当垃圾回收器确定不存在该对象的更多引用时，由对象的垃圾回收器调用此方法
- 什么时候被回收：当某个对象没有任何引用时，则 jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用 该对象的finalize() 方法。
- 如果程序员不重写finalize()方法，那么就会调用Object类的finalize() 方法，即默认处理。
- 如果程序员在子类重写finalize() 方法，可以去做一些释放资源的操作。
使用alt+insert —— finalize - 垃圾回收机制的调用，是由系统来决定(即有自己的 GC垃圾回收算法)，也可以通过 System.gc() 主动触发垃圾回收机制（主动调用垃圾回收器）
- 提示： 我们在实际开发中，几乎不会运用 finalize() , 所以更多就是为了应付面试
零钱通OOP小项目
package com.smallchange;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
/**
* 完成各个功能的类
* 使用OOP方法
* 将各个功能对应一个方法
*/
public class SmallChangeSysOOP {
// 属性
boolean loop = true;
Scanner scanner = new Scanner(System.in);
String key = "";
String details = "=============零钱通明细===============";
double money = 0;
double balance = 0;
Date date = null;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm"); // 用于日期格式化
String note = "";
// 完成显示菜单，并可以选择
public void mainMenu(){
do { // do-while 知至少执行一次
System.out.println("\n\n=========菜单==========");
System.out.println("\t\t\t1. 明细");
System.out.println("\t\t\t2. 收益入账");
System.out.println("\t\t\t3. 消费");
System.out.println("\t\t\t4. 退 出");
System.out.println("请选择1-4？");
key = scanner.next();
//使用switch分支结构
switch (key) {
case "1":
this.detail();
break;
case "2":
this.income();
break;
case "3":
this.pay();
break;
case "4":
this.exit();
break;
default:
System.out.println("菜单选择错误，请重新选择");
}
} while (loop);
System.out.println("退出了这个项目");
}
// 完成零钱通明细
public void detail(){
System.out.println(details);
}
// 收益入账
public void income(){
System.out.println("收益入账金额为：");
money = scanner.nextDouble();
// money 的值范围校验
if(money<=0) {
System.out.println("收益金额不正确请重新输入");
return; // 退出方法 不在执行
}
balance += money;
date = new Date(); // 获取当前的日期,并格式化时间
details += "\n收益入账\t" + money + "\t" + sdf.format(date) + "\t余额：" + balance; // 更新收益信息加在detail后面
return;
}
public void pay(){
System.out.println("输入消费金额");
money = scanner.nextDouble();
// 消费范围校验
if(money<=0 || money > balance) {
System.out.println("消费金额不正确请重新输入");
return;
}
System.out.println("输入消费说明");
note = scanner.next();
balance -= money;
date = new Date(); // 获取当前的日期,并格式化时间
details += "\n\t" + note + "\t-" + money + "\t" + sdf.format(date) + "\t余额：" + balance; // 更新消费信息加在detail后面
return;
}
public void exit(){
String choice;
do{
System.out.println("你要退出吗？？？？？ 输入y或n");
choice = scanner.next();
} while (!(choice.equals("y")) && !(choice.equals("n")));
if(choice.equals("y")){
loop = false; // 就退出全部的程序
return;
} else {
return;
}
}
}
package com.smallchange;
// OOP方法 完成测试 创建SmallChangeSysOOP对象，调用相关方法，完成功能
public class SmallChangeSysApp {
public static void main(String[] args) {
SmallChangeSysOOP smallChangeSysOOP = new SmallChangeSysOOP();
smallChangeSysOOP.mainMenu();
}
}
return 如何在退出方法后也退出外层循环
其他
Arrays.sort(arr)数组排序从小到大- Debug断点调试的时候，是以对象的运行类型来执行的
- F7 ：Step into 跳入方法
- Shift F8 ：Step out 跳出方法
- F9：resume 运行到下一个断点
扫一扫
830
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
