Java基础加强_MyEclipse、JDK1.5新特性、枚举、反射

Java基础加强---day01

一、MyEclipse的使用技巧

    Eclipse和MyEclipse：MyEclipse本来是Eclipse的一个插件，增加了java ee项目的开发功能。但安装了Eclipse还要安装插件，很麻烦；于是MyEclipse厂商就把Eclipse包含进来，并提供一个默认的JRE，一键安装即可。

    IDE：IDE是集成开发环境，支持使用工程化方式管理一个项目的程序开发过程，一般来说，一个相对独立的项目就是一个工程，一个项目中涉及的多个java文件，资源文件等用一个工程进行管理。在不使用工程管理的情况下，如果一个项目中包括多个Java源文件，编程人员需要精心维护这些源文件之间、以及源文件与其它文件的目录关系，需要逐一编译这些源文件，需要手工启动运行编译后的结果。如果将一个程序的所有源文件用一个工程来组织，开发工具能对所有源文件集中管理，记住每个源文件的位置和相互关系。工程中有哪几个源文件、启动类是哪个、启动参数设置等配置信息在工程中都记录。

    一个Workspace(工作区)可以包含多个Project(工程)，一个Workspace保留了Eclipse的一套环境变量的配置。

    一个Perspective代表了若干个View的集合，可以通过window-->show view-->选择需要的View；

    可以手动配置编译和运行环境：window-->preference-->java-->compiler(或者Installed JREs)；注意：高版本编译出来的字节码交给低版本的JRE运行，会出现错误。

    导入已有的工程：先把要导入的工程copy到Workspace文件目录下，然后：import-->Existing  Projects into Workspace，确认即可。导入的工程后，有可能工程原来所用的JRE与Workspace中的JRE不一致，导致一些编译运行错误。这时可以点击右键，buildPath-->configure  buildPath,先删除已有的JRE库，再增加原来的JRE库，即可。

    怎样调试一个变量的值？双击一行，观察到左边出现断点，右键debug  as，切换到调试视图下，选中变量右键watch，单步运行即可。

    注释整个段落的内容：先选中要注释的内容，然后ctr+shift+/；

    当类文件或者某个字段的名称写错时，可以重构：右键refactor-->rename，即可。

    设置单个工程的javac和java，选择工程，右键->properties可以设置javac，右键->run as-->open rundialog可以设置java。

    内容助理：alt+/；单行注释：ctr+/；多行注释：ctr+shift+/。

    代码模板的设置：java-->editor-->Templates。

二、JDK1.5的几个新特性

    2.1、静态导入：import static

    import语句可以导入一个类或者某个包中的所有类；

    import  static语句可以导入一个类中的某个静态方法或者所有的静态方法。导入后可以直接写方法名，不用注明类名；但静态导入的多个类中有相同的静态方法，需要注明方法的类名。

    2.2、可变参数

    当一个方法接收的参数不固定时，在JDK1.4版本之前，用一个数组存储这些参数；在1.5版本之后，用可变参数(…)的形式。其实可变参数内部还是封装了一个数组，只不过是编译器隐式帮助创建一个数组罢了；注意：可变参数必须出现在参数列表的末尾。

    2.3增强for循环

    格式：for（type 变量名：集合变量名）{…}；

    被遍历的集合变量要么是数组，要么是集合，增强for循环只能对集合中的元素进行遍历，不能进行增删改等的操作。建议平时使用普通for循环，因为可以操作角标。这个升级：简化书写。

2.4基本数据类型的自动装箱和自动拆箱

    自动拆箱与自动装箱：发生在八种基本数据类型和所对应的包装类之间的自动转换动作。

享元模式：flyweight，当整数在一个字节大小内时，使用享元模式，即在内存中使用的是同一个对象。

三、枚举

    枚举：枚举就是让某个类型的变量的取值只能是若干个固定值中的一个，否则，编译器会报错。枚举可以让编译器在编译时期就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。枚举也是JDK1.5的一个新特性。

    用普通类实现枚举功能的方法：1、私有化构造方法；2、每个元素用一个公有的静态成员变量表示；3、可以定义一些抽象方法，然后每个枚举的元素用匿名内部类的形式实现该抽象方法。

    enum：枚举有enum关键字表示，相当于一个类，其中也可以定义构造方法、成员变量、普通方法、抽象方法等等。

    注意：枚举元素必须位于枚举体中的最开始部分，枚举元素列表的最后要有分号与其他成员分隔。在枚举中的构造方法必须私有化；枚举中可以带有抽象的方法，抽象方法可以交给枚举元素分别取实现，使用匿名内部类的形式。

下面代码体现：

1、用一个星期类模拟枚举

package itheima.day07;

//模拟枚举的类
public abstract  class Weekday {
	
//	1、私有化构造函数，外界不能创建对象
	private Weekday(){}
	
//	2、向外提供该类的实例
	public final static Weekday SUN = new Weekday(){
		public Weekday nextday(){
			return MON;
		}
	};
	public final static Weekday MON = new Weekday(){
		public Weekday nextday(){
			return SUN;
		}
	};
	
//	在类中定义了抽象方法，那么该类也是抽象类，
//	可以让实例对象通过匿名内部类的形式实现这些抽象方法
	public abstract Weekday nextday();
	
//	覆盖继承于Object类的toString方法
	@Override
	public String toString() {
		if(this ==SUN)
			return "SUN";
		else
			return "MON";
	}	
}

2、星期、交通灯的枚举形式

package itheima.day07;

public class EnumTest {

	public static void main(String[] args) {
		
//		Weekday wd1 = Weekday.SUN;
//		System.out.println(wd1.nextday());	
//		Weekday wd2 = Weekday.MON;
//		System.out.println(wd2.nextday());
		
//		使用星期的枚举类
		Weekday1 wd1 =Weekday1.MON;
		Weekday1 wd2 = Weekday1.SUN;
		
//		使用交通灯的枚举类
		TrafficLamp red = TrafficLamp.RED;
		System.out.println(red);
		System.out.println(red.nextLamp());
//		名称
		System.out.println(red.name());
//		秩序
		System.out.println(red.ordinal());
		System.out.println(red.valueOf("RED").toString());
		System.out.println(red.values().length);
	}
	
//	为了让权限为public，不同包中也可以访问，
//	但一个源文件中不能有两个类为public权限，所以使用内部类的形式
	public enum TrafficLamp{
//		枚举的元素
		 RED(30){
			@Override
			public TrafficLamp nextLamp() {
				return GREEN;
			} 
		 },
		 GREEN(45){
			@Override
			public TrafficLamp nextLamp() {
				return YELLOW;
			}	 
		 },
		 YELLOW(5){
			@Override
			public TrafficLamp nextLamp() {
				return RED;
			}	 
		 };
		 
//		 枚举中的抽象方法，交给实例对象去实现
		public abstract  TrafficLamp nextLamp();
		
//		枚举的构造方法可以自定义，但必须是private权限，其实枚举就是一个特殊的类
		private int time;
		private TrafficLamp(int time){
			this.time = time;
		}
	}
//	星期的枚举
	public	enum Weekday1{
		SUN(1),MON;
		private Weekday1(){
			System.out.println("first");
		}
		private Weekday1(int day){
			System.out.println("second");
		}
	}
}

四、反射

    4.1、Class类

    Person类代表人，它的实例对象可以是张三、李四等等这样具体的人。同理：Class类描述的是内存中的字节码，每一份字节码都是Class类在内存中的一个具体对象。

    获取Class类对象、即具体的一份字节码的方法：

        1、类名.class；例如：System.class；

        2、对象.getClass(),例如：new Stirng(“abc”).getClass()；

        3、Class.forName(“类名”),例如：Class.forName(“java.lang.String”)；

    每一种不同的类型，都有对应的字节码，同一种类型在内存中使用的是同一份字节码。

例如：int、double、int[]、int[][]、void等等都有对应的字节码。

注意：每一个类在内存中的字节码唯一！

    4.2、反射

    反射：反射就是把java类中的各个成分映射成为相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。

    4.3、Constructor类

    Constructor类：代表某一份字节码中的构造方法。

    获取全部构造函数：Constructor[] constructors =

        Class.forName(“java.lang.String”).getConstructors()；

    获取某一个构造函数：Constructor constructor =

        Class.forName(“java.lang.String”).getConstructor(StringBuffer.class)；

    获取到一份字节码中的构造函数后，就可以用这些构造函数创建具体的实例对象了，

        例如：constructor.newInstance(new StringBuffer(“abc”))；注意：构造函数的参数列表的类型必须一致，否则运行出错。

    一般是先获取具体的一份字节码，然后再获取该字节码中的构造函数，之后才能用该构造函数去创建对象；为了简化过程，可以使用字节码直接创建对象(只能创建默认无参的)；

    例如：Class.newInstance()方法：

        Stringobj =(String)Class.forName(“java.lang.String”).newInstance();

    该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象，缓存机制。

    4.4、Field类

    Field类：代表某一份字节码中的成员变量。注意：得到的只是一份字节码中的某个成员变量字段，并非具体对象的那个成员变量字段。具体的操作会在代码中说明。

    4.5、Method类

    Method类：代表的是某一份字节码中的成员方法。关于main方法的反射、数组的反射等都在接下来的代码中详细说明，在此不再细说。

    4.6、反射的作用

    反射的作用：实现框架功能。因为框架往往是先写成，写的时候要调用的那些类还没存在，所以只能使用反射，将特定的类名传入到框架中，即可。

    框架：专门调用别人的类，提高效率的工具。注意：框架是调用用户提供的类，而工具类被用户的类调用。

    Java中有内存泄露吗？有；比如当把对象存入到hashSet集合中时，改变了hashSet集合中对象的hashcode值；要知道，contains/remove、equals方法的底层都是调用hashcode和equals方法的，这时就会存在内存泄露，所以应该禁止改变已经存入hashSet集合中的hashcode值。

    getRealPath()可以获取到软件项目的安装路径，可以加上内部的路径，就是绝对路径了，confige配置文件的绝对路径一般这样获得。

    一般将配置文件放在classpath路径下，但myEclipse能把src源文件路径下的配置文件在编译时复制到classpath路径下，所以可以把配置文件放在源文件下；

    类加载器可以将类的字节码加载进内存，也可以将配置文件顺带加进内存。

下面代码体现：

3、演示反射的基本类：

package itheima.day07;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;

//演示反射的基本类
public class ReflectTest {

	public static void main(String[] args) throws Exception{
		String str1 ="abc";
//		获取字节码
		Class clazz1 = str1.getClass();
		Class clazz2 = String.class;
		Class clazz3 = Class.forName("java.lang.String");
		
//		一个类在内存中的字节码唯一
		System.out.println(clazz1 ==clazz3);
		
		System.out.println(clazz1.isPrimitive());
		System.out.println(int.class.isPrimitive());
		System.out.println(int.class == Integer.class);
		System.out.println(int.class == Integer.TYPE);
		
//		获取构造方法
		Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
		
//		用反射获取到的字节码创建对象
		String str2 = (String) constructor1.newInstance(new StringBuffer("abcdefg"));
		
		System.out.println(str2.toUpperCase());
		
		ReflectPoint pt1 = new ReflectPoint(3, 5);
//		获取类中的一个字段
		Field fieldY = pt1.getClass().getField("y");
//		类中的字段与相应的对象相关联
		System.out.println(fieldY.get(pt1));
		
//		暴力反射私有字段
		Field fieldX = pt1.getClass().getDeclaredField("x");
		fieldX.setAccessible(true);
		
		System.out.println(fieldX.get(pt1));
		
//		改变字符串的某一个值
		changeStrValue(pt1);
		System.out.println(pt1);
		
//		获取类中的方法
		Method methodCharAt = String.class.getMethod("charAt", int.class);
		System.out.println(methodCharAt.invoke(str1, 1));
		
//		关于main方法的反射
		String startingClassName = args[0];
		Method mainMethod =
				Class.forName(startingClassName).getMethod("main", String[].class);
		mainMethod.invoke(null, new Object[]{new String[]{"aaa","bbb","ccc"}});
		
//		数组类型的字节码
		int[] a1 =new int[]{1,2,3};
		int[] a2 =new int[4];
		int[][] a3 =new int[2][3];
		String[] a4 =new String[]{"aaa","bbb","ccc"};
		
		System.out.println(a1.getClass() ==a2.getClass());//true
//		以下两端代码编译都通不过，更加说明了 每种类型在内存中的字节码唯一
//		System.out.println(a1.getClass() ==a3.getClass());
//		System.out.println(a1.getClass() ==a4.getClass());
		
		Object aObj1 = a1;
		Object aObj2 = a4;
		Object[] aObj4 = a3;
		Object[] aObj5 =a4;
		
//		用数组工具类Arrays把一个数组转换成为一个List集合
//		当数组中的元素是基本数据类型时，那么整个数组看做是一个List元素
		System.out.println(Arrays.asList(a1));
//		非基本数据类型时，数组中的每个元素看做是一个List元素
		System.out.println(Arrays.asList(a4));
		
//		该方法就是弥补上面方法的不足！
		printObject(a1);
		printObject(a4);
	}
	private static void printObject(Object obj) {
//		既然是反射，那么先获取字节码
		Class clazz = obj.getClass();
		
//		如果字节码是数组类型的话，拆分
		if(clazz.isArray()){
			int len = Array.getLength(obj);
			for(int i=0;i<len;i++){
				System.out.println(Array.get(obj, i));
			}
		}else{
			System.out.println(obj);
		}
	}
//	利用反射的方式改变一个类的某些字符字段中的字母
	private static void changeStrValue(ReflectPoint pt1) throws IllegalArgumentException, IllegalAccessException {
		Field[] fields = pt1.getClass().getFields();
		
		for(Field field:fields){
			if(field.getType() ==String.class){
				String oldValue =(String) field.get(pt1);
				String newValue = oldValue.replace('b', 'a');
				field.set(pt1, newValue);
			}
		}
	}
}

演示反射main方法的类：

package itheima.day07;

public class MainReflectTest {

	public static void main(String[] args) {
		for(String arg:args){
			System.out.println(arg);
		}
	}
}

演示反射的类：

package itheima.day07;

public class ReflectPoint {
	
	private int x;
	public int y;
	
	public String str1 = "ball";
	public String str2 = "basketball";
	public String str3 ="itcast";
	
//	构造方法
	public ReflectPoint(int x,int y){
		this.x =x;
		this.y =y;
	}
	
//	getter and setter
	public int getX() {
		return x;
	}

	public void setX(int x) {
		this.x = x;
	}

	public int getY() {
		return y;
	}

	public void setY(int y) {
		this.y = y;
	}
	
//	复写toString方法，不然打印的东西看不懂
	@Override
	public String toString() {
		return "str1::"+str1+"  ,str2::"+str2+" ,str3::"+str3;
	}
}

4、反射的演示2

package itheima.day01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Properties;

public class ReflectTest2 {

	public static void main(String[] args) throws IOException, InstantiationException, IllegalAccessException, ClassNotFoundException {
		
//		记住用完整的路径，不是硬编码，而是运算出来的
//		InputStream ips = new FileInputStream("config.properties");
	
//		用类加载器的形式加载配置文件
//		InputStream ips = 
//			ReflectTest2.class.getClassLoader().getResourceAsStream("itheima/day01/config.properties");
//		相对路径，文件放在包的resource文件夹下
		InputStream ips = ReflectTest2.class.getResourceAsStream("resource/config.properties");
		

//		IO流与Map结合的一个重要工具类
		Properties props = new Properties();
//		加载
		props.load(ips);
//		关闭流
		ips.close();
//		获取类名
		String className = props.getProperty("className");
//		根据类名创建一个集合类，反射！
		Collection collection = (Collection)Class.forName(className).newInstance();
		
		ReflectPoint pt1 = new ReflectPoint(3,3);
		ReflectPoint pt2 = new ReflectPoint(5,5);
		ReflectPoint pt3 = new ReflectPoint(3,3);
		
		collection.add(pt1);
		collection.add(pt2);
		collection.add(pt3);
		collection.add(pt1);
		
		System.out.println(collection.size());
	}
}