java复习笔记-04

回顾前几次复习，java的主要内容：面向对象思想，java编程语言，jvm和类文件格式，api。面向对象思想主要内容：uml工具（统一建模语言）：针对面向对象思想的图，便于做项目等面向对象思想的程序时交流。类似货币的存在。面向对象的特性：封装，继承，多态。

概念性的东西学的够多了，该来点实际的了。

面向对象的封装：将对象的内容隐藏起来让外界只能通过他的方法才能访问。

这里直接从面向对象过渡到了java编程语言结合到了一起。

user类：

解释：这个类就用了面向对象封装的思想，我们可以注意到类中属性卡号身份证号等前面都用了访问修饰符private。使得这些属性都只能再本类直接访问。外界要使用，就要用到我设置的set/get方法。有了这些方法就可以进行一些安全设置。这些属性就不会轻易被更改。

package homework;
/**
 * @author lh
 *以下是封装的实例：
 *target：实现银行的功能
 *实现银行需要实现的类：用户，账户——类图，对象图
 *功能：银行类要实现的功能-》初始化用户，用户登录，显示菜单，存款，取款，转账，
 *查询余额，修改密码，退出。
 * 用例图，状态图，顺序图，部署图
 * 状态图；
 * 初始化用户
 * 用户登录
 * 显示菜单
 * 存取查改（其实就是数据库的增删改查）
 */
public class User {
	//卡号
	private String cardNo;
	//身份证号
	private String identity;
	//用户名
	private String username;
	//密码
	private String password;
	//电话
	private String phone;
	//余额
	private double balance;
	
	public User() {
		// 构造函数
	}
	
	
	
	public User(String cardNo, String identity, String username, String password, String phone, double balance) {
		super();
		this.cardNo = cardNo;
		this.identity = identity;
		this.username = username;
		this.password = password;
		this.phone = phone;
		this.balance = balance;
	}



	@Override
	public String toString() {
		return "User [cardNo=" + cardNo + ", identity=" + identity + ", username=" + username + ", password=" + password
				+ ", phone=" + phone + ", balance=" + balance + "]";
	}



	public String getCardNo() {
		return cardNo;
	}

	public void setCardNo(String cardNo) {
		this.cardNo = cardNo;
	}

	public String getIdentity() {
		return identity;
	}

	public void setIdentity(String identity) {
		this.identity = identity;
	}

	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 String getPhone() {
		return phone;
	}

	public void setPhone(String phone) {
		this.phone = phone;
	}

	public double getBalance() {
		return balance;
	}

	public void setBalance(double balance) {
		this.balance = balance;
	}
	
	
}

 bank类：

解释：写bank类时，要先初始化数据（这个之后加入数据库了就可以不用了），我可以选择直接写个方法，然后再在主方法里调用，这里直接把他放在构造方法里面了。这样一创建对象这些数据就会直接初始化，这一点涉及到类的周期问题。

package homework;

import java.util.Scanner;

/**
 * 
 * @author Administrator
 *bank要实现的功能初始化，登录，显示菜单，增删改查，退出
 */
public class Bank {
//封装用户user
	private User[] users=new User[5];
	int size=0;//初始化用户数量
	
	public Bank() {
		initial();
	}
	//初始化用户
	public void initial() {
		User u1 = new User();
		u1.setCardNo("73102210294844");
		u1.setIdentity("1");
		u1.setUsername("lh");
		u1.setPassword("123456");
		u1.setPhone("120");
		u1.setBalance(1000);
		
		User u2 = new User("731232032583","2","hao","654321","110",2000);
		
		users[0]=u1;
		users[1]=u2;
		size=2;
		System.out.println("初始化成功");
	}
	//登录功能
	public void login() {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入用户名和密码：");
		String user = sc.next();
		String pad = sc.next();
		for(int i=0;i<size;i++) {
			if(users[i].getUsername().equals(user)&&users[i].getPassword().equals(pad)) {
				//登录成功
				Menu(users[i]);
			}else {//登录失败
				System.out.println("登录失败");
			}
		}
	}
	//显示页面界面
	public void Menu(User u) {
		System.out.println("=====欢迎进入xx银行=="+u.getUsername()+"===");
		do {
			System.out.println("1.存款  2.取款  3.转账  4.查询余额  5.修改密码  6.退出");
			Scanner input = new Scanner(System.in);
			int i = input.nextInt();
			switch (i) {
			case 1:
				deposit(u);
				break;
			case 2:
				withDraw(u);
				break;
			case 3:
				transfer(u);
				break;
			case 4:
				checkMoney(u);
				break;
			case 5:
				changPwd(u);
				break;
			case 6:
				return;
			default:
				break;
			}
		} while (true);
	}
	//存款
	public void deposit(User u) {
		System.out.println("请输入存款金额");
		Scanner sc = new Scanner(System.in);
		double cun = sc.nextDouble();
		if(cun>0) {
			u.setBalance(u.getBalance()+cun);
		}else {
			System.out.println("输入错误");
		}
	}
	
	//取款
	public void withDraw(User u) {
		System.out.println("请输入取款金额");
		Scanner sc = new Scanner(System.in);
		double qu = sc.nextDouble();
		if(qu>0&&u.getBalance()>=qu) {
			u.setBalance(u.getBalance()-qu);
		}else {
			System.out.println("输入错误");
		}

	} 
	
	//转账
	public void transfer(User u) {
		System.out.println("请输入目标账户和转账金额");
		Scanner sc = new Scanner(System.in);
		String card = sc.next();
		double money = sc.nextDouble();
		if(money>0&&u.getBalance()>=money) {
			for(int i=0;i<size;i++) {
				if(users[i].getCardNo()==card) {//当确定了账户存在后
					users[i].setBalance(users[i].getBalance()+money);
					u.setBalance(u.getBalance()-money);
				}
			}
		}
	}
	
	//查询余额
	public void checkMoney(User u) {
		System.out.println("===当前用户"+u.getUsername()+"余额："+u.getBalance());
	}
	
	//修改密码
	public void changPwd(User u) {
		System.out.println("请输入原密码：");
		Scanner sc = new Scanner(System.in);
		String pwd = sc.next();
		if(u.getPassword().equals(pwd)) {
			System.out.println("请输入新密码密码：");
			Scanner sd = new Scanner(System.in);
			String rpwd = sd.next();
			u.setPassword(rpwd);
		}
	}
	
}

 main方法：

package homework;

public class MainFangFa {

	public static void main(String[] args) {
		Bank bank = new Bank();
		bank.login();
	}

}

这个银行系统是网上学到的，目前最显眼的缺陷是退出后就会报错，我后期想完善一下，估计可以涉及到线程问题，比如存钱失败，钱的数值又加了上去这种问题，还有银行系统是不能出错的，应该还有很多值得学习的地方。

继承：父类抽取了子类共同的特征，子类继承他们就拥有了这些成员。但是有部分成员无法被继承=》构造方法（只负责构建本类对象，不可继承），无法访问到的成员（private修饰的属性和方法，父子类不在同一个package中，default修饰的属性和方法）

访问修饰符：

	本类	同包	非同包	其他
private	√	x	x	x
default	√	√	x	x
protected	√	√	√	x
public	√	√	√	√

重写：overrode 子类重写访问修饰符不能比父类更严。什么时候重写？在你觉得父类给的方法功能不够强大。

super：重写后的子类方法属性要用这个词加以区分。当你重写后发现又想用到父类的方法就用这个修饰符。注意super和this关键字必须写在第一行而且两者不能同时出现。

 

在具有继承关系的对象构建时，会先构造该对象的父类对象

 

 

 好处:提高了代码的复用性，又提高了代码的可扩展性。

 多态：父类产生多种子类，子类的多种形态即为多态。概念：父类引用指向子类对象，从而产生多种形态。Animal a=new Dog();

父类引用仅可调用父类所声明的属性和方法，不可调用子类独有的属性和方法。

如果子类中覆盖了父类中的方法，则优先执行覆盖后的方法。

多态的应用

 场景一：使用父类作为方法形参实现多态，使方法参数的类型更为宽泛。

实参和形参：实参就是变量int i=0;形参就是对象dog i =new dog();

场景二：使用父类作为方法返回值实现多态，使方法可以返回不同子类对象。

向上转型和向下转型。向上只能用父类的类型和方法以及子类重写的方法。向下转型记得instanceof判断是否

为想要转换的类型。参数 instanceof 对象