1.  在test包下分别创建一个Person类和PersonTest测试类，在测试类中可以直接用Person来new一个对象
 
 
 
 
 
 
2.  把定义类和测试类这两个类放在一个源文件中，注意：一个java源文件中只能有一个public类
 
package test;


class Person {
	String name;
	int age;
	int sex;
	
	public void study() {
		System.out.println("studying");
	}
	
	public void showAge() {
		System.out.println(age);
	}
	
	public int addAge(int i) {
		age += i;
		return age;
	}

}


public class PersonTest {
	public static void main(String[] args) {
		
		Person p1 = new Person();
		
		p1.name = "han";
		p1.age = 22;
		p1.sex = 1;
		
		p1.study();
		p1.showAge();
		p1.addAge(2);
		
		
	}
}
 
 
 
3.  只定义一个类，同时也可以完成类的测试
 
     这种可以看成：在自己定义的PersonTest类中定义一个main方法用来执行测试命令，这个public static void main(String[] args) 也是该类成员方法的一个。
 
     在该方法中用PersonTest p1 = new PersonTest();new一个对象。
 
package test;

public class PersonTest {
	
	String name;
	int age;
	int sex;
	
	public static void main(String[] args) {
		
		PersonTest p1 = new PersonTest();
		
		p1.name = "han";
		p1.age = 22;
		p1.sex = 1;
		
		p1.study();
		p1.showAge();
		p1.addAge(2);	
	}
	
	public void study() {
		System.out.println("studying");
	}
	
	public void showAge() {
		System.out.println(age);
	}
	
	public int addAge(int i) {
		age += i;
		return age;
	}
	
}
 
 
 
 
 
 

Java测试类
 
初学Java，有什么不对不好的地方，希望大家能多多指教
 
Java测试类的编写
 
大家好，今天从课本上看到一个题目，其中要用到测试类的知识，在刚开始学习 Java的时候，我也对测试类非常困扰，今天我们就来好好聊一聊Java的测试类。
 
我们先从书中的一个例题开始。
 例：定义一个接口，声明一个方法area()来计算圆的面积（根据半径长度），在用一个具体的类实现此接口，在编写一个测试类来使用该类。
 
代码如图所示
 
 这是自己写的代码，有什么不对的地方，还请大家指正。
 
其实大家能看出来，测试类，顾名思义，就是用来测试的。其实这只是测试类的一种，还有另外一种用于测试单元的，但在这里不做详述，该例子只是一个非常简单的例子，但它需要在测试类中有一个main()方法才行，可以在main()方法之中添加要测试的方法，即对象名.方法名即可，也可以在里面生成一个对象。

 
求解JAVA，定义一个课程类和一个学生类和测试类
 
mip版  关注:152  答案:1  悬赏:0
 
解决时间 2021-01-28 06:31
 

 
已解决
 
2021-01-27 21:33
 
课程类中包含：
 
属性：课程的名称和成绩
 
方法：属性的get/set方法
 
学生类中包含：
 
属性：学生的姓名、一个包含3门课程的数组和平均成绩属性
 
方法：
 
1.属性的get/set方法
 
2.显示学生所有信息的方法display()，显示学生的姓名，三门课程的名称和成绩以及平均成绩
 
3.计算三门课平均成绩的方法
 
4.编写void changGrade(int i , int score) 方法用来改变学生第i门课的成绩为score参数指定的成绩。注意：确保i的取值范围为0-2之间，score为0-100之间。
 
测试类：
 
在main()方法中：
 
创建一个学生对象，完成学生信息的初始化，显示学生的信息。修改学生第二门课的成绩为90分，再显示学生的信息。
 
注意：学生的成绩需在0-100之间
 
请将测试类与学生类和课程类放在不同的包里
 
最佳答案
 

 
2021-01-27 22:16
 
package arraylist;
 
public class Course
 
{
 
private String name;
 
private double score;
 
public String getName()
 
{
 
return name;
 
}
 
public void setName(String name)
 
{
 
this.name = name;
 
}
 
public double getScore()
 
{
 
return score;
 
}
 
public void setScore(double score)
 
{
 
this.score = score;
 
}
 
}
 
package arraylist;
 
public class Student
 
{
 
private String name;
 
private Course[] scores;
 
private double average;
 
public String getName()
 
{
 
return name;
 
}
 
public void setName(String name)
 
{
 
this.name = name;
 
}
 
public Course[] getScores()
 
{
 
return scores;
 
}
 
public void setScores(Course[] scores)
 
{
 
this.scores = scores;
 
}
 
public double getAverage()
 
{
 
return average;
 
}
 
public void setAverage(double average)
 
{
 
this.average = average;
 
}
 
public void display(){
 
System.out.println("学生的姓名是" + this.getName() + ".");
 
for(int i = 0; i < scores.length; i++){
 
System.out.println("第" + (i + 1) + "门课程的名称是 " + scores[i].getName() + ",成绩是" + scores[i].getScore());
 
}
 
System.out.println("学生" + this.getName() +"的平均成绩是" + this.getAverage());
 
}
 
public void calAverage(){
 
double sum = 0;
 
for(int i = 0; i< scores.length; i++){
 
sum += scores[i].getScore();
 
}
 
this.setAverage(sum/scores.length);
 
}
 
public void changeGrade(int i, int score){
 
scores[i].setScore(score);
 
}
 
}
 
package arraylist;
 
public class TestDemo
 
{
 
public static void main(String[] args){
 
Student stu = new Student();
 
stu.setName("小明");
 
Course[] scores = new Course[3];
 
scores[0] = new Course();
 
scores[0].setName("英语");
 
scores[0].setScore(90);
 
scores[1] = new Course();
 
scores[1].setName("语文");
 
scores[1].setScore(99);
 
scores[2] = new Course();
 
scores[2].setName("数学");
 
scores[2].setScore(80);
 
stu.setScores(scores);
 
stu.calAverage();
 
stu.display();
 
stu.changeGrade(1, 90);
 
stu.display();
 
}
 
}
 
我要举报
 
如果感觉以上信息为低俗/不良/侵权的信息，可以点下面链接进行举报，我们会做出相应处理，感谢你的支持！
 
点此我要举报以上信息！
 
推荐资讯
 
大家都在看

Java单元测试和类加载
 
回顾：
 
1 Lambda表达式：相等于匿名内部类，实现代码作为方法的参数传统。
   函数式接口 变量=(参数列表)->{
      	方法体
	};
   注意：  ->操作符 分成两部分 
   左侧：（参数列表）
   右侧:  方法体
   1 左侧的类型可以省略，类型推断
   2 左侧没有参数，写一个（）
   3 左侧有一个参数,  （）可以省略
   4 右侧如果只有一条语句,可以省略{}，如果有返回值，只有一条语句，return省略，如果有多条语句，必须写{}
   5 Labmda表达式没有生成内部类
   6 访问局部变量，加上final

  函数式接口：只有一个抽象方法
  Consumer 消费型    有参数没有返回值
  Supplier 供给型    没有参数有返回值
  Function 函数型    有参数有返回值
  Predicate 断言型   有参数 返回值boolean
2 方法引用： 如果方法体中只调用一条语句，可以使用方法引用
	对象::实例方法
		System.out::println
	类名::静态方法	
		Integer:compare
	类名::实例方法
		String::equals
		Employee::getName
	类名::new 	创建对象
		Employee::new
	数组引用
	String[]::new 	
3 Stream API  
	流：包含对集合和数组的操作
	三步
	1 创建流 
		Stream.of()
		Arrays.stream()
		集合的.stream()
		Stream.iterate()
		Stream.generate();
	2 中间操作
    	filter 排除不满足条件数据
    	limit  限制
    	skip   跳过
    	distinct  去重复 
    	
    	map 映射
    	
  
   3 终止操作 
   		forEach();
   		
   		allMatch()
   		anyMatch()
   		noneMath();
   		findFirst();
   		findAny();
   		count();
   		
   		
   		reduce() 归约
    	collect() 收集
   		
    
 时间和日期
 	LocalDate
 	LocalTime
 	LocalDateTime
 	
 	Instant 时间时刻
 	
 	时间矫正器
 	
 	时间格式化
 	DateTimeFormatter
   
   
	
 
今天任务
 
1.单元测试
2.注解
3.类加载器
 
教学目标
 
1.掌握单元测试
2.掌握注解
3.理解类加载器
 
第一节：单元测试
 
1.1 什么是软件测试
 
软件测试是程序的一种执行过程，目的是尽可能发现并改正被测试软件中的错误，提高软件的可靠性。
 
1.2 测试分类
 
按照是否知道源代码
 
​ 黑盒测试：不关心具体的逻辑代码，只测功能
 
​ 白盒测试：测试逻辑代码
 
​ 灰盒测试
 
从软件开发的过程
 
​ 单元测试Unit Testing
 
​ 集成测试Integrated Testing
 
​ 系统测试System Testing
 
根据测试的次数
 
​ 冒烟测试
 
​ 压力测试
 
1.3 Junit单元测试
 
Junit是一个基于Java语言的单元测试框架。是白盒测试的一种技术。
 
演示测试1
 
public class Operation {
	public int add(int x,int y) {
		return x^y;
	}
	
	public int sub(int x,int y) {
		return x-y;
	}
}

public class OperationTest {

	@Test
	public void testAdd() {
		Operation operation=new Operation();
		int result=operation.add(20, 30);
		System.out.println(result);
		Assert.assertEquals(50, result);
	}
	@Test
	public void testSub() {
		Operation operation=new Operation();
		int result=operation.sub(10,5);
		System.out.println(result);
	}
}
 
演示测试2
 
有一个学生类StudentDao，添加测试类
 
public class StudentDao {
	public void add() {
		System.out.println("添加学生");
	}
	public void update() {
		System.out.println("更新学生");
	}

}	

public class StudentDaoTest {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		System.out.println("测试类执行之前。。。。。。。。。");
	}

	@AfterClass
	public static void tearDownAfterClass() throws Exception {
		System.out.println("测试类执行之后。。。。。。。。。");
	}

	@Before
	public void setUp() throws Exception {
		System.out.println("方法之前执行........");
	}

	@After
	public void tearDown() throws Exception {
		System.out.println("方法之后执行........");
	}

	@Test
	public void test() {
		System.out.println("测试方法");
	}
	@Test
	public void test2() {
		System.out.println("测试方法2");
	}
  
  	@Test
	public void testAdd() {
		StudentDao studentDao=new StudentDao();
		studentDao.add();
	}
	@Test
	public void testUpdate() {
		StudentDao studentDao=new StudentDao();
		studentDao.update();
	}

}
 
注意：
 
​ ①测试方法上必须使用@Test进行修饰
 
​ ②测试方法必须使用public void 进行修饰，不能带任何的参数
 
​ ③新建一个源代码目录来存放我们的测试代码，即将测试代码和项目业务代码分开
 
​ ④测试类所在的包名应该和被测试类所在的包名保持一致
 
​ ⑤测试单元中的每个方法必须可以独立测试，测试方法间不能有任何的依赖
 
​ ⑥测试类使用Test作为类名的后缀（不是必须）
 
​ ⑦测试方法使用test作为方法名的前缀（不是必须）
 
第二节：注解
 
注释：给代码添加说明和解释，注释帮助开发人员理解程序。（Comment）
 
注解：给代码添加说明,这个说明给程序使用。
 
从 JDK 5.0 开始,Java 增加了对元数据(MetaData) 的支持, 也就是Annotation(注解)。
 
三个基本的 Annotation:
 
​ @Override:限定重写父类方法, 该注解只能用于方法
 
​ @Deprecated:用于表示某个程序元素(类, 方法等)已过时
 
​ @SuppressWarnings: 抑制编译器警告.
 
什么是注解
 
​ Annotation其实就是代码里的特殊标记, 它用于替代配置文件，也就是说，传统方式通过配置文件告诉类如何运行，有了注解技术后，开发人员可以通过注解告诉类如何运行。在Java技术里注解的典型应用是：可以通过反射技术去得到类里面的注解，以决定怎么去运行类。
 
注解技术的要点：
 
​ 如何定义注解
 
​ 如何反射注解，并根据反射的注解信息，决定如何去运行类
 
2.1自定义注解：
 
​ 定义新的 Annotation 类型使用@interface关键字
 
​ 声明注解的属性
 
注解属性的作用：原来写在配置文件中的信息，可以通过注解的属性进行描述。
Annotation的属性声明方式：Stringname();
属性默认值声明方式：Stringname() default “xxx”;
特殊属性value：如果注解中有一个名称value的属性，那么使用注解时可以省略value=部分，如@MyAnnotation(“xxx")
特殊属性value[];
 
注解属性的类型可以是：
    String类型
    基本数据类型
    Class类型
    枚举类型
    注解类型
    以上类型的一维数组
 
案例演示1 创建和使用注解
 
public @interface MyAnnocation {
	String name();
	int num() default 10;
	MyAnnocation2 anno();
}
public @interface MyAnnocation2 {
	String value();
}

public class Demo1 {
	@MyAnnocation(name="哈哈",num=50,anno=@MyAnnocation2(value = "xxx"))
	public void show() {
		System.out.println("xxxxxxx");
	}
}

 
2.2 JDK的元 Annotation
 
元 Annotation指修饰Annotation的Annotation。
 
@Retention: 只能用于修饰一个 Annotation 定义, 用于指定该 Annotation 可以保留的域, @Rentention 包含一个 RetentionPolicy 类型的成员变量, 通过这个变量指定域。
 
RetentionPolicy.CLASS: 编译器将把注解记录在 class文件中. 当运行 Java 程序时, JVM 不会保留注解. 这是默认值
RetentionPolicy.RUNTIME:编译器将把注解记录在 class文件中. 当运行 Java 程序时, JVM 会保留注解. 程序可以通过反射获取该注释
RetentionPolicy.SOURCE: 编译器直接丢弃这种策略的注释
 
@Target：指定注解用于修饰类的哪个成员.@Target 包含了一个名为value，类型为ElementType的成员变量。
 
@Documented:用于指定被该元 Annotation 修饰的Annotation类将被 javadoc 工具提取成文档。
 
@Inherited:被它修饰的 Annotation 将具有继承性.如果某个类使用了被 @Inherited 修饰的Annotation,则其子类将自动具有该注解。
 
案例演示2 使用反射获取注解信息
 
@Retention(RetentionPolicy.RUNTIME)
public @interface PersonInfo {
	String name();
	int age() default 20;
	String gender();
}

public class PersonOpe {
	@PersonInfo(name="李四",age=20,gender="男")
	public void show(String name,int age,String gen) {
		System.out.println(name);
		System.out.println(age);
		System.out.println(gen);
	}
}
public class Demo2 {
	public static void main(String[] args) throws Exception{
		PersonOpe ope=new PersonOpe();
		Class<?> class1=PersonOpe.class;
		Method method = class1.getMethod("show", String.class,int.class,String.class);
		PersonInfo annotation = method.getAnnotation(PersonInfo.class);
		String name=annotation.name();
		int age=annotation.age();
		String gender=annotation.gender();
		method.invoke(ope, name,age,gender);
		
		
	}
}
 
第三节：类加载器
 
​ Java类加载器（Java Classloader）是Java运行时环境（Java Runtime Environment）的一部分，负责动态加载Java类到Java虚拟机的内存空间中。
 
​ 类通常是按需加载，即第一次使用该类时才加载。由于有了类加载器，Java运行时系统不需要知道文件与文件系统。
 
​ JVM中有3个默认的类加载器：
 
 
引导（Bootstrap）类加载器。由原生代码（如C语言）编写，不继承自java.lang.ClassLoader。负责加载核心Java库，存储在<JAVA_HOME>/jre/lib目录中。
 
 
扩展（Extensions）类加载器。用来在<JAVA_HOME>/jre/lib/ext,或java.ext.dirs中指明的目录中加载 Java的扩展库。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。该类由sun.misc.Launcher$ExtClassLoader实现。
 
 
Apps类加载器（也称系统类加载器）。根据 Java应用程序的类路径（java.class.path或CLASSPATH环境变量）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader()来获取它。该类由sun.misc.Launcher$AppClassLoader实现。
 
​
 
​ 这三个类装载器存在父子层级关系，即根装载器是ExtClassLoader的父装载器，ExtClassLoader是AppClassLoader的父装载器。默认情况下使用AppClassLoader装载应用程序的类。
 
 
public class Test{
    Public static void main(String[] arg){
      	ClassLoader c  = Test.class.getClassLoader();  //获取Test类的类加载器
        System.out.println(c); 
      	ClassLoader c1 = c.getParent();  //获取c这个类加载器的父类加载器
        System.out.println(c1);
      	ClassLoader c2 = c1.getParent();//获取c1这个类加载器的父类加载器
        System.out.println(c2);
    }
}
 
3.1类加载过程
 
​ 每个编写的”.java”拓展名类文件都存储着需要执行的程序逻辑，这些”.java”文件经过Java编译器编译成拓展名为”.class”的文件，”.class”文件中保存着Java代码经转换后的虚拟机指令，当需要使用某个类时，虚拟机将会加载它的”.class”文件，并创建对应的class对象，将class文件加载到虚拟机的内存，这个过程称为类加载，这里我们需要了解一下类加载的过程，如下：
 
​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SoNgkVA9-1575685440937)(图片\02.png)]
 
加载：类加载过程的一个阶段：通过一个类的完全限定查找此类字节码文件，并利用字节码文件创建一个Class对象
验证：目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求，不会危害虚拟机自身安全。主要包括四种验证，文件格式验证，元数据验证，字节码验证，符号引用验证。
准备：为类变量(即static修饰的字段变量)分配内存并且设置该类变量的初始值即0(如static int i=5;这里只将i初始化为0，至于5的值将在初始化时赋值)，这里不包含用final修饰的static，因为final在编译的时候就会分配了，注意这里不会为实例变量分配初始化，类变量会分配在方法区中，而实例变量是会随着对象一起分配到Java堆中。
解析：主要将常量池中的符号引用替换为直接引用的过程。符号引用就是一组符号来描述目标，可以是任何字面量，而直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。有类或接口的解析，字段解析，类方法解析，接口方法解析(这里涉及到字节码变量的引用，如需更详细了解，可参考《深入Java虚拟机》)。
初始化：类加载最后阶段，若该类具有超类，则对其进行初始化，执行静态初始化器和静态初始化成员变量(如前面只初始化了默认值的static变量将会在这个阶段赋值，成员变量也将被初始化)。
 
3.2 双亲委托模式
 
​ Java装载类使用“全盘负责委托机制”。“全盘负责”是指当一个ClassLoder装载一个类时，除非显示的使用另外一个ClassLoder，该类所依赖及引用的类也由这个ClassLoder载入；“委托机制”是指先委托父类装载器寻找目标类，只有在找不到的情况下才从自己的类路径中查找并装载目标类。这一点是从安全方面考虑的，试想如果一个人写了一个恶意的基础类（如java.lang.String）并加载到JVM将会引起严重的后果，但有了全盘负责制，java.lang.String永远是由根装载器来装载，避免以上情况发生 除了JVM默认的三个ClassLoder以外，第三方可以编写自己的类装载器，以实现一些特殊的需求。
 
​ 为什么要使用这种双亲委托模式呢？
 
​ 因为这样可以避免重复加载，当父亲已经加载了该类的时候，就没有必要子ClassLoader再加载一次。
 
​ 考虑到安全因素，我们试想一下，如果不使用这种委托模式，那我们就可以随时使用自定义的String来动态替代java核心api中定义类型，这样会存在非常大的安全隐患，而双亲委托的方式，就可以避免这种情况，因为String已经在启动时被加载，所以用户自定义类是无法被加载。
 
演示错误
 
创建java.lang包并创建String类。
 
双亲委派模式工作原理
 
​ 双亲委派模式要求除了顶层的启动类加载器外，其余的类加载器都应当有自己的父类加载器，请注意双亲委派模式中的父子关系并非通常所说的类继承关系，而是采用组合关系来复用父类加载器的相关代码，类加载器间的关系如下。
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TBburOWz-1575685440938)(图片\01.png)]
 
​ 双亲委派模式是在Java 1.2后引入的，其工作原理的是，如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式，即每个儿子都很懒，每次有活就丢给父亲去干，直到父亲说这件事我也干不了时，儿子自己想办法去完成，这不就是传说中的实力坑爹啊。
 
3.3 使用类加载器加载属性文件
 
使用类加载器加载属性文件。
 
案例1：Properties加载属性文件
 
InputStream is = Test.class.getClassLoader().getResourceAsStream("user.properties");
Properties properties=new Properties();
properties.load(new InputStreamReader(is, "utf-8"));
properties.list(System.out);
 
案例2：使用ResourceBundle加载属性文件
 
//不用带扩展名
ResourceBundle bundle = ResourceBundle.getBundle("com.qf.day19.user");
//解决中文乱码问题
System.out.println(new String(bundle.getString("name").getBytes("iso-8859-1"),"utf-8"));
System.out.println(bundle.getString("age"));
System.out.println(new String(bundle.getString("gender").getBytes("iso-8859-1"),"utf-8"));
 
注意：属性文件默认编码为ISO-88590-1,如果修改为utf-8需要代码中处理乱码问题。