在手机的设置中，我可以全局更改应用的字体大小。android设置：调整字体大小
 
设置>显示>字体大小
 
我可以做的字体大小(小，中，大，非常大)，也看过Java和(如果适用)。只为我的应用程序设置？ 我试图改变字体大小如下。
 
Button buttonbig = (Button) dialog.findViewById(R.id.btn_big);
 
buttonbig.setOnClickListener(new OnClickListener() {
 
public void onClick(View v) {
 
float fScale = getResources().getConfiguration().fontScale;
 
String fontSize = String.valueOf(fScale);
 
conf.fontScale =fScale + 0.15f;
 
getResources().getConfiguration().setTo(conf);
 
TextView textView = (TextView) dialog.findViewById(R.id.lbl_size_act);
 
textView.setText(fontSize);
 
}
 
});
 
dialog.show();
 
我的文本视图显示新的大小。然而，文本仍然是相同的大小。让任何人知道什么是错的？
 
+0
 
[从设置阅读字体大小]的可能的复制如何(http://stackoverflow.com/questions/ 16544931 /读字体大小从 - 设置) –

 
 
 
一、前言
 
二、效果预览
 
三、实现步骤
 
1、自定义字体调整控件
 
2、滑动按钮改变当前页面预览字体大小
 
3、返回时，保存放大倍数并重启应用
 
4、初始化应用时配置字体放大倍数。
 
四、Demo地址
 
五、内容推荐
 

一、前言
 
最近项目添加了一项调整应用字体大小功能，做完后空闲之余总结一下。本功能仿照微信应用“设置” - “通用”  -  “字体大小”功能，又有一点区别。据我所知，常见改变全局字体大小方法有两种（若有更好的方案可以留言，互相学习），我把这两种分为可控和不可控，为什么这么分呢，当然不是为了方便记忆。那么简单说下两者方式的实现过程：
 
1、不可控：通过重写Actiivity的getResources()方法更新应用的字体倍数来调整全局字体大小
 
 
 
优点：实现简单
 
 
缺点：不可控制（所有字体放大倍数都是一致），无法跨进程（项目中另一个进程的字体不会改变，需要重新配置），只对sp字体单位有效果。....
 
 
2、可控：通过setTheme()方法，一开始就初始化设置不同风格的字体样式来更改全局字体大小。
 
 
 
优点：随意调节任意位置的字体大小
 
 
缺点：实现麻烦
 
 
而本文正式采用了第一种方案，主要是中途添加该功能，时间也不充裕，抽取字体大小又太过耗时。
 
微信字体大小个人猜测使用第二种方案，后者是更好的实现方式也不一定。
 
好了，扯得有点多。我要开始真正的表演了 ... 掌声呢   鲜花呢 .....................人呢
 
 
二、效果预览
 
 
三、实现步骤
 
1、自定义字体调整控件
 
 
 
网上找了一个相似的控件并加以完善，功能相对简单，就不做介绍了。
 
 

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Point;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import java.util.ArrayList;
import java.util.List;
import blcs.lwb.lwbtool.R;
import blcs.lwb.lwbtool.utils.DensityUtils;

/**
 * TODO 仿微信字体大小调整
 * 自定义属性：
 * lineWidth        线条粗细
 * lineColor        线条颜色
 * totalCount       线条格数
 * circleColor      球型颜色
 * circleRadius     球型颜色半径
 * textFontColor    文字颜色
 * smallSize        小“A” 字体大小
 * standerSize      “标准” 字体大小
 * bigSize          大“A” 字体大小
 * defaultPosition  默认位置
 */
public class FontSizeView extends View {

    private int defaultLineColor = Color.rgb(33, 33, 33);
    private int defaultLineWidth;
    private int defaultMax = 5;
    private int defaultCircleColor = Color.WHITE;
    private int defaultCircleRadius;
    // 当前所在位置
    private int currentProgress;

    // 默认位置
    private int defaultPosition = 1;

    // 一共有多少格
    private int max = 7;
    // 线条颜色
    private int lineColor = Color.BLACK;
    // 线条粗细
    private int lineWidth;

    //字体颜色
    private int textColor = Color.BLACK;
    //字体大小
    private int smallSize = 14;
    private int standerSize = 16;
    private int bigSize = 28;

    // 圆半径
    private int circleRadius;
    private int circleColor = Color.WHITE;
    // 一段的宽度，根据总宽度和总格数计算得来
    private int itemWidth;
    // 控件的宽高
    private int height;
    private int width;
    // 画笔
    private Paint mLinePaint;
    private Paint mTextPaint;
    private Paint mText1Paint;
    private Paint mText2Paint;
    private Paint mCirclePaint;
    // 滑动过程中x坐标
    private float currentX = 0;
    // 有效数据点
    private List<Point> points = new ArrayList<>();

    private float circleY;
    private float textScaleX;
    private float text1ScaleX;
    private float text2ScaleX;

    public FontSizeView(Context context) {
        this(context, null);
    }

    public FontSizeView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context, attrs);
    }

    private void init(Context context, AttributeSet attrs) {

        // initDefault
        defaultLineWidth = DensityUtils.dp2px(context, 2);
        defaultCircleRadius = DensityUtils.dp2px(context, 35);
        lineWidth = DensityUtils.dp2px(context, 1);
        TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.FontSizeView);
        final int N = typedArray.getIndexCount();
        for (int i = 0; i < N; i++) {
            initCustomAttr(typedArray.getIndex(i), typedArray);
        }
        typedArray.recycle();
        // 初始化画笔
        mLinePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mLinePaint.setColor(lineColor);
        mLinePaint.setStyle(Paint.Style.FILL_AND_STROKE);
        mLinePaint.setStrokeWidth(lineWidth);

        //文字画笔
        mTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mTextPaint.setColor(textColor);
        mTextPaint.setStyle(Paint.Style.FILL_AND_STROKE);
//        mTextPaint.setStrokeWidth(DensityUtils.dp2px(context, 1));
        mTextPaint.setTextSize(DensityUtils.sp2px(context, smallSize));
        textScaleX = mTextPaint.measureText("A");
        //文字画笔
        mText1Paint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mText1Paint.setColor(textColor);
        mText1Paint.setStyle(Paint.Style.FILL_AND_STROKE);
        mText1Paint.setTextSize(DensityUtils.sp2px(context, bigSize));
        text1ScaleX = mText1Paint.measureText("A");

        //文字画笔
        mText2Paint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mText2Paint.setColor(textColor);
        mText2Paint.setStyle(Paint.Style.FILL_AND_STROKE);
        mText2Paint.setTextSize(DensityUtils.sp2px(context, standerSize));
        text2ScaleX = mText2Paint.measureText("标准");

        mCirclePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mCirclePaint.setColor(circleColor);
        mCirclePaint.setStyle(Paint.Style.FILL);

        // 设置阴影效果
        setLayerType(LAYER_TYPE_SOFTWARE, null);
        mCirclePaint.setShadowLayer(2, 0, 0, Color.rgb(33, 33, 33));
    }

    private void initCustomAttr(int attr, TypedArray typedArray) {
        if (attr == R.styleable.FontSizeView_lineColor) {
            lineColor = typedArray.getColor(attr, defaultLineColor);
        } else if (attr == R.styleable.FontSizeView_circleColor) {
            circleColor = typedArray.getColor(attr, defaultCircleColor);
        } else if (attr == R.styleable.FontSizeView_lineWidth) {
            lineWidth = typedArray.getDimensionPixelSize(attr, defaultLineWidth);
        } else if (attr == R.styleable.FontSizeView_circleRadius) {
            circleRadius = typedArray.getDimensionPixelSize(attr, defaultCircleRadius);
        } else if (attr == R.styleable.FontSizeView_totalCount) {
            max = typedArray.getInteger(attr, defaultMax);
        } else if (attr == R.styleable.FontSizeView_textFontColor) {
            textColor = typedArray.getColor(attr, textColor);
        } else if (attr == R.styleable.FontSizeView_smallSize) {
            smallSize = typedArray.getInteger(attr, smallSize);
        } else if (attr == R.styleable.FontSizeView_standerSize) {
            standerSize = typedArray.getInteger(attr, standerSize);
        } else if (attr == R.styleable.FontSizeView_bigSize) {
            bigSize = typedArray.getInteger(attr, bigSize);
        }else if (attr == R.styleable.FontSizeView_defaultPosition) {
            defaultPosition = typedArray.getInteger(attr, defaultPosition);
        }
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        height = h;
        width = w;
        circleY = height / 2;
        // 横线宽度是总宽度-2个圆的半径
        itemWidth = (w - 2 * circleRadius) / max;
        // 把可点击点保存起来
        for (int i = 0; i <= max; i++) {
            points.add(new Point(circleRadius + i * itemWidth, height / 2));
        }
        //初始刻度
        currentX = points.get(defaultPosition).x;
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        //画字
        canvas.drawText("A", points.get(0).x - textScaleX / 2, height / 2 - 50, mTextPaint);

        //画字
        canvas.drawText("标准", points.get(1).x - text2ScaleX / 2, height / 2 - 50, mText2Paint);

        //画字
        canvas.drawText("A", points.get(points.size() - 1).x - text1ScaleX / 2, height / 2 - 50, mText1Paint);

        // 先画中间的横线
        canvas.drawLine(points.get(0).x, height / 2, points.get(points.size() - 1).x, height / 2, mLinePaint);
        // 绘制刻度
        for (Point point : points) {
            canvas.drawLine(point.x + 1, height / 2 - 20, point.x + 1, height / 2 + 20, mLinePaint);
        }

        // 画圆
        if (currentX < circleRadius) {
            currentX = circleRadius;
        }
        if (currentX > width - circleRadius) {
            currentX = width - circleRadius;
        }

        // 实体圆
        canvas.drawCircle(currentX + 1, circleY, circleRadius, mCirclePaint);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        currentX = event.getX();
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                invalidate();
                break;
            case MotionEvent.ACTION_MOVE:
                invalidate();
                break;
            case MotionEvent.ACTION_UP:
                //回到最近的一个刻度点
                Point targetPoint = getNearestPoint(currentX);
                if (targetPoint != null) {
                    // 最终
                    currentX = points.get(currentProgress).x;
                    invalidate();
                }
                if (onChangeCallbackListener != null) {
                    onChangeCallbackListener.onChangeListener(currentProgress);
                }
                break;
        }
        return true;
    }

    /**
     * 获取最近的刻度
     */
    private Point getNearestPoint(float x) {
        for (int i = 0; i < points.size(); i++) {
            Point point = points.get(i);
            if (Math.abs(point.x - x) < itemWidth / 2) {
                currentProgress = i;
                return point;
            }
        }
        return null;
    }

    public void setChangeCallbackListener(OnChangeCallbackListener listener) {
        this.onChangeCallbackListener = listener;
    }

    private OnChangeCallbackListener onChangeCallbackListener;

    public interface OnChangeCallbackListener {
        void onChangeListener(int position);
    }

    public void setDefaultPosition(int position){
        defaultPosition=position;
        if (onChangeCallbackListener != null) {
            onChangeCallbackListener.onChangeListener(defaultPosition);
        }
        invalidate();
    }
}
 
 
 
xml使用方式：
 
 
   <blcs.lwb.lwbtool.View.FontSizeView
        android:id="@+id/fsv_font_size"
        android:layout_width="wrap_content"
        android:layout_height="120dp"
        android:layout_marginLeft="@dimen/space_line2"
        android:layout_marginRight="@dimen/space_line2"
        android:background="@color/white"
        app:circleRadius="11dp"
        app:lineColor="@color/round_corner_progress_bar_progress_default"
        app:standerSize="16" />
 
2、滑动按钮改变当前页面预览字体大小
 
    //备注
    <!--字体大小 及倍数-->
    <!--0.875=14/16 -->
    <dimen name="sp_small">14sp</dimen>
    <!--1  标准-->
    <dimen name="sp_stander">16sp</dimen>
    <!--1.125=18/16-->
    <dimen name="sp_big1">18sp</dimen>
    <!--1.25=20/16-->
    <dimen name="sp_big2">20sp</dimen>
    <!--1.375=22/16-->
    <dimen name="sp_big3">22sp</dimen>
    <!--1.5=24/16-->
    <dimen name="sp_big4">24sp</dimen>
    <!--1.625=26/16-->
    <dimen name="sp_big5">26sp</dimen>
    <!--1.75=28/16-->
    <dimen name="sp_big6">28sp</dimen>
 
        //滑动返回监听
        fsvFontSize.setChangeCallbackListener(new FontSizeView.OnChangeCallbackListener() {
            @Override
            public void onChangeListener(int position) {
                int dimension = getResources().getDimensionPixelSize(R.dimen.sp_stander);
                //根据position 获取字体倍数
                fontSizeScale = (float) (0.875 + 0.125 * position);
                //放大后的sp单位
                double v = fontSizeScale * (int) DensityUtils.px2sp(FontSizeActivity.this, dimension);
                //改变当前页面大小
                changeTextSize((int) v);
            }
        });
   
 
 /**
     * 改变textsize 大小
     */
    private void changeTextSize(int dimension) {
        tv_font_size1.setTextSize(dimension);
        tv_font_size2.setTextSize(dimension);
        tv_font_size3.setTextSize(dimension);
    }
 
3、返回时，保存放大倍数并重启应用
 
  public void onClick(View view) {
      SPUtils.put(FontSizeActivity.this,Constants.SP_FontScale,fontSizeScale);
      //重启应用
      AppManager.getAppManager().finishAllActivity();
      IntentUtils.toActivity(FontSizeActivity.this, MainActivity.class,true);
  }
 
4、初始化应用时配置字体放大倍数。
 
 
 
改变全局大小的关键  //  res.updateConfiguration(config,res.getDisplayMetrics());
 
 
  //fontSizeScale = (float) SPUtils.get(this, Constants.SP_FontScale, 0.0f);
 @Override
    public Resources getResources() {
        Resources res =super.getResources();
        Configuration config = res.getConfiguration();
        if(fontSizeScale>0.5){//防止第一次获取SP时得到默认值0
            config.fontScale= fontSizeScale;//设置正常字体大小的倍数
        }
        res.updateConfiguration(config,res.getDisplayMetrics());
        return res;
    }
 
就是这么简单。。细节我就不写了 ，贴出来代码太长。看着累 ，需要的大家可以去看我项目
 
 
四、Demo地址
 
 
 
https://github.com/DayorNight/BLCS
 
 
五、内容推荐
 
 
 
简书：《Android 仿微信全局字体大小调整》
 
 
《Android JUnit单元测试》
 
《Android Log日志封装》
 
《Android Rxjava+Retrofit网络请求框架封装》
 
 
 
如果你觉得我写的不错或者对您有所帮助的话
 
 
不妨顶一个【微笑】，别忘了点赞、收藏、加关注哈
 
 
您的每个举动都是对我莫大的支持
 
 

 
Android字体大小怎么自适应不同分辨率人到了某一个阶段，生活就会开始给你做减法。拿走你的一些朋友，让你知道谁才是真正的朋友。拿走你的一些梦想，让你认清现实是什么。当你能看着自己忙里忙外，成为自己生活的旁观者，你才能找到自己的节奏。
 
Android中一个layout想适配各种屏幕尺寸那么需要按以下规则去写layout: 1. 尽量使用wrap_content、match_parent、weight 来规定layout的大校 2. 要确保布局的灵活性并适应各种尺寸的屏幕，应使用 “wrap_content” 和 “match_parent” 控制某些视图早上第一个想到的是你，夜里最后一个想到的也是你。
 
Android 字体大小怎么自适应不同分辨率原谅我强烈的占有欲，不好意思我有感情洁癖，因为我爱你，所以我看谁都像情敌。
 

 
夜影驱动编程，很高兴为您解答问题。 通过计算比例来动态设置字体大小 //w2 实际屏幕宽度 //w1 默认视图宽度 float rate = (float) w2/w1; //20为默认大小 通过乘以比例算出当前字体大小 paint.setTextSize((int)(20*rate)) 如果我的回答没能帮助您。
 
Android 开发字体的大小需要用google提供的sp单位，而控件的大小需要使用dip 或者dp。 1. dp(或者dip device independent pixels)一种基于屏幕密度的抽象单位。在每英寸160点的显示器上，1dp=1px。不同设备有不同的显示效果。
 
字体大小一般是sp,控件大小采用dp, android 手机一般牵涉到适配的问题，基本有几个原则: 默认配置一般都是根据目前主流的分辨率来设置，比如现在都是4.7寸以上，720p,1080p这2个，可以默认为720p。这样就可以覆盖大多数的手机了。
 
Android字体大小怎么自适应不同分辨率 在textSize里面填写的尺寸的时候,尺寸的单位写成sp就好了,其实更换的自适应可以写成单位为dp,但是谷歌推荐用sp。都可以的。
 
如何让Android字体自适应屏幕分辨率转眼间，我都五年级啦。在小学阶段有好多同学都喜欢对方，我也不例外。他是个副班长，人还不错。今天下午他在玩游戏的时候，向我闺蜜告白啦！气死宝宝啦！我要和我的闺蜜绝交。啊～不开森！还是祝福他吧。人毕竟不可以强分享他人。反正是我闺蜜，抢啦就抢啦呗。没多大事啊！可我还是忍不住的哭啦！呜呜。
 
在不同的分辨率下，Android字体大小怎么自适应分辨率的变化？ 假设需要适应320x240，480x320分辨率。在res目录下新建文件夹values-320x240, values-480x320。然后在文件夹 values ，values-320x240 和 values-480x320 下新建xml文件dimens.xml。
 
自适应的话可以采用下面这样的办法： 假设需要适应320x240，480x320等分辨率。在res目录下新建文件夹values-320x240, values-480x320。然后在文件夹 values ，values-320x240 和 values-480x320 下新建xml文件dimens.xml xxdip 再将文字的大小在曾经的都是过往云烟，往事不回头，余生不将就，愿生活越来越好。
 
在android中如何让你的程序适应各种分辨率？(1)drawable-hdpi里面存放高分辨率的图片。如WVGA (480x800),FWVGA (480x854)。 (2)drawable-mdpi里面存放中等分辨率的图片。如HVGA (320x480)。 (3)drawable-ldpi里面存放低分辨率的图片,如QVGA (240x320)。
 
android开发软件如何做到自适应屏幕大小及不同分辨我看了网上说的一些方法，但是那都是特别简单的布局，只有一两个简单的代码中尽量不要设置控件的宽高(尽量使用match_parent或者wrap_content) 即使某些时候要一定要设置控件的大小,那也要用(控件用dp,字体用sp) 图片要分多套设计,mdpi里放320*480的;hdpi里放480*800的;xhdpi放720*1280的;xxhdpi里放1080*1920大小的 是上天安排，亦或是追寻内心深处的悸动。冥冥之中我选择了你，作为我旅程的第一站。
 
安卓游戏的分辨率是否能够自动调整。我的手机：魅族,M9 问题类型：系统设置老子喜欢你的时候你吃屎我都觉得你可爱，老子不喜欢你的时候你吃饭我都觉得你在吃
 
这个需要看游戏本身的设计了。有的游戏设计的好的话，有可能能做到分辨率的自动调整。

 
Android应用字体大小默认随系统设置的字体大小而变化，但您可能不希望您的应用字体大小随系统设置变化，想要自己控制，例如微信。本文简单介绍一下如何实现应用字体大小动态调整而不是依赖系统设置
 
字体大小变化是由android.content.res.Configuration.class类中的fontScale控制的，因此，若想我们的应用字体大小变化不随系统变化而是由我们自主控制，就需要我们修改fontScale为我们自己设置的数值。由于Android系统更新的问题，可能您无法通过网上的答案来实现您的目的。根据目前笔者的测试情况，我们需要从Activity层面进行处理才能自主控制字体大小变化，为了方便统一处理，将控制逻辑放在了Application中，下面贴出实例图片及代码(由于笔者水平实在是low，不会做滑动条来控制字体大小，因此，示例中使用了两个TextView来点击控制字体大小变化,哈哈哈~)
 

 
public class MainApplication extends Application implements Application.ActivityLifecycleCallbacks {
 
private List activityList;
 
private float fontScale;
 
private SharedPreferences preferences;
 
private static MainApplication mainApplication;
 
@Override
 
public void onCreate() {
 
super.onCreate();
 
init();
 
}
 
private void init() {
 
mainApplication = this;
 
preferences = PreferenceManager.getDefaultSharedPreferences(this);
 
fontScale = getFontScale();
 
registerActivityLifecycleCallbacks(this);
 
}
 
public static float getFontScale() {
 
float fontScale = 1.0f;
 
if (mainApplication != null) {
 
fontScale = mainApplication.preferences.getFloat("fontScale", 1.0f);
 
}
 
return fontScale;
 
}
 
@Override
 
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
 
if (activityList == null) {
 
activityList = new ArrayList<>();
 
}
 
// 禁止字体大小随系统设置变化
 
Resources resources = activity.getResources();
 
if (resources != null && resources.getConfiguration().fontScale != fontScale) {
 
android.content.res.Configuration configuration = resources.getConfiguration();
 
configuration.fontScale = fontScale;
 
resources.updateConfiguration(configuration, resources.getDisplayMetrics());
 
}
 
activityList.add(activity);
 
}
 
@Override
 
public void onActivityStarted(Activity activity) {
 
}
 
@Override
 
public void onActivityResumed(Activity activity) {
 
}
 
@Override
 
public void onActivityPaused(Activity activity) {
 
}
 
@Override
 
public void onActivityStopped(Activity activity) {
 
}
 
@Override
 
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
 
}
 
@Override
 
public void onActivityDestroyed(Activity activity) {
 
if (activityList != null) {
 
activityList.remove(activity);
 
}
 
}
 
public static void setAppFontSize(float fontScale) {
 
if (mainApplication != null) {
 
List activityList = mainApplication.activityList;
 
if (activityList != null) {
 
for (Activity activity : activityList) {
 
if (activity instanceof SettingActivity) {
 
continue;
 
}
 
Resources resources = activity.getResources();
 
if (resources != null) {
 
android.content.res.Configuration configuration = resources.getConfiguration();
 
configuration.fontScale = fontScale;
 
resources.updateConfiguration(configuration, resources.getDisplayMetrics());
 
activity.recreate();
 
if (fontScale != mainApplication.fontScale) {
 
mainApplication.fontScale = fontScale;
 
mainApplication.preferences.edit().putFloat("fontScale", fontScale).apply();
 
}
 
}
 
}
 
}
 
}
 
}
 
}
 
首先，我们需要让Application实现ActivityLifecycleCallbacks接口，并注册ActivityLifecycleCallbacks以便监控所有Activity，并维护一个Activity列表。在onActivityCreated方法中我们可以监控每个Activity的创建，当新建一个Activity时，获取其Resource资源，进而判断Configuration.fontScale数值是否与我们自己的fontScale数值(默认1.0，即大小没有经过调整)相等，若数值不一致时，修改之。其实，只要我们通过一个Activity修改了Configuration.fontScale数值，那么所有其他Activity再获取Configuration.fontScale数值时，其值均为我们修改过之后的数值。通过这一波操作，已经保证我们的应用的字体大小不随系统设置变化了。
 
下面看如何动态调整应用字体大小，看一下setAppFontSize方法。该方法遍历Activity列表，获取Resource配置信息并修改其fontScale数值，需要注意的是，若想及时生效，需要调用Activity的recreate()方法。
 
注意：recreate()方法会导致Activity重建，但幸运的是调用该方法，系统会触发onSaveInstanceState回调，因此强烈建议您在该回调方法中做好数据保存以便重建时恢复数据。
 
另外一个建议是：不要把字体大小设置选项层级埋的太深，最好放在首页，因为这样放置，当调整字体大小时只会导致首页重建，不会影响其他页面，将影响将到最小