java常用实用类详解

1.      String类（字符串检测）

返回值类型	常用方法	说明
int	length()	获取字符串的长度大小
boolean	equals(String s)	比较对象的实体是否相同。
boolean	startsWith(String s)	判断当前字符串前后缀是否是参数字符串s
	endsWith(String s)
boolean	regionMatches(x, String s, y, length)	取字符串a中参数x指定位置开始，长度为length的一个子串，将这个子串与字符串s从参数y指定位置开始，长度为length的子串进行比较，相同则true，否则false。
int	compareTo(String s)	按字典序与参数s指定的字符串比较大小，
boolean	contain(String s)	判断字符串a是否含有参数字符串s
int	indexOf(String s，x)	从字符串a的参数x指定位置开始检索字符串s，并返回首次出现的位置，没有检索到就返回-1。
String	subString(start，end)	截取字符串a中从参数start指定位置开始到end处的子串。
String	trim()	去掉字符串a前后的空格

 

1)      String中的构造方法

String（char a[]，x，y）:截取字符数组中的元素，将字符创建为字符串。从下标为x开始，截取y个元素。

例：char a [] = {‘s’,‘o’，‘k’，‘a’，‘b’}；

          String s = new String（a，1,2）；

相当于

    Strings = new String(“ok”)；

运行结果：s = ok

引用字符串常量对象：

例：String s1,s2；

s1 = “how are you”；

s2 = “how are you”；

这样s1,s2具有相同的引用，因而具有相同的实体。

2)       String常用方法

(1)     int length()方法，获取字符串的长度大小。

例:String num = “我爱学习”；

          intn1,n2；

          n1= num.length()；

          n2= “你好吗”.length()；

运行结果：n1=4；n2=3；

(2)     boolean equals(String s)方法，比较对象的实体是否相同。

例： Strings1 = {“we are students”}；

          Strings2 = {“you are students”}；

          Strings3 = {“we are students”}；

String n,m；

n = “how are you”；

m = “how are you”；

那么:        s1.equals(s2)的值是false，

s1.equals(s3)的值是true

n.equals(m)的值是true

s1==s3的值是false

n==m的值是true

         “==”比较的是两个字符串对象在内存中的地址，就是判断是否是同一个字符串对象。

         “equals()”比较的是两个字符串对象的值。

(3)     boolean startsWith(Strings)、boolean endsWith(String s)方法。判断当前字符串前后缀是否是参数字符串s

例：String num1 = “2837485826495”；

那么：  num1. startsWith(“283”)的值是true

                   num1. startsWith(“282”)的值是false

                   num1. endsWith(“6495”)的值是true

                   num1. endsWith(“6652”)的值是false

(4)     boolean regionMatches(x, Strings, y, length)方法。取字符串a中参数x指定位置开始，长度为length的一个子串，将这个子串与字符串s从参数y指定位置开始，长度为length的子串进行比较，相同则true，否则false。

例：String a = “we arefamily,are student.”

那么：a.regionMatches(0,“we”,0,2)；的值为true。

(5)     int compareTo(String s)方法。按字典序与参数s指定的字符串比较大小，如果字符串a与s相同，返回值0，如果字符串a大于s，返回值为正值，反正如果字符串a小于s，返回值为负值。

例：String a = “abcde”；

          那么：a.compareTo(“boy”)为负值

a.compareTo(“aba”)为正值

a.compareTo(“abcde”)为0

(6)     boolean contain(String s)方法。判断字符串a是否含有参数字符串s，含有值就为true，否则值为false。

例：Stringa = “student”；

          那么：a.contain(“stu”)的值为true

a.contain(“std”)的值为false

(7)     int indexOf(String s，x)方法。从字符串a的参数x指定位置开始检索字符串s，并返回首次出现的位置，没有检索到就返回的值为-1。

int lastIndexOf(String s,x) 从字符串a的参数x指定位置开始检索字符串s，并返回最后出现的位置，没有检索到就返回的值为-1。

例：String a = “I01A2M3  4A56G7O8O9D10 11C12A13T14”；

         那么： a.indexOf(“A”)；//值是2

               a.indexOf(“GOOD”,2)；//值是7

               a.indexOf(“a”,7)；//值是13

               a.indexOf(“w”,2)；//值是-1

(8)     String subString(start，end)方法。截取字符串a中从参数start指定位置开始到end处的子串。

例：String a = “I loveyou”；

          String s = a.substring(2,5)；

那么：s = “lov”

(9)     String trim()方法。去掉字符串a前后的空格。

2.      BigDecimal类（实现浮点型数据精确计算）

(1)     add(BigDeciml n)方法。加法。将BigDecimal类创建的数据与n相加。

(2)     subtract(BigDecimal n)方法。减法。将BigDecimal类创建的数据与n相减。

(3)     multiply(BigDecimal n)方法。乘法。将BigDecimal类创建的数据与n相乘。

(4)     divide(BigDecimal n)方法。除法。将BigDecimal类创建的数据与n相除。

.....比较大小，余数，绝对值，次幂，进制等方法与BigInteger类中的方法相同，

例：BigDecimal t1 =new BigDecimal(“2”);

BigDecimal t2 =new BigDecimal(“1.2”);

BigDecimal result= t1.add(t2);//result值为3.2

注意：在商业程序中，货币等需要精确计算的，需要使用BigDecimal类。

3.      BigInteger类（实现整数型数据精确计算）

Ø  构造方法：BigInteger(String s);

字符串参数s必须是数字字符，如果含有非数字字符就会发生NumberFormatException异常。

例：BigInteger sum =new BigInteger(“12”);//初始化sum=12

Ø  常用方法

Int compareTo(BigIntegers):比大小，返回当前整数对象与参数s 的比较结果，返回值1(大于)，-1(小于)，0(等于)。

BigInteger ads(BigIntegers):绝对值，返回当前整数对象与参数s的绝对值。

BigInteger pow(inta):a次幂，返回当前整数对象的a次幂。

String toString():十进制，返回当前整数对象十进制的字符串表示。

String toString(intp):p进制，返回当前整数对象p进制的字符串表示。

例：BigIntegersum = newBigInteger("23");

BigInteger one = new BigInteger("55");//初始化两个数

BigInteger he = one.add(sum);//求和

BigInteger cha = one.subtract(sum);//求差

int bijiao= one.compareTo(sum);//比较大小，sum>one,故返回值1

String s = sum.toString(2);//sum的二进制表示

运行结果：he= 78，cha=32，bijiao=1，s=10111

4.      字符串与基本数据相互转化

（1）用Integer类中的parseInt(String s)、parseByte(String s)、parseShort(String s)、parseLong(String s)、 parseFloat(String s)、parseDouble(String s)等等。

例：Strings = “2654”；

          Int x = Integer.parseInt(s)：//x=2654

 （2）用String类中String valueOf(数据类型 n)方法

例：int x = 12；

          String s = String.valueOf(x)；//s=“12”

 （3）用Long类中以下方法得到各进制的字符串

         String toBinaryString(long i)//返回整数i的二进制表示

         String toOctalString(long i)//返回整数i的八进制表示

         String toHexString(long i)//返回整数i的十六进制表示

         String toString(long i,int p)//返回整数i的p进制表示

5.      正则表达式及字符串替换分解

(1)     正则表达式

定义：正则表达式就是含有一些特殊意义的字符串（元字符）。

例：“\\dhello”.“\\d”就是具有特殊意义的字符串，代表0～9数字中任意一个，及1hello，4hello..等等都是和正则表达式\\dhello匹配的字符串。

元字符及其意义：

元字符	正则表达式写法	意义
.	“.”	代表任何一个字符
\d	“\\d”	代表数字0～9
\D	“\\D”	代表任何非数字字符
\s	“\\s”	代表空格类字符
\S	“\\S”	代表非空格类字符
\w	“\\w”	代表可用的标识符(不包括$)
\W	“\\W”	代表不能用的标识符

 

 

 

 

 

 

 

*********************************************************************************

方括号括起来的若干字符表示一个元字符。

«  例：[abc]:代表a,b,c中任何一个

                     [^abc]:代表a,b,c除外的任何一个字符

                     [a-zA-Z]:代表英文字母中任何一个

*********************************************************************************

限制修饰符：(X代表正则表达式中任意一个元字符或普通字符)

带限定符号的模式	意义
X?	X出现0次或1次
X*	X出现0次或多次
X+	X出现1次或多次
X{4}	X恰好出现n次
X{n,}	X至少出现n次
X{n,m}	X至少出现n至m次

例：c = “t\\w{4}”,\\w恰好出现四次，那么“tabcd”、“tdbhd”、“td37v”…任何一个四位标识符。

         s = “[1-9][0-9]*[.]?[0-9]*”。代表任意一个浮点型数据，因为第一位不能为0，所以为1-9中任何一个，第2.3.4…位可以为0-9中任何一个或多个，小数点出现一次或者0次，小数部分0-9任意一个或多个。例：12534.5562,45256,12.021等等都可以与正则表达式匹配。

(2)     字符串的替换

replaceAll()方法。

例：String b ="12hello345".replaceAll("\\d+","你好");

运行结果b就是“你好hello你好”。

(3)     字符串的分解

split(String s)方法。字符串s代表正则表达式

例：Stringstr = “1931年09月18日，日本发动侵华战争”；

           Strings = “\\D+”；

           Stringd[] = str.split(s);

运行结果：d[0],d[1],d[3]分别是：“1931”、“09”、“18”。

6.      StringBuffer类(字符串处理)

作用：StringBuffer类创建一个可修改的字符串序列。

返回值类型	常用方法	说明
StringBuffer	append(String s)	在字符串后追加一个字符串。
char	charAt(int n)	获取下标为n处的单个字符
void	setCharAt(int n,char ch)	将当前StringBuffer对象中的字符串位置n处的字符替换为指定参数ch。
StringBuffer	insert(int n,String s)	将指定字符串s插入到下标n处，并返回当前对象的引用。
StringBuffer	reverse()	将当前对象实体中的字符翻转，并返回当前对象的引用。
StringBuffer	delete(int start,int end)	删除当前字符串从下标start处到下标end-1处的子字符串。
StringBuffer	replace(int start,int end,String s)	将当前字符串从下标start处到下标end-1处的子字符串替换为指定参数字符串s

1)      StringBuffer类中构造方法

StringBuffer()、StringBuffer(intsize)和StringBuffer(Strings)三个构造方法。

2)      StringBuffer类常见方法

(1)     append()方法。追加字符串。在字符串后追加一个字符串。

StringBuffer append(Strings) 在字符串后追加一个字符串s

StringBuffer append(inti)将int型数据i转化为字符串，再追加。

例：StringBuffer ds = newStringBuffer("我爱学习java");

                             ds.append("生活");//在字符串后追加

运行结果：字符串ds为“我爱学习java生活”。

(2)    char charAt(int n)方法。获取某单个字符。获取下标为n处的单个字符。

例：StringBufferds = new StringBuffer(“我爱学习java”)；

          char ch = ds.charAt(2)；//获取下标为2的字符

运行结果：ch为‘学’。

(3)    setCharAt(int n,char ch)方法。替换某个字符。将当前StringBuffer对象中的字符串位置n处的字符替换为指定参数ch。

例：StringBufferds = new StringBuffer(“我爱学习java”)；

        ds.setCharAt(0,‘你’)；//替换下标为0的字符

        运行结果：ds为“你爱学习java”。

(4)    StringBuffer insert(intn,String s)方法。插入字符串。将指定字符串s插入到下标n处，并返回当前对象的引用。

例：StringBufferds = new StringBuffer(“我爱学习java”)；

         ds.insert(1,“很爱很”)；//在下标1处插入字符串

         运行结果：ds为“我很爱很爱学习java”。

(5)    StringBuffer reverse()方法。翻转字符串。将当前对象实体中的字符翻转，并返回当前对象的引用。

例：StringBufferds = new StringBuffer(“我爱学习java”)；

          ds.reverse()；

                                      运行结果：ds为 “avaj习学爱我”。

(6)    StringBuffer delete(intstart,int end)方法。删除部分字符串。删除当前字符串从下标start处到下标end-1处的子字符串。

例：StringBufferds = StringBuffer(“我爱学习java”)；

         ds.delete(1,4)；//删除下标1到下标3所有的字符

运行结果：ds为“我java”。

(7)    StringBuffer replace(intstart,int end,String s)方法。替换字符串。将当前字符串从下标start处到下标end-1处的子字符串替换为指定参数字符串s。

例：StringBufferds = new StringBuffer(“我爱学习java”)；

         ds.replace(1,4,“喜欢”)；//替换从下标1到下标3处的字符串

运行结果：ds为“我喜欢java”。

7.      StringTokenizer类（字符串解析分离）

java.util.*;包中

Ø  两个常用构造方法：

l  StringTokenizer(String s)方法:为字符串s构造一个分析器。使用默认的分隔符标记，即空格符、换行符、回车符、Tab符、进纸符。

l  StringTokenizer(Strings,String dilim)方法：为字符串s构造一个分析器。使用参数dilim中的字符的任意组合作为分隔标记。

Ø  使用nextToken()方法。通常在while语句中逐个获取分隔开后的字符串（单词）。

Ø  在while语句条件中使用hasMoreTokens()方法控制循环。

Ø  使用countTokens()方法得到分析器计数的次数。（分离出单词的次数）。

例：StringTokenizer b = new StringTokenizer(“we,are,students”，“,”);

int num = b.countTokens();//获得分析器计数的次数

while(b.hasMoreTokens()){  //调用hasMoreTokenizer()方法控制循环

s =b.nextToken();       //逐个获取分隔后的字符串

System.out.println(“s=”+s);

}

System.out.println(“num=”+num);

运行结果： s=we  s=are    s=students    num=3                                   

8.      Scanner类（字符串解析分离提取处理）

java.util.*;包中

         作用：Scanner类的对象能够从字符串中解析程序所需要的数据

解析步骤：

u  为了解析字符串s中的数据，首先创建一个Scanner对象：

                    Scanner ds = new Scanner(String s);//默认空格作为分隔符。

u  调用方法useDelimlter(正则表达式)方法重新设置分隔符。

u  ds使用next()方法依次返回被解析的字符串s中的单词数据。

u  利用while循环逐步获取解析后的字符串，利用hasNext()方法作为循环条件。

例：scanner.java

importjava.util.*;

public classscanner {

public static void main(String[] args) {

                   String s = "telephonecost 876。Computercost 2398.2 ";

                   Scanner ds = new Scanner(s);//创建一个Scanner对象

                   ds.useDelimiter("[^0123456789.]+");//设置除0123456789.外的字符作为分隔符

                   double sum=0;

                   while(ds.hasNext()){       //使用hasNext()方法作为循环条件

                            try{double b = ds.nextDouble();//可能返回非数字化单词出现InputMismatchException异常

                                sum = sum+b;

                                System.out.println(b); 

                            }

                            catch(InputMismatchException exp){//处理可能发生的异常

                                     String c= ds.next();       

         }  }

                       System.out.println(sum);

         }  }

运行结果：876.0   2398.2    3274.2

9.      Date类（时间获取）

java.util.*;包中

ü  构造方法：Date(long time);获取当前时间。

         默认顺序为：星期、月、日、小时、分、秒、时区、年。

         例：Date date1 = new Date();//当前时间

             Date date2 = new Date(1000);//格林威治时间后一秒，（公元后一秒）

         运行结果：date1为“Wed May 03 17:58:11 CST2017”。

                               date2为“Thu Jan 01 08:00:01 CST1970”。//1000代表一秒

====*===*===*===*===*===*===*===*===*===*===*===*===*===*===*===*===*===*==

«  System类的静态方法currentTimeMillis()获取系统当前时间与格林威治时间相差的秒数。

例：long ds = System.currentTimeMillis();

====*===*===*===*===*===*===*===*===*===*===*===*===*===*===*===*===*===*==

10. Calendar类（时间日期处理）

java.util.*;包中

1.       初始化：使用Calendar类的static方法getInstance()可以初始化一个Calendar对象。利用Calendar对象设置获取相关信息。

         例：Calendar ds = Calendar.getInstance();

                   int year = calendar.get(YEAR);//获取年份信息

                   int month = calendar.get(MONTH)+1;//获取月份信息，返回数是月份数-1，所以需要+1；

                   int day = calendar.get(DAY_OF_MONTH);//获取天数

                   int week = calendar.get(DAY_OF_WEEK);//获取星期

                   int hour = calendar.get(HOUR_OF_DAY);//获取小时

                   int minute = calendar.get(MINUTE);//获取分钟

                   int second = calendar.get(SECOND);//获取秒数

2.     日期的格式化

l  simpleDateFormat类

使用DateFormat的子类SimpleDateFormat实现日期格式化。

常用构造方法：SimpleDateFormat(String s);该构造方法可以用参数s指定的格式创建一个对象，对象调用format(Date date)方法格式化时间对象date。

如果参数s中出现普通ASCII字符，必须用单引号“'”字符括起来。

例：s = “‘time’:yyyy-MM-dd”;

例：Date nowTime = new Date();//nowTime获取当前时间

         SimpleDateFormat ds = SimpleDateFormat(“yyyy年M月d日H时m分s秒E”)；创建一个指定的格式对象ds

         ds1 = ds.format(nowTime);调用对象ds格式化当前时间nowTime。

         运行结果：ds1为2017年5月4日15时36分55秒星期四

日期替换格式如下：

以2017年5月4日15时36分55秒星期四为例：

格式符	替换结果
G	公元
y	两位数字的年：2017
M	年中的月份：5（2017年的5月）
w	年中的周数：18（2017年的第18周）
W	月份中的周数：1（5月第一周）
D	年中的天数：124（2017年的第124天）
d	月份中的天数：4（5月的第四天）
F	月份中的星期：1（5月的第一个星期）
E	星期的天数：星期四（一星期的第4天）
a	am/pm标记：PM（下午）
H	一天中的小时（0～23）：例如：0
k	一天中的小时数（1～24）：例如：24
K	am/pm中的小时数（0～11）：4（下午4点）
h	am/pm中的小时数（1～12）：4（下午4点）
m	小时中的分钟：36
s	分钟中的秒数：55
S	毫秒数：627
z	时区：CST

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

l  Formatter类

format(“格式化模式”，日期列表)：目前format()方法已经被封装到String类中，因此可以直接用String类调用format()方法。

格式化“日期列表”中同一日期时，可以在“格式化模式”中使用“<”

例如：String s = String.format(“%tY年%<tm月%<td日%<tH时%<tM分%<tS秒”,newDate());

常见日期格式符：

“%ty年%<tm月%<td日%<tp%<tH时%<tM分%<tS秒”

2017年05月04日下午16时50分10秒为例：

 

分类	格式符	作用
年	%tY	将日期中的年格式化为四位形式：2017
	%ty	将日期中的年格式化为两位形式：17
月	%tm	将日期中的月份格式化两位形式（01～13）：05
	%tB	将日期中的月份格式化为全称：“January”或 “五月”
	%tb	将日期中的月份格式化为简称： “Jan”或“五月”
am/pm	%tp	将日期中的日格式化为上午或下午格式：表示上午下午
日	%td	将日期中的日格式化为本月中的一天（01～31）：04日
	%tj	将日期中的日格式化为当年中的一天（001～365）：124
星期	%tA	将日期中的日格式化为星期几的全称：“sunday”或“星期四”
	%ta	将日期中的日格式化为星期几的简称：“sun”或“星期四”
时	%tH	将日期中的时格式化为24小时制00～23：16
	%tI	将日期中的时格式化为12小时制1～12: 4
分	%tM	将日期中的分格式化为两位形式00～60: 50
秒	%tS	将日期中的秒格式化为两位形式00～60:10
毫秒	%tL	将日期中的毫秒格式化为三位形式000～999；
微秒	%tN	将日期中的微秒格式化为9位形式：
偏移量	%tz	将日期与格林威治时间的偏移量格式化为4位形式
时区	%tZ	将日期所在的时区的名称格式化为标准缩写：CST

不同区域的星期格式：format(Locale s（地域），格式化模式，日期列表)；

例：s=String.format(LocaleUS,“%tY年%<tb月%<td日”，new Date());

11.  Math类（数据运算处理）

java.math.*;包中

         Math类常用类方法：

         Random类（随机生成器）

java.math.*;包中

         构造方法：Random();和Random(longt);

         使用nextInt(int n)方法返回一个0～n之间的随机数，包括0，不包括n。

         例：Random rand1 = new Random();

             int t1 = rand.nextInt(100);//随机产生一个0～100之间的数（不包括100）

             intt2 = rand.nextInt(100)+1;//随机产生一个1～101之间的数（不包括101）

12. Pattern与Match类(检索跟指定模式匹配的字符串)

      java.util.regec包中

 模式对象：

 模式匹配第一步就是使用Pattern类创建一个对象p，称为模式对象。

模式对象就是对正则表达式的封装。

然后Pattern类调用类方法compile(String regex);返回一个模式对象。

参数regex是一个正则表达式。或者compile(Stringregex,int n)方法。

例：Pattern p =Pattern.compile(“\\dhello”);

匹配对象：

          使用模式对象p调用matcher(s)方法返回一个Matcher对象m，称为

匹配对象。

查找子序列：

          一个Matcher对象m可以调用下列3种方法查找参数s指定字符串是否含

有和regex匹配的子序列。

l  boolean find()方法：寻找s中和regex匹配的下一子序列，成功返回true，否则返回false。通常在while中做循环条件。

对象m调用group()方法得到匹配的子序列。对象m调用start()方法和end()方法得到匹配子序列时的开始位置和结束位置。

l  boolean matches()方法;判断s是否和regex匹配。

l  boolean lookingAt()方法：判断第一个。判断s的开始位置是否含有和regex匹配的子序列。

l  boolean find(int start)方法，判断所有。判断s从参数start位置开始是否含有和regex匹配的子序列。start=0时与lookingAt功能相同。

l  String replaceFirst(String t)方法。替换第一个。对象m调用该方法返回一个字符串。该字符串是通过s中与regex第一个匹配的子字符串替换为参数t指定的字符串。

l  String replaceAll(String t)方法，替换全部。对象m调用该方法返回一个字符串。该字符串是通过s中与regex匹配的子字符串全部替换为参数t指定的字符串。

例：pattern.java

public classpattern {

public static void main(String[] args) {

Patternp = Pattern.compile("[1-9][0-9]*[.]?[0-9]*");//创建模式对象

Strings = "price:235.42$,weight:524.21,height:452";

Matcherm = p.matcher(s);//创建匹配对象

while(m.find()){//寻找匹配的子序列

Stringstr = m.group();//返回找到的子序列

System.out.println(+m.start()+"到"+m.end()+"子序列:"+str);

}

System.out.println(m.lookingAt());//判断s中第一个是否与p匹配

System.out.println(m.find(0));//判断s是否有与p匹配的子序列

Stringt = m.replaceAll("20.2");//替换所有匹配的子序列

System.out.println(t);

Stringg = m.replaceFirst("203.2");//替换第一个匹配的子序列

System.out.println(g);

}

}

运行结果： 6到12子序列:235.42

21到27子序列:524.21

35到38子序列:452

false

true

price:20.2$,weight:20.2,height:20.2

price:203.2$,weight:524.21,height:452

13. Class类（帮助程序创建类或获取类的内部信息）（搜集信息）

1.       使用Class实例化一个对象

(1)     使用Class的forName(String className)方法得到一个和某类相关的Class对象。className为指定的类（如何类在某个包中，className必须带有包名，例：“java.util.Date”）。

例：class ds{…………}//类ds

         Class cs = Class.forName(“ds”);

(2)     使用Class创建的对象cs调用newInstance()方法得到一个className类的对象。

例：ds s = (ds)cs.newInstance();

注意：使用Class对象调用newInstance()实例化一个className类的对象时，className类必须有无参的构造方法。

2.       获取类的有关信息

当一个类被加载且创建对象时，创建的任何对象调用Class中的getClass()方法返回一个Class对象，可以获取对象的相关信息。

Class对象经常调用以下方法：

String getName();返回类的名字。

Constructor[]getConstructors();返回类的全部构造方法。

Field[]getDeclaredFields():返回类的全部成员变量。

Method[]getDeclaredMethods():返回类的全部方法。

例：classlei.java

import java.lang.reflect.*;

import java.util.*;

public class classlei {

         publicstatic void main(String[] args) {

                   Date f = new Date();//创建一个Date类对象

                   Class cs =f.getClass();//Date对象调用方法创建一个Class类对象

                   String name = cs.getName();//Class对象返回类名

                   Constructor[] con =cs.getDeclaredConstructors();//Class对象返回构造方法（数组）

                   Field[] field = cs.getDeclaredFields();//Class对象返回成员变量（数组）

                   Method[] method =cs.getMethods();//Class对象返回全部方法（数组）

                   System.out.println("类名"+name);

                   System.out.println("成员变量如下：");

                   for(inti=0;i<field.length;i++){//循环打印所有成员变量（数组）

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

                   }

                   System.out.println("构造方法如下：");

                   for(inti=0;i<con.length;i++){//循环打印所有构造方法（数组）

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

                   }

                   System.out.println("全部方法如下：");

                   for(inti=0;i<method.length;i++){//循环打印所有全部方法（数组）

                            System.out.println(method[i].toString());     } } }

如果需要java开发视频教程的加QQ群：814394029，可联系群主获取，非诚勿扰哦！