1. 首页
  2. 文章中心
  3. java

java测试程序2

56 阅读 0 评论
我是靠谱客的博主 复杂蜡烛，最近开发中收集的这篇文章主要介绍java测试程序2，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

一：基本数据要注意的一些情况

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);
	}
}

运行结果：

5.2345557
true
NaN
false
true
-Infinity

二：获取基本数据类型所占比特数

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);
	}
}
运行结果：

8、16、16、32、64、32、64
三：基本数据类型遇到字符串，都会自动转为字符串类型

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);
	}
}

运行结果：

3.5
7Hello！
Hello！34

注意：System.out.println(3 + 4 + "Hello！");与System.out.println("Hello！" + 3 + 4);的区别

四：

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!");
	}
}
运行结果：

Hello!a7
104Hello!

‘a’的ascii码为97，97+7＝104，先转化为整形，再转化为字符型。

五：用Unicode为字符型赋值

package zb;
public class PrimitiveAndString
{
	public static void main(String[] args) 
	{
		char a='u0061';
		System.out.println(a);
	}
}
输出：a

六：求模运算

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);
	}
}
运行结果：

2.1
2
5对0.0求余的结果是:NaN
-5.0对0求余的结果是:NaN
0对5.0求余的结果是:0.0
0对0.0求余的结果是:NaN

七：数学运算

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);
	}
}
运行结果：

335.5443200000001
1.7888543819998317
0.3274970519909547
0.9999996829318346

八：说明+=更健壮

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;
	}
}
九：二维数组练习 

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]);
	}
}
十：练习使用数组的操作类Arrays 

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));
	}
}

运行结果：

a数组和a2数组是否相等：true
a数组和b数组是否相等：false
b数组的元素为：[3, 4, 5, 6, 0, 0]
b数组的元素为：[3, 4, 1, 1, 0, 0]
b数组的元素为：[0, 0, 1, 1, 3, 4]

十一：返回this，可以实现多次连续调用同一方法

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);
	}
}
运行结果：rt的age Field值是:4

十二：函数传入可变参数

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企业应用实战");		
	}
}
运行结果：

5
疯狂Java讲义
轻量级Java EE企业应用实战
5

对比以下代码：

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企业应用实战"});		
	}
}

补充：可将test(5,new String[0]);替代test(5,new String[] { });运行结果一样。

十三：可变参数、函数重载

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"});
	}
}
运行结果：

****形参长度可变的test方法****
****形参长度可变的test方法****
只有一个字符串参数的test方法 
****形参长度可变的test方法****
十四：多态

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();
	}
}

十五：初始化块的执行顺序

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();
	}
}
运行结果：

Root的静态初始化块
Mid的静态初始化块
Leaf的静态初始化块
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器，其参数值：疯狂Java讲义
Leaf的普通初始化块
执行Leaf的构造器
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器，其参数值：疯狂Java讲义
Leaf的普通初始化块
执行Leaf的构造器
十六：基本类型和字符串的互换，parseInt和valueOf函数

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());
	}
}

十七：只能产生一个实例，单例类

/**
 * 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);
	}
}

十八：final关键字的使用


/**
 * 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);
	}
}





最后

以上就是复杂蜡烛为你收集整理的java测试程序2的全部内容，希望文章能够帮你解决java测试程序2所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(37)

相关文章

简单java程序测试并发数
简单java程序测试并发数
C++构造函数和数组
C++构造函数和数组
java中测试程序运行时间
java中测试程序运行时间
java软件测试基础
java软件测试基础
java测试程序2
java测试程序2
[Java] 基础：简易算式测试程序① 程序功能② 实现思路③ 具体代码④ 程序执行结果
[Java] 基础：简易算式测试程序① 程序功能② 实现思路③ 具体代码④ 程序执行结果
Java程序性能测试Java程序性能测试
Java程序性能测试Java程序性能测试
Java如何测试
Java如何测试

评论列表共有 0 条评论

立即
投稿
返回
顶部