不使用String类方法前提下，用测试类完成字符串模式匹配 要求1.找出子串在父串首次出现的位置2.子串在父串出现的所有位置.3将子串在父串的字符替换成新串。

好的，如果不使用`String`类提供的方法，我们可以手动实现字符串模式匹配和替换功能。下面是示例代码：

public class StringMatcher {
    public static int indexOf(String parentStr, String subStr) {
        int parentLength = parentStr.length();
        int subLength = subStr.length();

        for (int i = 0; i <= parentLength - subLength; i++) {
            int j;
            for (j = 0; j < subLength; j++) {
                if (parentStr.charAt(i + j) != subStr.charAt(j)) {
                    break;
                }
            }
            if (j == subLength) {
                return i;
            }
        }
        return -1;
    }

    public static List<Integer> findAllIndex(String parentStr, String subStr) {
        List<Integer> indexes = new ArrayList<>();
        int parentLength = parentStr.length();
        int subLength = subStr.length();

        for (int i = 0; i <= parentLength - subLength; i++) {
            int j;
            for (j = 0; j < subLength; j++) {
                if (parentStr.charAt(i + j) != subStr.charAt(j)) {
                    break;
                }
            }
            if (j == subLength) {
                indexes.add(i);
            }
        }
        return indexes;
    }

    public static String replace(String parentStr, String subStr, String newStr) {
        int index = indexOf(parentStr, subStr);
        if (index == -1) {
            return parentStr;
        }

        int parentLength = parentStr.length();
        int subLength = subStr.length();
        int newLength = newStr.length();

        StringBuilder sb = new StringBuilder();
        int i = 0;
        while (i < parentLength) {
            if (i == index) {
                sb.append(newStr);
                i += subLength;
                index = indexOf(parentStr.substring(i), subStr);
                if (index != -1) {
                    index += i;
                }
            } else {
                sb.append(parentStr.charAt(i));
                i++;
            }
        }

        return sb.toString();
    }
}

上述代码中，我们手动实现了`indexOf()`、`findAllIndex()`和`replace()`方法，用于实现字符串模式匹配和替换功能。其中：

- `indexOf()`方法用于找出子串在父串中首次出现的位置，采用的是双重循环遍历父串和子串的方式。
- `findAllIndex()`方法用于找出子串在父串中所有出现的位置，采用的是在`indexOf()`方法的基础上加上一个`List`来存储所有出现的位置。
- `replace()`方法用于将子串在父串中的字符替换成新串，采用的是在`indexOf()`方法的基础上使用`StringBuilder`来构建新的字符串。

使用上述代码示例如下：

String parentStr = "Hello World! World is beautiful.";
String subStr = "World";
String newStr = "Universe";

int index = StringMatcher.indexOf(parentStr, subStr);
System.out.println("子串在父串中首次出现的位置：" + index);

List<Integer> indexes = StringMatcher.findAllIndex(parentStr, subStr);
System.out.println("子串在父串中出现的所有位置：" + indexes);

String replacedStr = StringMatcher.replace(parentStr, subStr, newStr);
System.out.println("替换后的字符串：" + replacedStr);

输出结果如下：

子串在父串中首次出现的位置：6
子串在父串中出现的所有位置：[6, 13]
替换后的字符串：Hello Universe! Universe is beautiful.

以上就是不使用`String`类提供的方法，手动实现字符串模式匹配和替换功能的示例代码。