Java程序员面试题(二)JavaSE高级

如果觉得文章对您有一点点帮助,麻烦帮忙点个赞?哦

一、Java 中的反射

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

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

二、Java 中的动态代理

1. 写一个 ArrayList 的动态代理类(笔试题)

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

2. 动静态代理的区别,什么场景使用?

静态代理通常只代理一个类,动态代理是代理一个接口下的多个实现类。
静态代理事先知道要代理的是什么,而动态代理不知道要代理什么东西,只有在运行时才知道。
动态代理是实现 JDK 里的 InvocationHandler 接口的 invoke 方法,但注意的是代理的是接口,也就是你的业务类必须要实现接口,通过 Proxy 里的 newProxyInstance 得到代理对象。
还有一种动态代理 CGLIB,代理的是类,不需要业务类继承接口,通过派生的子类来实现代理。通过在运行时,动态修改字节码达到修改类的目的。
AOP 编程就是基于动态代理实现的,比如著名的 Spring 框架、Hibernate 框架等等都是动态代理的使用例子。

三、Java 中的设计模式&回收机制

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

Java 中一般认为有 23 种设计模式,我们不需要所有的都会,但是其中常用的几种设计模式应该去掌握。
总体来说设计模式分为三大类:
创建型模式,共五种:工厂方法模式抽象工厂模式单例模式建造者模式、原型模式。
结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式
行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

2. 单例设计模式

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

  • 饿汉式:
  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() {
		  if (singleton == null) {
			  synchronized (Singleton.class) {
				  if (singleton == null) {
					  singleton = new Singleton();
				  }
			  }
		  }
		  return singleton;
	  }
  }

详情请参考:Java设计模式(二)单例模式

3. 工厂设计模式

工厂模式分为工厂方法模式和抽象工厂模式。
1 工厂方法模式
工厂方法模式分为三种:普通工厂模式,就是建立一个工厂类,对实现了同一接口的一些类进行实例的创建。
多个工厂方法模式,是对普通工厂方法模式的改进,在普通工厂方法模式中,如果传递的字符串出错,则不能正确创建对象,而多个工厂方法模式是提供多个工厂方法,分别创建对象。
静态工厂方法模式,将上面的多个工厂方法模式里的方法置为静态的,不需要创建实例,直接调用即可。

1.1 普通工厂模式

public interface Sender {
	  public void Send();
  }
  public class MailSender implements Sender {
 
	  @Override
	  public void Send() {
		  System.out.println("this is mail sender!");
	  }
  }
  public class SmsSender implements Sender {
 
	  @Override
	  public void Send() {
		  System.out.println("this is sms sender!");
	  }
  }
  public class SendFactory {
	  public Sender produce(String type) {
		  if ("mail".equals(type)) {
			  return new MailSender();
		  } else if ("sms".equals(type)) {
			  return new SmsSender();
		  } else {
			  System.out.println("请输入正确的类型!");
			  return null;
		  }
	  }
  }
  

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

  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 factory = new SendFactory();
		  Sender sender = factory.produceMail();
		  sender.send();
	  }
  }

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

  public class SendFactory {
	  public static Sender produceMail(){ 
		  return new MailSender();
	  }
	 
	  public static Sender produceSms(){
		  return new SmsSender();
	  }
  }
 
 
  public class FactoryTest {
	  public static void main(String[] args) {
		  Sender sender = SendFactory.produceMail();
		  sender.send();
	  }
  }

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

  public interface Provider {
	  public Sender produce();
  }
  -------------------------------------------------------------------------------------
  public interface Sender {
	  public void send();
  }
  -------------------------------------------------------------------------------------
  public class MailSender implements Sender {
 
	  @Override
	  public void send() {
		  System.out.println("this is mail sender!");
	  }
  }
  -------------------------------------------------------------------------------------
  public class SmsSender implements Sender {
 
	  @Override
	  public void send() {
		  System.out.println("this is sms sender!");
	  }
  }
  -------------------------------------------------------------------------------------
  public class SendSmsFactory implements Provider {
 
	  @Override
	  public Sender produce() {
		  return new SmsSender();
	  }
  }
  public class SendMailFactory implements Provider {
 
	  @Override
	  public Sender produce() {
		  return new MailSender();
	  }
  }
  -------------------------------------------------------------------------------------
  public class Test {
	  public static void main(String[] args) {
		  Provider provider = new SendMailFactory();
		  Sender sender = provider.produce();
		  sender.send();
	  }
  }

详情请参考:Java设计模式(一)工厂模式

4. 建造者模式(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 TestBuilder {
	  public static void main(String[] args) {
		  Builder builder = new Builder();
		  builder.produceMailSender(10);
	  }
  }

5. 适配器设计模式

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

  public class Source {
	  public void method1() {
		  System.out.println("this is original method!");
	  }
  }
  -------------------------------------------------------------
  public interface Targetable {
	  /* 与原类中的方法相同 */
	  public void method1();
	  /* 新类的方法 */
	  public void method2();
  }
  public class Adapter extends Source implements Targetable {
	  @Override
	  public void method2() {
		  System.out.println("this is the targetable method!");
	  }
  }
  public class AdapterTest {
	  public static void main(String[] args) {
		  Targetable target = new Adapter();
		  target.method1();
		  target.method2();
	  }
  }

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

  public class Wrapper implements Targetable {
	  private Source source;
	 
	  public Wrapper(Source source) {
		  super();
		  this.source = source;
	  }
	 
	  @Override
	  public void method2() {
		  System.out.println("this is the targetable method!");
	  }
	 
	  @Override
	  public void method1() {
		  source.method1();
	  }
  }
  --------------------------------------------------------------
  public class AdapterTest {
 
	  public static void main(String[] args) {
		  Source source = new Source();
		  Targetable target = new Wrapper(source);
		  target.method1();
		  target.method2();
	  }
  } 

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

6. 装饰模式(Decorator)

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

  public interface Sourceable {
	  public void method();
  }
  ----------------------------------------------------
  public class Source implements Sourceable {
	  @Override
	  public void method() {
		  System.out.println("the original method!");
	  }
  }
  ----------------------------------------------------
  public class Decorator implements Sourceable {
	  private Sourceable source;
	  public Decorator(Sourceable source) {
		  super();
		  this.source = source;
	  }
 
	  @Override
	  public void method() {
		  System.out.println("before decorator!");
		  source.method();
		  System.out.println("after decorator!");
	  }
  }
  ----------------------------------------------------
  public class DecoratorTest {
	  public static void main(String[] args) {
		  Sourceable source = new Source();
		  Sourceable obj = new Decorator(source);
		  obj.method();
	  }
  }

7. 策略模式(strategy)

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

  public interface ICalculator {
	  public int calculate(String exp);
  }
  ---------------------------------------------------------
  public class Minus extends AbstractCalculator implements ICalculator {
 
	  @Override
	  public int calculate(String exp) {
		  int arrayInt[] = split(exp, "-");
		  return arrayInt[0] - arrayInt[1];
	  }
  }
  ---------------------------------------------------------
  public class Plus extends AbstractCalculator implements ICalculator {
 
	  @Override
	  public int calculate(String exp) {
		  int arrayInt[] = split(exp, "\\+");
		  return arrayInt[0] + arrayInt[1];
	  }
  }
  --------------------------------------------------------
  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 StrategyTest {
	  public static void main(String[] args) {
		  String exp = "2+8";
		  ICalculator cal = new Plus();
		  int result = cal.calculate(exp);
		  System.out.println(result);
	  }
  }

8. 观察者模式(Observer)

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

  public interface Observer {
	  public void update();
  }
 
  public class Observer1 implements Observer {
	  @Override
	  public void update() {
		  System.out.println("observer1 has received!");
	  }
  }
 
  public class Observer2 implements Observer {
	  @Override
	  public void update() {
		  System.out.println("observer2 has received!");
	  }
  }
 
  public interface Subject {
	  /*增加观察者*/
	  public void add(Observer observer);
	 
	  /*删除观察者*/
	  public void del(Observer observer);
	  /*通知所有的观察者*/
	  public void notifyObservers();
	  
	  /*自身的操作*/
	  public void operation();
  }
 
  public abstract class AbstractSubject implements Subject {
 
	  private Vector<Observer> vector = new Vector<Observer>();
	 
	  @Override
	  public void add(Observer observer) {
		  vector.add(observer);
	  }
	 
	  @Override
	  public void del(Observer observer) {
		  vector.remove(observer);
	  }
	 
	  @Override
	  public void notifyObservers() {
		  Enumeration<Observer> enumo = vector.elements();
		  while (enumo.hasMoreElements()) {
			  enumo.nextElement().update();
		  }
	  }
  }
 
  public class MySubject extends AbstractSubject {
 
	  @Override
	  public void operation() {
		  System.out.println("update self!");
		  notifyObservers();
	  }
  }
 
  public class ObserverTest {
	  public static void main(String[] args) {
		  Subject sub = new MySubject();
		  sub.add(new Observer1());
		  sub.add(new Observer2());
		  sub.operation();
	  }
  }

未完待续

注:
内容截取自:黑马程序员Java面试宝典
仅供学习使用

发布了10 篇原创文章 · 获赞 61 · 访问量 5515
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览