赊了两串冰糖葫芦才写出来的小结

一、选择题

1.A 派生出子类 B ， B 派生出子类 C ，并且在 java 源代码有如下声明：

1. A a0=new A();
2. A a1=new B();
3. A a2=new C();

问以下哪个说法是正确的？（）
A 只有第一行能通过编译
B 第1、2行能通过编译，但第3行编译出错
C 第1、2、3行能通过编译，但第2、3行运行时出错
D 第1行，第2行和第3行的声明都是正确的

正确答案 : D

解析 : ① 继承的传递性 , B继承于A，C继承于B，所以A为B和C共同的父类 ; ② 父类引用指向子类对象 , 子类可以自然地完成向上(到父类的)转型

2.下面代码将输出什么内容：（）

public class SystemUtil{
	public static boolean isAdmin(String userId){
		return userId.toLowerCase()=="admin";
	}
	public static void main(String[] args){
		System.out.println(isAdmin("Admin"));
	}
}

正确答案 : false

解析 : 在源码中 toLowerCase 是重新 new String() , "=="是比较身份而非比较值, 所以这两个对象的地址是不相同的.

3.阅读如下代码。 请问，对语句行 test.hello(). 描述正确的有（）

package NowCoder;
class Test {
	public static void hello() {
		System.out.println("hello");
	}
}
public class MyApplication {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Test test=null;
		test.hello();
	}
}

正确答案 : 能编译通过，并正确运行

解析 : 静态方法不依附于对象，这里是直接调用静态方法,类的静态成员不依赖实例对象，静态成员在类编译的时候就已经被创建好了，无论是是使用类名，还是使用实例对象都是可以访问的

4.在使用super和this关键字时，以下描述正确的是（）
A 在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
B super（）和this（）不一定要放在构造方法内第一行
C this（）和super（）可以同时出现在一个构造函数中
D this（）和super（）可以在static环境中使用，包括static方法和static语句块

正确答案 : A

解析 : ① super()调用父类中的某一个构造函数，this()是调用本类中另一种形成的构造函数 ② this()和super()都必须出现在构造器的第一行，所以两者不可能出现在同一个构造器中 ③ this和super都不能出现了静态方法、静态块中

5.如下代码的 结果是什么 ?

class Base {
	Base() {
		System.out.print("Base");
	}
}
public class Alpha extends Base {
	public static void main( String[] args ) {
		new Alpha();
		//调用父类无参的构造方法
		new Base();
	}
}

正确答案 : BaseBase

解析 : 在执行new Alpha()时，因为Alpha继承了Base , 在执行Alpha类的构造方法前 , 会先执行父类的构造方法，再执行相应的子类的构造方法，所以此处会打印Base，在执行new Base()时，会直接执行Base中无参构造器的代码，再输出Base

6.如下代码的输出结果是什么？

public class Test {
	public int aMethod(){
		static int i = 0;
		i++;
		return i;
	}
	public static void main(String args[]){
		Test test = new Test();
		test.aMethod();
		int j = test.aMethod();
		System.out.println(j);
	}
}

正确答案 : 编译失败

(来源牛客)大佬解析 : 静态变量是先于类的其他而加载的，所以static代码块只能是类成员变量，而不能是局部变量，因为在static加载时，方法还没有分配空间

7.下列哪一种叙述是正确的（）
A abstract修饰符可修饰字段、方法和类
B 抽象方法的body部分必须用一对大括号{ }包住
C 声明抽象方法，大括号可有可无
D 声明抽象方法不可写出大括号

正确答案 : D

解析 : abstract只可修饰方法和类 , 不可以修饰字段(类成员变量)；抽象方法是没有被实现的方法，没有body部分，也没有花括号，声明后面直接就是分号

8.下列说法正确的有：（）
A class中的constructor不可省略
B constructor必须与class同名，但方法不能与class同名
C constructor在一个对象被new 时执行
D 一个class只能定义一个constructor

正确答案 : C

解析 : . 类中的构造方法可以省略不写的 , 构造方法必须跟类名相同，普通的类方法是可以和类名同名的，和构造方法唯一的区分就是，构造方法没有返回值 , 构造方法都在new 对象的时候调用的 , 一个类可以定义多个构造方法的

9.选项中哪一行代码可以替换 //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

解析 : ① 抽象类可以包含抽象方法 , 用abstract修饰，是抽象方法，不能带方法体(带有{}的就是方法体，即使里面是空的) ② 类中定义成员和方法，不能直接进行运算，可以写在代码块{}或者静态代码块中static{}中 ③ 方法重载需要满足 , 在同一个类中 , 方法的名称相同 , 参数列表不同(参数的类型，个数，顺序) , 与访问修饰符和返回值类型无关

(未学)10.java 中哪个关键字可以对对象加互斥锁？
A transient
B synchronized
C serialize
D static

正确答案 : B

解析 :① transient是反序列化修饰符，序列化的时候，类中的属性都会被复制，但是被transient和static修饰的属性不会被复制 ② synchronized是同步锁，被synchronized修饰的方法或者代码块，同一时刻只允许被一个线程访问 ③ serialize是序列化 ④ static是静态修饰符。可修饰成员变量和方法，内部类/接口，不可修饰局部变量和外部类/接口。

二、编程题

1.标题：汽水瓶 | 时间限制：1秒 | 内存限制：32768K

有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？

输入描述：
输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。n=0表示输入结束，你的程序不应当处理这一行。

输出描述：
对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。

示例1:
输入
3
10
81
0
输出
1
5
40

import java.util.Scanner;
public class Main{
	public static void main(String[] args){
		Scanner scanner=new Scanner(System.in);
		while (scanner.hasNextInt()) {
			int num = scanner.nextInt();
			//一种偷懒写法
			//System.out.println(num/2);
			//int result=canMax(num);
			System.out.println(canMax(num));
		}
	}
	public static int canMax(int n){
		int sum=0;
		//核心就是抓住三和二这两种情况就好
		while(n>=3){
			sum=sum+n/3;
			n=n/3+n%3;
		}
		if(n==2){
			sum=sum+1;
		}
		return sum;
	}
}

2.标题：数组中的逆序对 | 时间限制：3秒 | 内存限制：32768K | 语言限制：[Python, C++, C#, Java]

有一组数，对于其中任意两个数组，若前面一个大于后面一个数字，则这两个数字组成一个逆序对。请设计一个高效的算法，计算给定数组中的逆序对个数。给定一个int数组A和它的大小n，请返回A中的逆序对个数。保证n小于等于5000。

测试样例：
[1,2,3,4,5,6,7,0],8
返回：7

import java.util.*;
public class AntiOrder {
	public int count(int[] A, int n) {
		// write code here
		int result=0;
		//从0号位置开始打擂 看是不是比后面的大
		for(int bound=0;bound<n-1;bound++){
			for(int cur=bound+1;cur<n;cur++){
				if(A[bound]>A[cur]){
					result++;
				}
			}
		}
		return result;
	}
}

最后一个编程题就是基于选择排序的理念进行改变了一下~