>使用正确的输入定义正常情况下的期望和期望输出。
>现在，通过声明一个类，将它命名为任何东西(通常类似TestAddingModule)，并将testAdd方法添加到它(即如下所示)来实现测试：
>编写一个方法，并在其上添加@Test注释。
>在方法中，运行你的二进制和和assertEquals(expectedVal，calculatedVal)。
>通过运行它来测试你的方法(在Eclipse中，右键单击，选择Run as→JUnit test)。
//for normal addition
@Test
public void testAdd1Plus1()
{
int x  = 1 ; int y = 1;
assertEquals(2, myClass.add(x,y));
}
>根据需要添加其他案例。
>测试你的二进制和不会引发意外的异常，如果有一个整数溢出。
>测试您的方法是否正常处理空输入(如下所示)。
//if you are using 0 as default for null, make sure your class works in that case.
@Test
public void testAdd1Plus1()
{
int y = 1;
assertEquals(0, myClass.add(null,y));
}

这是一个非常常见的测试问题,为此,我遇到的最常见的解决方案是使用依赖注入将数据源与使用数据的代码分开.这不仅支持良好的测试,而且在使用外部数据源时通常是一个好的策略(良好的职责分工,隔离集成点,促进代码重用是其中的一些原因).
您需要进行的更改如下：
>对于每个数据源,创建一个接口来定义如何访问该数据源中的数据,然后分解出将数据返回到实现此目标的单独类中的代码.
>依赖关系将数据源注入到包含“ long”函数的类中.
>对于单元测试,请为每个数据源注入模拟实现.
这是一些显示示例的代码示例-请注意,此代码仅是模式的说明,您将需要一些更合理的名称.值得研究这种模式,并更多地了解依赖注入和应用程序.嘲讽-单元测试军械库中最强大的武器中的两种.
数据源
public interface DataSourceOne {
public Data getData();
}
public class DataSourceOneImpl implements DataSourceOne {
public Data getData() {
...
return data;
}
}
public interface DataSourceTwo {
public Data getData();
}
public class DataSourceTwoImpl implements DataSourceTwo {
public Data getData() {
...
return data;
}
}
长方法类
public class ClassWithLongMethod {
private DataSourceOne dataSourceOne;
private DataSourceTwo dataSourceTwo;
public ClassWithLongMethod(DataSourceOne dataSourceOne,
DataSourceTwo dataSourceTwo) {
this.dataSourceOne = dataSourceOne;
this.dataSourceTwo = dataSourceTwo;
}
public Result longMethod() {
someData = dataSourceOne.getData();
someMoreData = dataSourceTwo.getData();
...
return result;
}
}
单元测试
import org.junit.Test;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class ClassWithLongMethodTest {
@Test
public void testLongMethod() {
// Create mocked data sources which return the data required by your test
DataSourceOne dataSourceOne = mock(DataSourceOne.class);
when(dataSourceOne.getData()).thenReturn(...);
DataSourceTwo dataSourceTwo = mock(DataSourceTwo.class);
when(dataSourceTwo.getData()).thenReturn(...);
// Create the object under test using the mocked data sources
ClassWithLongMethod sut = new ClassWithLongMethod(dataSourceOne,
dataSourceTwo);
// Now you can unit test the long method in isolation from it's dependencies
Result result = sut.longMethod();
// Assertions on result
...
}
}
请原谅(并纠正)任何语法错误,这些天我写的Java很少.

一，编程的一般思路

1，ooa:面向对象分析

2，ood:面向对象设计

3，oop:面向对象编程

4，测试

5，项目交接，给客户演示，演示完了项目就上线运行，运行期间有bug就项目升级（后期维护）----是收钱的哦

二，如何在java中创建一个类？定义属性，方法，以及实例化一个对象并调用类里面的内容？

方法：1：无进无出：没有返回值，没有参数传

2：无进有出：没有返回值，有参数

3：有进无出：有返回值，没有参数

4：有进有出 ：有返回值，有参数

三，方法重载：就是方法名相同,方法参数的个数和类型不同,通过个数和类型的不同来区分不同的函数。Java的重载是发生在本类中的,重载的条件实在本类中有多个方法名相同,但参数列表不同

###同一个类中，方法名相同，参数列表不同（1：参数个数不同2：参数类型不同3：参数顺序不同），切记：跟返回值类型无关，跟修饰符无关（public就是一个修饰符）

他们两个就构成了方法重载：：：：



思考：一个类中为什么要定义那么多的同名方法呢（方法重载）？

原因是每个方法的具体实现有差异，我们不能以偏概全

四，全局变量和局部变量

全局变量都是有默认值，而且在类的任何地方都可以使用，说白了就是定义在方法之外的变量

###8种基本数据类型的默认值



局部变量:定义在方法中，形参上，或者是一个块中，局部变量的作用域是从它的括号（{}）开始到结束.

###形参:　在方法被调用时用于接受外界输入的数据;（方法中的参数）

###实参: 　     调用方法时外界传给方法的数据;
注意：局部变量是没有默认值的，在你使用之前必须给它赋值
五，this关键字

（）

1:代表当前类对象

2：区分同名属性和局部变量

####当全局变量和局部变量重名时，在方法中使用this时，表示的是该方法所在类中的全局变量



3：调用本类中重载的构造器，谁调用它，它就是谁这个this必须写在构造器的第一句


六，构造器：构造方法，构造函数.

类在构建对象的时候系统会默认的去那个构造器，如果类中你自己没有定义构造器，系统会自动帮你生成一个无参构造器 。

构造器的作用是：1，初始化对象（给属性赋值）构造器也能重载

2.构造代码块，代码块  { }

构造代码块是在实例化对象的时候优先于构造器先执行的

构造代码块的作用：是给对象的共性赋值，比如张三爱吃米饭，李四爱吃米饭，王五也爱吃，所有人都爱吃米饭，所以用构造代码块给共性赋值

###我在百度上搜了一点：



七，引起类的加载方式

注意：实例变量（普通属性）隶属于构造代码块—就是谁在前面谁先执行

###实例变量（全局变量）：独立于方法之外的变量，不过没有 static 修饰。
String str="hello world"; // 实例变量

1：实例化对象，new的时候
int s=new ...

2：调用类里面的静态属性或静态方法

3：Class.forName(); 加载驱动（反射机制）

八，Static关键字

1：修饰属性

属性就是静态属性（类属性，类属性就是该属性是属于类的，不属于对象的），可以直接通过类名访问，所以实际共享该类属性
2：修饰方法

该方法可以直接被类名调用注意：静态方法中不能使用非静态属性静态方法中不能使用this和	super关键字



3：修饰代码块

{}静态代码块是最先执行的，在整个程序运行期间只执行一次，用于数据库连接
static{} 

4：静态导入
 import static java.lang.System.out;

就是输出时不再输System.；直接out.println();

九，8种基本数据类型对应的封装类


学习这8个封装类主要学习它里面的api

8种基本数据类型和8种对应的封装类可以自动转换，这8种封装类里面用的最多的一个api就是将字符串转成数字

注意：char不能进行字符串转数字

boolean只有字符串是ture的时候才转ture,其他都是false



十，内存分配

Java中内存分为5个

1：栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中）

2：堆：存放所有new出来的对象。

3：常量存储区：存放常量

4：静态存储区:存放静态成员（static定义的）

5：方法区

==是用来判断地址

栈和堆的区别：栈中的数据大小和生命周期是可以确定的，当没有引用指向数据时，这个数据就会消失。堆中的对象的由垃圾回收器负责回收

栈的优势是，存取速度比堆要快

本文实例讲述了Java使用自定义注解实现函数测试功能。分享给大家供大家参考，具体如下：
一 自定义注解
使用@interface定义Annotation
使用Annotation修饰程序中的类、方法、变量、接口等定义，通常我们会把Annotation放在所有修饰符之前。
定义带成员变量的Annotation。
为Annotation的成员变量指定初始值。
二 提取Annotation
Annotation接口来代表程序元素前面的注释，该接口是所有Annotation类型的父接口。
AnnotatedElement接口代表程序中可以接受注释的程序元素。
调用AnnotatedElement对象的如下三个方法来访问Annotation信息：
getAnnotation(Class annotationClass)：返回该程序元素上存在的、指定类型的注释，如果该类型的注释不存在，则返回null。
Annotation[] getAnnotations()：返回该程序元素上存在的所有注释。
boolean isAnnotationPresent(Class extends Annotation> annotationClass)：判断该程序元素上是否包含指定类型的注释，存在则返回true，否则返回false。
三 实战——标记哪些方法是可测试的
1 Testable.java
import java.lang.annotation.*;
// 使用JDK的元数据Annotation：Retention
@Retention(RetentionPolicy.RUNTIME)
// 使用JDK的元数据Annotation：Target
@Target(ElementType.METHOD)
// 定义一个标记注解，不包含任何成员变量，即不可传入元数据
public @interface Testable
{
}
2 MyTest.java
public class MyTest
{
// 使用@Testable注解指定该方法是可测试的
@Testable
public static void m1()
{
}
public static void m2()
{
}
// 使用@Testable注解指定该方法是可测试的
@Testable
public static void m3()
{
throw new IllegalArgumentException("参数出错了！");
}
public static void m4()
{
}
// 使用@Testable注解指定该方法是可测试的
@Testable
public static void m5()
{
}
public static void m6()
{
}
// 使用@Testable注解指定该方法是可测试的
@Testable
public static void m7()
{
throw new RuntimeException("程序业务出现异常！");
}
public static void m8()
{
}
}
3 ProcessorTest.java
import java.lang.reflect.*;
public class ProcessorTest
{
public static void process(String clazz)
throws ClassNotFoundException
{
int passed = 0;
int failed = 0;
// 遍历clazz对应的类里的所有方法
for (Method m : Class.forName(clazz).getMethods())
{
// 如果该方法使用了@Testable修饰
if (m.isAnnotationPresent(Testable.class))
{
try
{
// 调用m方法
m.invoke(null);
// 测试成功，passed计数器加1
passed++;
}
catch (Exception ex)
{
System.out.println("方法" + m + "运行失败，异常："
+ ex.getCause());
// 测试出现异常，failed计数器加1
failed++;
}
}
}
// 统计测试结果
System.out.println("共运行了:" + (passed + failed)
+ "个方法，其中：\n" + "失败了:" + failed + "个，\n"
+ "成功了:" + passed + "个！");
}
}
4 RunTests.java
public class RunTests
{
public static void main(String[] args)
throws Exception
{
// 处理MyTest类
ProcessorTest.process("MyTest");
}
}
四 运行
方法public static void MyTest.m7()运行失败，异常：java.lang.RuntimeException: 程序业务出现异常！
方法public static void MyTest.m3()运行失败，异常：java.lang.IllegalArgumentException: 参数出错了！
共运行了:4个方法，其中：
失败了:2个，
成功了:2个！
希望本文所述对大家java程序设计有所帮助。