小编Num*_*tor的帖子

如果我不知道它,我怎么得到数组的第二个维度？array.length只给出第一个维度.

例如,在

public class B {
    public static void main(String [] main){
        int [] [] nir = new int [2] [3];
        System.out.println(nir.length);
    }
}

我怎样才能得到第二维的值nir,即3.

谢谢

我正在尝试理解Observer和Observable.

这是我想要弄清楚的一个例子:

public class IntegerDataBag extends Observable implements Iterable<Integer> {

    private ArrayList<Integer> list= new ArrayList<Integer>();

    public void add(Integer i){
        list.add(i);
        setChanged();
        notifyObservers();
    }

    public Iterator<Integer> iterator(){
        return list.iterator();
    }

    public Integer remove (int index){
        if (index< list.size()){
            Integer i = list.remove(index);
            setChanged();
            notifyObservers();
            return i;
        }
        return null;
    }

}

public class IntegerAdder implements Observer {

    private IntegerDataBag bag;

    public IntegerAdder(IntegerDataBag bag) {
        this.bag = bag;
        bag.addObserver(this);
    }

    public void update(Observable o, Object arg) {
        if (o == bag) { …

我真的很感谢你的帮助,这决定了字母表中所有单词的语言是否都是{0,1}无法从同一方面读取的,是一种无上下文的语言(也就是说,它可以转换成特定的语法)规则).{ w | w <> wR }

我试图通过泵浦引理证明它不是一种无上下文的语言,但是我找不到会导致我矛盾的字符串.

有什么建议？

我定义了 List<Integer> stack = new ArrayList<Integer>();

当我试图通过以下方式将其转换为数组时:

Integer[] array= stack.toArray();

我得到这个例外:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
Type mismatch: cannot convert from Object[] to Integer[].

为什么？它与Integer完全相同 - Integer.当这些类是父子关系时,它不像这种通用情况

我试图做铸造:

    Integer[] array= (Integer[]) stack.toArray();

但在这里我得到这个错误:

Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;

问题是什么？

关于以下内容我有几点想法:

public interface MaxStack<T extends Comparable <T>>

1 - 为什么实现的类MaxStack应该像这样写:

public class MaxStackclass<T extends Comparable <T>> implements MaxStack<T>

不是public class MaxStackclass<T extends Comparable <T>> implements MaxStack<T extends Comparable <T>>吗？

2-为什么这个类的私有变量,当我使用泛型时,应该只用<T>而不是用<T extnds Comparable<T>>？例如, private List<T> stack= new ArrayList<T>();

3 - <T extends Comparable<T>>和之间有什么区别<T extends Comparable>- 如果我需要比较班上的各种元素,两者都可以,不是吗？

编辑:我认为3的问题是,它可能允许插入以第二种方式定义的列表,以便具有不同的元素,这些元素都可以从可比较的方面扩展,然后当我想比较它们时,它将是不可能的,因为我们无法将String与Integer进行比较,所以都从Comparable扩展.

我想使用Build Monitor插件,但还显示特定作业的所选模块的状态和进度,此外还有作业的状态.

我阅读了Build monitior插件描述并且还探索了Build Fauilre Analyzer,但它们似乎都没有我想要的能力.

您是否知道以任何方式或有任何想法在构建监视器插件对作业执行的方式上在屏幕上显示构建的作业状态？

我希望它看起来像这样:

public class Base {
public Base() {
    x = 0;
    bar();
}

public Base(int x) {
    this.x = x;
    foo();
}

public void foo() {
    System.out.println("Base.foo : " + x);
}

private void bar() {
    System.out.println("Base.bar:" + x.toString());
}

protected Integer x;
}

    public class Derived extends Base {
       public Derived() {
       bar();
       }
       public Derived(int x, int y) {
         super(x);
         this.y = y;
       }
       public void foo() {
         System.out.println("Derived.foo : " + x + ", " + y);
       } …

这是两个例子:

public class A {
    public void foo(A a) {
        System.out.println("in A");
    }
}


public class B extends A {      
    public void foo(B b) { // (1)
        System.out.println("in B");
    }
    public void f(Object o) { // (2)
        System.out.println("in B");
    }
}

我不明白为什么(1)和(2)被认为是A的覆盖方法foo().方法编号1接受比原版更低的类foo(),我的意思是我不能向她发送任何A类.正如我所看到的,(1)没有扩展foo(),但它仍然算作覆盖 - 为什么？(类似(2)的论据,但相反).

我让我认为它被压倒的原因是:

当我想跑的时候

  B b = new B();

  b.foo(b);

它检查是否A有foo接受B.因为每一个B都是一个A,它确实有一个所以它应该打印"在A"而不是"在B",因为B不会覆盖它.但它打印"在B"..

我希望您能帮助我理解如何执行以下操作:

我有一个包含由空格''分隔的整数的文件.我需要读取所有整数,对它们进行排序并将它们作为字符串写入另一个文件.我写了一个代码,但是我通过char读取char,把这个单词放在char sub_arr [Max_Int]中,当我遇到''时,我将这些字符放入另一个Main int数组后,现在放入一个字符串,直到到达文件的末尾,逐个字符串,然后我对它们进行排序并将它们写在另一个文件中.

但后来我记得有一个fscanf 功能:我读了它,但我仍然不完全理解它做了什么以及如何使用它.

在我的情况下,所有整数由空格分隔,我可以写fscanf(myFile,"%s",word)吗？它会不会考虑''并停在特定字符串的末尾？!怎么样？

更重要的是,我可以写fscanf(myFile,"%d",number),它会给我下一个号码吗？(我一定是误会了.感觉​​像魔术一样).

public class D {

void myMethod() {
    try {
        throw new IllegalArgumentException();
    } catch (NullPointerException npex) {
        System.out.println("NullPointerException thrown ");
    } catch (Exception ex) {
        System.out.println("Exception thrown ");
    } finally {
        System.out.println("Done with exceptions ");
    }
    System.out.println("myMethod is done");
}

public static void main(String args[]) {
    D d = new D();
    d.myMethod();
}

}

我不明白怎么"myMethod is done"也被打印出来.抛出了异常,因此它假设找到一个匹配的catch并执行finally块,但它继续在该myMethod方法上打印myMethod is done,而不是finally块的一部分.为什么？