JAVA程序开发参考手册

<!--包装数据类型 ->
	//javalangInteger——整数类 
	//bitCount方法——获取二进制补码中位的数量 
		int i = 10;
		int count = Integer.bitCount(i);
		System.out.print(i + "的二进制补码表示形式的1位的数量");
		System.out.println(count);
	//byteValue方法——获取byte类型的值 
		Integer tobyte = new Integer("125");
		byte byte1 = tobyte.byteValue();
		System.out.println(byte1);
	//compareTo方法——比较整数 
		Integer int1 = new Integer("100");
		Integer int2 = new Integer("100");
		int str = int1.compareTo(int2);
		System.out.println(str);
	//decode方法——将字符串解码为int类型 
		String str = new String("100");
		Integer a = Integer.decode(str);
		System.out.println(a);
	//doubleValue方法——返回double数值 
		Integer todouble = new Integer(123);
		double str = todouble.doubleValue();
		System.out.println(str);
	//equals方法——比较整数对象是否相等 
		Integer i = new Integer(123);
		Integer j = new Integer(123);
		boolean b = i.equals(j);
		System.out.println(b);
	//floatValue方法——返回float值 
		Integer floats = new Integer(123);
		float str = floats.floatValue();
		System.out.println(str);
	//getInteger方法——获取整数的系统属性值 
		String nm = "sun.arch.data.model";
		Integer i = Integer.getInteger(nm);
		System.out.println(i);
	//hashCode方法——生成整数的哈希码 
		Integer i = new Integer(10);
		int j = i.hashCode();
		System.out.println(j);
	//highestOneBit方法——获取整数二进制最高位的索引 
		for (int i = 0; i < 10; i++) {
		int j = Integer.highestOneBit(i);
		System.out.println(j);
	//intValue方法——获取int值 
		Integer ints = new Integer("12");
		int str = ints.intValue();
		System.out.println(str);
	//longValue方法——获取long值 
		Integer longs = new Integer("12");
		long str = longs.longValue();
		System.out.println(str);
	//lowestOneBit方法——获取整数二进制最低位的索引 
		for (int i = 0; i < 10; i++) {
			int j = Integer.lowestOneBit(i);
			System.out.println(j);
		}
	//parseInt方法——将字符串解析为int值 
		String stri = new String("100");
		int str = Integer.parseInt(stri);
		System.out.println(str);
	//reverse方法—反转整数二进制补码的位顺序 
		int i;
		int j = 10;
		i = Integer.reverse(j);
		System.out.println(i);
	//reverseBytes方法—反转整数字节的顺序 
		int i;
		int j = 10;
		i = Integer.reverseBytes(j);
		System.out.println(i);
	//shortValue方法—获取short值 
		int i = 10;
		Integer shorts = new Integer(i);
		short str = shorts.shortValue();
		System.out.println(str);
	//signum方法—获取整数符号 
		int i = 10;
		System.out.println(Integer.signum(i));
	//toBinaryString方法—生成整数的二进制字符串 
		int i = 10;
		Integer stri = new Integer(i);
		String str = Integer.toBinaryString(stri);
		System.out.println(str);
	//toHexString方法—生成整数的十六进制字符串 
		Integer stri = new Integer(10);
		String str = Integer.toHexString(stri);
		System.out.println(str);
	//toOctalString方法—生成整数的八进制字符串 
		Integer stri = new Integer(10);
		String str = Integer.toOctalString(stri);
		System.out.println(str);
	//toString方法—生成整数的十进制字符串 
		Integer stri = new Integer(10);
		String str = Integer.toString(stri);
		System.out.println(str);
	//valueOf方法—创建Integer对象 
		Integer stri = new Integer(10);
		Integer str = Integer.valueOf(stri);
		System.out.println(str);
//javalangString——字符串 
	//charAt方法——提取指定字符 
		String strCom = "I LIKE JAVA";
		char strLower = strCom.charAt(4);
		System.out.println(strLower);
	//codePointAt方法—提取索引字符代码点 
		String strCom = "I LIKE JAVA";
		int strLower = strCom.codePointAt(8);
		System.out.println(strLower);
	//codePointBefore方法——获取索引前一个字符的代码点 
		String strCom = "I LIKE JAVA";
		int strLower = strCom.codePointBefore(8);
		System.out.println(strLower);
	//codePointCount方法——获取指定范围文本代码点数 
		String strCom = "I LIKE JAVA";
		int strLower = strCom.codePointCount(2, 3);
		System.out.println(strLower);
	//compareTo方法——比较两个字符串 
		String strCom = "I LIKE JAVA";
		String strCom1 = "I LIKE PHP";
		int strLower = strCom.compareTo(strCom1);
		System.out.println(strLower);
	//compareToIgnoreCase方法——忽略大小写比较字符串 
		String strCom = "I LIKE JAVA";
		String strCom1 = "I LIKE PHP";
		int strLower = strCom.compareToIgnoreCase(strCom1);
		System.out.println(strLower);
	//concat方法——字符串结尾连接 
		String strCom = "I LIKE JAVA";
		String strCom1 = "I LIKE PHP";
		String str = strCom.concat(strCom1);
		System.out.println(str);
	//contains方法——判断是否包含指定字符 
		String strCom = "I LIKE JAVA";
		boolean str = strCom.contains("JAVA");
		System.out.println(str);
	//copyValueOf方法——字符数组生成字符串 
		char[] array = {'科','技'};
		String str = String.copyValueOf(array);
		System.out.println(str);
	//endsWith方法——判断后缀字符串 
		String strCom = "string.java";
		boolean str = strCom.endsWith(".java");
		System.out.println(str);
	//equals方法——判断字符串相等 
		String strCom1 = "MN";
		String strCom2 = "mn";
		boolean strB = strCom1.equals(strCom2);
		System.out.println(strB);
	//equalsIgnoreCase方法——忽略大小写判断字符串相等 
		String strCom1 = "MN";
		String strCom2 = "mn";
		boolean strB = strCom1.equalsIgnoreCase(strCom2);
		System.out.println(strB);
	//format方法——格式化字符串 
		String str = String.format("%d", 400/2);
		System.out.println(str);
	//getBytes方法——获取字符串的字节数组 
		String strCom = "java";
		byte[] str = strCom.getBytes();
		for (int i = 0; i < str.length; i++) {
			System.out.println(str[i]);
		}
	//getChars方法——获取字符数组 
		String str = "HELLO WORLD";
		char[] ch = new char[10];
		str.getChars(0, 10, ch, 0);
		for (int i = 0; i < ch.length; i++) {
			System.out.println(ch[i]);
		}
	//hashCode方法——生成字符串哈希表 
		String str = "I LIKE JAVA";
		System.out.println(str.hashCode());
	//indexOf方法——获取字符第一个索引 
		String str = "Hello World";
		int index = str.indexOf(5);
		System.out.println(index);
	//intern方法——获取规范化字符串 
		String str1 = new String("helloworld");
		String str2 = new String("helloworld");
		System.out.println(str1.equals(str2));
		System.out.println(str1 == str2);
		System.out.println(str1.intern() == str2.intern());
	//isEmpty方法——判断字符串是否为空 
		String str = "hello world";
		boolean b = str.isEmpty();
		System.out.println(b);
	//lastIndexOf方法——获取字符最后的索引 
		String strCom = "abcdefg gfdecba";
		int index = strCom.lastIndexOf("a");
		System.out.println(index);
	//length方法——获取字符串的长度 
		String str = "I like Java";
		int length = str.length();
		System.out.println(length);
	//matches方法——匹配正则表达式 
		String regex = "1234";
		System.out.println(regex.matches("\\d{4}"));
	//offsetByCodePoints方法——获取索引偏移后指定代码点的索引 
		String strCom = "I LIKE JAVA";
		int i = strCom.offsetByCodePoints(2, 3);
		System.out.println(i);
	//regionMatches方法——测试两个字符串区域是否相等 
		String strCom = "ABLIKE";
		String subStr = "CDLIKE";
		boolean b = subStr.regionMatches(true, 2, strCom, 2, 3);
		System.out.println(b);
	//replace方法——替换字符序列 
		String str = "图书";
		str.replace("图书", "参考");
		System.out.println(str);
	//replaceAll方法——正则表达式匹配替换所有字符串 
		String  str = "成功者找方法,";
		str = str.replaceAll(",", "失败者找理由");
		System.out.println(str);
	//replaceFirst方法——正则表达式替换第一个匹配的字符串 
		String str = "1词典，1图书，1软件";
		str = str.replaceFirst("1", "JAVA");
		System.out.println(str);
	//split方法——字符串分割成数组 
		String str = "公司名称：xxx科技！公司所在地：XXX市。公司电话：11122";
		String[] info = null;
		info = str.split("！|。");
		for (int i = 0; i < info.length; i++) {
			System.out.println(info[i]);
		}
	//startsWith方法——判断前缀字符串 
		String strCom1 = "I like Java";
		boolean strB = strCom1.startsWith("I l",0);
		System.out.println(strB);
	//subSequence方法——获取子字符串序列 
		String strCom = "I IIKE JAVA";
		System.out.println(strCom.subSequence(2, 6));
	//subString方法——获取子字符串 
		String strCom = "I IIKE JAVA";
		String strResult = strCom.substring(3);
		System.out.println(strResult);
	//toCharArray方法——字符串变字符数组 
		String strCom = "JAVA参考大全";
		char[] str = strCom.toCharArray();
		for (int i = 0; i < str.length; i++) {
			System.out.println(str[i]);
		}
	//toLowerCase方法——转换成小写字符串 
		String strCom = "I LIKE JAVA";
		String strLower = strCom.toLowerCase();
		System.out.println(strLower);
	//toUpperCase方法——转换成大写字符串 
		String strCom = "i like java";
		String strLower = strCom.toUpperCase();
		System.out.println(strLower);
	//trim方法——去除空格 
		String strCom = "  JAVA参考大全  ";
		String str = strCom.trim();
		System.out.println(str);
	//valueOf方法——基本数据类型转成字符串 
		boolean strCom = true;
		String str = String.valueOf(strCom);
		System.out.println(str);
//javalangLong——长整型类 
	//bitCount方法——获取二进制补码中的数量 
		for (int i = 0; i < 10; i++) {
			int count = Long.bitCount(i);
			System.out.println(count);
		}
	//byteValue方法——获取byte值 
		Long bytes = new Long("125");
		byte str = bytes.byteValue();
		System.out.println(str);
	//compareTo方法——比较长整数 
		Long l1 = new Long("125");
		Long l2 = new Long("125");
		int str = l1.compareTo(l2);
		System.out.println(str);
	//decode方法——字符串解码为long类型 
		String stri = new String("100");
		Long str = Long.decode(stri);
		System.out.println(str);
	//doubleValue方法——返回double数值 
		Long doubles = new Long(123);
		double str = doubles.doubleValue();
		System.out.println(str);
	//equals方法——判断长整数对象相等 
		Long i = new Long(123);
		Long j = new Long(123);
		boolean b = i.equals(j);
		System.out.println(b);
	//floatValue方法——获取float数值 
		Long floats = new Long(123);
		float str = floats.floatValue();
		System.out.println(str);
	//getLong方法——获取长整数的系统属性值 
		String nm = "sun.arch.data.mode1";
		Long i = Long.getLong(nm);
		System.out.println(i);
	//hashCode方法——生成长整数的哈希码 
		Long i = new Long(10);
		int j = i.hashCode();
		System.out.println(j);
	//highestOneBit方法——获取长整数二进制最高位的索引 
		Long l = new Long(10);
		long j = Long.highestOneBit(l);
		System.out.println(j);
	//intValue方法——获取int值 
		Long ints = new Long(22456L);
		int str = ints.intValue();
		System.out.println(str);
	//longValue方法——获取long值 
		Long longs = new Long("12");
		long str = longs.longValue();
		System.out.println(str);
	//lowestOneBit方法——获取长整数二进制最低位的索引 
		Long l = new Long(10);
		long j = Long.lowestOneBit(l);
		System.out.println(j);
	//parseLong方法——将字符串解析为long值 
		String str[] = {"15","20","45","35"};
		long sum = 0;
		for (int i = 0; i < str.length; i++) {
			long mylong = Long.parseLong(str[i]);
			sum += mylong;
		}
		System.out.println("数组求和为:"+sum);
	//reverse方法——反转长整数二进制补码的位顺序 
		long i;
		i = Long.reverse(10);
		System.out.println(i);
	//reverseBytes方法——反转长整数字节的顺序 
		long i;
		i = Long.reverseBytes(10);
		System.out.println(i);
	//shortValue方法——获取short值 
		Long shorts = new Long(12L);
		short str = shorts.shortValue();
		System.out.println(str);
	//signum方法——获取长整数符号 
		long i = 10;
		System.out.println(Long.signum(i));
	//toBinaryString方法——生成长整数的二进制字符串 
		Long stri = new Long(10L);
		String str = Long.toBinaryString(stri);
		System.out.println(str);
	//toHexString方法——生成长整数的十六进制字符串 
		Long stri = new Long(456);
		String str = Long.toHexString(stri);
		System.out.println(str);
	//toOctalString方法——生成长整数的八进制字符串 
		Long stri = new Long(456);
		String str = Long.toOctalString(stri);
		System.out.println(str);
	//toString方法——生成长整数的十进制字符串 
		Long stri = new Long(10);
		String str = Long.toString(stri);
		System.out.println(str);
	//valueOf方法——创建Long对象 
		Long stri = new Long(10L);
		long str = Long.valueOf(stri);
		System.out.println(str);
//javalangShort——短整型类 
	//compareTo方法——比较短整数 
		Short com = new Short("125");
		Short com1 = new Short("125");
		int str = com.compareTo(com1);
		System.out.println(str);
	//decode方法——字符串解码为short类型 
		String stri = new String("100");
		Short str = Short.decode(stri);
		System.out.println(str);
	//doubleValue方法——返回double数值 
		short shor = 125;
		Short doubles = new Short(shor);
		double str = doubles.doubleValue();
		System.out.println(str);
	//equals方法——判断短整数对象相等 
		Short i = new Short("123");
		Short j = new Short("123");
		boolean b = i.equals(j);
		System.out.println(b);
	//floatValue方法——获取float数值 
		Short shor = 125;
		Short floats = new Short(shor);
		float str = floats.floatValue();
		System.out.println(str);
	//hashCode方法——生成短整数的哈希码 
		Short i = new Short("10");
		int j = i.hashCode();
		System.out.println(j);
	//intValue方法——获取int值 
		short shor = 125;
		Short ints = new Short(shor);
		int str = ints.intValue();
		System.out.println(str);
	//longValue方法——获取long值 
		Short Shorts = new Short("12345");
		long str = Shorts.longValue();
		System.out.println(str);
	//parseShort方法——将字符串解析为十进制short值 
		String str[] = {"15","20","45","35"};
		short sum = 0;
		for (int i = 0; i < str.length; i++) {
			Short mylong = Short.parseShort(str[i]);
			sum += mylong;
		}
		System.out.println("数组求和为:"+sum);
	//reverseBytes方法——反转短整数字节的顺序 
		short i = 10;
		short j = Short.reverseBytes(i);
		System.out.println(j);
	//shortValue方法——获取short值 
		Short i = 10;
		short j = i.shortValue();
		System.out.println(j);
	//toString方法——生成短整数的十进制字符串 
		Short stri = new Short("10");
		String str = Short.toString(stri);
		System.out.println(str);
	//valueOf方法——创建Short对象 
		Short stri = new Short("100");
		Short str = Short.valueOf(stri);
		System.out.println(str);
//javalangBoolean——布尔类 
	//booleanValue方法——获取boolean值 
		Boolean bool = new Boolean("true");
		boolean b = bool.booleanValue();
		System.out.println(b);
	//compareTo方法——比较布尔值 
		Boolean b1 = true;
		Boolean b2 = true;
		int i;
		i = b1.compareTo(b2);
		System.out.println(i);
	//equals方法——判断相等 
		Boolean b1 = true;
		Boolean b2 = false;
		boolean b;
		b = b1.equals(b2);
		System.out.println(b);
	//getBoolean方法——获取布尔类型的系统属性值 
		String nm = "sun.arch.date.model";
		boolean b = Boolean.getBoolean(nm);
		System.out.println(b);
	//hashCode方法——生成布尔对象的哈希码 
		Boolean b = true;
		int i = b.hashCode();
		System.out.println(i);
	//parseBoolean方法——将字符串解析成boolean值 
		String s = "true";
		boolean b = Boolean.parseBoolean(s);
		System.out.println(b);
	//toString方法——生成布尔值的字符串 
		Boolean b = false;
		String s = b.toString();
		System.out.println(s);
	//valueOf方法——创建布尔对象 
		Boolean i = true;
		Boolean b = Boolean.valueOf(i);
		System.out.println(b);
//javalangByte——字节对象 
	//compareTo方法——比较字节对象 
		Byte b1 = new Byte("10");
		Byte b2 = new Byte("20");
		int i;
		i = b1.compareTo(b2);
		System.out.println(i);
	//decode方法——将字符串解码为byte值 
		String s = "0x64";
		Byte b = Byte.decode(s);
		System.out.println(b);
	//doubleValue方法——获取double值 
		Byte b = 100;
		double d = b.doubleValue();
		System.out.println(d);
	//equals方法——判断字节相等 
		Byte b1 = 10;
		Byte b2 = 20;
		boolean b;
		b = b1.equals(b2);
		System.out.println(b);
	//floatValue方法——获取float值 
		Byte b1 = 10;
		float f = b1.floatValue();
		System.out.println(f);
	//hashCode方法——生成字节对象的哈希码 
		Byte b1 = 10;
		int i = b1.hashCode();
		System.out.println(i);
	//intValue方法——获取int值 
		byte by = 123;
		Byte b = new Byte(by);
		int it = b.intValue();
		System.out.println(it);
	//longValue方法——获取long值 
		Byte b1 = 100;
		long i = b1.longValue();
		System.out.println(i);
	//parseByte方法——将字符串解析为byte值 
		String str = new String("12");
		byte it = Byte.parseByte(str);
		System.out.println(it);
	//shortValue方法——获取short值 
		Byte b1 = 10;
		short i = b1.shortValue();
		System.out.println(i);
	//toString方法——生成字节值的十进制字符串 
		Byte str = new Byte("125");
		String it = Byte.toString(str);
		System.out.println(it);
	//valueOf方法——创建Byte对象 
		Byte b1 = 10;
		Byte b = Byte.valueOf(b1);
		System.out.println(b);
//javalangCharacter——字符类 
	//charCount方法——计算指定字符代码点的数量 
		int c1 = 0x10000;
		int cha = Character.charCount(c1);
		System.out.println(cha);
	//charValue方法——获取char值 
		Character c1 = new Character('a');
		char cha = c1.charValue();
		System.out.println(cha);
	//codePointAt方法——获取字符数组元素的代码点 
		char[] c1 = {'科','技'};
		int cha = Character.codePointAt(c1, 1);
		System.out.println(cha);
	//codePointBefore方法——获取字符数组索引前一个元素的代码点 
		char[] c1 = {'科','技'};
		int cha = Character.codePointBefore(c1, 1);
		System.out.println(cha);
	//codePointCount方法——返回字符数组的子数组中代码点的数量 
		char[] c1 = {'科','技'};
		int cha = Character.codePointCount(c1,0,1);
		System.out.println(cha);
	//compareTo方法——比较字符对象 
		Character c1 = new Character('2');
		Character c2 = new Character('1');
		int cha = c1.compareTo(c2);
		System.out.println(cha);
	//equals方法——判断字符对象相等 
		Character c = new Character('a');
		boolean b = c.equals(new Character('a'));
		System.out.println(b);
	//getNumericValue方法——返回字符表示的int值 
		char c = '\u216C';
		int i = Character.getNumericValue(c);
		System.out.println(i);
	//getType方法——返回一个指示字符的常规类别的值 
		char ch = 'a';
		System.out.println(Character.getType(ch));
	//hashCode方法——生成字符对象的哈希码 
		Character c = new Character('a');
		int i = c.hashCode();
		System.out.println(i);
	//isDefined方法——判断是否为Unicode字符 
		boolean b = Character.isDefined(11);
		System.out.println(b);
	//isDigit方法——判断是否为数字字符 
		char c2 = '科';
		boolean cha = Character.isDigit(c2);
		System.out.println(cha);
	//isLetter方法——判断是否为字母字符 
		boolean bool = Character.isLetter('*');
		System.out.println(bool);
	//isLowerCase方法——判断是否为小写字符 
		char c1 = 'a';
		boolean bool = Character.isLowerCase(c1);
		System.out.println(bool);
	//isUpperCase方法——判断是否为大写字符 
		char c1 = 'L';
		boolean bool = Character.isUpperCase(c1);
		System.out.println(bool);
	//toLowerCase方法——转换为小写字符 
		char c1 = 'L';
		char cha = Character.toLowerCase(c1);
		System.out.println(cha);
	//toUpperCase方法——转换为大写字符 
		char c1 = 'a';
		char cha = Character.toUpperCase(c1);
		System.out.println(cha);
//javalangDouble——双精度数字类 
	//byteValue方法——获取byte值 
		Double d1 = new Double(58.78);
		byte dou = d1.byteValue();
		System.out.println(dou);
	//compare方法——比较双精度数字对象 
		double d1 = 45.23;
		double d2 = 45.22;
		int dou = Double.compare(d1, d2);
		System.out.println(dou);
	//compareTo方法——比较两个Double对象 
		Double d1 = 45.23;
		Double d2 = 45.22;
		int dou = d1.compareTo(d2);
		System.out.println(dou);
	//intValue方法——将double值以int形式返回 
		Double d1 = new Double(45.23F);
		int dou = d1.intValue();
		System.out.println(dou);
	//doubleToLongBits方法——返回指定浮点值的表示形式 
		double d = 123.456;
		long l = Double.doubleToLongBits(d);
		System.out.println(l);
	//doubleToRawLongBits方法——保留NaN值返回指定浮点值的表示形式 
		double d = 123.456;
		long l = Double.doubleToRawLongBits(d);
		System.out.println(l);
	//doubleValue方法——获取double值 
		Double d1 = new Double(123.456);
		double d2 = d1.doubleValue();
		System.out.println(d2);
	//equals方法——判断Double对象是否相等 
		Double d1 = new Double(123.456);
		Double d2 = new Double(123.456);
		boolean b = d1.equals(d2);
		System.out.println(b);
	//floatValue方法——获取float值 
		Double d1 = new Double(123.456);
		float f = d1.floatValue();
		System.out.println(f);
	//hashCode方法——生成Double对象的哈希码 
		Double d1 = new Double(123.456);
		int i = d1.hashCode();
		System.out.println(i);
	//isInfinite方法——判断double值的大小是否是无穷大 
		Double d1 = new Double(45.23F);
		boolean dou = d1.isInfinite();
		System.out.println(dou);
	//isNaN方法——判断double值是否是一个非数字值 
		Double d1 = new Double(45.23F);
		boolean dou = d1.isNaN();
		System.out.println(dou);
	//longBitsToDouble方法——返回给定位表示形式的double值 
		double d1 = 123.456;
		long l = Double.doubleToLongBits(d1);
		System.out.println(l);
	//longValue方法——获取long值 
		Double d1 = new Double(45.23F);
		long dou = d1.longValue();
		System.out.println(dou);
	//parseDouble方法——将字符串解析为double值 
		String d1 = new String("124");
		double dou = Double.parseDouble(d1);
		System.out.println(dou);
	//shortValue方法——获取short值 
		Double d1 = new Double(45.23F);
		short dou = d1.shortValue();
		System.out.println(dou);
	//toHexString方法——生成双精度数字的十六进制字符串 
		Double d1 = new Double(0.25);
		String dou = Double.toHexString(d1);
		System.out.println(dou);
	//toString方法——生成双精度数字的十进制字符串 
		Double d1 = new Double(0.25F);
		String dou = Double.toString(d1);
		System.out.println(dou);
	//valueOf方法——创建Double对象 
		Double d1 = new Double(0.25F);
		Double dou = Double.valueOf(d1);
		System.out.println(dou);
//javalangFloat——浮点类 
	//byteValue方法——获取byte值 
		Float f = new Float(123.456f);
		byte b = f.byteValue();
		System.out.println(b);
	//compare方法——比较Float对象 
		float f1 = 456.23F;
		float f2 = 456.22F;
		int f = Float.compare(f1, f2);
		System.out.println(f);
	//compareTo方法——比较两个Float对象所表示的数值 
		Float f1 = 456.23F;
		Float f2 = 456.22F;
		int f = f1.compareTo(f2);
		System.out.println(f);
	//doubleValue方法——获取double值 
		Float f = new Float(123.456F);
		double d = f.doubleValue();
		System.out.println(d);
	//equals方法——判断Float对象相等 
		Float f1 = new Float(123.456f);
		Float f2 = new Float(123.456f);
		boolean b = f1.equals(f2);
		System.out.println(b);
	//floatToIntBits方法——返回浮点值的表示形式 
		float f = 123.456f;
		int i = Float.floatToIntBits(f);
		System.out.println(i);
	//floatToRawIntBits方法——保留非数字值返回指定浮点值的表示形式 
		float f = 123.456f;
		int i = Float.floatToRawIntBits(f);
		System.out.println(i);
	//floatValue方法——获取float值 
		Float f = new Float(123.456f);
		float ff = f.floatValue();
		System.out.println(ff);
	//hashCode方法——返回Float对象的哈希码 
		Float f = new Float(123.456f);
		int i = f.hashCode();
		System.out.println(i);
	//intBitsToFloat方法——返回指定位表示形式的float值 
		float f = 123.456f;
		int i = Float.floatToIntBits(f);
		System.out.println(i);
	//intValue方法——获取int值 
		Float f1 = new Float(456.23F);
		int fol = f1.intValue();
		System.out.println(fol);
	//isInfinite方法——判断float值的大小是否是无穷大 
		Float f1 = new Float(456.23F);
		boolean b = f1.isInfinite();
		System.out.println(b);
	//isNaN方法——判断float值是否是一个非数字值 
		Float f = new Float(11.23F);
		boolean b = f.isNaN();
		System.out.println(b);
	//longValue方法——获取long值 
		Float f = new Float(456.23F);
		long l = f.longValue();
		System.out.println(l);
	//parseFloat方法——将字符串解析成float值 
		String s = new String("124");
		float f = Float.parseFloat(s);
		System.out.println(f);
	//shortValue方法——获取short值 
		Float f = new Float(35.23F);
		short sh = f.shortValue();
		System.out.println(sh);
	//toHexString方法——生成浮点数的十六进制字符串 
		Float f = new Float(0.25);
		String s = Float.toHexString(f);
		System.out.println(s);
	//toString方法——生成浮点数的十进制字符串 
		Float f = new Float(0.25F);
		String s = Float.toString(f);
		System.out.println(s);
	//valueOf方法——创建浮点数对象 
		Float f1 = new Float(0.25F);
		Float f2 = Float.valueOf(f1);
		System.out.println(f2);
<!--集合操作 ->
//javautilList——有序集合类 
	//add方法——向列表中插入元素 
		ArrayList<String> list = new ArrayList<String>();
		list.add("学生");
		list.add(null);
		list.add("老师");
		for (int i = 0; i < list.size(); i++) {
			System.out.println(i+":"+list.get(i));
		}
	//addAll方法——将指定collection添加到列表中 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		List<String> list_ad = new ArrayList<String>();
		list_ad.add("公益广告");
		boolean flag = list.addAll(list_ad);
		System.out.println(flag);
		System.out.println(list);
	//clear方法——从列表中移除所有元素 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		System.out.println(list);
		list.clear();
		System.out.println(list);
	//contains方法——判断列表中是否包含指定元素 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		String o = "保护环境";
		System.out.println(list.contains(o));
	//containsAll方法——判断列表中是否包含指定collection的所有元素 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		String o = "保护环境";
		List<String> list_ad = new ArrayList<String>();
		list_ad.addAll(list);
		list_ad.add(0,"公益广告");
		System.out.println(list_ad.containsAll(list));
	//equals方法——比较指定的对象与列表是否相等 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		List<String> list_ad = new ArrayList<String>();
		list_ad.add("保护环境");
		list_ad.add("爱护地球");
		list_ad.add("从我做起");
		boolean ret = list_ad.equals(list);
		if(ret){
			System.out.println("两个相同");
		}else{
			System.out.println("两个不同");
		}
	//get方法——获取列表指定位置的元素 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		String ret = list.get(1);
		System.out.println(ret);
	//set方法——替换列表中指定位置的元素 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		String ret = list.set(1, "少用塑料袋");
		System.out.println(ret);;
		System.out.println(list);
	//hashCode方法——返回列表的哈希码值 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		int ret = list.hashCode();
		System.out.println(ret);
	//indexOf方法——返回第一次出现指定元素的位置 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		int index = list.indexOf("从我做起");
		System.out.println(index);
	//lastIndexOf方法——返回最后一次出现指定元素的位置 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		int index = list.lastIndexOf("从我做起");
		System.out.println(index);
	//isEmpty方法——判断集合是否为空 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		boolean empty = list.isEmpty();
		System.out.println(empty);
	//iterator方法——返回迭代器 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		Iterator<String> it = list.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	//listIterator方法——返回列表迭代器 
		ArrayList list = new ArrayList();
		for (int i = 0; i < 5; i++) {
			list.add("JAVA参考大全"+i);
		}
		ListIterator li = list.listIterator();
		while (li.hasNext()) {
			System.out.println(li.next());
		}
	//remove方法——移出列表中的指定元素 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		String str = list.remove(1);
		System.out.println(str);
		Iterator<String> it = list.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	//removeAll方法——从列表中移除指定collection中包含的所有元素 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		List<String> list1 = new ArrayList<String>();
		list1.add("保护环境");
		list1.add("爱护地球");
		boolean ret = list1.removeAll(list);
		System.out.println(ret);
	//retainAll方法——保留指定collection中包含的所有元素 
		List<String> list = new ArrayList<String>();
		list.add("第一个");
		list.add("第二个");
		list.add("第三个");
		List<String> list1 = new ArrayList<String>();
		list1.add("第一个");
		list1.add("第三个");
		boolean ret = list.retainAll(list1);
		System.out.println(ret);
	//size方法——返回列表中元素的个数
		List<String> list = new ArrayList<String>();
		list.add("第一个");
		list.add("第二个");
		list.add("第三个");
		int listSize = list.size();
		System.out.println(listSize);
	//subList方法——获取列表中指定范围的子列表 
		List<String> list = new ArrayList<String>();
		list.add("第一个");
		list.add("第二个");
		list.add("第三个");
		list.add("第四个");
		list.add("第五个");
		List<String> subList = list.subList(3, 5);
		Iterator<String> iterator = subList.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	//toArray方法——返回所有元素的数组 
		List<String> list = new ArrayList<String>();
		list.add("第一个");
		list.add("第二个");
		list.add("第三个");
		list.add("第四个");
		list.add("第五个");
		Object[] arr = list.toArray();
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
//javautilMap——映射集合类
	//clear方法——移除所有映射关系 
		Map map = new HashMap();
		map.put("昨天", "定制目录");
		map.put("今天", "开始写作");
		map.put("明天", "当然继续写作");
		System.out.println(map.size());
		map.clear();
		System.out.println(map.size());
	//containsKey方法——判断是否包含指定的键名 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		String key = "book";
		boolean contains = map.containsKey(key);
		System.out.println(contains);
	//containsValue方法——判断是否包含指定的键值 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		String value = "新鲜苹果";
		boolean contains = map.containsValue(value);
		System.out.println(contains);
	//equals方法——判断是否与指定的对象相同 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		Map map2 = new HashMap();
		map2.put("apple", "新鲜苹果");
		map2.put("compiter", "配置优良的计算机");
		map2.put("book", "推挤成山的图书");
		boolean contains = map.equals(map2);
		System.out.println(contains);
	//get方法——返回指定键所映射的值 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		Object get = map.get("apple");
		System.out.println(get);
	//isEmpty方法——判断是否为空 
		Map map = new HashMap();
		System.out.println("是否为空"+map.isEmpty());
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		System.out.println("是否为空"+map.isEmpty());
	//keySet方法——获取Map集合的所有key 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		Set keySet = map.keySet();
		for (Object object : keySet) {
			System.out.println(object);
		}
	//put方法——向指定索引位置添加对象 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		int size = map.size();
		System.out.println(size);
	//putAll方法——追加另一个Map对象到当前Map集合 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		Map map1 = new HashMap();
		map1.put("apple1", "新鲜苹果");
		map1.put("compiter1", "配置优良的计算机");
		map1.put("book1", "推挤成山的图书");
		map1.putAll(map);
		System.out.println(map1);
	//remove方法——移除Map集合中指定键名的内容 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		map.remove("apple");
		System.out.println(map);
	//size方法——获取Map集合类的大小 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		System.out.println(map.size());
	//values方法——获取Map集合中的所有键值对象 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		Collection values = map.values();
		for (Object object : values) {
			System.out.println(object);
		}
//javautilSet——无重复元素集合类 
	//add方法——向Set集合中添加对象 
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		int size = set.size();
		System.out.println(size);
	//addAll方法——向Set集合添加另一个集合的所有内容 
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		HashSet set1 = new HashSet();
		set1.add("a1");
		set1.add("b1");
		set1.add("c1");
		set1.addAll(set);
		System.out.println(set1);
	//clear方法——从Set集合中移除所有内容 
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		int size = set.size();
		System.out.println(size);
		set.clear();
		size = set.size();
		System.out.println(size);
	//contains方法——判断Set集合是否包含指定对象 
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		boolean contains = set.contains("a");
		System.out.println(contains);
	//containsAll方法——判断Set集合是否包含另一个集合中的全部对象 
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		ArrayList list = new ArrayList();
		list.add("a");
		list.add("b");
		boolean contains = set.containsAll(list);
		System.out.println(contains);
	//equals方法——比较指定对象与Set集合对象是否相等 
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		HashSet set1 = new HashSet();
		set1.add("a");
		set1.add("b");
		set1.add("c");
		boolean contains = set1.equals(set);
		System.out.println(contains);
	//isEmpty方法——判断Set集合是否为空 
		HashSet set = new HashSet();
		System.out.println("是否为空"+set.isEmpty());
		set.add("a");
		set.add("b");
		set.add("c");
		System.out.println("是否为空"+set.isEmpty());
	//iterator方法——获取Set集合的迭代器 
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		Iterator iterator = set.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	//remove方法——移除Set集合中的指定对象 
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		System.out.println(set.size());
		set.remove("a");
		System.out.println(set.size());
	//removeAll方法——移除另一个集合所包含的所有内容 
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		System.out.println(set.size());
		set.removeAll(set);
		System.out.println(set.size());
	//retainAll方法——保留另一个集合所包含的所有内容 
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		System.out.println(set.size());
		set.retainAll(set);
		System.out.println(set.size());
	//size方法——获取Set集合类的大小 
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		System.out.println(set.size());
	//toArray方法——用Set集合的所有对象创建数组 
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		Object[] toArray = set.toArray();
		System.out.println(toArray.length);
<!--日期与时间 ->
//javautilDate——日期/时间类 
	//after方法——测试当前日期是否在指定的日期之后 
		Date beforeDate = new Date(302672606563L);
		Date nowDate = new Date();
		boolean flag = nowDate.after(beforeDate);
		System.out.println(flag);
	//before方法——测试当前日期是否在指定的日期之前 
		Date beforeDate = new Date(302672606563L);
		Date nowDate = new Date();
		boolean flag = nowDate.before(beforeDate);
		System.out.println(flag);
	//getTime方法——获得毫秒数 
		Date date = new Date();
		long value = date.getTime();
		System.out.println(value);
	//setTime方法——设置当前Date对象所表示的日期/时间值 
		Date date = new Date();
		date.setTime(302676633308L);
		System.out.println(date);
//javautilLocale——语言环境相关类 
	//getAvailableLocales方法——获得所有已安装语言环境的数组 
		Locale[] locales = Locale.getAvailableLocales();
		for (int i = 0; i < locales.length; i++) {
			System.out.println(locales[i]);
		}
	//getCountry方法——获得当前语言环境的国家/地区代码 
		Locale[] locales = Locale.getAvailableLocales();
		for (int i = 0; i < locales.length; i++) {
			System.out.println(locales[i]+":"+locales[i].getCountry());
		}
	//getDefault方法——获得默认语言环境 
		Locale locale = Locale.getDefault();
		System.out.println(locale);
	//getDisplayCountry方法——获得语言环境国家/地区名 
		Locale locale = Locale.getDefault();
		String displayCountry = locale.getDisplayCountry();
		System.out.println(displayCountry);
	//getDisplayLanguage方法——获取语言环境的语言名 
		Locale locale = Locale.getDefault();
		String displayLanguage = locale.getDisplayLanguage();
		System.out.println(displayLanguage);
	//getDisplayName方法——获取语言环境名 
		Locale locale = Locale.getDefault();
		String displayName = locale.getDisplayName();
		System.out.println(displayName);
//javatextDateFormat——格式化时间类
	//getDateInstance方法——获取日期格式器 
		Date date = new Date();
		DateFormat df = DateFormat.getDateInstance();
		String formatDate = df.format(date);
		System.out.println(formatDate);
	//getDateTimeInstance方法——获取日期/时间格式器 
		Date date = new Date();
		DateFormat df = DateFormat.getDateTimeInstance();
		String formatDate = df.format(date);
		System.out.println(formatDate);
	//getInstance方法——获取默认日期/时间格式器 
		Date date = new Date();
		DateFormat df = DateFormat.getInstance();
		String formatDate = df.format(date);
		System.out.println(formatDate);
	//parse方法——将字符串类型的日期/时间解析为Date类型 
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String stringDate = "2011-3-14 9:6:20";
		Date date = df.parse(stringDate);
		System.out.println(date);
<!--文件处理 ->
//javaioFile——文件类 
	//File构造方法 
		File file = new File("c:/test.txt");
		File folder = new File("c:/test1");
	//canExecute方法——判断文件是否可以运行 
		File file = new File("c:/test.txt");
		System.out.println(file.canExecute());
	//canRead方法——判断文件是否可以读取 
		File file = new File("c:/test.txt");
		System.out.println(file.canRead());
	//canWrite方法——判断文件是否可以写入 
		File file = new File("c:/test.txt");
		System.out.println(file.canWrite());
	//compareTo方法——比较文件或文件夹名称的关系 
		File file = new File("c:/test.txt");
		File file1 = new File("c:/test1.txt");
		System.out.println(file.compareTo(file1));
	//createNewFile方法——创建空文件或者空文件夹 
		File file = new File("c:/test.txt");
		file.createNewFile();
	//createTempFile方法——创建临时文件 
		File tempFile = File.createTempFile("abc", null);
		System.out.println(tempFile);
	//delete方法——删除文件或者空文件夹 
		File tempFile = File.createTempFile("abc", null);
		tempFile.delete();
	//deleteOnExit方法——虚拟机正常终止时逆序删除文件 
		File tempFile = File.createTempFile("abc", null);
		tempFile.deleteOnExit();
	//equals方法——判断两个文件的路径名是否相同 
		File file = new File("c:/test.txt");
		File file1 = new File("c:/test.txt");
		System.out.println(file.equals(file1));
	//exists方法——测试文件或者文件夹是否存在 
		File file = new File("c:/test.txt");
		System.out.println(file.exists());
	//getAbsoluteFile方法——获得使用绝对路径创建的文件对象 
		File file = new File("c:/test.txt");
		System.out.println(file.getAbsoluteFile());
	//getAbsolutePath方法——获得表示文件绝对路径的字符串 
		File file = new File("c:/test.txt");
		System.out.println(file.getAbsolutePath());
	//getCanonicalFile方法——获得使用规范形式的文件路径创建的文件对象 
		File file = new File("c:/test.txt");
		System.out.println(file.getCanonicalFile());
	//getCanonicalPath方法——获得表示文件规范路径的字符串 
		File file = new File("c:/test.txt");
		System.out.println(file.getCanonicalPath());
	//getFreeSpace方法——获取指定的分区中未分配的字节数 
		File file = new File("c:");
		long freeSize = file.getFreeSpace();
		long gb = freeSize / 1000000000;
		long mb = (freeSize-gb*1000000000)/1000000;
		System.out.println(gb+"GB"+mb+"MB");
	//getName方法——获得文件或者文件夹的名称 
		File file = new File("c:/test.txt");
		System.out.println(file.getName());
	//getParent方法——获取父文件夹的路径名字符串 
		File file = new File("c:/test.txt");
		System.out.println(file.getParent());
	//getParentFile方法——获取父文件夹的抽象路径名 
		File file = new File("c:/test.txt");
		System.out.println(file.getParentFile());
	//getPath方法——获取文件路径 
		File file = new File("c:/test.txt");
		System.out.println(file.getPath());
	//getTotalSpace方法——获取路径名指定的分区大小 
		File file = new File("c:/test.txt");
		System.out.println(file.getTotalSpace());
	//getUsableSpace方法——获取分区上的可用字节数 
		File file = new File("c:/test.txt");
		System.out.println(file.getUsableSpace());
	//hashCode方法——获取路径名的哈希码 
		File file = new File("c:/test.txt");
		System.out.println(file.hashCode());
	//isAbsolute方法——判断路径名是否为绝对路径名 
		File file = new File("c:/test.txt");
		System.out.println(file.isAbsolute());
	//isDirectory方法——判断是否为文件夹 
		File file = new File("c:/test.txt");
		System.out.println(file.isDirectory());
	//isFile方法——判断是否是一个标准文件 
		File file = new File("c:/test.txt");
		System.out.println(file.isFile());
	//isHidden方法——判断是否是隐藏文件 
		File file = new File("c:/test.txt");
		System.out.println(file.isHidden());
	//lastModified方法——获取文件的最后修改时间 
		File file = new File("c:/test.txt");
		long time = file.lastModified();
		Date date = new Date(time);
		System.out.println(date);
	//length方法——获取文件的长度 
		File file = new File("c:/test.txt");
		System.out.println(file.length());
	//list方法——返回字符串数组 
		File root = new File("c:");
		String[] files = root.list();
		for (String string : files) {
			System.out.println(string);
		}
	//listFiles方法——获取路径名数组 
		File root = new File("c:");
		File[] files = root.listFiles(new FileFilter() {
			
			@Override
			public boolean accept(File pathname) {
				if(pathname.isHidden()){
					return true;
				}
				return false;
			}
		});
		for (File file : files) {
			System.out.println(file);
		}
	//listRoots方法——列出可用的文件系统根 
		File[] roots = File.listRoots();
		for (File file : roots) {
			System.out.println(file);
		}
	//mkdir方法——创建文件夹 
		File file = new File("c:/test");
		file.mkdir();
	//mkdirs方法——创建文件夹 
		File file = new File("c:/test/test");
		file.mkdirs();
	//renameTo方法——重新命名文件 
		File file = new File("c:/test");
		file.renameTo(new File("c:/test1"));
	//setExecutable方法——设置执行权限 
		File file = new File("c:/test.txt");
		file.setExecutable(false);
	//setLastModified方法——设置文件或者文件夹的最后修改时间 
		File file = new File("c:/test.txt");
		GregorianCalendar calendar = new GregorianCalendar(2000,0,1);
		Date date = calendar.getTime();
		file.setLastModified(date.getTime());
	//setReadable方法——设置读权限 
		File file = new File("c:/test.txt");
		file.setReadable(true,true);
	//setReadOnly方法——设置文件或文件夹为只读 
		File file = new File("c:/test.txt");
		file.setReadOnly();
	//setWritable方法——设置文件的可写属性 
		File file = new File("c:/test.txt");
		file.setWritable(true);
	//toString方法——返回路径名的字符串形式 
		File file = new File("c:/test.txt");
		System.out.println(file.toString());
	//toURI方法——获取文件的URI 
		File file = new File("c:/test.txt");
		System.out.println(file.toURI());
//javaioFileInputStream类——文件输入流
	//available方法——估计剩余的字节数 
		File file = new File("C:/test.txt");
		FileInputStream in = new FileInputStream(file);
		System.out.println(in.available());
	//close方法——关闭文件输入流 
		File file = new File("C:/test.txt");
		FileInputStream in = new FileInputStream(file);
		for (int i = 0; i < file.length(); i++) {
			System.out.println(in.read());
		}
		in.close();
	//getChannel方法——返回FileChannel对象 
		File file = new File("C:/test.txt");
		FileInputStream in = new FileInputStream(file);
		FileChannel channel = in.getChannel();
		in.close();
	//getFD方法——返回FileDescriptor对象 
		File file = new File("C:/test.txt");
		FileInputStream in = new FileInputStream(file);
		FileDescriptor fd = in.getFD();
		in.close();
	//read方法——从文件字节输入流中读取数据 
		File file = new File("C:/test.txt");
		FileInputStream in = new FileInputStream(file);
		int temp = 0;
		while((temp=in.read())!=-1){
			System.out.println(temp);
		}
		in.close();
	//skip方法——从输入流中跳过并丢弃n字节的数据 
		File file = new File("C:/test.txt");
		FileInputStream in = new FileInputStream(file);
		in.skip(10);
		int length = 0;
		while((length = in.read())!=-1){
			System.out.println(length);
		}
		in.close();
//javaioFileOutputStream类——文件输出流 
	//close方法——关闭文件输出流 
		File file = new File("C:/test.txt");
		FileOutputStream out = new FileOutputStream(file);
		out.write("JAVA参考手册".getBytes());
		out.close();
	//getChannel方法——返回FileChannel对象 
		File file = new File("C:/test.txt");
		FileOutputStream out = new FileOutputStream(file);
		FileChannel channel = out.getChannel();
		out.close();
	//getFD方法——返回FileDescriptor对象 
		File file = new File("C:/test.txt");
		FileOutputStream out = new FileOutputStream(file);
		out.getFD();
		out.close();
	//write方法——向文件中写入数据 
		File inputfile = new File("C:/test.txt");
		File outputfile = new File("C:/test1.txt");
		FileInputStream in = new FileInputStream(inputfile);
		FileOutputStream out = new FileOutputStream(outputfile);
		byte[] b = new byte[1024];
		in.read(b);
		out.write(b);
		out.close();
		in.close();
//javaioFileReader类——文件的字符输入流 
	//close方法——关闭字符输入流 
		File file = new File("C:/test.txt");
		FileReader reader = new FileReader(file);
		char[] data = new char[512];
		int rs = 0;
		while((rs = reader.read(data))>0){
			System.out.println(new String(data,0,rs));
		}
		reader.close();
	//read方法——读取字符数据 
		File file = new File("C:/test.txt");
		FileReader reader = new FileReader(file);
		char[] data = new char[512];
		int rs = 0;
		while((rs = reader.read(data))>0){
			System.out.println(new String(data,0,rs));
		}
		reader.close();
//javaioFileWriter类——文件的字符输出流 
	//close方法——关闭字符输出流 
		File file = new File("C:/test.txt");
		FileWriter writer = new FileWriter(file);
		writer.write("JAVA参考手册");
		writer.close();
	//flush方法——刷新缓冲区 
		File file = new File("C:/test.txt");
		String[] contents = {"JAVA","PHP","C"};
		FileWriter writer = new FileWriter(file);
		for (String string : contents) {
			writer.write(string);
		}
		writer.flush();
		writer.close();
	//write方法——向字符输出流写数据 
		File file = new File("C:/test.txt");
		FileWriter writer = new FileWriter(file);
		writer.write("JAVA".toCharArray());
		writer.flush();
		writer.close();
<!--图片处理 ->
//javaximageioImageIO——图像输入/输出类 
	//createImageInputStream方法——创建一个ImageInputStream对象 
		File file = new File("src/img.gif");
		ImageInputStream iis = ImageIO.createImageInputStream(file);
		JOptionPane.showMessageDialog(null, "创建成功");
		iis.close();
	//getImageReaders方法——获得包含ImageReader的迭代器对象 
		File file = new File("src/img.gif");
		ImageInputStream iis = ImageIO.createImageInputStream(file);
		Iterator<ImageReader> it = ImageIO.getImageReaders(file);
		if(it.hasNext()){
			JOptionPane.showMessageDialog(null, "成功");
		}else{
			JOptionPane.showMessageDialog(null, "失败");	
		}
		iis.close();
	//getImageReadersByMIMEType方法——获得可以解码MIME类型的迭代器 
		Iterator<ImageReader> it = ImageIO.getImageReadersByMIMEType("image/jpg");
		boolean isRead = it.hasNext();
		System.out.println(isRead);
	//getImageReadersBySuffix方法——获得可以解码指定文件后缀的迭代器 
		String suffix = "gif";
		Iterator<ImageReader> it = ImageIO.getImageReadersBySuffix(suffix);
		JOptionPane.showMessageDialog(null, "后缀"+ suffix + "解码成功");
	//getImageWritersByFormatName方法——获得可以解码指定格式的迭代器 
		String formatName = "jpeg";
		Iterator<ImageWriter> it = ImageIO.getImageWritersByFormatName(formatName);
		ImageWriter imageWriter = (ImageWriter)it.next();
		JOptionPane.showMessageDialog(null, "格式"+formatName+"解码成功");
	//read方法——读取数据到BufferedImage对象 
		//从指定文件对象读取数据获得一个BufferedImage对象
	//write方法——将图像以文件的形式写入磁盘 
		//用于将图像以文件的形式写入磁盘
//javaximageioImageReader——图像的字符输入流 
	//getFormatName方法——获得文件的格式名称 
		File file = new File("src/img.gif");
		ImageInputStream iis = ImageIO.createImageInputStream(file);
		Iterator<ImageReader> it = ImageIO.getImageReaders(iis);
		if(it.hasNext()){
			ImageReader reader = (ImageReader)it.next();
			System.out.println("格式"+reader.getFormatName());
		}
		iis.close();
	//getNumImages方法——获得当前输入源中可用的图像数 
		String fileName = "src/img.gif";
		FileInputStream fin = new FileInputStream(fileName);
		Iterator<ImageReader> readers = ImageIO.getImageReadersBySuffix("gif");
		ImageReader imageReader = readers.next();
		ImageInputStream iis = ImageIO.createImageInputStream(fin);
		imageReader.setInput(iis,false);
		int num = imageReader.getNumImages(true);
		JOptionPane.showMessageDialog(null, "当前输入源"+num+"有可用图像");
		iis.close();
		fin.close();
	//read方法——获得一个BufferedImage对象 
		String fileName = "src/img.gif";
		FileInputStream fin = new FileInputStream(fileName);
		Iterator<ImageReader> readers = ImageIO.getImageReadersBySuffix("gif");
		ImageReader imageReader = readers.next();
		ImageInputStream iis = ImageIO.createImageInputStream(fin);
		imageReader.setInput(iis,false);
		BufferedImage bufferedImage = imageReader.read(0);
		iis.close();
		fin.close();
	//setInput方法——设置ImageReader的输入源 
		String fileName = "src/img.gif";
		FileInputStream fin = new FileInputStream(fileName);
		Iterator<ImageReader> readers = ImageIO.getImageReadersBySuffix("gif");
		ImageReader imageReader = readers.next();
		ImageInputStream iis = ImageIO.createImageInputStream(fin);
		imageReader.setInput(iis,false);
		BufferedImage bufferedImage = imageReader.read(0);
		iis.close();
		fin.close();
//javaximageioImageWriter——图像输出流 
	//setOutput方法——设置输出目标 
		Iterator<ImageWriter> it = ImageIO.getImageWritersByFormatName("jpg");
		ImageWriter imageWriter = it.next();
		File file = new File("src/img.jpg");
		ImageOutputStream ios = ImageIO.createImageOutputStream(file);
		imageWriter.setOutput(ios);
		Object obj = imageWriter.getOutput();
		if(obj!=null){
			JOptionPane.showMessageDialog(null, "成功");
		}
	//write方法——将完整图像流添加到输出流中 
		BufferedImage image = new BufferedImage(200,200,BufferedImage.TYPE_INT_RGB);
		Graphics2D g2 = image.createGraphics();
		g2.setColor(Color.BLUE);
		g2.fillRect(20, 20, 90, 90);
		g2.setColor(Color.RED);
		g2.fillOval(95, 95, 90, 90);
		Iterator<ImageWriter> it = ImageIO.getImageWritersByFormatName("jpg");
		ImageWriter imageWriter = it.next();
		File file = new File("src/img.jpg");
		ImageOutputStream ios = ImageIO.createImageOutputStream(file);
		imageWriter.setOutput(ios);
		imageWriter.write(image);
		ios.close();
<!--窗体和桌面面板 ->
//javaxswingJFrame窗体 
	//JFrame构造方法 
		JFrame frame = new JFrame();
		frame.setBounds(400,320,300,200);
		frame.setVisible(true);
	//getContentPane方法——获得JFrame窗体的内容窗格 
		JFrame frame = new JFrame("使用getContentPane");
		Container c = frame.getContentPane();
		c.setLayout(new FlowLayout());
		JButton btn_1 = new JButton("按钮一");
		JButton btn_2 = new JButton("按钮二");
		c.add(btn_1);
		c.add(btn_2);
		frame.setBounds(400,320,300,200);
		frame.setVisible(true);
	//getDefaultCloseOperation方法——获得指示窗体关闭操作的整数 
		JFrame frame = new JFrame("窗体默认关闭操作");
		System.out.println("DO_NOTHING_ON_CLOSE的值 \t"+WindowConstants.DO_NOTHING_ON_CLOSE);
		System.out.println("HIDE_ON_CLOSE的值  \t"+WindowConstants.HIDE_ON_CLOSE);
		System.out.println("DISPOSE_ON_CLOSE的值\t"+WindowConstants.DISPOSE_ON_CLOSE);
		System.out.println("EXIT_ON_CLOSE的值  \t"+WindowConstants.EXIT_ON_CLOSE);
		System.out.println();
		System.out.println("默认关闭操作整数\t"+frame.getDefaultCloseOperation());
		frame.dispose();
	//getGlassPane方法——返回当前窗体的玻璃窗格对象 
		JFrame frame = new JFrame("在玻璃面板上添加控件");
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		JPanel glassPanel = new JPanel();
		glassPanel.setLayout(new FlowLayout());
		JButton btn_1 = new JButton("按钮一");
		JButton btn_2 = new JButton("按钮二");
		glassPanel.add(btn_1);
		glassPanel.add(btn_2);
		frame.setGlassPane(glassPanel);
		Component c = frame.getGlassPane();
		c.setVisible(true);
		frame.setBounds(400,320,300,200);
		frame.setVisible(true);
	//getGraphics方法——创建绘图上下文对象 
		JFrame frame = new JFrame("绘制文本和图形");
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,300,200);
		frame.setVisible(true);
		Thread.sleep(1000);
		Graphics g = frame.getGraphics();
		g.drawString("graphics对象绘制文本", 70, 70);
		g.drawOval(100, 100, 80, 80);
	//getRootPane方法——获得当前窗体的根窗格对象 
		JFrame frame = new JFrame("设置窗体的默认按钮");
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		JButton ok = new JButton("确定");
		JButton cancel = new JButton("退出");
		JPanel panel = new JPanel();
		panel.add(ok);
		panel.add(cancel);
		cancel.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				System.exit(0);
			}
		});
		JRootPane root = frame.getRootPane();
		root.setDefaultButton(cancel);
		Container content = frame.getContentPane();
		content.add(panel);
		frame.setBounds(400,320,300,220);
		frame.setVisible(true);
	//remove方法——从当前窗体中移除指定的控件 
		final JFrame frame = new JFrame("移除窗体上的指定控件");
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		JButton centerButton = new JButton("移除面板的设置按钮");
		JButton removeButton = new JButton("移除窗体上方的控件");
		final JPanel centerPanel = new JPanel();
		JPanel southPanel = new JPanel();
		centerPanel.add(centerButton);
		southPanel.add(removeButton);
		removeButton.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				frame.remove(centerPanel);
				frame.pack();
			}
		});
		Container content = frame.getContentPane();
		content.add(centerPanel);
		content.add(southPanel,BorderLayout.SOUTH);
		frame.setBounds(400,320,300,220);
		frame.setVisible(true);
	//setContentPane方法——将指定容器设置为当前窗体的内容窗格 
		final JFrame frame = new JFrame("指定船体的内容窗格");
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		JLabel label = new JLabel("内容");
		JTextField text = new JTextField(20);
		JButton btn_1 = new JButton("确定");
		JButton btn_2 = new JButton("取消");
		JPanel panel = new JPanel();
		panel.add(label);
		panel.add(text);
		panel.add(btn_1);
		panel.add(btn_2);
		frame.setContentPane(panel);
		frame.setBounds(400,320,300,220);
		frame.setVisible(true);
	//setDefaultCloseOperation方法——设置close事件默认执行的操作 
		JFrame frame = new JFrame("设置窗体默认的关闭方式");
		frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
		frame.setBounds(400,320,300,220);
		frame.setVisible(true);
	//setGlassPane方法——设置当前窗体的玻璃窗格 
		JPanel glassPanel = new JPanel();
		glassPanel.setLayout(new FlowLayout());
		JLabel label = new JLabel("设置窗体玻璃窗格");
		label.setFont(new Font("宋体", Font.BOLD, 26));
		JButton btn_1 = new JButton("测 试");
		JButton btn_2 = new JButton("退出");
		glassPanel.add(label);
		glassPanel.add(btn_1);
		glassPanel.add(btn_2);
		glassPanel.setVisible(true);
		glassPanel.setBounds(400, 320, 300, 200);
	//setJMenuBar方法——设置当前窗体的菜单栏 
		JFrame frame = new JFrame("设置窗体的菜单栏");
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		JMenuBar menubar = new JMenuBar();
		JMenu menu = new JMenu("系统");
		JMenuItem menuItem = new JMenuItem("退出");
		menu.add(menuItem);
		menubar.add(menu);
		frame.setJMenuBar(menubar);
		frame.setBounds(400,320,300,200);
		frame.setVisible(true);
	//setLayout方法——设置当前窗体的布局管理器 
		JFrame frame = new JFrame("使用setLayout方法");
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		Container c = frame.getContentPane();
		frame.setLayout(new FlowLayout());
		JButton btn_1 = new JButton("按钮一");
		JButton btn_2 = new JButton("按钮二");
		c.add(btn_1);
		c.add(btn_2);
		frame.setBounds(400,320,300,200);
		frame.setVisible(true);
//javaxswingJDialog对话框窗体 
	//JDialog构造方法——创建对话框窗体 
		JDialog dialog = new JDialog();
		dialog.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
		dialog.setBounds(400,320,300,200);
		dialog.setVisible(true);
	//getContentPane方法——获得JDialog对话框窗体的内容窗格 
		JDialog dialog = new JDialog();
		dialog.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
		Container c = dialog.getContentPane();
		c.setLayout(new FlowLayout());
		JButton btn_ok = new JButton("OK");
		JButton btn_canel = new JButton("Cancel");
		c.add(btn_ok);
		c.add(btn_canel);
		dialog.setBounds(400,320,300,200);
		dialog.setVisible(true);
	//getDefaultCloseOperation方法——获得发起close事件时执行的操作 
		JDialog dialog = new JDialog();
		System.out.println("DO_NOTHING_ON_CLOSE的值 \t"+WindowConstants.DO_NOTHING_ON_CLOSE);
		System.out.println("HIDE_ON_CLOSE的值 \t"+WindowConstants.HIDE_ON_CLOSE);
		System.out.println("DISPOSE_ON_CLOSE的值 \t"+WindowConstants.DISPOSE_ON_CLOSE);
		System.out.println();
		System.out.println("对话框默认关闭操作的整数 \t"+dialog.getDefaultCloseOperation());
		dialog.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
		System.out.println("对话框默认关闭操作的整数 \t"+dialog.getDefaultCloseOperation());
		dialog.setBounds(400,260,300,200);
		dialog.setVisible(true);
	//getGlassPane方法——返回当前对话框窗体的玻璃窗格对象 
		JDialog dialog = new JDialog();
		dialog.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
		URL url = javaTest.class.getResource("src/img.gif");
		ImageIcon icon = new ImageIcon(url);
		JLabel label_icon = new JLabel(icon);
		JPanel glassPanel = new JPanel();
		glassPanel.setLayout(new BorderLayout());
		glassPanel.add(label_icon);
		dialog.setGlassPane(glassPanel);
		Component c = dialog.getGlassPane();
		c.setVisible(true);
		JLabel label_finish = new JLabel("已完成");
		label_finish.setFont(new Font("宋体",Font.BOLD,50));
		dialog.getContentPane().add(label_finish);
		dialog.setBounds(400,320,300,200);
		dialog.setVisible(true);
		Thread.sleep(1000);
		c.setVisible(false);
	//getGraphics方法——创建一个绘图上下文对象 
		JDialog dialog = new JDialog();
		dialog.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
		dialog.setBounds(400,320,300,200);
		dialog.setVisible(true);
		Thread.sleep(1000);
		Graphics g = dialog.getGraphics();
		g.drawOval(40, 50, 80, 80);
		g.drawOval(110, 50, 80, 80);
		g.drawOval(180, 50, 80, 80);
		g.drawOval(80, 110, 80, 80);
		g.drawOval(150, 110, 80, 80);
	//remove方法——从当前对话框窗体中移除指定的控件 
		final JDialog dialog = new JDialog();
		dialog.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
		final JButton centerButton = new JButton("将要被移除放到对话框中心的按钮");
		JButton southButton = new JButton("单击我可以移除对话框中心的按钮");
		southButton.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				dialog.remove(centerButton);
				dialog.repaint();
			}
		});
		Container c = dialog.getContentPane();
		c.add(centerButton,BorderLayout.CENTER);
		c.add(southButton,BorderLayout.SOUTH);
		dialog.setBounds(400,320,300,220);
		dialog.setVisible(true);
		dialog.setBounds(400,320,300,200);
		dialog.setVisible(true);
	//setContentPane方法——将指定容器设置为当前窗体的内容窗格 
		final JDialog dialog = new JDialog();
		dialog.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
		final JButton centerButton = new JButton("将要被移除放到对话框中心的按钮");
		JButton southButton = new JButton("单击我可以移除对话框中心的按钮");
		southButton.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				dialog.remove(centerButton);
				dialog.repaint();
			}
		});
		Container c = dialog.getContentPane();
		c.add(centerButton,BorderLayout.CENTER);
		c.add(southButton,BorderLayout.SOUTH);
		dialog.setBounds(400,320,300,220);
		dialog.setVisible(true);
		dialog.setBounds(400,320,300,200);
		dialog.setVisible(true);
	//setDefaultCloseOperation方法——设置发起close事件时默认执行的操作 
		final JDialog dialog = new JDialog();
		dialog.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
		dialog.addWindowListener(new WindowAdapter() {
			@Override
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
		dialog.getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER,10,30));
		dialog.getContentPane().add(new JButton("确定"));
		dialog.getContentPane().add(new JButton("退出"));
		dialog.setBounds(400,320,300,220);
		dialog.setVisible(true);
		dialog.setBounds(400,320,300,200);
		dialog.setVisible(true);
	//setGlassPane方法——设置当前对话框窗体的玻璃窗格 
		//设置当前对话框的玻璃窗格
	//setJMenuBar方法——设置当前对话框窗体的菜单栏 
		//设置当前对话框窗体的菜单栏
//javaxswingJDesktopPane桌面面板 
	//JDesktopPane构造方法 
		//创建桌面面板对象，对象是内部窗体的容器
	//getAllFrames方法——返回桌面中显示的所有JInternalFrame 
		//以数组的形式返回桌面中当前显示的所有JInternalFrame
	//getSelectedFrame方法——获得当前被选择的内部窗体 
		//用于获得桌面面板中当前活动的JInternalFrame，当前被选中的内部窗体
	//remove方法——移除指定的JInternalFrame 
		//用于从桌面面板中移除位于指定索引位置处的JInternalFrame
	//removeAll方法——移除所有的JInternalFrame 
		//用于从桌面面板中移除所有的JInternalFrame
	//selectFrame方法——选择下一个JInternalFrame 
		//用于选择此桌面面板中的下一个JInternalFrame
	//setSelectedFrame方法——设置当前活动的JInternalFrame 
		//用于设置桌面面板当前获得JInternalFrame
 //javaxswingJInternalFrame内部窗体 
	//JInternalFrame构造方法 
		//用于创建内部窗体，该窗体不能移除其所在桌面面板
	//dispose方法——关闭内部窗体 
		//用于是内部窗体不可见、取消选定并关闭该内部窗体
	//getContentPane方法——获得JInternalFrame窗体的内容窗格 
		//用于获得JInternalFrame窗体的内容窗格
	//getFrameIcon方法——获取JInternalFrame标题栏上显示的图标 
		//用于获取JInternalFrame标题栏上显示的图标
	//getTitle方法——获得内部窗体标题栏上显示的文本 
		//用于获得内部窗体标题了上显示的文本
	//setClosable方法——设置是否可以关闭内部窗体 
		//用于设置是否可以通过某个操作关闭内部的窗体
	//setFrameIcon方法——设置窗体标题栏上显示的图像 
		//用于设置要在此内部窗体标题栏上显示的图像
	//setIconifiable方法——设置是否可以使内部窗体图标化 
		//用于设置是否可以通过某个操作使内部窗体图标化
	//setMaximizable方法——设置是否可以使内部窗体最大化 
		//设置是否可以使内部窗体最大化
	//setResizable方法——设置是否可以改变内部窗体的大小 
		//用于设置是否可以通过某个操作改变内部窗体的大小
	//setSelected方法——选定或取消选定内部窗体 
		//用于选定或取消选定内部窗体
	//setTitle方法——设置内部窗体标题栏上显示的文本 
		//用于设置内部窗体标题栏上显示的文本
	//toBack方法——将内部窗体发送到后台 
		//用于将内部窗体发送到后台
	//toFront方法——将内部窗体置于前端 
		//用于将内部窗体发送到后台
<!--常用面板 ->
//javaxswingJPanel面板 
	//JPanel构造方法 
		JFrame frame = new JFrame("使用JPanel面板");
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		JPanel panel = new JPanel();
		panel.setBackground(Color.ORANGE);
		frame.getContentPane().add(panel);
		frame.setBounds(400,320,300,200);
		frame.setVisible(true);
	//add方法——在面板容器中添加控件 
		JPanel panel = new JPanel();
		panel.add(new JLabel("编号："));
		JTextField tf_id = new JTextField(15);
		panel.add(tf_id);
		panel.add(new JLabel("姓名:"));
		JTextField tf_name = new JTextField(15);
		panel.add(tf_name);
		JButton btn_exit = new JButton("退  出");
		panel.add(btn_exit);
		JFrame frame = new JFrame("使用JPanel面板");
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.getContentPane().add(panel);
		frame.setBounds(400,320,300,200);
		frame.setVisible(true);
	//paintComponent方法——在面板容器中绘制内容 
		public static void main(String[] args) throws Throwable {
		JFrame frame = new JFrame("在面板上绘制");
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JPanel panel = new PanelBack();
		frame.getContentPane().add(panel);
		frame.setVisible(true);
		}
		static class PanelBack extends JPanel{
			protected void paintComponet(Graphics g){
				g.setFont(new Font("宋体",Font.BOLD,26));
				g.drawString("重写方法", 20, 70);
				g.drawString("面板绘制文本内容", 20, 120);
			}
		}
	//setLayout方法——设置面板容器所使用的布局管理器 
		//设置布局管理器
//javaxswingJScrollPane滚动面板 
	//JScrollPane构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JScrollPane scrollPane = new JScrollPane();
		JTextArea ta = new JTextArea();
		scrollPane.setViewportView(ta);
		frame.getContentPane().add(scrollPane);
		frame.setVisible(true);
	//setViewportView方法——设置滚动面板上显示的视图控件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JScrollPane scrollPane = new JScrollPane();
		JTextArea ta = new JTextArea();
		scrollPane.setViewportView(ta);
		frame.getContentPane().add(scrollPane);
		frame.setVisible(true);
//javaxswingJSplitPane分割面板 
	//JSplitPane构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JSplitPane splitPane = new JSplitPane();
		frame.getContentPane().add(splitPane);
		frame.setVisible(true);
	//setBottomComponent方法——将组件设置到分隔条的下方或右侧 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
		splitPane.setDividerLocation(60);
		splitPane.setBottomComponent(new JButton("下方的按钮"));
		frame.getContentPane().add(splitPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//setContinuousLayout方法——设置分割面板的重绘方式 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JSplitPane splitPane = new JSplitPane();
		splitPane.setContinuousLayout(true);
		frame.getContentPane().add(splitPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//setDividerLocation方法——设置分隔条的绝对位置 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JSplitPane splitPane = new JSplitPane();
		splitPane.setDividerLocation(120);
		frame.getContentPane().add(splitPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//setDividerSize方法——设置分隔条的大小 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JSplitPane splitPane = new JSplitPane();
		splitPane.setDividerLocation(120);
		splitPane.setDividerSize(25);
		frame.getContentPane().add(splitPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//setLeftComponent方法——将组件添加到分隔条的左侧或上方 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JSplitPane splitPane = new JSplitPane();
		splitPane.setDividerLocation(120);
		splitPane.setLeftComponent(new JButton("左侧的按钮"));
		frame.getContentPane().add(splitPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//setOneTouchExpandable方法——设置分割面板是否提供UI小部件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JSplitPane splitPane = new JSplitPane();
		splitPane.setDividerLocation(90);
		splitPane.setLeftComponent(new JButton("左侧的按钮"));
		splitPane.setBottomComponent(new JButton("右侧的按钮"));
		splitPane.setOneTouchExpandable(true);
		frame.getContentPane().add(splitPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//setOrientation方法——设置分割面板的分割方向 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JSplitPane splitPane = new JSplitPane();
		splitPane.setOrientation(JSplitPane.VERTICAL_SPLIT);
		splitPane.setDividerLocation(90);
		splitPane.setLeftComponent(new JButton("上方的按钮"));
		splitPane.setBottomComponent(new JButton("下方的按钮"));
		splitPane.setOneTouchExpandable(true);
		frame.getContentPane().add(splitPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//setRightComponent方法——将组件添加到分隔条的右侧或下方 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JSplitPane splitPane = new JSplitPane();
		splitPane.setOrientation(JSplitPane.VERTICAL_SPLIT);
		splitPane.setDividerLocation(100);
		splitPane.setRightComponent(new JButton("右侧按钮"));
		splitPane.setOneTouchExpandable(true);
		frame.getContentPane().add(splitPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//setTopComponent方法——将组件添加到分隔条的上方或左侧 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JSplitPane splitPane = new JSplitPane();
		splitPane.setOrientation(JSplitPane.VERTICAL_SPLIT);
		splitPane.setDividerLocation(100);
		splitPane.setTopComponent(new JButton("上方的按钮"));
		frame.getContentPane().add(splitPane,BorderLayout.CENTER);
		frame.setVisible(true);
//javaxswingJTabbedPane选项卡面板 
	//JTabbedPane构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JTabbedPane tabbedPane = new JTabbedPane();
		JPanel panel = new JPanel();
		panel.setLayout(null);
		tabbedPane.addTab("标签一", null,panel,null);
		JButton button = new JButton();
		button.setBounds(77,51,155,28);
		button.setText("标签一中的按钮");
		panel.add(button);
		frame.getContentPane().add(tabbedPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//addChangeListener方法——将ChangeListener添加到选项卡面板中 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JTabbedPane tabbedPane = new JTabbedPane();
		tabbedPane.addChangeListener(new ChangeListener() {
			@Override
			public void stateChanged(ChangeEvent e) {
				if(true){
					int index = tabbedPane.getSelectedIndex();
					String title = tabbedPane.getTitleAt(index);
					JOptionPane.showMessageDialog(null, title);
				}
			}
		});
		frame.getContentPane().add(tabbedPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//addTab方法——为选项卡面板添加选项卡 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JTabbedPane tabbedPane = new JTabbedPane();
		JPanel panel = new JPanel();
		JPanel panel1 = new JPanel();
		tabbedPane.addTab("第一", panel);
		tabbedPane.addTab("第二", panel1);
		frame.getContentPane().add(tabbedPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//getSelectedIndex方法——返回选择的选项卡标签索引 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JTabbedPane tabbedPane = new JTabbedPane();
		JButton btn_showIndex = new JButton();
		btn_showIndex.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				int index = tabbedPane.getSelectedIndex();
				JOptionPane.showMessageDialog(null, "索引值"+index);
			}
		});
		btn_showIndex.setText("显示索引值");
		frame.getContentPane().add(tabbedPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//getTabCount方法——获得选项卡面板拥有选项卡的数量 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JTabbedPane tabbedPane = new JTabbedPane();
		JButton btn_showNum = new JButton();
		btn_showNum.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				int count = tabbedPane.getTabCount();
				JOptionPane.showMessageDialog(null, "选项卡面板共有"+count);
			}
		});
		btn_showNum.setText("选项卡数量");
		tabbedPane.add(btn_showNum);
		frame.getContentPane().add(tabbedPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//getTitleAt方法——获得选项卡标签的标题文本 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JTabbedPane tabbedPane = new JTabbedPane();
		JButton btn_showTitle = new JButton();
		btn_showTitle.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				int count = tabbedPane.getTabCount();
				JOptionPane.showMessageDialog(null, "共有"+count+"个");
			}
		});
		btn_showTitle.setText("选项卡数量");
		tabbedPane.add(btn_showTitle);
		frame.getContentPane().add(tabbedPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//insertTab方法——在指定索引位置处插入选项卡标签 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JTabbedPane tabbedPane = new JTabbedPane();
		JButton btn_insertTitle = new JButton();
		btn_insertTitle.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				tabbedPane.insertTab("aaa", null, new JButton("测试"), "测试", 1);
			}
		});
		btn_insertTitle.setText("插入选项卡标签");
		tabbedPane.add(btn_insertTitle);
		frame.getContentPane().add(tabbedPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//setDisabledIconAt方法——设置选项卡标签禁用时显示的图标 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JTabbedPane tabbedPane = new JTabbedPane();
		JPanel panel = new JPanel();
		tabbedPane.addTab("A", panel);
		frame.getContentPane().add(tabbedPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//setEnabledAt方法——设置指定选项卡标签是否可用 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JTabbedPane tabbedPane = new JTabbedPane();
		JButton btn_enabled = new JButton();
		btn_enabled.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				tabbedPane.setEnabledAt(0, true);
			}
		});
		btn_enabled.setText("启用A");
		tabbedPane.add(btn_enabled);
		frame.getContentPane().add(tabbedPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//setSelectedIndex方法——使指定的选项卡标签被选中 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JTabbedPane tabbedPane = new JTabbedPane();
		JPanel panel = new JPanel();
		tabbedPane.addTab("选项卡A", panel);
		JPanel panel_1 = new JPanel();
		tabbedPane.addTab("选项卡B", panel_1);
		tabbedPane.setSelectedIndex(1);
		frame.getContentPane().add(tabbedPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//setTabLayoutPolicy方法——设置选项卡标签的布局方式 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JTabbedPane tabbedPane = new JTabbedPane();
		JButton btn_wrap = new JButton();
		btn_wrap.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				tabbedPane.setTabLayoutPolicy(JTabbedPane.WRAP_TAB_LAYOUT);
			}
		});
		btn_wrap.setText("限制布局");
		tabbedPane.add(btn_wrap);
		frame.getContentPane().add(tabbedPane,BorderLayout.CENTER);
		frame.setVisible(true);
	//setTabPlacement方法——设置选项卡标签的显示位置 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JTabbedPane tabbedPane = new JTabbedPane();
		JButton btn_top = new JButton();
		btn_top.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				tabbedPane.setTabPlacement(JTabbedPane.TOP);
			}
		});
		btn_top.setText("上方");
		tabbedPane.add(btn_top);
		frame.getContentPane().add(tabbedPane,BorderLayout.CENTER);
		frame.setVisible(true);
<!--基本布局管理器 ->
//javaawtFlowLayout流布局 
	//FlowLayout构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		frame.getContentPane().setLayout(new FlowLayout());
		frame.getContentPane().add(new JButton("按钮A"));
		frame.getContentPane().add(new JButton("按钮B"));
		frame.getContentPane().add(new JButton("按钮C"));
		frame.getContentPane().add(new JButton("按钮D"));
		frame.setVisible(true);
	//setAlignment方法——设置流布局管理器使用的对齐方式 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		FlowLayout flowLayout = new FlowLayout();
		flowLayout.setAlignment(FlowLayout.LEFT);
		frame.getContentPane().setLayout(flowLayout);
		frame.getContentPane().add(new JButton("按钮A"));
		frame.getContentPane().add(new JButton("按钮B"));
		frame.getContentPane().add(new JButton("按钮C"));
		frame.getContentPane().add(new JButton("按钮D"));
		frame.setVisible(true);
	//setHgap方法——设置水平间隙 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		FlowLayout flowLayout = new FlowLayout();
		flowLayout.setHgap(25);
		frame.getContentPane().setLayout(flowLayout);
		frame.getContentPane().add(new JButton("按钮A"));
		frame.getContentPane().add(new JButton("按钮B"));
		frame.getContentPane().add(new JButton("按钮C"));
		frame.getContentPane().add(new JButton("按钮D"));
		frame.setVisible(true);
	//setVgap方法——设置垂直间隙 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		FlowLayout flowLayout = new FlowLayout();
		flowLayout.setVgap(20);
		frame.getContentPane().setLayout(flowLayout);
		frame.getContentPane().add(new JButton("按钮A"));
		frame.getContentPane().add(new JButton("按钮B"));
		frame.getContentPane().add(new JButton("按钮C"));
		frame.getContentPane().add(new JButton("按钮D"));
		frame.setVisible(true);
//javaawtBorderLayout边界布局 
	//BorderLayout构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JPanel panel = new JPanel();
		panel.setLayout(new BorderLayout());
		frame.getContentPane().add(panel,BorderLayout.CENTER);
		JButton button = new JButton("中");
		panel.add(button,BorderLayout.CENTER);
		JButton button1 = new JButton("北");
		panel.add(button1,BorderLayout.NORTH);
		JButton button2 = new JButton("西");
		panel.add(button2,BorderLayout.WEST);
		JButton button3 = new JButton("南");
		panel.add(button3,BorderLayout.SOUTH);
		JButton button4 = new JButton("东");
		panel.add(button4,BorderLayout.EAST);
		frame.setVisible(true);
	//setHgap方法——设置水平间距 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JPanel panel = new JPanel();
		BorderLayout borderLayout = new BorderLayout();
		panel.setLayout(borderLayout);
		borderLayout.setHgap(20);
		frame.getContentPane().add(panel,BorderLayout.CENTER);
		JButton button = new JButton("中");
		panel.add(button,BorderLayout.CENTER);
		JButton button1 = new JButton("北");
		panel.add(button1,BorderLayout.NORTH);
		JButton button2 = new JButton("西");
		panel.add(button2,BorderLayout.WEST);
		JButton button3 = new JButton("南");
		panel.add(button3,BorderLayout.SOUTH);
		JButton button4 = new JButton("东");
		panel.add(button4,BorderLayout.EAST);
		frame.setVisible(true);
	//setVgap方法——设置垂直间距 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JPanel panel = new JPanel();
		BorderLayout borderLayout = new BorderLayout();
		panel.setLayout(borderLayout);
		borderLayout.setVgap(15);
		frame.getContentPane().add(panel,BorderLayout.CENTER);
		JButton button = new JButton("中");
		panel.add(button,BorderLayout.CENTER);
		JButton button1 = new JButton("北");
		panel.add(button1,BorderLayout.NORTH);
		JButton button2 = new JButton("西");
		panel.add(button2,BorderLayout.WEST);
		JButton button3 = new JButton("南");
		panel.add(button3,BorderLayout.SOUTH);
		JButton button4 = new JButton("东");
		panel.add(button4,BorderLayout.EAST);
		frame.setVisible(true);
//javaawtGridLayout网格布局 
	//GridLayout构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		GridLayout gridLayout = new GridLayout(2, 3);
		frame.getContentPane().setLayout(gridLayout);
		JButton button = new JButton("1");
		frame.getContentPane().add(button);
		JButton button1 = new JButton("2");
		frame.getContentPane().add(button1);
		JButton button2 = new JButton("3");
		frame.getContentPane().add(button2);
		JButton button3 = new JButton("4");
		frame.getContentPane().add(button3);
		JButton button4 = new JButton("5");
		frame.getContentPane().add(button4);
		frame.setVisible(true);
	//setColumns方法——设置网格布局管理器的网格列数 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		GridLayout gridLayout = new GridLayout(0, 4);
		gridLayout.setColumns(2);
		frame.getContentPane().setLayout(gridLayout);
		JButton button = new JButton("1");
		frame.getContentPane().add(button);
		JButton button1 = new JButton("2");
		frame.getContentPane().add(button1);
		JButton button2 = new JButton("3");
		frame.getContentPane().add(button2);
		JButton button3 = new JButton("4");
		frame.getContentPane().add(button3);
		JButton button4 = new JButton("5");
		frame.getContentPane().add(button4);
		frame.setVisible(true);
	//setHgap方法——设置水平间距 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		GridLayout gridLayout = new GridLayout(0, 4);
		gridLayout.setHgap(10);
		frame.getContentPane().setLayout(gridLayout);
		JButton button = new JButton("1");
		frame.getContentPane().add(button);
		JButton button1 = new JButton("2");
		frame.getContentPane().add(button1);
		JButton button2 = new JButton("3");
		frame.getContentPane().add(button2);
		JButton button3 = new JButton("4");
		frame.getContentPane().add(button3);
		JButton button4 = new JButton("5");
		frame.getContentPane().add(button4);
		frame.setVisible(true);
	//setRows方法——设置网格布局管理器的网格行数 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		GridLayout gridLayout = new GridLayout(0, 4);
		gridLayout.setRows(2);
		frame.getContentPane().setLayout(gridLayout);
		JButton button = new JButton("1");
		frame.getContentPane().add(button);
		JButton button1 = new JButton("2");
		frame.getContentPane().add(button1);
		JButton button2 = new JButton("3");
		frame.getContentPane().add(button2);
		JButton button3 = new JButton("4");
		frame.getContentPane().add(button3);
		JButton button4 = new JButton("5");
		frame.getContentPane().add(button4);
		frame.setVisible(true);
	//setVgap方法——设置垂直间距 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		GridLayout gridLayout = new GridLayout(0, 4);
		gridLayout.setVgap(20);
		frame.getContentPane().setLayout(gridLayout);
		JButton button = new JButton("1");
		frame.getContentPane().add(button);
		JButton button1 = new JButton("2");
		frame.getContentPane().add(button1);
		JButton button2 = new JButton("3");
		frame.getContentPane().add(button2);
		JButton button3 = new JButton("4");
		frame.getContentPane().add(button3);
		JButton button4 = new JButton("5");
		frame.getContentPane().add(button4);
		frame.setVisible(true);
//javaawtCardLayout卡片布局 
	//CardLayout构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		CardLayout cardLayout = new CardLayout(10,15);
		frame.getContentPane().setLayout(cardLayout);
		frame.getContentPane().add("one",new JButton("第一个"));
		frame.getContentPane().add("two",new JButton("第二个"));
		frame.setVisible(true);
	//first方法——显示容器中的第一张卡片 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final CardLayout cardLayout = new CardLayout(10,15);
		frame.getContentPane().setLayout(cardLayout);
		final JPanel cardPanel = new JPanel();
		JButton button = new JButton();
		button.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				cardLayout.first(cardPanel);
			}
		});
		cardPanel.add(button);
		button.setText("第一张");
		frame.setVisible(true);
	//last方法——显示容器中的最后一张卡片 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final CardLayout cardLayout = new CardLayout(10,15);
		frame.getContentPane().setLayout(cardLayout);
		final JPanel cardPanel = new JPanel();
		JButton button = new JButton();
		button.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				cardLayout.last(cardPanel);
			}
		});
		cardPanel.add(button);
		button.setText("第一张");
		frame.setVisible(true);
	//next方法——显示容器中当前卡片的下一张卡片 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final CardLayout cardLayout = new CardLayout(10,15);
		frame.getContentPane().setLayout(cardLayout);
		final JPanel cardPanel = new JPanel();
		JButton button = new JButton();
		button.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				cardLayout.next(cardPanel);
			}
		});
		cardPanel.add(button);
		button.setText("第一张");
		frame.setVisible(true);
	//previous方法——显示容器中当前卡片的前一张卡片 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final CardLayout cardLayout = new CardLayout(10,15);
		frame.getContentPane().setLayout(cardLayout);
		final JPanel cardPanel = new JPanel();
		JButton button = new JButton();
		button.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				cardLayout.previous(cardPanel);
			}
		});
		cardPanel.add(button);
		button.setText("第一张");
		frame.setVisible(true);
	//show方法——显示容器中用户指定的卡片 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final CardLayout cardLayout = new CardLayout(10,15);
		frame.getContentPane().setLayout(cardLayout);
		final JPanel cardPanel = new JPanel();
		JButton button = new JButton();
		button.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				cardLayout.show(cardPanel,"test");
			}
		});
		cardPanel.add(button);
		button.setText("第一张");
		frame.setVisible(true);
<!--文本输入控件 ->
//javaxswingJLabel类 
	//JLabel构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JLabel label = new JLabel("aa");
		frame.getContentPane().add(label);
		frame.setVisible(true);
	//setFont方法——设置标签上文本的字体 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JLabel label = new JLabel("aa");
		label.setFont(new Font("微软雅黑",Font.BOLD,20));
		frame.getContentPane().add(label);
		frame.setVisible(true);
	//setHorizontalTextPosition方法——设置标签中文本相对于图标的水平位置 
		ImageIcon icon = new ImageIcon("src/1.jpg");
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JLabel label = new JLabel("aa");
		label.setIcon(icon);
		label.setHorizontalTextPosition(SwingConstants.RIGHT);
		frame.getContentPane().add(label);
		frame.setVisible(true);
	//setText方法——设置标签上显示的文本信息 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JLabel label = new JLabel();
		label.setText("Left");
		frame.getContentPane().add(label);
		frame.setVisible(true);
	//setVerticalTextPosition方法——设置文本相对于图标的垂直位置 
		ImageIcon icon = new ImageIcon("src/1.jpg");
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JLabel label = new JLabel();
		label.setIcon(icon);
		label.setText("aa");
		label.setVerticalTextPosition(SwingConstants.BOTTOM);
		label.setHorizontalTextPosition(SwingConstants.CENTER);
		frame.getContentPane().add(label);
		frame.setVisible(true);
//javaxswingJTextField类 
	//JTextField构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JTextField textField = new JTextField("科技");
		frame.getContentPane().add(textField);
		frame.setVisible(true);
	//addActionListener方法——响应用户在文本域中按Enter键时的操作 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JTextField textField = new JTextField();
		textField.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				textField.getText();
			}
		});
		frame.getContentPane().add(textField);
		frame.setVisible(true);
	//addFocusListener方法——响应文本域焦点事件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JTextField textField = new JTextField();
		textField.addFocusListener(new FocusAdapter() {
			@Override
			public void focusGained(FocusEvent e) {
				textField.setText("文本焦点");
			}
		});
		frame.getContentPane().add(textField);
		frame.setVisible(true);
	//getText方法——获得文本域中输入的文本 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JTextField textField = new JTextField();
		textField.getText();
		frame.getContentPane().add(textField);
		frame.setVisible(true);
	//setColumns方法——设置文本框的列数 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JTextField textField = new JTextField();
		textField.setColumns(10);
		frame.getContentPane().add(textField);
		frame.setVisible(true);
	//setFont方法——设置文本域中的字体 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JTextField textField = new JTextField();
		textField.setFont(new Font("微软雅黑",Font.BOLD,15));
		frame.getContentPane().add(textField);
		frame.setVisible(true);
//javaxswingJPasswordField类 
	//JPasswordField构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JPasswordField passwordField = new JPasswordField(10);
		frame.getContentPane().add(passwordField);
		frame.setVisible(true);
	//addActionListener方法——响应在密码域中按Enter键时的操作 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JPasswordField passwordField = new JPasswordField(10);
		passwordField.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				passwordField.setText(new String(passwordField.getPassword()));
			}
		});
		frame.getContentPane().add(passwordField);
		frame.setVisible(true);
	//getPassword方法——获得输入的密码 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JPasswordField passwordField = new JPasswordField(10);
		passwordField.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				passwordField.getPassword();
			}
		});
		frame.getContentPane().add(passwordField);
		frame.setVisible(true);
	//setEchoChar方法——修改密码域的回显字符 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final JPasswordField passwordField = new JPasswordField(10);
		passwordField.setEchoChar('&');
		frame.getContentPane().add(passwordField);
		frame.setVisible(true);
//javaxswingJTextArea类 
	//JTextArea构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JTextArea textArea = new JTextArea(5,10);
		frame.getContentPane().add(textArea);
		frame.setVisible(true);
	//addCaretListener方法——监听光标位置在文本区中的变化事件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final Label label = new Label();
		final JTextArea textArea = new JTextArea(5,10);
		textArea.addCaretListener(new CaretListener() {
			@Override
			public void caretUpdate(CaretEvent e) {
				label.setText(""+e.getDot());
			}
		});
		frame.getContentPane().add(textArea);
		frame.setVisible(true);
	//append方法——在文本区中文本末尾增加字符串 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final TextArea textArea = new TextArea();
		JButton button = new JButton("单击按钮");
		button.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				textArea.append("单击一次按钮");
			}
		});
		frame.getContentPane().add(textArea);
		frame.setVisible(true);
	//getText方法——获得文本区中输入的内容 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final TextArea textArea = new TextArea();
		JButton button = new JButton();
		button.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				textArea.getText();
			}
		});
		frame.getContentPane().add(textArea);
		frame.setVisible(true);
	//setFont方法——设置文本区字体 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		final TextArea textArea = new TextArea();
		textArea.setFont(new Font("微软雅黑",Font.BOLD,15));
		frame.getContentPane().add(textArea);
		frame.setVisible(true);
	//setLineWrap方法——设置是否自动换行 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JTextArea textArea = new JTextArea();
		textArea.setLineWrap(true);
		frame.getContentPane().add(textArea);
		frame.setVisible(true);
<!--选择控件 ->
//javaxswingJButton类 
	//JButton构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		JButton button = new JButton("这是一个按钮");
		frame.getContentPane().add(button);
		frame.setVisible(true);
	//addActionListener方法——向按钮控件增加动作事件监听器 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JButton button = new JButton("这是一个按钮");
		final Label label = new Label();
		button.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				label.setText("用户单击");
			}
		});
		frame.getContentPane().add(label);
		frame.getContentPane().add(button);
		frame.setVisible(true);
	//setActionCommand方法——设置按钮的动作命令 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JButton button = new JButton("单击按钮");
		final JLabel label = new JLabel();
		button.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				label.setText("单击");
			}
		});
		button.setActionCommand("alter");
		frame.getContentPane().add(label);
		frame.getContentPane().add(button);
		frame.setVisible(true);
	//setEnabled方法——设置按钮是否可用 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JButton button = new JButton("按钮");
		button.setEnabled(false);
		frame.getContentPane().add(button);
		frame.setVisible(true);
	//setHorizontalTextPosition方法——设置文本相对于图标的水平位置 
		ImageIcon icon = new ImageIcon("src/1.jpg");
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JButton button = new JButton("按钮",icon);
		button.setHorizontalTextPosition(SwingConstants.LEFT);
		frame.getContentPane().add(button);
		frame.setVisible(true);
	//setMnemonic方法——为按钮添加助记符 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JButton button = new JButton("按钮");
		button.setMnemonic(KeyEvent.VK_0);
		frame.getContentPane().add(button);
		frame.setVisible(true);
	//setVerticalTextPosition方法——设置文本相对于图标的垂直位置 
		ImageIcon icon = new ImageIcon("src/1.jpg");
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JButton button = new JButton("按钮",icon);
		button.setVerticalTextPosition(SwingConstants.TOP);
		frame.getContentPane().add(button);
		frame.setVisible(true);
	//isDefaultButton方法——判断是否为默认按钮 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JButton button = new JButton("按钮");
		frame.getRootPane().setDefaultButton(button);
		System.out.println(button.isDefaultButton());
		frame.getContentPane().add(button);
		frame.setVisible(true);
//javaxswingJCheckBox类 
	//JCheckBox构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JCheckBox checkBox = new JCheckBox("复选框");
		frame.getContentPane().add(checkBox);
		frame.setVisible(true);
	//addActionListener方法——向复选框控件增加动作事件监听器 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		final Label label = new Label();
		JCheckBox checkBox = new JCheckBox("复选框");
		checkBox.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				label.setText("这是一个复选框");
			}
		});
		frame.getContentPane().add(label);
		frame.getContentPane().add(checkBox);
		frame.setVisible(true);
	//addItemListener方法——为复选框增加选择状态变化事件监听 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		final Label label = new Label();
		JCheckBox checkBox = new JCheckBox("复选框");
		checkBox.addItemListener(new ItemListener() {
			@Override
			public void itemStateChanged(ItemEvent e) {
				label.setText("复选框已选择");
			}
		});
		frame.getContentPane().add(label);
		frame.getContentPane().add(checkBox);
		frame.setVisible(true);
	//isSelected方法——判断复选框是否被用户选择 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		final Label label = new Label();
		JCheckBox checkBox = new JCheckBox("复选框");
		label.setText(""+checkBox.isSelected());
		frame.getContentPane().add(label);
		frame.getContentPane().add(checkBox);
		frame.setVisible(true);
	//setSelected方法——将复选框设置成选择状态 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JCheckBox checkBox = new JCheckBox("复选框");
		checkBox.setSelected(true);
		frame.getContentPane().add(checkBox);
		frame.setVisible(true);
//javaxswingJRadioButton类 
	//JRadioButton构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JRadioButton radioButton = new JRadioButton("单选");
		frame.getContentPane().add(radioButton);
		frame.setVisible(true);
	//addActionListener方法——向单选按钮控件增加动作事件监听器 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		final JLabel label = new JLabel();
		JRadioButton radioButton = new JRadioButton("单选");
		radioButton.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				label.setText("选择");
			}
		});
		frame.getContentPane().add(label);
		frame.getContentPane().add(radioButton);
		frame.setVisible(true);
	//isSelected方法——判断单选按钮是否被用户选择 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		final JLabel label = new JLabel();
		JRadioButton radioButton = new JRadioButton("单选");
		label.setText(radioButton.isSelected()+"");
		frame.getContentPane().add(label);
		frame.getContentPane().add(radioButton);
		frame.setVisible(true);
	//setSelected方法——将单选按钮设置成选择状态 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		final JLabel label = new JLabel();
		JRadioButton radioButton = new JRadioButton("单选");
		radioButton.setSelected(true);
		frame.getContentPane().add(label);
		frame.getContentPane().add(radioButton);
		frame.setVisible(true);
//javaxswingButtonGroup类 
	//add方法——将按钮添加到按钮组中 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		ButtonGroup group = new ButtonGroup();
		JRadioButton radioButton1 = new JRadioButton("按钮1");
		JRadioButton radioButton2 = new JRadioButton("按钮2");
		group.add(radioButton1);
		group.add(radioButton2);
		frame.getContentPane().add(radioButton1);
		frame.getContentPane().add(radioButton2);
		frame.setVisible(true);
	//remove方法——删除已经添加到按钮组中的按钮 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		ButtonGroup group = new ButtonGroup();
		JRadioButton radioButton1 = new JRadioButton("按钮1");
		JRadioButton radioButton2 = new JRadioButton("按钮2");
		JRadioButton radioButton3 = new JRadioButton("按钮3");
		group.add(radioButton1);
		group.add(radioButton2);
		group.add(radioButton3);
		group.remove(radioButton3);
		frame.getContentPane().add(radioButton1);
		frame.getContentPane().add(radioButton2);
		frame.getContentPane().add(radioButton3);
		frame.setVisible(true);
//javaxswingBorderFactory类 
	//createBevelBorder方法——创建指定类型的斜面边框 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JPanel panel = new JPanel();
		panel.setBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED));
		frame.getContentPane().add(panel);
		frame.setVisible(true);
	//createCompoundBorder方法——指定复合边框 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JPanel panel = new JPanel();
		Border outside = BorderFactory.createBevelBorder(BevelBorder.LOWERED);
		Border inside = BorderFactory.createBevelBorder(BevelBorder.RAISED);
		panel.setBorder(new CompoundBorder(outside,inside));
		frame.getContentPane().add(panel);
		frame.setVisible(true);
	//createEmptyBorder方法——创建一个空白的边框 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JPanel panel = new JPanel();
		panel.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
		frame.getContentPane().add(panel,BorderLayout.CENTER);
		frame.setVisible(true);
	//createEtchedBorder方法——创建浮雕效果的边框 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JPanel panel = new JPanel();
		panel.setBorder(BorderFactory.createEtchedBorder(EtchedBorder.LOWERED));
		frame.getContentPane().add(panel);
		frame.setVisible(true);
	//createLineBorder方法——创建直线边框 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JPanel panel = new JPanel();
		panel.setBorder(BorderFactory.createLineBorder(Color.RED,5));
		frame.getContentPane().add(panel);
		frame.setVisible(true);
	//createMatteBorder方法——创建纯色或者指定图片的边框 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JPanel panel = new JPanel();
		panel.setBorder(BorderFactory.createMatteBorder(1, 2, 3, 4, Color.RED));
		frame.getContentPane().add(panel);
		frame.setVisible(true);
	//createTitledBorder方法——创建带有标题的边框 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JPanel panel = new JPanel();
		panel.setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(),"标题边框"));
		frame.getContentPane().add(panel);
		frame.setVisible(true);
//javaxswingJComboBox类 
	//JComboBox构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultComboBoxModel model = new DefaultComboBoxModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		JComboBox comboBox = new JComboBox(model);
		frame.getContentPane().add(comboBox);
		frame.setVisible(true);
	//addActionListener方法——监听组合框的选择事件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultComboBoxModel model = new DefaultComboBoxModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		JComboBox comboBox = new JComboBox(model);
		comboBox.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				JOptionPane.showMessageDialog(null, "选择");
				return;
			}
		});
		frame.getContentPane().add(comboBox);
		frame.setVisible(true);
	//addItem方法——给组合框增加元素 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultComboBoxModel model = new DefaultComboBoxModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		JComboBox comboBox = new JComboBox(model);
		comboBox.addItem("JAVA1");
		frame.getContentPane().add(comboBox);
		frame.setVisible(true);
	//getSelectedItem方法——获得用户选择的元素 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultComboBoxModel model = new DefaultComboBoxModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		final JComboBox comboBox = new JComboBox(model);
		comboBox.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				JOptionPane.showMessageDialog(null, ""+comboBox.getSelectedItem());
				return;
			}
		});
		frame.getContentPane().add(comboBox);
		frame.setVisible(true);
	//setEditable方法——设置组合框中的文本框是否处于编辑状态 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultComboBoxModel model = new DefaultComboBoxModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		final JComboBox comboBox = new JComboBox(model);
		comboBox.setEditable(true);
		frame.getContentPane().add(comboBox);
		frame.setVisible(true);
	//setMaximumRowCount方法——设置组合框中可以显示的列表项个数 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultComboBoxModel model = new DefaultComboBoxModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		final JComboBox comboBox = new JComboBox(model);
		comboBox.setMaximumRowCount(1);
		frame.getContentPane().add(comboBox);
		frame.setVisible(true);
	//setSelectedIndex方法——设置当前组合框中选择的元素 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultComboBoxModel model = new DefaultComboBoxModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		final JComboBox comboBox = new JComboBox(model);
		comboBox.setSelectedIndex(1);
		frame.getContentPane().add(comboBox);
		frame.setVisible(true);
//javaxswingJSlider类 
	//JSlider构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JSlider slider = new JSlider(JSlider.HORIZONTAL);
		frame.getContentPane().add(slider);
		frame.setVisible(true);
	//addChangeListener方法——监听滑块滑动事件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		final Label label = new Label("未滑动");
		JSlider slider = new JSlider(JSlider.HORIZONTAL);
		slider.addChangeListener(new ChangeListener() {
			@Override
			public void stateChanged(ChangeEvent e) {
				label.setText("已滑动");
			}
		});
		frame.getContentPane().add(label);
		frame.getContentPane().add(slider);
		frame.setVisible(true);
	//getValue方法——获得滑块的当前值 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		final Label label = new Label("未滑动");
		final JSlider slider = new JSlider(JSlider.HORIZONTAL);
		slider.addChangeListener(new ChangeListener() {
			@Override
			public void stateChanged(ChangeEvent e) {
				label.setText(""+slider.getValue());
			}
		});
		frame.getContentPane().add(label);
		frame.getContentPane().add(slider);
		frame.setVisible(true);
	//setFont方法——设置滑块上显示的标签的字体 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		final Label label = new Label("未滑动");
		final JSlider slider = new JSlider(0,100,50);
		slider.addChangeListener(new ChangeListener() {
			@Override
			public void stateChanged(ChangeEvent e) {
				label.setText(""+slider.getValue());
			}
		});
		slider.setMajorTickSpacing(20);
		slider.setMinorTickSpacing(1);
		slider.setPaintTicks(true);
		slider.setPaintLabels(true);
		slider.setFont(new Font("微软雅黑",Font.BOLD,15));
		frame.getContentPane().add(label);
		frame.getContentPane().add(slider);
		frame.setVisible(true);
	//setLabelTable方法——给滑块设置标签 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		final JSlider slider = new JSlider(0,100,50);
		Hashtable<Integer, Component> labels = new Hashtable<Integer, Component>();
		labels.put(0, new JLabel("0"));
		labels.put(0, new JLabel("50"));
		labels.put(0, new JLabel("100"));
		slider.setLabelTable(labels);
		slider.setPaintLabels(true);
		frame.getContentPane().add(slider);
		frame.setVisible(true);
	//setMajorTickSpacing方法——设置主刻度间的距离 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		final JSlider slider = new JSlider(0,100,50);
		slider.setMajorTickSpacing(10);
		slider.setPaintTicks(true);
		frame.getContentPane().add(slider);
		frame.setVisible(true);
	//setMaximum方法——设置滑块的最大值 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		final JSlider slider = new JSlider(0,100,50);
		slider.setMaximum(100);
		frame.getContentPane().add(slider);
		frame.setVisible(true);
	//setMinimum方法——设置滑块的最小值 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		final JSlider slider = new JSlider(0,100,50);
		slider.setMinimum(50);
		frame.getContentPane().add(slider);
		frame.setVisible(true);
	//setMinorTickSpacing方法——设置副刻度间的距离 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JSlider slider = new JSlider(0,50,25);
		slider.setMinorTickSpacing(1);
		slider.setPaintTicks(true);
		frame.getContentPane().add(slider);
		frame.setVisible(true);
//javaxswingJSpinner类 
	//JSpinner构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] months = {"周一","周二","周三","周四","周五"};
		SpinnerListModel model = new SpinnerListModel(months);
		JSpinner spinner = new JSpinner(model);
		frame.getContentPane().add(spinner);
		frame.setVisible(true);
	//addChangeListener方法——监听微调按钮变化事件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] months = {"周一","周二","周三","周四","周五"};
		SpinnerListModel model = new SpinnerListModel(months);
		JSpinner spinner = new JSpinner(model);
		spinner.addChangeListener(new ChangeListener() {
			@Override
			public void stateChanged(ChangeEvent e) {
				JOptionPane.showMessageDialog(null, "变化");
				return;
			}
		});
		frame.getContentPane().add(spinner);
		frame.setVisible(true);
	//getValue方法——获得微调按钮当前的值 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] months = {"周一","周二","周三","周四","周五"};
		SpinnerListModel model = new SpinnerListModel(months);
		final JSpinner spinner = new JSpinner(model);
		spinner.addChangeListener(new ChangeListener() {
			@Override
			public void stateChanged(ChangeEvent e) {
				JOptionPane.showMessageDialog(null, spinner.getValue()+"");
				return;
			}
		});
		frame.getContentPane().add(spinner);
		frame.setVisible(true);
	//setEditor方法——设置编辑微调按钮值的控件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		final JSpinner spinner = new JSpinner(new SpinnerDateModel());
		spinner.setEditor(new JSpinner.DateEditor(spinner,"yyyy-MM-dd"));
		frame.getContentPane().add(spinner);
		frame.setVisible(true);
<!--菜单和工具栏控件 ->
//javaxswingJMenuBar类 
	//JMenuBar构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenuBar menuBar = new JMenuBar();
		frame.setJMenuBar(menuBar);
		JMenu menu1 = new JMenu("菜单");
		menuBar.add(menu1);
		frame.setVisible(true);
	//add方法——向菜单条中增加菜单 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenuBar menuBar = new JMenuBar();
		frame.setJMenuBar(menuBar);
		JMenu menu1 = new JMenu("菜单");
		menuBar.add(menu1);
		frame.setVisible(true);
	//setLayout方法——设置控件的布局 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenuBar menuBar = new JMenuBar();
		menuBar.setLayout(new BoxLayout(menuBar, BoxLayout.Y_AXIS));
		frame.setJMenuBar(menuBar);
		JMenu menu1 = new JMenu("菜单");
		menuBar.add(menu1);
		frame.setVisible(true);
//javaxswingJMenu类 
	//JMenu构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenuBar menuBar = new JMenuBar();
		frame.setJMenuBar(menuBar);
		JMenu menu1 = new JMenu("菜单");
		menuBar.add(menu1);
		frame.setVisible(true);
	//add方法——给菜单增加菜单项 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenuBar menuBar = new JMenuBar();
		frame.setJMenuBar(menuBar);
		JMenu menu1 = new JMenu("菜单");
		menuBar.add(menu1);
		frame.setVisible(true);
	//addSeparator方法——给菜单项增加分隔符 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenuBar menuBar = new JMenuBar();
		frame.setJMenuBar(menuBar);
		JMenu menu1 = new JMenu("菜单");
		JMenu menu2 = new JMenu("菜单2");
		menuBar.add(menu1);
		menuBar.add(menu2);
		menu2.addSeparator();
		frame.setVisible(true);
	//setFont方法——设置菜单字体 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenuBar menuBar = new JMenuBar();
		frame.setJMenuBar(menuBar);
		JMenu menu1 = new JMenu("菜单");
		JMenu menu2 = new JMenu("菜单2");
		menu2.setFont(new Font("微软雅黑",Font.BOLD,15));
		menuBar.add(menu1);
		menuBar.add(menu2);
		frame.setVisible(true);
	//setMnemonic方法——给菜单设置助记符 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenuBar menuBar = new JMenuBar();
		frame.setJMenuBar(menuBar);
		JMenu menu1 = new JMenu("菜单");
		JMenu menu2 = new JMenu("菜单2");
		menu1.setMnemonic(KeyEvent.VK_A);
		menuBar.add(menu1);
		menuBar.add(menu2);
		frame.setVisible(true);
	//setPopupMenuVisible方法——设置弹出菜单是否可见 
		//设置弹出菜单是否可见 
//javaxswingJMenuItem类 
	//JMenuItem构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenuBar menuBar = new JMenuBar();
		frame.setJMenuBar(menuBar);
		JMenu menu1 = new JMenu("菜单");
		JMenuItem menuItem1 = new JMenuItem("打开");
		menu1.add(menuItem1);
		menuBar.add(menu1);
		frame.setVisible(true);
	//addActionListener方法——处理菜单项动作事件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenuBar menuBar = new JMenuBar();
		frame.setJMenuBar(menuBar);
		JMenu menu1 = new JMenu("菜单");
		JMenuItem menuItem1 = new JMenuItem("打开");
		menuItem1.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				System.out.println("+");
				return;
			}
		});
		menu1.add(menuItem1);
		menuBar.add(menu1);
		frame.setVisible(true);
	//setAccelerator方法——给菜单项设置快捷键 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenuBar menuBar = new JMenuBar();
		frame.setJMenuBar(menuBar);
		JMenu menu1 = new JMenu("菜单");
		JMenuItem menuItem1 = new JMenuItem("打开");
		menuItem1.setAccelerator(KeyStroke.getKeyStroke("ctrl 2"));
		menu1.add(menuItem1);
		menuBar.add(menu1);
		frame.setVisible(true);
	//setEnabled方法——启用或禁用菜单项 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenuBar menuBar = new JMenuBar();
		frame.setJMenuBar(menuBar);
		JMenu menu1 = new JMenu("菜单");
		JMenuItem menuItem1 = new JMenuItem("打开");
		menuItem1.setEnabled(false);
		menu1.add(menuItem1);
		menuBar.add(menu1);
		frame.setVisible(true);
	//setFont方法——为菜单项设置字体 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenuBar menuBar = new JMenuBar();
		frame.setJMenuBar(menuBar);
		JMenu menu1 = new JMenu("菜单");
		JMenuItem menuItem1 = new JMenuItem("打开");
		menuItem1.setFont(new Font("微软雅黑",Font.BOLD,15));
		menu1.add(menuItem1);
		menuBar.add(menu1);
		frame.setVisible(true);
//javaxswingJPopupMenu类 
	//JPopupMenu构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		JPanel jPanel = new JPanel();
		frame.setBounds(400,320,400,240);
		JPopupMenu popup = new JPopupMenu();
		jPanel.setComponentPopupMenu(popup);
		frame.getContentPane().add(jPanel);
		frame.setVisible(true);
	//add方法——给弹出菜单增加菜单项 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JPanel panel = new JPanel();
		JPopupMenu popup = new JPopupMenu();
		popup.add(new JMenuItem("男生",new ImageIcon("src/1.jpg")));
		panel.setComponentPopupMenu(popup);
		frame.getContentPane().add(panel);
		frame.setVisible(true);
	//addSeparator方法——给弹出菜单的菜单项之间增加分隔符 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JPanel panel = new JPanel();
		JPopupMenu popup = new JPopupMenu();
		popup.add("男");
		popup.add("女");
		popup.addSeparator();
		panel.setComponentPopupMenu(popup);
		frame.getContentPane().add(panel);
		frame.setVisible(true);
	//setPopupSize方法——设置弹出菜单的大小 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JPanel panel = new JPanel();
		JPopupMenu popup = new JPopupMenu();
		popup.add("男");
		popup.add("女");
		popup.addSeparator();
		popup.setPopupSize(100,100);
		frame.getContentPane().add(panel);
		frame.setVisible(true);
//javaxswingJCheckBoxMenuItem类 
	//JCheckBoxMenuItem构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenu menu = new JMenu();
		JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem("菜单");
		frame.getContentPane().add(menu);
		frame.setVisible(true);
	//addActionListener方法——监听复选框菜单项的动作事件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenu menu = new JMenu();
		JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem("菜单");
		jCheckBoxMenuItem.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				System.out.println("+");
			}
		});
		frame.getContentPane().add(menu);
		frame.setVisible(true);
	//setFont方法——给复选框菜单项设置字体 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenu menu = new JMenu();
		JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem("菜单");
		jCheckBoxMenuItem.setFont(new Font("微软雅黑", Font.BOLD, 15));
		frame.getContentPane().add(menu);
		frame.setVisible(true);
//javaxswingJRadioButtonMenuItem类 
	//JRadioButtonMenuItem构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenu menu = new JMenu();
		JRadioButton jRadioButton = new JRadioButton("菜单");
		menu.add(jRadioButton);
		frame.getContentPane().add(menu);
		frame.setVisible(true);
	//addActionListener方法——监听单选按钮菜单项的动作事件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenu menu = new JMenu();
		JRadioButton jRadioButton = new JRadioButton("菜单");
		jRadioButton.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				System.out.println("+");
			}
		});
		frame.getContentPane().add(menu);
		frame.setVisible(true);
	//setFont方法——给单选按钮菜单项设置字体 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JMenu menu = new JMenu();
		JRadioButton jRadioButton = new JRadioButton("菜单");
		jRadioButton.setFont(new Font("微软雅黑",Font.BOLD,15));
		frame.getContentPane().add(menu);
		frame.setVisible(true);
//javaxswingJToolBar类 
	//JToolBar构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JToolBar toolBar = new JToolBar();
		JButton button = new JButton("按钮");
		toolBar.add(button);
		frame.getContentPane().add(toolBar);
		frame.setVisible(true);
	//add方法——为工具栏添加控件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JToolBar toolBar = new JToolBar();
		JButton button = new JButton("按钮");
		toolBar.add(button);
		frame.getContentPane().add(toolBar);
		frame.setVisible(true);
	//addSeparator方法——给工具栏增加分隔符 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JToolBar toolBar = new JToolBar();
		JButton button = new JButton("按钮");
		toolBar.add(button);
		JButton button1 = new JButton("按钮");
		toolBar.add(button1);
		toolBar.addSeparator(new Dimension(50,100));
		frame.getContentPane().add(toolBar);
		frame.setVisible(true);
	//setFloatable方法——固定工具栏 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JToolBar toolBar = new JToolBar();
		toolBar.setFloatable(false);
		JButton button = new JButton("按钮");
		toolBar.add(button);
		JButton button1 = new JButton("按钮");
		toolBar.add(button1);
		frame.getContentPane().add(toolBar);
		frame.setVisible(true);
<!--对话框控件 ->
//javaxswingJOptionPane类 
	//showConfirmDialog方法——创建一个确认对话框 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JOptionPane.showConfirmDialog(frame, "确定退出");
		frame.setVisible(true);
	//showInputDialog方法——创建接收用户输入信息的对话框 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JOptionPane.showInputDialog(frame,"输入名字");
		frame.setVisible(true);
	//showMessageDialog方法——创建消息对话框 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JOptionPane.showMessageDialog(frame, "欢迎使用");
		frame.setVisible(true);
	//showOptionDialog方法——根据用户指定的选项创建对话框 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JOptionPane.showOptionDialog(frame, "对话框", "对话框1", JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE, null, null, "java");
		frame.setVisible(true);
//javaxswingJFileChooser类 
	//JFileChooser构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JFileChooser fileChooser = new JFileChooser();
		fileChooser.showOpenDialog(frame);
		frame.setVisible(true);
	//getSelectedFile方法——获得用户选择的文件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JFileChooser fileChooser = new JFileChooser();
		fileChooser.showOpenDialog(frame);
		File selectedFile = fileChooser.getSelectedFile();
		System.out.println(selectedFile.getAbsolutePath());
		frame.setVisible(true);
	//getSelectedFiles方法——获得选择的一组文件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JFileChooser fileChooser = new JFileChooser();
		fileChooser.showOpenDialog(frame);
		File[] selectedFile = fileChooser.getSelectedFiles();
		System.out.println(selectedFile.length);
		frame.setVisible(true);
	//setFileFilter方法——设置文件过滤器 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JFileChooser fileChooser = new JFileChooser();
		fileChooser.showOpenDialog(frame);
		fileChooser.setFileFilter(new FileFilter() {
			@Override
			public String getDescription() {
				return null;
			}
			@Override
			public boolean accept(File f) {
				return false;
			}
		});
		frame.setVisible(true);
	//setFileHidingEnabled方法——设置是否显示隐藏文件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JFileChooser fileChooser = new JFileChooser();
		fileChooser.showOpenDialog(frame);
		fileChooser.setFileHidingEnabled(true);
		frame.setVisible(true);
	//setFileSelectionMode方法——设置选择模式 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JFileChooser fileChooser = new JFileChooser();
		fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
		fileChooser.showOpenDialog(frame);
		frame.setVisible(true);
	//setMultiSelectionEnabled方法——设置是否能够同时选择多个文件或文件夹 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JFileChooser fileChooser = new JFileChooser();
		fileChooser.setMultiSelectionEnabled(true);
		fileChooser.showOpenDialog(frame);
		frame.setVisible(true);
	//showDialog方法——打开对话框 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JFileChooser fileChooser = new JFileChooser();
		fileChooser.showDialog(frame,"自定义按钮");
		frame.setVisible(true);
	//showOpenDialog方法——弹出打开对话框 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JFileChooser fileChooser = new JFileChooser();
		fileChooser.showOpenDialog(frame);
		frame.setVisible(true);
	//showSaveDialog方法——弹出保存对话框 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JFileChooser fileChooser = new JFileChooser();
		fileChooser.showSaveDialog(frame);
		frame.setVisible(true);
//javaxswingJColorChooser类 
	//JColorChooser构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JColorChooser chooser = new JColorChooser();
		frame.getContentPane().add(chooser);
		frame.setVisible(true);
	//getColor方法——获得在颜色选择器中选择的颜色 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		final JColorChooser chooser = new JColorChooser();
		frame.getContentPane().add(chooser);
		chooser.getSelectionModel().addChangeListener(new ChangeListener() {
			@Override
			public void stateChanged(ChangeEvent e) {
				System.out.println(chooser.getColor());
			}
		});
		frame.setVisible(true);
	//showDialog方法——创建颜色选择对话框 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		Color showDialog = JColorChooser.showDialog(frame, "", null);
		frame.getContentPane().setBackground(showDialog);
		frame.setVisible(true);
<!--列表控件 ->
//javaxswingJList类 
	//JList构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultListModel model = new DefaultListModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		model.addElement("ASP");
		JList list = new JList(model);
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//addListSelectionListener方法——监听列表项选择事件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] items = {"Java","Perl","C++"};
		JList list = new JList(items);
		list.addListSelectionListener(new ListSelectionListener() {
			@Override
			public void valueChanged(ListSelectionEvent e) {
				System.out.println("选中");
			}
		});
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//addMouseListener方法——监听鼠标事件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] items = {"Java","Perl","C++"};
		JList list = new JList(items);
		list.addMouseListener(new MouseAdapter() {
			@Override
			public void mouseClicked(MouseEvent e) {
				System.out.println("选中");
			}
		});
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//getSelectedIndex方法——获得当前选择元素的索引值 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] items = {"Java","Perl","C++"};
		final JList list = new JList(items);
		list.addMouseListener(new MouseAdapter() {
			@Override
			public void mouseClicked(MouseEvent e) {
				System.out.println(list.getSelectedIndex());
			}
		});
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//getSelectedValue方法——获得当前选择的元素 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] items = {"Java","Perl","C++"};
		final JList list = new JList(items);
		list.addMouseListener(new MouseAdapter() {
			@Override
			public void mouseClicked(MouseEvent e) {
				System.out.println(list.getSelectedValue());
			}
		});
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//setCellRenderer方法——为列表设置渲染器 
		//列表设置渲染器
	//setLayoutOrientation方法——设置列表项的布局方式 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] items = {"Java","Perl","C++"};
		final JList list = new JList(items);
		list.setLayoutOrientation(JList.HORIZONTAL_WRAP);
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//setListData方法——为列表设置列表项 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] items = {"Java","Perl","C++"};
		final JList list = new JList();
		list.setListData(items);
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//setModel方法——为列表设置列表模型 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultListModel model = new DefaultListModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		model.addElement("ASP");
		JList list = new JList(model);
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//setSelectedIndex方法——设置当前选中的列表项 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] items = {"Java","Perl","C++"};
		final JList list = new JList();
		list.setListData(items);
		list.setSelectedIndex(1);
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//setSelectionBackground方法——设置列表项选中时的背景色 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] items = {"Java","Perl","C++"};
		final JList list = new JList();
		list.setListData(items);
		list.setBackground(Color.BLUE);
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//setSelectionForeground方法——设置列表项选中时的前景色 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] items = {"Java","Perl","C++"};
		final JList list = new JList();
		list.setListData(items);
		list.setSelectionForeground(Color.BLUE);
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//setSelectionMode方法——设置列表项的选择模式 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] items = {"Java","Perl","C++"};
		final JList list = new JList();
		list.setListData(items);
		list.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//setVisibleRowCount方法——设置visibleRowCount属性 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] items = {"Java","Perl","C++"};
		final JList list = new JList();
		list.setListData(items);
		list.setVisibleRowCount(2);
		frame.getContentPane().add(list);
		frame.setVisible(true);
//javaxswingDefaultListModel类 
	//add方法——在列表模型中的指定位置增加元素 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultListModel model = new DefaultListModel();
		model.add(0, "JAVA");
		model.add(0, "PHP");
		model.add(0, "ASP");
		model.add(0, "JSP");
		JList list = new JList();
		list.setModel(model);
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//addElement方法——向列表模型的末尾增加新元素 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultListModel model = new DefaultListModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		model.addElement("ASP");
		JList list = new JList();
		list.setModel(model);
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//clear方法——清空列表模型中的全部元素 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultListModel model = new DefaultListModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		model.addElement("ASP");
		model.clear();
		JList list = new JList();
		list.setModel(model);
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//contains方法——判断列表模型中是否包含指定的元素 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultListModel model = new DefaultListModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		model.addElement("ASP");
		JList list = new JList();
		list.setModel(model);
		System.out.println(model.contains("JAVA"));
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//elementAt方法——获得指定索引值的元素 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultListModel model = new DefaultListModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		model.addElement("ASP");
		JList list = new JList();
		list.setModel(model);
		System.out.println(model.elementAt(2));
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//elements方法——获得模型中全部元素的枚举 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultListModel model = new DefaultListModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		model.addElement("ASP");
		JList list = new JList();
		list.setModel(model);
		Enumeration<?> elements = model.elements();
		while (elements.hasMoreElements()) {
			System.out.println(elements.nextElement());
		}
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//getSize方法——获得列表模型中元素的个数 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultListModel model = new DefaultListModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		model.addElement("ASP");
		JList list = new JList();
		list.setModel(model);
		System.out.println(model.getSize());
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//remove方法——删除列表模型中指定索引的元素 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultListModel model = new DefaultListModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		model.addElement("ASP");
		JList list = new JList();
		list.setModel(model);
		System.out.println(model.remove(2));
		frame.getContentPane().add(list);
		frame.setVisible(true);
	//removeRange方法——从列表模型中删除指定区域的元素 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultListModel model = new DefaultListModel();
		model.addElement("JAVA");
		model.addElement("PHP");
		model.addElement("ASP");
		JList list = new JList();
		list.setModel(model);
		model.removeRange(0,1);
		frame.getContentPane().add(list);
		frame.setVisible(true);
<!--表格控件 ->
//javaxswingJTable类 
	//JTable构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] columnNames = {"学号","姓名"};
		String[][] rowData = {{"20101","小王"},{"20102","大王"}};
		JTable table = new JTable(rowData,columnNames);
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//addColumn方法——向表格中增加一列 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"20101","1号"});
		model.addRow(new String[]{"20102","2号"});
		JTable table = new JTable(model);
		TableColumn column = new TableColumn(0,100);
		table.addColumn(column);
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//addRowSelectionInterval方法——增加选中的行 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"20101","1号"});
		model.addRow(new String[]{"20102","2号"});
		JTable table = new JTable(model);
		table.addRowSelectionInterval(0, 1);
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//getColumn方法——获得表格中的指定列 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"20101","1号"});
		model.addRow(new String[]{"20102","2号"});
		JTable table = new JTable(model);
		System.out.println(table.getColumn("学号"));
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//getColumnClass方法——获得表格中指定列的类型 
		//用于获得表格中指定列的类型
	//getColumnCount方法——获得列模型中的列数 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"20101","1号"});
		model.addRow(new String[]{"20102","2号"});
		JTable table = new JTable(model);
		System.out.println(table.getColumnCount());
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//getColumnName方法——获得指定列的名称 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"20101","1号"});
		model.addRow(new String[]{"20102","2号"});
		JTable table = new JTable(model);
		System.out.println(table.getColumnName(0));
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//getModel方法——获得当前表格使用的表格模型 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"20101","1号"});
		model.addRow(new String[]{"20102","2号"});
		JTable table = new JTable(model);
		System.out.println(table.getModel());
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//getRowCount方法——获得表格中包含的行数 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"20101","1号"});
		model.addRow(new String[]{"20102","2号"});
		JTable table = new JTable(model);
		System.out.println(table.getRowCount());
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//getSelectedColumn方法——获得用户选中的第一列的索引 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"20101","1号"});
		model.addRow(new String[]{"20102","2号"});
		JTable table = new JTable(model);
		System.out.println(table.getSelectedColumn());
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//getSelectedRow方法——获得选中行的索引 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"20101","1号"});
		model.addRow(new String[]{"20102","2号"});
		JTable table = new JTable(model);
		System.out.println(table.getSelectedRow());
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//print方法——打印调用该方法的表格 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"20101","1号"});
		model.addRow(new String[]{"20102","2号"});
		JTable table = new JTable(model);
		table.print();
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//setAutoCreateRowSorter方法——设置表格能否根据行的内容进行排列 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"20101","1号"});
		model.addRow(new String[]{"20102","2号"});
		JTable table = new JTable(model);
		table.setAutoCreateRowSorter(true);
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//setAutoResizeMode方法——指定改变表格大小时各列的调整方式 
		//指定改变表格大小时各列的调整方式
	//setModel方法——为表格设置新的表格模型 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"20101","1号"});
		model.addRow(new String[]{"20102","2号"});
		JTable table = new JTable();
		table.setModel(model);
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//setRowHeight方法——设置表格的列高 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"20101","1号"});
		model.addRow(new String[]{"20102","2号"});
		JTable table = new JTable(model);
		table.setRowHeight(0,50);
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//setShowGrid方法——设置是否显示单元格的分隔线 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"20101","1号"});
		model.addRow(new String[]{"20102","2号"});
		JTable table = new JTable(model);
		table.setShowGrid(false);
		frame.getContentPane().add(table);
		frame.setVisible(true);
//DefaultTableModel类 
	//DefaultTableModel构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JTable table = new JTable();
		DefaultTableModel model = new DefaultTableModel();
		table.setModel(model);
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//addColumn方法——向表格模型中增加列 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JTable table = new JTable();
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		table.setModel(model);
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//addRow方法——向表格模型中增加一行数据 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JTable table = new JTable();
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"2001","2002"});
		model.addRow(new String[]{"小张","小王"});
		table.setModel(model);
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//getDataVector方法——将表格中的数据保存到一个向量中 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JTable table = new JTable();
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"2001","2002"});
		model.addRow(new String[]{"小张","小王"});
		table.setModel(model);
		Vector dateVector = model.getDataVector();
		for (Iterator iterator = dateVector.iterator(); iterator.hasNext();) {
			System.out.println(iterator.next());
			
		}
		frame.getContentPane().add(table);
		frame.setVisible(true);
	//setRowCount方法——设置表格模型中数据的行数 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JTable table = new JTable();
		DefaultTableModel model = new DefaultTableModel();
		model.addColumn("学号");
		model.addColumn("姓名");
		model.addRow(new String[]{"2001","2002"});
		model.addRow(new String[]{"小张","小王"});
		table.setModel(model);
		model.setRowCount(0);
		frame.getContentPane().add(table);
		frame.setVisible(true);
<!--树控件 ->
//javaxswingJTree类 
	//JTree构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] nodes = {"JAVA","PHP","JSP"};
		JTree tree = new JTree(nodes);
		frame.getContentPane().add(tree);
		frame.setVisible(true);
	//addSelectionInterval方法——将树控件指定范围内的路径增加到选择状态中 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] nodes = {"JAVA","PHP","JSP"};
		JTree tree = new JTree(nodes);
		tree.addSelectionInterval(0, 2);
		frame.getContentPane().add(tree);
		frame.setVisible(true);
	//addSelectionRow方法——将位于特定行的路径增加到选择状态中 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] nodes = {"JAVA","PHP","JSP"};
		JTree tree = new JTree(nodes);
		tree.addSelectionRow(0);
		frame.getContentPane().add(tree);
		frame.setVisible(true);
	//addTreeExpansionListener方法——监听树结点展开合并事件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] nodes = {"JAVA","PHP","JSP"};
		JTree tree = new JTree(nodes);
		tree.addTreeExpansionListener(new TreeExpansionListener() {
			@Override
			public void treeExpanded(TreeExpansionEvent event) {
				JOptionPane.showMessageDialog(null, "合并节点");
			}
			
			@Override
			public void treeCollapsed(TreeExpansionEvent event) {
				JOptionPane.showMessageDialog(null, "展开节点");
			}
		});
		frame.getContentPane().add(tree);
		frame.setVisible(true);
	//addTreeSelectionListener方法——监听树结点的选择事件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] nodes = {"JAVA","PHP","JSP"};
		JTree tree = new JTree(nodes);
		tree.addTreeSelectionListener(new TreeSelectionListener() {
			@Override
			public void valueChanged(TreeSelectionEvent e) {
				JOptionPane.showMessageDialog(null, "选择了一个节点");
				return;
			}
		});
		frame.getContentPane().add(tree);
		frame.setVisible(true);
	//getLastSelectedPathComponent方法——获得用户选择的结点 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] nodes = {"JAVA","PHP","JSP"};
		final JTree tree = new JTree(nodes);
		tree.addTreeSelectionListener(new TreeSelectionListener() {
			@Override
			public void valueChanged(TreeSelectionEvent e) {
				Object selectObject = tree.getLastSelectedPathComponent();
				JOptionPane.showMessageDialog(null, "选择"+selectObject);
			}
		});
		frame.getContentPane().add(tree);
		frame.setVisible(true);
	//getModel方法——获得树模型 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] nodes = {"JAVA","PHP","JSP"};
		final JTree tree = new JTree(nodes);
		TreeModel model = tree.getModel();
		System.out.println(model.getRoot());
		frame.getContentPane().add(tree);
		frame.setVisible(true);
	//getRowCount方法——输出树结构中当前显示的行数 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] nodes = {"JAVA","PHP","JSP"};
		final JTree tree = new JTree(nodes);
		System.out.println(tree.getRowCount());
		frame.getContentPane().add(tree);
		frame.setVisible(true);
	//setCellEditor方法——设置树结点编辑器 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] nodes = {"JAVA","PHP","JSP"};
		final JTree tree = new JTree(nodes);
		tree.setCellEditor(new DefaultCellEditor(new JTextField()));
		tree.setEditable(true);
		frame.getContentPane().add(tree);
		frame.setVisible(true);
	//setCellRenderer方法——为树控件设置渲染器 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] nodes = {"JAVA","PHP","JSP"};
		final JTree tree = new JTree(nodes);
		DefaultTreeCellRenderer renderer = new DefaultTreeCellRenderer();
		renderer.setLeafIcon(new ImageIcon("src/1.jpg"));
		tree.setCellRenderer(renderer);
		frame.getContentPane().add(tree);
		frame.setVisible(true);
	//setRootVisible方法——设置根结点是否可见 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] nodes = {"JAVA","PHP","JSP"};
		final JTree tree = new JTree(nodes);
		tree.setRootVisible(true);
		frame.getContentPane().add(tree);
		frame.setVisible(true);
	//setRowHeight方法——设置结点的高度 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] nodes = {"JAVA","PHP","JSP"};
		final JTree tree = new JTree(nodes);
		tree.setRowHeight(50);
		frame.getContentPane().add(tree);
		frame.setVisible(true);
	//setShowsRootHandles方法——设置是否显示“把手” 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		String[] nodes = {"JAVA","PHP","JSP"};
		final JTree tree = new JTree(nodes);
		tree.setShowsRootHandles(false);
		frame.getContentPane().add(tree);
		frame.setVisible(true);
//javaxswingtreeDefaultTreeModel类 
	//getChild方法——获得指定结点的指定位置的元素 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultMutableTreeNode root = new DefaultMutableTreeNode("图书");
		DefaultMutableTreeNode parent1 = new DefaultMutableTreeNode("人工智能");
		parent1.add(new DefaultMutableTreeNode("大数据"));
		parent1.add(new DefaultMutableTreeNode("大数据1"));
		parent1.add(new DefaultMutableTreeNode("大数据2"));
		parent1.add(new DefaultMutableTreeNode("大数据3"));
		root.add(parent1);
		DefaultTreeModel model = new DefaultTreeModel(root);
		System.out.println(model.getChild(parent1, 3));
		JTree jTree = new JTree(model);
		frame.getContentPane().add(jTree);
		frame.setVisible(true);
	//getChildCount方法——获得指定结点的子结点个数 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultMutableTreeNode root = new DefaultMutableTreeNode("图书");
		DefaultMutableTreeNode parent1 = new DefaultMutableTreeNode("人工智能");
		parent1.add(new DefaultMutableTreeNode("大数据"));
		parent1.add(new DefaultMutableTreeNode("大数据1"));
		parent1.add(new DefaultMutableTreeNode("大数据2"));
		parent1.add(new DefaultMutableTreeNode("大数据3"));
		root.add(parent1);
		DefaultTreeModel model = new DefaultTreeModel(root);
		System.out.println(model.getChildCount(parent1));
		JTree jTree = new JTree(model);
		frame.getContentPane().add(jTree);
		frame.setVisible(true);
	//getRoot方法——获得树模型的根结点 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		DefaultMutableTreeNode root = new DefaultMutableTreeNode("图书");
		DefaultMutableTreeNode parent1 = new DefaultMutableTreeNode("人工智能");
		parent1.add(new DefaultMutableTreeNode("大数据"));
		parent1.add(new DefaultMutableTreeNode("大数据1"));
		parent1.add(new DefaultMutableTreeNode("大数据2"));
		parent1.add(new DefaultMutableTreeNode("大数据3"));
		root.add(parent1);
		DefaultTreeModel model = new DefaultTreeModel(root);
		System.out.println(model.getRoot());
		JTree jTree = new JTree(model);
		frame.getContentPane().add(jTree);
		frame.setVisible(true);
	//insertNodeInto方法——向树模型中指定位置插入新结点 
		//插入新的节点	
	//removeNodeFromParent方法——从树模型中删除结点 
		//删除节点
<!--进度指示控件 ->
//javaxswingJProgressBar控件 
	//JProgressBar构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JProgressBar jProgressBar = new JProgressBar(0,100);
		frame.getContentPane().add(jProgressBar);
		frame.setVisible(true);
	//addChangeListener方法——监听进度条变化事件 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JProgressBar jProgressBar = new JProgressBar(0,100);
		jProgressBar.addChangeListener(new ChangeListener() {
			@Override
			public void stateChanged(ChangeEvent e) {
				System.out.println("启动完毕");
			}
		});
		frame.getContentPane().add(jProgressBar);
		frame.setVisible(true);
	}
	//getValue方法——获得当前进度条显示的值 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JProgressBar jProgressBar = new JProgressBar(0,100);
		System.out.println(jProgressBar.getValue());
		frame.getContentPane().add(jProgressBar);
		frame.setVisible(true);
	//setBorderPainted方法——设置是否绘制滚动条的边框 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JProgressBar jProgressBar = new JProgressBar(0,100);
		jProgressBar.setBorderPainted(false);
		frame.getContentPane().add(jProgressBar);
		frame.setVisible(true);
	//setIndeterminate方法——设置滚动条持续滚动 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JProgressBar jProgressBar = new JProgressBar(0,100);
		jProgressBar.setIndeterminate(true);
		frame.getContentPane().add(jProgressBar);
		frame.setVisible(true);
	//setString方法——设置在滚动条上显示的文本 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JProgressBar jProgressBar = new JProgressBar(0,100);
		jProgressBar.setString("图书");
		jProgressBar.setStringPainted(true);
		frame.getContentPane().add(jProgressBar);
		frame.setVisible(true);
	//setValue方法——设置滚动条当前显示的值 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		frame.setBounds(400,320,400,240);
		JProgressBar jProgressBar = new JProgressBar(0,100);
		jProgressBar.setValue(50);
		System.out.println(jProgressBar.getValue());
		frame.getContentPane().add(jProgressBar);
		frame.setVisible(true);
//javaxswingProgressMonitor控件 
	//ProgressMonitor构造方法 
		//创建进度显示器
	//close方法——关闭进度显示器 
		//关闭进度显示器
	//setNote方法——设置进度显示器上显示的文本 
		//设置进度显示器上的文本
<!--高级布局管理器 ->
//javaawtGridBagLayout网格包布局
	//GridBagLayout构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		GridLayout gridBagLayout = new GridLayout();
		frame.getContentPane().setLayout(gridBagLayout);
		frame.setVisible(true);
	//anchor属性——设置组件在其所显示区域的显示位置 
		//设置组件在其显示区域的显示位置，通常有9个方位
	//fill属性——设置组件的填充方式 
		//fill属性可以设置组件填充
	//gridx属性和gridy属性——设置组件起始点所在单元格的索引值 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		GridLayout gridBagLayout = new GridLayout();
		JButton button = new JButton();
		button.setText("0,0");
		GridBagConstraints gridBagConstraints = new GridBagConstraints();
		gridBagConstraints.gridy = 0;
		gridBagConstraints.gridx = 0;
		frame.getContentPane().setLayout(gridBagLayout);
		frame.getContentPane().add(button,gridBagConstraints);
		frame.setVisible(true);
	//gridheight属性和gridwidth属性——设置组件占用网格的行数和列数 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		GridLayout gridBagLayout = new GridLayout();
		JButton button = new JButton();
		button.setText("0,0");
		GridBagConstraints gridBagConstraints = new GridBagConstraints();
		gridBagConstraints.gridy = 0;
		gridBagConstraints.gridx = 0;
		gridBagConstraints.gridwidth = 2;
		frame.getContentPane().setLayout(gridBagLayout);
		frame.getContentPane().add(button,gridBagConstraints);
		frame.setVisible(true);
	//insets属性——设置组件四周与单元格边缘之间的最小距离 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		GridLayout gridBagLayout = new GridLayout();
		JButton button = new JButton();
		button.setText("0,0");
		GridBagConstraints gridBagConstraints = new GridBagConstraints();
		gridBagConstraints.insets = new Insets(10, 10, 10, 10);
		gridBagConstraints.gridx = 1;
		gridBagConstraints.gridy = 1;
		frame.getContentPane().setLayout(gridBagLayout);
		frame.getContentPane().add(button,gridBagConstraints);
		frame.setVisible(true);
	//ipadx属性和ipady属性——修改组件的首选大小 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		GridLayout gridBagLayout = new GridLayout();
		JButton button = new JButton();
		button.setText("0,0");
		GridBagConstraints gridBagConstraints = new GridBagConstraints();
		gridBagConstraints.ipadx = 10;
		gridBagConstraints.ipady = 20;
		gridBagConstraints.gridx = 1;
		gridBagConstraints.gridy = 1;
		frame.getContentPane().setLayout(gridBagLayout);
		frame.getContentPane().add(button,gridBagConstraints);
		frame.setVisible(true);
	//weightx属性和weighty属性——设置网格组的每一行和每一列对额外空间的分布方式 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		GridLayout gridBagLayout = new GridLayout();
		JButton button = new JButton();
		button.setText("0,0");
		GridBagConstraints gridBagConstraints = new GridBagConstraints();
		gridBagConstraints.weightx = 40;
		gridBagConstraints.weighty = 40;
		gridBagConstraints.gridx = 1;
		gridBagConstraints.gridy = 1;
		frame.getContentPane().setLayout(gridBagLayout);
		frame.getContentPane().add(button,gridBagConstraints);
		frame.setVisible(true);
//javaxswingSpringLayout弹簧布局 
	//SpringLayout构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		SpringLayout springLayout = new SpringLayout();
		frame.getContentPane().setLayout(springLayout);
		frame.setVisible(true);
	//getConstraints方法——获得组件的SpringLayoutConstraints对象 
		//获得组件的SpringLayoutConstraints对象 
	//putConstraint方法——建立组件之间各个边的约束 
		//建立组件之间各个边的约束 
//javaxswingBoxLayout箱式布局 
	//BoxLayout构造方法 
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		frame.setBounds(400,320,400,240);
		BoxLayout hBox = new BoxLayout(frame.getContentPane(), BoxLayout.X_AXIS);
		frame.getContentPane().setLayout(hBox);
		frame.setVisible(true);
	//Box容器——箱式容器 
		//布局管理器轻量级容器
<!--输入/输出流 ->
//javaioBufferedInputStream——缓冲字节输入流 
	//available方法——返回可读取的估计字节数 
		File file = new File("c:/test.txt");
		FileInputStream in = new FileInputStream(file);
		BufferedInputStream bis = new BufferedInputStream(in);
		bis.read();
		System.out.println(bis.available());
		bis.close();
		in.close();
	//close方法——关闭输入流并释放与该流关联的所有系统资源 
		File file = new File("c:/test.txt");
		FileInputStream in = new FileInputStream(file);
		BufferedInputStream bis = new BufferedInputStream(in);
		bis.read();
		System.out.println(bis.available());
		bis.close();
		in.close();
	//mark方法——记录当前指针所在的位置 
		File file = new File("c:/test.txt");
		FileInputStream in = new FileInputStream(file);
		BufferedInputStream bis = new BufferedInputStream(in);
		bis.mark(5);
		int count = 0;
		for (int i = 0; i < file.length(); i++) {
			count++;
			int read = bis.read();
			if (count%5 == 0) {
				bis.reset();
				System.out.println(read);
			}
		}
		bis.close();
		in.close();
	//markSupported方法——测试是否支持mark方法和reset方法 
		File file = new File("c:/test.txt");
		FileInputStream in = new FileInputStream(file);
		BufferedInputStream bis = new BufferedInputStream(in);
		if(bis.markSupported()){
			System.out.println("BUFFERED类支持mark和reset方法");
		}
		bis.close();
		in.close();
	//read方法——从输入流中读取数据 
		File file = new File("c:/test.txt");
		FileInputStream in = new FileInputStream(file);
		BufferedInputStream bis = new BufferedInputStream(in);
		bis.read();
		System.out.println(bis.available());
		bis.close();
		in.close();
	//reset方法——重新定位输入流 
		File file = new File("c:/test.txt");
		FileInputStream in = new FileInputStream(file);
		BufferedInputStream bis = new BufferedInputStream(in);
		bis.mark(5);
		int count = 0;
		for (int i = 0; i < file.length(); i++) {
			count++;
			int read = bis.read();
			if (count%5 == 0) {
				bis.reset();
				System.out.println(read);
			}
		}
		bis.close();
		in.close();
	//skip方法——跳过并丢弃指定字节数量的数据 
		File file = new File("c:/test.txt");
		FileInputStream in = new FileInputStream(file);
		BufferedInputStream bis = new BufferedInputStream(in);
		bis.skip(5);
		int i = 0;
		while ((i = bis.read())!=-1) {
			System.out.println(i);
		}
		bis.close();
		in.close();
	//javaioBufferedOutputStream——缓冲字节输出流 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		BufferedOutputStream bus = new BufferedOutputStream(fos);
		byte[] by = "香蕉".getBytes();
		bus.write(by);
		bus.flush();
		bus.close();
	//flush方法——刷新此缓冲输出流 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		BufferedOutputStream bus = new BufferedOutputStream(fos);
		byte[] by = "香蕉".getBytes();
		bus.write(by);
		bus.flush();
		bus.close();
	//write方法——向输出流中写数据 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		BufferedOutputStream bus = new BufferedOutputStream(fos);
		byte[] by = "香蕉".getBytes();
		bus.write(by);
		bus.flush();
		bus.close();
//javaioBufferedReader——缓冲字符输入流 
	//close方法——关闭流并释放与之关联的所有资源 
		BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("输入一个字符串");
		String str = buf.readLine();
		buf.close();
		System.out.println(str);
	//mark方法——记录当前读指针所在的位置 
		File file = new File("c:/test.txt");
		BufferedReader buf = new BufferedReader(new FileReader(file));
		int count = 0;
		buf.mark(1);
		for (int i = 0; i < file.length(); i++) {
			count++;
			int read = buf.read();
			if(count%5==0){
				buf.reset();
				System.out.println(read);
			}
		}
		buf.close();
	//markSupported方法——判断指定流是否支持mark操作 
		File file = new File("c:/test.txt");
		BufferedReader buf = new BufferedReader(new FileReader(file));
		if(buf.markSupported()){
			System.out.println("BufferedReader支持mark");
		}
		buf.close();
	//read方法——从缓冲输入流中读取字符 
		File file = new File("c:/test.txt");
		BufferedReader buf = new BufferedReader(new FileReader(file));
		int count = 0;
		buf.mark(1);
		for (int i = 0; i < file.length(); i++) {
			count++;
			int read = buf.read();
			if(count%5==0){
				buf.reset();
				System.out.println(read);
			}
		}
		buf.close();
	//readLine方法——读取一个文本行 
		BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("输入一个字符串");
		String str = buf.readLine();
		buf.close();
		System.out.println(str);
	//ready方法——判断此流是否已准备好被读取 
		File file = new File("c:/test.txt");
		BufferedReader buf = new BufferedReader(new FileReader(file));
		if(buf.ready()){
			System.out.println(buf.readLine());
		}
		buf.close();
	//reset方法——重定位指针 
		File file = new File("c:/test.txt");
		BufferedReader buf = new BufferedReader(new FileReader(file));
		int count = 0;
		buf.mark(10);
		for(int i= 0; i< file.length();i++){
			count++;
			int read = buf.read();
			if(count%3 == 0)
			buf.reset();
			System.out.println(read);
		}
		buf.close();
	//skip方法——跳过指定数量的字符 
		File file = new File("c:/test.txt");
		BufferedReader buf = new BufferedReader(new FileReader(file));
		buf.skip(10);
		int i;
		while((i = buf.read())!=-1){
			System.out.println(i);
		}
		buf.close();
//javaioBufferedWriter——缓冲字符输出流 
	//close方法——关闭流 
		File file = new File("c:/test.txt");
		FileWriter fw = new FileWriter(file);
		BufferedWriter bufw = new BufferedWriter(fw);
		String str = "最近好吗";
		bufw.write(str);
		bufw.close();
		fw.close();
	//flush方法——刷新缓冲区 
		File file = new File("c:/test.txt");
		FileWriter fw = new FileWriter(file);
		String strArr[] = {"词典","参考大全","手册"};
		BufferedWriter bufw = new BufferedWriter(fw);
		for (int i = 0; i < strArr.length; i++) {
			bufw.write(strArr[i]);
		}
		bufw.flush();
		fw.close();
	//newLine方法——写入一个行分隔符 
		File file = new File("c:/test.txt");
		FileWriter fw = new FileWriter(file);
		String strArr[] = {"词典1","参考大全1","手册1"};
		BufferedWriter bufw = new BufferedWriter(fw);
		for (int i = 0; i < strArr.length; i++) {
			bufw.write(strArr[i]);
			bufw.newLine();
		}
		bufw.flush();
		fw.close();
	//write方法——向缓冲区中写数据 
		File file = new File("c:/test.txt");
		FileWriter fw = new FileWriter(file);
		char[] ch = {'a','b','c'};
		BufferedWriter bufw = new BufferedWriter(fw);
		bufw.write(ch,0,3);
		bufw.flush();
		fw.close();
//javaioDataInputStream——数据输入流 
	//read方法——读取一定数量的字节 
		File file = new File("c:/test.txt");
		FileInputStream fis = new FileInputStream(file);
		DataInputStream dis = new DataInputStream(fis);
		byte[] b = new byte[50];
		dis.read(b);
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}
		dis.close();
		fis.close();
	//readByte方法——读取此操作需要的字节 
		File file = new File("c:/test.txt");
		FileInputStream fis = new FileInputStream(file);
		DataInputStream dis = new DataInputStream(fis);
		System.out.println(dis.readByte());
		dis.close();
		fis.close();
	//readBoolean方法——读取一个布尔值 
		File file = new File("c:/test.txt");
		FileInputStream fis = new FileInputStream(file);
		DataInputStream dis = new DataInputStream(fis);
		System.out.println(dis.readBoolean());
		dis.close();
		fis.close();
	//readchar方法——读取此操作需要的字符 
		File file = new File("c:/test.txt");
		FileInputStream fis = new FileInputStream(file);
		DataInputStream dis = new DataInputStream(fis);
		System.out.println(dis.readChar());
		dis.close();
		fis.close();
	//readDouble方法——读取一个double值 
		File file = new File("c:/test.txt");
		FileInputStream fis = new FileInputStream(file);
		DataInputStream dis = new DataInputStream(fis);
		System.out.println(dis.readDouble());
		dis.close();
		fis.close();
	//readFloat方法——读取一个float值 
		File file = new File("c:/test.txt");
		FileInputStream fis = new FileInputStream(file);
		DataInputStream dis = new DataInputStream(fis);
		System.out.println(dis.readFloat());
		dis.close();
		fis.close();
	//readFully方法——读取一些字节 
		File file = new File("c:/test.txt");
		FileInputStream fis = new FileInputStream(file);
		DataInputStream dis = new DataInputStream(fis);
		byte[] b = new byte[20];
		dis.readFully(b);
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}
		dis.close();
		fis.close();
	//readInt方法——读取一个int值 
		File file = new File("c:/test.txt");
		FileInputStream fis = new FileInputStream(file);
		DataInputStream dis = new DataInputStream(fis);
		System.out.println(dis.readInt());
		dis.close();
		fis.close();
	//readLong方法——读取一个long值 
		File file = new File("c:/test.txt");
		FileInputStream fis = new FileInputStream(file);
		DataInputStream dis = new DataInputStream(fis);
		System.out.println(dis.readLong());
		dis.close();
		fis.close();
	//readShort方法——读取一个short值 
		File file = new File("c:/test.txt");
		FileInputStream fis = new FileInputStream(file);
		DataInputStream dis = new DataInputStream(fis);
		System.out.println(dis.readShort());
		dis.close();
		fis.close();
	//readUnsignedByte方法——读取无符号的byte值 
		File file = new File("c:/test.txt");
		FileInputStream fis = new FileInputStream(file);
		DataInputStream dis = new DataInputStream(fis);
		System.out.println(dis.readUnsignedByte());
		dis.close();
		fis.close();
	//readUnsignedShort方法——读取无符号的short值 
		File file = new File("c:/test.txt");
		FileInputStream fis = new FileInputStream(file);
		DataInputStream dis = new DataInputStream(fis);
		System.out.println(dis.readUnsignedShort());
		dis.close();
		fis.close();
	//readUTF方法——读取UTF-编码的字符串 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		DataOutputStream dos = new DataOutputStream(fos);
		dos.writeUTF("图书");
		FileInputStream fis = new FileInputStream(file);
		DataInputStream dis = new DataInputStream(fis);
		System.out.println(dis.readUTF());
		dos.close();
		dis.close();
		fos.close();
		fis.close();
	//skipBytes方法——在输入流中跳过数据的n字节 
		File file = new File("c:/test.txt");
		FileInputStream fis = new FileInputStream(file);
		DataInputStream dis = new DataInputStream(fis);
		byte[] b = new byte[50];
		dis.skipBytes(10);
		dis.read(b);
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}
		dis.close();
		fis.close();
//javaioDataOutputStream——数据输出流 
	//flush方法——清空此数据输出流 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		DataOutputStream dos = new DataOutputStream(fos);
		byte[] b = "欢迎使用".getBytes();
		dos.write(b);
		dos.flush();
		dos.close();
		fos.close();
	//size方法——返回计数器written的当前值 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		DataOutputStream dos = new DataOutputStream(fos);
		byte[] b = "欢迎使用".getBytes();
		dos.write(b);
		System.out.println(dos.size());
		dos.flush();
		dos.close();
		fos.close();
	//write方法——写入基础输出流 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		DataOutputStream dos = new DataOutputStream(fos);
		byte[] b = "欢迎使用".getBytes();
		dos.write(b);
		dos.flush();
		dos.close();
		fos.close();
	//writeBoolean方法——将boolean值写入输出流 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		DataOutputStream dos = new DataOutputStream(fos);
		dos.writeBoolean(true);
		dos.flush();
		dos.close();
		fos.close();
	//writeByte方法——将byte值写入输出流 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		DataOutputStream dos = new DataOutputStream(fos);
		dos.writeByte(99);
		dos.flush();
		dos.close();
		fos.close();
	//writeBytes方法——将字符串中每一个字符的低字节内容写入输出流 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		DataOutputStream dos = new DataOutputStream(fos);
		dos.writeBytes("JAVA");
		dos.flush();
		dos.close();
		fos.close();
	//writeChar方法——将char值写入输出流 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		DataOutputStream dos = new DataOutputStream(fos);
		char v = 'a';
		dos.writeChar(v);
		dos.flush();
		dos.close();
		fos.close();
	//writechars方法——将字符串每个char值写入输出流 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		DataOutputStream dos = new DataOutputStream(fos);
		dos.writeChars("JAVA");
		dos.flush();
		dos.close();
		fos.close();
	//writeDouble方法——将double值写入输出流 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		DataOutputStream dos = new DataOutputStream(fos);
		double v = 123.10;
		dos.writeDouble(v);
		dos.flush();
		dos.close();
		fos.close();
	//writeFloat方法——将float值写入输出流 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		DataOutputStream dos = new DataOutputStream(fos);
		float v = (float) 123.100;
		dos.writeFloat(v);
		dos.flush();
		dos.close();
		fos.close();
	//writeLong方法——将long值写入输出流 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		DataOutputStream dos = new DataOutputStream(fos);
		long v = 123456;
		dos.writeLong(v);
		dos.flush();
		dos.close();
		fos.close();
	//writeShort方法——将short值写入输出流 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		DataOutputStream dos = new DataOutputStream(fos);
		short v = 123;
		dos.writeShort(v);
		dos.flush();
		dos.close();
		fos.close();
	//writeUTF方法——将UTF-编码字符写入输出流 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		DataOutputStream dos = new DataOutputStream(fos);
		dos.writeUTF("写入文件的数据");
		dos.flush();
		dos.close();
		fos.close();
//javaioInputStream——字节输入流 
	//available方法——获取有效的可读取字节数 
		File file = new File("c:/test.txt");
		FileInputStream in = new FileInputStream(file);
		System.out.println(in.available());
	//close方法——关闭输入流 
		InputStream is = System.in;
		byte[] b = new byte[50];
		is.read(b);
		System.out.println("控制台内容"+new String(b).trim());
		is.close();
	//mark方法——在此输入流中标记当前的位置 
		File file = new File("c:/test.txt");
		InputStream bis = new BufferedInputStream(new FileInputStream(file));
		int count = 0;
		bis.mark(50);
		for (int i = 0; i < file.length(); i++) {
			int read = bis.read();
			if(count%5==0){
				bis.reset();
				System.out.println();
			}
			count++;
			System.out.println(read);
		}
		bis.close();
	//markSupported方法——判断是否支持mark和reset方法 
		File file = new File("c:/test.txt");
		FileInputStream in = new FileInputStream(file);
		if(in.markSupported()){
			System.out.println("支持mark和reset");
		}else {
			System.out.println("不支持");
		}
		in.close();
	//read方法——读取字节输入流中的数据 
		InputStream is = System.in;
		byte[] b = new byte[50];
		is.read(b);
		System.out.println("控制台内容"+new String(b).trim());
		is.close();
	//reset方法——重新定位到最后一次mark方法时的位置 
		File file = new File("c:/test.txt");
		FileInputStream in = new FileInputStream(file);
		BufferedInputStream bis = new BufferedInputStream(in);
		int count = 0;
		bis.mark(50);
		for (int i = 0; i < file.length(); i++) {
			count++;
			int read = bis.read();
			if(count== 5)
			bis.reset();
			System.out.println(read);
		}
		bis.close();
	//skip方法——跳过并丢弃n字节 
		File file = new File("c:/test.txt");
		FileInputStream in = new FileInputStream(file);
		in.skip(10);
		int i;
		while ((i = in.read())!=-1) {
			System.out.println(i);
		}
		in.close();
//javaioOutputStream——字节输出流 
	//close方法——关闭字节输出流 
		PrintStream out = System.out;
		byte[] b = "欢迎使用".getBytes();
		out.write(b);
		out.close();
	//flush方法——刷新缓冲区 
		PrintStream out = System.out;
		byte[] b = "欢迎使用".getBytes();
		out.write(b);
		out.flush();
		out.close();
	//write方法——向输出流写数据 
		PrintStream out = System.out;
		byte[] b = "欢迎使用".getBytes();
		out.write(b);
		out.flush();
		out.close();
//javaioObjectOutputStream——对象输出流 
	//close方法——关闭对象输出流 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.close();
		fos.close();
	//flush方法——刷新缓冲区 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.write(10);
		oos.flush();
		oos.close();
		fos.close();
	//writeObject方法——向输出流写入对象 
		public class javaTest {
			public static void main(String[] args) throws Throwable {
					File file = new File("c:/test.txt");
					FileOutputStream fos = new FileOutputStream(file);
					ObjectOutputStream oos = new ObjectOutputStream(fos);
					Student student = new Student();
					student.name = "小王";
					student.sex = "男";
					oos.writeObject(student);
					oos.flush();
					oos.close();
					fos.close();
				}
			}
		class Student implements Serializable{
			String name;
			String sex;
		}
	//writeBytes方法——向输出流写入字符串 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		String str = "JAVA";
		oos.writeBytes(str);
		oos.close();
		fos.close();
	//write方法——向输出流写入byte值 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		byte[] b = "JAVA".getBytes();
		oos.write(b);
		oos.close();
		fos.close();
	//writeChar方法——向输出流写入char值 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		char v = 'a';
		oos.writeChar(v);
		oos.close();
		fos.close();
	//writeChars方法——向输出流写入String值 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeChars("JAVA");
		oos.close();
		fos.close();
	//writeDouble方法——向输出流写入double值 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeDouble(123.456);
		oos.close();
		fos.close();
	//writeFields方法——将已缓冲的字段写入流中 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		double d = 123.456;
		oos.writeDouble(d);
		oos.writeFields();
		oos.close();
		fos.close();
	//writeFloat方法——向输出流写入float值 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeFloat(100.123f);
		oos.close();
		fos.close();
	//writeInt方法——向输出流写入int值 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeInt(100);
		oos.close();
		fos.close();
	//writeLong方法——向输出流写入long值 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		long v = 10000;
		oos.writeLong(v);
		oos.close();
		fos.close();
	//writeShort方法——向输出流写入short值 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		short v = 123;
		oos.writeShort(v);
		oos.close();
		fos.close();
	//writeUTF方法——向输出流写入float值 
		File file = new File("c:/test.txt");
		FileOutputStream fos = new FileOutputStream(file);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeUTF("aaaaa");
		oos.close();
		fos.close();
//javaioObjectInputStream——对象输入流 
	//readObject方法——从输入流读取对象 
		public class javaTest {
			public static void main(String[] args) throws Throwable {
				File file = new File("c:/test.txt");
				FileInputStream fis = new FileInputStream(file);
				ObjectInputStream ois = new ObjectInputStream(fis);
				Student st = (Student) ois.readObject();
				System.out.println(st.name);
				System.out.println(st.sex);
				ois.close();
				fis.close();
			}
		}
		class Student implements Serializable{
			String name;
			String sex;
		}
	//readInt方法——从输入流读取int值 
		File file = new File("c:/test.txt");
		FileInputStream fis = new FileInputStream(file);
		ObjectInputStream ois = new ObjectInputStream(fis);
		System.out.println(ois.readInt());
		ois.close();
		fis.close();
	//readFloat方法——从输入流读取float值 
		File file = new File("c:/test.txt");
		FileInputStream fis = new FileInputStream(file);
		ObjectInputStream ois = new ObjectInputStream(fis);
		System.out.println(ois.readFloat());
		ois.close();
		fis.close();
	//readchar方法——从输入流读取char值 
		File file = new File("c:/test.txt");
		FileInputStream fis = new FileInputStream(file);
		ObjectInputStream ois = new ObjectInputStream(fis);
		System.out.println(ois.readChar());
		ois.close();
		fis.close();
//javaioRandomAccessFile——随机文件访问类 
	//close方法——关闭数据流 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		r.read();
		r.close();
	//getChannel方法——返回此文件的FileChannel对象 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		FileChannel channel = r.getChannel();
		r.close();
	//getFD方法——返回此流的不透明文件描述符对象 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		FileDescriptor fd = r.getFD();
		r.close();
	//getFilePointer方法——返回文件中的当前偏移量 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		r.seek(10);
		System.out.println(r.getFilePointer());
		r.close();
	//length方法——返回此文件的长度 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		System.out.println(r.length());
		r.close();
	//read方法——读取一个数据字节 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		r.read();
		r.close();
	//readBoolean方法——从文件读取一个boolean值 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		System.out.println(r.readBoolean());
		r.close();
	//readByte方法——从文件读取一个byte值 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		System.out.println(r.readByte());
		r.close();
	//readInt方法——从文件读取一个int值 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		System.out.println(r.readInt());
		r.close();
	//readChar方法——从文件读取一个char值 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		System.out.println(r.readChar());
		r.close();
	//readDouble方法——从文件读取一个double值 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		System.out.println(r.readDouble());
		r.close();
	//readFloat方法——从文件读取一个float值 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		System.out.println(r.readFloat());
		r.close();
	//readFully方法——从文件读取一个字节数组 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		byte[] b = new byte[10];
		r.readFully(b);
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}
		r.close();
	//readLine方法——从此文件读取文本的下一行 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		System.out.println(r.readLine());
		r.close();
	//readLong方法——从文件读取一个long值 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		System.out.println(r.readLong());
		r.close();
	//readShort方法——从文件读取一个short值 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		System.out.println(r.readShort());
		r.close();
	//readUnsignedByte方法——从文件读取无符号byte值 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		System.out.println(r.readUnsignedByte());
		r.close();
	//readUnsignedShort方法——从文件读取无符号short值 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		System.out.println(r.readUnsignedShort());
		r.close();
	//readUTF方法——从此文件读取一个UTF-字符串 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		System.out.println(r.readUTF());
		r.close();
	//setLength方法——设置此文件的长度 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		r.setLength(10);
		r.close();
	//seek方法——将文件指针移至指定位置 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		r.seek(10);
		r.writeChars("欢迎使用");
		r.close();
	//skipBytes方法——跳过并丢弃n字节 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		r.skipBytes(3);
		System.out.println(r.read());
		r.close();
	//write方法——向此文件写入指定的字节 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		byte[] b = {65,66,67,68,69,70};
		r.seek(r.length());
		r.write(b);
		r.close();
	//writeBoolean方法——将boolean值写入文件 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		r.seek(r.length());
		boolean v = true;
		r.writeBoolean(v);
		r.close();
	//writeByte方法——将byte值写入该文件 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		r.seek(r.length());
		byte v = 24;
		r.writeByte(v);
		r.close();
	//writeBytes方法——按字节序列将该字符串写入该文件 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		r.seek(r.length());
		r.writeBytes("JAVA");
		r.close();
	//writeChars方法——写入作为字符数据的字符串 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		r.seek(r.length());
		r.writeChars("JAVA");
		r.close();
	//writeDouble方法——写入double值 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		r.seek(r.length());
		double v = 123.123d;
		r.writeDouble(v);
		r.close();
	//writeFloat方法——向文件写入float值 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		r.seek(r.length());
		float v = 123.123f;
		r.writeFloat(v);
		r.close();
	//writeInt方法——向文件写入int值 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		r.seek(r.length());
		int v = 123;
		r.writeInt(v);
		r.close();
	//writeLong方法——向文件写入long值 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		r.seek(r.length());
		long v = 123123;
		r.writeLong(v);
		r.close();
	//writeShort方法——向文件写入short值 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		r.seek(r.length());
		short v = 12;
		r.writeShort(v);
		r.close();
	//writeUTF方法——向文件写入UTF- 编码的字符串 
		File file = new File("c:/test.txt");
		RandomAccessFile r = new RandomAccessFile(file, "rw");
		r.seek(r.length());
		r.writeUTF("参考手册");
		r.close();
//javaioReader——读取字符流的抽象类 
	//close方法——关闭流 
		InputStreamReader rin = new InputStreamReader(System.in);
		char[] c = new char[50];
		rin.read(c);
		String str = new String(c);
		System.out.println(str.trim());
		rin.close();
	//mark方法——标记流中的当前位置 
		File file = new File("c:/test.txt");
		BufferedReader r = new BufferedReader(new FileReader(file));
		int count = 0;
		r.mark(10);
		for (int i = 0; i < file.length(); i++) {
			int read = r.read();
			if(count%5 == 0){
				r.reset();
				System.out.println();
			}
			count++;
			System.out.println(read);
		}
		r.close();
	//markSupported方法——判断是否支持mark操作 
		File file = new File("c:/test.txt");
		FileReader r = new FileReader(file);
		if(r.markSupported()){
			System.out.println("支持");
		}else{
			System.out.println("不支持");
		}
		r.close();
	//read方法——读取流中的数据 
		InputStreamReader r = new InputStreamReader(System.in);
		char[] c = new char[100];
		r.read(c);
		String str = new String(c);
		System.out.println(str.trim());
		r.close();
	//ready方法——判断是否准备读取此流 
		File file = new File("c:/test.txt");
		FileReader r = new FileReader(file);
		if(r.ready()){
			int i ;
			while ((i = r.read())!=-1) {
				System.out.println(i);
			}
		}
		r.close();
	//reset方法——重置该流 
		File file = new File("c:/test.txt");
		BufferedReader r = new BufferedReader(new FileReader(file));
		int count = 0;
		r.mark(5);
		for (int i = 0; i < file.length(); i++) {
			int read = r.read();
			if(count % 5 == 0){
				r.reset();
				System.out.println();
			}
			count++;
			System.err.println(read);
		}
		r.close();
	//skip方法——跳过并丢弃n字节 
		File file = new File("c:/test.txt");
		FileReader r = new FileReader(file);
		if(r.ready()){
			r.skip(10);
			int i;
			while ((i=r.read())!=-1) {
				System.out.println(i);
			}
		}
		r.close();
//javautilScanner——简单文本扫描器 
	//close方法——关闭扫描器 
		Scanner s = new Scanner("JAVA LIKE PHP");
		s.close();
	//delimiter方法——返回匹配分隔符的 Pattern 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		s.findInLine("(\\d+) and (\\d+) and (\\w+) and (\\w+)");
		MatchResult result = s.match();
		for (int i = 0; i < result.groupCount(); i++) {
			System.out.println(result.group(i));
		}
		s.close();
	//findInLine方法——忽略分隔符查找下一个构造模式 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		s.findInLine("(\\d+) and (\\d+) and (\\w+) and (\\w+)");
		MatchResult result = s.match();
		for (int i = 0; i < result.groupCount(); i++) {
			System.out.println(result.group(i));
		}
		s.close();
	//findWithinHorizon方法——试图查找下一个指定模式 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		String str = s.findWithinHorizon("and", 7);
		System.out.println(str);
		s.close();
	//hasNext方法——扫描器的输入中是否有另一个标记 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if (s.hasNext(Pattern.compile("\\d"))) {
			System.out.println("有另一个标记");
		}
		s.close();
	//hasNextBigDecimal方法——下一个标记是否默认基数中的一个 BigDecimal 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if (s.hasNextBigDecimal()) {
			System.out.println(s.nextBigDecimal());
		}
		s.close();
	//hasNextBigInteger方法——下一个标记是否默认基数中的一个BigInteger 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if (s.hasNextBigInteger()) {
			System.out.println(s.nextBigInteger());
		}
		s.close();
	//hasNextBoolean方法——下一个标记是否为布尔值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if (s.hasNextBoolean()) {
			System.out.println(s.nextBoolean());
		}
		s.close();
	//hasNextByte方法——下一个标记是否为byte值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if (s.hasNextByte()) {
			System.out.println(s.nextByte());
		}
		s.close();
	//hasNextDouble方法——下一个标记是否为double值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if (s.hasNextDouble()) {
			System.out.println(s.nextDouble());
		}
		s.close();
	//hasNextFloat方法——下一个标记是否为float值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if (s.hasNextFloat()) {
			System.out.println(s.nextFloat());
		}
		s.close();
	//hasNextInt方法——下一个标记是否为int值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if (s.hasNextInt()) {
			System.out.println(s.nextInt());
		}
		s.close();
	//hasNextLine方法——是否存在下一行 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if (s.hasNextLine()) {
			System.out.println(s.nextLine());
		}
		s.close();
	//hasNextLong方法——下一个标记是否为long值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if (s.hasNextLong()) {
			System.out.println(s.nextLong());
		}
		s.close();
	//hasNextShort方法——下一个标记是否为short值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if (s.hasNextShort()) {
			System.out.println(s.nextShort());
		}
		s.close();
	//ioException方法——最后抛出的 IOException 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		IOException ie = s.ioException();
		if(ie != null){
			ie.printStackTrace();
		}
		s.close();
	//locale方法——返回此扫描器的语言环境 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		System.out.println(s.locale());
		s.close();
	//match方法——最后扫描操作的匹配结果 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		s.findInLine("(\\d+) and (\\d+) and (\\w+) and (\\w+)");
		MatchResult result = s.match();
		for (int i = 0; i < result.groupCount(); i++) {
			System.out.println(result.group(i));
		}
		s.close();
	//next方法——读取下一个完整标记 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if(s.hasNext()){
			System.out.println(s.next());
		}
		s.close();
	//nextBigDecimal方法——读取下一个BigDecimal值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if(s.hasNextBigDecimal()){
			System.out.println(s.nextBigDecimal());
		}
		s.close();
	//nextBigInteger方法——读取下一个BigInteger值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if(s.hasNextBigInteger()){
			System.out.println(s.nextBigInteger());
		}
		s.close();
	//nextBoolean方法——读取下一个boolean值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if(s.hasNextBoolean()){
			System.out.println(s.nextBoolean());
		}
		s.close();
	//nextByte方法——读取下一个byte值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if(s.hasNextByte()){
			System.out.println(s.nextByte());
		}
		s.close();
	//nextDouble方法——读取下一个double值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if(s.hasNextDouble()){
			System.out.println(s.nextDouble());
		}
		s.close();
	//nextFloat方法——读取下一个float值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if(s.hasNextFloat()){
			System.out.println(s.nextFloat());
		}
		s.close();
	//nextInt方法——读取下一个int值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if(s.hasNextInt()){
			System.out.println(s.nextInt());
		}
		s.close();
	//nextShort方法——读取下一个short值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if(s.hasNextShort()){
			System.out.println(s.nextShort());
		}
		s.close();
	//nextLine方法——读取下一行文本 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if(s.hasNextLine()){
			System.out.println(s.nextLine());
		}
		s.close();
	//nextLong方法——读取下一个long值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if(s.hasNextLong()){
			System.out.println(s.nextLong());
		}
		s.close();
	//nextShort方法——读取下一个short值 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		if(s.hasNextShort()){
			System.out.println(s.nextShort());
		}
		s.close();
	//radix方法——返回扫描器的默认基数 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		System.out.println(s.radix());
		s.close();
	//reset方法——重置扫描器 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		s.useRadix(4);
		s.reset();
		s.close();
	//skip方法——忽略分隔符跳过匹配的输入信息 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		s.skip(Pattern.compile("\\d and"));
		if(s.hasNext()){
			System.out.println(s.next());
		}
		s.close();
	//toString方法——返回扫描器的字符串表示形式 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		System.out.println(s.toString());
		s.close();
	//useDelimiter方法——设置为指定分隔模式 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		s.useDelimiter(Pattern.compile("\\sfish\\s"));
		s.close();
	//useLocale方法——设置为指定的语言环境 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		s.useDelimiter(Pattern.compile("\\sfish\\s"));
		s.useLocale(new Locale("EN","US"));
		System.out.println(s.locale());
		s.close();
	//useRadix方法——设置指定基数 
		Scanner s = new Scanner("1 and 2 and yellow and blue and");
		s.useRadix(16);
		System.out.println(s.radix());
		s.close();
//javautilWriter——写入字符流的抽象类 
	//append方法——添加指定字符 
		PrintWriter out = new PrintWriter(System.out);
		out = out.append('a');
		out.write(0);
		out.close();
	//close方法——关闭数据流 
		PrintWriter out = new PrintWriter(System.out);
		out = out.append('a');
		out.write(0);
		out.close();
	//flush方法——刷新流的缓冲 
		PrintWriter out = new PrintWriter(System.out);
		out.write("欢迎使用");
		out.flush();
		out.close();
	//write方法——向字符输出流中写数据 
		PrintWriter out = new PrintWriter(System.out);
		out.write("欢迎使用");
		out.flush();
		out.close();
<!--数据库操作 ->
//javasqlDriverManager——驱动程序管理类 
	//deregisterDriver方法——删除一个驱动程序 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Driver driver = DriverManager.getDriver(url);
		DriverManager.deregisterDriver(driver);
	//getDriver方法——选择一个适当的驱动程序 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Driver driver = DriverManager.getDriver(url);
		DriverManager.deregisterDriver(driver);
	//getDrivers方法——获取全部已加载的驱动程序 
		Class.forName("com.mysql.jdbc.Driver");
		Enumeration<Driver> em = DriverManager.getDrivers();
		while (em.hasMoreElements()) {
			Driver d = em.nextElement();
			System.out.println(d.getClass().getName());
		}
	//getConnection方法——获取数据库连接 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		System.out.println("连接成功");
	//getLoginTimeout方法——获取连接数据库的等待时间 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		System.out.println(DriverManager.getLoginTimeout());
	//getLogWriter方法——获取日志的打印输出流 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		PrintWriter out = DriverManager.getLogWriter();
		if(out != null){
			out.print("得到信息");
			out.close();
		}
	//println方法——输出日志 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		DriverManager.println("获取驱动成功");
	//registerDriver方法——注册给定的驱动程序 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Driver driver = DriverManager.getDriver(url);
		DriverManager.deregisterDriver(driver);
		DriverManager.registerDriver(driver);
	//setLoginTimeout方法——设置连接数据库的等待时间 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		DriverManager.setLoginTimeout(10);
	//setLogWriter方法——设置日志的打印输出流 
		File file = new File("c:/test.txt");
		PrintWriter out = new PrintWriter(file);
		DriverManager.setLogWriter(out);
//javasqlConnection——数据库连接接口 
	//clearWarnings方法——清除警告信息 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		con.clearWarnings();
	//close方法——关闭数据库连接对象 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		con.close();
	//commit方法——提交事务 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		con.setAutoCommit(false);
		Statement st = con.createStatement();
		String sql = "insert into users(username,password)values('xiaoli','123456')";
		st.execute(sql);
		con.commit();
	//createBlob方法——构造二进制的对象 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		con.setAutoCommit(true);
		Blob blob = con.createBlob();
	//createNClob方法——构造字节字符的对象 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		con.setAutoCommit(true);
		NClob nclob = con.createNClob();
	//createSQLXML方法——构造SQLXML对象 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		con.setAutoCommit(true);
		SQLXML sqlXML = con.createSQLXML();
	//createStatement方法——创建一个Statement对象 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		con.setAutoCommit(true);
		Statement st = con.createStatement();
	//getAutoCommit方法——获取提交模式 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		con.setAutoCommit(true);
		Statement st = con.createStatement();
	//getCatalog方法——获取当前目录名称 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		System.out.println(con.getCatalog());
	//getClientInfo方法——获取客户端信息列表 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Properties props = con.getClientInfo();
	//getHoldability方法——获取ResultSet对象的可保存性 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		System.out.println(con.getHoldability());
	//getMetaData方法——获取数据库的元数据 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		DatabaseMetaData metaData = con.getMetaData();
	//getTransactionIsolation方法——获取事务隔离级别 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		System.out.println(con.getTransactionIsolation());
	//getTypeMap方法——获取Map对象 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Map<String, Class<?>> map = con.getTypeMap();
	//getWarnings方法——获取调用报告的第一个警告 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		SQLWarning warning = con.getWarnings();
	//isClosed方法——判断Connection对象是否被关闭 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		System.out.println(con.isClosed());
		con.close();
		System.out.println(con.isClosed());
	//isReadOnly方法——判断Connection对象是否为只读模式 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		System.out.println(con.isReadOnly());
	//isValid方法——判断连接是否有效 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		if(con.isValid(10)){
			System.out.println("连接有效");
		}
	//nativeSQL方法——返回SQL语句的本机形式 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select top 10 * from users";
		System.out.println(con.nativeSQL(sql));
	//prepareCall方法——调用数据库存储过程 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "{call saveuser(?,?)}";
		con.prepareCall(sql);
	//prepareStatement方法——创建一个预处理语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users where password = 123456";
		PreparedStatement ps = con.prepareStatement(sql);
	//rollback方法——事务回滚 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement st = con.createStatement();
		con.setAutoCommit(false);
		st.execute("delete from users where username = 'xiaoli'");
		con.rollback();
	//setAutoCommit方法——设置数据库连接的提交模式 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement st = con.createStatement();
		con.setAutoCommit(false);
		st.execute("delete from users where username = 'xiaoli'");
		con.rollback();
	//setCatalog方法——设置目录名称 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		con.setCatalog("gmy");
	//setClientInfo方法——设置客户端信息 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Properties props = new Properties();
		props.setProperty("ClientUser", "root");
		props.setProperty("ClientHostname", "root");
		con.setClientInfo(props);
	//setHoldability方法——设置ResultSet对象的可保存性 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		con.setHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT);
	//setReadOnly方法——设置连接只读模式 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		con.setReadOnly(true);
	//setSavepoint方法——创建一个未命名的保存点 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		con.setSavepoint();
	//releaseSavepoint方法——移除指定的SavePoint示例 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Savepoint sp = con.setSavepoint("spName");
		con.releaseSavepoint(sp);
	//setTransactionIsolation方法——设置事务隔离级别 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		int level = Connection.TRANSACTION_SERIALIZABLE;
		con.setTransactionIsolation(level);
	//getTransactionIsolation方法——获取事务隔离级别 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		int level = con.getTransactionIsolation();
		System.out.println(level);
//javasqlStatement——执行SQL语句接口 
	//addBatch方法——添加批处理语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql1 = "insert into users values('aaa','111')";
		String sql2 = "insert into users values('bbb','111')";
		String sql3 = "insert into users values('ccc','111')";
		Statement stmt = con.createStatement();
		stmt.addBatch(sql1);
		stmt.addBatch(sql2);
		stmt.addBatch(sql3);
		stmt.executeBatch();
		stmt.close();
	//cancel方法——中止SQL语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		stmt.cancel();
	//clearBatch方法——清除批处理语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql1 = "insert into users values('aaa','111')";
		String sql2 = "insert into users values('bbb','111')";
		Statement stmt = con.createStatement();
		stmt.addBatch(sql1);
		stmt.addBatch(sql2);
		stmt.clearBatch();
		stmt.close();
	//clearWarnings方法——清除所有警告 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		stmt.clearWarnings();
	//execute方法——执行SQL语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql1 = "insert into users values('ddd','111')";
		Statement stmt = con.createStatement();
		boolean bool = stmt.execute(sql1);
		System.out.println(bool);
	//executeBatch方法——执行批处理语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql1 = "insert into users values('eee','111')";
		String sql2 = "insert into users values('fff','111')";
		String sql3 = "insert into users values('ggg','111')";
		Statement stmt = con.createStatement();
		stmt.addBatch(sql1);
		stmt.addBatch(sql2);
		stmt.addBatch(sql3);
		stmt.executeBatch();
		stmt.close();
		con.close();
	//executeUpdate方法——执行更新操作 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "delete from users";
		Statement stmt = con.createStatement();
		stmt.addBatch(sql);
		stmt.executeUpdate(sql);
		stmt.close();
		con.close();
	//executeQuery方法——执行查询操作 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement stmt = con.createStatement();
		ResultSet rs = stmt.executeQuery(sql);
		stmt.close();
		con.close();
	//getConnection方法——获取数据库连接对象 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		Connection conn2 = stmt.getConnection();
		stmt.close();
		con.close();
	//getFetchDirection方法——获取从数据库表获取行的方向 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		System.out.println(stmt.getFetchDirection());
		stmt.close();
		con.close();
	//getFetchSize方法——获取结果集的行数 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		System.out.println(stmt.getFetchSize());
		stmt.close();
		con.close();
	//getGeneratedKeys方法——获取自动生成的键 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		ResultSet rs = stmt.getGeneratedKeys();
		stmt.close();
		con.close();
	//getMaxFieldSize方法——获取最大字节数 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		System.out.println(stmt.getMaxFieldSize());
		stmt.close();
		con.close();
	//getMaxRows方法——获取最大行数 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		System.out.println(stmt.getMaxRows());
		stmt.close();
		con.close();
	//getMoreResults方法——移动到Statement对象的下一个结果 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		if(stmt.getMoreResults()){
			System.out.println("下一个对象");
		}
		stmt.close();
		con.close();
	//getQueryTimeout方法——获取等待执行的秒数 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		System.out.println(stmt.getQueryTimeout());
		stmt.close();
		con.close();
	//getResultSet方法——获取结果集 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		String sql = "select * from users";
		ResultSet rs = stmt.executeQuery(sql);
		while (rs.next()) {
			System.out.println(rs.getString(1));
		}
		stmt.close();
		con.close();
	//getResultSetConcurrency方法——获取结果集并发性 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		System.out.println(stmt.getResultSetConcurrency());
		stmt.close();
		con.close();
	//getResultSetHoldability方法——获取结果集可保存性 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		System.out.println(stmt.getResultSetHoldability());
		stmt.close();
		con.close();
	//getResultSetType方法——获取结果集类型 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		System.out.println(stmt.getResultSetType());
		stmt.close();
		con.close();
	//getUpdateCount方法——获取更新的记录数 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		System.out.println(stmt.getUpdateCount());
		stmt.close();
		con.close();
	//getWarnings方法——获取调用报告的第一个警告 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		System.out.println(stmt.getWarnings());
		stmt.close();
		con.close();
	//setMaxRows方法——获取最大行数 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		stmt.setMaxRows(20);
		stmt.close();
		con.close();
	//getMaxRows方法——获取最大行数限制值 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		System.out.println(stmt.getMaxRows());
		stmt.close();
		con.close();
	//close方法——关闭Statement对象 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		stmt.close();
		con.close();
	//isClosed方法——判断Statement对象是否关闭 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		System.out.println(stmt.isClosed());
		stmt.close();
		System.out.println(stmt.isClosed());
		con.close();
	//isPoolable方法——判断对象是否可池化 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		System.out.println(stmt.isPoolable());
		stmt.close();
		con.close();
	//setCursorName方法——设置指针名称 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		stmt.setCursorName("pname");
		stmt.close();
		con.close();
	//setEscapeProcessing方法——设置是否进行转义处理 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		stmt.setEscapeProcessing(true);
		stmt.close();
		con.close();
	//setFetchDirection方法——设置处理行的方向 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		stmt.setFetchDirection(ResultSet.FETCH_FORWARD);
		stmt.close();
		con.close();
	//setFetchSize方法——设置结果集合的最大行数 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		stmt.setFetchSize(50);
		stmt.close();
		con.close();
	//setMaxFieldSize方法——设置可返回的最大字节数 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		stmt.setMaxFieldSize(1000);
		stmt.close();
		con.close();
	//setMaxRows方法——设置最大行数 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		stmt.setMaxRows(20);
		stmt.close();
		con.close();
	//setPoolable方法——设置语句是否可池化 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		stmt.setPoolable(true);
		stmt.close();
		con.close();
	//setQueryTimeout方法——设置等待执行的秒数 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		stmt.setQueryTimeout(5);
		stmt.close();
		con.close();
//javasqlPreparedStatement——预编译SQL语句接口 
	//clearParameters方法——立即清除当前参数值 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "update users set username = ? where username= ? ";
		PreparedStatement ps = con.prepareStatement(sql);
		ps.setString(1, "ccc");
		ps.setString(2, "aaa");
		ps.clearParameters();
		ps.executeUpdate();
		con.close();
	//execute方法——执行SQL语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		PreparedStatement ps = con.prepareStatement(sql);
		boolean bool = ps.execute();
		System.out.println(bool);
		con.close();
	//executeQuery方法——执行SQL查询语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		PreparedStatement ps = con.prepareStatement(sql);
		ResultSet rs = ps.executeQuery();
		con.close();
	//executeUpdate方法——执行更新语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "insert into users values(?,?)";
		PreparedStatement ps = con.prepareStatement(sql);
		ps.setString(1, "ddd");
		ps.setString(2, "1111");
		int i = ps.executeUpdate();
		System.out.println(i);
		con.close();
	//getMetaData方法——获取ResultSet对象列的信息 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "insert into users values(?,?)";
		PreparedStatement ps = con.prepareStatement(sql);
		ResultSetMetaData rsmd = ps.getMetaData();
		System.out.println(rsmd.getColumnName(0));
		con.close();
	//getParameterMetaData方法——获取参数信息 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "insert into users values(?,?)";
		PreparedStatement ps = con.prepareStatement(sql);
		ParameterMetaData pmd = ps.getParameterMetaData();
		con.close();
	//setAsciiStream方法——将指定参数设置为给定输入流 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		FileInputStream is1 = new FileInputStream(new File("c:/1.txt"));
		FileInputStream is2 = new FileInputStream(new File("c:/2.txt"));
		String sql = "insert into users values(?,?)";
		PreparedStatement ps = con.prepareStatement(sql);
		ps.setAsciiStream(1, is1);
		ps.setAsciiStream(2, is2);
		ps.executeUpdate();
		ps.close();
		con.close();
	//setBigDecimal方法——设置大数字参数值 
		//设置大数字参数值
	//setBinaryStream方法——设置二进制参数值 
		//设置二进制参数值 
	//setBlob方法——设置Blob型参数 
		//设置Blob型参数 
	//setBoolean方法——设置布尔型参数 
		//设置布尔型参数 
	//setByte方法——设置字节型参数 
		//设置字节型参数 
	//setBytes方法——设置字节数组型参数 
		//设置字节数组型参数
	//setCharacterStream方法——将指定参数设置为给定Reader对象 
		//将指定参数设置为给定Reader对象 
	//setClob方法——设置Clob型参数 
		//设置Clob型参数 
	//setDate方法——设置日期型参数 
		//设置日期型参数 
	//setDouble方法——设置双精度型参数 
		//设置双精度型参数 
	//setFloat方法——设置单精度型参数 
		//设置单精度型参数 
	//setInt方法——设置整型参数 
		//设置整型参数
	//setLong方法——设置长整型参数 
		//设置长整型参数 
	//setNCharacterStream方法——将指定参数设置为Reader对象 
		//将指定参数设置为Reader对象
	//setNClob方法——设置NClob类型的参数 
		//设置NClob类型的参数
	//setNString方法——设置String类型的参数 
		//设置String类型的参数
	//setShort方法——设置Short类型的参数 
		//设置Short类型的参数 
	//setString方法——设置String类型的参数 
		//设置String类型的参数
	//setTime方法——设置时间类型的参数 
		//设置时间类型的参数
	//setTimestamp方法——设置参数值为时间戳 
		//设置参数值为时间戳
	//setURL方法——设置参数为URL 
		//设置参数为URL 
//javasqlResultSet——结果集接口 
	//absolute方法——将光标移动到指定行 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		boolean b = rs.absolute(5);
		System.out.println(b);
		con.close();
	//afterLast方法——将光标移动到最后一行之后 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		rs.afterLast();
		con.close();
	//beforeFirst方法——将光标移动到第一行之前 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		rs.beforeFirst();
		con.close();
	//cancelRowUpdates方法——取消对当前行所做的更新 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		PreparedStatement ps = con.prepareStatement(sql,ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
		ResultSet rs = ps.executeQuery();
		if(rs.next()){
			if(rs.absolute(5)){
				rs.updateString("username", "abc");
				rs.cancelRowUpdates();
				rs.updateRow();
			}
		}
		rs.close();
		con.close();
	//clearWarnings方法——清除所有警告 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		PreparedStatement ps = con.prepareStatement(sql);
		ResultSet rs = ps.executeQuery();
		rs.clearWarnings();
		rs.close();
		con.close();
	//close方法——关闭ResultSet对象 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		PreparedStatement ps = con.prepareStatement(sql);
		rs.close();
		con.close();
	//deleteRow方法——删除当前行 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		PreparedStatement ps = con.prepareStatement(sql,ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
		ResultSet rs = ps.executeQuery();
		if(rs.next()){
			rs.deleteRow();
		}
		rs.close();
		con.close();
	//findColumn方法——获取ResultSet的列索引 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		PreparedStatement ps = con.prepareStatement(sql,ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
		ResultSet rs = ps.executeQuery();
		if(rs.next()){
			int i = rs.findColumn("username");
			System.out.println(i);
		}
		rs.close();
		con.close();
	//first方法——将光标移动到第一行 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		boolean bool = rs.first();
		System.out.println(bool);
		rs.close();
		con.close();
	//getAsciiStream方法——获取指定列的ASCII字符流的值 
		//获取指定列的ASCII字符流的值
	//getBigDecimal方法——获取BigDecimal型的数据 
		//获取BigDecimal型的数据 
	//getBinaryStream方法——获取字节流型的数据 
		//获取字节流型的数据 
	//getBlob方法——获取Blob型的数据 
		//获取Blob型的数据 
	//getBoolean方法——获取布尔型的数据 
		//获取布尔型的数据
	//getByte方法——获取字节型的数据 
		//获取字节型的数据
	//getBytes方法——获取字节数组的数据 
		//获取字节数组的数据 
	//getCharacterStream方法——获取Reader型的数据 
		//获取Reader型的数据 
	//getClob方法——获取Clob型的数据 
		//获取Clob型的数据 
	//getConcurrency方法——获取并发模式 
		//获取并发模式
	//getCursorName方法——获取SQL光标的名称 
		//获取SQL光标的名称 
	//getDate方法——获取日期型的数据 
		//获取日期型的数据
	//getDouble方法——获取双精度型的数据 
		//获取双精度型的数据 
	//getFetchDirection方法——获取方向 
		//获取方向 
	//getFetchSize方法——获取ResultSet对象的当前获取大小 
		//获取ResultSet对象的当前获取大小 
	//getFloat方法——获取单精度型的数据 
		//获取单精度型的数据 
	//getHoldability方法——获取可保存性 
		//获取可保存性 
	//getInt方法——获取整型数据 
		//获取整型数据
	//getLong方法——获取长整型数据 
		//获取长整型数据
	//getMetaData方法——获取对象的列信息 
		//获取对象的列信息 
	//getNCharacterStream方法——获取Reader形式的数据 
		//获取Reader形式的数据
	//getNClob方法——获取NClob型的数据 
		//获取NClob型的数据 
	//getNString方法——获取String型的数据 
		//获取String型的数据 
	//getObject方法——获取object型的数据 
		//获取object型的数据
	//getRow方法——获取当前行编号 
		//获取当前行编号 
	//getShort方法——获取短整型的数据 
		//获取短整型的数据
	//getStatement方法——获取Statement对象 
		//获取Statement对象 
	//getString方法——获取String类型的数据 
		//获取String类型的数据 
	//getTime方法——获取时间型的数据 
		//获取时间型的数据
	//getTimestamp方法——获取时间戳 
		//获取时间戳
	//getType方法——获取ResultSet对象的类型 
		//获取ResultSet对象的类型
	//getURL方法——获取URL对象形式的数据 
		//获取URL对象形式的数据 
	//getWarnings方法——获取报告的第一个警告 
		//获取报告的第一个警告 
	//insertRow方法——插入当前行到数据库中 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		PreparedStatement ps = con.prepareStatement(sql,ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
		ResultSet rs = ps.executeQuery();
		rs.moveToInsertRow();
		rs.updateString("username", "fffff");
		rs.updateString("password", "11111");
		rs.insertRow();
		rs.close();
		con.close();
	//isAfterLast方法——判断光标是否位于最后一行之后 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		System.out.println(rs.isAfterLast());
		rs.afterLast();
		System.out.println(rs.isAfterLast());
		rs.close();
		con.close();
	//isBeforeFirst方法——判断光标是否位于第一行之前 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		System.out.println(rs.isBeforeFirst());
		rs.next();
		System.out.println(rs.isAfterLast());
		rs.close();
		con.close();
	//isClosed方法——判断ResultSet对象是否已经关闭 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		System.out.println(rs.isClosed());
		rs.close();
		System.out.println(rs.isClosed());
		con.close();
	//isFirst方法——判断光标是否位于第一行 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		System.out.println(rs.isFirst());
		rs.first();
		System.out.println(rs.isFirst());
		con.close();
	//isLast方法——判断光标是否位于最后一行 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		System.out.println(rs.isLast());
		rs.last();
		System.out.println(rs.isLast());
		con.close();
	//last方法——将光标移动到最后一行 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		rs.last();
		con.close();
	//moveToCurrentRow方法——将光标移动到记住的光标位置 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		PreparedStatement ps = con.prepareStatement(sql);
		ResultSet rs = ps.executeQuery();
		rs.next();
		rs.moveToCurrentRow();
		ps.close();
		rs.close();
		con.close();
	//moveToInsertRow方法——将光标移动到插入行 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		PreparedStatement ps = con.prepareStatement(sql);
		ResultSet rs = ps.executeQuery();
		rs.next();
		rs.moveToInsertRow();
		rs.updateString("username", "dddd");
		rs.updateString("passsword", "11111");
		ps.close();
		rs.close();
		con.close();
	//next方法——将光标从当前的位置向下移动一行 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		while (rs.next()) {
			System.out.println(rs.getString("username"));
		}
		rs.close();
		st.close();
		con.close();
	//previous方法——光标移动到上一行 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		System.out.println(rs.previous());
		rs.close();
		st.close();
		con.close();
	//relative方法——按相对行数移动光标 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		rs.relative(2);
		System.out.println(rs.getRow());
		rs.close();
		st.close();
		con.close();
	//setFetchDirection方法——设置行的处理方向 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		PreparedStatement ps = con.prepareStatement(sql);
		ResultSet rs = ps.executeQuery();
		rs.setFetchDirection(ResultSet.FETCH_FORWARD);
		rs.close();
		ps.close();
		con.close();
	//setFetchSize方法——设置结果集的最大行数 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		PreparedStatement ps = con.prepareStatement(sql);
		ResultSet rs = ps.executeQuery();
		rs.setFetchSize(10);
		rs.close();
		ps.close();
		con.close();
	//updateBigDecimal方法——用BigDecimal值更新指定列 
		//用BigDecimal值更新指定列 
	//updateBoolean方法——用boolean值更新指定列 
		//用boolean值更新指定列 
	//updateByte方法——用byte值更新指定列 
		//用byte值更新指定列 
	//updateBytes方法——用byte数组值更新指定列 
		//用byte数组值更新指定列
	//updateDate方法——用Date值更新指定列 
		//用Date值更新指定列
	//updateDouble方法——用double值更新指定列 
		//用double值更新指定列 
	//updateFloat方法——用float值更新指定列 
		//用float值更新指定列 
	//updateInt方法——用int值更新指定列 
		//用int值更新指定列 
	//updateLong方法——用long值更新指定列 
		//用long值更新指定列 
	//updateNString方法——用String值更新指定列 
		//用String值更新指定列 
	//updateNull方法——用null值更新指定列 
		//用null值更新指定列 
	//updateRow方法——更新当前行 
		//更新当前行
	//updateShort方法——用short值更新指定列 
		//用short值更新指定列
	//updateString方法——用String值更新指定列 
		//用String值更新指定列
	//updateTime方法——用Time值更新指定列 
		//用Time值更新指定列 
	//updateTimestamp方法——用时间戳更新指定列 
		//用时间戳更新指定列 
<!--安全与加密 ->
//javasecurity、Key接口 
	//getAlgorithm方法——返回当前密钥的算法名称 
		KeyGenerator generator = KeyGenerator.getInstance("DES");
		SecretKey key = generator.generateKey();
		String algorithm = key.getAlgorithm();
		System.out.println(algorithm);
	//getEncoded方法——返回当前密钥 
		KeyGenerator generator = KeyGenerator.getInstance("DES");
		SecretKey key = generator.generateKey();
		byte[] encoded = key.getEncoded();
	//getFormat方法——返回密钥的基本编码格式 
		KeyGenerator generator = KeyGenerator.getInstance("DES");
		SecretKey key = generator.generateKey();
		String format = key.getFormat();
		System.out.println(format);
//javasecurityKeyPair类 	
	//getPrivate方法——返回对密钥对的私钥组件的引用 
		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
		KeyPair keyPair = keyPairGen.generateKeyPair();
		PrivateKey key = keyPair.getPrivate();
		System.out.println(key);
	//getPublic方法——返回对密钥对的公钥组件的引用 
		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
		KeyPair keyPair = keyPairGen.generateKeyPair();
		PublicKey key = keyPair.getPublic();
		System.out.println(key);
//javasecurityKeyPairGenerator类 	
	//generateKeyPair方法——生成一个密钥对 
		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
		KeyPair keyPair = keyPairGen.generateKeyPair();
	//getAlgorithm方法——返回密钥对生成器算法的标准名称 
		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
		String algorithm = keyPairGen.getAlgorithm();
		System.out.println(algorithm);
	//getInstance方法——返回生成指定算法密钥对的KeyPairGenerator对象 
		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
	//initialize方法——初始化密钥对生成器 
		DHPublicKey dhPublicKey = null;
		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("DH");
		keyPairGen.initialize(dhPublicKey.getParams());
//javasecuritySignature类 	
	//getAlgorithm方法——返回签名对象的算法名称 
		Signature signature = Signature.getInstance("MD5withRSA");
		String algorithm = signature.getAlgorithm();
		System.out.println(algorithm);
	//getInstance方法——返回实现指定签名算法的Signature对象 
		Signature signature = Signature.getInstance("MD5withRSA");
	//initSign方法——初始化当前签名的对象 
		Signature signature = Signature.getInstance("MD5withRSA");
		PrivateKey privateKey = null;
		signature.initSign(privateKey);
	//initVerify方法——初始化签名验证 
		Signature signature = Signature.getInstance("MD5withRSA");
		PrivateKey privateKey = null;
		signature.initVerify(privateKey);
	//sign方法——返回已经更新数据的签名 
		byte[] data = null;
		PrivateKey privateKey = null;
		Signature signature = Signature.getInstance("MD5withRSA");
		signature.initSign(privateKey);
		signature.update(data);
		byte[] sign = signature.sign();
	//update方法——更新要签名或验证的数据 
		byte[] data = null;
		PrivateKey privateKey = null;
		Signature signature = Signature.getInstance("MD5withRSA");
		signature.initSign(privateKey);
		signature.update(data);
	//verify方法——验证签名是否有效 
		PublicKey publicKey = null;
		Signature signature = Signature.getInstance("MD5withRSA");
		signature.initVerify(publicKey);
//javasecuritySecureRandom类 	
	//SecureRandom方法——构造实现默认随机数算法的安全随机数生成器 
		SecureRandom secureRandom = new SecureRandom();
	//getSeed方法——返回随机数生成器的种子字节数量 
		SecureRandom secureRandom = new SecureRandom();
		byte[] seed = secureRandom.getSeed(5);
		for (int i = 0; i < seed.length; i++) {
			System.out.println(seed[i]);
		}
	//nextBytes方法——为字节数组生成随机数 
		SecureRandom secureRandom = new SecureRandom();
		byte[] by = new byte[5];
		secureRandom.nextBytes(by);
		for (int i = 0; i < by.length; i++) {
			System.out.println(by[i]);
		}
	//setSeed方法——重新设置随机对象的种子 
		SecureRandom secureRandom = new SecureRandom();
		byte[] by = secureRandom.getSeed(5);
		secureRandom.setSeed(by);
//javaxcryptoCipher类 	
	//doFinal方法——结束加密或解密的操作 
		//结束加密或解密的操作 
	//getAlgorithm方法——返回当前Cipher对象的算法名称 
		Cipher cipher = Cipher.getInstance("DES");
		String algorithm = cipher.getAlgorithm();
		System.out.println(algorithm);
	//getBlockSize方法——返回块的大小 
		Cipher cipher = Cipher.getInstance("DES");
		int blockSize = cipher.getBlockSize();
		System.out.println(blockSize);
	//getInstance方法——返回实现指定转换的Cipher对象 
		Cipher cipher = Cipher.getInstance("DES");
	//init方法——用密钥初始化当前Cipher对象 
		Key key = null;
		Cipher cipher = Cipher.getInstance("DES");
		cipher.init(Cipher.DECRYPT_MODE, key);
	//update方法——继续多部分加密或解密操作 
		//继续多部分加密或解密操作
//javaxcryptoSecretKeyFactory类 	
	//generateSecret方法——根据密钥规范生成密钥 
		//根据密钥规范生成密钥
	//getAlgorithm方法——返回当前SecretKeyFactory对象的算法名称 
		//返回当前SecretKeyFactory对象的算法名称
	//getInstance方法——返回转换指定算法秘密密钥的SecretKeyFactory对象 
		SecretKeyFactory factory = SecretKeyFactory.getInstance("des");
		Provider provider = factory.getProvider();
		System.out.println(provider.getInfo());
	//getProvider方法——返回当前SecretKeyFactory对象的提供者 
		SecretKeyFactory factory = SecretKeyFactory.getInstance("des");
		Provider provider = factory.getProvider();
		System.out.println(provider.getInfo());
<!--网络传输 ->
//javanetInetAddress类 
	//getByName方法——根据主机名获取InetAddress对象 
		InetAddress address = InetAddress.getByName("hello");
		System.out.println(address);
	//getHostAddress方法——获取IP地址 
		InetAddress address = InetAddress.getByName("hello");
		String ip = address.getHostAddress();
		System.out.println(ip);
	//getHostName方法——获取主机名称 
		InetAddress address = InetAddress.getLocalHost();
		String name = address.getHostName();
		System.out.println(name);
	//getLocalHost方法——返回本地主机的InetAddress对象 
		InetAddress address = InetAddress.getLocalHost();
		System.out.println(address);
//javanetSocket类 	
	//Socket方法——创建一个客户端套接字Socket对象 
		InetAddress address = InetAddress.getByName("2013-20160705IB");
		Socket socket = new Socket(address,7777);
	//close方法——关闭Socket套接字连接 
		InetAddress address = InetAddress.getByName("2013-20160705IB");
		Socket socket = new Socket(address,7777);
		socket.close();
	//connect方法——将Socket套接字连接到指定的服务器 
		SocketAddress address = new InetSocketAddress("hello",1995);
		Socket socket = new Socket();
		socket.connect(address);
		InetAddress addre = socket.getInetAddress();
		socket.close();
	//getInetAddress方法——返回Socket套接字连接的地址 
		SocketAddress address = new InetSocketAddress("hello",1995);
		Socket socket = new Socket();
		socket.connect(address);
		InetAddress addre = socket.getInetAddress();
		socket.close();
	//getInputStream方法——返回套接字的输入流 
		SocketAddress address = new InetSocketAddress("hello",1995);
		Socket socket = new Socket();
		socket.connect(address);
		InputStream stream = socket.getInputStream();
		socket.close();
	//getOutputStream方法——返回套接字的输出流 
		SocketAddress address = new InetSocketAddress("hello",1995);
		Socket socket = new Socket();
		socket.connect(address);
		OutputStream stream = socket.getOutputStream();
		socket.close();
//javanetServerSocket类 	
	//ServerSocket方法——创建服务器端套接字ServerSocket对象 
		ServerSocket serverSocket = new ServerSocket(1995);
	//accept方法——侦听并接受套接字的连接 
		ServerSocket serverSocket = new ServerSocket(1995);
		serverSocket.accept();
	//close方法——关闭当前的服务端套接字ServerSocket连接 
		ServerSocket serverSocket = new ServerSocket(1995);
		serverSocket.accept();
		serverSocket.close();
	//isClosed方法——返回ServerSocket的关闭状态 
		ServerSocket serverSocket = new ServerSocket(1995);
		serverSocket.accept();
		serverSocket.close();
		System.out.println(serverSocket.isClosed());
//javanetURL类 	
	//URL方法——使用URL构造方法创建URL对象 
		URI url = new URI("www.baidu.com");
		System.out.println(url);
	//getPort方法——获取当前URL的端口号 
		URI url = new URI("www.baidu.com");
		int port = url.getPort();
		System.out.println(port);
	//getDefaultPort方法——获取URL使用的当前协议的默认端口号 
		//获取URL使用的当前协议的默认端口号 
	//getProtocol方法——获取URL的协议名称 
		//获取URL的协议名称 
	//getHost方法——获取当前URL的主机名称 
		URI url = new URI("www.baidu.com");
		String host = url.getHost();
		System.out.println(host);
	//openConnection方法——返回一个URLConnection对象 
		//返回一个URLConnection对象 
	//openStream方法——打开当前URL的连接 
		//打开当前URL的连接 
//javanetURLConnection类	
	//connect方法——建立通信连接
		//建立通信连接
	//getContentLength方法——返回URL连接中的内容长度
		//返回URL连接中的内容长度
	//getContentType方法——返回content-type头字段的值
		//返回content-type头字段的值
	//getDate方法——返回date头字段的值
		//返回date头字段的值
	//getHeaderFields方法——返回投资端中不可修改的信息
		//返回投资端中不可修改的信息
	//getInputStream方法——返回URL连接的输入流
		//返回URL连接的输入流
	//getOutputStream方法——返回写入的连接的输出流
		//返回写入的连接的输出流
	//setDoInput方法——设置当前URLConnection的doInput字段值
		//设置当前URLConnection的doInput字段值
	//setDoOutput方法——设置当前URLConnection的doOutput字段值
		//设置当前URLConnection的doOutput字段值