问题[class](coding)

首先，我是编程初学者，所以请不要指望我对此有太多了解。

我正在为计算机科学的编程课程做一个项目，我们使用 JUnit 进行教授提供的测试。

当我尝试解决一个问题时，IDE 询问我是否愿意切换到 Java 预览版。这样一来，就引入了隐式声明的类。我们正在构建一个面向对象编程 (OOP) 项目，所以有一些文件只包含类、构造函数、实例方法以及这些对象的 getter 和 setter 方法。但没有主类。

现在，一个特定的类被分割并以某种方式包装在一起。所有 getter 最终都会被放到一个同名的“父”类中，而其余部分（对象、它们的构造函数、方法和 setter）则被“包装”在第一个类中的一个文件中。我这样描述，是因为它在左侧的树状层次结构中可见。

| |_ CustomerVO.java（最终类）| |_CustomerVO.java

父类有一个鼠标悬停消息，表示它将是“最终类”，尽管我从未这样声明过。

此外，运行代码会导致重复出现此错误消息：“语言级别‘23’不支持隐式声明的类”

嗯，呃。我不希望它们被支持。而且我从来没有把一个类声明为隐式的。我甚至不知道这到底是什么意思。

我在“设置”里修改了 Java 版本，删除了文件，然后重新修改了。但还是不行。一旦它包含 getter 方法，我又回到了这种奇怪的情况。

我能做些什么？

我尝试了前面提到的所有解决方案：

• 删除并重写类
• 在 intellijIDEA 中降级 Java 版本
• 重新安装整个 IDE
• 问chatty该怎么办。AI只是建议修改设置，然后忽略错误信息。也没什么帮助。
• 在网上其他地方找不到类似的问题。

我正在尝试在 Dafny 中制作 Dijkstra 算法。我编写了一个自定义 Pair 类：

class Pair <U,V>{
  var first:U
  var second:V

  constructor (x:U, y:V) 
  ensures first == x
  ensures second == y
  {
    first := x;
    second := y;
  }
  function getFirst():U
  reads this
  {
    first
  }
  function getSecond():V
  reads this
  {  
    second
  }
}

稍后再为主要算法自定义 PriorityQueue 和 Graph 类：

class PriorityQueue {
  var heap: array<Pair<int, int>>
  var size: int
  var capacity: int

  constructor (private_capacity: int)
  requires private_capacity > 0 
  ensures heap.Length == capacity
  ensures size <= heap.Length
  ensures size < capacity
  ensures size == 0
  {
    capacity := private_capacity;
    size := 0;
    var default := new Pair<int, int>(0, 0);
    heap := new Pair<int, int>[private_capacity](_ => default);
  }

  method parent(i: int) returns (p: int)
  requires 0 <= i < size
  requires i < heap.Length
  ensures p < heap.Length
  ensures i > 0 ==> 0 <= p < size
  ensures i == 0 ==> p == -1
  {
    if i > 0 {
      p := (i - 1) / 2;
    } else {
      p := -1;
    }
  }

  method leftChild(i: int) returns (l: int)
  requires 0 <= i < size
  ensures l == 2 * i + 1
  {
    l := 2 * i + 1;
  }

  method rightChild(i: int) returns (r: int)
  requires 0 <= i < size
  ensures r == 2 * i + 2
  {
    r := 2 * i + 2;
  }

  method swap(i: int, j: int)
  requires 0 <= i < size && 0 <= j < size
  requires i < heap.Length && j < heap.Length
  modifies heap
  ensures heap[i] == old(heap[j]) && heap[j] == old(heap[i])
  {
    var temp := heap[i];
    heap[i] := heap[j];
    heap[j] := temp;
  }

  method heapifyUp(i: int)
  requires 0 <= i < size
  requires size <= heap.Length
  modifies heap
  decreases i
  {
    var current_parent := parent(i);

    if current_parent >= 0 && current_parent < size
      && 0 <= current_parent < size 
      && heap[i].second < heap[current_parent].second 
    {
      swap(i, current_parent);
      if (current_parent < i) {
        heapifyUp(current_parent); 
      }
    }
  }

  method heapifyDown(i: int)
  requires 0 <= i < size
  modifies heap
  decreases size - i
  {
    var smallest := i;
    var left_child := leftChild(i);
    var right_child := rightChild(i);
    if left_child < size && left_child < heap.Length && heap[left_child].second < heap[smallest].second {
      smallest := leftChild(i);
    }
    if right_child < size && right_child < heap.Length && heap[right_child].second < heap[smallest].second {
      smallest := rightChild(i);
    }
    if smallest != i {
      swap(i, smallest);
      heapifyDown(smallest);
    }
  }

  method insert(item: int, priority: int)
  requires heap.Length == capacity
  requires 0 <= size < capacity
  modifies this, heap
  {
    heap[size] := new Pair<int, int>(item, priority);
    size := size + 1;
    heapifyUp(size - 1);
  }

  method extractMin() returns (item: int)
  requires size > 0
  requires heap.Length > 0
  requires size - 1 < heap.Length
  modifies this, heap
  ensures size == old(size) - 1
  {
    item := heap[0].first;
    heap[0] := heap[size - 1];
    size := size - 1;
    if size > 0 {
      heapifyDown(0);
    }
  }

  // Peek the element with the smallest priority without removing it
  method peek() returns (item: int)
  requires size > 0
  requires heap.Length > 0
  ensures item == heap[0].first
  {
    item := heap[0].first;
  }

  // Check if the priority queue is empty
  method isEmpty() returns (empty: bool)
  ensures empty == (size == 0)
  {
    empty := (size == 0);
  }
}

class Graph {
  var adj: map<int, seq<Pair<int, int>>>
  var numNodes: int

  constructor (nodes: int, edges: map<int, seq<Pair<int, int>>>)
  ensures adj == edges
  ensures numNodes == nodes
  {
    adj := edges;
    numNodes := nodes;
  }
}

在我看来，这些看起来不错，但是当我尝试实现类之外的 Dijkstras 方法时：

method Dijkstra(graph: Graph, start: int) returns (distances: map<int, int>)
requires 0 <= start < graph.numNodes
requires forall n :: n in graph.adj ==> 0 <= n < graph.numNodes
{
  var pq := new PriorityQueue(graph.numNodes);
  pq.insert(start, 0);
  
  var inf := 1000000000; // Representation of infinity

  var initMap := map n | n in graph.adj :: inf;
  distances := initMap[start := 0];


  while true
  invariant forall n :: n in graph.adj ==> distances[n] >= 0
  invariant distances[start] == 0
  {
    var empty := pq.isEmpty();
    if empty {
      break;
    }

    var u := pq.extractMin();

    if u in graph.adj {
      var edges := graph.adj[u];
      for i := 0 to |edges| - 1 {
        var edge := edges[i];
        var v := edge.first;
        var weight := edge.second;

        if distances[u] + weight < distances[v] {
          distances := distances[v := distances[u] + weight];
          pq.insert(v, distances[v]);
        }
      }
    }
  }

}

我收到多个错误，主要是

调用可能违反上下文的修改条款

对于pq.insert(start, 0)和var u := pq.extractMin()

我在 Dijkstra 方法中遗漏了什么，导致验证者不认可我的算法？

我把错误范围缩小到可能是insert优先级队列的功能。如果我删除修改子句，验证不会在 Dijkstra 算法方法中发现任何错误，但它会对我大喊大叫，因为我正在修改数组heap和size变量。

我正在尝试从定义类的文档中运行此代码：

#lang racket/class

(define book-class%
  (class object%
    (field (pages 5))
    (define/public (letters)
      (* pages 500))
    (super-new)))

当我尝试运行它时出现错误：

欢迎使用 DrRacket，版本 8.15 [cs]。语言：从源确定语言；内存限制：128 MB。standard-module-name-resolver：未找到模块路径的集合：racket/class/lang/reader
集合：“racket/class/lang”在集合目录中：
/home/bert/snap/racket/26/.local/share/racket/8.15/collects
/snap/racket/current/usr/share/racket/collects/... [166 个附加链接和包目录] 没有可用的包建议。[更新目录]

交互已禁用。

我最初是从 snap 命令安装的，但后来从他们网站的 shell 脚本安装了它，因为我无法让 Help->Racket 文档在原始安装下显示。但出现此错误后，我尝试删除 shell 安装（位于您的 $HOME 目录中），现在我的安装来自 Ubuntu 软件应用程序。

我单击了上述错误消息中的 [更新目录]，它会在 pkgs.racket-lang.org 上检查更新，但更新/检查后错误仍然存​​在。

在具有一些实例变量的 Crystal 类中：

class Coordinate
    def initialize(x : Int32, y : Int32)
        @x = x
        @y = y
    end
end

为了访问所述变量，您需要编写如下方法：

...
    def x
        @x
    end

在本例中这很好，但如果您需要访问大量变量，则可能会非常乏味且耗时。有没有一种方法可以普遍访问类的任何变量？

我确实想过尝试找到与 ruby​​ 相当的东西eval()，但由于 Crystal 是编译的，所以显然没有太多可以使用的东西。

理想的解决方案会做这样的事情：

...
    def get(var)
        @var
    end