创建对象
1. 构造器创建对象
Student stu1 = new Student("kygo", 100);
System.out.println(stu1);
2. 通过克隆创建对象(内存复制)
实现Cloneable接口，重写clone()方法
@Override
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
throw new RuntimeException();
}
}
测试
Student stu2 = (Student) stu1.clone();
System.out.println(stu2);
3. 通过反序列化创建对象(从流中读取对象)
实现序列化接口Serializable
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(out);
oos.writeObject(stu2);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
ObjectInputStream ois = new ObjectInputStream(in);
Student stu3 = (Student) ois.readObject();
System.out.println(stu3);
4. 通过反射(reflection)创建对象
拿到一个类的原始数据类对象
1.根据路径
Class<?> clazz1 = Class.forName("com.kygo.Student");
2.用类.class
Class<?> clazz2 = Student.class;
3.用类对象实例的getClass()方法
Class<?> clazz3 = stu3.getClass();
根据类的类对象可以创建这个类的对象实例
Student stu4 = (Student) clazz1.newInstance();
根据类的类对象使用getConstructor()方法的到这个类的构造器，使用构造器可以创建对象
Constructor<?> constructor = clazz2.getConstructor(String.class, int.class);
Student stu5 = (Student) constructor.newInstance("wang Dachui", 18);
测试：
Class<?> clazz1 = Class.forName("com.kygo.Student");
Class<?> clazz2 = Student.class;
Class<?> clazz3 = stu3.getClass();
// System.out.println(clazz1 == clazz2); // true
// System.out.println(clazz2 == clazz3); // true
Student stu4 = (Student) clazz1.newInstance();
System.out.println(stu4);
// System.out.println(stu4.getName());
Constructor<?> constructor = clazz2.getConstructor(String.class, int.class);
Student stu5 = (Student) constructor.newInstance("wang Dachui", 18);
System.out.println(stu5);
// System.out.println(stu5.getName());
// System.out.println(stu5.getAge());
Constructor<?>[] constructors = clazz3.getConstructors();
for (Constructor<?> temp : constructors) {
Student stu6 = (Student) temp.newInstance();
System.out.println(stu6);
}
设计模式
单例
单例 - 让一个类只能创建出一个对象(服务器上常用)
- 将构造器私有(不允许直接使用构造器创建对象)
- 通过公开的静态的方法向外界返回该类的唯一实例
饿汉式单例
public class StudentManager {
private static StudentManager instance = new StudentManager();
// ...
private StudentManager() {
}
public static StudentManager getInstance() {
return instance;
}
// ...
}
懒汉式单例(懒加载单例)
public class StudentManager {
private static StudentManager instance = null;
// ...
private StudentManager() {
}
public static synchronized StudentManager getInstance() {
if (instance == null) {
instance = new StudentManager();
}
return instance;
}
// ...
}
登记式单例
public class ServiceFactory {
private static Map<Class<?>, Object> map = new HashMap<>();
// 登记式单例
static {
map.put(DeptService.class,
ServiceProxy.getProxyInstance(new DeptServiceImpl()));
map.put(EmpService.class,
ServiceProxy.getProxyInstance(new EmpServiceImpl()));
}
private ServiceFactory() {
throw new AssertionError();
}
public static Object factory(Class<?> serviceType) {
return map.get(serviceType);
}
}
一般类里面没有状态属性都可以改造成单例模式类
简单工厂模式
简单工厂模式(静态工厂模式)
将对象的实例化过通过工厂方法隐藏起来
使得对象的使用者可以和具体的对象以及创建对象的过程解耦合
例子1:在工厂用构造器创建对象
工厂类：
public class FruitFactory {
public static Fruit factory(String type) {
Fruit fruit = null;
switch (type.toLowerCase()) {
case "apple":
fruit = new Apple();
break;
case "banana":
fruit = new Banana();
break;
case "durian":
fruit = new Durian();
break;
}
return fruit;
}
}
测试：
Fruit apple = FruitFactory.factory("apple");
Fruit durian = FruitFactory.factory("durian");
Fruit grape = FruitFactory.factory("grape");
System.out.println(apple);
System.out.println(durian);
System.out.println(grape);
例子2：使用反射
工厂类：
public class FruitFactory {
public static Fruit factory(String className) {
try {
Class<?> clazz = Class.forName(className);
return (Fruit) clazz.newInstance();
} catch (Exception e) {
// throw new RuntimeException();
return null;
}
}
public static Fruit factory(Class<?> fruitType) {
try {
return (Fruit) fruitType.newInstance();
} catch (Exception e) {
throw new RuntimeException();
}
}
}
测试：
Fruit apple = FruitFactory.factory(Apple.class);
Fruit durian = FruitFactory.factory(Durian.class);
Fruit grape = FruitFactory.factory("com.kygo.Grape");
System.out.println(apple);
System.out.println(durian);
System.out.println(grape);
动态代理
JDK 1.3引入了动态代理机制 - 可以通过反射的方式动态生成代理对象
InvocationHandler - invoke(Object, Method, Object[])
Proxy类 - newProxyInstance(ClassLoader, Class<?>[], InvocationHandler)
旧做法：创建代理类并实现要代理的类相同的接口，重写接口方法，在要代理的方法，添加自己的东西（日志等）
例子1：考生找枪手代考
考生接口：
public interface Candidate {
public void joinExam();
}
人类：
public class Person {
protected String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
懒学生：
public class LazyStudent extends Person implements Candidate {
public LazyStudent(String name) {
super(name);
}
@Override
public void joinExam() {
System.out.println("姓名: " + name);
}
}
枪手：
public class ExamAgent extends Person implements Candidate {
private Candidate target;
public ExamAgent(String name) {
super(name);
}
public void setTarget(Candidate target) {
this.target = target;
}
@Override
public void joinExam() {
target.joinExam();
System.out.println(name + "奋笔疾书答案.");
System.out.println(name + "答题完毕交卷.");
}
}
测试：
LazyStudent student = new LazyStudent("王大锤");
ExamAgent agent = new ExamAgent("骆昊");
agent.setTarget(student);
agent.joinExam();
现在：
- 第一步 创建代理类并实现InvocationHandler的接口
class ListProxy<E> implements InvocationHandler
- 第二步 添加被代理对象的属性，和代理对象的构造器 - 单例
private Object target; // 被代理的对象(目标对象)
private ListProxy(Object target) {
this.target = target;
}
- 第二步 实现静态方法getProxyInstance()拿到代理类对象
通过Proxy工具类的newProxyInstance方法生成动态代理
public static <E> Object getProxyInstance(Object target) {
Class<?> clazz = target.getClass();
// 通过Proxy工具类的newProxyInstance方法生成动态代理
// 第一个参数是被代理对象的类加载器
// 第二个参数是被代理对象实现的接口(被代理对象和代理对象要实现相同的接口)
// 第三个参数是实现了InvocationHandler接口的对象
return Proxy.newProxyInstance(clazz.getClassLoader(),
clazz.getInterfaces(), new ListProxy<E>(target));
}
- 第三步 重写回调方法invoke()
InvocationHandler接口(单方法接口/函数式接口)中的invoke方法是一个回调方法
当执行被代理对象target的任何一个方法时不是直接执行而是回调代理对象的invoke方法
该方法的第二个参数代表了需要执行的方法 第三个参数是执行方法时传入的参数
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
// InvocationHandler接口(单方法接口/函数式接口)中的invoke方法是一个回调方法
// 当执行被代理对象target的任何一个方法时不是直接执行而是回调代理对象的invoke方法
// 该方法的第二个参数代表了需要执行的方法 第三个参数是执行方法时传入的参数
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 被代理对象的所有方法都要通过代理对象来帮它调用执行
// 调用被代理对象的方法 第一个参数是被代理的对象 第二个参数是方法参数
// 如果被代理对象当前要执行的方法没有参数那么args的值就是null
// 如果被代理对象的方法有返回值那么retValue就保存该返回值
// 如果被代理对象的方法没有返回值那么retValue的值就是null
Object retValue = method.invoke(target, args);
// 如果执行的方法名以add、remove、clear、retain打头
// 那么通过下面代码给这些方法增加在控制台打印日志的功能
String methodName = method.getName();
// System.out.println("正在执行" + methodName + "方法");
if (methodName.startsWith("add") || methodName.startsWith("remove")
|| methodName.startsWith("clear") || methodName.startsWith("retain")) {
if (target instanceof List) {
List<E> list = (List<E>) target;
// 以下代码就是代理对象附加的行为(被代理对象没有的行为)
System.out.println("Size = " + list.size());
System.out.println(Arrays.toString(list.toArray()));
}
}
// 将之前执行被代理对象的方法得到的返回值返回
return retValue;
}
}
