DK1.5引入了新的类型——枚举。在Java中它虽然算个“小”功能，却给我的开发带来了“大”方便。
用法一：常量
在JDK1.5之前，我们定义常量都是：publicstaticfianl....。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。
Java代码
1.public enum Color {
2. RED, GREEN, BLANK, YELLOW
3.}
用法二：switch
JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。
Java代码
1.enum Signal {
2. GREEN, YELLOW, RED
3.}
4.public class TrafficLight {
5. Signal color = Signal.RED;
6. public void change() {
7. switch (color) {
8. case RED:
9. color = Signal.GREEN;
10. break ;
11. case YELLOW:
12. color = Signal.RED;
13. break ;
14. case GREEN:
15. color = Signal.YELLOW;
16. break ;
17. }
18. }
19.}
用法三：向枚举中添加新方法
如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且Java要求必须先定义enum实例。
Java代码
1.public enum Color {
2. RED("红色" , 1 ), GREEN( "绿色" , 2 ), BLANK( "白色
" , 3 ), YELLO( "黄色" , 4 );
3. // 成员变量
4. private String name;
5. private int index;
6. // 构造方法
7. private Color(String name, int index) {
8. this .name = name;
9. this .index = index;
10. }
11. // 普通方法
12. public static String getName( int index) {
13. for (Color c : Color.values()) {
14. if (c.getIndex() == index) {
15. return https://www.doczj.com/doc/9f17927167.html,;
16. }
17. }
18. return null ;
19. }
20. // get set 方法
21. public String getName() {
22. return name;
23. }
24. public void setName(String name) {
25. this .name = name;
26. }
27. public int getIndex() {
28. return index;
29. }
30. public void setIndex( int index) {
31. this .index = index;
32. }
33.}
用法四：覆盖枚举的方法
下面给出一个toString()方法覆盖的例子。
Java代码
1.public enum Color {
2. RED("红色" , 1 ), GREEN( "绿色" , 2 ), BLANK( "白色
" , 3 ), YELLO( "黄色" , 4 );
3. // 成员变量
4. private String name;
5. private int index;
6. // 构造方法
7. private Color(String name, int index) {
8. this .name = name;
9. this .index = index;
10. }
11. //覆盖方法
12. @Override
13. public String toString() {
14. return this .index+ "_" + this .name;
15. }
16.}
用法五：实现接口
所有的枚举都继承自https://www.doczj.com/doc/9f17927167.html,ng.Enum类。由于Java不支持多继承，所以枚举对象不能再继承其他类。
Java代码
1.public interface Behaviour {
2. void print();
3. String getInfo();
4.}
5.public enum Color implements Behaviour{
6. RED("红色" , 1 ), GREEN( "绿色" , 2 ), BLANK( "白色
" , 3 ), YELLO( "黄色" , 4 );
7. // 成员变量
8. private String name;
9. private int index;
10. // 构造方法
11. private Color(String name, int index) {
12. this .name = name;
13. this .index = index;
14. }
15.//接口方法
16. @Override
17. public String getInfo() {
18. return this .name;
19. }
20. //接口方法
21. @Override
22. public void print() {
23. System.out.println(this .index+ ":" + this .name);
24. }
25.}
用法六：使用接口组织枚举
Java代码
1.public interface Food {
2. enum Coffee implements Food{
3. BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO
4. }
5. enum Dessert implements Food{
6. FRUIT, CAKE, GELATO
7. }
8.}
用法七：关于枚举集合的使用
java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的 key是enum类型，而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述，可以参考JDK文档。
Classpath*与classpath的区别
Spring可以通过指定classpath*:与classpath:前缀加路径的方式从classpath 加载文件,如bean的定义文件.classpath*:的出现是为了从多个jar文件中加载相同的文件.classpath:只能加载找到的第一个文件.
比如 resource1.jar中的package 'com.test.rs' 有一个
'jarAppcontext.xml' 文件,内容如下:
resource2.jar中的package 'com.test.rs' 也有一个 'jarAppcontext.xml' 文件,内容如下:
ApplicationContext ctx = new ClassPathXmlApplicationContext(
"classpath*:com/test/rs/jarAppcontext.xml");
而如果写成下面的代码,就只能找到其中的一个xml文件(顺序取决于jar包的加载顺序)
ApplicationContext ctx = new ClassPathXmlApplicationContext(
"classpath:com/test/rs/jarAppcontext.xml");
classpath*:的使用是为了多个component(最终发布成不同的jar包)并行开发,各自的bean定义文件按照一定的规则:package+filename,而使用这些component的调用者可以把这些文件都加载进来.
classpath*:的加载使用了classloader的 getResources() 方法,如果是在不同的J2EE服务器上运行,由于应用服务器提供自己的classloader实现，它们在处理jar文件时的行为也许会有所不同。要测试 classpath*: 是否有效，可以用classloader从classpath中的jar文件里加载文件来进行测试：
getClass().getClassLoader().getResources("
Servlet 3.0 实战：异步Servlet 与Comet 风格应用程序https://www.doczj.com/doc/9f17927167.html,/blog/1189209
简介： 自JSR 315 规范（即Servlet 3.0）的草案公开发布以来，最新一代Servlet 规范的各种新特性被越来越多的开发人员所关注。规范中提到的一系列高级目标：如可插拔的Web 框架、便捷开发特性、增强安全性支持等都令人期待。但其中关注程度最高的，毫无疑问是异步Servlet。本文将详细介绍Comet 风格应用的实现方式，以及Servlet 3.0 中的异步处理特性在Comet 风格程序中的实际应用。
概述
作为Java EE 6 体系中重要成员的JSR 315 规范，将Servlet API 最新的版本从2.5 提升到了3.0，这是近10 年来Servlet 版本号最大的一次升级，此次升级中引入了若干项令开发人员兴奋的特性，如：
?可插拔的Web 架构（Web framework pluggability）。
?通过Annotations 代替传统web.xml 配置文件的EOD 易于开发特性（ease of development）。
?Serlvet 异步处理支持。
?安全性提升，如Http Only Cookies、login/logout 机制。
?其它改进，如文件上传的直接支持等。
其中，在开源社区中讨论得最多的就是Servlet 异步处理的支持，所谓Servlet 异步处理，包括了非阻塞的输入/输出、异步事件通知、延迟request 处理以及延迟response 输出等几种特性。这些特性大多并非JSR 315 规范首次提出，譬如非阻塞输入/输出，在Tomcat 6.0 中就提供了Advanced NIO 技术以便一个Servlet 线程能处理多个Http Request，Jetty、GlassFish 也曾经有过类似的支持。但是使用这些Web 容器提供的高级特性时，因为现有的Servlet API 没有对这类应用的支持，所以都必须引入一些Web 容器专有的
类、接口或者Annotations，导致使用了这部分高级特性，就必须与特定的容器耦合在一起，这对很多项目来说都是无法接受的。因此JSR 315 将这些特性写入规范，提供统一的API 支持后，这类异步处理特性才真正具备广泛意义上的实用性，只要支持Servlet 3.0 的Web 容器，就可以不加修改的运行这些Web 程序。
JSR 315 中的Servlet 异步处理系列特性在很多场合都有用武之地，但人们最先看到的，是它们在“服务端推”（Server-Side Push）方式—— 也称为Comet 方式的交互模型中的价值。在JCP（Java Community Process）网站上提出的JSR 315 规范目标列表，关于异步处理这个章节的标题就直接定为了“Async and Comet support”（异步与Comet 支持）。
本文将详细介绍Comet 风格应用的实现方式，以及Servlet 3.0 中的异步处理特性在Comet 风格程序中的实际应用。
经典Request-Response 交互模型的突破
“Comet 技术”、“服务端推技术（Server-Side Push）”、“反向Ajax 技术”这几个名称说的是同一件事情，可能您已经听说过其中的一项或者几项。但没听说过也没有关系，一句话就足以表达它们全部的意思：“在没有客户端请求的情况下，服务端向客户端发送数据”。
这句话听起来很简单很好理解，但是任何一个长期从事B/S 应用程序开发的程序都清楚，这实现起来并不简单，甚至很长一段时间内，人们认为这是并不可能的。因为这种做法完全不符合传统基于HTTP 协议的交互思想：只有基于Socket 层次的应用才能做到Server 和Client 端双方对等通讯，而基于HTTP 的应用中，Server 只是对来自Client 的请求进行回应，不关心客户端的状态，不主动向客户端请求信息，因此Http 协议被称为无状态、单向性协议，这种交互方式称为Request-Response 交互模型。
无状态、单向的经典Request-Response 交互模型有很多优点，譬如高效率、高可伸缩等。对于被动响应用户请求为主的应用，像CMS、MIS、ERP 等非常适合，但是对于另外一些需要服务端主动发送的需求，像聊天室（用户不发言的时候也需要把其它用户的发言传送回来）、日志系统（客户端没有请求，当服务端有日志输出时主动发送到客户端）则处理起来很困难，或者说这类应用根本不适合使用经典的Request-Response 交互模型来处理。当“不适合”与“有需求”同时存在时，人们就开始不断寻找突破这种限制的方法。
Comet 实现的方法
简单轮询
最早期的Web 应用中，主要通过JavaScript 或者Meta HTML 标签等手段，定
时刷新页面来检测服务端的变化。显然定时刷新页面服务端仍然在被动响应客户端
的请求，只不过客户端的请求是连续、频繁的，让用户看起来产生有服务端自动将
信息发过来的错觉。这种方式简单易行，但缺陷也非常明显：可能大部分请求都是
无意义的，因为服务端期待的事件没有发生，实际上并没有需要发送的信息，而不
得不重复的回应着页面上所有内容给浏览器；另外就是当服务端发生变化时，并不
能“实时”的返回，刷新的间隔太短，产生很大的性能浪费，间隔太长，事件通知又可能晚于用户期望的时间到达。
当绝大部分浏览器提供了XHR（XmlHttpRequest）对象支持后，Ajax 技术出现并迅速流行，这一阶段做的轮询就不必每次都返回都返回整个页面中所有的内容，如
果服务端没有事件产生，只需要返回极少量内容的http 报文体。Ajax 可以节省轮询传输中大量的带宽浪费，但它无法减少请求的次数，因此Ajax 实现的简单轮询
仍然有轮询的局限性，对其缺陷只能一定程度缓解，而无法达到质变。
?长轮询（混合轮询）
长轮询与简单轮询的最大区别就是连接时间的长短：简单轮询时当页面输出完连接
就关闭了，而长轮询一般会保持30 秒乃至更长时间，当服务器上期待的事件发生，将会立刻输出事件通知到客户端，接着关闭连接，同时建立下一个连接开始一次新
的长轮询。
长轮询的实现方式优势在于当服务端期待事件发生，数据便立即返回到客户端，期
间没有数据返回，再较长的等待时间内也没有新的请求发生，这样可以让发送的请
求减少很多，而事件通知的灵敏度却大幅提高到几乎是“实时”的程度。
?Comet 流（Forever Frame）
Comet 流是按照长轮询的实现思路进一步发展的产物。令长轮询将事件通知发送回客户端后不再关闭连接，而是一直保持直到超时事件发生才重新建立新的连接，这
种变体我们就称为Comet 流。客户端可以使用XmlHttpRequest 对象中的
readyState 属性来判断是Receiving 还是Loaded。Comet 流理论上可以使用一
个链接来处理若干次服务端事件通知，更进一步节省了发送到服务端的请求次数。
无论是长轮询还是Comet 流，在服务端和客户端都需要维持一个比较长时间的连接状态，这一点在客户端不算什么太大的负担，但是服务端是要同时对多个客户端服务的，按照经典Request-Response 交互模型，每一个请求都占用一个Web 线程不释放的话，Web 容器的线程则会很快消耗殆尽，而这些线程大部分时间处于空闲等待的状态。这也就是为什么Comet 风格服务非常期待异步处理的原因，希望Web 线程不需要同步的、一对一的处理客户端请求，能做到一个Web 线程处理多个客户端请求。
实战Servlet 异步处理
当前已经有不少支持Servlet API 3.0 的Web 容器，如GlassFish v3、Tomcat 7.0、Jetty 8.0 等，在本文撰写时，Tomcat 7 和Jetty 8 都仍然处于测试阶段，虽然支持Servlet 3.0，但是提供的样例代码仍然是与容器耦合的NIO 实现，GlassFish v3 提供的样例（玻璃鱼聊天室）则是完全标准的Servlet 3.0 实现，如果读者需要做找参考样例，不妨优先查看GlassFish 的example 目录。本文后一部分会提供另外一个更具备实用性的例子
“Web 日志系统”作为Servlet API 3.0 的实战演示进行讲解。
Web 日志系统实战
Apache Log4j 是当前最主流的日志处理器，它有许多不同的Appender 可以将日志输出到控制台、文件、数据库、Email 等等。在大部分应用中用户都不可能查看服务器的控制台或者日志文件，如果能直接在浏览器上“实时”的查看日志将会是给开发维护带来方便，在本例中将实现一个日志输出到浏览器的Appender 实现。
清单 1. Log4j 异步Web Appender
上面是Appender 类的代码模版，派生自org.apache.log4j.WriterAppender，Log4j 默认提供的所有Appender 都从此类继承，子类代码执行的逻辑仅仅是告知WriterAppender 如何获取Writer。而我们最关心的如何异步将日志信息输出至浏览器，则在AsyncContextQueueWriter 中完成。
清单2：异步上下文队列Writer
这个类是Web 日志实现的关键类之一，它继承至Writer，实际上是一组Writer 的集合，其中包含至少一个默认Writer 将数据输出至控制台，另包含零至若干个由
Queue<AsyncContext> 所决定的Response Writer 将数据输出至客户端。输出过程中，控制台的Writer 是同步的直接输出，输出至http 客户端的则由线程notifierRunnable 进行异步输出。具体实现方式是信息放置在阻塞队列MESSAGE_QUEUE 中，子线程循环时使用到这个队列的take() 方法，当队列没有数据这个方法将会阻塞线程直到等到新数据放入队列为止。
我们在Log4j.xml 中修改一下配置，将Appender 切换为WebLogAppender，那对Log4j 本身的扩展就算完成了：
清单3：Log4j.xml 配置
接着，建立一个支持异步的Servlet，目的是每个访问这个Servlet 的客户端，都在ASYNC_CONTEXT_QUEUE 中注册一个异步上下文对象，这样当有Logger 信息发生时，就会输出到这些客户端。同时，将建立一个针对这个异步上下文对象的监听器，当产生超时、错误等事件时，将此上下文从队列中移除。
清单4：Web 日志注册Servlet
服务端处理到此为止差不多就结束了，我们再看看客户端的实现。其实客户端我们直接访问这个Servlet 就可以看到浏览器不断的有日志输出，并且这个页面的滚动条会一直持续，显示http 连接并没有关闭。为了显示，我们还是对客户端进行了包装，通过一个隐藏的frame 去读取WebLogServlet 发出的信息，既Comet 流方式实现。
清单5：客户端页面
清单6：客户端引用的application.js
为了模拟日志输出，我们读取了一个已有的日志文件，将内容调用Logger 输出到浏览器，读者在调试时直接运行源码包中的TestServlet 即可，运行后整体效果如下所示：
图 1. 运行效果
结束语
Comet 的出现为Web 交互带来了全新的体验，而Servlet 3.0 和异步IO 则为Comet
实现过程中服务端Web 线程占用的问题提供了规范的解决方案。随着各种支持Servlet 3.0 容器的出现，Comet 的应用将越来越频繁，目前开发Comet 应用还是具有一定的挑
战性，但随着需求推动技术的发展，相信Comet 的应用会变得和AJAX 一样普及。
逻辑与/或和短路与/或的区别
What will happen when you attempt to compile and run the following code? int Output = 10;
boolean b1 = false;
if((b1 == true) && ((Output += 10) == 20)){
System.out.println("We are equal " + Output);
}else{
System.out.println("Not equal! " + Output);
}
A. Compilation error, attempting to perform binary comparison on logical data type.
B. Compilation and output of "We are equal 10".
C. Compilation and output of "Not equal! 20".
D. Compilation and output of "Not equal! 10".
逻辑操作符：&(与运算),^(异或运算),|(或运算)。
短路逻辑操作符：&&(并且),||(或者).
短路与/或运算符和逻辑与/或一样可以实现逻辑运算,但是此时有一个重要的区别:用逻辑与/或运算时,不管操作符两边的条件表
达式成不成立,它都要进行运算判断,而短路与/或运算不一样了,如果通过左侧的操作数就可以进行它们需要的判断,那么它就不会
再计算右侧的操作数了，请看下面的例子：
……
double value=0;
if(value!=0 && 1/value<1000){
System.out.println("The value is not too small.");
}
else{
System.out.println("The value is too small.");
}
……
运行结果:
The value is too small.
结果分析:
照理说应会出现除数为0的错误,但由于条件逻辑操作符是短路操作符,显然,value!=0条件不成立,立即就可作出判断应执行else
后的语句,所以它就不再会运算判断1/value<1000了.如果不懂请再看一例:
......
double int1=0,int2=1,int3=1;
if(int1!=0 & (int2=2)==1){
}
System.out.println("int2="+int2);
if(int1!=0 && (int3=2)==1){
}
System.out.println("int3="+int3);
......
运行结果:
int2=2.0
int3=1.0
＆＆当前一个逻辑判断为false时，后面的判断是不执行的
老猪(43284683) 11:39:27
与之相应的|| 当前一个逻辑判断为true时，后面的判断也是不执行的
枚举类型是JDK5.0的新特征。Sun引进了一个全新的关键字enum来定义一个枚举类。下面就是一个典型枚举类型的定义： Java代码 1.public enum Color{ 2. RED,BLUE,BLACK,YELLOW,GREEN 3.} 显然，enum很像特殊的class，实际上enum声明定义的类型就是一个类。而这些类都是类库中Enum类的子类(https://www.doczj.com/doc/9f17927167.html,ng.Enum
Java基础学习心得笔记 对于很多只会C语言的初学者而言，面对java基础语法学习，反而感觉很难，其实其中最大的问题不是语法难，而是一种编程思想的转变。面向过程就是把你的代码封装成函数，然后依次去做一件事情，面向过程是把你要做的事情抽象成对象，告诉对象去做。所以要想学好java入门，必须知道类和对象的概念。 类是对生活中事物的抽象描述，比如人类，动物类，交通工具类；对象即是对类的具体实例化，比如张三是人，猫是动物，飞机是交通工具（对象-----类）。Java基础入门学习路线可以总结为四步走： 1.java开发环境的搭建； 2.java初级之基础语法学习（80%类似C语言）; 3.java中级之面向对象编程学习(重点)； 4.java中级之应用编程学习。 第一步：JDK软件开发包时java软件开发环境， 包括jre运行环境和jvm虚拟机，在oricle官网下载javaSE版本JDK包；配置好环境变量就可以使用了。 第二步:java初级语法学习， 1.基本数据类型整形，字符型，字节型，长整形，短整形，浮点型，双精度，布尔型；
2.运算符+，-，*，/，%等； 3.控制流（while,switch，if else）; 4.数组的定义方式。 此阶段基本无难度，只要了解练习例题。 第三步:java面向对象学习， 1.类和对象； 2.java语言三大特性，封装、继承、多态； 3.一些关键字学习（static，final，abstract,extends）等。 这是重点，大家根据知识点一步步研究学习才是关键。 第四步：java应用编程， 例如：文件IO，集合（类似C语言数据结构），异常处理，线程，网络，JDBC数据库操作等，都是掌握面向对象以后，在查找不同的类使用类中不同的方法达到应用的效果，所以并不会很难。等基础语法掌握了就可以继续后面框架学习（java web方向，android学习），相信明确思路你会豁然开朗，更有学习动力。 以上没有具体的实例和知识点讲解，分享的只是完全没接触过java的初学者自学java的思路和学习的流程，应该把握的重点，希望大家有所帮助。 如果你想学好Java，找一家靠谱的培训机构，能让你的学习事半功倍。
Enum类 Enum枚举类就是class，而且是一个不可以被继承的final类。（后面均用Color举例）。 其枚举值(RED,BLUE...)都是Color类型的类静态常量，我们可以通过下面的方式来得到Color枚举类的一个实例： Color c=Color.RED; 注意：这些枚举值都是public static final的，也就是我们经常所定义的常量方式，因此枚举类中的枚举值最好全部大写。 1、即然枚举类是class，当然在枚举类型中有构造器，方法和数据域。但是，枚举类的构造器有很大的不同，不能使用public的构造函数，只能使用private的构造函数，这样可以保证外部代码无法新构造枚举类的实例。 2．所有枚举值都是public , static , final的。注意这一点只是针对于枚举值，我们可以和在普通类里面定义变量一样定义其它任何类型的非枚举变量，这些变量可以用任何你想用的修饰符。 3．Enum默认实现了https://www.doczj.com/doc/9f17927167.html,parable接口。 4．Enum覆载了了toString方法，因此我们如果调用 Color.Blue.toString()默认返回字符串”Blue”. 5．Enum提供了一个valueOf方法，这个方法和toString方法是相对应的。调用valueOf(“Blue”)将返回Color.Blue.因此我们在自己重写toString方法的时候就要注意到这一点，一把来说应该相对应地重写valueOf方法。
6．Enum还提供了values方法，这个方法使你能够方便的遍历所有的枚举值。 7．Enum还有一个oridinal的方法，这个方法返回枚举值在枚举类种的顺序，这个顺序根据枚举值声明的顺序而定，这里Color.RED.ordinal(); //返回结果：0 Color.BLUE.ordinal(); //返回结果：1 8.equals()方法：比较两个枚举类对象的引用。 public final boolean equals(Object other) { return this==other; } https://www.doczj.com/doc/9f17927167.html,pareTo()方法: Enum实现了https://www.doczj.com/doc/9f17927167.html,parable接口，因此可以比较象与指定对象的顺序。Enum中的compareTo返回的是两个枚举值的顺序之差。当然，前提是两个枚举值必须属于同一个枚举类，否则会抛出ClassCastException()异常。 https://www.doczj.com/doc/9f17927167.html,pareTo(Color.BLUE); //返回结果-1 10.枚举类可以在switch语句中使用。 Color color=Color.RED; switch(color){ case RED: System.out.println("it's red");break; case BLUE: System.out.println("it's blue");break; case BLACK: System.out.println("it's blue");break; } 枚举类的定义： 例1： public class TestEnum { //只能是三种颜色之一
Java基础知识总结（超级经典） 写代码： 1，明确需求。我要做什么？ 2，分析思路。我要怎么做？1,2,3。 3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。 4，代码实现。用具体的java语言代码把思路体现出来。 学习新技术的四点： 1，该技术是什么？ 2，该技术有什么特点(使用注意)： 3，该技术怎么使用。demo 4，该技术什么时候用？test。 ----------------------------------------------------------------------------------------------- 一：java概述： 1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器； 1994年将Oak语言更名为Java； Java的三种技术架构: JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发； JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础； JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序； 1，JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。 2，JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。3，配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。 环境变量的配置： 1）：永久配置方式：JAVA_HOME=%安装路径%\Java\jdk path=%JAVA_HOME%\bin 2）：临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin 特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。classpath的配置: 1）：永久配置方式：classpath=.;c:\;e:\ 2）：临时配置方式：set classpath=.;c:\;e:\ 注意：在定义classpath环境变量时，需要注意的情况 如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件； 如果指定了classpath，那么会在指定的目录下查找要运行的类文件。 还会在当前目录找吗？两种情况： 1）：如果classpath的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次。 2）：如果classpath的值结果出没有分号，在具体的路径中没有找到运行的类，不会再当前目录找。 一般不指定分号，如果没有在指定目录下找到要运行的类文件，就报错，这样可以调试程序。 4，javac命令和java命令做什么事情呢？ 要知道java是分两部分的：一个是编译，一个是运行。 javac：负责的是编译的部分，当执行javac时，会启动java的编译器程序。对指定扩展名的.java 文件进行编译。生成了jvm可以识别的字节码文件。也就是class文件，也就是java的运行程序。 java：负责运行的部分.会启动jvm.加载运行时所需的类库,并对class文件进行执行. 一个文件要被执行,必须要有一个执行的起始点,这个起始点就是main函数. ----------------------------------------------------------------------------------------------
java枚举类型 public class TestEnum { /*最普通的枚举*/ public enum ColorSelect { red, green, yellow, blue; } /* 枚举也可以象一般的类一样添加方法和属性,你可以为它添加静态和非静态的属性或方法,这一切都象你在一般的类中做的那样. */ public enum Season { // 枚举列表必须写在最前面，否则编译出错 winter, spring, summer, fall; private final static String location = "Phoenix"; public static Season getBest() { if (location.equals("Phoenix")) return winter; else return summer; } } /*还可以有构造方法*/ public enum Temp { /*通过括号赋值,而且必须有带参构造器和一属性跟方法，否则编译出错 * 赋值必须是都赋值或都不赋值，不能一部分赋值一部分不赋值 * 如果不赋值则不能写构造器，赋值编译也出错*/ absoluteZero(-459), freezing(32),boiling(212), paperBurns(451); private final int value; public int getValue() { return value; } //构造器默认也只能是private, 从而保证构造函数只能在内部使用 Temp(int value) { this.value = value; } } public static void main(String[] args) { /* * 枚举类型是一种类型，用于定义变量，以限制变量的赋值赋值时通过"枚举名.值"来取得相
1什么是变量？ 答:是指代在内存中开辟的储存空间，用于存放运算过程中需要用到的数据。 一个类中不能有2个public以为有pulic要和类名保持一致，有2个的话就不知道是和谁保持一致了，可以用很多类。 2变量的声明 答:当需要使用一个变量的时候，必须要对该变量就行声明，变量的声明包含2点，1是变量的基本数 据类型，2是变量名比如int a ；int是数据类型a是变量名，可以声明多个变量，比如int a，b，c；等 3，变量的初始化 答:有2种初始化方法， 1是在变量声明时初始化，变量类型变量名=初始值，比如int a=0； 2是先声明变量，然后再初始化给变量赋值，，比如int a；a=0； 3.1可以对变量中的值进行存取，操作，变量使用之前，要使用与其变量符合的数据类型。 3.2基本数据类型，8种 1整数类行:byte,short int(常用)，long（常用）2浮点类型:float，double（常用）3，boolean 4 char 类型名称字节空间使用场景 ------------------------------------------------------------------------------------------------------------ byte 丨1字节（8位）丨储存字节数据（较少用） --------------------------------------------------------------------------------------------------------------- short 丨2字节（16位）丨兼容性考虑（很少用） ------------------------------------------------------------------------------------------------------------ int 丨4字节（32位）丨存储普通整数（常用） -------------------------------------------------------------------------------------------------------------- long 丨8字节（64位）丨存储长整数（常用） ------------------------------------------------------------------------------------------------------------- float 丨4字节（32位）丨存储浮动数（不常用） ------------------------------------------------------------------------------------------------------------ double 丨8字节（64位）丨存储双精浮点数（常用） ----------------------------------------------------------------------------------------------------------- boolean 丨1字节（8位）丨存储逻辑变量（true，fales）（常用） --------------------------------------------------------------------------------------------------------------- char 丨2字节（16位）丨存储一个字符（常用） ---------------------------------------------------------------------------------------------------------------
static 关键字修饰的成员就是类成员，前面已经介绍的类成员有类属性、类方法、静态初始化块等三个成分，static关键字不能修饰构造器。static修饰的类成员属于整个类，不是属于单个实例的。 在JA V A类里只能包含属性，方法，构造器，初始化块，内部类和枚举类等六种成员，也包含了接口，目前已经介绍了前面四种，其中static可以修饰属性，方法，初始化块，内部类和枚举类，以static修饰的成员就是类成员，类成员属于整个类，而不是属于单个对象。 我们要知道，当系统第一次准备使用该类时，系统会为该类属性分配内存空间，类属性开始生效，直到该类被卸载，该类的类属性怕占有的内存才被系统的垃圾回收机制回收。类属性生存范围几乎等同于该类的生存范围，当类初始化完成后，类属性也被初始化完成。 类属性既可通过类来访问，也可通过类的对象来访问。但通过类的对象来访问类属性时，实际上并不是访问该对象所具有的属性。当通过对象来访问类属性时，系统会在底层转换让为通过该类来访问类属性。 由于所有对象实际上并不保持类属性，类属性是由该类来保持的，同一个类的所有对象访问类属性时，实际上访问的是该类所持有的属性。因此从程序运行表面上来看，即可看到同一类的所有实例的类属性共享同一块内存区。 类方法也是类成员的一种，类方法也是属于类的，通常直接使用类作为调用类方法，但也可以使用对象来调用类方法。与类属性类似的，即使使用对象来调用类方法，其效果与采用类来调用类方法完全一样。 当使用实例来访问类成员时，实际依然委托给该类来访问类成员，因此即使某个实例为Null它也可以访问它所属类的类成员。
本来是不想写太多的概念性的东西的，但为了大家能更好的理解写出来的代码，所以还是麻烦下自已写出来。 看代码： public class NullAccessStatic { private static void test() { System.out.println("static修饰的类方法"); } //主方法入口 public static void main(String[] args) { //定义一个NullAccessStatic变量，其值为：null NullAccessStatic nas = null; //null对象调用所属类的静态方法 nas.test(); } }
2010.3.11.Java笔记 1、定义一个年份判定这个年是否是闰年： import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; publicclass near { publicstaticvoid main(String args[])throws IOException{ int year; String str; BufferedReader buf; buf=new BufferedReader(new InputStreamReader(System.in)); System.out.println("Input the year:"); str=buf.readLine(); year=Integer.parseInt(str); if(year%4==0&&year%100!=0||year%400==0) System.out.println("year"+year+"is a leap year."); else System.out.println("year"+year+"is not a leap year."); } } 2、求出1~100之间的奇数： publicclass qishu { publicstaticvoid main(String args[]){ int i,j; for(i=1;i<=100;i++){ if(i%2!=0){ System.out.print(i+" "); } } } } 3、一段刚才长2000米每天截取一半多少天后长度短于5米publicclass day { publicstaticvoid main(String args[]){ int i ,j=0; for(i=2000;i>0;i--){ if(i/2<5) j++;} System.out.print(j+" "); } } 4、求125的所有因子： publicclass yinzi { publicstaticvoid main(String args[]){ int i; for(i=1;i<=125;i++){ if(125%i==0){
基本语法 编写Java程序时，应注意以下几点： ?大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。 ?类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。 ?方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。 ?源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。 ?主方法入口：所有的Java 程序由public static void main(String []args)方法开始执行。 Java标识符 Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。 关于Java标识符，有以下几点需要注意： ?所有的标识符都应该以字母（A-Z或者a-z）,美元符（$）、或者下划线（_）开始 ?首字符之后可以是字母（A-Z或者a-z）,美元符（$）、下划线（_）或数字的任何字符组合 ?关键字不能用作标识符 ?标识符是大小写敏感的 ?合法标识符举例：age、$salary、_value、__1_value ?非法标识符举例：123abc、-salary
Java修饰符 像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符： ?访问控制修饰符: default, public , protected, private ?非访问控制修饰符: final, abstract, strictfp 在后面的章节中我们会深入讨论Java修饰符。 Java变量 Java中主要有如下几种类型的变量 ?局部变量 ?类变量（静态变量） ?成员变量（非静态变量） Java数组 数组是储存在堆上的对象，可以保存多个同类型变量。在后面的章节中，我们将会学到如何声明、构造以及初始化一个数组。 Java枚举 Java 5.0引入了枚举，枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的bug。 例如，我们为果汁店设计一个程序，它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。 实例
1. 枚举类的说明： * 1.枚举类的理解：类的对象只有有限个，确定的。我们称此类为枚举类* 2.当需要定义一组常量时，强烈建议使用枚举类 * 3.如果枚举类中只一个对象，则可以作为单例模式的实现方式。 2. 如何自定义枚举类？步骤： //自定义枚举类 class Season{ //1.声明Season对象的属性:private final修饰 private final String seasonName; private final String seasonDesc; //2.私化类的构造器,并给对象属性赋值 private Season(String seasonName,String seasonDesc){ this.seasonName = seasonName; this.seasonDesc = seasonDesc; } //3.提供当前枚举类的多个对象：public static final的 public static final Season SPRING = new Season("春天","春暖花开"); public static final Season SUMMER = new Season("夏天","夏日炎炎"); public static final Season AUTUMN = new Season("秋天","秋高气爽"); public static final Season WINTER = new Season("冬天","冰天雪地"); //4.其他诉求1：获取枚举类对象的属性 public String getSeasonName() { return seasonName; } public String getSeasonDesc() { return seasonDesc; } //4.其他诉求1：提供toString() @Override public String toString() { return "Season{" + "seasonName='" + seasonName + '\'' + ", seasonDesc='" + seasonDesc + '\'' + '}'; } }
【黑马程序员】毕向东老师Java基础入门教程笔记 毕向东Java基础视频教程_适合初学者入门 完整视频：https://www.doczj.com/doc/9f17927167.html,/course/7.html?1911sxkqq 提取码：ks8m 课程资料：https://https://www.doczj.com/doc/9f17927167.html,/s/1jAjI85SlUTlrTuF_J2QNeQ 提取码：4bfg 黑马程序员视频库网址：https://www.doczj.com/doc/9f17927167.html,（海量热门编程视频、资料免费学习）学习路线图、学习大纲、各阶段知识点、资料网盘免费领取+QQ 3285264708 / 3549664195 1.编程：人与计算机之间交流的过程就是编程。 2.Java语言特点：跨平台性。原理：JAVA程序是通过java虚拟机运行在系统平台上的， 只要该系统可以安装相应的java虚拟机，该系统就可以运行JAVA程序。 3.JRE和JDK的区别： JDK：开发工具包，JDK是提供给开发人员使用的工具包。 JRE：JAVA运行环境包括java虚拟机和java程序所需的核心类库。 4.JAVA虚拟机jvm 是JAVA语言的运行环境，jvm读取并处理编译过的与平台无关的字节码文件 5.JAVA程序运行机制 Java源文件通过javac.exe 编译器编译成字节码文件，然后再通过jvm运行。 6.Java中需要注意的地方：一个JAVA源文件只定义一个类，不同的类使用不同的源文件 定义；将每个源文件中单独定义的类都定义成public的；保持JAVA源文件的主文件名与源文件中的类名一致；
7.Main方法的作用：程序的入口，保证程序的独立运行，被JVM调用。 8.文档注释： 单行注释：// 多行注释/* */ 文档注释/** */ 9.标识符的命名规则： 由字母、数字、下划线、$组成，不能以数字开头，严格区分大小写，不能使用关键字，10.Java中的常量和变量 定义变量的格式：数据类型变量名=初始化值； 作用范围：定义开始到定义它的代码块结束，定义范围内的左大括号开始，到右大括号结束。同一作用范围内，不允许多个局部变量命名冲突； 常量分为：整型常量小数常量布尔型常量字符型常量空常量（null）。、 11.整型常量：三种表现形式：计算机中存放的是二进制最低组成单位是八位，每八位 表示一个字节。 分为十进制八进制十六进制 12.局部变量和成员变量 局部变量：不是声明在类体括号里面的变量； 局部变量使用前必须初始化值; 局部变量没有默认初始化值; 局部变量的作用域是从定义开始到定义它的代码块结束; 成员变量:在方法体外,类体内声明的变量，又称字段(Field)或全局变量；（其实Java中没有全局变量，由于Java是面向对象语言，所有变量都是类成员），没有初始化时，会被赋予默认的初始化值。
/*通过getValue()取得相关枚举的值*/ System.out.println(t+"的值是"+t.getValue()); } } } 要求： （1）分析该程序，写出运行结果 【实验结果与分析】 图1 运行结果 分析：该程序主要应用了泛型和枚举的知识点。 2、编辑、编译、运行下面java程序 class Gen
public void setOb(T ob) { this.ob = ob; } public void showTyep() { System.out.println("T的实际类型是: " + ob.getClass().getName()); } } public class GenDemo { public static void main(String[] args){ //定义泛型类Gen的一个Integer版本 Gen
Java基础知识总结 写代码： 1，明确需求。我要做什么？ 2，分析思路。我要怎么做？1,2,3。 3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。 4，代码实现。用具体的java语言代码把思路体现出来。 学习新技术的四点： 1，该技术是什么？ 2，该技术有什么特点(使用注意)： 3，该技术怎么使用。demo 4，该技术什么时候用？test。 ----------------------------------------------------------------------------------------------- 一：java概述： 1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器； 1994年将Oak语言更名为Java； Java的三种技术架构: JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发； JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础； JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序； 1，JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。 2，JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java 虚拟机)。 3，配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。 环境变量的配置： 1）：永久配置方式：JAVA_HOME=%安装路径%\Java\jdk path=%JAVA_HOME%\bin 2）：临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin 特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。 classpath的配置: 1）：永久配置方式：classpath=.;c:\;e:\ 2）：临时配置方式：set classpath=.;c:\;e:\ 注意：在定义classpath环境变量时，需要注意的情况 如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件； 如果指定了classpath，那么会在指定的目录下查找要运行的类文件。 还会在当前目录找吗？两种情况： 1）：如果classpath的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次。 2）：如果classpath的值结果出没有分号，在具体的路径中没有找到运行的类，不会再当前目
JAVA的面向对象编程--------课堂笔记 面向对象主要针对面向过程。 面向过程的基本单元是函数。 什么是对象：EVERYTHING IS OBJECT（万物皆对象） 所有的事物都有两个方面： 有什么（属性）：用来描述对象。 能够做什么（方法）：告诉外界对象有那些功能。 后者以前者为基础。 大的对象的属性也可以是一个对象。 为什么要使用面向对象： 首先，面向对象符合人类看待事物的一般规律。 对象的方法的实现细节是屏蔽的，只有对象方法的实现者了解细节。 方法的定义非常重要。方法有参数，也可能有返回值。 注意区分：对象（本身）、对象的实现者、对象的调用者。 分析对象主要从方法开始。 我们通过类来看待对象，类是对象的抽象。 其次，采用面向对象方法可以使系统各部分各司其职、各尽所能。 对象之间的耦合性一定要低（比如不同硬盘和不同主板之间的关系）。这样才能使每个对象本身做成最好的。 对于对象的要求：高内聚、低耦合，这样容易拼装成为一个系统。 实现高内聚就是要最大限度低提高复用性（复用性好是因为高内聚）。 可复用性是OOP的基础。 比较面向过程的思想和面向对象的思想： 面向过程的思想：由过程、步骤、函数组成，以过程为核心； 面向对象的思想：以对象为中心，先开发类，得到对象，通过对象之间相互通信实现功能。 面向过程是先有算法，后有数据结构。 面向对象是先有数据结构，然后再有算法。 在用面向对象思想开发的过程中，可以复用对象就进行复用，如无法进行复用则开发新的对象。 开发过程是用对个简单的对象的多个简单的方法，来实现复杂的功能。 从语法上来看，一个类是一个新的数据类型。 在面向对象编程中，除了简单数据类型，就是对象类型。 定义类的格式： class Student{ 代码 } 注意类名中单词的首字母大写。 实例变量：定义在类中但在任何方法之外。（New出来的均有初值） 局部变量：定义在方法之中的变量。
Java_U1课堂笔记 （一）初识Java 一、配置Java环境变量： 1、复制JDK安装路径，如：C:\Program Files (x86)\Java\jdk1.7.0_51\bin 2、粘贴到我的电脑->属性->高级系统设置->环境变量->Path 3、加上英文的分号 4、验证是否配置正确：dos-->java -version 进入DOS窗口的方法： 运行（或快捷键windows键+r） 二、Java程序编写三步骤： 编写.java 编译：javac **.java 运行java ** 三、使用jad反编译工具： DOS中切换至jad安装目录，如：C:\jad1.5.8g.win 输入命令：jad -s java D:\t01\HelloWorld.class 四、变量的使用: 变量 取名，命名规则 类型 数值：int、double、float(f) 非数值:char、String 类型名字= 值; int age=10; 五、上机验证： System.out.println(5+3); System.out.println("5"+3); 六、Scanner的使用，接收用户键盘输入 Scanner import java.util.Scanner; Scanner input=new Scanner(System.in); input.next();（相关方法，nextDouble()、nextFloat()、nextInt(等）bin:exe jre lib src.zip （二）数据类型 一、数据类型转换 自动类型转换： int num=100; double b=num;
Java枚举类型入门 这里就将为大家谈谈Java枚举类型，static final通常跟的是一个int类型的常数，所以有时候可以用int型代替枚举。在Java中，枚举确实是一个类。 Tiger中的一个重要新特性是枚举构造，它是一种新的Java枚举类型，允许用常量来表示特定的数据片断，而且全部都以类型安全的形式来表示。Tiger 专家、developerWorks 的多产作者Brett McLaughlin将解释枚举的定义，介绍如何在应用程序中运用枚举，以及它为什么能够让您抛弃所有旧的public static final 代码。 您已经知道，Java 代码的两个基本的构造块是类和接口。现在Tiger 又引入了枚举，一般简称它为enum。这个新类型允许您表示特定的数据点，这些数据点只接受分配时预先定义的值集合。当然，熟练的程序员可以用静态常量实现这项功能，如清单 1 所示：清单 1. public static final 的常量 1.public class OldGrade { 2. 3.public static final int A = 1; 4.public static final int B = 2; 5.public static final int C = 3; 6.public static final int D = 4; 7.public static final int F = 5; 8.public static final int INCOMPLETE = 6; 9.} 说明：我要感谢O'Reilly 媒体公司，该公司允许在本文中使用我撰写的Java 1.5 Tiger:A Developer's Notebook 一书中“枚举”这一章中的代码示例（请参阅参考资料）。 然后您就可以让类接受像OldGrade.B 这样的常量，但是在这样做的时候，请记住这类常量是Java 中int 类型的常量，这意味着该方法可以接受任何int 类型的值，即使它和OldGrade 中定的所有级别都不对应。因此，您需要检测上界和下界，在出现无效值的时候，可能还要包含一个IllegalArgumentException。而且，如果后来又添加另外一个级别（例如OldGrade.WITHDREW_PASSING），那么必须改变所有代码中的上界，才能接受这个新值。 换句话说，在使用这类带有整型常量的类时，该解决方案也许可行，但并不是非常有效。幸运的是，枚举提供了更好的方法。 定义枚举清单 2 使用了一个可以提供与清单 1 相似的功能的枚举： 清单 2. 简单的枚举类型
枚举类型的定义enum Enum作为Sun全新引进的一个关键字，看起来很象是特殊的class, 它也可以有自己的变量，可以定义自己的方法，可以实现一个或者多个接口。当我们在声明一个enum类型时，我们应该注意到enum类型有如下的一些特征。 1．它不能有public的构造函数，这样做可以保证客户代码没有办法新建一个enum 的实例。 2．所有枚举值都是public , static , final的。注意这一点只是针对于枚举值，我们可以和在普通类里面定义变量一样定义其它任何类型的非枚举变量，这些变量可以用任何你想用的修饰符。 3．Enum默认实现了https://www.doczj.com/doc/9f17927167.html,parable接口。 4．Enum覆载了了toString方法，因此我们如果调用Color.Blue.toString()默认返回字符串”Blue”. 5．Enum提供了一个valueOf方法，这个方法和toString方法是相对应的。调用valueOf(“Blue”)将返回Color.Blue.因此我们在自己重写toString方法的时候就要注意到这一点，一把来说应该相对应地重写valueOf方法。 6．Enum还提供了values方法，这个方法使你能够方便的遍历所有的枚举值。 7．Enum还有一个oridinal的方法，这个方法返回枚举值在枚举类种的顺序，这个顺序根据枚举值声明的顺序而定，这里Color.Red.ordinal()返回0。 了解了这些基本特性，我们来看看如何使用它们。 1．遍历所有有枚举值. 知道了有values方法，我们可以轻车熟路地用ForEach 循环来遍历了枚举值了。 for (Color c: Color.values()) System.out.println(“find value:” + c); 2．在enum中定义方法和变量，比如我们可以为Color增加一个方法随机返回一个颜色。