javavariant类型

⑴ java中的private到底有什么用

private是访问控制修饰符，用来使用访问控制符来保护对类、变量、方法和构造方法的访问。

在程序中需要隐藏类的实现细节和保护类的数据时，就要使用private来修饰。例如：

public class Logger {

private String format;

public String getFormat() {
return this.format; }

public void setFormat(String format) {
this.format = format; }

}

实例中，Logger 类中的 format 变量为私有变量，所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个 public 方法：getFormat() （返回 format的值）和 setFormat(String)（设置 format 的值）。

(1)javavariant类型扩展阅读

1、private的访问控制：

当前类：可见

同一包内：不可见

子孙类(同一包)：不可见

子孙类(不同包)：不可见

其他包：不可见

2、private的使用对象：变量、方法；不能修饰类（外部类）。

⑵ java中如何初始定义一个数组是float型的

java中如何凳凳初始定义一个数组是float型的

float foo[]=new float[n];
n为该阵列的长度。
一维阵列的初始化例子：float foo={1,2,3,4,5};

定义一个数组，初始化为1,2,3.10. 输出检验

#include<stdio.h>
void main() { int a[10],i;
for ( i=0;i<10;i++ ) a[i]=i+1;
for ( i=0;i<10;i++ ) printf("%d ",a[i]); printf(" ");
}

请教vba中如何判断一个数组是否初始化

整体判断很难，找不到这样的函式啊。用第一个元素判断可以的：
VB code
Option Explicit
Dim XXX(99) As Variant
Private Sub Form_Load()
'Dim i As Long
'For i = 0 To 99
' XXX(i) = i
'Next

If IsEmpty(XXX(0)) Then
Debug.Print "没有初始化！"
Else
Debug.Print "已经初始化！"
End If
End Sub

如何定义一个初始float型别的变数的语句

看半天没弄明白楼主的意思，到底是要定义一个float型别的变数，还是一个语句？

php中如何初始化一个数组

初始化一个数组一般有2种方法：一个是单独给阵列中的元素赋值；还有一种是把所有的元素一起初始化。
下面简要枣态旅介绍初始化阵列的2种方法：
第一种方法：
$a["color"]="red";
$a["taste"]="sweet";
$a["shape"]="round";
$a["name"]="apple";
$a[3]=4;
第二种方法：
$a=array(
"color"=>"red",
"taste"=>"sweet",
"shape"=>"round",
"name"=>"apple",
3=>4);
这两种方法的效果是相同的，不同的只是给元素赋值的方法不同。

<?php
$arr =array();
这样$arr就初始化了
?>

C# 如何定义一个数组,阵列的成员是一个类

你好,
ArrayList al = new ArrayList();
al[0] = 类物件;
或:
object[] objs = new objects[看要放几个];
objs[0] = 类物件;

读取, 类名 cls = objs[0] as 类名
类名 cls = al[0] as 类名

定义一个长度为10 的float型别的阵列，初始化10个数使用回圈结构，输出数组里的数

#include<stdio.h>
void main() { float a[10]; int i;
for ( i=0;i<10;i++ ) a[i]=1.0f/i;
for ( i=0;i<10;i++ ) printf("%d ",a[i]);
printf(" ");
}

如何用汇编语言在ROM中定义一个数组

既然是rom即只读储存器，闭兄无须定义，直接将资料段指向具 *** 置，可直接读取它们。

⑶ java如何使用静态库

1.缺少declare,正确的描述如下
private Declare Function FindWindow Lib "user32" Alias "FindWindowA" (ByVal lpClassName As String, ByVal lpWindowName As String) As Long

2 declare的说明
Declare 语句

用于在模块级别中声明对动态链接库 (DLL) 中外部过程的引用。
语法 1
[Public | Private] DeclareSubnameLib"libname" [Alias"aliasname"] [([arglist])]
语法 2
[Public | Private] DeclareFunctionnameLib"libname" [Alias"aliasname"] [([arglist])] [Astype]
Declare 语句的语法包含下面部分：
部分 描述
Public 可选的。用于声明对所有模块中的所有其它过程都可以使用的过程。
Private 可选的。用于声明只能在包含该声明的模块中使用的过程。
Sub 可选的（但Sub 或 Function 二者需选其一）。表示该过程没有返回值。
Function 可选的（但Sub 或 Function 二者需选其搜尘正一）。表示该过程会返回一个可用于表达式的值。
name 必需的。任何合法的过程名。注意动兄指态链接库的入口处（entry points）区分大小写。
Lib 必需的。指明包含所声明过程的动态链接库或代码资源。所有声明都需要Lib 子句。
libname 必需的。包含所声明的过程动态链接库名或代码资源名。
Alias 可选的。表示将被调用的过程在动态链接库 (DLL)
中还有另外的名称。当外部过程名与某个关键字重名时，就可以使用这个参数。当动态链接库的过程与同一范围内的公用变量、常数或任何其它过程的名称相同时，也可以使用
Alias。如果该动态链接库过程中的某个字符不符合动态链接库的命名约定时，也可以使用 Alias。
aliasname 可选的。动态链接库或代码资源中的过程名。如果首字符不是数世悔字符号 (#)，则
aliasname 是动态链接库中该过程的入口处的名称。如果首字符是
(#)，则随后的字符必须指定该过程的入口处的顺序号。
arglist 可选的。代表调用该过程时需要传递的参数的变量表。
type 可选的。Function 过程返回值的数据类型；可以是 Byte、布尔、Integer、Long、Currency、Single、Double、Decimal（目前尚不支持）、Date、String（只支持变长）或 Variant，用户定义类型，或对象类型。
arglist 参数的语法以及语法各个部分如下：
[Optional] [ByVal | ByRef] [ParamArray] varname[( )] [Astype]

⑷ java中如何map转换为数组

map.put("123",newfloat[]{11,11,11});

按照已有的代码，存进去的时候，new一个float数组，直接传值就可以。

或

Map sMap = new HashMap<String[], String>();

String[] strs = {"1","2"};

sMap.put(strs, "map的键值可以为数组");

System.out.println(sMap.get(strs));//---->map的键值可以为数组。

(4)javavariant类型扩展阅读：

一个数组中的所有元素具有相同的数据类型（在C、C++、Java、pascal中都这样。但也并非所有涉及数组的地方都这样，比如在Visual Foxpro中的数组就并没这样的要求）。当然，当数据类型为 Variant 时，各个元素能够包含不同种类的数据（对象、字符串、数值等等）。可以声明任何基本数据类型的数组，包括用户自定义类型和对象变量。

⑸ 谁能帮我解释一下这段程序的意思最好每一句特别是开头那几句有什么作用万分感谢

小弟只有10年VC++经验,帮你解读一下哦: 满意的话麻烦给我分.

如下代码是为了实现: 接收串口过来的数据! 首先初始化一个泛型类型接受容器, 接收串口接口发来的数据,然后显示在界面上的edit控件上!

VARIANT variant_inp; 用VARIANT 泛型变量类型 定义一个数组变量variant_inp; 泛型就是任何类型都可以放进去的意思. 作为缓冲池使用很适合.

COleSafeArray safearray_inp; 用兄颤蚂COleSafeArray用OLE安全数据容器类 定义一个对象名字是 safearray inp 因为VARIANT虽然可以放任何类型数据到这个数组中,但该类型没有丰富的处理成员函数,说白了他是结构体不是类, 所以 需要做个转换, 转为COleSafeArray类型的数组类即可. 他具有非常丰富的成员函数.

那么, 你会问为什么不直接让safearray_inp=m_ctrlComm.GetInput(); 读缓冲区，而要经过一个中间变量呢？
variant_inp=m_ctrlComm.GetInput(); 读缓冲区
safearray_inp=variant_inp; VARIANT转换成COleSafeArray型变量

VARIANT和COleSafeArray 是什么关系呢?

原因是:

这中间有调用不同的重载=运算符，m_ctrlComm.GetInput(); 的数据可以转化为variant_inp，有默认的转化方式，而safearray_inp=variant_inp则是另一个转化方式，如果直接转，可能数据不对。
VARIANT和COleSafeArray 一个是结构体，一个是类，各自的数据构造不一样。

long k=0; 初始化一个长整型变量 k=0;
int len; 定义长度len,整数型.

BYTE rxdata[2048]; 定义接受数据的数组,2k大小,2048字节. 为BYTE类型,也即unsigned char类型.
CString strtemp; 定义一个CString类型的字符串strtemp;
if(m_ctrlComm.GetCommEvent()) 如果控制通信对象m_ctlComm有get的事件发生,
{

------------------------
这里应该加switch(ret) , 将上面getcommevent赋值给ret.

case 2: 事件值为2表示接收缓冲区内有字符
{
variant_inp=m_ctrlComm.GetInput(); 控制通信器对象得到输入数据流. 如果GetCommEvent返回2,说明有字符到达了, 接收缓冲区内有字符
safearray_inp=variant_inp; 将variant inp转换为COleSafeArray 类型,付给safearry inp. 因为COleSafeArray提供了丰羡埋富的函数处理.符合我们的需要.

len=safearray_inp.GetOneDimSize(); 获取输入安全数组的长度len
for(k=0;k<len;k++) 做个循环,
{
safearray_inp.GetElement(&k,rxdata+k); 从输入的安全数组到rxdata进行数据拷贝. 一次一个字节拷贝.
}
for(k=0;k<len;k++) 做个循环. 读取len长度的所有字节.
{
BYTE bt=*(char*)(rxdata+k); 内存 rxdata 起始地址+k字节偏移的指针 取值,得到 一个字节.
strtemp.Format("%c",bt); strtemp赋值为bt,也就是一个字符.
m_strEditRXData+=strtemp; m_strEdit这个CEdit控件显示一洞闷直加长.
}
}
UpdateData(FALSE); 将内存变量数据更新到界面.

====================
参考:

VARIANTC++、BASIC、Java、Pascal、Script......计算机语言多种多样，而它们各自又都有自己的数据类型，COM
产生目的，其中之一就是要跨语言(注3)。而 VARIANT
数据类型就具有跨语言的特性，同时它可以表示（存储）任意类型的数据。从C语言的角度来讲，VARIANT
其实是一个结构，结构中用一个域(vt)表示------该变量到底表示的是什么类型数据，同时真正的数据则存贮在 union
空间中。结构的定义太长了（虽然长，但其实很简单）大家去看 MSDN 的描述吧，这里给出如何使用的简单示例：

学生：我想用 VARIANT 表示一个4字节长的整数，如何做？
老师：VARIANT v; v.vt=VT_I4; v.lVal=100;

学生：我想用 VARIANT 表示布尔值“真”，如何做？
老师：VARIANT v; v.vt=VT_BOOL; v.boolVal=VARIANT_TRUE;
学生：这么麻烦？我能不能 v.boolVal=true; 这样写？
老师：不可以！因为


类型
字节长度
假值
真值

bool
1(char)
0(false)
1(true)

BOOL
4(int)
0(FALSE)
1(TRUE)

VT_BOOL
2(short int)
0(VARIANT_FALSE)
-1(VARIANT_TRUE)

所以如果你 v.boolVal=true 这样赋值，那么将来 if(VARIANT_TRUE==v.boolVal)
的时候会出问题(-1 !=
1)。但是你注意观察，任何布尔类型的“假”都是0，因此作为一个好习惯，在做布尔判断的时候，不要和“真值”相比较，而要与“假值”做比较。
学生：谢谢老师，你太牛了。我对老师的敬仰如滔滔江水，连绵不绝......

学生：我想用 VARIANT 保存字符串，如何做？
老师：VARIANT v; v.vt=VT_BSTR; v.bstrVal=SysAllocString(L"Hello,你好");

学生：哦......我明白了。可是这么操作真够麻烦的，有没有简单一些的方法？
老师：有呀，你可以使用现成的包装类 CComVariant、COleVariant、_variant_t。比如上面三个问题就可以这样书写：CComVariant v1(100),v2(true),v3("Hello,你好"); 简单了吧？！(注4)

学生：老师，我再问最后一个问题，我如何用 VARIANT 保存一个数组？
老师：这个问题很复杂，我现在不能告诉你，我现在告诉你怕你印象不深......(注5)
学生：~!@#$%^&*()......晕！

VARIANT 数据类型在文件OAIDL.IDL中定义如下：

struct tagVARIANT {
union {

struct __tagVARIANT {

VARTYPE vt;

WORD wReserved1;

WORD wReserved2;

WORD wReserved3;

union {

ULONGLONG ullVal;

LONGLONG llVal;

LONG lVal;

BYTE bVal;

SHORT iVal;

FLOAT fltVal;

DOUBLE dblVal;

VARIANT_BOOL boolVal;

_VARIANT_BOOL bool;

SCODE scode;

CY cyVal;

DATE date;

BSTR bstrVal;

IUnknown * punkVal;

IDispatch * pdispVal;

SAFEARRAY * parray;

BYTE * pbVal;

SHORT * piVal;

LONG * plVal;

LONGLONG * pllVal;

FLOAT * pfltVal;

DOUBLE * pdblVal;

VARIANT_BOOL *pboolVal;

_VARIANT_BOOL *pbool;

SCODE * pscode;

CY * pcyVal;

DATE * pdate;

BSTR * pbstrVal;

IUnknown ** ppunkVal;

IDispatch ** ppdispVal;

SAFEARRAY ** pparray;

VARIANT * pvarVal;

PVOID byref;

CHAR cVal;

USHORT uiVal;

ULONG ulVal;

INT intVal;

UINT uintVal;

DECIMAL * pdecVal;

CHAR * pcVal;

USHORT * puiVal;

ULONG * pulVal;

ULONGLONG * pullVal;

INT * pintVal;

UINT * puintVal;

struct __tagBRECORD {

PVOID pvRecord;

IRecordInfo * pRecInfo;

} __VARIANT_NAME_4;

} __VARIANT_NAME_3;

} __VARIANT_NAME_2;

DECIMAL decVal;

} __VARIANT_NAME_1;
};

⑹ java中整除和浮点除什么区别

被除数和除数都为整数即为整除，结果也为整数，如果有余数，则忽略余数，比如
5/2结果为2。棚冲
被除数和除数只如卜要有一个是浮点数（小数）即为浮点除，结果为链橡歼浮点数，比如
5.0/2
结果为
2.5

⑺ 用JAVA语言编译：数组中包含n个整数，从其中找出k个最小的数，写出你能想到的最快的方法！！！

最快k*O(n)~O(n)，将前K个数放入一个k的数组中，按序放，对K+1到N的数，依次如果比K数组总的小，将K中最大的取出，放入最小的数，一直维持K个，最后就是最小的K个。

import java.util.Arrays;

/**先给数值里的值进行从小到大排序，取从0到k-1索引的数组值

* @创建一个数组,包含11个元素，求5个最小的数

* @author Administrator

public class ArrayTest {

public static void main(String[] args) {

//最小元素的个数

int k=5;

//创建一个数组,

int[] arr = {1,3,45,33,67,12,88,11,46,32,89};

//操作数组的工具Arrays,sort()方法自动排序，由小到大

Arrays.sort(arr);

for(int i=0;i<k;i++){

System.out.println(arr[i]);

}

(7)javavariant类型扩展阅读：

此处数组是程序中声明的变量数组宏缓。它们不同于控件蔽肆模数组，控件数组是在设计时通过设置控件的 Index 属性规定的。变量数组总是连续的；与控件数组不同雹兄的是，不能从一个数组的中部加载或卸载数组元素。

一个数组中的所有元素具有相同的数据类型（在C、C++、Java、pascal中都这样。但也并非所有涉及数组的地方都这样，比如在Visual Foxpro中的数组就并没这样的要求）。当然，当数据类型为 Variant 时，各个元素能够包含不同种类的数据（对象、字符串、数值等等）。可以声明任何基本数据类型的数组，包括用户自定义类型和对象变量。

⑻ java中 locale类 及相关方法

在项目中经常要用到将字符串解析成Locale，但是没有一个比较好用的类。
java本好厅身提供了3个构造函数

Locale(langugae)
locale(language,country)

Locale(String language, String country, String variant)
Apache 有个 LocaleUtils.toLocale(String language)但是不支型态持最后2个字符为小写的，如:zh_CN支持， zh_cn就不支持。
[java] view plainprint?
import java.util.Locale;

public class LocaleUtil
{
private final static Locale DEFAULT_LOCALE = Locale.ENGLISH;

public final static String IETF_SEPARATOR = "-";

public final static String SEPARATOR = "_";

public final static String EMPTY_STRING = ""友租隐;

public static Locale toLocale( String language )
{
if( !StringUtil.isNullOrEmpty( language ) )
{
return langToLocale( language, SEPARATOR );
}
return DEFAULT_LOCALE;
}

public static Locale langToLocale( String lang , String separator )
{
if( StringUtil.isNullOrEmpty( lang ) )
{
return DEFAULT_LOCALE;
}
String language = EMPTY_STRING;
String country = EMPTY_STRING;
String variant = EMPTY_STRING;

int i1 = lang.indexOf( separator );
if ( i1 < 0 )
{
language = lang;
} else
{
language = lang.substring(0, i1);
++i1;
int i2 = lang.indexOf( separator, i1);
if (i2 < 0)
{
country = lang.substring(i1);
} else
{
country = lang.substring(i1, i2);
variant = lang.substring(i2+1);
}
}

if(language.length() == 2)
{
language = language.toLowerCase();
}else
{
language = EMPTY_STRING;
}

if(country.length() == 2)
{
country = country.toUpperCase();
}else
{
country = EMPTY_STRING;
}

if( (variant.length() > 0) &&
((language.length() == 2) ||(country.length() == 2)) )
{
variant = variant.toUpperCase();
}else
{
variant = EMPTY_STRING;
}

return new Locale(language, country, variant );
}
}
import java.util.Locale;

public class LocaleUtil
{

private final static Locale DEFAULT_LOCALE = Locale.ENGLISH;

public final static String IETF_SEPARATOR = "-";

public final static String SEPARATOR = "_";

public final static String EMPTY_STRING = "";

public static Locale toLocale( String language )
{

if( !StringUtil.isNullOrEmpty( language ) )

{

return langToLocale( language, SEPARATOR );

}

return DEFAULT_LOCALE;
}

public static Locale langToLocale( String lang , String separator )

{

if( StringUtil.isNullOrEmpty( lang ) )

{

return DEFAULT_LOCALE;

}

String language = EMPTY_STRING;

String country = EMPTY_STRING;

String variant = EMPTY_STRING;

int i1 = lang.indexOf( separator );

if ( i1 < 0 )

{

language = lang;

} else

{

language = lang.substring(0, i1);

++i1;

int i2 = lang.indexOf( separator, i1);

if (i2 < 0)

{

country = lang.substring(i1);

} else

{

country = lang.substring(i1, i2);

variant = lang.substring(i2+1);

}

}

if(language.length() == 2)

{

language = language.toLowerCase();

}else

{

language = EMPTY_STRING;

}

if(country.length() == 2)

{

country = country.toUpperCase();

}else

{

country = EMPTY_STRING;

}

if( (variant.length() > 0) &&

((language.length() == 2) ||(country.length() == 2)) )

{
variant = variant.toUpperCase();

}else

{

variant = EMPTY_STRING;

}

return new Locale(language, country, variant );

}
}

注意：

public class StringUtil
{
public static boolean isNullOrEmpty(String target) {
return target == null || "".equals(target);
}
}

⑼ java Variant数据类型转换

可能要Variant的
SafeArray s=v.toSafeArray();//得到安全数组
再
String[] texts=s.toStringArray();
获得字符串数组..

⑽ 怎么用java调用用codesoft设计的条形码文档

现在代码共享如下，仅供参考因为本人还不精通。
package
com.prodPrint;
import
java.io.File;
import
java.util.HashMap;
import
org.eclipse.swt.SWT;
import
org.eclipse.swt.ole.win32.OleAutomation;
import
org.eclipse.swt.ole.win32.OleControlSite;
import
org.eclipse.swt.ole.win32.OleFrame;
import
org.eclipse.swt.ole.win32.Variant;
import
org.eclipse.swt.widgets.Composite;
import
org.eclipse.swt.widgets.Display;
import
org.eclipse.swt.widgets.Shell;
import
com.lppx2.OleDispatch;
public
class
ActiveXPrinter
extends
Composite{
private
OleFrame
myFrame
=
new
OleFrame(this,
SWT.NONE);
//
Microsoft
Internet
Explorer
ProgID:
Shell.Explorer.2
//
Codesoft
ProgID
:
Lppx2.Application
private
String
progId
=
"Lppx2.Application";
private
OleControlSite
controlSite;
private
OleAutomation
automation;;
private
OleDispatch
appActiveDoc;
private
OleDispatch
appDocs;
File
currentFile;
public
ActiveXPrinter(Composite
parent,
int
style)
{
super(parent,
style);
myFrame
=
new
OleFrame(this,
SWT.NONE);
controlSite
=
new
OleControlSite(myFrame,
SWT.NONE,
progId);
automation
=
new
OleAutomation(controlSite);
}
public
void
print
(String
fileName)
{
currentFile
=
new
File(fileName);
initialize();
}
private
void
initialize()
{
try{
Variant
documents
=
(new
OleDispatch(automation)).Invoke("Documents",new
Variant[0]);
appDocs
=
new
OleDispatch(documents.getAutomation());
if
(!currentFile.canRead()
)
{
System.out.println("Unable
to
read
file
:
"
+
currentFile);
}
else
{
Variant
file[]
=
new
Variant[1];
file[0]
=
new
Variant(currentFile.getAbsolutePath());
if
(appDocs.Invoke("Open",
file)
!=
null)
{
System.out.println(currentFile.getAbsolutePath()
+
"
is
opened
now");
}
else
{
System.out.println("Unable
to
open
"
+
currentFile.getAbsolutePath());
}
Variant
activeDocumentV
=
(new
OleDispatch(automation)).Invoke(
"ActiveDocument",
new
Variant[0]);
try
{
appActiveDoc
=
new
OleDispatch(activeDocumentV.getAutomation());
}
catch
(Exception
excpt)
{
}
Variant[]
quantity
=
new
Variant[1];
quantity[0]
=
new
Variant(1);
if
(appActiveDoc.Invoke("PrintDocument",
quantity)
!=
null)
System.out.println("Print
OK");
else
{
System.out.println("Unable
to
print
!");
}
}
}catch(Exception
excpt)
{
System.out.println("You
can't
print
anything
until
a
document
is
opened
!");
excpt.printStackTrace();
return;
}
}
public
static
void
main(String[]
args)
{
Display
display
=
Display.getDefault();
Shell
shell
=
new
Shell(display);
new
ActiveXPrinter(shell,
0).print("C:\Document1.Lab");
while
(!shell.isDisposed())
{
if
(!display.readAndDispatch())
{
display.sleep();
}
}
display.dispose();
}
}