鸿蒙OS开发--初级计算器实例

最新推荐文章于 2024-11-01 09:19:41 发布
最新推荐文章于 2024-11-01 09:19:41 发布
阅读量1.8k 收藏 18
点赞数 40
文章标签： harmonyos 华为
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79900717/article/details/140910834
版权

文章目录

"成功不是将来才有的，而是从决定去做的那一刻起，持续累积而成。”
—— 保罗·柯艾略（Paulo Coelho）

前言

学习完成本次实例需要运用的知识：

  1. 栈的基本操作，将中缀表达式变成后缀表达式并计算结果
  2. 首选项数据存储的应用，将上次程序留下的表达式进行保存
  3. ArkUI的基础布局知识，用于布局数字和符号的按钮，以及表达式字体的大小。

本实例需要对上述知识有一定的了解，接下来是代码的实现目标：

  1. 通过按钮输入表达式，点击等于能够计算出结果，其中，当操作表达式的时候表达式字体较大，点击等于显示结果的时候字体较大，另外可以继续操作结果。
  2. 首选项数据存储的应用，将上次程序留下的表达式进行保存。
  3. 识别括号和‘-’号，优先计算括号里的内容，能够进行加减乘除的运算。
  4. 实现清零和‘<’的功能。

注：本篇文章用于个人学习总结

代码实现

根据以上功能可以将代码分为两大块，第一模块就是实现布局并且能将表达式正确输入上去，第二模块就是处理表达式并计算出结果。

布局

按钮部分

按钮大体分为两种，一种是按下之后把自己的值附上去的，比如数字和加减乘除括号，另一种是按下去之后可以实现某种功能的，比如说等于号，清理以及删除。

按照上述功能我们可以将其封装成如下类：

export default  class PressKeysBean {
  flag: number;
  value: string;
  ability?:number

  constructor(flag: number, value: string,ability?:number) {
    this.flag = flag;
    this.value = value;
    this.ability=ability
  }
}

flag用来区分是否为功能键，而value用来存放值，ability就是功能键的功能加以区分。

import PressKeysBean from './PressKeysItem'

 class PressKeysBeanViewModel{
  public getPressKeys():Array<Array<PressKeysBean>>{
    return [
      [
        new PressKeysBean(1,'C',0),
        new PressKeysBean(0,'7'),
        new PressKeysBean(0,'4'),
        new PressKeysBean(0,'1'),
        new PressKeysBean(1,'<',1)
      ],
      [
        new PressKeysBean(1,'('),
        new PressKeysBean(0,'8'),
        new PressKeysBean(0,'5'),
        new PressKeysBean(0,'2'),
        new PressKeysBean(0,'0')
      ],
      [
        new PressKeysBean(1,')'),
        new PressKeysBean(0,'9'),
        new PressKeysBean(0,'6'),
        new PressKeysBean(0,'3'),
        new PressKeysBean(0,'.')
      ],
      [
        new PressKeysBean(1,'÷'),
        new PressKeysBean(1,'×'),
        new PressKeysBean(1,'-'),
        new PressKeysBean(1,'+'),
        new PressKeysBean(2,'=')
      ]
    ]
  }
}
let keysModel = new PressKeysBeanViewModel();
export default keysModel as PressKeysBeanViewModel;

至此，我们的十六个键按照功能划分封装好了，接下来就是布局了！

布局可以用Grid布局，也可以用线性布局进行两层循环，这里使用后者。

Row({space:10}){
        ForEach(keysModel.getPressKeys(),(columnItem:Array<PressKeysBean>)=>{
          Column({space:30}){
            ForEach(columnItem,(Item:PressKeysBean)=> {
            //flag==0，表示是数字键，按下后直接将数字压进栈中
              if (Item.flag == 0) {
                Button(Item.value).style('#ffffffff','#000000').onClick(()=>{
                  this.expressions.push(Item.value)
                })
                //以下是加减乘除键和功能键
              } else if (Item.flag == 1) {
                Button(Item.value).style('#66ffffff','#000000').onClick(()=>{
                //等于0，是清除键，把表达式的值变成空，这里的flag，和flag1初始化。
                //flag和flag1是用来控制表达式和字体大小的，可以先不管
                  if(Item.ability==0){
                    this.expressions=[]
                    this.flag=0
                    this.flag1=0
                    //这里是删除键，点击一次在栈中弹出一个元素
                  }else if(Item.ability==1){
                    this.expressions.pop()
                    //加减乘除直接赋值
                  }else {
                    this.expressions.push(Item.value)
                    if(this.flag1==1){
                      this.expressions=[]
                      this.expressions.push(this.result.toString())
                      this.expressions.push(Item.value)
                      this.flag1=0
                    }
                  }
                })
                //这里是等于键，执行的功能是将表达式的结果进行解析赋值出结果
              }else if(Item.flag==2){
                Button(Item.value).style('#ff20b4cf','#ffffffff').onClick(()=>{
                  this.result=getCalculate(this.expressions.join(''))
                  if(Number.isNaN(this.result)){
                    this.result='表达式有误'
                  }
                  this.flag=1
                  this.flag1=1
                })
              }
            })
          }.justifyContent(FlexAlign.SpaceAround)
        })
      }.justifyContent(FlexAlign.SpaceAround)
      .width(350)
      .height(310)
      .alignItems(VerticalAlign.Bottom)
      .margin({top:280})

表达式和结果部分

情况1：表达式过长

Column({space:20}){
        TextInput({text:this.expressions.join('')})
          .minFontSize(15)
          .maxFontSize(this.flag1==1?30:50)
          .heightAdaptivePolicy(TextHeightAdaptivePolicy.MAX_LINES_FIRST)
          ...

给字体划定一个区间，一开始显示maxFontSize的字体大小，如果超出文本框显示范围，会自动缩小，直到缩小到minFontSize。

情况2：一开始的时候，结果处为空

使用flag处理，初始是0，当为0时，显示’ ',当flag为1时，结果显示。

情况3：点击等于时，结果会变大，表达式会变小，操作表达式的时候，则反之。

思路：定义flag1处理，初始是0，即一开始肯定是表达式大，点击等于的时候，让flag1等于1，结果会变得更大一些，而再次按下加减乘除继续进行操作的时候，让flag1=0.让表达式变大

布局完整代码

 @State KeyColor:string=''
  @State expressions:string[]=[]
  @State result:number|string=0
  @State flag:number=1
  @State flag1:number=0
  i:number=0
  build() {
    Stack(){

      Column({space:20}){
        TextInput({text:this.expressions.join('')})
          .fontColor($r('sys.color.mask_tertiary'))
          .backgroundColor('#ffefe8e8')
          .caretStyle({color:'#ff0a4dac',width:65})
          .minFontSize(15)
          .maxFontSize(this.flag1==1?30:50)
          .heightAdaptivePolicy(TextHeightAdaptivePolicy.MAX_LINES_FIRST)
          .textAlign(TextAlign.End)



        Text(this.flag==1?this.result.toString():'')
          .textAlign(TextAlign.End)
          .width('85%')
          .fontSize(this.flag1==1?50:30)
      }

      .margin({bottom:240})



      Row({space:10}){
        ForEach(keysModel.getPressKeys(),(columnItem:Array<PressKeysBean>)=>{
          Column({space:30}){
            ForEach(columnItem,(Item:PressKeysBean)=> {
              if (Item.flag == 0) {
                Button(Item.value).style('#ffffffff','#000000').onClick(()=>{
                  this.expressions.push(Item.value)
                })
              } else if (Item.flag == 1) {
                Button(Item.value).style('#66ffffff','#000000').onClick(()=>{
                  if(Item.ability==0){
                    this.expressions=[]
                    this.flag=0
                    this.flag1=0
                  }else if(Item.ability==1){
                    this.expressions.pop()
                  }else {
                    this.expressions.push(Item.value)
                    if(this.flag1==1){
                      this.expressions=[]
                      this.expressions.push(this.result.toString())
                      this.expressions.push(Item.value)
                      this.flag1=0
                    }
                  }
                })
              }else if(Item.flag==2){
                Button(Item.value).style('#ff20b4cf','#ffffffff').onClick(()=>{
                  this.result=getCalculate(this.expressions.join(''))
                  if(Number.isNaN(this.result)){
                    this.result='表达式有误'
                  }
                  this.flag=1
                  this.flag1=1
                })
              }
            })
          }.justifyContent(FlexAlign.SpaceAround)
        })
      }.justifyContent(FlexAlign.SpaceAround)
      .width(350)
      .height(310)
      .alignItems(VerticalAlign.Bottom)
      .margin({top:280})


    }
    .width('100%')
    .height('100%')
    .backgroundColor('#ffefe8e8')
  }
}

表达式处理

中缀表达式转后缀表达式

function getCalculate(expr: string): number {
  // 输入参数是一个字符串类型的表达式
  if('+-&times;&divide;'.includes((expr[expr.length - 1])))
    return NaN // 如果表达式的最后一个字符是运算符，则返回 NaN
  // 使用正则表达式匹配表达式中的数字、运算符和括号
  let tokens = expr.match(/(\\d+(\\.\\d+)?|\\+|-|&times;|&divide;|\\(|\\))/g) || []; // 使用正则表达式匹配数字、小数、运算符和括号，并存储在 tokens 数组中
  // 初始化 output 数组用于存储数字和运算符
  let output: string[] = []
  // 初始化 operations 数组用于存储运算符栈
  let operations: string[] = []
  // 定义一个函数来获取运算符的优先级
  const getPrecedence = (op: string): number => {
    // 运算符优先级映射
    switch(op){
      case '&times;':
      case '&divide;':
        return 2 // 乘法和除法的优先级最高
      case '+':
      case '-':
        return 1 // 加法和减法的优先级次之
      default:
        return 0 // 其他运算符的优先级为 0
    }
  }
  // 初始化前一个 token 为 'NaN'
  let prevToken: string = 'NaN';
  // 遍历 tokens 数组
  for (let token of tokens) {
    // 如果 token 可以转换为数字，则添加到 output 数组
    if (!isNaN(Number(token))) {
      output.push(token)
    } else if (token == '(') {
      // 如果 token 是 '('，则将其推入 operations 栈
      operations.push(token)
    } else if (token == '-' && (prevToken == 'NaN' || prevToken == '(' || '+-&times;&divide;%^'.includes(prevToken))) {
      // 如果 token 是 '-'，并且前一个 token 是 'NaN'、'(' 或 '+'、'-'、'&times;'、'&divide;'、'%'、'^' 中的任何一个
      // 将 '-' 视为一个一元运算符，相当于 '-1' 乘以一个运算符
      output.push('-1')
      operations.push('&times;')
    } else {
      // 当 operations 栈不为空且栈顶运算符的优先级大于等于当前运算符的优先级时
      while (operations.length > 0 && getPrecedence(operations[operations.length - 1]) >= getPrecedence(token)) {
        // 弹出栈顶运算符并添加到 output 数组
        let op = operations.pop()
        if (op) {
          output.push(op)
        }
      }
      // 如果 token 不是 ')'，则将其推入 operations 栈
      if (token != ')')
        operations.push(token)
    }
    // 更新前一个 token
    prevToken = token;
  }
  // 当 operations 栈不为空时，继续弹出运算符并添加到 output 数组
  while (operations.length > 0) {
    const op = operations.pop()
    if (op !== undefined)
      output.push(op)
  }
 
}

计算后缀表达式

 // 初始化 nums 数组用于存储数字
  let nums: number[] = []
  // 遍历 output 数组
  for (let value of output) {
    // 如果 value 可以转换为数字，则添加到 nums 数组
    if (!isNaN(Number(value))) {
      nums.push(Number(value))
    } else {
      // 弹出 nums 数组中的最后两个数字，执行相应的运算，并将结果推回 nums 数组
      let num1 = nums.pop() ?? 0
      let num2 = nums.pop() ?? 0
      switch (value) {
        case '+':
          nums.push(num2 + num1)
          break
        case '-':
          nums.push(num2 - num1)
          break
        case '&divide;':
          // 如果除数为零，则返回 NaN
          if (num1 !== 0)
            nums.push(num2 / num1)
          else
            return NaN
          break
        case '&times;':
          nums.push(num2 * num1)
          break
      }
    }
  }
  // 返回 nums 数组中的第一个元素，如果没有元素则返回 NaN
  return nums[0] ?? NaN;

保存表达式功能

首选项实际运用

该功能作用是，当程序退出时，你的表达式和结果均会被留在那里，下次进入程序还可以进行进一步的运算。

//创建时，获取数据
aboutToAppear(): void {
     this.getPreference().then((preference)=>{
       preference.get('exp',[]).then((v)=>{
         this.expressions=v as string[]
         this.result=getCalculate(this.expressions.join(''))
         this.flag1=1
       })
     })


   }

//销毁时，进行表达式的存储并数据持久化
   aboutToDisappear(): void {
     this.getPreference().then((p)=>{
       p.put('exp',this.expressions)
       p.flush()
     })
   }

//获取实例
   context:Context=getContext(this)
   getPreference(){
     return preferences.getPreferences(this.context,'user')
   }

总结

完成本次实例，复习了首选项数据存储，装饰器的使用，页面布局，字体大小设置，栈的使用，中缀转后缀，等众多知识，是一个综合性极强的实例，相信通过本次的学习，对于app开发的综合能力有了较大的提示！以下是完整代码：

PressKeysItem.ets

export default  class PressKeysBean {
  flag: number;
  value: string;
  ability?:number

  constructor(flag: number, value: string,ability?:number) {
    this.flag = flag;
    this.value = value;
    this.ability=ability
  }
}

PressKeysViewModel.ets

import PressKeysBean from './PressKeysItem'

 class PressKeysBeanViewModel{
  public getPressKeys():Array<Array<PressKeysBean>>{
    return [
      [
        new PressKeysBean(1,'C',0),
        new PressKeysBean(0,'7'),
        new PressKeysBean(0,'4'),
        new PressKeysBean(0,'1'),
        new PressKeysBean(1,'<',1)
      ],
      [
        new PressKeysBean(1,'('),
        new PressKeysBean(0,'8'),
        new PressKeysBean(0,'5'),
        new PressKeysBean(0,'2'),
        new PressKeysBean(0,'0')
      ],
      [
        new PressKeysBean(1,')'),
        new PressKeysBean(0,'9'),
        new PressKeysBean(0,'6'),
        new PressKeysBean(0,'3'),
        new PressKeysBean(0,'.')
      ],
      [
        new PressKeysBean(1,'÷'),
        new PressKeysBean(1,'×'),
        new PressKeysBean(1,'-'),
        new PressKeysBean(1,'+'),
        new PressKeysBean(2,'=')
      ]
    ]
  }
}
let keysModel = new PressKeysBeanViewModel();
export default keysModel as PressKeysBeanViewModel;

Page.ets

import keysModel from '../viewmodel/PressKeysViewModel';
import  PressKeysBean  from '../viewmodel/PressKeysItem';
import { preferences } from '@kit.ArkData';


@Extend(Button) function style(color:string,fontColor?:string){
  .backgroundColor(color)
  .fontColor(Color.Black).margin(5).width(70).height(50).fontSize(30).fontColor(fontColor)
}

@Entry
@Component
struct Calculator{


   aboutToAppear(): void {
     this.getPreference().then((preference)=>{
       preference.get('exp',[]).then((v)=>{
         this.expressions=v as string[]
         this.result=getCalculate(this.expressions.join(''))
         this.flag1=1
       })
     })


   }

   aboutToDisappear(): void {
     this.getPreference().then((p)=>{
       p.put('exp',this.expressions)
       p.flush()
     })
   }

   context:Context=getContext(this)
   getPreference(){
     return preferences.getPreferences(this.context,'user')
   }

  @State KeyColor:string=''
  @State expressions:string[]=[]
  @State result:number|string=0
  @State flag:number=1
  @State flag1:number=0
  i:number=0
  build() {
    Stack(){

      Column({space:20}){
        TextInput({text:this.expressions.join('')})
          .fontColor($r('sys.color.mask_tertiary'))
          .backgroundColor('#ffefe8e8')
          .caretStyle({color:'#ff0a4dac',width:65})
          .minFontSize(15)
          .maxFontSize(this.flag1==1?30:50)
          .heightAdaptivePolicy(TextHeightAdaptivePolicy.MAX_LINES_FIRST)
          .textAlign(TextAlign.End)



        Text(this.flag==1?this.result.toString():'')
          .textAlign(TextAlign.End)
          .width('85%')
          .fontSize(this.flag1==1?50:30)
      }

      .margin({bottom:240})



      Row({space:10}){
        ForEach(keysModel.getPressKeys(),(columnItem:Array<PressKeysBean>)=>{
          Column({space:30}){
            ForEach(columnItem,(Item:PressKeysBean)=> {
              if (Item.flag == 0) {
                Button(Item.value).style('#ffffffff','#000000').onClick(()=>{
                  this.expressions.push(Item.value)
                })
              } else if (Item.flag == 1) {
                Button(Item.value).style('#66ffffff','#000000').onClick(()=>{
                  if(Item.ability==0){
                    this.expressions=[]
                    this.flag=0
                    this.flag1=0
                  }else if(Item.ability==1){
                    this.expressions.pop()
                  }else {
                    this.expressions.push(Item.value)
                    if(this.flag1==1){
                      this.expressions=[]
                      this.expressions.push(this.result.toString())
                      this.expressions.push(Item.value)
                      this.flag1=0
                    }
                  }
                })
              }else if(Item.flag==2){
                Button(Item.value).style('#ff20b4cf','#ffffffff').onClick(()=>{
                  this.result=getCalculate(this.expressions.join(''))
                  if(Number.isNaN(this.result)){
                    this.result='表达式有误'
                  }
                  this.flag=1
                  this.flag1=1
                })
              }
            })
          }.justifyContent(FlexAlign.SpaceAround)
        })
      }.justifyContent(FlexAlign.SpaceAround)
      .width(350)
      .height(310)
      .alignItems(VerticalAlign.Bottom)
      .margin({top:280})


    }
    .width('100%')
    .height('100%')
    .backgroundColor('#ffefe8e8')
  }
}


//函数部分
function getCalculate(expr:string): number {
  if('+-×÷'.includes((expr[expr.length - 1])))
    return NaN
  // 使用正则划分出 整数或小数和符号的数组，修改正则表达式以支持负数
  let tokens = expr.match(/(\d+(\.\d+)?|\+|-|×|÷|\(|\))/g) || [];
  let output: string[] = []
  let operations: string[] = []

  const getPrecedence = (op:string):number => {
    switch(op){
      case '×':
      case '÷':
        return 2
      case '+':
      case '-':
        return 1
      default:
        return 0
    }
  }


  let prevToken:string = 'NaN';
  for (let token of tokens) {
    if (!isNaN(Number(token))) {
      output.push(token)
    } else if (token == '(') {
      operations.push(token)
    }
    else if (token == '-' && (prevToken == 'NaN' || prevToken == '(' || '+-×÷%^'.includes(prevToken))) {
      // 处理负号的情况
      output.push('-1')
      operations.push('×')
    } else {
      while (operations.length > 0 && getPrecedence(operations[operations.length - 1]) >= getPrecedence(token)) {
        let op = operations.pop()
        if (op === '(')
          break
        if (op) {
          output.push(op)
        }
      }
      if (token != ')')
        operations.push(token)
    }
    prevToken = token;
  }

  while (operations.length > 0) {
    const op = operations.pop()
    if (op !== undefined)
      output.push(op)
  }

  let nums: number[] = []

  for (let value of output) {
    if (!isNaN(Number(value))) {
      nums.push(Number(value))
    }

    else {
      let num1 = nums.pop() ?? 0
      let num2 = nums.pop() ?? 0
      switch (value) {
        case '+':
          nums.push(num2 + num1)
          break
        case '-':
          nums.push(num2 - num1)
          break
        case '÷':
          if (num1 !== 0)
            nums.push(num2 / num1)
          else
            return NaN  // 除数为零
          break
        case '×':
          nums.push(num2 * num1)
          break
      }
    }
  }

  return nums[0] ?? NaN;
}
Lincode12
关注
HarmonyOS - 实现简易的计算器
z2210068235的博客
12-11 1838
HarmonyOS - 实现简易的计算器
harmonyOS智慧屏,在鸿蒙HarmonyOS智慧屏上实现一款粗糙的计算器
weixin_34908663的博客
05-27 519
在学习的路上我们不能只是停留在对理论知识的理解，还应该将理论和实战进行结合，这样才有利于我们能够更有深度的掌握知识，最终形成自己的知识体系结构。我们在实战的时候，不仅可以巩固我们的理论知识，还能够在实战中发现问题，并找到合适的解决方案。前面的章节中我们已经学习了六大布局和常用的组件，我们在学习布局和组件的时候也有一些小示例。通过这些小示例我们仅仅是对当前的布局和组件的使用有了深刻的认识，但UI界面...
HarmonyOS开发案例：【计算器】
鸿蒙的技术博客
05-07 2350
基于基础组件、容器组件，实现一个支持加减乘除混合运算的计算器。由于数字都是双精度浮点数，在计算机中是二进制存储数据的，因此小数和非安全整数（超过整数的安全范围[-Math.pow(2, 53)，Math.pow(2, 53)]的数据）在计算过程中会存在精度丢失的情况。
鸿蒙应用开发——计算器（5）
J1062517968的博客
06-21 596
再之前的文章中我们已经完整的实现了计算器项目的功能，再此次实验中我们将对该计算器项目添加一些有趣的功能来达到创新的功能。
HarmonyOS应用开发：鸿蒙Js实战，计算器功能开发
08-09 3567
开发计算器最主要的是连续计算，连续计算需要添加计算优先级逻辑，后续考虑通过遍历来判断里面的计算。
鸿蒙开发实战案例-计算器（附整套源码）
shudaoshanQAQ的博客
03-05 3863
鸿蒙开发实战案例-计算器（附整套源码）
2024年HarmonyOS Next 大文件拷贝案例_鸿蒙next 拷贝本地文件(1)，2024年最新大厂面试必备技能有哪些
2401_84850808的博客
05-08 1257
有很多小伙伴不知道学习哪些鸿蒙开发技术？不知道需要重点掌握哪些鸿蒙应用开发知识点？而且学习时频繁踩坑，最终浪费大量时间。所以有一份实用的鸿蒙（HarmonyOS NEXT）资料用来跟着学习是非常有必要的。为了能够帮助大家快速掌握**鸿蒙（HarmonyOS NEXT）**应用开发技术知识。在此给大家分享一下我结合鸿蒙最新资料整理出来的鸿蒙南北向开发学习路线以及整理的最新版鸿蒙学习文档资料。这份鸿蒙（HarmonyOS NEXT）资料包含了鸿蒙开发必掌握的核心知识要点，内容包含了。
移动应用开发-仿制应用-计算器-实用工具-高仿苹果计算器小程序.zip
06-15
本资源提供了一个高仿苹果计算器的小程序开发指南和完整源码，旨在帮助开发者创建一个类似于苹果原生计算器的应用。这个小程序模仿了苹果计算器的界面和功能，提供了基础和科学计算模式，非常适合需要精确和高效计算...
66-矩阵键盘简易计算器(51单片机C语言实例Proteus仿真和代码)
06-15
66-矩阵键盘简易计算器(51单片机C语言实例Proteus仿真和代码)66-矩阵键盘简易计算器(51单片机C语言实例Proteus仿真和代码)66-矩阵键盘简易计算器(51单片机C语言实例Proteus仿真和代码)66-矩阵键盘简易计算器(51...
安卓开发实例-计算器
11-10
本实例中的"安卓开发实例-计算器"是一个实际的项目，它提供了完整的代码，可以帮助学习者理解如何在安卓环境中构建一个功能完备的计算器。下面将详细探讨这个计算器应用涉及的安卓开发知识点。 1. **用户界面（UI）...
Protues仿真实例-51单片机-计算器+万年历.rar
04-28
《51单片机在Protues仿真实例中的应用：计算器与万年历设计》 51单片机，作为微控制器领域的经典型号，广泛应用于各类电子设备中。本实例聚焦于51单片机在Protues软件中的仿真应用，通过构建计算器与万年历项目，...
鸿蒙应用开发-ArkUI 计算器
liuhaikang的博客
04-04 1725
效果图上的计算器界面简洁大方，每个按钮都经过精心设计，颜色搭配恰到好处，使得整体界面既美观又实用。按钮的实现代码已经给出，通过这段代码，我们可以看到如何设置按钮的文字颜色、背景颜色、圆角大小等属性。例如，我们选择了合适的颜色搭配，使得按钮在视觉上更加吸引人；同时，设置了较大的圆角，使得按钮呈现出圆润的外观，更加符合现代审美趋势。要实现计算器中的按钮，我们首先需要使用ArkUI中的Text组件来表示按钮上的文字。每个按钮都是一个独立的个体，因此我们使用Column布局来包裹每个按钮，以便进行统一的样式设置。
【鸿蒙】HarMonyOS的UI组件学习九之计算器
笔触狂放的博客
07-02 4387
计算器是电脑和手机都必不可少的一款软件，今天分享在鸿蒙系统上开发计算器软件。 先看功能效果: 这里演示了一下加法，该计算器中实现了加减乘除求余，开根号，倒数等所有功能。其他功能的演示这里就不浪费篇幅了。 接下来看界面的设计，这里设计了两种边框主题，一个是显示计算过程和结果的两个Text组件的边框，在graphic文件夹下新建xml文件: <?xml version="1.0" encoding="utf-8"?> <shape xmlns:ohos="http://s
HarmonyOS 5.0应用开发——用户文件操作
最新发布
高心星的专栏
11-01 625
用户文件：文件所有者为登录到该终端设备的用户，包括用户私有的图片、视频、音频、文档等。 用户文件存放在用户目录下，归属于该设备上登录的用户。 用户文件存储位置主要分为内置存储、外置存储。 应用对用户文件的创建、访问、删除等行为，需要提前获取用户授权，或由用户操作完成。
鸿蒙进阶篇-Swiper组件的使用
2401_88463044的博客
10-30 797
在科技的浪潮中，鸿蒙操作系统宛如一颗璀璨的新星，引领着创新的方向。作为鸿蒙开天组，今天我们将一同踏上鸿蒙基础的探索之旅，为您揭开这一神奇系统的神秘面纱。各位小伙伴们我们又见面了,我就是鸿蒙开天组,下面让我们进入今天的学习,鸿蒙进阶篇-Swiper组件的使用。
初体验鸿蒙 HarmonyOS NEXT开发
dawn0718的专栏
10-30 342
使用华为DevEco Studio做手机应用的初体验。
「Mac畅玩鸿蒙与硬件15」鸿蒙UI组件篇5 - Slider 和 Progress 组件
weixin_44217688的博客
10-30 825
Slider 和 Progress 是鸿蒙系统中的常用 UI 组件。Slider 控制数值输入，如音量调节；Progress 显示任务的完成状态，如下载进度。本文通过代码示例展示如何使用这些组件，并涵盖 进度条类型介绍、节流优化、状态同步 和 定时器动态更新。
鸿蒙Harmony-矩形绘制组件Rect使用详解
袁震的博客
10-31 1118
Rect是鸿蒙提供的矩形绘制组件，利用该组件可以绘制矩形背景，矩形图案等官方提供的参数和属性：参数名参数类型必填默认值参数描述width否0宽度。异常值按照默认值处理。height否0高度。异常值按照默认值处理。radius否0圆角半径，支持分别设置四个角的圆角度数。该属性和radiusWidth/radiusHeight属性效果类似，在组合使用时优先于radiusWidth/radiusHeight生效异常值按照默认值处理。否0圆角宽度。
深入分析Casio fx-9750 GII计算器的OS更新
SH-4是一种高性能的微处理器，由日本半导体公司Renesas Electronics开发，它在Casio计算器中负责执行复杂的数学计算和逻辑运算，提供快速和准确的计算结果。 标签中提及的"casio 计算器；OS"，进一步明确了我们关注...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值