精华内容
下载资源
问答
  • 十六进制转换为进制两种常见方法 好久以前学都忘了,正好复习一下 对于十六进制转进制 第一种:快速法(自己挺喜欢第一种快捷) 比如: 012A=0 X 163 + 1 X 162+ 2 X 161 + 10 X 160 = 298 说明:当中...

    十六进制的转换为十进制两种常见方法

    好久以前学的都忘了,正好复习一下

    对于十六进制转十进制

    第一种:快速法(自己挺喜欢第一种的快捷)
    比如:
    012A=0 X 163 + 1 X 162+ 2 X 161 + 10 X 160 = 298

    说明:当中的十六进制a=10 b=11 c=12 d=13 e=14 f=15

    第二种:迂回法
    将十六进制转换为二进制在转换为十进制(第一种小伙伴们或许不好理解,第二种容易理解)
    比如:
    1A首先转为二进制:0001 1010
    0001 1010 再通过二进制的算法转十进制:0001 1010=1 X 24 + 1 X 23 + 1 X 21 = 26
    愿努力的人们,收获自己的一片天!

    展开全文
  • 资料:关于说明文的说明方法 打比方:天上的星星像一颗颗宝石。 作比较:春天的雨细腻柔媚,夏天的雨粗犷热烈。 举例子:晕能预示天气。比如,在新疆地区,出现晕。映入眼帘的是一个晶莹的球体,上面蓝色和白色的纹...

    资料:关于说明文的说明方法 打比方:天上的星星像一颗颗宝石。 作比较:春天的雨细腻柔媚,夏天的雨粗犷热烈。 举例子:晕能预示天气。比如,在新疆地区,出现晕。

    映入眼帘的是一个晶莹的球体,上面蓝色和白色的纹痕相互交错,周围裹着一层薄薄的水蓝色“纱衣”。多少(打比方) 地球,这位人类的母亲,这个生命的摇篮,是那样的美。

    语文句子有十种说明方法。常见的多少钱有:举例子,列数字,打比方,分类别,作比较,引资料,分类别,摹状貌,下定义,列图表。1,举例子 举出实际价格事例来说明事物,使。

    例子,下定义,作比较,列数字,打比方

    写十句有关列数字的说明方法的句子1,其实,太阳离我们有1.5亿公里远。2,到太阳上去,如果步行,日夜不停地走,差不多要走3500年;就费用是坐飞机,也要飞二十几年。

    1,人际关系这一门科学永远没有学成毕业的一日,每天都似投身于砂石中,缓缓磨。 4,有得有失,才是人生,切忌忿忿不平。感慨人生的哲理句子5,哭要一个人躲着哭。

    说明方法有如报价下9种。 1.举例子:为了说明事物的情况或事理有时光从道理上讲,人们不太理解,这就需要举些既通俗易懂又有代表性的例子来加以说明。如(中国石拱桥。

    要10个有说明方法的句子 如: ···。 ( ) ( 句子 ) (说明方法)

    1下定义:科技是人们心血的结晶 2打比方:雪是白色的精灵 3列数字:全世界平均每1秒钟有3个婴儿夭折 4作比较:暖国的雨,柔顺飘飞;朔方的雨,刚猛豪放 5作引用。

    1 列数字:这座塔占地300平方米,高100米。(列举数字进行说文洁明) 2 下定义:大气层中的对流层就是指温度上低下高的紧贴地面因而能形成对流葵儿的一层。(定义要求完整。

    1,我国的石拱桥几乎到处都有。这些桥大小不一,形莫小娘式多样,有许多是惊人的杰作。 蒸汽机的燃起,引起了人类世界的大变革,大转折时期,从经济生产方式到政治制度。

    展开全文
  • 这里通过数字宫殿的方法快速记忆10种常见的设计模式,通过记忆名字+理解的情况下熟悉常见的软件架构模式 文章目录10种常见的软件架构模式-快速记忆前言一、快速记忆二、详细解释体系架构模式的比较 前言 主要分两...

    10种常见的软件架构模式-快速记忆

    这里通过数字宫殿的方法快速记忆10种常见的设计模式,通过记忆名字+理解的情况下熟悉常见的软件架构模式



    前言

    主要分两个部分,第一个是快速记忆,第二个部分是相关的理解,这里的说明来源文章:https://www.cnblogs.com/IcanFixIt/p/7518146.html 关于记忆这个因人而异,如果觉的适合可以试试这个,如果觉的不好可以试试别的,不过无论用什么方法,我们的目标是相同的,那就是技术的不断进步和提高;


    一、快速记忆

    在这里插入图片描述

    上面这个图片是数字宫殿里面的联想记忆对照,我们这里只需要记忆住前十个就可以了;

    具体记忆内容为:
    一个屋子中,蜡烛照亮了一个一块分层的蛋糕,鸭子客服在客户端和服务端之间来回走,(上帝)在草中侧倾听,屋子旁边红旗下面水管道过滤废水的声音,红旗上有个挂钩挂着伞架子(只有伞的里面,即为代理),屋子门上一个口哨两点之间拉的笔直,门下面一个拄着拐杖的老人在讲解故事事件的总线,老人旁边一个小女孩在控制着双手画着葫芦模型视图,女孩旁边有一个黑板,黑板上画着球拍,黑板下面一个手拿棒球的男孩在像旁边的女孩解释问题;

    二、详细解释

    如果下面样式不好可以访问:https://www.cnblogs.com/IcanFixIt/p/7518146.html

    10种常见的软件架构模式
    有没有想过要设计多大的企业规模系统?在主要的软件开发开始之前,我们必须选择一个合适的体系结构,它将为我们提供所需的功能和质量属性。因此,在将它们应用到我们的设计之前,我们应该了解不同的体系结构。
    在这里插入图片描述

    什么是架构模式?
    根据维基百科中的定义:

    架构模式是一个通用的、可重用的解决方案,用于在给定上下文中的软件体系结构中经常出现的问题。架构模式与软件设计模式类似,但具有更广泛的范围。

    在本文中,将简要地解释以下10种常见的体系架构模式,以及它们的用法、优缺点。

    1. 分层模式
    2. 客户端-服务器模式
    3. 主从设备模式
    4. 管道-过滤器模式
    5. 代理模式
    6. 点对点模式
    7. 事件总线模式
    8. 模型-视图-控制器模式
    9. 黑板模式
    10. 解释器模式

    一. 分层模式

    这种模式也称为多层体系架构模式。它可以用来构造可以分解为子任务组的程序,每个子任务都处于一个特定的抽象级别。每个层都为下一个提供更高层次服务。

    一般信息系统中最常见的是如下所列的4层。

    • 表示层(也称为UI层)
    • 应用层(也称为服务层)
    • 业务逻辑层(也称为领域层)
    • 数据访问层(也称为持久化层)

    使用场景:

    • 一般的桌面应用程序
    • 电子商务Web应用程序
      在这里插入图片描述

    二. 客户端-服务器模式

    这种模式由两部分组成:一个服务器和多个客户端。服务器组件将为多个客户端组件提供服务。客户端从服务器请求服务,服务器为这些客户端提供相关服务。此外,服务器持续侦听客户机请求。

    使用场景:

    • 电子邮件,文件共享和银行等在线应用程序
      在这里插入图片描述

    三. 主从设备模式

    这种模式由两方组成;主设备和从设备。主设备组件在相同的从设备组件中分配工作,并计算最终结果,这些结果是由从设备返回的结果。

    使用场景:

    • 在数据库复制中,主数据库被认为是权威的来源,并且要与之同步
    • 在计算机系统中与总线连接的外围设备(主和从驱动器)
      在这里插入图片描述

    四. 管道-过滤器模式

    此模式可用于构造生成和处理数据流的系统。每个处理步骤都封装在一个过滤器组件内。要处理的数据是通过管道传递的。这些管道可以用于缓冲或用于同步。

    使用场景:

    • 编译器。连续的过滤器执行词法分析、解析、语义分析和代码生成
    • 生物信息学的工作流
      在这里插入图片描述

    五. 代理模式

    此模式用于构造具有解耦组件的分布式系统。这些组件可以通过远程服务调用彼此交互。代理组件负责组件之间的通信协调。
    服务器将其功能(服务和特征)发布给代理。客户端从代理请求服务,然后代理将客户端重定向到其注册中心的适当服务。

    使用场景:

    • 消息代理软件,如Apache ActiveMQ,Apache Kafka,RabbitMQ和JBoss Messaging
      在这里插入图片描述

    六. 点对点模式

    在这种模式中,单个组件被称为对等点。对等点可以作为客户端,从其他对等点请求服务,作为服务器,为其他对等点提供服务。对等点可以充当客户端或服务器或两者的角色,并且可以随时间动态地更改其角色。

    使用场景:

    • 像Gnutella和G2这样的文件共享网络
    • 多媒体协议,如P2PTV和PDTP
    • 像Spotify这样的专有多媒体应用程序
      在这里插入图片描述

    七. 事件总线模式

    这种模式主要是处理事件,包括4个主要组件:事件源、事件监听器、通道和事件总线。消息源将消息发布到事件总线上的特定通道上。侦听器订阅特定的通道。侦听器会被通知消息,这些消息被发布到它们之前订阅的一个通道上。

    使用场景:

    • 安卓开发
    • 通知服务
      在这里插入图片描述

    八. 模型-视图-控制器模式

    这种模式,也称为MVC模式,把一个交互式应用程序划分为3个部分,
    模型:包含核心功能和数据
    视图:将信息显示给用户(可以定义多个视图)
    控制器:处理用户输入的信息
    这样做是为了将信息的内部表示与信息的呈现方式分离开来,并接受用户的请求。它分离了组件,并允许有效的代码重用。

    使用场景:

    • 在主要编程语言中互联网应用程序的体系架构
    • 像Django和Rails这样的Web框架
      在这里插入图片描述

    九. 黑板模式

    这种模式对于没有确定解决方案策略的问题是有用的。黑板模式由3个主要组成部分组成。
    黑板——包含来自解决方案空间的对象的结构化全局内存
    知识源——专门的模块和它们自己的表示
    控制组件——选择、配置和执行模块
    所有的组件都可以访问黑板。组件可以生成添加到黑板上的新数据对象。组件在黑板上查找特定类型的数据,并通过与现有知识源的模式匹配来查找这些数据。

    使用场景:

    • 语音识别
    • 车辆识别和跟踪
    • 蛋白质结构识别
    • 声纳信号的解释
      在这里插入图片描述

    十. 解释器模式

    这个模式用于设计一个解释用专用语言编写的程序的组件。它主要指定如何评估程序的行数,即以特定的语言编写的句子或表达式。其基本思想是为每种语言的符号都有一个分类。

    使用场景:

    • 数据库查询语言,比如SQL
    • 用于描述通信协议的语言
      在这里插入图片描述

    体系架构模式的比较

    下面给出的表格总结了每种体系架构模式的优缺点。
    在这里插入图片描述

    展开全文
  • 在数据库中的静态表上做 OLAP 分析时,两表 join 是非常常见的操作。同理,在流式处理作业中,有时也需要在两条流上做 join 以获得更丰富的信息。Flink DataStream API 为用户提供了3个算子来实现双流 join,分别是...

    声明:本系列博客是根据SGG的视频整理而成,非常适合大家入门学习。

    《2021年最新版大数据面试题全面开启更新》

    在数据库中的静态表上做 OLAP 分析时,两表 join 是非常常见的操作。同理,在流式处理作业中,有时也需要在两条流上做 join 以获得更丰富的信息。Flink DataStream API 为用户提供了3个算子来实现双流 join,分别是:

    • join()
    • coGroup()
    • intervalJoin()

    本文举例说明它们的使用方法,顺便聊聊比较特殊的 interval join 的原理。

    1 准备数据

    从 Kafka 分别接入点击流和订单流,并转化为 POJO。

    复制代码

    DataStream<String> clickSourceStream = env
      .addSource(new FlinkKafkaConsumer011<>(
        "ods_analytics_access_log",
        new SimpleStringSchema(),
        kafkaProps
      ).setStartFromLatest());
    DataStream<String> orderSourceStream = env
      .addSource(new FlinkKafkaConsumer011<>(
        "ods_ms_order_done",
        new SimpleStringSchema(),
        kafkaProps
      ).setStartFromLatest());
    
    DataStream<AnalyticsAccessLogRecord> clickRecordStream = clickSourceStream
      .map(message -> JSON.parseObject(message, AnalyticsAccessLogRecord.class));
    DataStream<OrderDoneLogRecord> orderRecordStream = orderSourceStream
      .map(message -> JSON.parseObject(message, OrderDoneLogRecord.class));

    复制代码

    2 join()

    join() 算子提供的语义为"Window join",即按照指定字段和(滚动/滑动/会话)窗口进行 inner join,支持处理时间和事件时间两种时间特征。
    以下示例以10秒滚动窗口,将两个流通过商品 ID 关联,取得订单流中的售价相关字段。

    复制代码

    clickRecordStream
      .join(orderRecordStream)
      .where(record -> record.getMerchandiseId())
      .equalTo(record -> record.getMerchandiseId())
      .window(TumblingProcessingTimeWindows.of(Time.seconds(10)))
      .apply(new JoinFunction<AnalyticsAccessLogRecord, OrderDoneLogRecord, String>() {
        @Override
        public String join(AnalyticsAccessLogRecord accessRecord, OrderDoneLogRecord orderRecord) throws Exception {
          return StringUtils.join(Arrays.asList(
            accessRecord.getMerchandiseId(),
            orderRecord.getPrice(),
            orderRecord.getCouponMoney(),
            orderRecord.getRebateAmount()
          ), '\t');
        }
      })
      .print().setParallelism(1);

    复制代码

    简单易用。

    3 coGroup()

    只有 inner join 肯定还不够,如何实现 left/right outer join 呢?答案就是利用 coGroup() 算子。它的调用方式类似于 join() 算子,也需要开窗,但是 CoGroupFunction 比 JoinFunction 更加灵活,可以按照用户指定的逻辑匹配左流和/或右流的数据并输出。
    以下的例子就实现了点击流 left join 订单流的功能,是很朴素的 nested loop join 思想(二重循环)。

    复制代码

    clickRecordStream
      .coGroup(orderRecordStream)
      .where(record -> record.getMerchandiseId())
      .equalTo(record -> record.getMerchandiseId())
      .window(TumblingProcessingTimeWindows.of(Time.seconds(10)))
      .apply(new CoGroupFunction<AnalyticsAccessLogRecord, OrderDoneLogRecord, Tuple2<String, Long>>() {
        @Override
        public void coGroup(Iterable<AnalyticsAccessLogRecord> accessRecords, Iterable<OrderDoneLogRecord> orderRecords, Collector<Tuple2<String, Long>> collector) throws Exception {
          for (AnalyticsAccessLogRecord accessRecord : accessRecords) {
            boolean isMatched = false;
            for (OrderDoneLogRecord orderRecord : orderRecords) {
              // 右流中有对应的记录
              collector.collect(new Tuple2<>(accessRecord.getMerchandiseName(), orderRecord.getPrice()));
              isMatched = true;
            }
            if (!isMatched) {
              // 右流中没有对应的记录
              collector.collect(new Tuple2<>(accessRecord.getMerchandiseName(), null));
            }
          }
        }
      })
      .print().setParallelism(1);

    复制代码

    4 intervalJoin()

    join() 和 coGroup() 都是基于窗口做关联的。但是在某些情况下,两条流的数据步调未必一致。例如,订单流的数据有可能在点击流的购买动作发生之后很久才被写入,如果用窗口来圈定,很容易 join 不上。所以 Flink 又提供了"Interval join"的语义,按照指定字段以及右流相对左流偏移的时间区间进行关联,即:

    right.timestamp ∈ [left.timestamp + lowerBound; left.timestamp + upperBound]

     

     interval join 也是 inner join,虽然不需要开窗,但是需要用户指定偏移区间的上下界,并且只支持事件时间。
    示例代码如下。注意在运行之前,需要分别在两个流上应用 assignTimestampsAndWatermarks() 方法获取事件时间戳和水印。

    复制代码

    clickRecordStream
      .keyBy(record -> record.getMerchandiseId())
      .intervalJoin(orderRecordStream.keyBy(record -> record.getMerchandiseId()))
      .between(Time.seconds(-30), Time.seconds(30))
      .process(new ProcessJoinFunction<AnalyticsAccessLogRecord, OrderDoneLogRecord, String>() {
        @Override
        public void processElement(AnalyticsAccessLogRecord accessRecord, OrderDoneLogRecord orderRecord, Context context, Collector<String> collector) throws Exception {
          collector.collect(StringUtils.join(Arrays.asList(
            accessRecord.getMerchandiseId(),
            orderRecord.getPrice(),
            orderRecord.getCouponMoney(),
            orderRecord.getRebateAmount()
          ), '\t'));
        }
      })
      .print().setParallelism(1);

    复制代码

    由上可见,interval join 与 window join 不同,是两个 KeyedStream 之上的操作,并且需要调用 between() 方法指定偏移区间的上下界。如果想令上下界是开区间,可以调用 upperBoundExclusive()/lowerBoundExclusive() 方法。

    interval join 的实现原理

    以下是 KeyedStream.process(ProcessJoinFunction) 方法调用的重载方法的逻辑。

    复制代码

    public <OUT> SingleOutputStreamOperator<OUT> process(
            ProcessJoinFunction<IN1, IN2, OUT> processJoinFunction,
            TypeInformation<OUT> outputType) {
        Preconditions.checkNotNull(processJoinFunction);
        Preconditions.checkNotNull(outputType);
        final ProcessJoinFunction<IN1, IN2, OUT> cleanedUdf = left.getExecutionEnvironment().clean(processJoinFunction);
        final IntervalJoinOperator<KEY, IN1, IN2, OUT> operator =
            new IntervalJoinOperator<>(
                lowerBound,
                upperBound,
                lowerBoundInclusive,
                upperBoundInclusive,
                left.getType().createSerializer(left.getExecutionConfig()),
                right.getType().createSerializer(right.getExecutionConfig()),
                cleanedUdf
            );
        return left
            .connect(right)
            .keyBy(keySelector1, keySelector2)
            .transform("Interval Join", outputType, operator);
    }

    复制代码

    可见是先对两条流执行 connect() 和 keyBy() 操作,然后利用 IntervalJoinOperator 算子进行转换。在 IntervalJoinOperator 中,会利用两个 MapState 分别缓存左流和右流的数据。

    复制代码

    private transient MapState<Long, List<BufferEntry<T1>>> leftBuffer;
    private transient MapState<Long, List<BufferEntry<T2>>> rightBuffer;
    
    @Override
    public void initializeState(StateInitializationContext context) throws Exception {
        super.initializeState(context);
        this.leftBuffer = context.getKeyedStateStore().getMapState(new MapStateDescriptor<>(
            LEFT_BUFFER,
            LongSerializer.INSTANCE,
            new ListSerializer<>(new BufferEntrySerializer<>(leftTypeSerializer))
        ));
        this.rightBuffer = context.getKeyedStateStore().getMapState(new MapStateDescriptor<>(
            RIGHT_BUFFER,
            LongSerializer.INSTANCE,
            new ListSerializer<>(new BufferEntrySerializer<>(rightTypeSerializer))
        ));
    }

    复制代码

    其中 Long 表示事件时间戳,List<BufferEntry<T>> 表示该时刻到来的数据记录。当左流和右流有数据到达时,会分别调用 processElement1() 和 processElement2() 方法,它们都调用了 processElement() 方法,代码如下。

    复制代码

    @Override
    public void processElement1(StreamRecord<T1> record) throws Exception {
        processElement(record, leftBuffer, rightBuffer, lowerBound, upperBound, true);
    }
    
    @Override
    public void processElement2(StreamRecord<T2> record) throws Exception {
        processElement(record, rightBuffer, leftBuffer, -upperBound, -lowerBound, false);
    }
    
    @SuppressWarnings("unchecked")
    private <THIS, OTHER> void processElement(
            final StreamRecord<THIS> record,
            final MapState<Long, List<IntervalJoinOperator.BufferEntry<THIS>>> ourBuffer,
            final MapState<Long, List<IntervalJoinOperator.BufferEntry<OTHER>>> otherBuffer,
            final long relativeLowerBound,
            final long relativeUpperBound,
            final boolean isLeft) throws Exception {
        final THIS ourValue = record.getValue();
        final long ourTimestamp = record.getTimestamp();
        if (ourTimestamp == Long.MIN_VALUE) {
            throw new FlinkException("Long.MIN_VALUE timestamp: Elements used in " +
                    "interval stream joins need to have timestamps meaningful timestamps.");
        }
        if (isLate(ourTimestamp)) {
            return;
        }
        addToBuffer(ourBuffer, ourValue, ourTimestamp);
        for (Map.Entry<Long, List<BufferEntry<OTHER>>> bucket: otherBuffer.entries()) {
            final long timestamp  = bucket.getKey();
            if (timestamp < ourTimestamp + relativeLowerBound ||
                    timestamp > ourTimestamp + relativeUpperBound) {
                continue;
            }
            for (BufferEntry<OTHER> entry: bucket.getValue()) {
                if (isLeft) {
                    collect((T1) ourValue, (T2) entry.element, ourTimestamp, timestamp);
                } else {
                    collect((T1) entry.element, (T2) ourValue, timestamp, ourTimestamp);
                }
            }
        }
        long cleanupTime = (relativeUpperBound > 0L) ? ourTimestamp + relativeUpperBound : ourTimestamp;
        if (isLeft) {
            internalTimerService.registerEventTimeTimer(CLEANUP_NAMESPACE_LEFT, cleanupTime);
        } else {
            internalTimerService.registerEventTimeTimer(CLEANUP_NAMESPACE_RIGHT, cleanupTime);
        }
    }

    复制代码

    这段代码的思路是:

      1. 取得当前流 StreamRecord 的时间戳,调用 isLate() 方法判断它是否是迟到数据(即时间戳小于当前水印值),如是则丢弃。
      2. 调用 addToBuffer() 方法,将时间戳和数据一起插入当前流对应的 MapState。
      3. 遍历另外一个流的 MapState,如果数据满足前述的时间区间条件,则调用 collect() 方法将该条数据投递给用户定义的 ProcessJoinFunction 进行处理。collect() 方法的代码如下,注意结果对应的时间戳是左右流时间戳里较大的那个。
    private void collect(T1 left, T2 right, long leftTimestamp, long rightTimestamp) throws Exception {
        final long resultTimestamp = Math.max(leftTimestamp, rightTimestamp);
        collector.setAbsoluteTimestamp(resultTimestamp);
        context.updateTimestamps(leftTimestamp, rightTimestamp, resultTimestamp);
        userFunction.processElement(left, right, context, collector);
    }


                     4 调用 TimerService.registerEventTimeTimer() 注册时间戳为 timestamp + relativeUpperBound 的定时器,该定时器负责在水印超过区间的上界时执行状态的清理逻辑,防止数据堆积。注意左右流的定时器所属的 namespace 是不同的,具体逻辑则位于 onEventTime() 方法中。

    复制代码

    @Override
    public void onEventTime(InternalTimer<K, String> timer) throws Exception {
        long timerTimestamp = timer.getTimestamp();
        String namespace = timer.getNamespace();
        logger.trace("onEventTime @ {}", timerTimestamp);
        switch (namespace) {
            case CLEANUP_NAMESPACE_LEFT: {
                long timestamp = (upperBound <= 0L) ? timerTimestamp : timerTimestamp - upperBound;
                logger.trace("Removing from left buffer @ {}", timestamp);
                leftBuffer.remove(timestamp);
                break;
            }
            case CLEANUP_NAMESPACE_RIGHT: {
                long timestamp = (lowerBound <= 0L) ? timerTimestamp + lowerBound : timerTimestamp;
                logger.trace("Removing from right buffer @ {}", timestamp);
                rightBuffer.remove(timestamp);
                break;
            }
            default:
                throw new RuntimeException("Invalid namespace " + namespace);
        }
    }

    复制代码

     

     

    展开全文
  • 自从2005年谷歌提供在线卫星地图服务以来,具有实力大公司竞相角逐,到目前为止应该有数十种之多在线卫星地图服务。如果要想下载某个地方卫星图,不得不打开多个在线地图网站分别进行比较,事情较为繁锁。...
  • 1、二进制转换为进制 ...八进制,Octal,缩写OCT或O,一以8为基数计数法,采用0,1,2,3,4,5,6,7八个数字,逢八进一,以0o开头,如0o34,接下来以0o34为例说明八进制转换为进制的方法。 ...
  • 半导体二极管又称为晶体二极管,具有明显的单向导电性,是各种电器设备中应用较为广泛的一半导体元器件,也是日常维修中经常碰到的—元器件,常见的有普通二极管、稳压二极管、发光二极管、光敏二极管等。...
  • 【JS】深拷贝与浅拷贝区别,实现深拷贝种方法 壹 ❀ 引 如何区分深拷贝与浅拷贝,简单点来说,就是假设B复制了A,当修改A时,看B是否会发生变化,如果B也跟着变了,说明这是浅拷贝,拿人手短,如果B没变,...
  • 好象孩子们玩积木,虽然只有十来种或二三十种块块,可是在孩子们手中却可以搭成几十乃至几百种平面图形或立体模型。同样道理, 再复杂电路,经过分析就可发现,它也是由少数几个单元电路组成。因此初学者只要...
  • 前面介绍了JavaFX...比如JavaFX按钮控件名叫Button,对应SwingJButton,两按钮提供的方法也类似,下面是Button控件常用方法说明: setText:设置按钮文本。 setPrefSize:设置按钮推荐宽高。 setAl...
  • Java开发笔记(一百三五)Swing文件对话框除了常规提示对话框,还有一对话框也很常见,它叫做文件对话框。文件对话框又分为两小类:打开文件对话框、保存文件对话框,但在Swing中它们都用类型JFileChooser...
  • 给出范例都是自定义接口代码,其实Java系统本身就自带了若干行为接口,为了更好地理解系统接口详细用法,接下来还是从一个基础例子出发,抽丝剥茧地逐步说明接口调用方式。 早在阐述如何使用数组...
  • 除了常规提示对话框,还有一对话框也很常见,它叫做文件对话框。文件对话框又分为两小类:打开文件对话框、保存文件对话框,但在Swing中它们都用类型JFileChooser来表达。下面是JFileChooser常用方法说明...
  • 除了常规提示对话框,还有一对话框也很常见,它叫做文件对话框。文件对话框又分为两小类:打开文件对话框、保存文件对话框,但在Swing中它们都用类型JFileChooser来表达。下面是JFileChooser常用方法说明...
  • 给出范例都是自定义接口代码,其实Java系统本身就自带了若干行为接口,为了更好地理解系统接口详细用法,接下来还是从一个基础例子出发,抽丝剥茧地逐步说明接口调用方式。早在阐述如何使用数组时候...
  • 、网狐荣耀版手机端分享时出现“由于不支持分享类型,无法分享到微信“解决办法 去腾讯开放平台申请账号,审核通过后,在开放平台添加相应信息,就可以正常分享了。 十一、网狐荣耀版vs生成解决方案时出现...
  •  或者说,软件测试是根据软件开发各阶段规格说明和程序内部结构而精心设计一批测试用例(输入以及预期输出结果),并利用这些测试用例去运行程序,以发现程序中错误。 二思维:正向:验证程序是否正常...
  • 介绍几种常见的App调试方法,包括使用外置模拟器调试,比如几种国产模拟器的用法;电脑连接真机调试,描述真机调试要具备的条件;分发APK安装包给他人调试,着重说明签名证书的创建方法,以及如何利用签名证书导出...
  • 文章目录前言一、排序算法介绍1.1 排序分类二、算法时间复杂度2.1 度量一个程序(算法)执行时间种方法2.2 时间频度2.2.1 基本介绍2.2.2 举例说明-基本案例2.2.3 举例说明-忽略常数项2.2.4 举例说明-忽略低次项...
  • 上一章节,介绍了目前开发中常见的log4j2及logback日志框架的整合知识。在很多时候,我们在开发一个系统时,不管出于何考虑,比如是审计要求,或者防抵赖,还是保留操作痕迹的角度,一般都会有个全局记录日志的...
  • 下面简要说明各部分电路作用与要求: 1、键盘输入电路: 主要把实验过程中一些功能通过键盘设置到系统中。 2、显示电路: 显示主叫与被叫电路电话号码,同时显示通话时间。 3、输入输出扩展电路: 显示电路...
  • 按工具名说话有中科院nlpir,哈工大ltp,不知何出jieba,还有清华北大都有分词工具,还有很多,应该有。所有工具我都看了效果并不是他们吹嘘那么好,很多场景都无法正常分词。 主要问题:   emsp...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 327
精华内容 130
关键字:

十种常见的说明方法