一文带你精通Android中的Activity

本文将会从活动的生命周期、启动模式、Intent数据传输、最佳实践等多维度来讲解Activity,希望对你有用

生命周期

  • 深入理解活动的生命周期,可以帮助我们更加流畅地编程,并在管理系统资源方面更加游刃有余

活动状态

每个活动在生命周期中最多有运行、暂停、停止、销毁四种状态

  • 1)运行状态:当一个活动在返回栈的栈顶时,该活动就处于运行状态,如果回收处于运行状态的活动,会带来极差的用户体验
  • 2)暂停状态:当活动不再处于栈顶,但仍然可见时,则活动进入了暂停状态(并非每个活动都会占满屏幕);处于暂停状态的活动属于完全存活;只有在内存非常紧张的情况下,系统才会考虑回收该状态的活动
  • 3)停止状态:当活动不再处于栈顶,且完全不可见时,会进入停止状态;系统仍然会为该状态的活动保存相应的状态和成员变量;当其他地方需要内存时,系统可能会回收该状态的活动
  • 4)销毁状态:当活动从返回栈中移除后就变成了销毁状态,系统会最为倾向于回收处于该状态的活动,以保证系统的内存充足

生存期 & 回调方法

Activity有如下7个回调函数,覆盖活动生命周期的每个环节:

  • onCreate()在活动第一次被创建时调用,用于完成活动的初始化操作,如:布局加载、绑定事件
  • onStart():在活动由不可见变为可见时调用

  • onResume():在活动准备好和用户交互时调用,该活动会处于返回栈的栈顶,且活动处于运行状态
  • onPause()在系统准备去启动或恢复其他活动时调用,通常会在该方法中释放比较消耗CPU的资源,以及某些关键数据

  • onStop()在活动完全不可见时调用,和onPause()方法的主要区别在于:如果启动的新活动是对话框类的活动,onPause()方法会执行,而onStop()方法并不会执行
  • onDestory()在活动被销毁前调用,之后活动的状态将变为销毁状态,常用于完成内存释放等操作

  • onRestart():在活动由停止变为运行状态前调用,即让活动重新启动

以上,除了onRestart(),其他方法都是两两相对的,所以,活动可分为三种生存期:

  • 完整生存期:活动在onCreate()方法和onDestory()方法之间所经历的,即为完整的生存期
  • 可见生存期:活动在onStart()方法和onStop()方法之间所经历的,为可见生存期,即活动对用户总是可见的,即便可能无法和用户交互;可通过onStart()和onStop()方法来合理地管理对用户可见的资源以保证处于停止状态的活动不会占用过多内存
  • 前台生存期:活动在onResume()方法和onPause()方法之间所经历的,即为前台生存期 =》活动总是处于运行状态,活动可以和用户交互

代码验证

  • 在LifecycleActivity、NormalActivity的生命周期的回调方法中输出日志以便于查看:
import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import com.example.myapplication1.R;

public class LifecycleActivity extends AppCompatActivity {

    public static final String TAG = "LifecycleActivity";

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

        Log.d(TAG, "--- onCreate ---");

        Button startNormalBtn = (Button) findViewById(R.id.start_normal_btn);
        startNormalBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startActivity(new Intent(LifecycleActivity.this, NormalActivity.class));
            }
        });
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.d(TAG, "--- onStart ---");
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "--- onResume ---");
    }


    @Override
    protected void onPause() {
        super.onPause();
        Log.d(TAG, "--- onPause ---");

    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d(TAG, "--- onStop ---");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "--- onDestroy ---");
    }

    @Override
    public void onRestart() {
        super.onRestart();
        Log.d(TAG, "--- onRestart ---");
    }
}
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

import com.example.myapplication1.R;

public class NormalActivity extends AppCompatActivity {

    public static final String TAG = "NormalActivity";

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

        Log.d(TAG, "--- onCreate ---");
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.d(TAG, "--- onStart ---");
    }
    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "--- onResume ---");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d(TAG, "--- onPause ---");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d(TAG, "--- onStop ---");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "--- onDestroy ---");
    }

    @Override
    public void onRestart() {
        super.onRestart();
        Log.d(TAG, "--- onRestart ---");
    }
}
  • activity_lifecycle.xml:
    <Button
        android:id="@+id/start_normal_btn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Start NormalActivity" 
        android:textAllCaps="false"/>
  • layout_normal.xml:
    <TextView
        android:id="@+id/start_normal_tv"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="this is NormalActivity" />

运行结果分析如下:

  • 启动LifecycleActivity,当LifecycleActivity第一次被创建时会依次执行onCreate()onStart()onResume()
    在这里插入图片描述
  • 点击按钮,启动NormalActivity,NormalActivity会将LifecycleActivity完全遮盖,LifecycleActivity会执行onPause()onStop(),而启动的NormalActivity则会像LifecycleActivity一样,依次执行onCreate()onStart()onResume()
    在这里插入图片描述
  • 在Back键返回LifecycleActivity,由于返回栈中已存在LifecycleActivity,则会调用onRestart()方法重启活动,来到运行状态,准备好和用户交互的资源,同时还会调用onStop()、onDestory() 暂停,销毁活动
  • LifecycleActivity界面再返回到桌面,会像前面的NormalActivity一样,依次onPause()、onStop()、onDestroy()在这里插入图片描述

小结:

  • 打开新页面的方法调用顺序为:onCreate =》onStart =》onResume
  • 关闭旧页面的方法调用顺序为:onPause =》onStop =》onDestory
  • 活动相应的状态转换如下:在这里插入图片描述

启动模式(launchMode)

  • Activity由任务(Task)栈管理,一个任务就是一组存放在栈中活动的集合,该栈也被称为返回栈(Back Stack)
  • 默认情况下,每当启动一个新的Activity,该Activity就会被加入到返回栈中,并处于栈顶的位置;当按下Back键或调用finish()方法区销毁活动时,处于栈顶的Activity机会出栈(系统总是会显示栈顶的Activity给用户)
  • 启动模式一共有4种,分别为standard、singleTop、singleTask和singleInstance,可在AndroidManifest.xml中通过给标签指定android:launchMode属性来指定启动模式

1)standard(标准模式)

  • standard是默认的启动模式,即标准模式,在不显示指定启动模式的情况下,所有的活动都默认使用该启动模式;每启动一个Activity,都会创建一个新的实例
  • 如果目标活动FirstActivity已经在栈顶,再次启动活动,还会再创建一个新的活动实例并压入栈中
  • 应用场景:适用于不希望保留状态或者每次启动都需要创建新实例的场景,例如,一个浏览器的多个页面,每次打开新的页面都会创建一个新的实例
import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import com.example.myapplication1.R;
import com.example.myapplication1.intent.SecondActivity;

public class OneActivity extends AppCompatActivity {

    private Button oneBtn;

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

        oneBtn = findViewById(R.id.oneBtn);
        oneBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startActivity(new Intent(OneActivity.this, OneActivity.class));   // 验证standard和singleTop启动模式
                // startActivity(new Intent(OneActivity.this, SecondActivity.class));
            }
        });
    }
}
  • 修改AndroidManifest.xml,添加launchMode属性:
        <activity
            android:name=".launch.OneActivity"
            android:exported="true"
            android:launchMode="standard" />
  • xml布局:
    <Button
        android:id="@+id/oneBtn"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="this is OneActivity"
        android:gravity="center"
        android:textAllCaps="false"/>
  • 在OneActivity上启动OneActivity显得有些奇怪,这里只是为便于我们理解、验证,一般不会这么写

  • 多次点击按钮,从logcat过滤出的日志可看出,每次点击按钮都会创建一个新的Activity入栈,同时,要多次点击返回键才能退出程序

  • 触发点击事件后,从OneActivity跳转到TwoActivity时,修改代码:

startActivity(new Intent(OneActivity.this, SecondActivity.class));

输出结果如下,如果目标Activity不在栈顶,就会新建Activity并入栈:
在这里插入图片描述

2)singleTop(栈顶复用模式)

  • singleTop:当要启动的目标Activity已经处于栈顶时,不会创建新的实例,会复用栈顶的Activity,并且其onNewIntent()方法会被调用;如果目标Activity不在栈顶,则跟standard一样会重复创建新的Activity实例
  • 应用场景:适合需要频繁打开和关闭的场景,例如:通知栏点击后打开的页面;一个推送通知的详情页面,用户可能会频繁打开和关闭它,使用SingleTop模式可以避免创建多个实例
  • 将前面用到OneActivity的launchMode属性修改为singleTop,重新运行OneActivity,多次点击按钮,只会创建一个Activity,并一直复用
    在这里插入图片描述

在这里插入图片描述

3)singleTask(栈内复用模式)

  • singleTask:每次启动活动时,系统会首先检查任务栈中是否存在该Activity的实例,如果发现存在,则直接复用该实例(目标Activity会调用onRestart()方法重新启动),在该目标Activity上的Activity都会调用onDestroy()方法清除(被弹出栈);如果任务栈中没有该Activity,则创建新的实例
  • 应用场景:适合作为应用的主页或者一个任务的开始页面,例如:邮箱应用的主页面;一个邮箱应用的主Activity,用户从任何地方返回到主页面时,都应该看到同一个Activity实例,而不是创建新的实例
  • TwoActivity、OneActivity重写onRestart()和onDestroy()方法
    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d("OneActivity","---onRestart---");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d("OneActivity","---onDestroy---");
    }
  • 重新运行OneActivity,点击按钮,OneActivity跳转到TwoActivity,在TwoActivity中重新启动OneActivity,则会发现返回栈中已经有OneActivity实例了,于是TwoActivity出栈【onDestroy()方法被调用】,OneActivity来到栈顶【onRestart()方法被调用】
    在这里插入图片描述

4)singleInstance(全局单例模式)

  • singleInstance:全局复用,不管哪个Task栈,只要存在目标Activity,就复用;每个Activity占用一个新的Task栈
  • 如果应用中的活动要允许其他程序调用,且其他应用和我们的应用可共享该活动实例,前面三种启动模式无法做到(同一个活动在不同的返回栈中入栈需要创建新的实例),而使用singleInstance模式就可以解决该问题,实现只有一个单独的返回栈来管理该活动,不管是哪个应用来访问该活动,都共用同一个返回栈,如此可解决共享活动实例的问题
  • 应用场景:适合需要与程序分离开的页面,如拨打电话、系统通讯录等;一个来电页面,它应该总是单独存在,不受其他Activity的影响。
  • 修改launchMode属性singleInstance,并在Activity中输出返回栈的唯一标识:taskId
|  |  |
|--|--|
|  |  |

Log.d("OneActivity","task id is " + getTaskId());
  • 输出结果如下,三个Activity都分别放在不同的返回栈中
    在这里插入图片描述

基本使用

下面我用一个复杂的案例重新串下Activity相关的知识点:

  • 第一个Activity:
import androidx.appcompat.app.AppCompatActivity;
import android.app.ActivityManager;
import android.content.ComponentName;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import com.example.myapplication1.R;

public class FirstActivity extends AppCompatActivity {

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

        // 输出日志,便于测试Activity的启动模式
        Log.d("FirstActivity","---onCreate---");
        Log.d("FirstActivity","taskId ="+getTaskId() + ", hasCode =" + hashCode());
        printTaskLog();

        TextView view = findViewById(R.id.firstView);
        view.setText("this is first activity");

        Button detailBtn = findViewById(R.id.detail);
        detailBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 创建Intent对象的三种方式
                // 1. Intent(Context packageContext, Class<?> cls)
                Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
                // 2. Intent intent = new Intent();
                //  intent.setClass(FirstActivity.this, SecondActivity.class);
                // 3. intent.setComponent(new ComponentName(FirstActivity.this, SecondActivity.class));
                startActivity(intent);
            }
        });
    }

    private void printTaskLog() {
        try {
            ActivityInfo activityInfo = getPackageManager().getActivityInfo(getComponentName(), PackageManager.GET_META_DATA);
            Log.d("current task name", activityInfo.taskAffinity);
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
    }
}
  • 页面布局activity_first.xml:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:gravity="center"
    tools:context=".intent.FirstActivity">

    <TextView
        android:id="@+id/firstView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello,Android developer!" />

    <Button
        android:id="@+id/detail"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="查看详情"/>

</LinearLayout>
  • 第一个Activity跳转来到的第二个Activity:
import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
import android.graphics.Color;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import com.example.myapplication1.R;

public class SecondActivity extends AppCompatActivity {

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

        Log.d("SecondActivity","---onCreate---");
        Log.d("SecondActivity","taskId ="+getTaskId() + ", hasCode =" + hashCode());
        printTaskLog();

        Button button = findViewById(R.id.second);
        button.setText("this is second activity");
        button.setTextColor(Color.RED);
        button.setBackgroundColor(Color.BLUE);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(SecondActivity.this,"SecondActivity向ThirdActivity传递数据",Toast.LENGTH_LONG).show();
                Intent intent = new Intent(SecondActivity.this, ThirdActivity.class);
                startActivity(intent);
            }
        });
    }

    private void printTaskLog() {
        try {
            ActivityInfo activityInfo = getPackageManager().getActivityInfo(getComponentName(), PackageManager.GET_META_DATA);
            Log.d("current task name", activityInfo.taskAffinity);
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
    }
}
  • 页面布局activity_second.xml:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 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"
    android:gravity="center"
    tools:context=".intent.SecondActivity">

    <Button
        android:id="@+id/second"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/detail"/>

</LinearLayout>
  • 第二个Activity跳转来到的第三个Activity:
import androidx.appcompat.app.AppCompatActivity;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.TextView;

import com.example.myapplication1.R;

public class ThirdActivity extends AppCompatActivity implements View.OnClickListener {

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

        Log.d("ThirdActivity","---onCreate---");
        Log.d("ThirdActivity","taskId ="+getTaskId() + ", hasCode =" + hashCode());
        printTaskLog();

        TextView view = findViewById(R.id.third);
        view.setText("this is third activity");

        // this: ThirdActivity对象
        view.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        if (v.getId() == R.id.third){
            // 结束当前的活动页面
            finish();
        }
    }

    private void printTaskLog() {
        try {
            ActivityInfo activityInfo = getPackageManager().getActivityInfo(getComponentName(), PackageManager.GET_META_DATA);
            Log.d("current task name", activityInfo.taskAffinity);
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
    }
}
  • 页面布局activity_third.xml:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 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=".intent.ThirdActivity">

    <Button
        android:id="@+id/third"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        android:text="@string/thirdText"/>

</LinearLayout>
  • 控件触发事件的两种常用写法(以Click点击事件举例):
    1)控件调用set开头的监听事件方法
    View.java:
    public void setOnClickListener(@Nullable OnClickListener l) {
        if (!isClickable()) {
            setClickable(true);
        }
        getListenerInfo().mOnClickListener = l;
    }

在这里插入图片描述

2)实现监听事件的接口View.OnClickListener,重写事件的onClick(View v)处理方法:
在这里插入图片描述

  • AndroidManifest.xml清单文件中加入三个Activity的声明,没有指定launchMode属性,则默认为standard:
        <activity
            android:name=".intent.ThirdActivity"
            android:exported="true" />
        <activity
            android:name=".intent.SecondActivity"
            android:exported="true" />
        <activity
            android:name=".intent.FirstActivity"
            android:exported="true" 
            android:launchMode="standard"/>

运行结果说明:

  • 运行FirstActivity,依次点击FirstActivity、SecondActivity、ThirdActivity中的Button按钮,输出结果如下图所示,三个Activity被放入id为83,名称为com.example.myapplication1的任务栈中,又hash值不同,则可认为每启动一个Activity,都会重新创建一个Activity栈帧压入任务栈中
    在这里插入图片描述
  • 当跳转到ThirdActivity时,点击Button,触发点击事件,调用finish()方法,会结束ThirdActivity,跳转到SecondActivity
  • 启动模式使用singleInstance,修改AndroidManifest.xml中Activity的launchMode属性:
    android:launchMode="singleInstance"
    如下图可见,任务栈的唯一标识taskId不同,即存放每个Activity的Task栈不同,每创建一个Activity,都会生成一个新的任务栈来存放Activity
    在这里插入图片描述

最佳实践

随时随地退出程序

  • 当跳转的页面足够多后,退出程序需要连按多次Back键才行,Home键只是将程序挂起,并没有退出程序
  • 如果程序需要一个注销或退出的功能,则必须要实现随时随地能退出程序
  • 实现思路:用集合类管理所有的活动,代码如下:
import android.app.Activity;
import android.os.Build;

import java.util.ArrayList;
import java.util.List;

public class ActivityManager {
    private static List<Activity> activityList = new ArrayList<>();

    // 将当前创建的活动添加到管理器中
    public static void add(Activity activity){
        activityList.add(activity);
    }

    // 将要销毁的活动从管理器中移除
    public static void remove(Activity activity){
        activityList.remove(activity);
    }

    // 完成管理器中的所有活动,保证能随时随地退出程序
    public static void finishAll(){
        for (Activity activity : activityList) {
            if (!activity.isFinishing()){
                activity.finish();
            }
        }
    }

    public static List<Activity> getAll(){
        return activityList;
    }
}
  • 编写Activity测试:
import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;

import com.example.myapplication1.R;

public class ManagerActivity extends AppCompatActivity {

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

        Log.d("ManagerActivity","current activity: " + getClass().getSimpleName());
        ActivityManager.add(this);

        findViewById(R.id.managerBtn).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startActivity(new Intent(ManagerActivity.this,LogoutActivity.class));
            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        ActivityManager.remove(this);
    }
}
import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import com.example.myapplication1.R;

public class LogoutActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_logout);
        ActivityManager.add(this);

        Log.d("logout before",ActivityManager.getAll().toString());

         findViewById(R.id.logoutBtn).setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
                 // 完全退出应用程序
                 ActivityManager.finishAll();
//                 Log.d("logout going",ActivityManager.getAll().toString());
             }
         });

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        ActivityManager.remove(this);
        Log.d("logout after",ActivityManager.getAll().toString());
    }
}
  • 为能明显看出效果,可以多跳转几个页面,最后来到LogoutActivity,点击Button,直接退出应用程序,来到桌面
    注意:需要在跳转Activity中重写onDestroy()方法并在管理器中移除当前Activity,在onCreate()方法中,触发点击事件前加入 ActivityManager.add(this);
    @Override
    protected void onDestroy() {
        super.onDestroy();
        ActivityManager.remove(this);
    }
  • 活动管理器中的活动在执行finishAll()前后的变化:
    在这里插入图片描述

参考

  • 23
    点赞
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Eclipse是一个开放源代码的集成开发环境(IDE),可用于Java开发,但也可以用于其他编程语言的开发。在本文,我将向你展示如何使用Eclipse进行Java开发。 1. 下载Eclipse 首先,你需要从Eclipse官方网站下载Eclipse IDE。下载页面上将提供几个不同的版本,包括Eclipse IDE for Java Developers、Eclipse IDE for JavaScript and Web Developers,以及Eclipse IDE for C/C++ Developers等。选择适合你的版本,然后按照安装向导进行安装。 2. 创建Java项目 一旦你安装了Eclipse,你可以启动它并创建一个新的Java项目。选择“File”->“New”->“Java Project”,然后按照向导创建一个新的Java项目。在创建项目时,你需要指定项目名称、项目类型以及JRE版本等信息。 3. 创建Java类 一旦你创建了一个Java项目,你就可以创建一个Java类。选择你的Java项目,在“src”文件夹上右键单击,然后选择“New”->“Class”。输入类名和选择要继承的类(如果有的话),然后点击“Finish”。 4. 编写Java代码 现在你已经创建了一个Java类,可以开始编写Java代码了。在Eclipse的编辑器,你可以输入Java代码并保存它。当你保存Java文件时,Eclipse会自动编译你的代码,并在Problems视图显示任何编译错误。 5. 运行Java程序 一旦你编写了Java代码并保存了它,你可以运行Java程序。右键单击Java文件,然后选择“Run As”->“Java Application”。如果一切顺利,你的Java程序将在控制台输出结果。 6. 调试Java程序 如果你的Java程序出现了错误或不按预期运行,你可以使用Eclipse的调试器来调试它。在Eclipse的编辑器,你可以设置断点并启动调试器。当程序执行到断点时,调试器会暂停程序并允许你检查变量、运行代码等。 7. 导入外部JAR包 有时,你可能需要使用外部JAR包来完成你的Java项目。在Eclipse,你可以简单地将外部JAR包导入到你的项目。右键单击Java项目,然后选择“Build Path”->“Configure Build Path”。在“Libraries”选项卡上,你可以添加外部JAR包。 总结 在本文,我们介绍了如何使用Eclipse进行Java开发。我们学习了如何创建Java项目、创建Java类、编写Java代码、运行Java程序、调试Java程序以及导入外部JAR包。Eclipse具有强大的功能,可以大大提高Java开发的效率。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值