class Singleton
{
    static  class A{
        static public void show()
        {
            System.out.println("静态内部类");   
        }
    }
}

public class Main
{
    public static void main(String[] args)
     {
     //静态内部类和静态变量和静态方法一样，可以直接通过类名调用
        Singleton.A.show();
    }
}

Inner i = new Outer.Inner();

Outer o = new Outer();
Inner i = new o.Inner();

<dependency>
    <groupId>org.reflections</groupId>
    <artifactId>reflections</artifactId>
    <version>0.9.11</version>
</dependency>
 
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>21.0</version>
</dependency>

//入参 要扫描的包名
Reflections f = new Reflections("com.ggband.netty.execute.command");
 
//入参 目标注解类
Set<Class<?>> set = f.getTypesAnnotatedWith(Cmd.class);

package com.mh.others.reflect_;

import com.mh.others.log.LOGUtils;
import org.junit.Test;
import org.reflections.Configuration;
import org.reflections.Reflections;
import org.reflections.scanners.*;
import org.reflections.util.ClasspathHelper;
import org.reflections.util.ConfigurationBuilder;
import org.reflections.util.FilterBuilder;

import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.Set;

/**
 * 学习 org.reflections
 */
public class ReflectionsStu {

    @Test
    public void test1() throws Exception {
        Reflections  reflections =  new Reflections(
                "com.mh.others.reflect_", //指定被扫描的包名
                Arrays.asList(
                    new SubTypesScanner(false)//允许getAllTypes获取所有Object的子类, 不设置为false则 getAllTypes 会报错.默认为true.
                    ,new MethodParameterNamesScanner()//设置方法参数名称 扫描器,否则调用getConstructorParamNames 会报错
                    ,new MethodAnnotationsScanner() //设置方法注解 扫描器, 否则getConstructorsAnnotatedWith,getMethodsAnnotatedWith 会报错
                    ,new MemberUsageScanner() //设置 member 扫描器,否则 getMethodUsage 会报错, 不推荐使用,有可能会报错 Caused by: java.lang.ClassCastException: javassist.bytecode.InterfaceMethodrefInfo cannot be cast to javassist.bytecode.MethodrefInfo
                    ,new TypeAnnotationsScanner()//设置类注解 扫描器 ,否则 getTypesAnnotatedWith 会报错
                )
        );



        Set<Class<? extends ReflectionsStu>> subTypes = reflections.getSubTypesOf(ReflectionsStu.class);//获取某一类的子类

        Set<Class<?>> annotatedTypes = reflections.getTypesAnnotatedWith(ReflectClassFlag.class); //获取在Class上标有 ReflectClassFlag 注解的类, 包含被继承的子类

        Set<Class<?>> annotatedTypesHonor = reflections.getTypesAnnotatedWith(ReflectClassFlag.class, true);//获取在Class上标有 ReflectClassFlag 注解的类, 不包含被继承的子类

        Set<String> allTypes = reflections.getAllTypes(); //获取所有Object类的所有子类.此方法不推荐, 推荐 reflections.getSubTypesOf(class)

        List<String> constructorParamNames = reflections.getConstructorParamNames(ChildReflectionsStu.class.getDeclaredConstructor(ReflectionsStu.class,Integer.class)); //获取构造方法上参数的名称

        Set<Constructor> constructorsAnnotatedWith = reflections.getConstructorsAnnotatedWith(ReflectConstructorFlag.class);//获取标有注解ReflectConstructorFlag 的构造对象

        Set<Method> methodsAnnotatedWith = 
        reflections.getMethodsAnnotatedWith(ReflectConstructorFlag.class); //获取带有ReflectConstructorFlag的注解的 method对象

        Set<Member> methodUsage = reflections.getMethodUsage((Method)methodsAnnotatedWith.toArray()[0]); //获取 method 的 结构描述, 不推荐使用

        reflections.save("/home/cmj/dump/a.txt"); //将数据保存到a.txt

        Reflections collect = reflections.collect(new File("/home/cmj/dump/a.txt")); //从a.txt中加载数据

        LOGUtils.printLog(Arrays.toString(subTypes.toArray()));

        LOGUtils.printLog(Arrays.toString(annotatedTypes.toArray()));

        LOGUtils.printLog(Arrays.toString(annotatedTypesHonor.toArray()));

        LOGUtils.printLog(Arrays.toString(allTypes.toArray()));

        LOGUtils.printLog(Arrays.toString(constructorParamNames.toArray()));


    }
    @ReflectClassFlag
    class ChildReflectionsStu extends ReflectionsStu{

        private String name;
        private Integer age;

        @ReflectConstructorFlag
        public ChildReflectionsStu(String name) {
            this.name = name;
        }

        public ChildReflectionsStu(Integer age) {
            this.age = age;
        }

        public ChildReflectionsStu() {
        }

        @ReflectConstructorFlag
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public Integer getAge() {
            return age;
        }

        public void setAge(Integer age) {
            this.age = age;
        }
    }

    class GrandsonReflectionsStu extends ChildReflectionsStu{

    }
}

mybatis:
    type-aliases-package: com.atguigu.springcloud.entities #实体类所在的包

<dependency>

<groupId>dom4j</groupId>

<artifactId>dom4j</artifactId>

<version>1.6.1</version>

</dependency>

         SAXReader reader = new SAXReader();              
		   Document   document = reader.read(new File("csdn.xml"));

class A {
    public static void show() {
        System.out.println("Class A show() function");
    }
}

class B extends A {
    public static void show() {
        System.out.println("Class B show() function");
    }
}

public class TestCast {

    public static void main(String[] args) {

        TestCast cls = new TestCast();
        Class c = cls.getClass();
        System.out.println(c);

        Object obj = new A();
        B b1 = new B();
        b1.show();

        // casts object
        A a = new A();
        a = A.class.cast(b1);

        System.out.println(obj.getClass());
        System.out.println(b1.getClass());
        System.out.println(a.getClass());
    }
}

    //在不解压压缩文件的情况下，读取压缩文件里面的文件名
    public List<String> getZipInnerFileName(String zipPath) throws IOException//压缩文件的路径
    {
        List<String> fileNameLists=new ArrayList<>();
        java.util.zip.ZipEntry zipEntry = null;
        File file = new File(zipPath);
        if(file.exists()){ //判断文件是否存在
            ZipInputStream zipInputStream = new ZipInputStream( new FileInputStream(zipPath), Charset.forName("GBK")); //解决包内文件存在中文时的中文乱码问题
            while ((zipEntry=zipInputStream.getNextEntry()) != null) {
                //遇到文件夹就跳过
                if(zipEntry.isDirectory())
                {
                    continue;
                }else
                {
                    //获取到压缩文件里面文件的名称
                   fileNameLists.add(zipEntry.getName());
                }
            }
            //关闭流---一定要管理流，不然不能删除zip压缩文件
            zipInputStream.close();
        }
        return fileNameLists;
    }

<dependency>
	<groupId>org.apache.ant</groupId>
	<artifactId>ant</artifactId>
	<version>1.10.10</version>
</dependency>

package xfx.com.reader;

import org.apache.tools.zip.ZipEntry;
import org.apache.tools.zip.ZipFile;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

import java.io.*;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.zip.ZipInputStream;

//从properties文件中读取路径
@Component
@PropertySource("classpath:path.properties")
public class PathReader
{
    @Value("${file.path}")
    private  String filePath;
    @Value("${img.path}")
    private  String imgPath;
    @Value("${course.file.prefix}")
    private String filePrefix;
    @Value("${course.study.prefix}")
    private String studyPrefix;
    @Value("${course.file.name}")
    private String courseFileName;
    @Value("${course.file.cover}")
    private  String courseFileCover;

    public String getCourseFileName() {
        return courseFileName;
    }
    public String getCourseFileCover() {
        return courseFileCover;
    }
    public String getFilePrefix() {
        return filePrefix;
    }
    public String getStudyPrefix() {
        return studyPrefix;
    }
    public String getFilePath() {
        return filePath;
    }
    public String getImgPath() {
        return imgPath;
    }
    //在不解压压缩文件的情况下，读取压缩文件里面的文件名
    public List<String> getZipInnerFileName(String zipPath) throws IOException//压缩文件的路径
    {
        List<String> fileNameLists=new ArrayList<>();
        java.util.zip.ZipEntry zipEntry = null;
        File file = new File(zipPath);
        if(file.exists()){ //判断文件是否存在
            ZipInputStream zipInputStream = new ZipInputStream( new FileInputStream(zipPath), Charset.forName("GBK")); //解决包内文件存在中文时的中文乱码问题
            while ((zipEntry=zipInputStream.getNextEntry()) != null) {
                //遇到文件夹就跳过
                if(zipEntry.isDirectory())
                {
                    continue;
                }else
                {
                    //获取到压缩文件里面文件的名称
                   fileNameLists.add(zipEntry.getName());
                }
            }
            //关闭流
            zipInputStream.close();
        }
        return fileNameLists;
    }



    private static byte[] _byte = new byte[1024*8] ;

    //解压文件的方法
    //zipFile  解压缩文件
    //descDir  压缩的目标地址
    public void unZipFile(File zipFile,String descDir)
    {
        try {
            //指定使用编码格式，防止中文乱码
           ZipFile _zipFile = new ZipFile(zipFile,"GBK");
            //得到枚举,通过循环来读取zip文件内部一个个文件
            for(Enumeration entries = _zipFile.getEntries(); entries.hasMoreElements() ; )
            {
                //创建文件条目对象，来接收枚举得到的文件或者目录
                ZipEntry entry = (ZipEntry)entries.nextElement();
                //当前压缩文件具体要解压到的地址
                //压缩到具体的目录地址+分隔符号(即'\')+当前文件的名字
                File _file = new File(descDir + File.separator + entry.getName()) ;
                //如果当前得到的不是文件而是目录，那么就创建目录
                if( entry.isDirectory() )
                {
                    _file.mkdirs() ;
                }
                else//如果得到的是文件
                {
                    //获得父目录
                    File _parent = _file.getParentFile() ;
                    //判断父目录是否存在，如果不存在，就创建父目录
                    if( !_parent.exists() ){
                        _parent.mkdirs() ;
                    }
                    //将当前文件条目对象放到文件字节输入流中---将文件里面的数据读取出来
                    InputStream _in = _zipFile.getInputStream(entry);
                    //获得文件字节输出流---将数据写到文件里面
                    OutputStream _out = new FileOutputStream(_file) ;
                    //当len=-1表示读取完毕
                    int len ;
                    while( (len = _in.read(_byte)) > 0)
                    {
                        //参数一是缓冲数组，参数2是从数组中的哪个位置开始读取，参数3是读取的长度
                        _out.write(_byte, 0, len);
                    }
                    //将读取数据刷新到硬盘上
                    //然后关闭输出流
                    if (null !=_out){
                        _out.flush();
                        _out.close();
                    }
                    //关闭输入流
                    if (null !=_in){
                        _in.close();
                    }
                }
            }
            //关闭zip流
            _zipFile.close();
            //删除解压完后的压缩文件
            zipFile.delete();
        } catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}