从零学习java的第二天（变量常量 基础运算符 Junit单元测试）

变量与常量

1）变量：是一直在变化的量，在同一个方法中，同一个变量的值可以持续被修改，持续被赋值

             在输出之前，保存最后被修改的值被输出

2）常量：在同一个方法中，同一个常量只能被赋值一次，定义常量时，要在数值类型前加final修饰

package cn.tedu.java0423;//用来测试常量与变量

public class VarConstant {
public static void main(String[] args) {
	final int a = 10;
	//	a = 11;
	//	The final local variable a cannot be assigned. It must be blank and not using a compound assignment
	//  final为常量修饰符，在同一个类中，同一个常量只能被定义与赋值一次，且不能被修改
	int b = 10;//int b 为变量，变量的值可以被重复修改和赋值，修改的值会被覆盖，输出的值为最后被修改的值
		b = 11;
		b = 12;
System.out.println(a+b);
}
}

算法

基础运算符

1）加减乘除取余

      计算机内用+ - * / %来表示加减乘除

2）递增递减

      ++ -- 都表示为递增+1或递增-1

递增：a++ ++a

           a++：++在后表示先给a赋值并打印，再进行运算

           ++a：++在前表示先计算，再进行赋值和打印

递减：b--  --b

           b--：++在后表示先给a赋值并打印，再进行运算

           --b：--在前表示先计算，再进行赋值和打印

3）综合赋值运算符

int a = 1  ; int b = 1

+=：a+=b等于a=a+b

-=：a-=b等于a=a-b

*=：a*=b等于a=a*b

/=：a/=b等于a=a/b

%=：a%=b等于a=a%b

4）逻辑运算符

&：与：并列关系，必须两个为真才为真

|：或：或者选择关系，一个为真就为真

!：非：取反，真非假，假非真

5）三元运算符

boolean ? true：false

三个参数，Boolean，为真输出true，为假输出false

6）关系运算符

==：判断两个值是否相等

！=：判断两个值是否不相等

package cn.tedu.java0423;//这是一个基础运算法的测试

public class Operator {
	public static void main(String[] args) {
	Operator ope = new Operator();
	 int r=ope.add(1, 2);//所有的int a=1 int b=2
	 int r1=ope.sub(1, 2);//+
	 int r2=ope.mul(1, 1);//-
	 int r3=ope.div(1, 2);//*
	 int r33=ope.mod(1, 2);//除
	 int r4=ope.asc(1, 2);//递增
	 int r5=ope.dec(1, 2);//递减
	 int r6=ope.addequ(1, 2);//加等
	 int r7=ope.subequ(1, 2);//减等
	 int r8=ope.mulequ(1, 2);//乘等
	 int r9=ope.divequ(1, 2);//除等
	 boolean r10=ope.and(true, true);//真与真得真
	 boolean r11=ope.and(true, false);//真与假得假
	 boolean r12=ope.and(false, false);//假与假得假
	 boolean r13=ope.and(false, true);//假与真得假
	 boolean r101=ope.or(true, true);//真或真得真
	 boolean r111=ope.or(true, false);//真或假得真
	 boolean r121=ope.or(false, false);//假或假得假
	 boolean r131=ope.or(false, true);//假或真得真
	 boolean r14=ope.not(false);//非真即假，非假即真
	 int r15=ope.terope(1, 2, 3, 4);
	 System.out.println("变量值：a = 1 b = 2 c = 3 d = 4");
	 System.out.println("a + b = "+r);
	 System.out.println("a - b = "+r1);
	 System.out.println("a * b = "+r2);
	 System.out.println("a / b = "+r3);
	 System.out.println("a % b = "+r33);
	 System.out.println("(a++) + (++b) = "+r4);
	 System.out.println("(a--) - (--b) = "+r5);
	 System.out.println("a + = b = "+r6);
	 System.out.println("a - = b = "+r7);
	 System.out.println("a * = b = "+r8);
	 System.out.println("a / = b = "+r9);
	 System.out.println("true && true ="+r10);
	 System.out.println("true && false ="+r11);
	 System.out.println("false && false ="+r12);
	 System.out.println("false && false ="+r13);
	 System.out.println("true || true ="+r101);
	 System.out.println("true || false ="+r111);
	 System.out.println("false || false ="+r121);
	 System.out.println("false || true ="+r131);
	 System.out.println("!false = "+r14);
	 System.out.println("比较a,b,c,d的大小");
	 System.out.println("r = a < b ? a : b");
	 System.out.println("r = c < r ? c : r");
	 System.out.println("r = d < r ? d : r = "+r15);
	 System.out.println("r=(((a<b ? a : b)<c)? c : (a<b ? a : b))<d ? d :(((a<b ? a : b)<c)? c : (a<b ? a : b)) = "+r15);
}
public int add(int a,int b) {
	return a+b;
}
public int sub(int a,int b) {
	return a-b;
}
public int mul(int a,int b) {
	return a*b;
}
public int div(int a,int b) {
	return a/b;
}
public int mod(int a,int b) {
	return a%b;
}
public int asc(int a,int b) {
	return (a++)+(++b);
}
public int dec(int a,int b) {
	return(a--)-(--b);
}
public int addequ(int a,int b) {
	return a+=b;
}
public int subequ(int a,int b) {
	return a-=b;
}
public int mulequ(int a,int b) {
	return a*=b;
}
public int divequ(int a,int b) {
	return a/=b;
}
public int modequ(int a,int b) {
	return a%=b;
}
public boolean and(boolean a,boolean b) {
	return a && b;
}
public boolean or(boolean a,boolean b) {
	return a || b;
}
public boolean not(boolean a) {
	return !a ;
}
public boolean equ(boolean a,boolean b) {
	return a==b;
}
public boolean ine(boolean a,boolean b) {
	return a!=b;
}
public int terope(int a,int b,int c,int d) {
	int r=a<b ? a : b;//三目运算符格式 boolean? a:b
	    r=c<r ? c : r;//在使用多个参数比较时推荐使用多行代码，易读性比简便性更重要
	    r=d<r ? d : r;
	int r1=(((a<b ? a : b)<c)? c : (a<b ? a : b))<d ? d :(((a<b ? a : b)<c)? c : (a<b ? a : b));
	return r1;
}
}

 

Junit单元测试

@Test：在方法前添加

          作用：优势：可以单独测试类中的方法，不需要main方法的存在，也不需要在添加删除注释，更不需要在main方法中测试

                     缺陷：测试方法必须无返回值，多个方法测试时，不能表达顺序关系

package cn.tedu.java0423;//这是Junit的第一次使用测试

import org.junit.Test;

public class Junit {
	@Test
public void TestJunit() {
	}
	@Test
public void TestJunit1() {
	}
	@Test
public void TestJunit2() {
	
}
}