静态代理

静态代理:通过代理角色帮助真实角色完成一些事情,真实角色只专注于自己的事情

前提条件:代理角色和真实角色必须实现同一个接口.

信号灯法的优化

(1)将共享数据类的成员加入私有化

(2)提供set()方法对共享数据进行赋值并加入同步方法

(3)在生产者资源类中调用set()方法进行赋值

(4)在共享资源类中提供get()方法,获取共享数据并加入同步方法

(5)在消费者资源类调用get()方法.

线程组:ThreadGroup

public ThreadGroup(String name)//构造一个新的线程组
public final ThreadGroup getThreadGroup()//获取当前线程所属的线程组
public final boolean isDaemon()//是否为守护线程组
public final ThreadGroup getParent()//返回此线程组的父级
public final int getMaxPriority()//返回此线程组的最大优先级
public final String getName()//返回此线程组的名称

线程组的特点:线程组里的线程将用户执行的动作执行完毕,纠结束了,不会在返回线程组中了(默认的线程组就是用户线程main线程)

线程池:系统维护容纳线程的容器

线程池的特点:线程池里会规定可重复的线程,这些线程使用完毕之后不会被立即回收,会将线程再次归还到线程池中,等待下一次利用

线程池的功能

//创建一个固定的可重复的线程数的线程池
public static ExecutorService newFixedThreadpool(int nThreafs)
//启动有序关闭,其中先提交的任务将被执行,但不会接受任何新任务
public void shutdown()
//创建一个根据需要创建新线程的线程池，但在可用时将重新使用以前构造的线程    
public static ExecutorService newCachedThreadPool()
//创建一个使用从无界队列运行的单个工作线程的执行程序
public static ExecutorService newSingleThreadExecutor()

ExecutorService接口:可以进行多个异步任务的执行

//提交异步任务,这些异步任务就要执行Callable中的call方法
<T> Future<T> submit(Callable<T> task)
//计算一个结果，如果不能这样做，就会抛出一个异常
V call() throws Exception

注意事项:如果仅仅只是要实现多个线程并发执行,那么调用sumbit()方法的方式返回值可以不用写;如果需要计算具体的结果,那么就需要将Future返回,它表示异步计算的结果值是什么.

线程池的七大参数:

(1)corePoolSize:线程池核心线程数量

(2)maximumPoolSize:线程池的最大线程数

(3)keepAlive Time:超过核心线程数量的"临时线程"的存活时间

(4)unit:"临时线程"存活时间的单位

(5)workQueue:超过核心线程数量时,新的任务会处在等待状态,并且存在workQueue中

(6)threadFactory:创建线程的工厂类

(7)handler:线程池执行的拒绝策略

线程池的四大拒绝策略:

(1)AbortPolicy:线程池的默认拒绝策略,直接抛出异常处理

(2)DiscardPolicy:直接抛弃不处理

(3)DiscardOldestPolicy:丢弃队伍中最老的任务

(4)CallerRunsPolicy:将任务分配给当前执行execute方法线程来处理

Lock接口:

1.Lock:实现提供比synchronized方法和语句可以获得更广泛的锁定操作.

2.ReentrantLock:Lock接口的子实现类,可重入的互斥锁.

public void lock()//获得锁
public void unlock()//释放锁

3.异常的处理:

(1)throws抛出异常,抛出在方法声明上.

(2)捕获异常

try {
}
cath{
}
finally{
}

Timer:

1.Timer:JavaSE的定时器,处理一次或重复执行的任务.

2.构造方法

public Timer()//创建一个新的定时器,不是守护线程.

3.成员方法

public void cancel()//取消定时器
public void schedule(TimerTask task, long delay)//经过多少秒后执行一次定时任务
//经过delay毫秒后指向定时任务,经过period后重复执行定时任务
public void schedule(TimerTask task, long delay, long period)
public void schedule(TimerTask task, Date time)//在指定时间的时候(精确到毫秒)执行定时任务.

4.TimerTask类:可以由计时器进行一次性或重复执行任务;抽象类,不能实例化,自定义子类或者匿名内部类

public abstract void run()//定时器要执行的操作.

设计模式

1.简单工厂模式:也称静态工厂方法模式,主要作用负责某些类的实例的创建过程.

优点:通过工厂类完成各个类的对象的创建

弊端:当有新的类型增加,需要不断修改工厂类,维护性难度大

2.工厂方法模式:抽象工厂类负责定义创建对象的接口,具体对象创建工作由继承抽象工厂的具体类实现

优点:具体的工厂类负责创建当前具体的实例,结构层次很清晰,由具体类/工厂类/抽象工厂(接口)

弊端:有新的类型增加,需要编写额外的代码,所有代码增加,导致工作量增加了.

3.单例模式:一个类的实例在内存中有且仅有一个.

(1)饿汉式:当类一加载就创建了当前类对象,而且始终只有一个;永远不会出现安全问题的一种单例模式

饿汉式使用的步骤:

a.自定义一个具体类

b.无参构造私有化,使外界不能创建对象

c.在当前类的成员位置,创建自己本身对象

d.在当前类中提供一个对外的公共静态的功能,返回值是她本身

(2)懒汉式:可能出现安全问题的一种单例模式

延迟加载,:懒加载,在查询时一次进行加载,按需求加载,多对多,一对多时是一个较多

立即加载:在查询时关联的表格将会立即查询出来加载内存,无论用不用;一对一,多对一时使用较多

懒汉式使用步骤:

a.自定义一个具体类

b.无参构造方法私有化,使外界不能创建当前类对象

c.在当前类的成员位置声明当前类型的变量

d.提供一个对外公共并且静态的访问方法,返回值就是当前类本身.

e.在静态方法里判断当前类的变量是否为null

安全问题的解决:将当前类对外提供的公共方法加入synchronized关键字,变成同步方法.

Runtime类

Runtime类:每个Java程序都有自己的运行程序,通过Runtime创建的实例表示:当前系统的运行环境.4

递归调用:

1.递归:方法调用方法本身的一种现象.

2.递归思想:有去有回

3.递归三要素:

(1)必须定义一个方法

(2)有一定的规律

(3)必须要有结束条件.

IO流

1. File类

2. File类的构造方法

   public File(String Pathname)//通过给定的路径名字符串转换成抽象路径名来创建File实例
   public File(String parent , String child)//根据一个目录和一个子文件/目录得到File对象
   public file(File parent , String child)//根据一个父File对象和一个子文件/目录得到File对象.

3. File类的成员方法

   public boolean createNewFile()//创建文件
   public boolean mkdir()//创建文件夹
   public boolean mkdirs()//创建文件夹,如果父类文件夹不存在,则创建
   public boolean delete()//删除
   public boolean renameTo()//重命名
   public boolean isDirectory()
   public boolean isFile()
   public boolean exists()
   public boolean canRead()
   public boolean canWrite()
   public boolean isHidden()
   public String getAbsolutePath()
   public String getPath()
   public String getName()
   public long length()
   public long lastModified()
   public String[] list()
   public File[] listFiles()

4. 异常的处理

   1.throws:抛出异常,抛在方法声明上,谁调用这个方法,谁就是调用者,通过调用者进行处理(dao层)

   2.try...catch...finally:捕获异常,通常在业务层捕获异常

   (1)分别处理

   try{//可能出现问题的代码;   
   }catch{//处理异常
   }try{//可能出现问题的代码;
   }catch{//处理异常
   }

   (1)一次性处理

   try{//可能出现问题的代码;...
   }catch{//处理异常
   }finally{//释放资源
   }

   字节输出流:FileOutputStream

   换行操作:在写入数据的时候使用换行符号"\r\n"

   FileOutputStream的功能

   //创建文件输出流以写入由制定的File对象表示的文件;如果第二个参数为true,则自动后面追加.
   public FileOutputStream(String pathname,boolean append)
   //关闭此文件输出流并释放与此流相关的任何系统资源
   public void close() throws IOException
   //将 b.length个字节从指定的字节数组写入此文件输出流
   public void write(byte[] b)
   //将 len字节从位于偏移量 off的指定字节数组写入此文件输出流
   public void write(byte[] b, int off, int len) 

   字节输入流:FileInputStream

   FileInputStream的功能

   //创建文件字节输入流对象
   public FileInputStream(String name) throws FileNotFoundException
   //一次读取一个字节,返回的读取的字节数
   abstract int read()
   //一次读取一个字节数组
   int read(byte[] b)

   注意事项:

   (1)read这些方法都是阻塞式方法,只要文件没有读完,一直等待要读取

   (2)一次读一个字节将文件内容打印在控制台,如果文件中有中文,就会出现乱码,出现的原因就是在UFT-8中一个英文对应一个字节,一个中文对应三个字节,拼接不上导致乱码,所以需要将字节数强转为char类型

   字节缓冲输出流:BufferedOutputStream,又叫字符高效流

   BufferedOutputStream:这个流仅仅是在内部提供了一个字符串缓冲区(字节数组),针对文件输出并且同时写入数据数据,但是底层使用的还是底层流OutoutStream

   构造方法

   //构造一个默认的缓冲区大小,通过底层流进行输出 ;   缓冲区默认长度为8192
   public BufferedOutputStream(OutputStream out)

   字节缓冲输入流:BufferedInputStream

   public BufferedInputStream(InputStream in)

   合并流:SequenceInputStream,将多个文件复制到一个文件中

   SequenceInputStream:InputStream的子类,这个类只能操作源文件

   //通过记住参数来初始化新创建的SequenceInputStream 
   public SequenceInputStream(Enumeration<? extends InputStream>e)
   //将两个字节文件流对象指向的文件进行合并
   public SequenceInputStream(InputStream s11 , InputStream s2)

   字符输入流:Reader

   Reader:抽象类,子类InputStreamReader

   InputStreamReader:字符缓冲输入流,通向字节输入流的桥梁

   构造方法

   //使用平台默认的字符集进行解码,里面包装的字节流
   public InputStreamReader(InputStream in)
   //使用指定的字符集进行解码
   public InputStreamReader(IntPutStream in,String charsetName)

   功能

   //读一个字符
   read()
   //读一个字符数组
   read(char[] ch)

   字符输出流:Writer

   Writer:抽象类,子类是OutputStreamWriter

   OutputStreamWriter:字符转换输出流,里面包装的字节流

   构造方法

   //使用平台默认的编码字符集进行编码,写入数据
   public OutputStreamWriter(OutputStream out)
   //使用指定的编码字符集进行编码,写入数据
   public OutputStreamWriter(OutputStream out)

   功能

   writer(int ch)//写一个字符
   writer(char[] ch)//写字符数组
   writer(char[] ch,int index,int len)//写字符数组的一部分
   writer(String str)//写字符串
   writer(String str,int index,int len)//写字符串的一部分

   BufferedReader:字符缓冲输入流,提供默认的缓冲大小,缓冲区足够大

   BufferedReader(Reader in)
   String ReadLine()//读取一行内容

   BufferedWriter:字符缓冲输出流,字符流的高效流

   BufferedWriter(Writer out)//提供默认缓冲区大小,默认值足够大,为8192个长度,底层是一中字符数组
   public void newLine() throws IOException//写入行的分隔符号.

   序列化:ObectOutputStream

   1.序列化:将java对象变成一种流数据,将他们里面的数据存储在流中,就可以在网络中传输.

   2.构造方法

   public ObjectOutputStream(OutputStream out)

   3.成员方法

   //写入一个实体对象
   public final void writerObject(Object object) throws IOException

   4.前提条件:自定义类必须实现序列化标记接口Serializable.

   5.transient关键字:可以标记某个成员变量不参加序列化.

   反序列化:

   1.反序列化:将流数据(存储的一些相关的实体类数据)还原成java对象

   2.功能

   //将文件中的数据进行读取
   public ObjectInputStream(InputStream in) throws IOException
   //
   public final Object readObject()thows IOException,ClassNotFoundException

   属性集合类

   1.propertis:属性集合类,是一个Map,但是没有泛型,键和值都是String

   2.功能

   //添加键和值
   public Object setProperty(String key,String value)
   //获取所有键的集合
   public Set<String> stringPropertyNames()
   //获取键对应的值
   public String getProperty(String key)
   //将属性列表中的内容保存到指定文件中,参数2是给属性列表一个描述
   public void store(Weiter writer,String comments)
   //将文件中的内容加载到属性列表中
   public void load(Reader reader)

   网络编程三要素

   IP地址

   1.InetAddress:表示i地址

   2.功能

   //通过主机名称获取ip地址
   public static IntAdddress getByName(String host) throws UnknownHostException
   //获取IP地址对象所描述的主机名称
   public String getHostName()
   //获取ip地址,返回字符串
   public String getHostAddress()

   端口

   1.port:端口号.

   2范围:0~65535;0~1024属于保留端口

   协议

   1.UDP协议

   (1)不可靠协议

   (2)不需要建立连接通道,执行效率高,但是安全性低.

   (3)发送内容时有大小限制.

   2.UDP发送端代码实现步骤:

   (1)创建UDP发送端的Socket对象

   (2)创建数据报包

   (3)发送

   (4)释放资源

   3.UDP接收端代码实现步骤:

   (1)创建Socket对象

   (2)创建接受容器:自定义一个缓冲区数据,创建数据报包

   (3)接受

   (4)解析真实数据

   (5)获取实际内容

   TCP/IP协议

   (1)属于可靠协议

   (2)需要建立连接通道;服务器监听客户端连接,如果客户端没有跟服务器端口进行绑定,则服务器会一直等待,执行效率高,但是安全性低

   (3)发送内容时没有大小限制

   TCP/IP客户端实现步骤:

   (1)创建客户端的Socket对象

   (2)创建客户端所在的通道内的字节输入流OutoutStream

   (3)给客户端通道内的流写入数据

   (4)释放客户端的资源对象

   TCP/IP服务器端的实现步骤:

   (1)创建服务器端的Socket对象

   (2)监听客户端的连接,一旦监听到了就获取那个客户端的Socket

   (3)获取连接的客户端通道的通道内的输入流,读取数据

   (4)展示数据

   (5)释放资源