Java概念性问题10

最新推荐文章于 2023-10-13 13:02:09 发布

zyssmx

最新推荐文章于 2023-10-13 13:02:09 发布

阅读量295

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/zyssmx/article/details/72146648

版权

java 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

以下内容来自学习整理：

以下代码运行输出的是C

public class Person{
    private String name = "Person";
    int age=0;
}
public class Child extends Person{
    public String grade;
    public static void main(String[] args){
        Person p = new Child();
        System.out.println(p.name);
    }
}

A 输出：Person
B 没有输出
C 编译出错
D 运行出错

Java中对字段属性是静态绑定，方法成员是动态绑定，这里错在：在子类中试图访问父类的private字段，所以编译不通过，将private去掉就可访问，不是动态绑定的问题，它本来就属于静态绑定。

首先不能两个public类，其次child类中无法访问父类的私有变量。
这两种对象的创建很容易混淆。

Parent p1 = new Child();
p1.function();
当function()为子类覆盖父类的function时，则调用子类的；
。。。。不是。。。。。。。。。。。。，则调用父类的；
注意：p1是不能调用子类独有的方法的，会产生编译错误！！；
对于成员变量，则p1只能调用父类的，不能调用子类的
Child c1 = new Child();
c1就不存在不能调用子类独有的方法了。

JSP 表达式的写法：C

A <% expression %>
B <=% expression %>
C <%= expression %>
D <.expression/>
jsp 语法：
1） jsp 表达式： <%=变量或表达式%> 向浏览器输出变量或表达式计算的结果
2） jsp 脚本： <% java 代码 %> 执行 java 代码原理：翻译到_jspService（）方法中
3） jsp 声明： <%! 变量或方法 %> 声明 jsp 的成员变量或成员方法
4） jsp 注释： <%!-- jsp 注释 --%> 用于注释 jsp 代码，不会翻译到 java 文件中，也不会执行。

HashMap与Hashtable源码

//HashMap的源码
public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable
-----------------------------------
//Hashtable的源码
public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable
----------------------------------
很明显，都实现了Map接口，所以，A正确
----------------------------------------------------------------------------------------------
public V put(K key, V value) //HashMap的put方法，没有同步
 
public synchronized V put(K key, V value) //Hashtable的put方法
//当然，Hashtable的其他方法，如get，size，remove等方法，
//都加了synchronized关键词同步操作
------------------------------------------------------------------------------------------------
//Hashtable的put方法有以下语句块，大伙看了都知道
// Make sure the value is not null
if (value == null) {
    throw new NullPointerException();
} 
//那么，我们再来看下HashMap的put方法中，有如下语句
//调用某个方法直接把key为null，值为value的键值对插入进去。
if (key == null)
    return putForNullKey(value);
--------------------------------------------------------------------------------------
//以下是Hashtable的方法
public synchronized boolean contains(Object value)
public synchronized boolean containsKey(Object key)
public boolean containsValue(Object value)
 
//以下是HashMap中的方法，注意，没有contains方法，所以，D错误
public boolean containsKey(Object key)
public boolean containsValue(Object value)

HashTable和HashMap区别

HashTable和HashMap区别
①继承不同。
public class Hashtable extends Dictionary implements Map
public class HashMap extends AbstractMap implements Map
②Hashtable中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。在多线程并发的环境下，可以直接使用Hashtable，但是要使用HashMap的话就要自己增加同步处理了。
③ Hashtable中，key和value都不允许出现null值。
在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键，而应该用containsKey()方法来判断。
④两个遍历方式的内部实现上不同。Hashtable、HashMap都使用了Iterator。而由于历史原因，Hashtable还使用了Enumeration的方式。
⑤ 哈希值的使用不同，HashTable直接使用对象的hashCode。而HashMap重新计算hash值。
⑥ Hashtable和HashMap它们两个内部实现方式的数组的初始大小和扩容的方式。HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。

对于JVM内存配置参数：其最小内存值和Survivor区总大小分别是（D）

-Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3
A 5120m，1024m
B 5120m，2048m
C 10240m，1024m
D 10240m，2048m
-Xmx10240m表示堆内存最大是10240m，-Xms10240m表示堆内存最小是10240m，（说明堆内存是不可扩展了，大小就是10240m，如果-Xmx后面数字是20480m的话，说明如果需要的话堆内存可以自动扩展到20480m）； -Xmn5120m表示前面分配的堆内存（10240m）中新生代堆内存是5120m； -XXSurvivorRatio=3表示在新生代中，Eden与Survivor大小比是3：1，由于有两个Survivor（新生代内又分Eden、from Survivor、to Survivor三块区域），所以Survivor总区大小为5120/(3+1+1)*2=2048m。

String, StringBuffer,StringBuilder的区别

java中String、StringBuffer、StringBuilder是编程中经常使用的字符串类，他们之间的区别也是经常在面试中会问到的问题。现在总结一下，看看他们的不同与相同。
1.可变与不可变
String类中使用字符数组保存字符串，如下就是，因为有“final”修饰符，所以可以知道string对象是不可变的。
private final char value[];
String为不可变对象,一旦被创建,就不能修改它的值.
对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.
StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，如下就是，可知这两种对象都是可变的。
char[] value;
StringBuffer:是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象
它只能通过构造函数来建立,如： 
StringBuffer sb = new StringBuffer();
不能通过赋值符号对他进行付值，如
sb = "welcome to here!";//error
对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向StringBuffer中赋值的时候可以通过它的append方法.
sb.append("hello");
2.是否多线程安全
String中的对象是不可变的，也就可以理解为常量，显然线程安全。
AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。
StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。看如下源码：
public synchronized StringBuffer reverse() {
super.reverse();
return this;
}
public int indexOf(String str) {
return indexOf(str, 0);        
//存在 public synchronized int indexOf(String str, int fromIndex) 方法
}
StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
3.StringBuilder与StringBuffer共同点
StringBuilder与StringBuffer有公共父类AbstractStringBuilder(抽象类)。
抽象类与接口的其中一个区别是：抽象类中可以定义一些子类的公共方法，子类只需要增加新的功能，不需要重复写已经存在的方法；而接口中只是对方法的申明和常量的定义。
StringBuilder、StringBuffer的方法都会调用AbstractStringBuilder中的公共方法，如super.append(...)。只是StringBuffer会在方法上加synchronized关键字，进行同步。
最后，如果程序不是多线程的，那么使用StringBuilder效率高于StringBuffer。
效率比较String < StringBuffer < StringBuilder，但是在String S1=“This is only a”+“simple”+“test”时，String效率最高。

What will happen when you attempt to compile and run the following code?D

public class Test{
static{
   int x=5;
}
static int x,y;
public static void main(String args[]){
   x--;
   myMethod( );
   System.out.println(x+y+ ++x);
}
public static void myMethod( ){
  y=x++ + ++x;
 }
}

A compiletime error
B prints:1
C prints:2
D prints:3
E prints:7
F prints:8
http://blog.csdn.net/qq523786283/article/details/58612990

执行以下程序后的输出结果是（D）

public class Test {
public static void main(String[] args) {
    StringBuffer a = new StringBuffer("A"); 
    StringBuffer b = new StringBuffer("B"); 
    operator(a, b); 
    System.out.println(a + "," + b); 
} 
public static void operator(StringBuffer x, StringBuffer y) { 
    x.append(y); y = x; 
}
}

A A,A
B A,B
C B,B
D AB,B
x,y是a,b的副本，x.append(y)使得AB在一起，而y=x后，y指向AB，方法结束后x,y消亡，故a-AB,b-B;

true、false、null、sizeof、goto、synchronized 哪些是Java关键字？EF

A true
B false
C null
D sizeof
E goto
F synchronized
1，Java 关键字列表 (依字母排序共50组)：
abstract, assert, boolean, break, byte, case, catch, char, class, const（保留关键字）, continue, default, do, double, else, enum, extends, final, finally, float, for, goto（保留关键字）, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, throw, throws, transient, try, void, volatile, while
2，保留字列表 (依字母排序共14组)，Java保留字是指现有Java版本尚未使用，但以后版本可能会作为关键字使用：
byValue, cast, false, future, generic, inner, operator, outer, rest, true, var, goto （保留关键字） , const （保留关键字） , null

jvm中垃圾回收分为scanvenge gc和full GC，其中full GC触发的条件可能有哪些CDE

A 栈空间满
B 年轻代空间满
C 老年代满
D 持久代满
E System.gc()
1，新生代：（1）所有对象创建在新生代的Eden区，当Eden区满后触发新生代的Minor GC，将Eden区和非空闲Survivor区存活的对象复制到另外一个空闲的Survivor区中。（2）保证一个Survivor区是空的，新生代Minor GC就是在两个Survivor区之间相互复制存活对象，直到Survivor区满为止。
2，老年代：当Survivor区也满了之后就通过Minor GC将对象复制到老年代。老年代也满了的话，就将触发Full GC，针对整个堆（包括新生代、老年代、持久代）进行垃圾回收。
3，持久代：持久代如果满了，将触发Full GC。

下面有关JVM内存，说法错误的是？C

A 程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，是线程隔离的
B 虚拟机栈描述的是Java方法执行的内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的
C 方法区用于存储JVM加载的类信息、常量、静态变量、即使编译器编译后的代码等数据，是线程隔离的
D 原则上讲，所有的对象都在堆区上分配内存，是线程之间共享的

方法区在JVM中也是一个非常重要的区域，它与堆一样，是被线程共享的区域。在方法区中，存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。

大多数 JVM将内存区域划分为 Method Area（Non-Heap）（方法区） ,Heap（堆） , Program Counter Register（程序计数器） , VM Stack（虚拟机栈，也有翻译成JAVA方法栈的）,Native Method Stack （本地方法栈），其中Method Area 和
Heap 是线程共享的,VM Stack，Native Method Stack 和Program Counter Register
是非线程共享的。为什么分为线程共享和非线程共享的呢?请继续往下看。首先我们熟悉一下一个一般性的Java 程序的工作过程。一个 Java 源程序文件，会被编译为字节码文件（以 class为扩展名），每个java程序都需要运行在自己的JVM上，然后告知 JVM 程序的运行入口，再被 JVM通过字节码解释器加载运行。那么程序开始运行后，都是如何涉及到各内存区域的呢？
概括地说来，JVM初始运行的时候都会分配好 MethodArea（方法区）和Heap（堆），而JVM每遇到一个线程，就为其分配一个 Program Counter Register（程序计数器） , VM Stack（虚拟机栈）和Native Method Stack （本地方法栈），当线程终止时，三者（虚拟机栈，本地方法栈和程序计数器）所占用的内存空间也会被释放掉。这也是为什么我把内存区域分为线程共享和非线程共享的原因，非线程共享的那三个区域的生命周期与所属线程相同，而线程共享的区域与JAVA程序运行的生命周期相同，所以这也是系统垃圾回收的场所只发生在线程共享的区域（实际上对大部分虚拟机来说知发生在Heap上）的原因。

JVM 内存模型图
这里写图片描述
方法区域存放了所加载的类的信息（名称、修饰符等）、类中的静态变量、类中定义为final类型的常量、类中的Field信息、类中的方法信息，当开发人员在程序中通过Class对象中的getName、isInterface等方法来获取信息时，这些数据都来源于方法区域，同时方法区域也是全局共享的，在一定的条件下它也会被GC，当方法区域需要使用的内存超过其允许的大小时，会抛出OutOfMemory的错误信息
这里写图片描述
可以参考如下的链接:
http://www.cnblogs.com/sunada2005/p/3577799.html
http://blog.csdn.net/ns_code/article/details/17565503