Java基础

一、JAVA 异常分类及处理

如果某个方法不能按照正常的途径完成任务，就可以通过另一种路径退出方法。在这种情况下 会抛出一个封装了错误信息的对象。此时，这个方法会立刻退出同时不返回任何值。另外，调用这个方法的其他代码也无法继续执行，异常处理机制会将代码执行交给异常处理器。

Throwable 是 Java 语言中所有错误或异常的超类。下一层分为 Error 和 Exception  

Error

1. Error 类是指 java 运行时系统的内部错误和资源耗尽错误。应用程序不会抛出该类对象。如果出现了这样的错误，除了告知用户，剩下的就是尽力使程序安全的终止。

Exception（RuntimeException、CheckedException）

2. Exception又有两个分支 ， 一个是运行时异常 RuntimeException ， 一个是 CheckedException。

RuntimeException 如 ： NullPointerException 、ClassCastException；RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。如果出现 RuntimeException，那么一定是程序的错误.。

CheckedException：一般是外部错误，这种异常都发生在编译阶段，Java 编译器会强制程序去捕获此类异常，即会出现要求你把这段可能出现异常的程序进行 try catch。

二、反射

动态语言，是指程序在运行时可以改变其结构：新的函数可以引进，已有的函数可以被删除等结构上的变化。比如常见的 JavaScript 就是动态语言，除此之外 Ruby,Python 等也属于动态语言， 而 C、C++则不属于动态语言。从反射角度说 JAVA 属于半动态语言。在 Java 中的反射机制是指在运行状态中，对于任意一个类都能够知道这个类所有的属性和方法； 并且对于任意一个对象，都能够调用它的任意一个方法；这种动态获取信息以及动态调用对象方 法的功能成为 Java 语言的反射机制。

在 Java 程序中许多对象在运行是都会出现两种类型：编译时类型和运行时类型。 编译时的类型由声明对象时实用的类型来决定，运行时的类型由实际赋值给对象的类型决定 。如：

Person p = new Student();
其中编译时类型为 Person，运行时类型为 Student。

有时候，程序在运行时还可能接收到外部传入的对象，该对象的编译时类型为 Object,但是程序有需要调用该对象的运行时类型的方法。为了解决这些问题，程序需要在运行时发现对象和类的真实信息。然而，如果编译时根本无法预知该对象和类属于哪些类，程序只能依靠运行时信息来发现该对象和类的真实信息，此时就必须使用到反射了。

package com.example.collection;

public class User {
private int userid;
private String username;

public User() {
}

public User(int userid, String username) {

this.userid = userid;
this.username = username;
}

public int getUserid() {

return userid;
}

public void setUserid(int userid) {
this.userid = userid;
}

public String getUsername() {
return username;
}

public void setUsername(String username) {
this.username = username;
}

public void sayHello() {
System.out.println("sayHello");
}

protected void sayGoodBye() {
System.out.println("good bye");
}

private void makeFriend(User user) {
System.out.println("I am making friend with " + user.getUsername());
}

@Override
public String toString() {
return "User{" +
"userid=" + userid +
", username='" + username + '\'' +
'}';
}
}
package com.example.collection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Date;

public class Main {
public static void main1() {
try {
Class clazz = Class.forName("com.example.collection.User");
// Class.newInstance 方法创建对象 必须有默认构造方法
User user1 = (User)clazz.newInstance();
System.out.println(user1);
Constructor constructor = clazz.getDeclaredConstructor(int.class,String.class);
// Constructor.newInstance 方法创建对象
User user2 = (User)constructor.newInstance(1,"username");
System.out.println(user2);

} catch (Exception e) {
e.printStackTrace();
}
}


public static void main(String[] args) {
try {
Class clazz = Class.forName("com.example.collection.User");
// 获取所有的方法
Method[] methods = clazz.getDeclaredMethods();
for (Method method :
methods) {
System.out.println(method.toString());
}
// 获取所有的属性
Field[] fields = clazz.getDeclaredFields();
for (Field field:
fields) {
System.out.println(field.toString());
}
// 获取所有的构造方法
Constructor[] constructors = clazz.getDeclaredConstructors();
for (Constructor constructor :
constructors) {
System.out.println(constructor.toString());
}
} catch (Exception e) {
e.printStackTrace();
}

}
}
三、内部类

Java 类中不仅可以定义变量和方法，还可以定义类，这样定义在类内部的类就被称为内部类。根据定义的方式不同，内部类分为静态内部类，成员内部类，局部内部类，匿名内部类四种。

静态内部类

1.静态内部类可以访问外部类所有的静态变量和方法，即使是 private 的也一样。

2. 静态内部类和一般类一致，可以定义静态变量、方法，构造方法等。

3. 其它类使用静态内部类需要使用“外部类.静态内部类”方式，如下所示：Out.Inner inner = new Out.Inner();inner.print();

4. Java集合类HashMap内部就有一个静态内部类Entry。Entry是HashMap存放元素的抽象，HashMap 内部维护 Entry 数组用了存放元素，但是 Entry 对使用者是透明的。像这种和外部类关系密切的，且不依赖外部类实例的，都可以使用静态内部类。

package com.example.collection;

public class OutClass {
private static int i = 10;
private int j;
protected static class Inner{
private int a;
protected static int b = 20;
public void setA(int a){
this.a = a;
}
public int getA(){
return a;
}
public void getParentI(){
System.out.println(i);
}
}
}
package com.example.collection;

public class Main {
public static void main(String[] args) {
OutClass.Inner inner = new OutClass.Inner();
inner.getParentI();
inner.setA(55);
System.out.println(inner.getA());
System.out.println(inner.b);
}
}
 

成员内部类

定义在类内部的非静态类，就是成员内部类。成员内部类不能定义静态方法和变量（final 修饰的除外）。这是因为成员内部类是非静态的，类初始化的时候先初始化静态成员，如果允许成员内部类定义静态变量，那么成员内部类的静态变量初始化顺序是有歧义的。

局部内部类

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

匿名内部类

匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一个接口。同时它也是没有 class 关键字，这是因为匿名内部类是直接使用 new 来生成一个对象的引用。

//让按钮具备关闭窗口的功能
JButton bt = new JButton();
bt.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
System.out.println("按钮执行关闭窗口的功能");
System.exit(0);
}
});
四、泛型

泛型方法

package com.example.collection;

public class General {

public static <E> void printElement(E[] array){
for (E e:
array) {
System.out.println(e.toString());
}
}
}
package com.example.collection;

import java.util.Date;
import java.util.Random;

public class Main {
public static void main(String[] args) {
String[] strings = {"1","2","34"};
Integer[] ints = {45,6,3};
General.printElement(strings);
General.printElement(ints);
}

}
 <? extends T>表示该通配符所代表的类型是 T 类型的子类。

 <? super T>表示该通配符所代表的类型是 T 类型的父类。

泛型类

泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。

public class Box<T> {
private T t;
public void add(T t) {
this.t = t;
}
public T get(http://www.my516.com) {
return t;
}
}
 

类型通配符?

类型通配符一般是使用 ? 代 替 具 体 的 类 型 参 数 。 例 如 List<?> 在逻辑上是List<String>,List<Integer> 等所有 List<具体类型实参>的父类，

类型擦除

Java 中的泛型基本上都是在编译器这个层次来实现的。在生成的 Java 字节代码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会被编译器在编译的时候去掉。这个过程就称为类型擦除。如在代码中定义的 List<Object>和 List<String>等类型，在编译之后都会变成 List。JVM 看到的只是 List，而由泛型附加的类型信息对 JVM 来说是不可见的。

类型擦除的基本过程也比较简单，首先是找到用来替换类型参数的具体类。这个具体类一般是 Object。如果指定了类型参数的上界的话，则使用这个上界。把代码中的类型参数都替换 成具体的类。

 
---------------------