2019年11月22日 java1

发表于 更新于 分类于 ， ， ， Waline： 本文字数： 3.2k 阅读时长 ≈ 3 分钟

考点1

下面所示的java代码,运行时,会产生()类型的异常
int Arry_a[] = new int[10];
System.out.println(Arry_a[10]);

  • A ArithmeticException
  • B NullPointException
  • C IOException
  • D ArrayIndexOutOfBoundsException

解析

显示答案/隐藏答案正确答案: D

这里有图片

考点2

以下哪个区域不属于新生代？

  • A eden区
  • B from区
  • C 元数据区
  • D to区

解析

显示答案/隐藏答案正确答案: C

Java 中的堆是JVM 所管理的最大的一块内存空间,主要用于存放各种类的实例对象。
在Java 中,堆被划分成两个不同的区域:

  • 新生代(Young)、
  • 老年代(Old)。

新生代(Young)又被划分为三个区域:

  • Eden、
  • From Survivor、
  • To Survivor。

这样划分的目的是为了使 JVM 能够更好的管理堆内存中的对象,包括内存的分配以及回收。
堆的内存模型大致为:
这里有图片
从图中可以看出： 堆大小 = 新生代 + 老年代。其中，堆的大小可以通过参数 –Xms、-Xmx 来指定。
本人使用的是 JDK1.6，以下涉及的 JVM 默认值均以该版本为准。
默认的新生代 ( Young ) 与老年代 ( Old ) 的比例的值为 1:2 ( 该值可以通过参数 –XX:NewRatio 来指定 )，即：

  • 新生代 ( Young ) = 1/3 的堆空间大小。
  • 老年代 ( Old ) = 2/3 的堆空间大小。

其中，新生代 ( Young ) 被细分为 Eden 和 两个 Survivor 区域，这两个 Survivor 区域分别被命名为 from 和 to，以示区分。
默认的，Edem : from : to = 8 : 1 : 1 ( 可以通过参数 –XX:SurvivorRatio 来设定 )，即：

  • Eden = 8/10 的新生代空间大小，
  • from = to = 1/10 的新生代空间大小。

JVM 每次只会使用 Eden 和其中的一块 Survivor 区域来为对象服务，所以无论什么时候，总是有一块 Survivor 区域是空闲着的。
因此，新生代实际可用的内存空间为 9/10 ( 即90% )的新生代空间。

考点3

以下JAVA程序代码的输出是

1
2
3
public static void main(String args[]) {
    System.out.println(17^5);
}
  • A 12
  • B 22
  • C 20
  • D 1419857

解析

显示答案/隐藏答案正确答案: C

异或运算是一个二进制运算：两者相同为0，两者不同为1

运算 数据
17 0001 0001
5 0000 0101
亦或结果 0001 0100
转10进制 20

考点4

下面程序的运行结果是

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package Wangyi;
class Base
{
    public void method()
    {
        System.out.println("Base");
    } 
}
class Son extends Base
{
    public void method()
    {
        System.out.println("Son");
    }
    
    public void methodB()
    {
        System.out.println("SonB");
    }
}
public class Test01
{
    public static void main(String[] args)
    {
        Base base = new Son();
        base.method();
        base.methodB();
    }
}

  • A Base SonB
  • B Son SonB
  • C Base Son SonB
  • D 编译不通过

解析

显示答案/隐藏答案正确答案: D

多态 编译看左边 运行看右边

这类多态问题中，无论向上或向下转型，都记住一句话就可以了。
编译看左边，运行看右边

  • 意思编译时候，看左边有没有该方法，
  • 运行的时候结果看new的对象是谁，就调用谁的方法。

考点5

关于 访问权限说法正确 的是 ？ ( )

  • A 类定义前面可以修饰public,protected和private
  • B 内部类前面可以修饰public,protected和private
  • C 局部内部类前面可以修饰public,protected和private
  • D 以上说法都不正确

解析

显示答案/隐藏答案正确答案: B

内部类分类

在Java中，可以将一个类定义在另一个类里面或者一个方法里边，这样的类称为内部类，广泛意义上的内部类一般包括四种：

  • 成员内部类，
  • 局部内部类，
  • 匿名内部类，
  • 静态内部类 。

1.成员内部类

成员内部类中可以访问外部类的所有成员

该类像是外部类的一个成员，可以无条件的访问外部类的所有成员属性和成员方法（包括private成员和静态成员）；

成员内部类的成员会隐藏外部类成员

成员内部类拥有与外部类同名的成员变量时，会发生隐藏现象，即成员内部类中，默认情况下访问的是成员内部类中的成员。如果要访问外部类中的成员，需要以下形式访问：
【外部类.this.成员变量 或 外部类.this.成员方法】；

外部类中要先创建内部类对象才能调用内部类的成员

成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象；
在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问；

内部类可以拥有四种访问权限

内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。

  • 如果成员内部类用private修饰，则只能在外部类的内部访问；
  • 如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；
  • 如果是默认访问权限，则只能在同一个包下访问。
  • 如果用public修饰，则任何地方都能访问；

外部类只能有两种访问权限

外部类只能被public和包访问两种权限修饰。

2.局部内部类

局部内部类只在方法或者代码块中可见

局部内部类是定义在一个方法或者一个代码块里面的类
它和成员内部类的区别在于
局部内部类的访问仅限于方法内或者该作用域内；

局部内部类不能用访问修饰符修饰

局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

3.匿名内部类

  • 匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。
  • 匿名内部类是唯一一种没有构造器的类；
  • 匿名内部类是不能有访问修饰符和static修饰符的；
  • 一般使用匿名内部类的方法来编写事件监听代码；

    4.内部静态类

  • 静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似；
  • 静态成员不能访问非静态成员，也就是静态内部类不能使用外部类的非static成员变量或者方法

考点6

下面哪一项不属于优化Hibernate所鼓励的？

  • A 使用单向一对多关联,不使用双向一对多
  • B 不用一对一,用多对一取代
  • C 配置对象缓存,不使用集合缓存
  • D 继承类使用显式多态

解析

显示答案/隐藏答案正确答案: A

有空了解一下

优化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.消除大表，使用二级缓存