day02-2021-8-24
知识回顾
600多种开发语言，为何市场独爱java？
J2EE Enterprise Edition 企业级版本，它推出EJB 企业级JavaBean，也是在java中最早提出bean概念。
它开了企业级分布式结构先河，但是EJB本身结构不够优化，被新市场产品淘汰，新产品迎来了java春天Spring框架
java有多强大？
京东最早的架构使用.net框架，早被java替代
新浪微博使用php，鹿晗事件发生后，多次宕机，最新核心已经使用java替代
java是通过30年血雨腥风依然屹立不倒。
JDK、JRE、JVM的区别
java编译过程及跨平台特性
快速编码
首先大家要练习打字，作为一个专业的程序员是有打字速度的要求：每分钟120字，好150字，较好200字
技巧：快捷键 eclipse
1）ctrl +s 保存
2）ctrl +d 删除一行
3）快速创建main方法
a. 创建类时，指定main方法
b. 快捷键：输入main字母+Alt+/，快速提示，进行选择确认
4）快速创建打印语句
快捷键：输入syso字母+Alt+/，快速提示，进行选择确认
package cn.tedu.hello;
public class Hello {
//代码要缩进，好习惯，看的清爽，层次结构清晰
//TAB键，4个空格，7个空格
//main+ Alt+/快速提示main，别选错，eclipse提供模块，开发效率高
public static void main(String[] args) {
//打印快捷键：syso+ALT+/
System.out.println(“Hello World2”);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
junit单元测试
开发时，必须有测试，每个开发者每天最多的时间是解决BUG（错误）
单元测试，每个类的每个方法每个参数都需要进行测试，尽量去做。
1）早期就利用main来测试（控制台内容是给开发者看的，不是给用户的），java设计main方式是程序执行入口。毕竟不好。main方法只能执行一个方法，不能去调用每个方法都测试，多个方法通过注释来回切换。开发效率低。
2）主流第三方（非java提供，不在jdk中）提供新的测试方法：junit
junit开发步骤
1）找到第三方提供的jar包（资深程序员给的：官网、Maven仓库，分发给团队成员，eclipse直接提供junit.jar ）
2）import 导入jar包 ，语句固定位置：package下面，class声明的上面
import java.util.Scanner; //导包
3）给junit测试方法戴上一个帽子 @Test 注解（特殊类）
一个类可以粗略分为3个方法：main、普通业务方法add()加法、单元测试方法 test
测试方法很多要求：公用的 public、无返回值的 void、方法不能有参数 test()
package cn.tedu.base;
import org.junit.Test;
//自动，导入注解
/*
-
需求：比较main方法和junit单元测试方法的区别
-
导入junit，反着来的，加入@Test后会自动找jar和导入import
*/
public class Hello {
public static void main(String[] args) {
System.out.println(“main method”);
}/*
- 测试方法：
- 1）必须public
- 2）必须void
- 3）必须无参
- 方法名自己随便定义，按驼峰规则
- 导入成功有3处变化
- 1）选对junit4 不报错
- 2）eclipse项目加入junit支持（自动）
- 3）
*/
@Test
public void hello() {
System.out.println(“junit test method”);
}
}
- 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
关键字
java中“写死”了很多固定单词，不能变，都小写，这些单词你不能使用。
标识符
java中开发者可以自己命名名字，这些名字就叫做标识符。
变量
int x = 10;
int y = 2;
x/y
y = 5; //变化的量就称为变量
常量
不变化的量。
package test;
import org.junit.Test;
//需求：测试变量和常量，学会演算
public class TestVar {
@Test //测试常量
public void finaltype() {
//final修饰变量就变成常量，常量不允许修改
final int z = 100;
/** The final local variable z cannot be assigned. * 局部变量z不能被分配内存空间* It must be blank and not using a compound assignment*///z = 200;System.out.println(z);//常见常量，习惯大写final double PI = 3.1415926;final double P = 6.18;final String SYSTEM_NAME = "京淘电商";
}
@Test //测试变量
public void var() {int x = 10;int y = 2;//Duplicate local variable y 局部变量y定义了多个//原因：java要求在一个方法体内只能定义一个同名变量//局部变量不能定义两次，不能重名//int y = 5; //修改了y的值，并且覆盖y = 5; //修改了y的值，并且覆盖System.out.println(x/y); //10/5=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
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
运算符
数学：x+y=z，x,y,z操作符，+运算符，=赋值
package test;
import org.junit.Test;
//需求：算术运算符 ±*/ %
public class TestArith {
@Test
public void arith() {
int x = 10;
int y = 2;
System.out.println( x + y ); //12/** 字符串中内容原样输出* 如何判断+是字符串连接符还是数学+呢？* 如果+号两边有一边是字符串，结果就是字符串*/System.out.println("x+y="+x+y); //x+y=102System.out.println("x+y="+(x+y)); //x+y=12
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
算术运算符
package test;
import org.junit.Test;
//需求：算术运算符 ±*/ %
public class TestArith {
@Test
public void arith() {
int x = 10;
int y = 2;
System.out.println( x + y ); //12/** 字符串中内容原样输出* 如何判断+是字符串连接符还是数学+呢？* 如果+号两边有一边是字符串，结果就是字符串*/System.out.println("x+y="+x+y); //x+y=102System.out.println("x+y="+(x+y)); //x+y=12System.out.println("x-y="+(x-y));System.out.println("x*y="+ x*y ); //*优先级高+System.out.println("x/y="+ x/y ); //除优先级高+//取余，余数x = 11;System.out.println("x%y="+ x%y);
}
}
- 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
package test;
import org.junit.Test;
//需求：测试++自增（每次+1）和–自减（每次-1）
public class TestSelf {
@Test
public void self() {
int i = 10;
i++; //i=i+1 缩写
System.out.println(i);int j = 100;System.out.println(j++); //100，先打后加，101System.out.println(++j); //102，先加后打，102System.out.println(--j); //101，先减后打，101System.out.println(j--); //101，先打后减，100
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
赋值运算符
package test;
import org.junit.Test;
//需求：赋值运算符 =、+=、-=、=、/=
public class TestAssign {
@Test
public void assign() {
//赋值语句特点：先执行右边
int i = 10+20-302; //表达式
System.out.println(“i=” + i);
i += 5; //i=i+5System.out.println(i);i -= -10; //i=i - -10System.out.println(i);i *= 0; // i=i*0System.out.println(i);i /= 2; // i=i/2;System.out.println(i);
}
}
- 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 test;
import org.junit.Test;
//关系运算符：==相等和!=不等
public class TestRelation {
@Test
public void relation() {
int a = 10;
int b = 20;
//判断是否相等，结果布尔表达式，true/falseSystem.out.println(a == b); //falseSystem.out.println(a != b); //true
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
逻辑运算符
package test;
import org.junit.Test;
//逻辑运算符：与&、或|、非!、异或^
public class TestLogic {
@Test //利用穷举法，通过结果来记忆
public void logical() {
//与 &，特点：两边条件都成立结果才成立
System.out.println(true & true); //t
System.out.println(true & false); //f
System.out.println(false & true); //f
System.out.println(false & false); //f
System.out.println("--短路与--"); //空行//短路与 &&，前面条件不成立false，后面无需再执行，推荐使用，速度快System.out.println(true && true); //t System.out.println(true && false); //f//Dead Code 死代码，不会执行的代码System.out.println(false && true); //fSystem.out.println(false && false); //fSystem.out.println(); //空行//或 |，特点：有一边成立结果就成立System.out.println(true | true); //tSystem.out.println(true | false); //tSystem.out.println(false | true); //tSystem.out.println(false | false); //f//短路或 ||，特点：条件结果true，后面的条件就无需判断，推荐使用，速度快System.out.println("--短路或--");System.out.println(true || true); //tSystem.out.println(true || false); //tSystem.out.println(false || true); //tSystem.out.println(false || false); //fSystem.out.println();//非，!，特点：取反System.out.println(!true); //fSystem.out.println(!false); //tSystem.out.println();//异或，^，特点：两边相同结果为false，两边不同结果为trueSystem.out.println(true ^ true); //fSystem.out.println(true ^ false); //tSystem.out.println(false ^ true); //tSystem.out.println(false ^ false); //f
}
}
- 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 test;
import org.junit.Test;
/*
-
需求：三目运算符（三元）
-
格式：布尔表达式 ? 值1（表达式） : 值2（表达式）
-
特征：1 ? 2 : 3（死记）
-
结果：如果布尔表达式结果为true，返回值1，false，返回值2
*/
public class TestVar3 {
@Test //两个数求最大值
public void max2() {
int x = 10;
int y = 5;
int max = (x>y)?x:y;System.out.println("x="+x+",y="+y+", 最大值："+ max);}
@Test //三个值求最大值
public void max3() {
int x = 10;
int y = 200;
int z = 30;//第一种思路，把max和z在进行三目，然后结果给maxint max = (x>y)?x:y; //临时保存中间值，先求出x和y中的最大值max = (max>z)?max:z; //利用中间变量和最终值进行比较System.out.println("最大值："+max);//第二种思路，一行应用两次三目int max2 = (x>y)?x:y>z?(x>y)?x:y:z; //结构太乱了，推荐上面的方法System.out.println("最大值："+max2);}
}
- 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
小结
1、测试方法比较main方法和junit区别
1）main是java自身结构，junit第三方公司开发
2）main是程序application执行而生（用户），junit测试方法是为测试而生（开发）
3）main约束，一个类中只能有一个main方法（一个），一个类中可以有多个test方法（多个1~n）
2、怎么使用junit单元测试？
1）寻找junit.jar（官网，百度下载，资深程序员（架构师、高级程序员）给我们）开发工具自带（eclipse）
2）导包 import org.junit.Test（导包后面的内容可以自己写-手动，也可以利用eclipse导入-自动选择-推荐）
3）在类中给单元测试方法戴个帽子 @Test（注解@开头，特殊类）看着怪怪的，开发效率非常高，代码量少
开发时，写好类中的单元测试方法，最后给它带帽子，通过错误提示菜单，把它们都加进来
jar一个项目加载一次（项目）
import 一个类导包一次（类）
3、导包
1）import org.junit.*; //把org.junit包路径下的所有的类都导入（类加载器，加载jvm中）
方便，会多加载无用的到内存中，浪费内存
2）import org.junit.Test; //只加载Test.class这个类
推荐，高效，速度快
关键字和标识符
1）关键字：java定死的单词，这些单词都小写，开发者不许用，50+多个
注意一些特殊字：java、test、const（常量）不要使用
作业：晚上把关键字写10遍，死背记住
2）标识符：开发者自定义名称
习惯方法内的局部变量：
- a,b,c,x,y,z,i,j,k,m 小写，一个字母；
- 小驼峰 name,age,address,firstName,secondName
习惯常量的：
- 全大写，增加final修饰符 double PI=3.14; String SYS_NAME=“京淘电商”;
变量和常量的区别
1）变量：变化的量，变量可以进行多次赋值，赋值后会覆盖之前的值（丢了）
2）常量：不变化的量，一旦赋值就无法进行修改。（安全，修改不了）
运算符
本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！