java测试程序2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package zb;

public class FloatTest
{
	public static void main(String[] args) 
	{
		float af = 5.2345556f;
		//下面将看到af的值已经发生了改变
		System.out.println(af);
		double a = 0.0;
		double c = Double.NEGATIVE_INFINITY;    //注意:是Double不是double
		float d = Float.NEGATIVE_INFINITY;      //注意:是Float不是float
		//看到float和double的负无穷大是相等的。
		System.out.println(c == d);
		//0.0除以0.0将出现非数
		System.out.println(a / a);
		//两个非数之间是不相等的
		System.out.println(a / a == Float.NaN);
		//所有正无穷大都是相等的
		System.out.println(6.0/0 == 555.0/0);
		//负数除以0.0得到负无穷大
		System.out.println(-8 / a);
		//整数除以0会抛出异常
		//System.out.println(-3 / 0);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package zb;

public class FloatTest
{
	public static void main(String[] args) 
	{
		int a=Byte.SIZE;
		int b=Short.SIZE;
		int c=Character.SIZE;
		int d=Integer.SIZE;
		int e=Long.SIZE;
		int f=Float.SIZE;
		int g=Double.SIZE;		
		System.out.println(a+"、"+b+"、"+c+"、"+d+"、"+e+"、"+f+"、"+g);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package zb;
public class PrimitiveAndString
{
	public static void main(String[] args) 
	{
		//下面代码是错的，因为5是一个整数，不能直接赋给一个字符串
		//String str1 = 5;
		//一个基本类型值和字符串进行连接运算时，基本类型值自动转换为字符串
		String str2 = 3.5f + "";
		//下面输出3.5
		System.out.println(str2);
		//下面语句输出7Hello!
		System.out.println(3 + 4 + "Hello！");
		//下面语句输出Hello!34，因为Hello! + 3会把3当成字符串处理，
		//而后再把4当成字符串处理
		System.out.println("Hello！" + 3 + 4);
	}
}

1
2
3
4
5
6
7
8
9
10
11
package zb;
public class PrimitiveAndString
{
	public static void main(String[] args) 
	{
		//输出字符串Hello!a7
		System.out.println("Hello!"+'a'+7);
		//输出字符串104Hello!
		System.out.println('a'+7+"Hello!");
	}
}

1
2
3
4
5
6
7
8
9
package zb;
public class PrimitiveAndString
{
	public static void main(String[] args) 
	{
		char a='u0061';
		System.out.println(a);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package zb;

public class ModTest
{
	public static void main(String[] args) 
	{
		double a = 5.2;
		double b = 3.1;
		double mod = a % b;
		//mod的值为2.1
		System.out.println(mod);
		System.out.println(5%3);
		//输出非数:NaN
		System.out.println("5对0.0求余的结果是:" + 5 % 0.0);
		//输出非数:NaN
		System.out.println("-5.0对0求余的结果是:" + -5.0 % 0);
		//输出0
		System.out.println("0对5.0求余的结果是:" + 0 % 5.0);
		//输出非数:NaN
		System.out.println("0对0.0求余的结果是:" + 0 % 0.0);
		//下面代码将出现异常 
		//java.lang.ArithmeticException: / by zero
		//System.out.println("-5对0求余的结果是:" + -5 % 0);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package zb;

public class MathTest
{
	public static void main(String[] args) 
	{
		//定义变量a为3.2
		double a = 3.2;
		//求a的5次方，并将计算结果赋为b。
		double b = Math.pow(a , 5);
		//输出b的值
		System.out.println(b);
		//求a的平方根，并将结果赋给c
		double c = Math.sqrt(a);
		//输出c的值
		System.out.println(c);
		//计算随机数,返回一个0～1之间的伪随机数。
		double d = Math.random();
		//输出随机数d的值
		System.out.println(d);
		//求1.57的sin函数值：1.57被当成弧度数
		double e = Math.sin(1.57);
		//输出接近1
		System.out.println(e);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package zb;

public class EnhanceAssignTest
{
	public static void main(String[] args) 
	{
		//定义一个byte类型的变量
		byte a = 5;
		//下面语句出错，因为5默认是int类型，a + 5就是int类型。
		//把int类型赋给byte类型的变量，所以出错
		//a = a + 5;
		//定义一个byte类型的变量
		byte b = 5;
		//下面语句将不会出现错误
		b += 5;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package zb;

public class TwoDimensionTest
{
	public static void main(String[] args) 
	{
		//定义一个二维数组
		int[][] a;
		//把a当成一维数组进行初始化，初始化a是一个长度为4的数组
		//a数组的数组元素又是引用类型
		a = new int[4][];
		//把a数组当成一维数组，遍历a数组的每个数组元素
		for (int i = 0 , len = a.length; i < len ; i++ )
		{
			System.out.println(a[i]);
		}
		//初始化a数组的第一个元素
		a[0] = new int[2];
		//访问a数组的第一个元素所指数组的第二个元素
		a[0][1] = 6;
		//a数组的第一个元素是一个一维数组，遍历这个一维数组
		for (int i = 0 , len = a[0].length ; i < len ; i ++ )
		{
			System.out.println(a[0][i]);
		}

		//同时初始化二维数组的2个维数
		int[][] b = new int[3][4];
		for(int i=0;i<b.length;i++)
			for(int j=0;j<b[0].length;j++)
				System.out.print(b[i][j]+"、");
		System.out.println();
		//使用静态初始化的语法来初始化一个二维数组
		String[][] str1 = new String[][]{new String[3] 
			, new String[]{"hello"}};
		//使用简化的静态初始化语法来初始化二维数组
		String[][] str2 = {new String[3] 
			, new String[]{"hello"}};
		for(int i=0;i<str1[0].length;i++)
			str1[0][i]="hello"+i;
		for(int i=0;i<str1[0].length;i++)
			System.out.println(str1[0][i]);
		System.out.println(str1[1][0]);
		System.out.println(str2[1][0]);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package zb;

import java.util.Arrays;

public class ArraysTest
{
	public static void main(String[] args) 
	{
		//定义一个a数组
		int[] a = new int[]{3, 4 , 5, 6};
		//定义一个a2数组
		int[] a2 = new int[]{3, 4 , 5, 6};
		//a数组和a2数组的长度相等，每个元素依次相等，将输出true
		System.out.println("a数组和a2数组是否相等："
			+ Arrays.equals(a , a2));
		//通过复制a数组，生成一个新的b数组
		int[] b = Arrays.copyOf(a, 6); 
		System.out.println("a数组和b数组是否相等："
			+ Arrays.equals(a , b));
		//输出b数组的元素，将输出[3, 4, 5, 6, 0, 0]
		System.out.println("b数组的元素为："
			+ Arrays.toString(b));
		//将b数组的第3个元素（包括）到第5个元素（不包括）赋为1
		Arrays.fill(b , 2, 4 , 1);
		//输出b数组的元素，将输出[3, 4, 1, 1, 0, 0]
		System.out.println("b数组的元素为：" 
			+ Arrays.toString(b));
		//对b数组进行排序,升序
		Arrays.sort(b);
		//输出b数组的元素，将输出[0, 0, 1, 1, 3, 4]
		System.out.println("b数组的元素为：" 
			+ Arrays.toString(b));
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package zb;

public class ReturnThis
{
	public int age;
	public ReturnThis grow()
	{
		age++;
		//return this，返回调用该方法的对象
		return this;
	}
	public static void main(String[] args)
	{
		ReturnThis rt = new ReturnThis();
		//可以连续调用同一个方法
		rt.grow()
			.grow()
			.grow().grow();
		System.out.println("rt的age Field值是:" + rt.age);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package zb;

public class Varargs
{
	//定义了形参个数可变的方法
	public static void test(int a , String... books)
	{
		//books被当成数组处理
/*		for (String tmp : books)
		{
			System.out.println(tmp);
		}*/
		for(int i=0;i<books.length;i++)
			System.out.println(books[i]);
		//输出整数变量a的值
		System.out.println(a);
	}
	public static void main(String[] args) 
	{
		//调用test方法
		test(5);
		test(5 , "疯狂Java讲义" , "轻量级Java EE企业应用实战");		
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package zb;

public class Varargs
{
	//定义了形参个数可变的方法
	public static void test(int a , String[] books)
	{
		//books被当成数组处理
/*		for (String tmp : books)
		{
			System.out.println(tmp);
		}*/
		for(int i=0;i<books.length;i++)
			System.out.println(books[i]);
		//输出整数变量a的值
		System.out.println(a);
	}
	public static void main(String[] args) 
	{
		//调用test方法
		test(5,new String[]{});
		test(5 ,new String[]{"疯狂Java讲义" , "轻量级Java EE企业应用实战"});		
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package zb;

public class OverloadVarargs
{
	public void test(String msg)
	{
		System.out.println("只有一个字符串参数的test方法 ");
	}
	//因为前面已经有了一个test方法，test方法里有一个字符串参数。
	//此处的长度可变形参里不包含一个字符串参数的形式
	public void test(String... books)
	{
		System.out.println("****形参长度可变的test方法****");
	}
	public static void main(String[] args)
	{
		OverloadVarargs olv = new OverloadVarargs();
		//下面两次调用将执行第二个test方法
		olv.test();
		olv.test("aa" , "bb");
		//下面将执行第一个test方法
		olv.test("aa");
		//下面调用将执行第二个test方法,因为显示的说明了函数参数是一个String数组
		olv.test(new String[]{"aa"});
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package zb;

class BaseClass
{
	public int book = 6;
	public void base()
	{
		System.out.println("父类的普通方法");
	}
	public void test()
	{
		System.out.println("父类的被覆盖的方法");
	}
}
public class SubClass extends BaseClass
{
	//重新定义一个book实例Field隐藏父类的book实例Field
	public String book = "轻量级Java EE企业应用实战";
	public void test()
	{
		System.out.println("子类的覆盖父类的方法");
	}
	public void sub()
	{
		System.out.println("子类的普通方法");
	}
	public static void main(String[] args)
	{
		//下面编译时类型和运行时类型完全一样，因此不存在多态
		BaseClass bc = new BaseClass();
		//输出 6
		System.out.println(bc.book);
		//下面两次调用将执行BaseClass的方法
		bc.base();
		bc.test();
		//下面编译时类型和运行时类型完全一样，因此不存在多态
		SubClass sc = new SubClass();
		//输出"轻量级J2EE企业应用实战"
		System.out.println(sc.book);
		//下面调用将执行从父类继承到的base方法
		sc.base();
		//下面调用将执行从当前类的test方法
		sc.test();
		//下面编译时类型和运行时类型不一样，多态发生
		BaseClass ploymophicBc = new SubClass();
		//输出 6 —— 表明访问的是父类Field
		System.out.println(ploymophicBc.book);
		//下面调用将执行从父类继承到的base方法
		ploymophicBc.base();
		//下面调用将执行从当前类的test方法
		ploymophicBc.test();
		//因为ploymophicBc的编译类型是BaseClass，
		//BaseClass类没有提供sub方法,所以下面代码编译时会出现错误。
		//ploymophicBc.sub();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
package zb;

class Root
{
	static{
		System.out.println("Root的静态初始化块");
	}
	{
		System.out.println("Root的普通初始化块");
	}
	public Root()
	{
		System.out.println("Root的无参数的构造器");
	}
}
class Mid extends Root
{
	static{
		System.out.println("Mid的静态初始化块");
	}
	{
		System.out.println("Mid的普通初始化块");
	}
	public Mid()
	{
		System.out.println("Mid的无参数的构造器");
	}
	public Mid(String msg)
	{
		//通过this调用同一类中重载的构造器
		this();
		System.out.println("Mid的带参数构造器，其参数值："
			+ msg);
	}
}
class Leaf extends Mid
{
	static{
		System.out.println("Leaf的静态初始化块");
	}
	{
		System.out.println("Leaf的普通初始化块");
	}	
	public Leaf()
	{
		//通过super调用父类中有一个字符串参数的构造器
		super("疯狂Java讲义");
		System.out.println("执行Leaf的构造器");
	}
}
public class Test
{
	public static void main(String[] args) 
	{
		new Leaf();
		new Leaf();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package zb;

public class Primitive2String
{
	public static void main(String[] args) 
	{
		String intStr = "123";
		//把一个特定字符串转换成int变量
		int it1 = Integer.parseInt(intStr);
		int it2 = new Integer(intStr);
		System.out.println(it1+"  "+it2);
		String floatStr = "4.56";
		//把一个特定字符串转换成float变量
		float ft1 = Float.parseFloat(floatStr);
		float ft2 = new Float(floatStr);
		System.out.println(ft1+" "+ft2);
		//把一个float变量转换成String变量
		String ftStr = String.valueOf(2.345f);
		System.out.println(ftStr);
		//把一个double变量转换成String变量
		String dbStr = String.valueOf(3.344);
		System.out.println(dbStr);
		//把一个boolean变量转换成String变量
		String boolStr = String.valueOf(true);
		System.out.println(boolStr.toUpperCase());
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/**
 * Description:
 * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a> 
 * <br/>Copyright (C), 2001-2012, Yeeku.H.Lee
 * <br/>This program is protected by copyright laws.
 * <br/>Program Name:
 * <br/>Date:
 * @author Yeeku.H.Lee kongyeeku@163.com
 * @version 1.0
 */
class Singleton
{
	//使用一个变量来缓存曾经创建的实例
	private static Singleton instance;
	//将构造器使用private修饰，隐藏该构造器
	private Singleton(){}
	//提供一个静态方法，用于返回Singleton实例
	//该方法可以加入自定义的控制，保证只产生一个Singleton对象
	public static Singleton getInstance()
	{
		//如果instance为null，表明还不曾创建Singleton对象
		//如果instance不为null，则表明已经创建了Singleton对象，
		//将不会重新创建新的实例
		if (instance == null)
		{
			//创建一个Singleton对象，并将其缓存起来
			instance = new Singleton();
		}
		return instance;
	}
}
public class SingletonTest
{
	public static void main(String[] args)
	{
		//创建Singleton对象不能通过构造器，
		//只能通过getInstance方法来得到实例
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		//将输出true
		System.out.println(s1 == s2);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

/**
 * Description:
 * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a> 
 * <br/>Copyright (C), 2001-2012, Yeeku.H.Lee
 * <br/>This program is protected by copyright laws.
 * <br/>Program Name:
 * <br/>Date:
 * @author Yeeku.H.Lee kongyeeku@163.com
 * @version 1.0
 */
public class FinalVariableTest
{
	//定义成员变量时指定默认值，合法。
	final int a = 6;
	//下面变量将在构造器或初始化块中分配初始值
	final String str;
	final int c;
	final static double d;
	//既没有指定默认值，又没有在初始化块、构造器中指定初始值，
	//下面定义char Field是不合法的。
	//final char ch;
	//初始化块，可对没有指定默认值的实例Field指定初始值
	{
		//在初始化块中为实例Field指定初始值，合法
		str = "Hello";
		//定义a Field时已经指定了默认值，
		//不能为a重新赋值下面赋值语句非法
		//a = 9;
	}
	//静态初始化块，可对没有指定默认值的类Field指定初始值
	static
	{
		//在静态初始化块中为类Field指定初始值，合法
		d = 5.6;
	}
	//构造器，可对既没有指定默认值、有没有在初始化块中
	//指定初始值的实例Field指定初始值
	public FinalVariableTest()
	{
		//如果初始化块中对str指定了初始化值，
		//构造器中不能对final变量重新赋值，下面赋值语句非法
		//str = "java";
		c = 5;
	}
	public void changeFinal()
	{
		//普通方法不能为final修饰的成员变量赋值
		//d = 1.2;
		//不能在普通方法中为final成员变量指定初始值
		//ch = 'a';
	}
	public static void main(String[] args) 
	{
		FinalVariableTest ft = new FinalVariableTest();
		System.out.println(ft.a);
		System.out.println(ft.c);
		System.out.println(ft.d);
	}
}