1. 阅读以下程序，写出程序运行结果。 public class Test { public static void main(String[] args) { String str1 = "百年追梦"; String str2 = "百年追梦"; String str3 = new String("百年追梦"); String str4 = new String("百年追梦"); String str5 = "胸怀千秋伟业，恰是百年风华！"; System.out.println(str1 == str2); System.out.println(str3 == str4); System.out.println(str3.equals(str4)); System.out.println(str5.length()); System.out.println(str5.substring(9,13)); System.out.println(str5.indexOf("伟业")); } }

程序运行结果如下：

true
false
true
13
伟业
6

解释如下：
1. `str1`和`str2`都是直接赋值的字符串常量，它们的值相同，都指向字符串常量池中的同一个对象，因此`str1 == str2`的结果为`true`。
2. `str3`和`str4`都是通过`new`关键字创建的字符串对象，它们的值相同，但是它们指向堆内存中的不同对象，因此`str3 == str4`的结果为`false`。
3. `str3.equals(str4)`比较的是字符串对象的值是否相同，因此结果为`true`。
4. `str5.length()`返回字符串长度，结果为`13`。
5. `str5.substring(9,13)`返回字符串中索引为9到12的子串，结果为`伟业`。
6. `str5.indexOf("伟业")`返回第一次出现`"伟业"`的位置，结果为`6`。

相关问题

以下程序能否编译成功？如果能，写出程序的执行过程和执行结果；如果不能， 说明错误原因并修改代码 1. class StringDemo{ public static void main(String[] args){ String s1 = “a”; String s2 = “b”; show(s1,s2); System.out.println(s1+s2); } public static void show(String s1,String s2){ s1 = s1 +“q”; s2 = s2 + s1; } } 2. public class TestMonth{ public static void main(String []args){ try{ int month=Integer. parseInt("13"); if(month<0||month>12){ throw new ArithmeticException("没有"+month+"月份！"); } System.out.println("您输入的月份为"+month+"月份"); }catch(ArrayIndexOutOfBoundsException e){ System.out.println("请输入月份!"); }catch(ArithmeticException e){ System.out.println("捕获 ArithmeticException 异常"); System.out.println(e.toString()); } } } 3. class Test{ public void stringReplace(String text){ text= text.replace('j','i'); text=text+"C"; } public void bufferReplace(StringBuffer text){ text.setCharAt(0,'i'); text=text.append("C"); } public void change(char ch[]) { ch[0]='Y'; } public static void main(String args[]){ String str1="java"; StringBuffer str2=new StringBuffer("java"); char ch[]={'j','a','v','a'}; Test t=new Test(); t.change(ch); t.stringReplace(str1); t.bufferReplace(str2); System.out.println(str1); System.out.println(str2.toString()); System.out.println (new String(ch)); } } 4. class Test{ public static String stringReplace(String text){ text=text.replace('j','i'); text=text+"C"; return text; } public static StringBuffer bufferReplace(StringBuffer text){ text.setCharAt(0,'i'); text= text.append("C"); return text; } public static void main(String aargs[]){ String str1="java"; String str2="java"; String str3="j"+"a"+"v"+"a"; String str4=new String("java"); StringBuffer str5=new StringBuffer("java"); System.out.println(str1==str2); System.out.println(str2==str3); System.out.println(str2==str4); System.out.println(str3.equals(str4)); System.out.println(str4.equals(str5)); System.out.println (stringReplace(str1)); System.out.println(bufferReplace(str5)); System.out.println(str1); System.out.println(str5); } } 5. interface Shape{ double PI; public double area(); public double perimeter(); } class Cycle extends Shape{ private double r; public Cycle(double r){ this.r=r; } double area(){ System.out.println(PI*r*r); } } public class Test{ public static void main(String args[]){ Cycle c=new Cycle(1.5); System.out.println("面积为："+c.area()); } }

1. 可以编译成功。执行过程为：首先定义了两个字符串 s1 和 s2，然后调用 show 方法，将 s1 和 s2 传入。在 show 方法中，对 s1 进行了拼接，并将拼接结果赋值给了 s1，对 s2 进行了拼接并将拼接结果赋值给了 s2，但是这两个操作对原来的 s1 和 s2 没有影响。最后在 main 方法中打印 s1 和 s2 的拼接结果，输出为 "ab"。
2. 可以编译成功。执行过程为：首先将字符串 "13" 转换成整型数 month，由于 month 大于 12，所以抛出 ArithmeticException 异常，被 catch 语句块捕获，输出 "捕获 ArithmeticException 异常" 和异常信息 "没有13月份！"。
3. 可以编译成功。执行结果为：stringReplace 方法中对传入的字符串进行了替换和拼接的操作，但由于 Java 中字符串是不可变的，所以对 text 的修改并没有影响。bufferReplace 方法中对传入的 StringBuffer 对象进行了替换和拼接的操作，成功修改了字符串，返回值也是修改后的字符串。change 方法中对数组 ch 的第一个元素进行了修改，由于数组是引用类型，所以修改成功。最终输出为：java、iavaC、Yava。
4. 可以编译成功。执行结果为：首先定义了五个字符串，其中 str1、str2 和 str3 都是指向字符串常量池中同一个字符串 "java" 的引用，str4 是指向堆内存中新创建的一个字符串对象的引用，str5 是指向堆内存中新创建的一个 StringBuffer 对象的引用。接着依次输出了一些比较结果，其中 str1==str2 的结果为 true，表示它们是同一个对象；str2==str3 的结果为 true，表示它们也是同一个对象；str2==str4 的结果为 false，因为它们指向不同的对象；str3.equals(str4) 的结果为 true，表示它们的值相等；str4.equals(str5) 的结果为 false，因为它们的类型不同。最后依次输出了 stringReplace、bufferReplace、str1 和 str5 的值。
5. 不能编译成功。在 Shape 接口中定义的 PI 没有初始化，应该改为 double PI = 3.1415926;。另外，Cycle 类应该继承抽象类 Shape，并实现 Shape 中的抽象方法 area 和 perimeter。area 方法应该返回计算好的圆的面积。最终执行结果为：面积为：7.0685834705770345。下面是修改后的代码：

interface Shape{
    double PI = 3.1415926;
    public double area();
    public double perimeter();
}

abstract class Shape {
    public abstract double area();
    public abstract double perimeter();
}

class Cycle extends Shape {
    private double r;
    public Cycle(double r){
        this.r = r;
    }
    public double area(){
        return PI*r*r;
    }
    public double perimeter() {
        return 2*PI*r;
    }
}

public class Test{
    public static void main(String args[]){
        Cycle c = new Cycle(1.5);
        System.out.println("面积为：" + c.area());
    }
}

下面哪行代码有错误 public class Test { private String str1 = "str1"; private final String str2 = "str2"; public Test() { System.out.println("Done!"); } public Test(String str1, String str2) { 1 this.str1 = str1; 2 this.str2 = str2; } public static void main(String[] args) { 3 Test test1 = new Test(); 4 Test test2 = new Test("str1", "str2");

第二个构造函数的第二行代码有错误。因为str2是一个final变量，一旦被赋值后就无法修改。因此，尝试给它赋值会导致编译错误。正确的代码应该是：

public Test(String str1, String str2) {
    this.str1 = str1;
    this.str2 = str2;
}

或者可以将str2声明为非final变量：

private String str2 = "str2";