JavaSE *Linux集合 知识点Link

Linux碉堡了入门：https://blog.csdn.net/qq_41781322/article/details/79520181

java碉堡SE知识大全：https://blog.csdn.net/qq_35336425/article/details/82825542

java八种基本数据类型及包装类详解

https://blog.csdn.net/qq_37688023/article/details/85106894

谈一谈IO流体系：

https://www.cnblogs.com/ylspace/p/8128112.html

 

谈一谈Java集合体系：

https://www.cnblogs.com/linliquan/p/11323172.html

 

谈一谈java的反射体系：

https://blog.csdn.net/yangyuscript/article/details/79257055

 

谈一谈java的序列化：

https://www.cnblogs.com/zhengshao/p/8882613.html

https://www.runoob.com/java/java-serialization.html (菜鸟教程！)

 

 

 

 

 

 

 

Java 面向对象都有哪些特性以及你对这些特性的理解？

1）继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承
信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要
手段。
2） 封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象
的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们
编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接
口。
3） 多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调
用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界
提供的服务，那么运行时的多态性可以解释为：当A 系统访问 B 系统提供的服务时，B系统有多种提供服务的方式， 但一
切对 A 系统来说都是透明的。方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写
（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西，要实现多态需要做两
件事：1. 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；2. 对象造型（用父类型引用引用子类型对象，
这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。
4）抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象
有哪些属性和行为，并不关注这些行为的细节是什么。

接口和抽象类的区别

抽象类和接口均包含抽象方法，类必须实现所有的抽象方法，否则是抽象类

抽象类和接口都不能实例化，他们位于继承树的顶端，用来被其他类继承和实现

两者的区别主要体现在两方面：语法方面和设计理念方面

语法方面的区别是比较低层次的，非本质的，主要表现在：

接口中只能定义全局静态常量，不能定义变量。抽象类中可以定义常量和变量。

接口中所有的方法都是全局抽象方法。抽象类中可以有0个、1个或多个，甚至全部都是抽象方法。

抽象类中可以有构造方法，但不能用来实例化，而在子类实例化是执行，完成属于抽象类的初始化操作。接口中不能定义构造方法。

一个类只能有一个直接父类（可以是抽象类），但可以充实实现多个接口。一个类使用extends来继承抽象类，使用implements来实现接口。

一个类只能有一个直接父类（可以是抽象类），但可以充实实现多个接口。一个类使用extends来继承抽象类，使用implements来实现接口。

抽象类体现了一种继承关系，目的是复用代码，抽象类中定义了各个子类的相同代码，可以认为父类是一个实现了部分功能的“中间产品”，而子类是“最终产品”。父类和子类之间必须存在“is-a”的关系，即父类和子类在概念本质上应该是相同的。

接口并不要求实现类和接口在概念本质上一致的，仅仅是实现了接口定义的约定或者能力而已。接口定义了“做什么”，而实现类负责完成“怎么做”，体现了功能（规范）和实现分离的原则。接口和实现之间可以认为是一种“has-a的关系”

 

• 接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。

• 类可以实现很多个接口，但是只能继承一个抽象类

• 类如果要实现一个接口，它必须要实现接口声明的所有方法。但是，类可以不实现抽象类声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。

• 抽象类可以在不提供接口方法实现的情况下实现接口。

• Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。

• Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。

• 接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。

 

Java 中实现多态的机制是什么？

靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动
态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变
量的类型中定义的方法。

反射的作用：   扩展：https://blog.csdn.net/yangyuscript/article/details/79257055

通过反射可以使程序代码访问装载到JVM 中的类的内部信息

1) 获取已装载类的属性信息

2) 获取已装载类的方法

3) 获取已装载类的构造方法信息

反射的优点：

增加程序的灵活性。

如struts中。请求的派发控制。

当请求来到时。struts通过查询配置文件。找到该请求对应的action。已经方法。

然后通过反射实例化action。并调用响应method。

如果不适用反射，那么你就只能写死到代码里了。

所以说，一个灵活，一个不灵活。

很少情况下是非用反射不可的。大多数情况下反射是为了提高程序的灵活性。因此一般框架中使用较多。因为框架要适用更多的情况。对灵活性要求较高。

 

进程和线程的区别是什么？

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.

线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

有哪些线程安全的类？

vector：就比arraylist多了个同步化机制（线程安全），因为效率较低，现在已经不太建议使用。在web应用中，特别是前台页面，往往效率（页面响应速度）是优先考虑的。

statck：堆栈类，先进后出

hashtable：就比hashmap多了个线程安全

enumeration：枚举，相当于迭代器

除了这些之外，其他的都是非线程安全的类和接口。

线程安全的类其方法是同步的，每次只能一个访问。是重量级对象，效率较低。

 

----

HashMap 和 HashTable 有什么区别?
HashMap 是线程不安全的,HashMap 是一个接口,是 Map 的一个子接口,是将键映射到值得对象,不允许键值重复,

允许空键和空值;由于非线程安全,HashMap 的效率要较 HashTable 的效率高一些.
HashTable 是线程安全的一个集合,不允许 null 值作为一个 key 值或者 Value 值;
HashTable 是 sychronize,多个线程访问时不需要自己为它的方法实现同步,而 HashMap 在被多个线程访问的时
候需要自己为它的方法实现同步;

2. 多线程并发修改一 个 集合 怎么办

用老的Vector/Hashtable类

 

 

总结

Java线程间具有优先级，在调用栈可以设置优先级别（1-10）

yield()方法：暂停当前正在执行的线程对象，并执行其他线程。

yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

jion()方法：线程实例的join()方法可以使得一个线程在另一个线程结束后再执行，即也就是说使得当前线程可以阻塞其他线程执行；

thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。

比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。

详细说明

理解线程的优先权

接下来，理解线程优先级是多线程学习很重要的一步，尤其是了解yield()函数的工作过程。

1. 记住当线程的优先级没有指定时，所有线程都携带普通优先级。
2. 优先级可以用从1到10的范围指定。10表示最高优先级，1表示最低优先级，5是普通优先级。
3. 记住优先级最高的线程在执行时被给予优先。但是不能保证线程在启动时就进入运行状态。
4. 与在线程池中等待运行机会的线程相比，当前正在运行的线程可能总是拥有更高的优先级。
5. 由调度程序决定哪一个线程被执行。
6. t.setPriority()用来设定线程的优先级。
7. 记住在线程开始方法被调用之前，线程的优先级应该被设定。
8. 你可以使用常量，如MIN_PRIORITY,MAX_PRIORITY，NORM_PRIORITY来设定优先级

现在，当我们对线程调度和线程优先级有一定理解后，让我们进入主题。

yield()方法

理论上，yield意味着放手，放弃，投降。一个调用yield()方法的线程告诉虚拟机它乐意让其他线程占用自己的位置。这表明该线程没有在做一些紧急的事情。注意，这仅是一个暗示，并不能保证不会产生任何影响。

让我们列举一下关于以上定义重要的几点：

• Yield是一个静态的原生(native)方法
• Yield告诉当前正在执行的线程把运行机会交给线程池中拥有相同优先级的线程。
• Yield不能保证使得当前正在运行的线程迅速转换到可运行的状态
• 它仅能使一个线程从运行状态转到可运行状态，而不是等待或阻塞状态

具体的程序见参考连接

join()方法使用示例

线程实例的join()方法可以使得一个线程在另一个线程结束后再执行。如果join()方法在一个线程实例上调用，当前运行着的线程将阻塞直到这个线程实例完成了执行。例如下面代码所示，t将阻塞t1知道t执行完毕后在执行t1；

在join()方法内可以设定超时，使得join()方法在超时后无效。当超时时，主方法和任务线程申请运行的时候是平等的。然而，当涉及sleep时，join()方法依靠操作系统计，所以你不应该假定join()方法将会等待你指定的时间。

像sleep,join通过抛出InterruptedException对中断做出回应。

 

同步方法和同步代码块

事务的特性

框架题

 

Servlet的生命周期

Servlet 的生命周期：Servlet 加载—>实例化—>服务—>销毁。

    init（）：在Servlet的生命周期中，仅执行一次init()方法。它是在服务器装入Servlet时执行的，负责初始化Servlet对象。可以配置服务器，以在启动服务器或客户机首次访问Servlet时装入Servlet。无论有多少客户机访问Servlet，都不会重复执行init（）。
    service（）：它是Servlet的核心，负责响应客户的请求。每当一个客户请求一个HttpServlet对象，该对象的Service()方法就要调用，而且传递给这个方法一个“请求”（ServletRequest）对象和一个“响应”（ServletResponse）对象作为参数。在HttpServlet中已存在Service()方法。默认的服务功能是调用与HTTP请求的方法相应的do功能。
    destroy（）： 仅执行一次，在服务器端停止且卸载Servlet时执行该方法。当Servlet对象退出生命周期时，负责释放占用的资源。一个Servlet在运行service()方法时可能会产生其他的线程，因此需要确认在调用destroy()方法时，这些线程已经终止或完成。
 

 

 

 

Spring 

 

 

 

 

事务(transcation)的介绍

    事务就是用户定义的一系列执行SQL语句的操作, 这些操作要么完全地执行，要么完全地都不执行， 它是一个不可分割的工作执行单元。
    事务的使用场景:
    在日常生活中，有时我们需要进行银行转账，这个银行转账操作背后就是需要执行多个SQL语句，假
    如这些SQL执行到一半突然停电了，那么就会导致这个功能只完成了一半，这种情况是不允许出现，
    要想解决这个问题就需要通过事务来完成。

事务的四大特性：

    原子性(Atomicity)

    一致性(Consistency)

    隔离性(Isolation)

    持久性(Durability)

    原子性:

    一个事务必须被视为一个不可分割的最小工作单元，整个事务中的所有操作要么全部提交成功，要么
    全部失败回滚，对于一个事务来说，不可能只执行其中的一部分操作，这就是事务的原子性

    一致性:

数据库总是从一个一致性的状态转换到另一个一致性的状态。（在前面的例子中，一致性确保了，即
使在转账过程中系统崩溃，支票账户中也不会损失200美元，因为事务最终没有提交，所以事务中所做
的修改也不会保存到数据库中。）

    隔离性:

通常来说，一个事务所做的修改操作在提交事务之前，对于其他事务来说是不可见的。（在前面的例
子中，当执行完第三条语句、第四条语句还未开始时，此时有另外的一个账户汇总程序开始运行，则
其看到支票帐户的余额并没有被减去200美元。）

    持久性:

一旦事务提交，则其所做的修改会永久保存到数据库。

说明:事务能够保证数据的完整性和一致性，让用户的操作更加安全。

        事务的特性:
        原子性: 强调事务中的多个操作时一个整体
        一致性: 强调数据库中不会保存不一致状态
        隔离性: 强调数据库中事务之间相互不可见
        持久性: 强调数据库能永久保存数据，一旦提交就不可撤销
        MySQL数据库默认采用自动提交(autocommit)模式, 也就是说修改数据(insert、update、delete)的操 作会自动的触发事务,完成事务的提交或者回滚
        开启事务使用 begin 或者 start transaction; 事务 81
        回滚事务使用 rollback;
        pymysql 里面的 conn.commit() 操作就是提交事务
        pymysql 里面的 conn.rollback() 操作就是回滚事务
 

SpringMvc面试题：

SpringMVC的运作流程？

（1）用户发送请求至前端控制器DispatcherServlet；
（2） DispatcherServlet收到请求后，调用HandlerMapping处理器映射器，请求获取Handle；
（3）处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet；
（4）DispatcherServlet 调用 HandlerAdapter处理器适配器；
（5）HandlerAdapter 经过适配调用 具体处理器(Handler，也叫后端控制器)；
（6）Handler执行完成返回ModelAndView；
（7）HandlerAdapter将Handler执行结果ModelAndView返回给DispatcherServlet；
（8）DispatcherServlet将ModelAndView传给ViewResolver视图解析器进行解析；
（9）ViewResolver解析后返回具体View；
（10）DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）
（11）DispatcherServlet响应用户。

Springmvc的优点:

（1）可以支持各种视图技术,而不仅仅局限于JSP；

（2）与Spring框架集成（如IoC容器、AOP等）；

（3）清晰的角色分配：前端控制器(dispatcherServlet) , 请求到处理器映射（handlerMapping), 处理器适配器（HandlerAdapter), 视图解析器（ViewResolver）。

（4） 支持各种请求资源的映射策略。

Spring MVC的主要组件？

（1）前端控制器 DispatcherServlet（不需要程序员开发）

作用：接收请求、响应结果，相当于转发器，有了DispatcherServlet 就减少了其它组件之间的耦合度。

（2）处理器映射器HandlerMapping（不需要程序员开发）

作用：根据请求的URL来查找Handler

（3）处理器适配器HandlerAdapter

注意：在编写Handler的时候要按照HandlerAdapter要求的规则去编写，这样适配器HandlerAdapter才可以正确的去执行Handler。

（4）处理器Handler（需要程序员开发）

（5）视图解析器 ViewResolver（不需要程序员开发）

作用：进行视图的解析，根据视图逻辑名解析成真正的视图（view）

（6）视图View（需要程序员开发jsp）

View是一个接口， 它的实现类支持不同的视图类型（jsp，freemarker，pdf等等）

SpringMVC常用的注解有哪些？

@RequestMapping：用于处理请求 url 映射的注解，可用于类或方法上。用于类上，则表示类中的所有响应请求的方法都是以该地址作为父路径。

@RequestBody：注解实现接收http请求的json数据，将json转换为java对象。

@ResponseBody：注解实现将conreoller方法返回对象转化为json对象响应给客户。

如何解决POST请求中文乱码问题，GET的又如何处理呢？

（1）解决post请求乱码问题：

在web.xml中配置一个CharacterEncodingFilter过滤器，设置成utf-8；

    <filter>

        <filter-name>CharacterEncodingFilter</filter-name>

        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>

        <init-param>

            <param-name>encoding</param-name>

            <param-value>utf-8</param-value>

        </init-param>

    </filter>

    <filter-mapping>

        <filter-name>CharacterEncodingFilter</filter-name>

        <url-pattern>/*</url-pattern>

    </filter-mapping>

（2）get请求中文参数出现乱码解决方法有两个：

①修改tomcat配置文件添加编码与工程编码一致，如下：

    <ConnectorURIEncoding="utf-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>

②另外一种方法对参数进行重新编码：

String userName = new String(request.getParamter("userName").getBytes("ISO8859-1"),"utf-8")

ISO8859-1是tomcat默认编码，需要将tomcat编码后的内容按utf-8编码。
 

Round 2:

 

 

 

说下原生JDBC操作数据库的流程

 

 

 

关系型数据库中连接池的机制是什么？

 

 

http的常见状态码有哪些（至少5个）

web开发种如何输出某种编码的字符串？（请写出关键的代码）

 

实现失去焦点检测出用户名的ajax功能.

用户名<input type="text" id="username"/><span id="msg"></span>

 

 

 

编程题

Java实现

判断是否是水仙花数

import java.util.Scanner;

public class C4 {

public static void main(String[] args) {

Scanner x=new Scanner(System.in);

System.out.println("请输入这个数：");

int d=x.nextInt();

int a=d/100;

int b=d/10%10;

int c=d%10;

if(a*100+b*10+c==a*a*a+b*b*b+c*c*c) {

System.out.println( +d+"此数为水仙花数");

 

}

else {

System.out.println(+d+"此数不是水仙花数" );

}

}

}

所谓水仙花数就是一个三位数，它各位的立方之和加起来的数值等于本身，比如说，153,153 = 1 + 125 + 27 ；

 

 

实现

public class ShuiXianHua{
static int aaa,aa,a;
public static void main(String args[]){
floweer();
}

public static flower(){
int x=0,y=0,z=0;
for(int i=100;i<1000;i++){
x=i/100;
y=(i%100)/10;
z=(i%100)%10;
if(x*x*x+y*y*y+z*z*z==i){
System.out.println(i+"");
}
}
}
}

 

String a="aa"与 String a=new String("aa")的区别？

String a = "aa"; 先在内存中找是不是有"aa" 这个对象,

如果有，就让a指向那个"aa".如果内存里没有"aa"，就创建一个新的对象保存"aa".

String a=new String ("aa") 就是不管内存里是不是已经有"aa"这个对象，

都新建一个对象保存"aa"
String a = new String("aa");是在堆里面建立的对象 String,a和"aa"
ab="aa";是查找栈里有没有"aa",如果有就用ab引用它，如果没有就把“aa”存进栈


String r ="dsds"; ---------------------生成一个对象 "dsds"
String r =new String ("dsd"); ---------------生成两个对象,"dsd"和new String ("dsd")

因为new String("dsd")的参数"dsd"本身就是一个字符串对象，new String("dsd")又返回一个字符串对象。

 

看代码:

 

 

这就像如果有：

String s1 = "hello";  String s2 = "hello"; System.out.println(s1==s2);

结果为true，因为他们的地址值是一致的，都指向常量池中的字符串常量。

而

String s1 = new String("hello"); String s2 = new String("hello"); System.out.println(s1==s2);

结果则是false，因为他们都在堆中建立了对象，而对象之间的地址值不同