A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

本帖最后由 王永杰 于 2012-9-8 16:22 编辑

1.课程价值与目标介绍
听了张老师的讲述,感觉他讲的非常有意思,没讲到什么技术就用一些案例性的话题把我的学习欲望调动了出来,本来我一直很少听视频上的一些前言什么的,感觉听那些都是浪费时间,结果我就听了两句就想听下去的欲望,感觉这个老师很随和他的语言缺很实际。让我听着很受用。
2.eclipse及IDE开发工具介绍
简述的是Eclipse 与 myEclipse 的去别,还有其它编程工具的使用情况。虽然我这些之前都知道过了解过,但是我真的是后来自己在好奇的情况下了解的一些内容也都是无意中听来的,但是不是在课堂上听来的,所以让我在之前学习期间有些盲区,那时候还喜欢自己用一些特别的编程工具,后才才发现不是那么的在理,因为工作了后什么简单什么常用用什么,可大部分人都是用 eclipse 等常用的免费软件。让我才懂得这才是最好用的因为别人都在用。这就是市场。
3.eclipse工程管理与快捷键配置
IDE开发工具都支持使用工程化方式管理一个项目的程序开发过程,一般来说一个相对独立的项目就是一个工程,一个项目中涉及的多个java文件,资源文件等用一个工程进行管理。(在这里可以看看以前工作间中的某个工程的结构),在不使用工程管理的情况下,如果一个项目中包括多个Java源文件,编程人员需要精心维护这些源文件之间、以及源文件与其它文件的目录关系,需要逐一编译这些源文件,需要手工启动运行编译后的结果。如果将一个程序的所有源文件用一个工程来组织,开发工具能对所有源文件集中管理,记住每个源文件的位置和相互关系。 工程中有哪几个源文件、启动类是哪个、启动参数设置等配置信息在工程中都记录。
1.一个workspace可以包含多个project,一个workspace保留了eclipse的一套环境选项的配置,例如,所使用的javac和java命令,等等,细节请查看window->preferences。如果要为eclispe再配置一套环境选项,可以再创建一个workspace。Package explorer视图窗口中的filters菜单项,可以显示空的父包(此功能默认是关闭的)。
4.eclipse视图管理与程序调试
一个Perspective代表了若干个view的集合,如何显示各种view。
运行java程序:回到java 透视图
单个实图窗口的调用
调试程序调试窗口
例如 :看变量的值
5.配置eclispe的编译与运行环境
编译器的使用与查看配置
5.0 就是1.5
6.0
各个细节的配置与调用
设置单个工程的javac和java,选择工程,右键->properties可以设置javac,右键->run asàopen run dialog可以设置java。
    先用新的工作间,然后创建新工程,默认的语言即为5.0。先使用Integer  x = 3;调整编译器的语法版本为1.4,看到eclipse窗口报错了。然后将这个工程的语言设置为6.0,马上又看到bad version .class运行错误了,这是因为myeclise自带的java为1.5 。然后再将整个工作间的javac设置为6.0(eclipse自带的是jdk1.5),然后看新建工程的javac,也随之改成了6.0,运行则又报bad version .class错误。将工程的编译语言再单独改为5.0,运行则没了问题。整个工作间的语言设置为6.0后,再将整个工作间的java也设置为自己安装的java6。
6.在eclispe中配置java模板代码
快捷键的使用等
Ctrl+D: 删除当前行     
Ctrl+Alt+↓ 复制当前行到下一行(复制增加)
Ctrl+Alt+↑ 复制当前行到上一行(复制增加)
Alt+↓  当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)
Alt+↑   当前行和上面一行交互位置(同上)
Alt+←  前一个编辑的页面
Alt+→  下一个编辑的页面(当然是针对上面那条来说了)
Alt+Enter 显示当前选择资源(工程,or 文件 or文件)的属性
Shift+Enter 在当前行的下一行插入空行(这时鼠标可以在当前行的任一位置,不一定是最后)
Shift+Ctrl+Enter 在当前行插入空行(原理同上条)
Ctrl+Q   定位到最后编辑的地方
Ctrl+L  定位在某行  (对于程序超过100的人就有福音了)
Ctrl+M 最大化当前的Edit或View (再按则反之)
Ctrl+/   注释当前行,再按则取消注释
Ctrl+O   快速显示 OutLine
Ctrl+T   快速显示当前类的继承结构
Ctrl+W  关闭当前Editer
Ctrl+K   参照选中的Word快速定位到下一个
Ctrl+E 快速显示当前Editer的下拉列表(如果当前页面没有显示的用黑体表示)
Ctrl+/(小键盘) 折叠当前类中的所有代码
Ctrl+×(小键盘) 展开当前类中的所有代码
Ctrl+Space 代码助手完成一些代码的插入(但一般和输入法有冲突,可以修改输入法的热键,也可以暂用Alt+/来代替)
Ctrl+Shift+E 显示管理当前打开的所有的View的管理器(可以选择关闭,激活等操作)
Ctrl+J  正向增量查找(按下Ctrl+J后,你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在stutes line中显示没有找到了,查一个单词时,特别实用,这个功能Idea两年前就有了)
Ctrl+Shift+J 反向增量查找(和上条相同,只不过是从后往前查)
Ctrl+Shift+F4 关闭所有打开的Editer
Ctrl+Shift+X   把当前选中的文本全部变味小写
Ctrl+Shift+Y   把当前选中的文本全部变为小写
Ctrl+Shift+F  格式化当前代码
Ctrl+Shift+P 定位到对于的匹配符(譬如{}) (从前面定位后面时,光标要在匹配符里面,后面到前面,则反之)
下面的快捷键是重构里面常用的,本人就自己喜欢且常用的整理一下(注:一般重构的快捷键都是Alt+Shift开头的了)
Alt+Shift+R 重命名 (是我自己最爱用的一个了,尤其是变量和类的Rename,比手工方法能节省很多劳动力)
Alt+Shift+M 抽取方法 (这是重构里面最常用的方法之一了,尤其是对一大堆泥团代码有用)
Alt+Shift+C 修改函数结构(比较实用,有N个函数调用了这个方法,修改一次搞定)
Alt+Shift+L 抽取本地变量( 可以直接把一些魔法数字和字符串抽取成一个变量,尤其是多处调用的时候)
Alt+Shift+F 把Class中的local变量变为field变量 (比较实用的功能)
Alt+Shift+I 合并变量(可能这样说有点不妥Inline)
Alt+Shift+V 移动函数和变量(不怎么常用)
Alt+Shift+Z 重构的后悔药(Undo)
Ctrl + Z 返回到修改前的状态(编写代码时的后悔药)
Ctrl + Y 与上面的操作相反 (即刚后悔完又后悔)
Shift + / 自动导入类包 (在你写好的类名的右边用这个可导入包)
Ctrl + Shif + / 自动注释代码
Ctrl + Shif + \自动取消已经注释的代码
Ctrl + Shif +O 自动引导类包
模版的作用:
创建模版:
7.在eclipse中导入已有的工程

导入导出内容还没来得及截图(回头单独写个贴)
8.java5的静态导入与编译器语法设置
import语句可以导入一个类或某个包中的所有类
import static语句导入一个类中的某个静态方法或所有静态方法
语法举例:
import static java.lang.Math.sin;
import static java.lang.Math.*;
9.可变参数与OverLoad相关面试题分析
问题:一个方法接受的参数个数不固定,例如:
System.out.println(countScore(2,3,5));
System.out.println(countScore(1,2,3,5));        
可变参数的特点:
只能出现在参数列表的最后;这个要记住
...位于变量类型和变量名之间,前后有无空格都可以;
调用可变参数的方法时,编译器为该可变参数隐含创建一个数组,在方法体中以数组的形式访问可变参数。
举例代码:public static void main(String[] args) {
System.out.println(add(1,2,3,5));
System.out.println(add(2,3,5));               
}
public static int add(int x,int ...args) {
int sum = x;
for(int i=0;i<args.length;i++) {
sum += args;
}
                return sum; }
下面的朋友提出一个非常好的建议,就是我把我的总结的内容打包放了上来,希望大家多多支持。

张孝祥老师的java高新技术的视频总结.rar

28.73 KB, 下载次数: 275

评分

参与人数 1技术分 +1 收起 理由
唐志兵 + 1 很给力!

查看全部评分

16 个回复

倒序浏览
10.java5的增加for循环
语法:
for ( type 变量名:集合变量名 )  { … }
注意事项:
迭代变量必须在( )中定义!
集合变量可以是数组或实现了Iterable接口的集合类
举例:
        public static int add(int x,int ...args) {
                int sum = x;
                for(int arg:args) {
                        sum += arg;
                }
                return sum;
        }

11.基本数据的自动拆装箱及享元设计模式
自动装箱:
Integer num1 = 12;
自动拆箱:
System.out.println(num1 + 12);
基本数据类型的对象缓存:
Integer num1 = 12;
Integer num2 = 12;                这块相等,<=127都是真的
System.out.println(num1 == num2);

Integer num3 = 129;                这块不相等,因为是对象
Integer num4 = 129;
System.out.println(num3 == num4);

Integer num5 = Integer.valueOf(12);
Integer num6 = Integer.valueOf(12)  ;   这块的道理同上
System.out.println(num5 == num6);
12.枚举的作用介绍
为什么要有枚举
问题:要定义星期几或性别的变量,该怎么定义?假设用1-7分别表示星期一到星期日,但有人可能会写成int weekday = 0;或即使使用常量方式也无法阻止意外。
枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个,否则,编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值,普通变量的方式在开发阶段无法实现这一目标。
用普通类如何实现枚举功能,定义一个Weekday的类来模拟枚举功能。
私有的构造方法
每个元素分别用一个公有的静态成员变量表示
可以有若干公有方法或抽象方法。采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类。
枚举的基本应用
举例:定义一个Weekday的枚举。
扩展:枚举类的values,valueOf,name,toString,ordinal等方法(记住,讲课时要先于自定义方法前介绍,讲课更流畅)
总结:枚举是一种特殊的类,其中的每个元素都是该类的一个实例对象,例如可以调用WeekDay.SUN.getClass().getName和WeekDay.class.getName()。
13.用普通类模拟枚举的实现原理
枚举就相当于一个类,其中也可以定义构造方法、成员变量、普通方法和抽象方法。
枚举元素必须位于枚举体中的最开始部分,枚举元素列表的后要有分号与其他成员分隔。把枚举中的成员方法或变量等放在枚举元素的前面,编译器报告错误。
带构造方法的枚举
构造方法必须定义成私有的
如果有多个构造方法,该如何选择哪个构造方法?
枚举元素MON和MON()的效果一样,都是调用默认的构造方法。
带方法的枚举
定义枚举TrafficLamp
实现普通的next方法
实现抽象的next方法:每个元素分别是由枚举类的子类来生成的实例对象,这些子类采用类似内部类的方式进行定义。
增加上表示时间的构造方法
枚举只有一个成员时,就可以作为一种单例的实现方式。
14.java5的枚举的基本应用
我们可用类来模拟枚举功能,有以下几点注意:
1私有的构造方法,
2每个元素分别用一个公有的静态成员变量表示;
3可以有若干公有方法或抽象方法,例如,要提供nextDay()方法必须是抽象的
枚举的基本应用,枚举类的values,valueof,name,toString,ordinal等方法。
枚举是一种特殊的类,其中的每个元素都是该类的一个实例对象,例如可以调用WeekDay.SUN,getClass(),getName和WeekDay.class,getName();采用抽象方法定义nextDay()就将大量的if…else…语句转移成了一个个独立的类。如果想在一个类中编写完各个枚举和测试调用类,那么可以将枚举定义成调用类的内部类。
例如:
public enum WeekDay{/////////////枚举的定义
       SUN,MON,THU,WED,THI,FRI,SAT//有无;均可
    }
public static void main(String[] args) {
       WeekDay weekDay2=WeekDay.FRI;//WeekDay就相当于一个类了,
       System.out.println(weekDay2);//利用.来调用里面的对象
       System.out.println(weekDay2.ordinal());//排序从0开始
       System.out.println(WeekDay.valueOf("SUN"));//利用枚举来调用静态方法
       System.out.println(WeekDay.values().length);//values()就是所有元素组成的数组
    }

15.实现带有构造方法的枚举
带构造函数的枚举的应用,仍以WeekDay为例:
public enum WeekDay{/////////////枚举的定义
       SUN(1),MON(),THU(1,2),WED,THI,FRI,SAT;//有无;均可
       private WeekDay(){/////////后面定义了构造函数后,枚举对象后必要有;
           System.out.println("first");//在使用类时,在第一处就要调用构造函数进行初始化
       }
       private WeekDay(int x){
           System.out.println("second");//对对象的初始化,在选择构造函数时要根据对象后面的参数形式
       }
        private WeekDay(int x,int y){
           System.out.println("third");
       }
      
    }

public static void main(String[] args) {
       WeekDay weekDay2=WeekDay.FRI;//WeekDay就相当于一个类了,
       System.out.println(weekDay2);//利用.来调用里面的对象
       System.out.println(weekDay2.ordinal());//排序从0开始
       System.out.println(WeekDay.valueOf("SUN"));//利用枚举来调用静态方法
       System.out.println(WeekDay.values().length);//values()就是所有元素组成的数组
    }

16.实现带有抽象方法的枚举
带有抽象方法的枚举应用,以TraficLamp为例:
public enum TraficLamp{
       RED(30){
           public TraficLamp nextLamp(){
              return GREEN;
           }  
       },
       GREEN(40){
           public TraficLamp nextLamp(){
                  return YELLOW;
              }     
       },
       YELLOW(5){
           public TraficLamp nextLamp(){
                  return RED;
              }     
       };
       public abstract TraficLamp nextLamp();
       private int time;
       private TraficLamp(int time){
           this.time=time;
       }
  }
17.透彻分析反射的基础_Class类
对比提问: Person类代表人,它的实例对象就是张三,李四这样一个个具体的人, Java程序中的各个Java类属于同一类事物,描述这类事物的Java类名就是Class。对比提问:众多的人用一个什么类表示?众多的Java类用一个什么类表示?
人Person
Java类Class
Class类代表Java类,它的各个实例对象又分别对应什么呢?
对应各个类在内存中的字节码,例如,Person类的字节码,ArrayList类的字节码,等等。
一个类被类加载器加载到内存中,占用一片存储空间,这个空间里面的内容就是类的字节码,不同的类的字节码是不同的,所以它们在内存中的内容是不同的,这一个个的空间可分别用一个个的对象来表示,这些对象显然具有相同的类型,这个类型是什么呢?
如何得到各个字节码对应的实例对象( Class类型)
类名.class,例如,System.class
对象.getClass(),例如,new Date().getClass()
Class.forName("类名"),例如,Class.forName("java.util.Date");
九个预定义Class实例对象:
参看Class.isPrimitive方法的帮助
Int.class == Integer.TYPE
数组类型的Class实例对象
Class.isArray()
总之,只要是在源程序中出现的类型,都有各自的Class实例对象,例如,int[],void…

18.理解反射的概念
反射就是把Java类中的各种成分映射成相应的java类。例如,一个Java类中用一个Class类的对象来表示,一个类中的组成部分:成员变量,方法,构造方法,包等等信息也用一个个的Java类来表示,就像汽车是一个类,汽车中的发动机,变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法,来获得其中的变量,方法,构造方法,修饰符,包等信息,这些信息就是用相应类的实例对象来表示,它们是Field、Method、Contructor、Package等等。
一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示,通过调用Class类的方法可以得到这些实例对象后,得到这些实例对象后有什么用呢?怎么用呢?这正是学习和应用反射的要点。
19.构造方法的反射应用
Constructor类代表某个类中的一个构造方法
得到某个类所有的构造方法:
例子:Constructor [] constructors= Class.forName("java.lang.String").getConstructors();
得到某一个构造方法:
例子:             Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);
        //获得方法时要用到类型
创建实例对象:
通常方式:String str = new String(new StringBuffer("abc"));
反射方式: String str = (String)constructor.newInstance(new StringBuffer("abc"));
        //调用获得的方法时要用到上面相同类型的实例对象
Class.newInstance()方法:
例子:String obj = (String)Class.forName("java.lang.String").newInstance();
该方法内部先得到默认的构造方法,然后用该构造方法创建实例对象。
该方法内部的具体代码是怎样写的呢?用到了缓存机制来保存默认构造方法的实例对象。
回复 使用道具 举报
20.成员变量的反射
Field类代表某个类中的一个成员变量
演示用eclipse自动生成Java类的构造方法
问题:得到的Field对象是对应到类上面的成员变量,还是对应到对象上的成员变量?类只有一个,而该类的实例对象有多个,如果是与对象关联,哪关联的是哪个对象呢?所以字段fieldX 代表的是x的定义,而不是具体的x变量。
示例代码:
        ReflectPoint point = new ReflectPoint(1,7);
        Field y = Class.forName("cn.itcast.corejava.ReflectPoint").getField("y");
        System.out.println(y.get(point));
        //Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getField("x");
        Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("x");
        x.setAccessible(true);
        System.out.println(x.get(point));

21.成员变量反射的综合案例
作业:将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"。

22.成员方法的反射
Method类代表某个类中的一个成员方法
得到类中的某一个方法:
例子:             Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class);
调用方法:
通常方式:System.out.println(str.charAt(1));
反射方式: System.out.println(charAt.invoke(str, 1));
如果传递给Method对象的invoke()方法的第一个参数为null,这有着什么样的意义呢?说明该Method对象对应的是一个静态方法!
jdk1.4和jdk1.5的invoke方法的区别:
Jdk1.5:public Object invoke(Object obj,Object... args)
Jdk1.4:public Object invoke(Object obj,Object[] args),即按jdk1.4的语法,需要将一个数组作为参数传递给invoke方法时,数组中的每个元素分别对应被调用方法中的一个参数,所以,调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。

23.对接收数组参数的成员方法进行反射
目标:
写一个程序,这个程序能够根据用户提供的类名,去执行该类中的main方法。用普通方式调完后,大家要明白为什么要用反射方式去调啊?
问题:
启动Java程序的main方法的参数是一个字符串数组,即public static void main(String[] args),通过反射方式来调用这个main方法时,如何为invoke方法传递参数呢?按jdk1.5的语法,整个数组是一个参数,而按jdk1.4的语法,数组中的每个元素对应一个参数,当把一个字符串数组作为参数传递给invoke方法时,javac会到底按照哪种语法进行处理呢?jdk1.5肯定要兼容jdk1.4的语法,会按jdk1.4的语法进行处理,即把数组打散成为若干个单独的参数。所以,在给main方法传递参数时,不能使用代码mainMethod.invoke(null,new String[]{“xxx”}),javac只把它当作jdk1.4的语法进行理解,而不把它当作jdk1.5的语法解释,因此会出现参数类型不对的问题。
解决办法:
mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});
mainMethod.invoke(null,(Object)new String[]{"xxx"}); ,编译器会作特殊处理,编译时不把参数当作数组看待,也就不会数组打散成若干个参数了
24.数组与Object的关系及其反射类型
具有相同维数和元素类型的数组属于同一个类型,即具有相同的Class实例对象。
代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
基本类型的一维数组可以被当作Object类型使用,不能当作Object[]类型使用;非基本类型的一维数组,既可以当做Object类型使用,又可以当做Object[]类型使用。
Arrays.asList()方法处理int[]和String[]时的差异。
25.数组的反射应用
   Array工具类用于完成对数组的反射操作。
26.ArrayList_HashSet的比较及Hashcode分析
综合案例
先直接用new  语句创建ArrayList和HashSet的实例对象,演示用eclipse自动生成 ReflectPoint类的equals和hashcode方法,比较两个集合的运行结果差异。
然后改为采用配置文件加反射的方式创建ArrayList和HashSet的实例对象,比较观察运行结果差异。

27.框架的概念及用反射技术开发框架的原理
框架与框架要解决的核心问题
我做房子卖给用户住,由用户自己安装门窗和空调,我做的房子就是框架,用户需要使用我的框架,把门窗插入进我提供的框架中。框架与工具类有区别,工具类被用户的类调用,而框架则是调用用户提供的类。
框架要解决的核心问题
我在写框架(房子)时,你这个用户可能还在上小学,还不会写程序呢?我写的框架程序怎样能调用到你以后写的类(门窗)呢?
因为在写才程序时无法知道要被调用的类名,所以,在程序中无法直接new 某个类的实例对象了,而要用反射方式来做。

回复 使用道具 举报
28.用类加载器的方式管理资源和配置文件
引入了elipse对资源文件的管理方式的讲解。
29.由内省引出JavaBean的讲解
JavaBean是一种特殊的Java类,主要用于传递数据信息,这种java类中的方法主要用于访问私有的字段,且方法名符合某种命名规则。
如果要在两个模块之间传递多个信息,可以将这些信息封装到一个JavaBean中,这种JavaBean的实例对象通常称之为值对象(Value Object,简称VO)。这些信息在类中用私有字段来存储,如果读取或设置这些字段的值,则需要通过一些相应的方法来访问,大家觉得这些方法的名称叫什么好呢?JavaBean的属性是根据其中的setter和getter方法来确定的,而不是根据其中的成员变量。如果方法名为setId,中文意思即为设置id,至于你把它存到哪个变量上,用管吗?如果方法名为getId,中文意思即为获取id,至于你从哪个变量上取,用管吗?去掉set前缀,剩余部分就是属性名,如果剩余部分的第二个字母是小写的,则把剩余部分的首字母改成小的。
setId()的属性名id
isLast()的属性名last
setCPU的属性名是什么?CPU
getUPS的属性名是什么?UPS
总之,一个类被当作javaBean使用时,JavaBean的属性是根据方法名推断出来的,它根本看不到java类内部的成员变量。
一个符合JavaBean特点的类可以当作普通类一样进行使用,但把它当JavaBean用肯定需要带来一些额外的好处,我们才会去了解和应用JavaBean!好处如下:
在Java EE开发中,经常要使用到JavaBean。很多环境就要求按JavaBean方式进行操作,别人都这么用和要求这么做,那你就没什么挑选的余地!
JDK中提供了对JavaBean进行操作的一些API,这套API就称为内省。如果要你自己去通过getX方法来访问私有的x,怎么做,有一定难度吧?用内省这套api操作JavaBean比用普通类的方式更方便。
30.对JavaBean的简单内省操作
演示用eclipse自动生成 ReflectPoint类的setter和getter方法。
直接new一个PropertyDescriptor对象的方式来让大家了解JavaBean API的价值,先用一段代码读取JavaBean的属性,然后再用一段代码设置JavaBean的属性。
演示用eclipse将读取属性和设置属性的流水帐代码分别抽取成方法:
只要调用这个方法,并给这个方法传递了一个对象、属性名和设置值,它就能完成属性修改的功能。
得到BeanInfo最好采用“obj.getClass()”方式,而不要采用“类名.class”方式,这样程序更通用。
31.对JavaBean的复杂内省操作
采用遍历BeanInfo的所有属性方式来查找和设置某个RefectPoint对象的x属性。在程序中把一个类当作JavaBean来看,就是调用IntroSpector.getBeanInfo方法, 得到的BeanInfo对象封装了把这个类当作JavaBean看的结果信息。
32.使用BeanUtils工具包操作JavaBean
演示用eclipse如何加入jar包,先只是引入beanutils包,等程序运行出错后再引入logging包。
在前面内省例子的基础上,用BeanUtils类先get原来设置好的属性,再将其set为一个新值。
get属性时返回的结果为字符串,set属性时可以接受任意类型的对象,通常使用字符串。
用PropertyUtils类先get原来设置好的属性,再将其set为一个新值。
get属性时返回的结果为该属性本来的类型,set属性时只接受该属性本来的类型。
演示去掉JavaBean(ReflectPoint)的public修饰符时,BeanUtils工具包访问javabean属性时出现的问题。

33.了解和入门注解的应用
先通过@SuppressWarnings的应用让大家认识和了解一下注解:
通过System.runFinalizersOnExit(true);的编译警告引出@SuppressWarnings("deprecation")
@Deprecated
直接在刚才的类中增加一个方法,并加上@Deprecated标注,在另外一个类中调用这个方法。
@Override
public boolean equals(Reflect other)方法与HashSet结合讲解
总结:
注解相当于一种标记,在程序中加了注解就等于为程序打上了某种标记,没加,则等于没有某种标记,以后,javac编译器,开发工具和其他程序可以用反射来了解你的类及各种元素上有无何种标记,看你有什么标记,就去干相应的事。标记可以加在包,类,字段,方法,方法的参数以及局部变量上。
看java.lang包,可看到JDK中提供的最基本的annotation。
34.注解的定义与反射调用
注解类
@interface A
{
}
应用了“注解类”的类
@A
Class B{
}
对“应用了注解类的类”进行反射操作的类
Class C {
  B.class.isAnnotionPresent(A.class);
  A a = B.class.getAnnotion( A.class);}
35.为注解增加各种属性
什么是注解的属性
一个注解相当于一个胸牌,如果你胸前贴了胸牌,就是传智播客的学生,否则,就不是。如果还想区分出是传智播客哪个班的学生,这时候可以为胸牌在增加一个属性来进行区分。加了属性的标记效果为:@MyAnnotation(color="red")
定义基本类型的属性和应用属性:
在注解类中增加String color();
@MyAnnotation(color="red")
用反射方式获得注解对应的实例对象后,再通过该对象调用属性对应的方法
MyAnnotation a = (MyAnnotation)AnnotationTest.class.getAnnotation(MyAnnotation.class);
System.out.println(a.color());
可以认为上面这个@MyAnnotation是MyAnnotaion类的一个实例对象
为属性指定缺省值:
String color() default "yellow";
value属性:
String value() default "zxx";
如果注解中有一个名称为value的属性,且你只想设置value属性(即其他属性都采用默认值或者你只有一个value属性),那么可以省略value=部分,例如:@MyAnnotation("lhm")。
36.入门泛型的基本应用
Jdk 1.5以前的集合类中存在什么问题
        ArrayList collection = new ArrayList();
        collection.add(1);
        collection.add(1L);
        collection.add("abc");
        int i = (Integer) collection.get(1);//编译要强制类型转换且运行时出错!
Jdk 1.5的集合类希望你在定义集合时,明确表示你要向集合中装哪种类型的数据,无法加入指定类型以外的数据
ArrayList<Integer> collection2 = new ArrayList<Integer>();
collection2.add(1);
/*collection2.add(1L);
collection2.add(“abc”);*///这两行代码编译时就报告了语法错误
int i2 = collection2.get(0);//不需要再进行类型转换
泛型是提供给javac编译器使用的,可以限定集合中的输入类型,让编译器挡住源程序中的非法输入,编译器编译带类型说明的集合时会去除掉“类型”信息,使程序运行效率不受影响,对于参数化的泛型类型,getClass()方法的返回值和原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息,只要能跳过编译器,就可以往某个泛型集合中加入其它类型的数据,例如,用反射得到集合,再调用其add方法即可。
回复 使用道具 举报
37.泛型的内部原理及更深应用
ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语:
整个称为ArrayList<E>泛型类型
ArrayList<E>中的E称为类型变量或类型参数
整个ArrayList<Integer>称为参数化的类型
ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数
ArrayList<Integer>中的<>念着typeof
ArrayList称为原始类型
参数化类型与原始类型的兼容性:
参数化类型可以引用一个原始类型的对象,编译报告警告,例如,Collection<String> c = new Vector();//可不可以,不就是编译器一句话的事吗?
原始类型可以引用一个参数化类型的对象,编译报告警告,例如,Collection c = new Vector<String>();//原来的方法接受一个集合参数,新的类型也要能传进去
参数化类型不考虑类型参数的继承关系:
Vector<String> v = new Vector<Object>(); //错误!///不写<Object>没错,写了就是明知故犯
Vector<Object> v = new Vector<String>(); //也错误!
编译器不允许创建泛型变量的数组。即在创建数组实例时,数组的元素不能使用参数化的类型,例如,下面语句有错误:
        Vector<Integer> vectorList[] = new Vector<Integer>[10];
思考题:下面的代码会报错误吗?
Vector v1 = new Vector<String>();
Vector<Object> v = v1;
38.泛型的通配符扩展应用
问题:
定义一个方法,该方法用于打印出任意参数化类型的集合中的所有数据,该方法如何定义呢?
错误方式:
public static void printCollection(Collection<Object> cols) {
                for(Object obj:cols) {
                        System.out.println(obj);
                }
                /* cols.add("string");//没错
                 cols = new HashSet<Date>();//会报告错误!*/
}
正确方式:
public static void printCollection(Collection<?> cols) {
                for(Object obj:cols) {
                        System.out.println(obj);
                }
                //cols.add("string");//错误,因为它不知自己未来匹配就一定是String
                cols.size();//没错,此方法与类型参数没有关系
                 cols = new HashSet<Date>();
        }
总结:
使用?通配符可以引用其他各种参数化的类型,?通配符定义的变量主要用作引用,可以调用与参数化无关的方法,不能调用与参数化有关的方法。
限定通配符的上边界:
正确:Vector<? extends Number> x = new Vector<Integer>();
错误:Vector<? extends Number> x = new Vector<String>();
限定通配符的下边界:
正确:Vector<? super Integer> x = new Vector<Number>();
错误:Vector<? super Integer> x = new Vector<Byte>();
提示:限定通配符总是包括自己。
?只能用作引用,不能用它去给其他变量赋值
Vector<? extends Number> y = new Vector<Integer>();
Vector<Number> x = y;
上面的代码错误,原理与Vector<Object > x11 = new Vector<String>();相似,只能通过强制类型转换方式来赋值。
39.泛型集合的综合应用案例
能写出下面的代码即代表掌握了Java的泛型集合类:
HashMap<String,Integer> hm = new HashMap<String,Integer>();
  hm.put("zxx",19);
  hm.put("lis",18);
  
  Set<Map.Entry<String,Integer>> mes= hm.entrySet();
  for(Map.Entry<String,Integer> me : mes) {
   System.out.println(me.getKey() + ":" + me.getValue());
  }
对在jsp页面中也经常要对Set或Map集合进行迭代:
<c:forEach items=“${map}” var=“entry”>
        ${entry.key}:${entry.value}
</c:forEach>
40.自定义泛型方法及其应用
Java的泛型方法没有C++模板函数功能强大,java中的如下代码无法通过编译:
<T> T add(T x,T y) {
                return (T) (x+y);
                //return null;
        }
用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和在方法的返回类型之前,也就是紧邻返回值之前。按照惯例,类型参数通常用单个大写字母表示。
交换数组中的两个元素的位置的泛型方法语法定义如下:
static <E> void swap(E[] a, int i, int j) {
        E t = a[i];
        a[i] = a[j];
        a[j] = t;
}//或用一个面试题讲:把一个数组中的元素的顺序颠倒一下
只有引用类型才能作为泛型方法的实际参数,swap(new int[3],3,5);语句会报告编译错误。
除了在应用泛型时可以使用extends限定符,在定义泛型时也可以使用extends限定符,例如,Class.getAnnotation()方法的定义。并且可以用&来指定多个边界,如<V extends Serializable & cloneable> void method(){}
普通方法、构造方法和静态方法中都可以使用泛型。
也可以用类型变量表示异常,称为参数化的异常,可以用于方法的throws列表中,但是不能用于catch子句中。
在泛型中可以同时有多个类型参数,在定义它们的尖括号中用逗号分,例如:
public static <K,V> V getValue(K key) { return map.get(key);}

41.自定义泛型方法的练习与类型推断总结
编写一个泛型方法,自动将Object类型的对象转换成其他类型。
定义一个方法,可以将任意类型的数组中的所有元素填充为相应类型的某个对象。
采用自定泛型方法的方式打印出任意参数化类型的集合中的所有内容。
在这种情况下,前面的通配符方案要比范型方法更有效,当一个类型变量用来表达两个参数之间或者参数和返回值之间的关系时,即同一个类型变量在方法签名的两处被使用,或者类型变量在方法体代码中也被使用而不是仅在签名的时候使用,才需要使用范型方法。
定义一个方法,把任意参数类型的集合中的数据安全地复制到相应类型的数组中。
定义一个方法,把任意参数类型的一个数组中的数据安全地复制到相应类型的另一个数组中。
编译器判断范型方法的实际类型参数的过程称为类型推断,类型推断是相对于知觉推断的,其实现方法是一种非常复杂的过程。
根据调用泛型方法时实际传递的参数类型或返回值的类型来推断,具体规则如下:
当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了,那么根据调用方法时该处的实际应用类型来确定,这很容易凭着感觉推断出来,即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型,例如:
         swap(new String[3],3,4)       static <E> void swap(E[] a, int i, int j)
当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了,如果调用方法时这多处的实际应用类型都对应同一种类型来确定,这很容易凭着感觉推断出来,例如:
         add(3,5)    static <T> T add(T a, T b)
当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了,如果调用方法时这多处的实际应用类型对应到了不同的类型,且没有使用返回值,这时候取多个参数中的最大交集类型,例如,下面语句实际对应的类型就是Number了,编译没问题,只是运行时出问题:
         fill(new Integer[3],3.5f)    static <T> void fill(T[] a, T v)
当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了,如果调用方法时这多处的实际应用类型对应到了不同的类型, 并且使用返回值,这时候优先考虑返回值的类型,例如,下面语句实际对应的类型就是Integer了,编译将报告错误,将变量x的类型改为float,对比eclipse报告的错误提示,接着再将变量x类型改为Number,则没有了错误:
         int x =(3,3.5f)    static <T> T add(T a, T b)
参数类型的类型推断具有传递性,下面第一种情况推断实际参数类型为Object,编译没有问题,而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型,编译将出现问题:
        copy(new Integer[5],new String[5])  static <T> void copy(T[] a,T[]  b);
        copy(new Vector<String>(), new Integer[5])  static <T> void copy(Collection<T> a , T[] b);

回复 使用道具 举报
42.自定义泛型类的应用
如果类的实例对象中的多处都要用到同一个泛型参数,即这些地方引用的泛型类型要保持同一个实际类型时,这时候就要采用泛型类型的方式进行定义,也就是类级别的泛型,语法格式如下:
        public class GenericDao<T> {
                private T field1;
                public void save(T obj){}
                public T getById(int id){}
        }
类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的,例如,如下两种方式都可以:
GenericDao<String> dao = null;
new genericDao<String>();
注意:
在对泛型类型进行参数化时,类型参数的实例必须是引用类型,不能是基本类型。
当一个变量被声明为泛型时,只能被实例变量、方法和内部类调用,而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的,所以静态成员不应该有类级别的类型参数。
问题:类中只有一个方法需要使用泛型,是使用类级别的泛型,还是使用方法级别的泛型?
43.通过反射获得泛型的实际类型参数
示例代码:
        Class GenericalReflection {
                  private Vector<Date> dates = new Vector<Date>();
                  public void setDates(Vector<Date> dates) {
                    this.dates = dates;
                  }
                  public static void main(String[] args) {
                   Method methodApply = GenericalReflection.class.getDeclaredMethod("applyGeneric", Vector.class);
                   ParameterizedType pType = (ParameterizedType)
                                    (methodApply .getGenericParameterTypes())[0];
                            System.out.println("setDates("
                                    + ((Class) pType.getRawType()).getName() + "<"
                                    + ((Class) (pType.getActualTypeArguments()[0])).getName()
                                    + ">)" );
                  }
        }

泛型DAO的应用:
public abstract class DaoBaseImpl<T> implements DaoBase<T> {
        protected Class<T> clazz;
        public DaoBaseImpl() {
                Type type = this.getClass().getGenericSuperclass();
                ParameterizedType pt = (ParameterizedType) type;
                this.clazz = (Class) pt.getActualTypeArguments()[0];
                System.out.println("clazz = " + this.clazz);
        }
        }
public class ArticleDaoImpl extends DaoBaseImpl<Article> implements ArticleDao {
        }

44.类加载器及其委托机制的深入分析
简要介绍什么是类加载器和类加载器的作用
Java虚拟机中可以安装多个类加载器,系统默认三个主要类加载器,每个类负责加载特定位置的类:BootStrap,ExtClassLoader,AppClassLoader
类加载器也是Java类,因为其他是java类的类加载器本身也要被类加载器加载,显然必须有第一个类加载器不是不是java类,这正是BootStrap。
Java虚拟机中的所有类装载器采用具有父子关系的树形结构进行组织,在实例化每个类装载器对象时,需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载。
当Java虚拟机要加载一个类时,到底派出哪个类加载器去加载呢?
首先当前线程的类加载器去加载线程中的第一个类。
如果类A中引用了类B,Java虚拟机将使用加载类A的类装载器来加载类B。
还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。
每个类加载器加载类时,又先委托给其上级类加载器。
当所有祖宗类加载器没有加载到类,回到发起者类加载器,还加载不了,则抛ClassNotFoundException,不是再去找发起者类加载器的儿子,因为没有getChild方法,即使有,那有多个儿子,找哪一个呢?
对着类加载器的层次结构图和委托加载原理,解释先前将ClassLoaderTest输出成jre/lib/ext目录下的itcast.jar包中后,运行结果为ExtClassLoader的原因。
自定义类加载器的编写原理分析
知识讲解:
自定义的类加载器的必须继承ClassLoader
loadClass方法与findClass方法
defineClass方法

46.编写对class文件进行加密的工具类
编程步骤:
编写一个对文件内容进行简单加密的程序。
编写了一个自己的类装载器,可实现对加密过的类进行装载和解密。
编写一个程序调用类加载器加载类,在源程序中不能用该类名定义引用变量,因为编译器无法识别这个类。程序中可以除了使用ClassLoader.load方法之外,还可以使用设置线程的上下文类加载器或者系统类加载器,然后再使用Class.forName。
实验步骤:
对不带包名的class文件进行加密,加密结果存放到另外一个目录,例如: java MyClassLoader MyTest.class F:\itcast
运行加载类的程序,结果能够被正常加载,但打印出来的类装载器名称为AppClassLoader:java MyClassLoader MyTest F:\itcast
用加密后的类文件替换CLASSPATH环境下的类文件,再执行上一步操作就出问题了,错误说明是AppClassLoader类装载器装载失败。
删除CLASSPATH环境下的类文件,再执行上一步操作就没问题了。

47.编写和测试自己编写的解密类加载器

48.类加载器的一个高级问题的实验分析
编写一个能打印出自己的类加载器名称和当前类加载器的父子结构关系链的MyServlet,正常发布后,看到打印结果为WebAppClassloader。
把MyServlet.class文件打jar包,放到ext目录中,重启tomcat,发现找不到HttpServlet的错误。
把servlet.jar也放到ext目录中,问题解决了,打印的结果是ExtclassLoader 。
父级类加载器加载的类无法引用只能被子级类加载器加载的类,原理如下图:
回复 使用道具 举报
49.分析代理类的作用与原理及AOP概念
生活中的代理
武汉人从武汉的代理商手中买联想电脑和直接跑到北京传智播客旁边来找联想总部买电脑,你觉得最终的主体业务目标有什么区别吗?基本上一样吧,都解决了核心问题,但是,一点区别都没有吗?从代理商那里买真的一点好处都没有吗?
程序中的代理
要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能,例如,异常处理、日志、计算方法的运行时间、事务管理、等等,你准备如何做?
编写一个与目标类具有相同接口的代理类,代理类的每个方法调用目标类的相同方法,并在调用方法时加上系统功能的代码。 (参看下页的原理图)
如果采用工厂模式和配置文件的方式进行管理,则不需要修改客户端程序,在配置文件中配置是使用目标类、还是代理类,这样以后很容易切换,譬如,想要日志功能时就配置代理类,否则配置目标类,这样,增加系统功能很容易,以后运行一段时间后,又想去掉系统功能也很容易。
AOP概念
系统中存在交叉业务,一个交叉业务就是要切入到系统中的一个方面,如下所示:
                              安全       事务         日志
StudentService  ------|----------|------------|-------------
CourseService   ------|----------|------------|-------------
MiscService       ------|----------|------------|-------------
用具体的程序代码描述交叉业务:
method1         method2          method3
{                      {                       {
------------------------------------------------------切面
....            ....              ......
------------------------------------------------------切面
}                       }                       }
交叉业务的编程问题即为面向方面的编程(Aspect oriented program ,简称AOP),AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围,这与直接在方法中编写切面代码的运行效果是一样的,如下所示:
------------------------------------------------------切面
func1         func2            func3
{             {                {
....            ....              ......
}             }                }
------------------------------------------------------切面
使用代理技术正好可以解决这种问题,代理是实现AOP功能的核心和关键技术。
动态代理技术
要为系统中的各种接口的类增加代理功能,那将需要太多的代理类,全部采用静态代理方式,将是一件非常麻烦的事情!写成百上千个代理类,是不是太累!
JVM可以在运行期动态生成出类的字节码,这种动态生成的类往往被用作代理类,即动态代理类。
JVM生成的动态类必须实现一个或多个接口,所以,JVM生成的动态类只能用作具有相同接口的目标类的代理。
CGLIB库可以动态生成一个类的子类,一个类的子类也可以用作该类的代理,所以,如果要为一个没有实现接口的类生成动态代理类,那么可以使用CGLIB库。
代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外,还可以在代理方法中的如下四个位置加上系统功能代码:
1.在调用目标方法之前
2.在调用目标方法之后
3.在调用目标方法前后
4.在处理目标方法异常的catch块中

50.创建动态类及查看其方法列表信息
创建实现了Collection接口的动态类和查看其名称,分析Proxy.getProxyClass方法的各个参数。
编码列出动态类中的所有构造方法和参数签名
编码列出动态类中的所有方法和参数签名

51.创建动态类的实例对象及调用其方法
创建动态类的实例对象
用反射获得构造方法
编写一个最简单的InvocationHandler类
调用构造方法创建动态类的实例对象,并将编写的InvocationHandler类的实例对象传进去
打印创建的对象和调用对象的没有返回值的方法和getClass方法,演示调用其他有返回值的方法报告了异常。
将创建动态类的实例对象的代理改成匿名内部类的形式编写,锻炼大家习惯匿名内部类。

52.完成InvocationHandler对象的内部功能
总结思考:让jvm创建动态类及其实例对象,需要给它提供哪些信息?
三个方面:
生成的类中有哪些方法,通过让其实现哪些接口的方式进行告知;
产生的类字节码必须有个一个关联的类加载器对象;
生成的类中的方法的代码是怎样的,也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中,把对象传给它,它调用我的方法,即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象,它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码,就可以看到这些代码被调用运行了。
用Proxy.newInstance方法直接一步就创建出代理对象。

53.分析InvocationHandler对象的运行原理
动态生成的类实现了Collection接口(可以实现若干接口),生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。
构造方法接受一个InvocationHandler对象,接受对象了要干什么用呢?该方法内部的代码会是怎样的呢?
实现Collection接口的动态类中的各个方法的代码又是怎样的呢?InvocationHandler接口中定义的invoke方法接受的三个参数又是什么意思?
Client程序调用objProxy.add(“abc”)方法时,涉及三要素:objProxy对象、add方法、“abc”参数

Class Proxy$ {
        add(Object object) {
return handler.invoke(Object proxy, Method method, Object[] args);
        }
}
分析先前打印动态类的实例对象时,结果为什么会是null呢?调用有基本类型返回值的方法时为什么会出现NullPointerException异常?
分析为什么动态类的实例对象的getClass()方法返回了正确结果呢?
调用调用代理对象的从Object类继承的hashCode, equals, 或toString这几个方法时,代理对象将调用请求转发给InvocationHandler对象,对于其他方法,则不转发调用请求。
54.总结分析动态代理类的设计原理与结构
分析动态代理的工作原理图(见下页)
怎样将目标类传进去?
直接在InvocationHandler实现类中创建目标类的实例对象,可以看运行效果和加入日志代码,但没有实际意义。
为InvocationHandler实现类注入目标类的实例对象,不能采用匿名内部类的形式了。
让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量。
将创建代理的过程改为一种更优雅的方式,eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象,让调用者更懒惰,更方便,调用者甚至不用接触任何代理的API。
将系统功能代码模块化,即将切面代码也改为通过参数形式提供,怎样把要执行的系统功能代码以参数形式提供?
把要执行的代码装到一个对象的某个方法里,然后把这个对象作为参数传递,接收者只要调用这个对象的方法,即等于执行了外界提供的代码!
为bind方法增加一个Advice参数。

55.编写可生成代理和插入通告的通用方法

56.实现类似spring的可配置的AOP框架
工厂类BeanFactory负责创建目标类或代理类的实例对象,并通过配置文件实现切换。其getBean方法根据参数字符串返回一个相应的实例对象,如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean,则直接返回该类的实例对象,否则,返回该类实例对象的getProxy方法返回的对象。
BeanFactory的构造方法接收代表配置文件的输入流对象,配置文件格式如下:
        #xxx=java.util.ArrayList
        xxx=cn.itcast.ProxyFactoryBean
        xxx.target=java.util.ArrayList
        xxx.advice=cn.itcast.MyAdvice
ProxyFacotryBean充当封装生成动态代理的工厂,需要为工厂类提供哪些配置参数信息?
目标
通知
编写客户端应用:
编写实现Advice接口的类和在配置文件中进行配置
调用BeanFactory获取对象
回复 使用道具 举报
内容太多了,有些粗糙不过贴出来就是让大家给提些建议,我的摘要的内容肯定有一些不对的希望大家给找出来我好及时改正。同时也希望能帮助到一些朋友。
回复 使用道具 举报
你把这些打包成附件,。rar文件,我们下载下来来看  更好一些
回复 使用道具 举报
杨千里 发表于 2012-9-8 15:43
你把这些打包成附件,。rar文件,我们下载下来来看  更好一些

谢谢您的建议,整理一下就发上来。我怎么就这么笨呢,真没想到发文件包。唉!还好有你急时提醒
回复 使用道具 举报
呵呵 呀我还说呢,这个就要压缩包了,谢谢上面那个哥们。
回复 使用道具 举报
子龍 发表于 2012-9-14 08:48
呵呵 呀我还说呢,这个就要压缩包了,谢谢上面那个哥们。

嗯 不好意思, 有的弄了有的还没来的急发呢。
回复 使用道具 举报
王永杰 发表于 2012-9-14 16:29
嗯 不好意思, 有的弄了有的还没来的急发呢。

那也的支持你!!!
回复 使用道具 举报
子龍 发表于 2012-9-19 13:12
那也的支持你!!!

谢谢!别的我就不说什么了。
回复 使用道具 举报
你是对3套java编程思想的总结,非常突出,把rar down下来,很有用。
回复 使用道具 举报
学习一下,感谢分享!
回复 使用道具 举报
ucq 中级黑马 2014-2-27 21:07:55
17#
非常感谢,帮助很大
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马