Java se

本文主要是介绍Java se，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

简单了解java类加载的运行顺序

进入main方法的类时的操作

1. 以main方法的类作为入口
2. 给本类static修饰的成员变量赋一个默认值，如果还被final修饰，就赋值为定义的那个值，执行本类的static代码块（先执行static代码块还是成员变量由在代码中的位置决定）
3. 其次是static方法

当使用　　类的static属性　　或者static方法　　或者new一个对象时会触发类加载

当new一个时，如果父类还没有被初始化，会先对其父类先初始化

如果已经初始化了，会先执行父类的构造器

泛型

泛型只存在于编码阶段，在运行阶段会被擦除，目的是为了兼容老版本的jdk

泛型的通配符为“?”，泛型的通配符使用的上边界以及下边界问题

extends　　上边界　　当需要读取，但不需要写入

super　　下边界　　当需要写入，但不需要读写

自定义一个泛型类

public class People<T> {
    private T name;
    public T getName() {
        return name;
    }
    public void setName(T name) {
        this.name = name;
    }
}

public class People2<K,V> {
    private K name;
    private V age;
    public K getName() {
        return name;
    }
    public void setName(K name) {
        this.name = name;
    }
    public V getAge() {
        return age;
    }
    public void setAge(V age) {
        this.age = age;
    }
}

构建这个泛型的对象

其中可以指定为任意类型

People<String> people = new People<>();
        people.setName("happy");

People2<String, Integer> people2 = new People2<>();
        people2.setName("happy");
        people2.setAge(12);

定义一个泛型方法以及应用

静态的泛型方法需要自己声名占位符，与类的占位符无关，同理，普通方法也可以自定义

public class People3<T>{
    public void show(T name){
        System.out.println(name);
    }
    public T show2(T name){
        return name;
    }
    public <M> M show3(M name){
        return name;
    }
    public static <E>void showStatic(E name){
        System.out.println(name);
    }
    public static <V> V showStatic2(V name){
        return name;
    }
}

People3<String> people3 = new People3<>();
        people3.show("11111");
        System.out.println(people3.show2("返回值的普通泛型方法"));
        People3.showStatic("happyStatic");
        System.out.println(People3.showStatic2(111));

定义泛型接口

1：其实现类给接口指定类型

2：实现类也声明一个泛型

注解

@Target({ElementType.TYPE,ElementType.METHOD})//表示注解的作用域
@Retention(RetentionPolicy.RUNTIME)//什么时候生效
@Documented//表示方法已经过时，但是还能用
@Inherited//表示子类可以继承
public @interface MyAnnotation {
String value() default "";
}

反射

一个类只有一个class对象

类被加载后，类的整个结构都被封装在class对象中

获取反射对象

1. 通过路径

   Class<?> c1 = Class.forName("com.smu.User");

2. 通过对象获取　　　　

   Class<? extends User> aClass = user.getClass();

3. 通过类名获取

   Class<User> userClass = User.class;

4. 基本内置对象的封装类都有的TYPE属性

   Class<Integer> type = Integer.TYPE;

通过反射获取类的信息

获取类名　　

• String name = c1.getName();
• String simpleName = c1.getSimpleName();

获取字段（带有Declared的是获取包括private的字段）

• Field[] fields = c1.getFields();
• Field username = c1.getField("username");
• Field[] declaredFields = c1.getDeclaredFields();
• Field username1 = c1.getDeclaredField("username");

获取方法（不带Declared是获取本类以及父类的public方法，带有Declared的是获得本类的所有包括private的方法）

• Method[] methods = c1.getMethods();
• Method getAge = c1.getMethod("getAge");
• Method[] declaredMethods = c1.getDeclaredMethods();
• Method setPassword = c1.getDeclaredMethod("setPassword", String.class);

获取构造器

• Constructor<?>[] constructors = c1.getConstructors();
• Constructor<?>[] declaredConstructors = c1.getDeclaredConstructors();
• Constructor<?> declaredConstructor1 = c1.getDeclaredConstructor(String.class, String.class, Integer.class);

获取对象

通过class对象获取（需要有无参构造器，需要是public修饰的），通过构造器获取，如果是private修饰的需要setAccessible(true);

• User o = (User) c1.newInstance();
• o.setAge(12);
• System.out.println("class对象获取"+o);
• Constructor<?> declaredConstructor = c1.getDeclaredConstructor(String.class, String.class, Integer.class);
• declaredConstructor.setAccessible(true);
• User happy = (User) declaredConstructor.newInstance("happy", "889886", 21);
• System.out.println("通过构造器获取"+happy);

 执行方法

可以通过类对象调用私有方法，也可以直接通过class对象获取方法

• Constructor<?> declaredConstructor = c1.getDeclaredConstructor(String.class, String.class, Integer.class);
• declaredConstructor.setAccessible(true);
• Object happy1 = declaredConstructor.newInstance("happy", "889886", 15);
• Method setUsername = c1.getDeclaredMethod("setUsername", String.class);
• setUsername.invoke(happy1, "sjjshj");

这篇关于Java se的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！