Java牛客网日常练习题

每天10道选择题，1道编程题，记录易犯错的题型

2018.10.8 day1

1.以下对继承的描述错误的是（）

A Java中的继承允许一个子类继承多个父类

B父类更具有通用性，子类更具体

CJava中的继承存在着传递性

D当实例化子类时会递归调用父类中的构造方法
解析：选A Java只能继承一个父类，但可以实现多个接口。
2. this代表了()的对象引用,super表示的是当前对象的()对象?

A当前类当前类

B当前类的父类当前类

C当前类当前类的父类

D以上都不正确
解析：选C

3.下列关于功能性注释不正确的说法是()

A功能性注释嵌在源程序中，用于说明程序段或语句的功能以及数据的状态

B注释用来说明程序段，需要在每一行都要加注释

C可使用空行或缩进，以便很容易区分注释和程序

D修改程序也应修改注释
解析：选B 注释加在需要解释说明的代码行上即可，不需要每句都加。
4.下列说法正确的有：（）

A class中的constructor不可省略

B constructor必须与class同名，但方法不能与class同名

C constructor在一个对象被new 时执行

D 一个class只能定义一个constructor
解析：选C，构造犯法没有返回值且构造方法不能被子类继承。不同与实例方法的是构造方法不能被任何非访问性质的修饰符修饰，例如static，final，abstract。
5.下列代码运行的结果是什么（）

class B extends Object
{
    static
    {
        System.out.println("Load B");
    }
    public B()
    {
        System.out.println("Create B");
    }
}
class A extends B
{
    static
    {
        System.out.println("Load A");
    }
    public A()
    {
        System.out.println("Create A");
    }
}
 
public class Testclass
{
    public static void main(String[] args)
    {
        new A();
    }
}

A Load B ->Create B->Load A -> Create A

B Load B -> Load A ->Create B ->Create A

C Load B -> Create B-> Create A -> Load A

D Create B ->Create A ->Load B ->Load A
解析：选B
执行顺序：
父类静态代码块-》子类静态代码块-》父类构造代码块-》父类构造函数-》子类构造代码块-》子类构造函数

6.如果一个接口Glass有个方法setColor()，有个类BlueGlass实现接口Glass，则在类BlueGlass中正确的是？ ( )

A protected void setColor() { …}

B void setColor() { …}

C public void setColor() { …}

D 以上语句都可以用在类BlueGlass中
解析：选C (1)JAVA 子类重写继承的方法时,不可以降低方法的访问权限，子类继承父类的访问修饰符要比父类的更大，也就是更加开放，假如我父类是protected修饰的，其子类只能是protected或者public，绝对不能是friendly(默认的访问范围)或者private，当然使用private就不是继承了。还要注意的是，继承当中子类抛出的异常必须是父类抛出的异常的子异常，或者子类抛出的异常要比父类抛出的异常要少。（2）子类的权限不能比父类更低 .
7.选项中哪一行代码可以替换 //add code here 而不产生编译错误

public abstract class MyClass {
     public int constInt = 5;
     //add code here
     public void method() {
     }

A public abstract void method(int a);

B consInt=constInt+5;

C public int method();

D public abstract void anotherMethod(){}
解析：选A
（1）A是抽象方法，抽象类可以包含抽象方法，也可以不包含，实现重载。（√）
B 在类中不能constInt = constInt + 5（×）
C 返回值不能作为重载的依据（×）
D 有方法体的不能作为抽象函数（×）
（2）A：抽象类可以包含抽象方法
B：类中定义成员和方法，不能直接进行运算，可以写在代码块{}或者静态代码块中static{}中
C: 与第四行想要构成重载，二者区别是返回类型，但是返回类型不能作为重载的依据
D: 该方法使用abstract修饰，是抽象方法，但是他有方法体(带有{}的就是方法体，即使里面是空的)，就不能作为抽象方法
8.java中下面哪个能创建并启动线程（）

public class MyRunnable implements Runnable          { 
     public void run()             { 
         //some code here 
     } 
 }

A new Runnable(MyRunnable).start()

B new Thread(MyRunnable).run()

C new Thread(new MyRunnable()).start()

D new MyRunnable().start()
解析：选C
首先：创建并启动线程的过程为：定义线程—》实例化线程—》启动线程。
一、定义线程： 1、扩展java.lang.Thread类。 2、实现java.lang.Runnable接口。
二、实例化线程： 1、如果是扩展java.lang.Thread类的线程，则直接new即可。
2、如果是实现了java.lang.Runnable接口的类，则用Thread的构造方法：
Thread(Runnable target)
Thread(Runnable target, String name)
Thread(ThreadGroup group, Runnable target)
Thread(ThreadGroup group, Runnable target, String name)
Thread(ThreadGroup group, Runnable target, String name, long stackSize)
所以A、D的实例化线程错误。
三、启动线程：在线程的Thread对象上调用start()方法，而不是run()或者别的方法。
所以B的启动线程方法错误。

编程题：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

本题可以采用冒泡排序来计算。

/*
 * 输入一个整数数组，
 * 实现一个函数来调整该数组中数字的顺序，
 * 使得所有的奇数位于数组的前半部分，
 * 所有的偶数位于数组的后半部分，
 * 并保证奇数和奇数，
 * 偶数和偶数之间的相对位置不变。
 */
public class haha {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int a[ ]= {1,2,3,4,5,6,7,8,9,10 };
		for(int i=0;i<a.length-1;i++) {
			for(int j=0;j<a.length-1-i;j++) {
				if(a[j]%2==0&&a[j+1]%2!=0) {
					int temp=a[j];
					a[j]=a[j+1];
					a[j+1]=temp;
				}
			}
		}
		System.out.print("{");
		for(int i=0;i<a.length;i++) {
			if(i==a.length-1) {
				System.out.print(a[i]+"}");
			}else {
				System.out.print(a[i]+",");
			}
		}
	}

}

2018年10月9号

1.下列Java常见事件类中哪个是鼠标事件类？（）

A InputEvent

B KeyEvent

C MouseEvent

D WindowEvent
解析：选C

2.在 JAVA 编程中， Java 编译器会将 Java 程序转换为（）

A 字节码

B 可执行代码

C 机器代码

D 以上都不对
解析：选A

编译器将Java源代码编译成字节码class文件
类加载到JVM里面后，执行引擎把字节码转为可执行代码
执行的过程，再把可执行代码转为机器码，由底层的操作系统完成执行。

3.下列对接口的说法，正确的是( )

A 接口与抽象类是相同的概念

B 若要实现一个接口为普通类则必须实现接口的所有抽象方法

C 接口之间不能有继承关系

D 一个类只能实现一个接口
选项：选B
A 接口与抽象类是不同的概念。抽象类是用于捕捉子类的通用特性，接口是抽象方法的集合；
B 实现接口必须实现接口的所有方法；
C 接口可以继承一个或多个接口，抽象类只能继承一个类或者实现多个接口；
D 一个类只能继承一个类，但是可以实现多个接口。
4.下列运算符合法的是（）

A &&

B <>

C if

D :=
选项：选A
5.程序文件名必须与公共外部类的名称完全一致（包括大小写）.
正确
6.JUnit主要用来完成什么

A发送HTTP请求

B建立TCP连接

C集成测试

D单元测试
选项：D
JUnit是一个Java语言的单元测试框架，有程序员自测，就是所谓的白盒测试，主要四个方向 1、用于测试期望结果的断言（Assertion） 2、用于共享共同测试数据的测试工具 3、用于方便的组织和运行测试的测试套件 4、图形和文本的测试运行器
7.以下哪个方法用于定义线程的执行体？（）

A start()

B init()

C run()

D synchronized()
选项：C run定义方法体（意思就是run里面写各种操作，即run(){}），start启动线程，如果将start改成run,则意思是依次将程序从前到后的顺序执行
init（）和sychronized（）好像不是线程的方法，sychronized（）保证线程的安全。
8. 如果要建立一个java.scut.computer的包，叙述正确的是？ ( )

A 只需在代码中加入“package java.scut.computer;”一个语句

B 只需在代码中加入“package java.scut;”一个语句

C 必须在代码中加入“package java.scut;”和“package java.scut.computer;”两个语句

D 在代码中，不一定是第一句，只要是类定义前，加入package语句即可
选项：A
9.下列哪一项不属于Swing的顶层容器？（）

A JApplet

B JTree

C JDialog

D JFrame
选项：选B 顶层容器是指可以不能被其他容器包含，是容纳其他容器的容器组件，顶层容器包含JApplet、JDialog、JFrame和JWindow及其子类.
JFrame中就可以放Jtree（树形组件）
所以B不是
10.在Java中，对于不再使用的内存资源，如调用完成的方法，“垃圾回收器”会自动将其释放。（）

A 正确

B 错误
选项：B 方法调用时，会创建栈帧在栈中，调用完是程序自动出栈释放，而不是gc释放。

JVM 内存可简单分为三个区：

1、堆区（heap）：用于存放所有对象，是线程共享的（注：数组也属于对象）

2、栈区（stack）：用于存放基本数据类型的数据和对象的引用，是线程私有的（分为：虚拟机栈和本地方法栈）

3、方法区（method）：用于存放类信息、常量、静态变量、编译后的字节码等，是线程共享的（也被称为非堆，即 None-Heap）

Java 的垃圾回收器（GC）主要针对堆区

编程题：

在这里插入图片描述

public class haha {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		/*
		 * 1 2 4 2 1 0 1 2 1 0 i=3 -2-1 0 1 2 j
		 * 
		 */
		for (int i = 1; i <= 8; i++) {
			for (int k = 1; k <= 8 - i; k++) {
				System.out.print("   ");
			}
			for (int j = 1 - i; j < i; j++) {
				if (j <= 0) {
					System.out.print((int) Math.pow(2, j + i - 1) + " ");
				} else {
					System.out.print((int) Math.pow(2, i - 1 - j) + " ");
				}
			}
			System.out.println();
		}
	}
}

2018年10月10号

1.下列InputStream类中哪个方法可以用于关闭流？

A skip（）

B close（）

C mark（）

D reset（）
解析：选C inputstream的close方法用来关闭流
skip()用来跳过一些字节
mark（）用来标记流
reset（）复位流
2.下列程序执行后结果为( )

class A {
    public int func1(int a, int b) {
        return a - b;
    }
}
class B extends A {
    public int func1(int a, int b) {
        return a + b;
    }
}
public class ChildClass {
    public static void main(String[] args) {
    A a = new B();
    B b = new B();
    System.out.println("Result=" + a.func1(100, 50));
    System.out.println("Result=" + b.func1(100, 50));
    }
}

A Result=150Result=150

B Result=100Result=100

C Result=100Result=150

D Result=150Result=100
解析：选A 此题考查的是多态。

关键的来了，不论向上或者向下转型，都是一句话，“编译看左边，运行看右边”。也就是编译时候，会看左边引用类型是否能正确编译通过，运行的时候是调用右边的对象的方法。
就本题来说，编译时候会发现左边满足条件所以编译通过，运行时候又会调用右边也就是 class B 的方法，所以答案都是150。
对于多态，可以总结它为：

 一、使用父类类型的引用指向子类的对象；

二、该引用只能调用父类中定义的方法和变量；

三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）

四、变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。

多态的3个必要条件：
1.继承 2.重写 3.父类引用指向子类对象。

向上转型： Person p = new Man() ; //向上转型不需要强制类型转化
向下转型： Man man = (Man)new Person() ; //必须强制类型转化
3.为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为( )。

A static void method( )

B public void method( )

C final void method( )

D abstract void method( )
解析：选A 根据题目：使用类名AB作为前缀就可以调用，意思该方法就必须是静态方法。因为静态方法可以由类名直接调用。
A是静态方法，所以正确。
B、C、D是实例方法，必须由对象调用，不能由类名直接调用，所以错误。
只有静态方法才能被类名调用。
B、一般方法，只能被实例对象调用
C、final修饰方法，只是说明本方法不能被重写。
D、abstract修饰方法，表示本方法为抽象方法，没有方法体，且抽象方法必须在抽象类中，但是抽象类中可以没有抽象方法

4.执行下列代码后，哪些结论是正确的（）？
String[] s=new String[10];

A s[0]为未定义

B s[9]为null

C s.length为0

D s[10]为” “
解析：B
在这里插入图片描述

5.This调用语句必须是构造函数中的第一个可执行语句。

A 正确

B 错误
解析：选B
this()和super()为构造方法，作用是在JVM堆中构建出一个对象。因此避免多次创建对象，同一个方法内只能调用一次this()或super()。同时为了避免操作对象时对象还未构建成功，需要this()和super()的调用在第一行实现【以此来创建对象】，防止异常。
6.下列代码的输出结果是_____
boolean b=true?false:true==true?false:true;
System.out.println(b);
A true

B false

C null

D 空字符串

解析：选B
== 优先级高于三目运算符，先判断 true == true，此时返回为 true,
这时表达式为 boolean b = true?false:true?false:true
此时三目运算符从右向左执行,true?false:true，返回false
这时表达式为 boolean b = true?false:false;
结果为：boolean b = false ;

7.在 Java 中，属于整数类型变量的是（）

A single

B double

C byte

D char
选项：选C
8.Which statement at PointX on line I allows this code to compile and run?

   //point X
public class Foo {
    public static void main(String[] args) throws Exception {
 
        PrintWriter out = new PrintWriter(
            new java.io.OutputStreamWriter(System.out), true);
        out.printIn(“Hello”)；
    }
}

A import java.io.PrintWriter;

B include java.io.PrintWriter;

C import java.io.OutputStreamWriter;

D include java.io.OutputStreamWriter;

E no statement is needed.
解析：选A

9.Java.Thread的方法resume()负责重新开始被以下哪个方法中断的线程的执行（）。

A stop

B sleep

C wait

D suspend
选项：选D
suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的 resume() 被调用，才能使得线程重新进入可执行状态
10.JAVA中，下列语句哪一个正确（）

A class中的constructor不可省略

B constructor必须与class同名，但方法不能与class同名

C constructor在一个对象被new时执行

D 一个class只能定义一个constructor
解析：选C
A 省略构造函数,编译器会自动生成。
D 构造函数可以重载
B 方法是可以和类名同名的，和构造方法唯一的区别就是，构造方法没有返回值。如下代码：

public class TestConStructor
{
    public TestConStructor()
    {
        System.out.println("constructor");
    }
    public void TestConStructor()
    {
        System.out.println("not constructor");
}
public static void main(String[] args)
{
    TestConStructor testConStructor = new TestConStructor();
    System.out.println("main");
    testConStructor.TestConStructor();
}

编程题：
在这里插入图片描述

import java.util.Scanner;
public class Demo4_6 {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
/*
 *                           1    
 *                       2  1  2        
 *                   3  2  1  2  3              
 *               4  3  2  1  2  3  4                 
 *           5  4  3  2  1  2  3  4  5                       
 *       6  5  4  3  2  1  2  3  4  5  6                            
 *   -7  -6  -5 - 4  -3  -2  -1 0 1 2  3  4  5  6  7

 *                              
 */
    Scanner sc=new Scanner(System.in);
    System.out.print("请输入n：");
    int n=sc.nextInt();
    for(int i=1;i<=n;i++) {
    	for(int k=1;k<=n-i;k++) {
    		System.out.print("   ");
    	}
    	for(int j=-i;j<=i;j++) {
    		if(j!=0&&j!=1) {
    			System.out.print(Math.abs(j)+" ");
    		}
    	}
    	System.out.println();
    }
	}
}

2018年10月11

1.有程序片段如下，以下表达式结果为 true 的是（）

Float  s=new  Float(0.1f);

Float  t=new  Float(0.1f);

Double  u=new  Double(0.1);

A s==t

B s.equals(t)

C u.equals(s)

D t.equals(u)
解析：选B
2.如果希望某个变量只可以被类本身访问和调用，则应该使用下列哪一种访问控制修饰？
A public

B private

C private protected

D protected
解析：选B
1、public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用

 2、private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。 

 3、protected：protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private。 

     作用域       当前类    同一package   子孙类     其他package 

       public        √         √             √           √ 

      protected     √          √             √           × 

      friendly      √          √             ×           × 

      private       √          ×             ×           ×

3.以下程序执行的结果是：

class X{
    Y y=new Y();
    public X(){
        System.out.print("X");
    }
}
class Y{
    public Y(){
        System.out.print("Y");
    }
}
public class Z extends X{
    Y y=new Y();
    public Z(){
        System.out.print("Z");
    }
    public static void main(String[] args) {
        new Z();
    }
}

A ZYXX

B ZYXY

C YXYZ

D XYZX
解析：选C

初始化父类中的静态成员变量和静态代码块；
初始化子类中的静态成员变量和静态代码块；
初始化父类的普通成员变量和代码块，再执行父类的构造方法；
初始化子类的普通成员变量和代码块，再执行子类的构造方法；

（1）初始化父类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y
（2）再执行父类的构造方法；输出X
（3）初始化子类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y
（4）再执行子类的构造方法；输出Z
所以输出YXYZ

下列方法定义中，正确的是（）

A int x( ){ char ch=’a’; return (int)ch; }

B void x( ){ …return true; }

C int x( ){ …return true; }

D int x( int a, b){ return a+b; }
解析：选A

A.Java中涉及到byte、short和char类型都可以强制转化为int，符合返回类型 A正确
B.方法中定义为void 应该没有返回值，但返回值为boolean类型 B错
C. 方法中类型为int，应该返回int类型值，但是返回值为boolean类型 C错
D.方法应该定义为int(int a,int b)，所以D错
5.判断对错。在java的多态调用中，new的是哪一个类就是调用的哪个类的方法。
A 正确
B 错误
解析：选B
引用毕向东教程的一段话：
1.成员变量：编译和运行都参考左边。
2.成员函数（非静态）：编译看左边，运行看右边
3.静态函数：编译和运行都看左边。

下面哪个修饰符修饰的变量是所有同一个类生成的对象共享的（）

A public

B private

C static

D final
解析：选C

static修饰某个字段时，肯定会改变字段创建的方式（每个被static修饰的字段对于每一个类来说只有一份存储空间，而非static修饰的字段对于每一个对象来说都有一个存储空间）
static属性是属于类的，所有对象共同拥有，所以既可以通过类名.变量名进行操作，又可以通过对象名.变量名进行操作。

关于匿名内部类叙述正确的是？ ( )

A 匿名内部类可以继承一个基类，不可以实现一个接口

B 匿名内部类不可以定义构造器

C 匿名内部类不能用于形参

D 以上说法都不正确
解析：选B

由于构造器的名字必须与类名相同，而匿名类没有类名，所以匿名类不能有构造器。

在使用匿名内部类的过程中，我们需要注意如下几点：

  1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。

 2、匿名内部类中是不能定义构造函数的。

 3、匿名内部类中不能存在任何的静态成员变量和静态方法。

  4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。

 5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

8.关于 java 的异常处理机制的叙述哪些正确？

A 不论程序是否发生错误及捕捉到异常情况，都会执行finally部分

B 当try区段的程序发生异常时，才会执行catch区段的程序

C catch部分捕捉到异常情况时，才会执行finally部分

D 其它选项都不正确
解析：选AB

A、不论程序是否发生错误及捕捉到异常情况，都会执行finally部分。（正确）
B、当try区段的程序发生异常时，才会执行catch区段的程序。（正确）
C、 catch部分捕捉到异常情况时，才会执行finally部分（错误，不管有没有捕捉到异常，都会执行finally）
D、上面有正确的，D错误。

9.下列关于JAVA多线程的叙述正确的是（）

A 调用start()方法和run()都可以启动一个线程

B CyclicBarrier和CountDownLatch都可以让一组线程等待其他线程

C Callable类的call()方法可以返回值和抛出异常

D 新建的线程调用start()方法就能立即进行运行状态
解析：选择BC

A. start()方法来启动线程，真正实现了多线程运行，调用了run()方法；run()方法当作普通方法的方式调用。
B. CyclicBarrier让一组线程等待其他线程；CountDownLatch让一组线程等待某个事件发生。
C. Callable能够抛出checked exception。
D. start()方法让thread进去可运行状态（runnable），等待获取CPU的使用权。
CyclicBarrier(栅栏)：可以让一组线程等待其他线程。 CountDownLatch(闭锁)：可以让一组线程等待某个事件发生。

10.有以下程序段，则下面正确的选项是（）

public class MyThead extends Thread{
    public static void main(String[] args) {
        MyThead t=new MyThead();
        MyThead s=new MyThead();
        t.start();
        System.out.println("one.");
        s.start();
        System.out.println("two.");
    }
    public void run() {
        System.out.println("Thread");
    }
}

A 编译失败

B 程序运行可能结果为：
one.
Thread
two.
Thread

C 程序运行可能结果是：
one.
two.
Thread
Thread

D 程序运行结果不稳定

解析：选BCD
两个start方法之后一共三个线程就绪：主线程，线程s，线程t，处于就绪状态中的线程并没有开始运行，至于什么时候开始运行，取决于取决于JVM里线程调度器的调度。

编程题

在这里插入图片描述

public class Demo4_2 {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner sc = new Scanner(System.in);
		int firstScore = 0;
		int secondScore = 0;
		String firstname = " ";
		String secondname = " ";
		int count = 0;
		System.out.println("请输入学生的个数！");
		int num = sc.nextInt();
		while (count < num) {
			System.out.println("请输入学生姓名！");
			String name = sc.next();
			System.out.println("请输入成绩！");
			int score = sc.nextInt();
			if (score > firstScore) {
				secondScore = firstScore;
				secondname = firstname;
				firstScore = score;
				firstname = name;
			} else {
				secondScore = score;
				secondname = name;
			}
			count++;
		}
		System.out.println("最高分是" + firstname + ":" + firstScore);
		System.out.println("最低分是" + secondname + ":" + secondScore);
	}
}

2018.10.17

1.面向对象程序设计语言的三个基本特征是封装、继承、多态。
A.正确
B.错误
选项：选A
2. 导出类调用基类的构造器必须用到的关键字： ( )

A this

B final

C super

D static
选项：选C
3.一个以”.java”为后缀的源文件

A 只能包含一个类，类名必须与文件名相同

B 只能包含与文件名相同的类以及其中的内部类

C 只能有一个与文件名相同的类，可以包含其他类

D 可以包含任意类

选项：选C
一个.java文件中，只能存在一个类是用public修饰的，并且这个类必须与类名一致，文件中其他的类不能是public权限的，但可以有很多个类。

4.以下说法错误的是（）

A 数组是一个对象

B 数组不是一种原生类

C 数组的大小可以任意改变

D 在Java中，数组存储在堆中连续内存空间里
选项：选C
5.以下哪个不是Collection的子接口？

A List

B Set

C SortedSet

D Map

选项：选D
Collection主要的子接口:
List:可以存放重复内容
Set:不能存放重复内容,所有重复的内容靠hashCode()和equals()两个方法区分
Queue:队列接口
SortedSet:可以对集合中的数据进行排序
Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。

在这里插入图片描述

在这里插入图片描述
6.在使用super 和this关键字时，以下描述正确的是

A 在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过

B super（）和this（）不一定要放在构造方法内第一行

C this（）和super（）可以同时出现在一个构造函数中

D this（）和super（）可以在static环境中使用，包括static方法和static语句块

选项：选A
1）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
2）super()和this()类似,区别是，super从子类中调用父类的构造方法，this()在同一类内调用其它方法。
3）super()和this()均需放在构造方法内第一行。
4）尽管可以用this调用一个构造器，但却不能调用两个。
5）this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
6）this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
7）从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。
综上A正确！

*******

在这里插入图片描述

7.要表示10个学生的成绩，下列声明并初始化数组正确的是（）

A int[] score=new int[ ]

B int score[10]

C int score[]=new int[9]

D int score[]=new int[10]
选项：选D

数组初始化有三种方式：

动态初始化：数组定义与为数组分配空间和赋值的操作分开进行；
静态初始化：在定义数字的同时就为数组元素分配空间并赋值；
默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化。

public class Test {
 public static void main(String[] args) {
     //动态初始化
     int[] a;//int a[];两者都可以
     a = new int[10];
     a[0] = 0;
     a[1] = 1;
     a[2] = 2;
     //静态初始化
     int[] b = {0, 1, 2};//int b[] = {0, 1, 2};两者都可以
     //默认初始化
     int[] c = new int[10];//int c[] = new int[10];两者都可以
 }
}

8.以下是java concurrent包下的4个类，选出差别最大的一个

A Semaphore

B ReentrantLock

C Future

D CountDownLatch

选项：选C
A、Semaphore：类，控制某个资源可被同时访问的个数;
B、ReentrantLock：类，具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大；
C、 Future：接口，表示异步计算的结果；
D、 CountDownLatch：类，可以用来在一个线程中等待多个线程完成任务的类。

9.下列关于计算机系统和Java编程语言的说法，正确的是（）

A 计算机是由硬件、操作系统和软件组成，操作系统是缺一不可的组成部分。

B Java语言编写的程序源代码可以不需要编译直接在硬件上运行。

C 在程序中书写注释不会影响程序的执行，可以在必要的地方多写一些注释。

D Java的集成开发环境（IDE），如Eclipse，是开发Java语言必需的软件工具。
选项：选C
10.mysql数据库，game_order表表结构如下，下面哪些sql能使用到索引（）？
A select * from game_order where plat_game_id=5 and plat_id=134

B select * from game_order where plat_id=134 and
plat_game_id=5 and plat_order_id=’100’

C select * from game_order where plat_order_id=’100’

D select * from game_order where plat_game_id=5 and
plat_order_id=’100’ and plat_id=134

E select * from game_order where plat_game_id=5 and plat_order_id=’100’

选项：B C D E

编程题

import java.util.Scanner;

public class haha {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入密码：");
		String password = sc.nextLine();
		int count = 0;
		for (int i = 0; i < password.length(); i++) {
			char c = password.charAt(i);
			if (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9') {
				if (c >= '0' && c <= '9') {
					count++;
				}
			} else {
				System.out.println("格式错误");
				return;
			}
		}
		if (count < 2 || password.length() < 8) {
			System.out.println("格式错误！");
			return;
		}
		System.out.println("正确");
	}
}

2018.10.19

1.下列关于构造函数的描述正确的是?
正确答案: C 你的答案: C (正确)

A 构造函数可以声明返回类型

B 构造函数不可以用private修饰

C 构造函数必须与类名相同

D 构造函数不能带参数
2. 类Person里面有个方法sleep()，如果直接用Person.sleep()，则方法sleep前面必须用的关键词是？ ( )
正确答案: B 你的答案: B (正确)
A class

B static

C public

D final
3. 将类的成员的访问权限设置为默认的，则该成员能被( )
正确答案: A 你的答案: A (正确)

A 同一包中的类访问

B 其它包中的类访问

C 所有的类访问

D 所有的类的子类访问

解析：

public：可以被所有其他类所访问;
protected：自身、子类及同一个包中类可以访问;
default：同一包中的类可以访问;
private：只能被自己访问和修改。
public>protcted>default>priavte

4.Java中，main()方法的返回值的类型是：
正确答案: C 你的答案: C (正确)
A public

B static

C void

D String
5. 如果类的方法没有返回值，该方法的返回类型应是：( )
正确答案: A 你的答案: A (正确)
A void

B null

C abstract

D default
6.关于Java的异常处理机制的叙述哪些正确？

正确答案: C 你的答案: C (正确)

A 如果程序发生错误及捕捉到异常情况了，才会执行finally部分

B 其他选项都不正确

C 当try区段的程序发生异常且被catch捕捉到时，才会执行catch区段的程序

D catch部分捕捉到异常情况时，才会执行finally部分
7.如何跳出Array的forEach循环？（）

正确答案: A 你的答案: A (正确)

A break

B return true

C return false

D 以上都不是
8.下列关于构造函数的描述中，错误的是（）
正确答案: D 你的答案: D (正确)

A 构造函数可以设置默认的参数

B 构造函数在定义类对象时自动执行

C 构造函数可以是内联函数

D 构造函数不可以重载

9.下面哪个不属于HttpServletResponse接口完成的功能？
正确答案: C 你的答案: D (错误)

A 设置HTTP头标

B 设置cookie

C 读取路径信息

D 输出返回数据

解析：
A：设置HTTP头标
response.setHeader(“Refresh”,“3”); //三秒刷新页面一次
B：设置cookie
Cookie c1 = new Cookie(“username”,“only”);
response.addCookie(c1);
C（错误）：读取路径信息,request读取路径信息
1.从request获取各种路径总结
2.request.getRealPath(“url”); // 虚拟目录映射为实际目录
3.request.getRealPath("./"); // 网页所在的目录
4.request.getRealPath("…/"); // 网页所在目录的上一层目录
5.request.getContextPath(); // 应用的web目录的名称
D：输出返回数据
HttpServleteResponse.getOutputStream().write();

10.JSP分页代码中，哪个步骤次序是正确的？
正确答案: A 你的答案: B (错误)

A 先取总记录数，得到总页数，最后显示本页的数据。

B 先取所有的记录，得到总页数，再取总记录数，最后显示本页的数据。

C 先取总页数，得到总记录数，再取所有的记录，最后显示本页的数据。

D 先取本页的数据，得到总页数，再取总记录数，最后显示所有的记录。

解析：
1、count(*)得到总记录数
2、计算总页数
3、获取所有记录(个人感觉这一步不需要，可以直接获取指定页数数据)
4、过滤显示本页数据

在这里插入图片描述

import java.util.Scanner;

public class haha {
	/*
	 * 输入120 2*2*2*3*5=120 120%2=0 120/2=60 60%2=0 60/2=30 30%2=0 30/2=15 15%3=0
	 * 15/3=5 5%2!=0
	 * 
	 */
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入n");
		int n = sc.nextInt();
		while (true) {
			boolean flag = false;// 假设n不能被整除
			for (int i = 2; i <= n / 2; i++) {
				if (n % i == 0) {
					System.out.print(i + ",");
					n /= i;
					flag = true;
					break;
				}
			}
			if (!flag) {
				System.out.println(n);
				break;
			}
		}
	}
}

2018.10.21

1.以下不属于构造方法特征的是（）
正确答案: D 你的答案: D (正确)

A 构造方法名与类名相同

B 构造方法不返回任何值，也没有返回类型

C 构造方法在创建对象时调用，其他地方不能显式地直接调用

D 每一个类只能有一个构造方法
2.在某个类A中存在一个方法：void set(int x),以下不能作为这个方法的重载的声明的是（）
正确答案: A 你的答案: A (正确)

A void set(int y)

B int set(int x，double y)

C double set(int x,int y)

D void set(int x,int y)
3. 关于数据库连接的程序，以下哪个语句的注释是错误的（）
正确答案: C 你的答案: C (正确)
A Class.forName(“com.mysql.jdbc.Driver”); //指定MySQL JDBC驱动程序

B String url=” jdbc:mysql://localhost:3306/student”; //指定驱动程序与数据源的连接

C db.executeUpdate(sql); //用于返回查询结果

D while(rs.next())//用于遍历查询结果中的记录
4. 有以下代码片段：

String str1="hello";

String str2="he"+ new String("llo");

System.out.println(str1==str2);

请问输出的结果是：
正确答案: D 你的答案: D (正确)
A true

B 都不对

C null

D false

解析：

String类是final类，也即意味着String类不能被继承，并且它的成员方法都默认为final方法。在Java中，被final修饰的类是不允许被继承的，并且该类中的成员方法都默认为final方法。

2）String类底层是char数组来保存字符串的。

对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象

字符串常量池

在class文件中有一部分来存储编译期间生成的字面常量以及符号引用，这部分叫做class文件常量池，在运行期间对应着方法区的运行时常量池。

JVM为了减少字符串对象的重复创建，其维护了一个特殊的内存，这段内存被成为字符串常量池或者字符串字面量池

工作原理

当代码中出现字面量形式创建字符串对象时，JVM首先会对这个字面量进行检查，如果字符串常量池中存在相同内容的字符串对象的引用，则将这个引用返回，否则新的字符串对象被创建，然后将这个引用放入字符串常量池，并返回该引用。

实现前提

字符串常量池实现的前提条件就是Java中String对象是不可变的，这样可以安全保证多个变量共享同一个对象。如果Java中的String对象可变的话，一个引用操作改变了对象的值，那么其他的变量也会受到影响，显然这样是不合理的。



String str1 = "hello";

这里的str1指的是方法区中的字符串常量池中的“hello”，编译时期就知道的； 

String str2 = "he" + new String("llo");

这里的str2必须在运行时才知道str2是什么，所以它是指向的是堆里定义的字符串“hello”，所以这两个引用是不一样的。

如果用str1.equal(str2)，那么返回的是true；因为String类重写了equals()方法。

编译器没那么智能,它不知道"he" + new String("llo")的内容是什么,所以才不敢贸然把"hello"这个对象的引用赋给str2.

如果语句改为:"he"+"llo"这样就是true了。

new String("zz")实际上创建了2个String对象，就是使用“zz”通过双引号创建的（在字符串常量池），另一个是通过new创建的（在堆里）。只不过他们的创建的时期不同，一个是编译期，一个是运行期。

String s = "a"+"b"+"c";

语句中，“a”,"b", "c"都是常量，编译时就直接存储他们的字面值，而不是他们的引用，在编译时就直接将它们连接的结果提取出来变成"abc"了。

5.若下列所用变量均已经正确定义，一下表达式中不合法的是
正确答案: B 你的答案: B (正确)

A x>>3

B +++j

C a=x>y?x:y

D x%=4
6.关于依赖注入，下列选项中说法错误的是（）
正确答案: B 你的答案: C (错误)

A 依赖注入能够独立开发各组件，然后根据组件间关系进行组装

B 依赖注入使组件之间相互依赖，相互制约

C 依赖注入提供使用接口编程

D 依赖注入指对象在使用时动态注入

解析：

依赖注入和控制反转是同一概念：
依赖注入和控制反转是对同一件事情的不同描述，从某个方面讲，就是它们描述的角度不同。依赖注入是从应用程序的角度在描述，可以把依赖注入描述完整点：应用程序依赖容器创建并注入它所需要的外部资源；而控制反转是从容器的角度在描述，描述完整点：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的外部资源。

7.观察以下代码：

class Car extends Vehicle
{
    public static void main (String[] args)
    {
        new  Car(). run();
    }
    private final void run()
    {
        System. out. println ("Car");
    }
}
class Vehicle
{
    private final void run()
    {
        System. out. println("Vehicle");
    }
}

下列哪些针对代码运行结果的描述是正确的？
正确答案: A 你的答案: C (错误)

A Car

B Vehicle

C Compiler error at line 3

D Compiler error at line 5

E Exception thrown at runtime

解析：答案：A
首先final声明的方法是不能被覆盖的，但是这里并不错误，因为方法是private的，也就是子类没有继承父类的run方法，因此子类的run方法跟父类的run方法无关，并不是覆盖。new Car().run()也是调用子类的run方法。
此题的父类方法有private修饰，所以对子类不可见，子类不能覆盖。所以子类方法和父类是两个方法。
扩展：如果父类方法将private改为public 会怎样？
会报错，因为父类方法有final修饰，不能被覆盖。

8.关于AWT和Swing说法正确的是？
正确答案: D 你的答案: D (正确)

A Swing是AWT的子类

B AWT在不同操作系统中显示相同的风格

C AWT不支持事件类型，Swing支持事件模型

D Swing在不同的操作系统中显示相同的风格

解析：（1）AWT，抽象窗口工具包，是Java提供的建立图形用户界面的工具集，可用于生成现代的、鼠标控制的图形应用接口，且无需修改，就可以在各种软硬件平台上运行。
而swing是Java语言在编写图形用户界面方面的新技术，Swing采用模型-视图-控制设计范式，Swing可以使Java程序在同一个平台上运行时能够有不同外观以供用户选择。
两者不同在于一个是初代工具集，一个是进化版的工具集，用户不会再满足于初始的功能，而是更加注重于附加价值，明显从这点上，Swing是比AWT要好很多。
写法上，Swing的头文件引用包需要用到Javax，组件调用时也需要在AWT的基础上加上“J”。
（2）AWT和Swing都是java中的包。
AWT(Abstract Window Toolkit)：抽象窗口工具包，早期编写图形界面应用程序的包。
Swing ：为解决 AWT 存在的问题而新开发的图形界面包。Swing是对AWT的改良和扩展。
AWT和Swing的实现原理不同：
AWT的图形函数与操作系统提供的图形函数有着一一对应的关系。也就是说，当我们利用 AWT构件图形用户界面的时候，实际上是在利用操作系统的图形库。
不同的操作系统其图形库的功能可能不一样，在一个平台上存在的功能在另外一个平台上则可能不存在。为了实现Java语言所宣称的"一次编译，到处运行"的概念，AWT不得不通过牺牲功能来实现平台无关性。因此，AWT 的图形功能是各操作系统图形功能的“交集”。
因为AWT是依靠本地方法来实现功能的，所以AWT控件称为“重量级控件”。

   而Swing ，不仅提供了AWT 的所有功能，还用纯粹的Java代码对AWT的功能进行了大幅度的扩充。
   例如：并不是所有的操作系统都提供了对树形控件的支持， Swing则利用了AWT中所提供的基本作图方法模拟了一个树形控件。
   由于 Swing是用纯粹的Java代码来实现的，因此Swing控件在各平台通用。
   因为Swing不使用本地方法，故Swing控件称为“轻量级控件”。 

   AWT和Swing之间的区别：
   1)AWT 是基于本地方法的C/C++程序，其运行速度比较快；Swing是基于AWT的Java程序，其运行速度比较慢。
   2)AWT的控件在不同的平台可能表现不同，而Swing在所有平台表现一致。

   在实际应用中，应该使用AWT还是Swing取决于应用程序所部署的平台类型。例如：
   1)对于一个嵌入式应用，目标平台的硬件资源往往非常有限，而应用程序的运行速度又是项目中至关重要的因素。在这种矛盾的情况下，简单而高效的AWT当然成了嵌入式Java的第一选择。
   2)在普通的基于PC或者是工作站的标准Java应用中，硬件资源对应用程序所造成的限制往往不是项目中的关键因素。所以在标准版的Java中则提倡使用Swing， 也就是通过牺牲速度来实现应用程序的功能。

9.常用的servlet包的名称是？
正确答案: B D 你的答案: D (错误)

A java.servlet

B javax.servlet

C servlet.http

D javax.servlet.http
10. 下面哪些Java中的流对象是字节流?
正确答案: A B C D 你的答案: D (错误)

A FileInputStream

B BufferedInputStream

C PushbackInputStream

D ByteArrayInputStream

解析：
stream结尾都是字节流，reader和writer结尾都是字符流两者的区别就是读写的时候一个是按字节读写，一个是按字符。实际使用通常差不多。在读写文件需要对内容按行处理，比如比较特定字符，处理某一行数据的时候一般会选择字符流。只是读写文件，和文件内容无关的，一般选择字节流。

2018.10.22

1.类声明中，声明一个类不能再被继承的关键字是（）
A public

B abstract

C final

D static

解析：选C
inal关键字可用于修饰类、变量和方法。final修饰的类不能被继承，final修饰的方法不能被重写，final修饰的变量不可被修改，一旦获得初始值，该变量就不能被重新赋值。
public：访问控制修饰符，用于修饰类、类的方法、属性或者构造器。
abstract：用于修饰抽象类或者抽象方法
static：用于修饰类、方法或者成员变量，表明该类是静态类或者方法、成员变量属于当前类

2.下列说法哪个正确( )
正确答案: C 你的答案: C (正确)

A 不需要定义类，就能创建对象

B 对象中必须有数据域和方法

C 数据域可以是基本类型变量，也可以是一个对象

D 数据域必须是基本类型变量

解析： A.没有模板，怎么可能创建对象，创建对象必须先要定义类，常识
B.对象中的数据域和方法取决于该对象的类，类里面有就有，没有就没有
D.数据域不一定是基本类型，也可以是引用类型

3.以下关于java封装的描述中，正确的是：
正确答案: A 你的答案: A (正确)

A 封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性

B 封装的意义不大，因此在编码中尽量不要使用

C 如果子类继承父类，对于父类中进行封装的方法，子类仍然可以直接调用

D 只能对一个类中的方法进行封装，不能对属性进行封装

解析：
封装主要是隐藏内部代码；
继承主要是复用现有代码；
多态主要是改写对象行为。

4.在异常处理中，以下描述不正确的有
正确答案: D 你的答案: D (正确)

A try块不可以省略

B 可以使用多重catch块

C finally块可以省略

D catch块和finally块可以同时省略
5.编译java程序的命令文件是( )
正确答案: B 你的答案: B (正确)

A java.exe

B javac.exe

C applet.exe

解析：javac.exe是编译功能javaCompiler
java.exe是执行class，如果没有编译的话是不能执行的，同理，javac.exe编译完以后如果没有java.exe执行的话也是没有运行的

6.我们在程序中经常使用“System.out.println()”来输出信息，语句中的System是包名，out是类名，println是方法名。（）
正确答案: B 你的答案: A (错误)

A 正确

B 错误

解析：System是java.lang包下的一个类，out为System的final静态成员（PrintStream类型），println()是PrintStream类的实例方法

7.下列哪项不属于jdk1.6垃圾收集器？
正确答案: D 你的答案: A (错误)

A Serial收集器

B parNew收集器

C CMS收集器

D G1收集器

解析：
8.如果希望监听TCP端口9000，应该怎样创建socket?
正确答案: B 你的答案: D (错误)

A new Socket(“localhost”,9000);

B new ServerSocket(9000);

C new Socket(9000);

D new ServerSocket(“localhost”,9000);

解析：
ServerSocket(int port) 是服务端绑定port端口，调accept()监听等待客户端连接，它返回一个连接队列中的一个socket。
Socket(InetAddress address , int port)是创建客户端连接主机的socket流，其中InetAddress是用来记录主机的类，port指定端口。
socket和servletSocket的交互如下图所示：

在这里插入图片描述
9.给定以下JAVA代码，这段代码运行后输出的结果是（）

public class Test
{  
    public static int aMethod(int i)throws Exception
    {
        try{
            return i/10;
        }
        catch (Exception ex)
        {
            throw new Exception("exception in a aMethod");
        }finally{
      System.out.printf("finally");
        }
} 
    public static void main(String[] args){
        try
        {
            aMethod(0);
        }
        catch (Exception ex)
        {
            System.out.printf("exception in main");
        }
        System.out.printf("finished");
    }
}

A exception in main finished

B finally finished

C exception in main finally

D finally exception in main finally

选项：选B

10.下面哪几个函数 public void example(){…} 的重载函数？（）
正确答案: A D 你的答案: A D (正确)

A public void example(int m){…}

B public int example(){…}

C public void example2(){…}

D public int example(int m,float f){…}

2018.10.23

1.已知声明并初始化二维数组 int a[ ][ ]={{1,2},{3,4},{5,6}} ，则 a[1][1] 的值为（）
A 1

B 2

C 4

D 5
2.java中用()字指明继承关系.用()关键字指明对接口的实现。

A implements extends

B extends implements

C extend implement

D implement extend
选B
3.在 java 中 , 以下 _____ 类的对象以键 - 值的方式存储对象

A java,util.List

B java,util.ArrayList

C java,util.HashMap

D java,util.LinkedList

选项：选C
Map以key-value形式保存，HashMap、HashTable继承自Map;
ArrayList底层以数组方式存储；
LinkedList以链表形式存储。

4.以下关于 abstract 关键字的说法，正确的是（）

A abstract 可以与final 并列修饰同一个类。

B abstract 类中不可以有private的成员。

C abstract 类中必须全部是abstract方法。

D abstract 方法必须在abstract类或接口中。

解析：选D
1abstract类不能与final,static使用。final修饰方法，子类可以调用，但不能覆盖。
2最好不要有private因为私有和抽象放在一起，子类如果想重写父类的私有方法根本继承不过来，也就无法重写
3抽象类中可以有非抽象方法
4抽象类中可以都是非抽象的，但是抽象方法一定要在类和接口中

public class Test
{
    static boolean foo(char c)
    {
        System.out.print(c);
        return true;
    }
    public static void main( String[] argv )
    {
        int i = 0;
        for ( foo('A'); foo('B') && (i < 2); foo('C'))
        {
            i++ ;
            foo('D');
        }
    }
}

它的结果是什么？
A ABDCBDCB

B ABCDABCD

C Compilation fails.

D An exception is thrown at runtime.

解析：选A

6.下面有关java内存模型的描述，说法错误的是？

A JMM通过控制主内存与每个线程的本地内存之间的交互，来为java程序员提供内存可见性保证

B “synchronized” — 保证在块开始时都同步主内存的值到工作内存，而块结束时将变量同步回主内存

C “volatile” — 保证修饰后在对变量读写前都会与主内存更新。

D 如果在一个线程构造了一个不可变对象之后（对象仅包含final字段），就可以保证了这个对象被其他线程正确的查看

解析：选D

7.Java语言中，方法的重写（Overriding）和重载（Overloading）是多态性的不同表现。下边哪些说法是对的？
正确答案: A C 你的答案: A C (正确)

A 重写是父类与子类之间多态性的一种表现

B 重写是一个类中多态性的一种表现

C 重载是一个类中多态性的一种表现

D 重载是父类与子类之间多态性的一种表现

解析：
8.如果Child extends Parent，那么正确的有（）？

A 如果Child是class，且只有一个有参数的构造函数，那么必然会调用Parent中相同参数的构造函数

B 如果Child是interface，那么Parent必然是interface

C 如果Child是interface，那么Child可以同时extends Parent1，Parent2等多个interface

D 如果Child是class，并且没有显示声明任何构造函数，那么此时仍然会调用Parent的构造函数
选项：B C D

A 可以调用父类无参的构造函数，子类的有参构造函数和是否调用父类的有参数的构造函数无必然联系。
B 接口继承的时候只能继承接口不能继承类，因为如果类可以存在非抽象的成员，如果接口继承了该类，那么接口必定从类中也继承了这些非抽象成员，这就和接口的定义相互矛盾，所以接口继承时只能继承接口。
C 接口可以多继承可以被多实现，因为接口中的方法都是抽象的，这些方法都被实现的类所实现，即使多个父接口中有同名的方法，在调用这些方法时调用的时子类的中被实现的方法，不存在歧义；同时，接口的中只有静态的常量，但是由于静态变量是在编译期决定调用关系的，即使存在一定的冲突也会在编译时提示出错；而引用静态变量一般直接使用类名或接口名，从而避免产生歧义，因此也不存在多继承的第一个缺点。对于一个接口继承多个父接口的情况也一样不存在这些缺点。所以接口可以多继承。
D 子类即使没有显示构造函数，也会有个无参数的默认构造函数，仍然会调用父类的构造函数。

9.jvm中垃圾回收分为scanvenge gc和full GC，其中full GC触发的条件可能有哪些
正确答案: C D E
栈空间满

年轻代空间满

老年代满

持久代满

System.gc()
解析：
10下列说法正确的有（）
正确答案: A C D 你的答案: A D (错误)

A 环境变量可在编译source code时指定

B 在编译程序时，所能指定的环境变量不包括class path

C javac一次可同时编译数个Java源文件

D javac.exe能指定编译结果要置于哪个目录（directory）

在这里插入图片描述

package lianxi;

public class Demo5_20 {
/*
 * 1.计算两个骰子的和
 * 2.如果骰子的和为2、3、12 
 *    lose
 * 3.如果骰子的和为7、11
 *     win
 *   -----第二步和第三步执行一次------
 * 4.如果和为4、5、6、8、9、10
 *         4.1继续
 *         4.2如果和为7  lose
 *         4.3如果和与上次的和相等  win
 *         否则 继续 第四步以后的循环 直到满足条件后退出
 */
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		boolean flag=true;
		int lastsum=0;
		while(true) {
			int a=(int) (Math.random()*7);
			int b=(int) (Math.random()*7);
			int sum=a+b;
			if(flag) {
				if(sum==2||sum==3||sum==12) {
					System.out.println("你摇的点数和为"+a+"+"+b+"="+sum);
					System.out.println("你输了");
					break;
				}else if(sum==7||sum==11) {
					System.out.println("你摇的点数和为"+a+"+"+b+"="+sum);
					System.out.println("你赢了");
					break;
				}else {
					System.out.println("你摇的值是"+sum+"，不符合输赢规则，请继续！");
					lastsum=sum;
					flag=false;
				}
			}else {
				if(sum==7) {
					System.out.println("你摇的点数和为"+a+"+"+b+"="+sum);
					System.out.println("你输了");
					break;
				}else if(sum==lastsum){
					System.out.println("你摇的点数和为"+a+"+"+b+"="+sum);
					System.out.println("你赢了");
					break;
				}else {
					System.out.println("你摇的值是"+sum+"，不符合输赢规则，请继续！");
					lastsum=sum;
				}
			}	
		}
	}
}

2018.10.24

1.Which is the return type of the method main()?
正确答案: B 你的答案: B (正确)
A int

B void

C Boolean

D static
2.下面哪一项不是 java 类访问控制关键字
正确答案: B 你的答案: B (正确)
A public

B this

C private

D protected
3.Java中只有整型才能使用的运算符为？
正确答案: C 你的答案: B (错误)
A *

B /

C %

D +
4.关于 JAVA 堆,下面说法错误的是()
正确答案: D 你的答案: D (正确)

A 所有类的实例和数组都是在堆上分配内存的

B 对象所占的堆内存是由自动内存管理系统回收

C 堆内存由存活和死亡的对象,空闲碎片区组成

D 数组是分配在栈中的

解析：
Java把内存分成两种，一种叫做栈内存，一种叫做堆内存。
在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量分配的内存空间，该内存空间可以立刻被另作他用。
堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。在堆中产生了一个数组或者对象后，还可以在栈中定义一个特殊的变量，这个变量的取值等于数组或者对象在堆内存中的首地址，在栈中的这个特殊的变量就变成了数组或者对象的引用变量，以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象，引用变量相当于为数组或者对象起的一个别名，或者代号。
引用变量是普通变量，定义时在栈中分配内存，引用变量在程序运行到作用域外释放。而数组＆对象本身在堆中分配，即使程序运行到使用new产生数组和对象的语句所在地代码块之外，数组和对象本身占用的堆内存也不会被释放，数组和对象在没有引用变量指向它的时候（比如先前的引用变量x=null时），才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因。

   以上段落来自于某一本Java程序设计的书中，实际上，栈中的变量指向堆内存中的变量，这就是Java中的指针。

总结起来就是对象存储在堆内存，引用变量存储在栈内存。栈内存指向堆内存。
5.建立Statement对象的作用是？
正确答案: C 你的答案: D (错误)

A 连接数据库

B 声明数据库

C 执行SQL语句

D 保存查询结果

解析：
1、Statement对象用于执行不带参数的简单SQL语句。
2、Prepared Statement 对象用于执行预编译SQL语句。
3、Callable Statement对象用于执行对存储过程的调用。

6.以下Java程序运行的结果是:

public class Tester{
public static void main(String[] args){
   Integer var1=new Integer(1);
   Integer var2=var1;
   doSomething(var2);
   System.out.print(var1.intValue());
   System.out.print(var1==var2);
}
public static void doSomething(Integer integer){
    integer=new Integer(2);
    }
}

正确答案: A 你的答案: A (正确)

1true

2true

1false

2false

7.下面哪一项不属于优化Hibernate所鼓励的？
正确答案: A 你的答案: A (正确)

A 使用单向一对多关联，不使用双向一对多

B 不用一对一，用多对一取代

C 配置对象缓存，不使用集合缓存

D 继承类使用显式多态

解析：

优化Hibernate所鼓励的7大措施：
1.尽量使用many-to-one，避免使用单项one-to-many
2.灵活使用单向one-to-many
3.不用一对一，使用多对一代替一对一
4.配置对象缓存，不使用集合缓存
5.一对多使用Bag 多对一使用Set
6.继承使用显示多态 HQL:from object polymorphism=“exlicit” 避免查处所有对象
7.消除大表，使用二级缓存

8.面向对象程序设计语言不同于其他语言的主要特点。
正确答案: A C D 你的答案: A C D (正确)

A 继承性

B 消息传递

C 多态性

D 封装性
8.以下关于final关键字说法错误的是
正确答案: A C 你的答案: A C (正确)

A final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性

B final修饰的类肯定不能被继承

C final修饰的方法不能被重载

D final修饰的变量不允许被再次赋值

解析：
final修饰类、方法、属性！不能修饰抽象类，因为抽象类一般都是需要被继承的，final修饰后就不能继承了。
final修饰的方法不能被重写而不是重载！
final修饰属性，此属性就是一个常量，不能被再次赋值！

10.以下 json 格式数据，错误的是
正确答案: A C 你的答案: B C (错误)

A {company：4399}

B {“company”:{“name”:[4399,4399,4399]}}

C {[4399,4399,4399]}

D {“company”:[4399,4399,4399]}

C {“company”:{“name”:4399}}

解析：
A:错误 {company：4399} 首先，其为json对象。但json对象要求属性必须加双引号。
B:正确
C:错误 {[4399,4399,4399]} 。使用 {} 则为json对象。json对象必须由一组有序的键值对组成。
D:正确。

2018.10.25

1不考虑反射机制，一个子类显式调用父类的构造器必须用super关键字。（）

正确答案: A 你的答案: A (正确)

A正确

B错误
2.高优先级的线程比低优先级的线程运行得更快。
正确答案: B 你的答案: B (正确)

A对

B错
3JAVA属于（）。
正确答案: D 你的答案: D (正确)

A操作系统

B办公软件

C数据库系统

D计算机语言
4.A 派生出子类 B ， B 派生出子类 C ，并且在 Java 源代码中有如下声明：

A a0=new A();
A a1 =new B();
A a2=new C();

问以下哪个说法是正确的？（）
正确答案: D 你的答案: B (错误)

只有第1行能通过编译

第1、2行能通过编译，但第3行编译出错

第1、2、3行能通过编译，但第2、3行运行时出错

第1行、第2行和第3行的声明都是正确的

解析：
继承具有传递性，子类可以无条件向上转型！
5.以下选项中，合法的赋值语句是（）
正确答案: B 你的答案: B (正确)

Aa>1;

Bi++;

Ca= a+1=5;

Dy = int ( i );
6.检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果

public class HelloB extends HelloA 
{
 public HelloB()
 {
 }
 {
     System.out.println("I’m B class");
 }
 static
 {
     System.out.println("static B");
 }
 public static void main(String[] args)
 {
     new HelloB();
 }
}
class HelloA
{
 public HelloA()
 {
 }
 {
     System.out.println("I’m A class");
 }
 static
 {
     System.out.println("static A");
 }
}

A.
static A
I’m A class
static B
I’m B class
B.
I’m A class
I’m B class
static A
static B
C.
static A
static B
I’m A class
I’m B class
D.
I’m A class
static A
I’m B class
static B
7.以下描述错误的一项是（ D）？

A程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，是线程隔离的

B原则上讲，所有的对象都是在堆区上分配内存，是线程之间共享的

C方法区用于存储JVM加载的类信息、常量、静态变量，即使编译器编译后的代码等数据，是线程隔离的

DJava方法执行内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的
8.Which method you define as the starting point of new thread in a class from which n thread can be execution?
正确答案: B
A.public void start()

B.public void run()

C.public void int()

D.public static void main(String args[])

E.public void runnable()
9.下面哪个不对？
正确答案: C 你的答案: D (错误)

A.RuntimeException is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.

B.A method is not required to declare in its throws clause any subclasses of RuntimeExeption that might be thrown during the execution of the method but not caught

C.An RuntimeException is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch.

D.NullPointerException is one kind of RuntimeException
10.关于OutOfMemoryError，下面说法正确的是（）？
正确答案: A B C 你的答案: B C D (错误)

A java.lang.OutOfMemoryError: PermGen space 增加-XX:MaxPermSize这个参数的值的话，这个问题通常会得到解决。

B java.lang.OutOfMemoryError: Requested array size exceeds VM limit当你正准备创建一个超过虚拟机允许的大小的数组时，这条错误将会出现

C java.lang.OutOfMemoryError: Java heap space 一般情况下解决这个问题最快的方法就是通过-Xmx参数来增加堆的大小

D java.lang.OutOfMemoryError: nativeGetNewTLA这个异常只有在jRockit虚拟机时才会碰到

2018.10.26

1.覆盖与重载的关系是（）

正确答案: A 你的答案: A (正确)

覆盖只有发生在父类与子类之间，而重载可以发生在同一个类中

覆盖方法和重载方法都可以不同名，也可以同名

final修饰的方法可以被覆盖，但不能被重载

覆盖与重载是同一回事
2.下面所示的java代码，运行时，会产生（）类型的异常

int Arry_a[] = new int[10];
System.out.println(Arry_a[10]);

正确答案: D 你的答案: D (正确)

ArithmeticException

NullPointException

IOException

ArrayIndexOutOfBoundsException
3.C#、JAVA）扩展方法能访问被扩展对象的public成员
正确答案: A 你的答案: A (正确)

能

不能

4.列关于Java中类的构造方法的描述，正确的是（）
正确答案: B 你的答案: B (正确)

构造方法的返回类型为void

可以定义一个类而在代码中不写构造方法。

在同一个类中定义的重载构造方法不可以相互调用。

子类不允许调用父类的构造方法。
5.在jdk1.8之前，下列哪一种叙述是正确的（）
正确答案: D 你的答案: B (错误)

abstract修饰符可修饰字段、方法和类

抽象方法的body部分必须用一对大括号{ }包住

声明抽象方法，大括号可有可无

声明抽象方法不可写出大括号
6.给定代码：

public class SwitchTest{//1
    public static void main(String[] args) {//2
        System.out.println("value="+switchit(4));//3
    }//4
    public static int switchit(int x) {
        int j=1;
        switch (x) {
        case 1:j++;
        case 2:j++;
        case 3:j++;
        case 4:j++;
        case 5:j++;
        default:j++;
        }
        return j+x;
    }
}

第三行输出什么

value=6

value=8

value=3

value=5

value=4
答案：8
7.以下程序运行的结果为（）

public class Example extends Thread{
     @Override
     public void run(){
        try{
             Thread.sleep(1000);
             }catch (InterruptedException e){
             e.printStackTrace();
             }
             System.out.print("run");
     }
     public static void main(String[] args){
             Example example=new Example();
             example.run();
             System.out.print("main");
     }
}

正确答案: A 你的答案: A (正确)

run main

main run

main

run

不能确定
8.JSP 表达式的写法：
正确答案: C 你的答案: D (错误)

<% expression %>

<=% expression %>

<%= expression %>

9.给定以下JAVA代码，这段代码运行后输出的结果是（）

public class Test
{  
    public static int aMethod(int i)throws Exception
    {
        try{
            return i/10;
        }
        catch (Exception ex)
        {
            throw new Exception("exception in a aMethod");
        }finally{
      System.out.printf("finally");
        }
} 
    public static void main(String[] args){
        try
        {
            aMethod(0);
        }
        catch (Exception ex)
        {
            System.out.printf("exception in main");
        }
        System.out.printf("finished");
    }
}

正确答案: B 你的答案: B (正确)

exception in main finished

finally finished

exception in main finally

finally exception in main finally

10.下列不是 Java 关键字的是（）
正确答案: B D 你的答案: B C D (错误)

abstract

false

native

sizeof

解析：
ava中的关键字有哪些？
答：1）48个关键字：abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。
2）2个保留字（现在没用以后可能用到作为关键字）：goto、const。
3）3个特殊直接量：true、false、null。

2018.10.29

1.下列关于Java类中方法的定义，正确的是（）
正确答案: D 你的答案: D (正确)

若代码执行到return语句，则将当前值返回，而且继续执行return语句后面的语句。

只需要对使用基本数据类型定义的属性使用getter和setter，体现类的封装性。

方法的返回值只能是基本数据类型。

在同一个类中定义的方法，允许方法名称相同而形参列表不同。
2.Given the following class:

public class Cat
{
    long length;
    public Cat(long l)
    {
        length = 1;
    }
    public static void main(String arg[])
    {
        Cat c1, c2, c3;
        c1 = new Cat(10L);
        c2 = new Cat(10L);
        c3 = c2;
        long m = 21L;
    }
}

Which expression returns true?
正确答案: B 你的答案: B (正确)

c1==c2;

c2==c3;

m==c1;

c1.equals(m).
3.下面有关final, finally, finalize的区别描述错误的是？
正确答案: B 你的答案: B (正确)

如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承

如果一个方法被声明为final，可以被覆盖

finally在异常处理时提供 finally 块来执行任何清除操作。

Java使用 finalize() 方法在垃圾收集器象从内存中清除出去之前做必要的清理工作

4.以下代码执行后输出结果为（）

public class Test {
    public static void main(String[] args) {
        System.out.println("return value of getValue(): " +
        getValue());
    }
     public static int getValue() {
         try {
             return 0;
         } finally {
             return 1;
         }
     }
 }

正确答案: A 你的答案: A (正确)

return value of getValue(): 1

return value of getValue(): 0

return value of getValue(): 0return value of getValue(): 1

return value of getValue(): 1return value of getValue(): 0

5.关于String，StringBuilder以及StringBuffer，描述错误的是（）
正确答案: C 你的答案: B (错误)

A 对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象

B StringBuffer是线程安全

C StringBuilder是线程安全

D 可以修改StringBuilder和StringBuffer的内容

解析：C和B功能一样只不过C不支持线程

7.以下java程序代码，执行后的结果是（）

java.util.HashMap map=new java.util.HashMap(); 
map.put("name",null);      
map.put("name","Jack");
System.out.println(map.size());

正确答案: C 你的答案: B (错误)

A 0

B null

C 1

D 2

解析：
8. c中，二维数组初始化的方法是:int a[3][3]={{1},{2},{3}};说法是否正确？
正确答案: A 你的答案: B (错误)

正确

错误
9.若有以下程序段：

 ……

int a[]={4,0,2,3,1},i,j,t;

for(i=1;i<5;i++)

{

t=a[i];

j=i-1;

while(j>=0&&t>a[j])

{

a[j+1]=a[j];

--j;

}

a[j+1]=t;

}

……

则该程序段的功能是：
正确答案: B 你的答案: B (正确)

对数组a进行插入排序（升序）

对数组a进行插入排序（降序）

对数组a进行选择排序（升序）

对数组a进行选择排序（降序）

Java 多线程有几种实现方法？（）
正确答案: A B 你的答案: A B (正确)

继承Thread类

实现Runnable接口

实现Thread接口

以上都不正确

2018.10.30

1.在Java Applet程序用户自定义的Applet子类中，一般需要重载父类的( )方法来完成一些画图操作。
正确答案: D 你的答案: D (正确)

start( )

stop( )

init( )

paint( )
2.下列叙述错误的是( )
正确答案: D 你的答案: D (正确)

java提供了丰富的类库

java很好的利用了网络资源

java支持多线程

java不支持TCP/IP协议
3.类声明中，声明抽象类的关键字是 ( )
正确答案: B 你的答案: B (正确)

public

abstract

final

class
4.在程序代码中写的注释太多，会使编译后的程序尺寸变大。
正确答案: B 你的答案: B (正确)

正确

错误
5.关于顺序表叙述，正确的是（）
正确答案: B 你的答案: D (错误)

不可随机访问任意节点

插入需要移动元素

删除不需要移动元素

存储空间可以离散分布
6. 关于抽象类的叙述正确的是？( )

正确答案: A 你的答案: A (正确)

抽象类不可以实例化

抽象类就是一种特殊的接口

抽象类的方法都是抽象方法

抽象类的导出类一定不是抽象类

解析：

A选项中，抽象类不能实例化，这句是正确的。后面，抽象类不能申明为对象，是错误的。java中，接口和抽象类，都可以声明为对象，只需要在实例化的时候，用一个该接口/抽象类的实现类实例化就行了。即：
interface / abstract class obj = new class();其中，new后面的class是前面接口/抽象类的实现类。
B选项中，接口是一种特殊的抽象类。其中，成员变量都是默认public static final修饰的，方法都是public abstract修饰的，并且除了default和static的以外，只有声明，没有方法体。
C选项中，抽象类的方法，可以是抽象abstract的，也可以是普通的。就算全部是普通方法，也可以用abstract修饰。
D选项中，导出类，及子类，抽象类的子类可以是抽象的，也可以是普通的。

7.对于同一类中的两个方法 , 在判断它们是不是重载方法时 , 肯定不考虑（）
正确答案: C 你的答案: C (正确)

参数个数

参数类型

返回值类型

参数顺序
8.若二维数组 a 有 m 列，则在数组元素 a[i][j] 前的元素个数为（）

正确答案: B 你的答案: B (正确)

j * m + i

i * m + j

i * m + j - 1

j * m + i - 1

9.在C语言中，设有数组定义：char arrays[]=“China”；则数组array所占用的空间为（）。
正确答案: C 你的答案: D (错误)

4个字节

5个字节

6个字节

7个字节

解析：
C语言中的字符串用指向该串首个字符的指针表示。不保存长度信息，用’\0’来标识字符串的终止。
因此相当于 char arrays[] = {‘C’, ‘h’, ‘i’, ‘n’, ‘a’, ‘\0’};

10.不能用来修饰interface的有（）（仅限外部接口）
正确答案: A C D 你的答案: A D (错误)

private

public

protected

static

2018.10.31

1.在 main() 方法中给出数组buffer和下标i，如果将此下标中的元素显示到控制台上，需要使用（）。
正确答案: A 你的答案: A (正确)

System.out.print (buffer[i]);

FileOutputStream fout = new FileOutputStream(this.filename);

FileInputStream fin = new FileInputStream(this.filename);

System.in.read(buffer)。
2.只有实现了()接口的类，其对象才能序列化。
正确答案: A 你的答案: C (错误)

Serializable

Cloneable

Comparable

Writeable
3.对线性表进行折半查找时,要求线性表必须()
正确答案: B 你的答案: B (正确)

以顺序方式存储

以顺序方式存储,且数据元素有序

以链接方式存储

以链接方式存储,且数据元素有序
4.假设 A 类有如下定义，设 a 是 A 类的一个实例，下列语句调用哪个是错误的？（）

public class A

{

public int i;

static String s;

void method1(){}

static void method2(){}

}

正确答案: C 你的答案: D (错误)

System.out.println(a.i);

a.method1();

A.method1();

A.method2();

解析：tatic修饰的成员变量和方法，既可以通过类调用也可以通过实例(也就是对象)。无static修饰的只能通过实例(也就是对象)调用

5.下列语句正确的是（）
正确答案: A 你的答案: D (错误)

形式参数可被视为local variable

形式参数可被所有的字段修饰符修饰

形式参数为方法被调用时，是真正被传递的参数

形式参数不可以是对象

解析：A：形式参数可被视为local variable。形参和局部变量一样都不能离开方法。都只有在方法内才会发生作用，也只有在方法中使用，不会在方法外可见。

6.假设要存储一个数据集，数据维持有序，对其的操作只有插入、删除和顺序遍历，综合存储效率和运行速度，下列哪种数据结构是最适合的是？
正确答案: B 你的答案: A (错误)

数组

链表

哈希表

队列

解析：
数组可以实现顺序遍历但是插入删除操作复杂，平均移动n/2个元素
链表因为存储的地址不连续（逻辑上连续实际上不连续），可以实现顺序遍历
哈希表是随机存储，所以是离散分布，顺序遍历实现不了
队列只可以在队尾插入队头删除，不可以实现中间插入和删除，不满足条件
综上，链表最合适

7.下列关于java 中的 wait()方法和 sleep()方法的区别描述错误的是？
正确答案: D 你的答案: C (错误)

wait()方法属于Object类，sleep()属于Thread类

调用wait()方法的时候，线程会放弃对象锁

调用sleep()方法的过程中，线程不会释放对象锁

sleep()方法导致了程序暂停执行指定的时间，让出cpu给其他线程

解析：
sleep和wait的区别有：
1，这两个方法来自不同的类分别是Thread和Object
2，最主要是sleep方法没有释放锁，而wait方法释放了锁，使得敏感词线程可以使用同步控制块或者方法。
3，wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在
任何地方使用
synchronized(x){
x.notify()
//或者wait()
}
4,sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

8.下列关于java并发的说法中正确的是：
正确答案: B 你的答案: B (正确)

copyonwritearraylist适用于写多读少的并发场景

readwritelock适用于读多写少的并发场景

concurrenthashmap的写操作不需要加锁，读操作需要加锁

只要在定义int类型的成员变量i的时候加上volatile关键字，那么多线程并发执行i++这样的操作的时候就是线程安全的了
9. 以下哪项可能包含菜单条（）。
正确答案: B 你的答案: B (正确)

Panel

Frame

Applet

Dialog

10.广义表中的元素或者是一个不可分割的原子,或者是一个非空的广义表()
正确答案: B 你的答案: A (错误)

对

错

2018.11.1

1.Java 语言中，负责并发管理的机制是（）
正确答案: D 你的答案: D (正确)

垃圾回收

虚拟机

代码安全

多线程
2. 下列修饰符中与访问控制权限无关的是？（）

正确答案: D 你的答案: D (正确)

private

public

protected

final
3.基本数据类型均可任意互相转换。
正确答案: B 你的答案: B (正确)

对

错

4.与未加访问控制符的缺省情况相比，public和protected修饰符扩大了属性和方法的被访问范围，private修饰符则缩小了这种范围。
正确答案: A 你的答案: A (正确)

正确

错误

5.下列哪种说法是正确的（）
正确答案: D 你的答案: A (错误)

实例方法可直接调用超类的实例方法

实例方法可直接调用超类的类方法

实例方法可直接调用其他类的实例方法

实例方法可直接调用本类的类方法

6.根据下面的程序代码，哪些选项的值返回true？

public class Square {  
    long width;  
    public Square(long l) {   
        width = l;  
    }  
    public static void main(String arg[]) {   
        Square a, b, c;  
        a = new Square(42L);   
        b = new Square(42L);   
        c = b;   
        long s = 42L;  
    } 
}

正确答案: C 你的答案: C (正确)

a == b

s == a

b == c

a.equals(s)

7.一个文件中的字符要写到另一个文件中，首先需要（）。
正确答案: C 你的答案: C (正确)

System.out.print (buffer[i]);

FileOutputStream fout = new FileOutputStream(this.filename);

FileInputStream fin = new FileInputStream(this.filename);。

System.in.read(buffer)。
8.关于以下程序代码的说明正确的是?

public class HasStatic{
2.     private static int x=100;
3.     public static void main(String args[]){
4.          HasStatic hs1=new HasStatic();
5.          hs1.x++;
6.          HasStatic  hs2=new HasStatic();
7.          hs2.x++;
8.          hs1=new HasStatic();
9.          hs1.x++;
10.        HasStatic.x--;
11.        System.out.println("x="+x);
12.     }
13.   }

正确答案: D 你的答案: D (正确)

程序通过编译，输出结果为：x=103

10行不能通过编译，因为x是私有静态变量

5行不能通过编译，因为引用了私有静态变量

程序通过编译，输出结果为：x=102

9.以下是java concurrent包下的4个类，选出差别最大的一个
正确答案: C 你的答案: 空 (错误)

Semaphore

ReentrantLock

Future

CountDownLatch

10.下面有关JAVA异常类的描述，说法错误的是？
正确答案: D 你的答案: D (正确)

异常的继承结构：基类为Throwable，Error和Exception继承Throwable，RuntimeException和IOException等继承Exception

非RuntimeException一般是外部错误(非Error)，其必须被 try{}catch语句块所捕获

Error类体系描述了Java运行系统中的内部错误以及资源耗尽的情形，Error不需要捕捉

RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等，必须被 try{}catch语句块所捕获

2018.11.11

1.以下对继承的描述错误的是（）
正确答案: A 你的答案: A (正确)

Java中的继承允许一个子类继承多个父类

父类更具有通用性，子类更具体

Java中的继承存在着传递性

当实例化子类时会递归调用父类中的构造方法
2. main 方法是 Java Application 程序执行的入口点，关于 main 方法的方法头以下哪项是合法的（）？
正确答案: B 你的答案: B (正确)

public static void main()

public static void main(String args[])

public static int main(String [] arg)

public void main(String arg[])
3. 设有一个二维数组 A [ m ][ n ] ，假设 A [0][0] 存放位置在 644 (10) ， A [2][2] 存放位置在 676 (10) ，每个元素占一个空间，问 A [3][3] (10) 存放在什么位置？脚注 (10) 表示用 10 进制表示。

正确答案: C 你的答案: C (正确)

688

678

692

696
4. 向一个长度为n的向量的第i个元素(1≤i≤n+1)之前插入一个元素时，需向后移动（）个元素。

正确答案: B 你的答案: B (正确)

n-i

n-i+1

n-i-1
5.一个完整的URL地址由(),(),端口和文件四部分组成。
正确答案: B 你的答案: B (正确)

协议用户名

协议主机名

主机名 ip

以上都不正确
6.在一个长度为n的顺序表中删除第i个元素(1<=i<=n)时，需向前移动（）个元素
正确答案: A 你的答案: A (正确)

n-i

n-i+l

n-i-1

7.对于Java中异常的描述正确的是（）
正确答案: D 你的答案: D (正确)

用throws定义了方法可能抛出的异常，那么调用此方法时一定会抛出此异常。

如果try块中没有抛出异常，finally块中的语句将不会被执行。

抛出异常意味着程序发生运行时错误，需要调试修改

Java中的可不检测（unchecked）异常可能来自RuntimeException类或其子类。
8.子类A继承父类B, A a = new A(); 则父类B构造函数、父类B静态代码块、父类B非静态代码块、子类A构造函数、子类A静态代码块、子类A非静态代码块执行的先后顺序是？
正确答案: C 你的答案: C (正确)

父类Ｂ静态代码块->父类Ｂ构造函数->子类Ａ静态代码块->父类Ｂ非静态代码块->子类Ａ构造函数->子类Ａ非静态代码块

父类Ｂ静态代码块->父类Ｂ构造函数->父类Ｂ非静态代码块->子类Ａ静态代码块->子类Ａ构造函数->子类Ａ非静态代码块

父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数

父类Ｂ构造函数->父类Ｂ静态代码块->父类Ｂ非静态代码块->子类Ａ静态代码块->子类Ａ构造函数->子类Ａ非静态代码块
9.下列给定程序中，函数fun的功能是:求ss所指字符串数组中长度最短的字符串所在的行下标，作为函数值返回，并把其串长放在形参n所指的变量中。ss所指字符串数数组中共有M个字符串，且串长小于N。
请在程序的下画线处填入正确的内容并将下画线删除，使程序得出正确的结果。
试题程序。

#define M 5
 #define N 20
 int fun(char(* ss)[N], int *n)
 {
     int i, k = 0, len = N;
     for (i = 0; i < ______; i++)
     {
         len = strlen(ss[i]);
         if (i == 0)
             *n = len;
         if (len ____ * n)
         {
             *n = len;
             k = i;
         }
     }
     return ( _____ );
 }
 main( )
 {
     char ss[M][N] = {"shanghai", "guangzhou", "beijing", "tianjing", "chongqing"};
     int n, k, i;
     printf("\nThe originalb stringsare:\n");
     for (i = 0; i < M; i++)
         puts(ss[i]);
     k = fun(ss, &n);
     printf("\nThe length of shortest string is: % d\n", n);
     printf("\nThe shortest string is: % s\n", ss[k]);
 }

正确答案: C 你的答案: C (正确)

N，< ，k

N， >，k

M，<，k

M，>，k

10.有关hashMap跟hashTable的区别，说法正确的是？
正确答案: A B C D 你的答案: A B (错误)

HashMap和Hashtable都实现了Map接口

HashMap是非synchronized，而Hashtable是synchronized

HashTable使用Enumeration，HashMap使用Iterator

Hashtable直接使用对象的hashCode，HashMap重新计算hash值，而且用与代替求模

编程题

import java.util.Scanner;

public class Demo4 {
	// 1 2 6 34 5 6 9  
	/*
	 * 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 输入:
	 * [-2,1,-3,4,-1,2,1,-5,4], 输出: 6 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
	 */
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int nums[] = {11,11};
		int maxSum = maxSumArray(nums);
		System.out.println("最大和为" + maxSum);
	}

	private static int maxSumArray(int[] nums) {
		// TODO 自动生成的方法存根
		if (nums.length == 0 || nums == null) {
			return 0;
		}
		if (nums.length == 1) {
			return nums[0];
		}
		int max = nums[0];
		int maxsum = nums[0];
		for (int i = 0; i < nums.length; i++) {// 比的轮数
			int sum = 0;
			for (int j = i; j < nums.length; j++) {// 每一轮比的次数
				sum+=nums[j];
				if (sum > max) {
					max = sum;
				}
			}
			if (max > maxsum) {
				maxsum = max;
			}
		}
		return maxsum;
	}
}

2018.11.14

1.一个类可以有多个不同名的构造函数。（）
正确答案: B 你的答案: A (错误)

正确

错误

解析：构造函数必须与类名相同，可以重载，就是参数的类型，数量不同

2.下面有关JDK中的包和他们的基本功能，描述错误的是？
正确答案: C 你的答案: C (正确)

java.awt：包含构成抽象窗口工具集的多个类，用来构建和管理应用程序的图形用户界面

java.io：　包含提供多种输出输入功能的类

java.lang：包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET

java.util：　包含一些实用性的类

解析：
java.awt：包含构成抽象窗口工具集的多个类，用来构建和管理应用程序的图形用户界面
java.lang：提供java编成语言的程序设计的基础类
java.io：　包含提供多种输出输入功能的类，
java.net：　包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET，
java.applet：包含java小应用程序的类
java.util：　包含一些实用性的类

3.以下有关构造方法的说法，正确的是：（）
正确答案: A 你的答案: C (错误)

一个类的构造方法可以有多个

构造方法在类定义时被调用

构造方法只能由对象中的其他方法调用

构造方法可以和类同名，也可以和类名不同

解析：
A一个类有多个构造方法便是重载的表现。重载参数列表不同。所以A是正确的。
B构造方法是在对象创建时就被调用，用于初始化。
C构造方法是给与之对应的对象进行初始化，初始化的动作只执行一次。
D构造方法必须与所在类的名称同名。

4.线性表就是顺序存储的表()
正确答案: B 你的答案: B (正确)

对

错
5.下列关于功能性注释不正确的说法是()
正确答案: B 你的答案: B (正确)

功能性注释嵌在源程序中，用于说明程序段或语句的功能以及数据的状态

注释用来说明程序段，需要在每一行都要加注释

可使用空行或缩进，以便很容易区分注释和程序

修改程序也应修改注释

6.在java的一个异常处理中，可以包含多个的语句块是（）。
正确答案: D 你的答案: A (错误)

try

finally

throws

catch

解析：

异常处理一般格式： 
捕获异常： try{ //代码块 }
            catch(异常类型，例如：Exception e)
            { //需要抛出的异常，例如：e.printStackTrace(); }
            catch(异常类型)
            { //需要抛出的异常 }
            finally{ //必定执行的代码块 } 
            所以说在一个异常处理中catch语句块是可以多个的，也就是可以抛出多个异常！

7.下列关于构造方法的叙述中，错误的是（）
正确答案: C D 你的答案: C (错误)

java语言规定构造方法名与类名必须相同

java语言规定构造方法没有返回值，但不同void声明

java语言规定构造方法不可以重载

java语言规定构造方法只能通过new自动调用

解析：this关键字也可以调用。
8.下面有关java的instanceof、?、&、&&说法正确的有？
正确答案: A B C D 你的答案: A B C D (正确)

instanceof 可用来判断某个实例变量是否属于某种类的类型。

“?：” 三目运算符

&在逻辑运算中是非短路逻辑与，在位运算中是按位与

&& 逻辑运算：逻辑与

9.mysql数据库，game_order表表结构如下，下面哪些sql能使用到索引（）？
正确答案: B C D E 你的答案: B C D E (正确)

select * from game_order where plat_game_id=5 and plat_id=134

select * from game_order where plat_id=134 and
plat_game_id=5 and plat_order_id=’100’

select * from game_order where plat_order_id=’100’

select * from game_order where plat_game_id=5 and
plat_order_id=’100’ and plat_id=134

select * from game_order where plat_game_id=5 and plat_order_id=’100’
10.下面哪些类可以被继承？ Java.lang.Thread、java.lang.Number、java.lang.Double、java.lang.Math、 java.lang.ClassLoader
正确答案: A B E 你的答案: B C D (错误)

Thread

Number

Double

Math

ClassLoader

解析：
A，Thread可以被继承，用于创建新的线程
B，Number类可以被继承，Integer，Float，Double等都继承自Number类
C，Double类的声明为
public final class Doubleextends Numberimplements Comparable
final生明的类不能被继承
D，Math类的声明为
public final class Mathextends Object
不能被继承
E，ClassLoader可以被继承，用户可以自定义类加载器

编程题

在这里插入图片描述

public class Demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int price[]= {7,1,5,3,6,4};
		int maxProfit=maxprofit(price);
		System.out.println(maxProfit);
	}
	private static int maxprofit(int[] price) {
		// TODO 自动生成的方法存根
//		int maxProfit=0;
//		for(int i=0;i<price.length;i++) {
//			int profit=0;//用来计算利润的
//			int dayprofit=0;//计算第i天买入股票时  第n天时它的利润最大
//			for(int j=i+1;j<price.length;j++) {
//				if(price[i]<=price[j]) {
//					profit=price[j]-price[i];
//				}
//				if(profit>dayprofit) {
//					dayprofit=profit;
//				}
//			}
//			if(dayprofit>maxProfit) {
//				maxProfit=dayprofit;
//			}
//		}
//		return maxProfit;
		if(price.length==0||price==null) {
			return 0;
		}
		int maxprofit=0;
		int min=price[0];
		for(int i=0;i<price.length;i++) {
			if(price[i]<min) {
				min=price[i];
			}else if(price[i]-min>maxprofit) {
				maxprofit=price[i]-min;
			}
		}
		return maxprofit;
	}
}

牛客日常练习。

Java牛客网日常练习题

每天10道选择题，1道编程题，记录易犯错的题型

2018.10.8 day1

编程题：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

2018年10月9号

编程题：

2018年10月10号

2018年10月11

解析：选BCD 两个start方法之后一共三个线程就绪：主线程，线程s，线程t，处于就绪状态中的线程并没有开始运行，至于什么时候开始运行，取决于取决于JVM里线程调度器的调度。

编程题

2018.10.17

选项：选C 一个.java文件中，只能存在一个类是用public修饰的，并且这个类必须与类名一致，文件中其他的类不能是public权限的，但可以有很多个类。

*******

2018.10.19

public：可以被所有其他类所访问; protected：自身、子类及同一个包中类可以访问; default：同一包中的类可以访问; private：只能被自己访问和修改。 public>protcted>default>priavte

解析： 1、count(*)得到总记录数 2、计算总页数 3、获取所有记录(个人感觉这一步不需要，可以直接获取指定页数数据) 4、过滤显示本页数据

2018.10.21

2018.10.22

解析： A.没有模板，怎么可能创建对象，创建对象必须先要定义类，常识 B.对象中的数据域和方法取决于该对象的类，类里面有就有，没有就没有 D.数据域不一定是基本类型，也可以是引用类型

解析： 封装主要是隐藏内部代码； 继承主要是复用现有代码； 多态主要是改写对象行为。

解析：javac.exe是编译功能javaCompiler java.exe是执行class，如果没有编译的话是不能执行的，同理，javac.exe编译完以后如果没有java.exe执行的话也是没有运行的

解析：System是java.lang包下的一个类，out为System的final静态成员（PrintStream类型），println()是PrintStream类的实例方法

选项：选B

2018.10.23

选项：选C Map以key-value形式保存，HashMap、HashTable继承自Map; ArrayList底层以数组方式存储； LinkedList以链表形式存储。

2018.10.24

解析： 1、Statement对象用于执行不带参数的简单SQL语句。 2、Prepared Statement 对象用于执行预编译SQL语句。 3、Callable Statement对象用于执行对存储过程的调用。

解析： final修饰类、方法、属性！不能修饰抽象类，因为抽象类一般都是需要被继承的，final修饰后就不能继承了。 final修饰的方法不能被重写而不是重载！ final修饰属性，此属性就是一个常量，不能被再次赋值！

解析： A:错误 {company：4399} 首先，其为json对象。但json对象要求属性必须加双引号。 B:正确 C:错误 {[4399,4399,4399]} 。使用 {} 则为json对象。json对象必须由一组有序的键值对组成。 D:正确。

2018.10.25

2018.10.26

2018.10.29

解析：C和B功能一样 只不过C不支持线程

2018.10.30

解析： C语言中的字符串用指向该串首个字符的指针表示。不保存长度信息，用’\0’来标识字符串的终止。 因此相当于 char arrays[] = {‘C’, ‘h’, ‘i’, ‘n’, ‘a’, ‘\0’};

2018.10.31

解析：tatic修饰的成员变量和方法，既可以通过类调用也可以通过实例(也就是对象)。 无static修饰的只能通过实例(也就是对象)调用

解析：A：形式参数可被视为local variable。形参和局部变量一样都不能离开方法。都只有在方法内才会发生作用，也只有在方法中使用，不会在方法外可见。

2018.11.1

2018.11.11

编程题

2018.11.14

解析：构造函数必须与类名相同，可以重载，就是参数的类型，数量不同

编程题

猜你喜欢

解析：选BCD
两个start方法之后一共三个线程就绪：主线程，线程s，线程t，处于就绪状态中的线程并没有开始运行，至于什么时候开始运行，取决于取决于JVM里线程调度器的调度。

选项：选C
一个.java文件中，只能存在一个类是用public修饰的，并且这个类必须与类名一致，文件中其他的类不能是public权限的，但可以有很多个类。

public：可以被所有其他类所访问;
protected：自身、子类及同一个包中类可以访问;
default：同一包中的类可以访问;
private：只能被自己访问和修改。
public>protcted>default>priavte

解析：
1、count(*)得到总记录数
2、计算总页数
3、获取所有记录(个人感觉这一步不需要，可以直接获取指定页数数据)
4、过滤显示本页数据

解析： A.没有模板，怎么可能创建对象，创建对象必须先要定义类，常识
B.对象中的数据域和方法取决于该对象的类，类里面有就有，没有就没有
D.数据域不一定是基本类型，也可以是引用类型

解析：
封装主要是隐藏内部代码；
继承主要是复用现有代码；
多态主要是改写对象行为。

解析：javac.exe是编译功能javaCompiler
java.exe是执行class，如果没有编译的话是不能执行的，同理，javac.exe编译完以后如果没有java.exe执行的话也是没有运行的

选项：选C
Map以key-value形式保存，HashMap、HashTable继承自Map;
ArrayList底层以数组方式存储；
LinkedList以链表形式存储。

解析：
1、Statement对象用于执行不带参数的简单SQL语句。
2、Prepared Statement 对象用于执行预编译SQL语句。
3、Callable Statement对象用于执行对存储过程的调用。

解析：
final修饰类、方法、属性！不能修饰抽象类，因为抽象类一般都是需要被继承的，final修饰后就不能继承了。
final修饰的方法不能被重写而不是重载！
final修饰属性，此属性就是一个常量，不能被再次赋值！

解析：
A:错误 {company：4399} 首先，其为json对象。但json对象要求属性必须加双引号。
B:正确
C:错误 {[4399,4399,4399]} 。使用 {} 则为json对象。json对象必须由一组有序的键值对组成。
D:正确。

解析：C和B功能一样只不过C不支持线程

解析：
C语言中的字符串用指向该串首个字符的指针表示。不保存长度信息，用’\0’来标识字符串的终止。
因此相当于 char arrays[] = {‘C’, ‘h’, ‘i’, ‘n’, ‘a’, ‘\0’};

解析：tatic修饰的成员变量和方法，既可以通过类调用也可以通过实例(也就是对象)。无static修饰的只能通过实例(也就是对象)调用