面试准备之--java进阶（涉及对象拷贝、反射、设计模式）

1对象拷贝

1.1 对象的浅拷贝

浅复制(浅克隆)被复制对象的所有变量都含有与原来对象相同的值，而所有的对其他对象的引用仍然只指向原来的对象，换言之，浅复制仅仅复制锁考虑的对象，而不复制它所引用的对象。

 

public class Studentimplements Cloneable{  String name;  int age;  Student(String name,int age){   this.name=name;   this.age=age;  }    public Object clone(){   Object o =null;   try{    o=super.clone();//Object中的clone()识别出你要复制的哪一个对象   }   catch(CloneNotSupportedException e){    System.out.println(e.toString());   }   return o;  }    public static void main(String[] args){   Student s1 = new Student("zhang",18);   Student s2 = (Student)s1.clone();   s2.name="li";   s2.age=20;   System.out.println("name="+s1.name+","+"age="+s1.age);//修改学生2后不影响学生1的值    } }

 

 

1.2 对象深拷贝

深复制(深克隆)被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量，那些引用其他对象的变量将指向被复制过的新对象，而不再试原有的那些被引用的对象，换言之，深复制把要复制的对象所引用的对象都复制了一遍。

把对象写到流里的过程是串行化（Serilization）过程，但是在Java程序师圈子里又非常形象地称为“冷冻”或者“腌咸菜（picking）”过程；而把对象从流中读出来的并行化（Deserialization）过程则叫做“解冻”或者“回鲜(depicking)”过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。

在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里（腌成咸菜），再从流里读出来（把咸菜回鲜），便可以重建对象。

public Object deepClone() {  //将对象写到流里  ByteArrayOutoutStream bo=new ByteArrayOutputStream();  ObjectOutputStream oo=new ObjectOutputStream(bo);  oo.writeObject(this);  //从流里读出来  ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());  ObjectInputStream oi=new ObjectInputStream(bi);  return(oi.readObject()); }

 

1. 内存溢出

由于Java具备自动的垃圾回收机制,当我们使用完对象之后,它们会被自动回收,是不是我们在Java程序中不需要再考虑内存管理了吗?

请看如下程序:

class Stack { private Object[] elements; // 初始化角标 int index = 0; // 默认初始化容量 private int initialCapacity = 10;   public Stack() { elements = new Object[initialCapacity]; }   // 压栈 push public void push(Object e) { ensureCapacity(); elements[index++] = e; // System.out.println(index); }   // 弹栈 pop public Object pop() { if (index == 0) { throw new RuntimeException("没有元素"); } return elements[--index]; }   private void ensureCapacity() { if (index ==elements.length) { elements = Arrays.copyOf(elements,index * 2 + 1); } } }

注意:从栈中弹出的对象不会作为垃圾回收,即使程序不再使用这些对象,因为栈内部继续维护着这些对象.最终可能会导致内存占用的不断增加,程序性能降低.这就是内存泄漏.

改进版本

class Stack { private Object[] elements; // 初始化角标 int index = 0; // 默认初始化容量 private int initialCapacity = 10;   public Stack() { elements = new Object[initialCapacity]; }   // 压栈 push public void push(Object e) { ensureCapacity(); elements[index++] = e; // System.out.println(index); }   // 弹栈 pop public Object pop() { if (index == 0) { throw new RuntimeException("没有元素"); } Object obj = elements[--index]; elements[index] =null; return obj; }   private void ensureCapacity() { if (index ==elements.length) { elements = Arrays.copyOf(elements,index * 2 + 1); } } }

 

2. 设计模式

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

2.1. 观察者模式

有时又被称为

发布-订阅<Publish/Subscribe>模式、

模型-视图<Model/View>模式、

源-收听者<Source/Listener>模式

或从属者<Dependents>模式）

这是软件设计模式的一种。

观察者模式（Observer）完美的将观察者和被观察的对象分离开。

此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。

这通常透过呼叫各观察者所提供的方法来实现。

此种模式通常被用来实作事件处理系统。

有多个观察者时，不可以依赖特定的通知次序。

Swing大量使用观察者模式，许多GUI框架也是如此。

气象站：

public class WeatherStation { private String weather; String[] weathers = {"下雨","下雪","下冰雹","出太阳"}; static List<BookWeather>list = new ArrayList<BookWeather>(); Random random = new Random(); public void startWork(){ new Thread(){ @Override public void run() { while(true){ updateWeather(); try { Thread.sleep(random.nextInt(1000)+500); } catch (InterruptedException e) { e.printStackTrace(); } } } }.start(); } public void updateWeather(){ weather = weathers[random.nextInt(4)]; System.out.println("天气："+weather); } public String getWeather() { return weather; }

人：

public class Personimplements BookWeather { String name; public  Person(String name){ this.name = name; } private WeatherStationstation ; public Person(String name,WeatherStation station){ this(name); this.station = station; } //下雨","下雪","下冰雹","出太阳" @Override public void notifyWeather() { String weather = station.getWeather(); if("下雨".equals(weather)){ System.out.println(name+"打着雨伞上班"); }else if("下雪".equals(weather)){ System.out.println(name+"溜冰 上班"); }else if("下冰雹".equals(weather)){ System.out.println(name+"带着头盔 上班"); }else if("出太阳".equals(weather)){ System.out.println(name+"嗮着太阳 上班"); } } }

 

测试类：

public class Test { public static void main(String[] args)throws InterruptedException { WeatherStation station = new WeatherStation(); station.startWork(); Person p1 = new Person("小明",station); while(true){ p1.notifyWeather(); Thread.sleep(2000); } }

问题：天气变化两三次，小明才知道一次。

解决方案 ：

package cn.itcast.test; import java.util.List; import java.util.ArrayList; import java.util.Random; public class WeatherStation { private String weather; String[] weathers = {"下雨","下雪","下冰雹","出太阳"}; private static List<BookWeather> list = new ArrayList<BookWeather>(); Random random = new Random(); public void addListaner(BookWeather e){ list.add(e); } public void startWork(){ new Thread(){ @Override public void run() { while(true){ updateWeather(); try { Thread.sleep(random.nextInt(1000)+500); } catch (InterruptedException e) { e.printStackTrace(); } } } }.start(); } public void updateWeather(){ weather = weathers[random.nextInt(4)]; System.out.println("天气："+ weather); for(BookWeather item : list){ item.notifyWeather(weather); } } public String getWeather() { return weather; }

 

人：

public class Personimplements BookWeather { String name; public  Person(String name){ this.name = name; } private WeatherStation station ; public Person(String name,WeatherStation station){ this(name); this.station = station; } //下雨","下雪","下冰雹","出太阳" @Override public void notifyWeather(String weather) { if("下雨".equals(weather)){ System.out.println(name+"打着雨伞上班"); }else if("下雪".equals(weather)){ System.out.println(name+"溜冰 上班"); }else if("下冰雹".equals(weather)){ System.out.println(name+"带着头盔 上班"); }else if("出太阳".equals(weather)){ System.out.println(name+"嗮着太阳 上班"); } }

}

接口:

 

public interface BookWeather { public void notifyWeather(Stringweather); }

 

 

public class Test { public static void main(String[] args)throws InterruptedException { WeatherStation station = new WeatherStation(); station.startWork(); Person p1 = new Person("小明"); Person p2 = new Person("小红"); Person p3 = new Person("小青"); station.addListaner(p1); station.addListaner(p2); station.addListaner(p3); } }

 

 

2.2.  单例

java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。
　　单例模式有以下特点：
　　1、单例类只能有一个实例。
　　2、单例类必须自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。
　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。

一、懒汉式单例

[java]  view plain  copy

 print ?

1. //懒汉式单例类.在第一次调用的时候实例化自己   
2. public class Singleton {  
3.     private Singleton() {}  
4.     private static Singleton single=null;  
5.     //静态工厂方法   
6.     public static Singleton getInstance() {  
7.          if (single == null) {    
8.              single = new Singleton();  
9.          }    
10.         return single;  
11.     }  
12. }  

Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。

（事实上，通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。此问题在此处不做讨论，姑且掩耳盗铃地认为反射机制不存在。）

但是以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造，保证了懒汉式单例的线程安全，如果你第一次接触单例模式，对线程安全不是很了解，可以先跳过下面这三小条，去看饿汉式单例，等看完后面再回头考虑线程安全的问题：

1、在getInstance方法上加同步

[java]  view plain  copy

 print ?

1. public static synchronized Singleton getInstance() {  
2.          if (single == null) {    
3.              single = new Singleton();  
4.          }    
5.         return single;  
6. }  

2、双重检查锁定

[java]  view plain  copy

 print ?

1. public static Singleton getInstance() {  
2.         if (singleton == null) {    
3.             synchronized (Singleton.class) {    
4.                if (singleton == null) {    
5.                   singleton = new Singleton();   
6.                }    
7.             }    
8.         }    
9.         return singleton;   
10.     }  

3、静态内部类

[java]  view plain  copy

 print ?

1. public class Singleton {    
2.     private static class LazyHolder {    
3.        private static final Singleton INSTANCE = new Singleton();    
4.     }    
5.     private Singleton (){}    
6.     public static final Singleton getInstance() {    
7.        return LazyHolder.INSTANCE;    
8.     }    
9. }    

这种比上面1、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。

二、饿汉式单例

[java]  view plain  copy

 print ?

1. //饿汉式单例类.在类初始化时，已经自行实例化   
2. public class Singleton1 {  
3.     private Singleton1() {}  
4.     private static final Singleton1 single = new Singleton1();  
5.     //静态工厂方法   
6.     public static Singleton1 getInstance() {  
7.         return single;  
8.     }  
9. }  

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

3. 反射

类字节码文件是在硬盘上存储的，是一个个的.class文件。我们在new一个对象时，JVM会先把字节码文件的信息读出来放到内存中，第二次用时，就不用在加载了，而是直接使用之前缓存的这个字节码信息。

 

字节码的信息包括：类名、声明的方法、声明的字段等信息。在Java中“万物皆对象”，这些信息当然也需要封装一个对象，这就是Class类、Method类、Field类。

 

通过Class类、Method类、Field类等等类可以得到这个类型的一些信息，甚至可以不用new关键字就创建一个实例，可以执行一个对象中的方法，设置或获取字段的值，这就是反射技术。

3.1. Class类

1.1.1. 获取Class对象的三种方式

 

Java中有一个Class类用于代表某一个类的字节码。

Java提供了三种方式获取类的字节码

forName()。forName方法用于加载某个类的字节码到内存中，并使用class对象进行封装

类名.class

对象.getClass()

 

/**  * 加载类的字节码的3种方式  * @throws Exception  * */ public void test1()throws Exception { // 方式一 Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person"); // 方式二 Class clazz2 = Person.class; // 方式三 Person p1 = new Person(); Class clazz3 = p1.getClass(); }

1.1.2. 通过Class类获取类型的一些信息

1. getName()类的名称（全名，全限定名）

2 getSimpleName()类的的简单名称（不带包名）

3. getModifiers(); 类的的修饰符

4.创建对象

无参数构造创建对象

newInstance()

5. 获取指定参数的构造器对象，并可以使用Constructor对象创建一个实例

Constructor<T> getConstructor(Class<?>... parameterTypes)

/**  * 通过Class对象获取类的一些信息  *  * @throws Exception  * */ private static void test2()throws Exception {   Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person"); // 获取类的名称 String name = clazz1.getName(); System.out.println(name); // cn.itcast.gz.reflect.Person // 获取类的简单名称 System.out.println(clazz1.getSimpleName());// Person // 获取类的修饰符 int modifiers = clazz1.getModifiers(); System.out.println(modifiers); // 构建对象(默认调用无参数构造.) Object ins = clazz1.newInstance(); Person p = (Person) ins; System.out.println(p); // cn.itcast.gz.reflect.Person@c17164 // 获取指定参数的构造函数 Constructor<?> con = clazz1.getConstructor(String.class,int.class); // 使用Constructor创建对象. Object p1 = con.newInstance("jack", 28); System.out.println(((Person) p1).getName()); }

 

1.1.3. 通过Class类获取类型中的方法的信息

1.获取公共方法包括继承的父类的方法

getMethods()返回一个数组,元素类型是Method

2.获取指定参数的公共方法

getMethod("setName", String.class);

3.获得所有的方法,包括私有

Method[] getDeclaredMethods()  

4.获得指定参数的方法,包括私有

Method getDeclaredMethod(String name, Class<?>... parameterTypes)

/**  * 获取公有方法.  * @throws Exception  * */ private static void test3()throws Exception { Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person"); // 1.获取非私用方法(包括父类继承的方法) Method[] methods = clazz1.getMethods(); System.out.println(methods.length); for (Method m : methods) { // System.out.println(m.getName()); if ("eat".equals(m.getName())) { m.invoke(clazz1.newInstance(), null); } }   }

 

/**  * 获取指定方法签名的方法  *  * @throws Exception  * */ private static void test4()throws Exception { Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person"); // 获取指定名称的函数 Method method1 = clazz1.getMethod("eat",null); method1.invoke(new Person(),null); }

 

/**  * 获取指定方法名且有参数的方法  *  * @throws Exception  * */ private static void test5()throws Exception { Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person"); Method method = clazz1.getMethod("eat", String.class); method.invoke(new Person(),"包子"); }   /**  * 获取指定方法名,参数列表为空的方法.  *  * @throws Exception  * */ private static void test4()throws Exception { Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person"); // 获取指定名称的函数 Method method1 = clazz1.getMethod("eat",null); method1.invoke(new Person(),null); }

 

/**  * 反射静态方法  * @throws Exception  * */ private static void test7()throws Exception { Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person"); Method method = clazz1.getMethod("play",null); method.invoke(null,null); }   /**  * 访问私有方法 暴力反射  * @throws Exception  * */ private static void test6()throws Exception { Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person"); Method method = clazz1.getDeclaredMethod("movie", String.class); method.setAccessible(true); method.invoke(new Person(),"苍老师"); }

 

1.1.4. 通过Class类获取类型中的字段的信息

1.获取公共字段

Field[] getFields()  

2.获取指定参数的公共字段

Field getField(String name)  

3.获取所有的字段

Field[] getDeclaredFields()  

4.获取指定参数的字段,包括私用

Field getDeclaredField(String name)  

 

/**  * 获取公有的字段  * */ private static void test8()throws Exception { Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person"); Field[] fields = clazz1.getFields(); Person p = new Person(); System.out.println(fields.length); for (Field f : fields) { System.out.println(f.getName()); if ("name".equals(f.getName())) { System.out.println(f.getType().getName()); f.set(p, "jack"); } } System.out.println(p.getName());   }

 

/**  * 获取私有的字段  * @throws Exception  * */ private static void test9()throws Exception { Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person"); Field field = clazz1.getDeclaredField("age"); System.out.println(field.getName()); field.setAccessible(true); Person p = new Person(); field.set(p, 100); System.out.println(p.getAge()); }

 

3.2.  工厂模式

可参考播客：Factorhttp://www.cnblogs.com/zhouqiang/archive/2012/07/20/2601365.htmly

例如:汽车销售商场

 

该模式将创建对象的过程放在了一个静态方法中来实现.在实际编程中,如果需要大量的创建对象,该模式是比较理想的.

public class Demo1 { public static void main(String[] args) { System.out.println("买宝马"); Car bmw = CarFactory("BMW"); bmw.run(); System.out.println("买大奔"); Car benz = CarFactory("Benz"); benz.run(); }   public static Car CarFactory(String carName) { if ("BMW".equals(carName)) { return new BMW(); } else if ("Benz".equals(carName)) { return new Benz(); } else { throw new RuntimeException("车型有误"); } } }   abstract class Car {   public abstract void run(); }   class BMW extends Car {   @Override public void run() { System.out.println("BMW跑跑"); } }   class Benz extends Car {   @Override public void run() { System.out.println("Benz跑跑"); } }

 

模拟spring工厂：

import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.lang.reflect.Constructor; import java.lang.reflect.Field; class Student{ private int id; private  String name; public Student(int id , String name){ this.id = id; this.name = name; } public Student(){ } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { return this.id +"-"+this.name; } } class Person{ private int age; public Person(){ } @Override public String toString() { return this.age+""; } } public class Demo1 { public static void main(String[] args)throws Exception { Object o = getInstance(); System.out.println(o); } public static Object getInstance()throws Exception{ FileReader fileReader = new FileReader("src/info.txt"); BufferedReader bufferedReader = new BufferedReader(fileReader); String line = bufferedReader.readLine(); Class clazz  = Class.forName(line); Constructor c =  clazz.getConstructor(null); Object c1 = c.newInstance(null); while((line=bufferedReader.readLine())!=null){ String[] datas =  line.split("="); Field f = clazz.getDeclaredField(datas[0]); f.setAccessible(true); if(f.getType()==int.class){ f.set(c1, Integer.parseInt(datas[1])); }else{ //f.setAccessible(true); f.set(c1,datas[1]); } } return c1; } }