Java的新技术学习之一

1.IDE：集成开发环境
Eclipse的使用操作，MyEclipse类似于插件，用于javaweb程序的开发。

 

2.可变参数
特点：只能出现在参数列表的末尾；
    ...位于变量类型和变量名之间；
调用可变参数的时候，编译器为其隐含创建一个数组，在方法中以数组形式访问可变参数。
    int add（int x，int....args）

 

3、overload（重载）和override（覆写）的区别：
方法的重写(Overriding)和重载(Overloading)是Java多态性的不同表现。重写(Overriding)

是父类与子类之间多态性的一种表现，而重载(Overloading)是一个类中多态性的一种表现。 

 如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)

。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"

了。   如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类

型或有不同的参数次序，则称为方法的重载(Overloading)。不能通过访问权限、返回类型、

抛出的异常进行重载.
那么构造方法是否重载的一种表现？

 

4.for循环增强
for（type 变量名：集合变量名）{...}

注意事项：迭代变量必须在（）中定义；
集合变量可以是数组或是是想了iterable接口的集合类。
举例：
public static int add(int x,int...args){
 int sum=0;
 for(int arg:args){
  sum+=arg;
 }
 retrun sum;
}

 

5.基本数据类型的自动装箱和拆箱
自动装箱和拆箱：
   Integer num1=12；//自动装箱
    System.out。print（num1+12）；//num1的自动拆箱

 Integer i1=12；
Integer i2=12；
两对象用“==” 比较后返回的是true，但是当值不再-128~127之间时。返回的是false。
此处体现了一个设计叫做享元模式。

享元模式：减少对象的产生。列入如果要生成一个英文单词，只需形成26个对象，相同字母的

出现可以使用同一个对象，只需设置其显示位置的方法。

 

6.枚举
枚举就是让某个类型的变量的取值只能是若干固定个值中的一个，否则，编译器就会报错；枚

举可以让编译器在编译时就可以控制源程序中填写的非法值。
java.AWT.Color类就好似典型的枚举。

基本枚举类：

public enum WeekDay{
 SUB,MON,TUE,WED,THI,FRI,SAT
}
.
实现带有构造方法的枚举：注意：所有定义的构造，发放，元素必须定义在元素列表后面

public enum WeekDay{

 SUB,MON,TUE,WED,THI,FRI,SAT；
 private WeekDay(){}
 private WeekDay(int day){}

实现带有抽象方法的枚举：

   public enum TrafficLamp{ 
 RED(30){
  public TrafficLamp nextLamp（）{
   retrun Green；
  }
 
          },
 GREEN(30){
  public TrafficLamp nextLamp（）{
   retrun Yellow；
  }

     },
 YELLOW(5){
  public TrafficLamp nextLamp（）{
   retrun RED；
  }
    }; 
 public abstract TrafficLamp netxLamp();
 private int time;
 private TrafficLamp(int time){
 this.tim=time;
 }

}

 

7、反射 就是把java类中的各种成分映射成相应的java类
反射的基础Class类
Java程序中的个各类，他们属于同一类事物，也可以用一个类来描述，既Class类。

对象获取其字节码方法，getClass（）；
也可以调用Class类的静态方法返回字节码：static Class<?> forName(String className)
          返回与带有给定字符串名的类或接口相关联的 Class 对象。

反射编程举例；
 String str1="abcd";
Class cla1=str1.getClass();
Class cla2=String.class;                       //三种获取字节码方法；
Class cla3=Class.forName("java.lang.String");
                                         //并且cla1==cla2==cla3;都是同一份字节码。
 

数组类型的Class实例对象：Class.isArray（）

构造方法的反射；
String.class.getConstructor（）；

//new String (new StringBuffer("adc"));
Constructor constructor1 =String.class.getConstructor(Stringbuffer.class);//获取构

造方法类的对象
String str2=(String)constructor1.newInatance(new String Buffer("adc"));//通过构造

方法得到string类额对象；
以上方法：class--》constructor--》new object然后（String）转型；

如果要调用不带参数的构造方法实例化对象可以直接使用以下代码：
 Srring str=（String）Class.forName（"java.lang.String"）.newInstance（）；

Filed类（类中的成员变量类）
new一个类的对象
  Student st1=new Stundet（）；
    Filed fi1=st1.getClass（）.getField（"age"）;//取得了student中的age变量
getFiled（）是获取可见的，对于私有的可以用getDeclaredFiled（）方法取得但是对象取得

时还是会报错，可以用Filed类中的setAccessible（true）方法设置成可以访问。//暴力反射

。

使用成员变量反射改掉对象中所有String类型字段中的b转化成a；
class Student{
public String name="aaaa";
pulic   String add="abcd";

覆写tostring方法；
}

public class ReflectTest{
public static void main(String [] args){

Student st1=new Student();
st1.changeChar();//调用changeChar方法；
System.out.print（st1）；

}
private static void changeChar(Object obj){
 Filed [] fields=obj.getClass().getFields();//获取Filed类中各种字段类型。用

数组存储；
 for（Filed field： fields）{ //使用for循环取得filed值；
  if（field.getType()==String.class）{//此处不用equals是应为字节码只

有一份
   String oldValue=(String)filed.get(obj);
   String newValue=oldValue.replace('b','a');//使用replace()

方法;
   filed.set(obj,newValue);

}
}

}

}

 

Method类（成员方法类）
//str.charAt(1);
Method methodCharAt =String.class.getMethod("charAt",int.class);
System.out.print(methodCharAt.invoke(str1,1));//用charAt方法取出str1中的第二个字符
   
静态方法调用不需要对象。如果invoke（null，1）就是调用静态方法

用反射的方式调用main方法：
String startingClassName= args[0];
Method mainMethod =Class.forName(startingClassName).getMethod("main",String);
mainMethod.invoke(null,(object)new String[]{"123","321","333"});

Object和数组之间的关系：
int [] a1=new int[] {1,2,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());//true
System.out.println(a1.getClass()==a4.getClass())//false
System.out.println(a1.getClass()==a3.getClass())//false
System.put.println(a1.getClass().getName());
System.put.println(a1.getClass().getSuperclass().getName());//父类都是

java.lang.Object；
System.put.println(a4.getClass().getSuperclass().getyName());

Object o1=a1;
Object o2=a4；
//Object[] o3=a1;//int类型
Object []o4=a3;
Object []o5=a4;

最后可以用Array.aslist（）方法列出其中元素。Object[];

数组的反射：

 printObject(obj);//调用方法；

private static void main printObject(Object obj){//定义一个printObject方法
 
 Class cla1=obj.getClass();
 if(cla1.isArray()){
  int len=Array.getLength(obj);//获取数组长度
  for(int i=0; i<=len;i++){//循环输出数组元素
   System.out.println(Ayyay.get(obj,i));

}else{
 System.out.print(obj);
}

}
}
ArrayList和HashSet比较。
ArrayList集合时有序集合。
HashSet放入元素时会先检查是否有元素。当放入的对象里面已经存在时就会擦去原来的对象

在放入

hashCode的作用：java的Collection中有两种类；List既有序，的可以重复的。Set无序不可

重复。那么怎么判断要放入的元素是否重复，常用的思路是使用equals方法初步判断。这样当

需要判断的元素很多时就十分缺乏效率。hashCode（）初学者可以这样理解，hashCode方法实

际上返回的就是对象存储的物理地址（实际可能并不是）。
  这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到

它应该放置的物理位置上。如果这个位置上没有元素，它就可以直接存储在这个位置上，不用

再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较

，相同的话就不存了，不相同就散列其它的地址。所以这里存在一个冲突解决的问题。这样一

来实际调用equals方法的次数就大大降低了，几乎只需要一两次。
  所以，Java对于eqauls方法和hashCode方法是这样规定的：
1、如果两个对象相同，那么它们的hashCode值一定要相同；
2、如果两个对象的hashCode相同，它们并不一定相同

不要随便修改HashCode集合中对象的值。这样会造成对象无法被remove，内存泄露。

 

8、框架的概念和反射技术开发框架的原理：
框架于工具类的区别：框架是调用用户提供的类，工具类则是被用户调用。
编程例子：
先建立一个配置文件config.properties
 
InputStream ips=new FileInputStream("config.properties") ;
Properties props= new Properties();//建立一个Properties 对象；
props.load(ips);//加载配置文件；
ips.close();//关闭输入流；
string className=props.getProperties(key);//获取里面key的值

Collection collection=（Collection）Class.forName（className）.newInstance（）；

类加载器：
InputStream ips=XXXX.class.getClassLoader（）.getResourceAsStream（文件路径）；一

般以后的开发，配置文件都放在classpath下。

 

9、内省
javaBean是特殊的java类，主要用于传递数据信息，这种java类中的方法主要用于访问私有的

字段，且方法名符合某种命名规则。
如果要在两个模块传递多个信息，可以将这些信息封装在一个JavaBean中，这种JavaBean的实

例对象称之为值对象（Value Object简称VO）
JavaBean中的属性是根据setter和getter方法来确定的，而不是根据其中的成员变量。

JavaBean的简单的内省操作：
先建立一个Student类：
class Student{
 private  String name;
 private  int age;
//定义getter和setter方法

在建立一个IntroSpectorTest类
public class IntroSpectorTest{
//main方法；
   Student st1=new Student("陈凯"，21);

String propertyName="name";
PropertyDescriptor pd=new PropertyDescriptor(propertyName,st1.getClass());
Method methodGetName=pd.getReadMethod();
Object retVal=methodGetName.invoke(st1);
System.out.print(retVal);
}

}
}