设计模式六生口径

 

 

 HTML之核心组织

  今天张同样首讲解设计模式六大规格的章,非常深刻细致,转过来为大家一齐学习。

<!DOCTYPE HTML>

 

<html>

作者:zhengzhb ,发布于2012-11-2,来源:CSDN

<head>

   

<meta charset=”UTF-8″>

  设计模式六死条件(1):单一任务规范

<title>标题</title>

  定义:不要有多于一个导致类似变更的因由。通俗的说,即一个近乎就负责同起职责。 
问题因:类T负责两独不同的天职:职责P1,职责P2。当由任务P1需求发生转移如果需要改类T时,有或会见导致原先运行如常的任务P2功能来故障。

<link href=”XXX.css” rel=”stylesheet”>

  解决方案:遵循单一任务规范。分别树两单类T1、T2,使T1完成任务P1功能,T2完成任务P2功能。这样,当修改类T1常常,不会见要职责P2发生故障风险;同理,当修改T2不时,也非会见如职责P1发生故障风险。

<script type=”text/javascript” src=”XXX.js”></script>

  说交纯任务规范,很多人数犹见面瞧不起。因为它们不过简单了。稍有更的程序员即使从不曾读了设计模式、从来没耳闻过单一任务规范,在设计软件时也会自愿的信守就同着重原则,因为当时是常识。在软件编程中,谁吧未欲盖修改了一个成效造成其他的效能产生故障。而避免出现这无异于题材的艺术就是是以单一任务规范。虽然单一任务规范如此概括,并且为当是常识,但是就算是经验丰富的程序员写有之主次,也会发出负这同原则的代码有。为什么会起这种状况呢?因为有职责扩散。所谓职责扩散,就是盖某种原因,职责P被分化也粒度更仔细之任务P1和P2。

</head>

  比如:类T只担负一个职责P,这样设计是入单一任务规范的。后来出于某种原因,也许是要求变动了,也许是先后的设计者境界提高了,需要拿任务P细分为粒度更细之任务P1,P2,这时如假定如程序按照单一任务规范,需要用类T也诠释为寡独类T1以及T2,分别担当P1、P2两个任务。但是在次已经勾勒好之状况下,这样做简直太费时间了。所以,简单的改动类T,用它们来担负两单任务是一个比较不错的选择,虽然这么做有悖于单一任务规范。(这样做的风险在于职责扩散的不确定性,因为咱们无会见想到是职责P,在未来说不定会见扩散为P1,P2,P3,P4……Pn。所以记住,在职责扩散及我们无法控制的品位之前,立刻对代码进行重构。)

<body>

举例说明,用一个类描述动物呼吸这个场面:

正文内容

class Animal{
    public void breathe(String animal){
        System.out.println(animal+"呼吸空气");
    }
}
public class Client{
    public static void main(String[] args){
        Animal animal = new Animal();
        animal.breathe("牛");
        animal.breathe("羊");
        animal.breathe("猪");
    }
} 

<script>JS动态脚本</script>

  运行结果:

<body>

  牛呼吸空气

</html>

  羊呼吸空气

 

  猪呼吸空气

[meta标签]
1.charset属性:设置文档字符编码格式。
>>>写法: <meta charset=”UTF-8″>
>>>常见的编码格式:
GB-2312:国标码,简体中文
GBK:扩展的国标码,简体中文
UTF-8:万国码Unicode码,基本相当各国语言

  程序上线后,发现题目了,并无是怀有的动物都呼吸空气的,比如鱼就是呼吸水的。修改时一旦以单一任务规范,需要拿Animal类细分为陆生动物类Terrestrial,水生动物Aquatic,代码如下:

2.http-equiv属性:需配合content属性使用,主要声明浏览器如何编译文件。
>>>写法:<meta http-equiv=”属性值”
content=”属性值详细内容”>
>>>常因此属性值:Content-Type HTML4.01前的文档内容编码声明
refresh 网页刷新 set-Cookie设置浏览器cookie缓存

class Terrestrial{
    public void breathe(String animal){
        System.out.println(animal+"呼吸空气");
    }
}
class Aquatic{
    public void breathe(String animal){
        System.out.println(animal+"呼吸水");
    }
}

public class Client{
    public static void main(String[] args){
        Terrestrial terrestrial = new Terrestrial();
        terrestrial.breathe("牛");
        terrestrial.breathe("羊");
        terrestrial.breathe("猪");

        Aquatic aquatic = new Aquatic();
        aquatic.breathe("鱼");
    }
}

3.name属性:需配合content属性使用。主要用于为找引擎提供必要信息。
>>>写法:<meta name=”属性值” content=”属性值详细内容”
>>>重要属性值:author:作者,声明网站作者,常用公司网站表示
keyword:网站要字,多独根本字,用英文逗号分隔
description:网页描述,搜索引擎显示在title下的讲述内容

  运行结果:

[link标签]
1.图:用于为网页链接各种文件。
2.时不时因此性:
rel:用于表明被链接文件以及当下文件之涉及。
这里选icon,表明被链接图片是眼前网页的icon图标。
type:表明被链接文件是什么类型,可以略。
href:表明链接文件之地方。

  牛呼吸空气

[title]

  羊呼吸空气

网页的题目,即网页选项卡上的文

  猪呼吸空气

 

  鱼呼吸水

HTML之丘级标签

  我们见面发觉要这么改资费是可怜特别的,除了将原本的类似分解之外,还亟需改客户端。而一直修改类Animal来达到目的则违背了单纯任务规范,但费用却多少之大都,代码如下:

[常见的块级标签]
题标签<h1></h1>……<h6></h6>
水平线<hr/>
段落<p></p>
换行<br/>
引用<blockquote></blockquote >
预格式<pre></pre>

class Animal{
    public void breathe(String animal){
        if("鱼".equals(animal)){
            System.out.println(animal+"呼吸水");
        }else{
            System.out.println(animal+"呼吸空气");
        }
    }
}

public class Client{
    public static void main(String[] args){
        Animal animal = new Animal();
        animal.breathe("牛");
        animal.breathe("羊");
        animal.breathe("猪");
        animal.breathe("鱼");
    }
} 

[有序列表 ol  order list]

  可以观看,这种修改章程使简单的大多。但是可是在隐患:有平等天要以鱼分为呼吸淡水之鱼儿和呼吸海道之鱼群,则以得修改Animal类的breathe方法,而针对性原有代码的改会针对调用“猪”“牛”“羊”等有关职能带来风险,也许有平等天而会发觉程序运行的结果成“牛呼吸水”了。这种修改章程直接当代码级别达背了单纯性任务规范,虽然改起来最好简便易行,但隐患也是不过酷之。还有同栽修改章程:

[不管序列表ul  unorder list]

class Animal{
    public void breathe(String animal){
        System.out.println(animal+"呼吸空气");
    }

    public void breathe2(String animal){
        System.out.println(animal+"呼吸水");
    }
}

public class Client{
    public static void main(String[] args){
        Animal animal = new Animal();
        animal.breathe("牛");
        animal.breathe("羊");
        animal.breathe("猪");
        animal.breathe2("鱼");
    }
} 

[概念描述列表]
<dl>
<dt>标题</dt>
<dd>描述项</dd>
</dl>

  可以看出,这种修改章程没有变动原来的法子,而是以接近中初加了一个智,这样虽然也背离了单一任务规范,但在道级别达到却是吻合单一任务规范的,因为其并无动原来方式的代码。这三栽方法各发利弊,那么在实际编程中,采用哪一中呢?其实就诚然比难以说,需要根据实际情况来确定。我的准是:只有逻辑足够简单,才得以于代码级别上违反单一任务规范;只有类中方法数量足够少,才堪在方式级别达到背单一任务规范;

一般情形下,标题dt只发生雷同项,描述项dd可以产生N多起
浏览器显示时,标题顶格显示,dd会缩进显示

  例如本文所举的这例子,它极简单了,它仅发一个措施,所以,无论是在代码级别上负单一任务规范,还是以道级别及违反,都不见面促成极其老之熏陶。实际用被的接近都设复杂的多,一旦产生职责扩散而需要修改类时,除非是仿佛本身非常简单,否则要照单一任务规范的好。

[图表做标签figure]
1.<figure></figure> 有有限只子标签:
<img src=””>:一轴图,src表示图片路径
<figcaption></figcaption> 图片的题
2.浏览器显示力量:图片和标题上下排列,同时图片与标题缩进一个单位。

  遵循单一职责原的长处有:

[分区标签div]
时常配合CSS使用,为网页中的极常用分区标签,常用来网页布局使用

  • 可降低类的复杂度,一个好像就负责同起职责,其论理肯定使于负责多起职责简单的几近;
  • 提高类的可读性,提高系统的可维护性;
  • 转引起的高风险降,变越必然的,如果纯粹任务规范遵循的好,当修改一个意义时,可以显著降低对其余力量的震慑。

 

  需要说明的一点是纯任务规范不只是面向对象编程思想所特有的,只要是模块化的主次设计,都适用单一任务规范。

HTML之行级标签

  设计模式六很标准(2):里氏替换原则

[广泛的行级标签]
span(行内文本)
img(图片)
strong(强调)
a(超链接)
u(下划线)

  肯定有很多丁同自己正看这项条件的时节同样,对斯规则的名字充满疑惑。其实原因就是这项条件最早是在1988年,由麻省理工学院之均等各项姓里的娘(Barbara
Liskov)提出来的。

[img(图片)]
1、src:表示图片引用路径。
>>>路径地址的写法:
① 相对路径:以目前文件为按,去追寻图片地址。
a、与时文件处于同一层的图,直接写图片名
b、图片在此时此刻文件下一样重合:文件夹名/图片名[img/xiaowo]
c、图片以目前文件上一致重叠:../图片名
应用相对路径时图最外层只能在网站根本目录[图表必须于路文件夹着]
② 绝对路径:file:///盘符:/文件夹/图片.后缀名。但是,严禁动用。
③ 网络链接:网络达到之图片链接。但是,一般不采取,因为图片于他人服务器。

  定义1:如果对各级一个档次为 T1底对象 o1,都生项目也 T2
的目标o2,使得以 T1概念之所有程序 P 在备的对象 o1 都代表换成 o2 时,程序
P 的所作所为尚未发生变化,那么类型 T2 是项目 T1 的子类型。

2、title:图片标题。当鼠标指上后出示的提拔文字。

  定义2:所有援基类的地方要能够透明地以该子类的靶子。

3、alt:当图片无法加载的下,显示的亲笔。

  问题原因:有雷同职能P1,由类A完成。现需要用效能P1进行扩展,扩展后底成效为P,其中P由原有效力P1与新职能P2组成。新职能P由类A的子类B来就,则子类B于成功新力量P2的以,有或会见造成原有功能P1发生故障。

4、height=”” width=”” 图片的增长率高度。【属性】
可以用css【样式】(style=”width: ; height: ;”)代替

  解决方案:当使用持续时,遵循里氏替换原则。类B继承类A时,除上加新的办法好新增功能P2外,尽量不要再写父类A的主意,也尽可能不要重载父类A的法门。

5、align:设置图片周围文字相对于图片的职。[top, center ,bottom]

  继承包含这样同样叠意思:父类中凡是已经落实好之艺术(相对于肤浅方法而言),实际上是以设定一多元之专业和契约,虽然它不强制要求拥有的子类必须遵这些契约,但是只要子类对这些不抽象方法任意修改,就会见对整个继承体系造成破坏。而里氏替换原则就是是表达了马上同叠含义。

 

  继承作为面向对象三怪特色有,在让程序设计带来巨大便利之以,也带来了弊端。比如动用持续会受程序带来侵入性,程序的可移植性降低,增加了目标中的耦合性,如果一个近乎让另外的类所继承,则当以此看似需要改时,必须考虑到具有的子类,并且父类修改后,所有涉到子类的功力还发或会见来故障。

[超链接a]
1、href:超链接的跳转地址,可以是网链接,也得是当地文件(路径确定与img)
2、target:超链接打开的职务。_self 自身页面(默认) _blank 新页面
3、title:鼠标指上后显得的文。
4、rel:表明将跳转的页面,与时页面的干:
rel=”prev” 即将跳转的页面,是当下页面的面前一样篇文档 
rel=”next” 即将跳转的页面,是现阶段页面的继同首文档 
rel=”prefetch” 预加载。在眼前文档加载成功后,利用空闲时间,
预加载即将链接的文档

  举例说明继承的高风险,我们要完成一个星星数相减的意义,由类A来顶住。

[锚链接]
1.本页面锚链接: 
a.设置锚点:<a name=”top”></a> 用name属性表示锚点名称
b.在超链接上,使用#name 跳反至对应锚点。
<a href=”#top”>跳转锚点</a>
2.页面间锚链接: 
a.以用跨越反页面的指定位置,设置锚点
b.于超链接的href属性中,使用“页面地址.html#name”
<a href=”页面地址.html#top”>跳反至新页面指定部分</a>
横流:由于谷歌/IE的兼容问题,需锚点中插一个空格[ ]才会立竿见影:
<a name=”top”> </a>

class A{
    public int func1(int a, int b){
        return a-b;
    }
}

public class Client{
    public static void main(String[] args){
        A a = new A();
        System.out.println("100-50="+a.func1(100, 50));
        System.out.println("100-80="+a.func1(100, 80));
    }
} 

[功能性链接]
mailto://XXX@qq.com 给指定邮箱发送邮件
tencent://message/?uin=QQ号码 给指定QQ发送信息

  运行结果:

 

  100-50=50

 

  100-80=20

HTML之表格

  后来,我们得充实一个初的效能:完成两屡次相加,然后又同100呼吁与,由类B来负担。即类B需要做到两独作用:

<table>

  • 少数反复相减。
  • 个别屡相加,然后重新加100。

  <tr>

  由于类A已经落实了第一单作用,所以类B继承类A后,只待重形成第二独职能就是得了,代码如下:

    <th>表头</th>

class B extends A{
    public int func1(int a, int b){
        return a+b;
    }

    public int func2(int a, int b){
        return func1(a,b)+100;
    }
}

public class Client{
    public static void main(String[] args){
        B b = new B();
        System.out.println("100-50="+b.func1(100, 50));
        System.out.println("100-80="+b.func1(100, 80));
        System.out.println("100+20+100="+b.func2(100, 20));
    }
} 

    <th>表头</th>

  类B就后,运行结果:

  </tr>

  100-50=150

  <tr>

  100-80=180

    <td>表列</td>

  100+20+100=220

    <td>表列</td>

  我们发现原本运行正常化的相减功能发生了错。原因纵然是类B在被方从名时无意中重复写了父类的法门,造成所有运行相减功能的代码全部调用了类B重写后底方,造成原本运行正常化的法力出现了不当。在本例中,引用基类A完成的效用,换成子类B之后,发生了杀。在其实编程中,我们常会由此再写父类的法子来成功新的功效,这样写起虽然简易,但是任何继承体系的而复用性会比较差,特别是动多态比较频繁时,程序运行出错的几率十分充分。如果不要双重写父类的法,比较通用的做法是:原来的父类和子类都延续一个又易懂的基类,原有的后续关系去丢,采用依赖、聚合,组合等事关代替。

  </tr>

  里氏替换原则通俗的来讲就是是:子类可以扩大父类的效能,但未能够更改父类原有的功力。它富含以下4交汇含义:

  <tr>   

  • 子类可以实现父类的抽象方法,但无克掩盖父类的免抽象方法。
  • 子类中可追加自己故意的计。
  • 当子类的措施重载父类的艺术时,方法的放开条件(即方法的形参)要较父类方法的输入参数还宽大。
  • 当子类的办法实现父类的悬空方法时,方法的后置条件(即方法的返回值)要于父类更严格。

    <td>表列</td>

  看上去挺不可思议,因为咱们会发觉在自己编程中时常会背离里氏替换原则,程序还是跑的优秀的。所以大家都见面时有发生这样的疑难,假如自己弗要是无按里氏替换原则会产生啊结果?

    <td>表列</td>

  后果就是:你写的代码有题目之几率领将会见大大增加。

  </tr>

  设计模式六雅标准(3):依赖倒置原则

  <tr>

  定义:高层模块不应因低层模块,二者都应乘其抽象;抽象不应该负细节;细节应该借助抽象。

    <td>表列</td>

  问题原因:类A直接依赖类B,假如要用类A改呢依赖类C,则须经修改类A的代码来上。这种状况下,类A一般是高层模块,负责复杂的事情逻辑;类B和类C是低层模块,负责基本的原子操作;假如修改类A,会为程序带来不必要的风险。

    <td>表列</td>

  解决方案:将类A修改也倚接口I,类B和类C各自实现接口I,类A通过接口I间接与类B或者类C发生关系,则会大大降低修改类A的几率。

  </tr>

  依赖倒置原则根据这样一个真相:相对于细节的多变性,抽象的东西只要长治久安之大多。以抽象为根基搭建筑起来的架构比为细节为根基搭建筑起来的架使稳定之基本上。在java中,抽象指的凡接口或者抽象类,细节就是切实可行的实现类似,使用接口或者抽象类的目的是制定好规范及契约,而休去干任何实际的操作,把展现细节的天职交他们之兑现类似去做到。

</table>

  依赖倒置原则的核心思想是面向接口编程,我们依旧用一个例证来说明面向接口编程比相对于面向实现编程好于啊地方。场景是这么的,母亲让男女说故事,只要给它们同本书,她虽好按在书写被孩子谈话故事了。代码如下:

 

class Book{
    public String getContent(){
        return "很久很久以前有一个阿拉伯的故事……";
    }
}

class Mother{
    public void narrate(Book book){
        System.out.println("妈妈开始讲故事");
        System.out.println(book.getContent());
    }
}

public class Client{
    public static void main(String[] args){
        Mother mother = new Mother();
        mother.narrate(new Book());
    }
} 

[表格table]

  运行结果:

报表的表头<th></th>(默认加多少,且在单元格居中形)
表的行<tr></tr>
表的列<td></td>

  妈妈起来说故事

[table的常用属性]
1.Border:表格的界限框属性;当用border=””设置边框时,会于
抱有td以及table上嵌套边框当border加大时,只有table最外层框线会
加粗,td单元格上之框线不会见转变。

  很漫长很久以前有一个阿拉伯底故事……

2.Cellspacing:单元格及单元格之间的间隙,当Cellspacing=”0″时,
单元格之间的空余也0但边框线并没有统一(边框线还是有限漫长线之升幅)。
[合边框的写法]style=”border-collapse:collapse;”
使用边框合并后,无需设置cellspacing

  运行良好,假如发生同等龙,需求变成这样:不是深受写而是被同样客报纸,让这号妈妈说一下报上的故事,报纸的代码如下:

3.Cellpadding:单元格内边距,单元格中文字与单元格边框之间的偏离。

class Newspaper{
    public String getContent(){
        return "林书豪38+7领导尼克斯击败湖人……";
    }
} 

4.Width/Height:表格的红火高;

  这号妈妈也办不至,因为它竟然无会见念报纸及之故事,这不过荒唐了,只是以挥毫换成报,居然要要修改Mother才能够念。假如下需求变换成杂志为?换成网页为?还要不停地改Mother,这明明不是好的宏图。原因就是是Mother与Book之间的耦合性太胜了,必须降他们中间的耦合度才行。

5.Align:设置表格在父容器中之针对那法:left/居左,center/居中
right/居右
[注意]:当表格使用align属性时,相当给用表格浮动,
恐怕会见导致表格后的元素让表格浮动影响,导致布局散乱

  我们引入一个虚无的接口IReader。读物,只要是带字的且属读物:

6.Bgcolor:背景色

interface IReader{
    public String getContent();
} 

7.Background:背景图片,后接相对路径。当背景图和背景色同时
生效时,背景图会覆盖背景色

  Mother类与接口IReader发生依赖关系,而Book和Newspaper都属于读物的框框,他们各自还失去落实IReader接口,这样尽管合依赖倒置原则了,代码修改为:

8.Bordercolor:边框颜色

class Newspaper implements IReader {
    public String getContent(){
        return "林书豪17+9助尼克斯击败老鹰……";
    }
}
class Book implements IReader{
    public String getContent(){
        return "很久很久以前有一个阿拉伯的故事……";
    }
}

class Mother{
    public void narrate(IReader reader){
        System.out.println("妈妈开始讲故事");
        System.out.println(reader.getContent());
    }
}

public class Client{
    public static void main(String[] args){
        Mother mother = new Mother();
        mother.narrate(new Book());
        mother.narrate(new Newspaper());
    }
}

 

  运行结果:

[<tr><td><th>标签的习性]
>>>当表格属性,与行列属性冲突时常,会坐行属性为遵循
属性设置优先级:td>tr>table

  妈妈起来讲话故事

1.width/height:给单个的实践,列设置富有高.

  很遥远很久以前有一个阿拉伯之故事……

2.bgcolor:背景色

  妈妈起来称故事

3.align:设置单元格中之文字以单元格中的程度对其道:left/center/right

  林书豪17+9助尼克斯击败老鹰……

4.valign:设置单元格中之亲笔以单元格的直对齐方式:top/center/bottom

  这样修改后,无论以后如何扩展Client类,都未待再修改Mother类了。这就是一个简约的例子,实际状况遇,代表高层模块的Mother类将承担好重点的事体逻辑,一旦用针对她进行改动,引入错误的风险大。所以按照依赖倒置原则得以降低类之间的耦合性,提高系统的泰,降低修改程序造成的高风险。

5.nowrap:设置单元格文字行末不断行nowrap=”nowrap”

  采用依赖倒置原则被多总人口相互开发带来了极大的方便,比如达例被,原本Mother类与Book类直接耦合时,Mother类必须顶Book类编码完成后才好开展编码,因为Mother类依赖让Book类。修改后底顺序则可以开工,互不影响,因为Mother与Book类一点涉嫌呢从未。参与合作开发之人口尤其多、项目尤为粗大,采用依赖导致原则的含义就是更要。现在十分盛行的TDD开发模式就是是凭倒置原则最成功的使。

 

  传递依赖关系起三种艺术,以上的例证中以的办法是接口传递,另外还有少种植传递方式:构造方法传递与setter方法传递,相信用过Spring框架的,对借助之传递方式必定非见面生。

[表的跨行和跨列]
1.超过列:colspan,某单元格跨N列,则该单元格的右的N-1单td就不需要了。

  于骨子里编程中,我们一般用做到如下3触及:

2.超越行:rowspan,某单元格跨N行,则该单元格的下侧的N-1独td就未待了。

  • 低层模块尽量还如出抽象类还是接口,或者两者都发生。
  • 变量的扬言类型尽量是空洞类或接口。
  • 以持续时仍里氏替换原则。

 

  依赖倒置原则的基本就是如果我们面向接口编程,理解了面向接口编程,也就算明白了借助倒置。

HTML之表单

  设计模式六不行条件(4):接口隔离原则

 

  定义:客户端不应有靠它不待之接口;一个类对其余一个好像的负应该建立于太小的接口及。 
题目因:类A通过接口I依赖类B,类C通过接口I依赖类D,如果接口I对于类A和类B来说不是最为小接口,则类B和类D必须去落实他们无需之方式。

[from表单]

  解决方案:将重叠的接口I拆分为单身的几只接口,类A和类C分别与他们待的接口建立因关系。也就算是动接口隔离原则。

<form method=”POST” action=”url”>
  <label>请输入邮箱地址:</label>
  <input type=”text” name=”” placeholder=”请输入邮箱地址”>

  举例来证实接口隔离原则:

<br>邮箱格式请按要求格式输入
<br>

起名 1

  <label>请输入密码:</label>
  <input type=”password” name=”” placeholder=”请输入密码”>
  <label>请复输入密码:</label>
  <input type=”password” name=”” placeholder=”请复输入密码”>

  (图1 未按接口隔离原则的统筹)

<br>
密码要也6-16号英文数字
<br>

  这个图的意是:类A依赖接口I中的方法1、方法2、方法3,类B是对准类A依赖之兑现。类C依赖接口I中的办法1、方法4、方法5,类D是本着类C依赖的实现。对于类B和类D来说,虽然她们都设有着用不至的章程(也即是图中红色字体标记的法),但鉴于实现了接口I,所以呢务必要实现这些用无交之措施。对类图不熟识的好参见程序代码来了解,代码如下:

  <label>性别:</label>
  <input type=”radio” name=”sex” value=”male”>男
  <input type=”radio” name=”sex” value=”female”>女

interface I {
    public void method1();
    public void method2();
    public void method3();
    public void method4();
    public void method5();
}

class A{
    public void depend1(I i){
        i.method1();
    }
    public void depend2(I i){
        i.method2();
    }
    public void depend3(I i){
        i.method3();
    }
}

class B implements I{
    public void method1() {
        System.out.println("类B实现接口I的方法1");
    }
    public void method2() {
        System.out.println("类B实现接口I的方法2");
    }
    public void method3() {
        System.out.println("类B实现接口I的方法3");
    }
    //对于类B来说,method4和method5不是必需的,但是由于接口A中有这两个方法,
    //所以在实现过程中即使这两个方法的方法体为空,也要将这两个没有作用的方法进行实现。
    public void method4() {}
    public void method5() {}
}

class C{
    public void depend1(I i){
        i.method1();
    }
    public void depend2(I i){
        i.method4();
    }
    public void depend3(I i){
        i.method5();
    }
}

class D implements I{
    public void method1() {
        System.out.println("类D实现接口I的方法1");
    }
    //对于类D来说,method2和method3不是必需的,但是由于接口A中有这两个方法,
    //所以在实现过程中即使这两个方法的方法体为空,也要将这两个没有作用的方法进行实现。
    public void method2() {}
    public void method3() {}

    public void method4() {
        System.out.println("类D实现接口I的方法4");
    }
    public void method5() {
        System.out.println("类D实现接口I的方法5");
    }
}

public class Client{
    public static void main(String[] args){
        A a = new A();
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());

        C c = new C();
        c.depend1(new D());
        c.depend2(new D());
        c.depend3(new D());
    }
} 

  <label>城市:</label>
  <select>
    <option value=”北京” selected>北京</option>
    <option value=”上海”>上海</option>
    <option value=”深圳”>深圳</option>
    <option value=”珠海”>珠海</option>
  </select>

  可以看来,如果接口过于臃肿,只要接口中冒出的主意,不管对因让它的接近有没来因此处,实现类似吃还必去贯彻这些方式,这明明不是好的计划。如果以这个规划修改也契合接口隔离原则,就得对接口I进行拆分。在此地我们将本来的接口I拆分为三单接口,拆分后底宏图而图2所展示:

  <label>爱好:</label>
  <input type=”checkbox” name=”sports”>运动
  <input type=”checkbox” name=”art”>艺术
  <input type=”checkbox” name=”science”>科学

起名 2

  <label>个人描述:</label>
  <textarea
rows=”2″>这是一个差不多实施输入框,输入你的私家描述”</textarea>

  (图2 遵循接口隔离原则的计划性)

  <input type=”submit” name=”确认提交” value=”确认提交”>
</form>

  照例贴发出程序的代码,供不熟悉类图的冤家参考:

1.零星个重大性质
action:表单需要付的服务器地址
method:表单提交数据利用的法子,get/post
>>>get和post的区别
a.get传参使用URL传递,所有参数在地方栏可见,不安全。get传参数据有限;
b.post传参使用http请求传递,比较安全;post传递大量数量;
然,get传递速率比post快。

 interface I1 {
    public void method1();
}

interface I2 {
    public void method2();
    public void method3();
}

interface I3 {
    public void method4();
    public void method5();
}

class A{
    public void depend1(I1 i){
        i.method1();
    }
    public void depend2(I2 i){
        i.method2();
    }
    public void depend3(I2 i){
        i.method3();
    }
}

class B implements I1, I2{
    public void method1() {
        System.out.println("类B实现接口I1的方法1");
    }
    public void method2() {
        System.out.println("类B实现接口I2的方法2");
    }
    public void method3() {
        System.out.println("类B实现接口I2的方法3");
    }
}

class C{
    public void depend1(I1 i){
        i.method1();
    }
    public void depend2(I3 i){
        i.method4();
    }
    public void depend3(I3 i){
        i.method5();
    }
}

class D implements I1, I3{
    public void method1() {
        System.out.println("类D实现接口I1的方法1");
    }
    public void method4() {
        System.out.println("类D实现接口I3的方法4");
    }
    public void method5() {
        System.out.println("类D实现接口I3的方法5");
    }
} 

>>>URL传参的样式:链接URL地址?name1=value1&name2=value2

  接口隔离原则的含义是:建立单一接口,不要确立特大臃肿的接口,尽量细化接口,接口中的章程尽量少。也就是说,我们若呢顺序类建立专用的接口,而不要试图去立一个那个巨大的接口供有乘它的好像去调用。本文例子中,将一个大之接口变更为3只专用的接口所采用的哪怕是接口隔离原则。在程序设计着,依赖几单专用的接口要比依赖一个归结的接口更灵活。接口是设计时对标设定的“契约”,通过分散定义多单接口,可以防范外来变更的扩散,提高系统的八面玲珑和可维护性。

2.input底常用属性:
type:设置input的输入型
name:给input输入框起名。一般景象下,name属性必不可少。因为传递数据时,
用name=value(输入内容)的款式传递
value:input输入框的默认值
placeholder:输入框的唤起内容,当input有默认的value或者输入值时,
placeholder消失。

  说及此地,很多人会醒来的接口隔离原则以及之前的纯净任务规范很相像,其实不然。其一,单一任务规范原注重的是职责;而接口隔离原则注重针对接口依赖之断。其二,单一任务规范要是约束类,其次才是接口及措施,它对的凡次中的贯彻与细节;而接口隔离原则要约接口接口,主要针对抽象,针对程序整体框架的构建。

3.input-type属性的常用属性值
text;文本输入框
password:密码输入框,输入内容默认显示小黑点。
radio:单选框/checked:复选框
>>>使用radio/checked时,value属性必填;提交时,提交的吧value中之默认值。
>>>radio/checkbox凭借name属性确定是否属于同一组,name相同呢同组
>>>使用checked=”checked”属性,设置默认选中起
flie:文件及污染
>>>使用accept=”类型”,设置只能上传的文件类型,比如image/*
submit:提交按钮。将有所表单数据交由到后台服务器
reset:重置表单数据。将装有表单数据恢复到默认状态。
image:图形提价按钮。跟submit一样,具有表单提交功能。
>>>使用src属性,选择图片路径
button:普通按钮,没有任何软用

  采用接口隔离原则对接口进行约时,要小心以下几点:

4.属性名等于属性
checked=”checked” 设置radio或checkbox的默认选中起
multiple=”multiple”
设置select控件为多选择,可于界面使用Ctrl+鼠标,进行多选。一般不用。
selected=”selected”:设置selected控件,默认选中option选项。
readonly=”readonly”:设置也单纯念,不同意修改
disabled=”disable”:禁用控件
>>>当input被disabled时,该input的name和value将无法往后台传递
hidden=”hidden”:隐藏控件;等效为,<input type=”hidden” />

  • 接口尽量小,但是若出限度。对接口进行细化可以加强程序设计灵活性是免得利的实,但是如果过小,则会导致接口数量过多,使设计复杂化。所以自然要相宜。
  • 也倚接口的类定制服务,只暴露于调用的类似它用的方,它不需要之法则躲起来。只有专注地为一个模块提供定制服务,才会成立最小的借助关系。
  • 增进内聚,减少对外交互。使接口用最为少之方式去完成最好多的业务。

5.[下拉选择select]
a.写法:<select>
<option></option> //可以有N多个
<lect>
b.name属性,应该写以<select>上,所有选项才发一个name
c.option常用属性:
value=””:当option没有value属性时,往后台传递的是<option></option>标签中的文;
当option有value属性时,往后台传递的是value属性的值。
title=””:鼠标指上后显得的文字。
selected=”selected”:默认选中。
d.<optgroup label=”山东省”></optgroup>
:用于将option标签进行分组,label属性表示分组名。

  运用接口隔离原则,一定要是当,接口设计之了很或过多少且非好。设计接口的上,只有多花费来时间去思维和筹备,才会可靠地实践这无异于规则。

6.[文本域 textarea]
① 写法:<textarea></textarea>
② 设置富有高style=”width: 200px; height: 150px;” 自身产生cols=””
rows=””两独特性,但不常用
③ readonly=”readonly” 设置为就念模式,不容许编辑。
④ style=”resize: none;” 设置也方便高不允许修改。
⑤ style=”overflow: ;” 设置当文字超出区域时,如何处理。
>>>
也得通过overflow-x/overflow-y分别设置水平垂直方向的显示方式。
>>> 常用属性值:
hidden 超出区域的文字,隐藏无法展示
scroll 无论文字多少,均会显得滚动
auto 自动,根据仿多少活动决定是否出示滚动条(默认样式)

  设计模式六特别标准(5):迪米特法则

7.表格的边框和标题
<fieldset>
<legend>表格的题目</legend>
。。。N多个说明单元素[input/select/textarea]
</fieldset>
流动:一个表单可以有差不多只框以及标题

  定义:一个靶应该针对另外对象保障最少的摸底。

 

  问题由:类及类似中的关联进一步细,耦合度越老,当一个类有转移时,对另外一个好像的熏陶吗越发老。

CSS之选择器

  解决方案:尽量降低类与类似中的耦合。

【通用选择器】
1、写法: *{}
2、作用: 选中页面中之具备HTML标签
3、优先级:最低!

  自从我们接触编程开始,就了解了软件编程的究竟的准:低耦合,高内聚。无论是面向过程编程还是面向对象编程,只有使各个模块之间的耦合尽量的没有,才会加强代码的复用率。低耦合的长不言而喻,但是如何编程才会就低耦合呢?那正是迪米特法则使去做到的。

【标签选择器】

  迪米特法则还要吃最少知道原则,最早是于1987年由美国Northeastern
University的Ian
Holland提出。通俗的来讲,就是一个像样对自己因的接近知道之更加少越好。也就是说,对于被指之好像来说,无论逻辑多么复杂,都尽量地的用逻辑封装在类的中,对外除了提供的public方法,不对外泄漏任何音讯。迪米特法则还有一个重简明的定义:只与一直的朋友通信。首先来解释一下什么是一直的意中人:每个对象还见面暨其他对象来耦合关系,只要简单独对象之间时有发生耦合关系,我们虽说立刻半单对象期间是情侣干。耦合的办法多,依赖、关联、组合、聚合等。其中,我们遂出现成员变量、方法参数、方法返回值备受之类为直接的心上人,而产出在部分变量中之类似则不是一直的情侣。也就是说,陌生的切近最好永不当片变量的款型出现在类的里。

1、写法: HTML标签名{ }
2、作用: 选中保有对应之HTML标签,并修改其样式

  举一个事例:有一个集团,下属单位有分公司与从属单位,现在要求打印出富有下属单位的员工ID。先来拘禁一下背离迪米特法则的计划。

 

 //总公司员工
class Employee{
    private String id;
    public void setId(String id){
        this.id = id;
    }
    public String getId(){
        return id;
    }
}

//分公司员工
class SubEmployee{
    private String id;
    public void setId(String id){
        this.id = id;
    }
    public String getId(){
        return id;
    }
}

class SubCompanyManager{
    public List<SubEmployee> getAllEmployee(){
        List<SubEmployee> list = new ArrayList<SubEmployee>();
        for(int i=0; i<100; i++){
            SubEmployee emp = new SubEmployee();
            //为分公司人员按顺序分配一个ID
            emp.setId("分公司"+i);
            list.add(emp);
        }
        return list;
    }
}

class CompanyManager{

    public List<Employee> getAllEmployee(){
        List<Employee> list = new ArrayList<Employee>();
        for(int i=0; i<30; i++){
            Employee emp = new Employee();
            //为总公司人员按顺序分配一个ID
            emp.setId("总公司"+i);
            list.add(emp);
        }
        return list;
    }

    public void printAllEmployee(SubCompanyManager sub){
        List<SubEmployee> list1 = sub.getAllEmployee();
        for(SubEmployee e:list1){
            System.out.println(e.getId());
        }

        List<Employee> list2 = this.getAllEmployee();
        for(Employee e:list2){
            System.out.println(e.getId());
        }
    }
}

public class Client{
    public static void main(String[] args){
        CompanyManager e = new CompanyManager();
        e.printAllEmployee(new SubCompanyManager());
    }
} 

【类选择器 class选择器】
1、写法: .选择器名{}
2、调用: 在待改样式的HTML标签及,使用class=”选择器名”
3、优先级: 当作用为同层时,class选择器>标签选择器

  现在者设计的重点问题发以CompanyManager中,根据迪米特法则,只及一直的情人发生通信,而SubEmployee类并无是CompanyManager类的一直对象(以部分变量出现的耦合不属直接对象),从逻辑上讲话总公司才和外的分店耦合就尽了,与分公司的员工并无其他联系,这样设计引人注目是长了非必要的耦合。按照迪米特法则,应该避免类似中冒出这么不直接对象干之耦合。修改后底代码如下:

 

 

【ID选择器】
1、写法: #选器名{}
2、调用: 在用修改样式的HTML标签及,使用id=”选择器名”
3、优先级:同一层时,id选择器>class选择器
4、ID选择器是绝无仅有的!同一页面严禁出现同名ID!!!

class SubCompanyManager{
    public List<SubEmployee> getAllEmployee(){
        List<SubEmployee> list = new ArrayList<SubEmployee>();
        for(int i=0; i<100; i++){
            SubEmployee emp = new SubEmployee();
            //为分公司人员按顺序分配一个ID
            emp.setId("分公司"+i);
            list.add(emp);
        }
        return list;
    }
    public void printEmployee(){
        List<SubEmployee> list = this.getAllEmployee();
        for(SubEmployee e:list){
            System.out.println(e.getId());
        }
    }
}

class CompanyManager{
    public List<Employee> getAllEmployee(){
        List<Employee> list = new ArrayList<Employee>();
        for(int i=0; i<30; i++){
            Employee emp = new Employee();
            //为总公司人员按顺序分配一个ID
            emp.setId("总公司"+i);
            list.add(emp);
        }
        return list;
    }

    public void printAllEmployee(SubCompanyManager sub){
        sub.printEmployee();
        List<Employee> list2 = this.getAllEmployee();
        for(Employee e:list2){
            System.out.println(e.getId());
        }
    }
}

 

  修改后,为分行增加了打印人员ID的方,总公司直接调用来打印,从而避免了和分公司的员工发耦合。

【后代选择器】
1、写法: 选择器1 选择器2 …… 选择器N {}
2、生效规则: 选择器2必须是挑器1的【后代】……以此类推

  迪米特法则的初衷是降低类之间的耦合,由于每个接近都缩减了非必要的凭,因此真正可减低耦合关系。但是凡事都来度,虽然好避与不直接的类通信,但是一旦通信,必然会经一个“中介”来发生关联,例如本例中,总公司就是由此分行是“中介”来跟分公司的职工发生关联的。过分之采用迪米特原则,会生出大量如此的中介以及传递类,导致系统复杂度变充分。所以于采取迪米特法则常常如果勤权衡,既完成组织清晰,又如大内聚集低耦合。

【子代选择器】
1、写法: 选择器1>选择器2>……>选择器N{}
2、生效规则: 选择器2必须是选器1的【直接子代】……

  设计模式六雅原则(6):开闭原则 

 

  定义:一个软件实体如类、模块和函数应该针对扩大开放,对修改关闭。

【交集选择器】
1、写法: 选择器1选择器2……选择N{}
2、生效规则: 必须同时满足所有选择器,才会收效

  问题原因:在软件之生命周期内,因为变化、升级跟保护等原因需要对软件原有代码进行改动时,可能会见吃原来代码中引入错误,也可能会见如我们只能对总体功能进行重构,并且用原有代码通过又测试。

 

  解决方案:当软件用扭转时,尽量通过扩张软件实体的作为来促成转移,而不是通过改都部分代码来兑现转变。

【并集选择器】
1、写法: 选择器1,选择器2,……,选择N{}
2、生效规则: 满足任意一个选择器,均只是生效

  开闭原则是面向对象设计着最为基础之宏图基准,它点我们怎样建立稳定灵活的系。开闭原则可能是设计模式六码条件中定义最模糊的一个了,它只报告我们针对扩大开放,对修改关闭,可是到底怎么才会不负众望对扩大开放,对修改关闭,并从未明显的告知我们。以前,如果有人报自己“你进行设计之上一定要恪守开闭原则”,我会觉的异啊还不曾说,但一般又什么都说了。因为开闭原则真的太虚了。

 

  于密切琢磨与仔细读很多设计模式的篇章后,终于对开闭原则来矣好几认识。其实,我们本设计模式前面5怪条件,以及用23栽设计模式的目的就是是遵循开闭原则。也就是说,只要我们本着前5起标准遵循的好了,设计来之软件自然是副开闭原则的,这个开闭原则更像是前五项原则遵守程度的“平均得分”,前面5码条件遵循的好,平均分自然就是大,说明软件设计开闭原则遵循的好;如果前方5桩原则遵循的坏,则印证开闭原则遵循的不得了。

【选择器命名规范】
1、只能发出字母、数字、下划线组成;
2、开头不克是数字。

  其实笔者以为,开闭原则仅就是想发挥这么平等重叠意思:用抽象构建框架,用实现扩大细节。因为虚无灵活性好,适应性广,只要抽象的合理性,可以主导保持软件架构的祥和。而软件中易变的底细,我们为此起虚无缥缈派生的实现类似来开展扩张,当软件要发生变化时,我们仅需要基于需要又派生一个落实类似来扩充就足以了。当然前提是咱们的虚幻要成立,要针对需的改变发生前瞻性和前瞻性才行。

 

  说及这里,再回首一下前方说的5起原则,恰恰是喻我们所以抽象构建框架,用实现扩大细节的注意事项而曾:单一任务规范告诉我们贯彻类似设职责单一;里氏替换原则告诉我们不用毁继承体系;依赖倒置原则告诉我们只要面向接口编程;接口隔离原则告诉我们以统筹接口的早晚如果从简单一;迪米特法则告诉我们设退耦合。而开闭原则是总纲,他语我们只要指向扩大开放,对修改关闭。

【选择器优先级】
1、就近原则:近者优先。
2、当作用于平层时:可出且重算
    权重划分: 标签选择器 1
   class选择器 10
   id选择器 100
   行级样式表style=”” 1000
   #ul .li .li2 li{} 优先级权重121
    li .li1 .li2 .lis2 {} 优先级权重31
   #ul #li li{} 优先级201

  最后验明正身一下什么去遵守就六单极。对这六只极的信守并无是是和否的题目,而是基本上和少的问题,也就是说,我们一般不会见说发生没有出守,而是说遵守程度之小。任何事还是过犹不跟,设计模式的六只规划原则为是同样,制定这六个条件的目的并无是要我们死的守他们,而待根据实际情况灵活运用。对她们之迪程度而以一个合理的限量外,就终于帅的规划。我们因此同样帧图来说明一下。

【三栽采取CSS的道】
1、行内样式表:直接当HTML开始标签中动用style=””的艺术引用;
特征:将CSS代码与HTML代码完全混在共同,不符合W3C关于内容与见分离之渴求。不便利样式复用;
优先级:最高。

起名 3

2、内部样式表: 在<head></head>中,使用<style
type=”text/css”></style>方式引用;
特色:将CSS代码与HTML代码分离,但是没彻底分手CSS文件与HTML文件,不便宜多页面复用样式。

  图中的各国一样长条维度各代表一如既往项标准,我们根据对这项条件的迪程度在维度上绘一个碰,则只要对这项条件遵循的客观吧,这个点应该获得于红的同心圆内部;如果死守的例外,点用会当小圆内部;如果过于遵守,点拿会晤得于大圆表面。一个完好无损的规划体现于祈求被,应该是六独极都当同心圆中之六边形。

3、外部样式表起名:使用link标签链接CSS文件。
<link rel=”stylesheet” type=”text/css” href=”css/01css.css” />
特点:实现了CSS与HTML的干净分手,有利于样式复用及后期维护。

起名 4

 

  于直达图备受,设计1、设计2属于优秀的筹划,他们针对六桩条件的遵守程度还以情理之中之范围外;设计3、设计4统筹虽有点不足,但也基本得以承受;设计5尽管严重不足,对各类条件都没十分好之遵守;而规划6虽说守过渡了,设计5与计划性6且是迫切需要重构的统筹。

 

  到此处,设计模式的六颇口径就是描写了了。主要参考书籍有《设计模式》《设计模式之禅》《大话设计模式》以及网上有碎片之稿子,但关键内容要还是本身自己对这六只尺码的觉悟。写出来的目的一方面是对准及时六起原则系统地收拾一下,一方面也同普遍的网友享受,因为设计模式对编程人员来说,的确非常关键。正使发生句话称一千单读者眼中有一千只哈姆雷特,如果大家对及时六起原则的敞亮和我有所不同,欢迎留言,大家一齐探索。

CSS之文本属性

 

1、字体、字号:
font-weight:字体的粗细,可选属性值:bold加粗 lighter细体
100~900数值(400正常,700 bold)

font-size:字体大小 **PX
**%(浏览器默认字体大小的百分比,绝大部分默认16px) 

font-family:字体族,设置字体。
>>>多单字样式间用逗号分隔,浏览器解析时,会从左往右依次解析,选择可用字体。
>>>一般前面使用具体字体名称,最后一个用字体族类名称。
(常用字体族名称:衬线体serif 非衬线体sans-serif(常用)
等宽体Monospace)
>>>例如:font-family:Arial, ‘Microsoft Yahei’, sans-serif;

font-style:字体样式,正常(normal) 斜体(italic)

font-variant:small-caps; 将字母转为小型大写字体。

(了解)font缩写形式:font-style font-variant font-weight font-size
line-height font-family
>>> 使用注意事项 :
① 顺序必须严格遵循上述顺序;
② 多只样式之间为此空格分割,而且font-sizene-height 必须作为同一对用/分割
③ font-size和font-family必须指定,其他样式不点名将使默认样式显示;
>>> 例如:font:italic bold 75%/1.8 ‘Microsoft Yahei’,
sans-serif;
斜体 加粗 字号/行大 字体族(微软格外黑,非衬线字体族)

2、字体颜色:
color:字体颜色
opacity:透明度,0~1之间的数字。
调整时控件以及子控桩都会透明,而采取rgba调整时,只见面时按照控件透明,子控件不会见时有发生透明度变化。

3、行距、对齐等:
line-height:行高 ① 像素单位 48px ② 不牵动px 正常实施愈的倍数 ③百分数 同2
>>>
典型应用,调整控件中文垂直居中之计:控件的height=控件的line-height

text-align:块级元素中文字的程度对齐方式 left center right

letter-spacing:字符间距,字与字里面的间隔

text-decoration:文本修饰
下划线underline、删除线line-through、上写道overline、none

overflow:控制超出范围文本的显示方式(auto
根据仿多少活动显示滚动条,scroll始终显示滚动条, hidden
超出范围文本隐藏) 可以经overflow-x overflow-y分别安装水平垂直方向

text-overflow:设置多余文字的显示方式 clip裁剪掉 ellipsis省略号
>>>【重点】让每行多余文字显示省略号:
① white-space: nowrap; 如果是中文,需安装行末不断实践
② overflow: hidden; 设置控件超出范围隐藏
③ text-overflow: ellipsis; 设置多余文本省略号显示

white-space: nowrap; 设置中文行末不断推行显示

word-break:
浏览器默认在空格处断行,当一个单词长度超出范围时,会不断行显示,
break-all 允许以单词内换行。

text-shadow:文本阴影,有四个属于性值:
①水准阴影距离 必选,数值越充分,阴影右变
②沿直阴影距离 必选,数值越怪,阴影下移 
③影子模糊距离 可选,数值越老,阴影越模糊。默认为0,不模糊
④黑影颜色 可卜,默认为黑色

text-indent:首行缩进,可用像素值调整缩进大小

text-stroke: -webkit-text-stroke: 0.2px #008000; 描边的粗细,描边的颜色

 

CSS之背景属性

 

background

padding: 0px;”>
background-image:背景图,background-image:
url(图片地址相对路径);背景图和背景色同时在时时,背景图会覆盖背景色

background-repeat:背景图再次道 ,no-repeat不平铺 repeat平铺(默认)
repeat-x水平平铺 repeat-y垂直平铺

background-size:背景图大小。
【指定宽度高度】
>>>
宽高之写法,第一单属于性值为宽度,第二只属于性值为高度,可以:①直接写如素
②形容百分较(父容器宽高之百分比)
>>> 当只发生一个属于性值时,默认为宽度。高度等较缩放。
当有零星只属于性值时,会依照指定的莫大小幅进行削减/拉伸显示。
【其他属性值】
>>>
contain:图片等较缩放,缩放到富或赛的某个单方面等父容器的松高,另一面以图片大小缩放(可能致有空余区域无法覆盖)
>>>
cover:图片等比较缩放,使背景图像完全覆盖背景区域。(可能造成背景图有区域无法出示)

background-position:位置坐标、偏移量
>>> 指定位置:left/center/right top/center/bottom
当只写一个属于性值时,另一个默认居中
>>> 填写坐标:水平位置 垂直位置 (像素或比重形式)
① 当只有写一个属于性值时,默认写的也水平方向,则直居中
② 当以诸如素时:图片的左上角往各个方向动的骨子里距离
水平方向:正数右移 负数左移 垂直方法:正数下移 负数上转移
(左负有正 上负下正)

当用比例时时,一般只能是正数。代表去丢图片后,剩余空白距离的分布比例。例如
background-position:30%; 水平方向去丢图片后,剩余区域3:7分

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图