为了方便演示这个细节，我们首先创建一些 model：

```
// 轮子
public class Wheel {
	...
}
```

```
// 汽车的轮子
public class CarWheel extends Wheel {
	// 汽车的轮子相较于轮子，没有特定的属性
}
```

```
// 后备箱
public class Trunk {
	...
}
```

```
// 汽车的后备箱
public class CarTrunk extends Trunk {
	// 汽车的后备箱相较于后备箱，没有特定的属性
}
```

```
// 汽车
public class Car {
	private List<CarWheel> wheels; // 汽车有好几个轮子
	private CarTrunk trunk; // 汽车只有一个后备箱
}
```

现在，假设我们要用 Mybatis 查询汽车，需要在 xml 文件中配置映射关系如下：

```
<resultMap id="carMap" type="Car">
	<collection property="wheels" resultMap="carWheelMap"></collection>
	<association property="trunk" resultMap="carTrunkMap"></association>
</resultMap>
<resultMap id="carWheelMap" type="Wheel">...</resultMap>
<resultMap id="carTrunkMap" type="CarTrunk">...</resultMap>
```

可以看到，在 <collection> 中使用的 carWheelMap 里，type 是可以为父类 Wheel 的；而在 <association> 中使用的 carTrunkMap 里，type 必须为明确的 CarTrunk，否则查询时会报错 Could not set property ……

<resultMap>中关于<association>的继承细节

1. pages 用来存放所有小程序的页面（官方建议把所有小程序的页面，都存放在 pages 目录中，以单独的文件夹存在）
   1. index 首页
      1. index.js 页面的脚本文件
      2. index.json 页面的配置文件
      3. index.wxml 页面的模板结构文件
      4. index.wxss 页面的样式表文件
   2. logs 日志页
      1. logs.js
      2. logs.json
      3. logs.wxml
      4. logs.wxss
2. utils 用来存放工具性质的模块（例如：格式化时间的自定义模块）
3. app.js 小程序项目的入口文件
4. app.json 小程序项目的全局配置文件
5. app.wxss 小程序项目的全局样式文件
6. project.config.json 项目的配置文件
7. sitemap.json 用来配置小程序及其页面是否允许被微信索引

微信小程序项目结构

1. 项目根目录中的 app.json 配置文件
   1. app.json 是当前小程序的全局配置，包括了小程序的所有页面路径、窗口外观、界面表现、底部 tab 等，如下：

      ```
      {
        "pages":[
          "pages/index/index",
          "pages/logs/logs"
        ],
        "window":{
          "backgroundTextStyle":"light",
          "navigationBarBackgroundColor": "#fff",
          "navigationBarTitleText": "Weixin",
          "navigationBarTextStyle":"black"
        },
        "style": "v2",
        "sitemapLocation": "sitemap.json"
      }
      
      ```
   2. 全局配置中的4个配置项的作用：
      1. pages：用来记录当前小程序所有页面的路径
      2. window：全局定义小程序所有页面的背景色、文字颜色等
      3. style：全局定义小程序组件所使用的样式版本
      4. sitemapLocation：用来指明 sitemap.json 的位置
2. 项目根目录中的 project.config.json 配置文件
   1. project.config.json 是项目配置文件，用来记录我们对小程序开发工具所做的个性化配置，如下：

      ```
      {
        "description": "项目配置文件",
        "packOptions": {
          "ignore": [],
          "include": []
        },
        "setting": {
          "bundle": false,
          "userConfirmedBundleSwitch": false,
          "urlCheck": true,
          "scopeDataCheck": false,
          "coverView": true,
          "es6": true,
          "postcss": true,
          "compileHotReLoad": false,
          "lazyloadPlaceholderEnable": false,
          "preloadBackgroundData": false,
          "minified": true,
          "autoAudits": false,
          "newFeature": false,
          "uglifyFileName": false,
          "uploadWithSourceMap": true,
          "useIsolateContext": true,
          "nodeModules": false,
          "enhance": true,
          "useMultiFrameRuntime": true,
          "useApiHook": true,
          "useApiHostProcess": true,
          "showShadowRootInWxmlPanel": true,
          "packNpmManually": false,
          "enableEngineNative": false,
          "packNpmRelationList": [],
          "minifyWXSS": true,
          "showES6CompileOption": false,
          "minifyWXML": true,
          "babelSetting": {
            "ignore": [],
            "disablePlugins": [],
            "outputPath": ""
          },
          "condition": false
        },
        "compileType": "miniprogram",
        "libVersion": "2.19.4",
        "appid": "wx0000000000000000",
        "projectname": "miniprogram-92",
        "condition": {},
        "editorSetting": {
          "tabIndent": "insertSpaces",
          "tabSize": 2
        }
      }
      
      ```
   2. 其中：
      1. setting 中保存了编译相关的配置
      2. projectname 中保存的是项目名称
      3. appid 中保存的是小程序的账号 ID
3. 项目根目录中的 sitemap.json 配置文件
   1. 微信现已开放小程序内搜索，效果类似于 PC 网页的 SEO。sitemap.json 文件用来配置小程序页面是否允许微信索引
   2. 当开发者允许微信索引时，微信会通过爬虫的形式，为小程序的页面内容建立索引。当用户的搜索关键字和页面的索引匹配成功的时候，小程序的页面将可能展示在搜索结果中
   3. 注意：sitemap 的索引提示是默认开启的，如需要关闭 sitemap 的索引提示，可在小程序项目配置文件 project.config.json 的 setting 中配置字段 checkSiteMap 为 false
4. 每个页面文件夹中的 .json 配置文件
   1. 小程序中的每一个页面，可以使用 .json 文件来对本页面的窗口外观进行配置，页面中的配置项会覆盖 app.json 的 window 中相同的配置项

微信小程序项目中的4种 JSON 配置文件

### 题目要求：

给你一个链表的头节点 head，请你编写代码，反复删去链表中由 总和 值为 0 的连续节点组成的序列，直到不存在这样的序列为止。

删除完毕后，请你返回最终结果链表的头节点。

你可以返回任何满足题目要求的答案。

（注意，下面示例中的所有序列，都是对 ListNode 对象序列化的表示。）

示例 1：

```
输入：head = [1,2,-3,3,1]
输出：[3,1]
提示：答案 [1,2,1] 也是正确的。
```

示例 2：

```
输入：head = [1,2,3,-3,4]
输出：[1,2,4]
```

示例 3：

```
输入：head = [1,2,3,-3,-2]
输出：[1]
```

提示：

* 给你的链表中可能有 1 到 1000 个节点。
* 对于链表中的每个节点，节点的值：1000 <= node.val <= 1000.

### 题解：

```
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeZeroSumSublists(ListNode head) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        Map<Integer, ListNode> seen = new HashMap<>();
        int prefix = 0;
        for (ListNode node = dummy; node != null; node = node.next) {
            prefix += node.val;
            seen.put(prefix, node);
        }
        prefix = 0;
        for (ListNode node = dummy; node != null; node = node.next) {
            prefix += node.val;
            node.next = seen.get(prefix).next;
        }
        return dummy.next;
    }
}
```

### 补充图解：

以输入[1,2,-3,3,1,-4,5]为例，输出为[5]

![](https://image.hackertalk.net/images/6d3ac6a1-6f61-412b-9950-63ee9f974d71)

LC1171 从链表中删去总和值为零的连续节点题解

**本文不讨论二叉树层次遍历**

刷题的时候看到一些二叉树遍历的解法，整理在这里作为笔记，也分享给大家

语言是 Java 的，我会采取代码+图解+说明形式来尽可能讲明白每种遍历方式

# 一些准备

为了便于整理和展示，我建立了一个简单的纯 Java 工程来测试各种解法

### 树节点类代码（TreeNode）

一个简单的树节点类：

```
public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode() {
    }

    TreeNode(int val) {
        this.val = val;
    }

    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}
```

### 树节点类图解

这是一棵二叉树，它拥有四个树节点，左侧虚线框内是它的简化图

![](https://image.hackertalk.net/images/e7b05c92-8e88-4367-bc12-48fdba5948bf)

### 工程文件结构

![](https://image.hackertalk.net/images/67484347-5d4e-4d7f-8f29-19ffc852a847)

### 工程文件说明

* TreeNode：树节点类
* RecursiveTraversal：递归遍历二叉树的各种实现
* IterativeTraversal：迭代遍历二叉树的各种实现
* MorrisTraversal：Morris 遍历二叉树的各种实现

# 递归解法（RecursiveTraversal）

![](https://image.hackertalk.net/images/b039288d-d22e-4de4-b99a-9c0521f7db63)

* 二叉树天然是一种递归结构，因此递归解法是最简洁的，代码量最少
  * 简洁不一定可读性好；对于不熟悉递归思想的人来说，递归解的可读性并不高
* 显而易见，递归解法总是会消耗大量栈空间
  * 而且，Java 编译器不支持尾递归优化（这与 Java 语言的设计哲学和实现细节有关）
* 另一方面，递归导致的大量函数调用，会产生一定不必要的开销

### 递归解法复杂度

| 时间复杂度 | 空间复杂度 |
| ----- | ----- |
| O(n)  | O(n)  |

### 前序（递归）

根左右

```
public static void preOrder(TreeNode root) {
    if (root == null) return;

    System.out.print(root.val + " ");
    preOrder(root.left);
    preOrder(root.right);
}
```

### 中序（递归）

左根右

```
public static void inOrder(TreeNode root) {
    if (root == null) return;

    inOrder(root.left);
    System.out.print(root.val + " ");
    inOrder(root.right);
}
```

### 后序（递归）

左右根

```
public static void postOrder(TreeNode root) {
    if (root == null) return;

    postOrder(root.left);
    postOrder(root.right);
    System.out.print(root.val + " ");
}
```

# 迭代解法（IterativeTraversal）

* 使用辅助数据结构（自定义栈）代替系统栈，有效降低栈空间消耗和溢出风险
* 避免了大量函数调用所产生的开销
* 代码复杂度相对较高
  * 然而，这并不意味着迭代解法更难以理解

### 迭代解法复杂度

| 时间复杂度 | 空间复杂度 |
| ----- | ----- |
| O(n)  | O(n)  |

### 前序（迭代，单层循环）

需要区分的一点是：

* 递归中，进入的是子树
* 迭代中，压入的是节点

尽管子树和节点看起来都是一个 TreeNode，但它们之间存在一些区别！

另外，这里使用 LinkedList（双向链表），而非 Stack

因为 Stack 底层是基于数组实现的，对于频繁插入和删除的场景下，并不太适合

> 注意：选择数组或链表实现栈的优劣取决于二叉树的分布特点

对于单层循环方式，我们利用栈的后进先出特点，要先压入右子节点，再压入左子节点

```
public static void preOrder1(TreeNode root) { // 前序单层循环
    if (root == null) return;

    Deque<TreeNode> stack = new LinkedList<>();
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        System.out.print(node.val + " ");
        if (node.right != null) stack.push(node.right);
        if (node.left != null) stack.push(node.left);
    }
}
```

### 前序（迭代，双层循环）

内循环中压入子树的所有左子节点

```
public static void preOrder2(TreeNode root) { // 前序双层循环
    if (root == null) return;

    TreeNode node = root;
    Deque<TreeNode> stack = new LinkedList<>();
    while (!stack.isEmpty() || node != null) {
        while (node != null) {
            System.out.print(node.val + " ");
            stack.push(node);
            node = node.left;
        }
        node = stack.pop();
        node = node.right;
    }
}
```

### 中序（迭代，双层循环）

对于单层循环方式，我们必须先把根节点压入栈中，所以它无法实现中序遍历

内循环中压入子树的所有左子节点

```
public static void inOrder(TreeNode root) { // 中序双层循环
    if (root == null) return;

    TreeNode node = root;
    Deque<TreeNode> stack = new LinkedList<>();
    while (!stack.isEmpty() || node != null) {
        while (node != null) {
            stack.push(node);
            node = node.left;
        }
        node = stack.pop();
        System.out.print(node.val + " ");
        node = node.right;
    }
}
```

### 后序（迭代，单层循环）

对于单层循环方式，后序遍历可以采用一个讨巧的办法：逆序输出

这需要额外的开销（对于下面的代码，既有辅助栈的空间开销，也有逆序的时间开销）

```
public static void postOrder1(TreeNode root) { // 后序单层循环
    if (root == null) return;

    Deque<TreeNode> stack1 = new LinkedList<>();
    Deque<TreeNode> stack2 = new LinkedList<>();
    stack1.push(root);
    while (!stack1.isEmpty()) {
        TreeNode node = stack1.pop();
        stack2.push(node);
        if (node.left != null) stack1.push(node.left);
        if (node.right != null) stack1.push(node.right);
    }
    while (!stack2.isEmpty()) {
        System.out.print(stack2.pop().val + " ");
    }
}
```

### 后序（迭代，双层循环）

内循环中压入子树的所有左子节点

```
public static void postOrder2(TreeNode root) { // 后序双层循环
    if (root == null) return;

    TreeNode node = root;
    TreeNode prev = null;
    Deque<TreeNode> stack = new LinkedList<>();
    while (!stack.isEmpty() || node != null) {
        while (node != null) {
            stack.push(node);
            node = node.left;
        }
        node = stack.pop();
        if (node.right == null || node.right == prev) {
            System.out.print(node.val + " ");
            prev = node;
            node = null;
        } else {
            stack.push(node);
            node = node.right;
        }
    }
}
```

### 5种迭代解法图解

我绘制了5种解法的核心代码 N-S 图，以便于横向对比

![](https://image.hackertalk.net/images/4ab675a6-0b47-47ba-8323-86ba2d7f27d7)

# Morris 解法（MorrisTraversal）

* 本质上，Morris 解法利用了二叉树节点中指向 null 的 left 和 right 属性（空闲指针），将原本的二叉树改造成临时线性结构，从而实现空间复杂度 O(1) 的遍历
* 在传统的线索二叉树中，我们一般需要使用左右 tag 来标识指向的是左右节点还是前驱或后继节点；Morris 解法可以看作是一种不使用 tag 的线索化二叉树方法
* Morris 解法不能直接适用于后序遍历，需要额外的操作才能实现（本文不展示）
* Morris 解法在遍历过程中修改了树的结构，因此不是线程安全的

### Morris 解法复杂度

| 时间复杂度 | 空间复杂度 |
| ----- | ----- |
| O(n)  | O(1)  |

### 前序（Morris）

```
public static void preOrder(TreeNode root) {
    if (root == null) return;

    TreeNode cur1 = root;
    TreeNode cur2 = null;
    while (cur1 != null) {
        cur2 = cur1.left;
        if (cur2 != null) {
            // 找到左子树的最右叶子节点
            while (cur2.right != null && cur2.right != cur1) {
                cur2 = cur2.right;
            }
            if (cur2.right == null) {
                cur2.right = cur1;
                System.out.print(cur1.val + " ");
                cur1 = cur1.left;
                continue;
            } else {
                cur2.right = null;
            }
        } else {
            System.out.print(cur1.val + " ");
        }
        cur1 = cur1.right;
    }
}
```

### 中序（Morris）

```
public static void inOrder(TreeNode root) {
    if (root == null) return;

    TreeNode cur1 = root;
    TreeNode cur2 = null;
    while (cur1 != null) {
        cur2 = cur1.left;
        if (cur2 != null) {
            // 找到左子树的最右叶子节点
            while (cur2.right != null && cur2.right != cur1) {
                cur2 = cur2.right;
            }
            if (cur2.right == null) {
                cur2.right = cur1;
                cur1 = cur1.left;
                continue;
            } else {
                cur2.right = null;
            }
        }
        System.out.print(cur1.val + " ");
        cur1 = cur1.right;
    }
}
```

整理：Java 二叉树遍历（递归、迭代、Morris）原创图解+代码

刚发现不能给自己点赞了

手搭我的世界基岩版后台网站 LiteloaderBDS - SQLite - Spring Boot - Vue：从零开始构建基于RESTful API 的后台系统；使用 Element-UI Plus 和 Three.js 实现可视化展览界面

昨天刷到一道题，做完后发现自己的解法和官方题解有一些差别，故分享一下

---

### 题目要求：

给定四个整数 rows ,   cols ,  rCenter 和 cCenter 。有一个 rows * cols 的矩阵，你在单元格上的坐标是 (rCenter, cCenter) 。

返回矩阵中的所有单元格的坐标，并按与 (rCenter, cCenter) 的 **距离** 从最小到最大的顺序排。你可以按 **任何** 满足此条件的顺序返回答案。

单元格(r1, c1) 和 (r2, c2) 之间的距离为|r1 - r2| + |c1 - c2|。

示例 1：

```
输入：rows = 1, cols = 2, rCenter = 0, cCenter = 0
输出：[[0,0],[0,1]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1]
```

示例 2：

```
输入：rows = 2, cols = 2, rCenter = 0, cCenter = 1
输出：[[0,1],[0,0],[1,1],[1,0]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2]
[[0,1],[1,1],[0,0],[1,0]] 也会被视作正确答案。
```

示例 3：

```
输入：rows = 2, cols = 3, rCenter = 1, cCenter = 2
输出：[[1,2],[0,2],[1,1],[0,1],[1,0],[0,0]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2,2,3]
其他满足题目要求的答案也会被视为正确，例如 [[1,2],[1,1],[0,2],[1,0],[0,1],[0,0]]。
```

提示：

* 1 <= rows, cols <= 100
* 0 <= rCenter < rows
* 0 <= cCenter < cols

### 官方题解：

* 基础的是二维矩阵存储曼哈顿距离，排序后输出
* 进阶一点，进行分桶排序，降低时间复杂度
* 几何法，从中心向外枚举曼哈顿距离，用广度优先搜索

### 我的思路图如下（生长方块）：

---

![](https://content.hackertalk.net/pub/gqeBw6-7d2zmAe)

---

首先手动放置中心位置的上下左右四个方块（可能不足四个，根据输入情况）到队列中，它们有各自的方向，可以根据方向进行生长

每一轮生长的方块都放置到队列中，这样取出的方块与中心的曼哈顿距离正是从小到大

步骤是先从队列中取出方块，让方块生长，新方块放置到队尾，然后将此取出方块的坐标填入数组中

switch 处利用了穿透

### 我的代码如下：

```java
class Solution {
    public static int[][] allCellsDistOrder(int rows, int cols, int rCenter, int cCenter) {
        GrowthBlock.rows = rows;
        GrowthBlock.cols = cols;
        int[][] answer = new int[rows * cols][2];
        answer[0][0] = rCenter;
        answer[0][1] = cCenter;
        int i = 1;
        Queue<GrowthBlock> blocks = new LinkedList<>();
        if (rCenter - 1 >= 0) {
            blocks.offer(new GrowthBlock(rCenter - 1, cCenter, 6));
        }
        if (rCenter + 1 < rows) {
            blocks.offer(new GrowthBlock(rCenter + 1, cCenter, 2));
        }
        if (cCenter - 1 >= 0) {
            blocks.offer(new GrowthBlock(rCenter, cCenter - 1, 0));
        }
        if (cCenter + 1 < cols) {
            blocks.offer(new GrowthBlock(rCenter, cCenter + 1, 4));
        }
        while (!blocks.isEmpty()) {
            GrowthBlock block = blocks.poll();//取出一个block
            answer[i++] = block.getInts();//输出到答案
            for (GrowthBlock b : block.growth()) {//生长并填入新的block
                blocks.offer(b);
            }
        }
        return answer;
    }
}

class GrowthBlock {//生长块
    public static int rows;
    public static int cols;
    byte x;
    byte y;
    byte growthDir;//生长方向

    //0右上 1右 2右下 3下 4左下 5左 6左上 7上
    public GrowthBlock(int x, int y, int growthDir) {
        this.x = (byte) x;
        this.y = (byte) y;
        this.growthDir = (byte) growthDir;
    }

    public int[] getInts() {//返回坐标
        return new int[]{x, y};
    }

    public List<GrowthBlock> growth() {//生长并返回
        List<GrowthBlock> bs=new ArrayList<>();
        switch (growthDir) {
            case 0:
                if (y - 1 >= 0) {
                    bs.add(new GrowthBlock(x, y - 1, 0));
                }
            case 1:
                if (x + 1 < rows) {
                    bs.add(new GrowthBlock(x + 1, y, 1));
                }
                break;
            case 2:
                if (x + 1 < rows) {
                    bs.add(new GrowthBlock(x + 1, y, 2));
                }
            case 3:
                if (y + 1 < cols) {
                    bs.add(new GrowthBlock(x, y + 1, 3));
                }
                break;
            case 4:
                if (y + 1 < cols) {
                    bs.add(new GrowthBlock(x, y + 1, 4));
                }
            case 5:
                if (x - 1 >= 0) {
                    bs.add(new GrowthBlock(x - 1, y, 5));
                }
                break;
            case 6:
                if (x - 1 >= 0) {
                    bs.add(new GrowthBlock(x - 1, y, 6));
                }
            case 7:
                if (y - 1 >= 0) {
                    bs.add(new GrowthBlock(x, y - 1, 7));
                }
                break;
        }
        return bs;
    }
}
```

LC1030 距离顺序排列矩阵单元格题解（生长方块）

JavaFX实现坦克大战

如题，下面的陈述内容来自《Java编程思想》：

9.8	嵌套接口

接口可以嵌套在类或其他接口中。这揭示了许多非常有趣的特性：

```java
package chapter_09;

class A{
	interface B{void f();}
	public class BImp implements B{public void f() {};}
	private class BImp2 implements B{public void f() {};}
	public interface C{void f();}
	class CImp implements C{public void f() {};}
	private class CImp2 implements C{public void f() {};}
	private interface D{void f();}
	private class DImp implements D{public void f() {};}
	public class DImp2 implements D{public void f() {};}
	public D getD() {return new DImp2();}
	private D dRef;
	public void receiveD(D d) {
		dRef=d;
		dRef.f();
	}
}

interface E{
	interface G{void f();}
	public interface H{void f();}//Redundant "public"
	void g();
	//Cannot be private within an interface:
//	private interface I{};
}

public class NestingInterfaces {
	public class BImp implements A.B{
		public void f() {}
	}
	class CImp implements A.C{
		public void f() {}
	}
	//Cannot implement a private interface except
	//within that interface's defining class:
//	class DImp implements A.D{
//		public void f() {}
//	}
	class EImp implements E{
		public void g() {};
	}
	class EGImp implements E.G{
		public void f() {};
	}
	class EImp2 implements E{
		public void g() {}
		class EG implements E.G{
			public void f() {}
		}
	}
	public static void main(String[] args) {
		A a=new A();
		//Can't access A.D:
//		A.D ad=a.getD();
		//Doesn't return anything but A.D:
//		A.DImp2 di2=a.getD();
		//Cannot access a member of the interface:
//		a.getD().f();
		//Only another A can do anything with getD():
		A a2=new A();
		a2.receiveD(a.getD());
	}
}///:~
```

在类中嵌套接口的语法是相当显而易见的，就像非嵌套接口一样，可以拥有public和“包访问”两种可视性

作为一种新添加的方式，接口也可以被实现为private的，就像在A.D中所看到的（相同的语法既适用于嵌套接口，也适用于嵌套类）。那么private的嵌套接口能带来什么好处呢？读者可能会猜想，它只能够被实现为DImp中的一个private内部类，但是A.DImp2展示了它同样可以被实现为public类。但是，A.DImp2只能被其自身所使用。你无法说它实现了一个private接口D。因此，实现一个private接口只是一种方式，它可以强制该接口中的方法定义不要添加任何类型信息（也就是说，不允许向上转型）

getD()方法使我们陷入了一个进退两难的境地，这个问题与private接口相关：它是一个返回对private接口的引用的public方法。你对这个方法的返回值能做些什么呢？在main()中，可以看到数次尝试使用返回值的行为都失败了。只有一种方式可成功，那就是将返回值交给有权使用它的对象。在本例中，是另一个A通过receiveD()方法来实现的

接口E说明接口彼此之间也可以嵌套。然而，作用于接口的各种规则，特别是所有的接口元素都必须是public的，在此都会被严格执行。因此，嵌套在另一个接口中的接口自动就是public的，而不能声明为private的

NestingInterfaces展示了嵌套接口的各种实现方式，特别要注意的是，当实现某个接口时，并不需要实现嵌套在其内部的任何接口。而且，private接口不能在定义它的类之外被实现

添加这些特性的最初原因可能是出于对严格的语法一致性的考虑，但是我总认为，一旦你了解了某种特性，就总能够找到它的用武之地

提问贴：Java一个类内部的private接口可以有哪些实际应用

详解Java实现小游戏2048（使用JavaFX）

点击顶部菜单栏Window->Show View->Project Explorer

从Project Explorer栏展开到要生成类图的对应java文件，然后拖曳，从Navigator栏进行拖曳是无效的

Eclipse插件AmaterasUML创建Class Diagram后拖曳java文件生成类图无反应的解决方法

“通常为了减少时间损失，采用猜测法，即当条件转移指令从取指阶段进入执行阶段时，指令部件仍按顺序预取下一条指令。这样，如果条件不成立，转移没有发生，则没有时间损失；若条件成立，转移发生，则所取的指令必须丢掉，并再取新的指令”

上面是CPU硬件层面的行为。那么这是否能表明在高级语言如c或java里将最可能发生的事件放在if语句块里而非else语句块里是更高效的

高级语言条件语句效率问题

标识符

483DAB9E-B587-4DAE-936C-201F5BC4BCBA

备注

Error Domain=kCFStreamErrorDomainSSL Code=-9806"(null)" UserInfo=/NSLocalizedRecoverySuggestion=Errorcode definition can be found in Apple's SecureTransport.h}

请求信息

CONNECT m.m******(手动打码).pt:443 HTTP/1.1

请求头部

Host: m.m*******.ptConnection: keep-alive

发送请求头部

未发送

服务端开始响应

未响应

请求完成2024/04/26 10:11:40.529

 app无法登录，抓包数据。网页版可以登录，求分析求解

前些天一直在找便宜的云服务器，偶然间发现一免费的云平台，这里推荐给大家。

就是阿贝云，网站是https://www.abeiyun.com

说一下感受

1、阿贝云虽然是一小众的云平台，重在免费，该有的东西都有，还能免备案这是最舒服的。

2、使用了一天，上了项目，网速不慢。

3、唯一要指出来就是磁盘太小。

分享免费云服务器

拉取了rustbuster的v3.0.3版本文件, 二进制文件无法使用, 执行结果如下:

```bash
[root_cn@archlinux target]$ ./rustbuster-v3.0.3-x86_64-unknown-linux-gnu
./rustbuster-v3.0.3-x86_64-unknown-linux-gnu: error while loading shared libraries: libssl.so.1.1: cannot open shared object file: No such file or directory
```

拉取了main源码, 想自行尝试编译, 然后卡在了openssl, 以下为报错信息:

```rust
The following warnings were emitted during compilation:

warning: openssl-sys@0.9.47: build/expando.c:4:24: error: pasting "RUST_VERSION_OPENSSL_" and "(" does not give a valid preprocessing token
warning: openssl-sys@0.9.47:     4 | #define VERSION2(n, v) RUST_VERSION_##n##_##v
warning: openssl-sys@0.9.47:       |                        ^~~~~~~~~~~~~
warning: openssl-sys@0.9.47: build/expando.c:5:23: note: in expansion of macro ‘VERSION2’
warning: openssl-sys@0.9.47:     5 | #define VERSION(n, v) VERSION2(n, v)
warning: openssl-sys@0.9.47:       |                       ^~~~~~~~
warning: openssl-sys@0.9.47: build/expando.c:10:1: note: in expansion of macro ‘VERSION’
warning: openssl-sys@0.9.47:    10 | VERSION(OPENSSL, OPENSSL_VERSION_NUMBER)
warning: openssl-sys@0.9.47:       | ^~~~~~~

error: failed to run custom build command for `openssl-sys v0.9.47`

Caused by:
  process didn't exit successfully: `/mnt/d/work/file/rust/rustbuster/target/debug/build/openssl-sys-c5a482a9e0e49574/build-script-main` (exit status: 101)
  --- stdout
  cargo:rustc-cfg=const_fn
  cargo:rerun-if-env-changed=X86_64_UNKNOWN_LINUX_GNU_OPENSSL_LIB_DIR
  X86_64_UNKNOWN_LINUX_GNU_OPENSSL_LIB_DIR unset
  cargo:rerun-if-env-changed=OPENSSL_LIB_DIR
  OPENSSL_LIB_DIR unset
  cargo:rerun-if-env-changed=X86_64_UNKNOWN_LINUX_GNU_OPENSSL_INCLUDE_DIR
  X86_64_UNKNOWN_LINUX_GNU_OPENSSL_INCLUDE_DIR unset
  cargo:rerun-if-env-changed=OPENSSL_INCLUDE_DIR
  OPENSSL_INCLUDE_DIR unset
  cargo:rerun-if-env-changed=X86_64_UNKNOWN_LINUX_GNU_OPENSSL_DIR
  X86_64_UNKNOWN_LINUX_GNU_OPENSSL_DIR unset
  cargo:rerun-if-env-changed=OPENSSL_DIR
  OPENSSL_DIR unset
  cargo:rustc-link-lib=ssl
  cargo:rustc-link-lib=crypto
  OPT_LEVEL = Some("0")
  TARGET = Some("x86_64-unknown-linux-gnu")
  HOST = Some("x86_64-unknown-linux-gnu")
  CC_x86_64-unknown-linux-gnu = None
  CC_x86_64_unknown_linux_gnu = None
  HOST_CC = None
  CC = None
  CFLAGS_x86_64-unknown-linux-gnu = None
  CFLAGS_x86_64_unknown_linux_gnu = None
  HOST_CFLAGS = None
  CFLAGS = None
  CRATE_CC_NO_DEFAULTS = None
  DEBUG = Some("true")
  CARGO_CFG_TARGET_FEATURE = Some("fxsr,sse,sse2")
  running: "cc" "-O0" "-ffunction-sections" "-fdata-sections" "-fPIC" "-g" "-fno-omit-frame-pointer" "-m64" "-Wall" "-Wextra" "-E" "build/expando.c"
  cargo:warning=build/expando.c:4:24: error: pasting "RUST_VERSION_OPENSSL_" and "(" does not give a valid preprocessing token
  cargo:warning=    4 | #define VERSION2(n, v) RUST_VERSION_##n##_##v
  cargo:warning=      |                        ^~~~~~~~~~~~~
  cargo:warning=build/expando.c:5:23: note: in expansion of macro ‘VERSION2’
  cargo:warning=    5 | #define VERSION(n, v) VERSION2(n, v)
  cargo:warning=      |                       ^~~~~~~~
  cargo:warning=build/expando.c:10:1: note: in expansion of macro ‘VERSION’
  cargo:warning=   10 | VERSION(OPENSSL, OPENSSL_VERSION_NUMBER)
  cargo:warning=      | ^~~~~~~
  exit status: 1

  --- stderr
  thread 'main' panicked at /home/root_cn/.cargo/registry/src/mirrors.sjtug.sjtu.edu.cn-4f7dbcce21e258a2/openssl-sys-0.9.47/build/main.rs:126:13:

  Header expansion error:
  Error { kind: ToolExecError, message: "Command \"cc\" \"-O0\" \"-ffunction-sections\" \"-fdata-sections\" \"-fPIC\" \"-g\" \"-fno-omit-frame-pointer\" \"-m64\" \"-Wall\" \"-Wextra\" \"-E\" \"build/expando.c\" with args \"cc\" did not execute successfully (status code exit status: 1)." }

  Failed to find OpenSSL development headers.

  You can try fixing this setting the `OPENSSL_DIR` environment variable
  pointing to your OpenSSL installation or installing OpenSSL headers package
  specific to your distribution:

      # On Ubuntu
      sudo apt-get install libssl-dev
      # On Arch Linux
      sudo pacman -S openssl
      # On Fedora
      sudo dnf install openssl-devel

  See rust-openssl README for more information:

      https://github.com/sfackler/rust-openssl#linux

  note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
warning: build failed, waiting for other jobs to finish...
```

经过检查openssl与rust均为最新版本, 

```bash
[root_cn@archlinux target]$ sudo pacman -S rust
[sudo] password for root_cn:
warning: rust-1:1.77.2-1 is up to date -- reinstalling
resolving dependencies...
looking for conflicting packages...

Package (1)  Old Version  New Version  Net Change

extra/rust   1:1.77.2-1   1:1.77.2-1     0.00 MiB

Total Installed Size:  249.41 MiB
Net Upgrade Size:        0.00 MiB

:: Proceed with installation? [Y/n] n
[root_cn@archlinux target]$ sudo pacman -S openssl
warning: openssl-3.2.1-1 is up to date -- reinstalling
resolving dependencies...
looking for conflicting packages...

Package (1)   Old Version  New Version  Net Change

core/openssl  3.2.1-1      3.2.1-1        0.00 MiB

Total Installed Size:  11.45 MiB
Net Upgrade Size:       0.00 MiB

:: Proceed with installation? [Y/n] n
```

在网上找了一下, 查到资料, 在[rust-openssl的issues](https://github.com/sfackler/rust-openssl/issues/1227)中提到类似报错, 得到解释如下:

> If you are cross compiling to MUSL, you either need to point openssl-sys to the location that you have a copy of OpenSSL cross compiled to MUSL, or tell it to build a copy of OpenSSL itself with the vendored feature.
>
>	如果你是交叉编译到MUSL，你需要将openssl-sys指向你有一个交叉编译到MUSL的OpenSSL副本的位置，或者告诉它用vendored特性构建一个OpenSSL本身的副本。

由于不会rust, 依靠关键词"交叉编译"+"cargo"搜索到了[cargo交叉编译rust程序](https://blog.csdn.net/tyc880616/article/details/104371502), 顺着找到文件:

```
[root_cn@archlinux .cargo]$ cat ~/.cargo/config
[source.crates-io]
replace-with = 'sjtu' # 指定使用下面哪个源，修改为source.后面的内容即可

# 中国科学技术大学
[source.ustc]
registry = "https://mirrors.ustc.edu.cn/crates.io-index"

# 上海交通大学
[source.sjtu]
registry = "https://mirrors.sjtug.sjtu.edu.cn/git/crates.io-index/"

# 清华大学
[source.tuna]
registry = "https://mirrors.tuna.tsinghua.edu.cn/git/crates.io-index.git"

# rustcc社区
[source.rustcc]
registry = "https://code.aliyun.com/rustcc/crates.io-index.git"
```

没有找到交叉编译的设置, 由于本人不会rust, 线索断了, 尝试向大家寻求一波帮助, 非常感谢阅读.



急切寻求rust编译问题帮助(archlinux, openssl)

永久免费，无需注册

[https://good.xjai.top](https://good.xjai.top)

分享免费GPT4站点

[MoienTajik/AspNetCore-Developer-Roadmap (github.com)](https://github.com/MoienTajik/AspNetCore-Developer-Roadmap/blob/master/ReadMe.zh-Hant.md)

![](https://github.com/MoienTajik/AspNetCore-Developer-Roadmap/raw/master/aspnetcore-developer-roadmap.zh-Hant.png)



【轉貼】ASP.NET Core Developer Roadmap in 2024

南京大学数字金融 - 新华报业集团联合诚邀全职博士后！

【研究方向涵盖】

数智传播、数智金融经济、数据金融经济、数智政务、数智监管治理，以及“大数据、大模型、大计算”全新范式等方向理论与实践

 【具体研究领域】

包括 Bigdata4SocialScience、AI4SocialScience、LLM4SocialScience、Blockchain4SocialScience，以及先进信息技术融合创新在数智金融经济、数智传播社会、数智健康医疗、数智政务治理中的应用。

【薪资待遇优渥】

年薪可达 30 万人民币左右，另有绩效奖金及江苏省和南京市人才补贴。具体薪资需与HR面议，总收入依据专业背景和技能经验而定（计算机 AI 背景者薪资更优）。

【欢迎学科交叉、专业背景不限】

不限制专业背景，致力于构建一个多元、开放、包容的科研环境，因此，欢迎计算机、软件、大数据、人工智能、区块链、隐私计算、数据安全、数据科学等背景的博士人才，也热切邀请具有人文社科背景的博士加入我们的团队，共同探索信息技术与社会科学的交叉前沿。也欢迎其他编程能力强的理工科博士毕业生（即使没有AI等背景也欢迎）。

【南京大学研究中心】

南京大学研究中心为双院士领军的校级科研和创新平台，详情请见：fintech.nju.edu.cn。

【团队氛围】

学科交叉、理论与实践相结合、国际化视野、行业前沿视角和项目。

【联系我们】

请感兴趣的朋友将个人简历发送至邮箱:blockchainfintech@126.com。

【更多招募】 南京大学研究中心招收硕士生、博士生、博士后、青年教师、研究员，也欢迎访问、客座、联培以及科研助理（有些岗位可兼职或远程合作）等

欢迎加入我们，您将在这个富有挑战性和机遇的环境中，开启广阔的职业发展道路，实现个人价值与学术梦想的双赢！

期待您的加入，携手共创数智未来！

南京大学研究中心诚募博士后



![](https://image.hackertalk.net/images/62537abc-405f-44da-a67e-9f18082f3d74)















sqlmap -u "xxxxx.com/#/login" --all  --delay 1 --batch --random-agent

[CRITICAL]can't establish SSL connection.

![](https://image.hackertalk.net/images/4a856cac-750c-4972-aa1f-4bf02f000394)

sqlmap -r win.txt --dbs

**

[CRITICAL] anti-CSRF token 'XSRF-TOKEN' can't be found 


**


