题目：
下面关于Java接口的说法错误的是（）
A、一个Java接口是一些方法特征的集合，但没有方法的实现
B、Java接口中定义的方法在不同的地方被实现，可以具有完全不同的行为
C、Java接口中可以声明私有成员
D、Java接口不能被实例化
答案：C
解释：
A：接口就是功能的封装，没有方法的实现，A正确
B：不同的类实现同一个接口，可以具有完全不同的行为，这就是多态，B正确
C：Java接口中不可以声明私有成员，如下：



所以C错误
D：接口不能被实例化，但是可以赋值匿名内部类对象，或者赋值实现类对象，所以D正确

选择
1、在下面代码中的(1)(2)处可以填写（多选）	BC



2、下列说法中不正确的是：	D



3、关于Comparable接口的说法，以下哪个是错误的？	B


编程
1、对英文单词进行排序，效果图如下：


package project0731;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class StringSort {
	public static void main(String[] args) {
		// 给list添加元素
		List<String> list = new ArrayList<String>();
		list.add("orange");
		list.add("tomato");
		list.add("apple");
		list.add("litchi");
		list.add("banana");
		// 输出排序前list中的内容
		System.out.println("排序前:");
		for(String s : list) {
			System.out.print(s + " ");
		}
		// 对list中的元素进行排序
		Collections.sort(list);
		// 输出排序后list中的内容
		System.out.println("\n排序后:");
		for(String s : list) {
			System.out.print(s + " ");
		}
	}
}




2、定义一个学生信息类，包括学号，姓名，年龄三个成员变量，然后按名字进行升序排序。(使用Comparator接口)


package project0731.demo2;

public class Student {
	// 成员属性
	private int id;
	private String name;
	private int age;

	// get/set方法
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	// 构造方法
	public Student() {
		super();
	}

	public Student(int id, String name, int age) {
		super();
		this.setId(id);
		this.setName(name);
		this.setAge(age);
	}

	// 重写toString方法
	@Override
	public String toString() {
		return "[学号：" + this.getId() + "，年龄：" + this.getAge() + "，姓名：" + this.getName() + "]";
	}
	
}


package project0731.demo2;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class StudentTest {

	public static void main(String[] args) {
		// 创建学生对象
		Student s1 = new Student(40, "peter", 20);
		Student s2 = new Student(28, "angel", 5);
		Student s3 = new Student(35, "tom", 18);
		// 创建列表并添加学生对象
		List<Student> list = new ArrayList<Student>();
		list.add(s1);
		list.add(s2);
		list.add(s3);
		// 排序前打印输出
		System.out.println("按名字排序前：");
		for (Student s : list) {
			System.out.println(s);
		}
		// 调用排序算法
		Collections.sort(list, new Comparator<Student>() {
			@Override
			public int compare(Student o1, Student o2) {
				String name1 = o1.getName();
				String name2 = o2.getName();
				return name1.compareTo(name2);
			}
		});
		// 排序后打印输出
		System.out.println("按名字排序后：");
		for (Student s : list) {
			System.out.println(s);
		}
	}

}




3、定义一个员工信息类，包括编号，姓名，工资三个成员变量，要求工资定义为float类型，然后按工资进行降序排序。(使用Comparable接口)


package project0731.demo3;

public class Employee implements Comparable<Employee> {
	// 成员属性
	private String id;
	private String name;
	private float salary;

	// get/set方法
	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public float getSalary() {
		return salary;
	}

	public void setSalary(float salary) {
		this.salary = salary;
	}

	// 构造方法
	public Employee() {
		super();
	}

	public Employee(String id, String name, float salary) {
		super();
		this.setId(id);
		this.setName(name);
		this.setSalary(salary);
	}

	// 重写toString方法
	@Override
	public String toString() {
		return "员工[编号：" + getId() + "，姓名：" + getName() + "，工资：" + getSalary() + "]";
	}

	// 重写compareTo方法
	@Override
	public int compareTo(Employee o) {
		float f1 = this.getSalary();
		float f2 = o.getSalary();
		int n = new Float(f2 - f1).intValue();
		return n;
	}

}


package project0731.demo3;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class EmployeeTest {

	public static void main(String[] args) {
		// 创建员工对象
		Employee e1 = new Employee("emp001","张三",1800.0F);
		Employee e2 = new Employee("emp002","李四",2500.0F);
		Employee e3 = new Employee("emp003","王五",1600.0F);
		// 创建列表并添加员工对象
		List<Employee> list = new ArrayList<Employee>();
		list.add(e1);
		list.add(e2);
		list.add(e3);
		// 排序前打印输出
		System.out.println("排序前：");
		for(Employee e : list) {
			System.out.println(e);
		}
		// 调用排序算法
		Collections.sort(list);
		// 排序后打印输出
		System.out.println("排序后：");
		for(Employee e : list) {
			System.out.println(e);
		}
	}

}

java基础错题集合解析：


chapter1：
6、下面哪种类型的文件可以在Java虚拟机中运行？（D）

A..java   B.jre    C.exe   D.class
解析：java虚拟机可以编译的是.java文件，但是运行的只能是.class java字节码文件；


8、下列关于变量和常量的说法正确的是（A、D）

A.常量表示不能被改变的值，例如1、2、“abc”都是常量

B.常量表示常见的变量

C.int x = 0;代码中，x表示常量，0表示变量

D.在同一个大括号｛｝内，定义的变量不能够重名

解析：易错点，A选项中数字 1、2表示的是整型常量，“abc”表示的是字符型常量；


11、下列各种符号的定义格式，那种在java语言中是错误的变量定义（D）

A.int myVal =1;            B.char $myVal =1;

C.byte _myVal =1;          Dfloat 3.14myVal=1;

解析：*java语言变量的命名规则是允许“字母、数字、下划线、$、￥”，但是数字不能开头；  *char 字符类型数据，可以直接赋值0~65535（2^16-1）数值，而不用添加单引号，
因为这些直接用数值赋值的char会直接会在ascii码表中寻找对应的字符，这一过程是自动完成的；但是如果赋值的是字母或者符号等字符型时则必须添加单引号；

		/*char 类型时2个字节，取值范围是：0~65535 （2^16-1）
		 * */
		char a0 = 1; //不报错，该字符的ascii码是 1；
		char a1 = '1';//不报错，纯字符 1。
		char a3 = -1;//报错,小于char的最小取值范围
		char a4 = 65535;//不报错
		char a5 = 65536;//报错，超过char最大值65535（2^16-1）


例外知识点： float 型数据在赋值时，如果赋值是整数型则不需要在数值后面添加F，如果是小数类型必须在后面添加F，否则会报错；
		float a0 = 1; //赋值时整数类型不添加F不报错
		float a1 = 1.0;//小数类型，不添加F报错
		float a2 = 1.0F;//添加F后不报错；
		float b0 = 0; //不报错
		float b1 = 0.0;//报错
		float b2 = 0.0f;//不报错



1个字节是8位

只有8种基本类型可以算.其他引用类型都是由java虚拟机决定的自己不能操作

byte 1字节

short 2字节

int 4字节

long 8字节

float 4字节

double 8字节

char 2字节

boolean 1字节



16、语句System.out.println(1+2+"java"+3+4)输出的结果是（A）

A. 3java34    B. 12java34  C. 3java7D. 12java7
解析：一开始是1+2 = 3，做纯数学运算，但是在+"java"后是做字符串链接，计算结果和“java”这个字符串进行了连接形成了“3java”这个新的字符串再后后面的做字符串连接操作，所以后面的结果是： 3java34  ；
总结：java中在进行“+”操作时按照执行顺序，如果后面跟的不是字符串，则进行的“加”操作，一旦后面时字符串，则进行的是“字符串连接操作”，后面的所有“+”都是按照字符串连接进行操作的，而不会是“加”操作；
chapter2：

1.关于容器下面说法正确的是


列表(List)和集合(Set)存放的元素都是可重复的 
列表(List)和集合(Set)存放的元素都是不可重复的 
映射(Map)< key,value>中key是可以重复的
映射(Map)< key,value>中value是可以重复的


解析： 


列表（List）的元素是有序，可重复的  
集合（Set）的元素是无序，不可重复的


2.Java语言与其它语言相比，独有的特点是


面向对象
多线程 
平台无关 
网络编程


3.有这样一段程序



public class Test{
            public static void main(String [] args){
                List list=new ArrayList();
                list.add("a");
                list.add("b");
                list.add("a");
                Set set=new HashSet();
                set.add("a");
                set.add("b");
                set.add("a");
                System.out.println(list.size()+","+set.size());
            }
        }

运行主要的程序会打印出的是什么？


2，2
2，3      
3，2
3，3


解析： 


List和Set的区别，set中不能放重复的元素
Set中重复的定义，未定义自己的equals方法的话，调用默认的，也就是直接==
首先会调用Object的hashCode方法判断hashCode是否已经存在，如不存在则直接插入元素
如果已经存在则调用Object对象的equals方法判断是否返回true，如果为true则说明元素已经存在，如为false则插入元素。


4.列表（List）和集合（Set）下面说法正确的是


Set中至多只能有一个空元素
List中至多只能有一个空元素
List和Set都可以包含重复元素的有序集合
List和Set都是有序集合


解析： 


Set不能有重复的元素，且是无序的，要有空值也只能有一个，因为他不允许重复。
List可以有重复元素，且是有序的，要有空值也可以有多个，因为他可以重复
Java的有序无序：指的是你按照顺序存进去数据，然后再按照顺序取出来，两者是一样的。比如List(0)我放的是“a”，那么我list.get(0)取出来也是“a”。并不代表我存了打乱顺序存1到10十个数，它会自己给按照升序或者降序给你排好序。


5.Java字符类型采用的是Unicode编码方案，每个Unicode码占用（）个比特位


6
16 
32
64


解析： 


在Java中一个Unicode占2个字节（byte）
一个字节等于8比特位（bit）
所以每个Unicode码占用16个比特位


6.以下哪项陈述是正确


垃圾回收线程的优先级很高，以保证不再 使用的内存将被及时回收
垃圾收集允许程序开发者明确指定释放 哪一个对象
垃圾回收机制保证了JAVA程序不会出现 内存溢出
进入”Dead”状态的线程将被垃圾回收器回收
以上都不对


解析： 


垃圾回收在JVM中优先级相当相当低
垃圾收集器（GC）程序开发者只能推荐JVM进行回收，但何时回收，回收哪些，程序员不能控制
垃圾回收机制只是回收不再使用的JVM内存，如果程序有严重BUG，照样内存溢出
进入DEAD的线程，它还可以恢复，GC不会回收


7.下列有关Java异常处理的叙述正确的是


finally是为确保一段代码不管是否捕获异常都会被执行的一段代码
throws是用来声明一个成员方法可能抛出的各种非运行异常情况
final用于可以声明属性和方法，分别表示属性的不可变及方法的不可继承
throw是用来明确地抛出一个异常情况


解析： 


final用于可以声明属性和方法，分别表示属性的不可变及方法的不可覆盖。不是方法的不可继承！！！


9-5

1.下列关于继承的描述正确的是


在Java中允许定义一个子类的引用，指向父类的对象
在Java中一个子类可以继承多个抽象类，在extends关键字后依次列出
在Java中继承是通过extends关键字来描述的，而且只允许继承自一个直接父类
在Java中抽象类之间不允许出现继承关系，所有的抽象类都相互独立


解析： 


父类的引用直接指向子类的对象，即向上转型；当子类的引用直接指向父类的对象时，则需要强制转换。


2.以下程序的运行结果是



public class Increment
{
    public static void main(String args[])
    {
        int a;
        a = 6;
        System.out.print(a);
        System.out.print(a++);
        System.out.print(a);
    }
}


666
667


3.在使用super和this关键字时，以下描述正确的是


在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行否则编译不通过
super（）和this（）不一定要放在构造方法内第一行
this（）和super（）可以同时出现在一个构造函数中
this（）和super（）可以在static环境中使用，包括static方法和static语句块


解析： 


static方法或语句块没有实例时可以使用，而此时不需要构造实例，所以不能用this（）和super（）


4.JDK1.7中，以下说法正确的是（）


Java中所有的非抽象方法都必须在类内定义
Java中主方法可以不在类内定义，其他方法都必须定义在类内 
Java中主方法必须定义在类内，其他方法可以不必定义在类内
Java中所有方法都不必在类内定义


5.对于abstract声明的类，下面说法正确的是


可以实例化 
不可以被继承
子类为abstract
只能被继承 
可以被抽象类继承


解析：  

A：抽象类不能实例化，因为有抽象方法没有实现  

B：可以被继承。派生类可以实现抽象方法  

C：子类可以是抽象的，也可以非抽象  

D：太肯定  

E：可以被抽象类继承，也可以被非抽象类继承

6.非抽象类实现接口后，必须实现接口中的所有抽象方法，除了abstract外，方法头必须完全一致


正确
错误


解析：  

实际考察的是两同两小一大原则： 


方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型
子类抛出异常小于等于父类方法抛出异常
子类访问权限大于等于父类方法访问权限


7.下面哪个行为被打断不会导致InterruptedException？


Thread.join 
Thread.sleep 
Object.wait
CyclicBarrier.await
Thread.suspend


解析：  

抛InterruptedException的代表方法有：


java.lang.Object 类的 wait 方法
java.lang.Thread 类的 sleep 方法
java.lang.Thread 类的 join 方法


1.如下语句通过算术运算和逻辑运算之后i和 j的结果是（ ）



int i=0;
int j=0;
if((++i>0)||(++j>0))
{
//打印出i和j的值。
}


i=1;j=1 
i=1;j=0


解析： 

&&和||为短路与，短路或 


&&若前面的表达式为false，整个表达式为false，所以后面的表达式无论true和false都无法影响整个表达式的逻辑，所以为了提高效率后面的表达式就不会执行


&和|为不短路与，不短路或 


无论什么情况，前面的和后面的都要执行


2.正确的是



public class Test
{
    public int x;
    public static void main(String []args)
    {
        System. out. println("Value is" + x);
    }
}


程序会打出 “Value is 0” 
程序会抛出 NullPointerException 
非静态变量不能够被静态方法引用 编译器会抛出
“possible reference before assignment”的错误


解析： 


非静态成员只能被类的实例化对象引用，因此这里在静态方法中访问x会造成编译错误
当类加载时，static静态方法随着类加载而初始化，此时实例对象还没被创建，但是非静态成员变量需要等到实例对象创建才会被初始化，故无法被引用。


3.下列说法错误的是


Java面向对象语言容许单独的过程与函数存在 
Java面向对象语言容许单独的方法存在
Java语言中的非静态方法属于类中的成员（member）   
Java语言中的方法必定隶属于某一类（对象），调用方法与C语言的过程或C++语言的函数相同


解析： 


Java不允许单独的方法，过程或函数存在，需要隶属于某一类中——AB错
Java语言中的方法属于对象的成员而不是类的成员，不过，其中静态方法属于类成员——C错


4.下列有关Java异常处理的叙述中正确的是


finally是为了确保一段代码不管是否捕获异常都会被执行的一段代码
throws是用来声明一个成员方法可能抛出的各种非运行异常情况
final用于可以声明属性和方法，分别表示属性的不可变及方法的不可继承
throw是用来明确地抛出一个异常情况


解析： 


throws用来在方法上声明该方法不需要处理的异常类型，用在方法上后面跟异常类名，可以是多个异常类
throw用于抛出具体异常类的对象，用在方法内，后面跟异常对象只能是一个异常类型实体
try块必须和catch和finally同时存在，不能单独存在，二者必须出现一个
finally块总会执行，不论是否有错误