javase重点作业之面向对象
OOP
- 设计一个词典类Dic，每个单词包括英文单词及对应的中文含义，并有一个英汉翻译成员函数，通过查词典的方式将一段英语翻译成对应的汉语。
思路： 字典项类DicItem包括EngLish(英语单词)、Chinese(对应中文含义)数据成员，字典类包括一个字典项类的列表，包含Add()(添加单词)和trans(英汉翻译)成员函数。
源代码：package 接口与抽象类;
class Dic
{ fanyi[] arrays=new fanyi[5];//数组初始化
int size=0;
void add(String english ,String chinese)//增加单词
{
int p=chack(english);
if(p!=-1)
{
arrays[p].chinese=chinese;
}else {
resize();
this.arrays[size]=new fanyi(english,chinese);
size++;
}
System.out.println("增加单词："+english+": "+chinese);
}
void tras(String english)//翻译
{ int f=0;
for(int i=0;i<size;i++)
{
if(arrays[i].english.equals(english))
{ f=1;
System.out.println(english+" 意思是："+arrays[i].chinese);
}
}
if(f==0) {
System.out.println("字典中没有此单词！！！");}
}
int chack(String english)//检查单词是否重复
{
int i;
for(i=0;i<this.size;i++)
{
if(arrays[i].english.equals(english))
{
return i;
}
}
return -1;
}
void resize()//扩容
{
if(arrays.length==size)
{
fanyi[] newarrays=new fanyi[arrays.length*3/2+1];
System.arraycopy(arrays, 0, newarrays, 0, size);
arrays=newarrays;
}
}
void show()//打印数组所有成员
{
for(int i=0;i<this.size;i++)
System.out.println(arrays[i].english+" "+arrays[i].chinese);
}
private class fanyi//内部类
{
String english;
String chinese;
public fanyi(String english, String chinese) {
this.english = english;
this.chinese = chinese;
}
}
}
public class 词典 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Dic dic=new Dic();
dic.add("am", "是");
dic.add("facebook", "脸书");
dic.add("book", "书");
dic.add("computer","电脑");
dic.add("computer","电脑");
dic.add("computer","电脑");
dic.add("computer","电脑");
dic.add("computer1","电脑1");
dic.add("computer2","电脑2"); dic.tras("am");
dic.tras("book1");
System.out.println("该词典中所有单词为:");
dic.show();
}
}
运行结果：
- 自已封装一个动态数组类，可以根据用户传递的数据，动态的对数组的长度进行扩展；
类名是:MyArray
方法有：
void add(int value); //追加一个值
vold remove(int index); //根据索引，删除一个值
void add(int position,int value); //在指定位置插入一个数值
void set(int position,int value); //修改某个位置的数值
int get(int index); //根据索引，获得元数的值
int size(); //获得动态数组中元素的个数；
源代码：
package 面向对象;
import java.util.Arrays;
import javax.sound.midi.Synthesizer;
class MyArray
{ int[] a=new int [10];
int size=0;//元素个数
void add(int v)//添加元素
{ resize();//扩容
a[size++]=v;
}
void resize()//扩容
{
if(size==a.length)
{
int[] newa=new int[a.length*3/2+1];
// for(int i=0;i<a.length;i++)
// {
// newa[i]=a[i];
// }
System.arraycopy(a, 0, newa, 0, a.length);
a=newa;
}
}
void add(int index,int v)
{
resize();
System.arraycopy(a, index, a, index+1, this.size-index);
a[index]=v;
size++;
}
void remove(int index)
{
System.arraycopy(a, index+1, a, index, this.size-index-1);
size--;
}
void set(int index,int v)
{
a[index]=v;
}
int get(int index)
{
return a[index];
}
int size()
{
return size;
}
}
public class 动态数组 {
public static void main(String[] args) {
MyArray array=new MyArray();
System.out.println("原始数组为：");
for(int i=0;i<=15;i++)
array.add(i+50);
for(int i=0;i<array.size;i++)
{
System.out.print(array.a[i]+" ");
}
System.out.println("此时数组长度为："+array.size());
System.out.println();
System.out.println("在数组位置0和2插入90和100：");
array.add(0,90);
array.add(2,100);
for(int i=0;i<array.size;i++)
{
System.out.print(array.a[i]+" ");
}
System.out.println("数组的长度为："+array.size());
System.out.println("将数组位置2的值移除后结果为：");
array.remove(2);
for(int i=0;i<array.size;i++)
{
System.out.print(array.a[i]+" ");
}
System.out.println("数组的长度为："+array.size());
System.out.println("将数组位置2的值设置为10000：");
array.set(2,10000);
for(int i=0;i<array.size;i++)
{
System.out.print(array.a[i]+" ");
}
System.out.println("数组的长度为："+array.size());
System.out.println("获取数组位置2的值：");
System.out.println(array.get(2));
}
}
运行结果：
- 编写工资系统，实现不同类型员工(多态)的按月发放工资。如果当月出现某个Employee对象的生日，则将该雇员的工资增加100元。
实验目的：对象、继承、封装、多态、抽象类的组合应用。
实验说明：
（1）定义一个Employee类，该类包含：
private成员变量name,number,birthday，其中birthday 为MyDate类的对象；
abstract方法earnings()；toString()方法输出对象的name,number和birthday。
（2）MyDate类包含:
private成员变量month,day,year；
toDateString()方法返回日期对应的字符串：xxxx年xx月xx日
（3）定义SalariedEmployee类继承Employee类，实现按月计算工资的员工处理。该类包括：
private成员变量monthlySalary；
实现父类的抽象方法earnings(),该方法返回monthlySalary值；toString()方法输出员工类型信息及员工的name，number,birthday。
（4）参照SalariedEmployee类定义HourlyEmployee类，实现按小时计算工资的员工处理。该类包括：
private成员变量wage和hour；
实现父类的抽象方法earnings(),该方法返回wage*hour值；toString()方法输出员工类型信息及员工的name，number,birthday。
（4）定义PayrollSystem类，创建Employee变量数组并初始化，该数组存放各类雇员对象的引用。利用循环结构遍历数组元素，输出各个对象的类型,name,number,birthday,以及该对象生日。当键盘输入本月月份值时，如果本月是某个Employee对象的生日，还要输出增加工资信息。
提示：
//定义People类型的数组
People c1[]=new People[10];
//数组元素赋值
c1[0]=new People("John","0001",20);
c1[1]=new People("Bob","0002",19);
//若People有两个子类Student和Officer，则数组元素赋值时，可以使父类类型的数组元素指向子类。
c1[0]=new Student("John","0001",20,85.0);
c1[1]=new Officer("Bob","0002",19,90.5);
源代码：
package 接口与抽象类;
abstract class Employee
{
private String name;
private String number;
private MyDate birthday;
abstract void earnings(MyDate a) ;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public MyDate getBirthday() {
return birthday;
}
public void setBirthday(MyDate birthday) {
this.birthday = birthday;
}
public Employee(String name, String number, MyDate birthday) {
super();
this.name = name;
this.number = number;
this.birthday = birthday;
}
public void toString1 ()
{
System.out.println("name:"+this.name+"number:"+this.number+birthday.toDateString());
}
}
class MyDate
{
private String month,day,year;
public String getMonth() {
return month;
}
public void setMonth(String month) {
this.month = month;
}
public String getDay() {
return day;
}
public void setDay(String day) {
this.day = day;
}
public String getYear() {
return year;
}
public void setYear(String year) {
this.year = year;
}
public MyDate( String year,String month, String day) {
super();
this.month = month;
this.day = day;
this.year = year;
}
String toDateString()
{
return year+"年"+month+"月"+day+"日";
}
}
class SalariedEmployee extends Employee
{
private int monthlySalary;
public SalariedEmployee(String name, String number, MyDate birthday, int monthlySalary) {
super(name, number, birthday);
this.monthlySalary = monthlySalary;
}
@Override
void earnings(MyDate a) {
// TODO Auto-generated method stub
if(a.getMonth().equals(super.getBirthday().getMonth()))
{
System.out.println("该员工按月结算工资并且今天是她的生日工资增加100："+(monthlySalary+100));
}
else {
System.out.println("该员工按月结算工资为:"+monthlySalary);
}
}
public void toString1 ()
{
System.out.println("按月结算工资 "+"name:"+super.getName()+"number:"+super.getNumber()+" 该员工的的生日是： "+super.getBirthday().toDateString());
}
}
class HourlyEmployee extends Employee
{
public HourlyEmployee(String name, String number, MyDate birthday, int wage, int hour) {
super(name, number, birthday);
this.wage = wage;
this.hour = hour;
}
private int wage,hour;
@Override
void earnings(MyDate a) {
if(a.getMonth().equals(super.getBirthday().getMonth()))
{
System.out.println("该员工是 小时工并且今天是她的生日工资增加100："+(this.wage*this.hour+100));
}
else {
System.out.println("该员是工小时工 工资为:"+this.wage*this.hour);
}
}
public void toString1 ()
{
System.out.println("小时工 "+"name:"+super.getName()+"number:"+super.getNumber()+" 该员工的的生日是： "+super.getBirthday().toDateString());
}
}
public class 工资系统 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Employee[] a=new Employee[3];
System.out.println("今天的日期是2018年8月4日，创建了3个人，李易峰和李荣浩是长工按月结10000工资，张杰为小时工工作了4小时每小时为50，若当月是谁的生日则工资增加100");
MyDate c=new MyDate("2018","8","4");
a[0]=new SalariedEmployee("李易峰", "111",new MyDate("1996","2","19"), 10000);
a[0].toString1();
a[0].earnings(c);
a[1]=new HourlyEmployee("张杰", "222", new MyDate("2008","3","3"), 4, 50);
a[1].toString1();
a[1].earnings(c);
a[2]=new SalariedEmployee("李荣浩", "333",new MyDate("2018","8","4"), 10000);
a[2].toString1();
a[2].earnings(c);
}
}
运行结果：
2、写一个名为Account的类模拟账户。该类的属性和方法如下图所示。该类包括的属性：账号id，余额balance，年利率annualInterestRate；包含的方法：访问器方法（getter和setter方法），取款方法withdraw()，存款方法deposit()。
|
Account |
|
private int id private double balance private double annualInterestRate |
|
public Account (int id, double balance, double annualInterestRate ) |
|
public int getId() public double getBalance() public double getAnnualInterestRate() public void setId( int id) public void setBalance(double balance) public void setAnnualInterestRate(double annualInterestRate) public void withdraw (double amount) public void deposit (double amount) |
提示：在提款方法withdraw中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。
2. 创建Customer类。
|
Customer |
|
private String firstName private String lastName private Account account |
|
public Customer(String f,String l) |
|
public String getFirstName() public String getLastName() public Account getAccount() public void setAccount(Account account) |
a. 声明三个私有对象属性：firstName、lastName和account。
b. 声明一个公有构造器，这个构造器带有两个代表对象属性的参数（f和l）
c. 声明两个公有存取器来访问该对象属性，方法getFirstName和getLastName返回相应的属性。
d. 声明setAccount 方法来对account属性赋值。
e. 声明getAccount 方法以获取account属性。
3.写一个测试程序。
- 创建一个Customer ，名字叫 Jane Smith, 他有一个账号为1000，余额为2000元，年利率为 1.23％ 的账户。
- 对Jane Smith操作。
存入 100 元，再取出960元。再取出2000元。
打印出Jane Smith 的基本信息
成功存入 ：100.0
成功取出：960.0
余额不足，取款失败
Customer [Smith, Jane] has a account: id is 1000, annualInterestRate is 1.23％, balance is 1140.0
源代码：
package 方法与构造方法;
class Account
{ private int id;
private double balance;
private double annualInterestRate;
public Account(int id, double balance, double annualInterestRate) {
super();
this.id = id;
this.balance = balance;
this.annualInterestRate = annualInterestRate;
}
public int getId()
{
return this.id;
}
public double getBalance()
{
return this.balance;
}
public double getAnnualInterestRate()
{
return this.annualInterestRate;
}
public void setId( int id)
{
this.id=id;
}
public void setBalance(double balance)
{
this.balance=balance;
}
public void setAnnualInterestRate(double annualInterestRate)
{
this.annualInterestRate=annualInterestRate;
}
public void withdraw (double amount)
{ if(amount>this.balance)
{
System.out.println("余额不足，取款失败！");
}else {
this.balance-=amount;
System.out.println("成功取出："+amount+"元");
}
}
public void deposit (double amount)
{
this.balance+=amount;
}
}
class Customer
{ private String firstName;
private String lastName;
private Account account;
public Customer(String firstName, String lastName) {
super();
this.firstName = firstName;
this.lastName = lastName;
}
public String getFirstName()
{
return this.firstName;
}
public String getLastName()
{
return this.lastName;
}
public Account getAccount()
{
return this.account;
}
public void setAccount(Account account)
{
this.account=account;
}
}
public class class14 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Customer customer=new Customer("Jane","Smith");
Account account=new Account(1000,2000,0.0123);
customer.setAccount(account);
System.out.println("（1） 创建一个Customer ，名字叫 Jane Smith, 他有一个账号为1000，余额为2000元，年利率为 1.23％ 的账户。");
System.out.println("（2） 对Jane Smith操作。\r\n" +
"存入 100 元，再取出960元。再取出2000元。\r\n" +
"打印出Jane Smith 的基本信息\r\n" +
"");
int a=100;
account.deposit(a);
System.out.println("成功存入 ："+a+"元");
int b=960;
account.withdraw(b);
int c=2000;
account.withdraw(c);
System.out.println("Customer ["+customer.getFirstName()+","+customer.getLastName()+"]"+" has a account: id is "+customer.getAccount().getId()+","+"annualInterestRate is "+account.getAnnualInterestRate()+","+"balance is "+account.getBalance());
}
}
运行结果：