Java-面向对象2-银行账户系统

最新推荐文章于 2024-03-15 22:14:09 发布
最新推荐文章于 2024-03-15 22:14:09 发布
阅读量1k 收藏 10
点赞数 3
分类专栏： Java 文章标签： java 开发语言
原文链接：https://blog.csdn.net/m0_46153949/article/details/105655318
版权

面向对象特征之一：封装与隐藏

1、封装性的引入与体现：
为什么需要封装？封装的作用和含义？
我要用洗衣机，只需要按一下开关和洗涤模式就可以了。没有有必要了解洗衣机内部的结构。没有必要碰电动机。
2、我们程序设计追求“高内聚，低耦合”。

  • 高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
  • 低耦合：仅对外暴露少量的方法用于使用。

3、隐藏对象内部的复杂性，只对外公开简单的接口。
便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

一、问题的引入：
当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。但除此之外，没有其他制约条件。但是，实际问题中，我们往往需要给属性赋值加入额外限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行条件的添加。比如说，setLegs，同时，我们需要避免用户再使用“对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的(private)。此时，针对于属性就体现了封装性。
二、封装性的体现：
我们将类的属性私有化(private),同时,提供公共的(public)方法来获取(getXxx)和设置(setXxx)
拓展：封装性的体现：① 如上 ② 单例模式 ③ 不对外暴露的私有方法

public class AnimalTest {

	public static void main(String[] args) {
		Animal a = new Animal();
		a.name = "大黄";
//		a.age = 1;
//		a.legs = 4;//The field Animal.legs is not visible
		
		a.show();
		
//		a.legs = -4;
//		a.setLegs(6);
		a.setLegs(-6);
		
//		a.legs = -4;//The field Animal.legs is not visible
		a.show();
		
		System.out.println(a.name);
		System.out.println(a.getLegs());
	}
}
class Animal{
	
	String name;
	private int age;
	private int legs; //腿的个数
	
	//对于属性的设置
	public void setLegs(int l){
		if(l >= 0 && l % 2 == 0){
			legs = l;
		}else{
			legs = 0;
		}
	}
	
	//对于属性的获取
	public int getLegs(){
		return legs;
	}
	
	public void eat(){
		System.out.println("动物进食");
	}
	
	public void show(){
		System.out.println("name = " + name + ",age = " + age + ",legs = " + legs);
	}
	
	//提供关于属性 age 的 get 和 set 方法
	public int getAge(){
		return age;
	}
	
	public void setAge(int a){
		age = a;
	}
}

结果：

name = 大黄,age = 0,legs = 0
name = 大黄,age = 0,legs = 0
大黄
0

四种权限修饰符的理解与测试

Java 权限修饰符public、protected、default(缺省)、private 置于类的成员定义前，用来限定对象对该类成员的访问权限。请添加图片描述

对于 class 的权限修饰只可以用 public 和 default(缺省)。

  • public 类可以在任意地方被访问。
  • default （缺省）类只可以被同一个包内部的类访问。

Order 类

封装性的体现，需要权限修饰符来配合。

  • Java 规定的 4 种权限：(从小到大排序)private、缺省、protected、public。
  • 4 种权限用来修饰类及类的内部结构：属性、方法、构造器、内部类。
  • 具体的，4 种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类修饰类的话，只能使用：缺省、public总结封装性：Java 提供了 4 中权限修饰符来修饰类积累的内部结构，体现类及类的内部结构的可见性的方法。
public class Order {

	private int orderPrivate;
	int orderDefault;
	public int orderPublic;
	
	private void methodPrivate(){
		orderPrivate = 1;
		orderDefault = 2;
		orderPublic = 3;
	}
	
	void methodDefault(){
		orderPrivate = 1;
		orderDefault = 2;
		orderPublic = 3;
	}
	
	public void methodPublic(){
		orderPrivate = 1;
		orderDefault = 2;
		orderPublic = 3;
	}
}

测试类：

public class OrderTest {

	public static void main(String[] args) {
		
		Order order = new Order();
		
		order.orderDefault = 1;
		order.orderPublic = 2;
		//出了 Order 类之后，私有的结构就不可调用了
//		order.orderPrivate = 3;//The field Order.orderPrivate is not visible
		
		order.methodDefault();
		order.methodPublic();
		//出了 Order 类之后，私有的结构就不可调用了
//		order.methodPrivate();//The method methodPrivate() from the type Order is not visible
	}
}

他们在在同一个package的状态：
在这里插入图片描述

封装性的练习

请添加图片描述
1.创建程序,在其中定义两个类：Person 和 PersonTest 类。定义如下：用 setAge()设置人的合法年龄(0~130)，用 getAge()返回人的年龄。

public class Person {

	private int age;
	
	public void setAge(int a){
		if(a < 0 || a > 130){
//			throw new RuntimeException("传入的数据据非法");
			System.out.println("传入的数据据非法");
			return;
		}
		
		age = a;
		
	}
	
	public int getAge(){
		return age;
	}
	
	//绝对不能这样写！！！
	//public int doAge(int a){
		//age = a;
		//return age;
	}
}

测试类：

public class PersonTest {

	public static void main(String[] args) {
		Person p1 = new Person();
//		p1.age = 1;	//编译不通过
		
		p1.setAge(12);
		
		System.out.println("年龄为:" + p1.getAge());
	}
}

构造器(构造方法)

构造器的理解：类的结构之三:构造器(构造方法、constructor)的使用

一、构造器的作用:
1.创建对象
2.初始化对象的属性

二、说明
1.如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器。
2.定义构造器的格式: 权限修饰符 类名(形参列表) { }
3.一个类中定义的多个构造器，彼此构成重载。
4.一旦显示的定义了类的构造器之后，系统不再提供默认的空参构造器。
5.一个类中，至少会有一个构造器。

public class PersonTest {

	public static void main(String[] args) {
		//创建类的对象:new + 构造器
		Person p = new Person();	//Person()这就是构造器
		
		p.eat();
		
		Person p1 = new Person("Tom");
		System.out.println(p1.name);
	}
}
class Person{
	//属性
	String name;
	int age;
	
	//构造器
	public Person(){
		System.out.println("Person()......");
	}
	
	public Person(String n){
		name = n;
	}
	
	public Person(String n,int a){
		name = n;
		age = a;
	}
	
	//方法
	public void eat(){
		System.out.println("人吃饭");
	}
	
	public void study(){
		System.out.println("人学习");
	}
}

练习1

在前面定义的 Person 类中添加构造器，利用构造器设置所有人的 age 属性初始值都为 18。

public class Person {

	private int age;
	
	public Person(){
		age = 18;
	}
}

public class PersonTest {

	public static void main(String[] args) {
		Person p1 = new Person();

		System.out.println("年龄为:" + p1.getAge());
	}
}

public class Person {

	private int age;
	
	public Person(){
		age = 18;
	}
}

public class PersonTest {

	public static void main(String[] args) {
		Person p1 = new Person();

		System.out.println("年龄为:" + p1.getAge());
	}
}

练习2

/* 3.修改上题中类和构造器，增加 name 属性,
 *   使得每次创建 Person 对象的同时初始化对象的 age 属性值和 name 属性值。
 */
public class Person {

	private int age;
	private String name;
	
	public Person(){
		age = 18;
	}
	
	public Person(String n,int a){
		name = n;
		age = a;
	}
	
	public void setName(String n){
		name = n;
	}
	
	public String getName(){
		return name;
	}
	
	public void setAge(int a){
		if(a < 0 || a > 130){
//			throw new RuntimeException("传入的数据据非法");
			System.out.println("传入的数据据非法");
			return;
		}
		
		age = a;
		
	}
	
	public int getAge(){
		return age;
	}
}

public class PersonTest {

	public static void main(String[] args) {
		
		Person p2 = new Person("Tom",21);
		
		System.out.println("name = " + p2.getName() + ",age = " + p2.getAge());
	}
}

JavaBean

JavaBean 是一种 Java 语言写成的可重用组件。
  所谓 javaBean，是指符合如下标准的 Java 类：
  		> 类是公共的
  		> 有一个无参的公共的构造器
  		> 有属性，且有对应的 get、set 方法

UML 类图

请添加图片描述

关键字this 调用属性、方法、构造器

1.this 用来修饰、调用：属性、方法、构造器

2.this 修饰属性和方法:
this 理解为：当前对象,或当前正在创建的对象。

2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性和方法。
通常情况下，我们都选择省略“this.”。特殊情况下，如果方法的形参和类的属性同名，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用正在创建的对象属性和方法。但是，通常情况下，我们都选择省略“this.”。特殊情况下，如果构造器的形参和类的属性同名，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

3.this 调用构造器
① 我们可以在类的构造器中，显式的使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！
② 构造器中不能通过"this(形参列表)“的方式调用自己。
③ 如果一个类中声明了n个构造器，则最多有n -1个构造器中使用了"this(形参列表)”。
④ "this(形参列表)“必须声明在类的构造器的首行！
⑤ 在类的一个构造器中，最多只能声明一个"this(形参列表)”。

public class PersonTest {

	public static void main(String[] args) {
		Person p1 = new Person();
		
		p1.setAge(1);
		System.out.println(p1.getAge());
		
		p1.eat();
		System.out.println();
		
		Person p2 = new Person("jerry" ,20);
		System.out.println(p2.getAge());
	}
}
class Person{
	
	private String name;
	private int age;
	
	public Person(){
		this.eat();
		String info = "Person 初始化时，需要考虑如下的 1,2,3,4...(共 40 行代码)";
		System.out.println(info);
	}
	
	public Person(String name){
		this();
		this.name = name;
	}
	
	public Person(int age){
		this();
		this.age = age;
	}
	
	public Person(String name,int age){
		this(age);	//调用构造器的一种方式
		this.name = name;
//		this.age = age;
	}
	
	public void setNmea(String name){
		this.name = name;
	}
	
	public String getName(){
		return this.name;
	}
	
	public void setAge(int age){
		this.age = age;
	}
	
	public int getAge(){
		return this.age;
	}
	
	public void eat(){
		System.out.println("人吃饭");
		this.study();
	}
	
	public void study(){
		System.out.println("学习");
	}
}

银行账户系统

Account 类

public class Account {

	private double balance; //余额

	public double getBalance() {
		return balance;
	}

	public Account(double init_balance){
		this.balance = init_balance;
	}
	
	//存钱操作
	public void deposit(double amt){
		if(amt > 0){
			balance += amt;
			System.out.println("存钱成功");
		}
	}
	
	//取钱操作
	public void withdraw(double amt){
		if(balance >= amt){
			balance -= amt;
			System.out.println("取钱成功");
		}else{
			System.out.println("余额不足");
		}
	}
}

Customer 类

public class Customer {

	private String firstName;
	private String lastName;
	private Account account;
	
	public String getFirstName() {
		return firstName;
	}
	public String getLastName() {
		return lastName;
	}
	public Account getAccount() {
		return account;
	}
	public void setAccount(Account account) {
		this.account = account;
	}
	public Customer(String f, String l) {
		this.firstName = f;
		this.lastName = l;
	}	
}

Bank 类

public class Bank {

	private int numberOfCustomers;	//记录客户的个数
	private Customer[] customers;	//存放多个客户的数组
	
	public Bank(){
		customers = new Customer[10];
	}
	
	//添加客户
	public void addCustomer(String f,String l){
		Customer cust = new Customer(f,l);
//		customers[numberOfCustomers] = cust;
//		numberOfCustomers++;
		customers[numberOfCustomers++] = cust;
	}

	//获取客户的个数
	public int getNumberOfCustomers() {
		return numberOfCustomers;
	}

	//获取指定位置上的客户
	public Customer getCustomers(int index) {
//		return customers;	//可能报异常
		if(index >= 0 && index < numberOfCustomers){
			return customers[index];
		}
		
		return null;
	}	
	
}

BankTest 类

public class BankTest {

	public static void main(String[] args) {
		
		Bank bank = new Bank();
		
		bank.addCustomer("Jane", "Smith");	
		
		bank.getCustomers(0).setAccount(new Account(2000));
		
		bank.getCustomers(0).getAccount().withdraw(500);
		
		double balance = bank.getCustomers(0).getAccount().getBalance();
		
		System.out.println("客户: " + bank.getCustomers(0).getFirstName() + "的账户余额为：" + balance);
		
		System.out.println("***************************");
		bank.addCustomer("万里", "杨");
		
		System.out.println("银行客户的个数为: " + bank.getNumberOfCustomers());
		
	}
}

它们在包中的状态：
在这里插入图片描述

关键字—package

一、package 关键字的使用
1.为了更好的实现项目中类的管理，提供包的概念
2.使用 package 声明类或接口所属的包，声明在源文件的首行
3.包，属于标识符，遵循标识符的命名规则、规范"见名知意"
4.每“.”一次,就代表一层文件目录。

补充:同一个包下，不能命名同名接口或同名类
不同包下，可以命名同名的接口、类。

JDK 中主要的包介绍

1.java.lang----包含一些 Java 语言的核心类，如 String、Math、Integer、System 和 Thread，提供常用功能
2.java.net----包含执行与网络相关的操作的类和接口。
3.java.io----包含能提供多种输入/输出功能的类。
4.java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
5.java.text----包含了一些 java 格式化相关的类
6.java.sql----包含了 java 进行 JDBC 数据库编程的相关类/接口
7.java.awt----包含了构成抽象窗口工具集（abstractwindowtoolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。B/S  C/S

MVC 设计模式

MVC 是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，数据模型层。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。
请添加图片描述
请添加图片描述

关键字—import

1.在源文件中显式的使用import结构导入指定包下的类、接口
2.声明在包的声明和类的声明之间
3.如果需要导入多个结构，则并列写出即可
4.可以使用"xxx.*"的方式,表示可以导入xxx包下的所有结构。
5.如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
6.如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。
7.如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
8.import static组合的使用：调用指定类或接口下的静态的属性或方法.

Asura_____
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA银行账户
12-16
期末做的一个java银行账户管理，代码简单适合初学者学习，不做使用。连接SQL2005 需要者就下载吧！
Java学习路线：day10 面向对象(上)3
杨丙寅
04-21 1614
文章目录第四章 面向对象(上)4.6 面向对象特征之一：封装与隐藏四种权限修饰符的理解与测试封装性的练习4.7 构造器(构造方法)构造器的理解总结属性赋值的过程JavaBean 的使用UML 类图(`了解！！！`)4.8 关键字：this 的使用this 调用属性、方法、构造器this 的练习实验1：Account_Customer.pdf实验2：Account_Cust...Bank.pdf4....
利用Java建立一个银行账户类
最新发布
LIx1022的博客
03-15 851
包含存款、取款、查询余额等操作。用此类创建对象，对象1的账号为100，姓名为Tom、密码。利用Java建立一个银行账户类，能够存放用户的账号、姓名、密码和账户余额等个人信息。为11111，账户余额为10000。进行存钱、取钱、查信息操作。
Java面向对象——银行业务调度系统
新长城
03-24 1264
银行业务调度系统 模拟实现银行业务调度系统逻辑，具体需求如下： ●       银行内有6个业务窗口，1 - 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。 ●       有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。 ●       异步随机生成各种类型的客户，生成各类型用户的概率比例为： ●
使用Java编写银行账户类（面向对象思考实验）
qq_51868285的博客
11-27 5257
银行账户类(Accoount)可以为账户存储交易。取款和存款都会产生交易信息。需要记录账户每次交易（Transaction）的信息，包括取钱还是存钱，交易的金额，交易时间和交易之后的余额。系统可以通过账户查询所有的交易次数(最多10次)。 问题一：为了实现此功能需要设计几个类？ 答：两个类，Account类和Transaction类。 问题二：请写出你的设计的类的代码（先画UML图在展示代码）。 UML图： Account类： Transaction类： 注意： 两者之间为单项关联 代码如下： Acco
java开发面向对象（银行小项目）
08-16
银行项目: 要求： 1：新建一个DataBase类来模拟数据库; 2: 用相应类型的数组来模拟数据库的表,存储数据; 3：银行系统有登录、注册、存钱、取钱等功能; 4：要有删除、修改用户信息等功能; 目的： 1：熟悉使用数组模拟数据库进行增、删、改、查的操作； 2：熟悉类的写法及自定义类作为另一个类的属性的写法； 3：熟悉方法的调用，及避免属性空指针操作； 4：熟悉项目流程控制操作；为阶段考核的预演； 有两个角色，用户和管理员 用户有存钱，取钱，修改密码的功能，管理员有开户，删除账户，查询账户的功能。纯java代码，没有数据库，针对于初学者，希望大家多提提意见
Java面向对象编程经典实例-银行账户
08-08
Java面向对象编程经典实例-银行账户 Eclipse下的一个完整的工程
java银行笔试题-tdd-bank-account-java:TD-银行账户-java
06-13
开出银行账户 这个会议会很有趣。 这是主要目标，玩得开心和编码。 就是这样！ 在本次会议中，我们将讨论为什么 XP 实践很重要，然后我们可以编写一些代码来练习两个最基本的实践。 代码将非常简单，这不是编写复杂...
银行账户管理系统 java课程设计 流程图
01-09
编辑一个银行账户管理程序。通过此次课程设计，来巩固所学Java语言基本知识，加深对循环语句、选择语句的熟练程度，以及对面向对象、继承的理解等。掌握JDK、JCreator等开发工具的运用，拓宽常用类库的应用。
CST8132-Assignment-3:CST8132“面向对象编程”中的作业 #3 - 银行账户对账程序
06-09
该程序用 Java 编写，对一个人的银行账户进行核对（根据银行账户跟踪每笔交易）。 它允许借记（取款）和贷记（存款）以及每笔交易的类别和日期（最多 1000）。 该计划从银行账户中的 100 美元开始。 由于每笔交易都...
java银行账户管理系统
05-11
支持管理员登录，存款，取款，注册账户，注销账户，转账操作，利息计算以及退出系统操作。
JAVA实现银行账户类
04-19
一个实现银行账户类的非常简单的小程序，主要能实现信息录入以及存取款，实现不了太强大的程序，嘿嘿，实验过程中做出来的，放心下载……
java 银行账户
11-06
编写一个类实现银行账户，包括的属性有“账号”、“储户姓名”、“地址”、“存款余额”，包括的方法有“存款”、“取款”、“查询”、“计算利息”、“累加利息”等。 增加类的一个静态属性“最小余额”和一个用来修改这个最小余额属性的方法。 设计类的一个静态属性“活期利息”和封装这个数据的相应方法。
银行账户管理系统（java程序编写）
06-03
账户管理系统，银行的atm机使用的微型管理系统模拟
BankSystem_java系统_面向对象_BankSystem_银行_java上机实验_
09-30
简易模拟银行系统，要求：有开户（储蓄、信用）、存款提款、打印明细、检查溢出报错等功能。文件列表：BankAccount.javaBankSystem.javaCashAccount.javaCheckingAccount.javaCreditAccount.javaCustomer.java
银行账户管理系统-java开发
03-08
这是一个银行账户管理系统,用户可以通过ATM终端界面来操作自己的银行账户.
java---面向对象 7 （银行、客户、账户）
m0_64819500的博客
08-07 139
java---面向对象 7 （银行、客户、账户）
java实验作业：银行账户
ImagineForever的博客
04-29 1831
关于大学实验课作业的分享，包含一些自己额外添加的想法
面向对象银行管理系统JAVA代码 上
qq_44231628的博客
01-26 1109
面向对象银行管理系统JAVA代码 上
银行账户管理━面向对象java实验中遇到的具体问题及解决方法
05-11
在银行账户管理的面向对象Java实验中，可能会遇到以下问题： 1. 如何设计银行账户类？ 解决方法：首先需要考虑银行账户类的属性和方法，例如账户号、账户余额、账户类型、存款、取款等。然后根据这些属性和方法，设计一个合理的银行账户类。 2. 如何实现账户的存款和取款？ 解决方法：可以在银行账户类中定义存款和取款的方法，通过这些方法来实现账户的存款和取款操作。在存款和取款方法中，需要考虑账户余额是否充足，如果余额不足则不能进行取款操作。 3. 如何实现账户的利息计算？ 解决方法：可以在银行账户类中定义一个计算利息的方法，根据账户类型和账户余额来计算利息金额。 4. 如何实现多个账户的管理？ 解决方法：可以在银行类中定义一个账户列表，用于存储所有的账户对象。然后在银行类中定义账户管理的方法，例如开户、销户、查询账户信息等。 5. 如何进行数据的持久化？ 解决方法：可以使用文件或数据库来进行数据的持久化。在银行类中定义读写文件或数据库的方法，用于保存和读取账户信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值