黑马程序员_Java基础加强（下）

8、注解类

注解相当于一种标记，加了注解就等于打上了某种标记，没加就等于没打特殊标记，开发工具和其他程序可以用反射来了解你的类及各种元素上有无何种标记，看你有什么标记就去干什么事，标记可以加在包、类、字段、方法，方法的参数以及局部变量上。

注解的应用结构图：

为注解增加属性

定义基本类型的属性和应用属性

在注解类中增加String color();

@MyAnnotation(color = "red")

用反射方式获得注解对应的实例对象后，再通过该对象调用属性对应的方法

MyAnnotation a
=(MyAnnotation)AnnotationTest.class.getAnnotation(MyAnnotation.class);

System.out.println(a.color);

可以认为上面这个@MyAnnotation是MyAnnotation类的一个实例对象。

为属性指定缺省值

String color() default"yellow";

value属性

String value() default "xyz"

为注解增加高级属性

数组类型的属性

int[] arrayAttr() default {1,2,3}

@MyAnnotation(arrayAttr={2,3,4})

如果数组属性中只有一个元素，这时候属性值部分可以省略大括号

枚举类型的属性

EnumTest.TrafficLamp lamp();

MateAnnotation annotationAttr() default @MateAnnotation("xxxxx")

@MyAnnotation(annotationAttr = @MateAnnotation("yyy"))

可以认为上面这个@MyAnnotation是MyAnnotation类的一个实例对象，同样道理可以认为上面这个@MateAnnotation是MateAnnotation类的一个实例对象调用代码如下：

MateAnnotation ma=myAnnotation.annotationAttr();

System.out.println(ma.value());

例：


package cn.itcast.day2;


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;


import cn.itcast.day1.EnumTest;


@Retention(RetentionPolicy.RUNTIME)

@Target({ElementType.METHOD,ElementType.TYPE})

public @interface ItcastAnnotation { //创建注解类

    String color() default "blue";

    String value();

    int[] arrayAtt() default {3,4,5};

    EnumTest.TrafficLamp lamp() default EnumTest.TrafficLamp.RED;

    MetaAnnotation annotationAttr() default @MetaAnnotation("lhm");

}


package cn.itcast.day2;


@ItcastAnnotation(annotationAttr = @MetaAnnotation("flx"), color = "red",value = "abc",arrayAtt = {1,2,3})

public class AnnotationTest {


@SuppressWarnings("deprecation")

    @ItcastAnnotation("xyz")

    public static void main(String[] args){


System.runFinalizersOnExit(true);


if(AnnotationTest.class.isAnnotationPresent(ItcastAnnotation.class)){


ItcastAnnotation annotation = (ItcastAnnotation)AnnotationTest.class.getAnnotation(ItcastAnnotation.class);

            System.out.println(annotation.color());

            System.out.println(annotation.value());

            System.out.println(annotation.arrayAtt().length);

            System.out.println(annotation.lamp().nextLamp().name());

            System.out.println(annotation.annotationAttr().value());

        }

    }


@Deprecated

    public static void sayHello(){

        System.out.println("hi,传智播客");

    }

}

public @interface MetaAnnotation {


String value();

}

9、泛型

泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样
。由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如反射得到集合在调用其add方法即可。

例：


import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Date;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

import java.util.Vector;


import cn.itcast.day1.ReflectPoint;


public class GenericTest {


public static void main(String[] args) throws Exception{

        // TODO Auto-generated method stub

        ArrayList connection1 = new ArrayList();

        connection1.add(1);

        connection1.add(1L);

        connection1.add("abc");

        //int i = (Integer)connection1.get(1);


ArrayList<String> connection2 = new ArrayList<String>();

        //connection2.add(1);

        //connection2.add(1L);

        connection2.add("abc");

        String element = connection2.get(0);


Constructor<String> constructor1 = String.class.getConstructor(StringBuffer.class);

        String str2 = constructor1.newInstance(new StringBuffer("abc"));

        System.out.println(str2.charAt(2));


ArrayList<Integer> connection3 = new ArrayList<Integer>();

        System.out.println(connection3.getClass() == connection2.getClass());


connection3.getClass().getMethod("add", Object.class).invoke(connection3, "abc");

        System.out.println(connection3.get(0));


printCollection(connection3);


//Class<Number> x = String.class.asSubclass(Number.class);

        Class<?> y;

        Class<String> x;


HashMap<String,Integer> maps = new HashMap<String,Integer>();

        maps.put("zxx", 20);

        maps.put("lhm", 30);

        maps.put("flx", 35);


Set<Map.Entry<String,Integer>> entrySet = maps.entrySet();

        for(Map.Entry<String,Integer> entry : entrySet){

            System.out.println(entry.getKey()+":"+entry.getValue());

        }


add(3,5);

        add(3.5,3);

        add(3,"abc");


swap(new String[]{"abc","xyz","123"},1,2);


Object obj = "abc";

        String x3 = autoConvert(obj);


copy1(new Vector<String>(),new String[10]);

        copy2(new Date[10],new String[10]);

        //copy1(new Vector<Date>(),new String[10]);


GenericDao<ReflectPoint> dao = new GenericDao<ReflectPoint>();

        dao.add(new ReflectPoint(3,3));

        //String s = dao.findById(0);


//Vector<Date> v1 = new Vector<Date>();

        Method applyMethod = GenericTest.class.getMethod("applyVector", Vector.class);

        Type[] types = applyMethod.getGenericParameterTypes();

        ParameterizedType pType = (ParameterizedType)types[0];

        System.out.println(pType.getRawType());

        System.out.println(pType.getActualTypeArguments()[0]);

    }

    public static void applyVector(Vector<Date> v1){


}

    private static <T> void fillArray(T[] a,T obj){

        for(int i=0;i<a.length;i++){

            a[i] = obj;

        }

    }

    private static <T> T autoConvert(Object obj){

        return (T)obj;

    }


private static <T> void swap(T[] a,int i,int j){

        T tmp = a[i];

        a[i] = a[j];

        a[j] = tmp;


}

    private static <T> T add(T x , T y){


return null;

    }

    public static void printCollection(Collection<?> collection){


System.out.println(collection.size());

        for(Object obj : collection){

            System.out.println(obj);

        }

    }

    public static <T> void printCollection2(Collection<T> collection,T obj2){


System.out.println(collection.size());

        for(Object obj : collection){

            System.out.println(obj);

        }

        collection.add(obj2);

    }

    public static <T> void copy1(Collection <T> dest,T[] src){


}

    public static <T> void copy2(T[]

            dest,T[] src){


}

}


import java.util.Set;


public class GenericDao <T> {


public void add(T X){


}

    public T findById(int id){


return null;

    }

    public void delete(T obj){


}

    public void delete(int id){


}

    public void updata(T obj){


}

    public static <T> void updata2(T obj){


}

    public T findByUserName(String name){

        return null;

    }

    public Set<T> findByConditions(String where){


return null;

    }

}

10、类加载器

类加载器也是Java类因为其他Java类的类加载器本身也要被类加载器加载，显然必须有第一个类加载器不是Java类，这正是BootStrap(c++提供的类)

Java虚拟机可以安装多个类加载器，系统默认三个类加载器，每个类负责加载特定位置的类：BootStrap,ExtClassLoader,AppClassLoader

类加载器之间的父子关系和管辖范围图

类加载器的委托加载机制

当Java虚拟机要加载一个类时到底派出哪个类加载器加载呢？

首先当前现成的类加载器去加载线程中的第一个类

如果A中引用了类B，Java虚拟机将使用加载类A的类加载器来加载类B

还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类

11、代理类

程序中的代理是指要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如：异常处理、日志、计算方法的运行时间、事务管理等等

代理架构图：

例：


import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.Collection;


public class ProxyTest {


public static void main(String[] args) {

        // TODO Auto-generated method stub

        Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(),Collection.class);

        System.out.println(clazzProxy1.getName());


System.out.println("");

        /*$Proxy0();

         $Proxy0(InvocationHandler,int);*/

        Constructor[] constructors = clazzProxy1.getConstructors();

        for(Constructor constructor :constructors){

            String name = constructor.getName();

            StringBuilder sBuilder = new StringBuilder(name);

            sBuilder.append(‘(‘);

            Class[] clazzParams = constructor.getParameterTypes();

            for(Class clazzParam : clazzParams){

                sBuilder.append(clazzParam.getName()).append(‘,‘);

            }

            if(clazzParams!=null && clazzParams.length!=0){

                sBuilder.deleteCharAt(sBuilder.length()-1);

            }

            sBuilder.append(‘)‘);

            System.out.println(sBuilder.toString());

        }

        System.out.println("");

        /*$Proxy0();

         $Proxy0(InvocationHandler,int);*/

        Method[] methods = clazzProxy1.getMethods();

        for(Method method :methods){

            String name = method.getName();

            StringBuilder sBuilder = new StringBuilder(name);

            sBuilder.append(‘(‘);

            Class[] clazzParams = method.getParameterTypes();

            for(Class clazzParam : clazzParams){

                sBuilder.append(clazzParam.getName()).append(‘,‘);

            }

            if(clazzParams!=null && clazzParams.length!=0){

                sBuilder.deleteCharAt(sBuilder.length()-1);

            }

            sBuilder.append(‘)‘);

            System.out.println(sBuilder.toString());

        }


}


}

黑马程序员_Java基础加强（下）,布布扣,bubuko.com

时间： 2024-04-26 16:11:04

黑马程序员_Java基础加强（下）的相关文章

黑马程序员_JAVA 基础加强学习笔记

一.面向对象 (一)继承  1.继承的好处: (1) 提高了代码的复用性. (2) 让类与类之间产生了关系,提供了另一个特征多态的前提. 注意: 子类中所有的构造函数都会默认访问父类中的空参数的构造函数,因为每一个子类构造内第一行都有默认的语句super();  如果父类中没有空参数的构造函数,那么子类的构造函数内,必须通过super语句指定要访问的父类中的构造函数. 如果子类构造函数中用this来指定调用子类自己的构造函数,那么被调用的构造函数也一样会访问父类中的构造函数. 2.final特点

黑马程序员_Java基础加强（上）

1.静态导入 静态导入是jdk1.5版本以后出现的新特性,一般是指导入静态方法,如:import static java.lang.System.out 是指导入系统输出的静态方法. 例: import static java.lang.System.out //导入java.lang包下的System类的静态方法out public class StaticImport { public static void main(String[] args) { int x=1; x++; out.p

黑马程序员_Java基础_接口

------- android培训.java培训.期待与您交流! ---------- 0.接口知识体系 Java接口的知识体系如下图所示,掌握下图中的所有知识就可精通接口. 1.接口概论 1)接口概念 接口是从多个相似类中抽象出来的规范,接口中不包含普通方法,所有方法都是抽象方法,接口不提供实现.接口体现的是规范和实现分离的哲学.规范和实现分离正是接口的好处,让软件系统的各个组件之间面向接口耦合,是一种松耦合的设计.接口定义的是多个类共同的公共行为规范,定义的是一组公用方法. 2)接口与抽象类

黑马程序员_Java基础String类

- - - - - android培训.java培训.期待与您交流! - - - - - - - String是一个对象 String不属于8种基本数据类型(byte, char, short, int, float, long, double, boolean),String是对象,所以其默认值是null. String是一种特殊的对象,有其它对象没有的一些特性,通过JDK发现: public final class String implements java.io.Serializable

黑马程序员——Java基础---IO(下)

黑马程序员——Java基础---IO(下) ------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------ 一.概述 Java除了基本的字节流.字符流之外,还提供了File类.properties类.打印流.序列流等和输入输出相关的类,它们能够帮助我们更好的处理信息.下面将对它们进行简单的介绍. 一.正

黑马程序员——Java基础---面向对象(下)

一.概述 面向对象除了封装.继承和多态三大特征之外,还有其他的特性,例如abstract抽象.interface接口等,抽象类主要作为多个类的模板,而接口则定义了多类应该遵守的规范,final关键字让java实现不可变类,让系统更加安全. 二.正文 1.构造器和初始化块 1.1 构造器 构造器是一种特殊方法,这个特殊方法用于创建实例时执行初始化,是创建对象的重要途径,如果程序员没有为JAVA类提供任何构造器,则系统会为这个类提供一个无参数的构造器,这个构造器的执行体为空,不做任何事情.无论如何,

黑马程序员_Java基础知识

java基础知识 1.Dos命令: dir:列出当前目录下所有的的文件及文件夹 md:创建目录 rd:删除目录 cd:进入指定mul cd\:返回到根目录 cd..:退到上级目录 del:删除文件 exit:退出dos命令行 *:通配符 help:帮助命令 2.path系统变量:系统中应用程序所在的路径 临时配置的环境变量的方式:用set命令完成 set:用于查看本机中所有环境变量的信息 set 变量名:查看具体的一个环境变量的值 set 变量名=:清空变量的值 set 变量名=具体值:赋值 在

黑马程序员_JAVA基础知识总结3

Java源文件的扩展名是.java,编译之后生成.class的文件.所有的类都有一个共同的继承祖先Object类 一个.java文件中只能有一个public类,一个public类只能定义在以它的类名命名的文件中 Implement关键字用来实现接口,类可以实现多个接口,继承使用extends 关键字 package(包)为了更好的组织java程序,包为java程序提供了一个命名空间,一个java类的完整路径由它的包和类名共同组成 Java类或者没有public关键字表示该类在它所在的包中可见,这

黑马程序员_java基础知识精华总结

本文总结了JAVA中的基础知识部分,具体包括:1.对象的初始化:2.2.继承时,对象的初始化过程:3.关于构造方法:4.有关public.private和protected:5.抽象类:6.final关键字:7.接口interface:8.多重继承:9.接口的嵌入:10.类的嵌入:11.异常类. 1.对象的初始化 (1)非静态对象的初始化在创建对象时,对象所在类的所有数据成员会首先进行初始化.基本类型:int型,初始化为0.如果为对象:这些对象会按顺序初始化.※在所有类成员初始化完成之后,才调用