java基础

2020-04-13  本文已影响0人  jiahzhon

throw、throws

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

JAVA 反射：

注解

 /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 "大雁";
   }
   });
 } }

泛型

 // 泛型方法 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 类型的父类。
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());
}

解释：ArrayList和list的关系是：

　　public interface List<E> 

　　public class ArrayList<E> implements List<E>

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

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

上一篇下一篇

猜你喜欢

热点阅读