黑马程序员---5.0新特性

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

本篇主要是对java 5.0后的新特性进行讲解，面试中也经常问起。  

静态导入：是5.0过后的新特性

          import static java.lang.Math.*;导入类下所有的静态方法。

     import static java.lang.Math.Max;导入类下某一个的静态方法

     

     方法使用：

      import static java.lang.Math.*;

       public class test {

       //静态导入

       public  static   void main(String[] args){

            System. out.println(((random()*10)+ "").substring(2,8));     

      }

     }

     

可变参数：是5.0过后的新特性，也称之为动态传参。

  

    可变参数特点：

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

      ...位于变量类型与变量之间，前后有无空格都可以。

      调用可变参数时，编译器创建一个隐含的可变数组，以数组的形式的去访问。

      

   overload：重载：一个类中，多个方法名相同，但其中参数类型或参数顺序有所不同。

   override：重写：是父类与子类多态性的一种体现。如果子类定义的方法与父类有相同的参数和名称，我们称之       为重写。子类的对象调用使用这个方法时，将调用子类的定义，对他而言，父类中的定义如图被屏蔽了。

 

  Demo：

public static void main(String[] args) {
public static void main(String[] args) {
System. out.println(getSum(0, 2));
System. out.println(getSum(5,2,8));
}
/**
* 求参数相加的和
* 以数组的形式去访问那个可变参数
* @return
*/
public static int getSum( int a,int ...args){

int sum=a;
for(int i=0;i<args.length;i++){
sum+=args[i];
}
return sum;
}

System. out.println(getSum(0, 2));
System. out.println(getSum(5,2,8));
}
/**
* 求参数相加的和
* 以数组的形式去访问那个可变参数
* @return
*/
public static int getSum( int a,int ...args){

int sum=a;
for(int i=0;i<args.length;i++){
sum+=args[i];
}
return sum;
}

 

增强for循环：是5.0过后的新特性

  格式：for(数据类型 变量 : 被遍历集合或数组){

                执行语句

       }

  传统for和高级for的区别：  

       高级for有一个局限性。必须有被遍历的目标（集合或数组）。  

       传统for遍历数组时有索引。   

建议在遍历数组的时候，还是希望使用传统for。因为传统for可以定义角标。  

注意：变量类型前可加修饰符，如final（可被局部内部类访问到）

枚举：是5.0过后的新特性

概念：就是某个类型的变量只能为若干个固定值中的一个，否则编译将会报错。

枚举可以让编译器在编译时控制源程序填写的值非法写入。普通变量不能实现这一目标。

可以把枚举看成一个类，枚举元素必须位于方法最开始部分。

枚举的构造方法要用private，为什么呢？防止被实例化。

publicclass EnumTest {
public static void main(String[] args){
Lamp lamp=Lamp. YELLOW;
System.out.println(lamp.nextLamp());
}
public enum Lamp{
RAD {
@Override
public Lamp nextLamp() {
return GREEN ;
}
},
GREEN{
@Override
public Lamp nextLamp() {
return YELLOW ;
}
},
YELLOW
{
@Override
public Lamp nextLamp() {
// TODO Auto-generatedmethod stub
return RAD ;
}
};
// 定义一个内部的抽象方法实现灯之间的切换
public abstract Lamp nextLamp();
}
}

 

自动装箱和拆箱：是5.0过后的新特性

 

java中数据类型分为两种：基本数据类型   引用数据类型

Integer a=1; 装箱  int b=a+2;拆箱

Integer x=1;  Integer  y=1; x==y //true

Integer x=139;  Integer y=139;  x==y //false

为什么呢？因为对于基本数据类型，自动装箱会把-127~128间的数据缓存起来，下一次从缓存池中获取。

这种模式称之为享元设计模式。

享元模式概念：就是把很多小的对象，他们有很多相同的属性，把他们变成一个对象。那些不同的属性把他们变成参数，称之为外部状态，相同的属性称之为内部状态。

 

类加载器：

 

类加载器作用：java虚拟机会把类的字节码从硬盘以二进制形式加载到内存中来。

java虚拟机可以安装多个类加载器。系统默认三个主要类加载器，分别负责加载特定位置的类。他们是BootStrap,ExtClassLoader,AppClassLoader.

类加载器也是java类，显然有第一个类加载器不是java类，他就是BootStrap.System类就是由它加载。

 

类加载器的委托机制：

当java虚拟机需要加载一个类时,到底派哪一个类加载器去加载呢？？

1、首先当前线程的类加载器去加载线程中的第一个类。

2、如果类A引用了类B，那么java虚拟机将使用加载类A的类加载器去加载类B。

3、还可以调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。

每个类加载器加载类时，又先委托上一级。当所有类加载器没有加载到类时，此时返回发起者类加载器，抛出ClassNotFoundException类找不到异常。

有道面试题：可不可以让我们自己写个类叫做java.lang.System呢？回答：通常不可以，因为当类加载器加载到BootStrap时，它会自动找到rt.jar包下的System类，所以我们自己写的根本就不会加载，如果要加载可以自定义一个加载类去做特定的加载。

 

泛型：是5.0过后的新特性

 

泛型用于编译过程中，检查开发者的非法输入。

泛型中的专业术语
4000
:

ArrayList<E>类定义和ArrayList<Integer>类引用中的术语:

1.       这个称谓ArrayList<E>泛型类型

2.       整个ArrayList<E>中的E称为类型变量或类型参数

3.       整个ArrayList<Integer>称为参数化类型

4.       ArrayList<Integer>中的Integer称谓类型参数的实例或者实际类型参数

5.       ArrayList<Integer>中的<>念typeof

6.       ArrayList称为原始类型

demo1：

packagecn.itheima.reflect;

importjava.util.ArrayList;

publicclass GenericTest {

/**
* @param ArrayList list = newArrayList();
* 在这个泛型为Integer的ArrayList中存放一个String类型的对象
*/
public static void main(String[] args)throws Exception{
ArrayList<Integer> alList=new ArrayList<Integer>();
//利用反射的方式透过编译器 添加
alList.getClass().getMethod("add" , Object.class ).invoke(alList, "abcd" );
alList.getClass().getMethod("add" , Object.class ).invoke(alList, "abcd1" );
for (Object object : alList){
System. out.println(object);
}
printCollenct(alList);
Object obj= "hao are you" ;
String str= autoConvert(obj);
System. out .println("类型强制装换：" +str);
Copy( new String[10], newInteger[10]);

}
//参数化类型通配符使用
public static void printCollenct(ArrayList<?> list){
//list.add(1);这里不能够调用带类型的参数方法.可以调用list.size();因为该方法不带类型
for (Object object :list){
System. out.println("--" +object);
}
}

public static <T> TautoConvert(Object obj){
return (T) obj;
}
public static <T> void Copy(T[]a,T[] b){

}
public void add(){
//autoConvert( obj)
}

}

 

demo2：泛型综合使用，也是开发中常见方式。

packagecn.itheima.reflect;

importjava.util.HashMap;
importjava.util.Map;
importjava.util.Set;

publicclass GenericTest2 {

/**
* Map类提供了一个称为entrySet()的方法，这个方法返回一个Map.Entry实例化后的对象集。
* 接着，Map.Entry类提供了一个getKey()方法和一个getValue()方法
*/
public static void main(String[] args) {
Person p1=new Person("zd",21);
Person p2=newPerson("lisi", 23);
HashMap<String, Person> maps=new HashMap<String, Person>();
maps.put("0", p1);
maps.put("1", p2);
//注意 这里map集合不能够进行直接迭代，所以要装换成set集合
//通过Map.Entry<>实例来遍历
Set<Map.Entry<String,Person>> entry=maps.entrySet();
for(Map.Entry<String,Person>enMap : entry){
System.out.println(enMap.getKey() + ":" +enMap.getValue().getName());
Person p3=enMap.getValue();
// System.out.println(enMap.getKey()+":"+p3.getName());
}

}

}
classPerson{

private String name;
private int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}

}

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

 

[align=left]
[/align]