• Java实验三：面向对象(二)

    目录

    1.设计一个抽象类图形类 

    2.定义一个抽象接口，该接口用于求和与统计数量 

    3.定义一个抽象类动物类，同时定义其行为的抽象接口

    4.编写一个类，实现银行账户

    1.设计一个抽象类图形类 

    设计一个抽象类图形类，在该类中包含有至少三个抽象方法，分别用于求周长、求面积，以及对图形进行描述（如，“这是**形状，周长是**，面积是**”），分别定义圆形类、长方形类、等边三角形类来继承图形类，实现上述三个方法，并创建实例验证。

    抽象类

    1. package task.task;
    2.  
    3. public abstract class Graphical {
    4.     public abstract void area();//面积
    5.     public abstract void perimeter();//周长
    6.     public abstract void describe();//对图形的描述
    7. }

    圆形类 

    1. package task.task;
    2.  
    3. /**
    4.  * 圆形
    5.  */
    6. public class Circular extends Graphical {
    7.  
    8.     public static final double Π = 3.14;
    9.  
    10.     public int r;//半径
    11.     public String name;//形状
    12.     public double area;//面积
    13.     public double perimeter;//周长
    14.  
    15.     public Circular(int r, String name) {
    16.         this.r = r;
    17.         this.name = name;
    18.     }
    19.  
    20.     @Override
    21.     public void area() {
    22.         this.area = Π*r*r;
    23.         System.out.println("半径为" + r + "的圆的面积为" + area);
    24.     }
    25.  
    26.     @Override
    27.     public void perimeter() {
    28.         this.perimeter = Π*(2 * r);
    29.         System.out.println("半径为" + r + "的圆的周长为" + perimeter);
    30.     }
    31.  
    32.     @Override
    33.     public void describe() {
    34.         System.out.println("这是" + name + "形状,"+ "周长是" + area + ",面积是" + perimeter);
    35.     }
    36.  
    37.     /**
    38.      * 测试方法
    39.      */
    40.     public static void main(String[] args) {
    41.         Circular c = new Circular(4,"圆形");
    42.         c.area();
    43.         c.perimeter();
    44.         c.describe();
    45.     }
    46. }

     

    长方形类 

    1. package tsak1;
    2.  
    3. /**
    4.  * 长方形类
    5.  */
    6. public class Rectangle extends Graphical {
    7.  
    8.     public String name = "长方形";
    9.     public int length;//长
    10.     public int wide;//宽
    11.     public int area;//面积
    12.     public int perimeter;//周长
    13.  
    14.     public Rectangle(int length, int wide) {
    15.         this.length = length;
    16.         this.wide = wide;
    17.     }
    18.  
    19.     @Override
    20.     public void area() {
    21.         this.area = length * wide;
    22.         System.out.println("长为" + length + "宽为" + wide + "的长方形的面积为" + area);
    23.     }
    24.  
    25.     @Override
    26.     public void perimeter() {
    27.         this.perimeter = (length + wide) * 2;
    28.         System.out.println("长为" + length + "宽为" + wide + "的长方形的周长为" + perimeter);
    29.     }
    30.  
    31.     @Override
    32.     public void describe() {
    33.         System.out.println("这是" + name + "形状,"+ "周长是" + perimeter + ",面积是" + area);
    34.     }
    35.  
    36.     public static void main(String[] args) {
    37.         Rectangle r = new Rectangle(5,2);
    38.         r.area();
    39.         r.perimeter();
    40.         r.describe();
    41.     }
    42. }

    等边三角形类 

    1. package tsak1;
    2.  
    3. /**
    4.  * 等边三角形类
    5.  */
    6. public class Triangle extends Graphical {
    7.  
    8.     public static final double SIN60 = 0.87;//取sin60°的近似值
    9.     public String name = "等边三角形";
    10.     public int sideLength;//边长
    11.     public int perimeter;//周长
    12.     public double area;//面积
    13.  
    14.     public Triangle(int sideLength) {
    15.         this.sideLength = sideLength;
    16.     }
    17.  
    18.     @Override
    19.     public void area() {
    20.         area = 0.5 * sideLength * sideLength * SIN60;
    21.         System.out.println("边长为" + sideLength + "的等边三角形形的面积为" + area);
    22.     }
    23.  
    24.     @Override
    25.     public void perimeter() {
    26.         perimeter = 3 * sideLength;
    27.         System.out.println("边长为" + sideLength + "的等边三角形形的周长为" + perimeter);
    28.     }
    29.  
    30.     @Override
    31.     public void describe() {
    32.         System.out.println("这是" + name + "形状,"+ "周长是" + perimeter + ",面积是" + area);
    33.     }
    34.  
    35.     public static void main(String[] args) {
    36.         Triangle t = new Triangle(2);
    37.         t.area();
    38.         t.perimeter();
    39.         t.describe();
    40.     }
    41. }

    2.定义一个抽象接口，该接口用于求和与统计数量 

    定义一个抽象接口，该接口用于求和与统计数量。定义两个奇数类与偶数类实现上述接口，分别可以求100以内的奇数的和，统计100以内的奇数个数，以及求100以内的偶数的和，统计100以内的偶数个数。

    抽象接口

    1. package task2;
    2.  
    3. /**
    4.  * 接口类
    5.  */
    6. public interface SumCount {
    7.     public static final int RANGE = 100;//直接在接口中初始化要求的范围
    8.     public abstract void sumAndCount();
    9. }

    偶数类 

    1. package task2;
    2.  
    3. /**
    4.  * 偶数类
    5.  */
    6. public class EvenNum implements SumCount {
    7.     private int evenCount;//偶数个数
    8.     private int evenSum;//偶数和
    9.  
    10.     @Override
    11.     public void sumAndCount() {
    12.         for (int i = 1; i <= RANGE; i++) {
    13.             if(i % 2 == 0) {
    14.                 evenCount++;
    15.                 evenSum += i;
    16.             }
    17.         }
    18.         System.out.println("100以内的偶数的和为" + evenSum + "，100以内的偶数个数为" + evenCount);
    19.     }
    20. }

    奇数类 

    1. package task2;
    2.  
    3. /**
    4.  * 奇数类
    5.  */
    6. public class OddNum implements SumCount {
    7.     private int oddCount = 0;//奇数个数
    8.     private int oddSum = 0;//奇数和
    9.  
    10.     @Override
    11.     public void sumAndCount() {
    12.         for (int i = 1; i <= RANGE; i++) {
    13.             if(i % 2 != 0) {
    14.                 oddCount++;
    15.                 oddSum += i;
    16.             }
    17.         }
    18.         System.out.println("100以内的奇数的和为" + oddSum + "，100以内的奇数个数为" + oddCount);
    19.     }
    20. }

    测试类 

    1. package task2;
    2.  
    3. public class Test {
    4.     public static void main(String[] args) {
    5.         //初始化偶数类，调用偶数类求和求个数
    6.         EvenNum e = new EvenNum();
    7.         e.sumAndCount();
    8.         //初始化奇数类，调用奇数类求和求个数
    9.         OddNum o = new OddNum();
    10.         o.sumAndCount();
    11.     }
    12. }

    3.定义一个抽象类动物类，同时定义其行为的抽象接口

    定义一个抽象类动物类，同时定义抽象接口：进食接口、睡觉接口、思考接口、说话接口、行走接口、游泳接口、飞翔的接口。分别定义猫类、人类、鸟类、鱼类继承动物类，同时，根据实际情况，选择性实现上述接口，并创建实例验证

    文件布局 

    抽象动物类

    为其设置姓名和年龄两个共有属性

    1. package task1.abstractcalss;
    2.  
    3. public abstract class Animal {
    4.     public String name;
    5.     public int age;
    6. }

    接口 

    · 进食接口

    1. package task1.myinterface;
    2.  
    3. /**
    4.  * 进食接口
    5.  */
    6. public interface IEating {
    7.     void eat();
    8. }

    · 飞行接口 

    1. package task1.myinterface;
    2.  
    3. /**
    4.  * 飞行接口
    5.  */
    6. public interface IFlying {
    7.     void fly();
    8. }

    · 睡觉接口 

    1. package task1.myinterface;
    2.  
    3. /**
    4.  * 睡觉接口
    5.  */
    6. public interface ISleeping {
    7.     void sleep();
    8. }

    · 讲话接口 

    1. package task1.myinterface;
    2.  
    3. /**
    4.  * 讲话接口
    5.  */
    6. public interface ISpeaking {
    7.     void speak();
    8. }

    · 游泳接口 

    1. package task1.myinterface;
    2.  
    3. /**
    4.  * 游泳接口
    5.  */
    6. public interface ISwimming {
    7.     void swim();
    8. }

    · 思考接口 

    1. package task1.myinterface;
    2.  
    3. /**
    4.  * 思考接口
    5.  */
    6. public interface IThinking {
    7.     void think();
    8. }

    · 行走接口 

    1. package task1.myinterface;
    2.  
    3. /**
    4.  * 行走接口
    5.  */
    6. public interface IWalking {
    7.     void walk();
    8. }

    实现类 

    · Bird类 

    1. package task1.inheritance;
    2.  
    3. import task1.abstractcalss.Animal;
    4. import task1.myinterface.*;
    5.  
    6. public class Bird extends Animal implements IEating, IFlying, ISleeping, ISpeaking {
    7.  
    8.     public Bird(String name, int age) {
    9.         super.age = age;
    10.         super.name = name;
    11.     }
    12.  
    13.     @Override
    14.     public void printfInfo() {
    15.         System.out.println("这是" + super.name + "，年龄为" + super.age + "岁");
    16.     }
    17.  
    18.     @Override
    19.     public void eat() {
    20.         System.out.println(super.name + "正在吃饭");
    21.     }
    22.  
    23.     @Override
    24.     public void fly() {
    25.         System.out.println(super.name + "正在飞行");
    26.     }
    27.  
    28.     @Override
    29.     public void sleep() {
    30.         System.out.println(super.name + "正在睡觉");
    31.     }
    32.  
    33.     @Override
    34.     public void speak() {
    35.         System.out.println(super.name + "吱吱吱");
    36.     }
    37.  
    38.     public static void main(String[] args) {
    39.         Bird bird = new Bird("布谷鸟", 4);
    40.         bird.printfInfo();
    41.         bird.eat();
    42.         bird.fly();
    43.         bird.sleep();
    44.         bird.speak();
    45.     }
    46. }

    · Cat类 

    1. package task1.inheritance;
    2.  
    3. import task1.abstractcalss.Animal;
    4. import task1.myinterface.*;
    5.  
    6. public class Cat extends Animal implements IEating, ISleeping, ISpeaking, IWalking {
    7.  
    8.     public Cat(String name, int age) {
    9.         super.age = age;
    10.         super.name = name;
    11.     }
    12.  
    13.     @Override
    14.     public void printfInfo() {
    15.         System.out.println("这是" + super.name + "，年龄为" + super.age + "岁");
    16.     }
    17.  
    18.     @Override
    19.     public void eat() {
    20.         System.out.println(super.name + "正在吃饭");
    21.     }
    22.  
    23.     @Override
    24.     public void sleep() {
    25.         System.out.println(super.name + "正在睡觉");
    26.     }
    27.  
    28.     @Override
    29.     public void speak() {
    30.         System.out.println(super.name + "喵喵喵");
    31.     }
    32.  
    33.     @Override
    34.     public void walk() {
    35.         System.out.println(super.name + "在跑步");
    36.     }
    37.  
    38.     public static void main(String[] args) {
    39.         Cat cat = new Cat("波斯猫", 3);
    40.         cat.printfInfo();
    41.         cat.eat();
    42.         cat.sleep();
    43.         cat.walk();
    44.         cat.speak();
    45.     }
    46.  
    47. }

    · Fish类 

    1. package task1.inheritance;
    2.  
    3. import task1.abstractcalss.Animal;
    4. import task1.myinterface.*;
    5.  
    6. public class Fish extends Animal implements IEating, ISleeping, ISwimming {
    7.  
    8.     public Fish(String name, int age) {
    9.         super.age = age;
    10.         super.name = name;
    11.     }
    12.     @Override
    13.     public void printfInfo() {
    14.         System.out.println("这是" + super.name + "，年龄为" + super.age + "岁");
    15.     }
    16.  
    17.     @Override
    18.     public void eat() {
    19.         System.out.println(super.name + "正在吃饭");
    20.     }
    21.  
    22.     @Override
    23.     public void sleep() {
    24.         System.out.println(super.name + "正在睡觉");
    25.     }
    26.  
    27.     @Override
    28.     public void swim() {
    29.         System.out.println(super.name + "正在游泳");
    30.     }
    31.  
    32.     public static void main(String[] args) {
    33.         Bird bird = new Bird("鲤鱼", 4);
    34.         bird.printfInfo();
    35.         bird.speak();
    36.         bird.sleep();
    37.         bird.eat();
    38.     }
    39. }

    · Person类 

    1. package task1.inheritance;
    2.  
    3. import task1.abstractcalss.Animal;
    4. import task1.myinterface.*;
    5.  
    6. public class Person extends Animal implements IEating, ISpeaking, ISleeping, IThinking, IWalking,ISwimming {
    7.  
    8.     public Person(String name, int age) {
    9.         super.name = name;
    10.         super.age = age;
    11.     }
    12.  
    13.     @Override
    14.     public void printfInfo() {
    15.         System.out.println("这是" + super.name + "，年龄为" + super.age + "岁");
    16.     }
    17.  
    18.     @Override
    19.     public void eat() {
    20.         System.out.println(super.name + "正在吃饭");
    21.     }
    22.  
    23.     @Override
    24.     public void sleep() {
    25.         System.out.println(super.name + "正在睡觉");
    26.     }
    27.  
    28.     @Override
    29.     public void speak() {
    30.         System.out.println(super.name + "说我爱学Java");
    31.     }
    32.  
    33.     @Override
    34.     public void swim() {
    35.         System.out.println(super.name + "在游泳");
    36.     }
    37.  
    38.     @Override
    39.     public void think() {
    40.         System.out.println(super.name + "在思考");
    41.     }
    42.  
    43.     @Override
    44.     public void walk() {
    45.         System.out.println(super.name + "在跑步");
    46.     }
    47.  
    48.     public static void main(String[] args) {
    49.         Person person = new Person("张三", 18);
    50.         person.printfInfo();
    51.         person.eat();
    52.         person.sleep();
    53.         person.speak();
    54.         person.swim();
    55.         person.think();
    56.         person.walk();
    57.     }
    58. }

     

    4.编写一个类，实现银行账户

    编写一个类，实现银行账户，并完成程序的测试：

    · 设置的属性有“账号”、 “储户姓名”、“地址”以及“存款余额”；

    · 设置的方法有“存款”、“取款”、“查询”、“计算利息”、“累加利息”；

    · 给类增加一个静态属性“最小余额”和一个用来修改这个最小余额属性的方法；

    · 给类增加一个静态属性“活期利息”和封装这个数据的对应方法；

    ①设置的属性有“账号”、 “储户姓名”、“地址”以及“存款余额”

    根据实验要求，定义出三个变量账号、姓名、地址、存款余额，定义为public共有属性，账号也定义为String类型变量.

    ②定义活期利率

    public static final double RATE = 0.0035;//定义活期利率

    ③ 设置的方法有“存款”、“取款”、“查询”、“计算利息”、“累加利息”

      

    首先定义出四个方法，①存款的实现即传入要存的金额，直接用当前余额加上存入余额即可； ②取款的实现即传入要取的金额，用当前余额减去取款金额即可；③计算利息为活期利率，根据存入的时间来计算利率；④累加利息，假如当前存入了一年，一年结束后又存了一年，则根据第一年结束后的余额来计算第二年的利息，再累加两年的利息.

    ④给类增加一个静态属性“最小余额”和一个用来修改这个最小余额属性的方法

    增加了最小余额后，在取出金额的时候利用最小余额对其进行约束：如果取出后余额小于最小余额则不允许取出 

     ⑤给类增加一个静态属性“活期利息”和封装这个数据的对应方法

    完整代码 

    1. package task2;
    2.  
    3. public class Account {
    4.  
    5.     public static final double RATE = 0.0035;//定义活期利率
    6.  
    7.     public String username;//账号
    8.     public String name;//储户姓名
    9.     public String address;//地址
    10.     public double money;//存款
    11.     public double interest;//利息
    12.     public double allInterest;//累加利息
    13.  
    14.     public Account(String username, String name, String address, double money) {
    15.         this.username = username;
    16.         this.name = name;
    17.         this.address = address;
    18.         this.money = money;
    19.     }
    20.  
    21.     private static double minimumBalance = 2000;//最小余额
    22.     private static double currentInterest;//活期利息
    23.  
    24.     //获得封装的最小余额数据
    25.     public  double getMinimumBalance() {
    26.         return minimumBalance;
    27.     }
    28.     //修改封装的最小余额数据
    29.     public void setMinimumBalance(double minimumBalance) {
    30.         Account.minimumBalance = minimumBalance;
    31.     }
    32.     //获得封装的活期利息
    33.     public double getCurrentInterest() {
    34.         return currentInterest;
    35.     }
    36.     //修改封装的活期利息
    37.     public  void setCurrentInterest(double currentInterest) {
    38.         Account.currentInterest = currentInterest;
    39.     }
    40.  
    41.     //存款
    42.     public void deposit(double money) {
    43.             this.money += money;
    44.             System.out.println("成功存入" + money + "rmb，当前余额为: " + this.money + "rmb");
    45.     }
    46.     //取款
    47.     public void withdraw(double money) {
    48.         if((this.money-money) < minimumBalance) {
    49.             System.out.println("取出后余额小于最小余额" + minimumBalance + "rmb，取款失败");
    50.         }else {
    51.             this.money -= money;
    52.             System.out.println("成功取出" + money + "rmb，当前余额为: " + this.money + "rmb");
    53.         }
    54.     }
    55.     //计算利息
    56.     public void calculateInterest(int year) {
    57.         this.interest = money * year * RATE;
    58.         //计算完利息后加入余额
    59.         this.money += interest;
    60.         System.out.println("当前余额为: " + this.money + "rmb，存入" + year + "年可以获得利息: " + this.interest + "rmb");
    61.     }
    62.     //累加利息
    63.     public void accumulatedInterest() {
    64.         this.allInterest += interest;
    65.         System.out.println("目前累加利息为: " + this.allInterest + "rmb");
    66.     }
    67.  
    68. }

    测试代码 

    1. package task2;
    2.  
    3. public class TestAccount {
    4.     public static void main(String[] args) {
    5.         Account account = new Account("62456", "张三", "陕西西安", 4000);//需要保证初始余额大于最小余额
    6.         //模拟存款
    7.         account.deposit(100000);
    8.         //模拟取款
    9.         account.withdraw(4000);
    10.         //计算利息(存入五年)
    11.         account.calculateInterest(5);
    12.         account.accumulatedInterest();
    13.         //再次计算利息，存入三年
    14.         account.calculateInterest(3);
    15.         account.accumulatedInterest();
    16.  
    17.         //测试活期利息
    18.         //获得当前活期利息
    19.         System.out.println("当前活期利息为: " + account.getCurrentInterest() + "rmb");
    20.         //修改当前活期利息
    21.         account.setCurrentInterest(6000);
    22.         //显示当前活期利息
    23.         System.out.println("当前活期利息为: " + account.getCurrentInterest() + "rmb");
    24.     }
    25. }

     

  • 相关阅读:
    银行ATM系统
    【C++】二叉搜索树
    第5章 插叙：进程API
    采用一种估值方法，自动化评估某个股票价格合理性
    Java并发(一)----进程、线程、并行、并发
    这几个音乐伴奏提取的方法快码住了
    java培训之SpringMVC提示消息的国际化
    LoveCount统计“爱”——Scala-Spark实战应用案例
    Java集合大总结——Iterator(迭代器)接口
    C++ 语法基础课 习题4 —— 数组
  • 原文地址：https://blog.csdn.net/qq_58284486/article/details/125438706