`
dinner_pig
  • 浏览: 7620 次
文章分类
社区版块
存档分类
最新评论

java学习总结

 
阅读更多

java学习期间总结


-------------------java基础---------------
-------------IO流--------------
IO流:字符流(字节 字符)  字符流每次读取16个字节单位的数据
       字节流(只流字节)   字节流每次读取8个字节单位的数据
       注:一个中文两个或多个字节

常见的IO类:
ByteArrayInputStream ----- 内存流---把信息存入内存中的一个缓冲区中
PipedInputStream     -----管道流----实现了pipe的概念,主要在线程中使用
SequenceInputStream  -----顺序连结流
ObjectInputStream    -----对象流
BufferedInputStream  -----缓存流
DataInputStream      -----特殊流
PushbackInputStream  -----回压流
FileOutputStream     -----文件输入流-----把信息存入文件中

面试点:***************

-----------------------异常-----------------------
异常:java异常是java提供的用于处理程序程序中错误的一些异常事件。运行期出现的错误。

throwable:Errow(错误 不可恢复)
       Exception(异常 可恢复)

Exception:系统异常(系统已写好)
           自定义异常
       也分为:检查性异常(Exception直接子类 必须捕获)   不检查性异常(runtime直接子类)
1.图
2.五个关键字:try catch finally throw throws
3.catch原则  先小的  后大的
4.异常与重写的关系
自定义异常的实现:自定义类实现RuntimeException接口 在本类的构造方法调父类的构造方法(super()) 并传入自定义内容 在另一类中直接抛出该类对象
常见的异常:
ArrayIndexOutOfBoundsException
ArrayStoreException
ClassNotFoundException
ClassCastException
IllegalAccessException
IllegalArgumentException
NullPointerException




----------------------------线程---------------------------
线程:线程从本质上说是一个正在执行的程序 它拥有自己独立的数据空间 占有一定的系统资源
线程与进程的关系:线程是进程的细分 它是进程内部的一个顺序控制流 有一个入口 一个出口 还有一个顺序执行序列
与进程不同的是 线程不能单独运行  必须依赖某个进程运行 统一进程中的所有线程共享进程所有的资源。
线程:守护线程
      用户线程
线程的五种状态:新建 就绪 运行 阻塞(挂起) 终止(死亡)
创建线程的两种方式:继承Thread
                    实现runnable接口
            比如:A a = new A(); Thread temp = new Thread(a); temp.start();
造成死锁的原因和解决方法:
原因:每条线程都调用了suspend方法 被挂起了 都等待着另一条线程调用resume 方法唤醒自己。
解决方法:

线程安全转化为线程不安全?
1.加synchronizd
2.调用sleep()方法。
3.调用wait()方法 再调用notify()方法;


---------------java.util-----------------
各个容器间的区别和联系


------------------补充----------------------
java 内置注解:
@Override
@Deprected
@SuppressWarning

java中实现多态的机制?
方法重写和方法重载
重写:是父类与子类之间多态性的一种表现
重载:是一个类中多态性德表现

对象的操作方法有哪些?
直接序列化 传参 返回值 数组 反射

对象序列化:
把一个对象任意时候的状态保存到web机制(外部文件)
反序列化:
web机制把对象的状态还原到对象中
-----缓存的作用


----------------反射---------------------
反射:Java提供了一套机制来动态执行方法和构造方法,以及数组操作等,这套机制就叫——反射
反射机制主要提供以下功能:
1.在运行时判断任意一个对象所属的类
2.在运行时构造任意一个类的对象
3.在运行时判断任意一个类所具有的成员变量和方法(通过反射甚至可以调用private方法)
4.在运行时调用任意一个对象的方法(*****注意:前提都是在运行时,而不是在编译时)
例子:
创建实例:
1.Class c = Class.forname("xxxx"); // 得到一个类的class对象
  Constractor con = c.getConstractor(String.Class); // 传入参数的class 对象
  Stu stu = con.newInstance("xxxxxx"); // 传入参数  并 得到对象

2.Class c = Class.forName("xxxx");
  Stu  stu = (Stu)c.newInstance(); /// 得到对象

方法区别:
class 对象-----
          getDeclaredConstractors(); // 本类的所有构造方法(包括private 修饰)
          getDeclaredMethods();  // 得到本类的方法
      getMethods(); /// 得到所有的方法(包括父类的)

XML: Extensible Markup Language
XML:  自定义标记语言
HTML: 固定标记语言

定义XML的方式:DTD
               Schema


-----------------------------------XML的解析----------------------------------
-------dom4j 解析xml文件例子:-----------
   Document document = null;
    try
    {
        document = new SAXReader().read(filePath);// 得到document 对象
    } catch (DocumentException e)
    {
        e.printStackTrace();
        throw new GeneralException("Dom4j解析配置文件jdbc.xml出现异常!");
    }
   Element root = document.getRootElement(); //得到根节点对象
   Iterator<Element> iter = root.elementIterator("db"); // 得到根节点下的所有元素
   while(iter.hasNext()){
    Element element = iter.next();
        String type = element.elementText("type");// 拿到具体的值
   }

---------SAX 解析xml文件例子---------
优点:
因此不需要将数据存储在内存中。
SAX 解析器采用了基于事件的模型 可以激活一个回调方法。

public class Ceshi extends DefaultHandler{ // 需要继承DefaultHandler 并实现里面的方法
public static void main(String[] args)
{
String filename = "WebContent/WEB-INF/ceshi.xml";
SAXParserFactory spf = SAXParserFactory.newInstance();
try
{
SAXParser saxParser = spf.newSAXParser();
saxParser.parse(new File(filename), new Ceshi());
}catch (){

}

在startElement 方法循环迭代出来



---------------------------ajax-------------------------------
创建一个ie 对象 判断为ie 或非ie




--------------------基础面试点---------------------
java.lang包
String,StringBuffer,StringBuild各自的含义的区别
截取字符串的编程题
反射(java reflection的定义和用法。
请问java下Class.forName的作用是什么,为什么要使用它
NEW了一个String对象问你这个共有几个对象
java.io包
java中有那几种流(最基础的)?
io和nio(new io)的区别以及nio的用法。
写一段程序,如何读取一个文件夹所有的文件和子文件夹的所有文件
java.io.Reader与java.io.InputStream的区别
什么是序列化?序列化的作用?
java.io.StringWriter,什么时候调用 他的flush方法,以及StringWriter的作用
java.net包
tcp和udp的区别?
socket怎么得到当前ip
通过Socket来编写一个聊天程序。

java.sql包

   给你ip,数据库名,表名,密码要你将通过jdbc连接,并查出前100条数据的过程代码
   请写出jdbc调用存储过程的代码
   插入10万条数据用jdbc语句怎么写。
   preparedstatement与statement的区别?
   jdbc里你是怎么样进行批处理的。

java.util包

ArrayList,LinkedList和HashMap的各种比较,比如ArrayList 同 Vector的比较,HashMap同treeMap的比较, ArrayList同LinkedList的比较,数组和ArrayList的区别,List与Set区别,Set与Map区别;
简述HashMap原理,并画出它的结构图;
Collection和Collections的区别
线程
什么叫线程?谈谈你对多线程的理解
多线程有几种实现方法,都是什么?
sleep和wait区别?
java线程里的wait,sleep,synchronzied,notify分别有什么作用?
启动线程有那几种方式?
唤醒一个线程与唤醒所有线程的方法分别是?
有两个线程,一个线程每分钟把系统时间写入一个文件,另一个线程读出文件里的数据.
同步与异步的区别? 在什么情况下分别使用?同步的方法有哪些?
进程与线程的概念理解
线程的状态控制
设计4个线程,其中两个线程每次对j增加1,另外两个线程对j每次减少1。写出程序。
异常
EROOR与Exception的区别


------------------------------Ext----------------------------
Ext:ExtJs的简称 是一个强大的Js类库
ExtJs框架支持Ajax实现 通常 Ajax 应用程序的一个公用特征是应用程序可以异步的响应用户输入 它会刷新局部用户界面而不需要重新显示整个Web界面
ExtJs中基本组件体系:
基本组件
工具栏组件
表单及字段组件

基本组件:
box
button
component
container
panel


1.ext它提供了一套非常绚丽的UI,与后台无关的框架。
2.ext是一套开源的框架。
3.容器组件用来装组件的。
4.ext.form.FormPanel用来装表单组件的。
5.容器是用来装东西的(记好了)。
6.所有的表单组件都继承field组件。
7.组件(都是BoxComponent下面的组件):基本组件,工具栏组件(tbar下面的组件),表单组件(表单下面的组件)。
8.所有的组件销毁都是引用BoxComponent来的。
9.ext中一个组件代表一个类,要用组件直接new一个就可以,默认的情况下所有的组件都初始化了。
10.当对象指向rendering以后,每一个对象都对应一个DOM。

1.Ext的核心组件(component):自动支持了标准的隐藏,显示,启用,禁用等,Ext中每一个组件都对应着一个xtype属性,在Ext中xytpe直接可以创建组件,所有的组件都可以通过renderTo来进行渲染html页面。
2.组件的生命周期是:创建,初始化,销毁。
3.Ext.container有两个重要的属性:1.layout2.items。
4.页面布局都交给Viewport来管理。
5.Ext实用工具:1.onReady()
6.js中没有静态的,静态的就是一个函数。
7.get方法是获取HTML元素或者ext元素的一个函数,返回来的数据类型是Ext.element,必须通过id或者dom对象。
8.getCmp用来获得一个Ext组件。
9.getBody返回当前body的element。
10.borderLayout布局:把界面分成了5部分,东南西北中,中是一定要的(如果没有中,就报布局出错)。





-------------------------------------JQuery-----------------------
JQuery是一个类库 为web的javascript开发提供辅助功能
JQuery使用户能方便的处理HTMLdocument Event   实现动态效果并且方便的为网站提供ajax 交互。
优势:
文档说明很全 而且各种应用也说的很详细
很多成熟的插件

JQuery----->$

jquery的得值方式:
$("#id")[0].value() -----转化为DOM 元素取 debug调试发现
$("#id").val()      -----直接调方法取

$(dom)   DOM---->Jquery




------------------------------过滤器的使用-----------------

1.实现Filter接口 重写init() doFilter() destroy()方法
2.具体的操作
public class CharacterEncodingFilter implements Filter {
    private FilterConfig config = null; //filet配置
    private String encoding = "UTF-8";    // 默认字符编码

    public void init(FilterConfig config) throws ServletException {
        this.config = config;
        this.encoding = config.getInitParameter("encoding");//web.xml配置参数
    }
    /**
     * 字符处理方法
     */
    public void doFilter(ServletRequest srequest, ServletResponse sresponse,
            FilterChain chain) throws IOException, ServletException {
        if (null != encoding) {
            HttpServletRequest request = (HttpServletRequest)srequest;
            HttpServletResponse response = (HttpServletResponse)sresponse;
               
            // 对请求进行编码设置
            request.setCharacterEncoding(encoding);        //把请求用指定的方法编码
            response.setContentType("text/html");
            response.setCharacterEncoding(encoding);    //把返回响应指定 编码方式
            System.out.println("------------过滤编码-------------" + encoding);
        }
        // 把处理权限交给下一个过滤器
        chain.doFilter(srequest, sresponse);
    }
    public void destroy() {
    }
}
3.web.xml 配置
<filter>
<filter-name>filter</filter-name>
<filter-class>servlet.filter.filter</filter-class>
<init-param>
<param-name>encoding</param-name>  ///可传参数
<param-value>utf-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>filter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

--------------------------DButil-----------------------------
解决的问题:
a、大量的重复代码
b、jdbc的简单封装
c、使用策略模式可以生成不同的返回类型
涉及技术:
a、反射
b、泛型
c、元数据
d、可变参数
缺点:没有进行事务处理
流程:
调用query 方法(具体的) ---->适配器模式兼容查询功能  预处理------->选择类型-------->创建bean 利用反射机制生成一个对象

用法:
1.定义一类:继承BasicDataSource 并定义一方法 用this 定义父类连结数据库的属性
public class LoginDataSource extends BasicDataSource{
  public LoginDataSource() {
    this.setDriverClassName("com.mysql.jdbc.Driver");
    this.setUsername("root");
    this.setPassword("123");
    this.setUrl("jdbc:mysql://192.168.2.72/english?useUnicode=true&amp;charactorEncodering=UTF-8");
  }
}

2.得到QueryRunner 构造QueryRunner 有两种方法:无参 ,DataSource类型的参数   采用后一种
QueryRunner  queryRunner= new QueryRunner(new LoginDataSource());

3.执行具体的SQL操作
  queryRunner.query();
  queryRunner.update();
  .......
  Connection connection = queryRunner.getDataSource().getConnection();  // 得到连结对象


---------------------UML--------------------------------------
UML:统一建模语言
UML为面向对象开发系统的产品进行说明、可视化、和编制文档的一种标准语言。
UML最适于数据建模,业务建模,对象建模,组件建模。
UML的内容:
(1) UML语义
    描述基于UML的精确元模型定义。元模型为UML的所有元素在语法和语义上提供了简单、一致、通用的定义性说明,
    使开发者能在语义上取得一致,消除了因人而异的最佳表达方法所造成的影响。此外UML还支持对元模型的扩展定义。
(2) UML表示法  标准建模语言UML的重要内容可以由下列五类图(共9种图形)来定义
第一类是用例图
第二类是静态图 (Static diagram),
第三类是行为图(Behavior diagram),
第四类是交互图(Interactive diagram),
第五类是实现图 ( Implementation diagram )。

用例图的关系:包含关系:用例可以简单地包含其他用例具有的行为,并把它所包含的用例行为做为自身行为的一部分,这被称作包含关系
              扩展关系:意外情况

类图的三种关系:关联:一个类的实例必须要用到另一类实例 才能完成工作叫关联
                聚合:带菱形的连线
        泛化:一个指向其他类作为超类的继承连线


--------------------------ubuntu 简单操作-------------------
touch  ----->生成新的文件
sudo   ----->设置密码
rm  file --->删除文件
mkdir    --->新建目录
加 -r    --->删除目录
ls:     --->清单

面试点:
rm命令可删除文件或目录,其主要差别就是是否使用递归开关 -r或-R 。

查看当前监听80端口的程序
lsof -i :80
查看当前有哪些进程
ps -A
查看当前的内存使用情况
free -l
查看CPU信息
cat /proc/cpuinfo








---------------------------CC 持续集成-----------------------
持续集成是一种软件开发实践 简称ci 可以让程序员持续不断的集成svn上的代码 是为了解决程序员手动检出svn上最新的代码的问题而出现
优点:
更容易发现bug 因为单独提供了一个单元测试的页面 自动的测试  并将测试结果反馈在页面上 自动 不间断的检测svn上的代码  并更新
安全性比较高
自动化程度比较高

缺点:配置文件过于复杂 特别是config文件

公司怎么用的:
首先下载一个cc工具 并配置环境变量 然后在dos命令中 检 出svn服务器 上的项目 并且在 config.xml文件进行项目的相关配置 比如项目名 和自动检测的间隔时间和延迟时间  如果有改动就及时更新 首先会找到build.xml文件 build文件首先清空以前的一些垃圾信息比如class文件和目录 然后执行预编译 将项目打包成jar 包 或者war 包 发布tomcat 中 就可以运行了
也可以对项目进行单元测试 和数据库集成 比如数据库集成 首先是对数据库进行清空和删除一些表信息 然后再初始化数据库一些文件信息 就可以持续不断的进行数据库集成了

经验就是:编译后的class文件要放在build 目录的下的class文件夹 并且junit的输入和ant 的输入路径相同 否则找不到测试类

首先是以config.xml文件为入口 并且找到 该项目的build 文件 并首先会清空里面原有的信息比如class文件 然后执行预编译 包括jar包和java文件 然后进行单元测试 和 对数据库进行一些初始化

同类框架比较:
    更加自动化···
最佳实践:
    
经常提交代码
不要提交无法构建的代码
避免检出无法构建的代码

立即修复无法集成的构建

编写自动化测试
必须通过所有的测试和审查
执行私有构建
自动化构建

自动化数据库集成
使用本地数据库沙盒

执行单命令构建
创建一致的目录结构
及时的提交可构造的代码 保持svn上代码的正确性

自动化单元测试
自动化功能测试
自动化系统测试
自动化组件测试


svn检出:

先将ant有关的jar包导入 到cc工具中  因为eclipse 没有自带
然后配置 svn 的地址 用户名 密码等 连结属性
让后配置里面的 svn 节点的配置 就可以自动的检出svn上的代码了

---------------------------------spring事物配置----------------------------------
有五种:
第一种方式:每个Bean都有一个代理
       <bean id="sessionFactory"   
               class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">   
           <property name="configLocation" value="classpath:hibernate.cfg.xml" />   
           <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /> 
       </bean>   
     
       <!-- 定义事务管理器(声明式的事务) -->   
       <bean id="transactionManager" 
           class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
           <property name="sessionFactory" ref="sessionFactory" /> 
       </bean> 
        
       <!-- 配置DAO --> 
       <bean id="userDaoTarget" class="com.bluesky.spring.dao.UserDaoImpl"> 
           <property name="sessionFactory" ref="sessionFactory" /> 
       </bean> 
        
       <bean id="userDao"   
           class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">   
              <!-- 配置事务管理器 -->   
              <property name="transactionManager" ref="transactionManager" />      
           <property name="target" ref="userDaoTarget" />   
            <property name="proxyInterfaces" value="com.bluesky.spring.dao.GeneratorDao" /> 
           <!-- 配置事务属性 -->   
           <property name="transactionAttributes">   
               <props>   
                   <prop key="*">PROPAGATION_REQUIRED</prop> 
               </props>   
           </property>   
       </bean>   
    lt;/beans> 

所有Bean共享一个代理基类:
    <bean id="sessionFactory"   
                class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">   
            <property name="configLocation" value="classpath:hibernate.cfg.xml" />   
            <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /> 
        </bean>   
     
        <!-- 定义事务管理器(声明式的事务) -->   
        <bean id="transactionManager" 
            class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
            <property name="sessionFactory" ref="sessionFactory" /> 
        </bean> 
         
        <bean id="transactionBase"   
                class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"   
                lazy-init="true" abstract="true">   
            <!-- 配置事务管理器 -->   
            <property name="transactionManager" ref="transactionManager" />   
            <!-- 配置事务属性 -->   
            <property name="transactionAttributes">   
                <props>   
                    <prop key="*">PROPAGATION_REQUIRED</prop>   
                </props>   
            </property>   
        </bean>     
        
        <!-- 配置DAO --> 
        <bean id="userDaoTarget" class="com.bluesky.spring.dao.UserDaoImpl"> 
            <property name="sessionFactory" ref="sessionFactory" /> 
        </bean> 
         
        <bean id="userDao" parent="transactionBase" >   
            <property name="target" ref="userDaoTarget" />    
        </bean> 
    </beans> 

第三种方式:使用拦截器:
    <bean id="sessionFactory"   
                class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">   
            <property name="configLocation" value="classpath:hibernate.cfg.xml" />   
            <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /> 
        </bean>   
     
        <!-- 定义事务管理器(声明式的事务) -->   
        <bean id="transactionManager" 
            class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
            <property name="sessionFactory" ref="sessionFactory" /> 
        </bean>  
        
        <bean id="transactionInterceptor"   
            class="org.springframework.transaction.interceptor.TransactionInterceptor">   
            <property name="transactionManager" ref="transactionManager" />   
            <!-- 配置事务属性 -->   
            <property name="transactionAttributes">   
                <props>   
                    <prop key="*">PROPAGATION_REQUIRED</prop>   
                </props>   
            </property>   
        </bean> 
           
        <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">   
            <property name="beanNames">   
                <list>   
                    <value>*Dao</value> 
                </list>   
            </property>   
            <property name="interceptorNames">   
                <list>   
                    <value>transactionInterceptor</value>   
                </list>   
            </property>   
        </bean>   
       
        <!-- 配置DAO --> 
        <bean id="userDao" class="com.bluesky.spring.dao.UserDaoImpl"> 
            <property name="sessionFactory" ref="sessionFactory" /> 
        </bean> 
    </beans> 

第四种方式:使用tx标签配置的拦截器:
    <context:annotation-config /> 
       <context:component-scan base-package="com.bluesky" /> 
     
       <bean id="sessionFactory"   
               class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">   
           <property name="configLocation" value="classpath:hibernate.cfg.xml" />   
           <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /> 
       </bean>   
     
       <!-- 定义事务管理器(声明式的事务) -->   
       <bean id="transactionManager" 
           class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
           <property name="sessionFactory" ref="sessionFactory" /> 
       </bean> 
     
       <tx:advice id="txAdvice" transaction-manager="transactionManager"> 
           <tx:attributes> 
               <tx:method name="*" propagation="REQUIRED" /> 
           </tx:attributes> 
       </tx:advice> 
        
       <aop:config> 
           <aop:pointcut id="interceptorPointCuts" 
               expression="execution(* com.bluesky.spring.dao.*.*(..))" /> 
           <aop:advisor advice-ref="txAdvice" 
               pointcut-ref="interceptorPointCuts" />         
       </aop:config>       
    lt;/beans> 

第五种方式:全注解:








-------------------------
长沙博赛软件有限公司
湖南省长沙市岳麓区景秀路2号
109路,117路,118路,132路,301路,301路区间,317路,318路,401路,804路

毕业院校:
北京科技师范学院  计算机科学与技术
北京科技师范学院创建于1980年
北京市大兴区黄村镇北程庄东路2号院
北京师范大学北校门的旁边



---------------------------------------经典面试----------------------------------
6、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
对于short s1 = 1; s1 = s1 + 1; 由于s1+1运算时会自动提升表达式的类型,所以结果是int型,再赋值给short类型s1时,编译器将报告需要强制转换类型的错误。
对于short s1 = 1; s1 += 1;由于 += 是java语言规定的运算符,java编译器会对它进行特殊处理,因此可以正确编译。

内部类:
特征:在一个类的内部定义的类  其他类不能直接调用 不能定义静态变量  可以访问外部变量

Static Nested Class 和 Inner Class区别:
static Nested Class能访问外部类的非static成员变量。

关于return finally 执行顺序:

<jsp:userbean>中scope有哪几种类型? // scope :作用域
page   —   bean只能在单一JSP页面中被访问,寿命期只存在于当前请求(即其为service方法中的局部变量)。 
request   —   bean能在单一JSP页面及此页面include或forward的其他页面或servlet中被访问(即其为Request的属性)。---整个应用用的是同一个bean。 比如:页面刷新
session   —   bean能在特定用户会话中的所有JSP页面和servlet中被访问(即其为session的属性)。 ---- 这次会话中用的是同一个。
application   —   bean能在此web应用程序下的所有JSP页面和servlet中被访问(即其为Servlet  context的属性)。----整个应用用的是同一个bean。

Cookie与Session的区别,Session的工作原理
Cookie:客户端保存用户信息
Session:服务端保存用户信息  安全性相对要高一些;
session:保存的是对象,cookie中保存的是字符串
通常session cookie是不能跨窗口使用的,当你新开了一个浏览器窗口进入相同页面时,
系统会赋予你一个新的sessionid,这样我们信息共享的目的就达不到了,此时我们可以先把sessionid保存在persistent cookie中,然后在新窗口中读出来,就可以得到上一个窗口SessionID了,这样通过session cookie和persistent cookie的结合我们就实现了跨窗口的session tracking(会话跟踪)。



43、try {}里有一个 return 语句,那么紧跟在这个 try 后的finally {}里的 code 会不会被执行,什么时候被执行,在 return 前还是后?
会执行,在 return 前执行。
如果再加个catch finally加个return语句  会执行后面那个return语句

简述synchronized和java.util.concurrent.locks.Lock的异同 ?
主要相同点:Lock能完成synchronized所实现的所有功能
主要不同点:Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁,而Lock一定要求程序员手工释放,并且必须在finally从句中释放。Lock还有更强大的功能,例如,它的tryLock方法可以非阻塞方式去拿锁

Collection 和 Collections的区别。
  Collection是集合类的上级接口,继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类,他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

request.getAttribute() 和 request.getParameter()区别:
方式:
1.getParameter取值是基于Post和Get方式的传递的.(url 挂问号传递的值)
  getAttribute取值是以编程的方式存储到WEB会话上下面中的,
      例如:request.setAttribute("roleList", roleList);
类型:
2.getParameter的值没有类型或者看成是String类型的;
  getAttribute的值是对象,可以是String已及用户自已定义的类型



11. jsp有哪些内置对象?作用分别是什么? 分别有什么方法?
答:JSP共有以下9个内置的对象:
request 用户端请求,此请求会包含来自GET/POST请求的参数
response 网页传回用户端的回应
pageContext 网页的属性是在这里管理
session 与请求有关的会话期
application servlet 正在执行的内容
out 用来传送回应的输出
config servlet的构架部件
page JSP网页本身
exception 针对错误网页,未捕捉的例外

request表示HttpServletRequest对象。它包含了有关浏览器请求的信息,并且提供了几个用于获取cookie, header, 和session数据的有用的方法。
   response表示HttpServletResponse对象,并提供了几个用于设置送回 浏览器的响应的方法(如cookies,头信息等)
   out对象是javax.jsp.JspWriter的一个实例,并提供了几个方法使你能用于向浏览器回送输出结果。
   pageContext表示一个javax.servlet.jsp.PageContext对象。它是用于方便存取各种范围的名字空间、servlet相关的对象的API,并且包装了通用的servlet相关功能的方法。
   session表示一个请求的javax.servlet.http.HttpSession对象。Session可以存贮用户的状态信息
   applicaton 表示一个javax.servle.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息
   config表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。
   page表示从该页面产生的一个servlet实例

12. jsp有哪些动作?作用分别是什么?
(这个问题似乎不重要,不明白为何有此题)
答:JSP共有以下6种基本动作
jsp:include:在页面被请求的时候引入一个文件。
jsp:useBean:寻找或者实例化一个JavaBean。
jsp:setProperty:设置JavaBean的属性。
jsp:getProperty:输出某个JavaBean的属性。
jsp:forward:把请求转到一个新的页面。
jsp:plugin:根据浏览器类型为Java插件生成OBJECT或EMBED标记

16、页面间对象传递的方法
request,session,application,cookie等



7.分页语句
取出sql表中第31到40的记录(以自动增长ID为主键)
sql server方案1:
    select top 10 * from t where id not in (select top 30 id from t order by id ) orde by id
sql server方案2:
    select top 10 * from t where id in (select top 40 id from t order by id) order by id desc

mysql方案:select * from t order by id limit 30,10

oracle方案:select * from (select rownum r,* from t where r<=40) where r>30



集合类的排序 提示:可实现comparable 接口:
两种:
1.对象本身实现Comparable接口,那么该类的实例就是可以排序的.
只要实现了Comparable接口,就可以调用Collections的sort方法对集合中的元素排序.
TestList   // list 排序



TestMap     // map 排序

class TestBean{
     private int count;
     private String name;
     public void toString(){
    return count+"\t"+name;
     }
}

class TestComparator implements Comparator{
    public int compare(TestBean o, TestBean oo) {
        if(o.count==oo.count){
            return 0;
        }else if(o.count>oo.count){
            return 1;
        }else{
            return -1;
        }
    }
}



TreeSet tree=TreeSet(new TestComparator());
tree.add(new TestBean());


2.指定一个Comparator,也就是实现了Comparator的类的一个实例.
但是Java本身只提供了一个Comparator的实现,就是Collections.reverseOrder().
该方法返回的是一个已经实现了Comparable接口的反序.




--------------------待整理进去的内容-------------------------------------
pageSize=20;
pageNo = 5;

1.分页技术1(直接利用sql语句进行分页,效率最高和最推荐的)

mysql:sql = "select * from articles limit " + (pageNo-1)*pageSize + "," + pageSize;
oracle: sql = "select * from " +
                                "(select rownum r,* from " +
                                    "(select * from articles order by postime desc)" +
                                "where rownum<= " + pageNo*pageSize +") tmp " +
                            "where r>" + (pageNo-1)*pageSize;
注释:第7行保证rownum的顺序是确定的,因为oracle的索引会造成rownum返回不同的值
简洋提示:没有order by时,rownum按顺序输出,一旦有了order by,rownum不按顺序输出了,这说明rownum是排序前的编号。如果对order by从句中的字段建立了索引,那么,rownum也是按顺序输出的,因为这时候生成原始的查询结果集时会参照索引表的顺序来构建。

sqlserver:sql = "select top 10 * from id not id(select top " + (pageNo-1)*pageSize + "id from articles)"


4、你对Spring的理解。
1.Spring实现了工厂模式的工厂类(在这里有必要解释清楚什么是工厂模式),这个类名为BeanFactory(实际上是一个接口),在程序中通常BeanFactory的子类ApplicationContext。Spring相当于一个大的工厂类,在其配置文件中通过<bean>元素配置用于创建实例对象的类名和实例对象的属性。
2. Spring提供了对IOC良好支持,IOC是一种编程思想,是一种架构艺术,利用这种思想可以很好地实现模块之间的解耦。IOC也称为DI(Depency Injection),什么叫依赖注入呢?
譬如,Class Programmer
{
    Computer computer = null;
    public void code()
    {
        //Computer computer = new IBMComputer();
        //Computer computer = beanfacotry.getComputer();
        computer.write();
    }
    public void setComputer(Computer computer)
    {
        this.computer = computer;
    }
}
另外两种方式都由依赖,第一个直接依赖于目标类,第二个把依赖转移到工厂上,第三个彻底与目标和工厂解耦了。在spring的配置文件中配置片段如下:
<bean id=”computer” class=”cn.itcast.interview.Computer”>
</bean>

<bean id=”programmer” class=”cn.itcast.interview.Programmer”>
    <property name=”computer”  ref=”computer”></property>
</bean>
3. Spring提供了对AOP技术的良好封装, AOP称为面向切面编程,就是系统中有很多各不相干的类的方法,在这些众多方法中要加入某种系统功能的代码,例如,加入日志,加入权限判断,加入异常处理,这种应用称为AOP。实现AOP功能采用的是代理技术,客户端程序不再调用目标,而调用代理类,代理类与目标类对外具有相同的方法声明,有两种方式可以实现相同的方法声明,一是实现相同的接口,二是作为目标的子类在,JDK中采用Proxy类产生动态代理的方式为某个接口生成实现类,如果要为某个类生成子类,则可以用CGLI B。在生成的代理类的方法中加入系统功能和调用目标类的相应方法,系统功能的代理以Advice对象进行提供,显然要创建出代理对象,至少需要目标类和Advice类。spring提供了这种支持,只需要在spring配置文件中配置这两个元素即可实现代理和aop功能,例如,
<bean id=”proxy” type=”org.spring.framework.aop.ProxyBeanFactory”>
    <property name=”target” ref=””></property>
    <property name=”advisor” ref=””></property>


6、四种会话跟踪技术
会话作用域ServletsJSP 页面描述
page否是代表与一个页面相关的对象和属性。一个页面由一个编译好的 Java servlet 类(可以带有任何的 include 指令,但是没有 include 动作)表示。这既包括 servlet 又包括被编译成 servlet 的 JSP 页面
request是是代表与 Web 客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面,涉及多个 Web 组件(由于 forward 指令和 include 动作的关系)
session是是代表与用于某个 Web 客户机的一个用户体验相关的对象和属性。一个 Web 会话可以也经常会跨越多个客户机请求
application是是代表与整个 Web 应用程序相关的对象和属性。这实质上是跨越整个 Web 应用程序,包括多个页面、请求和会话的一个全局作用域




-----------------------------ibatis------------------------------
1.ibatis中 # 跟 $的区别?
select * from member where id =#id#  ------ 适用于传参问题 可以直接传属性值  也可以传javabean  ibatis会自动解析

问题:iBATIS默认会把“#”中间的变量作为字符串来处理

解决问题:
使用$将你的变量括起来,iBATIS不会给这个变量做任何的处理,直接生成你要的SQL

简单的说:
使用#号传值 ibatis默认会把#号中间的变量作为字符串来处理。
使用$号传值 ibatis不会给这个变量做任何处理  直接生成你想要的SQL。
$方式一般用于传入数据库对象.例如传入表名;
一般能用#的就别用$ ; 性能问题吧

2.Ibatis中使用like ‘%#filedName#%’ 时,有什么问题?
在xml映射文件中,如果直接按如上写法,会报异常:java.sql.SQLException: Invalid argument in JDBC call: parameter index out of range: 1。
所以一般会采用如下两种方式:
1) 将#换成$,如like ‘%$ filedName $%’,这样就没有问题了..
2) 采用字符串联接符||,如:like ‘%’||# filedName #||’%’

与hibernate相比较:
难易度:a.更容易掌握 
SQL:b.更容易进行SQL优化, hibernate的自动生成的sql 有点难看。
c.可以进行细度的优化
1.比如我要查询一个表中的一个或几个字段 直接一个sql 搞定  而hibernate利用面向对象的方式会将所有的数据查出来 就浪费的内存
效率:不考虑hibernate的缓存的话 ibatis的效率要高一些。
可维护性:个人觉得ibatis要好一些。ibatis 的sql 单独保存到一个文件中 易于维护  而hibernate在java代码中保存sql
hibernate的优点:对数据库类型兼容比较好
                 自动化程度比较高

还得根据不同需求选择不同数据库。



------------------------------WebService-------------------------------
解决了什么问题:
在以往传统应用程序中 采用独立的进程模式 这些应用程序之间没法进行真正通信,彼此间不能共享数据 而Webservice正好解决了一些问题。

Web services(也称web 服务技术)是一种面向服务的架构技术,是一种进行分布式部署和应用的流行方式,通常用来建立可互操作的分布式应用程序

简单地说,Web services就是一个应用程序,它向外界暴露出能够进行远程调用的接口程序。
一种思想  一种架构
一种 SOA 架构 : 面向服务架构
webservicer 的框架:axis1 axis2 xfire cxf
怎么用的?
我用的是axis2 框架
a.浏览器访问:
1.首先是下载----它是apache公司的一个开源框架。
2.解压axis2.war ,然后部署到tomcat/webapps目录下
3.利用POJO实现零配置的WebService
4.编写POJO --- 就是定义一个类和几个方法
5.SimpleService.class文件放到<Tomcat安装目录>\webapps\axis2\WEB-INF\pojo目录中(如果没有pojo目录,则建立该目录)
6.访问:http://localhost:8080/axis2/services/listServices 也可以直接在url 后面带参数过去

b.使用RPC方式调用web service
1.// RPC客户端服务类
    RPCServiceClient serviceClient = new RPCServiceClient();
    Options options = serviceClient.getOptions();
2.// 指定调用web service的URL
String url = "http://localhost:9090/axis2/services/SimpleService";
    EndpointReference taretRef = new EndpointReference(url);
    options.setTo(taretRef);
3.// 指定getGreeting方法的返回值的数据类型的calss对象
    Object[] opsArgs = new Object[] { "和尚" };
    Class[] returnTypes = new Class[] { String.class };

// 指定要调用的getGreeting方法及其WSDL文件的命名空间
    QName qName = new QName("http://ws.apache.org/axis2", "getGreeting");

4.调用
System.out.println(serviceClient.invokeBlocking(qName, opsArgs,returnTypes)[0]);

----------------------------------- SSH 框架整合 ------------------------------------------
web.xml 配置文件
<!利用监听器初始化spring 的配置文件applicationContext.xml文件  实现依赖注入  >
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!struts 的配置>
<filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<!路径拦截>
<filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>
    <dispatcher>FORWARD</dispatcher>
</filter-mapping>
applicationContext.xml 配置文件  spring
<!-- 配置dataSource 数据库连接 -->
<bean id="dataSource"
    class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql:///hibernate"></property>
    <property name="username" value="root"></property>
    <property name="password" value="123"></property>
</bean>
<bean id="sessionFactory"
    class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource"></property>
    <property name="hibernateProperties">
        <props><!-- 一些属性 比如sql 可见  自动创建表 -->
            <prop key="hibernate.show_sql">true</prop>
            <prop key="hibernate.hbm2ddl.auto">update</prop>
        </props>
    </property>
    <property name="mappingResources">
        <list><!-- 初始化javabean映射文件 -->
            <value>com/lxit/ssh/bean/person.hbm.xml</value>
        </list>
    </property>
</bean>

<!-- 一般的spring注入 -->
<bean id="personDao" class="com.lxit.ssh.dao.PersonDaoImpl">
    <property name="sessionFactory" ref="sessionFactory"></property><!-- hibernate模板需要注入sessionFactory -->
</bean>
<bean id="personService" class="com.lxit.ssh.service.PersonServiceImpl">
    <property name="personDao" ref="personDao"></property>
</bean>
<bean name="personAction" class="com.lxit.ssh.web.PersonAction">
    <property name="personService" ref="personService"></property>
</bean>

person.hbm.xml----javabean映射配置文件
<hibernate-mapping package="com.lxit.ssh.bean" >
<class name="Person"  >
  <id name="id">
   <generator class="uuid.hex"></generator>
  </id>
  <property name="name" ></property>
  <property name="age" ></property>
</class>
</hibernate-mapping>







---------------------------spring ioc aop ----------------------
ioc:在客户端调用一个类的方法 以往的作风 new 这个的实例 然后进行调用 
     现在是通过spring FactoryBean 利用工厂模式来创建的 这就叫控制反转
  当一个类中调用另一个类中的方法 通过spring 容器 将另一个类的实例 注入到这个类中
     创建类实例 利用FactoryBean 来完成  ---- 控制反转
     通过spring 容器 将一个类的实例注入到另一个类中 ---- 依赖注入

aop: 面向切面编程
   实现方式:1.动态代理 (一定需要接口)
             2.cglib     (不需要接口也可创建代理类)
 
     三个切面(advisor)Regexp、names、defalut
     五个通知
     三个代理 ProxybeanFactory ----、、
              BeanNemaAutoProxyCreator //可以为多个类创建代理  因为只要我们在beanNames 中注入bean的id。
          DefaultAutoProxyCreator//他默认搜索所有的advisor 并且为所有的bean创建代理所以以为我

事物:分为jta 和jdbc
      声明试和编程式
      实现有五种方式

     






分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics