分类 计算机相关 下的文章

由于大疆新的无人机采用Mobile SDK 5.x版本(Kotlin)，而之前学习的版本是4.x(Java)，并且大疆对于5.x版本的文档写的实在不怎么样(相比4.x来说)，所以从新记录一下。

The lateinit keyword in Kotlin is used to declare(声明) a property that will be initialized later. It allows you to avoid(避免) null checks or the use of the null type for properties that you are certain will be initialized before use, but for some reason, you can't initialize them immediately(立即) at declaration.

上周末跟老朋友聚会，谈到技术的时候，有一个共识，软件开发方面真正有价值的进步，应当是有利于用户、有利于项目管理、有利于解决领域问题，而不是有利于程序员。多年以来，主流语言和系统的很多改进，其目的都是为了让写程序的人感觉更爽，而与用户、管理和解决问题毫无关系。C++ 在这方面是带了一个很坏的头，又要追求强大的表达能力，又要追求不打折扣的效率，结果搞出一大堆诸如操作符重载，template meta-programming 之类的东西。老实讲，我也觉得：

computed区别于methods的两个核心

  • computed是属性访问，而methods是函数调用
  • computed带有缓存功能，而methods不是

示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>浅析Vue中computed与method的区别</title>
    <script type="text/javascript" src="js/vue.js"></script>
</head>
<body>
<div id="app">
    <h1>{{message}}</h1>
    <p class="test1">{{methodTest}}</p>
    <p class="test2-1">{{methodTest()}}</p>
    <p class="test2-2">{{methodTest()}}</p>
    <p class="test2-3">{{methodTest()}}</p>
    <p class="test3-1">{{computedTest}}</p>
    <p class="test3-2">{{computedTest}}</p>
</div>
<!--script部分-->
<script>
    let vm = new Vue({
        el: '#app',
        data: {
            message: '我是消息，'
        },
        methods: {
            methodTest() {
                return this.message + '现在我用的是methods'
            }
        },
        computed: {
            computedTest() {
                return this.message + '现在我用的是computed'
            }
        }
    })
</script>
</body>
</html>

Java RMI(Remote Method Invocation)是一种强大的技术，它允许对象调用运行在另一个 Java 虚拟机（JVM）中的对象的方法。RMI 为创建分布式应用程序提供了一个简单直接的模型，使开发人员能够构建和部署可轻松跨网络（包括互联网）运行的系统。它是 Java SE（标准版）平台的一部分。

The State Pattern is a behavioral design pattern that allows an object to alter(改变) its behavior when its internal(内部) state changes. This pattern is used to encapsulate(封装) varying(变化) behavior for the same routine(例行程序) based on an object's state object. It's essentially(本质上) a way to model state transitions(过渡) in an object-oriented(面向对象) way.

The Iterator Pattern is a design pattern used in software development to provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation. It falls under the category of behavioral patterns, as it is used to manage algorithms, relationships, and responsibilities between objects.
迭代器模式（Iterator Pattern）是软件开发中使用的一种设计模式，它提供了一种在不暴露底层表示的情况下按顺序访问聚合对象元素的方法。它属于行为模式的范畴，因为它用于管理对象之间的算法、关系和责任。

The Template Method Pattern is a behavioral design pattern that defines the program skeleton of an algorithm in a method, deferring some steps to subclasses. It lets one or more steps of the algorithm vary by letting subclasses redefine certain steps of the algorithm without changing the algorithm's structure. This pattern is a fundamental technique in software engineering for reusing code and is particularly useful in situations where the overall structure of an operation is fixed, but the individual steps are flexible and subject to change.
模板方法模式（Template Method Pattern）是一种行为设计模式，它在一个方法中定义了算法的程序骨架，将某些步骤推迟到子类中。它允许子类在不改变算法结构的情况下重新定义算法的某些步骤，从而使算法的一个或多个步骤发生变化。这种模式是软件工程中重用代码的基本技术，尤其适用于操作的整体结构固定，但各个步骤灵活多变的情况。

Simple Factory Example

// Simple Factory
class AnimalFactory {
    public Animal getAnimal(String type) {
        if ("Dog".equalsIgnoreCase(type)) {
            return new Dog();
        } else if ("Cat".equalsIgnoreCase(type)) {
            return new Cat();
        }
        return null;
    }
}

interface Animal {
    void speak();
}

class Dog implements Animal {
    public void speak() {
        System.out.println("Woof");
    }
}

class Cat implements Animal {
    public void speak() {
        System.out.println("Meow");
    }
}

// Client code
public class Main {
    public static void main(String[] args) {
        AnimalFactory factory = new AnimalFactory();
        Animal myDog = factory.getAnimal("Dog");
        myDog.speak(); // Outputs: Woof
    }
}

The Command Pattern is a behavioral design pattern that turns a request into a stand-alone object. This object contains all information about the request. This transformation allows you to parameterize methods with different requests, delay or queue a request's execution, and support undoable operations. It's a part of the larger family of design patterns often utilized in software development for organizing code in a way that is both flexible and scalable.
命令模式是一种行为设计模式，它将请求转化为一个独立的对象。该对象包含请求的所有信息。通过这种转换，您可以为具有不同请求的方法设置参数，延迟或排队执行请求，并支持可撤消(undo)的操作。它是软件开发中常用的大型设计模式系列的一部分，用于以灵活和可扩展的方式组织代码。

如何定义一个设计模式呢？为何不能定义一个新的设计模式呢？难道就只有 GoF 中所说的 23 种设计模式吗？

Summary

The Chain of Responsibility pattern is a design pattern used in software development. It's a part of the behavioral design patterns, which are concerned with algorithms and the assignment of responsibilities between objects.

The Factory Pattern is a creational design pattern used in software development. It provides a way to encapsulate object creation without specifying the exact class of object that will be created.
工厂模式是一种用于软件开发的创建设计模式。它提供了一种封装对象创建的方法，而无需指定将要创建的对象的具体类别。

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. ...
  7. 13