什么是选择器？

每一条CSS样式声明（定义）由两部分组成，形式如下：

选择器｛
        样式；
｝

选择器，说白了就是用一种方式把你想要的哪一个标签选中!

标签选择器

标签选择器其实就是html代码中的标签。例如：

p{font-size:12px;line-height:1.6em;};

类选择器

类选择器在CSS样式编码中是最常用到的。

语法：

．类选择器名称｛css样式代码；｝

注意：

英文圆点开头
	
其中类选择器可以任意起名
<span class="stress">胆小如鼠</span>
.setGreen{
    color:green;
}

ID选择器

在很多方面，ID选择器都类似于类选择符，但也有一些重要的区别：

为标签设置id＝＂ID名称＂，而不是class＝”类名称“
	
ID选择符的前面是井号（＃），而不是英文圆点（．）
<span id="setGreen">公开课</span>
#setGreen{
   color:green;
}


类和ID选择器的区别？

相同点：可以应用于任何元素

不同点：

 在一个html文档中，ID选择器只能使用一次，而且仅一次。而类选择器可以使用多少次。
	
可以使用类选择器词列表方法为一个元素同时设置多个样式。我们可以为一个元素同时设多个样式，但只可以用类选择器的方法实现，ID选择器是不可以的（不能使用ID词列表）
错误代码：

#stressid{
    color:red;
}
#bigsizeid{
    font-size:25px;
}
<p>到了<span id="stressid bigsizeid">三年级</span>下学期时，我们班上了一节公开课...</p>

子选择器

还有一个比较有用的选择器子选择器，即大于符号（>),用于选择指定标签元素的第一代子元素。

如：

.food>li{border:1px solid red;}

这行代码会使class名为food下的子元素li（水果、蔬菜）加入红色实线边框。

包含（后代）选择器

包含选择器，即加入空格,用于选择指定标签元素下的后辈元素。

如：

.first  span{color:red;}

包含选择器与子选择器的区别？

子选择器（child selector）仅是指它的直接后代，或者可以理解为作用于子元素的第一代后代。

而后代选择器是作用于所有子后代元素。

而后代选择器是作用于所有子后代元素。（>作用于元素的第一后代，空格作用于元素所有后代）

.food>li{
    border:1px solid red;/*添加边框样式（粗细为1px， 颜色为红色的实线）*/	
}

<ul class="food">
    <li>水果
        <ul>
        	<li>香蕉</li>
            <li>苹果</li>
            <li>梨</li>
        </ul>
    </li>
    <li>蔬菜
    	<ul>
        	<li>白菜</li>
            <li>油菜</li>
            <li>卷心菜</li>
        </ul>
    </li>
</ul>



.food li{
    border:1px solid red;/*添加边框样式（粗细为1px， 颜色为红色的实线）*/	
}



通用选择器

通用选择器是功能最强大的选择器，它使用一个（*）号指定，它的作用是匹配html中所有标签元素，如下使用下面代码使用html中任意标签元素字体颜色全部设置为红色：

* {color:red;}

 

有时候我们给同样一个属性用多种方式去定义样式，来自最具体的样式的属性会胜出，但不知道到底哪种样式最具体，好在css还提供了一个公式，他根据指派给样式选择器的值决定样式的特性——标签选择器、类选择器、ID选择器，等等。这个系统是这样进行的：

   1.一个标签选择器值1分。

   2.一个类选择器值10。

   3.一个ID选择器值100分。

   4.一个行内样式（如：style）值1000分。   

数字越大。特性就越大。（如图）



当不止一个样式应用给一个标签是，一旦样式属性有冲突，网页浏览器必须决定哪个样式要“胜出”。在css中一个样式的重要性称作特征。它取决于创建这个样式时所用的选择器类型。每种选择器类型有一个不同的值，并且当多个选择器类型出现在一个样式中时——例如派生选择器#banner p——所用的所有选择器的值要加在一起。

注意：伪元素（例如像：first-child）被当作标签选择器对待时值1分。伪类（例如：link）被当作类对待时值10分。

   最近正在看《CSS实战手册》这本书，发现第五章管理多种样式中的样式优先级公式挺实用的。
   有时候我们给同样一个属性用多种方式去定义样式，来自最具体的样式的属性会胜出，但不知道到底哪种样式最具体，好在css还提供了一个公式，他根据指派给样式选择器的值决定样式的特性——标签选择器、类选择器、ID选择器，等等。这个系统是这样进行的：
   1.一个标签选择器值1分。
   2.一个类选择器值10。
   3.一个ID选择器值100分。
   4.一个行内样式（如：style）值1000分。    
数字越大。特性就越大。（如图）
 
当不止一个样式应用给一个标签是，一旦样式属性有冲突，网页浏览器必须决定哪个样式要“胜出”。在css中一个样式的重要性称作特征。它取决于创建这个样式时所用的选择器类型。每种选择器类型有一个不同的值，并且当多个选择器类型出现在一个样式中时——例如派生选择器#banner p——所用的所有选择器的值要加在一起。
注意：伪元素（例如像：first-child）被当作标签选择器对待时值1分。伪类（例如：link）被当作类对待时值10分。
 
 

	
这个设计模式更像是一种选择器，大家都用过只是概念比较模糊；
	
	

	
这种类型的设计模式属于创建模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们创建对象时，不会对客户端暴漏创建逻辑，并且是通过共同的接口来指向新创建的对象；
	
	

	
意图：定义一个创建对象的接口，让其子类自己决定哪一个工厂类，工厂模式使用其创建过程延迟到子类进行；
	
	

	
主要解决：主要解决接口选择的问题；
	
	

	
何时使用：我们明确地计划不同条件下创建不同实例时；
	
	

	
如何解决：让其子类实现工厂接口，返回的也是一个抽象产品；
	
	

	
关键代码：创建过程在其子类进行；
	
	

	
应用实例：
	
	

	

		
1.你需要一辆汽车，可以直接从工厂里提货，而不用管这辆汽车是怎么做出来的，以及这个汽车里面具体的实现；
		
		

		
2.Hibernate换数据库只需要换方言和驱动就可以；
		
	
	

	
优点
	
	

	

		
1.一个调用者想创建一个对象，只需要知道名字就可以了；
		
		

		
2.扩展性高，如果想增加一个产品，只需要扩展一个工厂类就可以；
		
		

		
3.屏蔽产品的具体实现，调用者只关心产品的接口；
		
	
	

	
缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖；
	
	

	
使用场景：
	
	

	

		
1.日志记录器：记录可能记录到本地磁盘、系统事件、远程服务器等，用户选择记录日知道什么地方；
		
		

		
2.数据库访问、当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时；
		
		

		
3.设计一个连接服务器的框架，需要三个协议，“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口；
		
	
	

	
注意事项：
	
	

	

		
作为一个创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过new就可以完成创建的对象，无需使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度；
		
	
	

	
实战
	
	

	

		
我们将实现一个Shape接口和实现Shape接口的实体类，下一步是工厂类ShapeFactory;
		
		

		
FactoryPatternDemo,演示类使用ShapeFactory来获取Shape对象。
		
	
 



代码链接

 

package factorypattern;

/**
 * @author yangxin_ryan
 * create Circle Class
 */
public class Circle implements Shape {

    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

 

package factorypattern;

/**
 * @author yangxin_ryan
 * create FactoryPatternDemo Class
 */
public class FactoryPatternDemo {

    public static void main(String[] args) {
        ShapeFactory shapeFactory = new ShapeFactory();
        Shape shape1 = shapeFactory.getShape("CIRCLE");
        shape1.draw();
        Shape shape2 = shapeFactory.getShape("RECTANGLE");
        shape2.draw();
        Shape shape3 = shapeFactory.getShape("SQUARE");
        shape3.draw();
    }

}


 

package factorypattern;

/**
 * @author yangxin_ryan
 * Create Rectangle class
 */
public class Rectangle implements Shape {

    public void draw() {
        System.out.println("Inside Rectangle::draw() method");
    }
}


package factorypattern;

/**
 * @author yangxin_ryan
 * Create interface Shape
 */
public interface Shape {
    void draw();
}


 

package factorypattern;

/**
 * @author yangxin_ryan 
 * Create ShapeFactory class
 */
public class ShapeFactory {

    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        } else if (shapeType.equalsIgnoreCase("SQUARE")) {
            return new Square();
        }
        return null;
    }
}


 

package factorypattern;

/**
 * @author yangxin_ryan
 * create a Square Class
 */
public class Square implements Shape {

    public void draw() {
        System.out.println("Inside Square::draw() method.");
    }
}


执行结果：