目录
11. XML 和 JSON的格式和特点以及json 的转义方式 7
14. JSP/JS/AJAX/Cookie/HTML/CSS 10
16.JDK基本组件包括
17.maven的好处
18.Gitlab权限说明
面向对象程序设计：将一个对象的特征和行为抽象成属性和方法封装在类中，并利用多个对象之间的交互通信形成程序。
三大特性：
封装：将一个对象的特征和行为抽象成属性和方法封装在类中。
继承：子类继承父类的属性和方法，即子承父业。
多态：通过父类调用子类方法，即同一消息可以根据发送对象的不同而采用多种不同的行为方式。
六大原则：
单一职责原则：一个类，最好只做一件事，只有一个引起它的变化。
开放封闭原则(OCP)：软件的功能应该是可扩展的，而尽可能的不修改。
里氏（Liskov）替换原则(LSP)：子类必须能够替换基类。
依赖倒置原则(DIP):依赖于抽象，即高层模块不依赖底层模块，二者都通依赖于抽象。/客户类和服务类都应该依赖于抽象（接口），并且客户类拥有接口。
接口隔离原则：使用多个小的专门的接口，而不要使用一个大的总接口。
合成复用原则（Composite Reuse Principle）：原则是尽量首先使用合成/聚合的方式，而不是使用继承
8种基本数据类型：byte、short、char、int、long、float、double、boolean
变量定义格式：(1)以字母（A-Z或者a-z）,美元符（$）、或者下划线（_）开始;
（2)关键字不能用作标识符;
(3)标识符是大小写敏感的
类型转换：从低级到高级-----自然转换，反向要强制类型转换。可能精度损失，舍弃小数变整型。
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);
}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"));
}
}
}
异常事件的分类：
Error： Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等。
Exception分两种：
编译时异常：ClassNotFoundException(没找到类)、FileNotFoundException(文件没找到)、SQLException(数据库异常)
运行时异常：ArrayIndexOutOfBoundsException(数组越界异常)、
ClassCastException(类转换异常)、NullPointerException(空指针异常)、
ArithmeticException(算法异常)、ClassCastException(类转换异常)
异常处理方式：(1)throws方法头部抛出异常；(2)throw在方法内部抛出异常；(3)通过try-catch-finally语句实现
线程的生命周期：创建、就绪、运行、阻塞、死亡
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()) + "毫秒】");
}
}
- 写出常见的字节流和字符流；
字节流：InputStream: FileInputStream/ObjectInputStream/filterInputStream
OutputStream: FileInputStream/ObjectInputStream/filterInputStream
字符流：Reader: FileReader/StringReader/filterReader/InputStreamReader
Writer: FileWriter/StringWriter/filterWriter/OutputStreamWriter
- 字节流操作的基本单元为字节；字符流操作的基本单元为Unicode码元。
- 字节流默认不使用缓冲区；字符流使用缓冲区。
- 字节流通常用于处理二进制数据，实际上它可以处理任意类型的数据，但它不支持直接写入或读取Unicode码元；字符流通常处理文本数据，它支持写入及读取Unicode码元。
三次握手的目的是建立可靠的通信信道，就是双方确认自己与对方的发送与接收机能正常。
四次挥手的目的是一方发送FIN只表示自己发完了所有要发的数据，但还允许对方继续把没发完的数据发过来。
TCP:面向连接、提供可靠的服务、对系统资源要求较多、连接只能是点到点的。
UDP:无连接、尽最大努力交付、具有较好的实时性、UDP对系统资源要求较少、支持一对一，一对多，多对一和多对多的交互通信。
常用的模式：工厂模式、抽象工厂模式、单例模式、代理模式、策略模式
工厂模式：建造简单工厂类，根据传递参数的不同实例化对应的对象。
抽象工厂模式：建立超级工厂其中包含简单工厂类，先选择调用的工厂再选择实例化的对象。
单例模式：
懒汉式--线程不安全
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() {
}
}
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);
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连接
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:'demo.php',
type:"POST",
data:$('#form').serialize(),
success: function(data) {
$("#result").text(data);
}
});
});
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 |
不允许修改代码，可以查阅，拉取代码或提交问题 |