Java概述
Java特点
跨平台性（一次编写到处执行的特点）
完全面对对象
分布式（支持对Internet应用的开发）
可移植性
多线程（支持多个线程同时执行）
安全性（Java提供一种安全级管理机制）
Java运行时环境(JRE)。它包括Java虚拟机、Java核心类库和支持文件。它不包含开发工具（JDK）–编译器、调试器和其他工具。
Java开发工具包(JDK)是完整的Java软件开发包，包含了JRE，编译器和其他的工具(比如：JavaDoc，Java调试器)，可以让开发者开发、编译、执行Java应用程序
面对对象
面向对象：
把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象。对同类对象抽象出其共性，形成类。类中的大多数数据，只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。
面向过程就是：
自顶向下顺序执行，逐步求精；其程序结构是按功能划分为若干个基本模块，这些模块形成一个树状结构；各模块之间的关系尽可能简单，在功能上相对独立；每一模块内部均是由顺序、选择和循环三种基本结构组成；其模块化实现的具体方法是使用子程序。程序流程在写程序时就已决定。
面向过程（POP）是分析解决问题的步骤，然后用函数把这些步骤一步一步的实现，然后在使用的时候一一调用则可。
面向对象（OOP）是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是为了描述某个事物在解决整个问题的过程中所发生的行为。下面举一例说明面向过程和面向对象编程。
面向服务（SOA）是一种进行系统开发的新的体系架构。在基于SOA架构的系统中，具体应用程序的功能是由一些松耦合并且具有统一接口定义方式的组件(也就是Service)组合构建起来的，它对迅速变化的业务环境具有良好适应力。
三大基本特征：封装、继承、多态
1、封装
2、继承
3、多态
五大基本原则
1、单一职责原则（SRP）
2、开放封闭原则（OCP）
3、里氏替换原则（LSP）
4、依赖倒置原则（DIP）
5、接口隔离原则（ISP）
三大特性
封装
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
优点：只能通过规定的方法访问数据。 隐藏类的实例细节，方便修改和实现。
把数据项和方法隐藏在对象的内部，把方法的实现内容隐藏起来。
为实现基本数据类型到面对对象的转化，Java提供了每个基本数据类型提供了对应的包装类字符串实际上是String类的实例对象，是引用类型，String类是final修饰的类，三种创建方式
A，java中的字符串存储在字符串常量区，不会改变，发生改变是会新创建一个对象
B，StringBuffer是线程安全的StringBuilder不是
C，StringBuilder跟StringBuffer功能相同，区别是StringBuilder不是线程安全的
D，StringBuilder和StringBuffer底层都是以字符数组存放的，可以修改内容
封装
类Double，Integer，Float，Byte，Long，Character，short，Boolean。
Java中实现了自动装包和拆包来完成基本数据类型与包装对象的转换
Java提供构造方法，析构方法，方法重载，设置访问控制权限等措施对类进行封装
继承
继承是类与类的一种关系，子类拥有父类的所有属性和方法（除了private修饰的属性不能拥有）从而实现了实现代码的复用。由继承派生类
方法的重写（全部重写为覆盖）：重新实现基类中的方法。
继承的初始化顺序:
1、初始化父类再初始化子类
2、先执行初始化对象中属性，再执行构造方法中的初始化。
final关键字
使用final关键字做标识有“最终的”含义。
- final 修饰类，则该类不允许被继承。
- final 修饰方法，则该方法不允许被覆盖(重写)，允许重载。
- final 修饰属性，则该类的该属性不会进行隐式的初始化，所以 该final 属性的初始化属性必须有值，或在构造方法中赋值(但只能选其一，且必须选其一，因为没有默认值！)，且初始化之后就不能改了，只能赋值一次。
- final 修饰变量，则该变量的值只能赋一次值，在声明变量的时候才能赋值，即变为常量。
super关键字
在对象的内部使用，可以代表父类对象。
1、访问父类的属性：super.age
2、访问父类的方法：super.eat()
多态
多态就是对象的多种形态
1.引用多态
父类的引用可以指向本类的对象；编译时多态
父类的引用可以指向子类的对象；运行时多态
2.方法多态
根据上述创建的两个对象：本类对象和子类对象，同样都是父类的引用，当我们指向不同的对象时，它们调用的方法也是多态的。
创建本类对象时，调用的方法为本类方法；
创建子类对象时，调用的方法为子类重写的方法或者继承的方法；
使用多态的时候要注意：如果我们在子类中编写一个独有的方法（没有继承父类的方法），此时就不能通过父类的引用创建的子类对象来调用该方法！！！
注意： 继承是多态的基础。
Java中使用重载和重写机制实现多态。
多态类型
引用类型转换
instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题
抽象类
定义：抽象类前使用abstract关键字修饰，则该类为抽象类。
使用抽象类要注意以下几点：
- 抽象类是约束子类必须有什么方法（抽象方法），而并不关注子类如何实现这些方法。
- 抽象类应用场景：
a. 在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法(可实现动态多态)。
b. 从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免子类设计的随意性。 - 抽象类定义抽象方法，只有声明，不需要实现。抽象方法没有方法体以分号结束，抽象方法必须用abstract关键字来修饰。
- 包含抽象方法的类是抽象类。抽象类中可以包含普通的方法，也可以没有抽象方法。
- 抽象类不能直接创建，可以定义引用变量来指向子类对象，来实现抽象方法。
接口
接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成。也可理解为一个特殊的抽象类，因为它含有抽象方法。
如果说类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供的某些方法。（这里与抽象类相似）
接口是把多个继承类的公共对象抽象出来并封装这些公共对象的行为。接口继承描述了一个对象在什么时候可以被用来替代另一个对象
接口中的属性都是常量，即使定义时不添加public static final 修饰符，系统也会自动加上；接口中的方法都是抽象方法，即使定义时不添加public abstract修饰符，系统也会自动加上。
注意：如果要继承父类，继承父类必须在实现接口之前,即extends关键字必须在implements关键字前
注意:
1）接口不能有构造方法，抽象类可以有。
2）接口不能有方法体，抽象类可以有。
3）接口不能有静态方法，抽象类可以有。
4）在接口中凡是变量必须是public static final，而在抽象类中没有要求。
5）接口中的成员变量和成员方法只能是public(或缺省不写也表示public）
五大原则
单一职责原则SRP(Single Responsibility Principle)
是指一个类的功能要单一，不能包罗万象。
开放封闭原则OCP(Open－Close Principle)
一个模块在扩展性方面应该是开放的,而在更改性方面应该是封闭的。
比如：一个网络模块，原来只服务端功能，而现在要加入客户端功能，那么应当在不用修改服务端功能代码的前提下，就能够增加客户端功能的实现代码
这要求在设计之初，就应当将服务端和客户端分开，公共部分抽象出来。
替换原则(the Liskov Substitution Principle LSP)
子类应当可以替换父类并出现在父类能够出现的任何地方。
比如：公司搞年度晚会，所有员工可以参加抽奖，那么不管是老员工还是新员工，也不管是总部员工还是外派员工，都应当可以参加抽奖，否则这公司就不和谐了。
依赖原则(the Dependency Inversion Principle DIP)
具体依赖抽象，上层依赖下层。
假设B是较A低的模块，但B需要使用到A的功能，这个时候，B不应当直接使用A中的具体类： 而应当由B定义一抽象接口，并由A来实现这个抽象接口，B只使用这个抽象接口： 这样就达到了依赖倒置的目的，B也解除了对A的依赖，反过来是A依赖于B定义的抽象接口。
通过上层模块难以避免依赖下层模块，假如B也直接依赖A的实现，那么就可能造成循环依赖。
接口分离原则(the Interface Segregation Principle ISP)
模块间要通过抽象接口隔离开，而不是通过具体的类强耦合起来
Java核心机制
JDBC数据库连接
JSP
java Server page java服务网页
servlet 小服务程序
JSP需要服务器先翻译成Servlet文件，然后编译成.class文件
JavaBean
JavaBean是一种Java语言写成的可重用组件，其他Java类可以通过自省机制（反射机制）发现和操作这些JavaBean的属性
JavaMail
Java平台(JRE)
Java虚拟机(JVM)
JVM体系结构：
类装载子系统 执行引擎子系统 本地方法接口 运行时数据区
运行数据区:JVM的内存，包括堆，栈，方法区，程序计数器，本地方法栈
Java字节码是在JRE中执行(JRE：Java运行环境) JVM是JRE中的核心组成部分，承担分析和执行字节码的工作。
JVM通过类加载器加载Java应用，并通过Java API进行执行
源文件由编译器编译成字节码(.class)---->字节码由java虚拟机解释运行(.java)。
类加载器
类加载器就是加载字节码文件(.class)
类的加载是由类加载器完成的，类加载器包括：根加载器（ BootStrap ）、扩展加载器（ Extension ）、系统加载器（ System ）和用户自定义类加载器（ java.lang.ClassLoader 的子类）
==Bootstrap ：一般用本地代码实现，负责加载 JVM 基础核心类库（ rt.jar ）；
Extension(ExtClassLoader) ：从 java.ext.dirs 系统属性所指定的目录中加载类库，它的父加载器是 Bootstrap ；
system class loader(APPClassLoader) ：又叫应用类加载器，其父类是 Extension 。它是应用最广泛的类加载器。它从环境变量 classpath 或者系统属性 java.class.path 所指定的目录中记载类，是用户自定义加载器的默认父加载器。
用户自定义类加载器： java.lang.ClassLoader 的子类 ==
引导类加载器(bootstrap class loader):它用来加载 Java 的核心库,是用原生代码来实现的
扩展类加载器(extensions class loader):它用来加载 Java 的扩展库。
系统类加载器(system class loader):它根据 Java 应用的类路径(CLASSPATH)来加载 Java 类
tomcat 为每个 App 创建一个 Loader,里面保存着此 WebApp 的 ClassLoader。需要加载 WebApp 下的类时,就取出 ClassLoader 来使用
JVM的编译器(javac编译)
反射通过字节码对象操纵字节码内部的方法和字段
获得字节码对象：
- Class.forName()
- 对象.getClass()
- 类名.class
获得类加载器
ClassLoader 字节码对象.getClassLoader();
JVM的基本特性
基于栈(Stack-based)的虚拟机: 不同于Intel x86和ARM等比较流行的计算机处理器都是基于寄存器(register)架构，JVM是基于栈执行的。
符号引用(Symbolic reference): 除基本类型外的所有Java类型(类和接口)都是通过符号引用取得关联的，而非显式的基于内存地址的引用。
垃圾回收机制(GC:Garbage Collection): 类的实例通过用户代码进行显式创建，但却通过垃圾回收机制自动销毁。
java语言采用JVM自动垃圾回收机制来清理对象。JVM按照某种策略（如定时，内存使用情况）使用垃圾回收机（GC），自动回收系统中不再使用的对象。
Java语言提供垃圾回收机制，他可以回收那些不在被使用的对象，以释放内存空间，但也会存在编程导致的内存泄漏。通常是不在使用的对象，但程序又对该对象又引用，侧导致对象无法被回收。所有Java中存在内存泄漏
什么是堆内存？什么是栈内存？有什么区别？
答：Java的内存空间分为堆内存和栈内存。栈内存用于存储定义的基本类型变量、函数返回值、对象的引用等，而堆内存用于存放new出来的一切对象。
自动内存管理机制
Java应用程序接口(API)
后缀:java 表示核心包 javax 表示扩展包
java.lang 包括基本类和核心类String Math Integer System Runtime包中所有类默认导入
java.awt java.awt.event javax.swing包含一些编写图形界面（GUI）应用程序的类
java.until 包含一些实用工具类和数据结构类
java.io包含一些做输入输出处理的类
java.net包含用于建立网络连接的类，与java.io同时使用
Java语法基础
数据类型
byte：1字节 -2的8----2的8次方-1次方 默认值0
boolean：1字节 false true 默认值false
short：2字节 -2的16次方----2的十六次方 默认值0
char：2字节 ‘\u0000’~’\uffff’(16进制数) 默认值’\u0000’
int：4字节 -2的32次方—2的32次方 默认值0
float：4字节 -3.4E38—3.4E38 默认值0.0f
long：8字节 -2的64次方—2的64次方-1 默认值0L
double：8字节 -1.7E308—1.7E308 默认值0.0d
正则表达式
正则表达式贪婪与非贪婪模式
之前做程序的时候看到过正则表达式的贪婪与非贪婪模式，今天用的时候就想不起来了，现在这里总结一下，以备自己以后用到注意。
1.什么是正则表达式的贪婪与非贪婪匹配
如：String str=“abcaxc”;
Patter p=“ab.*c”;
贪婪匹配:正则表达式一般趋向于最大长度匹配，也就是所谓的贪婪匹配。如上面使用模式p匹配字符串str，结果就是匹配到：abcaxc(ab.*c)。
非贪婪匹配：就是匹配到结果就好，就少的匹配字符。如上面使用模式p匹配字符串str，结果就是匹配到：abc(ab.*c)。
2.编程中如何区分两种模式
默认是贪婪模式；在量词后面直接加上一个问号？就是非贪婪模式。
量词：{m,n}：m到n个
*：任意多个
+：一个到多个
？：0或一个
.*？非贪婪
(?=Expression) 顺序环视
其他略
面向对象编程
什么叫面向对象？
面向对象编程OOP技术：程序就是许多对象在计算机中表现自己，而对象则是一个个程序实体，对象具有属性和和行为能力
类是抽象的概念，用于创建对象，对象是类的实例，是存在的实体
this关键字
（1）指代对象
用于指代调用成员方法的当前对象本身
（2）访问本类的成员方法和成员变量（区分实例变量和局部变量）
（3）调用本类重载的构造方法
对象的关系运算和比较相等
== =！比较两个对象是否引用一个实例
equals()方法用于比较两个对象是否相等（拷贝相等）
instanceof判断一个对象所引用的实例是否属于指定类
类和类成员访问权限
类访问权限:public,default 被任何包的类访问；本包类访问
类成员访问权限：
| 成员修饰符 | 类自己 | 相同包 | 不同包的子类 | 任意类 |
|---|---|---|---|---|
| public | Y | Y | Y | Y |
| protected | Y | Y | Y | N |
| default | Y | Y | N | N |
| private | Y | N | N | N |
static关键字
1.静态属性
static修饰类的成员和方法后，成为类成员和类方法，该类所有实例的共享，不依赖于某个对象而存在，实际上就是一个共享的变量，被多个对象共享，可以通过类名直接调用
2.静态方法中只能访问静态变量和局部变量，不能访问类的属性，不能被覆盖
3.静态块初始化
static{}
先执行静态块或静态属性的初始化，然后执行实例化对象。
被static修饰的变量称为静态变量，静态变量属于整个类，而局部变量属于方法，只在该方法内有效，所以static不能修饰局部变量
static块保证执行一次：
类加载时执行，类是由类加载器读取，类加载器带有一个缓冲区把读取到的static缓存起来，在虚拟机运行期间，一个类只能被加载一次
内部类
实例内部类
局部内部类
静态内部类
匿名内部类
return new 继承的类
反射
Java程序运行时可以动态加载解析和使用一些在编译阶段并不确定的类型，这一机制称为反射或内省
在运行过程中，对于任何一个类，能够获取这个类的所有属性和方法，对于一个对象，能够调用它的任何一个方法和属性，这种动态获取的信息以及动态调用信息的方法的功能就成为Java的反射机制。
通过getClass forName .class方法获取一个对象的反射类
例子：spring的IOC(控制反转)/DI(依赖注入)
javaBean和 jsp之间的调用
作用：在运行期间获取对象的类型信息，利用这一特性可以实现设计模式和代理模式等工作模式
集合框架
集合框架接口:
Collection接口
1.Set(集) SortSet
2.List(列表)
3.Map(映射) SortedMap
| 接口 | 一维数组 | 循环双链表 | 平衡二叉树 | 散列表 |
|---|---|---|---|---|
| List列表 | ArrayList 不支持同步，Vector支持同步 | LinkedList | ||
| Set集合 | LinkedHashSet | TreeSet | HashSet | |
| Map映射 | LinkedHashMap | TreeMap | HashMap |
集合实现类
Collection-<HashSet(Set)-<TreeSet(SortSet)-<LinkedList,Vector,ArrayList(List)
HashTable HashMap(Map)-<TreeMap(SortMap)
ArrayList底层使用数组作为容器，类似数据结构的顺序表。插入删除需要移动大量元素
LinkedList底层使用双向链表作为容器，类十余数据结构中的双向链表。获取元素耗时。
ArrayList是一个动态的数组结构，而LinkedList是双向链表结构；存取数据的时候，ArrayList更适合按位随机存取，而LinkedList更适合顺序读存取；插入/删除数据时，ArrayList的开销就比LinkedList更大，因为对于ArrayList，插入/删除一个数据时需要移动其后所有数据，而LinkedList只需要修改几个指针即可。
输出ArrayList所有元素
for循环 Foreach 迭代器Iterator
HashSet类是使用HashMap类的对象实现的
HashMap的本质仍然是数组，不过数组中存储的不是数据，而是一个链表的头节点。所以准确的说，其实现就是链表数组。HashMap中保存的是一个键值对，插入对象时必须提供一个键对象；查找对象时必须给定一个键对象（因此必须记住键）。键对象时不允许重复的，但是允许null空键的存在。
HashMap插入对象时，根据给定的键key计算hashcode，然后再与数组长度进行求余运算得到数组下标。然后与该位置上的链表中已存储的键进行比较，对于已存在的键，则覆盖；对于不存在的键，则添加到链表尾。
Set和List接口的实现类可以保存null元素，仅能保存一个
Map接口 keySet()方法用于获取键的集合，返回值Set型，size()方法获取当前映射包含的键值对数量
HashMap不支持同步，线程不安全，Hashtable支持同步，线程安全
异常
Error：JVM错误，不可恢复，只能终止程序
Exception：编程错误
throw：抛出异常类对象
throws方法声明抛出异常的throws子句
流
字节流
FileInputStream
BufferedInputStream
DataInputStream
字符流
FileReader
BufferedReader
字节字符转换流
InputStreamReader
eg:
FileInputStream fis = new FileInputStream(“D:\file.txt”); 字节流
InputStreamReader isr = new InputStreamReader(fis);字节字符转换流
BufferedReader br = new BufferedReader(isr);字符流
FileOutputStream fos = new FileOutputStream(“D:\file.txt”);
OutputStreamWriter isr = new OutputStreamWriter(fis);
BufferedWriter bw = new BufferedWriter(fos);
线程
线程的创建，一是继承java.lang.Thread类，二是实现java.lang.Runnable接口
线程各个状态：
NEW 创建态
------------------------------------BLOCKED阻塞态
RUNNABLE 运行态 ---------WAITING等待态
------------------------------------TIMED_WAITING计时等待状态
TERMINATED终止态
线程属性：
ID属性 Name属性 Priority线程优先级属性 Daemon是否守护线程属性
线程停止
转换为等待态：sleep()方法，另一个优先级更高线程处于运行状态，执行I/O流方法
转换为终止态：抛出中断异常
join()等待调用该方法的线程终止
notify()唤醒在此对象监视器上等待的单个线程All全部
wait()线程处于等待状态，知道其他线程调用此对象的notify()方法
synchronized修饰方法或修饰代码块。创建同步方法。每次保证只有一个线程进入方法和对象
volatile关键字 实现同步
sleep()和wait()方法区别
在调用sleep()方法的过程中，线程不会释放对象锁。
而当调用wait()方法的时候，线程会放弃对象锁
死锁：资源竞争，彼此需要对方的资源，资源的请求设释放顺序不当
解决方法：破坏循环等待
计算机系统中的死锁
1.竞争不可抢占性资源引起死锁
2.竞争可消耗资源引起死锁
3.进程推进顺序不当引起死锁
产生死锁的必要条件
1.互斥条件
2.请求和保持条件
3.不可抢占条件
4.循环等待条件
处理死锁的方法
1.预防死锁
2.避免死锁
3.检测死锁
4.解除死锁
预防死锁（主要是破坏产生死锁的后三个条件）
1.破坏‘请求和保持’条件
2.破坏‘不可抢占条件’条件
3.破坏‘循环等待’条件
Executors类用于创建线程池
Swing不是线程安全的
线程和进程的区别？
（1）进程是资源的分配和调度的一个独立单元，而线程是CPU调度的基本单元，是进程的一个实体
(2）同一个进程中可以包括多个线程，并且线程共享整个进程的资源（寄存器、堆栈、上下文），一个进行至少包括一个线程。
线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。
线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据
悲观锁
总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。
乐观锁
总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。
乐观锁常见的两种实现方式
乐观锁一般会使用版本号机制或CAS算法实现。
version方式：
一般是在数据表中加上一个数据版本号version字段，表示数据被修改的次数，当数据被修改时，version值会加一。当线程A要更新数据值时，在读取数据的同时也会读取version值，在提交更新时，若刚才读取到的version值为当前数据库中的version值相等时才更新，否则重试更新操作，直到更新成功。
CAS算法
即compare and swap（比较与交换），是一种有名的无锁算法。无锁编程，即不使用锁的情况下实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步
synchronized修饰符
- 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；改代码块称为同步代码块
- 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
- 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
- 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。
volatile不会造成线程的阻塞；
synchronized可能会造成线程的阻塞。
网络通信
TCP/IP模型
分为四层分别为 网络接口层、网络层、传输层、应用层
| 层 | 协议名 |
|---|---|
| 应用层 | DNS（域名系统）HTTP（超文本传输协议）FTP（文件传输协议）Telnet（远程终端协议）SMTP（简单邮件传输协议）… |
| 传输层 | TCP（传输控制协议）UDP（用户数据报协议）… |
| 网络层 | IP（网络协议）ARP（地址解析协议）ICMP（控制信息协议）… |
| 网络接口层 | 以太网… |
HTTP协议
HTTP协议是指计算机通信网络中两台计算机之间进行通信所必须共同遵守的规定或规则，超文本传输协议(HTTP)是一种通信协议，它允许将超文本标记语言(HTML)文档从Web服务器传送到客户端的浏览器
TCP协议
面向连接的可靠字节流服务。
传输数据之前在不同主机的传输端口之间建立一条链路。
提供可靠的传输控制协议，即传输前建立逻辑连接，然后传输数据，最后释放连接。
传输层连接的建立采用了三次握手机制：
第一次握手：客户端向服务器端发送连接请求包，等待服务器回应；
第二次握手：服务器端收到客户端连接请求包后，将客户端的请求包放入到自己的未连接队列，此时服务器需要发送两个包给客户端；
（1）向客户端发送确认自己收到其连接请求的确认包，向客户端表明已知道了其连接请求
（2）向客户端发送连接询问请求包，询问客户端是否已经准备好建立连接，进行数据通信；
第三次握手：客户端收到服务器的包后，知道了服务器同意建立连接，此时需要发送连接已建立的消息给服务器；
向服务器发送连接建立的确认包，告诉服务器，我们之间已经建立了连接，可以进行数据通信。
服务器收到后，此时服务器与客户端进入建立状态，开始进行数据传送。
UDP协议
面向进程的无连接传输服务
无连接的传输层协议，不提供数据包分组，组装，面向事务简单的不可靠的传送服务。
端口
操作系统支持多程序（进程）并发执行，操作系统根据应用程序定义的端口号接受带有相同端口号的数据包。
URL统一资源定位器
对网上一个资源的引用，通过URL访问网络上的资源。
事务
是数据库管理系统执行过程中的一个逻辑单位，由一个有限的数据库操作序列构成。
一个事务中的所有操作要么全部执行，要么全不执行。
A：原子性，事务是数据库的逻辑工作单位，事务中包含的操作，要么都做，要么都不做。
C：一致性，事务执行的结果必须是使数据库从一个一致性状态到另一个一致性状态。
I ：隔离性，一个事务的执行不能干扰其他事务。
D：持续性，也即永久性，指的是一个事务执行后对数据库数据的更改是永久性的。
索引是对数据库表中一列或多列的值进行排序的一种结构，使用索引可快速访问数据库表中的特定信息。
Servlet基础
Servlet使用Java编写的Server端程序，它运行在基于Java语言的Web服务器端，与协议和平台无关。
Servlet处于服务端进程中，通过多线程方式运行service()方法，一个实例可以服务于多个请求
生命周期
1.装载Servlet
2.服务器创建一个Servlet的实例
3.服务器调用Servlet的init()方法
4.一个服务端的请求到达服务器
5.服务器创建一个请求对象
6.服务器创建一个响应对象
7.服务器激活Servlet的service()方法
8.service()方法获取请求对象的信息
9.service()方法使用相应对象的方法，将响应传回服务器最终达到客户端
10.结束服务，调用destroy()方法
JSP基础
JSP是Servlet技术的扩展，更强调与表现层的处理。JSP侧重于视图，Servlet主要用于控制逻辑。容器先把JSP转换成一个Servlet，所有的JSP元素都会转换成Java代码，然后再编译这个Servlet。
动态代理
代理：实际调用者通过代理对象对目标对象进行操作，代理对象和目标对象有相同的方法(实现同一接口)
动态代理：不用手动编写一个代理对象，不需要一一编写与目标对象相同的方法，这个过程，在运行时的内存中动态生成代理对象。------字节码对象级别的代理对象
动态代理的API：
在jdk的API中存在一个Proxy中存在一个生成动态代理的的方法newProxyInstance
| static Object | newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) |
|---|
返回值：Object就是代理对象
参数：
loader：代表与目标对象相同的类加载器-------目标对象.getClass().getClassLoader()
interfaces：代表与目标对象实现的所有的接口字节码对象数组
h：具体的代理的操作，InvocationHandler接口
每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。InvocationHandler这个接口的唯一一个方法 invoke 方法（执行代理对象的方法）：
Object invoke(Object proxy, Method method, Object[] args) throws Throwable
proxy: 指代我们所代理的那个目标对象
method: 指代的是我们所要调用目标对象的某个方法的字节码对象
args: 指代的是调用目标对象某个方法时接受的参数
new InvocationHandler() {
//invoke 代表的是执行代理对象的方法
@Override
//method：代表目标对象的方法字节码对象
//args:代表目标对象的响应的方法的参数
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("目标方法前的逻辑");
//执行目标对象的方法
Object invoke = method.invoke(new Target(), args);
System.out.println("目标方法后的逻辑");
return invoke;
}
}
);
注意：JDK的Proxy方式实现的动态代理 目标对象必须有接口 没有接口不能实现jdk版动态代理
8777
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
