首页 文章 精选 留言 我的

精选列表

搜索[techo day],共2891篇文章
优秀的个人博客,低调大师

day19_java基础加强_动态代理+注解+类加载器

一、动态代理 1.1、代理模式 什么是代理模式及其作用? Proxy Pattern(即:代理模式),23种常用的面向对象软件的设计模式之一。 代理模式的定义:为其他对象提供一种代理以控制对这个对象的访问。 在某些情况下,一个对象不适合或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。 优点: (1) 职责清晰,真实的角色就是实现实际的业务逻辑,不用关心其他非本职责的事务,通过后期的代理完成一件完成事务,附带的结果就是编程简洁清晰。 (2) 代理对象可以在客户端和目标对象之间起到中介的作用,这样起到了保护目标对象的作用。 (3) 高扩展性。 结构: 一个是你要访问的真正的对象(目标类),另一个是代理对象,真正对象(目标对象)与代理对象实现同一个接口,先访问代理类再访问真正要访问的对象。 其实装饰(包装)设计模式就是静态代理。 静态代理模式简单案例: KindWomen.java(接口) package com.itheima.demo;public interface KindWomen {public void throwEye();public void doSomething();} PJL.java(目标类1 实现 接口,并具体实现) package com.itheima.demo;public class PJL implements KindWomen {@Overridepublic void throwEye() { System.out.println("潘金莲抛媚眼"); }@Overridepublic void doSomething() { System.out.println("潘金莲XOXO"); }} YPX.java(目标类2 实现 接口,并具体实现) package com.itheima.demo;public class YPX implements KindWomen {@Overridepublic void throwEye() { System.out.println("阎婆惜抛媚眼"); }@Overridepublic void doSomething() { System.out.println("阎婆惜XOXO"); }} WP.java(代理类 也实现接口,但是空实现) package com.itheima.demo;public class WP implements KindWomen {private KindWomen kw;public WP(KindWomen kw) {this.kw = kw; }@Overridepublic void throwEye() { kw.throwEye(); }@Overridepublic void doSomething() { kw.doSomething(); }} XMQ.java(我) package com.itheima.demo;public class XMQ {public static void main(String[] args) { PJL pjl = new PJL(); YPX ypx = new YPX(); KindWomen wp1 = new WP(pjl); KindWomen wp2 = new WP(ypx); wp1.throwEye(); wp1.doSomething(); wp2.throwEye(); wp2.doSomething();} 1.2、动态代理 动态代理它可以直接给某一个目标对象生成一个代理对象,而不需要代理类存在。 动态代理与代理模式原理是一样的,只是它没有具体的代理类,直接通过反射生成了一个代理对象。 动态代理生成技术: 1. 基于jdk提供一个Proxy类,可以直接给实现某接口的实现类直接生成代理对象。 2. 基于cglib (spring框架会学习) java.lang.reflect.Proxy; 该类可以直接生成一个代理对象。 Proxy类的方法: public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 返回一个指定接口的代理类实例。 仅能代理实现至少一个接口的类(即目标对象需要至少有一个接口)。 ClassLoader:类加载器。固定写法,和被代理类使用相同的类加载器即可。 Class[]:代理类要实现的接口。固定写法,和被代理类使用相同的接口即可。 InvocationHandler:策略(方案)设计模式的应用。如何去具体实现代理,由我们自己决定。 InvocationHandler接口中的invoke方法:调用代理类的任何方法,此方法都会执行。 Object invoke(Object proxy, Method method, Object[] args) Object proxy:代理对象本身的引用。一般用不着。 Method method:当前调用的方法。 Object[] args:当前方法用到的参数。 动态代理模式简单案例: KindWomen.java(接口) package com.itheima.demo;public interface KindWomen {public void throwEye(double money);public void doSomething(double money);} PJL.java(目标类1 实现 接口,并具体实现) package com.itheima.demo;public class PJL implements KindWomen {@Overridepublic void throwEye(double money) { System.out.println("潘金莲拿了" + money + "元钱,抛媚眼"); }@Overridepublic void doSomething(double money) { System.out.println("潘金莲拿了" + money + "元钱,XOXO"); }} XMQ.java(我) package com.itheima.demo;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;public class XMQ {public static void main(String[] args) {final KindWomen kw = new PJL(); // 真实对象(目标对象)// final YPX ypx = new YPX();// PJL pjl = new PJL();// YPX ypx = new YPX();// KindWomen wp1 = new WP(pjl);// KindWomen wp2 = new WP(ypx);// wp1.throwEye();// wp1.doSomething();// wp2.throwEye();// wp2.doSomething();// public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) // 返回一个指定接口的代理类实例。仅能代理实现至少一个接口的类(即目标对象至少有一个接口)。 KindWomen proxy = (KindWomen) Proxy.newProxyInstance(kw.getClass().getClassLoader(), kw.getClass().getInterfaces(), new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("代理帮你做事情之前,可以做别的事情"); Object o = method.invoke(kw, new Object[] { (Double) args[0] / 2 }); // 这是真实对象执行的方法(做的事情) System.out.println("代理帮你完做事情之后,仍可以做别的事情");return o; } }); proxy.throwEye(5); proxy.doSomething(10); }} 静态/动态代理图解: 1.3、AOP(面向切面编程)编程思想(Spring框架中的核心思想之一) Spring框架中的核心思想包括: Dependency Injection(依赖注入) Inverse of Control(控制反转) Aspect Oriented Programming(面向切面编程) AOP编程思想解决的问题: 1、问题:业务的方法日后会很多,这样会有很多重复的代码。 2、问题:业务已经存在很多的方法,并没有考虑到事务的问题,现在要求加上。那么业务的重心就变了。 动态代理实现AOP示例代码:(转账功能) 完成业务的代码: package com.itheima.service.impl;import com.itheima.dao.AccountDao;import com.itheima.dao.impl.AccountDaoImpl;import com.itheima.domain.Account;import com.itheima.service.AccountService;public class AccountServiceImpl implements AccountService {@Override // 运用AOP思想,转账功能就是转账功能,不要加其他的东西,比如事务控制、日志、权限控制等,这样代码健壮性好,优美。public void transfer(String fromname, String toname, double money) throws Exception {// ad.updateAccount(fromname, toname, money); AccountDao ad = new AccountDaoImpl();// 分别得到转出和转入账户对象 Account fromAccount = ad.findAccountByName(fromname); Account toAccount = ad.findAccountByName(toname);// 修改账户各自的金额 fromAccount.setMoney(fromAccount.getMoney() - money); toAccount.setMoney(toAccount.getMoney() + money);// 完成转账操作 ad.updateAccout(fromAccount);// int i = 10 / 0; ad.updateAccout(toAccount); }}/*package com.itheima.service.impl;import java.sql.Connection;import java.sql.SQLException;import com.itheima.dao.AccountDao;import com.itheima.dao.impl.AccountDaoImpl;import com.itheima.domain.Account;import com.itheima.service.AccountService;import com.itheima.util.C3P0Util;import com.itheima.util.ManagerThreadLocal;public class AccountServiceImpl implements AccountService { @Override public void transfer(String fromname, String toname, double money) { // ad.updateAccount(fromname, toname, money); AccountDao ad = new AccountDaoImpl(); try { ManagerThreadLocal.startTransacation(); // 开启事务 // 分别得到转出和转入账户对象 Account fromAccount = ad.findAccountByName(fromname); Account toAccount = ad.findAccountByName(toname); // 修改账户各自的金额 fromAccount.setMoney(fromAccount.getMoney() - money); toAccount.setMoney(toAccount.getMoney() + money); // 完成转账操作 ad.updateAccout(fromAccount); // int i = 10 / 0; ad.updateAccout(toAccount); ManagerThreadLocal.commit(); // 提交事务 } catch (Exception e) { try { ManagerThreadLocal.rollback(); // 回滚事务 } catch (Exception e1) { e1.printStackTrace(); } } finally { try { ManagerThreadLocal.close(); // 关闭 } catch (Exception e) { e.printStackTrace(); } } }}*/ 产生代理对象的工厂代码: package com.itheima.util;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import com.itheima.service.AccountService;import com.itheima.service.impl.AccountServiceImpl;public class ObjectFactory {// 该方法返回一个代理对象public static AccountService getAccountService() {final AccountService as = new AccountServiceImpl(); // 真实对象(目标对象) AccountService proxy = (AccountService) Proxy.newProxyInstance(as.getClass().getClassLoader(), as.getClass().getInterfaces(), new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object invoke = null;try { ManagerThreadLocal.startTransacation(); // 开启事务// 执行的是真实对象的转账方法 invoke = method.invoke(as, args); ManagerThreadLocal.commit(); // 提交事务 } catch (Exception e) {try { ManagerThreadLocal.rollback(); // 回滚事务 } catch (Exception e1) { e1.printStackTrace(); } } finally {try { ManagerThreadLocal.close(); // 关闭 } catch (Exception e) { e.printStackTrace(); } }return invoke; } });return proxy; }} 测试类代码: package com.itheima.test;import com.itheima.service.AccountService;import com.itheima.util.ObjectFactory;public class TestTransfer {/** * @param args * @throws Exception */public static void main(String[] args) throws Exception {// AccountService as = new AccountServiceImpl();// as.transfer("aaa", "bbb", 100); AccountService as = ObjectFactory.getAccountService(); as.transfer("aaa", "bbb", 100); }}/*package com.itheima.test;import com.itheima.service.AccountService;import com.itheima.service.impl.AccountServiceImpl;import com.itheima.util.ObjectFactory;public class TestTransfer { public static void main(String[] args) throws Exception { AccountService as = new AccountServiceImpl(); as.transfer("aaa", "bbb", 100); }}*/ 二、注解 注解不是注释,注释是程序员写的,给程序员看的。注解给程序看,用于描述程序如何运行及在什么阶段来运行。现在在实际开发中,注解最大的功能是用于替换配置文件。 注解是jdk1.5的新特性。可以通过反射来让注解具有功能。注解格式: @Xxxx 2.1 JDK中的三个基本的注解: a. @Override 检查子类确实是覆盖了父类的方法。 b. @Deprecated 说明已经过时了。 c. @SuppressWarnings({ "unused", "deprecation", "rawtypes" }) 抑制程序中的警告。unused(变量未使用)、deprecation(过时)和rawtypes(泛型)表示警告的类型。{}数组。 d. @SuppressWarnings("all") all抑制所有警告。 示例代码如下: package com.itheima.demo1;import java.util.ArrayList;import java.util.Date;import java.util.List;public class Demo1 {// @SuppressWarnings({ "unused", "deprecation", "rawtypes" }) @SuppressWarnings("all")public void ff() {int i = 0; System.out.println("abc"); List list = new ArrayList(); System.out.println(new Date().toLocaleString()); }public void HaHa() { }}class Demo2 extends Demo1 {@Overridepublic void ff() { }@Deprecatedpublic void HaHaHa() { System.out.println(new Date().toLocaleString()); }} 2.2 自定义注解的语法(注解的肉体) 研究一下注解的本质: 声明一个注解(或者创建一个注解类): @interface 注解名{…} public @interface MyAnnotation {} 通过反编译可知,注解它的本质就是一个接口,这个接口需要继承 Annotation接口。但是不能按照下述的代码格式写,需要按照上述代码格式写。 public interface MyAnnotation extends java.lang.annotation.Annotation {...} 分析注解类中的成员: 注解本质上就是接口,我们知道接口中可以有属性和方法。 属性:public static final int age; 方法:public abstract void show(); 但是在注解中也可以有属性,也可以有方法。但是,注解中一般不使用属性。 在注解的开发中,我们只写方法。 我们管注解中的方法,叫做注解的属性。 在注解中我们管方法的返回值叫做注解的类型。 注解定义属性的格式 : 例如:int age(); 关于注解的属性类型可以有哪些? 1. 基本类型 2. String 3. 枚举类型 4. 注解类型 5. Class类型 6. 以上类型的一维数组类型 注解:就是在你的程序代码中的某个位置加了一个标记而已。 示例代码如下图所示: 2.3 注解的反射(注解的灵魂) 模拟 Junit 的 @Test 方法 a、反射注解类 java.lang.reflect.AnnotatedElement; < T extends Annotation > T getAnnotation(Class< T > annotationType) 得到指定类型的注解引用。没有,返回null。 Annotation[] getAnnotations() 得到所有的注解,包含从父类继承下来的。 Annotation[] getDeclaredAnnotations() 得到自己身上的注解。 boolean isAnnotationPresent(Class< ? extends Annotation > annotationType) 判断指定的注解有没有。 Class、Method、Field、Constructor等实现了AnnotatedElement接口。 例如: Class.isAnnotationPresent(MyTest.class); 判断类上面有没有@MyTest注解。 Method.isAnnotationPresent(MyTest.class); 判断方法上面有没有@MyTest注解。 b、反射注解中的属性 如下图元注解图片中所示: 2.4 元注解 a、自定义注解的存活范围(生命周期):默认是CLASS。 什么是 元注解? 答:只能用在注解类上的注解叫做元注解。(即:用于 修饰注解的注解) @Retention 作用:改变自定义注解的存活范围。 RetentionPolicy SOURCE CLASS RUNTIME 例如:@Retention(RetentionPolicy.RUNTIME) @Target 作用:指定该注解能用在什么地方。 ElementType TYPE METHOD FIELD ANNOTATION_TYPE 例如:@Target({ ElementType.METHOD, ElementType.TYPE }) @Documented 作用:使用了@MyTest的注解的类,如果@MyTest注解类上面有@Documented注解,那么使用了@MyTest的注解的类的API文档中会出现@MyTest的身影。 @Inherited 作用:说明使用了该注解的类的子类可以继续使用该注解。 示例代码如下图所示: 三、简单介绍Servlet3.0中的几个注解 增加对注解的支持。 Servlet3.0 要求:Tomcat7+ JDK6.0+ Servlet3.0:web.xml已经不是必须的了。替代它的就是注解。 四、类加载器 1、作用:类加载器负责将 .class 文件(可能在磁盘上, 也可能在网络上) 加载到内存中, 并为之生成对应的 java.lang.Class。 2、JVM中的类加载器:(当 JVM 启动时,会形成由三个类加载器组成的初始类加载器层次结构: ) BootStrap:是老大。类加载器的祖先。 打印它会得到null。 负责加载 JRE/lib/rt.jar(JDK中绝大部分的类) ExtClassLoader: 负责加载 JRE/lib/ext/*.jar AppClassLoader: 负责加载在 classpath环境变量中的所有类 类加载器之间的父子关系图和管辖范围图 3、父类委托机制 示例代码: package com.itheima;import javax.xml.crypto.dsig.keyinfo.KeyName;public class TestClassLoader {public static void main(String[] args) {// BootStrap:是老大。类加载器的祖先。 打印它会得到null。负责加载 JRE/lib/rt.jar(JDK中绝大部分的类) ClassLoader cl = KeyName.class.getClassLoader(); System.out.println(cl); // null// System.out.println(cl.getClass().getName()); // java.lang.NullPointerException// ExtClassLoader: 负责加载 JRE/lib/ext/*.jar // 没有找着可以测试的类,因为该目录下需要导入源码包,就没有测试啦!但是效果同AppClassLoader。// AppClassLoader: 负责加载在 classpath环境变量中的所有类 ClassLoader cl1 = Student.class.getClassLoader(); System.out.println(cl1); // sun.misc.Launcher$AppClassLoader@73d16e93 System.out.println(cl1.getClass().getName()); // sun.misc.Launcher$AppClassLoader }} 示例图解01: 示例图解02: 我的GitHub地址: https://github.com/heizemingjun 我的博客园地址: http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址: http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

优秀的个人博客,低调大师

【Java入门提高篇】Day13 Java中的反射机制

前一段时间一直忙,所以没什么时间写博客,拖了这么久,也该更新更新了。最近看到各种知识付费的推出,感觉是好事,也是坏事,好事是对知识沉淀的认可与推动,坏事是感觉很多人忙于把自己的知识变现,相对的在沉淀上做的实际还不够,我对此暂时还没有什么想法,总觉得,慢慢来,会更快一点,自己掌握好节奏就好。 好了,言归正传。 反射机制是Java中的一个很强大的特性,可以在运行时获取类的信息,比如说类的父类,接口,全部方法名及参数,全部常量和变量,可以说类在反射面前已经衣不遮体了(咳咳,这是正规车)。先举一个小栗子,大家随意感受一下: public void testA(){ String name = "java.lang.String"; try{ Class cl = Class.forName(name); Class supercl = cl.getSuperclass(); String modifiers = Modifier.toString(cl.getModifiers()); if (modifiers.length() > 0){ System.out.print(modifiers + " "); } System.out.print(name); if (supercl != null && supercl != Object.class){ System.out.print(" extents " + supercl.getName()); } System.out.print("{\n"); printFields(cl); System.out.println(); printConstructors(cl); System.out.println(); printMethods(cl); System.out.println("}"); }catch (ClassNotFoundException e){ e.printStackTrace(); } System.exit(0); } private static void printConstructors(Class cl){ Constructor[] constructors = cl.getDeclaredConstructors(); for (Constructor c : constructors){ String name = c.getName(); System.out.print(" "); String modifiers = Modifier.toString(c.getModifiers()); if (modifiers.length() > 0){ System.out.print(modifiers + " "); } System.out.print(name + "("); Class[] paraTypes = c.getParameterTypes(); for (int j = 0; j < paraTypes.length; j++){ if (j > 0){ System.out.print(", "); } System.out.print(paraTypes[j].getSimpleName()); } System.out.println(");"); } } private static void printMethods(Class cl){ Method[] methods = cl.getDeclaredMethods(); for (Method m : methods){ Class retType = m.getReturnType(); String name = m.getName(); System.out.print(" "); String modifiers = Modifier.toString(m.getModifiers()); if (modifiers.length() > 0){ System.out.print(modifiers + " "); } System.out.print(retType.getSimpleName() + " " + name +"("); Class[] paramTypes = m.getParameterTypes(); for(int j = 0; j < paramTypes.length; j++){ if (j > 0){ System.out.print(", "); } System.out.print(paramTypes[j].getName()); } System.out.println(");"); } } private static void printFields(Class cl){ Field[] fields = cl.getFields(); for (Field f : fields){ Class type = f.getType(); String name = f.getName(); System.out.print(" "); String modifiers = Modifier.toString(f.getModifiers()); if (modifiers.length() > 0){ System.out.print(modifiers + " "); } System.out.println(type.getSimpleName() + " " + name +";"); } } 调用testA方法输出如下: public final java.lang.String{ public static final Comparator CASE_INSENSITIVE_ORDER; public java.lang.String(byte[], int, int); public java.lang.String(byte[], Charset); public java.lang.String(byte[], String); public java.lang.String(byte[], int, int, Charset); public java.lang.String(byte[], int, int, String); java.lang.String(char[], boolean); public java.lang.String(StringBuilder); public java.lang.String(StringBuffer); public java.lang.String(byte[]); public java.lang.String(int[], int, int); public java.lang.String(); public java.lang.String(char[]); public java.lang.String(String); public java.lang.String(char[], int, int); public java.lang.String(byte[], int); public java.lang.String(byte[], int, int, int); public boolean equals(java.lang.Object); public String toString(); public int hashCode(); public int compareTo(java.lang.String); public volatile int compareTo(java.lang.Object); public int indexOf(java.lang.String, int); public int indexOf(java.lang.String); public int indexOf(int, int); public int indexOf(int); static int indexOf([C, int, int, [C, int, int, int); static int indexOf([C, int, int, java.lang.String, int); public static String valueOf(int); public static String valueOf(long); public static String valueOf(float); public static String valueOf(boolean); public static String valueOf([C); public static String valueOf([C, int, int); public static String valueOf(java.lang.Object); public static String valueOf(char); public static String valueOf(double); public char charAt(int); private static void checkBounds([B, int, int); public int codePointAt(int); public int codePointBefore(int); public int codePointCount(int, int); public int compareToIgnoreCase(java.lang.String); public String concat(java.lang.String); public boolean contains(java.lang.CharSequence); public boolean contentEquals(java.lang.CharSequence); public boolean contentEquals(java.lang.StringBuffer); public static String copyValueOf([C); public static String copyValueOf([C, int, int); public boolean endsWith(java.lang.String); public boolean equalsIgnoreCase(java.lang.String); public static transient String format(java.util.Locale, java.lang.String, [Ljava.lang.Object;); public static transient String format(java.lang.String, [Ljava.lang.Object;); public void getBytes(int, int, [B, int); public byte[] getBytes(java.nio.charset.Charset); public byte[] getBytes(java.lang.String); public byte[] getBytes(); public void getChars(int, int, [C, int); void getChars([C, int); private int indexOfSupplementary(int, int); public native String intern(); public boolean isEmpty(); public static transient String join(java.lang.CharSequence, [Ljava.lang.CharSequence;); public static String join(java.lang.CharSequence, java.lang.Iterable); public int lastIndexOf(int); public int lastIndexOf(java.lang.String); static int lastIndexOf([C, int, int, java.lang.String, int); public int lastIndexOf(java.lang.String, int); public int lastIndexOf(int, int); static int lastIndexOf([C, int, int, [C, int, int, int); private int lastIndexOfSupplementary(int, int); public int length(); public boolean matches(java.lang.String); private boolean nonSyncContentEquals(java.lang.AbstractStringBuilder); public int offsetByCodePoints(int, int); public boolean regionMatches(int, java.lang.String, int, int); public boolean regionMatches(boolean, int, java.lang.String, int, int); public String replace(char, char); public String replace(java.lang.CharSequence, java.lang.CharSequence); public String replaceAll(java.lang.String, java.lang.String); public String replaceFirst(java.lang.String, java.lang.String); public String[] split(java.lang.String); public String[] split(java.lang.String, int); public boolean startsWith(java.lang.String, int); public boolean startsWith(java.lang.String); public CharSequence subSequence(int, int); public String substring(int); public String substring(int, int); public char[] toCharArray(); public String toLowerCase(java.util.Locale); public String toLowerCase(); public String toUpperCase(); public String toUpperCase(java.util.Locale); public String trim(); } 这里把String类型的所有方法和变量都获取到了,使用的仅仅是String类型的全名。当然,反射的功能不仅仅是获取类的信息,还可以在运行时动态创建对象,回想一下,我们正常的对象使用,都是需要在代码中先声明,然后才能使用它,但是使用反射后,就能在运行期间动态创建对象并调用其中的方法,甚至还能直接查看类的私有成员变量,还能获取类的注解信息,在泛型中类型判断时也经常会用到。反射可以说完全打破了类的封装性,把类的信息全部暴露了出来。 上面的代码看不太明白也没关系,只要稍微感受一下反射的能力就好了。介绍完了反射能做的事情,本篇教程就不再写一些玩具代码了,这次以一个实用型的代码为媒介来介绍反射。 在开发中,经常会遇到两个不同类对象之间的复制,把一个类中的字段信息get取出来,然后set到另一个类中,大部分情况下,两个类对应的字段是一样,每次这样使用是很麻烦的,那么利用反射就可以实现一个封装,只需要调用一个方法即可实现简单的类字段复制。 那么,先来想想,要复制一个类对象的所有字段信息到另一个类对象中,首先,怎么获取一个类的某个字段的值呢?我们先来编写一个方法: /** * 获取对象的指定字段的值 * @param obj 目标对象 * @param fieldName 目标字段 * @return 返回字段值 * @throws Exception 可能抛出异常 */ private static Object getFieldValue(Object obj, String fieldName) throws Exception{ //获取类型信息 Class clazz = obj.getClass(); //取对应的字段信息 Field field = clazz.getDeclaredField(fieldName); //设置可访问权限 field.setAccessible(true); //取字段值 Object value = field.get(obj); return value; } 这里使用了两个之前没有说过的类,一个是Class,是不是很眼熟,想一想,我们每次定义一个类的时候是不是都要用到它,哈哈,那你就想错了,那是class关键词,java是大小写的敏感的,这里的Class是一个类名,那这个类是干嘛用的呢? 虚拟机在加载每一个类的时候,会自动生成一个对应的Class类来保存该类的信息,可以理解为Class类是那个类的代理类,是连接实际类与类加载器的桥梁,可以通过它来获取虚拟机的类加载器引用,从而实现更多的骚操作。Class类是一个泛型类,每个类都有对应的一个Class类,比如String对应的Class类就是Class<String>。 Class有很多方法来获取更多关于类的信息,这里使用getDeclaredField方法来获取指定字段信息,返回的是Field类型对象,这个对象里存储着关于字段的一些信息,如字段名称,字段类型,字段修饰符,字段可访问性等,setAccessible方法可以设置字段的可访问性质,这样就能直接访问private修饰的字段了,然后使用get方法来获取指定对象的对应字段的值。 我们来测试一下: public void testB(){ try{ Employee employee = new Employee(); employee.setName("Frank"); employee.setSalary(6666.66); System.out.println((String)getFieldValue(employee,"name")); System.out.println((double)getFieldValue(employee,"salary")); }catch (Exception e){ e.printStackTrace(); } } 输出如下: Frank 6666.66 接下来,我们需要获取类中所有字段,然后在另一个类中查找是否有对应字段,如果有的话就设置字段的值到相应的字段中。 /** * 复制一个类对象属性到另一个类对象中 * @param objA 需要复制的对象 * @param objB 复制到的目标对象类型 * @return 返回复制后的目标对象 */ private static void parseObj(Object objA,Object objB) throws Exception{ if (objA == null){ return; } //获取objA的类信息 Class classA = objA.getClass(); Class classB = objB.getClass(); try { //获取objA的所有字段 Field[] fieldsA = classA.getDeclaredFields(); //获取objB的所有字段 Field[] fieldsB = classB.getDeclaredFields(); if (fieldsA == null || fieldsA.length <= 0 || fieldsB == null || fieldsB.length <= 0){ return; } //生成查询map Map<String,Field> fieldMap = new HashMap<>(); for (Field field:fieldsA){ fieldMap.put(field.getName(),field); } //开始复制字段信息 for (Field fieldB : fieldsB){ //查找是否在objB的字段中存在该字段 Field fielaA = fieldMap.get(fieldB.getName()); if (fielaA != null){ fieldB.setAccessible(true); fieldB.set(objB,getFieldValue(objA,fielaA.getName())); } } } catch (IllegalStateException e) { throw new IllegalStateException("instace fail: " ,e); } } 这里获取到classA和classB的所有字段之后,先生成了一个map用于查找,可以减少遍历次数,然后之后只需要遍历一次就可以判断相应字段是否存在,如果存在则取出对应值设置到相应的字段里去。 接下来测试一下: public void testB(){ try{ //生成Employee对象 Employee employee = new Employee("Frank",6666.66); //生成一个Manager对象 Manager manager = new Manager(); //复制对象 parseObj(employee,manager); System.out.println(manager.getName()); System.out.println(manager.getSalary()); }catch (Exception e){ e.printStackTrace(); } } public class Employee { private String name; private Double salary; public Employee(String name, Double salary) { this.name = name; this.salary = salary; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Double getSalary() { return salary; } public void setSalary(Double salary) { this.salary = salary; } } public class Manager { private String name; private Double salary; private Double bonus; public String getName() { return name; } public void setName(String name) { this.name = name; } public Double getSalary() { return salary; } public void setSalary(Double salary) { this.salary = salary; } public Double getBonus() { return bonus; } public void setBonus(Double bonus) { this.bonus = bonus; } } 输出如下: Frank 6666.66 完美,这样我们就利用了反射机制完美的把相同的字段在不同类的对象之间进行了复制,这里仅仅是两个字段,所以可能好处不明显,但事实上,实际开发中,经常会有将BO转换为VO的操作,这时候,这个操作就很有必要了,简单的一行命令就可以代替一大堆的get和set操作。 当然,使用反射机制固然高端大气上档次,但是也是一把双刃剑,使用不当很可能会带来严重后果,而且使用反射的话,会占用更多资源,运行效率也会降低,上述工具类是用运行效率换开发效率。开发中不建议大量使用,还是那句话,技术只是手段,需要使用的时候再使用,不要为了使用而使用。 至于反射中的其他方法和姿势,大家尽可以慢慢去摸索,这里仅仅是抛砖引玉。 至此,本篇讲解完毕,欢迎大家继续关注。 真正重要的东西,用眼睛是看不见的。

优秀的个人博客,低调大师

【Java入门提高篇】Day12 Java代理——Cglib动态代理

今天来介绍另一种更为强大的代理——Cglib动态代理。 什么是Cglib动态代理? 我们先回顾一下上一篇的jdk动态代理,jdk动态代理是通过接口来在运行时动态创建委托类的代理对象,但是跟静态代理一样有一个缺点,就是必须和委托类实现相同的接口,当接口数量增加时,便需要增加代理类的数量才能满足需求,而且如果委托类是别人写的,而且没有实现任何接口,那么jdk动态代理就有些力不从心了。 这时候Cglib动态代理就脱颖而出了,Cglib并不依赖接口,可以直接生成委托类的代理对象,而且可以代理委托类的任意非final修饰的public和protected方法,我们可以先来看一个栗子。 先定义一个Programmer类: public class Programmer { private String name; public void setName(String name) { System.out.println("Setting Name."); this.name = name; }public void code(){ System.out.println(name + " is writing bugs."); } } 然后定义一个代理类: public class ProgrammerProxy implements MethodInterceptor { /** * 内部持有委托类对象的引用 */ private Object target; /** * 创建代理类对象 */ public Programmer createProxy(Programmer object){ target = object; //创建Enhancer对象 Enhancer enhancer = new Enhancer(); //设置要代理的目标类,以扩展功能 enhancer.setSuperclass(this.target.getClass()); //设置单一回调对象,在回调中拦截对目标方法的调用 enhancer.setCallback(this); //设置类加载器 enhancer.setClassLoader(object.getClass().getClassLoader()); //创建代理对象 return (Programmer)enhancer.create(); } /** * 回调方法:在代理实例上拦截并处理目标方法的调用,返回结果 * @param proxy 代理类 * @param method 被代理的方法 * @param params 该方法的参数数组 * @param methodProxy */ @Override public Object intercept(Object proxy, Method method, Object[] params, MethodProxy methodProxy) throws Throwable { //调用之前处理 doBefore(); //调用原方法 method.invoke(target,params); //调用之后处理 doAfter(); return null; } private void doAfter() { System.out.println("do after."); } private void doBefore() { System.out.println("do before."); } } 然后测试一下: public class ProxyTest { @Test public void testCglibProxy(){ //创建一个Programmer对象 Programmer programmerA = new Programmer(); programmerA.setName("Frank"); //创建代理对象 Programmer programmerProxyA = new ProgrammerProxy().createProxy(programmerA); programmerProxyA.code(); //修改代理对象 programmerProxyA.setName("Wang"); programmerProxyA.code(); //修改委托类对象 programmerA.setName("Song"); programmerProxyA.code(); } } 输出如下: Setting Name. do before. Frank is writing bugs. do after. do before. Setting Name. do after. do before. Wang is writing bugs. do after. Setting Name. do before. Song is writing bugs. do after. Cglib实现动态代理的步骤也不是很麻烦,先创建一个类实现MethodInterceptor接口,重写intercept方法,在intercep中可以截获委托类的所有非final修饰的public和protected方法,上例中,method.invoke(target,params);即为调用原对象的原方法,在代理类中保存了委托类对象的引用,这一点跟JDK动态代理是一样的。在调用原方法前先调用了doBefore方法,调用之后还调用了doAfter方法,从而实现了代理功能。至于createProxy方法,也只是一个固定步骤,先创建Enhance对象,然后将委托类的一些属性往里塞,然后调用create方法来动态生成代理对象。 在测试类中,为了更明显的说明代理类与委托类的关系,分别用代理类对象programmerProxyA和委托类对象programmerA对name字段进行修改,可以产生一样的效果。 下面来对比一下Cglib动态代理与JDK动态代理: 1.两者都是动态代理,都是运行时动态生成代理对象。 2.JDK动态代理利用的是接口信息来实现的代理,委托类必须实现某个或者某些接口,而Cglib则是利用继承关系,利用asm在运行时动态生成委托类的子类,从而实现对委托类的代理。因此不依赖接口。 3.Cglib由于是利用继承关系来实现代理的,因此无法代理被final修饰的类以及被final修饰的方法。 4.Cglib一般来说效率要比JDK动态代理效率更高,可以实现的代理也更为强大。 当然,具体情况具体分析,虽然Cglib比Jdk动态代理更强大,但并不一定各个地方都强行使用,有时候JDK动态代理相对来说更加简单粗暴。 至此,本篇完结,代理相关内容讲解完毕,欢迎大家继续关注。 jar包下载地址:http://download.csdn.net/download/qiuyingjia/10181844真正重要的东西,用眼睛是看不见的。

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 40)——析构函数

与构造过程相反,实例最后释放的时候,需要清除一些资源,这个过程就是析构过程。在析构过程中也会调用一种特殊的方法deinit,称为析构函数。析构函数deinit没有返回值,也没有参数,也不需要参数的小括号,所以不能重载。 下面看看示例代码: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 class Rectangle{ varwidth:Double varheight:Double init(width:Double,height:Double){ self.width=width self.height=height } init(Wwidth:Double,Hheight:Double){ self.width=width self.height=height } deinit{ //定义了析构函数 print( "调用析构函数..." ) self.width= 0.0 self.height= 0.0 } } varrectc1:Rectangle?=Rectangle(width: 320 ,height: 480 ) //实例rectc1 print( "长方形:\(rectc1!.width)x\(rectc1!.height)" ) rectc1=nil //触发调用析构函数的条件 varrectc2:Rectangle?=Rectangle(W: 320 ,H: 480 ) //实例rectc2 print( "长方形:\(rectc2!.width)x\(rectc2!.height)" ) rectc2=nil //触发调用析构函数的条件 析构函数的调用是在实例被赋值为nil,表示实例需要释放内存,在释放之前先调用析构函数,然后再释放。 运行结果如下: 长方形:320.0 x 480.0 调用析构函数... 长方形:320.0 x 480.0 调用析构函数... 析构函数只适用于类,不能适用于枚举和结构体。类似的方法在C++中也称为析构函数,不同的是,C++中的析构函数常常用来释放不再需要的内存资源。而在Swift中,内存管理采用自动引用计数(ARC),不需要在析构函数释放不需要的实例内存资源,但是还是有一些清除工作需要在这里完成,如关闭文件等处理。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1747011,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 19)——函数参数传递

函数的语法格式如下: func函数名(参数列表) ->返回值类型{ 语句组 return返回值 } 关键字是func。 多个参数列表之间可以用逗号(,)分隔,也可以没有参数。 使用箭头“->”指示返回值类型。返回值有单个值和多个值。如果函数没有返回值,则“->返回值类型”部分可以省略。 如果函数有返回值,就需要在函数体最后使用return语句;如果没有返回值,则函数体中可以省略return语句。 函数定义示例代码如下: 1 2 3 4 5 6 funcrectangleArea(width:Double,height:Double)->Double{ letarea=width*height return area } print( "320x480的长方形的面积:\(rectangleArea(320,height:480))" ) 传递参数 介绍几种不同形式的参数。 使用外部参数名 为每个参数提供一个可以在函数外部使用的名称,称为外部参数名,修改rectangleArea函数的定义如下: 1 2 3 4 funcrectangleArea(Wwidth:Double,Hheight:Double)->Double{ letarea=width*height return area } 在局部参数名之前给一个“外部参数名”,用空格分隔。定义代码中的W和H就是外部参数名。调用代码如下: 1 2 3 4 print ("320x480 的长方形的面积 :\(rectangleArea(W: 320 ,H: 480 ))") 如果我们提供了外部参数名,那么在函数调用时,必须使用外部参数名,所以W和H不能省略。 省略外部参数名 Swift 2.0提供省略外部参数名可能,在定义函数时,使用下划线(_)表示外部参数名,示例代码如下: 1 2 3 4 funcrectangleArea(width:Double,_height:Double)->Double{ letarea=width*height return area } 这样函数在调用时就可以省略外部参数名,代码如下: 1 2 3 4 print ("320x480 的长方形的面积 :\(rectangleArea( 320 , 480 ))") 在定义函数时第一个参数不需要使用下划线(_),默认第一个参数名是省略的,其他参数名要想省略则需要使用下划线(_)符号。 参数默认值 在定义函数的时候可以为参数设置一个默认值,当调用函数的时候可以忽略该参数。看下面的一个示例: 1 2 3 funcmakecoffee(type:String= "卡布奇诺" )->String{ return "制作一杯\(type)咖啡。" } 在调用的时候,如果调用者没有传递参数,则使用默认值。调用代码如下: 1 2 letcoffee1=makecoffee( "拿铁" ) letcoffee2=makecoffee() 最后输出结果如下: 制作一杯拿铁咖啡。 制作一杯卡布奇诺咖啡。 可变参数 Swift中函数的参数个数可以变A化,它可以接受不确定数量的输入类型参数,它们具有相同的类型。我们可以通过在参数类型名后面加入(...)的方式来指示这是可变参数。 下面看一个示例: 1 2 3 4 5 6 7 funcsum(numbers:Double...)->Double{ vartotal:Double= 0 for numberinnumbers{ total+=number } return total } 下面是两次调用sum函数代码: 1 2 sum( 100.0 , 20 , 30 ) sum( 30 , 80 ) 可以看到每次传递参数的个数是不同的。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1746245,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 39)——构造函数重载

构造函数作为一种特殊方法,也可以重载。 Swift中构造函数可以多个,他们参数列表和返回值可以不同,这些构造函数构成重载。 示例代码如下: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 class Rectangle{ varwidth:Double varheight:Double init(width:Double,height:Double){ self.width=width self.height=height } init(Wwidth:Double,Hheight:Double){ self.width=width self.height=height } init(length:Double){ self.width=length self.height=length } init(){ self.width= 640.0 self.height= 940.0 } } varrectc1=Rectangle(width: 320.0 ,height: 480.0 ) print( "长方形:\(rectc1.width)x\(rectc1.height)" ) varrectc2=Rectangle(W: 320.0 ,H: 480.0 ) print( "长方形:\(rectc2.width)x\(rectc2.height)" ) varrectc3=Rectangle(length: 500.0 ) print( "长方形3:\(rectc3.width)x\(rectc3.height)" ) varrectc4=Rectangle() print( "长方形4:\(rectc4.width)x\(rectc4.height)" ) 构造函数代理 为了减少多个构造函数间的代码重复,在定义构造函数时,可以通过调用其他构造函数来完成实例的部分构造过程,这个过程称为构造函数代理。构造函数代理在结构体和类中使用方式是不同,先介绍结构体中构造函数代理。 将上一节的示例修改如下: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 structRectangle{ varwidth:Double varheight:Double init(width:Double,height:Double){ self.width=width self.height=height } init(Wwidth:Double,Hheight:Double){ self.width=width self.height=height } init(length:Double){ //调用了self.init语句 self.init(W:length,H:length) } init(){ //调用了self.init语句 self.init(width: 640.0 ,height: 940.0 ) } } varrectc1=Rectangle(width: 320.0 ,height: 480.0 ) print( "长方形:\(rectc1.width)x\(rectc1.height)" ) varrectc2=Rectangle(W: 320.0 ,H: 480.0 ) print( "长方形:\(rectc2.width)x\(rectc2.height)" ) varrectc3=Rectangle(length: 500.0 ) print( "长方形3:\(rectc3.width)x\(rectc3.height)" ) varrectc4=Rectangle() print( "长方形4:\(rectc4.width)x\(rectc4.height)" ) 将Rectangle声明为结构体类型,其中也有4个构造函数重载。 这种在同一个类型中通过self.init语句进行调用当前类型其它构造函数,其它构造函数被称为构造函数代理。 类构造函数横向代理 由于类有继承关系,类构造函数代理比较复杂,分为横向代理和向上代理。 横向代理类似于结构体类型构造函数代理,发生在同一类内部,这种构造函数称为便利构造函数(convenience initializers)。 向上代理发生在继承情况下,在子类构造过程中要先调用父类构造函数,初始化父类的存储属性,这种构造函数称为指定构造函数(designated initializers)。 将上面的示例修改如下: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 class Rectangle{ varwidth:Double varheight:Double init(width:Double,height:Double){ self.width=width self.height=height } init(Wwidth:Double,Hheight:Double){ self.width=width self.height=height } convenienceinit(length:Double){ self.init(W:length,H:length) } convenienceinit(){ self.init(width: 640.0 ,height: 940.0 ) } } varrectc1=Rectangle(width: 320.0 ,height: 480.0 ) print( "长方形:\(rectc1.width)x\(rectc1.height)" ) varrectc2=Rectangle(W: 320.0 ,H: 480.0 ) print( "长方形:\(rectc2.width)x\(rectc2.height)" ) varrectc3=Rectangle(length: 500.0 ) print( "长方形3:\(rectc3.width)x\(rectc3.height)" ) varrectc4=Rectangle() print( "长方形4:\(rectc4.width)x\(rectc4.height)" ) 将Rectangle声明为类,其中也有4个构造函数重载。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1747009,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 51)——扩展构造函数

扩展类型的时候,也可以添加新的构造函数。值类型与引用类型扩展有所区别。值类型包括了除类以外的其他类型,主要是枚举类型和结构体类型。 值类型扩展构造函数 扩展结构体类型中定义构造函数的示例: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 structRectangle{ varwidth:Double varheight:Double init(width:Double,height:Double){ self.width=width self.height=height } } extensionRectangle{ //定义了Rectangle的扩展类型 init(length:Double){ self.init(width:length,height:length) } } varrect=Rectangle(width: 320.0 ,height: 480.0 ) //调用两个参数的构造函数,这个构造函数是原始类型提供,Rectangle类型已经是扩展类型 print( "长方形:\(rect.width)x\(rect.height)" ) varsquare=Rectangle(length: 500.0 ) //调用一个参数的构造函数,这个构造函数是扩展类型提供的 print( "正方形:\(square.width)x\(square.height)" ) self.init是调用了原始类型的两个参数的构造函数。 引用类型扩展构造函数 扩展类中定义构造函数的示例: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 class Person{ varname:String varage:Int funcdescription()->String{ return "\(name)年龄是:\(age)" } init(name:String,age:Int){ self.name=name self.age=age } } extensionPerson{ //定义Person类的扩展类型 convenienceinit(name:String){ //便利构造函数 self.init(name:name,age: 8 ) } } letp1=Person(name: "Mary" ) //调用两个参数的构造函数,这个构造函数是原始类型提供,这时候的Person类型已经是扩展类型。 print( "Person1:\(p1.description())" ) letp2=Person(name: "Tony" ,age: 28 ) //调用一个参数的构造函数创建Person实例,这个构造函数是扩展类型提供的。 print( "Person2:\(p2.description())" ) 代码self.init(name :name, age : 8)调用指定构造函数代理部分构造任务。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1748298,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 23)——尾随闭包

闭包表达式可以作为函数的参数传递,如果闭包表达式很长,就会影响程序的可读性。尾随闭包是一个书写在函数括号之后的闭包表达式,函数支持将其作为最后一个参数调用。 下面我们来看一个示例代码: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 funccalculate(opr:String,funN:(Int,Int)->Int){ //最后一个参数funN是(Int,Int)->Int函数类型,funN可以接收闭包表达式 switch (opr){ case "+" : print( "10+5=\(funN(10,5))" ) default : print( "10-5=\(funN(10,5))" ) } } calculate( "+" ,funN:{(a:Int,b:Int)->Intin return a+b}) //调用 calculate( "+" ){(a:Int,b:Int)->Intin return a+b} //调用,这种形式就是尾随闭包 calculate( "+" ){$ 0 +$ 1 } //调用,这种形式就是尾随闭包 需要注意的是,闭包必须是参数列表的最后一个参数,如果calculate函数采用如下形式定义: func calculate(funN:(Int,Int)->Int,opr:String) { ... } 由于闭包表达式不是最后一个参数,那么调用calculate函数就不能使用尾随闭包写法的。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1746417,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 41)——类的继承

Swift中的继承只能发生在类上,不能发生在枚举和结构体上。一个类可以继承另一个类的方法、属性、下标等特征,当一个类继承其他类时,继承类叫子类,被继承类叫父类(或超类)。子类继承父类后,可以重写父类的方法、属性、下标等特征。 为了了解继承性,看这样一个场景:一位面向对象的程序员小赵,在编程过程中需要描述和处理个人信息,于是他定义了类Person,如下所示: 1 2 3 4 5 6 7 8 9 10 11 12 class Person{ varname:String varage:Int funcdescription()->String{ return "\(name)年龄是:\(age)" } init(){ name= "" age= 1 } } 一周以后,小赵又遇到了新的需求,需要描述和处理学生信息,于是他又定义了一个新的类Student,如下所示: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class Student{ varname:String varage:Int varschool:String funcdescription()->String{ return "\(name)年龄是:\(age)" } init(){ school= "" name= "" age= 8 } } 很多人会认为小赵的做法能够理解并相信这是可行的,但是问题在于Student和Person两个类的结构太接近了,后者只比前者多了一个属性school,却要重复定义其他所有的内容,实在让人“不甘心”。Swift提供了解决类似问题的机制,那就是类的继承,代码如下所示: 1 2 3 4 5 6 7 8 class Student:Person{ varschool:String overrideinit(){ school= "" super .init() age= 8 } } Student类继承了Person类中的所有特征,“:”之后的Person类是父类。Swift中的类可以没有父类,例如Person类,定义的时候后面没有“:”,这种没有父类的就是基类。 此外override init()是子类重写父类构造函数。 一般情况下,一个子类只能继承一个父类,这称为单继承,但有的情况下一个子类可以有多个不同的父类,这称为多重继承。在Swift中,类的继承只能是单继承。多重继承可以通过遵从多个协议实现。也就是说,在Swift中,一个类只能继承一个父类,但是可以遵循多个协议。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1747494,如需转载请自行联系原作者

优秀的个人博客,低调大师

Android Day01-Android按钮点击事件的4种写法

按钮点击事件,说白了就一个方法,setOnClickListener(OnClickListener)。 只要传递的参数只要是OnClickListener接口的子类即可,很容易想到的2种实现方式就是匿名内部类和定义一个类实现这个接口。另外还有2种实现方法,有必要着重讲一下: 1.让Activity自身实现OnClickListener接口,传递setOnClickListener参数用this。 然后在onClick(View v)方法中,判断事件源id. switch(v.getId()) { case R.id.XXX000 响应代码 break; case R.id.XXX111 响应代码 break; } 这个和定义一个类实现接口的方法一个道理,只是免得我们再去多定义一个类而已。直接让Activity自身实现OnClickListener接口,实现它里面的OnClick方法。 这种定义方式适用于有多个点击事件的情况。使用这种方式注意导包很容易导错的。 2.在布局文件中定义一个标签属性android:onclick="方法名",然后在Android项目调用这个布局的.java文件中定义一个方法,public 方法名(View v),记住要public且有View参数。 通过查看Button的父类View的源码,可以发现,OnClick底层使用的是反射原理,但是没有使用暴力反射,所以定义方法时要用public。 这种定义事件的方法一般只在测试的时候使用,也可以给多个按钮添加同一个方法名称,通过 v.getId()再去判断一下ID就好了。 本文转自屠夫章哥 51CTO博客,原文链接:http://blog.51cto.com/4259297/1675142,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 37)——默认构造函数

结构体和类的实例在构造过程中会调用一种特殊的init方法,称为构造函数。构造函数没有返回值,可以重载。在多个构造函数重载的情况下,运行环境可以根据它的外部参数名或参数列表调用合适的构造函数。 默认构造函数 结构体和类在构造过程中会调用一个构造函数,即便是没有编写任何构造函数,编译器也会提供一个默认的构造函数。下面看示例代码: 1 2 3 4 5 6 7 8 9 10 class Rectangle{ varwidth:Double= 0.0 varheight:Double= 0.0 } varrect=Rectangle() //创建实例,并调用默认构造函数init() rect.width= 320.0 rect.height= 480.0 print( "长方形:\(rect.width)x\(rect.height)" ) Rectangle()表示调用了某个方法,这个方法就是默认构造函数init()。 事实上,在Rectangle的定义过程中省略了构造函数,相当于如下代码: 1 2 3 4 5 6 7 8 class Rectangle{ varwidth:Double= 0.0 varheight:Double= 0.0 init(){ } } 如果Rectangle是结构体,则它的定义如下: 1 2 3 4 structRectangle{ varwidth:Double= 0.0 varheight:Double= 0.0 } 而结构体Rectangle的默认构造函数与类Rectangle的默认构造函数是不同的,相当于如下代码: 1 2 3 4 5 6 7 8 9 10 11 12 13 structRectangle{ varwidth:Double= 0.0 varheight:Double= 0.0 init(){ } init(width:Double,height:Double){ //有参数的构造函数 self.width=width self.height=height } } 要调用哪个构造函数是根据传递的参数名和参数类型决定的。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1746995,如需转载请自行联系原作者

优秀的个人博客,低调大师

微软称黑客组织正在利用 Atlassian 新的 0day 漏洞

根据科技媒体 Techcrunch 报道,微软的威胁情报团队在 X(前身为 Twitter)上发布的帖子表示,它观察到一个名为 Storm-0062 的黑客组织正在利用 Atlassian Confluence 数据中心和服务器中最近披露的一个关键缺陷。 Atlassian 在 10 月 4 日披露了其 Confluence 数据中心和服务器中的一个漏洞:CVE-2023-22515。 微软安全团队表示,它从 9 月 14 日起就观察到了漏洞利用。Atlassian 本周更新了安全通知,称该漏洞正被活跃利用,并表示此漏洞可能允许远程攻击者创建未经授权的管理员帐户来访问 Confluence 服务器。

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长,特征是大鼻子、头戴帽子、身穿背带裤,还留着胡子。与他的双胞胎兄弟路易基一起,长年担任任天堂的招牌角色。

腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题,腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构,目前腾讯云软件源站支持公网访问和内网访问。

Spring

Spring

Spring框架(Spring Framework)是由Rod Johnson于2002年提出的开源Java企业级应用框架,旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念,提供核心容器、应用上下文、数据访问集成等模块,支持整合Hibernate、Struts等第三方框架,其适用范围不仅限于服务器端开发,绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux

Rocky Linux(中文名:洛基)是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版,作为CentOS稳定版停止维护后与RHEL(Red Hat Enterprise Linux)完全兼容的开源替代方案,由社区拥有并管理,支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性,采用模块化包装和SELinux安全架构,默认包含GNOME桌面环境及XFS文件系统,支持十年生命周期更新。

用户登录
用户注册
修改密码
忘记密码