190717 — 接口可以有普通方法(1.8)、数据类型转换、并发编程同步器、获取结果集的方式、finally优先级、volatile vs synchronized、抽象类

1. JDK1.8新特性（接口可以有普通方法）

1.1 题目

jdk1.8中，下面有关java 抽象类和接口的区别，说法错误的是？

抽象类可以有构造方法，接口中不能有构造方法
抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法
一个类可以实现多个接口，但只能继承一个抽象类
接口中可以有普通成员变量，抽象类中没有普通成员变量

1.2 答案

BD

抽象类

特点:

1.抽象类中可以构造方法

2.抽象类中可以存在普通属性，方法，静态属性和方法。

3.抽象类中可以存在抽象方法。

4.如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。

5.抽象类中的抽象方法，需要有子类实现，如果子类不实现，则子类也需要定义为抽象的。

接口

特点：

1.在接口中只有方法的声明，没有方法体。

2.在接口中只有常量，因为定义的变量，在编译的时候都会默认加上public static final

3.在接口中的方法，永远都被public来修饰。

4.接口中没有构造方法，也不能实例化接口的对象。

5.接口可以实现多继承

6.接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法

7.则实现类定义为抽象类。

jdk1.8中接口可以有default、static方法

2. 数据类型转换

2.1 题目

Java类Demo中存在方法func0、func1、func2、func3和func4，请问该方法中，哪些是不合法的定义？( )

public class Demo{
　　float func0()
　　{
　　　　byte i=1;
　　　　return i;
　　}
　　float func1()
　　{
　　　　int i=1;
　　　　return;
　　}
　　float func2()
　　{
　　　　short i=2;
　　　　return i;
　　}
　　float func3()
　　{
　　　　long i=3;
　　　　return i;
　　}
　　float func4()
　　{
　　　　double i=4;
　　　　return i;
　　}
}

func1
func2
func3
func4

2.2 答案

AD

数据类型的转换，分为自动转换和强制转换。自动转换是程序在执行过程中 “ 悄然 ” 进行的转换，不需要用户提前声明，一般是从位数低的类型向位数高的类型转换；强制类型转换则必须在代码中声明，转换顺序不受限制。

自动数据类型转换

自动转换按从低到高的顺序转换。不同类型数据间的优先关系如下：
低 ---------------------------------------------> 高
byte,short,char-> int -> long -> float -> double

3. 并发编程同步器（没学过）

3.1 题目

JDK提供的用于并发编程的同步器有哪些？

Semaphore
CyclicBarrier
CountDownLatch
Counter

3.2 答案

ABC

A. semaphore：信号量。用于表示共享资源数量。用acquire()获取资源，用release()释放资源。

B. CyclicBarrier ： 线程到达屏障后等待，当一组线程都到达屏障后才一起恢复执行

C. CountDownLatch： 初始时给定一个值，每次调用countDown值减1，当值为0时阻塞的线程恢复执行

D. 不知道是啥。。。。反正不是同步器

4. 获取结果集的方式PreparedStatement vs Statement

4.1 题目

以下可以正确获取结果集的有

Statement sta=con.createStatement();ResultSet rst=sta.executeQuery(“select * from book”);

Statement sta=con.createStatement(“select * from book”); ResultSet rst=sta.executeQuery();

PreparedStatement pst=con.prepareStatement();
ResultSet rst=pst.executeQuery(“select * from book”);

PreparedStatement pst=con.prepareStatement(“select * from book”);
ResultSet rst=pst.executeQuery();

4.2 答案

AD

两种方式获取结果集，传入sql语句的地方不同

1. Statement

Statement sta=con.createStatement();
ResultSet rst=sta.executeQuery(“select * from book”);//String类型的sql语句在执行对象执行命令时传入

2. PreparedStatement

PreparedStatement pst=con.prepareStatement(“select * from book”);//String类型的sql语句在创建执行对象时传入
ResultSet rst=pst.executeQuery();//执行对象执行命令直接执行即可，不需要传入命令

5. 类相关

5.1 题目

下列哪个选项是错误的。（）

一个文件中只能有一个public class。
一个文件中可以有多个类。
一个类中可以有两个main方法。
若类中只含一个main方法，则必须是public的。

5.2 答案

这道题的4个选项全是错的。

A.一个文件中，可以有多个public class

public class Main { public class Inner{

    }
}

即，外部类为public，还可以有public的内部类。

B.一个文件中可以有多个类，可以是多个并列的类，也可以是外部类、内部类结合。

C.一个类中，可以有多个main方法，这是重载，但是public static void main(String[] args)的方法只能有一个。

D.类中，可以有main方法，也可以没有main方法，而有一个main()方法的时候，也可以是任意访问权限。因为这个类不一定要执行，可以只是辅助类。

public class MainTest { void main(){
    }
}

6. finally语句先于return和throw

6.1 题目

如下代码的输出是

package Test;
public class Test {
    private static void test(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            try {
                if (arr[i] % 2 == 0) {
                    throw new NullPointerException();
                } else {
                    System.out.print(i);
                }
            } finally {
                System.out.print("e");
            }
        }
    }
 
    public static void main(String[]args) {
        try {
            test(new int[] {0, 1, 2, 3, 4, 5});
        } catch (Exception e) {
            System.out.print("E");
        }
    }
 
}

编译出错
eE
Ee
eE1eE3eE5
Ee1Ee3Ee5

6.2 答案

B

由于arr[0] =0,所以在进入 test()方法里面会在第一个if 上抛出一个 NullPointerException,接着会执行 finally 的语句, (finally语句先于 return 和 throw语句执行)，输出一个’e’，然后回到 main方法中，由于捕捉到异常，所以进入到catch语句中，然后打印一个'E',所以最终结果为"eE"

7. vilatile vs synchronized

7.2 题目

下列说法正确的是( )

volatile,synchronized
都可以修改变量，方法以及代码块

volatile，synchronized 在多线程中都会存在阻塞问题

volatile能保证数据的可见性，但不能完全保证数据的原子性，synchronized即保证了数据的可见性也保证了原子性

volatile解决的是变量在多个线程之间的可见性、原子性，而sychroized解决的是多个线程之间访问资源的同步性

7.2 答案

C

volatile和synchronized的区别

• volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
• volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、代码块和类级别的。
• volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性。
• volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
• volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化。
• volatile能保证数据的可见性，但不能完全保证数据的原子性（不能保证复合操作的原子性），synchronized即保证了数据的可见性，也保证了原子性。

8. 抽象类

8.1 题目

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

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

8.2 答案

E

• 只能被继承 //错误。抽象类不仅可以被继承，还可以直接拿来使用的，当然，这个使用是拿来声明，而不是实例化，因为抽象类不能实例化，但可以声明使用。就像接口一样。可以动态绑定，地实现多态，如下例子，AbstractMap就是抽象类，它可以这样使用。

AbstractMap<String, Integer> am = new HashMap<String, Integer>();  am.put("young", 23);
am.put("strongyoung", 26);
Iterator<String> itr = am.keySet().iterator();
while(itr.hasNext()){
    String key = itr.next();
    System.out.println(key + " : " + am.get(key));
}