Ioc注入框架 注入布局 注入控件 动态代理注入事件

最新推荐文章于 2024-04-28 18:05:26 发布
最新推荐文章于 2024-04-28 18:05:26 发布
阅读量403 收藏
点赞数
分类专栏： Android 文章标签： 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jianjiaqqq001/article/details/73443278
版权

IOC控制反转注入框架

很早之前我们用过Xutils框架 里面有通过注解来使用findViewById 之前我们只是使用。

这样的框架我们要自己实现一遍

主要分为三个部分
1. 注入布局 （利用注解）
2. 注入控件
3. 注入事件 （利用动态代理注入事件）

注入布局

定义注入布局时注解

package com.jiang.iocxutil.annotion;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by jiang on 2017/6/17.
 * 注入布局
 *
 * ElementType.TYPE 表示类的注解
 * RetentionPolicy.RUNTIME 运行时注解 一般我们编写的都是基于运行时的注解
 */

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ContentView
{
    int value();
}
在基类中初始化注入
package com.jiang.iocxutil;

import android.os.Bundle;
import android.os.PersistableBundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;

/**
 * Created by jiang on 2017/6/17.
 */

public class BaseActivity extends AppCompatActivity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        InjectUtils.inject(this);
    }
}

注入布局相关代码

  /**
     * 注入布局
     * @param context
     */
    public static void injectLayout(Context context) {
        Class<?> clazz =  context.getClass();
        ContentView contentView = clazz.getAnnotation(ContentView.class);
        if (contentView != null) {
            int layoutId = contentView.value();
            //setContentView
            try {
                Method method = clazz.getMethod("setContentView", int.class);
                method.setAccessible(true);
                method.invoke(context, layoutId);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

        }

    }
在MainActiviy里面编写注入布局
package com.jiang.iocxutil;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;

import com.jiang.iocxutil.annotion.ContentView;
import com.jiang.iocxutil.annotion.OnClick;
import com.jiang.iocxutil.annotion.OnLongClick;
import com.jiang.iocxutil.annotion.ViewInject;

/**
 * IOC控制反转框架
 *
 */
@ContentView(value = R.layout.activity_main)
public class MainActivity extends BaseActivity {
    private static final String TAG = "MainActivity";

//    @Override
//    protected void onCreate(Bundle savedInstanceState) {
//        super.onCreate(savedInstanceState);
//        setContentView(R.layout.activity_main);
//    }

    @ViewInject(R.id.text_ioc)
    TextView textView;

    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "textView ==" + textView.hashCode());

//        textView.setOnClickListener(new View.OnClickListener() {
//            @Override
//            public void onClick(View v) {
//
//            }
//        });

//        textView.setOnLongClickListener(new View.OnLongClickListener() {
//            @Override
//            public boolean onLongClick(View v) {
//                return false;
//            }
//        });
    }


//    @OnClick(R.id.text_ioc)
//    public void click(View view){
//        toast("测试点击");
//    }
    @OnLongClick(R.id.text_ioc)
    public boolean click(View view){
        toast("测试点击");
        return false;
    }

    public void toast(String string) {
        Toast.makeText(this, string, Toast.LENGTH_SHORT).show();
    }
}

这样就可以通过注入布局来代替展示SetContentView()方法

注入控件

定义注解

package com.jiang.iocxutil.annotion;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by jiang on 2017/6/17.
 * 注入控件注解
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ViewInject {
    int value();
}

2.利用反射找到findViewById来注入控件

 /**
     * 依赖注入控件
     * @param context
     */
    public static void injectView(Context context) {
        Class<?> aClass = context.getClass();
        // 拿到成员变量 数组
        Field[] fields = aClass.getDeclaredFields();
        // 遍历所有的属性
        for (Field field: fields) {
            ViewInject viewInject = field.getAnnotation(ViewInject.class);

            if (viewInject != null) {
                int valueID = viewInject.value();
                try {
                    Method method = aClass.getMethod("findViewById", int.class);
                    View view = (View) method.invoke(context, valueID);
                    field.setAccessible(true);
                    field.set(context, view);
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }
  1. 在MainActivity中我们使用 测试一下注入控件是否可用
    @ViewInject(R.id.text_ioc)
    TextView textView;

    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "textView ==" + textView.hashCode());
    }

注入事件（这个比较复杂也是难点）

为了事件的扩展性 我们要拿到事件的三个要素
1.事件的注册
2.事件的类型
3.事件的回调方法

package com.jiang.iocxutil.annotion;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by jiang on 2017/6/17.
 * 注解的注解 事件的三要素
 */
@Target(ElementType.ANNOTATION_TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface EventBase {
    /**
     * 监听事件的方法
     * @return String
     */
    String listenerSetter();

    /**
     * 事件的类型
     * @return Class
     */
    Class<?> listenerType();

    /**
     * 事件被触发后的回调方法
     * @return
     */
    String callBackMethod();
}
我们先写点击事件
package com.jiang.iocxutil.annotion;

import android.app.Dialog;
import android.view.View;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by jiang on 2017/6/17.
 * 以EventBase做注解
 *
 * 目前需要View.OnClickListener.class
 * 为了扩展可能还需要Dialog.OnClickListener.class
 */
@EventBase(listenerSetter = "setOnClickListener"
        , listenerType = View.OnClickListener.class

        , callBackMethod = "onClick")
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface OnClick {

    int[] value();
}

然后通过反射和动态代理去执行回调

 /**
     * 注入事件
     *
     * public Method[] getMethods()返回某个类的所有公用（public）方法包括其继承类的公用方法，当然也包括它所实现接口的方法。
     * public Method[] getDeclaredMethods()对象表示的类或接口声明的所有方法，
     * 包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。当然也包括它所实现接口的方法。
     * @param context
     */
    private static void injectEvent(Context context) {
        Class<?> clazz = context.getClass();
        Method[] methods = clazz.getMethods();

        for (Method method: methods) {
            /**
             * 扩展性
             */
            Annotation[] anns = method.getAnnotations();

            // 循环拿到方法类型注解
            for (Annotation ann: anns) {
                // 拿到注解的类  先拿到OnlickC注解
                Class<? extends Annotation> anntionType = ann.annotationType();
                //然后再拿到注解的注解EvenBase
                EventBase eventBase = anntionType.getAnnotation(EventBase.class);
                if (eventBase == null) {
                    continue;
                }
                //拿到事件的三要素
                // 设置事件 拿到 setOnclickListener
                String listenerSetter = eventBase.listenerSetter();
                // 事件类型 拿到 View.OnClickListener.class
                Class<?> listenerType = eventBase.listenerType();
                // 回调方法  拿到 callBackMethod onClick
                String callBackMethod = eventBase.callBackMethod();
                // 下一步 通过反射 给View 设置
                // 继续反射拿到 注解里面的id

                Map<String, Method> methodMap = new HashMap<>();
                // 得到当前callBackMethod 对应  Onclick  method -- clikText
                methodMap.put(callBackMethod, method);
                try {
                    //
                    Method declaredMethod = anntionType.getMethod("value");
                    // 注解上的方法  找到Id数组
                    int[] valuesId = (int[]) declaredMethod.invoke(ann);
                    for (int viewId: valuesId) {
                        Method findViewById = clazz.getMethod("findViewById", int.class);
                        View view = (View) findViewById.invoke(context, viewId);
                        //
                        if (view == null) {
                            continue;
                        }
                        //上面的事件三个要素全部拿到了  View的Class  setOnClickListener 对应  view的setOnClickListener
                        Method setOnClickListener = view.getClass().getMethod(listenerSetter, listenerType);

                        ListenerInvocationHandler handler = new ListenerInvocationHandler(context, methodMap);
                        // 拿到动态代理
                        Object proxyInstance = Proxy.newProxyInstance(listenerType.getClassLoader(), new Class[]{ listenerType }, handler);
                        // 将我们的方法执行
                        setOnClickListener.invoke(view, proxyInstance);
                    }
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }

        }
    }

    /**
     * 如何给其设置一个监听  onClick又不在InjectUtils回调 而是在MainActivity里面回调
     * 动态代理  今天的需求是要给按钮设置一个监听 我要执行的一个回调监听不能卸载InjectUtils里面
     * 而是想回调 MainActivity
     */

动态代理类的设计

package com.jiang.iocxutil;

import android.content.Context;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Map;

/**
 * Created by jiang on 2017/6/17.
 */

public class ListenerInvocationHandler implements InvocationHandler {

    private Context context;



    private Map<String, Method> methodMap;

    public ListenerInvocationHandler(Context context, Map<String, Method> methodMap) {
        this.context = context;
        this.methodMap = methodMap;
    }

    /**
     * 处理代理对象的代理方法
     * 我们要代理谁  MainActivity OnClickListener
     * 持有一个真正的对象引用就是MainActivity
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String name = method.getName();
        Method mtd = methodMap.get(name);
        if (mtd == null) {
            //不需要代理
            return method.invoke(proxy, args);
        } else {
            //真正的代理方法
            return mtd.invoke(context, args);
        }
    }
}

然后再MainActivity里面测试注册事件

 @OnClick(R.id.text_ioc)
    public void click(View view){
        toast("测试点击");
    }

此时我们的注册事件就已经完工。
我们看一下其扩展性

然后写长按点击事件 首先定义注解类似于点击事件

package com.jiang.iocxutil.annotion;

import android.view.View;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by jiang on 2017/6/17.
 * 长按事件的注解
 */
@EventBase(listenerSetter = "setOnLongClickListener"
        , listenerType = View.OnLongClickListener.class
        , callBackMethod = "onLongClick")
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface OnLongClick {
    int[] value();
}

在Manactivity里面 添加

 @OnLongClick(R.id.text_ioc)
    public boolean longLlick(View view){
        toast("测试点击");
        return false;
    }

长按点击也就可以成功了

注入工具类 包含注入布局 注入控件 和 注入事件

package com.jiang.iocxutil;

import android.content.Context;
import android.view.View;

import com.jiang.iocxutil.annotion.ContentView;
import com.jiang.iocxutil.annotion.EventBase;
import com.jiang.iocxutil.annotion.ViewInject;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;

/**
 * Created by jiang on 2017/6/17.
 * 依赖注入工具类、
 * 分别为注入布局
 * 注入控件
 * 注入事件
 */

public class InjectUtils {

    /**
     * 初始化注入
     * @param context
     */
    public static void inject(Context context) {
        injectLayout(context);
        injectView(context);
        injectEvent(context);
    }

    /**
     * 依赖注入控件
     * @param context
     */
    public static void injectView(Context context) {
        Class<?> aClass = context.getClass();
        // 拿到成员变量 数组
        Field[] fields = aClass.getDeclaredFields();
        // 遍历所有的属性
        for (Field field: fields) {
            ViewInject viewInject = field.getAnnotation(ViewInject.class);

            if (viewInject != null) {
                int valueID = viewInject.value();
                try {
                    Method method = aClass.getMethod("findViewById", int.class);
                    View view = (View) method.invoke(context, valueID);
                    field.setAccessible(true);
                    field.set(context, view);
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 注入布局
     * @param context
     */
    public static void injectLayout(Context context) {
        Class<?> clazz =  context.getClass();
        ContentView contentView = clazz.getAnnotation(ContentView.class);
        if (contentView != null) {
            int layoutId = contentView.value();
            //setContentView
            try {
                Method method = clazz.getMethod("setContentView", int.class);
                method.setAccessible(true);
                method.invoke(context, layoutId);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

        }

    }


    /**
     * 注入事件
     *
     * public Method[] getMethods()返回某个类的所有公用（public）方法包括其继承类的公用方法，当然也包括它所实现接口的方法。
     * public Method[] getDeclaredMethods()对象表示的类或接口声明的所有方法，
     * 包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。当然也包括它所实现接口的方法。
     * @param context
     */
    private static void injectEvent(Context context) {
        Class<?> clazz = context.getClass();
        Method[] methods = clazz.getMethods();

        for (Method method: methods) {
            /**
             * 扩展性
             */
            Annotation[] anns = method.getAnnotations();

            // 循环拿到方法类型注解
            for (Annotation ann: anns) {
                // 拿到注解的类  先拿到OnlickC注解
                Class<? extends Annotation> anntionType = ann.annotationType();
                //然后再拿到注解的注解EvenBase
                EventBase eventBase = anntionType.getAnnotation(EventBase.class);
                if (eventBase == null) {
                    continue;
                }
                //拿到事件的三要素
                // 设置事件 拿到 setOnclickListener
                String listenerSetter = eventBase.listenerSetter();
                // 事件类型 拿到 View.OnClickListener.class
                Class<?> listenerType = eventBase.listenerType();
                // 回调方法  拿到 callBackMethod onClick
                String callBackMethod = eventBase.callBackMethod();
                // 下一步 通过反射 给View 设置
                // 继续反射拿到 注解里面的id

                Map<String, Method> methodMap = new HashMap<>();
                // 得到当前callBackMethod 对应  Onclick  method -- clikText
                methodMap.put(callBackMethod, method);
                try {
                    //
                    Method declaredMethod = anntionType.getMethod("value");
                    // 注解上的方法  找到Id数组
                    int[] valuesId = (int[]) declaredMethod.invoke(ann);
                    for (int viewId: valuesId) {
                        Method findViewById = clazz.getMethod("findViewById", int.class);
                        View view = (View) findViewById.invoke(context, viewId);
                        //
                        if (view == null) {
                            continue;
                        }
                        //上面的事件三个要素全部拿到了  View的Class  setOnClickListener 对应  view的setOnClickListener
                        Method setOnClickListener = view.getClass().getMethod(listenerSetter, listenerType);

                        ListenerInvocationHandler handler = new ListenerInvocationHandler(context, methodMap);
                        // 拿到动态代理
                        Object proxyInstance = Proxy.newProxyInstance(listenerType.getClassLoader(), new Class[]{ listenerType }, handler);
                        // 将我们的方法执行
                        setOnClickListener.invoke(view, proxyInstance);
                    }
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }

        }
    }

    /**
     * 如何给其设置一个监听  onClick又不在InjectUtils回调 而是在MainActivity里面回调
     * 动态代理  今天的需求是要给按钮设置一个监听 我要执行的一个回调监听不能卸载InjectUtils里面
     * 而是想回调 MainActivity
     */
}

匆匆编写 细节还需大家验证 有疑问
邮箱 zhangdanjiang_java@163.com
GitBub地址 https://github.com/JiangGeJavaAndroid/IocXutil

还记得梦想吗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自我提升之二 揭秘IOC注入框架，轻松实现布局、属性、事件注入
FLY346422332的博客
04-24 361
基础知识讲解 什么是DIP、IOC、DI、IOC容器 IOC容器的技术剖析 IOC中最基本的技术就是“反射(Reflection)”编程 我们可以把IOC容器的工作模式看做是工厂模式的升华，可以把IOC容器看作是一个工厂，这个工厂里要生产的对象都在配置文件中给出定义，然后利用编程语言的的反射编程，根据配置文件中给出的类名生成相应的对象。从实现来看，IOC是把以前在工厂方法里写死的对象生成代码，...
Android-基于IOC的布局，控件，事件注入
Carmen_l的博客
04-12 627
 首先我们说说java元注解@Target（注解的作用目标） @Retention（注解的保留位置）@Ducument（说明该注解将包含在javadoc中） @Inherited（说明子类可以继承父类中的该注解）1， @Target(ElmentType.Type)   //同下  ElementTypeTYPE      类、接口（包括注释类型）或枚举声明   ElementTypeFIELD ...
IoC注入框架
星火幽光的博客
12-01 173
反射
揭秘IoC注入框架
chengcanyue的博客
03-03 149
什么是DIP、IoC、DI、IoC容器 DIP:依赖倒置原则（Dependency Inverse Principle） 强调系统的“高层组件”不应当依赖于“底层组件”，并且不论是“高层组件”还是“底层组件”都应当依赖于抽象。抽象不应当依赖于实现，实现应当依赖于抽象（软件设计原则）。 IoC：控制反转（Inversion of Control） 一种反转流、依赖和接...
IOC架构设计之事件注入
涂文远的博客
02-28 845
IOC之事件注入
动态代理-事件注入（一）
写好每一篇文章
01-14 1628
1.目的： 通过代理的方式去注册控件的点击事件，长按事件等其他事件。 优点：隔离代码层，解耦 缺点：运行时反射的效率低 2.第一版本（先不用动态代理）： 2.1 创建一个注解类 （用来区分方法是否需要注册点击事件） @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface OnClick { //接收控件的ID int[] value() default -1; } 2.2
Android中自定义实现IoC（控件注入、布局注入、事件注入）
04-15
本篇文章将深入探讨如何在Android环境中自定义实现IoC，包括控件注入、布局注入和事件注入。 首先，我们来理解一下什么是控件注入。在传统的Android开发中，我们通常在Activity或Fragment中手动初始化UI控件，如...
仿ButterKnife，写自己的IOC控件-布局-事件注入注解框架
12-21
1.强大的View绑定和Click事件处理功能，简化代码，提升开发效率 2.运行时不会影响APP效率，使用配置方便(采用的是编译时注解) 3.代码清晰，可读性强 可以写在BaseActivity、FragmentActivity中。 最近也在学习...
《撸代码学习 IOC注入技术2》—— 事件注入
cjm2484836553的博客
02-29 346
不诗意的女程序媛不是好厨师~ 转载请注明出处，From李诗雨—https://blog.csdn.net/cjm2484836553/article/details/104581855 源代码下载地址：https://github.com/junmei520/iocStudy 在上一篇 的文章 《撸代码 学习 IOC注入技术1 》—— 布局注入 与 控件注入中，我们已经自己通过敲代码，一步一...
在Spring中注入动态代理Bean
最新发布
xiaoyi52的专栏
04-28 1555
下面仿照Mapper的实现原理来自定义注解和代理工厂，实现自定义注入动态代理Bean。Class
注解实现布局 ，控件的赋值 ，点击事件
xiaozhang0414的博客
01-30 187
1.setContentView绑定 //注解 @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @Documented @Inherited public @interface ContentView { int value(); } @Retention(RetentionPolicy.RUNTI
IOC架构实现布局、事件注入
aruba的博客
10-28 471
IOC全称Inverse Of Control，中文释义为控制反转，常见的方式叫作依赖注入(Dependency Injection)，IOC核心的思想和代理模式一样，使用者不必关心资源的具体获取，资源通过第三方来管理 之前有提到过注解是设计框架时常用的工具，利用注解可以在编译期(通过APT)或运行期生成代码，今天通过运行期使用注解来实现ButterKnife的布局和事件绑定功能 一、布局注入 我...
依赖注入&动态代理&AOP
qq_34558909的博客
04-18 1124
一 简述Spring核心 ​ 控制反转:IOC—>创建对象的过程 ​ 依赖注入: DI---->初始化对象属性 面向切面:AOP--->不改变原码的前提,在其方法前后插入业务逻辑代码 二 依赖注入 2.1 set方法注入 简述: B类对象持有A类对象,spring通过无参构造反射创建B对象,并将A对象当作参数传入set方法赋值给A对象变量; set方法注入用的较...
IOC实现ButterKnife（一）之注入布局与注入控件
张无影的博客
01-09 183
IOC是什么？ 是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度，其中最常见的便是依赖注入。简单点说就是如果你在一个类A中实例化一个对象B，那么久需要在A类中使用new来进行实例化对象B，这样A和B的耦合度就很高，而IOC是通过注解让其进行动态生成，而不需要自己去实例化，以此来降低耦合度。（依赖注入核心） 需要用到的知识： 反射 注解 如果不熟悉上面两个知识，可百度找一篇如果...
手写IOC注入View，View点击事件，防多次点击
qq_42359647的博客
07-22 762
Android使用IOC注入View属性，View点击事件，防止快速多次点击
反射，注解，动态代理，依赖注入控制反转
weixin_33795743的博客
06-07 507
一.反射调用方法,获取成员变量值假如我们有这样一个类：public class Hello { public String name = "张三"; private int age = 43; public String getSex( String aaa) { return aaa; } private String getCl...
Spring原理(通过源码深入分析Spring生命周期和依赖注入、动态代理的实现)
zhangCheng的博客
08-09 640
一、分析BeanPostProcessor接口: 这个接口里面的两个方法每个Spring容器里面的Bean初始化时候都会调用， 一个是postProcessBeforeInitialization， 一个是postProcessAfterInitialization, 都是在bean属性设置完成后,进行调用。 postProcessBeforeInitialization在init方法之前调用, ...
Spring ioc依赖倒置
马里奥的专栏
04-15 1093
所谓依赖，从程序的角度看，就是比如A要调用B的方法，那么A就依赖于B，反正A要用到B，则A依赖于B。 所谓倒置，你必须理解如果不倒置，会怎么着，因为A必须要有B，才可以调用B，如果不倒置，意思就是A主动获取B的实例：B b = new B()，这就是最简单的获取B实例的方法（当然还有各种设计模式可以帮助你去获得B的实例，比如工厂、Locator等等），然后你就可以调用b对象了。 所以，不倒置，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值