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

最新推荐文章于 2021-04-14 22:19:36 发布

start_zhang

最新推荐文章于 2021-04-14 22:19:36 发布

阅读量583

点赞数

分类专栏：黑马程序员

本文链接：https://blog.youkuaiyun.com/start_zhang/article/details/19832971

版权

黑马程序员专栏收录该内容

12 篇文章

订阅专栏

---------------------- 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过后的新特性

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

泛型中的专业术语:

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培训、期待与您交流！----------------------