• 2017年4月24号课堂笔记

    2017年4月24号  晴  空气质量：中度污染

    内容：反射及相关，java设计六大原则（自学）

    一、反射机制

    在 程序运行期间，对于任何一个类，都能获得它的所有方法和属性！
    对于任何一个对象，都能调用它的任意方法和属性！
    这种动态获取类的信息 或者动态调用对象的方法或者属性的功能！ ===》java 反射机制

    二、反射Demo

    老师代码：

    1）学生实体类：

    package cn.bdqn.bean;
    //学生实体类
    public class Student extends Person {

    private String name; // 私有化的姓名
    public String address; // 公共的地址
    protected int age; // 受保护的年龄
    char sex; // 默认权限的性别

    static {
    System.out.println("student类中静态代码块！01");
    }

    {
    System.out.println("student类中普通代码块！02");
    }

    public Student() {
    System.out.println("student类中无参构造03");
    }

    // 私有的方法
    private String getWords(String name) {
    return name + "====>大家辛苦了！";
    }

    public String getName() {
    return name;
    }

    public void setName(String name) {
    this.name = name;
    }

    public String getAddress() {
    return address;
    }

    public void setAddress(String address) {
    this.address = address;
    }

    public int getAge() {
    return age;
    }

    public void setAge(int age) {
    this.age = age;
    }

    public char getSex() {
    return sex;
    }

    public void setSex(char sex) {
    this.sex = sex;
    }

    }

    2）父类person类：

    package cn.bdqn.bean;

    //父类人类
    public class Person {

    }

    3）反射测试类：

    package cn.bdqn.bean;
    //反射测试类
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;

    import org.junit.Test;

    public class ReflectTest {

    /**
    * 对象名.getClass() === 类名.class
    * 都是获取类的class 实例
    *
    * 所有类的实例 都是Class类的对象
    */
    @Test
    public void test01() {
    Student stu = new Student();
    System.out.println("stu对象所属类的父类" + stu.getClass().getSuperclass());
    System.out.println("Student类的父类" + Student.class.getSuperclass());
    }

    @Test
    public void test02() {
    Integer a = 5;
    System.out.println(a.getClass().getSuperclass());
    Class<?>[] interfaces = Integer.class.getSuperclass().getInterfaces();
    for (Class<?> class1 : interfaces) {
    System.out.println(class1.getName());
    }
    }

    // 三种方式获取指定类的完整限定名 （全类名==包名+类名）
    @Test
    public void test03() {
    try {
    // 01. 常用（推荐）
    System.out.println(Class.forName("cn.bdqn.bean.Student").getName());//此时会把类加载到JVM中！！
    System.out.println(Class.forName("cn.bdqn.bean.Student")
    .getSimpleName()); // 简单类名
    } catch (ClassNotFoundException e) {
    e.printStackTrace();
    }
    }

    @Test
    public void test04() {
    // 02.
    System.out.println(Student.class.getName()); // 类名点
    }

    @Test
    public void test05() {
    // 03.
    System.out.println(new Student().getClass().getName()); // 对象点
    }

    // 获取包名
    @Test
    public void test06() {
    try {
    Class c = Class.forName("cn.bdqn.bean.Student");
    System.out.println(c.getPackage().getName());
    } catch (ClassNotFoundException e) {
    e.printStackTrace();
    }
    }

    // 获取类的修饰符
    @Test
    public void test07() {
    try {
    Class c = Class.forName("cn.bdqn.bean.Student");
    System.out.println("类的修饰符===》"
    + Modifier.toString(c.getModifiers()));
    } catch (ClassNotFoundException e) {
    e.printStackTrace();
    }
    }

    // 获取属性的相关信息
    @Test
    public void test08() {
    try {
    Class c = Class.forName("cn.bdqn.bean.Student");
    // Field[] fields = c.getFields();// 获取public修饰的属性
    Field[] fields = c.getDeclaredFields(); // 获取所有的属性
    for (Field field : fields) {
    System.out.println(field);
    }
    System.out.println("获取所有属性的名称");
    for (Field field : fields) {
    System.out.println(field.getName());
    }
    System.out.println("获取所有属性的修饰符");
    for (Field field : fields) { // default的int 是0
    System.out.println(Modifier.toString(field.getModifiers()));
    }
    } catch (ClassNotFoundException e) {
    e.printStackTrace();
    }
    }

    // 通过反射获取类中的构造方法
    @Test
    public void getConstructors() throws Exception {
    Class c = Class.forName("cn.bdqn.test.Student"); // 加载静态代码块
    Constructor[] constructors = c.getDeclaredConstructors();
    for (int i = 0; i < constructors.length; i++) {
    System.out.println("构造的修饰符："
    + Modifier.toString(constructors[i].getModifiers()));
    System.out.println("构造的名称：" + constructors[i].getName());
    /**
    * 1.8才有getParameterCount

    System.out
    .println("构造的参数个数：" + constructors[i].getParameterCount());
    */
    Class[] types = constructors[i].getParameterTypes(); // 参数的类型
    for (Class class1 : types) {
    System.out.println("参数类型的名称：" + class1.getName());
    System.out.println("参数的类型简写：" + class1.getSimpleName());
    }
    System.out.println("******************************");
    }
    }

    // 通过反射观察执行顺序
    @Test
    public void test09() {
    // Student stu = new Student(); 耦合
    try {
    Class c = Class.forName("cn.bdqn.bean.Student");
    Student student = (Student) c.newInstance(); // 解耦合
    } catch (ClassNotFoundException e) {
    e.printStackTrace();
    } catch (InstantiationException e) {
    e.printStackTrace();
    } catch (IllegalAccessException e) {
    e.printStackTrace();
    }
    }

    // 调用类的私有方法
    @Test
    public void test10() throws Exception {
    Class c = Class.forName("cn.bdqn.bean.Student"); // 没有实例化对象
    // 获取类中所有的方法
    Method[] methods = c.getDeclaredMethods();
    Method method = c.getDeclaredMethod("getWords", String.class);
    // 实例化对象
    Student stu = (Student) c.newInstance();
    // 打开开关
    method.setAccessible(true);
    // 执行方法
    String result = (String) method.invoke(stu, "小黑");
    System.out.println(result);
    }

    }

    三、传参中的一种模式（...）

    老师代码：

    1）参数...类

    package cn.bdqn.bean;

    //参数...类
    public class ArrayPPP {

    /**
    * ...的注意事项：
    * 01.底层就是一个数组,操作它就是操作我们的数组
    * 02.在作为参数的时候，必须位于参数列表的最后一个位置
    * 03.它可以是0-N个数据的组合
    * 04.只能作为参数，并不能代替数组的声明
    */
    public static void main(String[] args) {
    int[] nums = { 1, 2, 3, 4, 5 };
    changeNums(500);
    System.out.println(nums[0]);
    }

    private static void changeNums(int num, int... nums) {
    nums[0] = num;
    }

    /**
    * private static void changeNums(int num, int [] nums) {
    nums[0] = num;
    }*/

    }

    2）测试类

    package cn.bdqn.bean;

    //测试类
    public class PTest {

    public static void main(String[] args) {
    String[] words = test("a", "n", "c");
    // 会把"a", "n", "c" 封装成一个String类的数组 传给 words
    System.out.println(words[0]);
    }

    public static String[] test(String... words) {
    words[0] = "5555";
    for (String s : words) {
    System.out.println(s);
    }
    return words;
    }

    }

    四、java设计中的六大原则

    转载自：http://blog.csdn.net/cq361106306/article/details/38708967

     

      六种设计原则

    （一）单一职责原则

    不要存在多于一个导致类变更的原因。通俗的说，即一个类只负责一项职责。 
    问题由来：类T负责两个不同的职责：职责P1，职责P2。当由于职责P1需求发生改变而需要修改类T时，有可能会导致原本运行正常的职责P2功能发生故障。
    一句话总结：不能为图代码量少，把牛头马嘴一起往一个类塞
     

    （二）里氏替换原则

    1.子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。

    2.子类中可以增加自己特有的方法。

    3.当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。

    4.当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。

    一句话总结：尽量不要重写父类的已经实现了的方法，可以用接口等其他方法绕过

    （三）依赖倒置原则

    高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。

    这里用一个列子来说明：

    1. import java.util.LinkedList;  
    2. import java.util.Queue;  
    3.   
    4.   
    5.   
    6. interface IEAT  
    7. {  
    8.     public void eat();//抽象吃这个动作  
    9. }  
    10. class EatApple implements IEAT  
    11. {  
    12.   
    13.     @Override  
    14.     public void eat()   
    15.     {  
    16.         //这里是吃苹果  
    17.         System.out.print("eat a apple");  
    18.           
    19.     }  
    20. }  
    21. class EatWater implements IEAT  
    22. {  
    23.   
    24.     @Override  
    25.     public void eat() {  
    26.         // 这里是吃水  
    27.         System.out.print("dringk water");  
    28.           
    29.     }  
    30.       
    31. }  
    32. public class Human  
    33. {  
    34.     public void dosomething(IEAT ieat)//我爱吃东西，吃什么呢，看传入什么  
    35.     {  
    36.         ieat.eat();  
    37.     }  
    38.     /* 
    39.     public void dosomething(String food)//我爱吃东西，吃什么呢，看传入什么 
    40.     { 
    41.         if(food.equals("apple")) 
    42.         { 
    43.             //吃苹果 
    44.         } 
    45.         if(food.equals("water")) 
    46.         { 
    47.             //喝水 
    48.         } 
    49.     } 
    50.     */  
    51.     public static void main(String[] args)  
    52.     {  
    53.         Human human=new Human();  
    54.         /* 
    55.         human.dosomething("apple"); 
    56.         human.dosomething("water"); 
    57.          */  
    58.         //给你吃个苹果  
    59.         human.dosomething(new EatApple());  
    60.         //再给你喝点水  
    61.         human.dosomething(new EatWater());  
    62.     }  
    63. }  


    其中注释的就是我们常用的方法。这种方法非常不适于扩展，因为如果要吃香蕉，吃西瓜，又要在dosomething里面写一堆判断。写着写着就混了。

    因此一句话总结：多用抽象的接口来描述相同的动作，降低实现这个动作的人和物之间的耦合度

     

    （四）接口隔离原则

    客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。 
    问题由来：类A通过接口I依赖类B，类C通过接口I依赖类D，如果接口I对于类A和类B来说不是最小接口，则类B和类D必须去实现他们不需要的方法。
    一句话总结：就好比鱼和人两个类，鱼是游泳和腮呼吸两个动作，人是走路和吃饭两个动作，这些动作不能写在一个接口里面，把这四个动作都包含了。要拆成专门对鱼和人的两个接口才行。

    （五）迪米特法则

    迪米特法则又叫最少知道原则，最早是在1987年由美国Northeastern University的Ian Holland提出。通俗的来讲，就是一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类来说，无论逻辑多么复杂，都尽量地的将逻辑封装在类的内部，对外除了提供的public方法，不对外泄漏任何信息。

    这个有点不好记，总结就是：father1<-child1,father2<-child2,father1和father2是的手下， father1尽量通过father2去访问child2, 不要直接在类里面访问child2. 下属怎么能随便去领导家的孩子呢，小心别人说你拐卖 

     

    （六）开闭原则

    这个没啥好说的：尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。

    五、作业

    1、总结U1的MindManager（周三上课前交ftp）

    2、写soso，周五考试+答辩

    3、周四晚上考linux和hadoop命令

    六、老师辛苦了！

     
  • 相关阅读:
    IOS之helloworld
    xcode4.2中创建Navigation－Based Application
    IOS之数据持久化
    IOS之多视图应用程序
    IOS之高级控件表视图
    IOS之基本UI控件
    IOS之导航控制器与表视图
    IOS之应用程序设置
    IOS之高级控件拾取器
    IOS之UI基础
  • 原文地址：https://www.cnblogs.com/wsnedved2017/p/6756199.html
Copyright © 2020-2023  润新知