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;
}
}
//星期的枚举
publicenum 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;演示反射main方法的类：
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);
}
}
}
}
package itheima.day07;public class MainReflectTest {public static void main(String[] args) {for(String arg:args){System.out.println(arg);}}}
演示反射的类：
package itheima.day07;4、反射的演示2
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;
}
}
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());}}