Fragment管理工具类
- Fragment相关→FragmentUtils.java→Demo
addFragment : 新增fragment
removeFragment : 移除fragment
replaceFragment : 替换fragment
popFragment : 出栈fragment
popToFragment : 出栈到指定fragment
popAddFragment : 先出栈后新增fragment
hideFragment : 隐藏fragment
showFragment : 显示fragment
hideShowFragment : 先隐藏后显示fragment
getLastAddFragment : 获取最后加入的fragment
getLastAddFragmentInStack: 获取栈中最后加入的fragment
getTopShowFragment : 获取顶层可见fragment
getTopShowFragmentInStack: 获取栈中顶层可见fragment
findFragment : 查找fragment
getPreFragment : 获取目标fragment的前一个fragment
getFragments : 获取同级别的fragment
getAllFragments : 获取所有fragment
getAllFragmentsInStack : 获取栈中所有fragment
setBackgroundColor : 设置背景色
setBackgroundResource : 设置背景资源
setBackground : 设置背景
具体路线
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.os.Bundle;
import android.support.annotation.ColorInt;
import android.support.annotation.DrawableRes;
import android.support.annotation.NonNull;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.view.View;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* <pre>
* author: Blankj
* blog : http://blankj.com
* time : 2017/1/17
* desc : Fragment相关工具类
* </pre>
*/
public class FragmentUtils {
private FragmentUtils() {
throw new UnsupportedOperationException("u can't instantiate me...");
}
private static final int TYPE_ADD_FRAGMENT = 0x01 << 0;
private static final int TYPE_REMOVE_FRAGMENT = 0x01 << 1;
private static final int TYPE_REPLACE_FRAGMENT = 0x01 << 2;
private static final int TYPE_HIDE_FRAGMENT = 0x01 << 3;
private static final int TYPE_SHOW_FRAGMENT = 0x01 << 4;
private static final int TYPE_HIDE_SHOW_FRAGMENT = 0x01 << 5;
private static final int TYPE_POP_ADD_FRAGMENT = 0x01 << 6;
private static final String ARGS_ID = "args_id";
private static final String ARGS_IS_HIDE = "args_is_hide";
private static final String ARGS_IS_ADD_STACK = "args_is_add_stack";
/**
* 新增fragment
*
* @param fragmentManager fragment管理器
* @param containerId 布局Id
* @param fragment fragment
* @return fragment
*/
public static Fragment addFragment(@NonNull FragmentManager fragmentManager,
@NonNull Fragment fragment,
int containerId) {
return addFragment(fragmentManager, fragment, containerId, false);
}
/**
* 新增fragment
*
* @param fragmentManager fragment管理器
* @param containerId 布局Id
* @param fragment fragment
* @param isHide 是否显示
* @return fragment
*/
public static Fragment addFragment(@NonNull FragmentManager fragmentManager,
@NonNull Fragment fragment,
int containerId,
boolean isHide) {
return addFragment(fragmentManager, fragment, containerId, isHide, false);
}
/**
* 新增fragment
*
* @param fragmentManager fragment管理器
* @param containerId 布局Id
* @param fragment fragment
* @param isHide 是否显示
* @param isAddStack 是否入回退栈
* @return fragment
*/
public static Fragment addFragment(@NonNull FragmentManager fragmentManager,
@NonNull Fragment fragment,
int containerId,
boolean isHide,
boolean isAddStack) {
putArgs(fragment, new Args(containerId, isHide, isAddStack));
return operateFragment(fragmentManager, null, fragment, TYPE_ADD_FRAGMENT);
}
/**
* 新增fragment
*
* @param fragmentManager fragment管理器
* @param containerId 布局Id
* @param fragment fragment
* @param isAddStack 是否入回退栈
* @param sharedElement 共享元素
* @return fragment
*/
public static Fragment addFragment(@NonNull FragmentManager fragmentManager,
@NonNull Fragment fragment,
int containerId,
boolean isAddStack,
SharedElement... sharedElement) {
putArgs(fragment, new Args(containerId, false, isAddStack));
return operateFragment(fragmentManager, null, fragment, TYPE_ADD_FRAGMENT, sharedElement);
}
/**
* 移除fragment
*
* @param fragment fragment
* @return fragment
*/
public static Fragment removeFragment(@NonNull Fragment fragment) {
return operateFragment(fragment.getFragmentManager(), null, fragment, TYPE_REMOVE_FRAGMENT);
}
/**
* 替换fragment
*
* @param srcFragment 源fragment
* @param destFragment 目标fragment
* @param isAddStack 是否入回退栈
* @return {@code null} 失败
*/
public static Fragment replaceFragment(@NonNull Fragment srcFragment,
@NonNull Fragment destFragment,
boolean isAddStack) {
if (srcFragment.getArguments() == null) return null;
int containerId = srcFragment.getArguments().getInt(ARGS_ID);
if (containerId == 0) return null;
return replaceFragment(srcFragment.getFragmentManager(), containerId, destFragment, isAddStack);
}
/**
* 替换fragment
*
* @param fragmentManager fragment管理器
* @param containerId 布局Id
* @param fragment fragment
* @param isAddStack 是否入回退栈
* @return fragment
*/
public static Fragment replaceFragment(@NonNull FragmentManager fragmentManager,
int containerId,
@NonNull Fragment fragment,
boolean isAddStack) {
putArgs(fragment, new Args(containerId, false, isAddStack));
return operateFragment(fragmentManager, null, fragment, TYPE_REPLACE_FRAGMENT);
}
/**
* 出栈fragment
*
* @param fragmentManager fragment管理器
* @return {@code true}: 出栈成功<br>{@code false}: 出栈失败
*/
public static boolean popFragment(@NonNull FragmentManager fragmentManager) {
return fragmentManager.popBackStackImmediate();
}
/**
* 出栈到指定fragment
*
* @param fragmentManager fragment管理器
* @param fragmentClass Fragment类
* @param isIncludeSelf 是否包括Fragment类自己
* @return {@code true}: 出栈成功<br>{@code false}: 出栈失败
*/
public static boolean popToFragment(@NonNull FragmentManager fragmentManager,
Class<? extends Fragment> fragmentClass,
boolean isIncludeSelf) {
return fragmentManager.popBackStackImmediate(fragmentClass.getName(), isIncludeSelf ? FragmentManager.POP_BACK_STACK_INCLUSIVE : 0);
}
/**
* 先出栈后新增fragment
*
* @param fragmentManager fragment管理器
* @param containerId 布局Id
* @param fragment fragment
* @param isAddStack 是否入回退栈
* @return fragment
*/
public static Fragment popAddFragment(@NonNull FragmentManager fragmentManager,
int containerId,
@NonNull Fragment fragment,
boolean isAddStack,
SharedElement... sharedElement) {
putArgs(fragment, new Args(containerId, false, isAddStack));
return operateFragment(fragmentManager, null, fragment, TYPE_POP_ADD_FRAGMENT, sharedElement);
}
/**
* 先出栈后新增fragment
*
* @param fragmentManager fragment管理器
* @param containerId 布局Id
* @param fragment fragment
* @param isAddStack 是否入回退栈
* @return fragment
*/
public static Fragment popAddFragment(@NonNull FragmentManager fragmentManager,
int containerId,
@NonNull Fragment fragment,
boolean isAddStack) {
putArgs(fragment, new Args(containerId, false, isAddStack));
return operateFragment(fragmentManager, null, fragment, TYPE_POP_ADD_FRAGMENT);
}
/**
* 隐藏fragment
*
* @param fragment fragment
*/
public static Fragment hideFragment(@NonNull Fragment fragment) {
Args args = getArgs(fragment);
if (args != null) {
putArgs(fragment, new Args(args.id, true, args.isAddStack));
}
return operateFragment(fragment.getFragmentManager(), null, fragment, TYPE_HIDE_FRAGMENT);
}
/**
* 显示fragment
*
* @param fragment fragment
*/
public static Fragment showFragment(@NonNull Fragment fragment) {
Args args = getArgs(fragment);
if (args != null) {
putArgs(fragment, new Args(args.id, false, args.isAddStack));
}
return operateFragment(fragment.getFragmentManager(), null, fragment, TYPE_SHOW_FRAGMENT);
}
/**
* 先隐藏后显示fragment
*
* @param hideFragment 需要hide的Fragment，如果为null则把栈中的fragment都隐藏
* @param showFragment 需要show的Fragment
*/
public static Fragment hideShowFragment(@NonNull Fragment hideFragment,
@NonNull Fragment showFragment) {
Args args = getArgs(hideFragment);
if (args != null) {
putArgs(hideFragment, new Args(args.id, true, args.isAddStack));
}
args = getArgs(showFragment);
if (args != null) {
putArgs(showFragment, new Args(args.id, false, args.isAddStack));
}
return operateFragment(showFragment.getFragmentManager(), hideFragment, showFragment, TYPE_HIDE_SHOW_FRAGMENT);
}
/**
* 传参
*
* @param fragment fragment
* @param args 参数
*/
private static void putArgs(@NonNull Fragment fragment, Args args) {
Bundle bundle = fragment.getArguments();
if (bundle == null) {
bundle = new Bundle();
fragment.setArguments(bundle);
}
bundle.putInt(ARGS_ID, args.id);
bundle.putBoolean(ARGS_IS_HIDE, args.isHide);
bundle.putBoolean(ARGS_IS_ADD_STACK, args.isAddStack);
}
/**
* 获取参数
*
* @param fragment fragment
*/
private static Args getArgs(@NonNull Fragment fragment) {
Bundle bundle = fragment.getArguments();
if (bundle == null || bundle.getInt(ARGS_ID) == 0) return null;
return new Args(bundle.getInt(ARGS_ID), bundle.getBoolean(ARGS_IS_HIDE), bundle.getBoolean(ARGS_IS_ADD_STACK));
}
/**
* 操作fragment
*
* @param fragmentManager fragment管理器
* @param srcFragment 源fragment
* @param destFragment 目标fragment
* @param type 操作类型
* @param sharedElements 共享元素
* @return destFragment
*/
private static Fragment operateFragment(@NonNull FragmentManager fragmentManager,
Fragment srcFragment,
@NonNull Fragment destFragment,
int type,
SharedElement... sharedElements) {
if (srcFragment == destFragment) return null;
if (srcFragment != null && srcFragment.isRemoving()) {
LogUtils.e(srcFragment.getClass().getName() + " is isRemoving");
return null;
}
String name = destFragment.getClass().getName();
Bundle args = destFragment.getArguments();
FragmentTransaction ft = fragmentManager.beginTransaction();
if (sharedElements == null || sharedElements.length == 0) {
ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
} else {
for (SharedElement element : sharedElements) {// 添加共享元素动画
ft.addSharedElement(element.sharedElement, element.name);
}
}
switch (type) {
case TYPE_ADD_FRAGMENT:
ft.add(args.getInt(ARGS_ID), destFragment, name);
if (args.getBoolean(ARGS_IS_HIDE)) ft.hide(destFragment);
if (args.getBoolean(ARGS_IS_ADD_STACK)) ft.addToBackStack(name);
break;
case TYPE_REMOVE_FRAGMENT:
ft.remove(destFragment);
break;
case TYPE_POP_ADD_FRAGMENT:
popFragment(fragmentManager);
if (args.getBoolean(ARGS_IS_ADD_STACK)) ft.addToBackStack(name);
ft.add(args.getInt(ARGS_ID), destFragment, name);
break;
case TYPE_HIDE_FRAGMENT:
ft.hide(destFragment);
break;
case TYPE_SHOW_FRAGMENT:
ft.show(destFragment);
break;
case TYPE_HIDE_SHOW_FRAGMENT:
ft.hide(srcFragment).show(destFragment);
break;
case TYPE_REPLACE_FRAGMENT:
if (args.getBoolean(ARGS_IS_ADD_STACK)) ft.addToBackStack(name);
ft.replace(args.getInt(ARGS_ID), destFragment, name);
break;
}
ft.commitAllowingStateLoss();
return destFragment;
}
/**
* 获取最后加入的fragment
*
* @param fragmentManager fragment管理器
* @return 栈顶fragment
*/
public static Fragment getLastAddFragment(@NonNull FragmentManager fragmentManager) {
List<Fragment> fragments = getFragments(fragmentManager);
if (fragments.isEmpty()) return null;
for (int i = fragments.size() - 1; i >= 0; i--) {
if (fragments.get(i) != null) {
return fragments.get(i);
}
}
return null;
}
/**
* 获取栈中最后加入的fragment
*
* @param fragmentManager
* @return
*/
public static Fragment getLastAddFragmentInStack(@NonNull FragmentManager fragmentManager) {
List<Fragment> fragments = getFragments(fragmentManager);
if (fragments.isEmpty()) return null;
for (int i = fragments.size() - 1; i >= 0; i--) {
Fragment fragment = fragments.get(i);
if (fragment != null && fragment.getArguments().getBoolean(ARGS_IS_ADD_STACK)) {
return fragment;
}
}
return null;
}
/**
* 获取顶层可见fragment
*
* @param fragmentManager fragment管理器
* @return 栈顶可见fragment
*/
public static Fragment getTopShowFragment(@NonNull FragmentManager fragmentManager) {
return getTopShowFragment(fragmentManager, null);
}
/**
* 获取顶层可见fragment
*
* @param fragmentManager fragment管理器
* @param parentFragment 父fragment
* @return 顶层可见fragment
*/
private static Fragment getTopShowFragment(@NonNull FragmentManager fragmentManager,
Fragment parentFragment) {
List<Fragment> fragments = getFragments(fragmentManager);
if (fragments.isEmpty()) return parentFragment;
for (int i = fragments.size() - 1; i >= 0; i--) {
Fragment fragment = fragments.get(i);
if (fragment != null && fragment.isResumed() && fragment.isVisible() && fragment.getUserVisibleHint()) {
return getTopShowFragment(fragment.getChildFragmentManager(), fragment);
}
}
return parentFragment;
}
/**
* 获取栈中顶层可见fragment
*
* @param fragmentManager fragment管理器
* @return 栈顶可见fragment
*/
public static Fragment getTopShowFragmentInStack(@NonNull FragmentManager fragmentManager) {
return getTopShowFragmentInStack(fragmentManager, null);
}
/**
* 获取栈中顶层可见fragment
*
* @param fragmentManager fragment管理器
* @param parentFragment 父fragment
* @return 顶层可见fragment
*/
private static Fragment getTopShowFragmentInStack(@NonNull FragmentManager fragmentManager,
Fragment parentFragment) {
List<Fragment> fragments = getFragments(fragmentManager);
if (fragments.isEmpty()) return parentFragment;
for (int i = fragments.size() - 1; i >= 0; i--) {
Fragment fragment = fragments.get(i);
if (fragment != null && fragment.isResumed() && fragment.isVisible() && fragment.getUserVisibleHint() && fragment.getArguments().getBoolean(ARGS_IS_ADD_STACK)) {
return getTopShowFragmentInStack(fragment.getChildFragmentManager(), fragment);
}
}
return parentFragment;
}
/**
* 查找fragment
*
* @param fragmentManager fragment管理器
*/
public static Fragment findFragment(@NonNull FragmentManager fragmentManager, Class<? extends Fragment> fragmentClass) {
List<Fragment> fragments = getFragments(fragmentManager);
if (fragments.isEmpty()) return null;
return fragmentManager.findFragmentByTag(fragmentClass.getName());
}
/**
* 获取目标fragment的前一个fragment
*
* @param fragment 目标fragment
*/
public static Fragment getPreFragment(@NonNull Fragment fragment) {
FragmentManager fragmentManager = fragment.getFragmentManager();
if (fragmentManager == null) return null;
List<Fragment> fragments = getFragments(fragmentManager);
if (fragments.isEmpty()) return null;
int index = fragments.indexOf(fragment);
for (int i = index - 1; i >= 0; i--) {
if (fragments.get(i) != null) {
return fragments.get(i);
}
}
return null;
}
/**
* 获取同级别的fragment
*
* @param fragmentManager fragment管理器
* @return 同级别的fragments
*/
public static List<Fragment> getFragments(@NonNull FragmentManager fragmentManager) {
List<Fragment> fragments = fragmentManager.getFragments();
if (fragments == null || fragments.isEmpty()) return Collections.emptyList();
return fragments;
}
/**
* 获取所有fragment
*
* @param fragmentManager fragment管理器
* @return 所有fragment
*/
public static List<FragmentNode> getAllFragments(@NonNull FragmentManager fragmentManager) {
return getAllFragments(fragmentManager, new ArrayList<FragmentNode>());
}
/**
* 获取所有fragment
*
* @param fragmentManager fragment管理器
* @param result 结果
* @return 所有fragment
*/
private static List<FragmentNode> getAllFragments(@NonNull FragmentManager fragmentManager,
List<FragmentNode> result) {
List<Fragment> fragments = fragmentManager.getFragments();
if (fragments == null || fragments.isEmpty()) return Collections.emptyList();
for (int i = fragments.size() - 1; i >= 0; i--) {
Fragment fragment = fragments.get(i);
if (fragments.get(i) == null) continue;
result.add(new FragmentNode(fragment, getAllFragments(fragment.getChildFragmentManager(), new ArrayList<FragmentNode>())));
}
return result;
}
/**
* 获取回退栈中的fragment
* <p>需之前对fragment的操作都借助该工具类</p>
*
* @param fragmentManager fragment管理器
* @return 回退栈中的fragment
*/
public static List<FragmentNode> getAllFragmentsInStack(@NonNull FragmentManager fragmentManager) {
List<Fragment> fragments = fragmentManager.getFragments();
if (fragments == null || fragments.isEmpty()) return Collections.emptyList();
List<FragmentNode> result = new ArrayList<>();
for (int i = fragments.size() - 1; i >= 0; i--) {
Fragment fragment = fragments.get(i);
if (fragments.get(i) != null && fragment.getArguments().getBoolean(ARGS_IS_ADD_STACK)) {
result.add(new FragmentNode(fragment, getAllFragments(fragment.getChildFragmentManager(), new ArrayList<FragmentNode>())));
}
}
return result;
}
/**
* 处理fragment回退键
* <p>如果fragment实现了OnBackClickListener接口，返回{@code true}: 表示已消费回退键事件，反之则没消费</p>
* <p>具体示例见FragmentActivity</p>
*
* @param fragment fragment
* @return 是否消费回退事件
*/
public static boolean dispatchBackPress(@NonNull Fragment fragment) {
return dispatchBackPress(fragment.getFragmentManager());
}
/**
* 处理fragment回退键
* <p>如果fragment实现了OnBackClickListener接口，返回{@code true}: 表示已消费回退键事件，反之则没消费</p>
* <p>具体示例见FragmentActivity</p>
*
* @param fragmentManager fragment管理器
* @return 是否消费回退事件
*/
public static boolean dispatchBackPress(@NonNull FragmentManager fragmentManager) {
List<Fragment> fragments = fragmentManager.getFragments();
if (fragments == null || fragments.isEmpty()) return false;
for (int i = fragments.size() - 1; i >= 0; i--) {
Fragment fragment = fragments.get(i);
if (fragment != null
&& fragment.isResumed()
&& fragment.isVisible()
&& fragment.getUserVisibleHint()
&& fragment instanceof OnBackClickListener
&& ((OnBackClickListener) fragment).onBackClick()) {
return true;
}
}
return false;
}
/**
* 设置背景色
*
* @param fragment fragment
* @param color 背景色
*/
public static void setBackgroundColor(@NonNull Fragment fragment, @ColorInt int color) {
View view = fragment.getView();
if (view != null) {
view.setBackgroundColor(color);
}
}
/**
* 设置背景资源
*
* @param fragment fragment
* @param resId 资源Id
*/
public static void setBackgroundResource(@NonNull Fragment fragment, @DrawableRes int resId) {
View view = fragment.getView();
if (view != null) {
view.setBackgroundResource(resId);
}
}
/**
* 设置背景
*
* @param fragment fragment
* @param background 背景
*/
public static void setBackground(@NonNull Fragment fragment, Drawable background) {
View view = fragment.getView();
if (view != null) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
view.setBackground(background);
} else {
view.setBackgroundDrawable(background);
}
}
}
static class Args {
int id;
boolean isHide;
boolean isAddStack;
Args(int id, boolean isHide, boolean isAddStack) {
this.id = id;
this.isHide = isHide;
this.isAddStack = isAddStack;
}
}
public static class SharedElement {
View sharedElement;
String name;
public SharedElement(View sharedElement, String name) {
this.sharedElement = sharedElement;
this.name = name;
}
}
static class FragmentNode {
Fragment fragment;
List<FragmentNode> next;
public FragmentNode(Fragment fragment, List<FragmentNode> next) {
this.fragment = fragment;
this.next = next;
}
@Override
public String toString() {
return fragment.getClass().getSimpleName() + "->" + ((next == null || next.isEmpty()) ? "no child" : next.toString());
}
}
public interface OnBackClickListener {
boolean onBackClick();
}
}终点站
好了，终点站到了，如果对本次旅途满意的话，请给五星好评哦，毕竟老司机牺牲了很多时间才换来这么一份工具类，如果该工具类依赖其他工具类，都可以在我的Android开发人员不得不收集的代码(持续更新中)中找到。
Fragment管理工具类的更多相关文章
- android的Log日志打印管理工具类(一)
android的Log日志的打印管理工具类: package com.gzcivil.utils; import android.util.Log; /** * 日志打印管理 * * @author ...
- Android 软件管理工具类Utils
Android 软件管理工具类Utils /** * Created by uilubo on 2015/9/30. * 工具类 */ public class Utils { public stat ...
- 阶段3 2.Spring_07.银行转账案例_4 编写事务管理工具类并分析连接和线程解绑
事务管理工具类 首先需要有connection.并且是当前线程上的connection.声明connectionUtils.提供set方法等着spring来注入 有异常需要放在事务里面 close关闭 ...
- Dialog对话框管理工具类
import android.app.Dialog; import android.content.Context; import android.content.DialogInterface; i ...
- 可以获取JVM信息的一些管理工具类
一些可以获取JVM信息的java工具类 BufferPoolMXBean.class ClassLoadingMXBean.class CompilationMXBean.class GarbageC ...
- 【Android工具类】Activity管理工具类AppManager
转载请注明出处:http://blog.csdn.net/zhaokaiqiang1992 import java.util.Stack; import android.app.Activity; i ...
- 【笔记】cookies管理工具类
package com.ulearning.ulms.util; import java.io.UnsupportedEncodingException; import java.net.URLDec ...
- Logger日志管理工具类
import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import j ...
- JBPM4入门——4.封装流程管理的工具类（JbpmUtil）
本博文只是简要对JBPM4进行介绍,如需更详细内容请自行google 链接: JBPM入门系列文章: JBPM4入门——1.jbpm简要介绍 JBPM4入门——2.在eclipse中安装绘制jbpm流 ...
随机推荐
- iOS开发中多线程断点下载大文件
主要思想,就是创建一个与目标文件等大小的空白文件,然后分段往这个空白文件中写入数据. 可以通过发送HEAD请求,获得服务器中文件的具体大小,然后再将这样的长度分割成若干等大的数据块,在发送get请求时 ...
- poj1988（判断一个结点下面有多少个结点，推荐）
题意:有n个元素,开始每个元素自己一栈,有两种操作,将含有元素x的栈放在含有y的栈的顶端,合并为一个栈.第二种操作是询问含有x元素下面有多少个元素. 6 M 1 6 C 1 M 2 4 M 2 6 C ...
- iOSAFNetworking 网络请求
前言 在 iOS 开发中,一般情况下,简单的向某个 Web 站点简单的页面提交请求并获取服务器的响应,用 Xcode 自带的 NSURLConnection 是能胜任的.但是,在绝大部分下我们所需要访 ...
- IIS时间格式设置
IIS时间格式调整: (已解决)今天在用IIS7的时候发现一个关于时间格式的问题,当我在ASP中使用now()时间函数的时候,日期是以“/”来分隔,而不是以“-”来分隔的,使得我在运行程序的时候老出错 ...
- webstorm 设置jsp支持ZenCoding
setting -> File Type - html 里面增加*.jsp
- .Net MVC 自定义Action类型，XmlAction，ImageAction等
MVC开发的时候,难免会用到XML格式数据,如果将XML数据当作字符串直接返回给前台,其实这不是真正意义上的xmL,你可以看到ContentType是text/html而非XML类型,这往往会造成前端 ...
- 前端最全的 API 集锦
window.getComputedStyle(el,':after')[attrName]------------------------------------------------------ ...
- CSS3圆角,阴影,透明
CSS实现圆角,阴影,透明的方法很多,传统的方法都比较复杂,用CSS3就方便很多了,虽然现在各浏览器对CSS3的支持还不是很好,但不久的将来CSS3就会普及. 1.圆角 CSS3实现圆角有两种方法. ...
- Java 之 File
11.3 I/O类使用 由于在IO操作中,需要使用的数据源有很多,作为一个IO技术的初学者,从读写文件开始学习IO技术是一个比较好的选择.因为文件是一种常见的数据源,而且读写文件也是程序员进行IO编程 ...
- Selenium常用操作汇总二——如何操作select下拉框
下面我们来看一下selenium webdriver是如何来处理select下拉框的,以http://passport.51.com/reg2.5p这个页面为例.这个页面中有4个下拉框,下面演示4种选 ...