---------------------------day01
虽然刷选择题有一段时间了，可是总不做笔记，这次做笔记希望坚持久一点
关于C++/JAVA类中static 成员和对象成员的说法正确的是？(C)
static 成员变量在对象构造时生成
static 成员函数在对象成员函数中无法调用
虚成员函数不可能是static 成员函数
static 成员函数不能访问static 成员变量
解析
static成员变量是在类加载的时候生成的
static成员函数既可以通过类名直接调用，也可以通过对象名进行调用
虚函数是C++中的，虚函数不可能是static的
static成员函数可以访问static成员变量
错误原因 眼挫、
下面有关JAVA swing的描述，说法错误的是？C
Swing是一个基于Java的跨平台MVC框架。使用单线程模式。
Swing 是为了解决 AWT 存在的问题而新开发的包，它以 AWT 为基础的
Swing优化了AWT，运行速度比AWT快
Swing是一个基于组件的框架，所有的组件都是从javax.swing.JComponent类继承来的
解析
首先swing是单线程的，这个是这篇文章的前提，也是意义所在，当swing界面程序启动的时候，会启动3个进程，
1、主线程
2、系统工具包线程:负责捕获操作系统事件，然后将事件转换成swing的事件，然后发送到事件派发线程EDT
3、事件派发线程(EDT):将事件派发到各个组件，并负责调用绘制方法更新界面
AWT和Swing之间的区别：
1)AWT 是基于本地方法的C/C++程序，其运行速度比较快；Swing是基于AWT的Java程序，其运行速度比较慢。
2)AWT的控件在不同的平台可能表现不同，而Swing在所有平台表现一致。
在实际应用中，应该使用AWT还是Swing取决于应用程序所部署的平台类型。例如：
1)对于一个嵌入式应用，目标平台的硬件资源往往非常有限，而应用程序的运行速度又是项目中至关重要的因素。在这种矛盾的情况下，简单而高效的AWT当然成了嵌入式Java的第一选择。
2)在普通的基于PC或者是工作站的标准Java应用中，硬件资源对应用程序所造成的限制往往不是项目中的关键因素。所以在标准版的Java中则提倡使用Swing， 也就是通过牺牲速度来实现应用程序的功能。
这题我没错，不过我的确不知道swing的知识点
下列关于final、finally、finalize说法正确的是(ABD )
final可以用来修饰类、方法、变量
finally是java保证重点代码一定要被执行的一种机制
变量被final修饰后不能再指向其他对象，但可以重写
finalize设计的目的是保证对象在被垃圾收集前完成特定资源的回收
解析
一、final关键字可以用来修饰类、方法、变量。各有不同。
A、修饰类(class)。
1、该类不能被继承。
2、类中的方法不会被覆盖，因此默认都是final的。
3、用途：设计类时，如果该类不需要有子类，不必要被扩展，类的实现细节不允许被改变，那么就设计成final类
B、修饰方法(method)
1、该方法可以被继承，但是不能被覆盖。
2、用途：一个类不允许子类覆盖该方法，则用final来修饰
3、好处：可以防止继承它的子类修改该方法的意义和实现；更为高效，编译器在遇到调用fianal方法转入内嵌机制，提高了执行效率。
4、注意：父类中的private成员方法不能被子类覆盖，因此，private方法默认是final型的(可以查看编译后的class文件)
C、修饰变量(variable)
1、用final修饰后变为常量。包括静态变量、实例变量和局部变量这三种。
2、特点：可以先声明，不给初值，这种叫做final空白。但是使用前必须被初始化。一旦被赋值，将不能再被改变。
D、修饰参数(arguments)
1、用final修饰参数时，可以读取该参数，但是不能对其作出修改
二、final关键字不能用来抽象类和接口
这题我也对了，但是这玩意是重点，指不定什么时候就忘记了 值得上错题本
以下哪种JAVA的变量表达式使得变量a和变量b具有相同的内存引用地址( A B )
String a = "hello"; String b = "hello";
Integer a; Integer b = a;
int a = 1; Integer b = new Integer(1);
int a = 1; Integer b = 1;
解析
首先结论：
(1)int与Integer、new Integer()进行==比较时，结果永远为true
(2)Integer与new Integer()进行==比较时，结果永远为false
(3)Integer与Integer进行==比较时，看范围；在大于等于-128小于等于127的范围内为true，在此范围外为false。
下面是解析过程：
**1**.Integer与int比较时，Integer会有拆箱的过程，我们可以看看拆箱的代码：
直接返回的就是value，因此int与Integer以及new Integer()进行 ==比较时结果都是true。
**2**.Integer a=n时，如果n大于等于-128小于等于127时，会直接从IntegerCache中取，不在这个范围内，会new一个对象，所以Integer与new Integer进行 ==比较时，结果都是false。
**3**.Integer与Integer比较，需要看范围，如果在-128~127(包含-128，不包含127)范围内，因为都是从IntegerCache中取值，所以相等；若不在这个范围内，则都要去new一个对象，所以结果为false。
我知道这个知识点 如果n大于等于-128小于等于127时，会直接从IntegerCache中取，不在这个范围内，会new一个对象，所以Integer与new Integer进行 ==比较时，结果都是false。
可我忘记了int a=1，不是指向堆空间，那就是说他只有值，没有地址。傻了~
以下代码的输出的正确结果是D
public class Test {
public static void main(String args[]) {
String s = "祝你考出好成绩！";
System.out.println(s.length());
}
}
24
16
15
8
Java中String的length() 返回数组的长度。一个字符(无论中文字符还是英文字符都一样)用一个char[] 存储。所以length() = 8.
这破题 我记得汉子等于两个字节啊~~~
结果
一个汉字等于一个字符 字符 是char
一个汉字也等于二个字节，字节 是byte
而且我看到后面还有一个空格~~~这题有点坑
以下多线程对int型变量x的操作，哪几个不需要进行同步( D )
x=y;
x++;
++x;
x=1;
A.由于y的值不确定，所以要加锁；
B,C 两个在多线程情况下是必须要加锁的，因为他们是先被读入寄存器，然后再进行+1操作，如果没有加锁，那么可能会出现数据异常；
D 原子操作，所以不需要加锁
原子性：指该操作不能再继续划分为更小的操作。
Java中的原子操作包括：
1、除long和double之外的基本类型的赋值操作
2、所有引用reference的赋值操作
3、java.concurrent.Atomic.* 包中所有类的一切操作
这题我没错，不过这个涉及到多线程的底层的原理 有必要放到错题本里面
就是读写读写~~~读写才要同步
如果我只是写那就不要同步
java运行时内存分为“线程共享”和“线程私有”两部分，以下哪些属于“线程共享”部分 BD
程序计算器
方法区
java虚拟机栈
java堆
共享的资源有：
a. 堆 由于堆是在进程空间中开辟出来的，所以它是理所当然地被共享的；因此new出来的都是共享的(16位平台上分全局堆和局部堆，局部堆是独享的)
b. 全局变量 它是与具体某一函数无关的，所以也与特定线程无关；因此也是共享的
c. 静态变量 虽然对于局部变量来说，它在代码中是“放”在某一函数中的，但是其存放位置和全局变量一样，存于堆中开辟的.bss和.data段，是共享的
d. 文件等公用资源 这个是共享的，使用这些公共资源的线程必须同步。Win32 提供了几种同步资源的方式，包括信号、临界区、事件和互斥体。
独享的资源有
a. 栈 栈是独享的
b. 寄存器 这个可能会误解，因为电脑的寄存器是物理的，每个线程去取值难道不一样吗？其实线程里存放的是副本，包括程序计数器PC
JVM里面的内容，我还没有系统性的看
今天刷了40道题 错的或者值得写入错题本的就这些
---------------------------day02
Which method you define as the starting point of new thread in a class from which n thread can be execution?
public void start()
public void run()
public void int()
public static void main(String args[])
public void runnable()
答案：B
要写一个线程类，可以继承Thread方法，然后override他的run()方法
另一种方法是实现Runable接口，即为实现run()方法。
A，start()是启动一个线程的方法
有一说一 英文没看太懂 我寻思是写一个线程类的方法 但实际上问的是下面哪一个是你类中定义可以作为新线程的起始点，直到线程n被执行完毕的方法 ？
吃了没文化的亏
执行如下代码段后，变量s1引用的字符串值是( A )。
String s1 = "ABCD";
String s2 = "1234";
System.out.println(s1 + s2);
ABCD
1234
ABCD1234
1234ABCD
这破题，恶心死老子了，变量s1引用的字符串值是 我就说没这么简单
关于运行时常量池，下列哪个说法是正确的BCD
运行时常量池大小受栈区大小的影响
运行时常量池大小受方法区大小的影响
存放了编译时期生成的各种字面量
存放编译时期生成的符号引用
在JDK1.8之前运行时常量池被放在方法区,属于线程共享,JDK1.8之后,元空间取代了方法区,运行时常量池被也被放在元空间中,运行时常池 主要存放, class文件元信息描述,编译后的代码，引用类型数据，类文件常量池。所谓的运行时常量池其实就是将编译后的类信息放入运行时的一个区域中，用来动态获取类信息。运行时常量池是在类加载完成之后，将每个class常量池中的符号引用值转存到运行时常量池中，也就是说，每个class都有一个运行时常量池，类在解析之后，将符号引用替换成直接引用，与全局常量池中的引用值保持一致。
运行时常量池是方法区的一部分。Class 文件中除了有类的版本、字段、方法、接口等描述信息外，还有常量池信息(用于存放编译期生成的各种字面量和符号引用)
有一说一jvm得抽时间系统学一下了
类之间存在以下几种常见的关系：
“USES-A”关系
“HAS-A”关系
“IS-A”关系
“INHERIT-A”关系
**USES-A：**依赖关系，A类会用到B类，这种关系具有偶然性，临时性。但B类的变化会影响A类。这种在代码中的体现为：A类方法中的参数包含了B类。
**关联关系：**A类会用到B类，这是一种强依赖关系，是长期的并非偶然。在代码中的表现为：A类的成员变量中含有B类。
**HAS-A：**聚合关系，拥有关系，是**关联关系**的一种特例，是整体和部分的关系。比如鸟群和鸟的关系是聚合关系，鸟群中每个部分都是鸟。
**IS-A：**表示继承。父类与子类，这个就不解释了。
要注意：还有一种关系：**组合关系**也是关联关系的一种特例，它体现一种contains-a的关系，这种关系比聚合更强，也称为强聚合。它同样体现整体与部分的关系，但这种整体和部分是不可分割的。
长见识了，之前都没听说过
建立Statement对象的作用是？C
连接数据库
声明数据库
执行SQL语句
保存查询结果
Class.forName("com.mysql.jdbc.Driver"); //加载jdbc驱动
con=DriverManager.getConnection(url,user,password); //建立连接
stmt=con.createStatement(); //创建语句执行者(stateMent用于执行不带参数的简单sql语句，PreparedStatement用于执行带参数的预编译sql语句能够预防sql注入，CallableStatement提供了一种标准形式的调用存储过程的方法)
stmt.execute(“sql语句”);
rs=stmt.executeQuery("sql查询语句"); //结果集
错误原因：直接翻译英文没有多想
java程序内存泄露的最直接表现是(C )
频繁FullGc
jvm崩溃
程序抛内存控制的Exception
java进程异常消失
答案 C，依次解释一下相关选项
首先理解一下内存泄漏的概念，内存泄漏就是对象引用消失了，对象内存却没有被回收。
A答案：FullGC 是老年代内存空间不足的时候，才会触发的，老年代一般是生命周期较长的对象或者大对象，频繁的 FullGC 不会可能会影响程序性能(因为内存回收需要消耗CPU等资源)，但是并不会直接导致内存泄漏。
B 答案：JVM奔溃的可能是内存溢出引起的，也可能是其他导致 JVM崩溃的操作，例如设置了错误的JVM参数等。
C 答案：内存异常，最常见的 就是 StackOverFlow 了把，内存溢出，其实内存泄漏的最终结果就是内存溢出。所以，基本上C是对的答案。
D 答案：Java 进程异常消失，这个明显不对的。
JVM的内容
下列Java代码中的变量a、b、c分别在内存的C__存储区存放。
class A {
private String a = “aa”;
public boolean methodB() {
String b = “bb”;
final String c = “cc”;
}
}
堆区、堆区、堆区
堆区、栈区、堆区
堆区、栈区、栈区
堆区、堆区、栈区
静态区、栈区、堆区
静态区、栈区、栈区
堆区：只存放类对象，线程共享；
方法区：又叫静态存储区，存放class文件和静态数据，线程共享;
栈区：存放方法局部变量，基本类型变量区、执行环境上下文、操作指令区，线程不共享;
我对了，但是有必要加进错题本
在Java中，关于HashMap类的描述，以下正确的是 (ACD)
HashMap使用键/值得形式保存数据
HashMap 能够保证其中元素的顺序
HashMap允许将null用作键
HashMap允许将null用作值
捕获.PNG
下面哪些类可以被继承？ Java.lang.Thread、java.lang.Number、java.lang.Double、java.lang.Math、 java.lang.ClassLoader ABE
Thread
Number
Double
Math
ClassLoader
java.lang包中不能被继承的类：
public final class Byte
public final class Character
public static final class Character.UnicodeBlock
public final class Class
public final class Compile
public final class Double
public final class Float
public final class Integer
public final class Long
public final class Math
public final class ProcessBuilder
public final class RuntimePermission
public final class Short
public final class StackTraceElement
public final class StrictMath
public final class String
public final class StringBuffer
public final class StringBuilder
public final class System
public final class Void
确实不知道
在开发中使用泛型取代非泛型的数据类型(比如用ArrayList取代ArrayList)，程序的运行时性能会变得更好。(B)
正确
错误
泛型仅仅是java的语法糖，它不会影响java虚拟机生成的汇编代码，在编译阶段，虚拟机就会把泛型的类型擦除，还原成没有泛型的代码，顶多编译速度稍微慢一些，执行速度是完全没有什么区别的.
//声明数据库驱动，数据源的url，用于登录数据库的账户和密码(将其他功能封装成方法的时> 候方便使用)
String driver = "数据库驱动名称"；
String url = "数据库连接地址"
String user = "用来连接数据库的用户名"；
String pwd = "用来连接数据库的密码"；
//加载数据库驱动
Class.forName(driver);
//根据url创建数据库连接对象Connection
Connection con = DriverManage.getConnection(url,user,pwd);
//用数据库连接对象创建Statement对象(或PrepareStatement)
Statement s = con.createStatement();
或
PrepareStatement ps = con.PrepareStatement(sql);
//做数据库的增删改查工作
ResultSet rs = s.executeQuery();
//关闭结果集对象Resultset，statement对象，connection对象，
rs.close();
s.close();
con.close();
//各个步骤的异常处理
以下哪些方法是Object类中的方法ABCD
clone()
toString()
wait()
finalize()
全选，Object 类中方法及说明如下：
registerNatives() //私有方法
getClass() //返回此 Object 的运行类。
hashCode() //用于获取对象的哈希值。
equals(Object obj) //用于确认两个对象是否“相同”。
clone() //创建并返回此对象的一个副本。
toString() //返回该对象的字符串表示。
notify() //唤醒在此对象监视器上等待的单个线程。
notifyAll() //唤醒在此对象监视器上等待的所有线程。
wait(long timeout) //在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或 者超过指定的时间量前，导致当前线程等待。
wait(long timeout, int nanos) //在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待。
wait() //用于让当前线程失去操作权限，当前线程进入等待序列
finalize() //当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
------------------------好久没刷题了 9.12
捕获.PNG
C
10
20
30
40
try块中抛出异常，try、catch和finally中都有return语句
public static int WithException(){
int i=10;
try{
System.out.println("i in try block is ： "+i);
i = i/0;
return --i;
}
catch(Exception e){
System.out.println("i in catch - form try block is ： "+i);
--i;
System.out.println("i in catch block is ： "+i);
return --i;
}
finally{
System.out.println("i in finally - from try or catch block is--"+i);
--i;
System.out.println("i in finally block is--"+i);
return --i;
}
}
执行结果：
============WithException==================
i in try block is ： 10
i in catch - form try block is ： 10
i in catch block is ： 9
i in finally - from try or catch block is--8
i in finally block is--7
6
===============================
执行顺序：
抛出异常后，执行catch块，在catch块的return的--i执行完后，并不直接返回而是执行finally，因finally中有return语句，所以，执行，返回结果6。
结论：
try块中抛出异常，try、catch和finally中都有return语句，返回值是finally中的return。
总体结论：
结论一：
return语句并不是函数的最终出口，如果有finally语句，这在return之后还会执行finally(return的值会暂存在栈里面，等待finally执行后再返回)
结论二：
finally里面不建议放return语句，根据需要，return语句可以放在try和catch里面和函数的最后。可行的做法有四：
(1)return语句只在函数最后出现一次。
(2)return语句仅在try和catch里面都出现。
(3)return语句仅在try和函数的最后都出现。
(4)return语句仅在catch和函数的最后都出现。
注意，除此之外的其他做法都是不可行的，编译器会报错
这个是jvm里面的内容，我所以这段时间了解jvm还是很有必要的 这道题·我对了
Java数据库连接库JDBC用到哪种设计模式?B
生成器
桥接模式
抽象工厂
单例模式
**桥接模式：**
**定义** ：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
**意图** ：将抽象与实现解耦。
**桥接模式所涉及的角色**
1. **Abstraction** ：定义抽象接口，拥有一个Implementor类型的对象引用
2. **RefinedAbstraction** ：扩展Abstraction中的接口定义
3. **Implementor** ：是具体实现的接口，Implementor和RefinedAbstraction接口并不一定完全一致，实际上这两个接口可以完全不一样Implementor提供具体操作方法，而Abstraction提供更高层次的调用
4. **ConcreteImplementor** ：实现Implementor接口，给出具体实现
Jdk中的桥接模式：JDBC
JDBC连接 [数据库](http://www.2cto.com/database/) 的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不动，原因就是JDBC提供了统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了
我以为是单例模式
以下那些代码段能正确执行
public static void main(String args[]) {
byte a = 3;
byte b = 2;
b = a + b;
System.out.println(b);
}
public static void main(String args[]) {
byte a = 127;
byte b = 126;
b = a + b;
System.out.println(b);
}
public static void main(String args[]) {
byte a = 3;
byte b = 2;
a+=b;
System.out.println(b);
}
public static void main(String args[]) {
byte a = 127;
byte b = 127;
a+=b;
System.out.println(b);
}
byte类型的变量在做运算时被会转换为int类型的值，故A、B左为byte，右为int，会报错；而C、D语句中用的是a+=b的语句，此语句会将被赋值的变量自动强制转化为相对应的类型。
我对了，不过这个知识点的确很重要
在Java线程状态转换时，下列转换不可能发生的有()？A D
初始态->运行态
就绪态->运行态
阻塞态->运行态
运行态->就绪态
image.png
image.png