实战：构建一个Kotlin版本的四则运算计算器

最新推荐文章于 2023-05-02 16:15:00 发布
最新推荐文章于 2023-05-02 16:15:00 发布
阅读量2.3k 收藏 3
点赞数
分类专栏： Kotlin学习 文章标签： kotlin java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a412845064/article/details/122510770
版权

实战：构建一个Kotlin版本的四则运算计算器

计算器 1.0

/*
* 大致列举一下计算器的功能需求：
* 交互式界面，输入算式，按下回车，程序就会帮我们计算出结果；
* 数字与字符之间要求有空格，“1 + 1”是可以的，“1+1”则不行；
* 输入 exit，按下回车，程序就会退出；支持“加减乘除”，四种运算，仅支持两个数的运算。
*/

val help = """
--------------------------------------
使用说明：
1. 输入 1 + 1，按回车，即可使用计算器；
2. 注意：数字与符号之间要有空格；
3. 想要退出程序，请输入：exit
--------------------------------------""".trimIndent()

fun main() {
    while (true) {
        println(help)

        val input = readLine() ?: continue
        if (input == "exit") exitProcess(0)

        val inputList = input.split(" ")
        val result = calculate(inputList)

        if (result == null) {
            println("输入格式不对")
            continue
        } else {
            println("$input = $result")
        }
    }
}

private fun calculate(inputList: List<String>): Int? {
    if (inputList.size != 3) return null

    val left = inputList[0].toInt()
    val operation = Operation.valueOf(inputList[1])
    val right = inputList[2].toInt()

    return when (operation) {
        Operation.ADD -> left + right
        Operation.MINUS -> left - right
        Operation.MULTI -> left * right
        Operation.DIVI -> left / right
    }
}

计算器 2.0

/*
在 2.0 版本中，我们会分成两个阶段：
* 第一个阶段，融入面向对象的思想。1.0 版本中，我们只写了两个函数，一个是 main() 函数，
  另一个是 calculate() 函数。虽然这样的设计非常直观且便于理解，但却不太符合我们工程界的思维习惯。
  我们应该将程序封装到一个类当中，并且尽量让每个函数的功能划分清楚，保持每个函数尽量简单。
* 第二个阶段，兼容输入格式。1.0 版本中，我们对输入有严格的要求，数字和符号之间必须有空格，否则我们的算式解析会出错。
  在 2.0 版本中，我们尝试兼容不同的输入格式，不管数字和符号之间有没有空格，我们都要能成功执行。
*/

class CalculatorV2 {

    val exit = "exit"
    val help = """
--------------------------------------
使用说明：
1. 输入 1 + 1，按回车，即可使用计算器；
2. 注意：数字与符号之间要有空格；
3. 想要退出程序，请输入：exit
--------------------------------------""".trimIndent()

    fun start() {
        while (true) {
            println(help)

            val input = readLine() ?: continue
            val result = calculate(input)

            if (result == null) {
                println("输入格式不对")
                continue
            } else {
                println("$input = $result")
            }
        }
    }

    /*
    拆分 calculate() 方法主要做了三件事：
    * 第一，将“是否退出”的逻辑封装到了 shouldExit() 方法当中，如果将来这部分逻辑变得更复杂，我们只改动这一个方法即可。
    * 第二，将算式的解析，封装到了 parseExpression() 方法当中，而解析算式的时候也需要解析操作符，这时候我们也需要 parseOperator()。
    * 第三，将具体的计算逻辑交给了对应的方法。这么做的原因，是可以让我们的程序变得更加灵活。
      比如，我们在下个版本当中会更改“加法”的计算逻辑，那么我们就只需要改动这一个方法就行了。
    */
    private fun calculate(input: String): String? {
        if (shouldExit(input)) exitProcess(0)

        val exp = parseExpression(input) ?: return null

        val left = exp.left
        val operator = exp.operator
        val right = exp.right

        return when (operator) {
            Operation.ADD -> addString(left, right)
            Operation.MINUS -> minusString(left, right)
            Operation.MULTI -> multiString(left, right)
            Operation.DIVI -> diviString(left, right)
        }
    }

    private fun addString(left: String, right: String): String {
        val result = left.toInt() + right.toInt()
        return result.toString()
    }

    private fun minusString(left: String, right: String): String {
        val result = left.toInt() - right.toInt()
        return result.toString()
    }

    private fun multiString(left: String, right: String): String {
        val result = left.toInt() * right.toInt()
        return result.toString()
    }

    private fun diviString(left: String, right: String): String {
        val result = left.toInt() / right.toInt()
        return result.toString()
    }

    private fun shouldExit(input: String): Boolean {
        return input == exit
    }

    private fun parseExpression(input: String): Expression? {
        val operation = parseOperator(input) ?: return null
        val list = input.split(operation.value)
        if (list.size != 2) return null
        return Expression(
            left = list[0].trim(),
            operator = operation,
            right = list[1].trim()
        )
    }

    private fun parseOperator(input: String): Operation? {
        Operation.values().forEach {
            if (input.contains(it.value)) {
                return it
            }
        }
        return null
    }

    private fun parseOperator1(input: String): Operation? {
        return when {
            input.contains(Operation.ADD.value) -> Operation.ADD
            input.contains(Operation.MINUS.value) -> Operation.MINUS
            input.contains(Operation.MULTI.value) -> Operation.MULTI
            input.contains(Operation.DIVI.value) -> Operation.DIVI
            else -> null
        }
    }
}

enum class Operation(val value: String) {
    ADD("+"),
    MINUS("-"),
    MULTI("*"),
    DIVI("/")
}

data class Expression(
    val left: String,
    val operator: Operation,
    val right: String
)

fun main() {
    val calculator = CalculatorV2()
    calculator.start()
}

/*
在这个过程中，创建了三个类：
* “Calculator”类，代表整个计算器；
* “Operation”枚举类，代表加减乘除四种运算操作符；
* “Expression”数据类，代表我们算式当中的数字和操作符。
  之后，我们又对计算器的核心功能进行了更细颗粒度的拆分，
  提高了程序的灵活性，为我们的功能扩展打下了基础。
*/

计算器 3.0

/*
针对 3.0 这个版本，我们也分为了两个阶段：
* 第一阶段，增加单元测试。单元测试是软件工程当中的一个概念，它指的是对软件当中的最小可执行单元进行测试，
  以提高软件的稳定性。在 Java 当中，最小单元一般会认为是类，因此，我们一般会以类为单元，对类当中的方法进行一一测试。
* 第二阶段，支持大数的加法。我们知道 Java、Kotlin 当中的整型都是有范围限制的，
  如果我们输入两个特别大的数字进行计算，那么程序是无法正常工作的。因此，我们需要对特别大的数进行兼容。
*/

//在 Kotlin 当中，如果要使用单元测试，我们需要在 gradle 文件当中，添加 Kotlin 官方提供的依赖：
//testImplementation 'org.jetbrains.kotlin:kotlin-test'

单元测试的代码，我们一般会放在工程的 test 目录下：
在这里插入图片描述
可以从这个图中看出很多信息：
·第一，test 目录、main 目录，它们是平级的目录，内部拥有着相同的结构。main 目录下放的是功能代码，test 目录下放的则是测试代码。
·第二，由于我们要开发 3.0 版本，所以我们在 main 目录下创建了 CalculatorV3 这个类；另外，由于我们需要在 3.0 版本加入单元测试，所以对应的，我们在 test 目录下相同的地方，创建了 TestCalculatorV3。这两个类的关系是一一对应的，CalculatorV3 是为了实现 3.0 版本的功能，TestCalculatorV3 是为了测试 3.0 版本的功能，确保功能正常。

/*
针对 3.0 这个版本，我们也分为了两个阶段：
* 第一阶段，增加单元测试。单元测试是软件工程当中的一个概念，它指的是对软件当中的最小可执行单元进行测试，
  以提高软件的稳定性。在 Java 当中，最小单元一般会认为是类，因此，我们一般会以类为单元，对类当中的方法进行一一测试。
* 第二阶段，支持大数的加法。我们知道 Java、Kotlin 当中的整型都是有范围限制的，
  如果我们输入两个特别大的数字进行计算，那么程序是无法正常工作的。因此，我们需要对特别大的数进行兼容。
*/

//在 Kotlin 当中，如果要使用单元测试，我们需要在 gradle 文件当中，添加 Kotlin 官方提供的依赖：
//testImplementation 'org.jetbrains.kotlin:kotlin-test'

//单元测试的代码，我们一般会放在工程的 test 目录下：

class CalculatorV3 {

    private val exit = "exit"
    private val help = """
--------------------------------------
使用说明：
1. 输入 1 + 1，按回车，即可使用计算器；
2. 注意：数字与符号之间要有空格；
3. 想要退出程序，请输入：exit
--------------------------------------""".trimIndent()

    fun start() {
        while (true) {
            println(help)

            val input = readLine() ?: continue
            val result = calculate(input)

            if (result == null) {
                println("输入格式不对")
                continue
            } else {
                println("$input = $result")
            }
        }
    }

    fun calculate(input: String): String? {
        if (shouldExit(input)) exitProcess(0)

        val exp = parseExpression(input) ?: return null

        val left = exp.left
        val operator = exp.operator
        val right = exp.right

        return when (operator) {
            Operation.ADD -> addString(left, right)
            Operation.MINUS -> minusString(left, right)
            Operation.MULTI -> multiString(left, right)
            Operation.DIVI -> diviString(left, right)
        }
    }
/*
* 注释①，我们创建了一个 StringBuilder 对象，用于存储最终结果，
  由于我们的结果是一位位计算出来的，所以每一位结果都是慢慢拼接上去的，
  在这里，为了提高程序的性能，我们选择使用 StringBuilder。
* 注释②，我们定义了两个可变的变量 index，它们分别指向了两个数字的个位，这是因为我们的计算是从个位开始的。
* 注释③，carry，我们用它来存储每一位计算结果的进位。
* 注释④，这个 while 循环当中，我们会让两个 index 从低位一直到高位，直到遍历完它们所有的数字位。
* 注释⑤，这里的逻辑是取每一位上的数字，其中有个细节就是补零操作，比如当程序运行到百位的时候，99 没有百位，这时候 rightVal = 0。
* 注释⑥，当我们的程序计算出结果后，我们要分别算出 carry，以及当前位的结果。这时候我们分别使用“除法”计算 carry，使用“取余”操作计算当前位的结果。
* 注释⑦，这里是为了兼容一个特殊的场景，在“99+1”的情况下，我们的 while 循环最多只会遍历到十位，
  如果不做特殊处理的话，结果将变成“99+1=00”。这并不是我们想要的，所以，为了兼容这种特殊情况，
  我们在 while 循环结束后增加了一个判断，如果 carry=1，那就说明在最大的那一位数计算完以后，仍然有进位，我们要手动添加。
* 注释⑧，对于一个算式“135+99”，我们的 result 拼接其实是倒叙的“432”，这时候我们需要将其翻转一下，才能得到正确的结果“135+99=234”。
*/
    private fun addString(leftNum: String, rightNum: String): String {
        // ①
        val result = StringBuilder()
        // ②
        var leftIndex = leftNum.length - 1
        var rightIndex = rightNum.length - 1
        // ③
        var carry = 0

        // ④
        while (leftIndex >= 0 || rightIndex >= 0) {
            // ⑤
            val leftVal = if (leftIndex >= 0) leftNum.get(leftIndex).digitToInt() else 0
            val rightVal = if (rightIndex >= 0) rightNum.get(rightIndex).digitToInt() else 0
            val sum = leftVal + rightVal + carry
            // ⑥
            carry = sum / 10
            result.append(sum % 10)
            leftIndex--
            rightIndex--
        }
        // ⑦
        if (carry != 0) {
            result.append(carry)
        }

        // ⑧
        return result.reverse().toString()
    }

    private fun minusString(left: String, right: String): String {
        val result = left.toInt() - right.toInt()
        return result.toString()
    }

    private fun multiString(left: String, right: String): String {
        val result = left.toInt() * right.toInt()
        return result.toString()
    }

    private fun diviString(left: String, right: String): String {
        val result = left.toInt() / right.toInt()
        return result.toString()
    }

    private fun shouldExit(input: String): Boolean {
        return input == exit
    }

    private fun parseExpression(input: String): Expression? {
        val operation = parseOperator(input) ?: return null
        val list = input.split(operation.value)
        if (list.size != 2) return null
        return Expression(
            left = list[0].trim(),
            operator = operation,
            right = list[1].trim()
        )
    }

    private fun parseOperator(input: String): Operation? {
        Operation.values().forEach {
            if (input.contains(it.value)) {
                return it
            }
        }
        return null
    }
}

fun main() {
    val calculator = CalculatorV3()
    calculator.start()
}

编写测试代码：

/*
首先，我们定义了一个方法 testCalculate()，
并且使用了一个注解 @Test 来修饰它。因为这样做以后，
IntelliJ 就会知道：哦，这是一个用来做测试的方法。
*/
class TestCalculatorV3 {
    @Test
    fun testCalculate() {
        val calculator = CalculatorV3()

        val res1 = calculator.calculate("1+2")
        assertEquals("3", res1)
    }
}
归梦忆他乡
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计算器app(Kotlin版)_20182131119曾伟泽1
08-03
1.1 数字键盘按钮 selector 文件 numbtn_set.xml 1.1.1 数字按钮半透明样式文件 numbtn.xml 1.2 功能按钮及运算符按
kotlin简单四则运算计算器
qq_44008364的博客
09-05 665
kotlin编写的简单的四则运算计算器
Android & Kotlin：打造自己的计算器
泛泛之素
09-09 3015
一直很好奇Android开发是个什么样的体验，最近赋闲在家，时间宽裕，找了几个教学视频跟着体验一下，顺便练习一下学的Kotlin，于是乎就写了一个计算器，感觉还像那么回事儿。 先上效果图： 1. kotlin Kotlin （科特林）是一个用于现代多平台应用的静态编程语言 ，由 JetBrains（知名IDE开发公司，如idea，pycharm） 开发。 Kotlin可以编译成Java字节码，也可以编译成JavaScript，方便在没有JVM的设备上运行。除此之外Kotlin还可以编译成二进制代码直
Kotlin学习（十）—— Kotlin 计算器
刘桂林
12-20 1137
我们也学习了这么久的Kotlin了，我们来用Kotlin写一个计算器的小案例吧，这也是比较简单的示例了。我们先来看下效果：图片先看下这个UI，上面是一个EditText 下面是一个Rec...
Android开发：基于Kotlin编写一个简易计算器
保温杯拖把风扇的博客
05-14 4285
一文快速实现基于Android平台及Kotlin语言的账本编写，包括加减乘除等基础功能。
kobalt：一个基于Kotlin的JVM构建系统
02-04
Kobalt Kobalt是一个通用的构建系统。 要构建它： $ ./kobaltw assemble请访问以获取完整的文档。
Kotlin 四则运算 (加、减、乘、除)
03-22
Kotlin 四则运算 (加、减、乘、除)
spring-petclinic-kotlin：Spring Petclinic的Kotlin版本
01-30
spring-petclinic-kotlin：Spring Petclinic的Kotlin版本
kotlin-calculator:使用Kotlin的计算器应用
03-09
kotlin-calculator:使用Kotlin的计算器应用
Kotlin-Rechner:用Kotlin编写的用于Android的简单计算器
03-29
里奇纳社会责任Dieser Rechner的诗歌《原始的实现》，《 Grundrechenarten》。 积极的和消极的扎赫伦（Zahlen）也就是甘兹和科马萨赫伦（Gammazahlen）。 达勒伯·海瑙斯·维尔福·德·勒克纳·杜尔·艾因·埃因伯乌...
kotlin实现的简易计算器
02-27
kotlin实现的简易计算器
Calculator:适用于Android（Kotlin）的简单计算器
04-23
基本信息 这个项目是一个简单的计算器。 用户界面
纯Kotlin编写仿iphone计算器
04-28
纯Kotlin编写仿iphone计算器，这个是本人学习kotlin所写的计算器代码，逻辑简单明了，
Android开发：kotlin语言实现简易计算器
Just Today的博客
10-22 1762
简易计算器 实现功能： 1. 输入两个数字，可选加减乘除操作符，并计算显示对应结果随系统切换语言 2. 可对结果进行四舍五入操作
Kotlin：使用Kotlin开发一个命令行计算器
向小凯同学学习
03-31 713
一、下面我们就来开发一个基于命令行的计算器 新建一个counter.kt文件 package net.println.kotlin.chapters /** * @author:wangdong * @description:使用kotlin开发一个命令行计数器 */ fun main(args: Array&lt;String&gt;) { while (true) { ...
android用kotlin制作计算器,使用Kotlin做一个简单计算器
weixin_42305264的博客
06-01 806
样式如下图:1、布局文件：xmlns:app="http://schemas.android.com/apk/res-auto"xmlns:tools="http://schemas.android.com/tools"android:layout_width="match_parent"android:layout_height="match_parent"tools:context=".Mai...
【随笔二】Android-kotlin-实现简单计算器功能
Androiddddd的博客
08-12 1955
上一篇博客Android-kotlin-配置/入门配置好了 AndroidStudio Kotlin 的环境； 今天做一个简单的demo实战—实现一个简单的计算器功能 1.选择包名，然后右键： 2.选择Class类型，会有class： 3.创建CounterClass： package cn.kotlin.kotlin_oop02 /** * 加减乘除计算的calss * var number1:Double 此Double是kotlin的 * var operapor:Char 此Char是
Kotlin：Android开发技巧
最新发布
Gaga246的博客
05-02 494
Kotlin作为Android开发第一语言，然而身边做Android的大多还是使用java。Android转到Kotlin的趋势是必然的，公司隔壁部门已经全部使用Kotlin开发，我们在以后新的项目里，也会以Kotlin为主。关于Kotlin的知识，博主只是在去年下半年的时候看过官网的教程，也读了《Kotlin for Android Developers》，并写了一个练手项目，不过大半年过去了，要把以前学过的知识重新拿起来有点儿不易，于是总结了一些Kotlin在Android开发中的常用技巧。
在Android Studio中，使用Kotlin语言编写一个四则运算式子生成器，支持的运算数为浮点小数（正或负或0），可以随机生成包含加、减、乘、除、括号的四则运算式子，式子中包含的运算符个数和种类...
weixin_35749796的博客
12-31 318
A. 运算数的生成、负数的处理 在 Kotlin 中，可以使用 Random 类生成随机数。要生成一个浮点数，可以使用 nextDouble() 方法，生成的数的范围是 $[0,1)$。如果需要生成指定范围内的数，可以将随机数与范围相乘再加上下界，例如： val lowerBound = -10.0 val upperBound = 10.0 val random = Random() val...
用kotlin语言实现一个计算器
04-21
当然可以，Kotlin是一种支持面向对象和函数式编程的现代编程语言，它可以方便地用于实现各种类型的应用程序，包括计算器。以下是一个用Kotlin实现简单计算器的例子： ```kotlin fun main() { val input = readLine() ?: "" // 读取命令行输入 val regex = Regex("(\\d+)\\s*([+\\-*/])\\s*(\\d+)") // 定义匹配表达式 val matchResult = regex.matchEntire(input) // 匹配输入 if (matchResult != null) { val (lhs, op, rhs) = matchResult.destructured // 分解输入 val result = when (op) { // 根据运算符计算结果 "+" -> lhs.toInt() + rhs.toInt() "-" -> lhs.toInt() - rhs.toInt() "*" -> lhs.toInt() * rhs.toInt() "/" -> lhs.toInt() / rhs.toInt() else -> throw IllegalArgumentException("Invalid operator: $op") } println(result) // 输出结果 } else { println("Invalid input") // 输入无效 } } ``` 你可以将这段代码保存到一个.kt文件中，然后使用Kotlin编译器编译运行：`kotlinc calculator.kt -include-runtime -d calculator.jar && java -jar calculator.jar`。 当你运行该程序时，它会等待你输入一个算术表达式，例如`2 + 3`，然后计算结果并输出。如果输入无效，它会输出一个错误消息。注意，这只是一个非常简单的计算器实现，你可以根据需要进行修改和扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值