今天我的就业班的生活开始啦~~~

今天是就业班的第一天，状态感觉还不错吧，听课的时候感觉脑袋清楚一点了，没有像在基础班那样的迷茫了，今天感觉很不错，加油啦~~~
上午讲了关于Eclipse的使用，工欲善其事，必先利其器。那就先回顾回顾一下Eclipse的工具使用情况吧。

1，快捷键

Alt+/：辅助功能，联想语块，内容辅助，自动导包
Ctrl+shift+上下键：复制单行或多行
Ctrl+shift+o：导入代码区中所有类或者接口
Ctrl+d:删除所选行
Ctrl+i:让光标到默认代码位置
Alt+上下键：移动一行代码
Ctrl+/：注释或取消单行注释
Ctrl+shift+/:对所选区域进行多行注释
Ctrl+shift+/:取消多行注释。只要将光标放在多行注释内即可
Ctrl+shift+f:格式化代码
Ctrl+m：将当前视窗最大化与原始状态切换
Ctrl+1：在选中的出错位置给出解决方案
f3：列出指定类或者方法的源码
f4：列出指定类的层次关系。打开层次视窗
f2：显示方法或者类的注释描述信息
Alt+shift+s:调出source菜单
Ctrl+shift+x：变成大写
Ctrl+shift+y：变成小写

2，Eclipse基本设置

window---preferences

3，外挂插件的步骤：

a，在Eclipse的目录下建立links目录
b，在links目录下，建立一个文件，内容为插件Eclipse目录的父目录；path=插件Eclipse目录的父目录 path=f://Eclipse//NLpack1-eclipse-SDK-3.2.1-win32
c，打开Eclipse进行验证

扩展：如果外挂多个插件，重复第二步骤，可配置多个连接文件。
通过Eclipse的目录的configuration/org.eclipse.update目录下的platform.xml文件可以看到配置的路径
将连接文件删除，即可卸载插件。
注意：如果执行eclipse.exe出现对话框提示jre or jdk无效
解决：配置一下path环境变量将jdk的目录下的bin目录配置其中。

4，在工程中导入jar包

两种方式：
a，右键项目--选择properties--Java build path--选择liberiers标签
add external jars--选择要导入的jar包即可
这样做有个问题就是如果jar的路径发生变化，项目就不能使用到这个jar包

b，在项目中建立一个lib目录，专门用于存放项目所使用的jar工具包，将要使用到的jar包复制粘贴进来，并在jar上点右键--选择builder path--add to build path，即可
这是jar包中的对象，就可以使用了
这样做的好处是项目移动，jar随项目移动

5，debug

通过加入端点可以让程序执行停止在端点位置上，通过debug as，运行调试程序，同时打开debug视图
f5：进到某一方法中
f6：执行下一步
f7：返回原被调试程序，没有进入任何方法内，f7不可以用
Ctrl+r：直接执行到指定的行位置进行调试
_

右边的Variables视窗
显示了运行时产生的对象，以及对象的属性和值。它的出现方便于对程序的调试。

6，JDK1.5之后出现的新特性
自动装箱，拆箱:

基本数据类型对象包装类。私有不是封装。
Integer a=123;//a=new Integer(123);装箱
a=a+4;//a.intvalue();拆箱//并装箱
需要注意的是：在使用时，Integer x=null;上面的代码就会出现NullPointerException
取值在一个字节范围之内不会开辟新的空间

细节1：
Integer x=new Integer(100);
Integer y=new Integer(100);
x==y?---->false
x.equals(y)?---->true

细节2：
Integer x=100;
Integer y=100;
x==y?---->true
x.equals(y)?---->true

静态导入：import static
JDK1.5版本的新特性
为了简化程序书写而出现
import的出现可以简化类名的书写
为了简化对静态的调用
新的导入方式：import static java.lang.System.*;
常用的工具类：Collections,Arrays（全是静态方法）
导入的是静态方法。
import导的是包中的类；import static导的是类中的方法

泛型：（Generic）
特点：提高程序的安全性；将运行期遇到的问题转移到了编译期；省去了类型强转的麻烦
      泛型类的出现优化了程序设计
泛型类的定义：当类中的成员使用的类型是同一种时，可以将类型定义在类上
泛型方法的定义：每个方法操作的类型不同时，将泛型单独定义在方法上（通常都是静态）
泛型就是在给类或者方法的<>中传递类型参数
什么时候使用泛型？当操作的引用数据类型不确定的时候，就使用泛型

泛型要注意的一些问题：
ArrayList<String> list=new ArrayList<Object>();

ArrayList<Object> list=new ArrayList<String>();

ArrayList<String> list=new ArrayList();

ArrayList list=new ArrayList<String>();

（使用泛型注意两边都要一致，不要考虑多态的问题了，但是后两个又可以了，据说这是高手和菜鸟的问题）

其实使用泛型时，如果两边都要指定类型，那类型就必须一致，也可以说只有一边指定类型，这种方法比较灵活。

public static void main(String[] args){
 int[] arr={1,2,3};
 chang(arr,0,2);

public void swap(T arr[],int i,int j)
{
 T temp=arr[i];
 arr[i]=arr[j];
 arr[j]=temp;
 //x y值交换，经典做法
 int x=0;
 int y=1;
 //第一种方法
 x=x^y;
 y=x^y;
 x=x^y;
 //第二种方法
 x=y-0*(y=x);
 }
}

//面试题
public static <T> void reverse(T arr[])
{
 int i=0;
 int j=arr.length-1;
 while(true){
 if(i>=j){
 break;
        }
 T temp=arr[i];
 arr[i]=arr[j];
 arr[j]=temp;
 i++;
 j--;
    }
}

for each语句：
Collection在JDK1.5后出现的父类接口Iterable就是提供了这个for语句
格式：
for（数据类型 变量名：数组或集合）
{
 执行语句；
}
简化了对数组，集合的遍历
遍历数组，取出元素，里面没有增量，必须有被遍历的目标（集合，数组）

函数的另一种表现形式：

返回值类型 函数名（参数类型... 形式参数）
{
 执行语句；
}
其实接收的是一个数组，可以指定实际参数个数
简化了程序的编写
注意：当有不同参数类型时，可变参数必须定义在最后一个参数位置上

反射：Reflect
动态获取类中的成员
如何获取类对象：
 对象.getClass();
 类名.class
 Class.forName("全类名");
获取到类文件对象就可以通过指挥对象的方法获取类文件的内容
对比以前：
Person p=new Person();
p.show();
反射机制：
Class clazz=Class.forName("Person");
Person p=(Person)clazz.newInstance();
p.show();//还可以获取方法对象
获取类中的方法：
Method[] getMethods();
Method getMethod(methodName,params);
获取类中的构造函数：
Constructor getConstructor(params);
反射的好处：增强了程序的扩展性，后期的可维护性
其实就是把Java类中的各种成分映射成一个个的Java对象，得到要反射的类的对象，有三种方式：比如反射student类name，age

1，得到student类的第一种方式
Class clazz=Student.class;启动类装载器，装载字节码
2,第二种方式
clazz=new Student().getClass();
3，第三种方式
clazz=Class.forName("cn.itcast.Student");
关于Java面向对象的思想，想想下面的问题：
关门，是人的方法，还是门的方法？
把人的心脏拿给医生做手术，这是谁的方法？
开电脑是谁的方法？

test1
反射无参的方法
//调用对象的方法，得到一个方法的对象
Method m=clazz.getMethod("方法名"，参数null);
//指定对象运动起来
m.invoke(new Student(),null);

test2
反射有参数方法
Class clazz=Class.forName();
Method m=class.getMethod("doaa",String.class);
m.invoke(new Student(),"bbb");

test3
多参 有返回值
Student s=new Student();
Class clazz=s.getClass();
Method m=clazz.getMethod("dobbb",String.class,List.class,int[].class);
Object o=m.invoke(s,"bbb",new ArrayList(),new int[1]);

test4
静态方法
Class clazz = Student.class;
Method m = clazz.getMethod("doccc",null);
m.invoke(null,null);

test5
私有方法
Class clazz = Student.class;
//Method m = clazz.getMethod("wc",null);
//m.invoke(new Student(),null);

//反射默认是拿不到私有成员的. 但是有一种除外哈哈
Method m = class.getDeclaredMethod("wc",null);

m.setAccessible(true);  这就是传说中的暴力反射

Class clazz = Student.class;
Method m = clazz.getMethod("main",String[]);
String str[] ={"ab","bb"};
m.invoke(null,(Object)str);  //JDK1.5中,如果是数组javac则会自动拆开,那么为了兼容1.4,

                              把数组强转成一个Object对象,就不会拆了
m.invoke(null,new Object[] {str});

                             //另外一种写法, 就是把数组封装在例外一个数组里面传进来 ,

                              拆开以后正好是数组

能看懂下面的意思么
main(String arg1,String arg2)

public (int i , int j)
      Method.invoke(Object,Object[] args) ;

      run.invoke(obj, new int[]{1,2})

===================
Demo3
test1
反射Student类的age字段
Class clazz = Student.class;
Student s  = new Student();

//通过反射设置属性值想想,在javabean中,什么事类的属性,又是由什么来决定的呢?
Field f = clazz.getField("age");

f.set(s,13);
System.out.println(s.age);

//通过反射设置属性值
Object obj = f.get(s);
System.out.println(s);

test2
//反射类的私有属性
Class clazz= Student.class;
//class.getField(name);

Field f = clazz.getDeclaredField("name");
f.setAccessible(true); //暴力破解私有属性,很多书中都写,私有属性是不能被外界所访问的,那么这种情况呢?

f.set(s,"zsf");

=============
Demo4

Person类 属性, 方法

tes1
反射类 反射类的构造方法的目的是为了创建类的对象
反射无参构造方法  Person(){}

Class clazz = Person.class;
Constructor c = clazz.getConstructor(null); //注意这里不是返回属性和方法类了

                                       而是返回了一个Constructor对象
Person p = c.newInstance(null);            //注意了返回一个Person对像
p.doxx();     //用得到的对象去调用类中的方法

但是Class类内部提供这样的方法,查API可以直到可以直接调用newInstance()方法

class类本身就代表某个类的字节码文件
Class clazz = Person.class
p =(Person)clazz.newInstance()  //因为直到反射类,直接强转了,如果不知道的情况下用

                            //Object obj = clazz.newInstance(); 比较方便
p.doxx();

 

test2

反射有参的构造方法 Person(String name){}
Class clazz = Person.class;
Constructor c = clazz.getConstrutor(String.class);
Person p  = c.newInstance("aaa");
p.doxx();

 

=========================
Demo5 看看框架是怎么反射的吧
config.properties //配置文件

FileInputStream in = new FileInputStream("src/config.properties");
Properties prop = new Properties();
prop.load(in);

String classname = prop.getProperty("classname");
String method = prop.getProperty("method");

//运行classname所对应的类的method方法
Class clazz = Class.forName(classname);
Object obj = clazz.newInstance();

Method m = clazz.getMethod(method,null);
m.invoke(obj,null);

 

不理解,就记住吧

字节码文件class只装载一次, 所以静态变量在class装载后就自动装载,且只装载一次
========================

Demo6

Class c1 = Class.forName("cn.itcast.reflect.Person");
Class c2 = Person.class;
Class c3 = new Person().getClass();
System.out.println(c1 == c2);  结果呢?

System.out.println(c2 == c3);  结果呢?

 

=====================
内省
Person类
1 JavaBean 作用就是封装对象

2 JavaBean 到底有什么属性,不是由字段决定的,而由拥有的setter或getter方法决定的
public class Person()
{
 private String name;//字段
 private String password;
 private int age;
 pulic String getName() //属性读取器
 {
     return name;
 }
 public void setName(String name)//属性获取修改器
 {
     this.name = name;
 }
}

===============================================
test1

通过传统方法访问Person类的属性

Person p = new Person();

p.set()..

p.get()..

通过内省(introspector)操作javabean  API : PropertyDescriptors属性描述器

PropertyDescriptor pd = new PropertyDescriptor("name",Person.class);
Method set=pd.getWriterMethod();
set.invoke(p,"aaa");

Method get=pd.getReadMethod();
get.invoke(p,null);

 

test2
BeanInfo info = Introspector.getBeanInfo(Person.class);
PropertyDescriptors pds[]=info.getPropertyDescriptors();

for(PropertyDescriptors pd: pds)
{
   System.out.println(pd.getName());
}

上面拿到的属性里面 还隐藏了一个class属性 为什么这么说呢  因为任何类都是object类的子类
而API中 object类本身就设计了getClass()方法, 而根据javabean中属性的定义,提供了getter方法就必然有这个属性

===================================
BeanUtils
导入jar包  需要日志记录包log4j.jar 和beanutils.jar , commons-logging.jar
Person p =new Person();
BeanUtils.setProperty(p,"name","aaa");       //虽然只支持8中基本数据类型的自动转换
BeanUtils.setProperty(p,"password","aaa");   //但是支持自定义转化器
BeanUtils.setProperty(p,"age","12");

不再提醒:

出现(NoClassDefFoundError)是因为没有导入相应的开发包

自定义转化器 实现方法 匿名内部类 new Converter() 必须实现Converter接口中的方法
ConvertUtils.regsiter(new Converter()

{
  public Object convert(Class arg0, Object arg1)  throws Exception
  {                 

   try 
   {
      DateFormat df =DateFormat.getDateInstance();
      Date date = df.parse(String arg1);      //arg1代表需要转换的数据
      reurn date;   //找到了就返回date
   }catch(ParseException e)
   {
      throw new RuntimeException(e);
   }
   return null;    //没找到 就返回null

 }, Date.class);

 

以上代码,是自定义转化器的实现代码 其实用下面这个BeanUtils API中已有的方法就可以解决(api中已有很多写好的方法了)

ConverUtils.register(new DateLocaleConverter(),Date.class);

 

=============================================================

//通过BeanUtils拷贝bean的属性
//假如客户端提交给服务器的数据

表单提交的 name password age birthday

开发一个bean对象 FormBean 封装提交过来的数据
除了set get方法,在写一个boolean validate方法

 

FormBean bean = new FormBean();
bean.set();
...
if(bean.validate()!=true)
BeanUtils.copyProperties(p ,bean); //拷贝到p  来自bean

====================================================
//首先来看枚举类

class  enumeration
{
 public static void main(String[] args)
 {
  System.out.println("Hello World!");

 public void
 if (grade.matches("[ABCDE]"))  注意这种写法
 {
  this.grade = grade;
  return
 }
 throw new RuntimeException("对不起,您传入的参数有误!!!")异常的问题,,就不用说了吧?

 }
}

class Grade //在jdk1.5以前.. 枚举类的写法是这样的
{
 //在设计grade类时,要保证别人只能拿到grade类的abcde这5个对象.
 private Grade(){};
 public final static Grade A= new Grade();
 public final static Grade B= new Grade();
 public final static Grade C= new Grade();
 public final static Grade D= new Grade();
 public final static Grade E= new Grade();
}

//枚举就是一个java类
enum Grade  //枚举的值还可以这么定义
{

 A(" 100-90"),B(" 89-80"),C(" 79-70"),D(" 69-60"),E(" 60-0");
}

 

class Student()
{
 private Grade grade;
 public void setGrade(String name)
 {
     this.name = name;
 }
 public void getGrade(String name)
 {
     return name;
 }
}

class enumeration2
{
  public static void main(String[] args)
  {
       System.out.println(Grade.A.getName());
       System.out.println(Grade.A.getInfo());
   }
}

enum Grade implements A
{
 //枚举也可以实现接口
 A("100-90"){
    public String getInfo()//匿名内部类的方式实现接口 五个对象 每个对象自己把方法实现了
   {
       return "优";
   }

}
 ,B("89-80"){

   public String getInfo()

   {

      return "良";

   }

},....... //看明白了么?  这是匿名的内部. 枚举也可以实现接口A,但是是采用的匿名内部类的方法

 

 

//Grade枚举类中自定义的构造方法
 private String name;
 Grade(String name)
 {
    this.name=name;
 }
}

//接口A

interface A
{
   public String getInfo();
}

 

怎么用单态设计模式设计一个类呢???  呵呵如果不会一定要记住啊
 1 构造函数私有化
 2 类自己创建一个实例对象 并使用static类型的变量
 3 定义一个静态方法,返回一个类的实例

class Xxx
{
 private Xxx(){ }
 private final static Xxx xx = new Xxx();
 public static Xxx getInstance()
 {
   return xx;
 }
}
定义一个枚举其实就是定义了一个类,其实枚举也是java中的类.这就是jdk1.5的特性
enum Xxx{
 xx;
}

//遍历枚举类的枚举值 枚举中的一个类
Grade[] gs = grade.values();
又是一个jdk1.5的特性加强的for循环注意:加强for循环只能用在数组和实现Iterator接口的集合类上

for(Grade g : gs)
{
  System.out.println(g);
}

枚举的原理是什么呢？
是一种引用数据类型，枚举中的每一个值都是一个实体，它的出现限定了数据的内容和范围。
每一个枚举都是Java.lang.Enum的子类
自定义枚举特有的方法：
values（）：获取枚举实例数组
valueOf(String name):通过名称获取枚举实例
枚举的构造函数：
不可以定义public修饰的构造函数
避免直接将枚举类型实例化
枚举类型的抽象方法覆盖
每一个枚举值都是一个枚举类型的实例对象
当一组常量，都可以用于特定数据类型，就使用枚举类型。如：星期，性别，月份等。

注解：
通过toString（）；equals（）；hashCode（）示例引出注解
通过示例发现，只有到了运行时才出现结果
加上注解，在编译时期出现提示
格式：
@interface注解名称
注解中没有构造函数
可以定义无参数，没有主体的函数
该函数可以作为注解应用时的属性
该函数支持的类型：8种基本数据类型，String，Class，enum。Annotation，数组
可以在函数后通过关键字default定义默认值
注解中的注解成为原注解
获取注解对象要通过反射的形式。

 

感觉在传智的每一天都很充实吧，我每天精力都挺充沛，呵呵，上课也不会偷偷睡觉了哦~~时间久了。我觉得上课真是件惬意的事情，觉得毕老师讲课讲得真好~~五一的时候反复的看之前我们上课毕老师的视频~~觉得之前一点都听不懂的东西，现在全都明白了，感觉真好~~~虽然只学了一个月，但是我还是决定来就业班了，加油啦~~