反射
第一次课  
一、 什么是反射
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
二、 反射的作用
Java程序可以加载一个运行时才得知名称的class，获悉其完整构造方法，并生成其对象实体、或对其fields设值、或调用其methods
反射是Java中的高级特性，在各种Java框架中都需要使用反射。
三、 反射中的对象
lClass：类的反射对象
每个.java源文件都会编译变为.class字节码，.class文件在使用时会被加载到JVM,
这个被加载的.class文件存在内存中，Class对象就代表内存中运行的.class文件
通过ClSS对象获取类中的构造方法、成员变量、方法，拿到后对外提供都是对象
* Constructor：构造器反射对象；
l* Field：属性反射对象；
l* Method：方法反射对象；
lClass、Construcator、Field、Method、：统称为“反射对象”。
四、 反射都是在操作Class类对象
注意：
1、 反射从Class类开始
要想使用反射，首先你需要得到Class对象，
然后才能通过Class对象获取Constructor、Field、Method等对象。
1、 获得Class对象
(1)、 通过对象获取Class对象：
String str = new String("");
Class c1 = 对象.getClass();
(1)、 通过类名.class获得Class对象
Class c2 = String.class;
(2)、 通过Class的静态方法:Class.forName("完整类名");
Class c3 = Class.forName("java.lang.String");
System.out.println(c1 == c2);
System.out.println(c2 == c3);
(3)、 代码示例
/**
 * 获得最大的Class对象
 * @throws ClassNotFoundException
 */
@Test
public void test1() throws ClassNotFoundException{
//1、通过已有的对象来创建
User user = new User();
Class clz1 = user.getClass();
System.out.println("完整的类名："+clz1.getName());
System.out.println("类的简写："+clz1.getSimpleName());
System.out.println("父类："+clz1.getSuperclass().getName());
//2、通过类名.clss
Class clz2 = User.class;
//普通数据类型也有class
//Class clzInt = int.class;
//System.out.println("int的类名："+clzInt.getName());
//3、通过Class里面的静态方法 Class.forName("完整的类名");
Class clz3 = Class.forName("com.tl.entity.User");
//比较他们，在内存中是否为同一个地址
System.out.println(clz1==clz2);
System.out.println(clz2==clz3);
}
　　上面代码输出的都是true，这是因为一个.class文件，硬盘区中只对应一个Class对象。
2、 Class类简单方法
l* String getName()：返回类名；
l* String getSimpleName()：返回简单类名，不包含包名
l* Class getSuperClass()：获取父类，Object.class.getSupperClass()返回null；
* T newInstance()：使用本类无参构造器来创建本类对象
五、 通过Class类获得构造函数
1、 通过指定的参数类型获取公有构造器反射对象
getConstructor(Class... parameterTypes)
3、 获取所有构造器对象，包含私有构造器
Constructor getDeclaredConstructor(Class ... parameterTypes)
4、 通过构造器反射对象调用构造器
T newInstance(Object... initargs)
5、 代码示例
/**
 * 获得构造器反射对象
 * @throws ClassNotFoundException
 */
@Test
public void test2() throws Exception{
Class clz = Class.forName("com.tl.entity.User");
//获得构造器反射对象
Constructor c = clz.getConstructor(int.class);
//使用构造器反射对象实例化出来
User user = (User) c.newInstance(100);
System.out.println("user id:"+user.getId());
}
六、 通过Class类获得Field
1、 通过名字获取公有属性反射对象，包含父类中声明的公有属性
Field getField(String name)
6、 通过名字获取本类中某个属性，包含本类的private属性，但父类中声明的任何属性都不包含
Field getDeclaredField(String name)
7、 获取所有公有属性反射对象，包含父类中声明的公有属性
Field[] getFields()
8、 获取本类中声明的所有属性，包含private属性，但不包含父类中声明的任何属性
Field[] getDeclaredFields()
9、 setAccessible(true)之后可以改变私有属性的值
10、 代码示例
(1)、 parentUser.java
package com.tl.entity;
public class ParentUser {
private String parentName1;//私有的
public String parentName2;//公有的
public String getParentName1() {
return parentName1;
}
public void setParentName1(String parentName1) {
this.parentName1 = parentName1;
}
public String getParentName2() {
return parentName2;
}
public void setParentName2(String parentName2) {
this.parentName2 = parentName2;
}
}
(4)、 User.java
/**
 * 实体类
 * Oracl数据库，建议属性名全部小写
 * @author Administrator
 *
 */
public class User extends ParentUser {
private int id;
private String userName;//用户名
private String password;//密码
private String role;//角色
public String test;//测试公有字段
public User(){}
public User(int id){
this.id = id;
}
public User(int id, String userName, String password, String role) {
this.id = id;
this.userName = userName;
this.password = password;
this.role = role;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
//测试私有方法
private String getPassword() {
return password;
}
//测试私有方法
private void setPassword(String password) {
this.password = password;
}
public String getRole() {
return role;
}
public void setRole(String role) {
this.role = role;
}
}
(5)、 测试方法
/**
 * 获得属性反射对象
 * @throws Exception
 */
@Test
public void test3() throws Exception{
Class clz = Class.forName("com.tl.entity.User");
//getDeclaredField获得自己本身声明的字段，包含私有
Field userName = clz.getDeclaredField("userName");
//clz.getField(name)获得自己或者父类，或者接口中所有的公有字段
//通过类的newInstance会去自动调用无参的构造方法，来实例化一个对象
User user = (User) clz.newInstance();
//设置可以改变私有变量的值
userName.setAccessible(true);
userName.set(user, "浩浩，面对疾风吧");
//通过getUserName方法获得刚刚改变的私有变量的值
System.out.println("userName:"+user.getUserName());
Field[] fs1 = clz.getDeclaredFields();
System.out.println("获取本类中所有属性(公有私有都包含)，但父类中声明的任何属性都不包含");
for(Field f:fs1){
System.out.println("字段名："+f.getName());
System.out.println("---字段类型："+f.getType().getName());
}
System.out.println("\n获取本类中所有的公有属性，包含父类中的公有属性");
Field[] fs2 = clz.getFields();
for(Field f:fs2){
System.out.println("字段名："+f.getName());
System.out.println("---字段类型："+f.getType().getName());
}
}
七、 通过Class类获得Method
1、 通过方法名和方法参数类型获取方法反射对象，包含父类中声明的公有方法，但不包含所有私有方法
Method getMethod(String name, Class... parameterTypes)
11、 通过方法名和方法参数类型获取本类中声明的方法的反射对象，包含本类中的私有方法，但不包含父类中的任何方法
Method getDeclaredMethod(String name, Class... parameterTypes)
12、 获取所有公有方法，包含父类中的公有方法，但不包含任何私有方法
Method[] getMethods()
13、 获取本类中所有方法，包含本类中的私有方法，但不包含父类中的任何方法
Method[] getDeclaredMethods()
14、 代码示例
@Test
/**
 * 获得方法反射对象，动态调用方法
 * @throws Exception
 */
public void test4() throws Exception{
//获得Class对象
Class clz = User.class;
//获得里面所有的公有的方法
Method[] ms1 = clz.getMethods();
System.out.println("获得本类中所有的公有方法，包括父类的");
for(Method m:ms1){
System.out.println("方法名："+m.getName());
}
//获得本类中的所有方法
Method[] ms2 = clz.getDeclaredMethods();
System.out.println("获得本类中所有的公有、私有方法方法，不包括父类的");
for(Method m:ms2){
System.out.println("方法名："+m.getName());
}
//通过Class中的newInstance调用无参构造方法实例化对象
User user = (User) clz.newInstance();
//通过方法名和方法参数类型获取要调用的方法
Method m = clz.getMethod("setRole", String.class);
//动态调用方法
m.invoke(user, "超级管理员");
//输出
System.out.println("user role:"+user.getRole());
}
八、 通用的查询方法
使用反射动态获得对象，动态调用对象里对应的set方法给实体类对象设值
1、 获得查询结果集的列名，查询出的列名(别名)必须和实体类字段名一致
ResultSetMetaData rsmd = rs.getMetaData();
int count = rsmd.getColumnCount();
String columnNames[] = new String[count];
for(int i=0;i
columnNames[i] = rsmd.getColumnLabel(i+1);
System.out.println("查询出的列名："+columnNames[i]);
}
15、 循环结果集时循环所有的列，根据查询出的列名组装需要调用的set方法名
for(int i=0;i
String cname = columnNames[i];
Field f = clz.getDeclaredField(cname);
Class type = f.getType();
String methodName = "set"+cname.substring(0,1).toUpperCase()+cname.substring(1);
System.out.println("方法名："+methodName);
Method m = clz.getDeclaredMethod(methodName, type);
m.invoke(obj, rs.getObject(cname));
}
16、 代码示例
(1)、 详细的请参照项目里的BaseDAO.java
/**
 * 根据SQL和集合里封装的Class类型，通用的查询方法
 * @param sql
 * @param clz
 * @return
 */
public List executeQuery(String sql, Class clz) {
// select id as id1,userName name form users
Connection conn = null;
PreparedStatement pstm = null;
ResultSet rs = null;
List list = new ArrayList();
try {
// 获得连接
conn = this.getConn();
// 获得预处理对象
pstm = conn.prepareStatement(sql);
// 获得结果集
rs = pstm.executeQuery();
// 问题:如何获得结果集中有多少列,列的名字，通过ResultSetMetaData来获取
ResultSetMetaData rsmd = rs.getMetaData();
// 获得有多少列，就知道查询语句中查询了几个字段
int count = rsmd.getColumnCount();
// 获得列名，用数组存起来
// 这里的列名要求和实体类的字段名一致
// 注意，oracle数据库，查询出来的都是大写
String columnNames[] = new String[count];
for (int i = 0; i < count; i++) {
// 获得查询语句中，查询的结果集字段名(有别名的是别名)
columnNames[i] = rsmd.getColumnLabel(i + 1).toLowerCase();
System.out.println("列名：" + columnNames[i]);
}
while (rs.next()) {
// 通过反射来获得Class对象，Class对象已经传过来了
// 通过反射调用无参的默认构造方法，动态构建一个对象
Object obj = clz.newInstance();
// 每读一行，rs指向一行，循环这一行里面所有的字段(列)
for (String cname : columnNames) {
// 列名拼装以下，set + 首字母大写 + 后面的字母，变为实体类中setXxx方法
String methodName = "set"
+ cname.substring(0, 1).toUpperCase()
+ cname.substring(1);
System.out.println("methodName:" + methodName);
// 根据列名(列名和属性名一致)获得属性
Field f = clz.getDeclaredField(cname);
// 根据属性的类型，来设置方法的参数类型
Method m = clz.getMethod(methodName, f.getType());
// 动态调用方法 rs.getObject方法，当oracl数据库的序列产生的number类型数据时，无效
// oracl数据库的处理以下
if (f.getType().getName().equals("int")|| f.getType().getName().equals("java.lang.Integer")) {
m.invoke(obj, rs.getInt(cname));
} else
m.invoke(obj, rs.getObject(cname));
}
// 将对象添加到集合
list.add(obj);
}
} catch (Exception e) {
e.printStackTrace();
}
return list;
}
(6)、 测试
@Test
public void testExecuteQuery(){
BaseDAO dao = new BaseDAO();
List list = dao.executeQuery("select * from users", Users.class);
for(int i=0;i
Users user = (Users) list.get(i);
System.out.println("---name:"+user.getName());
}
}
请支付10元
加微信好友
weixinghao:
d555888088
获得下载链接
	

类与类之间单根继承

使Java语言变得易于使用和简单,

如果一个类可以继承多个类,那么这个类所有成员变量名和方法名必须要不同(C++就是这样要求的).这是前提,我们必须确定这个才能用多重继承,如果在类方法名或者成员变量名很多情况下,这是很复杂的事情.原因:要确定子类到底继承方法或属性是哪一父类的




类与接口可以多重实现(接口与接口之间可以有相同的方法名),

接口中没有成员变量(只有常量),而方法是抽象的,没有方法体,所以实现类只要实现这个些接口都必须重写,实现谁的接口方法最终的结果都是要重写




接口与接口之间可以多重继承

原因与上类似

转载自：http://blog.sina.com.cn/u/2663033831 

接口
什么是接口？
接口是JAVA中一种自定义的特殊的类
接口中只能声明方法的原型，而不允许定义方法体
接口中定义的属性只能是常量
为什么需要接口
JAVA语言中只支持单继承模式，即一个类有且只有一个父类，那我想多层继承呢，那只能继承接口了，接口只有方法原型，接口定义的属性必须是常量
JAVA中的类都继承了Objiect，Objiect是所有JAVA类的父类
接口的定义和使用
JAVA通过关键字interface定义一个接口
接口中的属性和方法声明只能是public类型
接口其实是一种类类型，可以定义接口类型的引用变量
子类通过关键字implements实现接口中方法
一个子类可以实现多个接口，但是必须实现接口中的所以的方法，否则子类将成为抽象类
 
示例
interface Calculate{
         publicfloat PI=3.14f;
         publicfloat area();
         publicfloat perimeter();
}
 
class Shape{
         privatefloat x=0;
         privatefloat y=0;
         
         publicShape(float x,float y){
                   this.x=x;
                   this.y=y;
         }
 
         publicfinal float getX(){
                   returnx;
         }
 
         publicfinal float getY(){
                   returny;
         }
 
}
 
final class Rectangle extends Shapeimplements Calculate{
         privatefloat width = 0;
         privatefloat height =0;
         
         publicRectangle(float x,float y,float width,float height){
         super(x,y);
         this.width= width;
         this.height= height;
 
         }
 
         publicfloat area(){
                   returnwidth*height;
         }
 
         publicfloat perimeter(){
                   return2*(width+height);
         }
 
}
 
final class Circle extends Shape implementsCalculate{
         protectedfloat radius=0;
 
         publicCircle(float x,float y,float radius){
                   super(x,y);
                   this.radius= radius;
         }
 
         publicfloat area(){
                   returnPI*radius*radius;
         }
 
         publicfloat perimeter(){
                   return2*PI*radius;
         }
}
 
public class Main{
         publicstatic void main(String[] args){
                   Calculater=new Rectangle(2,4,5,10);
                   Calculatec=new Circle(9,10,5);
                   Rectanglez=new Rectangle(1,2,3,4);
         
                   System.out.println(z.getX());
                   System.out.println(r.perimeter());
                   System.out.println(r.area());
                   System.out.println();
                   System.out.println(c.perimeter());
                   System.out.println(c.area());
         //      System.out.println(c.getX());
         }
 
}        
 
接口只是一种特殊的抽象类
接口中的每个方法都是抽象方法
接口中定义的属性都是常量属性
 
内部类只是一个相对的概念，通常指内嵌于其他类中定义的类和内嵌于方法中定义的类
内部类在使用上和顶层类没有什么区别
只是由于内部类在其他类中定义，因此会有一些附加的规则
为什么需要内部类？
对类的使用者而言，只关心方法所提供的功能
对类的实现者而言，需要设计一个特殊的算法实现方法的功能
在设计算法的同时不可避免的会遇见一些逻辑概念，而这些概念可以抽象成一些只有内部使用的类
 
内部类和接口
类里面定义内部类
规则：
JAVA中的内部类可以访问外部类的属性和方法
内部类的使用必须以生成对象的方式进行
在出现二义性的情况下，还是可以通过外部类名+this的方式访问外部类的属性和方法
如果不加限定符，将通过最近声明原则确定具体属性
使用范例1：
这里有个Outer类
class Outer{
         privateint x=0;
         这里明显是定义一个类，这个类是在哪里定义的呢
         privateInner inner= null;
         这下面马上就定义了，在内部修饰的
         Private修饰这个类，明显不想让外部知道这个类
         privateclass Inner{
                   这个类干了什么是呢？首先这个内部有个X为0
                   privateint x=0;         
                   这里有个很奇怪的语法，Outer.this.x++
                   前面的Outer.this看起来是限定符， 
                   publicvoid addOuter(){
                            这里调用了外面类的对象来++
Outer.this.x++;
                   }
                   根据我们作用域访问原则：不加限定符，将通过最近声明原则确定具体属性，
                   所以这里的X就是前面Inner类里面的X
public void addSelf(){
                            x++;
                   }
 
                   publicint getX(){
                            returnx;
                   }
         }
         构造函数，构造函数里面创建了这个内部类
         publicOuter(){
                   inner= new Inner();
         }
         这个addOuter是外部类的
         publicvoid addOuter(){
                   调用内部类的addOuter
                   inner.addOuter();
         }
         addInner调用内部类的addSelf()
         publicvoid addInner(){
                   inner.addSelf();
         }
         这里是访问X，这个X明显是外部类的
         publicint getOuterX(){
                   returnx;
         }
         这里访问内部类的X
         publicint getInnerX(){
                   returninner.getX();
         }
}
 
如果不加限定符，将通过最近声明原则确定具体属性
如上面的addSelf方法中的x指的是Inner类的属性X
public class Main{
       public static void main(String[] args){
                Outer o=new Outer();
 
                o.addOuter();
                o.addOuter();
                o.addOuter();
                o.addInner();
 
               System.out.println(o.getOuterX());
               System.out.println(o.getInnerX());
       }
}
 
输出结构是3 1
 
内部类的第二种使用方法
 
方法里面定义内部类
class Outer{
         privateint x=0;
         publicint getX(){
                   finalint x=5;
                   intret=0;
                   classInner{
                            publicvoid addOuter(){
                                     Outer.this.x++;
                            }
                            publicint getX(){
                                     returnx;
                            }
                   }
                   Innerinner=new Inner();
                  这里的X是前面的 privateint x=0那里的x
                   if(this.x==0){
                            inner.addOuter();
                            ret= this.x;
                   }elseif(this.x==1){
                            inner.addOuter();
                            ret= inner.getX();
                   }else{
                            ret= x+inner.getX();
                   }
         
                   returnret;
                   }
}
 
 
 
public class Main{
       public static void main(String[] args){
                Outer o=new Outer();
 
                System.out.println(o.getX());
                System.out.println(o.getX());
                System.out.println(o.getX());
 
 
       }
}
 
输出结果 1 5 10
规则：
方法中的内部类依然可以访问外部类的属性和方法
方法中的内部类必须在使用前定义
方法中的内部类可以访问方法中的定义的变量
方法中的内部类通过最近声明原则确定具体属性或常量

java中，为什么有些类不需要导入？

 编程语言java



专业回答

枫神的天空
2015-07-17 11:47


java中java.lang包的内容是自动导入的，不需要手动导入，其它必须手动导入。

因为java.lang.Object是除了它自身之外的所有类的父类，所以不需要导入