本文目录一览：

1. 求Java基础，练习题。
2. Java面试题-基础+集合原理（一）？
3. java 中的 方法 总是调来调去的 求高人发题 专练习调方法的练习题 下下了 越多越好
4. JAVA基础测试题

求Java基础，练习题。

选择题 (25道)

1. 下列选项中，不属于Java语言特点的一项是( C )。 A: 分布式
   B: 安全性
   C: 编译执行
   D: 面向对象
2. Java语言的特点与 C/C语言的比较中说法错误的是：( D ) A：简单性Java继承了 C/C的语法，丢弃了其中不常用又容易引起混淆的功能。
   B：Java是一种纯面向对象的语言，具有封装、继承 (Inheritance)和多态 (Polymorphism)的特点。
   C：Java应用程序可凭借URL打开并访问网络上的对象。
   D：解释型Java写成的源代码需要被编译成高阶的字节码，它们与机器架构有关。
3. 阅读下列代码，选出该代码段正确的文件名( C )。

   class A{
       void method1(){
           System.out.println("Method1 in class A");
       }
   }
   public class B{
       void method2(){
           System.out.println("Method2 in class B");
       }
       public static void main(String[] args){
           System.out.println("main() in class B");
       }
   }
   

   A: A.java
   B: A.class
   C: B.java
   D: B.class
4. 如果一个类的文件名为Student.java，但是类的代码为：

   public class Student {
       public static void main(String[] args) {
           System.out.println(82);
       }
   }
   

   那么下列说法正确的是：( B ) A：程序运行结果为8
   B：程序运行结果为2
   C：程序运行结果为0
   D：程序编译错误，不能运行
5. 符合对象和类的关系的是( D )。 A: 教师和学生
   B: 书和房子
   C: 狗和猫
   D: 飞机和交通工具
6. 关于垃圾回收机制描述不正确的是( B ) A：垃圾回收机制不须通过程序员调用相应方法，也能自动启动。
   B：Java程序员用System.gc()方法一定能进行垃圾回收
   C：垃圾回收机制属于jvm自动操作，Java程序员可以不进行垃圾回收操作。
   D：垃圾回收机制并不是由操作系统自动执行。
7. 编译下面源程序会得到哪些文件( D )?

   class A1{
   }
   class A2 extends A1{
   }
   public class B{
       public static void main(String[] args){
       }
   }
   

   A: 只有B.class文件
   B: 只有A1.class和A2.class文件
   C: 编译不成功
   D: A1.class、A2.class和B.class文件
8. 下列关于基本数据类型的说法中，不正确的一项是( D )。 A: boolean类型变量的值只能取真或假
   B: float是带符号的32位浮点数
   C: double是带符号的64位浮点数
   D: char是8位Unicode字符
9. 下列( D )是合法的标识符? A: 12class
   B: void
   C: -5
   D: _blank
10. 在编写Java程序时，如果不为类的成员变量定义初始值，Java会给出它们的默认值，下列说法中不正确的一个是( D )。 A: byte的默认值是0
    B: boolean的默认值是false
    C: char类型的默认值是'\0'
    D: long类型的默认值是0.0L
11. 下列程序执行的结果是：( B )

    public class News {
        public static void main(String[] args) {
            System.out.println(1+2+ "aa"+3);
        }
    }
    

    A: "12aa3"
    B: "3aa3"
    C: "12aa"
    D: "aa3"
12. 表达式(12==0) || (1/0 ==1)的值为( B )。 A: true
    B: false
    C: 0
    D: 运行时抛出异常
13. 下列循环体执行的次数是( C )。

    int y=2, x=4;
    while(--x != x/y){ }
    

    A: 1
    B: 2
    C: 3
    D: 4
14. 已知如下代码：

    switch(m){
        case 0: System.out.println("Condition 0");
        case 1: System.out.println("Condition 1");
        case 2: System.out.println("Condition 2");
        case 3: System.out.println("Condition 3");break;
        default:System.out.println("Other Condition");
    }
    

    当m的值为( D )时，输出“Condition 3” A: 2
    B: 0、1
    C: 0、1、2
    D: 0、1、2、3
15. 下列语句输出的结果是：( C )

    public class X3 {
        public static void main(String[] args) {
            for(int i=0; i<10; i++){
                if(i==5) break;
                System.out.print(i);
            }
        }
    }
    

    A：编译错误
    B：1234
    C：01234
    D：12345
16. 下列语句输出的结果是：( D )

    public class Lx1 {
        public static void main(String[] args) {
            for(int i=0;i<5;i++){
                switch(i){
                    case 0:System.out.print("B");
                    case 1:System.out.print("e");break;
                    case 2:System.out.print("g");
                    case 3:System.out.print("!");break;
                    case 4:System.out.print("!");break;
                    default:System.out.print("!");
                }
            }
        }
    }
    

    A：Beg!!!
    B：Beeg!
    C：Beg!
    D：Beeg!!!
17. 下面foreach循环的程序输出结果是( D )。

    public class Lx1{
        public static void main(String[] args) {
            String s1[]={"欢迎您","3","G","同","学",};
            Arrays.sort(s1);
            for(String s0:s1)
                System.out.print (s0);
        }
    }
    

    A：欢迎您3G同学
    B：3G欢迎您同学
    C：同学欢迎您3G
    D：3G同学欢迎您
18. 阅读以下程序，选择正确的运行结果：( B )

    public class Lx1 {
        public static void main(String[] args) {
            byte d[]="YOUIHE你我他".getBytes();
            String s=new String(d,6,2);
            System.out.println(s);
        }
    }
    

    A：HE
    B：你
    C：我
    D：他
19. 设有下列数组定义语句：

    int a[][]= {{1, 2}, {3}};
    

    则对此语句的叙述正确的是( D )。 A: 定义了一个名为a的一维数组
    B: a数组 a[1][1]为0
    C: a数组元素的下标为1～3
    D: 数组中每个元素的类型都是整数
20. 下列程序输出的结果是：( B )

    public class Lx1 {
        public static void main(String[] args) {
            String a[][] ={{"","","",""},{""},{"",""}};
            System.out.println(a[2].length);
        }
    }
    

    A：1
    B：2
    C：3
    D：4
21. 关于以下程序的说明，正确的是( C )

    class StaticStuff
    {
        static int x=10;
        static { x+=5;}
        public static void main(String args[ ])
        {
            System.out.println("x=" + x);
        }
        static { x/=3;}
    }
    

    A：4行与9行不能通过编译，因为缺少方法名和返回类型
    B：9行不能通过编译，因为只能有一个静态初始化器
    C：编译通过，执行结果为：x=5
    D：编译通过，执行结果为：x=3
22. 给出下面代码，关于该程序以下哪个说法是正确的?( C )

    public class Person{
        static int arr[] = new int[5];
        public static void main(String a[]) {
            for(int i=0;i<arr.length;i++)
                System.out.print(arr[i]);
        }
    }
    

    A、编译时将产生错误
    B、编译时正确，运行时将产生错误
    C、输出零
    D、输出空
23. 下面程序中类ClassDemo中定义了一个静态变量sum，分析程序段的输出结果。( C )

    class ClassDemo {
        public static int sum=1;
        public ClassDemo() {
            sum = sum + 5;
        }
    }
    public class ClassDemoTest{
        public static void main(String args[]) {
            ClassDemo demo1=new ClassDemo();
            ClassDemo demo2=new ClassDemo();
            System.out.println(demo1.sum);
        }
    }
    

    A: 0
    B: 6
    C: 11
    D: 2
24. 下面关于方法的说法，不正确的是( C )。 A: Java中的构造方法名必须和类名相同
    B: 方法体是对方法的实现，包括变量声明和合法语句
    C: 如果一个类定义了构造方法，也可以用该类的默认构造方法
    D: 类的私有方法不能被其他类直接访问
25. 在Java中下列说法正确的是( C ) A) 一个子类可以有多个父类，一个父类也可以有多个子类
    B) 一个子类可以有多个父类，但一个父类只可以有一个子类
    C) 一个子类可以有一个父类，但一个父类可以有多个子类
    D) 上述说法都不对

Java面试题-基础+集合原理（一）？

面向对象的特征

面向对象的三个基本特征是：封装、继承、多态。

1. 封装 封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
2. 继承 面向对象编程（OOP）语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
3. 多态 多态性（polymorphism）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。 实现多态，有两种方式，重写，重载。 详见如下：网页链接

java 中的 方法 总是调来调去的 求高人发题 专练习调方法的练习题 下下了 越多越好

第一章 java技术入门

1. 练习环境变量的设置，如果出现问题，试分析其原因并更正。
2. 编写HelloWorld程序，并编译执行。
3. 在屏幕上打印出一下图形。

   ************************************************
   **************Java程序设计**********************
   *************************************************
   

4. 编辑、编译、运行以下程序，说出程序的功能。改变变量n的初值，观察运行结果。

   public class Sum10_for
   {
       public static void main(String[] args)
       {
           int i=1,n=10,s=0;
           System.out.print("Sum("+n+")=");
           for(i=1;i<=n;i++)
           {
               s+=i;
               System.out.print(i+"+");
           }
           System.out.println(i+"="+(s+i));
       }
   }
   

第二章 面向对象程序设计

1. 创建一个带缺省构造方法的类，在构造方法中打印一条信息。为这个类创建一个对象。
2. 设计一个银行账户类，成员变量包括账号、储户姓名、开户时间、身份证号码、存款余额等账户信息，成员方法包括存款、取款等操作。
3. 定义一个点对象。
4. 编写并测试一个代表地址的Address类，地址信息由国家、省份、城市、街道、邮编组成，并可以返回完整的地址信息。
5. 定义并测试一个代表员工的Employee类。员工属性包括编号、姓名、基本薪水，还包括获取这些属性的方法。
6. 创建一个Dog类，有名字、颜色、年龄等属性，定义构造方法来初始化类的这些属性，定义方法输出Dog信息，编写应用程序使用Dog类。

第四章 运算符、表达式和流程控制

1. 测试++运算符。问：当a=1时，如下表达式：(a)+(a)+(a); (a)+(a)+(a); (a)+(a)+(a)+(a)的值分别是多少。
2. 写一个打印从1到100值的程序。
3. 编写一个程序，求三个数中的最大值。
4. 求1~1000之间可以同时被3、5、7整除的数字。
5. 利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。 程序分析：(a>b)?a:b这是条件运算符的基本例子。
6. 利用递归方法求5!。

第五章 数组

1. 定义一个由整数组成的数组，要求求出其中的奇数个数和偶数个数。
2. 现在有如下的一个数组：

   int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};
   

   要求将不为0的值存入一个新数组。
3. 定义一个整型数组，求出数组元素的和、数组的最大值和最小值，并输出。
4. 设级数Sn定义为：S0=0，S1=1，Sn=Sn-1+2*Sn-2（n>=2），将前10个Sn数放入数组中。
5. 打印出二维数组中元素的最大值，及其行、列位置。

第六章 面向对象编程进阶

1. 设计一个表示用户的User类，类中的变量有用户名、口令等，定义类的三个构造方法（无参、为用户名赋值、为用户名和口令赋值），并设计获取和设置口令的方法和返回类信息的方法。
2. 创建一个名为Dog的类，具有重载的bark（）方法。此方法应根据不同的基本数据类型进行重载，并根据被调用的版本，打印出不同类型的狗的叫声。编写main（）来调用所有不同版本的方法。
3. 编写具有两个方法的类，在第一个方法内调用第二个方法两次：第一次调用不使用this，第二次调用时使用this。
4. 编写具有两个重载构造方法的类，并在第一个构造方法中调用第二个构造方法。
5. 创建一个带有public,private,protected和包访问权限的成员变量以及成员方法的类。创建该类的一个对象，看看在你试图调用所有类成员时，会得到什么类型的编译信息。注意在同一目录中的所有类都是缺省包范围。
6. （1）创建两个带有缺省构造器的类，A和B。从A中继承一个名为C的新类，并在C内创建一个B类的成员。不要给C编写构造器。创建一个C类的对象并观察其结果。 （2）对上述程序进行修改，使A和B含有带参数的构造器，以取代缺省的构造器。为C写一个构造器，并在其中执行所有初始化。
7. 证明基类构造器（a）总是被调用（b）在导出类构造器之前被调用。
8. 创建一个仅有一个非缺省构造器的基类，并创建一个带有缺省构造器和非缺省构造器的导出类。在导出类的构造器中调用基类的构造器。
9. （1）创建一个Root类，令其含有名为Component1、Component2、Component3的类各一个实例（这些也由你写）。从Root中派生一个类Stem，也含有上述各“组成部分”。所有的类都应带有打印出类的相关信息的缺省构造器。 （2）修改上述程序，使每个类都仅有非缺省的构造器。
10. 创建一个类，它应带有一个被重载了三次的方法。创建一个子类，并添加一个该方法的新的重载定义，展示这四个方法在子类中都可以使用。
11. 建立一个人类(Person)和学生类(Student)，功能要求如下： （1）Person中包含4个保护型的数据成员name、addr、sex、age，表示姓名、地址、性别和年龄。用一个4参构造方法、一个两参构造方法、一个无参构造方法、一个输出方法显示4种属性。 （2）Student类继承Person类，并增加输出成员math、english存放数学和英语成绩。用一个6参构造方法、一个两参构造方法、一个无参构造方法和重写输出方法用于显示6种属性。
12. 在包中编写一个类，你的类应具备一个protected方法。在包外部，试着调用该protected方法并解释此结果。然后，从你的类中派生一个导出类，并从该导出类的一个方法内部调用该protected方法。
13. （1）创建一个名为Amphibian的类。由此派生出一个被称为Frog的类。在基类中设置适当的方法。在main（）中，编写一个Frog并向上转型至Amphibian，然后说明所有方法都可工作。 （2）修改上述程序，使Frog重载基类中方法的定义，并重新调用，观察现象。
14. 声明一个图书类，其数据成员为书名、编号（利用静态变量实现自动编号）、书价，并拥有静态数据成员册数，记录图书的总册数，在构造方法中利用此静态变量为对象的编号赋值，在主方法中定义对象数组，并求出总册数。
15. 创建一个含有static final数据成员和final数据成员的类，说明二者间的区别。
16. 创建一个带有final数据成员的类。由此派生出一个类并重载此数据成员。
17. 创建一个包含两个方法的基类。在第一个方法中可以调用第二个方法。然后产生一个继承自该基类的导出类，且重载基类的第二个方法。为该导出类创建一个对象，向上转型到基类型并调用第一个方法，解释发生的情况。

第七章 高级类特性

1. （1）创建一个Rodent（啮齿动物）：Mouse（老鼠），Gerbil（鼹鼠），Hamster（大颊鼠）这样的继承层次结构。在基类中，提供对所有的Rodent都通用的方法，在基类中，根据特定的Rodent类型重载这些方法，以便执行不同的行为。 （2）修改上述程序，使Rodent成为一个抽象类。只要有可能，就将Rodent的方法声明为抽象方法。
2. 创建一个基类，包含抽象方法print（），并在导出类中将其重载。重载的版本中会打印基类中定义的某个整型变量的值。在定义该变量时，请赋予非零值。在基类的构造器中，可以调用这个方法。现在，在main（）方法中，创建一个导出类对象，然后调用它的print（）方法。解释发生的情形。
3. 创建一个不包含任何方法的抽象类，从它那里导出一个子类，并添加一个方法。在测试类中创建一个静态方法，可以接受一个指向基类的引用，将其向下转型到导出类，然后再调用该静态方法。在main（）方法中，证实它的可行性。
4. 定义类Shape，用来表示一般二维图形。Shape具有抽象方法area和perimeter，分别用来计算形状的面积和周长。试定义一些二维形状类（如矩形、三角形、圆形等），这些类均为Shape类的子类。
5. 在某个包中创建一个接口，内含三个方法，然后在另一个包中实现此接口。
6. 创建三个接口，使之各有两个方法。再创建一个新的接口，继承三者，并添加一个新方法。然后创建一个类，在实现此新接口的同时，继承一个实际的类。并为这个类写四个方法，每个方法分别以四个接口中的一个作为参数。在main（）中，创建这个类的对象，然后将它作为参数传递给那四个方法。
7. 在第一个包中创建至少有一个方法的接口。然后在第二个包内创建一个类，在其中增加一个protected的内部类以实现那个接口。在第三个包中，继承这个类，并在一个方法中返回该内部类的对象，在返回的时候向上转型为第一个包中的接口类型。
8. 创建一个至少有一个方法的接口。在某个方法内定义一个内部类，以实现此接口，这个方法返回此接口的引用。
9. 创建一个private内部类，实现一个public接口。写一个方法，它返回一个指向此private内部类的实例的引用，并将此引用向上转型为该接口类型。通过尝试向下转型，说明此内部类被完全隐藏了。
10. 创建一个仅有非缺省构造器的类。再创建第二个类，它包含一个方法，能够返回第一个类的引用。通过写一个继承自第一个类的匿名内部类，而创建一个用以返回的对象。
11. 定义一个品牌电脑的枚举类，其中只有固定的几个电脑品牌。
12. 定义一个Person类，其中包含姓名、年龄、生日、性别等属性，其中性别只能是男或女。

第八章 异常处理

1. 编写一个类，在main()的try块里抛出一个Exception对象。传递一个字符串参数给Exception的构造器。在catch子句里捕获此异常对象，并且打印字符串参数。添加一个finally子句，打印一条信息以证明这里确实得到了执行。
2. 使用extends关键字建立一个自定义异常类。为这个类写一个接受字符串参数的构造器，把此参数保存在对象内部的字符串引用中。写一个方法打印此字符串。写一个try-catch子句，对这个异常进行测试。
3. 为一个类定义两个方法，f()和g()。在g()里，抛出一个未定义的新异常。在f()里，调用g()，捕获它抛出的异常，并且在catch子句里抛出RuntimeException。在main()方法里测试你的代码。

第九章 精通常用的java类

1. 计算字符串中子串出现的次数。
2. 写一个接收两个字符串的方法，判断两个字符串是否相等，做==的同时，用equals做测试，在main()里面用不同的字符串做测试，并打印结果。
3. 写一个会随机生成25个整型值的程序。对每一个值，用if-else语句判断其实大于、小于，还是等于下一个随机生成的数。
4. 统计一个字符串中单词的个数。设单词之间用一个或多个空格分隔，该字符串只由字母与空格组成。
5. 输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
6. 编写程序，统计出字符串“want you to know one thing”中字母n和字母o的出现次数。
7. 字符串操作： （1）从字符串“Java技术学习班20091211”中提取开班日期。
   （2）将“IBM JAVA学习班”中的字符串JAVA替换为“J2SE”。
   （3）取出“JAVA技术学习班20091211”中的第八个字符。
   （4）清除“JAVA技术学习班20091211”中的所有的0。
   （5）清除“JAVA 技术学习班 学生 信息”中的所有空格。
8. 定义一个StringBuffer类对象，然后通过append()方法向对象中添加26个小写字母，要求每次只添加一次，共添加26次，然后按照逆序的方式输出，并且可以删除前五个字符。
9. 输入一个Email地址，然后使用正则表达式验证该Email地址是否正确。
10. 编写程序，用0~1之间的随机数来模拟扔硬币试验，统计扔1000次后出现正反面次数并输出。
11. 编写正则表达式，判断给定的是否是一个合法的IP地址。

第十一章 集合与映射

1. （1）创建一个新类Gerbil（沙鼠），包含int gerbilNumber，在构造器中初始化它。添加一个方法hop()，用以打印gerbil的号码。创建一个ArrayList，并向其中添加一串Gerbil对象。使用get()遍历List，并且对每个Gerbil调用hop()。 （2）修改上述程序，使用Iterator遍历List，并调用hop()。
2. 使用上述中的Gerbil类，将其放入Map中，将Gerbil的名字String（键）与每个Gerbil（值）关联起来。有keySet()获取Iterator，使用它遍历Map，针对每个"键"查询Gerbil，然后打印出"键"，并调用hop()。
3. 创建一个新容器，用private ArrayList来保存对象。用Class reference来判断容器中的第一个对象的类型，然后只允许用户插入此类型的对象。
4. 用String数组创建一个只能存取String的容器，这样使用的时候就没有类型转换的问题了。当容器发现数组不够大的时候，应该能够自动调整其内部数组的容量。
5. 创建一个包括两个String对象的类，然后做一个只比较第一个字符串的Comparable。产生多个对象并存入ArrayList。验证一下，排序能否正常工作。再做一个只比较第二个String的Comparator，然后验证一下，排序是否正常。
6. 写一个类，在其中创建一个已经初始化的对象数组。使用此数组填充List。使用subList()生成此List的子集，然后使用removeAll()将子集从List中移除。
7. 创建自己的容器，使它只能容纳特定类型的对象。
8. 编写学生类，该类定义了3个属性：学号、姓名、成绩。可以通过构造方法设置3个属性的值，并覆写Object类的toString()方法，在List集合中加入5个学生对象，并将内容输出，之后使用比较器将对象的内容进行排序并显示在屏幕上。

JAVA基础测试题

1. 跟Java运行的机制有关，Java先加载静态域，static int x=10;，然后静态块static { x+=5;}，static { x/=3;}（虽然位置在后但先运行），然后静态方法static void main。所以x=10，x=15，x=5。
2. 因为int [ ] x = new int[25]，数组建立后，每个元素默认值为0；x[24]=0；x[25]下标越界，x[0]=0；
3. switch(i)不接受long型，int或者枚举型可以。i=Integer.parseInt(args[0]);虽然这样每课时i还是long型的。
4. c，没什么好说的，就是这么规定的！