2.20日问题总结

1.Java创建对象有哪四种方式？

1. new关键字
2. clone
3. 反射
4. 对象反序列化

例如现在有一个学生类，用上面四种方式创建对象！

• 学生类

  package com.xbky.domain;
  
  import java.io.Serializable;
  
  public class Students implements Cloneable, Serializable {
  
      private int sid; //学号
      private String sname; //姓名
      private String gender; //性别
      private String birthday; //出生日期
      private String major; //专业
  
      //一定要保留这个默认的无参数的构造方法，否则spring也无法实例化。
  
      public Students() {
      }
  
      public Students(int sid, String sname, String gender, String birthday, String major) {
          this.sid = sid;
          this.sname = sname;
          this.gender = gender;
          this.birthday = birthday;
          this.major = major;
      }
  
      public int getSid() {
          return sid;
      }
  
      public void setSid(int sid) {
          this.sid = sid;
      }
  
      public String getSname() {
          return sname;
      }
  
      public void setSname(String sname) {
          this.sname = sname;
      }
  
      public String getGender() {
          return gender;
      }
  
      public void setGender(String gender) {
          this.gender = gender;
      }
  
      public String getBirthday() {
          return birthday;
      }
  
      public void setBirthday(String birthday) {
          this.birthday = birthday;
      }
  
      public String getMajor() {
          return major;
      }
  
      public void setMajor(String major) {
          this.major = major;
      }
  
      @Override
      public Object clone() throws CloneNotSupportedException {
          return super.clone();
      }
  
      @Override
      public String toString() {
          return "Students{" +
                  "sid=" + sid +
                  ", sname='" + sname + '\'' +
                  ", gender='" + gender + '\'' +
                  ", birthday='" + birthday + '\'' +
                  ", major='" + major + '\'' +
                  '}';
      }
  }
  

• 4种方法创建对象

  package com.xbky.test;
  
  /*
  * Spring也不使用new来创建对象，是使用ioc容器来注入的。
  *
  * */
  
  import com.xbky.domain.Students;
  
  import java.io.*;
  import java.lang.reflect.Constructor;
  
  public class IocDemo {
  
      public static void main(String[] args) throws Exception {
          File file = new File("dest.data");
  
          Students s1 = new Students(100,"宋小宝","男","1999-10-10","二人转");
          System.out.println(s1);
  
          //使用clone来创建对象。
          Students s2 = (Students) s1.clone();
          System.out.println(s2);
  
          Students s3 = s1;
  
          System.out.println(s1 == s2);
          System.out.println(s3 == s1);
  
          //反射怎么创建对象呢。大家仔细观察我没有使用new.使用了反射。
          Class clazz = s1.getClass();
          Constructor constructor = clazz.getConstructor(int.class,String.class,String.class,String.class,String.class);
          Students s5 = (Students) constructor.newInstance(new Object[]{100,"小沈阳","女","1999-10-10","二人转"});
          System.out.println(s5);
  
          //反序列化创建对象。
          ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
          out.writeObject(s1); //把宋小宝对象写入到文件中。
  
          ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
          Students s6 = (Students) in.readObject();
          System.out.println(s6);
          System.out.println(s1 == s6);
      }
  }
  

  使用Spring IOC容器注入一个对象

  没有使用new,内部也是通过反射+xml文档的解析来实现的

  • 在resources创建一个applicationContext.xml文件

       <bean id="s1" class="com.xbky.domain.Students">
            <property name="sid" value="200"/>
            <property name="sname" value="张三丰"/>
            <property name="gender" value="男" />
            <property name="birthday" value="1998-10-10"/>
            <property name="major" value="太极拳" />
        </bean>

  • 创建一个类注入对象测试

    package com.xbky.test;
    
    import com.xbky.domain.Students;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class IocDemo2 {
    
        public static void main(String[] args) {
            //使用了spring ioc 容器注入了一个对象。没有使用new.内部也是通过反射+xml文档的解析来实现的。
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            Students s1 = (Students) context.getBean("s2");
            System.out.println(s1);
        }
    }
    

  • Spring IOC执行的顺序

    1. 到resources下加载applicationContext.xml

    2. 解析这个xml文档

    3. getBean（“s1”）从文档中解析到s1对象，使用java的反射机制，反射出一个对象出来返回

       注意：属性的初始化是通过setXXX来实现的，对象的创建通过调用默认的无参数的构造方法去实现的，那么要求类必须要保留那个默认的无参数构造方法，否则Spring ICO容器也无法实例化对象。

  • IOC对象初始化的步骤

    1. 加载applicationContext.xml
    2. 解析对应id对象
    3. 通过反射调用默认无参构造方法，实例化对象
    4. 通过调用setXXX，初始化属性

2.什么是maven?maven的核心功能有哪些？

• 作为 Apache 组织中的一个颇为成功的开源项目， Maven 主要服务于基于 java 平台的项目构建， 依赖管理和项目信息管理。 无论是小型的开源类库项目， 还是大型的企业级应用； 无论是传统的瀑布式开发， 还是流行的敏捷开发， Maven 都能大显身手。Maven有依赖管理、模块管理、插件管理和部署管理四大核心功能。
• 平常需要的库：http://mvnrepository.com/

2.1、依赖管理

例子：依赖Service

<dependencies>
  <dependency>
          <groupId>com.shsxt</groupId>
          <artifactId>wc-service</artifactId>
          <version>0.0.1-SNAPSHOT</version>
  </dependency>
</dependencies>

然后复制到pom.xml文件中，记得写在project便签和dependencies中，保存就依赖了

• groupId：项目隶属的实际项目-公司名称
• artifactId：模块-项目名
• version：项目当前所处的版本

2.2、模块管理

在 Maven 中需要定义一个 parent POM 作为一组 module 的聚合 POM。在该 POM 中可以使用 标签来定义一组子模块。 parent POM 不会有什么实际构建产出。 而 parent POM 中的 build 配置以及依赖配置都会自动继承给子 module。

例如子模块的pom.xml配置如下：

<modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.hbgc</groupId>
        <artifactId>base</artifactId>
        <version>1.0-SNAPSHOT</version>
        <!--父模块的pom.xml位置-->
        <relativePath>../base/pom.xml</relativePath>
    </parent>
    <groupId>com.hbgc</groupId>
    <artifactId>springbootdemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springbootdemo</name>
    <description>Demo project for Spring Boot</description>

2.3、插件管理

添加插件，类似于添加依赖, 通过 GAV 来指定插件, 其中对于maven官方插件, 可以省略 GroupId。例如：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-clean-plugin</artifactId>
            <version>3.0.0</version>
        </plugin>
    </plugins>
</build>

与控制依赖版本类似, 可以通过引用属性和 pluginManagement 对项目中的插件版本进行统一管理。注意 pluginManagement 元素需要放在 build 元素之下。

例如：

<build>
    <pluginManagement>
        <plugins>
            <plugin>
                <artifactId>maven-clean-plugin</artifactId>
                <version>3.0.0</version>
            </plugin>
            <plugin>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.0.2</version>
            </plugin>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
            </plugin>
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.20.1</version>
            </plugin>
            <plugin>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.2.0</version>
            </plugin>
            <plugin>
                <artifactId>maven-install-plugin</artifactId>
                <version>2.5.2</version>
            </plugin>
        </plugins>
    </pluginManagement>
</build>

2.4、部署管理

在idea中，我们可以打开maven project视图。在maven的生命周期列表中进行测试、打包和安装

3.什么是MVC？说说分层的好处。

• MVC是一个架构，或者说是一个设计模式，它就是强制性使应用程序的输入，处理和输出分开。

• 将一个应用程序分为三个部分

  • Model
  • View
  • Controller

• 原理图
  

  分析：

  1. Model 模型：（完成业务逻辑：由javaBean构成，在MVC的三个部件中，模型拥有最多的处理任务。例如它可能用象EJBs和javabean这样的构件对象来处理数据库。由于应用于模型的代码只需写一次就可以被多个视图重用，所以减少了代码的重复性。）
  2. View 视图（就是负责跟用户交互的界面。一般就是由HTML，css元素组成的界面，当然现在还有一些像js，ajax，flex一些也都属于视图层。 在视图层里没有真正的处理发生，之负责数据输出，并允许用户操纵的方式。MVC能为应用程序处理很多不同的视图。 ）
  3. Controller 控制器（接收请求—>调用模型—>根据结果派发页面并经过模型处理返回相应数据 ）

• MVC的优点

  1. 分工明确（开发人员可以只关注整个结构中的其中某一层）：使用MVC可以把数据库开发，程序业务逻辑开发，页面开发分开，每一层都具有相同的特征，方便以后的代码维护。它使程序员（Java开发人员）集中精力于业务逻辑，界面程序员（HTML和JSP开发人员）集中精力于表现形式上。
  2. 松耦合（可以降低层与层之间的依赖）：视图层和业务层分离，这样就允许更改视图层代码而不用重新编译模型和控制器代码，同样，一个应用的业务流程或者业务规则的改变只需要改动MVC的模型层即可。因为模型与控制器和视图相分离，所以很容易改变应用程序的数据层和业务规则。
  3. 复用性高（利于各层逻辑的复用）：像多个视图能够共享一个模型，不论你视图层是用flash界面或是wap界面，用一个模型就能处理他们。将数据和业务规则从表示层分开，就可以最大化从用代码。
  4. 有利于标准化（有利于通过工程化、工具化产生管理程序代码）

4.Spring的两大核心技术是什么？

• IOC（DI）：Inverse of Controller,控制反转。

​ Dependency Inject ,依赖注入。

• AOP(面向切面编程)

面向切面编程，简单地说就是在不改变原程序的基础上为代码段增加新功能，对代码段进行增强处理

5.什么是IOC/DI？

5.1、IOC(DI)

• Inverse of Controller：控制反转，把创建对象的操作交给框架，所以又被称为依赖注入

  • 最基础的调用的对象是通过new一个对象出来，例如：People p=new People
  • 我们Spring框架中的IOC即改变这种方式的调用，将后面“new People”转换为xml文件去调用，即使用第三者调用
  • 举例说明
    • People p=new People 相当于两个人之前的直接调用，假如张三和李四，张三需要用到只有李四电脑里面的一份文件，张三就必须直接向李四要，假如李四的电脑坏了，那么张三也就拿不到这份文件，然而IOC就相当于张三叫王五去拿这份文件，李四将文件拷贝给了王五，在这过程中即使李四的电脑坏了，那么张三也能从王五那拿到文件，张三不会受到影响。这就是控制反转的最大好处。即用来降低程序代码之间的耦合度

• Dependency Inject ,依赖注入。

  • setter方式注入
    创建学生类创建学生类，给予学生类一个学号，一个姓名的属性（此两个属性必须生成set方法，才能完成setter方式的注入）

    public class Student {
    
        //学号
        private int num;
        //姓名
        private String name;
    
        public void setNum(int num) {
            this.num = num;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }

    在applicationContext.xml文件中赋值

    <!-- setter方法注入 -->
    <bean id="stu" class="Student" >
            <property name="num" value="1"></property>
            <property name="name" value="李四"></property>
    
    </bean>

  • 构造注入
    给学生类写个带参的构造函数（写完带参的构造函数后，必须再定义一个无参的构造函数）

    //构造器注入
    public class Student {
    
        public Student(){
    
    
        }
        public Student(int num,String name){
    
        }
        //学号
        private int num;
        //姓名
        private String name;
    }

    在applicationContext.xml文件中赋值

    <!-- 构造器注入 -->
        <bean id="st" class="Student">
            <constructor-arg>
                <value type="java.lang.int">101</value>
            </constructor-arg>
            <constructor-arg> 
                <value type="java.lang.String">张三</value>
            </constructor-arg>
        </bean>

  • 使用P命名空间注入
    在Student最基础类的基础上，给ApplicationContext.xml文件中导入一个头的包

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    
    
        xmlns:p="http://www.springframework.org/schema/p"
    
    </beans>

    之后再xml用bean标签赋值

    <bean id="stu" class="test.Student" p:name="张三" p:num="1001">
    </bean>

6.谈谈面向对象编程与面向接口编程的区别。

面向接口编程：

面向对象编程中不同的对象协作完成系统的各个功能，对象内部的实现由各个类自己实现。但是随着系统愈发杂，对象内部功能的实现已经不那么重要了（类自己内部实现），反之对象间的协作能力更为重要，这就是面向接口编程的思想
面向接口编程:

就是先将业务的逻辑线先提取出来，作为接口，而将具体的代码实现作为实现类来完成。当客户需变化时，只用更改接口下的实现类就可以
面向接口编程优点：

• 降低耦合性，能极大限度解耦
• 易于程序扩展
• 易于程序维护

• 抽象类和接口的选择
  在于使用动机，使用抽象类是为了代码的复用，而使用接口的动机是为了实现多态性与协作关系
  面向接口编程

• 经典的面向接口编程例子-JDBC
  SUN公司提供了JDBC接口的规范，而不同的数据库厂商开发不同的数据库驱动
  可以理解为只有实现者和调用者都遵循"面向接口编程"这个准则，制定者的协调目的才能达到

7.什么是反射？说说反射是如何应用到spring框架上。

8.说说java 解析xml有哪些技术？

• Dom解析
  是html和xml的应用程序接口(API)，DOM文档对象模型，采用树形结构来完成对文档的解析，在解析时，会将整个文档加载到内存中然后形成"节点数",当文档内容过多或者需要解析的文档过多时，会造成服务器内存紧张
• SAX解析
  流模型中的"推'模型分析方式。通过事件驱动,每发现-个节点就引发一个事件 ，事件推给事件处理器，通过回调方法完成解析工作,解析XML文档的逻辑需要应用程序完成
• JDOM解析
  Java特定的文档对象模型。自身不包含解析器，使用SAX
• DOM4J解析
  简单易用，采用Java集合框架，并完全支持DOM、SAX和JAXP， 提供了一完整的针对DOM和SAX的解析技术， 目前使用较为广泛
• STAX解析
  流模型中的拉模型分析方式。提供基于指针和基于迭代器两种方式的支持,JDK1.6新特性

9.抽象类与接口的区别。

10.谈谈表单的同步提交与异步提交的区别

同步：提交请求->等待服务器处理->处理完毕返回，在此期间浏览器不能做别的事情
异步：请求通过事件触发->服务器处理（服务器任然可以做别的事情）->处理完毕
区别：
同步提交的时候客户端浏览器不能做别的事情，只能等待服务器处理；而异步提交的时候客户端浏览器任然可以做别的
可以理解为吃饭，同步就是我叫你去吃饭，你没听见，我继续叫你，知道你回答我了，一起去吃饭。
异步就是我给你发消息说我去吃饭了，然后我就先走了，你后面自己来