黑马程序员--Java基础加强1

------- android培训、java培训、期待与您交流！ ----------

静态导入与编译器语法设置

  package com.itcast.day1; 

import staticjava.lang.Math.*;//导入全部  
import staticjava.lang.Math.max;//导入一个  
public class StaticImport { 
    publicstatic void main(String[] args) { 
       //sop(random());  

 } 
    publicstatic void sop(Object obj){ 
       System.out.println(obj); 
   } 
}

可变参数

 

l可变参数的特点：

   只能出现在参数列表的最后；这个要记住

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

1、枚举就是让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器报错。
 调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

举例代码：

  public static void main(String[] args) {  // TODO Auto-generated method stub  System.out.println(add(1,2,3,5));  System.out.println(add(2,3,5));   }   public static int add(intx,int ...args) {  int sum = x;  for(inti=0;i<args.length;i++) {  sum += args[i];  }  return sum;  }

增强for循环

  1、语法：
 

      for(type 变量名  : 集合变量名){}
    2、注意事项
       迭代变量必须在()中定义
       集合变量可以使数组或实现了Iterable接口的集合类

代码举例子：
 

public static int add(int x,int ...args) {int sum = x;for(int arg:args) {sum += arg;}return sum;}

基本数据的自动拆装箱及享元设计模式

享元设计模式 

flyweight,Integer.valueOf()将数字变为对象

public class AutoBox {     public static void main(String[] args) {         Integer num1 = 3;//自动装箱          int num = num1+12;//自动拆箱          Integer i1 = 4;         Integer i2 = 6;         // i1 和 i2是一个对象          Integer i3 = 138;         Integer i4 = 137;         // i2 和 i3不是一个对象，当Integer数据在 -128 ~ 127之间时，会放入到常量池中          System.out.println(num);     } 

用普通类模拟枚举的实现原理
 

      1,枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。
   2、枚举就是一种特殊的类，其中的每个元素都是该类中的一个实例对象

枚举的基本应用

public class EnumTest {     public static void main(String[] args) {         WeekDay mon = WeekDay.MON;         System.out.println(mon);//名称为MON          System.out.println(mon.name());//名称为MON          System.out.println(WeekDay.valueOf("XX"));//增加枚举，将"XX"变为枚举类型          System.out.println(WeekDay.values().length);//返回枚举值      }     public enum WeekDay{         SUN,MON,TUE,WED,THI,FRI,SAT     } } 

实现带有构造方法的枚举

 

  1、当枚举只有一个成员时，就可以作为一种单例的实现模式

public class EnumTest {     public static void main(String[] args) {         WeekDay mon = WeekDay.MON;         System.out.println(mon);//名称为MON          System.out.println(mon.name());//名称为MON          System.out.println(WeekDay.valueOf("XX"));//增加枚举，将"XX"变为枚举类型          System.out.println(WeekDay.values().length);//返回枚举值      }     public enum WeekDay{         //成员列表必须写在所有成员之前          SUN,MON,TUE,WED,THI,FRI,SAT;//MON和MON(1)就是表示在构造          private WeekDay(){}         private WeekDay(int day){}              }     public enum TrafficLamp{         RED(30){             public TrafficLamp nextLamp() {                 return GREEN;             }         },GREEN(45){             public TrafficLamp nextLamp() {                 return YELLOW;             }         },YELLOW(5){             public TrafficLamp nextLamp() {                 return RED;             }         };         public abstract TrafficLamp nextLamp();         private int time;         private TrafficLamp(int time){             this.time = time;         }     } } 

透彻分析反射的基础Class类

   Person p1 = new Person();
Class cls = Person.class;//字节码
p1.getClass()//字节码，有，得到字节码
Class.forName("java.lang.String")//字节码,虚拟机里没有，加载
 

  1、java程序中的各个java类属于同一类事物，描述这类事物的java类名就是Class
       (1)、java类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值施舍呢么，则是由
       这个类的实例对象来确定的，不同的实例对象有不同的属性值。Java程序中的各个java类，他们是否属于同一类事物，
       是不是可以用一个类来描述这类事物呢？这个类的名字就是Class，要注意与小写class关键字的区别。Class类描述
       哪些方面的信息呢？类的名字，类的访问属性，类所属的包名，字段名称的列表，方法名称的类表，等等，学习反射
       ，首先就要明白Class这个类
   2、对比体温：众多的人用一个什么类表示？众多的java类用一个什么类表示？
       (1)、人->Person
       (2)、Java类->Class
   3、对比提问：Person类代表人，他的实例对象就是张三，李四这样一个个具体的人，Class类代表Java类，
       它的各个实例对象又分别对应什么呢？
           (1)、对应各个类在内存中的字节码，例如Person类的字节码，ArrayList类的字节码，等等
           (2)、一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是累的字节码，不同的
               的类的字节码是不同的，所以它们在内存中是不同的，这一个个的空间可分别用一个个的对象来表示，
               这些对象显然具有相同的类型，这个类型是什么呢？
   4、如何得到各个字节码对应的实例对象（Class类型）
       (1)、类名.class，例如，System.class
       (2)、对象.getClass(),例如，new Date().getClass()
       (3)、Class.forName("类名")，例如，Class.forName("java.util.Date")
   5、九个预定义Class实例对象
       (1)、参看Class.isPrimitive()方法的帮助,是否为基本类型
       (2)、Int.class==Integer.TYPE
       (3)、Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。
           每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。
           基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字void 也表示为 Class 对象。
       (4)、int.class==Integer.TYPE ， isPrimitive public booleanisPrimitive()判定指定的 Class 对象是否表示一个基本类型。
           有九种预定义的 Class 对象，表示八个基本类型和 void。这些类对象由 Java 虚拟机创建，与其表示的基本类型同名，即boolean、byte、char、short、int、long、float 和 double。
           这些对象仅能通过下列声明为 public static final 的变量访问，也是使此方法返回 true 的仅有的几个 Class对象。
   6、数组类型的、class实例对像
       Class.isArray()
       总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[] void

public class ReflectTest {     public static void main(String[] args) throws Exception{         // TODO Auto-generated method stub          String str1 = "abc";         Class cls1 = str1.getClass();         Class cls2 = String.class;         Class cls3 = Class.forName("java.lang.String");         System.out.println(cls1==cls2);//true          System.out.println(cls1==cls3);//true          System.out.println(cls2==cls3);//true          System.out.println("------------------");         System.out.println(cls1.isPrimitive());//false          System.out.println(int.class.isPrimitive());//true          System.out.println(int.class==Integer.class);//false          System.out.println(int.class==Integer.TYPE);//true,type表示基本包装类          System.out.println(int[].class.isPrimitive());//false          System.out.println(int.class.isArray());//true      } } 

理解反射的概念

  1、反射就是把Java类中的各种成份映射成相应的java类。例如，一个java类中用一个Class类的对象来表，一个类中的组成部分:成员变量，方法，构造方法，
 

  包等等信息也用一个个的java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类，表示java类的Class类显然要提供一系列的方法，
   来获得其中变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应的类的实例对象来表示，他们是Field，Method、Contrutor、Package等等
   2、一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢?怎么用呢
   这正是学习和应用反射的要点。

构造方法的反射应用
 

  1、Constructor类代表某个类中的一个构造方法
       T newInstance(Object... initargs)  使用此 Constructor对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例
   2、得到某个类所有的构造方法：
       例子：Constructor[] constructor =Class.forName("java.lang.String").getConstructors();
       例子：Constructor[] constructor =Class.forName("java.lang.String").getConstructors(StringBuffer.class);
   3、创建实例对象
       通常方式：String str = new String(new StringBuffer("abc"));
       反射方式：String str = (String)constructor.newInstance(newStringBuffer("abc"));
       调用获得的方法时要用到上面相同类型的实例对象
   4、Class.newInstance()方法
       例子：String obj =(String)Class.forName("java.lang.String").newInstance();
       该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象
       该方法内部具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象

import java.lang.reflect.*; public class ReflectTest {     public static void main(String[] args) throws Exception{         Constructor<String> constructor1 = String.class.getConstructor(StringBuffer.class);         String str2 = constructor1.newInstance(new StringBuffer("abc"));         System.out.println(str2.charAt(2));     } } 

成员变量的反射

Field类
 

  1、Field类代表某个类中的一个成员变量
   2、问题：得到的Field对象是对应到类上面的成员变量，还是对应发到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，那关联那个对象呢？所以字段field代表的是类的定义，而不是具体的x变量
Field getDeclaredField(String name) 返回一个 Field 对象，该对象反映此 Class对象所表示的类或接口的指定已声明字段。
Field[] getDeclaredFields() 返回 Field 对象的一个数组，这些对象反映此 Class对象所表示的类或接口所声明的所有字段。
Field getField(String name) 返回一个 Field 对象，它反映此 Class对象所表示的类或接口的指定公共成员字段。
Field[] getFields() 返回一个包含某些 Field 对象的数组，这些对象反映此 Class对象所表示的类或接口的所有可访问公共字段。

 

import java.lang.reflect.*; public class ReflectTest {     public static void main(String[] args) throws Exception{         ReflectPoint pt1 = new ReflectPoint(3,5);         Field fieldY = pt1.getClass().getField("y");         //fieldY的值是多少？是5？错，fieldY不是对象身上的变量，而是类上的，要用它去取某个对象上对应的值          System.out.println(fieldY.get(pt1));//5          //fieldX为私有的，.getField("x")取不到，得用.getDeclaredField("x")          Field fieldX = pt1.getClass().getDeclaredField("x");         //由于私有，不可访问，使用setAccessible(true)，可以表示可以取          fieldX.setAccessible(true);         System.out.println(fieldX.get(pt1));//3               } } class ReflectPoint {     private int x;     public int y;     public ReflectPoint(int x, int y) {         super();         this.x = x;         this.y = y;     } } 

成员变量反射的综合案例

import java.lang.reflect.*; public class ReflectTest {     public static void main(String[] args) throws Exception{         ReflectPoint pt1 = new ReflectPoint(3,5);         changeStringValue(pt1);         System.out.println(pt1);     }     private static void changeStringValue(Object obj) throws Exception {         Field[] fields = obj.getClass().getFields();         for(Field field : fields){             if(field.getType()==String.class){                 String oldValue = (String)field.get(obj);                 String newValue = oldValue.replace('b', 'a');                 field.set(obj,newValue);             }         }     } } 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) {         super();         this.x = x;         this.y = y;     }     public String toString() {         return str1+":"+str2+":"+str3;     } } 

成员方法的反射

Method Method类代表某个类中的一个成员方法、得到类中的某一个方法：

       例子：Method charAt =Class.forName("java.lang.String").getMethod("charAt",int.class);
调用方法：
       通常方式：System.out.println(str.charAt(1));
       反射方式：System.out.println(charAt.intvoke(str,1))
           如果传递给Method对象的invoke()方法的一个参数为null，这有着什么意义呢？说明该Method对象对应的是一个静态方法。静态方法法不需要对象.

ljdk1.4和jdk1.5的invoke方法的区别：

ØJdk1.5：publicObject invoke(Objectobj,Object... args)

ØJdk1.4：publicObject invoke(Objectobj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为charAt.invoke(“str”, newObject[]{1})形式。

import java.lang.reflect.*; public class ReflectTest {     public static void main(String[] args) throws Exception{         Method methodCharAt = String.class.getMethod("charAt", int.class);         System.out.println(methodCharAt.invoke("abc",1 ));         //System.out.println(methodCharAt.invoke(null,1 ));如果为null则为静态方法          //System.out.println(methodCharAt.invoke("abc",new Object[]{2} ));1.5以前，没有可变参数，这么写      } 

对接收数组参数的成员方法进行反射

用反射方式执行某个类中的Main方法

 

   1、目标：
       写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。用普通方式调完后，大家要明白，为什么要用反射的方式去调呢？
    2、问题
       启动java程序的main方法的参数是一个字符串数组，即public static void main(String[]args),通过反射方式来调用这个main方法时，如何为invoke方法法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给jdk1.4的语法时，javac会到底按照那种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成若干个单独的参数，所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,newString[]{"xxx"}),javac只把它当做jdk1.4的语法进行理解，而不把它当做jdk1.5的语法解释，因此会出现参数类型不对的问题。
       //不只是main方法，普通方法也一样
    3、解决办法
       mainMethod.invoke(null,new Object[]{new String[]{"sddsfs"}})
       mainMethod.invoke(null,(Object)newString[]{"sddsfs"})编译器会作特殊处理，编译时不把参数当做数组看待，也就不会把数组打散成若个参数了

import java.lang.reflect.*; public class ReflectTest {     public static void main(String[] args) throws Exception{         TestArguments.main(new String[]{"sadfds","hjhgj"});         System.out.println("-----------------------------");         String startingClassName = args[0];         Method mainMethod = Class.forName(startingClassName).getMethod("main", String[].class);         mainMethod.invoke(null, (Object)new String[]{"sadfds","hjhgj"});         System.out.println("-----------------------------");         //不只是main方法，普通方法也一样          Method testMethod = Class.forName(startingClassName).getMethod("test", String[].class);         testMethod.invoke(null, new String[]{"sadfds","hjhgj"});     } } class TestArguments{     public static void main(String[] args){         for(String arg : args){             System.out.println(arg);         }     }     public static void test(String[] args){         for(String arg : args){             System.out.println(arg);         }     } } 

数组的反射

 

l具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。

l代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。

l基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。

lArrays.asList()方法处理int[]和String[]时的差异。

Array工具类用于完成对数组的反射操作

  

Object[] 与String[]没有父子关系，Object与String有父子关系,所以new Object[]{“aaa”,”bb”}不能强制转换成new String[]{“aaa”,”bb”};,Object x = “abc”能强制转换成String x = “abc”。main.invoke(null, (Object)(new Object[]{“aaa”,“xxx”}));不能调用public static void main(String [] args)1.看Class类帮助文档开始部分的介绍。String[] a1 = new String[8];String[] a2 = new String[9];String[][] a3 = new String[6][4];().getName());System.out.println(a3.getClass().getName());System.out.println(a1.getClass() == a2.getClass());System.out.println(a1.getClass() == a3.getClass());2.看getSuperClass方法的帮助System.out.println(a1.getClass().getSuperclass().getName());3.int[] a = new int[3];Object obj = a;//Object[] obj1 = a //有错！Object[] obj3 = a1Object obj4 = a3;if(obj4 instanceof String[][]){System.out.println(obj1.getClass().isArray());}**在这里分析研究Arrays.asList()方法处理int[]和String[]时的差异，以及Arrays.deepToString()方法不能处理int[]，但能处理String[]的原因。4.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);}}5.需要取出每个元素对象，然后再对各个对象进行判断，因为其中每个具体元素的类型都可以不同，例如Object[] x = new Object[]{“abc”,Integer.Max}。

import java.lang.reflect.*; public class ReflectTest {     public static void main(String[] args) throws Exception{         int[] a1 = new int[3];         int[] a2 = new int[4];         int[][] a3 = new int[2][3];         String[] a4 = new String[3];         System.out.println(a1.getClass()==a2.getClass());         System.out.println(a1.getClass().getName());         System.out.println(a1.getClass().getSuperclass().getName());         System.out.println(a2.getClass().getSuperclass().getName());         System.out.println(a3.getClass().getSuperclass().getName());         System.out.println(a4.getClass().getSuperclass().getName());         System.out.println(String.class.getSuperclass().getName());         System.out.println(StringBuffer.class.getSuperclass().getName());         //发现a1，a2，a3，a4的super都是objcet所以可以          Object aObj1 = a1;         Object aObj2 = a4;         //Object[] aObj3 = a1;不对 int 不可以直接转为object          Object[] aObj4 = a3;         Object[] aObj5 = a4;     } } 

ArrayList_HashSet的比较及Hashcode分析

成员在Hash中，按照存储区域返回不同hashcode，根据hashcode查找
当对象存入HashSet中后，就不要修改参与hash运算变量了，hash码会出错，会找不到，造成出错，内存泄露

  public class ReflectTest2 { 

    publicstatic void main(String[] args) { 
       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); 
       System.out.println(collections.size()); 
   } 
} 

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

 

   1,框架与框架要解决的核心问题

         我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。

2 ,框架要解决的核心问题

我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？

Ø因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new某个类的实例对象了，而要用反射方式来做。

l综合案例

Ø先直接用new 语句创建ArrayList和HashSet的实例对象，演示用eclipse自动生成ReflectPoint类的equals和hashcode方法，比较两个集合的运行结果差异。

Ø然后改为采用配置文件加反射的方式创建ArrayList和HashSet的实例对象，比较观察运行结果差异。

引入了elipse对资源文件的管理方式的讲解。

   由于框架不知道运行什么类和函数，所要使用反射

什么是框架，例如，我们要写程序扫描.java文件中的由于框架不知道运行什么类，要解决哪些问题：读取每一样，在每一个中查找@，找到的@再去查询一个列表，如果@后的内容出现在了列表中，就说明这是一个我能处理和想处理的注解，否则，就说明它不是一个注解或者说至少不是一个我感兴趣和能处理的注解。接着就编写处理这个注解的相关代码。现在sun提供了一个apt框架，它会完成所有前期工作，只需要我们提供能够处理的注解列表，以及处理这些注解的代码。Apt框找到我们感兴趣的注解后通知或调用我们的处理代码去处理。你做的门调用锁，锁是工具，你做的门被房子调用，房子是框架，房子和锁都是别人提供的。程序中不处理异常，而是main方法声明抛出异常，便于大家可以集中看主要的关键代码。Class类也提供getResourceAsStream方法的比喻：如果你每次都找我给你商店买可乐，那我还不如直接向你买可乐，即直接提供一个买可乐的方法给你。public static void main(String[] args) throws Exception{//应该先直接用ArrayList和HashSet，然后才引入从配置文件读，这样便于学员学习。Properties props = new Properties();//先演示相对路径的问题//InputStream ips = new FileInputStream("config.properties");/*一个类加载器能加载.class文件，那它当然也能加载classpath环境下的其他文件，既然它有如此能力，它没有理由不顺带提供这样一个方法。它也只能加载classpath环境下的那些文件。注意：直接使用类加载器时，不能以/打头。*///InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/javaenhance/config.properties");//Class提供了一个便利方法，用加载当前类的那个类加载器去加载相同包目录下的文件//InputStream ips = ReflectTest2.class.getResourceAsStream("config.properties");InputStream ips = ReflectTest2.class.getResourceAsStream("/cn/itcast/javaenhance/config.properties");props.load(ips);Ips.close();String className = props.getProperty("className");Class clazz = Class.forName(className);Collection collection = (Collection)clazz.newInstance();//Collection collection = new ArrayList();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());}

  

用类加载器的方式管理资源和配置文件

获取配置的路径，要使用方法计算出来，getRealPath

import java.util.*; import java.io.*; public class ReflectTest2 {     public static void main(String[] args) throws Exception {         //InputStream ips = new FileInputStream("config.properties");也可以用下面的方法加载，com前不加斜杠          //InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("com/itcast/day1/config.properties");          //InputStream ips = ReflectTest2.class.getResourceAsStream("config.properties");//可以是相对目录          InputStream ips = ReflectTest2.class.getResourceAsStream("/com/itcast/day1/config.properties");//用绝对的话，必须要写上斜杠          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);         System.out.println(collections.size());     } } 

由内省引出JavaBean的讲解

 

  1、内省--IntroSpector
   2、IntroSpector-->JavaBean-->特殊的Java类
   3、符合特殊的规则，set，get
       int getAge()
       void setAge(int Age)

 

      
class Person{
    private intx;
    public intgetAge(){
       return x;
    }
    public vlidsetAge(int age){
       this.x = age;
    }
}
Age--->如果第二个单词首是小写的，则把第二个单词第一个字母编程小写的，--->age，就是原样，只是去掉get，set
gettime-->time
setTime-->Time
getCPU--->CPU
int getAge(){