JAVA实现有理数的运算+JAVA中的适配器模式

水深无声 2022-07-28 10:53 173阅读 0赞

题目要求：

设计一个抽象类，声明有关算术运算的方法，并创建四个（或者一个）子类继承该抽象的类，完成进行加、减、乘、除四则运算。

整个题目总共经过了三轮完善，第一发没有利用抽象类，只是简单的实现了基本操作；第二枚用了四个子类去继承这个原有的抽象类，其中就用到了可以骗人的适配器模式，没有实现方法的重写，而是用的方法的重载；第三弹则是用一个子类去继承该抽象类，并重写了其中的抽象方法完成了运算。建议大家直接看第三种！

JAVA中的适配器模式：在学习抽象类的继承和接口的实现时，我们总是要全部重写其中的抽象方法，能不能不这么烦呢，有一种适配器模式，可以巧妙的使用，来达到这个目的。 

  1. Aa.java
  2. package cn.nefu.edu.zhihu;
  4. public interface Aa {
  5.     void a();
  6.     void b();
  8. }
  9. Ab.java
  10. package cn.nefu.edu.zhihu;
  12. public class Ab implements Aa{
  14.     public void a() {
  15.         // TODO Auto-generated method stub
  17.     }
  19.     public void b() {
  20.         // TODO Auto-generated method stub
  22.     }
  24. }
  25. Ac.java
  26. package cn.nefu.edu.zhihu;
  28. public class Ac extends Ab{
  31. }

方法一代码：

  1. Youlishu.java
  2. package cn.nefu.edu.zhihu;
  4. public class Youlishu {
  5.     int fenzi,fenmu;
  6.     Youlishu(){
  8.     }
  9.     Youlishu(int fenzi,int fenmu){
  10.         this.fenzi=fenzi;
  11.         this.fenmu=fenmu;
  12.     }
  14.     int gcd(int x,int y){
  15.         if(y==0)
  16.             return x;
  17.         else
  18.             return gcd(y,x%y);
  19.     }
  21.     int lcm(int x,int y){
  22.         return x*y/gcd(x,y);
  23.     }
  25.     Youlishu add(Youlishu a,Youlishu b){
  26.         Youlishu c=new Youlishu(0,0);
  27.         int d1,d2;
  28.         int lcmm=lcm(a.fenmu,b.fenmu);
  29.         c.fenmu=lcmm;
  30.         d1=lcmm/a.fenmu;
  31.         d2=lcmm/b.fenmu;
  32.         c.fenzi=d1*a.fenzi+d2*b.fenzi;
  33.         int d=gcd(c.fenzi,c.fenmu);
  34.         c.fenzi=c.fenzi/d;
  35.         c.fenmu=c.fenmu/d;
  36.         return c;
  37.     }
  39.     Youlishu sub(Youlishu a,Youlishu b){
  40.         Youlishu c=new Youlishu(0,0);
  41.         int d1,d2;
  42.         int lcmm=lcm(a.fenmu,b.fenmu);
  43.         c.fenmu=lcmm;
  44.         d1=lcmm/a.fenmu;
  45.         d2=lcmm/b.fenmu;
  46.         c.fenzi=d1*a.fenzi-d2*b.fenzi;
  47.         int d=gcd(c.fenzi,c.fenmu);
  48.         c.fenzi=c.fenzi/d;
  49.         c.fenmu=c.fenmu/d;
  50.         return c;
  51.     }
  53.     Youlishu cheng(Youlishu a,Youlishu b){
  54.         Youlishu c=new Youlishu(0,0);
  55.         c.fenzi=a.fenzi*b.fenzi;
  56.         c.fenmu=a.fenmu*b.fenmu;
  57.         int d=gcd(c.fenzi,c.fenmu);
  58.         c.fenzi=c.fenzi/d;
  59.         c.fenmu=c.fenmu/d;
  60.         return c;
  61.     }
  62.     Youlishu chu(Youlishu a,Youlishu b){
  63.         Youlishu c=new Youlishu(0,0);
  64.         c.fenzi=a.fenzi*b.fenmu;
  65.         c.fenmu=a.fenmu*b.fenzi;
  66.         int d=gcd(c.fenzi,c.fenmu);
  67.         c.fenzi=c.fenzi/d;
  68.         c.fenmu=c.fenmu/d;
  69.         return c;
  70.     }
  71.     //getxiaoshu()
  72.     void show(){
  73.         System.out.println(fenzi+"/"+fenmu);
  74.     }
  76. }
  78. Test1.java
  79. package cn.nefu.edu.zhihu;
  81. import java.util.Scanner;
  83. public class test1 {
  86.     public static void main(String[] args) {
  87.         Youlishu a=new Youlishu(2,3);
  88.         Youlishu b=new Youlishu(3,2);
  89.         Youlishu c=new Youlishu(0,0);
  90.         c=c.add(a,b);
  91.         c.show();
  92.         c=c.sub(a,b);
  93.         c.show();
  94.         c=c.cheng(a,b);
  95.         c.show();
  96.         c=c.chu(a,b);
  97.         c.show();
  98.         System.out.println("Please Input Youlishu a and b:");
  99.         Scanner reader=new Scanner(System.in);
  100.         a.fenzi=reader.nextInt();
  101.         a.fenmu=reader.nextInt();
  102.         b.fenzi=reader.nextInt();
  103.         b.fenmu=reader.nextInt();
  104.         c=c.add(a,b);
  105.         c.show();
  106.         c=c.sub(a,b);
  107.         c.show();
  108.         c=c.cheng(a,b);
  109.         c.show();
  110.         c=c.chu(a,b);
  111.         c.show();
  112.     }
  113. }

方法二代码：

  1. Yunsuan.java
  2. package cn.edu.nefu.zhihu;
  4. public abstract class Yunsuan {
  5.     int gcd(int a,int b){
  6.         if(b==0)
  7.             return a;
  8.         else
  9.             return gcd(b,a%b);
  10.     }
  11.     int lcm(int a,int b){
  12.         return a*b/gcd(a,b);
  13.     }
  14.     abstract Object add(Object a,Object b);
  15.     abstract Object sub(Object a,Object b);
  16.     abstract Object multi(Object a,Object b);
  17.     abstract Object divid(Object a,Object b);
  18. }
  19. Yunsuanzi.java
  20. package cn.edu.nefu.zhihu; //适配器模式
  22. public class Yunsuanzi extends Yunsuan{
  24.     @Override
  25.     Object add(Object a, Object b) {
  26.         // TODO Auto-generated method stub
  27.         return null;
  28.     }
  30.     @Override
  31.     Object divid(Object a, Object b) {
  32.         // TODO Auto-generated method stub
  33.         return null;
  34.     }
  36.     @Override
  37.     Object multi(Object a, Object b) {
  38.         // TODO Auto-generated method stub
  39.         return null;
  40.     }
  42.     @Override
  43.     Object sub(Object a, Object b) {
  44.         // TODO Auto-generated method stub
  45.         return null;
  46.     }
  47. }
  48. Add.java
  49. package cn.edu.nefu.zhihu;
  51. public class Add extends Yunsuanzi {
  52.         Object add(Youlishu a,Youlishu b){
  53.             Youlishu c = new Youlishu(0,0);
  54.             int d1,d2;
  55.             int lcmm=lcm(a.fenmu,b.fenmu);
  56.             c.fenmu=lcmm;
  57.             d1=lcmm/a.fenmu;
  58.             d2=lcmm/b.fenmu;
  59.             c.fenzi=d1*a.fenzi+d2*b.fenzi;
  60.             int d=gcd(c.fenzi,c.fenmu);
  61.             c.fenzi=c.fenzi/d;
  62.             c.fenmu=c.fenmu/d;
  63.             return c;
  64.         }
  65. }
  66. Sub.java
  67. package cn.edu.nefu.zhihu;
  69. public class Sub extends Yunsuanzi{
  70.     Object sub(Youlishu a,Youlishu b){  //注意：方法的重载，不是重写
  71.         Youlishu c=new Youlishu(0,0);
  72.         int d1,d2;
  73.         int lcmm=lcm(a.fenmu,b.fenmu);
  74.         c.fenmu=lcmm;
  75.         d1=lcmm/a.fenmu;
  76.         d2=lcmm/b.fenmu;
  77.         c.fenzi=d1*a.fenzi-d2*b.fenzi;
  78.         int d=gcd(c.fenzi,c.fenmu);
  79.         c.fenzi=c.fenzi/d;
  80.         c.fenmu=c.fenmu/d;
  81.         return c;
  82.     }
  83. }
  84. Multi.java
  85. package cn.edu.nefu.zhihu;
  87. public class Multi extends Yunsuanzi {
  88.     Object multi(Youlishu a,Youlishu b){
  89.         Youlishu c=new Youlishu(0,0);
  90.         c.fenzi=a.fenzi*b.fenzi;
  91.         c.fenmu=a.fenmu*b.fenmu;
  92.         int d=gcd(c.fenzi,c.fenmu);
  93.         c.fenzi=c.fenzi/d;
  94.         c.fenmu=c.fenmu/d;
  95.         return c;
  96.     }
  97. }
  98. Divid.java
  99. package cn.edu.nefu.zhihu;
  101. public class Divid extends Yunsuanzi{
  102.      Object divid(Youlishu a,Youlishu b){
  103.         Youlishu c=new Youlishu(0,0);
  104.         c.fenzi=a.fenzi*b.fenmu;
  105.         c.fenmu=a.fenmu*b.fenzi;
  106.         int d=gcd(c.fenzi,c.fenmu);
  107.         c.fenzi=c.fenzi/d;
  108.         c.fenmu=c.fenmu/d;
  109.         return c;
  110.     }
  111. }
  112. Youlishu.java
  113. package cn.edu.nefu.zhihu;
  115. public class Youlishu extends Object{
  116.     int fenzi,fenmu;
  117.     Youlishu(){
  119.     }
  120.     Youlishu(int fenzi,int fenmu){
  121.         this.fenzi=fenzi;
  122.         this.fenmu=fenmu;
  123.     }
  124.     void show(){
  125.         System.out.println(fenzi+"/"+fenmu);
  126.     }
  127. }
  128. Test.java
  129. package cn.edu.nefu.zhihu;
  130. import java.util.Scanner;
  131. public class test {
  133.     public static void main(String[] args){
  134.         Scanner reader=new Scanner(System.in);
  135.         int x1,y1,x2,y2;
  136.         x1=reader.nextInt();
  137.         y1=reader.nextInt();
  138.         x2=reader.nextInt();
  139.         y2=reader.nextInt();
  140.         Youlishu ylsa=new Youlishu(x1,y1);
  141.         Youlishu ylsb=new Youlishu(x2,y2);
  142.         Youlishu ylsc=new Youlishu(0,0);
  143.         Add jia=new Add();
  144.         ylsc=(Youlishu) jia.add(ylsa, ylsb);
  145.         ylsc.show();
  147.         Sub jian=new Sub();
  148.         ylsc=(Youlishu) jian.sub(ylsa, ylsb);
  149.         ylsc.show();
  151.         Multi cheng=new Multi();
  152.         ylsc=(Youlishu) cheng.multi(ylsa, ylsb);
  153.         ylsc.show();
  155.         Divid chu=new Divid();
  156.         ylsc=(Youlishu) chu.divid(ylsa, ylsb);
  157.         ylsc.show();
  158.     }
  159. }

方法三代码实现：

  1. Yunsuan.java
  2. package cn.edu.nefu.zhihu;
  3. public abstract class Yunsuan {
  4.     public abstract Object add(Object a);
  5.     public abstract Object sub(Object a);
  6.     public abstract Object multi(Object a);
  7.     public abstract Object divid(Object a);
  8.     public int gcd(int a,int b){
  9.         if(b==0)
  10.             return a;
  11.         else
  12.             return gcd(b,a%b);
  13.     }
  14.     public int lcm(int a,int b){
  15.         return a*b/gcd(a,b);
  16.     }
  17. }
  19. YouLiShu.java
  20. package cn.edu.nefu.zhihu;
  22. public class YouLiShu extends Yunsuan{
  23.     int fenzi,fenmu;
  24.     public YouLiShu(){}
  25.     public YouLiShu(int fenzi ,int fenmu){
  26.         this.fenzi=fenzi;
  27.         this.fenmu=fenmu;
  28.     }
  29.     @Override
  30.     public YouLiShu add(Object a) {
  31.         YouLiShu y=(YouLiShu)a;
  32.         YouLiShu z=new YouLiShu();
  33.         int lcmm=lcm(fenmu,y.fenmu);
  34.         z.fenmu=lcmm;
  35.         int d1,d2;
  36.         d1=lcmm/fenmu;
  37.         d2=lcmm/y.fenmu;
  38.         z.fenzi=d1*fenzi+d2*y.fenzi;
  39.         int gcdd2=gcd(z.fenmu,z.fenzi);
  40.         z.fenmu=z.fenmu/gcdd2;
  41.         z.fenzi=z.fenzi/gcdd2;
  42.         return z;
  43.     }
  44.     @Override
  45.     public YouLiShu divid(Object a) {
  46.         YouLiShu y=(YouLiShu)a;
  47.         YouLiShu z=new YouLiShu();
  48.         z.fenmu=fenmu*y.fenzi;
  49.         z.fenzi=fenzi*y.fenmu;
  50.         int gcdd2=gcd(z.fenmu,z.fenzi);
  51.         z.fenmu=z.fenmu/gcdd2;
  52.         z.fenzi=z.fenzi/gcdd2;
  53.         return z;
  54.     }
  55.     @Override
  56.     public YouLiShu multi(Object a) {
  57.         YouLiShu y=(YouLiShu)a;
  58.         YouLiShu z=new YouLiShu();
  59.         z.fenmu=fenmu*y.fenmu;
  60.         z.fenzi=fenzi*y.fenzi;
  61.         int gcdd2=gcd(z.fenmu,z.fenzi);
  62.         z.fenmu=z.fenmu/gcdd2;
  63.         z.fenzi=z.fenzi/gcdd2;
  64.         return z;
  65.     }
  66.     @Override
  67.     public YouLiShu sub(Object a) {
  68.         YouLiShu y=(YouLiShu)a;
  69.         YouLiShu z=new YouLiShu();
  70.         z.fenmu=fenmu*y.fenmu;
  71.         z.fenzi=fenzi*y.fenmu-fenmu*y.fenzi;
  72.         int gcdd2=gcd(z.fenmu,z.fenzi);
  73.         z.fenmu=z.fenmu/gcdd2;
  74.         z.fenzi=z.fenzi/gcdd2;
  75.         return z;
  76.     }
  77.     public String toString(){
  78.         return (fenzi+"/"+fenmu);
  79.     }
  80.     public double toXiaoShu(){
  81.         return fenzi*1.0/fenmu;
  82.     }
  83. }
  84. Test.java
  85. package cn.edu.nefu.zhihu;
  86. public class Test {
  88.     public static void main(String[] args) {
  89.         YouLiShu x=new YouLiShu(2,3);//匿名对象
  90.         YouLiShu y=new YouLiShu();
  91.         y=x.add(new YouLiShu(3,2));
  92.         System.out.println(y.toString());
  93.         System.out.println(y.toXiaoShu());
  94.         y=x.sub(new YouLiShu(1,3));
  95.         System.out.println(y.toString());
  96.         System.out.println(y.toXiaoShu());
  97.         y=x.multi(new YouLiShu(1,4));
  98.         System.out.println(y.toString());
  99.         System.out.println(y.toXiaoShu());
  100.         y=x.divid(new YouLiShu(3,2));
  101.         System.out.println(y.toString());
  102.         System.out.println(y.toXiaoShu());
  103.     }
  104. }

发表评论

表情：
评论列表 （有 0 条评论，173人围观）

还没有评论，来说两句吧...

相关阅读

    相关 java适配器模式

    java适配器模式 前言 1，创建报表顶层接口 2，更多其他报表接口 3，实现其他报表接口 4，创建适配器，适配器需实现报表顶层接口

    忘是亡心i忘是亡心i/ 0 赞/ 130 阅读

    相关 java适配器模式之类适配器

    一.类适配器模式 定义:适配器就是一种适配中间件，它存在于不匹配的二者之间，用于连接二者，将不匹配变得匹配，简单点理解就是平常所见的转接头，转换器之类的存在。 原理:通

    川长思鸟来川长思鸟来/ 0 赞/ 117 阅读

    相关 Java 适配器模式

    什么是适配器模式：                   就是将一个类的接口转换成客户需要的另一个接口，它的职责是将本来不能在一起工作的类，可以一起工作。 适配器模式中的角色

    ╰半夏微凉°╰半夏微凉°/ 0 赞/ 249 阅读