javaee作业 struts javaee课后作业答案

文章目录

• 1.Java创建对象有哪些方式
• 2.什么是maven?maven的核心功能有哪些
• 3.什么是MVC？说说分层的好处
• 4.Spring的两大核心技术是什么？
• 5.谈谈面向对象编程与面向接口编程的区别
• 6.什么是反射？说说反射是如何应用到spring框架上
• 7.说说java解析xml有哪些技术？
• 8.抽象类与接口的区别
• 9.谈谈表单的同步提交与异步提交的区别

1.Java创建对象有哪些方式

1. 使用new关键字
2. 使用clone()方法
   实体类实现Cloneable接口，重写clone()方法，调用clone()方法，克隆得到的对象与原来的对象不是一个对象
3. 使用反射
   得到Students类的Class对象，根据Class对象得到构造器，再根据构造器得到对象
4. 使用对象的反序列化
   西安序列化将对象写入文件中，再反序列化从文件中得到对象，记得关闭流
5. 使用spring获得对象
   先在xml配置文档里配置好对象的属性与id值，得到与配置文档的连接，根据配置文档里id属性的值，得到对象

Java代码：

//Students类
package org.westos.domain;

import java.io.Serializable;

public class Students implements Cloneable, Serializable {
    private String sid;
    private String sname;
    private String gender;
    private String birthday;
    private String major;
    
    //实现Cloneable接口，重写父类的clone()方法
    @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 + '\'' +
                '}';
    }

    public Students() {
    }

    public Students(String 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 String getSid() {
        return sid;
    }

    public void setSid(String 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;
    }
}


//测试类
package org.westos.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.westos.domain.Students;

import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;


public class Test {
    public static void main(String[] args) throws CloneNotSupportedException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException, InvocationTargetException {
        //1.使用new关键字创建对象
        Students s1 = new Students("001", "张三", "男", "1993-02-03", "古文");
        System.out.println("s1:" + s1);

        //2.使用clone()方法创建对象
        Students s2 = (Students) s1.clone();
        System.out.println("s2:" + s2);
        System.out.println(s1 == s2);//s1与s2不相等

        //3.使用反射得到对象
        Class aClass = Class.forName("org.westos.domain.Students");//使用类名得到类的Class对象
        //使用构造器的参数得到构造器
        Constructor constructor = aClass.getConstructor(String.class, String.class, String.class, String.class, String.class);
        //使用构造器得到对象
        Students s3 = (Students) constructor.newInstance(new Object[]{"002", "李四", "男", "1994-02-04", "高数"});
        System.out.println("s3:" + s3);

        //4.使用反序列化得到对象
        //得到对象输出流
        File file = new File("studentLists.text");
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
        //将对象序列化写到文件studentLists.txt中
        out.writeObject(s2);
        //得到对象输入流
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
        //反序列化读取对象
        Students s4 = (Students) in.readObject();
        System.out.println("s4:" + s4);
        //关闭流资源
        in.close();
        out.close();

        //5.使用spring中的IOC获取对象
        //与配置文档applicationContext.xml建立连接
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //根据配置文档里的id属性的值，获得对象
        Students s5 = (Students) context.getBean("s2");
        System.out.println("s5:" + s5);
    }
}

applicationContext.xml配置文档：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--定义学生对象-->
    <bean id="s1" class="org.westos.domain.Students">
        <property name="sid" value="003"/>
        <property name="sname" value="张三丰"/>
        <property name="gender" value="男"/>
        <property name="birthday" value="1998-10-10"/>
        <property name="major" value="太极拳"/>
    </bean>

    <!--定义学生对象-->
    <bean id="s2" class="org.westos.domain.Students">
        <property name="sid" value="004"/>
        <property name="sname" value="王五"/>
        <property name="gender" value="男"/>
        <property name="birthday" value="1999-10-10"/>
        <property name="major" value="乒乓球"/>
    </bean>
</beans>

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

1. 什么是maven
   管理项目的构建，报告和文档的项目管理工具软件。将程序中要使用的jar包存在放在maven仓库中，只需要在pom.xml文档中进行配置，就可以联网获得对应的jar包，而且会将所导入的jar包的所有依赖的jar包一起导入进去
2. 核心功能

1. 依赖管理
2. 模块管理
3. 插件管理
4. 部署管理

3. 生命周期
   maven将工程的构建过程理解为不同的生命周期和阶段， 一个工程的构建过程中，存在着不同的生命周期，生命周期间互相独立，没有一定的顺序关系。 每个生命周期又划分为不同的阶段，不同的阶段之间有明确的顺序关系， 同一生命周期内的阶段必须按顺序依次执行。

1. clear（清除）

1. pre-clean：执行清理的准备工作
2. clean：执行清理工作
3. post-clean：执行清理后的后续工作

2. default（核心）

1. validate：验证项目的正确性及项目所必需的信息是否可用
2. compile：编译项目中代码
3. test：用相关的单元测试框架测试编译后的代码，测试代码并不会随项目打包和布署
4. package：将编译后的代码打包成相应的格式文件，如jar包
5. integration-test： 如果需要在一个综合环境中运行我们的测试，这个阶段将会运行和布署项目到该环境中
6. verify： 检查项目中的包是否正确与符合要求
7. install：将包安装到本地maven仓库，其他项目也可以使用该包作为依赖
8. deploy：将包发布到远程的maven仓库，并提供给其他开发者使用

3. site（建立发布项目站点）

1. pre-site：准备生成
2. site：生成项目站点和文档
3. post-site：执行生成文档后的后续工作
4. site-deploy：发布项目文档

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

1. 什么是MVC
   MVC 是一种使用 MVC（Model View Controller 模型-视图-控制器）设计创建 Web 应用程序的模式。

1. Model（模型）：表示应用程序核心，应用程序中用于处理应用程序数据逻辑的部分，通常模型对象负责在数据库中存取数据
2. View（视图）：显示数据，应用程序中处理数据显示的部分，通常视图是依据模型数据创建的
3. Controller（控制器）：处理输入，应用程序中处理用户交互的部分，通常控制器负责从视图读取数据，控制用户输入，并向模型发送数据

2. 优点

1. 开发人员可以只用管理结构中的某一层
2. 容易使用新的层实替换原有的层
3. 降低层间依赖、也就是解耦，降低程序耦合度
4. 有利于各层逻辑的复用

3. 缺点

1. 降低了系统的性能，必须通过中间层才能访问数据库
2. 有时会倒是级联的修改，尤其是在上层做出修改后，下层的结构也要做出对应的修改

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

1. IOC（控制反转）/DI（依赖注入）

1. 一般来说在Java中创建对象是使用new关键字创建的，而使用IOC，只需要在配置文档中进行配置，使用配置文档中的数据进行对象的创建。不用再使用new关键字创建
2. IOC创建对象的过程是使用类的默认无参构造创建对象，然后使用类的set方法进行属性的赋值
3. IOC创建对象的本质是反射

2. AOP面向切面编程

1. 可以简单的理解为在不改变原有程序的基础上为代码增加新的功能
2. 分为前置增强、后置增强、最终增强、异常增强、环绕增强
3. 需要在原有的类上定义一个切口（方法），然后定义一个用于增强的AOP类，可以在类中定义增强的方法。最后在xml配置文档中进行配置

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

1. 什么是面向接口编程
   面向对象编程中不同的对象协作完成系统的各个功能，对象内部的实现由各个类自己实现。但是随着系统愈发复杂，对象内部功能的实现已经不那么重要了（类自己内部实现），反之对象间的协作能力更为重要，这就是面向接口编程的思想
   面向接口编程就是先将业务的逻辑线先提取出来，作为接口，而将具体的代码实现作为实现类来完成。当客户需求变化时，只用更改接口下的实现类就可以
2. 面向接口编程优点

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

3. 抽象类和接口的选择
   在于使用动机，使用抽象类是为了代码的复用，而使用接口的动机是为了实现多态性与协作关系
4. 经典的面向接口编程例子-JDBC
   SUN公司提供了JDBC接口的规范，而不同的数据库厂商开发不同的数据库驱动

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

1. 什么是反射
   反射是Java中一个非常重要的特性，它允许程序在运行时进行自我检查，同时也允许对其内部成员进行操作。主要有：得到一个对象所属的类、获取一个类的所有成员变量和方法、在运行时创建对象、在运行时调用对象的方法等
2. 反射的优点
   可以动态创建对象和编译，体现出很大的灵活性，通过反射机制可以获得类的各种内容，对于JAVA这种先编译再运行的语言来说，反射机制可以使代码更加灵活
3. 反射机制的缺点
   对性能有影响，使用反射基本上是一种解释操作，这类操作总是慢于只直接执行相同的操作
   破坏了类的封装性，不安全
4. 反射机制应用到spring框架中

1. 加载resourse资源目录下的配置文件
2. 解析配置文件
3. 从配置文件中找到对应id属性值的对象
4. 通过反射调用默认的无参构造创建对象
5. 使用set方法对属性赋值
6. 返回创建的对象

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

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

8.抽象类与接口的区别

1. 语法区别

1. 抽象类可以有构造方法，接口中不能有构造方法
2. 抽象类中可以有普通成员变量，接口中没有普通成员变量
3. 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法
4. 抽象类中的抽象方法的访问类型可以是public，protected，但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是默认public static final类型
7. 一个类可以实现多个接口，但只能继承一个抽象类

2. 应用区别

1. 接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的联系
2. 抽象类主要在代码实现方面发挥作用，来实现代码的重用

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

1. 处理步骤

1. 同步：提交请求->等待服务器处理->处理完毕返回，在此期间浏览器不能做别的事情
2. 异步：请求通过事件触发->服务器处理（服务器任然可以做别的事情）->处理完毕

2. 区别
   同步提交的时候客户端浏览器不能做别的事情，只能等待服务器处理；而异步提交的时候客户端浏览器任然可以做别的
   可以理解为吃饭，同步就是我叫你去吃饭，你没听见，我继续叫你，知道你回答我了，一起去吃饭。
   异步就是我给你发消息说我去吃饭了，然后我就先走了，你后面自己来
3. 具体应用
   同步表单使用submit按钮提交，执行表单的action动作会出现页面假死的现象，用户体验不好
   异步表单使用ajax异步提交，通过普通按钮提交实现页面局部刷新，用户体验好，大多数使用