黑马程序员_高新技术总结

---------------------- ASP.Net+Unity开发、 .Net培训、期待与您交流！ ----------------------

看视频整理的学习笔记

<一>

1.5版本后的新特性。通过 Integer的自动装箱和自动拆箱引发出来的Flyweight模式。
当是-128-127时，是同一个对象。不再那范围时，是不同的对象。

享元模式：就是一些很小的经常使用的对象，将它们封装成一个对象，然后对于对象不同的地方写成方法，可以在外面进行调用，叫外部状态。而相同的方法叫内部状态。

<二>
重载Overload和重写Overwrite的区别

重写是子类对父类方法的重写，方法名参数名类型都要一模一样，只是方法体不一样。
重载是方法名相同，返回类型，参数类型，参数个数，都可不同的重载。

1.5版本后引出可变参数  例如 int ... args  相当于是int[],数组长度可变。
作为参数传进来的时候，必须是参数列表中最后一个参数，否则会引起歧义，有错。
eg: void example(int x,int y,int ...args）这才是对的！

<三>
1.5版本后的静态导入
静态导入 和 导入
静态导入是导入包中的类的方法
导入只是导入包中的类

<四>
enhance for statement
增强型for语句
eg: for(int arg:args)
    {
       
     }


<五>
透视图（Perspective)和视图(View)
透视图是很多个视图的集合。

<六>
templates 模板
compiler 编译器
IDE intergrity develop environment 集成开发环境
content assistant 内容助理
<七>
枚举就是一个特殊的类。
枚举 ：就是编译时就规定了的名字，不可以改的名字。
1.为什么要用枚举：
枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。
2.用普通类如何实现枚举功能：
----1.私有的构造方法
----2.每个元素分别用一个公有的静态成员变量表示
----3.可以有若干个公有方法或抽象方法
3.枚举的应用
  public enum 名字
  {
   
   }
  枚举对象.name()  
  枚举类.valueof("str") 可以将字符串转换成枚举的成员
  枚举类.value() 返回的时装有枚举成员的数组
4.枚举的构造函数
   ----private ，必须是私有的
   ----调用自定义枚举构造函数时，在成员后面加括号，写参数即可。
5.子类可以调用父类的有参构造函数
  ！！！重点
  另外，单例可以用枚举来实现。
     //相当于一个内部类
       public enum TrafficLamp
       {
           //相当于TrafficLamp的一个子类
           Red(20){

            @Override
            public TrafficLamp nextLamp() {
                // TODO Auto-generated method stub
                return Green;
            }},
           Green(25){

            @Override
            public TrafficLamp nextLamp() {
                // TODO Auto-generated method stub
                return Yellow;
            }},
           Yellow(5){

            @Override
            public TrafficLamp nextLamp() {
                // TODO Auto-generated method stub
                return Red;
            }};
           int time;
           private TrafficLamp(int time)
           {
               this.time=time;
           }
           public abstract TrafficLamp nextLamp();
           
       }

<八>反射

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

/**
 * 基础加强的反射的基本了解
 * Class 是众多java类的共同特性抽象出来的一个类。里面包含了java类类型，类型所创建的对象，类型包含的对象的方法和成员。
 * 1.有三个方法可以获取到java类的字节码，即Class
 *   ----类名.class
 *   ----对象.getclass()
 *   ----Class.forname("java.lang.String")
 * 2.8个基本类型+void 
 *    ----（8个基本类型+void）.class()
 * 3. Class.isprimitive()
 *    用来判断是否是8个基本类型或者void。
 *    int.class==Integer.TYPE
 *    .TYPE代表的是该封装类型所封装的基本类型字节码
 * 4.可以通过.isarray()方法来判断类类型是否是数组
 *  构造方法的反射应用：
 *  ---得到类所有的构造方法
 *     .getConstructors()
 *  ---得到某个构造方法
 *     .getConstructors()
 *  ----字节码直接的无参构造方法
 *     .newInstanceof()
 * 5.Field 字段
 *   练习  changeStringValue()   
 * 6.Method方法
 *   可以通过方法类调用方法   
 * 7.数组的反射
 *     
 */
public class ReflectTest {
    public static void main(String[] args) throws Exception {
		String str="abc";
		Class cl1=str.getClass();
		Class cl2=String.class;
		Class cl3=Class.forName("java.lang.String");
		System.out.println(cl1==cl2);
		System.out.println(cl2==cl3);
		//结果为true,true.说明前面三个返回都是同一个字节码
		//int 是八个基本类型之一
		System.out.println(int.class.isPrimitive());
		//String 不是八个基本类型之一
		System.out.println(cl1.isPrimitive());
		System.out.println(void.class.isPrimitive());
		System.out.println(int[].class.isArray());
		System.out.println(int.class==Integer.TYPE);
		
		//new String()
		Constructor constructor=String.class.getConstructor(StringBuffer.class);
		String str1=(String) constructor.newInstance(new StringBuffer("abc"));  
		System.out.println(str1.charAt(1));
		String str2=String.class.newInstance();
		
		
		
	/*	String str3=new String("123");
		String str4=new String("123");
		System.out.println(str3==str4);//false
		System.out.println(str3.equals(str4));//true*/
		
		
		ReflectPoint rp1=new ReflectPoint(3,4);
		//这里得到的是field是RelfectPoint字节码的y，并不是rp1对象的y.
		Field fieldx=rp1.getClass().getField("y");
		//这里得到的才是rp1对象的y
		System.out.println(fieldx.get(rp1));
		//java.lang.NoSuchFieldException:因为x是私有的 ，应该用另一个方法获得
		//Field fieldy=rp1.getClass().getField("x");
		//正确的方法
		Field fieldy=rp1.getClass().getDeclaredField("x");
		//java.lang.IllegalAccessException
		//System.out.println(fieldy.get(rp1));
		//用暴力获取的方法
		fieldy.setAccessible(true);
		System.out.println(fieldy.get(rp1));
		
		System.out.println(rp1);
		changeStringValue(rp1);
		System.out.println(rp1);
		
		String str3=new String("abc");
		//通过反射的方法来获取一个方法
		Method method1=String.class.getMethod("charAt",int.class);
		//1.5版本后新方法
		System.out.println(method1.invoke(str3, 2));
		//1.4版本以前
		System.out.println(method1.invoke(str3, new Object[]{2}));
		
		//因为事先不知道类名实什么所有就用反射的方式的方法获取一个类的方法
		String methodclassname = args[0];
		Method method=Class.forName(methodclassname).getMethod("main",String[].class);
		//因为要兼容1.4版本还没有可变数组，所以会把new String[]{"111","222","333"这句话拆开，
		//那样子就变成了三个参数了，就造成不合法。而加（object)是让运行时，不用拆开，当成一个整体来看
		method.invoke(null, (Object)new String[]{"111","222","333"});
		
		
		//数组的放射
	    //同种类型，同纬度当成同一个数组字节码
		int[] i1=new int[]{1,2,3};
		int[] i2=new int[3];
		int[][] i3=new int[][]{{1},{2}};
		String[] s1=new String[]{"a","b","c"};
		System.out.println(i1.getClass()==i2.getClass());
		
		System.out.println(i1.getClass().getName());  //如果是数组的话，返回[ 如果元素时int 返回 I
		System.out.println(i1.getClass().getSuperclass().getName());//父类是object
		
		Object obj1=i1;
		//Object[] obj2=i1;//编译就出错
		Object[] obj3=i3;
		Object[] obj4=s1;
		
		//因为要考虑到兼容的特性，1.4版本的时候.asList()里面的参数是 Object[] ,再由上面可知，s1可以被看做Object[],然后被拆成了 
		//'a' 'b' 'c',而i1则不能被看做是Object[],所以不会用1.4版本的来拆开。而用的会是1.5版本的，看成了一个参数，所以返回的是
		//int[] 这一个对象的值
		System.out.println(Arrays.asList(i1));
		System.out.println(Arrays.asList(s1));
		
		
		String[] str00=new String[]{"123","323","fsd"};
		int x=984;
		String str01=new String("aaaaa");
		printobject(str00);
		printobject(x);
		printobject(str01);
	}
    //不知道打印的是否是数组，如果是数组就一个个打印出来，如果不是就直接打印出来
private static void printobject(Object obj) {     
		if(obj.getClass().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);
	}
//将一个对象里的所有字符串中的a装换成x
	private static void changeStringValue(Object obj) throws IllegalArgumentException, IllegalAccessException {
		
		Field[] fieldstrs=obj.getClass().getFields();
		for(Field fieldstr:fieldstrs)
		{
			//用==因为同种类型就对应一个
			//.class    标识此对象所表示字段的    声明类 型    ！！！  的 Class 对象
			if(fieldstr.getType()==String.class)
			{
			  String oldstr=(String) fieldstr.get(obj);
			  String newstr=oldstr.replace('b', 'x');
			  fieldstr.set(obj, newstr);
			}
		}
	}	
}
  class reflectmethod1
	{
		public static void main(String[] args) {
			for(String arg:args)
			{
				System.out.println(arg);
			}
			System.out.println("OK");
		}
	}

---------------------- ASP.Net+Unity开发、 .Net培训、期待与您交流！ ----------------------