1. 面向对象三大特性、六大原则 1
面向对象程序设计：将一个对象的特征和行为抽象成属性和方法封装在类中，并利用多个对象之间的交互通信形成程序。
三大特性：
封装：将一个对象的特征和行为抽象成属性和方法封装在类中。
继承：子类继承父类的属性和方法，即子承父业。
多态：通过父类调用子类方法，即同一消息可以根据发送对象的不同而采用多种不同的行为方式。
六大原则：
单一职责原则：一个类，最好只做一件事，只有一个引起它的变化。
开放封闭原则(OCP)：软件的功能应该是可扩展的，而尽可能的不修改。
里氏（Liskov）替换原则(LSP)：子类必须能够替换基类。
依赖倒置原则(DIP):依赖于抽象，即高层模块不依赖底层模块，二者都通依赖于抽象。/客户类和服务类都应该依赖于抽象（接口），并且客户类拥有接口。
接口隔离原则：使用多个小的专门的接口，而不要使用一个大的总接口。
合成复用原则（Composite Reuse Principle）：原则是尽量首先使用合成/聚合的方式，而不是使用继承
2. java的基本数据类型以及变量定义格式、类型转化 1
8种基本数据类型：byte、short、char、int、long、float、double、boolean
变量定义格式：(1)以字母（A-Z或者a-z）,美元符（$）、或者下划线（_）开始;
（2)关键字不能用作标识符;
(3)标识符是大小写敏感的
类型转换：从低级到高级-----自然转换，反向要强制类型转换。可能精度损失，舍弃小数变整型。
3. List、Set、Map的分类、区别以及遍历方式 1
List分为：
ArrayList:顺序表，适合更新、查询。
LinkedList：链表，适合插入、删除。
Set分为：
HashSet：无序，不重复
LinkedHashSet：存取有序，不重复
TreeSet：自动排序，不重复
map分为：键值对
HashMap：无序
LinkedHashMap：存取有序
TreeMap：自动排序
遍历基本方式：（1）for循环遍历；（2）Iterator迭代器遍历；（3）foreach循环遍历。
@Test
/**
* @author yto_yh
* ArrayList示例
* 适用于查询、修改
* 一下遍历方式set通用
*/
public void test() {
List<Integer> num= Arrays.asList(1,2,3,4,5);
System.out.println("初始："+num);
//Iterator迭代器遍历
System.out.print("第一种遍历：");
Iterator<Integer> it=num.iterator();
while(it.hasNext()) {
System.out.print(it.next()+" ");
}
//for循环遍历
System.out.print("\n第二种遍历：");
for(Iterator<Integer> it1=num.iterator();it1.hasNext();) {
System.out.print(it1.next()+" ");
}
//forEach遍历
System.out.print("\n第三种遍历：");
for(int i:num) {
System.out.print(i+" ");
}
//lambda表达式遍历
System.out.print("\n第四种遍历：");
num.forEach(i->System.out.print(i+" "));
//System.out::print遍历
System.out.print("\n第五种遍历：");
num.forEach(System.out::print);
}
4. 枚举的特性 2
public static final 形式的常量定义的缺点：类型不安全、没有命名空间、一致性差
创建枚举类型要使用enum关键字，且都是java.lang.Enum类的子类（java.lang.Enum是一个抽象类），类型安全。
枚举类的名称一般以Enum结尾
可以使用==直接来比较值
枚举的构造方法默认且只能是private的。
只能覆盖toString方法
两个方便操作enum的工具类——EnumSet 和 EnumMap。
values()：返回 enum 实例的数组，而且该数组中的元素严格保持在 enum 中声明时的顺序
name()：返回实例名。
ordinal()：返回实例声明时的次序，从0开始。
getDeclaringClass()：返回实例所属的 enum 类型。
equals()：判断是否为同一个对象。可以使用 == 来比较enum实例。
/**
* @author yto_yh
*
*/
public enum ColorEnum3 {
AB(1,"ab"),
BB(2,"bb"),
CB(3,"cb"),
DB(4,"db"),
EB(5,"eb");
private Integer ID;
private String NAME;
private ColorEnum3(Integer iD, String nAME) {
ID = iD;
NAME = nAME;
}
public Integer getID() {
return ID;
}
public void setID(Integer iD) {
ID = iD;
}
public String getNAME() {
return NAME;
}
public void setNAME(String nAME) {
NAME = nAME;
}
}
/**
* @author yto_yh
*
*/
public class TestEnum0904 {
public static void main(String[] args) {
for(ColorEnum3 i:ColorEnum3.values()) {
System.out.println(i.ordinal()+" "+i.name()+" "+i.getNAME()+" "+i.getDeclaringClass()+" "+i.getNAME().equals("cb"));
}
}
}
5. 异常分类和处理方式 2
异常事件的分类：
Error： Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等。
Exception分两种：
编译时异常：ClassNotFoundException(没找到类)、FileNotFoundException(文件没找到)、SQLException(数据库异常)
运行时异常：ArrayIndexOutOfBoundsException(数组越界异常)、
ClassCastException(类转换异常)、NullPointerException(空指针异常)、
ArithmeticException(算法异常)、ClassCastException(类转换异常)
异常处理方式：(1)throws方法头部抛出异常；(2)throw在方法内部抛出异常；(3)通过try-catch-finally语句实现
6. 线程的生命周期以及实现方式 2
线程的生命周期：创建、就绪、运行、阻塞、死亡
Lock和synchronized的不同:
Lock是一个接口，而synchronized是Java中的关键字
synchronized在发生异常时，会自动释放线程占有的锁；Lock在发生异常时，在finally块中通过unLock()去释放锁。
Lock可以让等待锁的线程响应中断，synchronized不行
通过Lock可以知道有没有成功获取锁，synchronized不行
Lock可以提高多个线程进行读操作的效率
线程的实现方式：
继承Thread类创建线程
实现Runnable接口创建线程
使用ExecutorService、Callable、Future实现有返回结果的线程【ExecutorService、Callable、Future三个接口实际上都是属于Executor框架。】
/**
* @author yto_yh
*
*/
public class MyCallable implements Callable<Object>{
private String taskNum;
MyCallable(String taskNum) {
this.taskNum = taskNum;
}
@Override
public Object call() throws Exception {
// TODO Auto-generated method stub
System.out.println(">>>" + taskNum + "任务启动");
Date dateTmp1 = new Date();
Thread.sleep(1000);
Date dateTmp2 = new Date();
long time = dateTmp2.getTime() - dateTmp1.getTime();
System.out.println(">>>" + taskNum + "任务终止");
return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";
}
//实现call()方法，作为线程执行体
/* public Integer call(){
int i = 5;
for( ; i<100 ; i++){
System.out.println(Thread.currentThread().getName() + "的循环变量i的值：" +i);
}
//call()方法可以有返回值
return i;
}
public static void main(String[] args) {
//创建Callable对象
Callable cd = new MyCallable();
//使用FutureTask来包装Callable对象
FutureTask<Integer> task = new FutureTask<Integer>(cd);
for(int i=0 ; i<100 ; i++){
System.out.println(Thread.currentThread().getName() + "的循环变量i的值：" +i);
if(i==20){
//实质还是以Callable对象来创建并启动线程
new Thread(task,"有返回值的线程").start();
}
}
try{
System.out.println("子线程的返回值" + task.get());
}catch(Exception e){
e.printStackTrace();
}
*/
}
/**
* @author yto_yh
*
*/
public class Test0903 {
/**
* @param args
* @throws ExecutionException
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException, ExecutionException {
// TODO Auto-generated method stub
System.out.println("----程序开始运行----");
Date date1 = new Date();
int taskSize = 5;
// 创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(taskSize);
// 创建多个有返回值的任务
List<Future> list = new ArrayList<Future>();
for (int i = 0; i < taskSize; i++) {
Callable c = new MyCallable(i + " ");
// 执行任务并获取Future对象
Future f = pool.submit(c);
// System.out.println(">>>" + f.get().toString());
list.add(f);
}
// 关闭线程池
pool.shutdown();
// 获取所有并发任务的运行结果
for (Future f : list) {
// 从Future对象上获取任务的返回值，并输出到控制台
System.out.println(">>>" + f.get().toString());
}
Date date2 = new Date();
System.out.println("----程序结束运行----，程序运行时间【"
+ (date2.getTime() - date1.getTime()) + "毫秒】");
}
}
7. 常用的字节流和字符流以及之间的区别 3
写出常见的字节流和字符流；
字节流：InputStream: FileInputStream/ObjectInputStream/filterInputStream
OutputStream: FileInputStream/ObjectInputStream/filterInputStream
字符流：Reader: FileReader/StringReader/filterReader/InputStreamReader
Writer: FileWriter/StringWriter/filterWriter/OutputStreamWriter
字节流操作的基本单元为字节；字符流操作的基本单元为Unicode码元。
字节流默认不使用缓冲区；字符流使用缓冲区。
字节流通常用于处理二进制数据，实际上它可以处理任意类型的数据，但它不支持直接写入或读取Unicode码元；字符流通常处理文本数据，它支持写入及读取Unicode码元。
8. 三次握手四次挥手、TCP与UDP的区别 3
三次握手的目的是建立可靠的通信信道，就是双方确认自己与对方的发送与接收机能正常。
四次挥手的目的是一方发送FIN只表示自己发完了所有要发的数据，但还允许对方继续把没发完的数据发过来。
TCP:面向连接、提供可靠的服务、对系统资源要求较多、连接只能是点到点的。
UDP:无连接、尽最大努力交付、具有较好的实时性、UDP对系统资源要求较少、支持一对一，一对多，多对一和多对多的交互通信。
9. （抽象）工厂模式以及单例模式实现方式 3
常用的模式：工厂模式、抽象工厂模式、单例模式、代理模式、策略模式
工厂模式：建造简单工厂类，根据传递参数的不同实例化对应的对象。
抽象工厂模式：建立超级工厂其中包含简单工厂类，先选择调用的工厂再选择实例化的对象。
单例模式：
懒汉式--线程不安全
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
懒汉式--线程安全
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
饿汉式--线程安全
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
双检锁/双重校验锁（DCL，即 double-checked locking） ---线程安全
public class Singleton {
private volatile static Singleton singleton;
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
return singleton ;
}
return null;
}
}
登记式/静态内部类 ---线程安全
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
枚举 ---线程安全
public enum Singleton {
INSTANCE;
public void whateverMethod() {
}
}
10. 选择 、插入、冒泡、递归的实现方式 5
public static void swap(int []arr,int a,int b){
arr[a] = arr[a]+arr[b];
arr[b] = arr[a]-arr[b];
arr[a] = arr[a]-arr[b];
}
插入：
public static void insertionSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int j = i;
while (j > 0 && arr[j] < arr[j - 1]) {
swap(arr,j,j-1);
j--;
}
}
}
选择：
public static void selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int min = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[min]) {
min = j;
}
}
if (min != i) {
swap(arr,min,i);
}
}
}
冒泡：
public static void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
swap(arr,j,j+1);
}
}
}
}
递归之-
. 阶乘
public static long f(int n){
if(n == 1) // 递归终止条件
return 1; // 简单情景
return n*f(n-1); // 相同重复逻辑，缩小问题的规模
}
.斐波纳契数列
public static int fibonacci(int n) {
if (n == 1 || n == 2) { // 递归终止条件
return 1; // 简单情景
}
return fibonacci(n - 1) + fibonacci(n - 2); // 相同重复逻辑，缩小问题的规模
}
杨辉三角的取值
public static int getValue(int x, int y) {
if(y <= x && y >= 0){
if(y == 0 || x == y){ // 递归终止条件
return 1;
}else{
return getValue(x-1, y-1) + getValue(x-1, y);
}
}
return -1;
}
汉诺塔问题
public static void moveDish(int level, char from, char inter, char to) {
if (level == 1) { // 递归终止条件
System.out.println("从" + from + " 移动盘子" + level + " 号到" + to);
} else {
moveDish(level - 1, from, to, inter); // 递归调用，缩小问题的规模
System.out.println("从" + from + " 移动盘子" + level + " 号到" + to);
moveDish(level - 1, inter, from, to); // 递归调用，缩小问题的规模
}
}
11. XML 和 JSON的格式和特点以及json 的转义方式 7
XML 主要用于对有特定意义的数据保存或者传递,自带描述性并具有结构化的文本。
XML特点：存储性、传递性、共享性、数据有用性
DTD(Document Type Defination), XSD(XML Schema Definition)就是对属性文件的约束。
JSON(JavaScript Object Notation(JavaScript 对象表示法):JSON 是存储和交换文本信息的语法，类似 XML,是轻量级的文本数据交换格式.
JSON 比 XML(1)更小、(2)更快，(3)更易解析，(4)更直观的了解数据。
JSON对象类型：前面永远为 String字符串类型 ,后面可以为（string number object array true false null）
转String：var strUser = JSON.stringify(user);
转对象：var user = JSON.parse(strUser);
12. 国际化和Tomcat配置文件信息 7
Internationalization=I18N,国际化:是使产品或软件具有不同国际市场的普遍适应性，从而无需重新设计 就可适应多种语言和文化习俗的过程。
Globalization=G11N ,全球化：是使产品或软件进入全球市场而进行的有关的商务活动.
Localization=L10N ,本地化：是将产品或软件针对特定国际语言和文化进行加工，使之符合特定区域市场的过程。
Tomcat 是由 Apache 开发的一个 Servlet 容器，实现了对 Servlet 和 JSP 的支持，并提供了作为Web服务器的一些特有功能。
在Tomcat中有四种部署Web应用的方式，分别是：
1.利用Tomcat自动部署
2.利用控制台进行部署
3.增加自定义的Web部署文件 (%Tomcat_Home%\conf\Catalina\localhost\AppName.xml)
4.手动修改%Tomcat_Home%\conf\server.xml文件来部署web应用(此方法即打开%Tomcat_Home%\conf\server.xml文件并在其中增加以下元素：<Context docBase="D:\workspace\WebApp\AppName" path="/XXX" debug="0" reloadable="false" /> 然后启动Tomcat即可。 )
Tomcat一次完整的http请求：
建立TCP连接；
web浏览器向Web服务器发送请求命令
Web浏览器发送请求头信息
Web服务器应答
Web服务器发送应答头信息
Web服务器向浏览器发送数据
Web服务器关闭TCP连接
13. SQL基本增改删查、增加/删除列等 8
https://blog.csdn.net/qq_37722734/article/details/82659116
SQL (Structured Query Language) 指结构化查询语言.
三大范式：
1NF是数据表中的每一列（每个字段）必须是不可拆分的最小单元
满足1NF后，要求表中的所有列，都必须依赖于主键
满足2NF后，表中的每一列只与主键直接相关而不是间接相关
常用的SQL约束：
NOT NULL约束 - 确保列不能有NULL值
默认值约束 - 提供未指定时为列的值时的默认值
唯一值约束 - 确保了在一列中的所有的值是唯一的
主键 - 唯一标识数据库表中的每一行/记录
外键 - 唯一标识任何其他数据库表中的行/记录
检查约束 - CHECK约束可以确保列中的所有值满足一定的条件
索引 - 使用非常快速地创建和检索数据库中的数据。
SQL 能做什么？
执行查询、取回数据、插入新的记录、更新数据库中的数据、删除记录、创建新数据库、在数据库中创建新表、存储过程、视图
设置表、存储过程和视图的权限
DDL - 数据定义语言：CREATE、ALTER、DROP
CREATE DATABASE - 创建新数据库
ALTER DATABASE - 修改数据库
CREATE TABLE - 创建新表
ALTER TABLE - 变更（改变）数据库表
DROP TABLE - 删除表
CREATE INDEX - 创建索引（搜索键）
DROP INDEX - 删除索引
DML - 数据操纵语言：SELECT、INSERT、UPDATE、DELETE
SELECT - 从数据库表中获取数据
UPDATE - 更新数据库表中的数据
DELETE - 从数据库表中删除数据
INSERT INTO - 向数据库表中插入数据
DCL - 数据控制语言：GRANT、 REVOKE
创建/删除数据库：CREATE DATABASE DatabaseName;
DROP DATABASE DatabaseName;
创建/删除表：CREATE TABLE table_name(
column1 INT auto_increment CHECK (AGE >= 18),
column2 INT NOT NULL UNIQUE,
columnN VARCHAR(20) DEFAULT “man”,
PRIMARY KEY(column1 )
);
DROP TABLE table_name;
查询：SELECT column1, column2, columnN FROM table_name;
SELECT * FROM table_name [WHERE CONDITION];
WHERE条件：>, <, =,LIKE(%/_),NOT,AND,OR,IN,BETWEEN
其他条件： TOP NUM, LIMIT NUM1, NUM2,ROWNUM NUM、ORDER BY [ASC | DESC], GROUP BY, DISTINCT、HAVING
实用函数： COUNT()、MAX()、MIN()、AVG()、SUM()、SQRT()、RAND()、CONCAT()、 Numeric()、String()
插入：INSERT INTO table_name( column1, column2,columnN)
VALUES ( value1, value2,valueN);
更新：UPDATE table_name
SET column1 = value1,columnN=valueN
[ WHERE CONDITION ];
删除：DELETE FROM table_name
WHERE {CONDITION};
增加/删除列：ALTER TABLE [表名] ADD [字段名] NVARCHAR (50) NULL
ALTER TABLE [表名] DROP COLUMN [字段名]
14. JSP/JS/AJAX/Cookie/HTML/CSS 10
Cookie与Session的区别：
cookie是存储在本地浏览器，而session存储在服务器。
存储在服务器的数据会更加的安全，不容易被窃取。但存储在服务器也有一定的弊端，就是会占用服务器的资源。
session 能够存储任意的 java 对象，cookie 只能存储 String 类型的对象。
最基本的HTML登录界面：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Login</title>
<!-- <link rel="stylesheet" type="text/css" href="Login.css"/> -->
<Style type="text/css">
html{
width: 100%;
height: 100%;
overflow: hidden;
font-style: sans-serif;
}
body{
width: 100%;
height: 100%;
font-family: ‘Open Sans‘,sans-serif;
margin: 0;
background-color: #4A374A;
}
#login{
position: absolute;
top: 50%;
left:50%;
margin: -150px 0 0 -150px;
width: 300px;
height: 300px;
}
#login h1{
color: #fff;
text-shadow:0 0 10px;
letter-spacing: 1px;
text-align: center;
}
h1{
font-size: 2em;
margin: 0.67em 0;
}
input{
width: 278px;
height: 18px;
margin-bottom: 10px;
outline: none;
padding: 10px;
font-size: 13px;
color: #fff;
text-shadow:1px 1px 1px;
border-top: 1px solid #312E3D;
border-left: 1px solid #312E3D;
border-right: 1px solid #312E3D;
border-bottom: 1px solid #56536A;
border-radius: 4px;
background-color: #2D2D3F;
}
.but{
width: 300px;
min-height: 20px;
display: block;
background-color: #4a77d4;
border: 1px solid #3762bc;
color: #fff;
padding: 9px 14px;
font-size: 15px;
line-height: normal;
border-radius: 5px;
margin: 0;
}
</Style>
</head>
<body>
<div id="login">
<h1>Login</h1>
<form method="post">
<input type="text" required="required" placeholder="用户名" name="u"></input>
<input type="password" required="required" placeholder="密码" name="p"></input>
<button class="but" type="submit">登录</button>
</form>
</div>
</body>
</html>
AJAX:
$("#submit").click(function(){
$.ajax({
url:"${pageContext.request.contextPath}/userLogin",
type:"post",
cache: false,
processData:false,
contentType:false,
data:form,
success:function(data){
var jsonData = JSON.parse(data);
alert("登陆状态:"+jsonData.message);
if("success"==jsonData.message){
window.location.href="${pageContext.request.contextPath}/doGetList?pageNow=1";
console.log("over……");
}else{
$("#message").html("登陆用户名或密码错误");
console.log("失败……");
}
},
error: function(XMLHttpRequest, textStatus){
console.log(XMLHttpRequest);
console.log(textStatus);
}
});
});
15. 文件/文件夹创建和遍历 11
File path;
File[] files;
List<String> pathName=new ArrayList<String>();
//递归遍历文件夹
public void iteratorPath(String dir) {
path=new File(dir);
files=path.listFiles();
if(files!=null) {
for(File file:files) {
if (file.isFile()) {
pathName.add(file.getPath()+""+file.getName());
}else if(file.isDirectory()) {
iteratorPath(file.getAbsolutePath());
}
}
}
}
//创建文件夹
public String CreateIteratorPath(String dir) {
path=new File(dir);
if (!path.exists()) {
path.mkdirs();
}
return path.getAbsolutePath();
}
16.JDK基本组件包括：
javac – 编译器，将源程序转成字节码
jar – 打包工具，将相关的类文件打包成一个文件
javadoc – 文档生成器，从源码注释中提取文档
17. maven的好处：
1）项目依赖被统一管理，不容易出现依赖冲突。
2）项目体积变小，Maven项目只需要一个pom.xml文件就搞定了
18.在Gitlab中创建新项目时，需要对不同的使用者赋予不同的使用权限：
角色
权限
描述
PMO
Owner
项目拥有者，包括项目的所有权限
项目经理/
开发负责人
Master
可以更改Master分支的代码
开发
Developer
只能修改Develop分支的代码，不允许修改Master的代码
测试
Reporter
不允许修改代码，可以查阅、拉取代码或提交问题
集成
Reporter
不允许修改代码，可以查阅，拉取代码或提交问题
19.5个常用包、类、接口、设计模式
包：java.lang java.util java.sql java.io java.awt javax.servlet javax.swing
接口：collection Iterator list set map Runnable HttpSession HttpServletRequest HttpServletResponse
类：基本类型封装类（Integer/Double/Boolean/Float/Character）、集合类（ArrayList/HashMap/HashSet）
————————————————
版权声明：本文为CSDN博主「丨一笑丶奈何」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_37722734/java/article/details/82380009
本人只是保留可靠的文件，下载此文章别无它意(很难找到这么好的文章了)
原文：https://www.cnblogs.com/Fengwb/p/13042023.html