黑马程序员--高新技术<一>eclipse开发工具及相关知识加强

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

第一节 eclipse开发工具简述

一、概述：

1、eclipse是运行在java基础上的工具。

2、常用术语缩写：

1）IDE：Itegrity Development Enviroment，集成开发环境

2）JavaEE：javaEnterprise Edition：java企业版开发工具。

3）JMS：Java MessageService，Java消息服务，是一个Java平台中关于面向消息中间件的API，用于在两个应用程序间，或分布式系统中，发送消息，进行异步通信。

4）JMX：Java ManagementExtensions，Java管理扩展；是一个为应用程序、设备、系统植入管理功能的框架。

5）JNDI：Java Nameingand Directory Interface：Java命名和目录接口。

6）JDBC：Java DataBase Connectivity：Java数据库连接。

3、Myeclipse和eclipse的区别：

1）Myeclipse：是elipse的插件，用于开发javaEE的平台，为其打补丁，扩展其功能，可以开发JavaEE程序即web项目，但是现在Myeclipse也集成了eclipse的功能，可直接使用Myeclipse。

2）eclipse：是开发java的一款专业的IDE（集成开发环境），以前需要Myeclipse才能开发JavaEE程序，现在的eclipse的版本也可以不用再安装Myeclipse插件，直接可以开发JavaEE项目。

二、eclipse开发工具介绍：

1、project（工程）：

1）一个工程包含有：包，jar包，资源文件，java源文件等内容。

2）将一个工程的所有源文件用一个工程来组织，开发工具能对所有源文件集中管理，记住每个源文件的位置和相互关系，配置信息等都在工程中有记录。

2、preferences（首选项）：

在workspace（工作间）中配置，将会影响到它下面所有的工程，一个工作间包含多个工程，不同透视图就是几个小窗口的集合。

3、在eclipse下如何查看变量值：

在变量处打个断点--->Debug透视图，调试运行--->选中变量，右键选watch（观察），就可以看到了。

4、perspective（透视图）和view（视图）的关系：

view：每一个小窗口就是一个视图。可通过window下的show view调出相应的视图。

perspective：透视图就是若干个小窗口的集合。

5、导入已有工程：

1）将其他工作间中的工程拷贝到当前工作间所在的文件夹下。

2）在eclipse中右击工程--->导入--->浏览选择当前工作间目录下拷贝过来的工程。

6、配置JDK环境：

右击工程--->BuildPath --->Libraries（库）--->移除导入的工程的JDK库，增加自己的库。

注：

Add JARs是增加打个Jar包，

如果Jar包不在当前工程文件夹中，用Add Exernd JARs

如果Jar包在当前工程文件夹中，用Add JARs

增加一个库相当于增加很多Jar，这是一个打包的过程。

 

第二节 JDK1.5新特性

一、静态导入 importstatic简述：

1、import语句：是导入一个类或某个包中的所有类。

2、import static语句：导入一个类中的某个静态方法或所有静态方法。

//import static java.lang.System.out;//引入静态成员
import static java.lang.System.currentTimeMillis;
import static java.lang.System.out;
import static java.util.Arrays.asList;

import java.util.List;
public class Demo1 {

	public static void main(String[] args) {
		out.print("aa");
		out.println();
		out.println();
		long time = currentTimeMillis();
		System.out.println(time);
		
		String s[] = {"a","b","c"};
		List list = asList(s);
		System.out.println(list);
	}	

}

二、增强for循环：

1、语法：for(type 变量名 : 集合变量名){statement}

2、注意：迭代变量必须定义在()中，集合变量可以使参数或实现Iterable接口的集合类，变量类型前可加修饰符，如final（可被局部内部类访问到）。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.Test;
//增强for循环
public class Demo3 {
	//数组
	@Test    //ctrl+1
	public void test1(){
		String s[] = {"a","b","c"};
		for(int i=0;i<s.length;i++){
			System.out.println(s[i]);
		}
		
		for(String ss:s){
			System.out.println(ss);
		}
		
	}
	@Test
	//List
	public void test2(){
		List l = new ArrayList();
		l.add("aa");
		l.add("bb");
		l.add("cc");
		
		Iterator it = l.iterator();
		while(it.hasNext()){
			String s = (String)it.next();
			System.out.println(s);
		}
		
		
		for(Object obj:l){
//			String s = (String)obj;
//			System.out.println(s);
			System.out.println(obj);
		}
	}
	//传统方式遍历Map
	@Test
	public void test3(){
		Map map = new LinkedHashMap();
		map.put("a", "aaa");
		map.put("b", "bbb");
		map.put("c", "ccc");
		
		Set keys = map.keySet();
		Iterator it = keys.iterator();
		while(it.hasNext()){
			String key = (String)it.next();
			String value = (String) map.get(key);
			System.out.println(key+"="+value);
		}
	}
	
	@Test//增强for遍历map方式一
	public void test31(){
		Map map = new LinkedHashMap();
		map.put("a", "aaa");
		map.put("b", "bbb");
		map.put("c", "ccc");
		
		Set keys = map.keySet();
		for(Object obj:keys){
			String key = (String)obj;
			String value = (String) map.get(key);
			System.out.println(key+"="+value);
		}
		
	}
	//传统方式遍历Map
	@Test
	public void test4(){
		Map map = new LinkedHashMap();
		map.put("a", "aaa");
		map.put("b", "bbb");
		map.put("c", "ccc");
		
		Set me = map.entrySet();
		Iterator it = me.iterator();
		while(it.hasNext()){
			Map.Entry m = (Map.Entry)it.next();
			String key = (String) m.getKey();
			String value = (String)m.getValue();
			System.out.println(key+"="+value);
		}
		
	}
	@Test//增强for循环遍历map方式二
	public void test41(){
		Map map = new LinkedHashMap();
		map.put("a", "aaa");
		map.put("b", "bbb");
		map.put("c", "ccc");
		
		for(Object obj:map.entrySet()){
			Map.Entry me = (Map.Entry )obj;
			String key = (String) me.getKey();
			String value = (String)me.getValue();
			System.out.println(key+"="+value);
		}
		
	}
	@Test//增强for的一些细节
	public void test5(){
		int arr[] = {1,1,1};
		for(int i:arr){
			i = 10;
		}
		//循环时改元素的值必须使用传统方式
//		for(int i=0;i<arr.length;i++){
//			arr[i] = 100;
//		}
		System.out.println(arr[0]);
	}
	@Test
	public void test6(){
		List list = new ArrayList();
		list.add("p");
		for(Object obj:list){
			obj = "ppp";
		}
		System.out.println(list.get(0));
	}

三、可变参数：（方法的重载）

特点：

1、只能出现在参数列表的最后。

2、用…这三个点表示参数可以有很多，且这三个点位于变量类型和变量名之间，前后有无空格皆可。

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

示例：

import org.junit.Test;

//可变参数
public class Demo4 {
	//计算任意数量的整数的和
	public int sum(int ...args){//可变参数就当做数组来用
		int sum = 0;
		for(int i:args){
			sum+=i;
		}
		return sum;
	}
	@Test//如何使用带有可变参数的方法
	public void test1(){
		int result = sum(1,2,3,4);
		System.out.println(result);
	}
	@Test
	public void test2(){
		int values[] = {1,2,3,4,5};
		int result = sum(values);
		System.out.println(result);
	}
	public String aa(String s2,String...s1){
		return null;
	}
}

四、基本数据类型的自动拆箱与装箱：

1、自动装箱：Integer iObj = 3;

2、自动拆箱：iObj + 2;

3、对于基本数据类型的说明：整数在-128 ~ 127之间的数，包装成Integer类型对象，会存入常量池中的缓存，再创建同一个对象的时候，会直接使用前一个已有的值，因为这些小数值使用的频率很高，所以这些数值需要如此的使用以优化内存。

import java.util.ArrayList;
import java.util.List;

public class Demo2 {

	public static void main(String[] args) {
		List list = new ArrayList();
		int i = 10;//Integer 
		list.add(new Integer(i));
		
		//5.0的做法
		int j = 100;
		list.add(j);//实际上编译器把基本类型的j自动调用了new Integer(10)，传递给集合
		
		//遍历
		int k = (Integer)list.get(1);//自动拆箱
		System.out.println(k);
		//注意的问题
//		Integer ii = null;
//		int l = ii;
//		System.out.println(l);
		System.out.println("-------------------------");
		
		Boolean b1 = true;
		Boolean b2 = true;
		System.out.println(b1==b2);
		
		Integer i1 = 100;
		Integer i2 = 100;
		System.out.println(i1==i2);
		
		Integer i3 = 129;
		Integer i4 = 129;
		System.out.println(i3==i4);
		
		Float f1 = 0.1f;
		Float f2 = 0.1f;
		System.out.println(f1==f2);
	}

}

4、享元模式（flyweight）：

1）概述：如果很多很小的对象，他们有很多相同的属性，那么就可变为一个对象使用，这些属性称为内部状态，还有些不同的属性，作为方法参数植入，这些称为外部状态。这种优化内存，只创建一个对象的模式，称之为享元模式。

2）应用：

（1）word中输入英文字母，可创建26对象，每个对象值是出现的位置不同（坐标），所以可用一个对象调用位置的方法：如，字母i：i.display(intx,int y)，将高度重复使用的char类型的字母i封装成一个对象使用。

（2）图标：window下的文件夹图标，只哟名称这个属性不同，包含了很多其他相同的属性，那么可以应用享元模式。

3）valueOf(int x)：Integer中静态方法，讲一个整数转换为Integer，即把基本数据类型变为包装类。

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Unity开发</a>、&lt;a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

详细请查看：<a href="http://edu.csdn.net" target="blank"> http://edu.csdn.net</a>