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());
}
}