Java基础---基础加强---增强for循环、自动拆装箱及享元、枚举的作用、实现带有构造方法、透彻分析反射的基础_Class类、成员变量的反射、数组参数的成员方法进行反射、数组的反射应用

在perference 加content Assist 可以设置快捷键

透视图与视图

透视图：Debug和java主窗口

视图：每一个小窗口就是视图

高版本的java可运行低版本的java版本

常见的错误：classversionError

一般都是文件编译与系统默认的编译器版本不同导致的。

在配置文件里把java compiler变了，整个工作间都会跟着改变

如何自己配置模板:

在preferences中有一个Editor。下面有一个Template,里面可以设置

提示：

如果在导入工程的时候，发现在jdk版本不一样，我们可以在Build Path下找到java Build path 有一个Libraries删除原来的jRE库，重新导入新的jRE,很多的jar文件在一起就称之为库，jre相当于打包的过程





静态方法的导入java.lang.*;

jdk1.5的新特性

1.可变参数 

一个方法接受的参数的个数不固定，例如：System.out.println(add(1,2,5);

System.out.println(add(1,2,3,5);

可变参数的特点：

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

位于变量类型和变量名之间。前后有无空格都可以。

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

overload override:

深入理解。

public class StaticImport {

	public static void main(String []args){
		//int x=1;
		//x++;
		System.out.println(add(2,3));
		System.out.println(add(2,3,4));
		//System.out.println(Math.max(3,6));
	}

	public static int add(int x,int ...args){
		int sum=x;
		for(int i=0;i<args.length;i++){
			sum+=args[i];
		}
		return sum;
	}

}

增强for循环

语法(类型 变量名：集合变量名）

注意事项：

跌代变量必须在()中定义。

集合变量可以是数组或实现了Iterable接口的集合类。

2.基本数据类型的自动拆箱与装箱及享元设计模式。

自动装箱

Integer num1=12;

自动拆箱

System.out.println(num1+12);

i{char,x,y},为了共用。里面的参数

享元设计模式：

如果很多很小的东西，它们具有相同的属性，我们就可以把它变成一个相同的对象。这些称之为内部状态。那些不同的属性作为方法的参数传入，称之为外部状态



3.枚举

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

用普通类如何实现枚举功能，定义一个Weekday的类来模拟枚举功能 。

私有的构造方法。

每个元素分别用一个公有的静态成员表量表示

可以用若干个公有方法或抽象方法，例如，要提供nextday方法必须是抽像的

public abstract class WeekDay1 {

	private WeekDay1(){

	}
	public final static WeekDay1 Sun=new WeekDay1(){

		@Override
		public WeekDay1 nextDay() {
			// TODO Auto-generated method stub
			return Mon;
		}

	};
	public final static WeekDay1 Mon=new WeekDay1(){

		@Override
		public WeekDay1 nextDay() {
			// TODO Auto-generated method stub
			return Sun;
		}

	};
	public abstract WeekDay1 nextDay();

//	public WeekDay nextDay(){
//		if(this==Sun){
//			return Mon;
//		}else{
//			return Sun;
//		}
//	}
	public String toString(){
		return this==Sun?"Sun":"Mon";
	}

}

为了更多的理解枚举，采用抽象方法定义next.day就将大量的if.else语句转移成了一个个独立的类。

如果想在一个类中完成各个枚举和测试调用类，那么就可以将枚举类定义成调用类的内部类。

内部类可以有4个访问修饰符。

一般的成员方法就是2个。public private，内部类与成员方法是平级的

package day01;

import java.sql.Date;

public class EnumTest {

	public static void main(String[] args) {

		WeekDay1 weekDay=WeekDay1.Mon;//赋值给引用变量
		System.out.println(weekDay.nextDay());
		WeekDay weekDay2=WeekDay.Fri;
		System.out.println(weekDay2);
		System.out.println(weekDay2.name());
		System.out.println(weekDay2.ordinal());
	//把静态的串变成枚举方法
		System.out.println(weekDay2.valueOf("Sun"));

		new Date(300){
			//调用父类的构造方法，调用有参的构造
		};

	}

	public enum WeekDay{
		Sun,Mon,Tue,Fri;//相当于里面的类。如果我们写成Sun(1),可会调用第二个方法
		//定义带有参数的构造方法
		private WeekDay(){
			System.out.println("first");
		}
		private WeekDay(int day ){
			System.out.println("second");
		}
	}

	//带有抽象方法的枚举类
	public enum TrafficLamp{
		Red(30){//red是一个元素，它是由trafficLamp子类来实现的
			public TrafficLamp nextLamp(){
				return Green;
			}

		},
		Green(45){
			public TrafficLamp nextLamp(){
				return Yellow;
			}
		},
		Yellow(5){
			public TrafficLamp nextLamp(){
				return Green;
			}
		};
		public abstract TrafficLamp nextLamp();

		private int time;
		private TrafficLamp(int time){
			this.time=time;
		}

	}
}

抽象类的返回值还是自己

枚举就相当于一个类，其中也可以定义构造方法，成员变量，普通方法和抽象方法。

枚举元素必须位于枚举体中的最开始部分，枚举元素列表的后面要有分号与其他成员分隔，把枚举中的成员或变是等放在枚举元素的前面，编译器报告错误 



带枚造方法的枚举

1.构造方法必须定义成私有的

2.如果有多个构造方法，该如何选择哪个构造方法？

3.枚举元素MON和MON()的效果一样，都是调用默认的构造方法。



带方法的枚举

1.定义枚举TrafficLamp

2.实现普通next的方法

3.实现抽象的next方法，每个元素分别是由枚举的子类来生成的实例对象，这些子类采用类似的内部类的方式进行定义

4.增加上不表示时间的构造方法



枚举只有一个成员时，就可以作为一种单例的实现方式。



反射

Person p1=new Person();



Class代表内存里央的字节码，不能实例化对象。

p1.getClass()也是代表person那个字节码

Class cls1=Data.class//字节码1;Data.class代表Data的那个字节码

Class cls2=Person class//字节码2;

Person class代表Person的那个字节码

每一份字节码就是一份Class的实例对象

还有一种是Class.forName("java.lang.String")，在写源程序的时候，可以把括号里面的变成变量，字符串变量，程序启动，从配置文件里装载进来。类的名字，在写的时候可以不知道，在运行的时候，临时送进来

这个forName的作用是：

1.返回刚刚加载进来的字节码

返回的方式有两种，第一种是说这份字节码曾经被加载过，已经在JVM里面了，直接返回。第二种是JVM还没有这个字节码，则用类加载器去加载，把加载进来的字节码缓存在JVM中，以后要得到这份字节码，就不用加载了



有9个预定义的class对象，8个基本类型加一个void

记得加了void，如Class cls1=void.class;



反射比较占用时间，它是先把构造方法存起来，如果有人要用了，再把它拿出来。这过程中就消耗了时间。

如何你在一个配置文件里，配置了好多东西，我们可以通过反射来修改。这个功能相当有用



面向对象就是把变量搞成私有的，如果谁要调用这个对象，那么方法就应该在谁身上

package day01;

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

public class ReflectTest {

	public static void main(String[] args)throws Exception {

		String str1="abc";
		Class cls1=str1.getClass();
		Class cls2=String.class;
		Class cls3=Class.forName("java.lang.String");
		System.out.println(cls1==cls2);
		System.out.println(cls2==cls3);
		//JVM中只存在一份字节码。供不同的对象调用
		//String不是基本类型的字节码，它是一个类
		System.out.println(cls1.isPrimitive());//isprim表示一个原始类型
		System.out.println(int.class.isPrimitive());
		System.out.println(int.class==Integer.class);
		System.out.println(int.class==Integer.TYPE);//表示包装类型的那个基本类型的字节码,所以为True
		System.out.println(int[].class.isPrimitive());//返回false,因为数组也是一个实例对象，用的方法是Class.isArray();

		//new String(new StringBuffer("abc"));
		Constructor constructor1=String.class.getConstructor(StringBuffer.class);//第一个StringBuffered表示选择哪个构造方法
		String str2=(String)constructor1.newInstance(new StringBuffer("abc"));//每调用一次相当于New了一次对象。第二个StringBuffered表示用这个StringBuffered传哪个对象进去。
		//在编译的时候，只知道constructor1是构造方法，而不知道是哪个类下的构造方法，编译器只看变量的类型，而不看执行
		System.out.println(str2.charAt(2));
		//得到方法的时候需要类型，在调用方法的时候，还是要类型

		ReflectPoint pt1=new ReflectPoint(3, 5);
		Field fieldY=pt1.getClass().getDeclaredField("y");
		//FieldY的值是多少？5,错，没有对应到对象身上，Field
		//不代表一个具体的值，只代表一个变量，而且是字节码里面的一个变量
		//它是指向哪个类身上的值
		fieldY.setAccessible(true);//这里用到的是暴力反射。
		System.out.println(fieldY.get(pt1));

		changeStringValue(pt1);
		System.out.println(pt1);

		//直接调用，str1.charAt(1);
		Method methodCharAt=String.class.getMethod("charAt", int.class);
		//得到字节码里面的方法，再用方法去作用某个对象
		System.out.println(methodCharAt.invoke(str1, 2));//args表示传几个参数。str1这个字符串身上调用charAt
		//invoke是方法对象身上的方法

		System.out.println(methodCharAt.invoke(str1, new Object[]{2}));//2表示一个object
		//这是jdk1.4里面的方法

		String startingClassName=args[0];
		Method mainMethod=Class.forName(startingClassName).getMethod("main", String[].class);
		//mainMethod.invoke(null,new Object[]{new String[]{"111","222","333"}});//把三个参数包到一起传送进去
		mainMethod.invoke(null,(Object)new String[]{"111","222","333"});
		//每个数组的父类都是object

		int [] a1=new int[3];
		int [] a2=new int[4];
		int [][] a3=new int [2][3];
		String [] a4=new String []{"a","b","c"};
		System.out.println(a1.getClass()==a2.getClass());
		//System.out.println(a1.getClass()==a4.getClass());
		//System.out.println(a1.getClass()==a3.getClass());

		Object aObj1=a1;
		Object aObj2=a4;
		//Object[] aObj3=a1;//int不是object,基本类型不是Object,基本类型的一维数组不能转成object数组
		Object[] aObj4=a3;//二维是object
		Object[] aObj5=a4;//String是object

		System.out.println(Arrays.asList(a1));
		System.out.println(Arrays.asList(a4));//只接受String类型，因为它是object数组

		printObject(a4);
		printObject("xyz");

	}

	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 changeStringValue(Object obj) throws Exception{
		Field [] fields=obj.getClass().getFields();//得到所有的字段
		for(Field field:fields){
			//if(field.getType().equals(String.class)){
			//对字节码的比较应该拿==相比
			if(field.getType()==(String.class)){//这里应该用==，因为是同一份字节码
				String oldValue=(String) field.get(obj);
				String newValue=oldValue.replace('b', 'a');
				field.set(obj, newValue);

			}
			//这个field代表字段 

		}
	}

}

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

ReflectPoint.java

package day01;

public class ReflectPoint {

	private int x;

	public String str1="ball";
	public String str2="basketball";
	public String str3="haha";

	public int y;

	public ReflectPoint(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + x;
		result = prime * result + y;
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		ReflectPoint other = (ReflectPoint) obj;
		if (x != other.x)
			return false;
		if (y != other.y)
			return false;
		return true;
	}

	@Override
	public String toString(){
		return str1+":"+str2+":"+str3;
	}
}

例子:

通过反射来调来main方法



数组的反射

int [] a=new int[3];

object[] a=new object[]("a",1)

a[0].getClass().getName();//只能得到它的元素的类型，不能得到a是什么类型



反射的综合应用。

ArrayList 是有顺序的数据。每放一次就引用一个变量。不是排序，而是位置顺序。

HashSet

先判断里面有没有这个对象，如果发现有的话，就不放。如果实在要放，就把原来的数据给删除掉。然后插入进去。



HashCode方法与HashSet类

如果想查找一个集合是否包含某个对象，大概的程序怎样写呢？你通常是逐一取出每个元素与要查找的对象的进行比较，当发现某个元素与要查找的对象进行equals方法比较的结果相等时，则停止继续查找并返回肯定的信息，否则，则返回否定的信息。如果一个集合中有很多元素，譬如有10000个元素，并且没有包含要查找的对象时，则意味着你的程序需要从该 集合中取出一个元素进行逐一比较才能得到结论。有人发明了哈希算法来提高从集合中查找元素的效率，这种方式将集合分成若干个区存储。每个对象可以计算出一个哈希码。可以将哈希码分组。每组分别对应某个存诸区域，根据一个对象的哈希码就可以确定该对象应该存储在哪个区域



hashcode的作用：

对象要有作用，必须在hash算法类的集合中，hashcode的值才有价值。两个相同的对象被存到了不同的Hashset内存里，当要再找这个对象时，只能在本区域里进行查找。如果对象不存到hashset集合里，那么也没有必要用到hashcode方法。



提示：

通常来说，一个类的两个实例对象用equals()方法比较的结果相等时，它们的哈希码也必须相等，但反之则不成立，即equals方法比较结果不相等的对象可以有相同的哈希码。

或者说哈希码相同的两个对象的equals方法比较的结果可以不等，例如，字符串“BB” 和“Aa"的equals方法比较结果肯定不相等，但它们的hashcode方法返回值相等。

2.当一个对象被存储进HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段，否则，对象修改后哈希值最初存储进HashSet集合中时的哈希值就不同了，在这种情况下，即使在Container方法使用该对象的当前引用作为的参数去HashSet集合中检索对象，也将返回找不到对象的结果，这也会导致无法从Hashset集合中单独删除当前对象，从而造成内存泄露。

package day01;

import java.io.FileInputStream;
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 Exception{

		InputStream ips=new FileInputStream("config.properties");//这里用到的是相对路径
		//现在的内容是ArrayList.所以结果是4，
		//如果把properties中的内容改为Hashcode,结果就变为2
		//这里就用到了反射技术开发框架的原理
		Properties props=new Properties();
		props.load(ips);
		ips.close();//告诉操作系统把这个流关闭

		String className=props.getProperty("className");
		Collection collections=(Collection) Class.forName(className).newInstance();
		//调用不带参数的构造方法
		//Collection collections=new HashSet();
		ReflectPoint pt1=new ReflectPoint (3,3);
		ReflectPoint pt2=new ReflectPoint (5,5);
		ReflectPoint pt3=new ReflectPoint (3,3);
		collections.add(pt1);
		collections.add(pt2);
		collections.add(pt3);
		collections.add(pt1);

		//pt1.y=7;//这个集合与hashcode没有关系
		//collections.remove(pt1);
		System.out.println(collections.size());
	}
}

反射的作用--->实现框架功能

newStance()，调用不参数的构造方法