软件设计模式（课堂测试）

最新推荐文章于 2024-06-17 16:00:22 发布

Roobert_Chao

最新推荐文章于 2024-06-17 16:00:22 发布

阅读量823

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/Roobert_Chao/article/details/87926630

版权

java 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

软件设计模式（第一节课堂测试）

后期持续更新。有不对的地方请多多指教。
2019.02.25

文章目录

软件设计模式（第一节课堂测试）
软件设计模式（第二节课堂内容）

01、什么是面向过程、面向过程的核心思想是什么？

1. 面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候依次调用就可以了。
面向过程的百度百科
2. 面向过程其实是最为实际的一种思考方式，就算是面向对象的方法也是含有面向过程的思想。
3. 一般的面向过程是从上往下步步求精，所以面向过程最重要的是模块化的思想方法。对比面向过程，面向对象的方法主要是把事物给对象化，对象包括属性与行为。

02、什么是面向对象、面向对象的核心理念是什么？

1. 面向对象是把构成问题事务按照一定规则划分为多个独立的对象，然后通过调用对象的方法来解决问题。
2. 在面向对象的思想中，最核心的就是对象。封装是面向对象的核心思想。
3. 面向对象的核心思想是对象，封装，可重用性和可扩展性。
在这里插入图片描述

面向过程与面向对象的举例对比

1. 表演

面向对象的思想
演出由两大部分组成：主持人、演员。与主持人相关的：开场、总结。与演员相关的：演员编号、所演的节目。
演出就可以这样策划：需要一个主持人a，需要两个演员b、c。演出的事情可以表示为：a的开场——> b、c的编号和节目——> a的总结。
面向过程的思想
主持人开场——》演员一》表演——》演员二表演——》主持人总结
先完成主持人开场，再完成演员一的表演，再完成演员二的表演，最后完成主持人的总结。

2.下五子棋

面向对象的思想

按照上述内容分为三类对象：第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。
面向过程的思想

上述步骤分别用函数来实现。

面向对象和面向过程的代码更新（大象装箱）

面向过程代码在不改动既有数据结构的前提下添加新函数。

public void open(){
	System.out.println("开门");
}
public void load(){
	System.out.println("装箱");
}
public void close(){
	System.out.println("关门");
}

对函数功能需要了解，一步一步的函数执行，如果增加操作，则需要添加新的函数。

open();	// 打开箱子
load();		// 将大象装进箱子
close();	// 关上箱子

面向对象代码便于在不改动既有函数前提下添加新类。

/*  首先创建对象  */
public class Elephant{
	public Elephant(){}
	public void open(){
		System.out.println("开门");
	}
	public void load(){
		System.out.println("装箱");
	}
	public void close(){
		System.out.println("关门");
	}
}

在面向对象的时候，则是使用类创建对象. 最后用对象去执行相关的操作。如有其它更新操作的情况，则需要更新类。

Elephant elephant = new Elephant();		//  使用类创建对象
elephant .open();		// 由对象去调用方法
elephant .load();
elephant .close();

03、Java 中，用程序说明多态的实现。

Java 三大特性：封装、继承、多态

继承的多态

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

接口的多态

// 定义接口 Animal
interface Animal{
	void shout();		// 定义抽象 shout方法
} 
// 定义 Cat 类实现 Animal 接口
class Cat implement Animal{
	// 实现 shout方法
	public void shout(){
		System.out.println("喵喵……");
	}
}
// 定义 Dog 类实现 Animal 接口
class Dog implement Animal{
	// 实现 shout方法
	public void shout(){
		System.out.println("汪汪……");
	}
}
// 定义测试类
public class TestExample{
	public static void main(){
		Animal a1 = new Cat();		// 创建 Cat 对象，使用Animal类型变量 a1 引用
		a1.shout();
		Animal a2 = new Dog();
		a2.shout();
	}
}

04、Java 中，用程序说明反射机制。

Java 反射机制的说明

在这里插入图片描述

05、Java 中，用程序写出三种集合类的遍历。

在这里插入图片描述

集合体系架构

单列集合 Collection
包括 List : Arraylist、LinkedList、Vector
包括 Set : HashSet -->LinkedHashSet 、TreeSet

双列集合 Map
包括 Hashtable --> properties
包括 HashMap --> LinkedHashMap
包括 TreeMap

List 集合的遍历

ArrayList list = new ArrayList();	// 创建 ArrayList 集合
list.add("Jack");list.add("Tom");
Iterator it = list.iterator();	// 获得 Iterator 对象
while(it.hasNext()){		// 判断该集合是否有下一个元素
	Object obj = it.next();		// 获取该集合中的元素
	System.out.println(obj);  // 输出集合的元素
}

Set集合的遍历（确保不出现重复的元素）

HashSet set= new HashSet ();	// 创建 HashSet 集合
set.add("Jack");set.add("Tom");	// 向该 Set 集合中添加字符串
set.add("Tom");  // 添加重复的元素
Iterator it = set.iterator();	// 获得 Iterator 对象
while(it.hasNext()){		// 通过 While 循环，判断集合中是否有元素
	Object obj = it.next();		// 获取该集合中的元素
	System.out.println(obj);  // 输出集合的元素
}

Map 集合的遍历

Map map = new HashMap();		// 创建 Map 集合
map.put("1","Jack");map.put("2","Tom");map.put("3","Cat"); 
Set KeySet = map.keySet();	// 获取键的集合
Iterator it = keySet.iterator();	// 迭代键的集合
while(it.hashNext()){
	Object key = is.nect();
	Object value = map.get(key); // 根据键获取值
	System.out.pringln(key+"："+value);
}

源码地址：

06、简单描述 Servlet 的工作流程。

在 Web 项目中，web.xml 文件中配置 servlet与servlet-mapping，在 web 项目加载的时候，Servlet 类会加载到内存中，实例化并调用 init() 方法来初始化该Servlet

工作流程如下：

客户端浏览器向服务器端发送请求。
服务器端由Tomcat服务器提供的Servlet容器解析接收到的请求。
通过Web应用程序的配置文件web.xml，解析到对应执行的Servlet。
调用 service() 方法，传递请求和响应对象作为参数秒选不择 doGet()/doPost() 处理请求。
Servlet完成客户端发送的请求逻辑，并完成向客户端发送的响应内容。
由Tomcat服务器提供的Servlet容器向客户端浏览器进行响应。
当 Server 服务器不再需要 Servlet 时（一般当 Server 关闭时），Server 调用 Servlet 的 destroy() 方法。

Tomcat 才是与客户端直接打交道的家伙。监听了端口，请求过来后，根据 url 等信息，确定要将请求交给哪个 Servlet 去处理，然后调用那个 Servlet 的service() 的方法，service 方法返回一个 response 对象，tomcat 再把这个对象返回给客户端。

可以看下图：
在这里插入图片描述

07、SSM 框架中，每个框架在数据处理中的作用。

SpringMvc 拥有前端控制器，接收外部请求，解析参数给服务层。Spring容器属于协调上下文，管理对象间的依赖，提供事务机制。Mybatis 属于 orm 持久层框架，将业务实体与数据表联合起来。
在这里插入图片描述

08、Java 体系的知识图谱。

菜鸟教程Java基础教程

09、B/S框架结构、C/S框架结构、MVC框架结构。

B/S框架结构

B/S(浏览器/服务器模式)是随着Internet技术的兴起，对C/S结构的一种改进。在这种结构下，软件应用的业务逻辑完全在应用服务器端实现，用户表现完全在Web服务器实现，客户端只需要浏览器即可进行业务处理，是一种全新的软件系统构造技术。这种结构更成为当今应用软件的首选体系结构。e通管理系列产品即属于此类结构。

C/S框架结构

C/S结构软件（即客户机/服务器模式）分为客户机和服务器两层，客户机不是毫无运算能力的输入、输出设备，而是具有了一定的数据处理和数据存储能力，通过把应用软件的计算和数据合理地分配在客户机和服务器两端，可以有效地降低网络通信量和服务器运算量。由于服务器连接个数和数据通信量的限制，这种结构的软件适于在用户数目不多的局域网内使用。国内现阶段的大部分ERP（财务）软件产品即属于此类结构。

MVC框架结构

Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。MVC被独特的发展起来用于映射传统的输入、处理和输出功能在一个逻辑的图形化用户界面的结构中。

MVC框架结构
在这里插入图片描述

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

Servlet 补充内容

第一个客户端的请求到达 Server；
Server 调用 Servlet 的 init() 方法（可配置为 Server 创建 Servlet 实例时调用，在 web.xml 中标签下配置标签，配置的值为整型，值越小 Servlet 的启动优先级越高）；
一个客户端的请求到达 Server；Server 创建一个请求对象，处理客户端请求；Server 创建一个响应对象，响应客户端请求；
Server 激活 Servlet 的 service() 方法，传递请求和响应对象作为参数；
service() 方法获得关于请求对象的信息，处理请求，访问其他资源，获得需要的信息；
service() 方法使用响应对象的方法，将响应传回Server，最终到达客户端。service()方法可能激活其它方法以处理请求，如 doGet() 或 doPost() 或程序员自己开发的新的方法；
对于更多的客户端请求，Server 创建新的请求和响应对象，仍然激活此 Servlet 的 service() 方法，将这两个对象作为参数传递给它。如此重复以上的循环，但无需再次调用 init() 方法（仅执行一次）。一般 Servlet 只初始化一次(只有一个对象)，当 Server 不再需要 Servlet 时（一般当 Server 关闭时），Server 调用 Servlet 的 destroy() 方法。

软件设计模式（第二节课堂内容）

使用面向对象和面向过程的方式进行加减乘除的二元运算。

面向对象中使用的是 简单工厂模式

package cn.chao.operation;

import java.math.BigDecimal;
import java.util.Scanner;


public class OperationMain {

	
	public static void main(String[] args) {
		// 开始输入提示
		System.out.println("请输入您要执行的操作符（+、-、*、/）：");
		// 开启控制台输入
		Scanner scanner = new Scanner(System.in);
		String oper = scanner.next();
		// 创建运算操作对象
		String regOfOperator = "^([+,\\-,*,/]{1})$";//验证运算符
		if (oper.matches(regOfOperator)) {
			System.out.println("请输入您要执行的两个操作数（数字类型，以空格分隔开）：");
			String num1 = scanner.next();
			String num2 = scanner.next();
			// 判断是否是小数 ？
			String vailed = isVailed(num1, num2);
			Operation operation = OperationFactory.createOperation(vailed,oper);
			// 设置对象操作数
			operation.setNum1(num1);
			operation.setNum2(num2);
			// 计算运算结果
			String result = operation.Oper();
			System.out.println("结果："+num1+" "+oper+" "+num2 +" = "+result);
		}else{
			System.out.println("操作符非法");
		}
		// 关闭控制台输入
		scanner.close();
	}
	// 判断是否是包含 "." ， 小数包含 "." 。
	public static String isVailed(String num1,String num2){
		String regOfDouble = "^([0-9]{1,}[.]{1}[0-9]{1,})$"; //验证正小数
		String regOfInt = "^(([1-9]{1}[0-9]{0,})||([0]{1}))$"; //验证正整数
		if(num1.matches(regOfDouble)||num2.matches(regOfDouble)){
			return "isDouble";
		}
		if(num1.matches(regOfInt)||num2.matches(regOfInt)){
			return "isInt";
		}
		return "notAllow";
	}
}
// 根据运算符 及 类型标识符，进行对象实例。
class OperationFactory{
	public static Operation createOperation(String is,String operation){
		// 声明对象
		Operation oper = null;
		// 使用多态，实例化操作对象。
		if(is.equals("isInt")){
			switch (operation) {
			case "+":
				oper = new OperationIntAdd();
				break;
			case "-":
				oper = new OperationIntSub();
				break;
			case "*":
				oper = new OperationIntMul();
				break;
			case "/":
				oper = new OperationIntDiv();
				break;
			default:
				break;
			}
		}else if(is.equals("isDouble")){
			switch (operation) {
			case "+":
				oper = new OperationDoubleAdd();
				break;
			case "-":
				oper = new OperationDoubleSub();
				break;
			case "*":
				oper = new OperationDoubleMul();
				break;
			case "/":
				oper = new OperationDoubleDiv();
				break;
			default:
				break;
			}
		}
		return oper;
	}
}
// 创建 父类对象，封装对象属性，编写计算方法。
abstract class Operation{
	protected String num1;
	protected String num2;
	
	public String getNum1() {
		return num1;
	}
	public void setNum1(String num1) {
		this.num1 = num1;
	}
	public String getNum2() {
		return num2;
	}
	public void setNum2(String num2) {
		this.num2 = num2;
	}
	abstract String Oper();
}
// 继承抽象父类，实现抽象方法。完成 整数类型加法操作。
class OperationIntAdd extends Operation{
	@Override
	String Oper() {
		int count = Integer.valueOf(num1)+Integer.valueOf(num2);
		return String.valueOf(count);
	}
}
//继承抽象父类，实现抽象方法。完成 整数类型减法操作。
class OperationIntSub extends Operation{
	@Override
	String Oper() {
		int count = Integer.valueOf(num1)-Integer.valueOf(num2);
		return String.valueOf(count);
	}
}
//继承抽象父类，实现抽象方法。完成 整数类型乘法操作。
class OperationIntMul extends Operation{
	@Override
	String Oper() {
		int count = Integer.valueOf(num1)*Integer.valueOf(num2);
		return String.valueOf(count);
	}
}
//继承抽象父类，实现抽象方法。完成 整数类型  除法 操作。
class OperationIntDiv extends Operation{
	@Override
	String Oper() {
		int count = Integer.valueOf(num1)/Integer.valueOf(num2);
		return String.valueOf(count);
	}
}
//继承抽象父类，实现抽象方法。完成 双精度浮点型 加法操作。
class OperationDoubleAdd extends Operation{
	@Override
	String Oper() {
		Double count = Double.valueOf(num1)+Double.valueOf(num2);
		return String.valueOf(count);
	}
}
//继承抽象父类，实现抽象方法。完成 双精度浮点型减法操作。
class OperationDoubleSub extends Operation{
	@Override
	String Oper() {
		Double count = Double.valueOf(num1)-Double.valueOf(num2);
		return String.valueOf(count);
	}
}
//继承抽象父类，实现抽象方法。完成 双精度浮点型 乘法操作。
class OperationDoubleMul extends Operation{
	@Override
	String Oper() {
		Double count = Double.valueOf(num1)*Double.valueOf(num2);
		return String.valueOf(count);
	}
}
//继承抽象父类，实现抽象方法。完成 双精度浮点型除法操作。
class OperationDoubleDiv extends Operation{
	@Override
	String Oper() {
		BigDecimal b1 = new BigDecimal(num1);
		BigDecimal b2 = new BigDecimal(num2);
		BigDecimal divide = b1.divide(b2);
		return String.valueOf(divide);
	}
}
// 添加 三位数加法运算
class ThridOperation extends Operation{
	String num3;
	
	public String getNum3() {
		return num3;
	}

	public void setNum3(String num3) {
		this.num3 = num3;
	}

	@Override
	String Oper() {
		int count = Integer.valueOf(num1)+Integer.valueOf(num2)+Integer.valueOf(num3);
		return String.valueOf(count);
	}
}

Roobert_Chao

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
软件设计模式（课堂测试）

软件设计模式（第一节课堂测试）后期持续更新。有不对的地方请多多指教。2019.02.25文章目录软件设计模式（第一节课堂测试）01、什么是面向过程、面向过程的核心思想是什么？02、什么是面向对象、面向对象的核心理念是什么？03、Java 中，用程序说明多态的实现。04、Java 中，用程序说明反射机制。05、Java 中，用程序写出三种集合类的遍历。06、简单描述 Servlet 的工作...
复制链接

扫一扫

专栏目录