单例：
保证该内存中只有一个对象（实例）
懒汉式：（可能出现问题的单例模式）
1）无参构造私有化
2）在成员位置声明当前类的静态变量
3）提供对外的静态公共访问方法：（加入synch：静态的同步方法：锁对象：当前类名.class
需判断：如果当前变量为null，创建该类实例，返回该类本身
1）延迟加载
2）线程安全问题
饿汉式：（不会出现问题的单例模式）
1）无参构造私有化
2）在成员变量位置提供该类静态成员变量
3）提供对外的静态的公共方法：返回值就是该类本身
不同点：1）是否立即释放锁
sleep()方法的调用，----等待休眠时间到了，计时等待，不会立即释放锁对象
释放的是一种等待的状态
在一定时间内处于阻塞状态
wait()方法的调用，会立即释放锁，然后后面才能使用锁对象唤醒对方线程
2）来源不同
sleep(long time)：来源于Thread类
wait():来源于Object类，wait()和锁对象息息相关，锁对象可以是任意的Java类型
共同点：
都会抛出异常(interrException）：任何线程中断了当前线程的这种状态，就会产生中断异常
有三种
方式1：
自定义一个类，继承Thread类
重写run方法
在当前线程中创建该类对象
方式2：
自定义一个类，实现Runnable接口
重写run方法
创建当前资源类，创建Thread对象
启动线程
方式三：
线程池：通过工厂类：Executors 方法：newFixedThreadPool（int nThreads）
ExecutorsService
提交异步任务
submit（Callable<T> call）
关闭线程池
showDown()
throws和throw的区别：
throws：书写位置在方法声明上、
它的后面跟的异常类名，而且可以跟多个异常类名，中间用逗号隔开
对于调用者来说，必须要对带throws的方法进行方法
throws表示抛出异常的一种可能性，
交给调用者处理，（谁调用方法，谁去做处理）
throw：抛出
书写位置在在方法体的语句中
throw的后面跟的异常对象，一般都是匿名对象new XXXExceotion ；跟的是具体的某一个异常对象
抛出异常的一种肯定性
交给逻辑语句（语句体进行处理）
静态代码块：只执行一次，
构造代码块：在执行构造方法之前，如果代码中存在构造代码块，优先执行构造代码块
静态代码块>构造代码块>构造方法
描述：D盘下的Damo文件夹
相关构造方法
File(String pathname):里面当前文件夹/文件路径
File file=new File("e:\\demo");
File(String parent,String chile):parent的字符串路径名和child的字符串路径名
File（File parent,String child）：需要描述parent文件路径名，child的字符串路径名
URI:URI的子集合（同一资源定位符）
http://localhost:8080/web/login
URL：（统一资源标识符）/web/login
网络协议：http://
ftp://
...
成员方法：
创建文件/文件夹功能
createNewFile()throws IOException：文件
mkdir():创建文件夹/目录：如果存在该文件夹，返回值为false
mkdirs()：创建多级目录：如果父目录不存在，会自动创建
若给的是相对路径，没有指定具体的盘符，相对路径：则默认在当前项目下创建
删除功能
delete（）：删除表示的文件或者目录，前提目录必须为空
deleteOnExit():
重命名
renameTo(Dile dest):针对某个文件操作
file.renameTo(file2):
情况1：
当前文件的路径与改命后的路径相同，仅仅只是该名
情况2
当前文件的路径与改名后的路径不同：剪切并重命名
判断
isFile（）:判断是否是文件
isDurectoy():判断是否是文件夹
canRead():判断是否可读
canWrite()：判断是否可写
exists():判断所表示的抽象路径file表示的文件是否存在
isAbsolute():判断是否是绝对路径
isHidden():判断是否是隐藏文件
获取功能
基本获取功能
String getAbsolutePath():获取绝对路径名
String getPath():获取文件表示的路径
long length():获取文件长度
long lastModified():获取当前文件最后一次修改时间
高级功能：listFiles()：获取当前盼复下/目录下的所有File数组
File[] liatFiles(FilenameFilter filter):获取的数某个盘符下/目录Flie数组
String[] list()：获取某个盘符/目录下的所有文件以及目录的字符串数组
endsWith（".jpg"）:判断以什么结尾
FilenameFilte:文件名称过滤器
accept(File dir,String name):测试指定文件是否包含在文件夹中
是否将文件添加到列表中。
方法本身调用方法的一种现象
1）符号一定的规律
2）必须出口（结束）条件
3）必须定义一个方法
注意事项：构造方法没有递归。
例子：需求：需要删除带内容的目录
删除当前项目下：damo文件夹
分析：
描述下当前damo文件夹：File file=new File（“damo”）；
定义一个方法：delete（file）递归删除方法
高级获取功能：获取当前file所表示的文件以及文件夹的File数组[]
判断当前File数组不为空
判断file是否为空：isDirectory()
不是文件夹，是文件，直接删除：ddelete（）
删除文件夹：delete（）
#
IO流的具体划分：在设备之间进行数据传输操作
按流的方向划分：
输入流
输出流
按流的类型划分：
字节流：
InputStream：字节输入流
FileInputStream：文件操作字节流
BufferedInputSteram：字节缓冲输入流
OutputStream：字节输出流
FileOutputStream：文件字节输出流
BufferedOutputStream：字节缓冲输出流
字符流：
Reader字符输入流
Writer字符输出流
字符流是在字节输入流后出现的，解决了中文乱码问题
FileOutputStream:针对文件操作：文件输出流
FileOutputStream（String file）
FileOutputStream（File file）
使用步骤：
创建OutputStream字节输出流对象
FileOutputStream out=new FileOutputStream("demo.txt");
给文件中写入内容(写入字节数组）
out.write("String".getBytes());
关闭相关的系统资源
out.close();
write(byte[] b):给指定的文件写入字节数组
write(int b):写入一个字节：存入的是char，ASII码表
write(byte[] b,int off,int len)写入字节数组的一部分
FileOutputStream的构造方法
FileOutputStream（String name,boolean append)
创建输入流对象，并指向文件，将文件内容写入末尾的位置
换行：写入换行符号：
fos.write("\r\n".getBytes());
read():一次读取一个字节
read（byte[] b)：一次读取一个字节数组，返回值为int类型，new String（byte）可以读取具体内容
new String（byte，0，len（int类型的返回值））每次从0开始，读取len长度的字节数组
在d盘下有一个FileInputStreamDamo.java文件---源文件
使字节输入流读取该文件内容
封装目标文件
复制到当前项目路径下：Copy.java文件中
使用字节输入流写数据，将上面的内容复制出来
两种方式：
1）一次读取一个字节
2）一次读取一个字节数组
使用步骤：
1）创建字节输入流对象
long begin=
FileInputStream fis=new FileInputStream（“d:\\FileInputStreamDemo”）;//封装源文件
FileOutputStream fos=...//封装目标文件
int by=0；
while((by=fis.read())!=-1){
fos.write(by);
}
fis.close();
fos.close();
2)读操作，复制操作
3）关闭资源
fis.close();
1.IO流的分类
按流的方向划分：
输入流
输出流
按流的类型划分：
字节流：
InputStream：字节输入流
FileInputStream：文件操作字节流
BufferedInputSteram：字节缓冲输入流
OutputStream：字节输出流
FileOutputStream：文件字节输出流
BufferedOutputStream：字节缓冲输出流
字符流：
Reader字符输入流
Writer字符输出流
2.使用字节流对文件进行读写复制操作的方式
两种方式：
1）一次读取一个字节
int by=0;
while((by=字节输入流对象.read())!=1){
字节输入流对象.write(by);
}
2）一次读取一个字节数组
byte[] byte=new byte[1024];
int len=0;
while((len.字节输入流对象.read（byte）)!=-1){
字节输出流对象.write(byte,0,len);
}
3. 获取字节码文件的方式
4. 多线程的线程状态
Thread类中
public enum State（枚举）{
NEW 线程新建状态
RUNNABLE,线程运行状态
BLOCKED，线程阻塞状态
WAITING,死死等待
TIMED_WATING//超时等待，超过时限，就不等了
TERMINATED 线程终止（死亡）
}
5. 什么是单例
单例（考点）：保证在内存中始终只有一个该类对象，该类对象的创建是自动创建
饿汉式（不会出问题）
创建一个类，这个类成员位置，定义一个静态实例变量：创建该类对象
提供对外的公共访问方法
提供对外的公共功能：获取该类对象
代表
java.lang.Runtime:表示与java应用程序相关的运行环境
懒汉式----懒加载---存在线程的安全问题
当前类中
构造方法私有化
在成员位置，并不是一开始就直接创建该类实例，而是声明当前类型的变量
在当前类定义一个公共静态功能，返回值是该类本身
判断当前变量是否为空
若为空，直接创建该类对象
返回该类实例
懒汉式：可能会出现问题的单例模式
延迟加载
线程的安全问题
解决线程安全问题
使用同步代码块将多条语句对共享的操作包裹起来
BufferedInputSteram extend InputSteam:字节缓冲输入流
BufferedInputSteram （InputStream in）
BufferedInputSteram (InputStream in,int len)一次读取一个字节
BufferedOutputStream extend OutputSteam：字节缓冲输出流
BufferedOutputStream（OutputStream iut）
创建一个缓冲输出流对象，默认缓冲区大小
目前：当前缓冲流只是在流中提供了byte[]缓冲区，默认足够大，一般通过无参构造方法创建
只是提供缓冲区，具体文件读写操作还是需要用到底层流
四种方式对文件进行读写操作：
BufferedInputSteramDamo.java将其复制到当前项目下copy.java文件中
FileInputStream/FileOutputStream:
一次读写一个字节/一次读写一个字节数组
BufferedInputSteram/BufferedOutputSteram
一次读写一个字节/一次读写一个字节数组
例子：生成methed("文件名"，"文件名")方法
方法中封装源文件和目标文件
FileInputStream fis=new FileInputStream(srcFile);
FileOutputStream fos=new FileOutputStream(desFile);
int by=0; byte[] b=new byte;
while((by=fis.read())!=-1){ int len=0;
fos.write(by); while((len=fis.read(b))!=-1){
} fos.write(b,0,len);
}
编码和解码：
编码：将能够看懂的内容---转换“看不懂的内容”
String byte[]
解码：将看不懂的内容----转换“能看懂的内容”
byte[] String
编码格式：
big-5：大五码（繁写字体）
gbk：中国的中文编码表：一个中文对应两个字节
gbk-2312：中国中文编码表：gbk的扩展
iso-8859-1：拉丁文码表
utf-8：一个中文对应三个字节码
JS：日本的编码格式
utf-8/gbk用得最多
编码和解码的过程必须保证格式统一：否则出现乱码
Reader：字符输入流
字符通向字节流的桥梁：InputStreamReader：字符输入流
FileReader
BufferedReader
InputStreamReader使用默认字符集进行编码
InputStreamReader isr=new InputStreamReader(new FileInputStream("osw.txt"),"utf-8");
int ch=0; byte[] b=new byte;
while((ch=isr.read())!=-1){ int len=0;
System.out.println((char)ch); while((len=isr.read(b))!=-1){
} System.out.println(new String(len))
}
成员方法：
read（）:读单个字符
char[] cbuf 读字符数组
char[] cbuf,int off,int len 读字符数组的一部分
Writer：字符输出流
OutputStreamReader：字符输出流（字符通向字节流的桥梁）转换构造方法
OutputStreamWrite（OutputStream out）：gbk格式
成员方法：
write（int c):写入单个字符
（har[] cbuf) 写入字符数组
( char[] cbuf,int off,int len )写入字符数组的一部分
( String str) 写入字符串内容
(tring str,int off,int len )写入字符串的一部分
OutputStreamWrite osw=new OutputStreamWrite（new FileOutputStream("osw.txt"),"utf-8")
可以不带utf-8，为最原始的构造方法，平台默认的gbk格式
osw.write("a");
在关闭之前，进行刷新
osw.flush();:一个刷新流，将换成数组刷新出来，流刷新后还可以写入数据
osw.close();
为了简化字符流读写操作：
提供了字符转换输入和字符转换输出的便捷类
FileReader/ FileWriter
FileReader fw=new FileRider("d:\\a.java");
FileWriter fw=new FileWrite("osw.java");
将文本写入字符输出流，缓冲各个字符，从而提升效率
BufferWrite（Write out）：构造一个缓冲输入流。默认缓冲区大小
BufferedWrite bw=new BufferedWrite(new FileWriter("b.txt"));
成员方法：
newLine（）：写入一个换行符
bw.newLine();
bw.write("hello");
bw.newLine();
bw.flush();
bw.close();
BufferedReader（Reader r）:构造一个字符缓冲输入流，提供默认大小
readLine():一次读取一行内容，当读取到\n的时候，（换行），就终止
创建字符缓冲输入流对象
BufferedReader br=new BufferedReader(new FileReader("b.txt"));
String str=br.readLine();//第一次读取
System.out.println(str);
str=br.readLine();//第二次读取
.....
键盘录入：
1）Scanner(InputStream in)
Scanner sc=new Scannner(System.in)
2）BufferedReader（Reader r）可以作为键盘录入：（流的方式）
分步走：
InputStream in=System.in;
Reader r=new InputStreamReader(in);
BufferedReader br=new BufferedReader(r);
温馨提示
String str=br.readLine();
一步走：
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
上面的String转换为int类型
int num=Integer.parseInt(str);
总结：针对文本文件的复制操作：
InputStreanReader/OutputStreanReader
FileReader/FileWriter
BufferedReader/BufferedWriter:一次读取一行
共有：一次读取一个字节/一次读取一个字节数组
PrintWriter：字符打印流
PrintStream：字节打印流
能够直接操作文件地址的流：
FileInputStream/FileOutputStream
FileReader/FileWriter
PrintWriter:能够操作文件
构造方法：
PrintWriter（Writer out，boolean autoFlush）
为ture表示开启自动刷新功能
public PrintWriter(String fileName)：可以操作具体文件路径
成员方法：
println（XXX x）:可以换行
ByteArryOutputStream：内存操作输入流
public ByteArrayOutputStream()：构造一个默认缓冲区大小
ByteArryInputStream：内存操作输出流
public ByteArrayInputStream(byte[] buf)：指定的字节数组作为缓冲区，构造内存操作输入流
SequenceStream:合并流：基本的字节输入流
构造方法：
public SequenceInputStream(InputStream s1,
InputStream s2)
将两个或者两个以上的文件操作合并到一个流中
public SequenceInputStream(Enumeration<? extends InputStream> e)复制两个以上的文件
1）创建Vertor《》集合对象
2）给添加多个InputStream对象
3）Vertor集合中：elements（）--->Enumeration<InputStreamm>
4）读写复制
序列化和反序列化
序列化：需要将网络中的数据/一些对象转换为流数据
ObjectOutputStream
ObjectOutputStream（OutputStream out）
序列化
成员方法：
WriteObject（Object obj）：将对象转换为数据
前提条件：只有实现接口：Serializable接口的类，才能序列化
序列化接口：没有字段，练成员方法都没有。只是一个标记接口
序列化的类----内存中进行编码：内容包含：类---类产生的字节码文件，类签名：序列化版本 ID（SeriVersionUID）
ObjectInputStream
反序列化
readObject（）将数据还原为对象
每一个类在内存中进行序列化的时候，会产生.class文件，产生一个序列化版本ID
反序列化时，若将成员变量改变，会导致产生一个新的序列化版本ID，会出现异常
想要当前成员不参与序列化：添加transient修饰
在类上有一个黄色警告线，--点击---产生一个不会改变的版本ID
Properties类表示了一个持久的属性集，没有泛型
继承自Hashtable<K,V>implements Map<K,V>
Properties p=new Properties（）；
Map集合的遍历方式
keyset()
get(K key)
添加键和值：public Object setProperty(String key,
String value)
遍历：public Set<String> stringPropertyNames()：获取属性列表中的所有的键集
public String getProperty(String key)：通过键获取值
public void load(Reader reader)将一些配置文件中的数据，加载到属性集合类中
Reader r=new Reader（“a.txt”）；
public void store(Writer writer,String comments)：将属性集合类中的数据保存到指定的文件中
new FileWrite（“name.txt”），“name‘s.list”
关于UDP/TCP的使用
网络编程三要素：
举例：
1）找到高圆圆---->ip地址
2）对它说话---->（耳朵）---端口号
3）说什么--->（i love you）--听不懂---协议（中文）
协议 IP地址 端口号
网络协议：
UDP TCP
区别：
1）是否需要建立连接通道
UDP不需要建立
TCP需要建立连接通道
2）是否是可靠安全连接
UDP：是一种不可靠连接，不安全---执行效率高
TCP：是一种可靠连接，服务器端一直在阻塞（同步的--安全性），执行效率低
三次握手，四次挥手
3）共同点：
UDP/TCP---两端都需要有Socket（Socket编程）
应用协议
http协议
https协议
第一要素：
ip地址：
192.168.138.1：使用点分十进制法
A类IP地址:第一段号码为网络号码，剩下的三段号码为本地计算机的号码（政府部门）
B类IP地址:前二段号码为网络号码，剩下的二段号码为本地计算机的号码（大学校园）
C类IP地址:前三段号码为网络号码，剩下的一段号码为本地计算机的号码（私人地址）
127.0.0.1：回环地址：表示本机
xxx.xxx.xxx.255 广播地址
第二要素：
端口号：
使用360软件查看当前计算机中每一个软件的端口号
有效端口号：0-65535
0-1024：保留端口号
一般：80端口号：是不写的（省略）
常见端口号
tomcat：8080
redis：6575..（数据库---非关系型数据库 key-value）
myaql软件：3306
...
没有构造方法，不能直接创建对象，提供一些成员方法使用：静态的
public static InetAddress getByName(String host)：返回IP地址
public String getHostAddress() ：返回 IP 地址字符串（以文本表现形式）
public String getHostName()：获取主机名
InetAddress i=InetAddress.getByName("主机名字")；
String ip=i.getHostAddress();
Socket编程
特点：
1）两端都需要Socket对象
2）发送端/客户端：有对应ip地址和端口号
3）接收端/服务端：绑定对应端口号
UDP协议发送端步骤：
1）创建发送端的Socket对象
2）数据报包对象：DatagramPacket
3）发送数据
4）关闭资源
public DatagramPacket(byte[] buf, int length, InetAddress address, int port)
参数1：当前发送数据的字节数组
2：当前数组的实际长度
3：ip地址对象
4：端口号：0-1024是保留端口
String s="hello,我来了"
byte[] b=s.getBytes()
int length=b.length;
DategramPacket d=new DategramPacket(b,length,)
UDP协议接收端的实现
1）创建接收端的Socket对象
2）创建数据报包---当前接收容器
3）接收数据
4）从接收的容器中
5）展示数据
DatagramSocket ds=new DatagramSocket（10086）；
byte[] b=new byte[1024];
int length=b.length;
DatagramSocket dp=new DatagramSocket（b,length）；
ds.receive(dp);
解析当前数据
byte[] bf=dp.getDate()
int length2=dp.getLength()
//public InetAddress getAddress()
InetAddress add=dp.getAddress();
String ip=add.getHostAddress();
展示：
String s=new String(bf,0,length2);
输出：(s+"--"+)
1. 网络编程的三要素
协议 IP地址 端口号
ip地址：---java.net.IntAddress
端口号：0-65535（0-1024保留端口号）
协议：TCP/UDP
2. Properties属性集合类的遍历方式
map集合的遍历方式：
Set<Object> keySet()
Object get(Object obj)
特有遍历方式：
setProperty(String key,String value)
public Set<String> stringPropertyNames()：获取属性列表中的所有的键集
public String getProperty(String key)：通过键获取值
3. 字符流读写复制操作的方式
FileReader---继承自InputStreamReader----Reader
FileWriter---继承自OutputStreamWriter---Writer
BufferedReader/BufferedWriter：一次读取一个字符/一次读取一个字符数组
（一次读取一行数据）
4.UDP发送端和接收端的步骤
UDP协议发送端步骤：
1）创建发送端的Socket对象 DatagramSocket（）
2）数据报包对象：DatagramPacket（byte[] b,int lenth,...）
3）发送数据 send（DatagramPacket dp）
4）关闭资源Socket.close();
UDP协议接收端的实现
1）创建接收端的Socket对象 DatagramSocket(int port)
2）创建数据报包---当前接收容器 DatagramPacket(byte[] b,int length)
3）接收数据 receive(DatagramPacket dp)
4）从接收的容器中 DatagramPacket
byte[] getData()
int getLength()
String str=new String(DatagramPacket.getData(),0,DatagramPacket.getLength());
5）展示数据
获取ip地址的文本形式
6）释放资源
5. UDP和TCP的区别
1）是否需要建立连接通道
UDP不需要建立
TCP需要建立连接通道
2）是否是可靠安全连接
UDP：是一种不可靠连接，不安全---执行效率高
TCP：是一种可靠连接，服务器端一直在阻塞（同步的--安全性），执行效率低
三次握手，四次挥手
3）共同点：
UDP/TCP---两端都需要有Socket（Socket编程）
键盘录入：
Scanner
字符流方式：
BufferedReader（new InputStreamReader（System.in））
客户端：Socket
1）创建客户端的Socket对象 Socket s=newSocket（）；
2）获取客户端通道内的输出流数据，写入内容
可以继续封装为BufferedWriter
3）关闭资源
服务器端：ServerSocket
1）创建服务器端的Socket对象，绑定端口 ServerSocket sc=new ServerSocket（8888）；
2）进入阻塞状态，监听客户端连接 Socket x=sc.accept(“地址”，网络名称：10324);
3）获取动态输出流 InputStream in=x.getInoutStream();
4)读数据 byte[] b=new byte[1024];
int len=0;
5）展示数据
需要有一只用通道直流，客户端写数据到服务器端，服务器端就需要解析
TCP存在三次握手
两次握手最基本：
发送端发出数据后 ---- 第一次握手
服务器端加入反馈信息，表示收到-----第二次握手
服务端（接收端）：
//创建ServerSocket对象
ServerSocket ss=new
//监听客户端连接
Socket s=ss.accept
//获取通道输入流
InputStream in=s.getInputeStream();
//一次读取图个字节数组
byte[] b=new byte[1024];
int len=in.read(b);
//展示
String s=new String（b，0，len）；
Syatem.our.println(s)；
s.close();
问题：加入服务器端的反馈后
服务器端和客户端没有接收，但是文件已经复制完毕：
String readLine():返回值为null。仅仅表示文件读完，但是服务器端不知道客户端文件已经写入到通道流中
就等待客户端告诉服务器“已经写完”
问题： 当前客户端并没有告诉服务端写入完毕，客户端也等着服务器端的反馈，所以两者就相互等待，而无法结束
解决方案：
1）客户端自定义一个结束标记
通道输出流写入字符串，服务器读到后，结束
2）在客户端Socket中：调用shutdownOutput()方法//禁用此套接字的输出流。没有内容写入
问题：图片文件没有复制完整，文件缺失一部分
需要使用字节缓冲输出流：flush（）：迫使一些缓存字节强制刷新出来
CreateNewFile创建文件
String类的spilt（“=”）进行拆分为一个数组String[] str
什么是反射：
反射就是通过获取类的字节码文件对象：Class
创建该类的实例(通过构造方法：Cinstroctor类)，调用成员方法（Method类）
给变量赋值（Field）
getClass：表示正在运行的java类
方式3获取字节码文件：
Class c=Class.forName("类名")；com.qianfeng.reflect_10.person
反射的应用
1. 网络编程TCP和UDP的区别
1）是否需要建立连接通道
UDP不需要建立
TCP需要建立连接通道
2）是否是可靠安全连接
UDP：是一种不可靠连接，不安全---执行效率高
TCP：是一种可靠连接，服务器端一直在阻塞（同步的--安全性），执行效率低
三次握手，四次挥手
3）共同点：
UDP/TCP---两端都需要有Socket（Socket编程）
2. throw和throws的区别
throw：在方法的语句体中使用，后面的异常类对象名为具体异常，只能跟一个；抛出异常的肯定性
throws：使用在声明上，后面跟多个异常类名，异常的处理交给调用者，抛出异常的可能性
3. final，finally，finalize的区别
final：状态修饰符；修饰类，类不能被继承；成员方法不能被重写；变量为一个常量
finally：释放资源使用；try...catch...finally；finally代码一定会执行（除非jvm提前退出）
finalize：Object类中的一个方法：当前开启垃圾回收器，调用该方法回收没有更多引用的对象
synhronized的底层实现：监视锁（minotor）
4. 反射：获取字节码文件的方式
方式1：本身自带的Class属性，getClass
方式2：任意JAVA.Class
方式3：Class.forName("全限定名称")
5. 什么的简单工厂模式以及单例模式
简单工厂模式：--静态工厂方法模式
工厂类
构造方法私有化
对外提供公共访问方法---创建该类对象（使用多态）
使用工厂类创建该类对象
好处：利用； 抽象类的多态/具体类多态
弊端：一个新的类增加，工厂类作为一些修改
单例模式：保证该类在内存中始终只有一个对象
饿汉式：不会出现问题的单例
懒汉式：使用的时候才创建对象
判断当前对象是否为空，为空则创建该类对象，不为空直接返回
6.网络编程TCP和UDP的步骤实现
TCP：
1）创建客户端Socket对象
2）获取通道内的输出流对象
3）写数据
4）释放资源
服务器端：
1）创建服务器端对象Socket:secverSocket对象
2）监听客户端连接
3）获取通道内的输入流
4）读取数据
5）展示数据
UDP：
1）创建发送端的Socket：datagamSocket对象
2）创建数据报包：DatagramPacket。将制定端口绑定到主机
3）发送数据报包：send（DatagramPacket dp）
4）释放资源
接收端：
1）创建接收端的Socket：datagamSocket对象
对象名.成员方法名（）----->获取Method--invoke（当前类的实力，方法中实际参数）
获取类的字节码文件对象
通过Class获取Constructor
public static Class<?> forName(String className)
Class c=Class.forName("com.qianfeng.reflect_01.peason")
Constrctor[] getConstructructors():获取当前类中的所有公共构造方法
Constrctor[] getDeclaredConstructors():获取当前类中的所有的构造方法
Constrctor getConstructor(Class parameter):获取指定公共构造方法
类型传递表示：java.lang.String
int
Constrctor con=c.getConstructor();拿到无参构造法
(String.class):单个参数构造法
取消Java语言的访问检查。能够访问私有方法
con.setAccessible(true):true为访问
创建该类的实例
//public T newInstance(Object... initargs)
Object obj=con.newInstance();
通过Class（运行的类对象）获取Methed方法并使用
//Method[] m=c.getMethods();//获取所有的方法
//Method m=c.getDeclaredMethod(null,null);//获取指定方法。
//参数1：方法名。
//参数2：当前方法如果有形式参数，跟上形式参数类型.Class
//Properties p=new Properties();//创建集合类对象
//p.getProperty("键值（获取全限定名或者方法名）");//String s（全限定名或者方法名）=
只需要修改文件中的键值，就能改变调用的方法。
读取src下的文件名.properties文件
//获取类加载器：
ClassLoader c=本类类名.Class.getClassLoader();
//读取指定资源的输入流
//参数是文件名，文件必须在src目录下
//方式1
InputStream in=c.getResourceAsStream("文件名.properties")
//创建集合对象
Properties p=new Properties();
p.load(in);
//获取键值名称
String j=p.getProperty("名称");
String z=p.....
Class class=Class.forName(j);
Object o=class.newInstance();
Method m=class.getMethod(z);
m.invoke(o);
代理设计模式：
结构型设计模式
代理模式
静态代理
动态代理
jdk动态代理
CGlib动态代理
静态代理：---Thread的实现方式2---实现了Runable接口
真实角色：专注自己的事情
代理角色：帮助真实角色对实际方法进行增强
都需要实现指定接口
动态代理：在程序运行过程中产生的代理类
JDK动态代理
Proxy
静态方法：newProxyInstance(参数1，参数2，参数3)
1）类加载器对象
2）接口列表
3）接口的处理程序。自己写
自定一个类，myxx实现InvocationHandler
//声明一个实例。对谁产生代理：Object（代表所有类型）
Private Object targer；
重写invoke方法
public Object invoke(参数1，参数2，参数3){
增强的处理
}
数据存储
集合
数组
容器---->使用完毕就不存在了，对象/数组被回收掉
IO流
字符流/字节流 将数组存储到配置文件中，效率低，耗时
在计算机上--按照数据库软件---
关系型数据库
SQLServer。Oracle,db2,Mysql(开源，小型化）
非关系型数据库
典型代表：mangodb/redis
如何校验是否完成
SQL：结构化查询语言：Structre Query Language
DDL语言：CRUD
创建库
create database 数据库名
create database if not exists 数据库名:如果不存在这个库，创建一个新的
删除库
drop database 数据库名
drop database if exists 数据库名：如果存在，删除该库
修改库,
alter databes 数据库名 default(可以省略) character set gbk
查询库
创建数据库的时候能够直接修改编码格式：
create database if not exists 数据库名 default character set gbk；
DML语句：数据操作语句
创建表：
create table 表名（字段名称1 字段类型1，字段类型2 字段类型2，...）;
字段类型：varchar(m):m多少个字符
int:默认int（11） int（num） 可以指定长度
double（5，2）：五位小数，小数保留两位
时间：
date 只表示日期，没有具体时分秒
datetime 具体时间，包含时分秒
timestamp 时间戳 具体哪个时间操作的
创建表前，先使用库
use 库名 show tables;查询表
create table student(//开始创建
name varchar(3),
age int, //各个属性
gender varchar(2),
);//结束
查询表的结构：
desc 表名；
修改表：新增
alter table student add address varchar(10);
表名：
alter table
删除表：
drop table 表名；
删除全表：
是否对自增长的主键影响
TRUNCATE table 表名：删除表以及表中数据，删完后，创建一个一模一样的表
会影响主键，创建的新表主键已经重置（自增长的主键会清除掉）
delete from 表名：删除全表数据
不会影响主键，只是删除全表数据（不会清除自增长主键）
ALTER TABLE student DROP remark;//删除指定的列
desc 表名：查询表的结构
修改表：
update 表名 set 字段名=赋值 where id=2；//将id=2位置的名称修改。否则变为批量修改
修改多个字段：
update 表名 set 字段名=赋值 ，字段名=赋值 where id=4；//将4字段的位置的内容修改
查询语句：DQL语句
select * from 表名；
查询指定字段：
select id，name，age...；
1. 数据库的基本操作语句
DDL 创建库，创建表，删除库，删除表
create database 库名：创建库
create database if not exists 库名：如果不存在这个库，创建这个库
drop database 库名：删除库
drop database if exists 库名：如果有这个库，删除这个库
create table 表名（字段1 字段类型1...字段n 字段类型n）：创建表
delete from 表名：删除表
drop table 表名：删除表
2. 修改表的数据类型的sql语句以及修改表的字段名称的sql语句
alter table 表名 add 类名 数据类型；
alter table 表名 change 当前字段名 新字段名 类型；
alter table 表名 drop 字段名；
3. 什么是反射，如何获取一个类的字节码文件方式
通过获取一个类的Class---获取当前类的Constructor---获取当前类的Method---获取当前类的Field
java代码经过三个阶段
SOURCE阶段：源码阶段 javac---java源代码编译
CLASS阶段：类的加载以及初始化 ----XXX.class文件
运行阶段：输入 java 类名---产生结果
三种获取字节码文件的方式：
getClass（）
任意Java类型.Class
Class.froName（“类的全限定名”）
4. 如何获取一个类的Constructor并创建该类实例
现获取当前类的Class对象
Class class=Class.forName（“类的全限定名”）
若方法为公共：Construtor getConstrictor（）
若方法为私有：Cinstructor getDeclaredConstructor（）
通过构造器创建该类实例：
Constructor类
newInstance（）
5. 如何获取一个类的Method并调用该方法
1)现获取当前类的Clsaa对象
Class c=Class.forName("类的全限定名");
1）直接通过当前字节码文件对象创建该类实例
Object ibj=c.newIntance（）；
2)获取Method并使用
如果方法是共有的：Method getMethod（）
若方法是私有的：Method getDelaredMethod（）;
3）调用方法
m.invoke（c）；
6. 如何读取src目录下的xxx.properties文件
1）获取当前类的字节码文件对象，同时获取该类的类加载器对象ClassLoader
2）InputStream in=getResourAstrean（“src目录下配置文件”）；
InputStream ins=类名.Class.getClassLoader.getResourceAsStrean("src目录下配置文件")
条件查询：
where 跟字段名=值；
where 表达式；
模糊查询：like %代表多个任意字符
where 字典 like ‘%马%’ 姓名包含马的人
where 字段 like ‘_化&’ 姓名第二个字是化的人
分组查询：geroup by
查询的字段可以是分组的字段，可以使用聚合函数
筛选：having
排序：按某个字段升序asc/降序desc
select * from 表名 order by 字段名 按照摸个规则；
分页查询：
limit 起始行数，每页起始条数
起始行数=当前页码数-1）*每页显示条数，每页显示条件
聚合函数：
count max min avg sun
统计 最大值 最小 平均 求和
count的使用：一般里面都是跟一些非业务字段
每一张id字段，设置都是一个自增长主键（非空并且唯一）
count（id）
group by 分组查询：在where条件后使用 后面不能使用聚合函数，但是查询的时候可以查询聚合函数
hanving 筛选：在group by之后使用 后面可以使用聚合函数
约束：通过一些特点关键字，保证数据的安全性，正确和有效性
默认约束：defaut 后面跟具体值 表示如果不赋值就默认为其后的值
非空：not null
唯一：uniue 直接加在字段后 不能重复
主键：primary key 等价于：非空+唯一
自增长：auto_increment
外键约束：foreign key
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
