【软件设计师】Java题详细蒙题技巧1

序言

笔者最近在备考软考，2022年的软考快开始了，刷完了软件设计师的一轮Java软考题，感觉能抓住一些规律，笔者基础没有太过牢固，入门Java一个月跟敲代码学习（详情见零基础学Java系列），然后学完基础知识就直接上手了，没有学过设计模式，以下规律全都是笔者通过刷题总结出来的，如有错误还望谅解。本文适合对于Java一知半解的人来蒙题使用（当然，如果能懂得Java的一些基础以及知道大致的样子其实根据自己的能力也能做出来）

本文适合

对Java学到一知半解的人，想速通软考Java题的人。考试科目为：软件设计师中级考试。可能是目前所能找到最详细的针对软考Java的博客了，笔者找了很多经验贴看，奈何许多帖子没有说得太清楚，笔者自学了一段时间Java（零基础学Java系列）然后总结出来的下面经验，希望能帮到大家。笔者可能资质尚浅，斗胆发表见解，如果有错误和理解不当的地方，还望多多指教。

序言
- 本文适合
题型分布
共有规律

题型分布

年份	时间	模式
2009	上	桥接
2009	下	组合
2010	上	策略
2010	下	组合
2011	上	组合
2011	下	状态
2012	上	装饰
2012	下	抽象工厂
2013	上	原型
2013	下	桥接
2014	上	观察者
2014	下	命令
2015	上	访问者
2015	下	策略
2016	上	适配器
2016	下	装饰
2017	上	生成器
2017	下	桥接
2018	上	生成器
2018	下	状态
2019	上	策略
2019	下	观察者
2020	下	中介者
2021	上	组合
2021	下	享元

（2020年因为找不到Java的的，先这么放着）

其中题型：

组合模式：4次。

桥接模式：3次。

策略模式：3次。

装饰器模式：2次。

生成器模式：2次。

观察者模式：2次。

状态模式：2次。

抽象工厂：1次。

原型模式：1次。

适配器模式：1次。

享元模式：1次。

命令模式：1次。

访问者模式：1次。

一下我将叙述所有模式都共有的一些挖空规律。

共有规律

接口类interface及其内部挖空

interface关键词是接口的意思，一般软考在这部分会在如下几个地方挖空：

挖空一个类的类型。而这个类是一个接口。比如

(1) Observer{
	public void update();

}

如果出现上面那种情况，请观察下方是否有出现implements这个关键词，比如：

class DocExplorer implements Observer{
    XXXXXXXXXXXXXXXXXXXXXXXXXXXX
}

如果有，（1）空填写interface。请注意，implements后面跟的一定要是这个接口的名字，比如上述接口名字叫做Observer，那么下方出现了一个类是实现了这个接口，即implements了这个接口。题目可能会出现两个及以上接口，请注意辨别当前类是否是implements了要填空的那个接口。

接口内部挖空，比如：

interface Observer{
	 （1）;

}

这种情况，请找到implements实现了这个接口的类，比如下面：

class DocExplorer implements Observer{
    private String myObsName;
    public DocExplorer(String name, Subject sub){
        myObsName = name;
        sub.Attach(this)
    }
    public void update(){
    	System.out.println("update observer["+myObsName"]");
    }
}

上面可以看到，有方法DocExplorer以及update方法，再仔细观察一下，DocExplorer居然和这个类名一样，这种出现重名的方法名字为构造方法，这种方法我们可以排除。而除此之外的方法就是我们要找的，也就是update方法。

此处可以专门找一下构造方法学习一下，笔者也会在后面在构造方法挖空的时候再详细说明。笔者在这里简要说明一下构造方法的作用：构造方法的作用一般是对于这个类的属性进行管理的。比如上面DocExplorer类有一个属性myObsName，可以看到，构造方法有个输入参数：String name，然后还有一条语句：myObsName = name;

①private String myObsName

②输入参数：String name

③myObsName = name

通过这三者，我在这个类的外面输入一个参数，那么这个实参就会通过输入参数，进入这个等式，然后通过等号，右边的值赋给左边，然后使得myObsName的值就是我所赋予的。

通过上面的解释可以看到，构造方法的用处有一个用处就是可以为当前这个类赋予初值。在构造方法内挖空也会出现，笔者在下面会讲到。

我们把目光返回到update方法上，可以显而易见，（1）空填写的是： public void update()。请注意，public，void，这些修饰符别少写。

如果运气好，笔者见过（大部分题型都会有）出现一个接口被两个类实现的情况：

可以从图里看到，接口方法是：public int getNumberOfPages();

抽象类abstract及其内部挖空

挖空一个类的类型。而这个类是一个抽象类。比如：

(1) class Piece{
	XXXXXXXXXXXXXXXXXXXXX
}

这种解法和接口类的填写一样，请观察下方是否有出现extends这个关键词，比如：

class BlackPiece extends Piece{
    XXXXXXXXXXXXXXXXXXXXXX
}

如果有，（1）空填写abstract。请注意，extends后面跟的一定要是这个抽象类的名字。比如上述抽象类名字叫做Piece，那么下方出现了一个类是继承了这个抽象类，即extends了这个抽象类。请注意辨别当前类是否是extends了要填空的那个抽象类。

抽象类内挖空，如：

abstract class Piece{
	protected PieceColor m_color;
	protected PiecePos m_pos;
	public Piece(PieceColor color,PiecePos pos){
		m_color = color;
		m_pos = pos;
	}
	(1)
}

和上面接口类似，我们找找继承它的类：

class BlackPiece extends Piece{
	public BlackPiece(PieceColor color,Piece pos){
		super(color,pos);
	}
	public void draw(){System.out.println("update observer["draw a blackpiece"]");}
}
class WhitePiece extends Piece{
	public WhitePiece(PieceColor color,Piece pos){
		super(color,pos);
	}
	public void draw(){System.out.println("update observer["draw a whitePiece"]");}
}

比如上面，可以看到WhitePiece和BlackPiece类都继承了Piece抽象类，除了它本身名字的方法（构造方法）外，都是父类抽象类的方法，即：public abstract void draw()。填写方法的时候，请一定加上abstract关键词！

这里就不过多解释为什么要加上abstract关键词，只要知道，abstract类里面不一定有abstract方法，但是abstract方法一定在abstract类中。而软考如果在abstract类挖空，一定是abstract方法！

构造方法里面挖空

比如下面：

class ShortWheelCar extends Car{
	public ShortWheelCar(BrakeBehavior behavior){
		(4)
	}
}

前面说到，构造方法的作用就是给当前这个类赋予初值的作用。那么可以猜测，（4）空就是this.XXX=XXX的类型（构造方法里面很多时候都是this.XXX = XXX的），一般来说，等号右边是形参，即图中的behavior，而等号左边，两种情况：

①当前类有没有属性

②当前类的父类有没有属性

如上述例子，很明显这个类没有属性，那么我们找它的父类，果然：

abstract class Car{
	protected BrakeBehavior wheel;
	public void brake(){wheel.stop()};
}

可以看到当前类ShortWheelCar的父类Car有属性：wheel，而且对比两边类型，都是BrakeBehavior类的，很明显对应上了。

所以（4）应该填上：this.wheel = behavior。

而①的情况有：

abstract Company{
	protected String name;
	public Company(String name){
		（2）=name;
	}
}

很明显，这里为this.name = name。

总结一句话就是：构造器里面挖空，一般是this.XXX=XXX的格式，等号左边首先看看当前类有没有属性，如果没有再看看父类有没有属性，等号右边一般看看构造方法的形参，最后等号两边的类型一定要对的上。

在方法里面挖空：

请记住一句话：定义了的对象一定会用上的。

据笔者的部分经验，这部分一般都是填写【对象.方法】，首先要找到正确的对象，然后去这个对象的类找找看有什么方法适用的，比如：

class ConcreteCompany extends Company{
	private List<Company>children = new ArrayList<Company>();
	public ConcreteCompany(String name){super(name)};
	public void Add(Company c){(5).add(c)};
}

首先可以看到，（5）所在的类定义了children对象，定义了一定要用，所以是children.add(c),其中add，remove是数组自带的方法。

再比如：

public class Teat{
	public static void main(String[] args){
	ConcreteCompany root = new ConcreteCompany("XXXX");
	(1).Add(new HRDepartment("XXXXXX"));
	(2).Add(new FinanceDepartment("XXXXXX"));
	}
}

根据定义了就要用的原则，有root对象，再看看root对象所在的类：

class ConcreteCompany extends Company{
	private List<Company>children = new ArrayList<Company>();
	public ConcreteCompany(String name){super(name)};
	public void Add(Company c){(5).add(c)};
}

有Add方法，那肯定是填写root的。

在集合定义里面挖空

请记住以下格式：

ArrayList<集合中的元素的数据类型> 集合名字 = new ArrayList<集合中的元素的数据类型>()；

挖空会挖集合中的元素的数据类型。

如：

class OfficeDoc implements Subject{
	private List<(2)>myObs;
	private String mySubjectName;
	private int m_status;
	public OfficeDoc(String name){
		mySubjectName = name;
		this.myObs = new ArrayList<Observer>();
		m_status = 0;
	}
	XXXXXXXXXX
}

出题人精明地很，有时候会直接给出一个定义式，有时候会拆开来定义，可以看到，上述代码以myObs作为桥梁来定义了一个集合，并且是在构造方法里面定义的，所以可以找到这个集合的类型：Observer。

在实例化定义里面挖空

这个就比较难了，有两种情况：

父类对象名1 = new 父类（）
父类对象名2 = new 子类（）

其中，1为普通的实例化，2为多态。有时候挖空会在new那边挖空，填写父类或者子类，这些则需要题目的理解以及刷题，或者看Java基础教程学习了。

以上，就是笔者总结的所有能够用得上的蒙题技巧，笔者也依靠这些技巧做对了一些题目，运气好有对四五个空，运气差能对两三个空左右，分享出来，

还望在博客园的下面点个推荐，谢谢！

posted @ 2022-05-13 21:25 机智的小柴胡阅读(7046) 评论(1) 收藏举报

刷新页面返回顶部

麦田里的北极熊

记录从零开始的自己