Android修改字体样式的示例代码

  private void settypefacefromattrs(string familyname, int typefaceindex, int styleindex) {
    typeface tf = null;
    if (familyname != null) {
      tf = typeface.create(familyname, styleindex);
      if (tf != null) {
        settypeface(tf);
        return;
      }
    }
    switch (typefaceindex) {
      case sans:
        tf = typeface.sans_serif;
        break;

      case serif:
        tf = typeface.serif;
        break;

      case monospace:
        tf = typeface.monospace;
        break;
    }

    settypeface(tf, styleindex);
  }

assetmanager mgr = getassets();
typeface tf = typeface.createfromasset(mgr, "fonts/notosanscjksc-black.otf");
tv_1.settypeface(tf);

public class customtextview extends textview
{

  public customtextview(context context, attributeset attrs)
  {
    super(context, attrs);
  }

  //重写设置字体方法
  @override
  public void settypeface(typeface tf)
  {
    tf = typeface.createfromasset(getcontext().getassets(), "fonts/notosanscjksc-light.otf");
    super.settypeface(tf);
  }
}

  <com.test.fontfamily.customtextview
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:padding="6dp"
    android:text="自定义字体"
    android:textsize="24dp"
    />

package com.test.fontfamily;

import android.app.application;
import android.content.context;
import android.graphics.typeface;
import android.support.annotation.nonnull;
import android.view.view;
import android.view.viewgroup;
import android.widget.textview;

import java.lang.ref.softreference;
import java.lang.reflect.field;
import java.util.hashmap;
import java.util.map;

/**
 * created by administrator on 2017/10/24.
 */

public class fontutils
{

  private static final string tag = fontutils.class.getsimplename();
  private map<string, softreference<typeface>> mcache = new hashmap<>();
  private static fontutils ssingleton = null;

  public static typeface default = typeface.default;

  // disable instantiate
  private fontutils()
  {
  }

  public static fontutils getinstance()
  {
    // double check
    if (ssingleton == null)
    {
      synchronized (fontutils.class)
      {
        if (ssingleton == null)
        {
          ssingleton = new fontutils();
        }
      }
    }
    return ssingleton;
  }

  /**
   * <p>replace the font of specified view and it's children</p>
   *
   * @param root   the root view.
   * @param fontpath font file path relative to 'assets' directory.
   */
  public void replacefontfromasset(@nonnull view root, @nonnull string fontpath)
  {
    replacefont(root, createtypefacefromasset(root.getcontext(), fontpath));
  }

  /**
   * <p>replace the font of specified view and it's children</p>
   *
   * @param root   the root view.
   * @param fontpath font file path relative to 'assets' directory.
   * @param style  one of {@link typeface#normal}, {@link typeface#bold}, {@link typeface#italic}, {@link typeface#bold_italic}
   */
  public void replacefontfromasset(@nonnull view root, @nonnull string fontpath, int style)
  {
    replacefont(root, createtypefacefromasset(root.getcontext(), fontpath), style);
  }

  /**
   * <p>replace the font of specified view and it's children</p>
   *
   * @param root   the root view.
   * @param fontpath the full path to the font data.
   */
  public void replacefontfromfile(@nonnull view root, @nonnull string fontpath)
  {
    replacefont(root, createtypefacefromfile(fontpath));
  }

  /**
   * <p>replace the font of specified view and it's children</p>
   *
   * @param root   the root view.
   * @param fontpath the full path to the font data.
   * @param style  one of {@link typeface#normal}, {@link typeface#bold}, {@link typeface#italic}, {@link typeface#bold_italic}
   */
  public void replacefontfromfile(@nonnull view root, @nonnull string fontpath, int style)
  {
    replacefont(root, createtypefacefromfile(fontpath), style);
  }

  /**
   * <p>replace the font of specified view and it's children with specified typeface</p>
   */
  private void replacefont(@nonnull view root, @nonnull typeface typeface)
  {
    if (root == null || typeface == null)
    {
      return;
    }

    if (root instanceof textview)
    { // if view is textview or it's subclass, replace it's font
      textview textview = (textview) root;
      // extract previous style of textview
      int style = typeface.normal;
      if (textview.gettypeface() != null)
      {
        style = textview.gettypeface().getstyle();
      }
      textview.settypeface(typeface, style);
    } else if (root instanceof viewgroup)
    { // if view is viewgroup, apply this method on it's child views
      viewgroup viewgroup = (viewgroup) root;
      for (int i = 0; i < viewgroup.getchildcount(); ++i)
      {
        replacefont(viewgroup.getchildat(i), typeface);
      }
    } // else return
  }

  /**
   * <p>replace the font of specified view and it's children with specified typeface and text style</p>
   *
   * @param style one of {@link typeface#normal}, {@link typeface#bold}, {@link typeface#italic}, {@link typeface#bold_italic}
   */
  private void replacefont(@nonnull view root, @nonnull typeface typeface, int style)
  {
    if (root == null || typeface == null)
    {
      return;
    }
    if (style < 0 || style > 3)
    {
      style = typeface.normal;
    }

    if (root instanceof textview)
    { // if view is textview or it's subclass, replace it's font
      textview textview = (textview) root;
      textview.settypeface(typeface, style);
    } else if (root instanceof viewgroup)
    { // if view is viewgroup, apply this method on it's child views
      viewgroup viewgroup = (viewgroup) root;
      for (int i = 0; i < viewgroup.getchildcount(); ++i)
      {
        replacefont(viewgroup.getchildat(i), typeface, style);
      }
    } // else return
  }

  /**
   * <p>create a typeface instance with specified font file</p>
   *
   * @param fontpath font file path relative to 'assets' directory.
   * @return return created typeface instance.
   */
  private typeface createtypefacefromasset(context context, string fontpath)
  {
    softreference<typeface> typefaceref = mcache.get(fontpath);
    typeface typeface = null;
    if (typefaceref == null || (typeface = typefaceref.get()) == null)
    {
      typeface = typeface.createfromasset(context.getassets(), fontpath);
      typefaceref = new softreference<>(typeface);
      mcache.put(fontpath, typefaceref);
    }
    return typeface;
  }

  private typeface createtypefacefromfile(string fontpath)
  {
    softreference<typeface> typefaceref = mcache.get(fontpath);
    typeface typeface = null;
    if (typefaceref == null || (typeface = typefaceref.get()) == null)
    {
      typeface = typeface.createfromfile(fontpath);
      typefaceref = new softreference<>(typeface);
      mcache.put(fontpath, typefaceref);
    }
    return typeface;
  }

  /**
   * <p>replace system default font. <b>note:</b>you should also add code below to your app theme in styles.xml. </p>
   * {@code <item name="android:typeface">monospace</item>}
   * <p>the best place to call this method is {@link application#oncreate()}, it will affect
   * whole app font.if you call this method after view is visible, you need to invalid the view to make it effective.</p>
   *
   * @param context {@link context context}
   * @param fontpath font file path relative to 'assets' directory.
   */
  public void replacesystemdefaultfontfromasset(@nonnull context context, @nonnull string fontpath)
  {
    replacesystemdefaultfont(createtypefacefromasset(context, fontpath));
  }

  /**
   * <p>replace system default font. <b>note:</b>you should also add code below to your app theme in styles.xml. </p>
   * {@code <item name="android:typeface">monospace</item>}
   * <p>the best place to call this method is {@link application#oncreate()}, it will affect
   * whole app font.if you call this method after view is visible, you need to invalid the view to make it effective.</p>
   *
   * @param context {@link context context}
   * @param fontpath the full path to the font data.
   */
  public void replacesystemdefaultfontfromfile(@nonnull context context, @nonnull string fontpath)
  {
    replacesystemdefaultfont(createtypefacefromfile(fontpath));
  }

  /**
   * <p>replace system default font. <b>note:</b>you should also add code below to your app theme in styles.xml. </p>
   * {@code <item name="android:typeface">monospace</item>}
   * <p>the best place to call this method is {@link application#oncreate()}, it will affect
   * whole app font.if you call this method after view is visible, you need to invalid the view to make it effective.</p>
   */
  private void replacesystemdefaultfont(@nonnull typeface typeface)
  {
    modifyobjectfield(null, "monospace", typeface);
  }

  private void modifyobjectfield(object obj, string fieldname, object value)
  {
    try
    {
      field defaultfield = typeface.class.getdeclaredfield(fieldname);
      defaultfield.setaccessible(true);
      defaultfield.set(obj, value);

    } catch (nosuchfieldexception e)
    {
      e.printstacktrace();
    } catch (illegalaccessexception e)
    {
      e.printstacktrace();
    }
  }
}

fontutils.getinstance().replacefontfromasset(view root, string fontpath)

fontutils.getinstance().replacesystemdefaultfontfromasset(this,"fonts/notosanscjksc-thin.otf");

<item name="android:typeface">monospace</item>