从0开始学习JavaScript--JavaScript对象封装

news2024/12/23 4:38:35

JavaScript中的对象封装是一种重要的编程概念，它允许将数据和方法组织成一个独立的单元，实现了数据的保护和抽象。本文将深入探讨JavaScript对象封装的原理、实践和最佳实践。

封装的基础概念

封装是面向对象编程的基础概念之一，它强调将数据和行为组合成一个单一的单元，并通过访问器方法来控制对数据的访问和修改。下面介绍如何使用构造函数和闭包创建封装对象，以及封装的优势。

使用构造函数创建封装对象

构造函数是一种用于创建对象的特殊函数，通过构造函数可以初始化对象的属性。通过将属性和方法添加到构造函数中，我们可以创建具有封装特性的对象。

function Car(make, model) {
  // 私有属性
  let _make = make;
  let _model = model;

  // 公有方法
  this.getMake = function () {
    return _make;
  };

  this.getModel = function () {
    return _model;
  };

  this.displayInfo = function () {
    console.log(`Make: ${_make}, Model: ${_model}`);
  };
}

// 创建封装对象
const myCar = new Car('Toyota', 'Camry');

// 访问封装对象的公有方法
console.log(myCar.getMake()); // 输出: Toyota
console.log(myCar.getModel()); // 输出: Camry

// 调用封装对象的公有方法
myCar.displayInfo(); // 输出: Make: Toyota, Model: Camry

使用闭包创建封装对象

使用闭包也可以实现封装，通过在一个函数内部定义私有变量和方法，然后返回一个包含这些变量和方法的对象。

function createPerson(name, age) {
  // 私有变量
  let _name = name;
  let _age = age;

  // 私有方法
  function increaseAge() {
    _age++;
  }

  // 返回包含私有变量和方法的对象
  return {
    getName: function () {
      return _name;
    },
    getAge: function () {
      return _age;
    },
    celebrateBirthday: function () {
      increaseAge();
      console.log(`Happy Birthday, ${_name}! Now you are ${_age} years old.`);
    },
  };
}

// 创建封装对象
const person = createPerson('John', 25);

// 访问封装对象的公有方法
console.log(person.getName()); // 输出: John
console.log(person.getAge()); // 输出: 25

// 调用封装对象的公有方法
person.celebrateBirthday(); // 输出: Happy Birthday, John! Now you are 26 years old.

封装的优势

  1. 隐藏实现细节： 封装允许将对象的实现细节隐藏起来，只暴露必要的接口，使得对象的内部结构对外部不可见。

  2. 提高代码可维护性： 封装将数据和行为封装在一个单元中，使得代码更易于理解和维护。修改对象的内部实现不会影响外部代码，只需要关注对象提供的接口。

  3. 控制访问权限： 通过封装，可以控制属性的访问权限，使一些属性只能通过特定的方法进行访问或修改，增强了代码的安全性。

  4. 简化接口： 封装使得对象的接口可以被简化，只暴露对外必要的方法，降低了使用者的认知负担。

封装是面向对象编程的基石之一，它使得代码更加模块化、可维护和可复用。通过构造函数和闭包等机制，我们可以在JavaScript中灵活地实现封装。

高级封装：使用ES6 Class

使用ES6 Class创建封装对象

ES6 Class语法简化了对象的创建和继承过程，使得封装对象更加清晰易懂。

class Car {
  constructor(make, model) {
    // 私有属性
    this._make = make;
    this._model = model;
  }

  // Getter方法
  get make() {
    return this._make;
  }

  get model() {
    return this._model;
  }

  // 公有方法
  displayInfo() {
    console.log(`Make: ${this._make}, Model: ${this._model}`);
  }
}

// 创建封装对象
const myCar = new Car('Toyota', 'Camry');

// 使用Getter方法访问私有属性
console.log(myCar.make); // 输出: Toyota
console.log(myCar.model); // 输出: Camry

// 调用封装对象的公有方法
myCar.displayInfo(); // 输出: Make: Toyota, Model: Camry

使用Getter和Setter方法

Getter和Setter方法允许更灵活地控制对属性的访问和修改。

class Person {
  constructor(name, age) {
    // 私有属性
    this._name = name;
    this._age = age;
  }

  // Getter方法
  get name() {
    return this._name;
  }

  get age() {
    return this._age;
  }

  // Setter方法
  set age(newAge) {
    if (newAge > this._age) {
      console.log(`Happy Birthday, ${this._name}!`);
    }
    this._age = newAge;
  }
}

// 创建封装对象
const person = new Person('John', 25);

// 使用Getter方法访问私有属性
console.log(person.name); // 输出: John
console.log(person.age); // 输出: 25

// 使用Setter方法修改私有属性
person.age = 26; // 输出: Happy Birthday, John!
console.log(person.age); // 输出: 26

静态方法与继承

Class还支持静态方法，这些方法属于类而不是类的实例，可以用于创建与类相关的工具函数。

class MathUtils {
  // 静态方法
  static add(a, b) {
    return a + b;
  }

  static subtract(a, b) {
    return a - b;
  }
}

// 使用静态方法
console.log(MathUtils.add(5, 3)); // 输出: 8
console.log(MathUtils.subtract(5, 3)); // 输出: 2

ES6 Class提供了更加清晰和语义化的语法，使得封装对象的创建和维护更加便捷。Getter和Setter方法以及静态方法增加了更多的灵活性和功能性。通过合理运用这些特性，可以构建出更具可读性和可扩展性的高级封装对象。

封装的实际应用

通过实际场景演示，探讨封装在现实项目中的应用。例如，模拟账户系统的封装、使用封装创建可复用组件等。

class BankAccount {
  #balance;

  constructor(initialBalance) {
    this.#balance = initialBalance;
  }

  get balance() {
    return this.#balance;
  }

  deposit(amount) {
    if (amount > 0) {
      this.#balance += amount;
    }
  }

  withdraw(amount) {
    if (amount > 0 && amount <= this.#balance) {
      this.#balance -= amount;
    }
  }
}

const account = new BankAccount(1000);
account.deposit(500);
account.withdraw(200);
console.log(account.balance); // 获取账户余额

封装与设计原则

封装是面向对象编程中的一个核心概念，与设计原则密切相关，能够帮助我们实现更加健壮、可维护的代码。以下是封装与几个设计原则的关系：

1. 单一职责原则（Single Responsibility Principle）

单一职责原则要求一个类应该只有一个引起变化的原因。封装有助于实现单一职责原则，因为封装将类的内部实现细节隐藏起来，使得类的外部只需要关心其提供的接口。这样，当需求变化时，只需修改一个类而不影响其他部分。

2. 开放-封闭原则（Open-Closed Principle）

开放-封闭原则要求软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。通过良好的封装，我们可以将变化隔离在类内部，使得外部代码无需修改即可扩展系统功能。新功能的引入可以通过扩展类而不是修改现有类来实现，从而符合开放-封闭原则。

3. 高内聚低耦合原则

封装有助于实现高内聚低耦合的设计，即将相关的功能放在一个类内部，减少类与类之间的依赖关系。高内聚表示类内部的元素紧密相关，而低耦合表示类与类之间的关联性较弱。这种设计使得系统更加灵活、可维护，并且易于单独测试和修改。

4. 接口隔离原则（Interface Segregation Principle）

封装有助于实现接口隔离原则，即一个类不应该被强迫实现它用不到的接口。通过封装，我们可以将类的接口设计得更加精细，每个类只需要关注与其职责相关的方法，而不用实现不相关的接口。

5. 依赖倒置原则（Dependency Inversion Principle）

封装也与依赖倒置原则相关，该原则要求高层模块不应该依赖于低层模块，而是应该依赖于抽象。通过封装，我们可以定义良好的抽象接口，使得高层模块依赖于抽象而不是具体实现，从而提高系统的灵活性和可维护性。

封装与继承

封装与继承是面向对象编程中两个关键的概念，它们之间的关系影响着代码的可维护性和灵活性。下面深入研究封装与继承的关系以及在继承中如何正确使用封装。

封装的作用

封装是将对象的状态（数据）和行为（方法）包装在一起，形成一个独立的单元。通过封装，可以隐藏对象的内部实现细节，只暴露必要的接口给外部使用。这样可以防止外部直接访问对象的内部数据，提高了安全性和稳定性。

继承与封装

在继承关系中，子类通常会继承父类的属性和方法。封装在继承中的作用主要体现在以下几个方面：

  1. 数据隔离： 封装确保子类不会直接访问父类的私有成员，从而实现数据的良好隔离。子类通过父类提供的公共接口来访问数据，而不需要了解父类的内部实现。

  2. 代码可维护性： 封装使得类的内部结构可以更灵活地调整，而不影响外部代码。当需要修改父类的实现时，只需保持公共接口不变，而不会对继承父类的子类造成影响。

  3. 接口定义： 封装定义了对象与外部的交互接口，这个接口是继承中的重要部分。子类通过继承父类的接口来获取父类的功能，并且可以根据需要进行扩展。

组合和聚合

在某些情况下，组合和聚合可以作为替代继承的方案，从而更灵活地构建对象关系。这些模式利用封装来将对象组合在一起，而不是通过继承来建立层次结构。这种方式可以避免一些继承带来的问题，例如多重继承的复杂性和耦合度的增加。

组合： 将多个对象组合成一个更大的对象。每个对象都是独立的，它们通过组合来实现新的功能。

class Engine {
  start() {
    console.log('Engine started');
  }
}

class Car {
  constructor() {
    this.engine = new Engine();
  }

  start() {
    this.engine.start();
    console.log('Car started');
  }
}

聚合： 将一个对象作为另一个对象的部分，但是两者的生命周期是独立的。

class Wheel {
  roll() {
    console.log('Wheel rolling');
  }
}

class Car {
  constructor() {
    this.wheels = [new Wheel(), new Wheel(), new Wheel(), new Wheel()];
  }

  drive() {
    this.wheels.forEach(wheel => wheel.roll());
    console.log('Car is moving');
  }
}

封装与继承相辅相成，通过良好的封装实践，可以在继承关系中实现数据隔离、提高代码可维护性，并且利用组合和聚合等方式来更灵活地构建对象关系。选择合适的方式取决于具体的场景和需求，通过理解封装与继承的关系，能够更好地设计和组织我们的代码。

封装的异步操作

封装异步操作是在现代JavaScript应用中保持代码清晰、可读性和可维护性的关键。通过使用Promise、async/await等技术，可以更好地组织和管理异步代码。以下是关于如何封装异步操作的一些建议：

使用Promise

Promise是一种用于处理异步操作的对象，它可以表示一个异步操作的最终完成或失败及其结果值。通过使用Promise，可以更清晰地表达异步操作的流程。

function fetchData() {
  return new Promise((resolve, reject) => {
    // 异步操作，例如请求数据
    setTimeout(() => {
      const data = /* 获取的数据 */;
      if (data) {
        resolve(data); // 操作成功
      } else {
        reject('Error fetching data'); // 操作失败
      }
    }, 1000);
  });
}

// 使用Promise
fetchData()
  .then(data => {
    console.log('Data:', data);
  })
  .catch(error => {
    console.error('Error:', error);
  });

使用async/await

async/await是异步操作的一种更现代的处理方式，它基于Promise，并提供了更直观的语法。通过async关键字声明一个函数为异步函数，使用await等待Promise的结果。

async function fetchData() {
  return new Promise((resolve, reject) => {
    // 异步操作，例如请求数据
    setTimeout(() => {
      const data = /* 获取的数据 */;
      if (data) {
        resolve(data); // 操作成功
      } else {
        reject('Error fetching data'); // 操作失败
      }
    }, 1000);
  });
}

// 使用async/await
async function fetchDataWrapper() {
  try {
    const data = await fetchData();
    console.log('Data:', data);
  } catch (error) {
    console.error('Error:', error);
  }
}

fetchDataWrapper();

封装异步操作

为了更好地组织异步代码，可以封装异步操作为一个可复用的函数，将具体的异步细节隐藏在函数内部，提供清晰的接口。

function fetchData() {
  return new Promise((resolve, reject) => {
    // 异步操作，例如请求数据
    setTimeout(() => {
      const data = /* 获取的数据 */;
      if (data) {
        resolve(data); // 操作成功
      } else {
        reject('Error fetching data'); // 操作失败
      }
    }, 1000);
  });
}

async function fetchDataWrapper() {
  try {
    const data = await fetchData();
    console.log('Data:', data);
  } catch (error) {
    console.error('Error:', error);
  }
}

// 调用封装的异步操作
fetchDataWrapper();

通过封装，我们可以在整个应用程序中轻松地复用这个异步操作，提高了代码的可维护性和可读性。

封装的测试与调试

封装的测试与调试是确保代码质量和稳定性的重要步骤。下面将介绍如何编写针对封装对象的单元测试以及如何使用调试工具来追踪封装对象的行为。

单元测试

单元测试是一种验证代码单个模块（函数、类等）是否按预期工作的测试方式。对于封装的异步操作，我们可以使用测试框架（如Jest、Mocha）和断言库（如Chai）来编写测试。

// fetchData.js

function fetchData() {
  return new Promise((resolve, reject) => {
    // 异步操作，例如请求数据
    setTimeout(() => {
      const data = /* 获取的数据 */;
      if (data) {
        resolve(data); // 操作成功
      } else {
        reject('Error fetching data'); // 操作失败
      }
    }, 1000);
  });
}

module.exports = fetchData;

// fetchData.test.js

const fetchData = require('./fetchData');

describe('fetchData', () => {
  test('should resolve with data', async () => {
    const data = await fetchData();
    expect(data).toBeDefined();
  });

  test('should reject with error message if no data', async () => {
    await expect(fetchData()).rejects.toMatch('Error fetching data');
  });
});

在这个例子中，使用Jest测试框架和Chai断言库，编写了两个测试用例，验证了fetchData函数的正确性。这些测试可以自动运行，确保封装的异步操作在不同情况下都能正常工作。

调试

调试是解决代码问题的关键步骤。通过使用调试工具（如Chrome DevTools、Node.js的内置调试器），可以追踪封装对象的执行流程，查看变量的值，以及定位代码中的错误。

// fetchData.js

async function fetchData() {
  try {
    // 异步操作，例如请求数据
    const data = await new Promise((resolve, reject) => {
      setTimeout(() => {
        const responseData = /* 获取的数据 */;
        if (responseData) {
          resolve(responseData); // 操作成功
        } else {
          reject('Error fetching data'); // 操作失败
        }
      }, 1000);
    });

    // 调试点
    debugger;

    return data;
  } catch (error) {
    console.error('Error:', error);
    throw error;
  }
}

// 在调试工具中设置断点，运行代码
fetchData();

在这个例子中，在fetchData函数中使用了debugger关键字，这会在代码执行到这一行时启动调试器。通过在调试器中设置断点，可以逐步执行代码，观察变量的值，并在需要时中断执行以进行进一步的检查。

封装的最佳实践

封装在软件开发中是一项关键的实践，正确的封装可以提高代码的可维护性、可测试性和可读性。以下是一些封装的最佳实践：

1. 选择合适的封装方式

在封装时，应根据具体情况选择合适的封装方式。有时候选择函数封装足够，有时候可能需要使用类或模块。确保选择的封装方式符合代码的结构和功能需求。

// 函数封装
function fetchData(url) {
  // 异步操作
}

// 类封装
class DataLoader {
  constructor(url) {
    // 初始化
  }

  fetchData() {
    // 异步操作
  }
}

2. 保持接口简洁

封装的接口应该简洁明了，不暴露过多的细节给调用者。通过提供清晰的方法和属性，尽量隐藏封装内部的复杂性。

// 不好的封装
function fetchDataAndProcess(url, callback) {
  // 复杂的异步操作
  // ...
  // 处理结果
  callback(result);
}

// 更好的封装
function fetchData(url) {
  // 简单的异步操作
  // ...
  return result;
}

3. 适时更新封装

随着项目的演进和需求的变化，封装可能需要不断更新。及时优化和更新封装，确保它仍然满足项目的需求，并且在新场景下能够更好地工作。

// 初始封装
function fetchData(url) {
  // 初始实现
}

// 更新封装
function fetchData(url, options) {
  // 更新实现
}

4. 灵活运用设计原则

应该根据设计原则（如单一职责原则、开放-封闭原则等）来指导封装的实践。遵循这些原则可以使封装更为健壮、灵活，有助于代码的长期维护。

// 单一职责原则
class DataFetcher {
  fetchData(url) {
    // 异步操作
  }
}

class DataProcessor {
  process(data) {
    // 处理数据
  }
}

总结

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1261243.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

文本三剑客（grep，awk，sed）

文本三剑客（grep，awk，sed）

一.正则表达式 注意事项&#xff1a;使用正则表达式必须加引号。 元字符 表示字符 ① . &#xff1a;在正则表达式中.表示任意单个字符。 [rootpc1 data]#grep -o r.t /etc/passwd #过滤passwd文件中开头为r中间任意单个字符结尾为t的内容 rat rat rat [rootpc1 data]#g…
阅读更多...
oracle impdp 导入元数据表空间异常增大的解决办法

oracle impdp 导入元数据表空间异常增大的解决办法

expdp导出的时候指定了contentsmetadata_only只导出元数据&#xff0c;但是在impdp导入到新库的时候&#xff0c;发现新库的表空间增长非常大&#xff0c;其实这个直接就可以想到&#xff0c;应该是大表的initial segment过大导致的 正常impdp&#xff0c;在执行创建表和索引的…
阅读更多...
DM8数据库版本升级

DM8数据库版本升级

DM数据库版本升级说明 DM数据库的版本一直在不断的的迭代。 对于DM 的数据库版本&#xff0c;分大版本和小版本。 1)大版本&#xff1a;指DM6&#xff0c;DM7&#xff0c;DM8 这种。2)小版本&#xff1a;指同一个大版本子版本的变化&#xff0c;比如DM8的&#xff1a;8.1.0.1…
阅读更多...
假定采用带头结点的单链表保存单词，当两个单词有相同的后缀时，可共享相同的后缀存储空间，例如，“loading”,“being”的存储映像如下图所示。

假定采用带头结点的单链表保存单词，当两个单词有相同的后缀时，可共享相同的后缀存储空间，例如，“loading”,“being”的存储映像如下图所示。

假定采用带头结点的单链表保存单词&#xff0c;当两个单词有相同的后缀时&#xff0c;可共享相同的后缀存储空间&#xff0c;例如&#xff0c;“loading”,“being”的存储映像如下图所示。 设str1和str2分别指向两个单词所在单链表的头结点&#xff0c;链表结点结构为 data ne…
阅读更多...
在ubuntu系统安装SVN服务端,并通过客户端进行远程访问

在ubuntu系统安装SVN服务端,并通过客户端进行远程访问

文章目录 前言1. Ubuntu安装SVN服务2. 修改配置文件2.1 修改svnserve.conf文件2.2 修改passwd文件2.3 修改authz文件 3. 启动svn服务4. 内网穿透4.1 安装cpolar内网穿透4.2 创建隧道映射本地端口 5. 测试公网访问6. 配置固定公网TCP端口地址6.1 保留一个固定的公网TCP端口地址6…
阅读更多...
浅谈基于EIoT能源物联网的工厂智能照明系统应用改造

浅谈基于EIoT能源物联网的工厂智能照明系统应用改造

【摘要】&#xff1a;随着物联网技术的发展&#xff0c;许多场所针对照明合理应用物联网照明系统&#xff0c;照明作为工厂的重要能耗之一&#xff0c;工厂的照明智能化控制&#xff0c;如何优化控制、提高能源的利用率&#xff0c;达到节约能源的目的。将互联网的技术应用到工…
阅读更多...
使用jenkins和tomcat创建并部署maven项目

使用jenkins和tomcat创建并部署maven项目

准备三台服务器&#xff1a; 192.168.58.139 部署tomcat 详细参照&#xff1a;http://t.csdnimg.cn/Yp2z2 192.168.58.140 部署gitlab 详细参照&#xff1a;http://t.csdnimg.cn/Sb1uz 192.168.58.153 部署Jenkins 详细参照…
阅读更多...
AT89S52单片机------中断系统

AT89S52单片机------中断系统

目录 单片机的内部结构 中断请求标志寄存器 (1)TCON寄存器 (2)SCON寄存器 (3)定时器2的控制寄存器T2CON 中断允许与中断优先级的控制寄存器 中断允许寄存器IE 中断优先级寄存器IP 响应中断请求的条件 外部中断响应时间 外部中断的触发方式选择 中断请求的撤销 1.定…
阅读更多...
小程序域名SSL证书的重要性

小程序域名SSL证书的重要性

1. 数据安全 小程序中可能涉及用户的个人信息、支付信息等敏感数据&#xff0c;而未加密的通信容易受到中间人攻击。通过使用SSL证书&#xff0c;所有数据在传输过程中都会被加密&#xff0c;确保用户信息不被窃取或篡改。 2. 用户信任 浏览器和操作系统对使用SSL证书的网站…
阅读更多...
【java】编译时bug 项目启动前bug合集

【java】编译时bug 项目启动前bug合集

文章目录 1. jdk8中 Optional orElseThrow 编译时报错java: 未报告的异常错误X; 必须对其进行捕获或声明以便抛出2. 启动项目时提示 Error running Application: Command line is too long. Shorten command line for Application or also for Spring Boot default configurati…
阅读更多...
代码随想录算法训练营 ---第四十六天

代码随想录算法训练营 ---第四十六天

第一题&#xff1a; 简介&#xff1a; 本题的重点在于确定背包容量和物品数量 确定dp数组以及下标的含义 dp[i] : 字符串长度为i的话&#xff0c;dp[i]为true&#xff0c;表示可以拆分为一个或多个在字典中出现的单词。 2.确定递推公式 如果确定dp[j] 是true&#xff0c;且…
阅读更多...
Arch Linux 安装 dwm 窗口管理器

Arch Linux 安装 dwm 窗口管理器

窗口管理器是管理桌面上各种窗口的组件&#xff0c;主要功能有&#xff1a;窗口堆叠方式&#xff0c;窗口移动规则等。大多数人接触到的是堆叠式窗口管理器&#xff0c;一个窗口可以叠放在其他窗口之上&#xff0c;调整窗口的主要方式是鼠标。而dwm&#xff08;Dynamic Window …
阅读更多...
32 - MySQL调优之事务：高并发场景下的数据库事务调优

32 - MySQL调优之事务：高并发场景下的数据库事务调优

数据库事务是数据库系统执行过程中的一个逻辑处理单元&#xff0c;保证一个数据库操作要么成功&#xff0c;要么失败。谈到他&#xff0c;就不得不提 ACID 属性了。数据库事务具有以下四个基本属性&#xff1a;原子性&#xff08;Atomicity&#xff09;、一致性&#xff08;Con…
阅读更多...
深入了解PBKDF2加密技术：原理与实践

深入了解PBKDF2加密技术：原理与实践

摘要&#xff1a;本文详细介绍了PBKDF2&#xff08;Password-Based Key Derivation Function 2&#xff09;加密技术&#xff0c;包括其原理、算法流程和实际应用&#xff0c;旨在帮助读者更好地理解这一重要的加密方法。 PBKDF2在线加密 -- 一个覆盖广泛主题工具的高效在线平…
阅读更多...
算法通关村第十二关-黄金挑战字符串冲刺题

算法通关村第十二关-黄金挑战字符串冲刺题

最长公共前缀 描述 : 编写一个函数来查找字符串数组中的最长公共前缀。 如果不存在公共前缀&#xff0c;返回空字符串 ""。 题目 : LeetCode 14.最长公共前缀 : 分析 : 第一种方式&#xff0c;我们可以竖着比较&#xff0c;如图所示&#xff0c;每前进一个位置就…
阅读更多...
css实现鼠标移入背景图片变灰并浮现文字的效果

css实现鼠标移入背景图片变灰并浮现文字的效果

首先上效果图 说明一下我的html结构 如上图是一个div包裹的img标签, div的块大小width, height 自己定义, 我说明一下核心样式代码 下面写法是scss, 请自行替换 .web-query-image {position: relative; // 相对定位, 方便浮现文案进行绝对定位border-radius: 8px;box-sizing: …
阅读更多...
MySQL安装与配置教程

MySQL安装与配置教程

&#x1f337;&#x1f341; 博主猫头虎&#xff08;&#x1f405;&#x1f43e;&#xff09;带您 Go to New World✨&#x1f341; &#x1f984; 博客首页——&#x1f405;&#x1f43e;猫头虎的博客&#x1f390; &#x1f433; 《面试题大全专栏》 &#x1f995; 文章图文…
阅读更多...
14、矩阵键盘

14、矩阵键盘

矩阵键盘介绍 在键盘中按键数量越多时&#xff0c;为了减少I/O口的占用&#xff0c;通常将按键排列成矩阵形式 采用逐行或逐列的“扫描”&#xff0c;就可以读出任何位置按键的状态 扫描的概念 数码管扫描&#xff08;输出扫描&#xff09; 原理&#xff1a;显示第1位—&g…
阅读更多...
【力扣】907.子数组的最小值之和

【力扣】907.子数组的最小值之和

【力扣】907.子数组的最小值之和 文章目录 【力扣】907.子数组的最小值之和1. 题目介绍2. 解法2.1 方法一&#xff1a;单调栈2.2 方法二&#xff1a;动态规划 3. Danger参考 1. 题目介绍 给定一个整数数组 arr&#xff0c;找到 min(b) 的总和&#xff0c;其中 b 的范围为 arr …
阅读更多...
蓝桥杯第100 题 九宫幻方 DFS 全排列 C++ 解题思维

蓝桥杯第100 题 九宫幻方 DFS 全排列 C++ 解题思维

题目 九宫幻方https://www.lanqiao.cn/problems/100/learning/?page1&first_category_id1&name%E4%B9%9D 思路和解题方法 一 &#xff08;DFS) 首先&#xff0c;定义了一些全局变量和数组。vis数组用于标记已经出现过的数字&#xff0c;a数组用于存储数独的初始状态…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023