Question

我有兴趣让Java更流利，所以我经历了Sun/Oracle's java tutorial。我正在实现接口的部分，我不理解他们作为其中一个练习的解决方案给出的代码。

exercise是实现java.lang.CharSequence接口，实现应该向后返回字符串，并编写一个小的main方法来测试你的类;确保调用所有四种方法。

这有点压倒性，所以我开始研究他们的解决方案，看看我是否能理解概念及其代码。以下是我的问题：

1）当他们实现charAt方法时，正在返回charAt方法的调用，为什么这不会导致某种无限循环？

提前致谢。

以下是代码：

/* Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved. */
// CharSequenceDemo presents a String value -- backwards.
public class CharSequenceDemo implements CharSequence {
    private String s;

    public CharSequenceDemo(String s) {
        //It would be much more efficient to just reverse the string
        //in the constructor. But a lot less fun!
        this.s = s;
    }

    //If the string is backwards, the end is the beginning!
    private int fromEnd(int i) {
        return s.length() - 1 - i;
    }

    public char charAt(int i) {
        if ((i < 0) || (i >= s.length())) {
        throw new StringIndexOutOfBoundsException(i);
        }
        return s.charAt(fromEnd(i));
    }

    public int length() {
        return s.length();
    }

    public CharSequence subSequence(int start, int end) {
        if (start < 0) {
        throw new StringIndexOutOfBoundsException(start);
        }
        if (end > s.length()) {
        throw new StringIndexOutOfBoundsException(end);
        }
        if (start > end) {
        throw new StringIndexOutOfBoundsException(start - end);
        }
        StringBuilder sub = 
        new StringBuilder(s.subSequence(fromEnd(end), fromEnd(start)));
        return sub.reverse();
    }

    public String toString() {
        StringBuilder s = new StringBuilder(this.s);
        return s.reverse().toString();
    }

    //Random int from 0 to max.
    private static int random(int max) {
        return (int) Math.round(Math.random() * max + 0.5);
    }

    public static void main(String[] args) {
        CharSequenceDemo s =
        new CharSequenceDemo("Write a class that implements the CharSequence interface found in the java.lang package.");

        //exercise charAt() and length()
        for (int i = 0; i < s.length(); i++) {
        System.out.println(s.charAt(i));
        }

        //exercise subSequence() and length();
        int start = random(s.length() - 1);
        int end = random(s.length() - 1 - start) + start;
        System.out.println(s.subSequence(start, end));

        //exercise toString();
        System.out.println(s);

    }
}

Answer 1

对charAt的嵌套调用是 s.charAt ，这意味着您在另一个对象上调用相同的方法。那里没有无限循环。

他们的fromEnd被定义为

  private int fromEnd(int i) {
        return s.length() - 1 - i;
    }

几乎在顶部。

Answer 2

1）当他们实施charAt时方法，正在返回调用charAt方法，为什么这不会导致某种情况无限循环？

没有无限循环，因为这些方法指的是两个完全不同的对象。

接口定义CharSequence的charAt()签名。在这种情况下，实现具有支持String实例。 CharSequence的实现为支持String实例调用charAt()方法。没有无限循环，因为它没有调用this.charAt()。

Answer 3

charAt实际上不是递归的，而是为charAt调用String类的String s方法。
fromEnd(i)是对fromEnd(int i)方法的方法调用，该方法也在您的班级中定义

-

//If the string is backwards, the end is the beginning!
    private int fromEnd(int i) {
        return s.length() - 1 - i;
    }

帮助我理解实现界面的这一课

3 个答案: