java基础2

一、Java中的反射

1、说说你对Java中反射的理解

       Java中的反射首先是能够获取到Java中要反射类的字节码，获取字节码有三种方法，
       1、Class.forName(className) 
       2、类名.class 
       3、this.getClass()。
       然后将字节码中的方法，变量，构造函数等映射成相应的Method、Filed、Constructor等类，这些类提供了丰富的方法可以被我们所使用。

二、Java中的动态代理

1、写一个ArrayList的动态代理类（笔试题）

1. final List<String> list = new ArrayList<String>();
   
2. List<String> proxyInstance = (List<String>) Proxy.newProxyInstance(list.getClass().getClassLoader(), 
   
3.         list.getClass().getInterfaces(), new InvocationHandler() {
   
4.                     @Override
   
5.                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
6.                             return method.invoke(list, args);
   
7.                     }
   
8.             }
   
9. );
   
10. proxyInstance.add("你好");
    
11. System.out.println(list);
    

复制代码

三、Java中的设计模式

1、你所知道的设计模式有哪些

       

       Java中一般认为有23种设计模式，我们不需要所有的都会，但是其中常用的几种设计模式应该去掌握。下面列出了所有的设计模式。需要掌握的设计模式我单独列出来了，当然能掌握的越多越好。

总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

2、单例设计模式

最好理解的一种设计模式，分为懒汉式和饿汉式。

饿汉式：

1. public class Singleton {
   
2.         // 直接创建对象
   
3.         public static Singleton instance = new Singleton();
   
4. 
   
5.         // 私有化构造函数
   
6.         private Singleton() {
   
7.         }
   
8. 
   
9.         // 返回对象实例
   
10.         public static Singleton getInstance() {
    
11.                 return instance;
    
12.         }
    
13. }

复制代码

懒汉式：

1. public class Singleton {
   
2.         // 声明变量
   
3.         private static volatile Singleton singleton2 = null;
   
4. 
   
5.         // 私有构造函数
   
6.         private Singleton2() {
   
7.         }
   
8. 
   
9.         // 提供对外方法
   
10.         public static Singleton2 getInstance() {
    
11.                 if (singleton2 == null) {
    
12.                         synchronized (Singleton2.class) {
    
13.                                 if (singleton == null) {
    
14.                                         singleton = new Singleton();
    
15.                                 }
    
16.                         }
    
17.                 }
    
18.                 return singleton;
    
19.         }
    
20. }
    

复制代码

3、工厂设计模式

       工厂模式分为工厂方法模式和抽象工厂模式。

       工厂方法模式分为三种：

       1、普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

       2、多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。

       3、静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

       普通工厂模式

1. public interface Sender {
   
2.         public void Send();
   
3. }
   
4. public class MailSender implements Sender {
   
5. 
   
6.         @Override
   
7.         public void Send() {
   
8.                 System.out.println("this is mail sender!");
   
9.         }
   
10. }
    
11. public class SmsSender implements Sender {
    
12. 
    
13.         @Override
    
14.         public void Send() {
    
15.                 System.out.println("this is sms sender!");
    
16.         }
    
17. }
    
18. public class SendFactory {
    
19.         public Sender produce(String type) {
    
20.                 if ("mail".equals(type)) {
    
21.                         return new MailSender();
    
22.                 } else if ("sms".equals(type)) {
    
23.                         return new SmsSender();
    
24.                 } else {
    
25.                         System.out.println("请输入正确的类型!");
    
26.                         return null;
    
27.                 }
    
28.         }
    
29. }

复制代码

       多个工厂方法模式

       该模式是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。

1. public class SendFactory {
   
2.         public Sender produceMail(){  
   
3.         return new MailSender();  
   
4.     }  
   
5.       
   
6.     public Sender produceSms(){  
   
7.         return new SmsSender();  
   
8.     }  
   
9. }  
   
10. 
    
11. public class FactoryTest {
    
12.         public static void main(String[] args) {
    
13.                 SendFactory factory = new SendFactory();
    
14.                 Sender sender = factory.produceMail();
    
15.                 sender.send();
    
16.         }
    
17. }

复制代码

       静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

1. public class SendFactory {
   
2.         public static Sender produceMail(){  
   
3.         return new MailSender();  
   
4.     }  
   
5.       
   
6.     public static Sender produceSms(){  
   
7.         return new SmsSender();  
   
8.     }  
   
9. }  
   
10. 
    
11. 
    
12. public class FactoryTest {
    
13.         public static void main(String[] args) {
    
14.                 Sender sender = SendFactory.produceMail();
    
15.                 sender.send();
    
16.         }
    
17. }

复制代码

       抽象工厂模式

       工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

1. public interface Provider {
   
2.         public Sender produce();
   
3. }
   
4. 
   
5. public interface Sender {
   
6.         public void send();
   
7. }
   
8. 
   
9. public class MailSender implements Sender {
   
10. 
    
11.         @Override
    
12.         public void send() {
    
13.                 System.out.println("this is mail sender!");
    
14.         }
    
15. }
    
16. 
    
17. public class SmsSender implements Sender {
    
18. 
    
19.         @Override
    
20.         public void send() {
    
21.                 System.out.println("this is sms sender!");
    
22.         }
    
23. }
    
24. 
    
25. public class SendSmsFactory implements Provider {
    
26. 
    
27.         @Override
    
28.         public Sender produce() {
    
29.                 return new SmsSender();
    
30.         }
    
31. }
    
32. public class SendMailFactory implements Provider {
    
33. 
    
34.         @Override
    
35.         public Sender produce() {
    
36.                 return new MailSender();
    
37.         }
    
38. }
    
39. 
    
40. public class Test {
    
41.         public static void main(String[] args) {
    
42.                 Provider provider = new SendMailFactory();
    
43.                 Sender sender = provider.produce();
    
44.                 sender.send();
    
45.         }
    
46. }

复制代码

4、建造者模式（Builder）

       工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。

1. public class Builder {
   
2.         private List<Sender> list = new ArrayList<Sender>();
   
3. 
   
4.         public void produceMailSender(int count) {
   
5.                 for (int i = 0; i < count; i++) {
   
6.                         list.add(new MailSender());
   
7.                 }
   
8.         }
   
9. 
   
10.         public void produceSmsSender(int count) {
    
11.                 for (int i = 0; i < count; i++) {
    
12.                         list.add(new SmsSender());
    
13.                 }
    
14.         }
    
15. }
    
16. 
    
17. public class TestBuilder {
    
18.         public static void main(String[] args) {
    
19.                 Builder builder = new Builder();
    
20.                 builder.produceMailSender(10);
    
21.         }
    
22. }

复制代码

5、适配器设计模式

       适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

       类的适配器模式

1. public class Source {
   
2.         public void method1() {
   
3.                 System.out.println("this is original method!");
   
4.         }
   
5. }
   
6. 
   
7. public interface Targetable {
   
8.         /* 与原类中的方法相同 */
   
9.         public void method1();
   
10.         /* 新类的方法 */
    
11.         public void method2();
    
12. }
    
13. 
    
14. public class Adapter extends Source implements Targetable {
    
15.         @Override
    
16.         public void method2() {
    
17.                 System.out.println("this is the targetable method!");
    
18.         }
    
19. }
    
20. 
    
21. public class AdapterTest {
    
22.         public static void main(String[] args) {
    
23.                 Targetable target = new Adapter();
    
24.                 target.method1();
    
25.                 target.method2();
    
26.         }
    
27. }
    

复制代码

       对象的适配器模式

       基本思路和类的适配器模式相同，只是将Adapter类作修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。

1. public class Wrapper implements Targetable {
   
2.         private Source source;
   
3. 
   
4.         public Wrapper(Source source) {
   
5.                 super();
   
6.                 this.source = source;
   
7.         }
   
8. 
   
9.         @Override
   
10.         public void method2() {
    
11.                 System.out.println("this is the targetable method!");
    
12.         }
    
13. 
    
14.         @Override
    
15.         public void method1() {
    
16.                 source.method1();
    
17.         }
    
18. }
    
19. 
    
20. public class AdapterTest {                    
    
21.     public static void main(String[] args) {  
    
22.         Source source = new Source();  
    
23.         Targetable target = new Wrapper(source);  
    
24.         target.method1();  
    
25.         target.method2();  
    
26.     }  
    
27. }  
    

复制代码

       接口的适配器模式

       接口的适配器是这样的：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。

6、装饰模式（Decorator）

       顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

1. public interface Sourceable {
   
2.         public void method();
   
3. }
   
4. 
   
5. public class Source implements Sourceable {
   
6.         @Override
   
7.         public void method() {
   
8.                 System.out.println("the original method!");
   
9.         }
   
10. }
    
11. 
    
12. public class Decorator implements Sourceable {
    
13.         private Sourceable source;
    
14.         public Decorator(Sourceable source) {
    
15.                 super();
    
16.                 this.source = source;
    
17.         }
    
18. 
    
19.         @Override
    
20.         public void method() {
    
21.                 System.out.println("before decorator!");
    
22.                 source.method();
    
23.                 System.out.println("after decorator!");
    
24.         }
    
25. }
    
26. 
    
27. public class DecoratorTest {
    
28.         public static void main(String[] args) {
    
29.                 Sourceable source = new Source();
    
30.                 Sourceable obj = new Decorator(source);
    
31.                 obj.method();
    
32.         }
    
33. }

复制代码

7、策略模式（strategy）

       策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数。策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可。

1. public interface ICalculator {
   
2.         public int calculate(String exp);
   
3. }
   
4. 
   
5. public class Minus extends AbstractCalculator implements ICalculator {
   
6. 
   
7.         @Override
   
8.         public int calculate(String exp) {
   
9.                 int arrayInt[] = split(exp, "-");
   
10.                 return arrayInt[0] - arrayInt[1];
    
11.         }
    
12. }
    
13. 
    
14. public class Plus extends AbstractCalculator implements ICalculator {
    
15. 
    
16.         @Override
    
17.         public int calculate(String exp) {
    
18.                 int arrayInt[] = split(exp, "\\+");
    
19.                 return arrayInt[0] + arrayInt[1];
    
20.         }
    
21. }
    
22. 
    
23. public class AbstractCalculator {
    
24.         public int[] split(String exp, String opt) {
    
25.                 String array[] = exp.split(opt);
    
26.                 int arrayInt[] = new int[2];
    
27.                 arrayInt[0] = Integer.parseInt(array[0]);
    
28.                 arrayInt[1] = Integer.parseInt(array[1]);
    
29.                 return arrayInt;
    
30.         }
    
31. }
    
32. 
    
33. public class StrategyTest {
    
34.         public static void main(String[] args) {
    
35.                 String exp = "2+8";
    
36.                 ICalculator cal = new Plus();
    
37.                 int result = cal.calculate(exp);
    
38.                 System.out.println(result);
    
39.         }
    
40. }

复制代码

8、观察者模式（Observer）

       观察者模式很好理解，类似于邮件订阅和RSS订阅，当我们浏览一些博客或wiki时，经常会看到RSS图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及时通知你。其实，简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。

1. public interface Observer {
   
2.         public void update();
   
3. }
   
4. 
   
5. public class Observer1 implements Observer {
   
6.         @Override
   
7.         public void update() {
   
8.                  System.out.println("observer1 has received!");  
   
9.         }
   
10. }
    
11. 
    
12. public class Observer2 implements Observer {
    
13.         @Override
    
14.         public void update() {
    
15.                  System.out.println("observer2 has received!");  
    
16.         }
    
17. }
    
18. 
    
19. public interface Subject {
    
20.          /*增加观察者*/  
    
21.     public void add(Observer observer);  
    
22.       
    
23.     /*删除观察者*/  
    
24.     public void del(Observer observer); 
    
25.     /*通知所有的观察者*/  
    
26.     public void notifyObservers();  
    
27.       
    
28.     /*自身的操作*/  
    
29.     public void operation();
    
30. }
    
31. 
    
32. public abstract class AbstractSubject implements Subject {
    
33. 
    
34.         private Vector<Observer> vector = new Vector<Observer>();
    
35. 
    
36.         @Override
    
37.         public void add(Observer observer) {
    
38.                 vector.add(observer);
    
39.         }
    
40. 
    
41.         @Override
    
42.         public void del(Observer observer) {
    
43.                 vector.remove(observer);
    
44.         }
    
45. 
    
46.         @Override
    
47.         public void notifyObservers() {
    
48.                 Enumeration<Observer> enumo = vector.elements();
    
49.                 while (enumo.hasMoreElements()) {
    
50.                         enumo.nextElement().update();
    
51.                 }
    
52.         }
    
53. }
    
54. 
    
55. public class MySubject extends AbstractSubject {
    
56. 
    
57.         @Override
    
58.         public void operation() {
    
59.                 System.out.println("update self!");  
    
60.         notifyObservers(); 
    
61.         }
    
62. }
    
63. 
    
64. public class ObserverTest {
    
65.         public static void main(String[] args) {
    
66.                 Subject sub = new MySubject();
    
67.                 sub.add(new Observer1());
    
68.                 sub.add(new Observer2());
    
69.                 sub.operation();
    
70.         }
    
71. }

复制代码