Алексей Федотов's questions

有必要获取存储有关分钟和秒信息的两个变量之间的时间差。例如 date1 存储值 01:15（1 分 15 秒），date2 变量存储值 04:20（4 分 20 秒）。需要找到 date3 = date2 - date1。同时，不以任何方式使用有关小时、天、月、年的信息 => 不需要。我尝试使用 DateTime 来解决问题，但是根据元数据中的信息，DateTime 具有以下构造函数：

public DateTime(long ticks);
public DateTime(long ticks, DateTimeKind kind);
public DateTime(int year, int month, int day);
public DateTime(int year, int month, int day, Calendar calendar);
public DateTime(int year, int month, int day, int hour, int minute, int second);
public DateTime(int year, int month, int day, int hour, int minute, int second, DateTimeKind kind);
<еще несколько вариаций>
public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, Calendar calendar, DateTimeKind kind);

没有只需要几分钟和几秒钟的构造函数。我阅读了有关使用自己的时间格式的信息，但如果我理解正确，DateTime 变量仍然存储有关年、小时和月的信息，我只能编辑输出选项，例如

Console.WriteLine(now.ToString("hh:mm:ss"));

是否可以按我需要的方式使用 DateTime 变量，并且只在其中存储有关分钟和秒的信息？或者我是否需要为这些目的使用其他类？我注意到存储在变量中的分钟和秒与现在无关（即现在创建 DateTime = DateTime.Now; 是不合适的）。

我正在尝试调整 HoughCircles() 方法，而不是搜索圆圈，而是搜索图片中我需要的颜色的像素。看不懂cannyThreshold、accumulatorThreshold、dp方法的输入参数是干什么的：

*cannyThreshold - 两个传递给 Canny 边缘检测器的较高阈值（较低的阈值将小两倍）。

*accumulatorThreshold - 中心检测阶段的累加器阈值。它越小，可能检测到的错误圆圈就越多。将首先返回与较大的累加器值相对应的圆圈

*dp - 用于检测圆心的累加器的解算。例如，如果为 1，累加器将具有与输入图像相同的分辨率，如果为 2 - 累加器将具有两倍的宽度和高度，等等

请从元数据中翻译此信息。

我为自己想出了一个任务：每分钟显示一条消息。此代码显示消息，但不是一次。这不应该，消息应该只显示一次。我真的不明白这个错误。

DateTime fixDate = DateTime.Now;
        int checkPoint = fixDate.Second;
        bool key = false;
        Console.WriteLine($"Секунды при запуске {checkPoint}");
        for (; ; )
        {
            DateTime now = DateTime.Now;

            if ((checkPoint == now.Second) && (key = true))
            {
                Console.WriteLine("Прошла минута");
                key = false;
            }
            if (checkPoint != now.Second)
            {
                key = true;
            }
        }

我确定了日期，为自己节省了一秒钟的程序启动时间。我开始不断更新日期，如果秒等于检查点并且标志为真，那么我会显示一条消息。只有当第二个不等于检查点时，标志才会更新并变为真。从这里开始，如果标志只有在第二个不等于检查点时才变为真，那么如何显示消息就完全不清楚了。我尝试使用调试，但由于时间的推移，该消息永远不会显示，因为标志始终为假。如何正确改进算法，使消息每分钟只显示一次？

研究事件这个话题，我给自己构思了一个任务：如果产生了给定的数字，那么就触发一个事件。我定义了将生成数字的代码：

delegate void RightNumber(object sendler, EventArguments e);

class Produce
{
    public event RightNumber NumberFound;
    private int rightNumber;
    Random random = new Random();

    public Produce(int rightNumber)
    {
        this.rightNumber = rightNumber;
    }

    public void FindNumber()
    {
        for (int counter = 0; counter < 100; counter++)
        {
            int newValue = random.Next(10);
            if (newValue == rightNumber)
                NumberFound(this, new EventArguments(rightNumber));
        }
    }
}

class EventArguments
{
    public int rightNumber
    {
        get
        {
            return rightNumber;
        }
        private set
        {
            rightNumber = value;
        }
    }


    public EventArguments(int rightNumber)
    {
        this.rightNumber = rightNumber;
    }
}

以及程序的调用部分：

 public static void Main()
    {

        Console.WriteLine("Введите задуманное число");
        string str = Console.ReadLine();
        int rightNumber = Convert.ToInt32(str);

        Produce produce = new Produce(rightNumber);
        produce.NumberFound += DisplayResult;

        produce.FindNumber();
        Console.ReadKey();
    }

    public static void DisplayResult(object sendler, EventArguments e)
    {
        Console.WriteLine($"Найдено загаданное число {e.rightNumber}");
    }

执行程序时，控制台抛出 Process is terminate due to StackOverflowException，环境指向这段代码：

如果找到所需的号码，就会出现问题。我尝试进行调试，但由于我的经验不足，我无法弄清楚。

我还想听听关于代码风格的评论。一般来说，怎样才能做得更好？

相对来说，有一个简单的继承层次结构，比如ISomeInterface接口，还有一些继承自它的类，比如MyClass。创建对象时，我可以进行以下输入：

ISomeInterface test = new MyClass();

问题是，为什么要这样做？我会从这样的演员阵容中得到什么好处？必须与例如以下创建对象的方式有所不同：

MyClass test = new MyClass();

我看到很多例子，其中一个接口变量被分配给一个继承这个接口的类的对象（通常它与泛型集合相关联），但直到现在我才意识到我不明白为什么我们在这个中构建代码方法。

处理泛型主题（根据 Shield 4.0），有必要编写一个泛型方法，如果数组包含某个值，该方法将返回布尔值 true。本书继续解释说，由于 T 是泛型类型，为了比较泛型类型的对象，这些对象的类必须实现带有 T 或 IEquatable 参数的 IEquatable 接口。还写到在这些接口中定义了一个比较 Equals() 的方法。这立即导致几个问题：

首先，为什么我们需要实现任何接口来比较泛型类型对象？Equals() 方法是指 Object => 中定义的方法，存在于每个对象中。我意识到为了在这个例子中比较对象，你需要实现上面描述的接口，但我不明白为什么要这样做。

其次，根据 Shield，正如我上面写的，为了比较泛型方法中的对象，建议使用参数 T 或 IEqutable 来实现 Equtable。一个是参数化的，另一个不是。问题是在哪种情况下应该使用哪一个？

此外，在他的书中，Shield 演示了一个检查值是否在数组中的方法示例。这是方法：

 public static bool IsIn<T>(T what, T[] obs) where T : IEquatable<T>
    {
        foreach(T v in obs)
        {
            if (v.Equals(what))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }

这里还有两个问题。

首先，让我先说这种方法行不通。工作室产生编译错误“并非所有方法分支都返回值”。我重新检查了几次编写的代码，但错误仍然存​​在。如何解决？

其次，我不确定我是否正确理解该方法的签名意味着只有实现 IEquatable 接口的那些类型的对象才能传递给该方法？换句话说，如果我想将一些学生的数组传递给该方法并在其中找到 Vasya Pupkin，那么我的学生类应该是这样的？

class Student<T> : IEquatable<T>
{
    public string Name;
    public string Surname;

    public bool Equals(T other)
    {
        //some code for compare
        return false;
    }
}

请按顺序回答所有问题。谢谢

有必要编写一个泛型方法，该方法接受一个数字数组（int、long 等），向每个元素添加一些相同类型的常量，然后返回一个新数组。我试图这样实现它：

static public T[] SomeMethod<T>(T[] myArray, T myConst)
    {
        T[myArray.Length] resultArray = default(T);

        for (int counter = 0; counter < myArray.Length; counter++)
        {
            resultArray[counter] = myArray[counter] + myConst;
        }
        return resultArray;
    }

首先，根据 Shield 4.0，这种泛型方法的语法如下：return_type method_name<list_of_type_parameters>(list_of_parameters) {...}。这里马上就出现了一个问题——是否有必要在方法名称后的尖括号中指定参数列表？之前实现其他方法，我没有这样做，一切正常。这是否意味着没有必要？其次，在此方法中声明新 resultArray 的局部变量时，出现错误，解释如下：“'T' is an type that is not valid in this context.” 但为什么？毕竟，代替所有 <> 将有一个类型作为参数传递，包括我在哪里创建一个新的结果数组。为什么会出现这个错误？我也尝试至少部分解决这个问题，

static public T[] SomeMethod<T>(T[] myArray, T myConst)
    {
        for (int counter = 0; counter < myArray.Length; counter++)
        {
            myArray[counter] = myArray[counter] + myConst;
        }
        return myArray;
    }

但是，在这种情况下，在行 myArray[counter] = myArray[counter] + myConst; 发生错误“运算符'+'不能应用于'T'和'T'类型的操作数”。我也不明白这个错误。我在做什么错，以及如何解决问题？

考虑到泛型限制的话题，我不明白构造函数限制的实际应用是什么。这是一个班级的例子，比如一个学生：

class Student
{
    public Student(){}
}

这是通用类：

class Class2<T> where T : new()
{
    public T typeTinClass2;

    public Class2()
    {
        typeTinClass2 = new T();
    }
}

让我们说一下程序的其他一些琐碎的调用部分：

class Program
{
    static void Main()
    {
        Class2<Student> vasiliy = new Class2<Student>();

    }
}

问题很简单——在什么实际情况下可以使用它？假设对类和接口有限制，为什么要理解它们并不难，因为什么时候以及如何使用它马上就清楚了。但是如何使用构造函数约束呢？是的，可以在通用代码中创建传递给 <> 的这种类型的类的实例，我也理解存在例如这种可能性：

Console.WriteLine(vasiliy.typeTinClass2.someField);

但在什么情况下可能需要这样做？为了让我对构造函数使用约束，我应该面对什么任务？

我想学习如何在反射的帮助下创建一个类的对象，它有一个显式的构造函数。假设有一个班级学生：

class Student
{
    private int _temp = 10;
    private string name = "Vasya";

}

在这种情况下，创建实例时使用反射如下所示：

class Program
{  
    static void Main(string[] args)
    {
        Type type = typeof(Student);

        ConstructorInfo info = type.GetConstructor(new Type[] { });
        object student = info.Invoke(new object[] { });
     }
}

但是，如果我的学生中出现了显式构造函数，例如：

class Student
{
    private int temp;
    private string name;

    public Student(int temp, string name)
    {
        this.temp = temp;
        this.name = name;
    }
}

那么我应该如何在程序的调用部分传递参数呢？即这里：

 ConstructorInfo info = type.GetConstructor(new Type[] { });
 object student = info.Invoke(new object[] { });

很高兴欢迎。问题如下：在 Visual Studio 中，我为 Windows 创建了一个空应用程序（在通用 Windows 应用程序选项卡中）。我的任务是制作一个固定（不可拉伸）尺寸（大约 800x600 像素）的小型表格。我不知道我怎么能做到这一点。

我尝试为Page设置Width和Height，在构造函数中大小发生变化，当组装解决方案时，布局的大小仍然保持全屏。设置页面的最小和最大宽度和高度也不会给出结果。

此窗口中选择的各种变化也不会导致任何结果：

无论我在构建解决方案并运行它时进行了哪些更改，大小都保持不变：

请帮我创建一个大小不变的小表格。

相对而言，我有一个基类 A 和它的后继类 B。A 类有一个虚方法，它在后继类中被覆盖。问题：我可以调用尚未在子对象（虚拟对象）上覆盖的基类方法吗？如果可以，如何调用？

class A
{
 public virtual void myMethod() {}
} 

class B : A
{
 public override void myMethod() {}
}

Нужно что бы в вызывающей части программы было что то вроде этого:
B b = new B();
b.myMethod(); // но метод базового класса

有一个断开按钮。点击之后，当前的InputStream和OutputStream都关闭了，服务端和客户端的连接断开了。问题是如何组织禁用按钮，使其仅在客户端连接到服务器时才处于活动状态？附上控制器和套接字代码。

控制器：包装样品；

import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.scene.control.Button;
import javafx.scene.control.TextField;

import java.io.IOException;

public class Controller
{
@FXML
TextField myTextField;

@FXML
Button buttonOff;



public void myBreakСonnection(ActionEvent event)
{
    try {
        MySocket.inputStream.close();
        MySocket.outputStream.close();
        buttonOff.disabledProperty();
    } catch (IOException e) {
        e.printStackTrace();
    }
}


}

主要的：

try
{
  s = new ServerSocket(8189);
  try(Socket incoming = s.accept())
        {
            boolean key = MySocket.s.isClosed();
            System.out.println(key);

             inputStream = incoming.getInputStream();
             outputStream = incoming.getOutputStream();

            try(Scanner in = new Scanner(inputStream))
            {
                PrintWriter out = new PrintWriter(outputStream, true);
                out.println("Hello! Enter BYE to exit.");

                boolean done = false;
                while(!done && in.hasNextLine())
                {
                    String line = in.nextLine();
                    out.println("Echo: " + line);
                    if(line.trim().equals("BYE")) done = true;
                }
            }


        }

不相关的问题，例如多线程中的静态等，请不要提出。

我使用 javaFX。我正在尝试为按钮指定事件处理方法。发出错误 Cannot resolve symbol actionOk。老实说，我不明白这是怎么回事。fx:controller 已指定，方法已创建，fxml 文件在这些方法所在的位置看到 EditDialogController（Intellij Idea 看到按钮和字段，我可以双击它们）。在这个有问题的代码旁边是主控制器和主框架，它们是按照图像和相似性制作的，效果很好。告诉我我错过了什么。文件

<?import javafx.geometry.*?>
<?import javafx.scene.control.*?>
<?import java.lang.*?>
<?import javafx.scene.layout.*?>

<BorderPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" 
minWidth="-Infinity" prefHeight="150.0" prefWidth="400.0" 
xmlns="http://javafx.com/javafx/8" xmlns:fx="http://javafx.com/fxml/1" 
fx:controller="sample.EditDialogController">
<left>
  <VBox prefHeight="200.0" prefWidth="100.0" BorderPane.alignment="CENTER">
     <children>
        <Label text="Full name">
           <VBox.margin>
              <Insets bottom="5.0" left="5.0" right="5.0" top="5.0" />
           </VBox.margin>
        </Label>
        <Label text="Phone">
           <VBox.margin>
              <Insets bottom="5.0" left="5.0" right="5.0" top="17.0" />
           </VBox.margin>
        </Label>
     </children>
     <BorderPane.margin>
        <Insets bottom="20.0" left="20.0" right="20.0" top="20.0" />
     </BorderPane.margin>
  </VBox>
</left>
<center>
  <VBox minWidth="200.0" prefHeight="200.0" prefWidth="100.0" 
BorderPane.alignment="CENTER">
     <children>
        <TextField fx:id="fieldFullName">
           <VBox.margin>
              <Insets bottom="5.0" left="5.0" right="5.0" top="5.0" />
           </VBox.margin>
        </TextField>
        <TextField fx:id="fieldPhone">
           <VBox.margin>
              <Insets bottom="5.0" left="5.0" right="5.0" top="5.0" />
           </VBox.margin>
        </TextField>
     </children>
     <BorderPane.margin>
        <Insets bottom="20.0" left="20.0" right="20.0" top="20.0" />
     </BorderPane.margin>
  </VBox>
</center>
<right>
  <VBox prefHeight="200.0" prefWidth="100.0" BorderPane.alignment="CENTER">
     <children>
        <Button fx:id="buttonOkName" defaultButton="true" 
mnemonicParsing="false" onAction="#actionOk" prefHeight="25.0" 
prefWidth="51.0" text="OK">
           <VBox.margin>
              <Insets bottom="5.0" left="25.0" right="5.0" top="5.0" />
           </VBox.margin>
        </Button>
        <Button fx:id="buttonPhoneCalcel" cancelButton="true" 
mnemonicParsing="false"  text="Cancel">
           <VBox.margin>
              <Insets bottom="5.0" left="25.0" right="5.0" top="5.0" />
           </VBox.margin>
        </Button>
     </children>
     <BorderPane.margin>
        <Insets bottom="20.0" left="20.0" right="20.0" top="20.0" />
     </BorderPane.margin>
  </VBox>
</right>
</BorderPane>

接下来分别是控制器文件：package sample；

import javafx.fxml.FXML;
import javafx.scene.Node;
import javafx.scene.control.Button;
import javafx.scene.control.TextField;
import javafx.stage.Stage;

import java.awt.event.ActionEvent;

public class EditDialogController
{
@FXML
public Button buttonOkName;

@FXML
public Button buttonPhoneCalcel;

@FXML
public TextField fieldFullName;

@FXML
public TextField fieldPhone;

public Person person;

public void actionClose(ActionEvent actionEvent)
{

}

public void setPerson(Person person)
{
   this.person = person;

   fieldFullName.setText(person.getFullName());
   fieldPhone.setText(person.getPhone());

}


public void actionOk(ActionEvent actionEvent)
{

}
}

我解决了一个问题，其条件听起来是这样的：“有两个线程，其中一个计算自会话开始以来经过的时间量，另一个线程每秒输出一次这种差异。有必要组织程序，使定时器线程通知输出线程。使用wait()和notify()。” 我删除了代码的细节，只留下同步结构。请确切地告诉我应该如何编写我的代码，在哪个对象上同步，何时获取锁，何时通知以及何时释放。

线程定时器：

 public void run()
 {
    while(true)
    {
        synchronized(lock)
        {
            // высчитываю разницу
        }
    }
 }

输出流：

public void run()
{
    try
    {
        synchronized(Timer.lock)
        {
            if (Thread.currentThread().getState() == RUNNABLE )
            {
                System.out.println(Timer.differeceInTime);
                wait();
            }
        }
    }
    catch(InterruptedException e)
    {

    }

条件if (Thread.currentThread().getState() == RUNNABLE)显示错误， write == RUNNABLE，据我所知，是不正确的。我还想知道如何正确设置这样的条件（“如果线程处于活动状态”）

我需要LocalDateTime将以格式（年、月、日、小时、分钟）存储在类型变量中的日期转换为自 1970 年 1 月 1 日以来经过的毫秒数格式，并将结果值分配给类型变量Date。您还需要学习如何从 反向转换Date为LocalDateTime。

package myDefault;

import java.time.*;


public class Main{

    public static void main(String[] args){
        LocalDateTime session = 
            LocalDateTime.of(2017, Month.FEBRUARY, 12, 10, 
 30);
        Date sessionInSec = // ?
    }

}

一定要写多线程程序。开发阶段之一是寻找时间差异（差异可以是年、月或日，具体取决于输入数据。差异是用过去的日期和当前时间计算的）。

我尝试了不同的选项，由于缺乏经验，我无法以任何方式找到解决方案，我不知道该使用什么：LocalDate、Date、Calendar 或其他选项。目前我使用 LocalDate，但路径在我看来不正确（我无法比较年份和月份）。

问题是——我应该使用什么数据类型来存储过去的时刻（年、月、日）以供以后成功比较（最好通过简单的减法 ala resultYear = firstYear - secondYear）？

package myDefaultPackage;

import java.time.*;

public class Timer extends Thread {
    public static final LocalDate DATE_OF_SESSION = LocalDate.of(2012, Month.DECEMBER, 12);
    public static LocalDate differenceOfTheTime;

    public void run() {
        LocalDate now;

        while (!Thread.currentThread().isInterrupted()) {
            try {
                sleep(500);
                now = LocalDate.now(); // получение текущей даты
            }
            catch (InterruptedException e) {

            }
        }
    }

    /*
     * Сравниваем два объекта LocalDate, возвращаем их разницу в виде 
     * объекта LocalDate*/
    LocalDate compare(LocalDate dateOfSession, LocalDate compared) {
        LocalDate resultYear = dateOfSession - compared;
    }    
}

3 在执行减法的代码行下方给出错误

-参数类型 java.time.LocalDate、java.time.LocalDate的运算符未定义。

您建议使用什么来代替 LocalDate 或如何比较 LocalDate（年和月）？

我想编写一个方法，它将采用两个通用类型的矩阵并返回另一个相同类型的矩阵。我不知道如何正确指定我需要的方法签名。我浏览了 Hortsmann 和互联网，但没有找到问题的答案。

public class MatrixMultiplication
{
public static Result<T> matrixMult(Matrix<T extends Number> one, Matrix<T extends Number> two)
{

}
}

或者我应该接受两个 Object[] 矩阵吗？

我的任务是计算输入文本中单词出现的频率。为了存储单词，我使用了一个集合TreeMap（用于自动排序）。
在寻找问题的解决方案时，我翻阅了 Kay Hortsmann 的 Java SE 8 参考书：

我对字符串感兴趣counts.put(word, counts.getOrDefault(word, 0) + 1);。

我试图为我的例子解释它，但它对我不起作用。我对正在发生的事情并不完全了解，因此在这个阶段我所能做的就是从不同的来源提取代码片段并尝试将它们连接在一起。

这是我的代码：

package firstPackage;

import java.io.*;
import java.util.*;

public class Test
{
    public static void main(String[] args)
    {
        Integer randomNumber;
        Console cons = System.console();
        Map<Integer,Word> list = new TreeMap<>();
        Random generator = new Random();
        String myText = cons.readLine();        
        for (String word : myText.split(" ")) 
        {
            randomNumber = generator.nextInt(100001);
            list.put(list.getOrDefault(0, word) + 1, word);
        }
    }

    class Word
    {
        Integer count = 0;
        String word;

        Word(Integer count, String word)
        {
            this.count = count;
            this.word = word;
        }
    }
}

在这种情况下，Eclipselist.put(list.getOrDefault(0, word) + 1, word);会在以下行中写入错误：

类型 Map 中的方法 getOrDefault(Object, Word) 不适用于参数 (int, String)。

我不明白我应该怎么做才能解决它。

如何编写代码list.put(list.getOrDefault(0, word) + 1, word);才能在我的程序中使用？我在哪里犯了错误？

我想实现 Comparable 接口，并使用它按 LocalDate 类型的字段比较（然后排序）数组元素。下面的代码给出错误 dateOfAdmission cannot be resolved or is not a field。我被建议阅读来自 oracle https://docs.oracle.com/javase/8/docs/api/java/time/chrono/ChronoLocalDate.html的帮助，但由于我的英语到目前为止包含麻烦和悲伤，我明白了一点。请向我解释错误是什么以及如何做，以便我可以通过 LocalDate 类型的字段比较对象。提前致谢。 ps：克隆未完成

package myDefault;
import java.time.*;
import java.util.*;


/*В данной программе ставлю целью повторить пройденный материал по сравнению и клонированию объектов*/

public class Student implements Comparable<LocalDate>, Cloneable
{
private String firstName;
private String lastName;
LocalDate dateOfAdmission;
int scholarship;

Student(String firstName, String lastName, int day, int month, int year, int scholarship)
{
    this.firstName = firstName;
    this.lastName = lastName;
    dateOfAdmission = LocalDate.of(day,month,year);
    this.scholarship = scholarship;
}

public int compareTo(LocalDate other)
{
    return Double.compare(dateOfAdmission, other.dateOfAdmission); 
}

public void fillArray()
{
    Student[] arrayOfStudents = new Student[3];
    Student petya = new Student("Petya","Popov",10,6,2017,1500);
    Student vasya = new Student("Vasya","Ovsyannikov",5,6,2017,1500);
    Student gena = new Student("Gena","Lolov",12,6,2017,1500);

    arrayOfStudents[0] = petya;
    arrayOfStudents[1] = vasya;
    arrayOfStudents[2] = gena;
}

public void createNewArray()
{
    Student[] newArray = new Student[3];
}

public void outputArray(Student[] arrayOfStudents)
{
    int counter;
    for(counter = 0; counter < 3; counter++)
    {
        System.out.println(arrayOfStudents[counter]);
    }
}

public Student clone() throws CloneNotSupportedException
{
    Student cloned = (Student) super.clone();
    return cloned;
}

}