引用andy222241的回答：
import java.util.Date;
/**
* 存钱帐号
* @author Jason
*
*/
public class Account
{
private int id;
/**
* 余额
*/
private double balance=0;
/**
* 利息
*/
private double annualInterestRate=0;
/**
* 账户开户日期
*/
private Date dataCreated;
public Account()
{
super();
this.dataCreated=new Date();
}
public Account(int id, double balance)
{
super();
this.id = id;
this.balance = balance;
this.dataCreated=new Date();
}
public int getId()
{
return id;
}
public void setId(int id)
{
this.id = id;
}
public double getBalance()
{
return balance;
}
public void setBalance(double balance)
{
this.balance = balance;
}
public double getAnnualInterestRate()
{
return annualInterestRate;
}
public Date getDataCreated()
{
return dataCreated;
}
public void setAnnualInterestRate(double annualInterestRate)
{
this.annualInterestRate = annualInterestRate;
}
/**
* 月利息--假设利息为年利息的话
* @return
* @throws Exception
*/
public double getMinthlyInterestRate() throws Exception
{
if(this.annualInterestRate==0)
{
throw new Exception("还没设置利息呢");
}else {
return annualInterestRate/12;
}
}
/**
* 取钱
* @throws Exception
*/
public void withDraw(double MoneyNum) throws Exception
{
if(MoneyNum>this.balance)
{
throw new Exception("没那么多钱");
}else
{
this.balance-=MoneyNum;
}
}
/**
* 存钱
* @param MoneyNum
*/
public void deposit(double MoneyNum)
{
this.balance+=MoneyNum;
}
/**
* 测试
* @throws Exception
*/
public static void  main(String[] args) throws Exception
{
Account myAccount=new Account(1122, 20000);
myAccount.setAnnualInterestRate(4.5/100);
myAccount.withDraw(2500);
myAccount.deposit(3000);
System.out.println("余额："+myAccount.getBalance());
System.out.println("月利息："+myAccount.getMinthlyInterestRate());
System.out.println("开户日期："+myAccount.getDataCreated());
}
}
这全是java基础啊，要好好学习啊，我是看着着100分太诱人了，哈哈
展开全部
要输出取款后余额和存款后余额该怎么改啊急用啊谢谢谢谢
已赞过
已踩过<
你对这个回答的评价是？
评论
收起

一，编程的一般思路

1，ooa:面向对象分析

2，ood:面向对象设计

3，oop:面向对象编程

4，测试

5，项目交接，给客户演示，演示完了项目就上线运行，运行期间有bug就项目升级（后期维护）----是收钱的哦

二，如何在java中创建一个类？定义属性，方法，以及实例化一个对象并调用类里面的内容？

方法：1：无进无出：没有返回值，没有参数传

2：无进有出：没有返回值，有参数

3：有进无出：有返回值，没有参数

4：有进有出 ：有返回值，有参数

三，方法重载：就是方法名相同,方法参数的个数和类型不同,通过个数和类型的不同来区分不同的函数。Java的重载是发生在本类中的,重载的条件实在本类中有多个方法名相同,但参数列表不同

###同一个类中，方法名相同，参数列表不同（1：参数个数不同2：参数类型不同3：参数顺序不同），切记：跟返回值类型无关，跟修饰符无关（public就是一个修饰符）

他们两个就构成了方法重载：：：：



思考：一个类中为什么要定义那么多的同名方法呢（方法重载）？

原因是每个方法的具体实现有差异，我们不能以偏概全

四，全局变量和局部变量

全局变量都是有默认值，而且在类的任何地方都可以使用，说白了就是定义在方法之外的变量

###8种基本数据类型的默认值



局部变量:定义在方法中，形参上，或者是一个块中，局部变量的作用域是从它的括号（{}）开始到结束.

###形参:　在方法被调用时用于接受外界输入的数据;（方法中的参数）

###实参: 　     调用方法时外界传给方法的数据;
注意：局部变量是没有默认值的，在你使用之前必须给它赋值
五，this关键字

（）

1:代表当前类对象

2：区分同名属性和局部变量

####当全局变量和局部变量重名时，在方法中使用this时，表示的是该方法所在类中的全局变量



3：调用本类中重载的构造器，谁调用它，它就是谁这个this必须写在构造器的第一句


六，构造器：构造方法，构造函数.

类在构建对象的时候系统会默认的去那个构造器，如果类中你自己没有定义构造器，系统会自动帮你生成一个无参构造器 。

构造器的作用是：1，初始化对象（给属性赋值）构造器也能重载

2.构造代码块，代码块  { }

构造代码块是在实例化对象的时候优先于构造器先执行的

构造代码块的作用：是给对象的共性赋值，比如张三爱吃米饭，李四爱吃米饭，王五也爱吃，所有人都爱吃米饭，所以用构造代码块给共性赋值

###我在百度上搜了一点：



七，引起类的加载方式

注意：实例变量（普通属性）隶属于构造代码块—就是谁在前面谁先执行

###实例变量（全局变量）：独立于方法之外的变量，不过没有 static 修饰。
String str="hello world"; // 实例变量

1：实例化对象，new的时候
int s=new ...

2：调用类里面的静态属性或静态方法

3：Class.forName(); 加载驱动（反射机制）

八，Static关键字

1：修饰属性

属性就是静态属性（类属性，类属性就是该属性是属于类的，不属于对象的），可以直接通过类名访问，所以实际共享该类属性
2：修饰方法

该方法可以直接被类名调用注意：静态方法中不能使用非静态属性静态方法中不能使用this和	super关键字



3：修饰代码块

{}静态代码块是最先执行的，在整个程序运行期间只执行一次，用于数据库连接
static{} 

4：静态导入
 import static java.lang.System.out;

就是输出时不再输System.；直接out.println();

九，8种基本数据类型对应的封装类


学习这8个封装类主要学习它里面的api

8种基本数据类型和8种对应的封装类可以自动转换，这8种封装类里面用的最多的一个api就是将字符串转成数字

注意：char不能进行字符串转数字

boolean只有字符串是ture的时候才转ture,其他都是false



十，内存分配

Java中内存分为5个

1：栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中）

2：堆：存放所有new出来的对象。

3：常量存储区：存放常量

4：静态存储区:存放静态成员（static定义的）

5：方法区

==是用来判断地址

栈和堆的区别：栈中的数据大小和生命周期是可以确定的，当没有引用指向数据时，这个数据就会消失。堆中的对象的由垃圾回收器负责回收

栈的优势是，存取速度比堆要快

作者说：

实验用到了数组和循环，这个实验主要是练习构造方法和自定义方法，以及类的设计，属性等等。

一、实验要求



二、运行效果截图





三、代码示例

EmployLeetest类：

public class EmployLeetest {
    public static void main(String[] args) {
        Employlee em=new Employlee();
        em.sign();
        em.output();
    }
}

Employlee类：

import java.util.Scanner;

public class Employlee {
    private String[] id=new String[100];
    private String[] name=new String[100];
    private String[] age=new String[100];
    private String[] job=new String[100];
    public String[] department=new String[100];
    public int attendnum=0;

    public Employlee(){}//构造方法。

    public void output(){//输出信息的方法。
        System.out.println("出勤总人数为："+attendnum);
        for(int i=0;i<attendnum;i++){
            System.out.println("第"+(i+1)+"个人:");
            System.out.println("编号:"+id[i]);
            System.out.println("姓名:"+name[i]);
            System.out.println("年龄:"+age[i]);
            System.out.println("职务:"+job[i]);
            System.out.println("部门:"+department[i]);
            System.out.println();
        }
    }

    public void sign(){//签到方法。
        Scanner data=new Scanner(System.in);
        System.out.println("开始签到！请输入相关信息！");
        for(int i=0;i<100;i++){
            System.out.print("请输入你的编号：");
            id[i]=data.next();
            System.out.print("请输入你的姓名：");
            name[i]=data.next();
            System.out.print("请输入你的年龄：");
            age[i]=data.next();
            System.out.print("请输入你的职务：");
            job[i]=data.next();
            System.out.print("请输入你的部门：");
            department[i]=data.next();
            attendnum++;
            System.out.println();
            System.out.println("输入-999结束签到，输入其他字符则继续签到~");
            int over=data.nextInt();
            if(over==-999) {
                System.out.println("签到结束！");
                System.out.println();
                System.out.println("签到情况为：");
                break;
            }
        }
    }

}

 

思考题：设计一个只能创建一个唯一实例的类。


有很多地方需要用到只能创建一个实例的类，比如说窗口上的工具箱，如果每次点击工具箱按钮都会创建一个工具箱实例，那么窗口中会出现很多工具箱，但是我们想要的是点击工具箱如果没有就出现，有了就不再出现了，这就需要用到单例模式。


文章内容取自《大话设计模式》 程杰著
单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点。


通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象。一个最好的方法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。
Singleton类，定义一个GetInstance操作，允许客户访问它的唯一实例。GetInstance是一个静态方法，主要负责创建自己的唯一实例




单例模式因为singleton 类封装它的唯一实例，这样它就可以严格地控制客户怎样访问它以及何时访问它。简单地说就是对唯一实例的受控访问。