javaEE学习笔记【01】集成环境开发应用、JDK新特性

标签：

1. 项目创建和运行
   
   在包视图中创建项目
   1. 右键->New->JavaProject      创建项目Java项目
   2. 右键->New  ->Class           创建类右键Run as ->JavaApplication
   可以直接在控制台Console视图中查看结果。
2.  编译器的环境设置
   1. 单击项目右键->Properties->JavaCompiler->5或6
   如果编译器的环境高于运行时环境会报错

3. 运行环境的JRE编译的设置
   

   1. 项目右键
   2. ->Build path->ConfigureBuild path->Libraries
   3. ->选中要修改的JRE->Edit->Alternate JRE ->Install JRE
   4. ->需要制定JRE的home目录然后单击安装->Finish
   5. ->选择自己的JRE即可
4. 常用快捷键

   代码	说明
   Alt+/	内容提示
   Ctrl+Alt+↓	快速的复制当前行
   Alt+↑或↓	快速一定当前行
   Ctrl+Shift+F	格式化
   Ctrl+/	单行注释，再次使用取消注释
   Ctrl+shift+/	多行注释，取消注释Ctrl+shift+\
   Ctrl+shift+O	导包语句，该快捷键一次性可以导入多个包
   Ctrl+1	快速修复错误，但是该快捷键只能修复小错误

5. 快捷键的修改：
   
   1. Window->preferences->搜索keys->找到要修改的快捷键->解除绑定-> 绑定
6.  小技巧：视图可以随意的缩放、所有的视图都是可以随意的拖拽的、视图的恢复、显示指定的视图
7. 调试流程
   【第一步】：在代码视图的左侧双击添加一个断点
   【第二步】：右键debug as-> java application
   【第三步】：自动单击yes切换到debug视图
   【第四步】：F5进入方法体内、F6逐步、F7返回上一个断点、F8返回到下一个断点、跳到方法头、也可以直接观察表达式的值
   【第五步】：如果已经熟悉了业务逻辑那么可以清空断点和查看的变量后直接切换视图到
   java编程视图。
8. Integer 的实例化如果指定值在-128~127之间那么直接返回的是该对象已经缓存好的Integer对象，那么同值的Integr是同一个对象，如果不在那么直接new出新的对象直接返回一定不等。
   
9. 静态导入：
   导入技术其实在java中是为了方便的使用其他人写好的类。

   1	import java.lang.*|类名

   在原来的导包语句中发现只能导入类。如果需要导入的是一些静态的方法或者属性那么就无能为力。
   

   举例1：求一个任意半径的圆形的面积？

   求一个任意半径的圆形的面积

   1 2 3 4 5 6

   public static void getArea(){     double r = Math.ceil(Math.random() * 10);// 1. 求一个随机的半径     double area = 0.0; // 2. 计算面积         area = Math.PI * r * r;     System.out.println("半径是" + r + "的圆形的面积是：" + area);// 3. 打印面积 }

   发现以上的代码中大量的出现了一些静态的成员，那么可以使用静态导入的方式简化代码的书写。

   语法：

   1	import static java.lang.*|静态成员

   静态导入例子：

   1 2 3 4 5 6 7 8 9 10 11 12

   import static java.lang.Math.PI; import static java.lang.System.out; import static java.lang.Math.random; import static java.lang.Math.ceil; public class Demo4 {     public static void getArea(){    // 求一个任意半径的圆形的面积         double r  = ceil(random()*10);         double area = 0.0;         area = PI*r*r;         out.println("半径是"+r+"的圆形的面积是："+area);     } }

   
   

   如果代码中使用到了一个类的多个静态成员那么可以直接使用* 进行全部的导入。

   1	import static java.lang.Math.*;

10. 可变参数：
    
    语法：定义函数的语法

    1 2 3 4

    修饰符 返回值类型 方法名(参数类型… 变量名 ) 异常的声明{     // 函数体     return; }

    可变参数的本质

    （1）可变参数其实是一个可变的数组

    （2）可变参数在方法的声明中只能出现在参数列表的最后一个位置

    （3）可变参数只能在参数列表中出现一次

    举例1：求任意个整数的累加和？

    1 2 3 4 5 6 7

    public static long getSum(int... is){        long sum = 0;        for (int i = 0; i < is.length; i++) {           sum +=is[i];        }        return sum; }

    举例2：SUN的API中用的可变参数。

    1	static <T> List<T> asList(T... a)

    返回一个受指定数组支持的固定大小的列表。
11. 包装类
    

    包装类	基本数据类型
    Byte	byte
    Short	short
    Integer	int
    Long	long
    Boolean	boolean
    Character	char
    Float	float
    Double	double

12. 举例1：体验Integer类提供的属性。

    1 2 3 4

    public static void getField() {     System.out.println(Integer.MIN_VALUE);   // -2147483648     System.out.println(Integer.MAX_VALUE);   // 2147483647 }

    阅读以下的代码，分析代码的错误原因：

    1	long date = 12345678910;   // 报错超出long的最大值

13. 举例2：体验Integer类提供的方法。
    主要学习的是整数到字符串之间的转换的方法。 

    1 2 3 4 5 6 7 8 9

    public static void getMethod() {     // 创建类对象     Integer in1 = new Integer(123);     int i1 = in1.intValue();     System.out.println(i1+1);     // 转换为字符串     String str1 = in1.toString();     System.out.println(str1+1); }

    其实在这里没有必要转型为String的时候进行基本的toString()调用。
    简化以上的代码：

    1 2 3 4 5 6 7 8

    public static void getMethod2() {     // 创建类对象     Integer in1 = new Integer(123);     int i1 = in1;      // 自动拆箱     System.out.println(i1+1);     // 转换为字符串     System.out.println(in1+""+1); }

14. 什么是自动拆箱和自动装箱？
    自动装箱: 如果将基本类型传递给包装类型。  Integer in1 = 12;
    自动拆箱: 如果将包装类型传递给基本类型。  int i1 = in1
    在泛型的时候比较有用：
    集合：主要的用途是进行对象的存储。

    1	list.add(1);    //自动装箱

    思考：String str = “hello”;
15. 增强for循环（foreach）
    如果要遍历一个指定的数，那么我们一般要使用传统的的for循环。
    语法：

    1 2 3

    for( 条件的初始化语句; 条件表达式; 循环的增量 ){    // 循环体  break或continue }

    这样写的话每次都会遇到一个下标越界的一个异常。
    因此可以使用增强for循环进行快速的遍历(数组、集合以及实现了Iterable接口的类)。
    举例1：遍历一个普通的数组。

    1 2 3 4 5

    public static  void printArray(int [] a){    for(int temp:a){        System.out.println(temp);    } }

    举例2：遍历一个List集合。

    1 2 3 4 5

    public static void printList(List<String> list){     for (String string : list) {          System.out.println(string);     } }

    举例3：遍历一个Map集合。

    1 2 3 4 5 6 7 8 9 10 11

    public static void printMap(Map<Integer,String> map){    // 想将其转换为实现了Iterable接口的Set类    Set<Map.Entry<Integer, String>> set = map.entrySet();    // 遍历set集合    for(Map.Entry<Integer, String> entry:set){    // 获取entry对象的key和value值    Integer key = entry.getKey();    String value = entry.getValue();    System.out.println(key+"="+value+",");      } }

16. 多学一招: 使用增强for循环是否可以改变集合中数据？
    因为for循环在遍历的时候使用的是将值拷贝一份给临时变量。因此改变临时变量不会改变集合中的数据值。
17. 多学一招:使用增强for循环遍历集合的时候操作集合的问题？

    1 2 3 4 5 6 7

    public static void printList(List<String> list){      for (String string : list) {          list.add("eeee");    // 运行错误          System.out.println(string);      }      System.out.println("遍历中: "+list);  }

    异常信息如下：
    Exception in thread "main" java.util.ConcurrentModificationException  foreach循环可以读取元素，但是不可以该表元素值或者追加这样会导致索引的改变
    模拟基础班看过的场景：

    1 2 3 4 5 6 7 8 9 10 11 12 13 14

    public static void main(String[] args) {      List<String> list = new ArrayList<String>();      list.add("aaaa");      list.add("bbbb");      list.add("cccc");      list.add("dddd");        Iterator<String> it = list.iterator();      while(it.hasNext()){          list.add("yyyy");          String str = it.next();          System.out.println(str);      }  }

    运行异常：
    Exception in thread "main" java.util.ConcurrentModificationException
    总结;
    在使用增强for循环进行集合的迭代的时候其实默认使用的是迭代器，因此在循环中不能使用集合的引用变量直接操作集合，避免导致多线程并发访问的安全性异常。
     
18. 安全的枚举类
    在实际的项目的开发中我们经常需要一类数据，这一类数据的值是特定范围的一组值。如：
    性别：[男、女]
    交通灯：[红、黄、绿]
    星期几：[一~七]
    以上的一组值可以定义为枚举数据类型。
    语法：

    1 2 3

    修饰符 enum 枚举类名{    // 定义枚举的一组值，多个值之间使用逗号进行分隔 }

    实现：

    1 2 3

    修饰符 enum 枚举类名{    // 定义枚举的一组值，多个值之间使用逗号进行分隔 }

19.  枚举的本质是什么？
    （1）枚举本质是一个类
    （2）默认继承自Enum类
    （3）枚举值本质是枚举类的静态常量值
    （4）枚举值都在静态代码块中进行初始化
    （5）枚举类的默认构造函数式有参数的且只能私有
    （6）枚举是单例模式
20. 如何使用javap工具查看class文件？
    使用以下的命令查看Gender的class文件
    1. D:\>javap Gender
    2. Compiled from "Gender.java"

    1 2 3 4 5 6 7

    public final class Gender extends java.lang.Enum{     public static final Gender MALE;     public static final Gender FEMALE;     public static Gender[] values();     public static Gender valueOf(java.lang.String);     static {}; }

    -c  反编译class文件
    -l  输出行号
    -private 显示所有的成员
    既然枚举是一个普通类，那么我们开发人员就可以在类中定义类的成员(属性、构造函数、函数)。
21. 举例1：在枚举中定义属性。

    1 2 3 4 5 6 7 8 9

    public enum TrafficLight {    // 定义枚举值    RED,GREEN,YELLOW;      // 定义成员属性    public String info = "交通灯信息";    public static void main(String[] args) {        System.out.println(TrafficLight.GREEN.info);    } }

22. 举例2:：在枚举中定义构造函数。

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

    public enum TrafficLight {    // 定义枚举值    RED("红灯"),GREEN("绿灯"),YELLOW("黄灯");      // 定义成员属性    public String info = "交通灯信息";    // 提供构造函数进行属性的初始化    private TrafficLight(String info){        this.info = info;    }    public static void main(String[] args) {        System.out.println(TrafficLight.GREEN.info);        System.out.println(TrafficLight.RED.info);        System.out.println(TrafficLight.YELLOW.info);    } }

    切记的是为了保证枚举是单例的那么构造函数全部要私有。
23. 举例3：在枚举中定义函数。【每一个枚举对象就相当一个类，所以可以直接构造函数实现，该枚举类中定义的抽象方法或者实现接口】【内部匿名类】

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

    public enum TrafficLight {     // 定义枚举值     RED("红灯") {         @Override         public void showMessage() {              System.out.println("红灯停!");         }     },     GREEN("绿灯") {         @Override         public void showMessage() {              System.out.println("绿灯行!");         }     },     YELLOW("黄灯") {         @Override         public void showMessage() {     内部枚举每一项都是一个类，所以可以内部匿名类实现抽象方法             System.out.println("你自己看着办!");         }     };     // 定义成员属性     public String info = "交通灯信息";     // 提供构造函数进行属性的初始化     private TrafficLight(String info) {         this.info = info;     }     // 提供一个表明灯的信息的方法     public abstract void showMessage();  定义抽象方法 }

    以上的代码可见在枚举类中可以定义抽象方法，但是不能将枚举类声明为抽象类，只能在声明枚举值的时候实现所有的抽象方法即(匿名内部类)。
    在实际的枚举中其实自定义的枚举类默认继承Enum类，那么我们的枚举类中就会有Enum类中的定义好的属性和方法。
24. 枚举常用的方法以及描述
    

    常用方法	方法的描述
    String name()	获取枚举值的名称
    int ordinal()	返回枚举值定义的序号
    valueOf(Class<T> enumType, String name)	通过反射查找指定的类中的指定名的枚举值
    values()	该方法在API中不可见但是可用

25.   面试题：简单叙述以下以下三个关键字有什么区别？
    Enum         --> 枚举类默认继承的类
    Enumeration      --> 早期的迭代器类型，主要用于Vector和顺序流
    enum          --> 定义一个类为枚举时候的关键字
26. 问题：如果不使用泛型，那么请看下面的代码发生的转型异常？

    1 2 3 4 5 6

    public static void printList(List list){     for(Object temp:list){         String str = (String) temp;         System.out.println(temp);     } }

    1 2 3 4 5 6 7

    public static void main(String[] args) {        List  list = new ArrayList();        list.add("aaa");        list.add(123);        list.add("bbb");        printList(list);    }

    因此我们在实际的开发环境中需要进行泛型的使用。通过使用泛型我们可以约束在集合中存储的对象的类型。
    泛型其实就是给容器上贴一个标签而已，指定容器存放的数据类型。
    泛型的有点其实就是将运行时候的异常前置在编译时解决。
    
    
    

javaEE学习笔记【01】集成环境开发应用、JDK新特性

标签：

原文地址：http://www.cnblogs.com/lindongdong/p/4861866.html