JAVA知识盲区整理

Posted 2021-09-15 大忽悠爱忽悠

JAVA知识盲区整理

• 静态内部类的调用时机
• 静态内部类
• Java中volatile关键字及其作用
• 一篇反射的好文链接
• 获取指定包下的注解--reflections工具类
• Spring如何在注解中传入变量作为参数---使用SPEL表达式

---

静态内部类的调用时机

• 调用外部类的静态变量，静态方法可以让外部类得到加载，不过这里静态内部类没有被加载
• 静态内部类的加载不需要依附外部类，在使用时才加载。不过在加载静态内部类的过程中也会加载外部类
• 静态修饰过后的一切物件都只与类相关，不与对象引用相关
• 静态变量，静态方法，静态块等都是类级别的属性，而不是单纯的对象属性。他们在类第一次被使用时被加载（记住，是一次使用，不一定是实例化）。我们可以简单得用 类名.变量 或者 类名.方法来调用它们。与调用没有被static 修饰过变量和方法不同的是：一般变量和方法是用当前对象的引用（即this）来调用的，静态的方法和变量则不需要。从一个角度上来说，它们是共享给所有对象的，不是一个角度私有。这点上，静态内部类也是一样的。

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

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

静态内部类何时初始化

---

静态内部类

• 静态内部类跟静态方法一样，只能访问静态的成员变量和方法，不能访问非静态的方法和属性，但是普通内部类可以访问任意外部类的成员变量和方法
• 静态内部类可以声明普通成员变量和方法，而普通内部类不能声明static成员变量和方法
• 静态内部类可以单独初始化:

Inner i = new Outer.Inner();

• 普通内部类初始化：

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

java 静态内部类

---

Java中volatile关键字及其作用

• 内存可见性：某线程对 volatile 变量的修改，对其他线程都是可见的。即获取 volatile 变量的值都是最新的
• 不能保证变量的原子性，要么都成功，要么都失败

浅析Java中volatile关键字及其作用

---

一篇反射的好文链接

Java基础之—反射（非常重要）

---

获取指定包下的注解–reflections工具类

依赖

<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{

    }
}

Spring内部的ClassUtils类
reflections工具类
使用建议看此篇文章
Reflections 反射api使用总结

---

Spring如何在注解中传入变量作为参数—使用SPEL表达式

SpEL表达式总结

---

持续整理中…