① java工作流怎麼用activity
java工作流怎麼用activity
常用的是：activiti-engine-5.91.jar，activiti-spring-5.9.jar；
解釋：以上兩個只是activiti工作流的常用包，通常會配置如spring開發的java包，還有資料庫jar包等進行使用，但具體要用到什麼包，這個和業務開發的邏輯有關系，也沒辦法進行詳細說明的，所以只需要先下載常用的兩個，其餘的輔助包如：日誌包、spring包、資料庫包、hibernate包、struts包、mybatis包等根據實際需要添加即可。
② java工作流怎麼用activity
上常式序中首先進行宏定義，定義M來替代表達式(y*y+3*y),在s=3*M+4*M+5* M中作了宏調用。在預處理時經宏展開後該語句變為：
s=3*(y*y+3*y)+4*(y*y+3*y)+5*(y*y+3*y);
但要注意的是，在宏定義中表達式(y*y+3*y)兩邊的括弧不能少。否則會發生錯誤。如當作以下定義後：
#difine M y*y+3*y
在宏展開時將得到下述語句：
s=3*y*y+3*y+4*y*y+3*y+5*y*y+3*y；
這相當於：
3y2+3y+4y2+3y+5y2+3y；
③ Java!為什麼startActivity找不到字元！求救
/* */ package com.e4a.runtime;
/* */ import com.e4a.runtime.annotations.SimpleFunction;
/* */ import com.e4a.runtime.annotations.SimpleObject;
/* */ import com.e4a.runtime.collections.哈希表;
/* */ import android.net.Uri;
/* */ import android.content.Intent;
/* */ import android.app.Activity;
/* */ import com.e4a.runtime.variants.Variant;
import android.os.Bundle;
/* */ @SimpleObject
/* */ public final class intent
/* */ {
Activity activity;
public intent(Activity activity){
this.activity=activity;
}
/* */ public static void intent_view (String parse) {
Uri URI = URI.parse(parse);
Intent it = new Intent(Intent.ACTION_VIEW,URI);
activity.startActivity(it);
/* */ }
/* */ public static void intent_sendto (String parse,哈希表 paramHashmap) {
Uri URI = URI.parse(parse);
Intent it = new Intent(Intent.ACTION_SENDTO,URI);
/* 71 */ String name = null;
/* 72 */ Variant value = null;
/* 73 */ while (paramHashmap.是否有下一個()) {
/* 74 */ name = paramHashmap.下一個();
/* 75 */ value = paramHashmap.取項目(name);
it.putExtra(name, value.getString());
/* */ }
activity.startActivity(it);
/* */ }
/* */ }
傳入一個activity實例
④ 在一個Activity的java程序中，具體看問題描述
1、Intent
Intent是各個組件之間交互的一種重要方式，它不僅可以指明當前組件想要執行的動作，而且還能在各組件之間傳遞數據。Intent一般可用於啟動Activity、啟動Service、發送廣播等場景。
Intent大致可分為2中：
1、顯示Intent
2、隱式Intent
1.1、顯示Intent打開Activity
fun openActivity(){
val intent = Intent(this, KotlinFirstActivity::class.java)
intent.putExtra("param", "testParams")
startActivity(intent)
}
注意：KotlinFirstActivity::class.java就相當於Java中的KotlinFirstActivity.class。
1.2、隱式Intent打開程序內的Activity
相比於顯示Intent，隱式Intent並不指明啟動那個Activity而是指定了一系列的action和category，然後交由系統去分析找到合適的Activity並打開。
什麼是合適的Activity，其實就是和隱式Intent中指定的action和category完全匹配的Activity，而action和category我們可以在AdnroidManifest中指定。
在標簽中配置了action和category，只有和隱式Intent中的action和category完全匹配才能正常的打開該頁面。
val intent = Intent("com.example.abu.alertdialogdemo.ACTION_START")
startActivity(intent)
不是說action和category要完全匹配才能打開頁面嗎？這是因為android.intent.category.DEFAULT是一種默認的category，在調用startActivity()時會自動將這個category添加到Intent中。所以在Manifest中一定不要忘記配置這個默認的category:android.intent.category.DEFAULT,否則會報錯。
還有一點需要注意：Intent中只能添加一個action，但是可以添加多個category。
1.3、隱式Intent打開程序外的Activity
比如我們要打開系統的瀏覽器
fun openWeb(view: View) {
val intent = Intent(Intent.ACTION_VIEW)
intent.data = Uri.parse("https://www..com")
startActivity(intent)
}
Intent.ACTION_VIEW是系統內置的動作，然後將https://www..com通過Uri.parse()轉換成Uri對象，傳遞給intent.setData(Uri uri)函數。Kotlin中intent.data=Uri.parse("https://www..com")就相當於Java中的intent.setData(Uri.parse("https://www..com"))，這是Kotlin中的語法糖。
與此對應在標簽中配置一個標簽，用於更精確的指定當前Activity能夠相應的數據。標簽中主要可以配置一下內容：
1、android:scheme：用於指定數據的協議部分，如https
2、android:host：用於指定數據的主機名部分，如www..com
3、android:port：用於指定數據的埠，一般緊隨主機名後
4、android:path：用於指定數據的路徑
5、android:mimeType：用於指定支持的數據類型
只有當標簽中指定的內容和Intent中攜帶的data完全一致時，當前Activity才能響應該Intent。下面我們通過設置data，讓它也能響應打開網頁的Intent。
我們在ThirdActivity的中配置當前Activity能夠響應的action是Intent.ACTION_VIEW的常量值，而category指定了默認的category值，另外在標簽data中我們通過android:scheme="https"指定了數據的協議必須是https。另外由於AndroidStudio認為能夠響應ACTION_VIEW的Activity都應該加上BROWSABLE的category,否則會報出警告。加上BROWSABLE的category是為了實現deep link 功能和目前學習無關，所以我們在intent-filter標簽上添加tools:ignore="AppLinkUrlError"忽略警告。
然後我們就能通過隱式Intent的方法打開ThirdActivity了，代碼如下：
val intent= Intent(Intent.ACTION_VIEW)
intent.data=Uri.parse("https:")
startActivity(intent)
除了指定android:scheme為https我們也能隨意指定它的值，只需要保證AndroidManifest中設置的值和Intent中設置的data相對應即可。
2、Activity的生命周期
Activity類中定義了7個回調方法，覆蓋了Activity聲明周期的每一個環節。
1、onCreate()： 在Activity第一次創建時調用
2、onStart():在Activity可見但是沒有焦點時調用
3、onResume():在Activity可見並且有焦點時調用
4、onPause()：這個方法會在准備啟動或者恢復另一個Activity時調用，我們通常在該方法中釋放消耗CPU的資源或者保存數據，但在該方法內不能做耗時操作，否則影響另一個另一個Activity的啟動或恢復。
5、onStop()：在Activity不可見時調用，它和onPause主要區別就是：onPause在失去焦點時會調用但是依然可見，而onStop是完全不可見。
6、onDestory()：在Activity被銷毀前調用
7、onRestart()：在Activity由不在棧頂到再次回到棧頂並且可見時調用。
為了更好的理解Activity的生命周期，看下圖
Activity生命周期.png
3、體驗Activity的生命周期
下面我們通過實例更直觀的看下Activity的生命周期過程。
1、打開FirstActivity，生命周期過程如下
FirstActivity onCreate
FirstActivity onStart
FirstActivity onResume
2、在FirstActivity中打開SecondActivity，生命周期過程如下
FirstActivity onPause
SecondActivity onCreate
SecondActivity onStart
SecondActivity onResume
FirstActivity onStop
可以看到在打開SecondActivity時FirstActivity的onPause會執行，所以在onPause中是不能做耗時操作的，否則會影響SecondActivity的打開。
3、按返回鍵回到FirstActivity，生命周期過程如下
SecondActivity onPause
FirstActivity onRestart
FirstActivity onStart
FirstActivity onResume
SecondActivity onStop
SecondActivity onDestroy
可以看到在返回FirstActivity時會調用SecondActivity的onPause，如果SecondActivity的onPause中做了耗時操作的話，那麼也會影響Activity的返回。而且當FirstActivity再次回到棧頂時會調用其onRestart，此時並不會執行onCreate因為FirstActivity並沒有銷毀。
4、Activity被回收了時的生命周期
現在描述一種場景：打開ActivityA，然後在ActivityA的頁面中打開ActivityB，此時ActivityA不在棧頂了如果內存不足可能會被回收，此時從ActivityB再回到ActivityA，下面描述下整個過程的生命周期。
1、打開ActivityA，執行的生命周期
ActivityA onCreate
ActivityA onStart
ActivityA onResume
2、打開ActivityB執行的生命周期
ActivityA onPause
ActivityB onCreate
ActivityB onStart
ActivityB onResume
ActivityA onStop
3、此時因內存不足，導致ActivityA被回收了，並返回ActivityA
ActivityA onDestory
ActivityB onPause
ActivityA onCreate
ActivityA onStart
ActivityA onResume
ActivityB onStop
從上面可以看出在ActivityA被回收後再次回到ActivityA時不再調用ActivityA的onRestart了，而是調用了ActivityA的onCreate，因為ActivityA已經被銷毀了。
5、Activity被銷毀，其中的臨時數據怎麼辦
ActivityA被銷毀了，這也就說明其中的臨時數據也會丟失了，比如ActivityA中有一個EditText，我們在其中輸入了一段文字，然後啟動ActivityB，此時由於內存緊張處於停止狀態的ActivityA被回收了，返回到ActivityA你會發現EditText中輸入的文字不見了，因為ActivityA重新創建了。
為此Activity提供了onSaveInstanceState方法，該方法能確保在被回收之前被調用，我們就能在onSaveInstanceState方法中進行臨時數據的保存，然後我們可以在onCreate(savedInstanceState: Bundle?)中利用savedInstanceState進行數據的恢復。Activity被回收重新創建時onCreate(savedInstanceState: Bundle?)中的savedInstanceState不再為null否則為null，其中帶有在savedInstanceState中保存的所有數據。
具體代碼如下：
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
Log.e("tag", "$tag onCreate")
//恢復數據
val tempData = savedInstanceState?.getString("data") ?: ""
et.setText(tempData)
}
//保存數據
override fun onSaveInstanceState(outState: Bundle?) {
super.onSaveInstanceState(outState)
Log.e("tag", "$tag onSaveInstanceState")
val tempData = et.text.toString().trim()
outState?.putString("data", tempData)
}
6、onSaveInstanceState()調用時機
1、用戶按下HOME鍵
2、長按HOME鍵進入其他程序
3、按下電源鍵關閉屏幕
4、從ActivityA跳轉到一個新的Activity
5、屏幕方向切換時，如從豎屏變成橫屏
總而言之，onSaveInstanceState()是在你的Activity有可能在未經允許的情況下被回收時調用，Activity被銷毀之前onSaveInstanceState()肯定會被觸發，我們可以onSaveInstanceState()中保存臨時數據，持久化的數據可以在onPause()中保存。
另外，雖然屏幕方向切換時，會造成Activity的重建會調用onSaveInstanceState()，但是不建議使用onSaveInstanceState()進行數據的保存，我們可以禁止屏幕的旋轉或禁止屏幕旋轉時Activity的重建。
禁止屏幕旋轉
可以在Mainifest中設置屏幕固定為豎屏
android:screenOrieritation="portrait"
禁止屏幕旋轉時Activity的重建
android:configChanges="orientation丨keyboardHidden丨screenSize"
7、Activity的啟動模式
啟動模式分為4種：
1、standard
2、singleTop
3、singleTask
4、singleInstance
我們可以在Manifest中通過android:launchMode指定啟動模式。
7.1、standard模式
如果不顯示指定啟動模式，那麼Activity的啟動模式就是standard，在該模式下不管Activity棧中有無該Activity，均會創建一個新的Activity並入棧，並處於棧頂的位置。
7.2、singleTop模式
1、要啟動的Activity位於棧頂
在啟動一個ActivityA時，如果棧頂的Activity就是ActivityA，那麼就不會重新創建ActivityA，而是直接使用，此時並不會調用ActivityA的onCreate()，因為並沒有重新創建Activity，ActivityA的生命周期如下：
ActivityA onPause
ActivityA onNewIntent
ActivityA onResume
可以看到調用了onNewIntent(intent: Intent?)，我們可以在onNewIntent(intent: Intent?)中通過intent來獲取新傳遞過來的數據，因為此時數據可能已經發生了變化。
2、要啟動的Activity不在棧頂
雖然我們指定了ActivityA的啟動模式為singleTop，但是如果ActivityA在棧中但是不在棧頂的話，那麼此時啟動ActivityA的話會重新創建一個新的ActivityA並入棧，此時棧中就有2個ActivityA的實例了。
7.3、singleTask模式
如果准備啟動的ActivityA的啟動模式為singleTask的話，那麼會先從棧中查找是否存在ActivityA的實例：
場景一、如果存在則將ActivityA之上的Activity都出棧，並調用ActivityA的onNewIntent()。
場景二、如果ActivityA位於棧頂，則直接使用並調用onNewInent()，此時和singleTop一樣。
場景三、 如果棧中不存在ActivityA的實例則會創建一個新的Activity並入棧。
場景一：ActivityA啟動ActivityB,然後啟動ActivityA，此時生命周期過程：
ActivityB onPause
ActivityA onRestart
ActivityA onStart
ActivityA onNewIntent
ActivityA onResume
ActivityB onStop
ActivityB onDestroy
此時ActivityA不在棧頂，ActivityA之上有ActivityB，所以在啟動ActivityA時ActivityA之上的ActivityB會出棧，ActivityA將置於棧頂，所以ActivityA的onRestart和ActivityB的onDestory會執行。
場景二：ActivityA啟動ActivityA，此時生命周期過程：
ActivityA onPause
ActivityA onNewIntent
ActivityA onResume
此時ActivityA位於棧頂，此時singleTask和singleTop作用一樣，都是直接使用ActivityA，並且會調用ActivityA的onPause、onNewIntent、onResume。
場景三：ActivityA啟動ActivityB,此時生命周期過程：
ActivityA onCreate
ActivityA onStart
ActivityA onResume
7.4、singleInstance模式
不同於另外3個模式，指定singleInstance模式的Activity會啟動一個新的返回棧來管理這個Activity(其實如果singleTask模式指定了不同的taskAffinity，也會啟動一個新的返回棧)，這么做的意義是什麼？
想像一個場景：如果我們程序內的一個Activity是允許其他程序訪問的，如果想實現其他程序和我們程序能共享這個Activity實例，該怎麼實現呢？使用前面3中模式是無法做到的，因為每個應用程序都有自己的返回棧，同一個Activity在不同返回棧中肯定都創建了新的實例，而使用singleInstance就可以解決這個問題。在這種模式下，會有一個單獨的返回棧來管理這個Activity，無論哪個應用程序來訪問這個Activity，都在同一個返回棧中，也就解決了共享Activity實例的問題。
為了更好的理解下面我們實戰一下：
1、將ActivityB的啟動模式修改為singleInstance
android:name=".ActivityB"
android:launchMode="singleInstance" />
2、在ActivityA、ActivityB、ActivityC的onCreate中列印taskId
##ActivityA
val tag = javaClass.simpleName
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
Log.e("TAG", "$tag taskId=$taskId")
}
##ActivityB
val tag = javaClass.simpleName
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(activity_second)
Log.e("TAG", "$tag taskId=$taskId")
}
##ActivityC
val tag = javaClass.simpleName
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(activity_c)
Log.e("TAG", "$tag taskId=$taskId")
}
在Kotlin中javaClass是當前實例的Class對象，相當於Java的getClass().
在Kotlin中ActivityB::class.java是獲取ActivityB類的Class對象，相當於Java中的ActivityB.class。
3、啟動ActivityA->啟動ActivityB->啟動ActivityC，taskId列印結果如下：
ActivityA taskId=4163
ActivityB taskId=4164
ActivityC taskId=4163
可以看到ActivityB的taskId是不同於ActivityA 和ActivityC的，這也說明了ActivityB 是在一個單獨的棧中的，並且返回棧中只有這一個Activity。
4、在ActivityC中按返回鍵，返回到ActivityA，再按返回鍵返回到ActivityB，這是為什麼呢？其實很好理解：ActivityA 和ActivityC 在同一個返回棧中，在ActivityC 中按返回鍵ActivityC 出棧，此時ActivityA就位於棧頂了，ActivityA就展示在界面上了，在ActivityA中再按返回鍵，這是當前的返回棧已經空了，於是就展示了另一個返回棧棧頂的ActivityB了。
————————————————
版權聲明：本文為CSDN博主「保瓶兒」的原創文章，遵循CC 4.0 BY-SA版權協議，轉載請附上原文出處鏈接及本聲明。
原文鏈接：https://blog.csdn.net/weixin_31211457/article/details/114052641
⑤ Android 中如何在java類中調用activity 中的一個方法，在線等，急、急、急
將你要使用的activity的實例當作參數傳入普通java類，這樣就可以調用，比如普通java類的構造函數，其中一個參數就是你需要的那個activity類型
在普通java類裡面使用activity實例調用你想調用的方法即可
⑥ 如何從Java類傳遞對象到任意activity
寫public方法、使用第3個類的靜態定義
~
~
~
⑦ java中Activity是什麼
是android裡面的。
// --------------創建Activity----------------
public class ExampleActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {//此方法必須要有
super.onCreate(savedInstanceState);
// The activity is being created.
}
@Override
protected void onStart() {
super.onStart();
// The activity is about to become visible.
}
@Override
protected void onResume() {
super.onResume();
// The activity has become visible (it is now "resumed").
}
@Override
protected void onPause() {
super.onPause();
// Another activity is taking focus (this activity is about to be "paused").
}
@Override
protected void onStop() {
super.onStop();
// The activity is no longer visible (it is now "stopped")
}
@Override
protected void onDestroy() {
super.onDestroy();
// The activity is about to be destroyed.
}
}
// -------------在manifest中注冊Activity------
//ExampleActivity在啟動應用的時候被啟動
<activity android:name=".ExampleActivity" android:icon="@drawable/app_icon">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
//---------------啟動 Activity------------
Intent intent = new Intent(this, SignInActivity.class);//SignInActivity為要跳轉的Activity
startActivity(intent);
⑧ Android 中如何在java類中調用activity 中的一個方法
通常，您不應該以這種方式創建新的 MainActivity 實例。要打開一個新的 MainActivity，請使用 Intent。在您的情況下，您應該引用原始 MainActivity 實例，並在那裡調用此方法。不要以任何方式創建新的，因為您已經在運行它。
一個簡單的解決方法：
MainActivity.this.myMethod("Hello there")
您不必存儲mContext. 你已經在 MainActivity 裡面了。
因此，完整的代碼將是：
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
WebView myWebView = findViewById(R.id.webview);
myWebView.loadUrl("http://www.google.com");
myWebView.addJavascriptInterface(new WebAppInterface(), "Android");
}
public void myMethod(String test){
Toast.makeText(this, test, Toast.LENGTH_SHORT).show();
}
public class WebAppInterface {
/** Show a toast from the web page */
@JavascriptInterface
public void showToast(String toast) {
MainActivity.this.myMethod("Hello there");
}
}
}
實際上，我認為您甚至可以避免使用MainActivity.this., 並myMethod直接調用。