Java 如何解决捕获或最终预期错误？

如何解决android studio中的“catch”或“finally”预期错误

公共类片段最近扩展了片段{
查看根视图、父视图；
私人回收站；
专用适配器通道适配器通道；
私人SwipeRefreshLayout SwipeRefreshLayout；
私有呼叫callbackCall=null；
私人int post_总计=0；
private int失败\u page=0；
私人间质；
专用离线数据库数据库助手；
int计数器=3；
@可空
@凌驾
CreateView上的公共视图（布局、充气机、视图组容器、捆绑包保存状态）{
根视图=充气器。充气（R.layout.fragment\u recent，null）；
父视图=getActivity（）.findViewById（R.id.main\u内容）；
loadalad（）；
swipeRefreshLayout=（swipeRefreshLayout）根视图.findViewById（R.id.swipe\u刷新\u布局\u主视图）；
swipeRefreshLayout.setColorSchemeResources（R.color.orange、R.color.green、R.color.blue、R.color.red）；
recyclerView=（recyclerView）root\u view.findViewById（R.id.RecyclerViewWhome）；
setLayoutManager（新的LinearLayoutManager（getActivity（））；
recyclerView.setHasFixedSize（true）；
//设置数据和列表适配器
adapterChannel=new adapterChannel（getActivity（），recyclerView，new ArrayList（））；
recyclerView.setAdapter（适配器通道）；
//在项目列表上单击
adapterChannel.setOnItemClickListener（新的adapterChannel.OnItemClickListener（）{
@凌驾
公共空间单击（视图v，通道obj，内部位置）{
Intent Intent=new Intent（getActivity（），ActivityDetailChannel.class）；
intent.putExtra（常量键通道类别、对象类别名称）；
intent.putExtra（常量键通道ID，对象通道ID）；
intent.putExtra（常量键通道名称，对象通道名称）；
intent.putExtra（常量键通道图像，对象通道图像）；
intent.putExtra（Constant.KEY\u CHANNEL\u URL，obj.CHANNEL\u URL）；
intent.putExtra（常量键通道描述，对象通道描述）；
星触觉（意向）；
showAlad（）；
}
});
//当滚动到达底部时检测
adapterChannel.setOnLoadMoreListener（新adapterChannel.OnLoadMoreListener（）{
@凌驾
public void onLoadMore（int当前页面）{
if（post_total>adapterChannel.getItemCount（）&当前页面！=0）{
int next_page=当前_page+1；
请求操作（下一页）；
}否则{
adapterChannel.setLoaded（）；
}
}
});
//在刷卡列表上
swipeRefreshLayout.setOnRefreshListener（新的swipeRefreshLayout.OnRefreshListener（））{
@凌驾
公共void onRefresh（）{
if（callbackCall！=null&&callbackCall.isExecuted（））callbackCall.cancel（）；
adapterChannel.resetListData（）；
请求行动（1）；
}
});
请求行动（1）；
返回root\u视图；
}
私有void displayApiResult（最终列表通道）{
适配器通道。插入数据（通道）；
swipeProgress（假）；
if（channels.size（）==0）{
showNoItemView（true）；
}
}
私有无效请求列表PostAPI（最终整版页码）{
ApiInterface ApiInterface=RestAdapter.createAPI（）；
callbackCall=apiInterface.getPostByPage（页码号，Config.LOAD\u MORE）；
callbackCall.enqueue（新的Callback（）{
@凌驾
公共void onResponse（调用、响应）{
CallbackChannel resp=response.body（）；
如果（resp！=null&&resp.status.equals（“ok”））{
post_总计=相应计数_总计；
显示结果（相应职位）；
}否则{
onFailRequest（页码）；
}
}
@凌驾
失败时公共无效（调用调用，可丢弃的t）{
如果（！call.isCanceled（））onFailRequest（页码）；
}
});
}
专用无效onFailRequest（整版页码）{
失败的页面=页面号；
adapterChannel.setLoaded（）；
swipeProgress（假）；
if（NetworkCheck.isConnect（getActivity（）））{
}否则{
//showToast（“互联网非”）；
如果（databaseHelper.getOfflineData（“FragmentCategory”）.length（）！=0）{
setJson（databaseHelper.getOfflineData（“FragmentCategory”），false；
}
}
}
//databaseHelper.removeAll（）；
私有无效请求操作（最终整版页码）{
showFailedView（假“”）；
showNoItemView（假）；
如果（页码=1）{
swipeProgress（正确）；
}否则{
adapterChannel.setLoading（）；
}
new Handler（）.postDelayed（new Runnable（））{
@凌驾
公开募捐{
requestListPostApi（页码）；
}
}，恒定延迟时间）；
}
@凌驾
公共空间{
super.ondestory（）；
swipeProgress（假）；
if（callbackCall！=null&&callbackCall.isExecuted（））{
callbackCall.cancel（）；
}
}
私有void showFailedView（布尔显示，字符串消息）{
View lyt\u failed=（View）root\u View.findviewbyd（R.id.lyt\u failed\u home）；
（（TextView）root_view.findviewbyd（R.id.failed_message））.setText（message）；
如果（显示）{
recyclerView.setVisibility（View.GONE）；
lyt_失败。设置可见性（View.VISIBLE）；
}否则{
recyclerView.setVisibility（View.VISIBLE）；
lyt_失败。设置可见性（视图已消失）；
}
（（按钮）
public class FragmentRecent extends Fragment {

    View root_view, parent_view;
    private RecyclerView recyclerView;
    private AdapterChannel adapterChannel;
    private SwipeRefreshLayout swipeRefreshLayout;
    private Call<CallbackChannel> callbackCall = null;
    private int post_total = 0;
    private int failed_page = 0;
    private InterstitialAd interstitialAd;
    private OfflineDatabase databaseHelper;
    int counter = 3;

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        root_view = inflater.inflate(R.layout.fragment_recent, null);
        parent_view = getActivity().findViewById(R.id.main_content);

        loadInterstitialAd();

        swipeRefreshLayout = (SwipeRefreshLayout) root_view.findViewById(R.id.swipe_refresh_layout_home);
        swipeRefreshLayout.setColorSchemeResources(R.color.orange, R.color.green, R.color.blue, R.color.red);

        recyclerView = (RecyclerView) root_view.findViewById(R.id.recyclerViewHome);
        recyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));
        recyclerView.setHasFixedSize(true);


        //set data and list adapter
        adapterChannel = new AdapterChannel(getActivity(), recyclerView, new ArrayList<Channel>());
        recyclerView.setAdapter(adapterChannel);

        // on item list clicked
        adapterChannel.setOnItemClickListener(new AdapterChannel.OnItemClickListener() {
            @Override
            public void onItemClick(View v, Channel obj, int position) {
                Intent intent = new Intent(getActivity(), ActivityDetailChannel.class);
                intent.putExtra(Constant.KEY_CHANNEL_CATEGORY, obj.category_name);
                intent.putExtra(Constant.KEY_CHANNEL_ID, obj.channel_id);
                intent.putExtra(Constant.KEY_CHANNEL_NAME, obj.channel_name);
                intent.putExtra(Constant.KEY_CHANNEL_IMAGE, obj.channel_image);
                intent.putExtra(Constant.KEY_CHANNEL_URL, obj.channel_url);
                intent.putExtra(Constant.KEY_CHANNEL_DESCRIPTION, obj.channel_description);
                startActivity(intent);

                showInterstitialAd();
            }
        });

        // detect when scroll reach bottom
        adapterChannel.setOnLoadMoreListener(new AdapterChannel.OnLoadMoreListener() {
            @Override
            public void onLoadMore(int current_page) {
                if (post_total > adapterChannel.getItemCount() && current_page != 0) {
                    int next_page = current_page + 1;
                    requestAction(next_page);
                } else {
                    adapterChannel.setLoaded();
                }
            }
        });

        // on swipe list
        swipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
            @Override
            public void onRefresh() {
                if (callbackCall != null && callbackCall.isExecuted()) callbackCall.cancel();
                adapterChannel.resetListData();
                requestAction(1);
            }
        });

        requestAction(1);


        return root_view;
    }

    private void displayApiResult(final List<Channel> channels) {
        adapterChannel.insertData(channels);
        swipeProgress(false);
        if (channels.size() == 0) {
            showNoItemView(true);
        }
    }

    private void requestListPostApi(final int page_no) {
        ApiInterface apiInterface = RestAdapter.createAPI();
        callbackCall = apiInterface.getPostByPage(page_no, Config.LOAD_MORE);
        callbackCall.enqueue(new Callback<CallbackChannel>() {
            @Override
            public void onResponse(Call<CallbackChannel> call, Response<CallbackChannel> response) {
                CallbackChannel resp = response.body();
                if (resp != null && resp.status.equals("ok")) {
                    post_total = resp.count_total;
                    displayApiResult(resp.posts);
                } else {
                    onFailRequest(page_no);
                }
            }

            @Override
            public void onFailure(Call<CallbackChannel> call, Throwable t) {
                if (!call.isCanceled()) onFailRequest(page_no);
            }

        });
    }

    private void onFailRequest(int page_no) {
        failed_page = page_no;
        adapterChannel.setLoaded();
        swipeProgress(false);
        if (NetworkCheck.isConnect(getActivity())) {
        } else {
            //showToast("Internet Not");
            if (databaseHelper.getOfflineData("FragmentCategory").length() != 0) {
                setJson(databaseHelper.getOfflineData("FragmentCategory"), false);
            }
        }
    }
    //databaseHelper.removeAll();


    private void requestAction(final int page_no) {
        showFailedView(false, "");
        showNoItemView(false);
        if (page_no == 1) {
            swipeProgress(true);
        } else {
            adapterChannel.setLoading();
        }
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                requestListPostApi(page_no);
            }
        }, Constant.DELAY_TIME);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        swipeProgress(false);
        if (callbackCall != null && callbackCall.isExecuted()) {
            callbackCall.cancel();
        }
    }

    private void showFailedView(boolean show, String message) {
        View lyt_failed = (View) root_view.findViewById(R.id.lyt_failed_home);
        ((TextView) root_view.findViewById(R.id.failed_message)).setText(message);
        if (show) {
            recyclerView.setVisibility(View.GONE);
            lyt_failed.setVisibility(View.VISIBLE);
        } else {
            recyclerView.setVisibility(View.VISIBLE);
            lyt_failed.setVisibility(View.GONE);
        }
        ((Button) root_view.findViewById(R.id.failed_retry)).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                requestAction(failed_page);
            }
        });
    }

    private void showNoItemView(boolean show) {
        View lyt_no_item = (View) root_view.findViewById(R.id.lyt_no_item_home);
        ((TextView) root_view.findViewById(R.id.no_item_message)).setText(R.string.no_post_found);
        if (show) {
            recyclerView.setVisibility(View.GONE);
            lyt_no_item.setVisibility(View.VISIBLE);
        } else {
            recyclerView.setVisibility(View.VISIBLE);
            lyt_no_item.setVisibility(View.GONE);
        }
    }


    private void swipeProgress(final boolean show) {
        if (!show) {
            swipeRefreshLayout.setRefreshing(show);
            return;
        }
        swipeRefreshLayout.post(new Runnable() {
            @Override
            public void run() {
                swipeRefreshLayout.setRefreshing(show);
            }
        });
    }

    public void setJson(String result, Boolean isOnline) {
        try {

            //inseting result to database
            if(isOnline) {
                ContentValues offline_data = new ContentValues();

                offline_data.put(OfflineDatabase.KEY_OFFLINE_DATA, result);

                if(databaseHelper.getOfflineData("FragmentCategory").length()!=0) {
                    databaseHelper.update("FragmentCategory",offline_data);
                } else {
                    offline_data.put(OfflineDatabase.KEY_ACTIVITY_NAME, "FragmentCategory");
                    databaseHelper.addOfflineData(offline_data, null);
                    //handle both exceptions
                }
            }}}
    private void loadInterstitialAd() {
        if (Config.ENABLE_ADMOB_INTERSTITIAL_ADS) {
            interstitialAd = new InterstitialAd(getActivity());
            interstitialAd.setAdUnitId(getResources().getString(R.string.admob_interstitial_unit_id));
            interstitialAd.loadAd(new AdRequest.Builder().build());
            interstitialAd.setAdListener(new AdListener() {
                @Override
                public void onAdClosed() {
                    interstitialAd.loadAd(new AdRequest.Builder().build());
                }
            });
        } else {
            Log.d("AdMob", "AdMob Interstitial is Enabled");
        }
    }

    private void showInterstitialAd() {
            if (Config.ENABLE_ADMOB_INTERSTITIAL_ADS) {

                if (interstitialAd != null && interstitialAd.isLoaded()) {

                    if (counter == Config.ADMOB_INTERSTITIAL_ADS_INTERVAL) {
                        interstitialAd.show();
                        counter = 1;
                    } else {
                        counter++;
                    }

                } else {
                    Log.d("AdMob", "Interstitial Ad is Disabled");
                }
            } else {
                Log.d("AdMob", "AdMob Interstitial is Disabled");
            }
        }}

public void setJson(String result, Boolean isOnline) {
    try {
       ...
    }
    ...
}

    try {
       ...
    } catch(Exception e) {

    } finally {

    }