Java概念性问题

最新推荐文章于 2022-05-21 22:31:40 发布

zyssmx

最新推荐文章于 2022-05-21 22:31:40 发布

阅读量607

点赞数

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

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

版权

java 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

以下内容来自学习整理：

下列Java常见事件类中哪个是鼠标事件类？（MouseEvent）

一、使用 MouseListener 接口处理鼠标事件

使用 MouseListener 接口可处理 5 类操作发生的鼠标事件：

在事件源上按下鼠标键
在事件源上释放鼠标键
在事件源上单击鼠标键
鼠标进入源
鼠标退出事件源

鼠标事件的类型是 MouseEvent ，该类中有下列主要方法：

getX() ：获取鼠标在事件源坐标系统中的 x 坐标。
getY() ：获取鼠标在事件源坐标系统中的 y 坐标。
getModifiers() ：获取鼠标的左键或右键。鼠标的左键和右键分别使用 InputEvent 类中的常量 BUTTON1_MASK 和 BUTTON3_MASK 来表示。
getClickCount() ：获取鼠标被单击的次数。
getSource() ：获取发生鼠标事件的事件源。
事件源获得监视器的方法是 addMouseListener( 监视器 ) 。
3.MouseListener 接口中有如下方法：
mousePressed(MouseEvent) ：负责处理鼠标按下事件。即当在事件源按下鼠标时，监视器发现这个事件后将自动调用接口中的这个方法对事件作出处理。
mouseReleased(MouseEvent) ：负责处理鼠标释放事件。
mouseEntered(MouseEvent) ：负责处理鼠标进入事件。
mouseExited(MouseEvent) ：负责处理鼠标离开事件。
mouseClicked(MouseEvent) ：负责处理鼠标单击事件。
二、使用 MouseMotionListener 接口处理鼠标事件

使用 MouseMotionListener 接口可以处理两种操作发生的鼠标事件：

在事件源上拖动鼠标。
在事件源上移动鼠标。
鼠标事件的类型是 MouseEvent, 即当发生鼠标事件时， MouseEvent 类自动创建一个事件对象。
事件源获得监视器的方法是 addMouseMotionListener( 监视器 ).
MouseMotionListener 接口中有如下方法：
mouseDragged(MouseEvent e) ：负责处理鼠标拖动事件。
mouseMoved(MouseEvent e) ：负责处理鼠标移动事件。
三、鼠标事件的转移
可以使用鼠标事件的转移将一个事件源发生的鼠标事件转移到另一个事件源上，即当用户在某个事件源上单击鼠标时，可以通过鼠标事件的转移导致另一个事件源上发生鼠标事件。使用 javax.swing 包中的 SwingUtilities 类的静态方法：
MouseEvent convertMouseEvent(Component source,MouseEvent sourceEvent,Component destination);
可以将 Source 组件上发生的鼠标事件转移到组件 destination 。

What will be printed when you execute the following code?

	```java
	class C {
	    C() {
	        System.out.print("C");
	    }
	}

class A {
    C c = new C();
 
    A() {
        this("A");
        System.out.print("A");
    }

    A(String s) {
        System.out.print(s);
    }
}

class Test extends A {
    Test() {
        super("B");
        System.out.print("B");
    }

    public static void main(String[] args) {
        new Test();
    }
}
```

初始化过程是这样的： 1.首先，初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化； 2.然后，初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化； 3.其次，初始化父类的普通成员变量和代码块，在执行父类的构造方法； 4.最后，初始化子类的普通成员变量和代码块，在执行子类的构造方法；（1）初始化父类的普通成员变量和代码块，执行 C c = new C(); 输出C （2）super("B"); 表示调用父类的构造方法，不调用父类的无参构造函数，输出B （3） System.out.print("B"); ######***下面哪种情况会导致持久区jvm堆内存溢出？*** A 循环上万次的字符串处理 B 在一段代码内申请上百M甚至上G的内存 C 使用CGLib技术直接操作字节码运行，生成大量的动态类 D 不断创建对象

原理
　　JVM堆内存分为2块：Permanent Space 和 Heap Space。Permanent 即持久代（Permanent Generation），主要存放的是Java类定义信息，与垃圾收集器要收集的Java对象关系不大。Heap = { Old + NEW = {Eden, from, to} }，Old 即年老代（Old Generation），New 即年轻代（Young Generation）。年老代和年轻代的划分对垃圾收集影响比较大。

年轻代
　　所有新生成的对象首先都是放在年轻代。年轻代的目标就是尽可能快速的收集掉那些生命周期短的对象。年轻代一般分3个区，1个Eden区，2个Survivor区（from 和 to）。
　　大部分对象在Eden区中生成。当Eden区满时，还存活的对象将被复制到Survivor区（两个中的一个），当一个Survivor区满时，此区的存活对象将被复制到另外一个Survivor区，当另一个Survivor区也满了的时候，从前一个Survivor区复制过来的并且此时还存活的对象，将可能被复制到年老代。
　　2个Survivor区是对称的，没有先后关系，所以同一个Survivor区中可能同时存在从Eden区复制过来对象，和从另一个Survivor区复制过来的对象；而复制到年老区的只有从另一个Survivor区过来的对象。而且，因为需要交换的原因，Survivor区至少有一个是空的。特殊的情况下，根据程序需要，Survivor区是可以配置为多个的（多于2个），这样可以增加对象在年轻代中的存在时间，减少被放到年老代的可能。针对年轻代的垃圾回收即 Young GC。

年老代
　　在年轻代中经历了N次（可配置）垃圾回收后仍然存活的对象，就会被复制到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。
针对年老代的垃圾回收即 Full GC。

持久代
　　用于存放静态类型数据，如 Java Class, Method 等。持久代对垃圾回收没有显著影响。但是有些应用可能动态生成或调用一些Class，例如 Hibernate CGLib 等，在这种时候往往需要设置一个比较大的持久代空间来存放这些运行过程中动态增加的类型。

所以，当一组对象生成时，内存申请过程如下：
１ JVM会试图为相关Java对象在年轻代的Eden区中初始化一块内存区域。
２当Eden区空间足够时，内存申请结束。否则执行下一步。
３ JVM试图释放在Eden区中所有不活跃的对象（Young GC）。释放后若Eden空间仍然
４不足以放入新对象，JVM则试图将部分Eden区中活跃对象放入Survivor区。
５ Survivor区被用来作为Eden区及年老代的中间交换区域。当年老代空间足够时，Survivor区中存活了一定次数的对象会被移到年老代。
６当年老代空间不够时，JVM会在年老代进行完全的垃圾回收（Full GC）。
７ Full GC后，若Survivor区及年老代仍然无法存放从Eden区复制过来的对象，则会导致JVM无法在Eden区为新生成的对象申请内存，即出现“Out of Memory”。

OOM（“Out of Memory”）异常一般主要有如下2种原因：

年老代溢出，表现为：java.lang.OutOfMemoryError:Javaheapspace
　　这是最常见的情况，产生的原因可能是：设置的内存参数Xmx过小或程序的内存泄露及使用不当问题。
　　例如循环上万次的字符串处理、创建上千万个对象、在一段代码内申请上百M甚至上G的内存。还有的时候虽然不会报内存溢出，却会使系统不间断的垃圾回收，也无法处理其它请求。这种情况下除了检查程序、打印堆内存等方法排查，还可以借助一些内存分析工具，比如MAT就很不错。
持久代溢出，表现为：java.lang.OutOfMemoryError:PermGenspace
　　通常由于持久代设置过小，动态加载了大量Java类而导致溢出，解决办法唯有将参数 -XX:MaxPermSize 调大（一般256m能满足绝大多数应用程序需求）。将部分Java类放到容器共享区（例如Tomcat share lib）去加载的办法也是一个思路，但前提是容器里部署了多个应用，且这些应用有大量的共享类库

JAVA语言的下面几种数组复制方法中，哪个效率最高？

Ａ　for循环逐一复制
Ｂ　System.arraycopy
Ｃ　Arrays.copyof
Ｄ　使用clone方法

A、for循环的话，很灵活，但是代码不够简洁。数组寻址访问
B、System.arraycopy()源码。可以看到是native方法：native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中。内存复制
可以将native方法比作Java程序同Ｃ程序的接口。

public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,int length);

C、选项有误，copyOf不是System的方法，而是Arrays的方法，下面是源码，可以看到本质上是调用的arraycopy方法。，那么其效率必然是比不上
arraycopy的

public static int[] copyOf(int[] original, int newLength) {
int[] copy = new int[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}

D、clone的话，返回的是Object【】，需要强制转换。一般用clone效率是最差的，
System.arraycopy是效率最高的。至于其他的实验时性能有所变化。
给出一下参考的：
http://bbs.csdn.net/topics/370151185
http://xuyuanshuaaa.iteye.com/blog/1046621

下列代码的输出结果是_____

boolean b=true?false:true==true?false:true;
System.out.println(b);

== 优先级高于三目运算符，先判断 true == true，此时返回为 true,
这时表达式为 boolean b = true?false:true?false:true
此时三目运算符从右向左执行,true?false:true，返回false
这时表达式为 boolean b = true?false:false;
结果为：boolean b = false ;

关于以下程序段，正确的说法是：（）

String s1="abc"+"def";//1
String s2=new String（s1);//2
if(s1.equals(s2))//3
System.out.println(".equals succeeded");//4
if(s1==s2)//5
System.out.println("==succeeded");//6

String s1=“123”，123是字符串常量被存在堆区的常量池中，常量池中的常量有与栈区相似的特点就是，当s2=“123”时，不会马上创建字符串123对象，会先查找常量池中是否存在相同常量，有，则s2指向同一内存空间，无则创建对象。而String s3=new String（）是在堆区创建对象，此对象是在堆区中的年轻代区域，与常量池所在的永久带区域必不相同，所以s3！=s1（s2）

equals 方法与 == 的区别，具体可参见博客
“http://blog.csdn.net/justloveyou_/article/details/52464440”
String 对象的创建方式，包括 new 方式和字符串字面值创建方式
“http://blog.csdn.net/justloveyou_/article/details/52556427”

下列说法错误的有（）重点内容

A 在类方法中可用this来调用本类的类方法
B 在类方法中调用本类的类方法时可直接调用
C 在类方法中只能调用本类中的类方法
D 在类方法中绝对不能调用实例方法
　　类方法：使用static修饰，属于整个类的，不是属于某个实例的，只能处理static域或调用static方法；
　　实例方法：属于对象的方法，由对象来调用。
　　一个类中的方法可以互相调用。但要注意：实例方法可以调用该类中的其他方法。
类方法只能调用其他类方法，不能调用实例方法。当类文件加载到内存时，实例方法不会被分配内存空间，只有在对象创建之后才会分配。而类方法在该类被加载到内存时就分配了相应的内存空间。实例方法既能对类变量操作也能对实例变量操作。类方法只能访问其他static方法。类方法只能访问其他static数据，例如，类变量。

Java程序的种类有（ＢＣＤ）

Ａ　类（Class）
Ｂ　Applet
Ｃ　Application
Ｄ　Servlet
Java程序的种类有：
（a）内嵌于Web文件中，由浏览器来观看的_Applet
（b）可独立运行的 Application
（c）服务器端的 Servlets
Application
―Java应用程序”是可以独立运行的Java程序。
由Java解释器控制执行。

Applet
―Java小程序”不能独立运行（嵌入到Web页中）。
由Java兼容浏览器控制执行
。
Serverlets
是Java技术对CGI 编程的解决方案。
是运行于Web server上的、作为来自于Web browser 或其他HTTP client端的请求和在server上的数据库及其他应用程序之间的中间层程序。
Serverlets的工作是：
１　读入用户发来的数据（通常在web页的form中）
２　找出隐含在HTTP请求中的其他请求信息（如浏览器功能细节、请求端主机名等。
３　产生结果(调用其他程序、访问数据库、直接计算)
４　格式化结果（网页）
５　设置HTTP response参数(如告诉浏览器返回文档格式)
６　将文档返回给客户端。

在Java中下面Class的声明哪些是错误的？ＡＢＣ

public abstract final class Test {
	abstract void method();
}
public abstract class Test {
	abstract final void method();
}
public abstract class Test {
	abstract void method() {
}
}
public class Test {
	final void method() {

}
}

A、final修饰的类为终态类，不能被继承，而抽象类是必须被继承的才有其意义的，因此，final是不能用来修饰抽象类的。
B、 final修饰的方法为终态方法，不能被重写。而继承抽象类，必须重写其方法。
C、抽象方法是仅声明，并不做实现的方法。

1、抽象类不能被实例化，实例化的工作应该交由它的子类来完成，它只需要有一个引用即可。
2、抽象方法必须由子类来进行重写。
3、只要包含一个抽象方法的类，该类必须要定义成抽象类，不管是否还包含有其他方法。
4、抽象类中可以包含具体的方法，当然也可以不包含抽象方法。
5、abstract不能与final并列修饰同一个类。
6、abstract 不能与private、static、final或native并列修饰同一个方法。

下面哪项技术可以用在WEB开发中实现会话跟踪实现？ＡＢＣＤ

Ａ　session
Ｂ　Cookie
Ｃ　地址重写
Ｄ　隐藏域
会话跟踪是一种灵活、轻便的机制，它使Web上的状态编程变为可能。
　　HTTP是一种无状态协议，每当用户发出请求时，服务器就会做出响应，客户端与服务器之间的联系是离散的、非连续的。当用户在同一网站的多个页面之间转换时，根本无法确定是否是同一个客户，会话跟踪技术就可以解决这个问题。当一个客户在多个页面间切换时，服务器会保存该用户的信息。
　　
有四种方法可以实现会话跟踪技术：URL重写、隐藏表单域、Cookie、Session。
1）.隐藏表单域：，非常适合步需要大量数据存储的会话应用。
2）.URL 重写:URL 可以在后面附加参数，和服务器的请求一起发送，这些参数为名字/值对。
3）.Cookie:一个 Cookie 是一个小的，已命名数据元素。服务器使用 SET-Cookie 头标将它作为 HTTP响应的一部分传送到客户端，客户端被请求保存 Cookie 值，在对同一服务器的后续请求使用一个Cookie 头标将之返回到服务器。与其它技术比较，Cookie 的一个优点是在浏览器会话结束后，甚至在客户端计算机重启后它仍可以保留其值
4）.Session：使用 setAttribute(String str,Object obj)方法将对象捆绑到一个会话

HTTP是“无状态”协议：客户程序每次读取 Web 页面，都打开到 Web 服务器的单独的连接，并且，服务器也不自动维护客户的上下文信息。即使那些支持持续性 HTTP 连接的服务器，尽管多个客户请求连续发生且间隔很短时它们会保持 socket 打开，但是，它们也没有提供维护上下文信息的内建支持。上下文的缺失引起许多困难。例如，在线商店的客户向他们的购物车中加入商品时，服务器如何知道购物车中己有何种物品呢？类似地，在客户决定结账时，服务器如何能确定之前创建的购物车中哪个属于此客户呢？这些问题虽然看起来十分简单，但是由于 HTTP 的不足，解答它们却异常复杂困难。对于这个问题，存在 3 种典型的解决方案：
　　
Cookie（结合session使用）
可以使用 cookie 存储购物会话的 ID；在后续连接中，取出当前的会话 ID，并使用这个 ID 从服务器上的查找表（lookup table）中提取出会话的相关信息。以这种方式使用 cookie 是一种绝佳的解决方案，也是在处理会话时最常使用的方式。但是，sevlet 中最好有一种高级的 API 来处理所有这些任务，以及下面这些冗长乏味的任务：从众多的其他cookie中（毕竟可能会存在许多cookie）提取出存储会话标识符的 cookie；确定空闲会话什么时候过期，并回收它们；将散列表与每个请求关联起来；生成惟一的会话标识符。

URL 重写
采用这种方式时，客户程序在每个URL的尾部添加一些额外数据。这些数据标识当前的会话，服务器将这个标识符与它存储的用户相关数据关联起来。 URL重写是比较不错的会话跟踪解决方案，即使浏览器不支持 cookie 或在用户禁用 cookie 的情况下，这种方案也能够工作。URL 重写具有 cookie 所具有的同样缺点，也就是说，服务器端程序要做许多简单但是冗长乏味的处理任务。即使有高层的 API 可以处理大部分的细节，仍须十分小心每个引用你的站点的 URL ，以及那些返回给用户的 URL。即使通过间接手段，比如服务器重定向中的 Location 字段，都要添加额外的信息。这种限制意味着，在你的站点上不能有任何静态 HTML 页面（至少静态页面中不能有任何链接到站点动态页面的链接）。因此，每个页面都必须使用 servlet 或 JSP 动态生成。即使所有的页面都动态生成，如果用户离开了会话并通过书签或链接再次回来，会话的信息也会丢失，因为存储下来的链接含有错误的标识信息。

隐藏的表单域
HTML 表单中可以含有如下的条目：
这个条目的意思是：在提交表单时，要将指定的名称和值自动包括在 GET 或 POST 数据中。这个隐藏域可以用来存储有关会话的信息，但它的主要缺点是：仅当每个页面都是由表单提交而动态生成时，才能使用这种方法。单击常规的超文本链接并不产生表单提交，因此隐藏的表单域不能支持通常的会话跟踪，只能用于一系列特定的操作中，比如在线商店的结账过程。

解析：实现会话跟踪的机制
Cookies，URL重写，隐藏式表单域，Session机制
Cookies
　　Cookies是使用最广泛的会话跟踪机制，Cookies是有服务器创建，并把Cookies信息保存在用户机器上的硬盘上，下次用户再次访问该站点服务器的时候，保存在用户机器上硬盘的Cookies信息就被送回给服务器。一般Cookies一般不多于4KB，且用户的敏感信息如信用卡账号密码不应该保存在Cookies中。
URL重写
　　URL重用户在每个URL结尾附加标识回话的数据，与标识符关联的服务器保存有关与会话的数据，如我们访问某个新闻的时候，在地址栏我们一般会看到这样的信息：http://www.XXX.com/news?id=??,通常的话id后面的问号表示该条新闻在后台数据库中的新闻表的id。URL重写能够在客户端停用cookies或者不支持cookies的时候仍然能够发挥作用。
隐藏表单域
　　通常，在表单中我们使用隐藏表单域的时候会有这么一句代码：。通过给type属性赋值为hidden值来实现隐藏，这样用户在浏览的时候看不到这行代码的数据，但是当用户通过查看源代码还是可以看到的。
Session机制
　　这个机制要慎用，特别是对于访问量很大的站点，因为这种机制是吧Session信息保存在服务器端。如果访问量特别大的话，对于服务器的承受力的要求有多高是可想而知的。

下面为true的是Ｇ

Integer i = 42;
Long l = 42l;
Double d = 42.0;

(i == l)
(i == d)
(l == d)
i.equals(d)
d.equals(l)
i.equals(l)
l.equals(42L)

1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
int a = 220;
Integer b = 220;
System.out.println(a==b);//true
2、两个Integer类型进行“==”比较，如果其值在-128至127 ，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。
Integer c=3;
Integer h=3;
Integer e=321;
Integer f=321;
System.out.println(c==h);//true
System.out.println(e==f);//false
3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true。
Integer a=1;
Integer b=2;
Integer c=3;
System.out.println(c.equals(a+b));//true
4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。
int i=1;
int j = 2;
Integer c=3;
System.out.println(c.equals(i+j));//true

关于抽象类与接口，下列说法正确的有？ＡＣ

Ａ　优先选用接口，尽量少用抽象类
Ｂ　抽象类可以被声明使用，接口不可以被声明使用
Ｃ　抽象类和接口都不能被实例化。
Ｄ　以上说法都不对

抽象类与接口:优先选用接口，尽量少用抽象类;抽象类和接口都不能被实例化。含有abstract修饰符的class即为抽象类，abstract类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。
　　abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。
　　接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为publicabstract类型，接口中的成员变量类型默认为public static final。接口中的方法都必须是抽象的，所以接口也不能实例化。
　
下面比较一下两者的语法区别：
1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4.抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然 eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
５.抽象类中可以包含静态方法，接口中不能包含静态方法
6.抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。