一、Eclipse的讲解
1、用人单位判断你的能力如何,也是看你的这些基础知识的深度，看你的学习新知识的能力（课程开始，张老师的说教，鄙人认为比较有水平）
Eclipse是什么开发的呢?用Java,我怎么感觉Java做不出，这么漂亮的工具来,呵呵
Eclipse是一种IDE，IDE:整合发展环境（Integrated Development Environment），JMS:Java消息服务（Java Message Service）,Java EE：Java平台企业版本（Java Platform，Enterprise Edition），JMX：即Java管理扩展（Java Management Extensions）
2、Eclipse的使用技巧MyEclipse是Eclipse的增强版
配置Eclipse的快捷键：
在不同的情况下有不同的透视图（perspective），view就是小窗口
3、Eclipse的编译和配置
高版本的java能否运行低版本的javac编译的程序？可以、低版本的java能否运行高版本的javac编译的程序？不可以
举例子：Microsoft Office2007能够打开Microsoft Office2003文档（doc格式）；
但是Microsoft Office2003打不开MicrosoftOffice2007文档（docx格式）（除非装个插件！）
4、模板代码（就是像这种syso这样的快捷输出System.out.println()）
那这时候就有了，那有了呢？
二、JDK1.5的新特性
1、JDK1.5的新特性_静态导入
注意点：import static java.lang.Math.*;在下面要调用Math里面的方法的时候，直接写方法名字，max(3, 8)
例子：StaticImport.java
1 package com.shanhw.javaEnhance.ninthDay; 2 3 import static java.lang.Math.*; 4 5 public class StaticImport { 6 7 /** 8 * 静态导入 9 */ 10 public static void main(String[] args) { 11 System.out.println(max(3, 8)); 12 System.out.println(min(3,6)); 13 } 14 }
2、JDK1.5的新特性_可变参数
·问题：一个方法接收的参数个数不固定，例如：
System.out.println(add(2,5));
System.out.println(add(2,5,3));
·可变参数的特点：
1、只能出现在参数列表的最后
2、... 位于变量类型和变量名之间，前后有无空格都可以
3、调用可变参数的方法的时候时，编译器为该可变参数隐含创建一个数组，在方法中以数组的形式访问可变参数
例子：TestVariableParameter.java
1 package com.shanhw.javaEnhance.ninthDay; 2 3 public class TestVariableParameter { 4 /** 5 * 2、可变参数 6 */ 7 public static void main(String[] args) { 8 System.out.println(add(2,3)); 9 System.out.println(add(2,3,5)); 10 } 11 public static int add(int x,int ... args){ 12 int sum = x; 13 for(int i=0;i<args.length;i++){ 14 sum +=args[i]; 15 } 16 return sum; 17 } 18 }
3、JDK1.5的新特性_For增强
·注意事项：1、迭代变量必须在()中定义 2、集合变量可以是数组或实现了Iterator接口的集合类
例子：TestForEnhanced.java
1 package com.shanhw.javaEnhance.ninthDay; 2 3 public class TestForEnhanced { 4 5 /** 6 * For循环增强 7 */ 8 public static void main(String[] args) { 9 System.out.println(add(2,3)); 10 } 11 public static int add(int x,int ... args){ 12 int sum = x; 13 for(int a : args){ 14 sum += a; 15 } 16 return sum; 17 } 18 19 }
4、JDK1.5的新特性_基本数据类型的自动装箱与拆箱
· 自动装箱:Integer num = 1;
· 自动拆箱:System.out.println(num + 1);
· 基本数据类型的对象缓存：
Integer num1 = 12; Integer num2 = 12; System.out.println(num1 == num2);
Integer num3 = 129; Integer num4 = 129; System.out.println(num3 == num4);
Integer num5 = Integer.valueOf(12); Integer num6 = Integer.valueOf(12); System.out.println(num5 == num6);
注意点： Integer i1 = 13; Integer i2 = 13;System.out.println(i1 == i2); // TRUE 而 Integer i3 = 137; Integer i4 = 137; System.out.println(i3 == i4);// FALSE 那为什么呢？正解：如果装箱在[-128~127]之间的这些数字，一旦我把它包装成为一个Integer对象之后，就把它缓存起来，缓存在一个池里面，如果下一次又要把另外包装成为一个Integer对象，先看缓存池里面有没有，这样就节省了内存空间，这是一种设计设计模式。享元模式（Flyweight），如果很小的对象，有很多属性相同，就可以编辑成一个对象，那些不同的属性，变成方法的参数称之为外部状态，那些相同的属性称之为这个对象的内部状态
例子：TestAutoBox.java
1 package com.shanhw.javaEnhance.ninthDay; 2 3 public class TestAutoBox { 4 5 /** 6 * 自动拆箱与装箱 7 */ 8 public static void main(String[] args) { 9 Integer iObj = 1;// 自动装箱 10 System.out.println(iObj + 3); // 自动拆箱 11 // 如果装箱在-128~127之间的这些数字，一旦我把它包装成为一个Integer对象之后， 12 // 就把它缓存起来，缓存在一个池里面，如果下一次又要把另外包装成为一个Integer 13 // 对象，先看缓存池里面有没有，这样就节省了内存空间 14 // 设置模式：享元模式（Flyweight），如果很小的对象，有很多属性相同， 15 // 就可以编辑成一个对象，那些不同的属性，变成方法的参数称之为外部状态， 16 // 那些相同的属性称之为这个对象的内部状态 17 Integer i1 = 13; 18 Integer i2 = 13; 19 System.out.println(i1 == i2); // TRUE 20 // 以为大的整数是的频率比较低 创建两个对象 21 Integer i3 = 137; 22 Integer i4 = 137; 23 System.out.println(i3 == i4); // FALSE 24 Integer i5 = Integer.valueOf(13); 25 Integer i6 = Integer.valueOf(13); 26 System.out.println(i5 == i6); // TRUE 27 Integer i7 = Integer.valueOf(213); 28 Integer i8 = Integer.valueOf(213); 29 System.out.println(i7 == i8); // FALSE 30 } 31 }
5、JDK1.5的新特性_枚举
·为什么要用枚举？问题：要定义星期几或者性别的变量，该怎么定义？假设用1-7表示星期一到星期日，但是有人可能写成，int weekDay = 0;
枚举就是让某个类型的变量的取值只能为若干个值中的一个，否则编译器就会报错。枚举可以让编译器在编译的时候就能控制源程序的非法值；
·普通类来模仿枚举类：
注意点：采用抽象方法定义nextDay，就将大量的if和else语句转换成了一个个独立的类，匿名内部类：匿名内部类 必须用WeekDay的子类去new对象，写上一对打括号表示用这个类的子类来创建实例对象,这个子类没有名字，所以称之为匿名内部类，这个子类的具体代 码：大括号和里面的代码
例子：TestEnum.java
1 package com.shanhw.javaEnhance.ninthDay; 2 3 public class TestEnum { 4 5 /** 6 * 普通类模拟枚举类 7 */ 8 public static void main(String[] args) { 9 // 每一个枚举都是对象 10 WeekDay mon = WeekDay.MON; 11 System.out.println(mon); 12 } 13 } 14 15 abstract class WeekDay { 16 private WeekDay(){} 17 18 // 匿名内部类 必须用WeekDay的子类去new对象，写上一对打括号 19 // 表示用这个类的子类来创建实例对象,这个子类没有名字，所以 20 // 称之为匿名内部类，这个类的具体代码：大括号和里面的代码 21 public static final WeekDay SUN = new WeekDay(){ 22 23 public WeekDay nextDay() { 24 return MON; 25 } 26 27 }; 28 public static final WeekDay MON = new WeekDay(){ 29 30 public WeekDay nextDay() { 31 return SUN; 32 } 33 34 }; 35 // 采用抽象方法定义nextDay，就将大量的if和else语句转换成了一个个独立的类 36 public abstract WeekDay nextDay(); 37 38 /*public WeekDay nextDay(){ 39 if(this == SUN){ 40 return MON; 41 }else{ 42 return SUN; 43 } 44 }*/ 45 46 // 打印枚举对象 47 public String toString(){ 48 return this==SUN?"SUNDAY":"MONDAY"; 49 } 50 }
·基本的枚举类的应用
注意点：只要用到了、枚举类，里面所有的静态变量都会被初始化
例子：TestEnum.java
1 package com.shanhw.javaEnhance.ninthDay; 2 3 public class TestEnum { 4 5 /** 6 * 普通枚举 7 */ 8 public static void main(String[] args) { 9 WeekEnum weekDay = WeekEnum.FRI; 10 System.out.println(weekDay); 11 System.out.println(weekDay.name()); 12 System.out.println(weekDay.ordinal()); 13 // 把字符串FRI变成WeekEnum里面的一个对象 14 System.out.println(WeekEnum.valueOf("FRI")); 15 // 把WeekEnum转换成数组 16 System.out.println(WeekEnum.values().length); 17 } 18 public enum WeekEnum{ 19 SUN,MON,TUE,WED,THI,FRI,SAT; 20 } 21 }
·带有构造方法的枚举
例子：TestEnum.java
1 package com.shanhw.javaEnhance.ninthDay; 2 3 public class TestEnum { 4 5 /** 6 * 带构造方法的枚举，而且构造方法里面有参数 7 */ 8 public static void main(String[] args) { 9 WeekEnum weekDay = WeekEnum.FRI; 10 System.out.println(weekDay); 11 System.out.println(weekDay.name()); 12 System.out.println(weekDay.ordinal()); 13 // 把字符串FRI变成WeekEnum里面的一个对象 14 System.out.println(WeekEnum.valueOf("FRI")); 15 // 把WeekEnum转换成数组 16 System.out.println(WeekEnum.values().length); 17 18 } 19 } 20 enum WeekEnum{ 21 SUN(1),MON(),TUE,WED,THI,FRI,SAT; 22 private WeekEnum(){ 23 System.out.println("First"); 24 }; 25 private WeekEnum(int day){ 26 System.out.println("Second"); 27 }; 28 }
·实现带有抽象方法的枚举（最复杂的例子了）
注意：枚举只有一个成员时，就可以作为一种单例的实现方式
1 package com.shanhw.javaEnhance.ninthDay; 2 3 public class TestEnumTrafficLamp { 4 5 /** 6 * 实现带有抽象方法的枚举（最复杂的枚举了） 7 */ 8 public static void main(String[] args) { 9 TrafficLamp lampR = TrafficLamp.RED; 10 TrafficLamp lampG = TrafficLamp.GREEN; 11 TrafficLamp lampY = TrafficLamp.YELLOW; 12 System.out.println(lampR.nextLamp()); 13 System.out.println(lampG.nextLamp()); 14 System.out.println(lampY.nextLamp()); 15 } 16 } 17 enum TrafficLamp{ 18 19 RED(30){ 20 21 public TrafficLamp nextLamp() { 22 return GREEN; 23 } 24 }, 25 GREEN(45){ 26 27 public TrafficLamp nextLamp() { 28 return YELLOW; 29 } 30 }, 31 YELLOW(5){ 32 33 public TrafficLamp nextLamp() { 34 return RED; 35 } 36 }; 37 private int time; 38 private TrafficLamp(int time ){ 39 this.time = time; 40 } 41 public abstract TrafficLamp nextLamp(); 42 }
6、JDK1.5的新特性_注解
在http://www.cnblogs.com/shanhouwang/archive/2013/03/20/2972282.html有讲解
7、JDK1.5的新特性_体验泛型
·JDK1.5以前集合类中存在什么问题？ArrayList collection = new ArrayList();collection.add(1);collection.add(1L);collection.add("abc");int i = (Integer)arrayList.get(1);// 编译器要强制转换类型，而且运行时出错
·JDK1.5的集合类希望你在定义集合时，明确表示你要向集合类中装什么类型的数据，无法加入，指定类型之外的数据:ArrayList<Integer> arrayList = new ArrayList<Integer>();arrayList.add(1);arrayList.add(1L);//此时会报错 int i = arrayList.get(0);// 不需要类型转换
·泛型是提供给javac编译器使用的,可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明集合时会去掉"类型"的信息，使程序效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一致，由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射的到集合，在调用其add方法即可。
入门例子：GenericityTest.java
注意：没有使用泛型时，只是对象，不管是什么类型的对象，都可以存储到同一个集合中，使用泛型集合，可以将一个集合中的数据类型限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全，并且当从集合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，这样更方便
1 package com.shanhw.javaEnhance.twelfthDay; 2 3 import java.util.ArrayList; 4 5 public class GenericityTest { 6 7 /** 8 * 泛型的入门 9 */ 10 public static void main(String[] args) { 11 ArrayList arrayList1 = new ArrayList(); 12 arrayList1.add(1); 13 arrayList1.add(1L); 14 arrayList1.add("abc"); 15 16 int i1 = (Integer) arrayList1.get(1);// Exception in thread "main" 17 // java.lang.ClassCastException: 18 // java.lang.Long cannot be cast 19 // to java.lang.Integer 20 // at 21 // com.shanhw.javaEnhance.twelfthDay.GenericityTest.main(GenericityTest.java:16) 22 23 ArrayList<String> arrayList2 = new ArrayList<String>(); 24 // arrayList2.add(1); 25 // arrayList2.add(1L); 26 arrayList2.add("abc"); 27 String i2 = arrayList2.get(0); 28 } 29 30 }
利用反射跳过编译器：往有泛型类型的ArrayList中加入不同类型的数据，并打印
1 package com.shanhw.javaEnhance.twelfthDay; 2 3 import java.util.ArrayList; 4 5 public class GenericityTest { 6 7 8 /** 9 * 泛型的入门 10 */ 11 @SuppressWarnings("unchecked") 12 public static void main(String[] args) throws Exception{ 13 14 // 1、反射方式跳过泛型的类型 15 ArrayList<String> arrayList2 = new ArrayList<String>(); 16 ArrayList arrayListRef = arrayList2.getClass().newInstance(); 17 arrayListRef.add("a"); 18 arrayListRef.add(1); 19 System.out.println(arrayListRef.get(0)); 20 21 // 2、反射方式跳过泛型的类型 22 ArrayList<Integer> arrayListRef2 = new ArrayList<Integer>(); 23 arrayList2.getClass().getMethod("add", Object.class).invoke(arrayListRef2, "abc"); 24 System.out.println(arrayListRef2.get(0)); 25 } 26 27 }
扫一扫
9691
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
