Day27练习

Hello World️

已于 2022-08-02 17:47:33 修改

阅读量134

点赞数

分类专栏： javaSE 文章标签： java 开发语言

于 2022-07-19 21:41:03 首次发布

本文链接：https://blog.csdn.net/m0_51318597/article/details/125881658

版权

javaSE 专栏收录该内容

59 篇文章 1 订阅

订阅专栏

文章目录

A:简答题

1、请把我们讲解过的所有类中的方法在API中找到，并使用自己的话进行描述

public static Class<?> forName(String className) 
通过类对应的全类名className 获取一个类对象的字节码文件对象

public Constructor<?>[] getConstructors() 
获取所有的公共的构造方法 不含有私有构造方法
public Constructor<?>[] getDeclaredConstructors() 
获取所有的构造方法 包括私有构造方法
public Constructor<T> getConstructor(Class<?>... parameterTypes) 
获取单个的公共的构造方法 不包含私有的
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 
获取单个的构造方法 包含私有的
public T newInstance(Object... initargs) 
使用空参数构造方法创建对象
通过反射的构造方法创建对象(initargs-传入对象的值)
public void setAccessible(boolean flag)。
通过私有构造方法创建对象是 取消语法检查不报错(flag->true)
 
public Method[] getMethods() 
获取所有的公共的成员方法 不包含私有的 包含父类继承过来的公共方法
public Method[] getDeclaredMethods() 
获取所有的成员方法 包含私有的
public Method getMethod(String name,Class<?>... parameterTypes) 
获取单个的成员方法 不包含私有的
传入方法名,参数类型
public Method getDeclaredMethod(String name,Class<?>... parameterTypes) 
获取单个的成员方法 包含私有的
public Object invoke(Object obj, Object... args) 
执行方法 传入对象名 参数
 
public Field[] getFields() 
获取所有公共的成员变量 包含从父类继承过来的
public Field[] getDeclaredFields() 
获取所有的成员变量 包含私有的 也包含从父类继承过来的成员变量
public Field getField(String name) 
获取单个指定名称name的公共成员变量 不包含私有的
public Field getDeclaredField(String name)
获取单个指定名称的成员变量 包含私有的
public Object get(Object obj) 
获取值 传入创建的对象
public void set(Object obj, Object value) 
设置值 传入创建的对象及其设置的值

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 
用于动态生成代理类
loader: 类加载器
interfaces:动态代理类需要实现的接口
h:动态代理方法在执行时，会调用h里面的invoke方法去执行

public Object invoke(Object proxy,Method method,Object[] args) 
对目标类进行增强
proxy：就是代理对象，newProxyInstance()方法的返回对象
method：调用的方法
args: 方法中的参数

2、回顾整个JavaSE知识点

3、请简述什么是类加载器？类加载器的分类及作用？

类加载器
   负责将.class文件加载到内存中 并为之生成对应的Class对象
类加载器的分类
   Bootstrap ClassLoader 根类加载器
   Extension ClassLoader 扩展类加载器
   System ClassLoader 系统类加载器
类加载器的作用
   1. Bootstrap ClassLoader 根类加载器
   	引导类加载器 负责Java核心类的加载
   	如String,System等
       在JDK中JRE的lib目录下rt.jar文件中
   2. Extension ClassLoader 扩展类加载器
   	负责JRE的扩展目录中jar包的加载
   	在JDK中JRE的lib目录下的ext目录
   3. System ClassLoader 系统类加载器
   	负责JVM启动时加载来自java命令的class文件 以及classpath环境变量所指定的jar包和类路径

4、请简述什么是反射机制？它有什么用处？

JAVA反射机制:
	在运行状态中 对于任意一个类,都能够知道这个类的所有属性和方法 对于任意一个对象,都能够调用它的任意一个方法和属性

用处:
	1.类
	判断任意一个对象是否属于某个类(找到对象对应的类)
	运行时构造某个类的一个对象
	2.对象
	判断任意一个对象具有的属性和方法
	运行时调用任意一个对象的方法

5、请简述什么是动态代理？

可以动态的创建代理并动态的处理对所代理方法的调用

特点: 字节码随用随创建 随用随加载
作用: 不修改源码的基础上对方法增强

6、请说说jdk5与jdk7的新特性有哪些？

jdk5
   自动拆装箱 泛型 增强for 可变参数 枚举
jdk7
   二进制字面量 
   	可以用二进制来表示整数(byte short int long)
   	int x = 0b110110(或0B110110)
   数字字面量可以出现下划线
   	int x = 100_1000;
   	注意:
           1.不能出现在进制标识和数值之间
           2.不能出现在数值开头和结尾
           3.不能出现在小数点旁边
   switch语句可以用字符串
   泛型简化

7、请简述使用枚举需要注意哪些事项？

定义枚举的关键字enum
所有的枚举类都是Enum的子类 不显示
枚举类的第一行上必须是枚举项
枚举类可以有构造器 但必须是private的
枚举类也可以有抽象方法 但是枚举项必须重写该方法
枚举在switch语句中可以使用

B:看程序写结果(写出自己的分析理由)，程序填空，改错，看程序写结果。

1、编写程序，将下面的每个方法对应的功能实现。

public class Reflection {
    /**
     * 得到某个对象的私有属性
     *
     * @param obj       对象
     * @param fieldName 属性名
     * @return return 该属性对象
     */
    public Object getProperty(Object obj, String fieldName) throws Exception {
        //编写代码 得到某个对象的私有属性
        Class<?> aClass = obj.getClass();
        Field declaredField = aClass.getDeclaredField("fieldName");
        return declaredField;
        
    }

    /**
     * 得到某类的静态公共属性
     *
     * @param className 类名
     * @param fieldName 属性名
     * @return 该属性对象
     */
    public Object getStaticProperty(String className, String fieldName) throws Exception {
        //编写代码 得到某类的静态公共属性
        Class<className> classNameClass = className.class;
        Field declaredField = classNameClass.getDeclaredField("fieldName");
        return declaredField;
    }
}

2、给出以下代码，请问该程序的运行结果是什么？如有问题，请说明原因。

enum MyEnum {
   ZHANGSAN(1, "zhangsan"), LISI(2, "lisi"), WANGWU(3, "wangwu");

   private MyEnum(int age, String name) {
       this.name = name;
       this.age = age;
   }

   private int age;
   private String name;

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

   public String getName() {
       return name;
   }

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

   public int getAge() {
       return age;
   }
}

public class Test {
   public static void useEnum(MyEnum enumType) {
       switch (enumType) {
           case LISI:
               System.out.println("LISI的名字是：" + enumType.getName());
               return;
           case WANGWU:
               System.out.println("WANGWU的名字是：" + MyEnum.WANGWU.getName());
               return;
           default:
               System.out.println("this is default");
               return;
       }
   }

   public static void main(String[] args) {
       useEnum(MyEnum.LISI);
       useEnum(MyEnum.WANGWU);
       useEnum(MyEnum.ZHANGSAN);
   }
}
/*
LISI的名字是：lisi
WANGWU的名字是：wangwu
this is default
*/

3、给出以下代码，请问该程序的运行结果是什么？如有问题，请说明原因。

public class TestEnum {
    public static void main(String[] args) {
        // 枚举是一种类型，用于定义变量，以限制变量的赋值；
        // 赋值时通过"枚举名.值"取得枚举中的值
        ColorEnum colorEnum = ColorEnum.blue;
        switch (colorEnum) {
            case red:
                System.out.println("color is red");
                break;
            case green:
                System.out.println("color is green");
                break;
            case yellow:
                System.out.println("color is yellow");
                break;
            case blue:
                System.out.println("color is blue");
                break;
        }
        //color is blue

        // 遍历枚举
        System.out.println("遍历ColorEnum枚举中的值");
        for (ColorEnum color : ColorEnum.values()) {
            System.out.println(color);
        }
        //red, green, yellow, blue

        // 获取枚举的个数
        System.out.println("ColorEnum枚举中的值有" + ColorEnum.values().length + "个");
        //4

        // 获取枚举的索引位置，默认从0开始
        System.out.println(ColorEnum.red.ordinal());
        System.out.println(ColorEnum.green.ordinal());
        System.out.println(ColorEnum.yellow.ordinal());
        System.out.println(ColorEnum.blue.ordinal());
        //0 1 2 3

        System.out.println("-------------");
        // 枚举默认实现了java.lang.Comparable接口
        System.out.println(ColorEnum.red.compareTo(ColorEnum.green));
        //-1

        System.out.println("-------------");
        System.err.println("季节为" + SeasonEnum.getSeason());
        //季节为spring

        for (Gender gender : Gender.values()) {
            System.out.println(gender.value);
        }
        //men women

        System.out.println("-------------");
        for (OrderState order : OrderState.values()) {
            System.out.println(order.getName());
        }
        //已取消 待审核 等待付款 正在配货 等待发货 已发货 已收货
    }

    /*
     * 颜色 普通枚举
     */
    public enum ColorEnum {
        red, green, yellow, blue;
    }

    /*
     * 季节 枚举像普通的类一样可以添加属性和方法，可以为它添加静态和非静态的属性或方法
     */
    public enum SeasonEnum {
        // 注： 枚举写在最前面，否则编译出错
        spring, summer, autumn, winter;

        private final static String position = "test";

        public static SeasonEnum getSeason() {
            if ("test".equals(position)) {
                return spring;
            } else {
                return winter;
            }
        }
    }

    /*
     * 性别 实现带有构造器的枚举
     */
    public enum Gender {
        /*
         * 通过括号赋值，而且必须带有一个有参数构造函数和一个属性跟方法，否则编译出错 赋值必须都赋值或都不赋值，不能一部分赋值一部分不赋值
         * 如果不赋值则不能写构造函数，赋值编译也出错
         */
        MAN("man"), WOMEN("women");
        private final String value;

        // 构造函数默认也只能是private，从而保证构造函数只能在内部使用
        Gender(String value) {
            this.value = value;
        }

        public String getValue() {
            return value;
        }
    }

    /*
     * 订单状态 实现带有抽象方法的枚举
     */
    public enum OrderState {
        // 已取消
        CANCEL {
            public String getName() {
                return "已取消";
            }
        },
        // 待审核
        WAITCONFIRM {
            public String getName() {
                return "待审核";
            }
        },
        // 等待付款
        WAITPAYMENT {
            public String getName() {
                return "等待付款";
            }
        },
        // 正在配货
        ADMEASUREPRODUCT {
            public String getName() {
                return "正在配货";
            }
        },
        // 等待发货
        WAITDELIVER {
            public String getName() {
                return "等待发货";
            }
        },
        // 已发货
        DELIVERED {
            public String getName() {
                return "已发货";
            }
        },
        // 已收货
        RECEIVED {
            public String getName() {
                return "已收货";
            }
        };

        public abstract String getName();
    }
}

C:编程题

1、编写程序，完成模板设计模式案例，并测试

//模板类
public abstract class WorkTime {
   public void workTime() {
       long start = System.currentTimeMillis();
       work();
       long end = System.currentTimeMillis();
       System.out.println(end - start + "毫秒");
   }

   public abstract void work();
}

//子类
public class Learn extends WorkTime {
   @Override
   public void work() {
       int count = 0;
       for (int i = 0; i < 5000000; i++) {
           count++;
       }
   }
}

//子类
public class Work extends WorkTime {
   @Override
   public void work() {
       int count = 0;
       for (int i = 0; i < 10000000; i++) {
           count++;
       }
   }
}

//测试类
public class MyTest {
   public static void main(String[] args) {
       WorkTime learn = new Learn();
       learn.workTime();

       WorkTime work = new Work();
       work.workTime();
   }
}

2、编写程序，完成装饰设计模式案例，并测试

//机器人类
public abstract class Robot {
    public abstract void sing();
    public abstract void sweepFloor();
}

//装饰类
public class DecorationRobot extends Robot {
    private Robot robot;

    public DecorationRobot(Robot robot) {
        this.robot = robot;
    }

    @Override
    public void sing() {
        robot.sing();
    }

    @Override
    public void sweepFloor() {
        robot.sweepFloor();
    }
}

public class FirstRobot extends Robot{
    @Override
    public void sing() {
        System.out.println("会唱歌");
    }

    @Override
    public void sweepFloor() {
        System.out.println("会扫地");
    }
}

public class SecondRobot extends DecorationRobot {
    public SecondRobot(Robot robot) {
        super(robot);
    }

    public void dance(){
        System.out.println("会跳舞");
    }
}

public class MyTest {
    public static void main(String[] args) {
        Robot robot = new FirstRobot();

        SecondRobot secondRobot = new SecondRobot(robot);
        secondRobot.sing();
        secondRobot.sweepFloor();
        secondRobot.dance();
    }
}