2个java基础的多选题

Question

 下列关于java数组论述，正确的是：
A) 定义一个Java的多维数组变量，实际上是定义了将会指向数组对象的引用，该数组对象所包含的元素又将是另一个数组对象的引用。
B) int[][] x = new int[3][5]; 所定义的二维数组对象含有15个int型元素。
C) String[] x = {"o", "k","ok"}; 所创建的数组对象含有3个串对象。
D) int[] x = {0}; 与 int[] x = new int[1]; 的结果是完全等价的。
E) int[][] x = {{1},{1,2},{1,2,3},new int[1]}; 是正确的语句。 下列叙述正确的是：
A) 方法中可以定义另一个方法，称为：内部方法。
B) 类中可以定义另一个类，称为内部类。
C) 接口中可以定义另一个接口，称为：内部接口。
D) 对象中可以包含另一个对象。
E) 属性中可以包含另一个属性。2个是软件大赛给的样题 先不说答案 反正我都选的不对
谁来解释一下

Answer 1

第一道题，我个人认为A-E都是对的！
第二道题，好饶人啊！！！估计只有奥赛和面试才会出这样的题目。
我敢肯定：
 “B) 类中可以定义另一个类，称为内部类。”和
 “D) 对象中可以包含另一个对象。”是对的！
其他的不知道。

Answer 2

1 BCE（蒙的）2 BCD

Answer 3

第一题: ABDE  (C: 数组里存的应该是引用而不是对象)
第二题：BCDE   (A: 内部方法参考内部方法调用概念；内部方法调用：一个方法调用同一个类里的其他方法)

Answer 4

答案公布 看来我跟大家选的差不多 都选多了下列关于java数组论述，正确的是：
A) 定义一个Java的多维数组变量，实际上是定义了将会指向数组对象的引用，该数组对象所包含的元素又将是另一个数组对象的引用。
B) int[][] x = new int[3][5]; 所定义的二维数组对象含有15个int型元素。
C) String[] x = {"o", "k","ok"}; 所创建的数组对象含有3个串对象。
D) int[] x = {0}; 与 int[] x = new int[1]; 的结果是完全等价的。
E) int[][] x = {{1},{1,2},{1,2,3},new int[1]}; 是正确的语句。答案：A, D, E 下列叙述正确的是：
A) 方法中可以定义另一个方法，称为：内部方法。
B) 类中可以定义另一个类，称为内部类。
C) 接口中可以定义另一个接口，称为：内部接口。
D) 对象中可以包含另一个对象。
E) 属性中可以包含另一个属性。答案：B, C 
我也是百思不得其解~~

Answer 5

int[][] x = new int[3][5]; 所定义的二维数组对象含有15个int型元素这个是正确的啊·不懂？等待高手解答

Answer 6

按照答案看的话，A是正确的，那B就自然可以认为数组里面的对象可以是另一个数组对象的引用，那15个int型元素就是不对的了，这么理解不知道对不~

Answer 7

强列要求lz核对答案int[] x = {8,5,6,4}; 写了个测试代码查看字节码    //    0    0:iconst_4        
    //    1    1:newarray        int[]
    //    2    3:dup             
    //    3    4:iconst_0        
    //    4    5:bipush          8
    //    5    7:iastore         
    //    6    8:dup             
    //    7    9:iconst_1        
    //    8   10:iconst_5        
    //    9   11:iastore         
    //   10   12:dup             
    //   11   13:iconst_2        
    //   12   14:bipush          6
    //   13   16:iastore         
    //   14   17:dup             
    //   15   18:iconst_3        
    //   16   19:iconst_4        
    //   17   20:iastore         
    //   18   21:astore_1        
    //   19   22:return     
从iastore 可以看出存在数组时基本类型的数值 第一个题的B选项 是不是问的这个问题！！B不对吗？？？

Answer 8

LZ来了 
这是工信部给的2个多选的样题
我看了单选和程序填空的题都挺靠谱的就是这个多选~我也是百思不得其解~~ 
答案真的就是这样给的 不是我看错了
你们要是感兴趣可以去把样题下下来看一下http://www.miit-nstc.org/jingsaiguize/2010451.html

Answer 9

看了你的题 感觉出的题很好！！面试考的话很能考验学生的对java语言和虚拟机的了解！！单选没问题！但 多选 真的有点疑惑///.....等待高手吧... int[][] x = new int[3][5]; 所定义的二维数组对象含有15个int型元素。这个谁解释下...........

Answer 10

String[] x = {"o", "k","ok"}; 所创建的数组对象含有3个串对象。
这个为什么不对？谁能解释一下..

Answer 11

明白了为什么不是 15个 元素呢？？因为  在数组里面存放的是int数组 不是元素  是 3个int[]数组对象....

Answer 12

jvm会把字符串常量放在缓冲池中，首先会把o放在池中，之后再把k放在池中，最后发现了ok,经常编译器的优化后发现就是o与k，因此直接引用了，因此应该是2个串对象！

Answer 13

貌似知道了，不过不知道是不是正解
第一题C选项 相当于
String[] x = {new String("o"),new String(k),new String("ok")};
应该是6个对象.

Answer 14

第一题: ADE (C: 数组里存的是引用而不是对象)
第二题：BC (A: 内部方法参考内部方法调用概念；内部方法调用：一个方法调用同一个类里的其他方法)

Answer 15

感觉好像知道为什么int[3][5]中存在15个数字是错的~~因为刚开始数组定义的时候只是在数组的空间里面填入他的引用地址，并没有吧15个int智放在里面

Answer 16

int[][] x = new int[3][5]; 所定义的二维数组对象含有15个int型元素。 这个应该是4*6 ，因为数组下标是从零开始的。

Answer 17

...哎.我给想错了..想成这句话创建了多少个String对象.按照题意，29楼这么解释是正解!

Answer 18

下标从0开始，但是到2就结束了，不是这个概念，这个答案不对是因为这里只定义了一个int型二维数组，并且为他分配了一个3*5的空间，但是他里面并没有包含任何int型元素，一个文字游戏而已。

Answer 19

String[] x = {"o", "k","ok"}; 这个是六个对象这些通过看字节码都可以得到的
{
    //    0    0:iconst_3        
    //    1    1:anewarray       String[]
    //    2    4:dup             
    //    3    5:iconst_0        
    //    4    6:new             #2   <Class String>
    //    5    9:dup             
    //    6   10:ldc1            #3   <String "o">
    //    7   12:invokespecial   #4   <Method void String(String)>
    //    8   15:aastore         
    //    9   16:dup             
    //   10   17:iconst_1        
    //   11   18:new             #2   <Class String>
    //   12   21:dup             
    //   13   22:ldc1            #5   <String "k">
    //   14   24:invokespecial   #4   <Method void String(String)>
    //   15   27:aastore         
    //   16   28:dup             
    //   17   29:iconst_2        
    //   18   30:new             #2   <Class String>
    //   19   33:dup             
    //   20   34:ldc1            #6   <String "ok">
    //   21   36:invokespecial   #4   <Method void String(String)>
    //   22   39:aastore         
    //   23   40:astore_1        
    //   24   41:return          
    }

Answer 20

D) int[] x = {0}; 与 int[] x = new int[1]; 的结果是完全等价的。
一个赋值了，一个没有赋值怎么就等价了

Answer 21

貌似在数组中,初等的数据类型会被默认初始化,Int为0,char为空''

Answer 22

胡说八道。你可以自己debug一下，并且顺便debug一下string中的char[] value。请不要和下面的搞混：String a = "abc";
String b = "abc";
编译期确定字符串相同，a == b

Answer 23

int[][] x = new int[3][5]; 所定义的二维数组对象含有15个int型元素。
只是定义了3*5=15个元素的空间，但是没包含15个元素啊，我可以只定义小于15个元素的内容，真是玩文字游戏

Answer 24

int[][] x = new int[3][5]; 
这个感觉应该是30个对象，不知道对不对，根据A 项理解后面的 new  int[3][5];是15个对象，把这15个对像的 地址再给 int[][]x ;而int[][]x 也是15个对象。就好像 String s=new String("ddd"）是俩个对象一样。不知道这样解释对不对~~~~~~~~

Answer 25

应该说有15个元素 
不能说 有15个int 类型的元素

Answer 26

B) int[][] x = new int[3][5]; 所定义的二维数组对象含有15个int型元素。
C) String[] x = {"o", "k","ok"}; 所创建的数组对象含有3个串对象。----------------------------------------------------------------
我觉得不能这么说
 应该说，这是一个int类型的数组变量有15个元素， 

Answer 27

答案公布 看来我跟大家选的差不多 都选多了下列关于java数组论述，正确的是：
A) 定义一个Java的多维数组变量，实际上是定义了将会指向数组对象的引用，该数组对象所包含的元素又将是另一个数组对象的引用。
B) int[][] x = new int[3][5]; 所定义的二维数组对象含有15个int型元素。
C) String[] x = {"o", "k","ok"}; 所创建的数组对象含有3个串对象。
D) int[] x = {0}; 与 int[] x = new int[1]; 的结果是完全等价的。
E) int[][] x = {{1},{1,2},{1,2,3},new int[1]}; 是正确的语句。B中的第二句话不对，不是15个int型的元素，是三个元素，分别指向三个引用，参照A 下列叙述正确的是：
A) 方法中可以定义另一个方法，称为：内部方法。
B) 类中可以定义另一个类，称为内部类。
C) 接口中可以定义另一个接口，称为：内部接口。
D) 对象中可以包含另一个对象。
E) 属性中可以包含另一个属性。答案：B, C  接口中可以定义接口，设计模式中有这种用法。

Answer 28

B 匿名类也是在类中定义的   所以第二个B应该不对吧D 对象中可以包含另一个对象。 这个应该也是对的 就像女人怀孕了一样E 属性中可以包含另一个属性。按照面向对象的思想 即一切都是对象 那属性也应该是对象 那就和D选项一样了

Answer 29

    1, ABCE
    2.ABCD

Answer 30

初始化：1.动态初始化：数组定义与为数组分配空间和赋值的操作分开进行；
2.静态初始化：在定义数字的同时就为数组元素分配空间并赋值；
3.默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐士初始化。
实例：
TestD.java(动态)：程序代码：public class TestD  
{  
     public static void main(String args[]) {  
         int a[] ;  
         a = new int[3] ;  
         a[0] = 0 ;  
         a[1] = 1 ;  
         a[2] = 2 ;  
         Date days[] ;  
         days = new Date[3] ;  
         days[0] = new Date(2008,4,5) ;  
         days[1] = new Date(2008,2,31) ;  
         days[2] = new Date(2008,4,4) ;  
     }  
}  
 
class Date  
{  
     int year,month,day ;  
     Date(int year ,int month ,int day) {  
         this.year = year ;  
         this.month = month ;  
         this.day = day ;  
     }  
}  
 TestS.java(静态)：程序代码：public class TestS     
{     
     public static void main(String args[]) {     
         int a[] = {0,1,2} ;     
         Time times [] = {new Time(19,42,42),new Time(1,23,54),new Time(5,3,2)} ;     
     }     
}     
 
class Time     
{     
     int hour,min,sec ;     
     Time(int hour ,int min ,int sec) {     
         this.hour = hour ;     
         this.min = min ;     
         this.sec = sec ;     
     }     
}    TestDefault.java(默认)：程序代码：public class TestDefault     
{     
     public static void main(String args[]) {     
         int a [] = new int [5] ;     
         System.out.println("" + a[3]) ;     
     }     
} 

Answer 31

对第一个问题没太大的疑问，第二题有点疑惑
第1题：B：选项中x 二维数组中包含3个元素，这三个元素分别引用5个int数值，但是x中仅仅包含3个元素。
       C：我个人认为是4个对象，“o”、“k”、“ok”和x
第2题：我觉得D和E也是正确的。比如下面这个类(B也是一个自定义类)：pulic class E{
    private B b = null;
    private String firstName = "三";
    private String lastName = "张";
    private String[] name = new String[]{firstName,lastName};//name属性包含了其它属性
    public E(){
        this.b = new B();
    }
    public String[] getName(){
     return this.name;
    }
    public static void main(String[] args){
        E a = new E();//这时对象a中包含有对象b
        System.out.println(Arrays.toString(a.getName()));//结果为[三, 张]
    }
}

Answer 32

int[][] x = new int[3][5]; 三个int型元素,这三个分别指向含有5个元素的地址。个人见解

Answer 33

个人认同你关于多维数组的看法，string那个,既然A对了，那C自然错了

Answer 34

public class test {
 public static void main(String[] args){
int[][] a = new int[3][5];
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++)
System.out.print(a[i][j]+ " ");
System.out.println();
}
}}
输出：
0 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 应该是对的啊

Answer 35

[Quote=引用 34 楼 sosoyiyi 的回复:]
引用 32 楼 hghghg000000 的回复:
int[][] x = new int[3][5]; 所定义的二维数组对象含有15个int型元素。这个应该是4*6 ，因为数组下标是从零开始的。下标从0开始，但是到2就结束了，不是这个概念，这个答案不对是因为这里只定义了一个int型二维数组，并且为他分配了一个3*5的空间，但是他里面并没有包含任何int型元素，一个文字游戏而已。……
[/Quote..

Answer 36

第一题：
    1. 首先我们要明白在java中虽然没有指针的概念，但是在java中还是有类似的引用的。在java中有两个变量空间，分别为堆空间和栈空间。比如int[] x = new int[] 实际上是在栈空间创建了一个变量x，这个x就相当于一个指针，它指向的是在堆空间创建出来的一个对象也就是 new int[]把这个原理在扩大一层就是答案A的叙述，所以A是对的。
    2.明白了A为什么对我就应该明白B的叙述中创建了很多的对象和引用。所以B是错的。
      原理明白了也就不多说了。
第二题：
    是考察面向对象的特性的，看一看继承、多态的概念就能明白了。
    

Answer 37

A) 定义一个Java的多维数组变量，实际上是定义了将会指向数组对象的引用，该数组对象所包含的元素又将是另一个数组对象的引用。B) int[][] x = new int[3][5]; 所定义的二维数组对象含有15个int型元素。
注：在Java中，数组对象创建的格式是：元素类型[] 数组名 = new 元素类型[元素的个数]；
，括号里写的不代表数组的最大下标，所以是15个元素，因为数组在创建过程中会自动进行初始化，所以里头就有15个0;二维数组时可以看成以数组为元素的数组，所以只能说有3个元素，而非15个元素，但能存15个数C) String[] x = {"o", "k","ok"}; 所创建的数组对象含有3个串对象。
注："o","k","ok"是字符常量，不是对象
D) int[] x = {0}; 与 int[] x = new int[1]; 的结果是完全等价的。
E) int[][] x = {{1},{1,2},{1,2,3},new int[1]}; 是正确的语句。

Answer 38

第一个选择题我可以说一下 第二个很抽象不知道从何说起 
首先 A) 定义一个Java的多维数组变量，实际上是定义了将会指向数组对象的引用，该数组对象所包含的元素又将是另一个数组对象的引用。 你可以将它想象成一个递归 理解一下
其次 B) int[][] x = new int[3][5]; 所定义的二维数组对象含有15个int型元素。上面有了不说了
再次 C) String[] x = {"o", "k","ok"}; 所创建的数组对象含有3个串对象。 应该不属于对象吧这个不是很清楚
然后 D) int[] x = {0}; 与 int[] x = new int[1]; 的结果是完全等价的。 int[0]默认是0
最后 E) int[][] x = {{1},{1,2},{1,2,3},new int[1]}; 是正确的语句。 new int[1]可看成上面d的选项 
不知道我说的对不对 错的话请高人指点

Answer 39

第一题中本人认为ADE是对的，DE在程序中一敲就行了