JAVA温习课堂12

最新推荐文章于 2021-03-09 20:33:34 发布
最新推荐文章于 2021-03-09 20:33:34 发布
阅读量540 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yours2/article/details/52732869
版权 
( 反射 )Annotation 注解
    @Test
    public void testAnnotation() throws Exception{
        String className = "com.reflectiondemo.Person";

        Class classTemp = Class.forName(className);

        Object obj = classTemp.newInstance();

        Method method = classTemp.getDeclaredMethod("setAge", int.class);

        int age = 17;
         Annotation annotation = method.getAnnotation(AgeValidator.class);

         if(annotation != null){
             if(annotation instanceof AgeValidator){
                 AgeValidator agevalidator = (AgeValidator) annotation;
                 if(age < agevalidator.min() || age > agevalidator.max()){
                     throw new RuntimeException("年龄非法");
                 }
             }
         }

         method.invoke(obj, age);
         System.out.println(obj);
    }

注解 示例代码  AgeValidator.java
    @Retention(RetentionPolicy.RUNTIME)
    @Target(value={ElementType.METHOD})
    public @interface AgeValidator {
        public int max();
        public int min();
    }

Person类 setAge 方法调用注解 示例代码
    @AgeValidator(min = 18,max = 50)
    public void setAge(int age){
        this.age = age;
    }   

( 反射 )Generic 泛型
    public static Class getSuperClassGenriType(Class classTemp,int index){

        Type type = classTemp.getGenericSuperclass();

        if(!(type instanceof ParameterizedType)){
            return null;
        }

        ParameterizedType parameterizedType = (ParameterizedType) type;

        Type [] types = parameterizedType.getActualTypeArguments();

        if(types == null){
            return null;
        }

        if(index < 0 || index > types.length - 1){
            return null; 
        }

        Type arg = types[index];

        if(arg instanceof Class){
            return (Class) arg;
        }
        return null;
    }

    @Test
    public void testGetSuperClassGenricType() throws ClassNotFoundException{
        String className = "com.reflectiondemo.EmployeeDao";
        Class classTemp = Class.forName(className);

        Class argClazz = getSuperClassGenriType(classTemp, 0);
        System.out.println(argClazz);

        argClazz = getSuperClassGenriType(classTemp, 1);
        System.out.println(argClazz);
    }

代码输出：
    class com.reflectiondemo.Enployee
    class java.lang.String

Reflection 反射（小结）

    Class 是一个类，是一个描述类的类，封装了描述方法的Method ， 描述字段的 Field
    描述构造器的Constructor 等属性

    得到Class 对象
        Student.class
        student.getClass( );
        Class.forName(String className);   较为常用

关于 Method
    获取Method
        getDeclaredMethods ： 得到Method 的数组
        getDeclaredMethod(String methodName , Class ... parameterTypes)
    调用Method    
        如果方法是private 修饰的，需要先调用Method 的setAccessible( true )，使其变为可访问
        method.invoke(obj, Object ... args );

关于Field
    获取Field : getField(String fieldName); 
    获取Field 的值
        setAccessible(true);
        field.get(Object obj);
    设置Field 的值
        field.set(Object obj,Object value);

了解Constructor 和 Annotation 

反射和泛型
    getGenericSuperClass( ); 获取带泛型参数的父类，返回值 :BaseDao<Employee,String>
    Type 的子接口： ParameterizedType 
    Type[ ] getActualTypeArguments( ) 获取 泛型参数数组


50、动态代理（解决模块化横切关注点）
    代理设计模式的原理：使用一个代理将对象包装起来，使用该代理对象取代原始对象
        任何对原始对象的调用都要通过代理，代理对象决定是否以及何时将方法调用转到原始对象上


示例代码：

    AirthmeticCalculator接口代码
    public interface AirthmeticCalculator {
        int add(int i ,int j);
        int sub(int i ,int j);
        void mul(int i ,int j);
        void div(int i ,int j);
    }

    @Test
    public void testProxy(){
        /** Proxy.newProxyInstance()
         *  参数列表：
         *      ClassLoader loader 由动态代理产生的对象由哪个类加载器进行加载
         *          通常和被代理对象使用一样的类加载器
         *      Class<?>[] : 由动态代理产生的对象必须实现的  接口的Class 数组
         *      InvocationHandler : 当具体调用代理对象的方法时，将产生什么行为
         * */

        final AirthmeticCalculator demo = new AirthmeticCalculatorDemo();

        AirthmeticCalculator proxy = 
                (AirthmeticCalculator)
                Proxy.newProxyInstance(demo.getClass().getClassLoader()
                        , new Class[]{AirthmeticCalculator.class}, 
                        new InvocationHandler(){
                            /**
                             * proxy
                             *      method: 正在被调用的方法
                             *      args: 调用方法时传入的参数
                             * */
                            public Object invoke(Object proxy, Method method,
                                    Object[] args) throws Throwable {   
//                              System.out.println(method);
                                System.out.println("The method" + method.getName() +" begin with  " +  Arrays.asList(args));

                                Object result = method.invoke(demo, args);

                                System.out.println("The method" + method.getName() + "end with  " + result);
                                return result;
                            }

                        });

        proxy.add(5, 5);

        int result = proxy.sub(10, 5);
        System.out.println(result);

    }


    /**
     * 动态代理的细节
     *      需要一个被代理的对象
     *      Proxy.newInstance( ) 的返回值 一定是被代理对象实现的接口的类型
     *          也可以是其他的接口类型
     *      ClassLoader 类加载器 通常是和被代理对象使用相同的类加载器
     *      若代理对象不需要额外实现被代理对象实现的接口以外的接口，可以使用被代理对象的方法 用法：demo.getClass().getInterfaces()
     *      代理对象需要实现被代理对象实现的接口以外的接口 用法：new Class[]{AirthmeticCalculator.class,RandomInterface.class}
     *
     *      InvocationHandler 通常是匿名内部类的方式进行 ，需要重写未实现的方法 
     *          被代理对象需要是final 类型的 
     *      InvocationHandler 的 invoke 方法 中的第一个参数 Object 类型的proxy
     *          指正在被返回的那个代理对象，通常不被使用
     * */

    @Test
    public void testProxy2(){
        /**
         * final 修饰的原因是 
         *      该局部变量被Object proxy 匿名内部类的重写方法引用
         *      而proxy 可能会长时间存在，所以 该demo 需要长的生命周期
         * */
        final AirthmeticCalculator demo = new AirthmeticCalculatorDemo();

        Object proxy = Proxy.newProxyInstance(demo.getClass().getClassLoader(),
                demo.getClass().getInterfaces(),
                new InvocationHandler() {

                    public Object invoke(Object proxy, Method method, Object[] args)
                            throws Throwable {

                        return method.invoke(demo, args);
                    }
                });
    }


实例需求：
    定义一个Service 接口
        void addNew(Person person);
        void delete(Integer id);
        void update(Person person);
    并提供具体实现类
    使用动态代理实现2事物操作
        在调用具体每个Service 方法前, 都打印：开始事务
        方法正常结束, 都打印： 事务提交
        若在调用目标方法处异常, 打印：事务回滚

（仅给出部分重要代码）实例代码：
        Person类中
            private int id;
            private String name;
            private int age;
            无参有参构造方法、重写ToString( )方法

        Service接口
            void addNew(Person person);
            void delete(Integer id);
            void update(Person person);

        public class PersonServiceDemo {

            private Service target = null;

            public PersonServiceDemo(Service target) {
                this.target = target;
            }

            public Service getPersonServiceProxy(){

                Service proxy = (Service) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                        target.getClass().getInterfaces(), 
                        new InvocationHandler() {

                            public Object invoke(Object proxy, Method method, Object[] args)
                                    throws Throwable {
                                System.out.println();
                                System.out.println( " 事务开始  "+"方法：" + method.getName() + " 参数："+Arrays.asList(args) );
                                try {
                                    Object result = method.invoke(target, args);
                                    System.out.println(" 事务结束");
                                    return result;
                                } catch (Exception e) {
                                    e.printStackTrace();
                                    System.out.println(" 回滚事务");
                                }
                                return null;
                            }
                        });
                return proxy;
            }
        }


        public class ServiceDemo implements Service {

            private static Map<Integer,Person> persons = new HashMap<Integer,Person>();

            public ServiceDemo() {
                persons.put(1001, new Person(1001,"EngineerZhong", 21));
                persons.put(1002, new Person(1002,"EngineerYe", 20));
            }

            public void addNew(Person person) {
                persons.put(person.getId(), person);

            }

            public void delete(Integer id) {
                if(id == 1001){
                    throw new RuntimeException( id +"不能被删除");
                }
                persons.remove(id);
            }

            public void update(Person person) {
                persons.put(person.getId(), person);
            }

            public static Map<Integer,Person> getMapValue(){
                return persons;
            }
        }

        @Test
        public void testProxyDate(){
            Service target = new ServiceDemo();

            Service proxy = new PersonServiceDemo(target).getPersonServiceProxy();

            System.out.println(ServiceDemo.getMapValue());

            proxy.addNew(new Person(1003,"EngineerZhong",20));

            System.out.println(ServiceDemo.getMapValue());

            proxy.delete(1001);

            System.out.println(ServiceDemo.getMapValue());

            proxy.update(new Person(1002, "EngineerZhongAndeYe", 21));

            System.out.println(ServiceDemo.getMapValue());
        }
更新时间：2016年10月4日
大离弟弟咯
关注
专栏目录
java实验2总结心得,java实验的心得体会
weixin_30516429的博客
03-11 4532
java实验的心得体会java实验心得体会篇一：java实验总结1. 设计一个Person类，包含：姓名，年龄，性别。要求：该类至多只能创建一男、一女两个对象！2. 设计一个测试类Test，创建若干个Person类对象，测试是否符合要求。 package test8;class person {String name;int age;char sex;static int flag1 = 1, f...
JAVA温习课堂7
步履蹒跚的攻城狮的博客
09-17 347
40、TreeSet（默认按升序排序） 调用集合元素的compareTo方法 TreeSet 添加的应该是同一个类的对象 equals方法返回的结果应该与compareTo方法返回的结果有一致性 如果使用TreeSet 无参数的构造器创建一个TreeSet对象，则要求放入其中的元素的类必须实现CompareTo方法，所以在其中不能放入
JAVA温习课堂14
步履蹒跚的攻城狮的博客
10-08 418
52、TCP/IP 编程基础（国际标准）传输控制协议TCP，网络互联协议IP 网络编程的目的：直接或间接通过网络协议与其它计算机进行通讯 准确定义网络上一台或多台主机 InetAddress.getByName(String arg); 找到主机后如何可靠高效地进行数据传输 IP定位网络中的一台主机 端口定位主机的一个网络程序 Inet
JAVA温习课堂6
步履蹒跚的攻城狮的博客
09-16 317
34、内部类 在类的内部定义的类 内部类相当于类的一个成员，可以修饰类的成员的private static final abstract 都可以修饰 声明、使用内部类的实例 非静态内部类的创建，先创建外部类的实例，再使用外部类的实例对象进行创建内部类的实例 静态内部类的创建：不再需要外部类的实例 内部类引用外部类的成员 匿名内部类对象：
JAVA温习课堂1
步履蹒跚的攻城狮的博客
09-10 336
1.基本数据类型定义直接把值放在栈内存空间里 2.引用数据类型是在栈内存空间里存该数据类型值存放在堆内存中的首地址 3、8种基本数据类型 整形 byte 1字节 short 2字节 int 4字节 long 8字节 L结尾 浮点型 默认为double float 结尾加F 十进制数形式: 5.12 512.0F 科学计数法: 5.12e2 == 5.12*10^2 布尔型 bool
JAVA温习课堂13
步履蹒跚的攻城狮的博客
10-07 382
51、线程（Thread） （ 程序 program 是对数据描述与操作的代码的集合，是应用程序执行的脚本 进程 process 程序一次执行过程，系统运行程序的基本单位。程序是静态的，进程是动态的 系统运行一个程序即是一个进程从创建、运行到消亡的进程。 多任务 multi task 在一个系统中可以同时运行多个程序，即
JAVA温习课堂11
步履蹒跚的攻城狮的博客
10-02 359
49、反射 Class 是对一个类的描述 类的属性： Field 类的方法： Method 类的构造器：Constrctor 对象照镜子后可以得到的信息：类的数据成员名、方法和构造器、实现了哪些接口 对于每个类 JRE都为其保留一个不变的Class类型的对象，一个Class对象包含了特定某个类的有关信息 Class对象只
JAVA温习课堂10
步履蹒跚的攻城狮的博客
09-28 358
StringBuffer 和 StringBuilder （可以被修改的字符序列） StringBuilder 是线程不安全的，效率相对较高，常用。 StringBuffer 是线程安全的，效率相对低，多线程的情况下使用。 append( )方法 是把字符串加入到以后的字符序列的后面 返回值还是当前的StringBuffer 对象，可以使用方法的连缀Date
JAVA温习课堂9
步履蹒跚的攻城狮的博客
09-25 394
对象流ObjectInoutStream ObjectOutputStream（对象 必须实现 Serializable 接口） 对象序列化的目标是将对象保存到磁盘上，或允许在网络中直接传输对象 为了让某类能够进行序列化，必须实现 Serializable 接口 如果类的某个字段不是基本数据类型或String 类型，而是另一种引用类型，那么这个引用类型必须是可序列化的，否则拥
JAVA温习课堂8
步履蹒跚的攻城狮的博客
09-21 385
43、Collections （操作集合的工具类） reverse(List) 反转 List 中元素的顺序 shuffle(List) 对 List 集合元素进行随机排序 sort(List) 根据元素的自然顺序对指定 List 集合元素按升序排序 sort(Li
Java实习报告范文精选5篇.pdf
07-08
【Java实习报告】Java实习是学生们从理论走向实践的关键步骤，通过实习，学生能更好地理解课堂上学到的Java基础知识，并将其应用到实际项目中。在Java实习报告中，通常会包含以下几个方面： 1. **实训内容**：Java...
java类与对象实验报告心得体会_java实习实训报告心得【三篇】
weixin_29801195的博客
12-29 4064
【导语】Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。而学习Java的同学java实习实训是必经的过程。以下是无忧考网整理的java实习实训报告心得，欢迎阅读！java实习实训报告心得篇1在本学期的二周时间内，我们在学校机房进行了为期二周的JAVA实训。现在即将结束了，回首本学期的java学习，重点还是在学习概念等一些常识性的东西，也学到平常在课堂中没有学到的东西，在JAVAAPI...
java实践体会,java实践心得体会范文3篇
weixin_30916653的博客
03-09 1586
在我所学的语言当中，我自认为JAVA是一门比较强大的面向对象的编程语言，不仅仅因为它的跨平台性，更多的是因为它的灵活多变和实用性较强，可以说比较的经典和强悍。所以学好java语言有很大的用处，这次实训，我们更多学到的是不懂就问和自己应该尽自己的全力去尝试，哪怕失败，只要自己尽自己的全力，和身边同学一起探讨而不是抄袭，团结合作，发挥团队意识，最后在自己的努力下，终于运行成功，这种成就感美不可言，心情...
JAVA JDK下载安装及配置环境
步履蹒跚的攻城狮的博客
07-11 574
配置JDK是必须的，JDK是 Java 语言的软件开发工具包 下载网站：http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html 安装路径:C:\Program Files\Java\jdk1.8.0_91\ JRE安装路径 C:\Program Files\Java
JAVA温习课堂4
步履蹒跚的攻城狮的博客
09-11 570
19、this关键字【只能在方法中使用】 对调用当前方法的那个对象的引用 当前对象：当前方法所在的对象 this的用途 在一般的方法中可以通过this来引用当前对象的成员（方法、属性） 通过this()调用重载的构造器，需要注意通过这种方法调用重载的构造器代码必须放在当前构造器的第一行 20、函数的参数传递 基本参数的传递
JAVA封装连接数据库【JDBC】
步履蹒跚的攻城狮的博客
07-04 486
菜鸟练手，大神勿喷。封装类 import java.sql.* public class mysqlCon { private String URL = null; // 数据库地址 private String JDBCNAME = null; // 数据库类名 private String USER = null;// 数据库
JAVA初识
步履蹒跚的攻城狮的博客
06-25 453
JAVA初识一、了解学习1、Java的起源 Oak——> Java2、Java的发展Java1.0 Java2 JavaSE:Java平台标准版 JavaME:微型版 JavaEE:企业版 sun公司 oracle公司3、Java的特性面向对象 可移植性、JVM实现了可移植性 健壮性 分布式 多线程：线程可以理解为轻量的进程4、Java的工作方式Java源文件（.java格式结尾）—
JAVA温习课堂3
步履蹒跚的攻城狮的博客
09-11 413
15、面向对象 三大特征：封装、继承、多态 类class 是一类事物描述，是抽象的、概念上的定义 对象Object 是实际存在的该类事物的每个个体，也称为实例 instance 修饰符：public private protected 类名定义标准：第一个单词首字母小写后继单词首字母大写 返回值类型 return 返回值;
java 贪吃蛇碰撞检测_温习数据算法—贪吃蛇
最新发布
05-29
对于Java贪吃蛇游戏的碰撞检测，通常需要考虑以下几个方面： 1. 蛇头和食物的碰撞检测：在游戏中，蛇会不断地移动，当蛇头与食物碰撞时，就意味着蛇吃到了食物，需要更新蛇的长度和分数。这个碰撞检测可以通过判断...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值