------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ ----

黑马程序员   反射

package cn.itcast.demo01_获取Class对象的三种方式;
/*
 * 获取Class对象的三种方式；
 * 
 * 1.Object类中的：getClass()：此方法不是静态的，必须对象的引用调用；
 * 2.class属性：任何的数据类型(包括基本数据类型)都有一个静态的class属性，它可以获取这个类的Class对象；
 * 3.Class类中有个静态方法：
 * Class forName(String className);className要是全名限定的类名(带包名的类名)
 * 常用：第3种；
 * 
 * class Student{
 * public static Class class = new Class();
 * }
 */
public class Demo {
public static void main(String[] args) throws ClassNotFoundException {
Student stu = new Student();//会产生：Student对象空间，Class对象空间
//方式一：获取Class对象
Class stuClass1 = stu.getClass();
//方式二：静态的class属性
Class stuClass2 = Student.class;
// Class intClass = int.class;//基本数据类型也有
System.out.println("stuClass1 == stuClass2 : " + (stuClass1 == stuClass2));

//方式三：Class的静态方法forName()
// Class stuClass3 = Class.forName("Student");//运行时异常：java.lang.ClassNotFoundException
Class stuClass3 = Class.forName("cn.itcast.demo01_获取Class对象的三种方式.Student");
System.out.println("stuClass1 == stuClass3 : " + (stuClass1 == stuClass3));

}
}

import java.lang.reflect.Constructor;


/*
 * 通过反射获取无参_有参构造方法并使用：
 * 
 * Class:
 * //---批量的；
 * Constructor[] getConstructors():获取所有的"公有"构造方法；
Constructor[] getDeclaredConstructors():：获取所有的(包括私有的)构造方法；

每一个Constructor内部都包含了"一个构造方法"的详细信息；

//---获取某个Constructor对象
public Constructor getConstructor(Class ... parameterTypes):获取某个公有的构造方法
public Constructor getDeclaredConstructor(Class<?>... parameterTypes)：获取某个构造方法(包括私有的)

//Constructor的成员方法：
public Object newInstance(Object... initargs)：创建这个Class类所表示的类的一个对象；




 */
public class Demo {
public static void main(String[] args) throws Exception{
//*********获取Class对象************//
Class stuClass = Class.forName("cn.itcast.demo02_通过反射获取无参_有参构造方法并使用.Student");
//*********获取所有的"公有的"构造方法*********
Constructor[] conArray = stuClass.getConstructors();
//遍历
System.out.println("**********所有   公共的       构造方法***********");
for(Constructor c : conArray){
System.out.println(c);
}

//********获取所有的构造方法***********//
System.out.println("**********所有构造方法(包括私有)***********");
conArray = stuClass.getDeclaredConstructors();
for(Constructor c : conArray){
System.out.println(c);
}
/*
* class Class{
* public Constructor getConstructor(){
* return new Constructor();
* }
* }
* class Constructor{
* }
*/
System.out.println("**********获取单个，公有，无参的构造方法，并调用***********");
Constructor con = stuClass.getConstructor();//获取无参的
Object obj = con.newInstance();
System.out.println("obj = " + obj);
System.out.println("**********获取单个，公有，带参的构造方法，并调用***********");
con = stuClass.getConstructor(int.class);//获取int参数的公有构造方法
con.newInstance(20);//20就是"实参"，使用这个实参去调用此构造方法

System.out.println("**********获取私有，带参的构造方法，并调用***********");
con = stuClass.getDeclaredConstructor(String.class,boolean.class);
con.setAccessible(true);//如果是私有的，设置暴力访问
con.newInstance("刘德华",false);



}
}

import java.lang.reflect.Field;


/*
 * 通过反射获取成员变量并使用
 * 
 * Class类：
 * 
 * ----批量的：
 * Field[] getFields():获取所有公有的成员变量
Field[] getDeclaredFields()：获取所有成员变量(包括私有)
   ----单个的：
    Field getField():获取单个，公有的成员变量
    Field getDeclaredField():获取单个的成员变量，包括私有的
   ----为成员变量赋值：
    Filed --> set(Object obj,Object value)
 */
public class Demo {
public static void main(String[] args) throws Exception {
//1.获取Class对象
Class stuClass = Class.forName("cn.itcast.demo03_通过反射获取成员变量并使用.Student");
System.out.println("*********获取所有公有的成员变量************");
Field[] fieldArray = stuClass.getFields();
for(Field f : fieldArray){
System.out.println(f);
}
System.out.println("*********获取所有的成员变量(包括私有的)************");
fieldArray = stuClass.getDeclaredFields();
for(Field f : fieldArray){
System.out.println(f);
}
System.out.println("*********获取单个公有的成员变量，并赋值************");
Field f = stuClass.getField("name");
//赋值前，一定要确保堆中有"对象空间"，所有要先创建一个对象
Object obj = stuClass.getConstructor().newInstance();//调用公有无参的构造方法
f.set(obj, "刘德华");

System.out.println("*********获取私有的成员变量，并赋值*********************");
f = stuClass.getDeclaredField("address");
f.setAccessible(true);//设置暴力访问
f.set(obj, "北京市");
//验证
Student stu = (Student)obj;
System.out.println("Student的 name = " + stu.name + " address = " + stu.getAddress());



}
}

import java.lang.reflect.Field;
import java.lang.reflect.Method;


/*
 * 获取成员方法：
 * 
 * Class类的：
 * 
 * ----批量的：
 * Method[] getMethods():获取所有公有的成员方法；
 * Method[] getDeclaredMethods():获取所有的成员方法包括私有的。
 * ----单个：
 * Method getMethod():获取单个公有的成员方法；
 * Method getDeclaredMethod():获取单个成员方法，包括私有的；
 * 
 * ----调用方法：
 * Method --> public Object invoke(Object obj,Object... args)
 */
public class Demo {
public static void main(String[] args) throws Exception{
//1.获取Class对象
Class stuClass = Class.forName("cn.itcast.demo04_通过反射获取成员方法并使用.Student");
System.out.println("*****************************获取所有公有的成员方法*****************************");
Method[] methodArray = stuClass.getMethods();//包含了父类的公有的
for(Method m : methodArray){
System.out.println(m);
}

System.out.println("*****************************获取所有的成员方法(包括私有的)*****************************");
methodArray = stuClass.getDeclaredMethods();//不包含继承的；
for(Method m : methodArray){
System.out.println(m);
}
System.out.println("*****************************获取单个公有的，无参的并调用*****************************");
Method m = stuClass.getMethod("show1");
//实例化一个对象
Object obj = stuClass.newInstance();
m.invoke(obj);

System.out.println("*****************************获取单个公有的，带参的，带返回值并调用*****************************");

m = stuClass.getMethod("show2", String.class,int.class);
Object result = m.invoke(obj, "张三",20);//传递实参，并接受返回值；
System.out.println("返回值为：" + result);

System.out.println("*****************************获取单个私有的，带参的并调用*****************************");
m = stuClass.getDeclaredMethod("show5", int.class);
m.setAccessible(true);//暴力访问
m.invoke(obj, 20);

}
}

代理模式：
 * 
 * 1.在不改变原类的基础上，可以为原类增加一些其他功能；
 * 2.当有代理后，我们可以直接面对：代理类
 * 
 * 有一个类，访问数据库中的Student表：
 * class StudentService{
 * public void add(){
 * //添加一条Student信息；
 * }
 * public void delete(){
 * //删除数据库中一条Student信息；
 * }
 * }
 * 
 * 现在要求，在不更改原类的基础上，在调用这两个方法时，都要做两个操作：
 * 1.在调用此方法之前：检查：是否有权限；
 * 2.在调用此方法之后：写日志；
 * 
 * 建立一个"代理类"，后期使用，直接使用此代理类；
 * 
 * 缺陷：如果其它类，也需要加这两个方法，也得添加代理类，这样会导致类太多；
 */
public class Demo {
public static void main(String[] args) {
/*StudentService stuService = new StudentService();
stuService.add();
stuService.delete();*/

//直接面对代理
StudentServiceProxy proxy = new StudentServiceProxy();
proxy.add();
proxy.delete();
}
}

Java中提供了"动态代理"：不需要"代理类"，动态代理机制会为要代理的类，自动产生一个代理对象；
 * Java中的动态代理是基于"接口"的，需要代理的类，一定要是某个接口的实现类；
 * 
 * 步骤：
 * 1.定义一个类，实现：InvocationHandler
 * 2.在使用时，使用Proxy：newProxyInstance()方法产生代理对象；
 * 
 */
public class Demo {
public static void main(String[] args) {
IService stuService = (IService)Proxy.newProxyInstance(
StudentService.class.getClassLoader(), 
StudentService.class.getInterfaces(), 
new MyInvocationHandler(new StudentService())
);


stuService.add();
stuService.delete();

IService teaService = (IService)Proxy.newProxyInstance(TeacherService.class.getClassLoader(), 
TeacherService.class.getInterfaces(), 
new MyInvocationHandler(new TeacherService()));
teaService.add();
teaService.delete();


}
}

模版设计模式概述和使用
 * 
 * 
 */
abstract class Person{
//模板方法
void show(){
System.out.println("我是传智播客的一名 " + getType() + " ，我骄傲！！");
}
abstract String getType();
}
class Student extends Person{
@Override
String getType() {
return "学生";
}
}
class Teacher extends Person{
@Override
String getType() {
return "教师";
}
}
public class Demo {
public static void main(String[] args) {
Student stu = new Student();
stu.show();//show()是继承的

Teacher tea = new Teacher();
tea.show();//
}
}

装饰模式:

public class Demo {
public static void main(String[] args) {
//我们可以直接使用具体的产品
/*ThinkPadX240 x240 = new ThinkPadX240();
x240.sellComputer();

ThinkPadX550 x550 = new ThinkPadX550();
x550.sellComputer();*/

//我们去西三旗经销商那里去买


ThinkPad_XSQ_Dealer xsq = new ThinkPad_XSQ_Dealer(new ThinkPadX240());
xsq.sellComputer();

//去中关村买
ThinkPad_ZGC_Dealer zgc = new ThinkPad_ZGC_Dealer(new ThinkPadX550());
zgc.sellComputer();
System.out.println("-------------------------------------");
IThinkPad think = new ThinkPad_XSQ_Dealer(new ThinkPad_ZGC_Dealer(new ThinkPadX240()));
think.sellComputer();

}
}