gang4415 的BLOG
用户名：gang4415
文章数：41
访问量：113211
注册日期：
阅读量：5863
阅读量：12276
阅读量：354559
阅读量：1051909
[匿名]51cto游客：
[匿名]嘿嘿：
51CTO推荐博文
Class对象内含有与Class相关的各种信息（别称meta-class） &
& 我们的程序中的每个类都有一个相应的Class对象．每当新的类被编译 &
& 完成，就会产生一个Class对象存储与相同的.class文件内．执行期间 &
& 当你想要产生该class的对象是，ＪＶＭ便会检查该型别的Class对象是 &
& 否被加载．如果没被加载，ＪＶＭ会根据名称找到.class文件并加载它． &
& getName()：Returns & the & name & of & the & entity & (class, & interface, & &
& array & class, & primitive & type, & or & void) & represented & by & this &
& Class & object, & as & a & String. &
& Class类的实例是用来表示Java程序在运行时载入的类(Class)或接口(Interface). &
& Java程序在运行时每个类都会对应一个Class对象, &
& 可以从Class对象中得到与类相关的信息 &
& 附上一例子，你看看吧，应该会明白点的 &
& public & class & MyClass & { &
& & public & static & void & main(String[] & args) & { &
& & & String & name & = & &ZhuJun&; & &
& & & & & & & & & Class & c & = & name.getClass(); & &
& & & & & & & & & System.out.println(&getName: & & & + & c.getName()); & &
& & & & & & & & & System.out.println(&isInterface: & & & + & c.isInterface()); & &
& & & & & & & & & System.out.println(&isPrimitive: & & & + & c.isPrimitive()); & &
& & & & & & & & & System.out.println(&isArray: & & & + & c.isArray()); & &
& & & & & & & & & System.out.println(&SuperClass: & & & + & c.getSuperclass().getName()); & &
& 输出结果: &
& getName: & java.lang.String &
& isInterface: & false &
& isPrimitive: & false &
& isArray: & false &
& SuperClass: & java.lang.Object
了这篇文章
类别：┆阅读(0)┆评论(0)String.class 是能对类名的引用取得在内存中该类型class对象的引用，
new String().getClass() 是通过实例对象取得在内存中该实际类型class对象的引用
（这个方法是从java.lang.Object类继承过来的）
getClass()是动态而且是final的
package com.chinacreator.yxg.
public abstract class PersonInfo {
&&& private S
&&& public int getAge() {
&&& public void setAge(int age) {
&&& && this.age =
package com.chinacreator.yxg.
public class ManInfo extends PersonInfo {
&&& public int getHeight() {
&&& public void setHeight(int height) {
&&& && this.height =
&&& public static void main(String[] args) {
&&& && PersonInfo personInfo = new ManInfo();
&&& && System.out.println(personInfo.getClass().getName());
&&& && System.out.println(PersonInfo.class.getName());
com.chinacreator.yxg.bean.ManInfo
com.chinacreator.yxg.bean.PersonInfo &
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：9640次
排名：千里之外css class选择器
css class选择器
css+class选择器&相关文章
一、CSS选择器
关于CSS选择器，请看这里：CSS选择器
通过以上，我们可以将CSS选择器分为以下几种：
1.基本选择器
（1）类选择器（.info）,匹配所有class属性中包含info的元素。
（2）ID选择器（#footer），匹配所有id属性等于footer的元素。
（3）通用选择器（*），匹配任何元素。
（4）标签选择器（E），匹配所有使用E标签的元素。
*{margin:0;:0;}
{border:#F00}
.info{background:#000;}
#footer{background:#999;}
CSS3的同级元素通用选择器
（5）E~F，匹配任何在E元素之后的同级F元素
p~ul{background:#ff0;}
2.属性选择器
以下：E表示元素，attr表示属性，val表述属性的值。
（1）E[attr]选择器
匹配所有具有attr属性的E元素，不考虑它的值。（注：E在此处可以省略，比如"[checked]".）
示例1：匹配所有含有title属性的div元素
div[title]{border:#000width:100height:100display:}
&divtitle="a"&&/div&
&divtitle="b"&&/div&
&divtitle="c"&&/div&
&atitle="d"="#"&&/a&
&atitle="e"href="#"&&/a&
示例2：匹配所有含有title属性的元素
[title]{border:#000width:100height:100display:}
&divtitle="a"&&/div&
&divtitle="b"&&/div&
&divtitle="c"&&/div&
&atitle="d"href="#"&&/a&
&atitle="e"href="#"&&/a&
看出区别了么~示例2就是比示例1省略了元素名div~
（2）E[attr=val],匹配所有attr属性值为val的E元素。（注：同上，这里的E也可以省略。）
示例：匹配所有class值为test的p元素。
p[class="test"]{border:#000width:100height:100display:}
&pclass="test"&&/p&
&pclass="test"&&/p&
&pclass="run"&&/p&
（3）E[attr~=val]，匹配具有attr属性且属性值用空格分隔的字符列表。
示例：匹配具有class属性且其中一个属性值为name的div元素
div[class~="name"]{font-size:12color:}
&divclass="testname"&我是第一个div&/div&&divclass="test"&我是第二个div&/div&
运行代码保存代码提示：您可以先修改部分代码再运行!
运行代码，我们可以看到第一个div会应用上面的样式~
（4）E[attr|=val],匹配具有attr属性且属性值为用连接符（-）分隔的字符串，并以val开头的E元素。
示例：匹配具有class属性且以test开头的div元素
div[class|="test"]{font-size:12color:}
&divclass="123-test"&我是第一个div&/div&&divclass="test-123"&我是第二个div&/div&
运行代码，可以看出第二个div会应用上面的样式~
CSS3属性选择器
（5）E[attr^="val"],属性attr的值以"val"开头的元素。
（6）E[attr$=“val”],属性attr的值以"val"结尾的元素。
（7）E[attr*="val"],属性attr的值包含"val"字符串的元素。
div[id^="nav"]{background:#ff0;}
3.组合选择器
（1）多元素选择器（E,F），同时匹配所有E元素或F元素。
h1,div,a{font-size:14color:red}
&h1&我是标题&/h1&
&div&我是一个div&/div&
&ahref="#"&我是一个超链接&/a&
（2）后代元素选择器（EF），匹配所有属于E元素后代的F元素，E和F之间用空格分隔。
divp{font-size:14color:red}
&h1&我是标题&/h1&
&div&&p&我是div的后代元素p&/p&&/div&
&p&我是p&/p&
（3）子元素选择器（E&F）,匹配所有E元素的子元素F。
div&p{font-size:14color:red}
&h1&我是标题&/h1&
&div&&p&我是div的后代元素p&/p&&/div&
&p&我是p&/p&
运行代码，大家是不是发现后代元素选择器和子元素选择器的效果一样啊~其实它们也是有区别的~
下面我们来简单讨论一下**后代元素选择器和子元素选择器的区别**
①写法不一样：
后代元素选择器标识：空格
如：ulli{width:150}【ul和li之间用空格隔开】
子元素选择器标识：&
如：ul&li{width:150}【ul和li之间用&隔开】
②功能不一样
接着上例来说：
后代选择器是选择ul包围的所以元素中的所有li元素，包括子元素、孙元素、曾孙元素等等等。
子选择器仅仅选择ul包围的子元素中的li元素，不包括孙元素、曾孙元素等等等。
③兼容性不一样：
后代选择器是所有浏览器都兼容的，都可使用。
子选择器在IE6、IE7、IE8中则是不被支持的选择器，各自bug！
下面我们再来看一个例子：
&divclass='con'&
&p&span2&/p&
css代码（后代元素选择器）
.condivp{color:}
css代码（子元素选择器）
div.con&div&p{color:}
运行（后代元素选择器）
&!DOCTYPEhtml&
&charset=utf-8&
&title&css_or&/title&
&styletype="text/css"&
*{margin:0;padding:0;}
.condivp{color:}
&divclass='con'&
&p&span2&/p&
运行（子元素选择器）
&!DOCTYPEhtml&
&metacharset=utf-8&
&title&css_selector&/title&
&styletype="text/css"&
*{margin:0;padding:0;}
div.con&div&p{color:}
&divclass='con'&
&p&span2&/p&
（4）相邻选择器（E+F），匹配所有紧随E元素之后的同级元素F。
div+p{font-size:14color:red}
&h1&我是标题&/h1&
&div&&p&我是div的后代元素p&/p&&/div&
&p&我是p1&/p&
&p&我是p2&/p&
&p&我是p3&/p&
&p&我是p2&/p&
&p&我是p3&/p&
可以发现，我们的样式只对紧跟div的第一个p元素起作用~
4.伪类选择器
CSS2.1中的伪类
（1）E:first-child,匹配父元素的第一个元素。
（2）E:link,匹配所有未被点击的链接.
（3）E:visited,匹配所有已被点击的链接。
（4）E:active,匹配鼠标已经将其按下，还没释放的E元素。
（5）E:hover,匹配鼠标悬停其上的E元素。
（6）E:focus,匹配获得当前焦点的E元素。
（7）E:lang(c),匹配lang属性等于c的E元素。
p:first-child{font-style:}
input[type=text]:focus{color:#000;background:#}
input[type=text]:focus:hover{background:#}
q:lang(sv){quotes:"\201D""\201D""\2019""\2019";}
CSS2.1中的伪元素
（8）E:first-line,匹配E元素的第一行。
（9）E:first-letter,匹配E元素的第一个字母。
（10）E:before,在E元素之前插入生成的内容。
（11）E:after,在E元素之后插入生成的内容。
p:first-line{font-weight:#600;}
.preamble:first-letter{font-size:1.5font-weight:}
.cbb:before{content:"";display:height:17width:18background:url(top.png)no-repeat00;margin:000-18}
a:link:after{content:"("attr(href)")";}
CSS3中与用户界面有关的伪类
（12）E:enabled,匹配表单中激活的元素。
（13）E:disabled,匹配表单中禁用的元素。
（14）E:checked,匹配表单中被选中的radio（单选框）或checkbox（复选框）元素。
（15）E::selection,匹配用户当前选中的元素。
input[type="text"]:disabled{background:#}
CSS3中的结构性伪类
（16）E:root,匹配文档的根元素，对于HTML文档，就是HTML元素。
（17）E:nth-child(n),匹配其父元素的第n个子元素，第一个编号为1.
（18）E:nth-last-child(n),匹配其父元素的倒数第n个子元素，第一个编号为1.
（19）E:nth-of-type(n),与:nth-child()作用类似，但是仅匹配使用同种标签的元素。
（20）E:nth-last-of-type(n),与:nth-last-child()作用类似，但是仅匹配使用同种标签的元素。
（21）E:last-child,匹配父元素的最后一个子元素，等同于:nth-last-child(1)。
（22）E:first-of-type,匹配父元素下使用同种标签的第一个子元素，等同于:nth-of-type(1).
（23）E:last-of-type,匹配父元素下使用同种标签的最后一个子元素，等同于:nth-last-of-type(1)。
（24）E:only-child,匹配父元素下仅有的一个子元素，等同于:first-child:last-child或:nth-child(1):nth-last-child(1).
（25）E:only-of-type,匹配父元素下使用同种标签的唯一一个子元素，等同于:first-of-type:last-of-type或:nth:first-of-type(1):nth-last-of-type(1).
（26）E:empty,匹配一个不包含任何子元素的元素，注意：文本节点也被看作子元素。
p:nth-child(3){color:#f00;}
p:nth-child(odd){color:#f00;}
p:nth-child(even){color:#f00;}
p:nth-child(3n+0){color:#f00;}
p:nth-child(3n){color:#f00;}
tr:nth-child(2n+11){background:#ff0;}
tr:nth-last-child(2){background:#ff0;}
p:last-child{background:#ff0;}
p:only-child{background:#ff0;}
p:empty{background:#ff0;}
CSS3的反选伪类
（26）E:not(s),匹配不符合当前选择器的任何元素
:not(p){border:1pxsolid#}
CSS3中的:targer伪类
（27）E:target,匹配文档中特定"id"点击后的效果
h2:target{color:background:#f60;}
CSS选择器这一部分就先到这里~
二、CSS优先级
1.什么是CSS优先级
CSS优先级：指CSS样式在浏览器中被解析的先后顺序。
2.样式的优先级
多重样式（MultipleStyles）：如果外部样式、内部样式和内联样式同时应用于同一个元素，就是多重样式的使用情况。
一般情况下：（外部样式）Externalstylesheet&（内部样式）Internalstylesheet&（内联样式）Inlinestyle
例外：如果外部样式放在内部样式的后面，则外部样式将会覆盖内部样式。
&!DOCTYPEhtml&
&metacharset=utf-8&
&styletype="text/css"&
/*内部样式*/
h3{color:}
&!--外部样式style.css--&
&linkrel="stylesheet"type="text/css"href="style.css"/&
&!--设置：h3{color:}--&
&h3&测试！&/h3&
运行代码保存代码提示：您可以先修改部分代码再运行!
3.选择器的优先级
给不同的选择器分配不同的权值
内联样式（style=""）id选择器类选择器/属性选择器/伪类选择器标签选择器
（1）内联样式表的权值最高1000；
（2）id选择器权值100；
（3）类选择器/属性选择器/伪类选择器权值10；
（4）HTML标签选择器权值为1.
&!DOCTYPEhtml&
&styletype="text/css"&
/*权值=100+1=101*/
color:#F00;/*红色*/
#redP.redem{
/*权值=100+10+1=111*/
color:#00F;/*蓝色*/
#redPpspanem{
/*权值=100+1+1+1=103*/
color:#FF0;/*黄色*/
&divid="redP"&
&pclass="red"&red
&span&&em&emred&/em&&/span&
&p&red&/p&
结果：&em&标签内的数据显示为蓝色。
4.CSS优先级法则
比较样式的优先级是，只需统计不同选择器的个数，然后与对应的权值相乘即可。根据结果便可得出优先级。
（1）结果较大的优先级较高；
（2）结果相同，则后定义的优先级较高
（3）创作者的优先级高于浏览者，网页编写者设置的CSS样式的优先权高于浏览器所设置的样式。
（4）继承的CSS样式优先级低于后来指定的CSS样式
（5）若样式值中含有!important，则该值优先级最高
看到这里，有些同学是不是对!important有点迷惑呀~为什么有了它，就优先级最高呐~下面我们再来详细讲一讲!important~
三、!important知识点
1.!important简介
!important是CSS1就定义的语法，作用是提高指定样式的应用优先权。
语法格式：{cssRule!important}，即写在定义的最后面，例如：box{color:red!important}
声明了!important的样式，具有最高的优先级，相当于写在最下面（最后定义）
2.IE6.0不完全支持!important
IE支持重定义中的!important，例如：
.yuanxin{color:#e00!}
.yuanxin{color:#000;}
你将会发现定义了样式class="yuanxin"时，在IE下，字体显示为红色（#e00）。
但不支持同一定义中的!important。例如：
.yuanxin{color:#e00!color:#000;}
此时在IE6下不支持，你将会发现定义了样式class="yuanxin"时，字体显示为黑色（#000）。
important的样式属性和覆盖它的样式属性单独使用时(不在一个{}里)，IE6.0认为!important优先级较高，否则当含!important的样式属性被同一个{}里的样式覆盖时，IE6.0认为!important较低!
再举一个例子：
#a{width:100!}/*有效*/
#a{width:50}/*无效*/
#a{width:100px!width:50}/*width:100px无效，width:50px有效*/
参考资料：
.cn/cssref/css_selectors.asp/xugang/archive//1833760.html
做一个有博客的web前端自媒体人，专注web前端开发，关注用户体验，加我qq/微信交流：6135833
小编&张惮纩
以下内容已过滤百度推广
css 选择器参考手册 实例 选择并设置 class=&intro& 的元素的样式: .intro { background-color: } 亲自试一试浏览器支持 iefirefoxchromesafariopera ...&&普通
日&-&选择器是css的核心,从最初的元素、class/id选择器,演进到伪元素、伪类,以及css3中提供的更丰富的选择器,定位页面上的任意元素开始变得愈发的简单。 1...&&普通
css id 和 class id 和 class 选择器 如果你要在html元素中设置css样式,你需要在元素中设置'id' 和 'class'选择器。 id 选择器 id 选择器可以为标有特定 ...&&普通
blockquote[class=quote][cite] { color:#f00; }四、css 2.1中的伪类序号 选择器 含义13. e:first-child 匹配父元素的第一个子元素...&&普通
日&-&在上面的例子中,所有拥有 center 类的 html 元素均为居中。 在下面的 html 代码中,h1 和 p 元素都有 center 类。这意味着两者都将遵守 &.center& 选择器中...&&缩略图结果
日&-&在css中类选择器就是在类名前面加一个点号了,如果是多类不是打多个点号而以.important.urgent这种形式了,下面我来给大家介绍一下css 类选择器与多类选...&&普通
日&-&css id选择器与class选择器发表于 17:10:11 617人阅读分类: html+css 在css 中,选择器是一种模式,用于选择需要添加样式的元素。 属性选择器...&&普通
css id 和 class id 和 class 选择器 如果你要在html元素中设置css样式,你需要在元素中设置'id' 和 'class'选择器。 id 选择器 id 选择器可以为标有特定 ...&&普通
在css 中,类选择器以一个点号显示: .center {text-align: center} 在上面... 你可以将类 fancy 分配给任何一个表格元素任意多的次数。那些以 fancy 标注的...&&普通
类选择器允许以一种独立于文档元素的方式来指定样式。css 类选择器 类选择器...为了将类选择器的样式与元素关联,必须将 class 指定为一个适当的值。请看下面...&&普通假设B的定义是在B.h中，而存在下面这个文件：
--------------------------------------------
　　B&*&impl_;
--------------------------------------------
--------------------------------------------
#include&&A.h&
//&其他具体实现
--------------------------------------------
那么直接编译的话，由于编译器不知道B的存在，就会报编译错误。为了解决这个问题，可以在A.h中include&B.h，如下：
--------------------------------------------
#include&&B.h&
　　B&*&impl_;
--------------------------------------------
但是这样，一旦B的定义修改，那么A.h也就会重新编译，导致所有用到A.h的文件也需要重新编译，这样就造成了编译依赖，增加了编译的时间，在大型项目中，如果很多这样的地方的话，甚至可能极度增加编译时间。为了避免这种情况，我们可以这么做
--------------------------------------------
　　B&*&impl_;
--------------------------------------------
--------------------------------------------
#include&&A.h&
#include&&B.h&
//&其他具体实现
--------------------------------------------
通过在A.h中声明class&B，在A.cpp中include&B.h，这样即使B.h改变，A.h也不会改变，其他使用到A.h的文件也就不需要重新编译了，这样就可以避免编译依赖。
阅读(...) 评论()