Java小试牛刀1

[align=center][size=xx-large][b]Java小试牛刀1[/b][/size][/align]


[size=large]一、快捷方式[/size]
Ctrl+1 快速修复(最经典的快捷键,就不用多说了)
Ctrl+D: 删除当前行
Ctrl+Alt+↓ 复制当前行到下一行(复制增加)
Ctrl+Alt+↑ 复制当前行到上一行(复制增加)
Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)
Alt+↑ 当前行和上面一行交互位置(同上)
Alt+← 前一个编辑的页面
Alt+→ 下一个编辑的页面(当然是针对上面那条来说了)
Alt+Enter 显示当前选择资源(工程,or 文件 or文件)的属性
Shift+Enter 在当前行的下一行插入空行(这时鼠标可以在当前行的任一位置,不一定是最后)
Shift+Ctrl+Enter 在当前行插入空行(原理同上条)
Ctrl+Q 定位到最后编辑的地方
Ctrl+L 定位在某行 (对于程序超过100的人就有福音了)
Ctrl+M 最大化当前的Edit或View (再按则反之)
Ctrl+/ 注释当前行,再按则取消注释
Ctrl+O 快速显示 OutLine
Ctrl+T 快速显示当前类的继承结构
Ctrl+W 关闭当前Editer
Ctrl+K 参照选中的Word快速定位到下一个
Ctrl+E 快速显示当前Editer的下拉列表(如果当前页面没有显示的用黑体表示)
Ctrl+/(小键盘) 折叠当前类中的所有代码
Ctrl+×(小键盘) 展开当前类中的所有代码
Ctrl+Space 代码助手完成一些代码的插入(但一般和输入法有冲突,可以修改输入法的热键,也可以暂用Alt+/来代替)
Ctrl+Shift+E 显示管理当前打开的所有的View的管理器(可以选择关闭,激活等操作)
Ctrl+J 正向增量查找(按下Ctrl+J后,你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在stutes line中显示没有找到了,查一个单词时,特别实用,这个功能Idea两年前就有了)
Ctrl+Shift+J 反向增量查找(和上条相同,只不过是从后往前查)
Ctrl+Shift+F4 关闭所有打开的Editer
Ctrl+Shift+X 把当前选中的文本全部变味小写
Ctrl+Shift+Y 把当前选中的文本全部变为小写
Ctrl+Shift+F 格式化当前代码
Ctrl+Shift+P 定位到对于的匹配符(譬如{}) (从前面定位后面时,光标要在匹配符里面,后面到前面,则反之)

下面的快捷键是重构里面常用的,本人就自己喜欢且常用的整理一下(注:一般重构的快捷键都是Alt+Shift开头的了)
Alt+Shift+R 重命名 (是我自己最爱用的一个了,尤其是变量和类的Rename,比手工方法能节省很多劳动力)
Alt+Shift+M 抽取方法 (这是重构里面最常用的方法之一了,尤其是对一大堆泥团代码有用)
Alt+Shift+C 修改函数结构(比较实用,有N个函数调用了这个方法,修改一次搞定)
Alt+Shift+L 抽取本地变量( 可以直接把一些魔法数字和字符串抽取成一个变量,尤其是多处调用的时候)
Alt+Shift+F 把Class中的local变量变为field变量 (比较实用的功能)
Alt+Shift+I 合并变量(可能这样说有点不妥Inline)
Alt+Shift+V 移动函数和变量(不怎么常用)
Alt+Shift+Z 重构的后悔药(Undo)

编辑
作用域 功能 快捷键
全局 查找并替换 Ctrl+F
文本编辑器 查找上一个 Ctrl+Shift+K
文本编辑器 查找下一个 Ctrl+K
全局 撤销 Ctrl+Z
全局 复制 Ctrl+C
全局 恢复上一个选择 Alt+Shift+↓
全局 剪切 Ctrl+X
全局 快速修正 Ctrl1+1
全局 内容辅助 Alt+/
全局 全部选中 Ctrl+A
全局 删除 Delete
全局 上下文信息 Alt+？
Alt+Shift+?
Ctrl+Shift+Space
Java编辑器 显示工具提示描述 F2
Java编辑器 选择封装元素 Alt+Shift+↑
Java编辑器 选择上一个元素 Alt+Shift+←
Java编辑器 选择下一个元素 Alt+Shift+→
文本编辑器 增量查找 Ctrl+J
文本编辑器 增量逆向查找 Ctrl+Shift+J
全局 粘贴 Ctrl+V
全局 重做 Ctrl+Y


查看
作用域 功能 快捷键
全局 放大 Ctrl+=
全局 缩小 Ctrl+-


窗口
作用域 功能 快捷键
全局 激活编辑器 F12
全局 切换编辑器 Ctrl+Shift+W
全局 上一个编辑器 Ctrl+Shift+F6
全局 上一个视图 Ctrl+Shift+F7
全局 上一个透视图 Ctrl+Shift+F8
全局 下一个编辑器 Ctrl+F6
全局 下一个视图 Ctrl+F7
全局 下一个透视图 Ctrl+F8
文本编辑器 显示标尺上下文菜单 Ctrl+W
全局 显示视图菜单 Ctrl+F10
全局 显示系统菜单 Alt+-


导航
作用域 功能 快捷键
Java编辑器 打开结构 Ctrl+F3
全局 打开类型 Ctrl+Shift+T
全局 打开类型层次结构 F4
全局 打开声明 F3
全局 打开外部javadoc Shift+F2
全局 打开资源 Ctrl+Shift+R
全局 后退历史记录 Alt+←
全局 前进历史记录 Alt+→
全局 上一个 Ctrl+,
全局 下一个 Ctrl+.
Java编辑器 显示大纲 Ctrl+O
全局 在层次结构中打开类型 Ctrl+Shift+H
全局 转至匹配的括号 Ctrl+Shift+P
全局 转至上一个编辑位置 Ctrl+Q
Java编辑器 转至上一个成员 Ctrl+Shift+↑
Java编辑器 转至下一个成员 Ctrl+Shift+↓
文本编辑器 转至行 Ctrl+L


搜索
作用域 功能 快捷键
全局 出现在文件中 Ctrl+Shift+U
全局 打开搜索对话框 Ctrl+H
全局 工作区中的声明 Ctrl+G
全局 工作区中的引用 Ctrl+Shift+G


文本编辑
作用域 功能 快捷键
文本编辑器 改写切换 Insert
文本编辑器 上滚行 Ctrl+↑
文本编辑器 下滚行 Ctrl+↓


文件
作用域 功能 快捷键
全局 保存 Ctrl+X
Ctrl+S
全局 打印 Ctrl+P
全局 关闭 Ctrl+F4
全局 全部保存 Ctrl+Shift+S
全局 全部关闭 Ctrl+Shift+F4
全局 属性 Alt+Enter
全局 新建 Ctrl+N


项目
作用域 功能 快捷键
全局 全部构建 Ctrl+B


源代码
作用域 功能 快捷键
Java编辑器 格式化 Ctrl+Shift+F
Java编辑器 取消注释 Ctrl+\
Java编辑器 注释 Ctrl+/
Java编辑器 添加导入 Ctrl+Shift+M
Java编辑器 组织导入 Ctrl+Shift+O
Java编辑器 使用try/catch块来包围 未设置，太常用了，所以在这里列出,建议自己设置。
也可以使用Ctrl+1自动修正。


运行
作用域 功能 快捷键
全局 单步返回 F7
全局 单步跳过 F6
全局 单步跳入 F5
全局 单步跳入选择 Ctrl+F5
全局 调试上次启动 F11
全局 继续 F8
全局 使用过滤器单步执行 Shift+F5
全局 添加/去除断点 Ctrl+Shift+B
全局 显示 Ctrl+D
全局 运行上次启动 Ctrl+F11
全局 运行至行 Ctrl+R
全局 执行 Ctrl+U


重构
作用域 功能 快捷键
全局 撤销重构 Alt+Shift+Z
全局 抽取方法 Alt+Shift+M
全局 抽取局部变量 Alt+Shift+L
全局 内联 Alt+Shift+I
全局 移动 Alt+Shift+V
全局 重命名 Alt+Shift+R
全局 重做 Alt+Shift+Y


[size=large]二、Java package的作用：[/size]

[b]深入分析package与import机制部分[/b]

1、不管你有没有使用import指令，存在目前目录下的类都会被编译器优先采用，只要它不属于任何package。这是因为编译器总是先假设您所输入的类名就是该类的全名（不属于任何package），然后-classpath所指定的路径中搜索属于该类的.java文件或.class文件，在这里可以知道default package的角色非常特殊。

2、必须明确告诉编译器我们用到哪个package下的类，导入时或在包名称.类名称中进行引用。导入某个包时，一定要进行-classpath路径指定某个包的位置。你如果指定了多个路径话，如果在一个路径下已经找到了该包话，就优先引用该包的类。

3、当java编译器开始编译某个类的源代码时，首先它会做一件事情，这就是建立“类路径引用表”，它是根据参数-classpath或classpath环境变量来建立的。如果没有指定选项-classpath或环境变量CLASSPATH时，缺省情况下类路径引用表只有一笔记录，即当前的目录(“.”)。环境变量CLASSPATH的内容会被选项-classpath所覆盖，没有累加效果。

4、当编译器将类路径引用表建立好之后，接着编译器要确定它可以利用类引用表里的数据作为相对起始路径，找到所有用到的package。编译器还要完成一张名为“类引用表”与“相对类引用表”的数据结构。

整个编译程序中package与import机制相关的部分流程如下：
1)开始
2)建立类路径引用表与类引用表
3)如果建立成功：则类名称解析程序
4)如果已存在该类的类文件，继续其它的编译工作
5)如果该类的文件不存在，寻找该类的源代码文件
6)如果找到，则编译该类的源代码，继续其它的编译工作
7)此时，也可返回到开始，make机制，递归式编译
8)如果找不到，编译结束，发出警告信息
9)如果建立失败：编译结束，发出警告信息。


[b]JAVA动态链接本质研究[/b]


1、不管你在同一个源代码（.java）中使用了几个类声明，它们都会一一编译成.class文件，即使是内部类、匿名类都是一样。在java中，对于每一个类所构成的类文件，都可将它视为动态链接库。

2、在类文件中，所有对于特写类的操作都被转换成类的全名。Import除了用来指引编译器解析出正确的类名称之外，没有其它功能。

3、在运行时期，仍然用到一个与编译器相同的程序，就是类路径引用表的建立，而利用动态链接载入类文件的机制流程如下：

1)开始，建立类路径引用表，根据类文件内部的信息，与类路径引用表的数据合成类文件的绝对路径。
2)如果找到类文件，检查该类的类文件内部信息，是否符合相对路径信息：如果符合，载入该类。如果不符合，执行错误，发出Exception信息。
3)如果找不到类文件，则执行错误，发出Exception信息。


最后，需要说明的是，在java中提供许多的类包，java语言中将完成与计算机底层相关的输入输出、常用的数据类型转换等功能的函数封装在包中。如果你的程序提示找不到这样基础包的话，你就可以用参数-classpath或环境变量classpath进行指定位置来解决此类问题！



[size=large]三、双彩球摇奖：[/size]

package TextPackge;
/**
 * 模拟双色球博彩
 * 
 * @author Sean 2012-9-6
 * 
 */
public class MainBody {

 /**
  * 主程序入口
  * 
  * @param args
  */
 public static void main(String[] args) {
  /**
   * 创建摇奖机
   */
  Ernie ernie = new Ernie();
  /**
   * 放入红球,并启动,抽取7只球
   */
  ernie.input("red",40, 7);
  ernie.start();
  /**
   * 放入蓝球,并启动,抽取2只球
   */
  ernie.input("blue",16, 2);
  ernie.start();
  /**
   * 公布中奖结果
   */
  ernie.announce();
 }
}

package TextPackge;
import java.util.Collections;
import java.util.Comparator;
import java.util.Vector;
/**
 * 摇奖机
 * 
 * @author Sean 2012-9-6
 * @param <T>
 * 
 */
public class Ernie {
 private int m;
 private String color;
 private String redBall;
 private String blueBall;

 /**
  * 创建存储球体的向量
  */
 Vector<Ball> ballList = new Vector<Ball>();
 /**
  * 中奖向量，用于存储中奖球体
  */
 Vector<Ball> luckList = new Vector<Ball>();

 /**
  * 置入球
  * 
  * @param i
  *            放入球的数量
  * @param j
  *            抽取球的数量
  */
 public void input(String color, int n, int m) {
  this.m = m;
  this.color = color;

  /**
   * 置入红球
   */
  if (color.equals("red")) {
   for (int t = 1; t <= n; t++) {
    Ball e = new Ball(t, "red");
    ballList.add(e);
   }
  } else if (color.equals("blue")) { // 置入蓝球
   for (int t = 1; t <= n; t++) {
    Ball e = new Ball(t, "blue");
    ballList.add(e);
   }
  } else {
   System.out.println("球的颜色有误！！！");
  }

 }
 /**
  * 启动摇奖
  */
 public void start() {
  /**
   * 随机抽取球
   */
  if (color.equals("red")) {
   for (int t = 1; t <= m; t++) {
    int i = (int) (Math.random() * ballList.size());
    luckList.add(ballList.get(i));
    ballList.remove(i);
   }
  } else if (color.equals("blue")) {
   for (int t = 1; t <= m; t++) {
    int i = (int) (Math.random() * ballList.size());
    luckList.add(ballList.get(i));
    ballList.remove(i);
   }
  }
  /**
   * 首先对向量内的元素排序 红球升序 蓝球降序
   */
  if (color.equals("red")) {
   redBall = "红球：";
   /**
    * 红球升序
    */
   Collections.sort(luckList, new Comparator<Ball>() {
    /**
     * 实现接口中的方法
     */
    public int compare(Ball o1, Ball o2) {
     return o1.id - o2.id;
    }
   });
  } else if (color.equals("blue")) {
   blueBall = "蓝球：";
   /**
    * 蓝球降序
    */
   Collections.sort(luckList, new Comparator<Ball>() {
    /**
     * 实现接口中的方法
     */
    public int compare(Ball o1, Ball o2) {
     return o2.id - o1.id;
    }
   });
  }
  /**
   * 将结果存入结果向量中
   */
  for (int t = 0; t < luckList.size(); t++) {
   if (color.equals("red")) {
    redBall += luckList.get(t).id + "  ";
   } else if (color.equals("blue")) {
    blueBall += luckList.get(t).id + "  ";
   }
  }
  luckList.clear();
 }

 /**
  * 公布结果
  */
 public void announce() {
  /**
   * 公布结果
   */
  System.out.println(redBall+blueBall);
 }

}

 /**
  * 构造函数
  * 
  * @param id
  *            编号
  * @param color
  *            颜色
  */
 public Ball(int id, String color) {
  this.id = id;
  this.color = color;
 }
}

[size=large]心得：[/size]

双色彩球摇奖，这是一个简单的数据模拟实验，从中学会了使用向量Vector存储数据，通过随机产生一个下标来抽取向量中的数据，存入一个优先队列中去，这样就可以自动生成一个有序队列，最后可以输出优先队列来公布这个中奖结果；功能很简单，在这个小实验中，让我切实的领会了JAVA一切皆为对象的特点，摇奖机是一个对象，每个球是一个对象；通过控制摇奖机来取出随机的彩球来得到最终的结果。其中，当向量中取出了该彩球后，立刻执行ballList.remove(n);语句，删除该元素，可避免抽到重复的彩球。