笔记之_java整理设计模式

设计模式分类：
        创建型：new方法，实例化
        结构型：类的结合，套用
        行为型：方法的操作
必须掌握的设计模式：工厂、模板、单例、命令、适配器、代理
接口先定义，后实现
抽象类与接口：
光用继承会导致，父类一改变，子类就不得不改变，代码可复用
光用接口子类必须要重写父类所有方法，代码不能复用
反射机制：
反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制
反射机制主要提供了以下功能：
    在运行时判断任意一个对象所属的类；
    在运行时构造任意一个类的对象；
    在运行时判断任意一个类所具有的成员变量和方法；
    在运行时调用任意一个对象的方法；
    生成动态代理。
通过一个对象获得完整的包名和类名
new 类名().getClass().getName()
获得类
Class.forName("net.xsoftlab.baike.TestReflect");
new TestReflect().getClass();
TestReflect.class;
获取一个对象的父类与实现的接口
取得父类
Class<?> parentClass = clazz.getSuperclass();
获取所有的接口
Class<?> intes[] = clazz.getInterfaces();
通过反射机制实例化一个类的对象
实例化默认构造方法
User user = (User) class1.newInstance()
取得全部的构造函数 使用构造函数赋值
Constructor<?> cons[] = class1.getConstructors();
取得构造函数的参数
cons[i].getParameterTypes();
取得本类的全部属性
Field[] field = clazz.getDeclaredFields();
权限修饰符
int Modifier= field[i].getModifiers();
String priv = Modifier.toString(mo);
属性类型
Class<?> type = field[i].getType();
取得实现的接口或者父类的属性
Field[] filed1 = clazz.getFields();
取得类的全部方法
Method method[] = clazz.getMethods();
取得方法返回值类型
Class<?> returnType = method[i].getReturnType();
取得方法参数
Class<?> para[] = method[i].getParameterTypes();
取得方法修饰符
int temp = method[i].getModifiers();
取得方法异常类型
Class<?> exce[] = method[i].getExceptionTypes();
通过反射机制调用某个类的方法
Method method = clazz.getMethod("reflect1");
method.invoke(clazz.newInstance());
通过反射机制操作某个类的属性
可以直接对 private 的属性赋值
        Field field = clazz.getDeclaredField("proprety");
        field.setAccessible(true);
        field.set(obj, "Java反射机制");
在泛型为Integer的ArrayList中存放一个String类型的对象
public static void main(String[] args) throws Exception {
        ArrayList<Integer> list = new ArrayList<Integer>();
        Method method = list.getClass().getMethod("add", Object.class);
        method.invoke(list, "Java反射机制实例。");
        System.out.println(list.get(0));
 }
通过反射修改数组的值
Array.set(temp, 0, 100);
通过反射机制修改数组的大小
System.arraycopy(旧数组名, 0,新数组名, 0, 旧数组长度);
设计模式：前辈程序员在解决具体的程序开发问题时给出的方案经验
单例模式：程序中对于某个类型的对象只能有一份
构造方法私有化
        创建静态的唯一对象，初值为null
        提供公共的静态方法返回唯一对象(判断对象是否已被实例化过)
        public class SingletonClass{
private static SingletonClass instance=null;
private SingletonClass(){
        }
           public static　synchronized　SingletonClass getInstance(){
            if(instance==null){
                   instance=new SingletonClass();
            }
            return instance;
        }
}
递归调用：
    public class Test{
        public static void main(String[] args) {
            System.out.println(method(5));
        }
        public static int method(int n){
            if (n == 1){
                return 1;
            }else{
                return n * method(n-1);
            }
        }
}
代理模式：
为其他对象提供一种代理，并以控制对这个对象的访问
代理模式在不同的场景，都会要建立不同的接口，导致代码不能复用
        Java中提供了一种反射机制叫做动态代理
在java的动态代理机制中，有两个重要的类或接口，
一个是 InvocationHandler(Interface)
InvocationHandler这个接口的唯一一个方法 invoke 方法：
Object invoke(Object proxy, Method method, Object[] args) throws Throwable
proxy:　　指代我们所代理的那个真实对象
method:　　指代的是我们所要调用真实对象的某个方法的Method对象
args:　　指代的是调用真实对象某个方法时接受的参数
另一个则是 Proxy(Class)
Proxy这个类的作用就是用来动态创建一个代理对象的类
public static Object newProxyInstance(
ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h) throws IllegalArgumentException
loader:　　一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
interfaces:　一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
h:　　一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
代理实例：
        代理公共接口：
            public interface ReadInterface {
    public void reader();
}
        被代理人(客户)：
            public class person implements ReadInterface{
    @Override
    public void reader() {
        System.out.println("---------现在开始读书---------");
        System.out.println("---------读了一章---------");
        System.out.println("---------又读了一章--------");
        System.out.println("---------这一章节很精彩---------");
        System.out.println("---------读了一天了---------");
        System.out.println("---------读完了---------");
    }
}
        代理人：
            public class ProxyRead implements InvocationHandler{
    private Object subject;
    public ProxyRead(Object subject) {
        this.subject = subject;
    }
    public Object createProxy(){
        return Proxy.newProxyInstance(subject.getClass().getClassLoader(),
                subject.getClass().getInterfaces(),this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        long begin=System.currentTimeMillis();
        System.out.println("--------万能代理类开始做事情----------");
        Object obj=method.invoke(subject, args);
        System.out.println("--------万能代理类做完做事情----------");
        long end=System.currentTimeMillis();
        System.out.println("执行程序花了"+(end-begin)*1.0/1000+"秒");
        return obj;
    }
}
        测试类：
            public class Test {
    public static void main(String[] args) {
        ProxyRead pr=new ProxyRead(new person());
        ReadInterface read=(ReadInterface) pr.createProxy();
        read.reader();
    }
}

将反射机制应用于工厂模式
interface fruit {
    public abstract void eat();
}
class Apple implements fruit {
    public void eat() {
        System.out.println("Apple");
    }
}
class Orange implements fruit {
    public void eat() {
        System.out.println("Orange");
    }
}
class Factory {
    public static fruit getInstance(String ClassName) {
        fruit f = null;
        try {
            f = (fruit) Class.forName(ClassName).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return f;
    }
}
策略模式：将可变的能力设为接口，在公共的父类中，设为变量，并调用其方法，另有子类实现接口，并在具体继承抽象父类时为接口变量赋值
    抽象父类：
public abstract class Duck {
    private FlyAble flyAble = null;
    public void setFlyAble(FlyAble flyAble) {
        this.flyAble = flyAble;
    }
    public void fly() {
        // 飞对象.飞();
        flyAble.fly();
    }
    public void swim() {
        System.out.println("浮水......");
    }
public abstract void dispaly();
}
    接口：
        public interface FlyAble {
    public void fly();
}
    接口实现：
        public class RocketFly implements FlyAble{
    @Override
    public void fly() {
        System.out.println("借助火箭飞........");
    }
}
public class WingFly implements FlyAble {
    @Override
    public void fly() {
        System.out.println("用本身翅膀飞.....");
    }
}
    继承抽象类：
public class RedDuck extends Duck{
     public RedDuck() {
        super.setFlyAble(new WingFly());
    }
    @Override
    public void dispaly() {
         System.out.println("红头鸭，头是红的");
    }
}
    测试：
        public class Test {
    public static void main(String[] args) {
        test3();
    }
    public static void test3(){
        Duck duck=new RedDuck();
        //变性的    吱吱叫
        //火箭 绑上去，看一看飞行效果
        duck.setFlyAble(new RocketFly());
        duck.dispaly();
        duck.swim();
        duck.fly();
    }
}
模板模式：
public  class Benz{
public  void start(){
   System.out.println(“奔驰车启动”);
}
public void trunLeft(){
   System.out.println(“奔驰车左转弯”);
}
public void alerm(){
   System.out.println(“奔驰车响笛一声”);
}
public void stop(){
  System.out.println(“奔驰车停车”);
}
}
public  class BMW{
public  void start(){
   System.out.println(“宝马车启动”);
}
public void trunLeft(){
   System.out.println(“宝马车左转弯”);
}
public void alerm(){
   System.out.println(“宝马车响笛一声”);
}
public void stop(){
  System.out.println(“宝马车停车”);
}
}
模板：
public  abstract class Car{
public  abstract void start()
    public  abstract void trunLeft();
public  abstract  void alerm();
Public  abstract  void stop();
public  void begin(){
    this.start();
    this.trunLeft();
    this.alerm();
    this.stop();
}
}
时间： 2024-10-07 10:00:17

笔记之_java整理设计模式的相关文章

笔记之_Java整理Spring MVC

springMVC原理讲解地址:http://www.cnblogs.com/dragonfei/p/6148625.html Ionic2和angularjs2和angularjs和nosql菜鸟教程一起是做手机的 https://www.bilibili.com/video/av8614724/index_10.html是ionic2公开课地址 FreeCMS DeDeCMS风信网,数据库表结构 DEDECMS简单建站 Filter和Interceptor的区别 Filter是基于函数回调的

笔记之_Java整理IO流

线程重复执行: ScheduledExecutorService exec = Executors.newScheduledThreadPool(1); exec.scheduleAtFixedRate(线程名, 1, 1, TimeUnit.SECONDS); 字符输出流writer写完后要执行flush()方法,不然内容不存在 IO流:实时交互 Socket网络交互 多线程和socket合为一体 所有软件几乎都会有多线程,所有跟网络有关的必须要使用socket 大多数的程序只能循环运行单独的

笔记之_java整理html5

查看手机唯一标识:http://html5plus.org/doc/zh_cn/device.html#plus.device.uuid html和html5的区别? html5+css3也逐渐的成为新一代web前端技术,最要用处在开发手机网站. 文档网站:http://www.w3school.com.cn/html5/index.asp HTML5的新功能 (1).强大的绘图功能 (2).新增音频/视频标签 (3).浏览器离线存储 (4).通过浏览器进行定位 外网连接局域网的项目:花生壳?内

笔记之_java整理框架

This依赖于对象,static依赖于类 字符串的模糊查询: instr(empName,?)>0 empName like '%白%' Create view 表名 as 多表连接 视图是临时表 多表连接语句生成,查询工具点开 <T,K>泛型可以用多个 ResultSetMetaData取得列名集合,rst.getMetaData Reflect反射,Field[] 实例化对象方法: New student(); Student.class.newInstance(); Class.f

笔记之_java整理hibernate

页面调试数据: <%@taglib uri="/struts-tags" prefix="s" %> <s:debug></s:debug> Js清除缓存 使用hibernate延迟加载时,并且数据库有关联关系,转换成json对象时不能直接转换,要用new JSONObject(),然后put()方法存值 国外框架项目地址:http://websystique.com/springmvc/spring-mvc-4-angularj

笔记之_java整理JavaScript

1.javascript 面向对象这一块 1). javascript的基本数据类型有哪些? Number (数字) 1 1.2 String (字符串) '' "" Boolean 布尔 true false Undefined 未定义 Null 空 2).javascript的引用数据类型有哪些? Object {}. 函数 function . 数组 [] 2.javascript定义对象,动态扩冲里面的变量或者属性 var a =new Object(); //实例化一个对象

笔记之_java整理kindeditor文件上传插件

下载插件压缩包 图片创建虚拟服务器路径: 在Tomcat中,打开Tomcat的系统文件夹servers,打开下面的server.xml, 在<Context docBase="class" path="/class"--/>标签中,修改绝对路径docBase和虚拟路径path ,绝对路径是磁盘上创建的保存图片的文件夹,虚拟路径是网页访问图片的路径, 根据自己要用的上传文件的类型,选择插件的相关案例,引用css.js,修改路径以及页面类型jsp.php,

笔记之_Java整理css3

微传单:http://s.wcd.im/index.jsp?id=9661Zi9&flyerAid=9661&p&loading=0&fromOfficial Friendly同包访问 子类重写方法的修饰符必须大于等于子类定义好的访问修饰符 类是抽象的对象是现实存在的 局部变量必须先赋值才能使用 一个Java文件可以包含n个类智能有一个是public并且与文件名一致 接口继承接口,方法名相同不是重写是覆盖 实现接口的类不是抽象类,则必须实现接口及其父级接口的所有方法 Str

笔记之_Java整理MyBaties单用

mybatis中#和$绑定参数: #{}将传入的数据都当成一个字符串,会对自动传入的数据加一个双引号.如:order by #{id},如果传入的值是111,那么解析成sql时的值为order by "111", 如果传入的值是id,则解析成的sql为order by "id". ${}将传入的数据直接显示生成在sql中.如:order by ${id},如果传入的值是111,那么解析成sql时的值为order by 111, 如果传入的值是id,则解析成的sql为