求解释几个题目 [ Java SE]

Question

3、编译下面程序会产生哪些文件？
interface J_SuperClass {
void mb_method();
}
public class J_Test {
class J_InnerClass1 { }
J_Test m_test = new J_Test() {
int m_data = 1;
public void mb_method() {
System.out.println(m_data);
}
};
void mb_method() { }
public static void main(String[] args) {
class J_InnerClass2 { }
J_SuperClass a = new J_SuperClass() {
int m_data = 1;
public void mb_method() {
System.out.println(m_data);
}
};
}
}
输出结果：
J_SuperClass.class
J_Test$1.class
J_Test$1J_InnerClass2.class
J_Test$2.class
J_Test$J_InnerClass1.class
J_Test.class
java

Answer 1

5、读程序，写出和程序输出格式一致的输出结果。
import java.io.RandomAccessFile;
public class J_Test {
public static void main(String[] args) throws Exception {
RandomAccessFile f = new RandomAccessFile(“a.txt”, “rw”);
f.writeBoolean(true);
f.writeBoolean(false);
for(int i = 1; i < 10; ++i)
f.writeInt(i);
f.seek(6);
System.out.println(f.readInt());
f.close();
}
}
输出结果：
2

Answer 2

7、读程序，写出和程序输出格式一致的输出结果。
public class J_Test {
public static void main(String[] args) {
int sum = 0;
outer:
for(int i = 1; i < 10; ++i) {
inner:
for(int j = 1; j < 3; ++j) {
sum += j;
if(i + j > 6)
break inner;
}
}
System.out.println("sum = " + sum);
}
}
输出结果：
sum = 19

Answer 3

8、读程序，写出和程序输出格式一致的输出结果。
class J_SuperClass {
void mb_method() {
System.out.println("J_SuperClass::mb_method");
}
static void mb_methodStatic() {
System.out.println("J_SuperClass::mb_methodStatic");
}
}
public class J_Test extends J_SuperClass {
void mb_method() {
System.out.println("J_Test::mb_method");
}
static void mb_methodStatic() {
System.out.println("J_Test::mb_methodStatic");
}
public static void main(String[] args) {
J_SuperClass a = new J_Test();
a.mb_method();
a.mb_methodStatic();
J_Test b = new J_Test();
b.mb_method();
b.mb_methodStatic();
}
}

Answer 4

public class J_Test {
public static void main(String[] args) {
int sum = 0;
outer://标记
for(int i = 1; i < 10; ++i) {
inner://标记
for(int j = 1; j < 3; ++j) {
sum += j;//注意是先加再判断
if(i + j > 6)
break inner;//当i+j>6的时候跳出inner循环。
//所以i等于1,2,3,4,5时，sum都会加上1和2，而当i>5时，只会加1，所以sum=(1+2)*5+1*4
}
}
System.out.println("sum = " + sum);
}
}其实这个应该挺好懂的，不懂的话可以单步调试，看看它是怎么走的

Answer 5

import java.io.RandomAccessFile;
public class J_Test {
public static void main(String[] args) throws Exception {
RandomAccessFile f = new RandomAccessFile(“a.txt”, “rw”);
f.writeBoolean(true);//按单字节将此boolean值写入文件，此时文件有1个字节
f.writeBoolean(false);//按单字节将此boolean值写入文件，此时文件有2个字节
for(int i = 1; i < 10; ++i)//向文件中写入9个int值，此时文件有2+4*9=38个字节
f.writeInt(i);
f.seek(6);//设置到此文件开头测量到的文件指针偏移量，在该位置发生下一个读取或写入操作。即此时在第6个字节的位置发生读写
System.out.println(f.readInt());//f.readInt()读当前位置的int值，即2
f.close();
}
}

Answer 6

class J_SuperClass {
void mb_method() {
System.out.println("J_SuperClass::mb_method");
}
static void mb_methodStatic() {
System.out.println("J_SuperClass::mb_methodStatic");
}
}
public class J_Test extends J_SuperClass {
void mb_method() {
System.out.println("J_Test::mb_method");
}
static void mb_methodStatic() {
System.out.println("J_Test::mb_methodStatic");
}
public static void main(String[] args) {
J_SuperClass a = new J_Test();//父类引用指向子类实例化对象
a.mb_method();//调用成员方法是看a引用的实例化对象的类型，所以调用的是J_Text的成员方法
a.mb_methodStatic();//调用类方法（static方法）是看a的类型，所以调用的是J_SuperClass的methodStatic()，这里最好写J_SuperClass.methodStatic()
J_Test b = new J_Test();//此时是子类引用指向子类实例化对象
b.mb_method();//理由同上
b.mb_methodStatic();//理由同上
}
} 
输出结果：
J_Test::mb_method
J_SuperClass::mb_methodStatic
J_Test::mb_method
J_Test::mb_methodStatic

Answer 7

12、读程序，从 A、B、C、D 中选择最合适的答案。
import java.awt.*;
import javax.swing.*;
public class J_Test extends JFrame {
public static void main(String[] args) {
J_Test app = new J_Test();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Container ct = app.getContentPane();
ct.setLayout(new GridLayout(1, 2));
JButton[] b = { new JButton("one"),new JButton("Two"),new JButton("Three") };
ct.add(b[0]);
ct.add(b[1]);
ct.add(b[2]);
app.setSize(220, 70);
app.setVisible(true);
}
}
（A）程序可以通过编译并正常运行，结果在程序界面上从左到右依次排列三个按钮
（B）程序可以通过编译并正常运行，结果在程序界面上三个按钮分成两行排列
（C）程序可以通过编译并正常运行，结果在程序界面上只出现两个按钮
（D）程序无法通过编译
输出结果（A、B、C、D 中选择）：A

Answer 8

@abc41106 
哥们再给我看几个，100分归你
10、读程序，写出和程序输出格式一致的输出结果。
class J_SuperClass {
int m_data;
J_SuperClass() {
mb_add(1);
}
public void mb_add(int i) {
m_data += i;
}
public void mb_print() {
System.out.println(m_data);
}
}
class J_SubClass extends J_SuperClass {
J_SubClass() {
mb_add(2);
}
public void mb_add(int i) {
m_data += i * 2;
}
}
public class J_Test {
public static void mb_method(J_SuperClass a) {
a.mb_add(6);
a.mb_print();
}
public static void main(String[] args) {
mb_method(new J_SubClass());
}
}

Answer 9

import java.awt.*;
import javax.swing.*;
public class J_Test extends JFrame {
public static void main(String[] args) {
J_Test app = new J_Test();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Container ct = app.getContentPane();
ct.setLayout(new GridLayout(1, 2));//GridLayout，一行两列，当超出1*2个组件时，列自动增加。仅当rows设为0时，cols才会对布局有影响
JButton[] b = { new JButton("one"),new JButton("Two"),new JButton("Three") };//创建3个按钮
ct.add(b[0]);//将3个按钮添加到容器里
ct.add(b[1]);
ct.add(b[2]);
app.setSize(220, 70);//设置大小
app.setVisible(true);//设置显示
}
}

Answer 10

class J_SuperClass {
int m_data;//成员变量，使用时自动初始化，int值初始化为0
J_SuperClass() {
mb_add(1);
}
public void mb_add(int i) {
m_data += i;
}
public void mb_print() {
System.out.println(m_data);
}
}
class J_SubClass extends J_SuperClass {
J_SubClass() {
mb_add(2);
}
public void mb_add(int i) {
m_data += i * 2;
}
}
public class J_Test {
public static void mb_method(J_SuperClass a) {
a.mb_add(6);
a.mb_print();
}
public static void main(String[] args) {
mb_method(new J_SubClass());//调用J_SubClass的构造函数
}
} mb_method(new J_SubClass());//调用J_SubClass的构造函数
    先调用父类的构造函数
    J_SuperClass() {
    mb_add(1);//调用成员函数mb_add，看实例化对象类型，所以是J_SubClass的成员函数，m_data变成2
    }
    
    然后调用子类构造函数
    J_SubClass() {
    mb_add(2);//同理，m_data变成2+2*2=6
    }
    调用mb_method函数
public static void mb_method(J_SuperClass a) {
a.mb_add(6);//同理，调用J_SubClass的成员函数，m_data变成6+6*2=18
a.mb_print();//打印m_data
}

Answer 11

3题interface J_SuperClass        //J_SuperClass.class
{
        void mb_method();
}
public class J_Test           //J_Text.class
{
        class J_InnerClass1   //J_Text$J_InnerClass1.clss  普通内部类
        { }        J_Test m_test = new J_Test()//J_Text$1.class.    匿名内部类(这是第一个).
        {
                int m_data = 1;
                public void mb_method() 
                {
                        System.out.println(m_data);
                }
        };
        void mb_method() 
        {}
        public static void main(String[] args)
        {
                class J_InnerClass2//J_Text$1J_InnerClass2.class  方法内的内部类，也叫局部内部类。$后有个1。
                {}
                J_SuperClass a = new J_SuperClass()//J_Text$2.class    匿名内部类(这是第二个)。
                {
                        int m_data = 1;
                        public void mb_method() 
                        {
                               System.out.println(m_data);
                        }
                };
        }
}