黑马程序员---基础加强（Eclipse编译与运行环境、jdk1.5的新特性）

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

 

 

工具：

Eclipse和MyEclipse的区别：

实际上MyEclipse是Eclipse的一个插件，先安装Eclipse再安装上MyEclipse这个插件就能开发javaEE的程序了，javaEE就是Java web程序。

但是后来MyEclipse公司说这样安装起来用户挺麻烦的，能不能把MyEclipse和Eclipse集成到一块呢？让开发者只安装一个MyEclipse就能开发了。

所以后来MyEclipse就是Eclipse和MyEclipse的集成开发软件了。

 

名词解释：

Java EE：（Java Platform，Enterprise Edition） 企业版

IDE：（Integrated Development Environment ） 集成开发环境

JMS：（Java Message Service） Java消息服务

JMX：（Java Management Extensions） Java管理扩展

JNDI：（Java Naming and Directory Interface）Java平台命名与目录的接口

 

 

 

Eclipse编译与运行环境：

低的编译器编译的Java程序，在高的运行环境下可以运行。（例如：在windows98下开发的应用程序，在windowsXP系统下可以运行。）

高的编译器编译的Java程序，在低的运行环境下不能运行。（例如：在windowsXP系统下开发的应用程序，在windows98下不能运行。）

 

jdk1.5的新特性：

1.静态导入

 

2.可变参数

overload（重载）   VS   override（覆盖）的区别：

1.覆盖是在有继承关系的字符类中，重载（同一个类中或者字符类中）都可以。

2.覆盖是权限要大于等于被覆盖，返回值函数名参数全部相同的情况下。

3.重载和权限和返回值都无关（权限和返回值可以不同），当然子类不能去重载父类中的私有函数，因为不会继承过来就不存在重载。

4.重载和参数有关，参数的个数、类型、顺序都有关。

package cn.itcast.day1;

public class VariableParameter {

	public static void main(String[] args) {
		System.out.println(add(2,3));
		System.out.println(add(2,3,4));
		System.out.println(add(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;
	}
}

 

3.增强for循环

package cn.itcast.day1;

public class VariableParameter {

	public static void main(String[] args) {
		System.out.println(add(2,3));
		System.out.println(add(2,3,4));
		System.out.println(add(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];
		}*/
		for (int arg : args) {
			sum+=arg;
		}
		return sum;
	}
}

 

4.基本数据类型的自动装箱与拆箱

package cn.itcast.day1;

public class AutoBox {

	public static void main(String[] args) {
		Integer iObj = 3;
		System.out.println(iObj+12);//15
		
		String s1 = new String("abc");
		String s2 = new String("abc");
		System.out.println(s1==s2);//false
		
		String s3 = "abc";
		String s4 = "abc";
		System.out.println(s3==s4);//true
		
		Integer i1 = new Integer(13);
		Integer i2 = new Integer(13);
		System.out.println(i1==i2);//false
		
		Integer i3 = 13;
		Integer i4 = 13;
		System.out.println(i3==i4);//true,-128~127,享元模式
		Integer i5 = 137;
		Integer i6 = 137;
		System.out.println(i5==i6);//false
		
		Integer i7 = Integer.valueOf(3);
		Integer i8 = Integer.valueOf(3);
		System.out.println(i7==i8);//true		
	}
	
}

 

Flyweight:

设计模式中的 享元模式，避免大量拥有相同内容的小类的开销(如耗费内存),使大家共享一个类(元类)。

有很多个小的对象，它们有很多属性相同，把它们变成一个对象。那些不同的属性把它们变成方法的参数，称之为外部状态。那些相同的属性称之为内部状态。

 

5.枚举

 

用普通的Java类来实现枚举：

package cn.itcast.day1;

public class EnumTest {

	public static void main(String[] args) {
		//我要定义个新的类型，我让这个新类型定义的变量只有固定的那么几个值，该怎么做？
		WeekDay weekDay = WeekDay.SUN;
		System.out.println(weekDay.nextDay());//自动调用了WeekDay的toString()方法。
	}

}

public class WeekDay {
	
	//这个类创建出来的实例对象只能是我规定的那么几个
	//首先把构造方法创建成私有的，让其他人不能随便创建对象。
	private WeekDay() {}
	
	//假设只允许有5个对象，那么这5个对象都由我自己来创建。
	public static final WeekDay SUN = new WeekDay();
	public static final WeekDay SAT = new WeekDay();
	public static final WeekDay FRI = new WeekDay();
	public static final WeekDay THU = new WeekDay();
	public static final WeekDay WED = new WeekDay();
	public static final WeekDay TUE = new WeekDay();
	public static final WeekDay MON = new WeekDay();
	
	public WeekDay nextDay() {
		if(this == SUN) {
			return MON;
		}else if(this == SAT) {
			return SUN;
		}else if(this == FRI) {
			return SAT;
		}else if(this == THU) {
			return FRI;
		}else if(this == WED) {
			return THU;
		}else if(this == TUE) {
			return WED;
		}else 
			return TUE;		
	}
	
	public String toString() {
		if(this == SUN) {
			return "SUNDAY";
		}else if(this == SAT) {
			return "SATURDAY";
		}else if(this == FRI) {
			return "FRIDAY";
		}else if(this == THU) {
			return "THURSDAY";
		}else if(this == WED) {
			return "WEDNESDAY";
		}else if(this == TUE) {
			return "TUESDAY";
		}else 
			return "MONDAY";
	}

}

另一种写法：

package cn.itcast.day1;

public class EnumTest {

	public static void main(String[] args) {
		//我要定义个新的类型，我让这个新类型定义的变量只有固定的那么几个值，该怎么做？
		WeekDay weekDay = WeekDay.SAT;
		System.out.println(weekDay.nextDay());//自动调用了WeekDay的toString()方法。
	}

}

public abstract class WeekDay {
	
	//这个类创建出来的实例对象只能是我规定的那么几个
	//首先把构造方法创建成私有的，让其他人不能随便创建对象。
	private WeekDay() {}
	
	//假设只允许有5个对象，那么这5个对象都由我自己来创建。
	public static final WeekDay SUN = new WeekDay() {
		public WeekDay nextDay() {
			return MON;
		}
	};
	public static final WeekDay SAT = new WeekDay() {
		public WeekDay nextDay() {
			return SUN;
		}
	};
	public static final WeekDay FRI = new WeekDay() {
		public WeekDay nextDay() {
			return SAT;
		}
	};
	public static final WeekDay THU = new WeekDay() {
		public WeekDay nextDay() {
			return FRI;
		}
	};
	public static final WeekDay WED = new WeekDay() {
		public WeekDay nextDay() {
			return THU;
		}
	};
	public static final WeekDay TUE = new WeekDay() {
		public WeekDay nextDay() {
			return WED;
		}
	};
	public static final WeekDay MON = new WeekDay() {
		public WeekDay nextDay() {
			return TUE;
		}
	};
	
	public abstract WeekDay nextDay();
	
	/*public WeekDay nextDay() {
		if(this == SUN) {
			return MON;
		}else if(this == SAT) {
			return SUN;
		}else if(this == FRI) {
			return SAT;
		}else if(this == THU) {
			return FRI;
		}else if(this == WED) {
			return THU;
		}else if(this == TUE) {
			return WED;
		}else 
			return TUE;		
	}*/
	
	public String toString() {
		if(this == SUN) {
			return "SUNDAY";
		}else if(this == SAT) {
			return "SATURDAY";
		}else if(this == FRI) {
			return "FRIDAY";
		}else if(this == THU) {
			return "THURSDAY";
		}else if(this == WED) {
			return "WEDNESDAY";
		}else if(this == TUE) {
			return "TUESDAY";
		}else 
			return "MONDAY";
	}

}

我们来写一个基本的枚举类：

把前面的WeekDay类改成了WeekDay1

此代码中WeekDay是我们新定义的枚举类。

package cn.itcast.day1;

public class EnumTest {
	public static void main(String[] args) {
		//我要定义个新的类型，我让这个新类型定义的变量只有固定的那么几个值，该怎么做？
		WeekDay1 weekDay = WeekDay1.SAT;
		System.out.println(weekDay.nextDay());//自动调用了WeekDay的toString()方法。
		
		WeekDay weekDay2 = WeekDay.MON;
		System.out.println(weekDay2);//自动产生了toString()方法。
		System.out.println(weekDay2.name());
		System.out.println(weekDay2.ordinal());
		System.out.println(weekDay2.getClass());
		System.out.println(WeekDay.valueOf("SUN").toString());//这个类的静态方法，已知字符串，获得相应的枚举对象。
		System.out.println(WeekDay.values().length);
		for (WeekDay weekDay3 : WeekDay.values()) {
			System.out.println(weekDay3.toString());
		}		
	}
	public enum WeekDay {
		SUN,MON,TUE,WED,THU,FRI,SAT;
	}
}

 

实现带有构造方法的枚举：

package cn.itcast.day1;

public class EnumTest {
	public static void main(String[] args) {
		//我要定义个新的类型，我让这个新类型定义的变量只有固定的那么几个值，该怎么做？
		WeekDay1 weekDay = WeekDay1.SAT;
		System.out.println(weekDay.nextDay());//自动调用了WeekDay的toString()方法。
		
		WeekDay weekDay2 = WeekDay.MON;
		System.out.println(weekDay2);//自动产生了toString()方法。
		System.out.println(weekDay2.name());
		System.out.println(weekDay2.ordinal());
		System.out.println(weekDay2.getClass());
		System.out.println(WeekDay.valueOf("SUN").toString());//这个类的静态方法，已知字符串，获得相应的枚举对象。
		System.out.println(WeekDay.values().length);
		for (WeekDay weekDay3 : WeekDay.values()) {
			System.out.println(weekDay3.toString());
		}		
	}
	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");}		
	}
}

 

实现带有抽象方法的枚举：

内部类可以加四个访问修饰符（modifier），而外部类只有两个（一个是public，一个是默认）

因为内部类与成员方法是平级的，那么成员方法有什么玩意，它就有什么玩意。

我们来写一个交通灯的枚举类，交通灯只有三种颜色：

package cn.itcast.day1;

public class EnumTest {
	public static void main(String[] args) {
		//我要定义个新的类型，我让这个新类型定义的变量只有固定的那么几个值，该怎么做？
		WeekDay1 weekDay = WeekDay1.SAT;
		System.out.println(weekDay.nextDay());//自动调用了WeekDay的toString()方法。
		
		WeekDay weekDay2 = WeekDay.MON;
		System.out.println(weekDay2);//自动产生了toString()方法。
		System.out.println(weekDay2.name());
		System.out.println(weekDay2.ordinal());
		System.out.println(weekDay2.getClass());
		System.out.println(WeekDay.valueOf("SUN").toString());//这个类的静态方法，已知字符串，获得相应的枚举对象。
		System.out.println(WeekDay.values().length);
		for (WeekDay weekDay3 : WeekDay.values()) {
			System.out.println(weekDay3.toString());
		}		
	}
	
	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");}		
	}
	
	public enum TrafficLamp {
		RED {
			public TrafficLamp nextLamp() {
				return GREEN;
			}
		},
		GREEN {
			public TrafficLamp nextLamp() {
				return YELLOW;
			}
		},
		YELLOW {
			public TrafficLamp nextLamp() {
				return RED;
			}
		};
		public abstract TrafficLamp nextLamp();		
	}
}

保存之后我们点open in explorer按钮：打开此类所在文件夹

我们在EnumTest里面写了一个交通灯TrafficLamp，而这个类是抽象类，它的三个对象都是由它的子类（匿名内部类）来实现的。我们看到每一个匿名内部类都是一个类。

现在我们还希望交通灯有时间，红绿黄的时间长短是不一样的：

package cn.itcast.day1;

public class EnumTest {
	public static void main(String[] args) {
		//我要定义个新的类型，我让这个新类型定义的变量只有固定的那么几个值，该怎么做？
		WeekDay1 weekDay = WeekDay1.SAT;
		System.out.println(weekDay.nextDay());//自动调用了WeekDay的toString()方法。
		
		WeekDay weekDay2 = WeekDay.MON;
		System.out.println(weekDay2);//自动产生了toString()方法。
		System.out.println(weekDay2.name());
		System.out.println(weekDay2.ordinal());
		System.out.println(weekDay2.getClass());
		System.out.println(WeekDay.valueOf("SUN").toString());//这个类的静态方法，已知字符串，获得相应的枚举对象。
		System.out.println(WeekDay.values().length);
		for (WeekDay weekDay3 : WeekDay.values()) {
			System.out.println(weekDay3.toString());
		}		
	}
	
	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");}		
	}
	
	public enum TrafficLamp {
		//new子类的对象，并且调用父类的有参的构造方法。
		RED(30) {
			public TrafficLamp nextLamp() {
				return GREEN;
			}
		},
		GREEN(39) {
			public TrafficLamp nextLamp() {
				return YELLOW;
			}
		},
		YELLOW(5) {
			public TrafficLamp nextLamp() {
				return RED;
			}
		};
		public abstract TrafficLamp nextLamp();	
		private int time;
		private TrafficLamp(int time) {this.time = time;}
	}
}

 

在学习枚举的过程中复习了内部类，提高了编程思想。

类的方法返回的类型可以是自己这个类型。

类里面可以定义静态常量，常量指向的结果就是自己这个类型的实例对象。

如果我们想设计单例设计模式，我们可以用枚举：元素列表中只有一个元素，并且不用你去写构造函数，自带的（没有参数的），new一个instance也不用自己写了，元素自然的就new出来了。

 

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

详细请查看：http://edu.csdn.net