本文目录
- Java的特点有哪些
- java反射机制的实现原理
- 下载了卡雷尔机器人,导入eclipse中运行不了!!
- java calendar的add和set方法的区别
- Jersey的介绍
- java中,PrintWriter类的flush()是做什么用的
- javaScript 的程序设计
- java1.exe和srvany.exe是什么进程,可以结束吗
- 已破解的java游戏网站
- javascript中input.parentElement.className中parentElement是什么意思啊
Java的特点有哪些
Java是一种优秀的程序设计语言,它具有令人赏心悦目的语法和易于理解的语义。不仅如此,Java还是一个由一系列计算机软件和规范形成的技术体系,这个技术体系提供了完整的用于软件开发和跨平台部署的支持环境,并广泛应用于嵌入式系统、移动终端、企业服务器、大型机等各种场合。顺便说一下,JavaScript和Java没有任何关系,最开始JavaScript叫liveScript,当时Java太火了,于是乎 liveScript更名为JavaScript借势宣传了一波。
随便搜搜近几年的编程类语言排行榜,Java绝对都是当之无愧的老大哥。那么,Java究竟有什么特性能获得 广大程序员的一致青睐呢? 在此列出java的11个特性:
1.简单性
Java语法是C++语法的一个“纯净版本”。这里没有头文件,指针运算(甚至指针语法),结构,联合,操作符重载,虚基类等等。不仅如此,Java开发环境远远超出大多数其他编程语言的开发环境。
2.面向对象
什么是面向对象?用木匠打一个比方,一个“面向对象”的木匠始终关注的是所制作的椅子,第二位才是所使用的工具;而一个“非面向对象”木匠首先考虑的是所使用的工具。
在Java的世界里,一切皆对象。
Java的面向对象特性与C++旗鼓相当,与C++不同的点在于多重继承。在Java中,取而代之的是更简单的接口概念。而且与C++想比,Java提供了更丰富非运行时自省功能。
3.分布式(微服务)
Java有丰富的例程库,用于处理HTTP和FTP之类的TCP/IP协议。Java应用程序能够通过URL打开和访问网络上的对象,其便捷程度就好像访问本地文件一样。
4.健壮性
Java与C++最大的不同在于Java使用的指针模型可以消除重写内存和损坏数据的可能性(对于曾经花费几个小时来检查由于指针bug而引起内存冲突的人来说,一定很喜欢Java的这一特性)。不仅如此,Java编译器能够检测许多在其他语言中仅在运行时才能够检测出来的问题。-JAVA
5.安全性
Java适用于网络/分式式环境。为了达到这个目标,在安全性方面投入了大量的精力。使用Java可以构建防病毒,防篡改的系统。
从一开始,Java就设计出能够防范常见的各种攻击:
(1)运行时堆栈溢出。蠕虫和病毒常用的攻击手段。(2)破坏自己进程空间之外的内存。(3)未经授权读写文件。
6.体系结构中立
编译器生成一个体系结构中立的目标文件格式,这是一种编译过的代码,只要有Java运行时系统,这些编译后的代码就可以在许多处理器上运行。Java编译器通过生成与特定计算机体系结构无关的字节码指令来实现这一特性。精心设计的字节码不仅可以很容易的在任何机器上解释执行,而且还可以动态地翻译成本地机器代码。-java
7.可移植性
与C/C++不同,Java规范中没有“依赖具体实现的地方”。基本数据类型的大小以及有关运算都做了明确的说明。例如,Java中的int永远是32位的整数,二在C/C++中,int可能是16位整数,32位整数,也可能是编译器提供商指定的其他大小。在Java中,数据类型具有固定的大小,这消除了代码代码移植时令人头疼的主要问题。-JAVA
8.解释型
Java解释器可以再任何移植了解解释器的机器上执行Java字节码。由于链接是一个增量式且轻量级的过程。所以开发过程也变得更加快捷,更加具有探索性。
9.高能性
尽管对解释后的字节码性能已经比较满意,但是在某些场合下可能需要更加高效的性能。字节码可以(在运行时刻)动态的翻译成对应运行这个应用的特定CPU的机器码。
10.多线程
Java在当时很超前,他是第一个支持并发程序设计的主流语言,多线程可以带来更好的交互影响和实时行为。并发程序设计绝非易事,但是Java在这方面表现出色,可以很好的管理这个工作。
11.动态性
Java与C/C++相比更具有动态性。它能够适应不断发展的环境。库中可以自由的添加新方法和实例变量,而对客户端没有任何影响。在Java中找出运行时类型信息十分简单。
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);
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.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;
partypes = Integer.TYPE;
partypes = Integer.TYPE;
Method meth = cls.getMethod(
“add“, partypes);
method2 methobj = new method2();
Object arglist = new Object;
arglist = new Integer(37);
arglist = 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;
partypes = Integer.TYPE;
partypes = Integer.TYPE;
Constructor ct
= cls.getConstructor(partypes);
Object arglist = new Object;
arglist = new Integer(37);
arglist = 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;
}
-java
下载了卡雷尔机器人,导入eclipse中运行不了!!
运行啊,点击那个奔跑的人形状。不过先要导入Assignment,点击import projects,选择Assignment路径。慢慢摸索一下,应该可以的。
java calendar的add和set方法的区别
public void set(int field, int value) 将指定的日历字段设置为给定的值,field参考常量字段值
public void set(year, month, date, hourOfDay, minute, second)
public void add(int field, int amount) 根据日历的规则,为给定的日历字段添加或减去指定的时间量。
// 例子
import java.util.Calendar;
import java.util.Date;
public class TestCalendar2 {
public static void main(String args) {
Calendar calendar = Calendar.getInstance();
// 从一个 Calendar 对象中获取 Date 对象
Date date = calendar.getTime();
//使用给定的 Date 设置此 Calendar 的时间
calendar.setTime(date);
calendar.set(Calendar.DAY_OF_MONTH, 8);
System.out.println(“当前时间日设置为8后,时间是:“ + calendar.getTime());
calendar.add(Calendar.HOUR, 2);
System.out.println(“当前时间加2小时后,时间是:“ + calendar.getTime());
calendar.add(Calendar.MONTH, -2);
System.out.println(“当前日期减2个月后,时间是:“ + calendar.getTime());
}
}
-JAVA
Jersey的介绍
Jersey是一个RESTFUL请求服务JAVA框架,与常规的JAVA编程使用的struts框架类似,它主要用于处理业务逻辑层。与Struts类似,它同样可以和hibernate,spring框架整合。-java
java中,PrintWriter类的flush()是做什么用的
flush,字面上是冲刷的意思。flush()方法用于强制将内存缓冲区的数据流刷入文件。进行流的操作时,数据首先会被读到内存中,然后再写到文件中。在进行流的操作时,我们都知道最后需要调用out.close()这个方法,如果最后调用了.close()方法的话,是不需要在这之前调用.flush()的,因为.close()方法内部会自动调用.flush()。
-JAVA
javaScript 的程序设计
百度自己查.很容易
乘法表 用到2次循环 ,嵌套循环
显示是用到更改当前页面对象了.用到HTML标签 ID属性,和innerHTML,
用到随机数 和字符串替换了就是随机替换welcome中的一个,你这个要知道welcome字符串长度,用到长度函数.随机数,还有替换函数.
这个用到IMG图片更改它的路径了..自己查去吧
给你个乘法表
《script》
str=““;
for(i=1;i《=9;i++){
for(j=1;j《=i;j++){
str=str+j+“*“+i+“=“+i*j+“ “;
}
str=str+ “《br》“;
}
document.write(str);
《/script》
java1.exe和srvany.exe是什么进程,可以结束吗
这两个进程都是无危险的具体见如下:(1)srvany - srvany.exe - 进程信息
进程文件: srvany 或者 srvany.exe
进程名称: Srvany
中文描述:
srvany.exe是一个Windows附加程序,用于将一个程序注册为一个服务。这不是纯粹的系统程序,但是如果终止它,可能会导致不可知的问题。
英文描述:
srvany.exe is an additional MicrosoftWindowsapplication which allows an executable to be ran as a service. This program is a non-essential system process, but should not be terminated unless suspected to be causing problems
出品者: Microsoft Corp.
属于: Microsoft Windows Resource Pack
系统进程: 是
后台程序: 是
使用网络: 否
硬件相关: 否
常见错误: 未知N/A
内存使用: 未知N/A
安全等级 (0-5): 0
间谍软件: 否
Adware: 否
病毒: 否
木马: 否
《/SPAN》《/SPAN》
《/p》 (2)java1.exe 这是一个无威胁文件。经过扫描,其中 0/6 款杀毒软件检测到 java1.exe 含有病毒木马及可疑风险!
软件名称检测结果(仅供参考,用于帮助您判断文件是否安全)毒霸没有检测到风险瑞星没有检测到风险卡巴斯基没有检测到风险Nod32没有检测到风险小红伞没有检测到风险Mcafee没有检测到风险
-java
已破解的java游戏网站
推荐手机网站:百分网,游戏全是免费,从不收费。你可以进去看看。不会失望的。 推荐以上网站都有你的机型游戏。
以后你就不必来这里苦苦的求手机游戏了!
如果不知道“百分网”,直接用百度搜索,看下面的相关搜索就知道了-JAVA
javascript中input.parentElement.className中parentElement是什么意思啊
input应该是一个变量了,HTML元素是有父子层关系的,比如
《div id=“divF“ class=“MyDiv“》
《div id=“divS“ /》
《/div》
那么里面这个divS.parentElement就是divF,
那么divS.parentElement.className就是指的“MyDiv“