Java复习之路（第十六天 Java高级基础知识）

Java高级基础知识

注解：一统江湖，主流的开发的开发到的方式：注解的方式、

反射reflect：Hello.java编译后为Hello.class  字节码文件二进制文件。以后三大框架SpringMVC  Spring  Mybatis他们的底层工作的原理，很多就是基于反射，先写会api调用

控制反转：万物皆对象,传统的方式：new   User(),控制反转它来创建对象，管理对象，你可以进行直接的拿过来使用，加个性事宜

依赖注入：对象的关联，Teacher，Student 绑定关系Teacher.Student属性，setTeacher()

手写Spring框架核心机制

递归遍历目录，自定义注解，反射，包扫描，容器，控制反转，依赖注入

转换工具类：

目的：将上面的文件的路径转换成为下面的路径

总结：1.去掉准目录  2.去掉.class后缀   3.将\转化为.分割符号

用到的常用API

1.indexOf(str)   在当前字符串中进行查找str开始的位置

2.subString (begInindex)      从beginIndex的位置截取到最后的位置

   subString (begInindex,endIndex)  截取中间的内容

3.replaceAll（regex 正则表达式）    s=s.replaceAll("\\\\","\\."); 

package javase.util;

public class FileUtil {
	public static void main(String[] args) {
		//起名称见名知意
		//   \在Java的世界里面是代表得是转义的字符，最终只代表一个\
		String fileNamePath="D:\\new WorkSpace\\day14"
																+ "\\bin\\day1401\\test.class";
		//将bin之前的内容进行截取，api定义bin的位置，利用indexOf(\\bin)方法
		//截取字符串，Substring()
		Integer pos= fileNamePath.indexOf("bin");
		System.out.println(pos);
		
		String s = fileNamePath.substring(pos+4);
		System.out.println(s);
		
		//将后缀去掉
		s=s.substring(0,s.length()-6);
		System.out.println(s);
		
		//将\替换为.  regex正则表达式,正则\需要被转义，.
		s=s.replaceAll("\\\\","\\.");
		System.out.println(s);
	}
}

单元测试：JUnit

@Test注解+规定（约定）名称testXxx

测试类的方法，进行引入单元的测试

单元测试没有返回值 void

递归的概念：各种语言都支持"递归",非常大的特性，反复的重复做一件事

磁盘的目录为例：

（1）含有目录，可以支持多级的目录

（2）目录中含有文件

（3）虽然重复是重复的进行遍历目录，但是每次目录的参数是不一样的每一次

每次做的事情也都可以进行终结，遍历完当前目录就结束

public class FileUtil {
	@Test           //单元测试
	public void testClassName(){
		//起名称见名知意
		//   \在Java的世界里面是代表得是转义的字符，最终只代表一个\

测试方法中可以直接进行创建父类的对象，也可以通过类进行创建对象两种方法（类中类）

@Test
	public void testClassName(){
		//或者是进行创建对象,创建对象的两种方式
	   String fileNamePath="D:\\new WorkSpace\\day14"
		       								+ "\\bin\\day1401\\test.class";
		//在自己的方法里面进行创建自己类的对象，在调用自己类的方法
	   FileUtil fu=new FileUtil();
		String className1 = this.getClassName(fileNamePath);
		String className = fu.getClassName(fileNamePath);
		System.out.println(className);
		System.out.println(className1);
	}

给你一个全路径：javase.spring.classes.Hello

获取他的类的实例的名称

类名：Hello  BeanName

实例名：Hello hello=new Hello();   beanName

三种工具类day16

package javase.util;

import org.junit.jupiter.api.Test;

public class FileUtil {
	public static void main(String[] args) {
		
	}
	
	@Test
	public void testBeanName(){
		String className="javase.spring.classes.Hello";
		FileUtil fu =new FileUtil();
		String beanName=fu.getBeanName(className);
		System.out.println(beanName);
	}
	
	@Test
	public void testFirstLower(){
		String string="TainXuan";
		FileUtil fu =new FileUtil();
		String firstLower = fu.toFirstLower(string);
		System.out.println(firstLower);
	}
	
	
	
	@Test
	public void testClassName(){
		//或者是进行创建对象,创建对象的两种方式
	   String fileNamePath="D:\\new WorkSpace\\day14"
		       														+ "\\bin\\day1401\\test.class";
		//在自己的方法里面进行创建自己类的对象，在调用自己类的方法
	   FileUtil fu=new FileUtil();
		String className1 = this.getClassName(fileNamePath);
		String className = fu.getClassName(fileNamePath);
		System.out.println(className);
		System.out.println(className1);
	}
	
	//工具类:返回真实的类名
	public  String  getBeanName(String className) {
		//正则表达式中的“.”需要进行转义，字符串类型的“.”是不需要进行转义的
		Integer pos=className.lastIndexOf(".");
		System.out.println(pos);
		String s=className.substring(pos+1);
		return s;
	}
	
	//工具类：首字母小写
	public String toFirstLower(String name) {
		//首先要截取到首字母
		char a= name.charAt(0);
		System.out.println(a);
		//转成小写的工具类
		char lowerCase = Character.toLowerCase(a);
		//利用拼接的方法将char类型转换成为string的类型
		//另外的一种转换的方法：return string.valueOf(owerCase),同样也是转换为string的类型
		return lowerCase+name.substring(1);
	}
	
	//工具类  :给一个文件的路径名称，转出一个类名
	public  String  getClassName(String fileNamePath) {
		
	
	
		//起名称见名知意
		//   \在Java的世界里面是代表得是转义的字符，最终只代表一个\
//	    String fileNamePath="D:\\new WorkSpace\\day14"
//																	+ "\\bin\\day1401\\test.class";
		//将bin之前的内容进行截取，api定义bin的位置，利用indexOf(\\bin)方法
		//截取字符串，Substring()
		Integer pos= fileNamePath.indexOf("bin");
		System.out.println(pos);
		
		String s = fileNamePath.substring(pos+4);
		System.out.println(s);
		
		//将后缀去掉
		s=s.substring(0,s.length()-6);
		System.out.println(s);
		
		//将\替换为.  regex正则表达式,正则\需要被转义，.同时也需要被转义
		s=s.replaceAll("\\\\","\\.");
		System.out.println(s);
		return s;
	}
}

 进行Debug调试的模式：

设置断点：双击段首，出现小点，就是Debug的模式

F5:进入当前行的方法中

F6:执行完本行跳转到下一行(单行执行)

F8:直接完成

枚举类型;enum

性别：男女，  就是用英文的全大写的类型

练习：利用递归的方法实现对多层目录的遍历，并结合其它的方法，对遍历出来的值按照要求进行变动

package javase.util;

import java.io.File;

import org.junit.jupiter.api.Test;

//遍历目录，打印出所有的文件
public class RecersionDir {
	/*
	 * 1.给定的固定的目录，利用文件提供的api进行转换
	 * 2.判断是否是空目录，如果有文件就行遍历
	 * 3.判断是不文件夹是否文件，如果是文件，进行递归的调用,.直接进行输出到控制台
	 * 就是再一次调用自身的方法（参数路径，当前的目录),必须要有出口
	 * 4.遍历的完成
	 */
	public static void main(String[] args) {
		
	}
	@Test
	public void testRecursion() {
		String path="D:\\new WorkSpace\\day16\\bin\\javase\\util";
		//
		this.readClassName(path);
		
	}

	public void readClassName(String path) {
		//就是将文件的字符串转化为文件的对象
		File file=new File(path);
		//就是将一层的目录进行打印，返回的是数组
		File[] listFiles = file.listFiles();
		if (listFiles==null||listFiles.length==0) {
			System.out.println("此文件夹为空");
		}else {
			for (File file2 : listFiles) {
				if (file2.isDirectory()) {
					//方法的递归,传递他的绝对的路径进行递归的调用
					readClassName(file2.getAbsolutePath());
				}else {
					//如果是文件，将文件直接打印
					System.err.println(file2.getAbsolutePath());
					//与前面的工具类进行连接，连接之后加入新的功能模块
					FileUtil fuFileUtil=new FileUtil();
					String className = fuFileUtil.getClassName(file2.getAbsolutePath());
					System.out.println(className);
					String beanName = fuFileUtil.getBeanName(file2.getAbsolutePath());
					System.out.println(beanName);
				}
			}
		}
	}
}

自定义的注解：要求

@controller，标识一个类，标识什么时候能够读出来（源代码，编译后，运行时）每一种都可以有注解，如果编译为源代码的阶段，到了运行期的时候就自动的删除，编译后会自动的删除，就是上一阶段存留的，如果没有特殊的声明，到了下一阶就会自动的删除利用反射读取出来一个.class文件

注解的格式与我们之前使用的格式是不相同的

@Target ({ElementType.TYPE})       //@Target目标，{}数组，枚举的类型
public @interface Controller {
	//注解有自己的语法的格式
//	private String value;   下面的代码和上面的代码块的含义是一致的
	String value() default " ";  有一个value的属性值，字符串的额类型，默认值是空的
}

注解：检查这个类上有没有注解，这个类上面有没有Controller

反射：refelect   java中独有的，他可以对我们的Class文件进行剖析

能够获取属性、方法、构造方法、带参数构造、注解，将来有很多私有化的属性值Private修饰的，同样被访问

在类上加入注解的方式：

package javase.spring.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import javax.lang.model.element.Element;

//标识他在工作在类上，还是在方法的头上
//注解标识在类上的用的关键字是Target,大括号里面表示的是可以运用于多个，
//小括号里面是一个枚举的类型，选择了一个Type，美枚举里面的英文的字母全部都是大写
@Target ({ElementType.TYPE})   
@Retention( RetentionPolicy.RUNTIME)     //里面包含了三种运行的阶段，需要进行特殊的声明，到了下一阶段才会将反射的机制进行保留
//SOURCE 就是在编译前的阶段    CLASS，代表得是编译后的保留文件    RUNTIME    代表得是在JVM里面运行的时期，一共就分为三个阶段
public @interface Controller {
	//注解有自己的语法的格式
//	private String value;   下面的代码和上面的代码块的含义是一致的
	String value() default " ";
}

在注解的方法里面进行创建类：

package javase.spring.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import javax.lang.model.element.Element;

//标识他在工作在类上，还是在方法的头上
//注解标识在类上的用的关键字是Target,大括号里面表示的是可以运用于多个，
//小括号里面是一个枚举的类型，选择了一个Type，美枚举里面的英文的字母全部都是大写
@Target ({ElementType.TYPE})   
@Retention( RetentionPolicy.RUNTIME)     //里面包含了三种运行的阶段，需要进行特殊的声明，到了下一阶段才会将反射的机制进行保留
public @interface Controller {
	//注解有自己的语法的格式
//	private String value;   下面的代码和上面的代码块的含义是一致的
	String value() default " ";
}

进行创建测试的方法:

package Test;

import java.lang.annotation.Annotation;

import org.junit.jupiter.api.Test;

import javase.spring.annotation.Controller;

public class TestRelect {
	@Test
	//进行获取类上面的注解
	public void testControllerAnnotation() throws Exception {
		//获取Hello.class上面的所有的注解
		//反射是与类挂钩的,括号里面是类的全路径的名称
		//<泛型>标识这个类中元素的类型选，?代表得是通配符号
		//forName()括号里面的内容时固定的，就是某个文件的全路径
		Class<?> clazz=Class.forName("javase.spring.pojo.Hello");
		
		//反射提供获取类上的所有的注解
		Annotation[] as = clazz.getDeclaredAnnotations();
		//进行遍历注释的个数，并且将存放在数组as[]中
		for (Annotation a : as) {
			System.out.println(a.toString());
		}
		
		//获取@colltroller注解
		//获取指定的注解的类
		Controller annotation = clazz.getAnnotation(Controller.class); 
		System.out.println(annotation.value());
	}
}

//注解的不同的标志符的作用之一是将他们划分为不同的使用的框架里面

概念+调用的过程方法要明白

 

总结：完成框架底层做的事情，

底层使用很多的Java高级的技术

递归：所有的开发语言都支持，经典的案例：目录的遍历，汉诺塔，实际来发过程中使用的不多

1.自己调用自己（非常的简介几行代码处理，不好理解）

2.调用时必须要有结束的语句，出口，没有出口就是死循环

3.方法的参数的内容每次都会变

注解：annotion :注解是修饰Java的代码的，增强Java代码的能力

1.注解不是给"开发人员"用的，不是给业务使用的

2.标识：@interface

3.@target 作用:标识：类 接口  属性  参数  返回值

4.retention :作用 SOURCE 源代码    CLASS编译后的类   RUNTIME运行时 （JVM）

5.默认：如果不标识话，运行时默认是注解是被删除的

泛型：表示 <>他在编译的阶段帮助我们检查深层的业务的逻辑的要求,在开发的运行时就不容易出现逻辑上的错误

List<string> list=new  ArrayList<>(String);

反射：Java独有，Java中的最难点之一，利用反射动态的剖析，在运行环境中的动态的编程

把类中私有的获取，还可以进行修改值，非常经典的应用，加密软件的加密

创建的方法与之前的不相同：

String value() default "";

String 是指定的类型，value是变量的名称，括号是书写的格式  default  代表的是设施初始值的方法