java防殺進程的原理是什麼

A. Android防止殺進程

1.在service中重寫下面的方法，這個方法有三個返回值， START_STICKY是service被kill掉後自動重寫創建 [代碼]java代碼： @Override public int onStartCommand(Intent intent, int flags, int startId) { return START_STICKY; }---------------- @Override public int onStartCommand(Intent intent, int flags, int startId) { // TODO Auto-generated method stub Log.v("TrafficService","startCommand"); flags = START_STICKY; return super.onStartCommand(intent, flags, startId); // return START_REDELIVER_INTENT; } 2.在Service的onDestroy()中重啟Service. public void onDestroy() { Intent localIntent = new Intent(); localIntent.setClass(this, MyService.class); //銷毀時重新啟動Service this.startService(localIntent); } 用qq管家殺掉進程的時候，調用的是系統自帶的強制kill功能（即settings里的），在kill時，會將應用的整個進程停掉，當然包括service在內，如果在running里將service強制kill掉，顯示進程還在。不管是kill整個進程還是只kill掉進應用的 service，都不會重新啟動service。不知道你是怎麼實現重啟的，實在是不解。 在eclipse中，用stop按鈕kill掉進程的時候，倒是會重啟service KILL問題： 1. settings 中stop service onDestroy方法中，調用startService進行Service的重啟。 2.settings中force stop 應用 捕捉系統進行廣播（action為android.intent.action.PACKAGE_RESTARTED） 3. 藉助第三方應用kill掉running task 提升service的優先順序 service開機啟動 今天我們主要來探討android怎麼讓一個service開機自動啟動功能的實現。Android手機在啟動的過程中會觸發一個Standard Broadcast Action，名字叫android.intent.action.BOOT_COMPLETED(記得只會觸發一次呀),在這里我們可以通過構建一個廣播接收者來接收這個這個action.下面我就來簡單寫以下實現的步驟： 第一步：首先創建一個廣播接收者,重構其抽象方法 onReceive(Context context, Intent intent)，在其中啟動你想要啟動的Service或app。 [代碼]java代碼： import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.util.Log; public class BootBroadcastReceiver extends BroadcastReceiver { //重寫onReceive方法 @Override public void onReceive(Context context, Intent intent) { //後邊的XXX.class就是要啟動的服務 Intent service = new Intent(context,XXXclass); context.startService(service); Log.v("TAG", "開機自動服務自動啟動....."); //啟動應用，參數為需要自動啟動的應用的包名 Intent intent = getPackageManager().getLaunchIntentForPackage(packageName); context.startActivity(intent ); } } 第二步：配置xml文件，在re ceiver接收這種添加intent-filter配置 [代碼]java代碼： <receiver android:name="BootBroadcastReceiver"> <intent-filter> <action android:name="android.intent.action.BOOT_COMPLETED"></action> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </receiver> 第三步：添加許可權 <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" /> 如何實現一個不會被殺死的進程 看Android的文檔知道，當進程長期不活動，或系統需要資源時，會自動清理門戶，殺死一些Service，和不可見的Activity等所在的進程。 但是如果某個進程不想被殺死（如數據緩存進程，或狀態監控進程，或遠程服務進程），應該怎麼做，才能使進程不被殺死。 add android:persistent="true" into the <application> section in your AndroidManifest.xml 切記，這個 不可濫用，系統中用這個的service，app一多，整個系統就完蛋了。 目前系統中有phone等非常有限的，必須一直活著的應用在試用。 提升service優先順序的方法 Android 系統對於內存管理有自己的一套方法，為了保障系統有序穩定的運信，系統內部會自動分配，控制程序的內存使用。當系統覺得當前的資源非常有限的時候，為了保 證一些優先順序高的程序能運行，就會殺掉一些他認為不重要的程序或者服務來釋放內存。這樣就能保證真正對用戶有用的程序仍然再運行。如果你的 Service 碰上了這種情況，多半會先被殺掉。但如果你增加 Service 的優先順序就能讓他多留一會，我們可以用 setForeground(true) 來設置 Service 的優先順序。 為什麼是 foreground ? 默認啟動的 Service 是被標記為 background，當前運行的 Activity 一般被標記為 foreground，也就是說你給 Service 設置了 foreground 那麼他就和正在運行的 Activity 類似優先順序得到了一定的提高。當讓這並不能保證你得 Service 永遠不被殺掉，只是提高了他的優先順序。 從Android 1.5開始，一個已啟動的service可以調用startForeground(int, Notification)將service置為foreground狀態，調用stopForeground(boolean)將service置為 background狀態。 我們會在調用startForeground(int, Notification)傳入參數notification，它會在狀態欄里顯示正在進行的foreground service。background service不會在狀態欄里顯示。 在Android 1.0中，將一個service置為foreground狀態： setForeground(true); mNM.notify(id, notification); 將一個service置為background狀態： mNM.cancel(id); setForeground(false); 對比看出，在1.0 API中調用setForeground(boolean)只是簡單的改變service的狀態，用戶不會有任何覺察。新API中強制將 notification和改變service狀態的動作綁定起來，foreground service會在狀態欄顯示，而background service不會。 Remote service controller & binding 跨進程調用Service。暫時不研究。 如何防止Android應用中的Service被系統回收? 很多朋友都在問，如何防止Android應用中的Service被系統回收？下面簡單解答一下。 對於Service被系統回收，一般做法是通過提高優先順序可以解決，在AndroidManifest.xml文件中對於intent-filter可以通過 android:priority = "1000"這個屬性設置最高優先順序，1000是最高值，如果數字越小則優先順序越低，同時實用於廣播，推薦大家如果你的應用很重要，可以考慮通過系統常用intent action來觸發。

B. Java如何殺死Windows系統下的進程

在java中有調用外部程序的類，Runtime.getRuntime().exec("./**.exe");此函數返回的是一個Process 對象，該對象在創建後，可以回對它進行 destroy () 殺掉子進程、 waitFor () 導致當前答線程等待，如有必要，一直要等到由該 Process 對象表示的進程已經終止。 而你想要的屏蔽空格的問題，在批處理中可以把整個命令用雙引號包起來就可以避免了。

C. java反射機制的實現原理

反射機制:所謂的反射機制就是java語言在運行時擁有一項自觀的能力。通過這種能力可以徹底的了解自身的情況為下一步的動作做准備。下面具體介紹一下java的反射機制。這里你將顛覆原來對java的理解。
Java的反射機制的實現要藉助於4個類：class，Constructor，Field，Method；其中class代表的時類對 象，Constructor－類的構造器對象，Field－類的屬性對象，Method－類的方法對象。通過這四個對象我們可以粗略的看到一個類的各個組 成部分。

Class：程序運行時，java運行時系統會對所有的對象進行運行時類型的處理。這項信息記錄了每個對象所屬的類，虛擬機通常使用運行時類型信息選擇正 確的方法來執行（摘自：白皮書）。但是這些信息我們怎麼得到啊，就要藉助於class類對象了啊。在Object類中定義了getClass()方法。我 們可以通過這個方法獲得指定對象的類對象。然後我們通過分析這個對象就可以得到我們要的信息了。

比如：ArrayList arrayList;

Class clazz = arrayList.getClass();

然後我來處理這個對象clazz。

當然了Class類具有很多的方法，這里重點將和Constructor，Field，Method類有關系的方法。

Reflection 是 Java 程序開發語言的特徵之一，它允許運行中的 Java 程序對自身進行檢查，或者說「自審」，並能直接操作程序的內部屬性。Java 的這一能力在實際應用中也許用得不是很多，但是個人認為要想對java有個更加深入的了解還是應該掌握的。

1．檢測類：

reflection的工作機制

考慮下面這個簡單的例子，讓我們看看 reflection 是如何工作的。

import java.lang.reflect.*;

public class DumpMethods {

public static void main(String args[]) {

try {

Class c = Class.forName(args[0]);

Method m[] = c.getDeclaredMethods();

for (int i = 0; i < m.length; i++)

System.out.println(m[i].toString());

} catch (Throwable e) {

System.err.println(e);

}

}

}

按如下語句執行：

java DumpMethods java.util.ArrayList

這個程序使用 Class.forName 載入指定的類，然後調用 getDeclaredMethods 來獲取這個類中定義了的方法列表。java.lang.reflect.Methods 是用來描述某個類中單個方法的一個類。

Java類反射中的主要方法

對於以下三類組件中的任何一類來說 -- 構造函數、欄位和方法 -- java.lang.Class 提供四種獨立的反射調用，以不同的方式來獲得信息。調用都遵循一種標准格式。以下是用於查找構造函數的一組反射調用：

Constructor getConstructor(Class[] params) -- 獲得使用特殊的參數類型的公共構造函數，

Constructor[] getConstructors() -- 獲得類的所有公共構造函數

Constructor getDeclaredConstructor(Class[] params) -- 獲得使用特定參數類型的構造函數(與接入級別無關)

Constructor[] getDeclaredConstructors() -- 獲得類的所有構造函數(與接入級別無關)

獲得欄位信息的Class 反射調用不同於那些用於接入構造函數的調用，在參數類型數組中使用了欄位名：

Field getField(String name) -- 獲得命名的公共欄位

Field[] getFields() -- 獲得類的所有公共欄位

Field getDeclaredField(String name) -- 獲得類聲明的命名的欄位

Field[] getDeclaredFields() -- 獲得類聲明的所有欄位

用於獲得方法信息函數：

Method getMethod(String name, Class[] params) -- 使用特定的參數類型，獲得命名的公共方法

Method[] getMethods() -- 獲得類的所有公共方法

Method getDeclaredMethod(String name, Class[] params) -- 使用特寫的參數類型，獲得類聲明的命名的方法

Method[] getDeclaredMethods() -- 獲得類聲明的所有方法

使用 Reflection：

用於 reflection 的類，如 Method，可以在 java.lang.relfect 包中找到。使用這些類的時候必須要遵循三個步驟：第一步是獲得你想操作的類的 java.lang.Class 對象。在運行中的 Java 程序中，用 java.lang.Class 類來描述類和介面等。

下面就是獲得一個 Class 對象的方法之一：

Class c = Class.forName("java.lang.String");

這條語句得到一個 String 類的類對象。還有另一種方法，如下面的語句：

Class c = int.class;

或者

Class c = Integer.TYPE;

它們可獲得基本類型的類信息。其中後一種方法中訪問的是基本類型的封裝類 (如 Intege ) 中預先定義好的 TYPE 欄位。

第二步是調用諸如 getDeclaredMethods 的方法，以取得該類中定義的所有方法的列表。

一旦取得這個信息，就可以進行第三步了——使用 reflection API 來操作這些信息，如下面這段代碼：

Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它將以文本方式列印出 String 中定義的第一個方法的原型。

處理對象：

a.創建一個Class對象

b.通過getField 創建一個Field對象

c.調用Field.getXXX(Object)方法(XXX是Int,Float等，如果是對象就省略；Object是指實例).

例如：

import java.lang.reflect.*;

import java.awt.*;

class SampleGet {

public static void main(String[] args) {

Rectangle r = new Rectangle(100, 325);

printHeight(r);

}

static void printHeight(Rectangle r) {

Field heightField;

Integer heightValue;

Class c = r.getClass();

try {

heightField = c.getField("height");

heightValue = (Integer) heightField.get(r);

System.out.println("Height: " + heightValue.toString());

} catch (NoSuchFieldException e) {

System.out.println(e);

} catch (SecurityException e) {

System.out.println(e);

} catch (IllegalAccessException e) {

System.out.println(e);

}

}

}

安全性和反射：

在處理反射時安全性是一個較復雜的問題。反射經常由框架型代碼使用，由於這一點，我們可能希望框架能夠全面接入代碼，無需考慮常規的接入限制。但是，在其它情況下，不受控制的接入會帶來嚴重的安全性風險，例如當代碼在不值得信任的代碼共享的環境中運行時。

由於這些互相矛盾的需求，Java編程語言定義一種多級別方法來處理反射的安全性。基本模式是對反射實施與應用於源代碼接入相同的限制：

從任意位置到類公共組件的接入

類自身外部無任何到私有組件的接入

受保護和打包（預設接入）組件的有限接入

不過至少有些時候，圍繞這些限制還有一種簡單的方法。我們可以在我們所寫的類中，擴展一個普通的基本類 java.lang.reflect.AccessibleObject 類。這個類定義了一種setAccessible方法，使我們能夠啟動或關閉對這些類中其中一個類的實例的接入檢測。唯一的問題在於如果使用了安全性管理 器，它將檢測正在關閉接入檢測的代碼是否許可了這樣做。如果未許可，安全性管理器拋出一個例外。

下面是一段程序，在TwoString 類的一個實例上使用反射來顯示安全性正在運行：

public class ReflectSecurity {

public static void main(String[] args) {

try {

TwoString ts = new TwoString("a", "b");

Field field = clas.getDeclaredField("m_s1");

// field.setAccessible(true);

System.out.println("Retrieved value is " +

field.get(inst));

} catch (Exception ex) {

ex.printStackTrace(System.out);

}

}

}

如果我們編譯這一程序時，不使用任何特定參數直接從命令行運行，它將在field .get(inst)調用中拋出一個IllegalAccessException異常。如果我們不注釋 field.setAccessible(true)代碼行，那麼重新編譯並重新運行該代碼，它將編譯成功。最後，如果我們在命令行添加了JVM參數 -Djava.security.manager以實現安全性管理器，它仍然將不能通過編譯，除非我們定義了ReflectSecurity類的許可權 限。

反射性能：（轉錄別人的啊）

反射是一種強大的工具，但也存在一些不足。一個主要的缺點是對性能有影響。使用反射基本上是一種解釋操作，我們可以告訴JVM，我們希望做什麼並且它滿足我們的要求。這類操作總是慢於只直接執行相同的操作。

下面的程序是欄位接入性能測試的一個例子，包括基本的測試方法。每種方法測試欄位接入的一種形式 -- accessSame 與同一對象的成員欄位協作，accessOther 使用可直接接入的另一對象的欄位，accessReflection 使用可通過反射接入的另一對象的欄位。在每種情況下，方法執行相同的計算 -- 循環中簡單的加/乘順序。

程序如下：

public int accessSame(int loops) {

m_value = 0;

for (int index = 0; index < loops; index++) {

m_value = (m_value + ADDITIVE_VALUE) *

MULTIPLIER_VALUE;

}

return m_value;

}

public int acces

sReference(int loops) {

TimingClass timing = new TimingClass();

for (int index = 0; index < loops; index++) {

timing.m_value = (timing.m_value + ADDITIVE_VALUE) *

MULTIPLIER_VALUE;

}

return timing.m_value;

}

public int accessReflection(int loops) throws Exception {

TimingClass timing = new TimingClass();

try {

Field field = TimingClass.class.

getDeclaredField("m_value");

for (int index = 0; index < loops; index++) {

int value = (field.getInt(timing) +

ADDITIVE_VALUE) * MULTIPLIER_VALUE;

field.setInt(timing, value);

}

return timing.m_value;

} catch (Exception ex) {

System.out.println("Error using reflection");

throw ex;

}

}

在上面的例子中，測試程序重復調用每種方法，使用一個大循環數，從而平均多次調用的時間衡量結果。平均值中不包括每種方法第一次調用的時間，因此初始化時間不是結果中的一個因素。下面的圖清楚的向我們展示了每種方法欄位接入的時間：

圖 1：欄位接入時間 ：

我們可以看出：在前兩副圖中(Sun JVM)，使用反射的執行時間超過使用直接接入的1000倍以上。通過比較，IBM JVM可能稍好一些，但反射方法仍舊需要比其它方法長700倍以上的時間。任何JVM上其它兩種方法之間時間方面無任何顯著差異，但IBM JVM幾乎比Sun JVM快一倍。最有可能的是這種差異反映了Sun Hot Spot JVM的專業優化，它在簡單基準方面表現得很糟糕。反射性能是Sun開發1.4 JVM時關注的一個方面，它在反射方法調用結果中顯示。在這類操作的性能方面，Sun 1.4.1 JVM顯示了比1.3.1版本很大的改進。

如果為為創建使用反射的對象編寫了類似的計時測試程序，我們會發現這種情況下的差異不象欄位和方法調用情況下那麼顯著。使用newInstance()調 用創建一個簡單的java.lang.Object實例耗用的時間大約是在Sun 1.3.1 JVM上使用new Object()的12倍，是在IBM 1.4.0 JVM的四倍，只是Sun 1.4.1 JVM上的兩部。使用Array.newInstance(type, size)創建一個數組耗用的時間是任何測試的JVM上使用new type[size]的兩倍，隨著數組大小的增加，差異逐步縮小。隨著jdk6.0的推出，反射機制的性能也有了很大的提升。期待中….

總結：

Java語言反射提供一種動態鏈接程序組件的多功能方法。它允許程序創建和控制任何類的對象(根據安全性限制)，無需提前硬編碼目標類。這些特性使得反射 特別適用於創建以非常普通的方式與對象協作的庫。例如，反射經常在持續存儲對象為資料庫、XML或其它外部格式的框架中使用。Java reflection 非常有用，它使類和數據結構能按名稱動態檢索相關信息，並允許在運行著的程序中操作這些信息。Java 的這一特性非常強大，並且是其它一些常用語言，如 C、C++、Fortran 或者 Pascal 等都不具備的。

但反射有兩個缺點。第一個是性能問題。用於欄位和方法接入時反射要遠慢於直接代碼。性能問題的程度取決於程序中是如何使用反射的。如果它作為程序運行中相 對很少涉及的部分，緩慢的性能將不會是一個問題。即使測試中最壞情況下的計時圖顯示的反射操作只耗用幾微秒。僅反射在性能關鍵的應用的核心邏輯中使用時性 能問題才變得至關重要。

許多應用中更嚴重的一個缺點是使用反射會模糊程序內部實際要發生的事情。程序人員希望在源代碼中看到程序的邏輯，反射等繞過了源代碼的技術會帶來維護問 題。反射代碼比相應的直接代碼更復雜，正如性能比較的代碼實例中看到的一樣。解決這些問題的最佳方案是保守地使用反射——僅在它可以真正增加靈活性的地方 ——記錄其在目標類中的使用。

一下是對應各個部分的例子：

具體的應用：

1、 模仿instanceof 運算符號

class A {}

public class instance1 {

public static void main(String args[])

{

try {

Class cls = Class.forName("A");

boolean b1

= cls.isInstance(new Integer(37));

System.out.println(b1);

boolean b2 = cls.isInstance(new A());

System.out.println(b2);

}

catch (Throwable e) {

System.err.println(e);

}

}

}

2、 在類中尋找指定的方法，同時獲取該方法的參數列表，例外和返回值

import java.lang.reflect.*;

public class method1 {

private int f1(

Object p, int x) throws NullPointerException

{

if (p == null)

throw new NullPointerException();

return x;

}

public static void main(String args[])

{

try {

Class cls = Class.forName("method1");

Method methlist[]

= cls.getDeclaredMethods();

for (int i = 0; i < methlist.length;

i++)

Method m = methlist[i];

System.out.println("name

= " + m.getName());

System.out.println("decl class = " +

m.getDeclaringClass());

Class pvec[] = m.getParameterTypes();

for (int j = 0; j < pvec.length; j++)

System.out.println("

param #" + j + " " + pvec[j]);

Class evec[] = m.getExceptionTypes();

for (int j = 0; j < evec.length; j++)

System.out.println("exc #" + j

+ " " + evec[j]);

System.out.println("return type = " +

m.getReturnType());

System.out.println("-----");

}

}

catch (Throwable e) {

System.err.println(e);

}

}

}

3、 獲取類的構造函數信息，基本上與獲取方法的方式相同

import java.lang.reflect.*;

public class constructor1 {

public constructor1()

{

}

protected constructor1(int i, double d)

{

}

public static void main(String args[])

{

try {

Class cls = Class.forName("constructor1");

Constructor ctorlist[]

= cls.getDeclaredConstructors();

for (int i = 0; i < ctorlist.length; i++) {

Constructor ct = ctorlist[i];

System.out.println("name

= " + ct.getName());

System.out.println("decl class = " +

ct.getDeclaringClass());

Class pvec[] = ct.getParameterTypes();

for (int j = 0; j < pvec.length; j++)

System.out.println("param #"

+ j + " " + pvec[j]);

Class evec[] = ct.getExceptionTypes();

for (int j = 0; j < evec.length; j++)

System.out.println(

"exc #" + j + " " + evec[j]);

System.out.println("-----");

}

}

catch (Throwable e) {

System.err.println(e);

}

}

}

4、 獲取類中的各個數據成員對象，包括名稱。類型和訪問修飾符號

import java.lang.reflect.*;

public class field1 {

private double d;

public static final int i = 37;

String s = "testing";

public static void main(String args[])

{

try {

Class cls = Class.forName("field1");

Field fieldlist[]

= cls.getDeclaredFields();

for (int i

= 0; i < fieldlist.length; i++) {

Field fld = fieldlist[i];

System.out.println("name

= " + fld.getName());

System.out.println("decl class = " +

fld.getDeclaringClass());

System.out.println("type

= " + fld.getType());

int mod = fld.getModifiers();

System.out.println("modifiers = " +

Modifier.toString(mod));

System.out.println("-----");

}

}

catch (Throwable e) {

System.err.println(e);

}

}

}

5、 通過使用方法的名字調用方法

import java.lang.reflect.*;

public class method2 {

public int add(int a, int b)

{

return a + b;

}

public static void main(String args[])

{

try {

Class cls = Class.forName("method2");

Class partypes[] = new Class[2];

partypes[0] = Integer.TYPE;

partypes[1] = Integer.TYPE;

Method meth = cls.getMethod(

"add", partypes);

method2 methobj = new method2();

Object arglist[] = new Object[2];

arglist[0] = new Integer(37);

arglist[1] = new Integer(47);

Object retobj

= meth.invoke(methobj, arglist);

Integer retval = (Integer)retobj;

System.out.println(retval.intValue());

}

catch (Throwable e) {

System.err.println(e);

}

}

}

6、 創建新的對象

import java.lang.reflect.*;

public class constructor2 {

public constructor2()

{

}

public constructor2(int a, int b)

{

System.out.println(

"a = " + a + " b = " + b);

}

public static void main(String args[])

{

try {

Class cls = Class.forName("constructor2");

Class partypes[] = new Class[2];

partypes[0] = Integer.TYPE;

partypes[1] = Integer.TYPE;

Constructor ct

= cls.getConstructor(partypes);

Object arglist[] = new Object[2];

arglist[0] = new Integer(37);

arglist[1] = new Integer(47);

Object retobj = ct.newInstance(arglist);

}

catch (Throwable e) {

System.err.println(e);

}

}

}

7、 變更類實例中的數據的值

import java.lang.reflect.*;

public class field2 {

public double d;

public static void main(String args[])

{

try {

Class cls = Class.forName("field2");

Field fld = cls.getField("d");

field2 f2obj = new field2();

System.out.println("d = " + f2obj.d);

fld.setDouble(f2obj, 12.34);

System.out.println("d = " + f2obj.d);

}

catch (Throwable e) {

System.err.println(e);

}

}

}

使用反射創建可重用代碼：

1、 對象工廠

Object factory(String p) {

Class c;

Object o=null;

try {

c = Class.forName(p);// get class def

o = c.newInstance(); // make a new one

} catch (Exception e) {

System.err.println("Can't make a " + p);

}

return o;

}

public class ObjectFoundry {

public static Object factory(String p)

throws ClassNotFoundException,

InstantiationException,

IllegalAccessException {

Class c = Class.forName(p);

Object o = c.newInstance();

return o;

}

}

2、 動態檢測對象的身份，替代instanceof

public static boolean

isKindOf(Object obj, String type)

throws ClassNotFoundException {

// get the class def for obj and type

Class c = obj.getClass();

Class tClass = Class.forName(type);

while ( c!=null ) {

if ( c==tClass ) return true;

c = c.getSuperclass();

}

return false;

}

D. 求解，C++這樣的防殺進程是怎麼做到的

最簡單的方式是：用system函數。如：system("taskkill /im exedbg32.exe /f" )

E. java中幽靈線程是什麼，以及它的作用和工作原理是什麼

你說的幽靈是之daemon 線程吧
當正在運行的線程都是daemon線程時，Java 虛擬機退出。
而對於普通線程運行時虛擬機是不會結束的。

F. Java中的反射機制的原理和用途是什麼

JAVA反射（放射）機制：「程序運行時，允許改變程序結構或變數類型，這種語言稱為動態語言」。從這個觀點看，Perl，Python，Ruby是動態語言，C++，Java，C#
不是動態語言。但是JAVA有著一個非常突出的動態相關機制：Reflection，用在Java身上指的是我們可以於運行時載入、探知、使用編譯期間完
全未知的classes。換句話說，Java程序可以載入一個運行時才得知名稱的class，獲悉其完整構造（但不包括methods定義），並生成其對
象實體、或對其fields設值、或喚起其methods。

用途：Java反射機制主要提供了以下功能： 在運行時判斷任意一個對象所屬的類；在運行時構造任意一個類的對象；在運行時判斷任意一個類所具有的成員變數和方法；在運行時調用任意一個對象的方法；生成動態代理。

有時候我們說某個語言具有很強的動態性，有時候我們會區分動態和靜態的不同技術與作法。我們朗朗上口動態綁定（dynamic binding）、動態鏈接（dynamic linking）、動態載入（dynamic loading）等。然而「動態」一詞其實沒有絕對而普遍適用的嚴格定義，有時候甚至像面向對象當初被導入編程領域一樣，一人一把號，各吹各的調。

一般而言，開發者社群說到動態語言，大致認同的一個定義是：「程序運行時，允許改變程序結構或變數類型，這種語言稱為動態語言」。從這個觀點看，Perl，Python，Ruby是動態語言，C++，Java，C#不是動態語言。

盡管在這樣的定義與分類下Java不是動態語言，它卻有著一個非常突出的動態相關機制：Reflection。
這個字的意思是「反射、映象、倒影」，用在Java身上指的是我們可以於運行時載入、探知、使用編譯期間完全未知的classes。換句話說，Java程
序可以載入一個運行時才得知名稱的class，獲悉其完整構造（但不包括methods定義），並生成其對象實體、或對其fields設值、或喚起其
methods。這種「看透class」的能力（the ability of the program to examine
itself）被稱為introspection（內省、內觀、反省）。Reflection和introspection是常被並提的兩個術語。

Java如何能夠做出上述的動態特性呢？這是一個深遠話題，本文對此只簡單介紹一些概念。整個篇幅最主要還是介紹
Reflection
APIs，也就是讓讀者知道如何探索class的結構、如何對某個「運行時才獲知名稱的class」生成一份實體、為其fields設值、調用其
methods。本文將談到java.lang.Class，以及java.lang.reflect中的Method、Field、Constructor等等classes。

G. 這個java程序所達到的功能的原理是什麼

你自己選的數字根據他的演算法算完以後都是9的倍數
你可以繼續觀察
他圖上凡是9的倍數 圖片都是一樣的
所以就能「猜」出你選的圖形。

任何10到99的數 減去 個位十位只和都為9的倍數

如果不明白的話 可以追問

H. 怎麼盡量防止進程被殺

這樣的：首先從Ring3獲得你自己的句柄（不要用GetCurrentProcess，這個函數只能返回一個偽句柄版-1），從Ring3傳進來，驅動保權存起來。在MyNtTerminateProcess中，你可以用PsGetCurrentProcess獲得調用者的句柄，和傳進來的句柄比較，如果相同，那麼是自己結束自己，放行；如果不是，則代表是其他進程要殺死本進程，攔截！

I. 殺進程是什麼意思，有啥用

Windows XP/2000的任務管理器是一個非常有用的工具，能讓你看到系統中正在運行哪些程序（進程），只要你平時多看任務管理器中的進程列表，熟悉系統的基本進程，就可以隨時發現可疑進程，這對防範木馬和病毒大有裨益！不過有一些可疑進程，你用任務管理器卻無法殺掉，這該怎麼辦呢？

一、哪些系統進程不能關掉

Windows運行的時候，會啟動多個進程。只要你按下「Ctrl+Alt+Del」鍵打開任務管理器，點擊「查看」/選擇列，勾選「PIO（進程標識符）」，然後單擊「進程」標簽，即可看到這些進程。不過有一些進程個人用戶根本用不到，例如Systray.exe（顯示系統托盤小喇叭圖標）、Ctfmon.exe（微軟Office輸入法）、Winampa.exe等，我們完全可以禁止它們，這樣做並不會影響系統的正常運行。

二、如何關閉任務管理器殺不了的進程

如果你在任務管理器中無法關閉某個可疑進程，可以使用下面的方法強行關閉，注意不要殺掉進程表中的系統核心進程：

1． 使用Windows XP/2000自帶的工具

從Windows 2000開始，Windows系統就自帶了一個用戶態調試工具Ntsd，它能夠殺掉大部分進程，因為被調試器附著的進程會隨調試器一起退出，所以只要你在命令行下使用Ntsd調出某進程，然後退出Ntsd即可終止該進程，而且使用Ntsd會自動獲得Debug許可權，因此Ntsd能殺掉大部分的進程。

操作方法：單擊「開始」/程序/附件/命令提示符，輸入命令：ntsd -c q -p PID（把最後那個PID，改成你要終止的進程的PID）。在進程列表中你可以查到某個進程的PID，例如我們要關閉圖1中的Explorer.exe進程，輸入：ntsd -c q -p 408即可。

以上參數-p表示後面跟隨的是進程PID， -c q表示執行退出Ntsd的調試命令，從命令行把以上參數傳遞過去就行了。

2． 使用專門的軟體來殺進程

任務管理器殺不掉的進程，你可以使用專門的軟體關閉。有很多軟體可以殺進程，例如進程殺手、IceSword、柳葉擦眼、系統查看大師、Kill process等。

（1）進程殺手2.5（【點擊下載「進程殺手2.5」】）
http://software.pchome.net/system/monitor/18017.html

它能夠瀏覽系統中正在運行的所有進程，包括用Ctrl+Alt+Del 看不到的進程，可以精簡進程、自動中止系統基本進程以外的所有進程，對木馬和病毒進程有一定清除作用，你可以用它隨時中止任一個正在運行的進程，選中該進程，按「中止進程」按鈕即可。

（2）IceSword（【點擊下載「IceSword」】）
http://software.pchome.net/system/sysenhance/18523.html

如今系統級木馬後門功能越來越強，一般都可輕易隱藏進程、埠、注冊表、文件信息，普通進程工具根本無法發現這些「幕後黑手」。IceSword使用大量新穎的內核技術，可以查出所有隱藏進程。

要查看當前進程，請點擊「進程」按鈕，在右部列出的進程中，隱藏的進程會以紅色醒目地標記出，以方便查找系統級後門。如果要結束某進程，可以先選中它（按住Ctrl鍵可選擇多個進程），然後使用右鍵菜單的「結束進程」，即可關閉之。

（3）柳葉擦眼

它可以列出系統中所有的進程（包括隱藏的），並可以殺死進程，能自動標示出系統文件，自動中止基本進程外的所有進程，還具有IE保護功能。

運行軟體後，單擊「柳葉擦眼」可以顯示當前正在運行的所有進程，你只需注意那些「定義級別」為「未知」及「危險」的進程，按「降妖伏魔」按鈕關閉它們即可。

（4）系統查看大師1.0

目前許多木馬都是在後台運行的，它們運行時會隱藏自己的窗口，因此你無法在屏幕上看到它們。該軟體可以獲取隱藏的不可見窗口，讓你發現木馬蹤影、關閉之。

軟體運行後，在左側視圖中點擊「取不可見窗口」按鈕，右側的窗口中就會顯示出所有當前運行的、隱藏的不可見窗口標題，選定其中的可疑窗口，然後點擊右下端的「結束此窗口」按鈕，即可關閉之。如果你要關閉某進程，可以單擊「進程列表」按鈕，選中該進程，然後右擊滑鼠在彈出的窗口中，單擊「結束進程」即可。

J. java怎麼殺掉java進程

java中有調用外部程序的類，Runtime.getRuntime().exec("./**.exe");此函數返回的是一個Process 對象，該對象在創建後，可以對它進行 destroy () 殺掉子進程、 waitFor () 導致當前線程等待，如有必要，一直要等到由該 Process 對象表示的進程已經終止。 如下例子可以殺掉已經打開的文本進程：

importjava.io.BufferedReader;
importjava.io.InputStreamReader;
publicclassTest
{
	publicstaticvoidmain(String[]args)
{
		try
{
String[]cmd=
{"notepad.exe"};
Processproc=Runtime.getRuntime().exec(cmd);//開啟文本
BufferedReaderin=newBufferedReader(newInputStreamReader(proc
.getInputStream()));
Stringstring_Temp=in.readLine();
while(string_Temp!=null)
{
System.out.println(string_Temp);
if(string_Temp.indexOf("notepad.exe")!=-1)
	Runtime.getRuntime().exec("Taskkill/IMnotepad.exe");
string_Temp=in.readLine();
}
}
catch(Exceptione)
{
//結束進程
}
}

結果如下：