小编Ale*_*erc的帖子

问题是使用线程生成1到99之间的随机数.不过这里的问题是我不知道"主要线程停止"从何而来？主线是不是最终死了？

这是示例输出:

Main thread stopping
Random no = 57
Random no = 47
Random no = 96
Random no = 25
Random no = 74
Random no = 15
Random no = 46
Random no = 90
Random no = 52
Random no = 97
Thread that generates random nos is stopping

神话类:

public class MyThread extends Thread {
    MyThread() {
        // default constructor
    }

    MyThread(String threadName) {
        super(threadName); // Initialize thread.
        start();
    }

    public void run() {
        // System.out.println(Thread.currentThread().getName()); …

在为脚本结果编写一些自定义流阅读器时,类中存在相当多的常量(主要用于预期的标记和关键字),我想知道是否存在任何类型的标准,约定或最佳实践来放置常量(在这里读到static final字段)在课堂内？

更具体地说,最好将每个常量放在类的顶部,或者将它们分组到它们有用的类的区域中,并将公共组合在顶部？

通过将所有内容放在顶部,在我看来,这可能更容易找到你在同一个地方寻找的所有东西,但如果这个区域越来越大,它会变得无法抗拒:

public class Test {
    // Constants.
    private static final String CLASSNAME = Test.class.getSimpleName();
    private static final String COMMON = " = ";
    private static final String CONSTRUCTOR = "#constructor";
    private static final String METHOD_1 = "#method1";
    private static final String METHOD_2 = "#method2";

    public Test(String message) {
        System.out.println(CLASSNAME + CONSTRUCTOR + COMMON + message);
        method1(message);
        method2(message);
    }

    private void method1(String message) {
        System.out.println(CLASSNAME + METHOD_1 + COMMON + message);
    }

    private void method2(String message) …

当我的程序员介意让我以面向对象的方式思考这个概念时,我正在读一些关于汽车防撞系统的文章,这让我想知道这些系统是否尊重面向对象的编程模型.

作为一名Java开发人员,我在Java环境中转换了这个问题,并提出了一个特殊问题:在同一个类(在非静态上下文中)调用公共方法是否尊重并遵循面向对象的方式？

我的意思是,采取这个简短的假设汽车课:

public class Car {
    // Class attributes.

    // Constructors.

    public void accelerate(final double amplitude) {
        // Accelerate according to the amplitude.
    }

    public void brake(final double amplitude) {
        // Brake according to the amplitude.
    }

    // Other useful methods.

    private void collisionPreventionActions() {
        // Some actions.

        brake(100.0);

        // Some other actions.
    }
}

假设一些Thread负责检测碰撞并在检测到碰撞时采取措施,其中一个动作就是制动.显然,该brake(...)方法成为一个有趣的选择,但这不是打破面向对象的做事方式吗？这不只是刹车.如果这个类中的防撞系统使用方向盘来避免事故怎么办？我觉得很奇怪汽车会从内部角度使用自己的输入......

在更一般的范围内,假设您有一个通用对象,我喜欢将其视为黑盒子.公共方法将相当于控制其行为的黑匣子上的杠杆.在此对象中调用公共方法意味着黑盒子将从其内部机制激活其自己的控制杆.

我问,因为我知道这样做是合法的,并且我已经看到公共方法在我的生活中多次在同一个类中被调用,但它是合法的并不一定意味着它是正确的OO方式它.

在非静态上下文中使用同一类中的公共方法是否遵循面向对象编程和封装的规则？如果没有,那么这样做的正确方法是什么,或者解决方法是什么？

我有以下方法规范化给定的XML标记名称:

public static String normaliseTagName(String tagName) {
    // Return a given empty tag name.
    if (tagName.length() == 0) {
        return tagName;
    }

    // Replace invalid start.
    if (isInvalidXMLStart(tagName.charAt(0))) {
        tagName = XML_REPLACEMENT + tagName;
    }

    // Replace invalid characters.
    StringBuilder normalised;
    boolean invalidFound = false;
    for (int i = 0; i < tagName.length(); i++) {
        if (isInvalidXMLChar(tagName.charAt(i))) {
            if (!invalidFound) {
                normalised = new StringBuilder(tagName.substring(0, i));
                invalidFound = true;
            }
            normalised.append(XML_REPLACEMENT); // COMPILER ERROR
        } else if (invalidFound) {
            normalised.append(tagName.charAt(i)); …