小白入门HorizontalListView

于 2018-08-02 14:38:20 发布
阅读量722 收藏 2
点赞数
文章标签： HorizontalListView
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42674696/article/details/81299956
版权

 

HorizontalListView思路

基于https://blog.csdn.net/qq941263013/article/details/80264198

五个部分：HorizontalListView.java（照搬https://blog.csdn.net/qq941263013/article/details/80264198）

                  HorizontalzlistViewAdapter.java(适配器需要自己写的)

                  MainActivity.java(调用adapter，然后填充数据)

                  activitymain.xml（父布局，放horizontalListview）

                  item_listview(子布局，每一个item的布局结构，例如本文里面子布局只放了一个textview)

结构：

 

1，horizontalListView.java(相当于listview的mainactivity)

import android.content.Context;
import android.database.DataSetObserver;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.view.GestureDetector;
import android.view.GestureDetector.OnGestureListener;
import android.view.MotionEvent;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ListAdapter;
import android.widget.Scroller;

import java.util.LinkedList;
import java.util.Queue;

/**
 * 横向滑动的ListView(滑动和点击冲突已经解决)
 */
public class HorizontalListView extends AdapterView<ListAdapter> {

    float startX;
    float startY;
    public boolean mAlwaysOverrideTouch = true;
    protected ListAdapter mAdapter;
    private int mLeftViewIndex = -1;
    private int mRightViewIndex = 0;
    protected int mCurrentX;
    protected int mNextX;
    private int mMaxX = Integer.MAX_VALUE;
    private int mDisplayOffset = 0;
    protected Scroller mScroller;
    private GestureDetector mGesture;
    private Queue<View> mRemovedViewQueue = new LinkedList<View>();
    private OnItemSelectedListener mOnItemSelected;
    private OnItemClickListener mOnItemClicked;
    private OnItemLongClickListener mOnItemLongClicked;
    private boolean mDataChanged = false;


    public HorizontalListView(Context context, AttributeSet attrs) {
        super(context, attrs);
        initView();
    }

    private synchronized void initView() {
        mLeftViewIndex = -1;
        mRightViewIndex = 0;
        mDisplayOffset = 0;
        mCurrentX = 0;
        mNextX = 0;
        mMaxX = Integer.MAX_VALUE;
        mScroller = new Scroller(getContext());
        mGesture = new GestureDetector(getContext(), mOnGesture);
    }

    @Override
    public void setOnItemSelectedListener(OnItemSelectedListener listener) {
        mOnItemSelected = listener;
    }

    @Override
    public void setOnItemClickListener(OnItemClickListener listener) {
        mOnItemClicked = listener;
    }

    @Override
    public void setOnItemLongClickListener(OnItemLongClickListener listener) {
        mOnItemLongClicked = listener;
    }

    private DataSetObserver mDataObserver = new DataSetObserver() {

        @Override
        public void onChanged() {
            synchronized (HorizontalListView.this) {
                mDataChanged = true;
            }
            invalidate();
            requestLayout();
        }

        @Override
        public void onInvalidated() {
            reset();
            invalidate();
            requestLayout();
        }
    };

    @Override
    public ListAdapter getAdapter() {
        return mAdapter;
    }

    @Override
    public View getSelectedView() {
        return null;
    }

    @Override
    public void setAdapter(ListAdapter adapter) {
        if (mAdapter != null) {
            mAdapter.unregisterDataSetObserver(mDataObserver);
        }
        mAdapter = adapter;
        mAdapter.registerDataSetObserver(mDataObserver);
        reset();
    }

    private synchronized void reset() {
        initView();
        removeAllViewsInLayout();
        requestLayout();
    }

    @Override
    public void setSelection(int position) {
    }

    private void addAndMeasureChild(final View child, int viewPos) {
        LayoutParams params = child.getLayoutParams();
        if (params == null) {
            params = new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);
        }

        addViewInLayout(child, viewPos, params, true);
        child.measure(MeasureSpec.makeMeasureSpec(getWidth(), MeasureSpec.AT_MOST),
                MeasureSpec.makeMeasureSpec(getHeight(), MeasureSpec.AT_MOST));
    }

    @Override
    protected synchronized void onLayout(boolean changed, int left, int top, int right, int bottom) {
        super.onLayout(changed, left, top, right, bottom);

        if (mAdapter == null) {
            return;
        }

        if (mDataChanged) {
            int oldCurrentX = mCurrentX;
            initView();
            removeAllViewsInLayout();
            mNextX = oldCurrentX;
            mDataChanged = false;
        }

        if (mScroller.computeScrollOffset()) {
            int scrollx = mScroller.getCurrX();
            mNextX = scrollx;
        }

        if (mNextX <= 0) {
            mNextX = 0;
            mScroller.forceFinished(true);
        }
        if (mNextX >= mMaxX) {
            mNextX = mMaxX;
            mScroller.forceFinished(true);
        }

        int dx = mCurrentX - mNextX;

        removeNonVisibleItems(dx);
        fillList(dx);
        positionItems(dx);

        mCurrentX = mNextX;

        if (!mScroller.isFinished()) {
            post(new Runnable() {
                @Override
                public void run() {
                    requestLayout();
                }
            });
        }
    }

    private void fillList(final int dx) {
        int edge = 0;
        View child = getChildAt(getChildCount() - 1);
        if (child != null) {
            edge = child.getRight();
        }
        fillListRight(edge, dx);

        edge = 0;
        child = getChildAt(0);
        if (child != null) {
            edge = child.getLeft();
        }
        fillListLeft(edge, dx);
    }

    private void fillListRight(int rightEdge, final int dx) {
        while (rightEdge + dx < getWidth() && mRightViewIndex < mAdapter.getCount()) {

            View child = mAdapter.getView(mRightViewIndex, mRemovedViewQueue.poll(), this);
            addAndMeasureChild(child, -1);
            rightEdge += child.getMeasuredWidth();

            if (mRightViewIndex == mAdapter.getCount() - 1) {
                mMaxX = mCurrentX + rightEdge - getWidth();
            }

            if (mMaxX < 0) {
                mMaxX = 0;
            }
            mRightViewIndex++;
        }
    }

    private void fillListLeft(int leftEdge, final int dx) {
        while (leftEdge + dx > 0 && mLeftViewIndex >= 0) {
            View child = mAdapter.getView(mLeftViewIndex, mRemovedViewQueue.poll(), this);
            addAndMeasureChild(child, 0);
            leftEdge -= child.getMeasuredWidth();
            mLeftViewIndex--;
            mDisplayOffset -= child.getMeasuredWidth();
        }
    }

    private void removeNonVisibleItems(final int dx) {
        View child = getChildAt(0);
        while (child != null && child.getRight() + dx <= 0) {
            mDisplayOffset += child.getMeasuredWidth();
            mRemovedViewQueue.offer(child);
            removeViewInLayout(child);
            mLeftViewIndex++;
            child = getChildAt(0);

        }

        child = getChildAt(getChildCount() - 1);
        while (child != null && child.getLeft() + dx >= getWidth()) {
            mRemovedViewQueue.offer(child);
            removeViewInLayout(child);
            mRightViewIndex--;
            child = getChildAt(getChildCount() - 1);
        }
    }

    private void positionItems(final int dx) {
        if (getChildCount() > 0) {
            mDisplayOffset += dx;
            int left = mDisplayOffset;
            for (int i = 0; i < getChildCount(); i++) {
                View child = getChildAt(i);
                int childWidth = child.getMeasuredWidth();
                child.layout(left, 0, left + childWidth, child.getMeasuredHeight());
                left += childWidth + child.getPaddingRight();
            }
        }
    }

    public synchronized void scrollTo(int x) {
        mScroller.startScroll(mNextX, 0, x - mNextX, 0);
        requestLayout();
    }


    /**
     * 上下滑动需要拦截，
     */
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        boolean handled = super.dispatchTouchEvent(ev);
        handled |= mGesture.onTouchEvent(ev);
        getParent().requestDisallowInterceptTouchEvent(true);

        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                startX = (int) ev.getX();
                startY = (int) ev.getY();
                break;
            case MotionEvent.ACTION_MOVE:
                int endX = (int) ev.getX();
                int endY = (int) ev.getY();

                int dx = (int) (endX - startX);
                int dy = (int) (endY - startY);

                if (Math.abs(dx) + 50 > Math.abs(dy)) {

                } else {
                    // 上下滑动,需要拦截
                    getParent().requestDisallowInterceptTouchEvent(false);
                }
                break;
            case MotionEvent.ACTION_UP:
                break;
        }
        return handled | super.dispatchTouchEvent(ev);
    }

    protected boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
                              float velocityY) {
        synchronized (HorizontalListView.this) {
            mScroller.fling(mNextX, 0, (int) -velocityX, 0, 0, mMaxX, 0, 0);
        }
        requestLayout();
        return true;
    }

    protected boolean onDown(MotionEvent e) {
        mScroller.forceFinished(true);
        return true;
    }

    private OnGestureListener mOnGesture = new GestureDetector.SimpleOnGestureListener() {

        @Override
        public boolean onDown(MotionEvent e) {
            return HorizontalListView.this.onDown(e);
        }

        @Override
        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
                               float velocityY) {
            return HorizontalListView.this.onFling(e1, e2, velocityX, velocityY);
        }

        @Override
        public boolean onScroll(MotionEvent e1, MotionEvent e2,
                                float distanceX, float distanceY) {

            synchronized (HorizontalListView.this) {
                mNextX += (int) distanceX;
            }
            requestLayout();
            return true;
        }

        @Override
        public boolean onSingleTapConfirmed(MotionEvent e) {
            for (int i = 0; i < getChildCount(); i++) {
                View child = getChildAt(i);
                if (isEventWithinView(e, child)) {
                    if (mOnItemClicked != null) {
                        mOnItemClicked.onItemClick(HorizontalListView.this, child, mLeftViewIndex + 1 + i, mAdapter.getItemId(mLeftViewIndex + 1 + i));
                    }
                    if (mOnItemSelected != null) {
                        mOnItemSelected.onItemSelected(HorizontalListView.this, child, mLeftViewIndex + 1 + i, mAdapter.getItemId(mLeftViewIndex + 1 + i));
                    }
                    break;
                }
            }
            return true;
        }

        @Override
        public void onLongPress(MotionEvent e) {
            int childCount = getChildCount();
            for (int i = 0; i < childCount; i++) {
                View child = getChildAt(i);
                if (isEventWithinView(e, child)) {
                    if (mOnItemLongClicked != null) {
                        mOnItemLongClicked.onItemLongClick(HorizontalListView.this, child, mLeftViewIndex + 1 + i, mAdapter.getItemId(mLeftViewIndex + 1 + i));
                    }
                    break;
                }

            }
        }

        private boolean isEventWithinView(MotionEvent e, View child) {
            Rect viewRect = new Rect();
            int[] childPosition = new int[2];
            child.getLocationOnScreen(childPosition);
            int left = childPosition[0];
            int right = left + child.getWidth();
            int top = childPosition[1];
            int bottom = top + child.getHeight();
            viewRect.set(left, top, right, bottom);
            return viewRect.contains((int) e.getRawX(), (int) e.getRawY());
        }
    };

    //解决滑动和点击冲突问题
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                startX = ev.getX();
                startY = ev.getY();
                break;
            case MotionEvent.ACTION_MOVE:
                float endX = ev.getX();
                float endY = ev.getY();

                float dx = endX - startX;
                float dy = endY - startY;

                if (Math.abs(dx) - 10 > Math.abs(dy)) {
                    return true;
                } else if (Math.abs(dx) < Math.abs(dy) - 10) {
                    return true;
                }
                break;
            case MotionEvent.ACTION_UP:
                break;
        }
        return super.onInterceptTouchEvent(ev);
    }
}

 

2，建立Adapter

重写getview！

convertview缓存机制，参考https://blog.csdn.net/xucongxiang/article/details/50151035

 

package maker.collage.photo.com.myapplication;

import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.TextView;

import java.util.List;
import java.util.Map;
import java.util.zip.Inflater;

import static maker.collage.photo.com.myapplication.R.*;
import static maker.collage.photo.com.myapplication.R.layout.activity_main;
import static maker.collage.photo.com.myapplication.R.layout.item_listview;

/**
 * Created by sja on 18/8/1.
 */


public class HorizontalListViewAdapter extends BaseAdapter {

    private LayoutInflater myLayoutInflater = null;
    private final Context context;
    private final int screenWidth;
    private String[] strings;

    public HorizontalListViewAdapter(Context applicationContext, int screenWidth, String[] strings) {
        this.context = applicationContext;
        this.screenWidth = screenWidth;
        this.strings = strings;

        this.myLayoutInflater = LayoutInflater.from(context);
    }


    @Override
    public int getCount() {
        return strings.length;
    }

    @Override
    public Object getItem(int position) {
        return strings[position];
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

//    }
    public View getView(final int position, View convertView, ViewGroup parent) {

        final ViewHolder holder;

        if (convertView == null) {
            holder = new ViewHolder();

            convertView = myLayoutInflater.inflate(R.layout.item_listview, null);

            holder.rl=(RelativeLayout) convertView.findViewById(R.id.rl);
            holder.tv = (TextView) convertView.findViewById(id.tv);

            convertView.setTag(holder);
        } else {
            holder = (ViewHolder) convertView.getTag();
        }

//        计算每个子布局的宽度
        RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) holder.rl.getLayoutParams();
        layoutParams.width = (int) (screenWidth / 5.5);
        layoutParams.addRule(RelativeLayout.CENTER_IN_PARENT);
        holder.rl.setLayoutParams(layoutParams);

        holder.tv.setText(strings[position]);


        return convertView;
    }
}

//class ViewHolder {//使用butterknife没成功
    @InjectView(R.id.tv)
//    TextView tv;
    @InjectView(R.id.rl)
//    RelativeLayout rl;

//}
final class ViewHolder {
    public TextView tv;
    public RelativeLayout rl;

}

3，主activity，自定义类

主要工作：初始化adapter需要的参数，实例horizontallistview和horizontallistviewadapter

public class MainActivity extends AppCompatActivity {



        private HorizontalListView hlv = null;
        private HorizontalListViewAdapter myAdapter =null;
        private String[] strings = new String[]{"零售ngvgmhg", "零退vghmvhj", "批销", "批退", "调剂","ghmv","gyhmvhm","sgnvgmv","bh","mvh",",bhjm"};
        int screenWidth =768;//不知道为啥使用windows manager获取屏幕宽度一直失败返回空指针，所以就直接给了一个数

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

            hlv = (HorizontalListView)findViewById(R.id.hlv);
            myAdapter = new HorizontalListViewAdapter(this,screenWidth,strings);
            hlv.setAdapter(myAdapter);
         
        }
}

4，activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="maker.collage.photo.com.myapplication.MainActivity">

    <maker.collage.photo.com.myapplication.HorizontalListView
        android:id="@+id/hlv"
        android:layout_width="match_parent"
        android:layout_height="96dp"
        android:orientation="horizontal"
        android:background="#FF3366"/>



</android.support.constraint.ConstraintLayout>

5,item_listview

这里踩了一个坑后面写

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="10dp">
    <RelativeLayout
        android:id="@+id/rl"
        android:layout_width="66dp"
        android:layout_height="match_parent"
        android:orientation="horizontal"
        android:background="#FFCC00">


        <TextView
            android:id="@+id/tv"
            android:layout_width="match_parent"
            android:layout_height="50dp"
            android:layout_centerInParent="true"
            android:textColor="#00FFCC"
            android:background="#000099"
            android:textSize="20dp"
            />
    </RelativeLayout>



</RelativeLayout>

效果：

以下是我踩的坑

1，我没学过listview直接baidu了horizontallistview，所以首先理解方面出了问题，不懂子布局怎么加入父布局，不懂自定义类到底啥玩意，不懂mainactivity咋写，只有照搬的horizontallistview.java是不报错的。

首先设计好item_listview，本文只加了一个文本

怎么加入的：首先在main activity.java中加入子布局中需要的数据（例如我想加入文本，就搞了一个string数组，传入数据），然后adpter相当于传输管道（两头分别是mian activity和horizontallistview），把数据传输到父布局对应的horizontallistview.java中，所以写好adapter很关键。

2，convertview和viewholder和butterknife

convertview一开始xjb copy，后来懂了adpter的意义才知道这么写

convertView = myLayoutInflater.inflate(R.layout.item_listview, null);

3，想写屏幕适配

//计算每个子布局的宽度
        RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) 
        holder.rl.getLayoutParams();//rl是子布局中的一个RelativeLayout，来用限制text大小
        layoutParams.width = (int) (screenWidth / 5.5);
        layoutParams.addRule(RelativeLayout.CENTER_IN_PARENT);
        holder.rl.setLayoutParams(layoutParams);

结果一直报错！因为最开始我直接把rl当作子局部id，后来一想子布局id是item_listview啊，然后加了RelativeLayout，把这个id叫做rl就好了。

结果获取屏幕宽度一直返回空指针，所以也间接失败了。

 

写了两天，一直xjb写，终于明白copy没用的，必须先了解背后的原理，数据的传递，代码才能真正的运行起来。

打不过我吧
关注
2024Matlab小白入门详细教程
全栈川川
07-10 6万+
2022年Matlab最新详细教程
HorizontalListView
01-18
HorizontalListView 实现右拉刷新 初始定位 点击改变item样式
Android UI开发: 横向ListView(HorizontalListView)及一个简单相册的完整实现 (附源码下载)
热门推荐
yanzi1225627的专栏
03-15 20万+
本文内容：1、横向ListView的所有实现思路; 2、其中一个最通用的思路HorizontalListView，并基于横向ListView开发一个简单的相册； 3、实现的横向ListView在点击、浏览时item背景会变色，并解决了listview里setSelected造成item的选择状态混乱的问题。
HorizontalListView 横向listview
chen88358323的专栏
12-04 4万+
tag:HorizontalListView 横向listview  仿 优酷 播放列表 由于优酷的客户端很酷，最近在做视频列表的时候客户要求做出类似效果，开始打算用Gallery的，不过后来发现横向的listview就可以解决这个问题，所以特此记录下，膜拜下国外的大牛，源码的传送门在这里 HorizontalListViewActivity.java package org.com
工具篇——HorizontalListView（横向滑动的ListView）
一个灵活的胖子MrWang
05-10 1万+
写代码的四点： 1.明确需求。要做什么？ 2.分析思路。要怎么做？（1,2,3……） 3.确定步骤。每一个思路要用到哪些语句、方法和对象。 4.代码实现。用具体的语言代码将思路实现出来。学习新技术的四点： 1.该技术是什么？ 2.该技术有什么特点？（使用需注意的方面） 3.该技术怎么使用？（写Demo） 4.该技术什么时候用？（在Pr...
HorizontalListView横着的Listview
tasty
11-30 407
先看一下效果图 介可不是什么ScrollView哦，android系统自带的ListView都是竖着的，这个是横着的，自定义的ListView，不说了上代码 package com.zhangyu.activity; import java.util.LinkedList; import java.util.Queue; import android.content.Context;
前端小白入门系列课程完整版
02-22
图标"icon.jpg"可能是课程的logo，而"前端小白入门系列课程完整版.zip"则包含了整个课程的视频、讲义、练习材料等资源，等待你去探索和学习。这个课程对于零基础的前端新手来说，是一条通往专业开发者的理想路径。
APICloud小白入门.zip
09-28
这个"APICloud小白入门.zip"压缩包文件显然是一份专为初学者设计的教程资源，旨在帮助新手快速掌握APICloud Studio 3的使用方法和APP开发的基本流程。 首先，APICloud Studio 3是APICloud提供的集成开发环境（IDE）...
人工智能小白入门指南 .zip
12-26
人工智能小白入门指南/人工智能小白入门指南/人工智能小白入门指南/人工智能小白入门指南
JSP Mysql数据库入门，基于intellij idea2020（新手小白入门）
06-21
讲解数据库mysql的安装，数据库工具navicat的安装；jsp环境jdk和tomcat的安装；intellij idea2020如何新建和运行jsp页面，如何连接mysql数据库和操作；分页如何实现；讲解一个完整的简易信息系统的实现；...
HorizontalListView 水平ListView
12-24
自定义的一个水平方向上的ListView——HorizontalListView，由网上一个开源项目修改而来： https://github.com/dinocore1/DevsmartLib-Android
Android UI使用HorizontalListView实现水平滑动
08-26
主要为大家详细介绍了Android UI使用HorizontalListView实现水平滑动效果，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Listview中完美嵌套HorizontalListView
10-06
HorizontalListView的应用：Listview中完美嵌套HorizontalListView 详细见博客：http://blog.csdn.net/whitley_gong/article/details/48936689
横向listview------ HorizontalListView
安逸猿
04-28 4237
tag:HorizontalListView 横向listview  仿 优酷 播放列表 由于优酷的客户端很酷，最近在做视频列表的时候客户要求做出类似效果，开始打算用Gallery的，不过后来发现横向的listview就可以解决这个问题，所以特此记录下，膜拜下国外的大牛，源码的传送门在这里 HorizontalListViewActivity.Java [ja
自定义水平滑动的listview
dsxjinzhiqiang的博客
07-11 424
package com.cn.bsnt_android_tv.views; /**  * Created by zhiming on 2016/11/14.  */ import java.util.LinkedList; import java.util.Queue; import android.content.Context; import android.da
安卓横向滑动ListView(HorizontalListView)
qq_33658730的博客
01-18 792
HorizontalListView.javapackage com.example.administrator.myapplication.listview; /* * HorizontalListView.java v1.5 * * * The MIT License * Copyright (c) 2011 Paul Soucy (paul@dev-smart.com) *
使用HorizontalListView完成一个可拉动刷新的横向listview并且初始可以定位的
Andy
01-18 2316
本人纯菜鸟 因项目所需需要横向的listview 然后可以右拉加载下一页的数据，在网上找了3天，就http://blog.csdn.net/yanzi1225627/article/details/21294553#reply,这个给了不少启发，感谢大神的贡献。 1、首先是初始定位到 最后的item ，由于HorizontalListView没有实现setSelection方法，并且在网
python小白入门
最新发布
06-12
作为小白入门，以下是一些关键概念和步骤： 1. **安装Python**：首先，你需要在官网（https://www.python.org/downloads/）下载并安装最新版本的Python。 2. **基础语法**：学习Python的基本结构，如变量、数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值