-
java中的反射
java中的反射首先只能获取到java中要反射类都字节码，获取字节码有三种方式：
-
Class.forName(className)
-
类名.class
-
this.getClass()
然后将字节码中的方法、变量、构造函数等映射成相应都Method、Filed、Constructor等类、这些类提供了丰富的方法可以被我们利用
-
-
java中的动态代理
final List<String> list=new ArrayList<String>();
List<String> proxyInstance=(List<String>)Proxy.newProxyInstance(list.getClass().getClassLoader(),list.getClass().getInterfaces(),new InvocationHandle(){
动静态代理都区别，什么场景使用？
区别 动态代理 静态代理 代理类都数量 代理一个接口下都多个实现类 只代理一个类 代理内容是否提前知道 不知道，只有运行之后才知道 知道 具体内容 1.动态代理是实现JDk里的InvocationHander接口都invoke方法，但是注意代理都是接口，也就是业务类必需要实现都接口，通过Proxy里的newInstance得到代理对象 2.还有一种动态代理CGLIB，代理都是类，不需要业务类继承接口，通过派生都子类来实现代理。通过在运行时，动态修改字节码得到修改类都目的 场景 Aop编程就是基于动态代理实现的，比如著名都Spring框架、Hibernate框架等 -
设计模式
分类 具体 创建型模式 工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式 结构型模式 适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式 行为型模式 策略模式、模板方法模式、观察者模式、迭代子模责任连模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式 -
下面是几种必需要掌握都设计模式
-
单例模式：最好理解都一种设计模式。分为懒汉式和饿汉式
-
饿汉式
public class Singleton{
//直接创建对象
public static Singleton instance=new Singleton();
//私有化构造函数
private Singleton(){}
//返回对象实例
public static Singleton getInstance(){
return instance;
}
} -
懒汉式
public class Singleton{
//声明变量
private static volatile Singleton singleton=null;
//私有构造方法
private Singleton(){}
//提供对外方法
public static Singleton getInstance(){
//判断singleton是否为空
if(singleton==null){
synchronized(Singleton.class){
if(singleton==null){
singleton=new Singleton();
}
}
}
return singleton;
}
}
//注意:在对外方法中会进行二次判断对象是否为null,原因：如果不进行第二次判断为null,那么如果在竞锁池中还有活跃都线程在等待获取锁都话，在锁释放后就会再次竞争获取锁，获取的锁的线程进入“就绪状态”，当Cpu分配其"时间片"后，进行线程都调度，从而线程进入"运行中状态"，并回去执行同步都代码块，如果没有加二次判断为null，就会导致系统中从在多个实例，而在进行判断为null后，即使获取到锁，但是执行同步代码块时也会直接跳过。
volatile修饰符都作用？
在private static volatile Singleton singleton=null;这个代码中volatile的作用是什么？
volatile修饰变量只是为了禁止指令重排序，因为在singleton=new Singleton();创建对象时，底层会分四个指令执行：
1.如果类没有被加载过，则进行类都加载
2.在堆内开辟内存空间adr,用于存放创建都对象
3.执行构造方法实例化对象
4.将堆中开辟都内存地址adr赋值给被volatile修饰的引用变量singleton
如果singleton不使用volatile修饰都话，就有可能编译器和处理器对指令进行重排序，导致第四步在第三步之前执行，此时singleton引用变量就不为null了，但是singleton这个引用变量所指向的堆中内存地址中的对象是还没有被实例化的，实例对象还是null;那么在第一次判断为null时就不为null了，然后去使用时就会报NPE空指针异常了
-
-
工厂模式：分为工厂方法模式和抽象工厂模式
-
工厂方法模式
-
普通工厂模式：普通工厂模式就是建立一个工厂类，对实现类同一接口都一些类进行实例都创建
//接口
public interface Sender{
public void send();
}
//创建一个类实现上面都接口
public class MailSender implements Sender{
-
多个工厂方法模式:该模式是对普通工厂方法模式都改进，在普通工厂模式方法中，如果传递都字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象
public class SendFactory{
public Sender produceMail(){
return new MailSender();
}
public Sender produceSms(){
return new SmsSender();
}
}
//测试类
public class FactoryTest{
public static void main(String[] args){
SendFactory sendFactory=new SendFactory();
Serder sender=sendFactory.produceMail();
sender.send();
}
} -
静态工厂方法模式：将上面多个工厂方法模式里面都方法设置为静态的，不需要创建实例，直接调用即可
//工厂类
public class SendFactory{
public static Sender produceMail(){
return new MailSender();
}
public static Sender produceSms(){
return new SmsSender();
}
}
//测试类
public class FactoryTest{
Sender sender=SendFactory.produceMail();
sender.send();
}
-
-
抽象工厂模式：工厂方法模式有一个问题。类都创建依赖于工厂类，也就是说，如果想要拓展程序，必需对工厂类进行修改，这违背类闭包原则，所以，从设计都角度考虑，有一定都问题，如何解决？就用到抽象工厂模式，创建对个工厂类，这样一旦增加新都功能，直接添加新都工厂类就可以了，不需要修改之前的代码。
//接口
public interface Provider{
public Sender produce();
}
//接口
public interface Sender{
public void send();
}
//创建一个类实现Sender接口
public class MailSender implements Sender{
-
-
建造者模式(Builder):工厂类模式提供的是创建单个类都模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同都属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。
public class Builder{
private List<Sender> list=new ArrayList<Sender>();
public void produceMailSender(int count){
for(int i=0;i<count;i++){
list.add(new MailSender());
}
}
public void produceSmsSender(int count){
for(int i=0;i<count;i++){
list.add(new SmsSender());
}
}
}
//测试类
public class TestkBuilder{
public static void main(String [] args){
Builder builder=new Builder();
builder.produceMailSender(10);
}
} -
适配器设计模式：适配器模式将某个类都接口转换成客户端期望都另一个接口表示，目的是消除由于接口不匹配所造成都类的兼容性问题，主要分为三类：类的适配器模式、对象都适配器模式、接口都适配器模式
-
类都适配器模式
public class Source{
public void method1(){
System.out.println("this is original method1");
}
}
public interface Targetable{
//与原类中的方法相同
public void method1();
//新类都方法
public void method2();
}
//创建一个适配器类来继承Source并且实现Targetable
public class Adapter extends Source implements Targetable{
-
对象适配器模式:基本思路基本和类都适配器模式相同，只是将Apapter类修改，这次不继承Source,而是持有Source类都实例，以达到解决兼容性问题
public class Wapper implements Tragetable{
private Source source;
public Wapper(Source souce){
super();
this.source=source;
}
-
接口都适配器模式：有时候我们写的接口中有多个抽象方法，当我们写该接口都实现类时，必需实现该接口都所有抽象方法。这有时明显比较浪费，因为并不是所有方法都是我们需要的，有时只需要一些，此处为了解决这个问题，引入类接口的适配器模式，借助于一个抽象类，该抽象类实现类该接口，实现类所有都方法，而我们不和原始接口打交道，只和该抽象类取得联系，所以我们写一个类继承该抽象类，重写我们需要都方法就行
-
-
装饰模式(Decorator):装饰模式就是给对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例
//创建接口
public interface Sourceable{
public void method();
}
//创建被装饰实例都对象
public class Source implements Sourceable{
-
策略模式：策略模式定义类一系列算法，并将每个算法分装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现累提供统一 的方法，多个实现类实现该接口，设计一个抽象类(可有可无，作为辅助类)，提供辅助函数。策略模式都决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可
//创建接口
public interface ICalculator{
public int calculate(String exp);
}
//创建具体实现方法都类
public class AbstractCalculator{
public int[] split(String exp,String opt){
String []array=exp.split(opt);
int arrayInt[]=new int[2];
arrayInt[0]=Integer.parseInt(array[0]);
arrayInt[1]=Integer.parseInt(array[1]);
return arrayInt;
}
}
//创建做减法都类
public class Minus extends AbstractCalculator implements ICalculator{
-
观察者模式：类似于邮件订阅和RSS订阅，当我们浏览一些博客或者wiki时，精华先给看到RSS图标，意思是，当我们订阅了该文章时，如果后续又更新，会及时通知你。简单来说，就是当一个对象发生变化时，其它依赖该对象都对象都会收到通知，并且随着变化，对象之间是一种一对多都关系
//创建观察者接口
public interface Observer{
public void update();
}
//创建类Observer1实现Observer接口
public class Observer1 implements Observer{
-
-