java基础

throw、throws

• 位置不用：
  • throws 用在函数上，后面跟的是异常类，可以跟多个；而 throw 用在函数内，后面跟的是异常对象。
• 功能不用：
  • throws 用来声明异常，让调用者只知道该功能可能出现的问题。throw 抛出具体的问题对象，执行到 throw，功能就已经结束了。
  • throws 表示出现异常的一种可能性。throw 则是抛出了异常，执行 throw 则一定抛出了某种异常对象。

两者都是消极处理异常的方式，只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。

JAVA 反射：

• 概念：
  • 在运行状态中，对于任意一个类都能够知道这个类所有的属性和方法；并且对于任意一个对象，都能够调用它的任意一个方法；这种动态获取信息以及动态调用对象方法的功能成为 Java 语言的反射机制。
• 应用场合：
  • 编译时类型和运行时类型
    • Person p=new Student();
    • 编译时的类型由声明对象时实用的类型来决定，运行时的类型由实际赋值给对象的类型决定 。
    • 该对象的编译时类型为 Object,但是程序有需要调用该对象的运行时类型的方法。为了解决这些问题，程序需要在运行时发现对象和类的真实信息。然而，如果编译时根本无法预知该对象和类属于哪些类，程序只能依靠运行时信息来发现该对象和类的真实信息，此时就必须使用到反射了。
• 角色：
  • Class 类：反射的核心类，可以获取类的属性，方法等信息。
  • Field 类：Java.lang.reflec 包中的类，表示类的成员变量，可以用来获取和设置类之中的属性值。
  • Method 类： Java.lang.reflec 包中的类，表示类的方法，它可以用来获取类中的方法信息或者执行方法。
  • Constructor 类： Java.lang.reflec 包中的类，表示类的构造方法。
• 创建对象的两种方法 :
  • Class 对象的 newInstance() :
    • 使用 Class 对象的 newInstance()方法来创建该 Class 对象对应类的实例，但是这种方法要求
      该 Class 对象对应的类有默认的空构造器。
  • 调用 Constructor 对象的 newInstance() :
    • 先使用 Class 对象获取指定的 Constructor 对象，再调用 Constructor 对象的 newInstance()
      方法来创建 Class 对象对应类的实例,通过这种方法可以选定构造方法创建实例。

注解

• 概念：
  • Annotation(注解)是一个接口，程序可以通过反射来获取指定程序中元素的 Annotation对象，然后通过该 Annotation 对象来获取注解中的元数据信息。
• 4 种标准元注解：

  • @Target 修饰的对象范围

    • @Target说明了Annotation所修饰的对象范围： Annotation可被用于 packages、types（类、
      接口、枚举、Annotation 类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数
      和本地变量（如循环变量、catch 参数）。

  • @Retention 定义 被保留的时间长短

    • SOURCE:在源文件中有效（即源文件保留）
    • CLASS:在 class 文件中有效（即 class 保留）
    • RUNTIME:在运行时有效（即运行时保留）

  • @Documented 描述-javadoc

  • @Inherited 阐述了某个被标注的类型是被继承的

    • @Inherited 阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited 修饰的 annotation 类型被用于一个 class，则这个 annotation 将被用于该class 的子类。
• 注解处理器：

 /1：*** 定义注解*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FruitProvider {
 /**供应商编号*/
public int id() default -1;
/*** 供应商名称*/
 public String name() default ""；
13/04/2018 Page 108 of 283
 /** * 供应商地址*/
 public String address() default "";
}

//2：注解使用
public class Apple {
 @FruitProvider(id = 1, name = "陕西红富士集团", address = "陕西省西安市延安路")
 private String appleProvider;
 public void setAppleProvider(String appleProvider) {
 this.appleProvider = appleProvider;
 }
 public String getAppleProvider() {
 return appleProvider;
 } }

/3：*********** 注解处理器 ***************/
public class FruitInfoUtil {
 public static void getFruitInfo(Class<?> clazz) {
 String strFruitProvicer = "供应商信息：";
 Field[] fields = clazz.getDeclaredFields();//通过反射获取处理注解
 for (Field field : fields) {
 if (field.isAnnotationPresent(FruitProvider.class)) {
 FruitProvider fruitProvider = (FruitProvider) field.getAnnotation(FruitProvider.class);
//注解信息的处理地方 
strFruitProvicer = " 供应商编号：" + fruitProvider.id() + " 供应商名称："
 + fruitProvider.name() + " 供应商地址："+ fruitProvider.address();
 System.out.println(strFruitProvicer);
 }
 }
 } }

public class FruitRun {
 public static void main(String[] args) {
 FruitInfoUtil.getFruitInfo(Apple.class);
/***********输出结果***************/
// 供应商编号：1 供应商名称：陕西红富士集团 供应商地址：陕西省西安市延
 } }

内部类

• 分类：为静态内部类，成员内部类，局部内部类，匿名内部类
• 静态内部类

 public class Out {
 private static int a;
 private int b;
 public static class Inner {
  public void print() {
   System.out.println(a);
  }
 } }

1. 静态内部类可以访问外部类所有的静态变量和方法，即使是 private 的也一样。
2. 静态内部类和一般类一致，可以定义静态变量、方法，构造方法等。
3. 其它类使用静态内部类需要使用“外部类.静态内部类”方式，如下所示：Out.Inner inner = new Out.Inner();inner.print();
4. Java集合类HashMap内部就有一个静态内部类Entry。Entry是HashMap存放元素的抽象，HashMap 内部维护 Entry 数组用了存放元素，但是 Entry 对使用者是透明的。像这种和外部类关系密切的，且不依赖外部类实例的，都可以使用静态内部类。

• 成员内部类
  • 定义在类内部的非静态类，就是成员内部类。

 public class Out {
 private static int a;
 private int b;
 public class Inner {
   public void print() {
   System.out.println(a);
   System.out.println(b);
 }
 } }

1、变量和方法不能声明为静态的。(类的编译顺序：外部类--静态方法或属性--内部类)类初始化的时候先初始化静态成员，如果允许成员内部类定义静态变量，那么成员内部类的静态变量初始化顺序是有歧义的。
2、实例化的时候需要依附在外部类上面。比如：B是A的非静态内部类，实例化B，则：A.B b = new A().new B();
3、成员内部类可以引用外部类的静态或者非静态属性或者方法。

局部内部类（定义在方法中的类）

定义在方法中的类，就是局部类。如果一个类只在某个方法中使用，则可以考虑使用局部类。

 public class Out {
 private static int a;
 private int b;
 public void test(final int c) {
 final int d = 1;
 class Inner {
   public void print() {
   System.out.println(c);
   }
 }
 } }

1. 不能使用任何的访问修饰符。
2. 会生成两个.class文件，一个是Outer.class ，另一个是Outer$LocalInner.class。
3. 局部内部类只能访问方法中声明的final类型的变量。这个原因是由于method方法调用完毕之后就从栈中弹出了，但是这个时候由于局部内部类中使用了这个方法中的局部变量，而这个类还是不会立即回收的，所以只能将局部变量声明为final，表示常量。

匿名内部类（要继承一个父类或者实现一个接口、直接使用new 来生成一个对象的引用）

 public abstract class Bird {
   private String name;
   public String getName() {
     return name;
   }
 public void setName(String name) {
   this.name = name;
 }
 public abstract int fly();
}

public class Test {
 public void test(Bird bird){
   System.out.println(bird.getName() + "能够飞 " + bird.fly() + "米");
 }
 public static void main(String[] args) {
   Test test = new Test();
   test.test(new Bird() {
   public int fly() {
     return 10000;
   }
   public String getName() {
     return "大雁";
   }
   });
 } }

泛型

• 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本
  质是参数化类型，也就是说所操作的数据类型被指定为一个参数。比如我们要写一个排序方法，
  能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，我们就可以使用 Java 泛型。
• 泛型方法（<E>）
  09221852-b0d764f4340946baa1a063da5a0d993e.png

 // 泛型方法 printArray 
 public static < E > void printArray( E[] inputArray )
 { 
   for ( E element : inputArray ){ 
     System.out.printf( "%s ", element );
   }
 }

1. 使用泛型方法时通常不需要指明参数类型,因为编译器会为我们找出具体的类型,这称为参数类型推断。
2. <? extends T>表示该通配符所代表的类型是 T 类型的子类。
3. <? super T>表示该通配符所代表的类型是 T 类型的父类。

• 泛型类<T>

public class A<T> { // 泛型类：定义类的时候指定类型形参T，在类里面T就可以当成类型使用
    private T a;

    public T getA() {
        return a;
    }

    public void setA(T a) {
        this.a = a;
    }
}

• 继承泛型类的几种方式

class B1 extends A<String> {}

class B2<E> extends A<String> {}

class B3<E> extends A<E> {}

class B4<E1, E2> extends A<E1> {}

public static void main(String[] args) {
    B1 b1 = new B1();
    b1.setA("b1");
    System.out.println(b1.getA());
    
    A<String> a1 = new B1();
    a1.setA("a1");
    System.out.println(a1.getA());
    
    //B2<?> b2 = new B2<String>();
    //B2<String> b2：声明变量时已经指定了B2的类型形参E为String，
    //new B2<>()：创建对象时可以使用菱形语法（泛型推断）
    B2<String> b2 = new B2<>();//菱形语法
    b2.setA("b2");
    System.out.println(b2.getA());
    
    // 无法通过A<String>推断出B2的类型形参E的类型，不可以使用菱形语法
    A<String> a2 = new B2<Object>();
    a2.setA("a2");
    System.out.println(a2.getA());
    
    B3<String> b3 = new B3<>();//菱形语法
    b3.setA("b3");
    System.out.println(b3.getA());
    
    A<String> a3 = new B3<>();//菱形语法
    a3.setA("a3");
    System.out.println(a3.getA());
}

• JDK7新特性：菱形语法（泛型推断）
  • 菱形语法（泛型推断）：从JDK 7 开始，Java允许在构造器后不需要带完整的泛型信息，只要给出一对尖括号<>即可，Java可以推断出尖括号里面应该是什么类型。
  • 比如：List<String> list = new ArrayList<>();

解释：ArrayList和list的关系是：

　　public interface List<E> 

　　public class ArrayList<E> implements List<E>

　　左边List<String> list定义变量时已经指定了ArrayList类型形参E为String，所以通过泛型推断知道new ArrayList<>()的尖括号里面类型是String

JAVA 序列化(创建可复用的 Java 对象)

• 保存(持久化)对象及其状态到内存或者磁盘
  • Java 平台允许我们在内存中创建可复用的 Java 对象，但一般情况下，只有当 JVM 处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比 JVM 的生命周期更长。但在现实应用中，就可能要求在JVM停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象。Java 对象序列化就能够帮助我们实现该功能。
• 序列化对象以字节数组保持-静态成员不保存
  • 使用 Java 对象序列化，在保存对象时，会把其状态保存为一组字节，在未来，再将这些字节组装成对象。必须注意地是，对象序列化保存的是对象的”状态”，即它的成员变量。由此可知，对象序列化不会关注类中的静态变量。
• 序列化用户远程对象传输
  • 除了在持久化对象时会用到对象序列化之外，当使用 RMI(远程方法调用)，或在网络中传递对象时，都会用到对象序列化。Java序列化API为处理对象序列化提供了一个标准机制，该API简单易用。
• Transient 关键字阻止该变量被序列化到文件中