Java知识点

知识点

1.java包

java.lang  java.util  java.math  java.io  java.regex：包，包中的类java.lang.Math  java.math

Math(abs pow sqrt max min)

2.异常

异常定义，抛出异常的方法须要声明，而后在调用该方法时使用try-catch捕获异常。

在程序运行时违反java语义规则时的错误表示为异常，一类是java类库内置的语义检查（NPE）二类是java容许程序员扩展这种语义检查

 

异常两类：error、exception

 

异常，将可能出错的代码从正常代码中分离出来，便于维护和修改。

 

免检异常：数组访问，除法等没有放在try-catch语句中

必检异常：代码必须放到try-catch语句中，或再次抛出该异常

（免检或必检异常由引用部分决定，或程序员决定）

异常：定义，抛出，声明，捕获

 

定义：将上面的Exception改成Exception1

public void Exception1 extends Exception{

数据；

方法；

}

异常执行逻辑：

 

method3可能抛出Exception三、Exception二、Exception1

获取异常信息：

异常链：在catch中抛出异常

 

 

3.集合、线性表、栈、队列、树、图、堆：泛型

集合(Set、List、Map)、栈、队列使用线性表(数组、链表)来实现的

java集合框架

 

list与set的区别：set中不包含相同元素

 

LinkedHashSet可以维护被插入元素的顺序，即输出元素的顺序和输入元素的顺序相同。HashSet，不维护插入元素的顺序，但比LinkedHashSet高效。

 

ArrayList、LinkedList：一个是数组实现，一个是链表实现。LinkedList提供了从两端获取、插入和删除元素的方法。

 

向量类Vector，栈类Stack，堆栈队列推荐LinkedList

LinkedList也可作队列

映射：

 

 

 

 

4.nested-class和inner-class的区别：嵌套类和内部类的区别

class OuterClass {  

    ...  

    static class StaticNestedClass {  

        ...  

    }  

    class InnerClass {  

        ...  

    }  

}  

StaticNestedClass是嵌套类

InnerClass是内部类

/////////////

nested-class和inner-class都是外层类的成员变量。只不过一个是静态的，一个是非静态的。

所以，nested-class和inner-class均可以被声明private,public,protested或package

可是由静态和非静态的不一样可知：nested-class是和类相关的，而inner-class是和实例相关的。所以能够不实例化对象，就直接访问nested-class，而必须实例化类才能访问inner-class。而nested-class不能访问外层类的其余成员变量或方法，而inner-class则能够。

由于inner-class是非静态成员变量，所以inner-class中不能再定义静态变量或方法了。

：匿名内部类是否能够继承其它类?是否能够实现接口?

匿名内部类能够继承自其余类或接口。但在new Class(){}或new Interface(){}后不能再extends或implements

 

5.SSHeasyUI:forward、redirect

forward：URL->后台-> URL（浏览器中URL不变）

redirect：URL->后台->浏览器->URL（浏览器中URL要变）

 

6.进程、线程：多线程并行执行

：进程和线程的区别——线程是指进程内的一个执行单元,也是进程内的可调度实体。

(2)并发性：不只进程之间能够并发执行，同一个进程的多个线程之间也可并发执行。

(1)调度：线程做为调度和分配的基本单位，进程做为拥有资源的基本单位。

(3)拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但能够访问隶属于进程的资源.

(4)系统开销：在建立或销毁进程时，因为系统都要为之分配和回收资源，致使系统的开销明显大于建立或销毁线程时的开销。

：进程间的通信方式及优缺点——

1）管道：数据只能单向流动，并且只能在具备亲缘关系的进程之间使用。进程的亲缘关系一般是指父子进程关系。在同一台电脑中。

2）命名（有名）管道（FIFO，队列管道）：命名管道不只可在同一台计算机的不一样进程之间传输数据，甚至能在跨越一个网络的不一样计算机的不一样进程之间，支持可靠的、单向或双向的数据通讯

6）共享内存( shared memory ) ：共享内存就是分配一块能被其余进程访问的内存。共享内存能够说是最有用的进程间通讯方式，也是最快的IPC形式。首先说下在使用共享内存区前，必须经过系统函数将其附加到进程的地址空间或说为映射到进程空间。两个不一样进程A、B共享内存的意思是，同一块物理内存被映射到 进程A、B各自的进程地址空间。进程A能够即时看到进程B对共享内存中数据的更新，反之亦然。因为多个进程共享同一块内存区域，必然须要某种同步机制，互 斥锁和信号量均可以。采用共享内存通讯的一个显而易 见的好处是效率高，由于进程能够直接读写内存，而不须要任何数据的拷贝。对于像管道和消息队列等通讯方式，则须要在内核和用户空间进行四次的数据拷贝，而 共享内存则只拷贝两次数据[1]：一次从输入文件到共享内存区，另外一次从共享内存区到输出文件。实际上，进程之间在共享内存时，并不老是读写少许数据后就 解除映射，有新的通讯时，再从新创建共享内存区域。而是保持共享区域，直到通讯完毕为止，这样，数据内容一直保存在共享内存中，并无写回文件。共享内存 中的内容每每是在解除映射时才写回文件的。所以，采用共享内存的通讯方式效率是很是高的。

3）信号量：信号量是一个计数器，能够用来控制多个进程对共享资源的访问。它常做为一种锁机制，防止某进程正在访问共享资源时，其余进程也访问该资源。所以，主要做为进程间以及同一进程内不一样线程之间的同步手段。临界资源：为某一时刻只能由一个进程或线程操做的资源，当信号量的值大于或等于0时，表示能够供并发进程访问的临界资源数，当小于0时，表示正在等待使用临界资源的进程数。更重要的是，信号量的值仅能由PV操做来改变。

4）消息队列：消息队列是有消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。

5）信号 ( sinal ) ：信号是在软件层次上对中断机制的一种模拟，在原理上，一个进程收到一个信号与处理器收到一个中断请求能够说是同样的。信号是异步的，一个进程没必要经过任何操做来等待信号的到达，事实上，进程也不知道信号到底何时到达。信号是进程间通讯机制中惟一的异步通讯机制，能够看做是异步通知，通知接收信号的进程有哪些事情发生了。信号机制通过POSIX实时扩展后，功能更增强大，除了基本通知功能外，还能够传递附加信息。信号事件的发生有两个来源：硬件来源(好比咱们按下了键盘或者其它硬件故障)；软件来源。

信号分为可靠信号和不可靠信号，实时信号和非实时信号。

进程有三种方式响应信号：

忽略信号

捕捉信号

执行缺省操做

7）套接字( socket ) ：套接字也是一种进程间通讯机制，与其余通讯机制不一样的是，它可用于不一样主机间的进程通讯。

：共享内存可实现不一样进程访问相同资源，并经过信号量等实现线程间的同步 

 

进程同步、ajax请求异步：

A,B作同一件事，A不等B去作另外一件事。当B通知来时再一块儿去作

线程安全的类,synchronized类：多线程对共享资源的访问

 

 

 

线程启动，运行后，由虚拟机调动run()方法

 

 

 

join使某线程优先执行完。

 

线程任务内再启动一个线程任务，两个线程并行执行。

在并行输出中，当数值输出到50时，就让thread1执行，其余线程等待它执行完再执行。

i==2的结果：

 

 

线程池

 

 

新建线程池实例，而后启动多个线程对共享资源进行访问：线程池

100线程，执行后应该是100（每一个任务很快执行，下个任务读到的是上个任务的结果）

Thread.sleep(5)，每一个线程任务读到的不是前面任务的结果，可能多个任务读到同一个值，而后再将结果写回，所以结果不肯定。（本机运行结果为2）

 

线程，共享资源(方法)

1、多线程访问共享资源

 

 

 

2、对共享资源进行显示加锁

 

 

 

3、访问共享资源的线程数

进程间通讯、java内置监视器 

 

 

线程状态

 

同步集合

 

7.多态

面向对象：三大特性、六大原则（单一职责，迪米特(最少知道-高内聚低耦合)，依赖置换(面向接口编程)，接口隔离原则(接口应尽可能小和简洁)，里氏替换，开放封闭）、3大目标（易维护，易扩展，易复用）

什么是多态

面向对象的三大特性：封装、继承、多态。从必定角度来看，封装和继承几乎都是为多态而准备的。

多态的定义：指容许不一样类的对象对同一消息作出对应响应。即同一消息能够根据“发送对象”的不一样而采用多种不一样的行为方式。（发送消息就是方法调用）

实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

多态存在的三个必要条件

1、要有继承；

2、要有重写；

3、父类引用指向子类对象。

多态的做用：消除类型之间的耦合关系。

现实中，关于多态的例子不胜枚举。比方说按下 F1 键这个动做，若是当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；若是当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不一样的对象上会产生不一样的结果。

 

多态的好处：

1.可替换性（substitutability）。多态对已存在代码具备可替换性。例如，多态对圆Circle类工做，对其余任何圆形几何体，如圆环，也一样工做。

2.可扩充性（extensibility）。多态对代码具备可扩充性。增长新的子类不影响已存在类的多态性、继承性，以及其余特性的运行和操做。实际上新加子类更容易得到多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。

3.接口性（interface-ability）。多态是超类经过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。

4.灵活性（flexibility）。它在应用中体现了灵活多样的操做，提升了使用效率。

5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤为在处理大量对象的运算和操做时，这个特色尤其突出和重要。

 

Java中多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载。

 

8.同步和异步去区别

例子：你叫我去吃饭，我听到了就马上和你去吃饭。若是我没有听到，你就会一直叫我，直到我听见和你一块儿去吃饭。若是我有事，你会等待，这个过程叫同步；异步过程指你叫我去吃饭，而后你就去吃饭了，而无论我是否和你一块儿去吃饭。而我获得消息后可能当即就走，也可能过段时间再走。

 

内容：在计算机领域，同步就是指一个进程在执行某个请求的时候，若该请求须要一段时间才能返回信息，那么这个进程将会一直等待下去，直到收到返回信息才继续执行下去；异步是指进程不须要一直等下去，而是继续执行下面的操做，无论其余进程的状态。当有消息返回时系统会通知进程进行处理，这样能够提升执行的效率。

同步问题多发生在多线程环境中的数据共享问题。即当多个线程须要访问同一个资源时，它们须要以某种顺序来确保该资源在某一特定时刻只能被一个线程所访问，而其余线程等待。若是使用异步，A在使用共享资源a，B请求使用a，若是是同步：B会等待知道A回应。若是是异步：B直接就使用a。

：实现同步的机制主要有临界区、互斥、信号量和事件

临界区：经过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。在任意时刻只容许一个线程对共享资源进行访问，若是有多个线程试图访问公共资源，那么在有一个线程进入后，其余试图访问公共资源的线程将被挂起，并一直等到进入临界区的线程离开，临界区在被释放后，其余线程才能够抢占。

互斥量：采用互斥对象机制。 只有拥有互斥对象的线程才有访问公共资源的权限，由于互斥对象只有一个，因此能保证公共资源不会同时被多个线程访问。互斥不只能实现同一应用程序的公共资源安全共享，还能实现不一样应用程序的公共资源安全共享 .互斥量比临界区复杂。由于使用互斥不只仅可以在同一应用程序不一样线程中实现资源的安全共享，并且能够在不一样应用程序的线程之间实现对资源的安全共享。

信号量：它容许多个线程在同一时刻访问同一资源，可是须要限制在同一时刻访问此资源的最大线程数目 。信号量对象对线程的同步方式与前面几种方法不一样，信号容许多个线程同时使用共享资源，这与操做系统中的PV操做相同。它指出了同时访问共享资源的线程最大数目。它容许多个线程在同一时刻访问同一资源，可是须要限制在同一时刻访问此资源的最大线程数目。

事件：经过通知操做的方式来保持线程的同步，还能够方便实现对多个线程的优先级比较的操做 。

补充：

PV操做及信号量的概念都是由荷兰科学家E.W.Dijkstra提出的。信号量S是一个整数，S大于等于零时表明可供并发进程使用的资源实体数，但S小于零时则表示正在等待使用共享资源的进程数。

        信号量：S。0为分界区，大于等于0，则信号量的队列中无等待进程，小于0，则信号量的队列中有等待进程。
　　 P操做申请资源：
　　（1）S减1；
　　（2）若S减1后仍大于等于零，则进程继续执行；
　　（3）若S减1后小于零，则该进程被阻塞后进入与该信号相对应的队列中，而后转入进程调度。
　　
　　V操做 释放资源：
　　（1）S加1；
　　（2）若相加结果大于零，则进程继续执行；
　　（3）若相加结果小于等于零，则从该信号的等待队列中唤醒一个被阻塞的等待进程，而后再返回原进程继续执行或转入进程调度。

总结：
　　1） 互斥量与临界区的做用很是类似，但互斥量是能够命名的，也就是说它能够跨越进程使用。因此建立互斥量须要的资源更多，因此若是只为了在进程内部是用的话使用临界区会带来速度上的优点并可以减小资源占用量。由于互斥量是跨进程的互斥量一旦被建立，就能够经过名字打开它。
　　2） 互斥量（Mutex），信号灯（Semaphore），事件（Event）均可以被跨越进程使用来进行同步数据操做，而其余的对象与数据同步操做无关，但对于进程和线程来说，若是进程和线程在运行状态则为无信号状态，在退出后为有信号状态。因此可使用WaitForSingleObject来等待进程和线程退出。
　　3） 经过互斥量能够指定资源被独占的方式使用，但若是有下面一种状况经过互斥量就没法处理，好比如今一位用户购买了一份三个并发访问许可的数据库系统，能够根据用户购买的访问许可数量来决定有多少个线程/进程能同时进行数据库操做，这时候若是利用互斥量就没有办法完成这个要求，信号灯对象能够说是一种资源计数器。

 

 

9.EJB(Enterprise JavaBean)

EJB是sun的JavaEE服务器端组件模型，设计目标与核心应用是部署分布式应用程序。简单来讲就是把已经编写好的程序（即：类）打包放在服务器上执行。凭借java跨平台的优点，用EJB技术部署的分布式系统能够不限于特定的平台。EJB (Enterprise JavaBean)是J2EE(javaEE)的一部分，定义了一个用于开发基于组件的企业多重应用程序的标准。其特色包括网络服务支持和核心开发工具(SDK)。 在J2EE里，Enterprise Java Beans(EJB)称为Java 企业Bean，是Java的核心代码，分别是会话Bean（Session Bean），实体Bean（Entity Bean）和消息驱动Bean（MessageDriven Bean）。在EJB3.0推出之后，实体Bean被单独分了出来，造成了新的规范JPA。

 

10.J2EE

J2EE（Java2Platform,EnterpriseEdition）是一个为大企业主机级的计算类型而设计的Java平台。Sun微系统（与其工业伙伴一块儿，例如IBM）设计了J2EE，以此来简化在瘦客户级环境下的应用开发。因为创造了标准的可重用模块组件以及因为构建出能自动处理编程中多方面问题的等级结构，J2EE简化了应用程序的开发，也下降了对编程和对受训的程序员的要求。

J2EE组件和“标准的”Java类的不一样点在于：它被装配在一个J2EE应用中，具备固定的格式并遵照J2EE规范，由J2EE服务器对其进行管理。J2EE规范是这样定义J2EE组件的：客户端应用程序和applet是运行在客户端的组件；Java Servlet和Java Server Pages (JSP) 是运行在服务器端的Web组件；Enterprise Java Bean (EJB )组件是运行在服务器端的业务组件。

J2EE典型的四层结构：

运行在客户端机器上的客户层组件

运行在J2EE服务器上的Web层组件

运行在J2EE服务器上的业务逻辑层组件

运行在EIS服务器上的企业信息系统（Enterprise information system）层软件

J2EE是Java 2 enterprise edition是Java的一种企业版用于企业级的应用服务开发

J2SE是Java 2 standard edition是Java的标准版，用于标准的应用开发

J2ME是Java 2 Micro Edition是Java的微型版，经常使用于手机上的开发

J2EE，J2SE，J2ME是java针对不一样的的使用来提供不一样的服务，也就是提供不一样类型的类库。

 

11.数据类型向下自动转换

short i=1;

i+=1;

//i=(short)i+1;//short会被转化成int

Object i1 = i;//基本类型自动转换成包装类

if(i1 instanceof Short){

System.out.println("yes");

}

12.类中变量也是对象

class A{

String s = new String("test");

}

建立该对象，生成了几个对象？

 

13.抽象类

抽象类能够有构造函数，但不该该有公共的构造函数（FxCop.设计规则）。FxCop.设计规则中说，若是抽象类须要构造函数，那么应该声明为“protected”。

（1）初始化抽象类的成员；

（2）为继承自它的子类使用。

 

抽象类能够继承实体类，可是和实体类的继承同样，也要求父类可继承(不是final)，而且拥有子类可访问到的构造器(不是private)

 

14.字节

一个byte由八个位组成，如00000000，其中，前7位表示数值，第8位是符号位（0为正，1为负）。最大的正数就是01111111；最小的负数是11111111。   

但负数会到-128。这不得不崇拜伟大的印度阿三们。

上述的描述会出现一个问题，就是0，会出现一个+0和一个-0。印度人他们规定-0为-128，这样就与计算机的补码（程序都是按补码运行的）完美的结合在一块儿。

 

15.字节流，字符流，文件

为知文件模块。

 

16.@Override @Overload

Properties-->Java Compiler-->compiler compliance level

1.5重写接口会报错，需1.6及以上

访问权限不能比父类中被重写的方法的访问权限更低。

父类的成员方法只能被它的子类重写。

声明为final的方法不能被重写。

声明为static的方法不能被重写，可是可以被再次声明，即静态方法属于类。

若是不能继承一个方法，则不能重写这个方法。

/////////////////////

A,B类中能够有同名的静态方法：

静态方法：A.c，B.c  B继承A，A=B，调用A.c，依然是调用A中的方法c，而不是B中的方法c

 

16，GC

垃圾回收机制有：

分代复制垃圾回收

标记垃圾回收

增量垃圾回收。 

 

17,JVM

：class加载机制？

：java 序列化，如何实现 java 序列化？

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。能够对流化后的对象进行读写操做，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象进行读写操做时所引起的问题。

序列化的实现：将须要被序列化的类实现 Serializable 接口，该接口没有须要实现的方法，

implements Serializable 只是为了标注该对象是可被序列化的，而后可使用一个输出流来输出对象。

 

18，String类

查看String类源码

private final char value[];

public String() {

this.value = new char[0];

//this.value[0] = 'a';//申请了内存，没有赋初值

}

 

19，byte,int,char等基本数据类型

底层是如何处理的？

 

20，JSP

：jsp是一个servlet，它如何得到request，session，application等对象？

：浏览器请求URL1，URL2，在服务器如何判断URL1，URL2是同一个session？

：浏览器请求URL1，服务器中页面jsp1，在页面中有URL2，直接在服务器内进行请求，服务器中页面jsp2或servlet2，此时，jsp2或servlet2中的request是由jsp1中的request而来吗？

：Servlet 执行时通常实现哪几个方法？

public ServletConfig getServletConfig()

public void init(ServletConfig config)

public void service(ServletRequest request,ServletResponse response)

public void destroy()

public String getServletInfo()

 

21，XML定义文档定义有几种形式？它们之间有何本质区别？解析 XML 文档有哪几种方式？

a: 两种形式 dtd schema

b: 本质区别:schema自己是xml的能够被XML解析器解析(这也是从DTD上发展 schema的根本目的)

c:DOM,SAX,STAX 等

DOM:处理大型文件时其性能降低的很是厉害。这个问题是由DOM的树结构所形成的，这种结构占用的内存较多，并且DOM必须在解析文件以前把整个文档装入内存,适合对 XML 的随机访问

SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不须要一次所有装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户经过在其回调事件中写入处理代码来处理 XML 文件，适合对 XML 的顺序访问

STAX:Streaming API for XML (StAX)

 

22，经常使用名称解释

web容器：给处于其中的应用程序组件（ JSP， SERVLET）提供一个环境，使 JSP,SERVLET 能直接在容器

中进行接口交互，没必要关注其它系统问题。主要有WEB服务器来实现。例如：TOMCAT,WEBLOGIC,WEBSPHERE等。该容器提供的接口严格遵照J2EE规范中的WEBAPPLICATION标准。咱们把遵照J2EE标准的WEB服务器就叫作J2EE中的WEB容器。

EJB 容器：Enterprise java bean容器。更具备行业领域特点。他提供给运行在其中的EJB组件各类管理功能。只要知足J2EE规范的EJB放入该容器，立刻就会被容器进行高效率的管理。而且能够经过现成的接口来得到系统级别的服务。例如邮件服务、事务管理。

JNDI：（JavaNamingDirectoryInterface）JAVA命名目录服务。主要提供的功能是：提供一个目录系统，让其它各地的应用程序在其上面留下本身的索引，从而知足快速查找和定位分布式应用程序的功能。

JMS：（ Java Message Service） JAVA消息服务。主要实现各个应用程序之间的通信。包括点对点和广播。

JTA：（ Java Transaction API） JAVA事务服务。提供各类分布式事务服务。应用程序只需调用其提供的接口便可。

JAF：（ Java Action FrameWork） JAVA 安全认证框架。提供一些安全控制方面的框架。让开发者经过各类部署和自定义实现本身的个性安全控制策略。

RMI/IIOP:（RemoteMethodInvocation）对象请求中介协议，他们主要用于经过远程调用服务。例如，远程有一台计算机上运行一个程序，它提供股票分析服务，咱们能够在本地计算机上实现对其直接调用。固然这是要经过必定的规范才能在异构的系统之间进行通讯。 RMI是JAVA特有的。

 

23，Object类

 

一个构造方法+11个方法

 

：clone()

实现了Cloneable接口，表示Object.clone()方法能够合法地对该类实例进行按字段复制。

在重写clone()方法时，有缺省行为，super.clone()，负责产生正确大小的空间，并逐位复制。

 

24，反射

在运行时，动态获取和调用类或对象中的属性和方法

Class<?> class1=null'

获取

Class.forName("java.lang.String");

String.class;

new String().getClass;

一、得到该类的包、类名

class1.getName();

二、获取父类和实现的接口

class1.getSuperclass();

class1.getInterfaces();

三、获取构造函数，构造函数的参数格式，参数类型

Constructors<?> cons[] =class1.getConstructors();

Class<?> c1= cons[0].getParameterTypes();

四、获取类的所有属性，属性的修饰符、类型

Field[] field=class1.getDeclaredFields();

五、获取父类或接口中的属性

class1.getFields();

六、获取类中的所有方法，方法修饰符、返回类型、参数、抛出的异常

Method[] method = class1.getMethods();

method[0].getModifiers();

method[0].getReturnType();

Class<?> para[] =method[0].getParameterTypes();

method[0].getExceptionTypes();

参数为字符串数组返回的值为：

[Ljava.lang.String;

七、获取某一个方法

class1.getMethod("add",Object.class);

 

调用

parameterType[]

parameterValue[]

Method method = class1.getMethod("methodName",int.class)

method.invoke(class1.newInstance(),1);

 

应用

运行时对private属性直接赋值

动态代理

运行时，将字符串放入ArrayList<int>

修改数组的大小

工厂模式

 

数据类型：String

数据类型字符串："String"

Class<?> type = field[i].getType();

String typeName = type.getName();

Class<?> typeClass = getPackClass(typeName);

 

// 基本类型对应的类

static Class<?> getPackClass(String typeName) {

if (typeName == null) {

return null;

}

switch (typeName) {

case "byte": {

return byte.class;

}

case "short": {

return short.class;

}

case "int": {

return int.class;

}

case "long": {

return long.class;

}

case "float": {

return float.class;

}

case "double": {

return double.class;

}

case "char": {

return char.class;

}

case "boolean": {

return boolean.class;

}

default:

try {

return Class.forName(typeName);

} catch (ClassNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

return null;

}

}

}