黑马程序员_java高新技术--枚举

day01***Eclipse/枚举
*Workspace与project

会切换工作间与导入项目

*Perspective(透视图)与view

windows下有reset perspective重置透视图

*设置整个workspace的javac与java

*设置单个工程的javac与java

*快捷键的绑定与代码模块

*利用快捷键提高工作效率

在应用中具体举例讲解。

@@快捷键

Ctrl+1 快速改正

Alt+选中 看源码(没有源码则粘贴源码进去，文件夹-External Folder),(java)文件-External File)

Alt+/ 联想功能

Alt+左右 看源码时的前后顺序

Alt+上下 移动选中的代码

ctrl+Alt+上下 复制选中的代码

ctrl+T 查看类的继承关系

f2 f2进入提示框,查看方法的说明

ctrl+shift+X/大写 ctrl+shift+Y/小写

ctrl+shift+f 格式化format代码

ctrl+shift+o 导包

ctrl+shift+/ 加注释

ctrl+shift+\ 除注释

ctrl+shift+L 查看所有快捷键

ctrl+shift+T 直接看源码(自己输入)

Alt+shift+s 自动生成一些源代码source等

选中代码Alt+shift+M ==> extract Method 提取方法

@@断点

f5：step into跳入

f6：step over跳过

f7：step return 跳回

drop to fram ：跳到当前方法的第一行

resume：跳到下一个断点(没有下一个则运行完整个程序)

watch：观察变量或表达式的值

断点注意问题：

1，断点调试完成后，要在breakpoints视图中清除所有断点

2，断点调试完成后，一定记得结束运行断点的JVM

@@eclipse的使用技巧

02 eclipce及ide开发工具的简介

myeclipse是eclipse的插件，使eclipse可以进行web项目开发

现在myeclipse整合了eclipse，包含了eclipse工具。

myeclipse是用java开发的

进程中的javaw.exe 开启的就是图形化的java控制台，而不像java.exe开启的是dos命令行。

专业术语(面试)

java ee

ide--> Integrated Development Environment 集成开发环境

jms

jmx

jndi

03 eclipse工程管理与快捷键配置。

window--preferences常用

一个相对独立的项目就是一个工程，一个工程中涉及的多个java文件，资源文件等用一个工程进行管理。

开发工具能对所有的源文件集中管理，记住每个源文件的位置和相互关系。

工程中有哪几个源文件，启动类是哪个，启动参数设置等配置信息在工程中都记录。

一个workspace可以包含多个project。如果要为eclipse再配置一套环境选项，可以再创建一个work是。

资源文件就是配置文件。

file--switch workspace 切换工作间

一个工作间有自己的特色环境配置，其下的工程与工作间的环境配置一样。

java工程的包名 com.机构名.内容 name:类名(大写)

快捷键的使用技巧：General-keys，设置 Alt+/ 进行内容提示，要注意解除Alt+/ 原来的绑定关系。直接输入alt+/

就可以找到它的绑定关系，删除用 remove binding 。

04 透视图 与程序调试

透视图：window --Show View

透视图其实就是界面的布局。不同的透视图，包含不同的视图（view），每个视图的位置、大小也不同。

断点

f5 :step into

f6: step over

f7: step return

调试:双击设置断点，右键 debug as ...打开debug视图 选中参数，右键watch

drop to frame: 跳到当前方法的第一行

resume： 跳到下一个断点。(如果没有下一个，则运行完整个程序)

watch:观察变量或表达式的值

注意：

调试完后，要在breakpoints视图中清除所有断点。

调试完后，一定记得结束运行断点的jvm。

05 编译与运行环境

java--compiler 编译时的环境

java--Installed JREs 运行时的环境

单独工程 右键--Properties java Compiler编译环境

--Run as --其它--JRE 查看单独一个工程的运行环境

高版本的java能否运行低版本的javac编译的程序？能：1.6jre的java，能运行1.5的javac编译的程序。

低版本的java能否运行高版本的javac编译的程序？不能：1.5jre的java，不能运行1.6编译的程序。

06 java模板代码 window--pre--java--Editor Templates

代码模块的设置java-editor-Templates,new，

name：tryf

pattern：try{

line_selection选中的内容

}finally{

cursor光标

}

使用模板 选中代码 右键 Surround With 循环/try异常/同步...

07 导入已有的工程：

先将工程文件拷贝到工作间下

然后file--import--general--Existig Projects Workspace--目录

jre的库设置

包和库的设置 选中工程--右键--Build Path--其它--Libraries --Add Library(多个jar包)--user Library--自己命名库，增加多个jar包

08 @@静态导入(JDK1.5后)与编译器语法设置

import 导入一个类或某个包中所有的类

import static 导入一个类中的某个静态方法或所有静态方法。

//import static java.lang.Math.max;

import static java.lang.Math.*;

System.out.println(max(3, 6));可以省略类名

System.out.println(abs(3 - 6));

09 @@可变参数与Overload面试题

可变参数的特点：

可变参数你就把它看成数组

只能出现的参数列表的最后面；

...位于变量类型和变量名之间，前后有无空格都可以

调用可变参数的方法，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式方法可变参数。

可以以数组的形式来调用可变参数。

public class VarableParameter {

public static void main(String[] args){

System.out.println(add(2,3,4));

System.out.println(add(1,2,3,4,5));

}

public static int add(int x,int...args){

int sum = x;

for(int i =0;i<args.length;i++){

sum += args[i];

}

return sum;

}

}

可变参数注意问题：

int nums[] = {1,2,3,5};

//把数组当成一个对象放进了list中了

list = Arrays.asList(nums);

System.out.println(list);//打印[[I@7ced01]地址值

Integer num[] = {1,2,3,5};

//把数组中的每个元素都当成一个对象放进了list中了

list = Arrays.asList(num);

System.out.println(list);//打印[1, 2, 3, 5]

overload重载 Vs override 覆盖

override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。

在覆盖要注意以下的几点：

1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；

2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；

3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；

4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。

在使用重载要注意以下的几点：

1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序；

2、不能通过访问权限、返回类型、抛出的异常进行重载；

3、方法的异常类型和数目不会对重载造成影响；

4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

10 @@增强for循环

增强for循环注意问题：增强for只适合取数据，不能改变数据。

for(type 变量名 : 集合变量名){...}

注意：迭代变量必须在()中定义

集合变量可以是数组或实现了Iterable接口的集合类。

11 @@自动装箱与拆箱(JDK1.5后)

Integer iObj = 3;//自动装箱

System.out.println(iObj + 12);//自动拆箱

Integer i1 = 13;

Integer i2 = 13;

//在装箱成Integer时，如果在-128~127;范围内，就会缓存以来。

System.out.println(i1==i2);//ture

Integer i3 = 134;

Integer i4 = 134;

//在装箱成Integer时，如果超过-128~127;范围，就不会缓存以来。

System.out.println(i3==i4);//false

这是一种享元模式。flyweight。(word中的字符，OS中的图标。。。等)

享元模式下：

word文档中的每个字符

把26个字符提前实例化变成对象，word中的每个字符只是调用某个字符对象的方法，参数是坐标。

通过方法 i(int x,int y)//调用字符 i 的方法，参数是字符想要显示的坐标

非享元模式下：

每次写下一个字符就是一次实例化，对每个字符进行实例化

i(char ch,int x,int y)//大量的创建实例，浪费内存资源。

Integer i5 = Integer.valueOf(127);

Integer i6 = Integer.valueOf(127);

System.out.println(i5==i6);//true

Integer i7 = Integer.valueOf(128);

Integer i8 = Integer.valueOf(128);

System.out.println(i7==i8);//false

12@@枚举

为什么要有枚举

问题：要定义星期几或性别的变量，该怎么定义？假设1-7分别表示星期一到星期七，但有人会写 0；

枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。

枚举可以让编译器在编译时就可以控制程序中的非法值，普通变量的方式在开发阶段无法实现这一功能。

用普通类如何实现枚举功能，定义一个Weekday的类来模拟枚举功能

*私有的构造方法

*每个元素分别用一个公有的静态成员变量表示

*可以有若干公有方法或抽象方法，要提供nextDay()方法必须是抽象的。

枚举的基本应用

*举例：定义一个WeekDay的枚举。

*扩展：枚举类的values，valueOf，getName，toString，ordinal等方法

*总结：枚举是一个特殊的类，其中的每个元素都是该类的一个实例化对象。

例如可以调用WeekDay.SUN.getClass().getName和WeekDay.class.getName()

枚举也可以实现接口、或者继承抽象类。

JDK5.0中扩展了switch语句，它除了接受int，byte，char，short，还可以接受一个枚举类型。

//测试枚举的常用方法

public void test2(){

System.out.println(Grand.C.name());//枚举常量的名字 C

System.out.println(Grand.C.ordinal());//枚举常量的序数 2

String str = "B";

//Grand g = Grand.valueOf(Grand.class, str);

Grand g = Grand.valueOf(str); //开发中常用！

System.out.println(g); //B

Grand gs[] = Grand.values(); //返回枚举类Grand中所有的枚举常量

for(Grand g1 : gs)

System.out.println(g1); //A B C D E

}

@@枚举入门

public static void main(String[] args) {

WeekDay weekDay2 = WeekDay.FRI;//该句话编译时，会调用WeekDay的七个构造函数

System.out.println(weekDay2);FRI

System.out.println(weekDay2.name());//FRI

System.out.println(weekDay2.ordinal());//5 位置

System.out.println(weekDay2.toString());//FRI

System.out.println(weekDay2.getClass());//class cn.itcast.day1.EnumTest$WeekDay

System.out.println(WeekDay.valueOf("SUN").toString());//SUN

System.out.println(WeekDay.values().length);//7

}

//格式

(1)最简单

public enum WeekDay{

SUN,MON,TUE,WED,THU,FRI,SAT

}

(2)带构造方法的枚举，构造方法必须私有

public enum WeekDay{//相当于内部类

SUN(1),MON(),TUE,WED,THU,FRI,SAT;//必须放第一行

private WeekDay(){System.out.println("first");}

private WeekDay(int day){System.out.println("second");}

}

(3)带抽象方法的枚举

public enum TrafficLamp{

RED {//生成一个类文件EnumTest$TrafficLamp$1.class

@Override

public TrafficLamp nextLamp() {

return GREEN;

}

},GREEN {//生成一个类文件EnumTest$TrafficLamp$2.class

@Override

public TrafficLamp nextLamp() {

return YELLOW;

}

},YELLOW {//生成一个类文件EnumTest$TrafficLamp$3.class

@Override

public TrafficLamp nextLamp() {

return RED;

}

};

public abstract TrafficLamp nextLamp();

}

(4)带构造方法和抽象方法的枚举

public enum TrafficLamp{

RED(30) {//生成一个类文件EnumTest$TrafficLamp$1.class

@Override

public TrafficLamp nextLamp() {

return GREEN;

}

},GREEN (45){//生成一个类文件EnumTest$TrafficLamp$2.class

@Override

public TrafficLamp nextLamp() {

return YELLOW;

}

},YELLOW (5){//生成一个类文件EnumTest$TrafficLamp$3.class

@Override

public TrafficLamp nextLamp() {

return RED;

}

};

public abstract TrafficLamp nextLamp();

private int time;

private TrafficLamp(int time){this.time = time;}

}

(5)带构造方法和普通方法的枚举

public enum TrafficLamp{

RED(30) {//生成一个类文件EnumTest$TrafficLamp$2.class

@Override

public TrafficLamp nextLamp() {

return GREEN;

}

},GREEN (45){//生成一个类文件EnumTest$TrafficLamp$2.class

@Override

public TrafficLamp nextLamp() {

return YELLOW;

}

},YELLOW (5);//不生成类文件

public TrafficLamp nextLamp(){

return null;

}

private int time;

private TrafficLamp(int time){this.time = time;}

}

*枚举就相当于一个类，其中也可以定义构造方法、成员变量、普通方法、抽象方法

*枚举元素必须位于枚举体中的最开始部分，枚举元素列表的最后面有分号与其他成员隔开。

把枚举中的成员方法或变量等放在枚举前面，会编译失败。

*带构造方法的枚举

构造方法必须私有

可以有多个构造方法

枚举元素MON和MON() 效果一样，都是调用默认的构造方法。

*带方法的枚举

实现普通的方法

实现抽象的方法：每个元素分别是有枚举类的子类来生成的实例对象，这些子类采用类似内部类的方式进行定义。

*枚举只有一个成员时，就可以作为一种单例的实现方式。