Java异常 equals，接口转对象可以。、反射机制

 

Throwable
Error
Exception
编译时异常(checked)
IOException/FileNotFoundException
SQLException
ClassNotFoundException

运行时异常(unchecked, RuntimeException)
NullPointerException
AirthmeticException
ArrayIndexOutOfBoundsException
ClassCastException
NumberFormatException
InputMismatchException

 

//Java8新特性：
try {

} catch (SQLException | IOException e) {
  e.printStackTrace();
}

 

//重写equals方法，放到集合重点的对象需要重写equals方法
public boolean equals(Object o) {
  if (null == o || !(o instanceof User)) return false;
  if (o == this) return true;

  User user = (User)o;
  return user.name.equals(this.name);
}

//放到HashMap和HashSet中的元素都时需要重写hashCode和equals
//hashCode值决定HashMap底层分布是否均匀
//HashMap底层是数组和链表。
//HashMap底层是将链表散列分布在数组上。
//HashMap扩容源码中的加载因子有关 达到75%时自动扩容,扩容是2倍。
//ArrayList在数组中添加元素时，不够才去扩容1.5倍。
//JDK8中 HashMap如果哈希表中单向链表数据数据大于8时，会将单向链表变成红黑树数据结构。
//如果红黑树节点数量小于6时会重新变回单向链表。初始化容量16，默认加载因子.75,扩容是2倍
HashMap的key和value可以为null
Hashtable的key和value不可以为null
//放在TreeSet集合中的元素需要实现java.lang.Comparable接口
按年龄再按姓名排序
方法一：（只有一个比较参数时使用）
class Vip implements Comparable<Vip> {
private int age;
private String name;
public int comparedTo(Vip v){
  if (this.age == v.age) {//年龄一样
    return this.name.compareTo(v.name);
  } else {//年龄不一样
    return this.age - v.age;
  }
}
}
方法二：比较器（多个比较参数时使用）
public class Vip2 {
　　private int age;
}
//比较器
class Vip2Comparator implements Comparator<Vip2> {
  public int compare(Vip2 v1, Vip2 v2){
    return v1.age - v2.age;
  }
}

Collections.synchronizedList(list);//保证list线程安全

Collections.synchronizedMap();

Collections、Collectors.toList()

Iterable
Collection
List
ArrayList
LinkedList
Vector
Set
HashSet
SortedSet - TreeSet


Map
HashMap
Hashtable - Properties
SortedMap - TreeMap

 二叉树

 

 

 

特别注意的一个流：RandomAccessFile
流向：输入流，输出流
数据单位：字节流，字符流
流的角色：节点流（通过构造方法直接读取文件的流叫做节点流），处理流（流上面包一个流）
java.io.*
四大家族都是抽象类：
字节流
java.io.Inputstream 字节输入流
java.io.Outputstream 字节输出流

字符流
java.io.Reader 字符输入流
java.io.Writer 字符输出流

输出流都要flush
输入流和输出流都要close

这四个是节点流：

文件专属
//文本文件，二进制文件，图片，音频，视频等
FileInputStream //byte bytes = new byte[1024*1024] //1M
FileOutputStream
//文本文件
FileReader //char chars = new char[4]
FileWriter

这2个是处理流
转换流（将字节流转字符流）
InputStreamReader
OutputStreamWriter

缓冲流专属
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter

数据流专属
DataInputStream
DataOutputStream

对象流专属
ObjectInputStream
ObjectOutputStream

标准输出流
PrintStream
PrintWriter

//FileInputStream/FileOutputStream
byte buffer = new byte[1024*1024];
int data = 0;
while((data = fis.read(buffer)) != -1) {
  fos.write(buffer, 0, data);
}
fos.flush
fis.close/fos.close需要单独try catch

//BufferedReader/BufferedWriter
BufferedReader br = new BufferedReader(new FileReader("Copy02.java");
BufferedWriter bw = new BufferedWriter(new FileWriter("Copy02_bak.java");
String data = null;
while((data = br.readLine()) != null) {
  bw.write(data);
}
bw.flush
bw.close/br.close单独try catch

private transient String name; //transient游离的属性，name不参与序列号
private static final long serialVersionUID = 1L;

 byte short int long float double char boolean

Set<Integer> key = map.keySet();
        Iterator<Integer> iterator = key.iterator();
        while (iterator.hasNext()) {
            String value = map.get(iterator.next());
            System.out.println(value);
        }

        Set<Map.Entry<Integer, String>> set = map.entrySet();
        Iterator<Map.Entry<Integer, String>> it2 = set.iterator();
        while (it2.hasNext()) {
            Map.Entry<Integer, String> map2 = it2.next();
            System.out.println(map2.getKey() + "=" + map2.getValue());
        }

        PrintStream ps = System.out;
        ps.println("dsfldsjflsfs");
        ps.println("dkfjsljfdlkjslf");
        ps.println("d--------------------");

//写入日志：
        PrintStream ps2 = new PrintStream(new FileOutputStream("log"));
        System.setOut(ps2);
        ps2.println("djflsjflss");
        ps2.println("dkfjsldjfsd");
        ps2.println("--------------------");
        System.out.println("000000000000000000");

============================================================= 

 

 UDP客户端和服务器端

 

 

 

 

 

 ======================================================

java.lang.Class
java.lang.reflect.Method
java.lang.reflect.Constructor
java.lang.reflect.Field

获取Class的3种方式：
Class z = new Date().getClass();
Class z = Class.forName("完整的包路径和类名");
Class z = String.class;


z.newInstance()//调用的是无参的构造方法，必须保证无参构造方法的存在

属性调用
Class.forName(类名)调用时 类加载代表类的静态代码块会执行，如果只想加载静态代码块可以这样做。例如：Class.forName("oracle.jdbc.driver.OracleDriver");加载数据库驱动
Class student = Class.forName("com.cn86trading.test.Student");
Object obj = student.newInstance();
Modifier.toString(student.getModifiers());//获取修饰符
student.getSimpleName();//

Field[] fields = student.getDeclaredFields();
for (Field field: fs) {
int i = field.getModifiers();
System.out.println(Modifier.toString(i);
Class fieldType = field.getType();
System.out.println(fieldType.getSimpleName());
System.out.println(field.getName());
}
Field f = student.getDeclaredField("no");
f.setAccessible(true);//打破封装，可以访问私有属性
f.set(obj, 2222);
System.out.println(f..get(obj);

方法调用
Method loginMethod = student.getDeclaredMethod("login, String.class, String.class);
Object retValue = loginMethod.invoke(obj, "admin", "123");
System.out.println(retValue);

构造函数调用
Constructor con = student.getDeclaredConstructor(int.class, String.class, String.class, boolean.class);
Object newObj = con.newInstance(110, "jackson", "1990-10-10", true);
System.out.println(newObj);
Constructor con2 = student.getDeclaredConstructor();
Object newObj2 = con2.newInstance();
System.out.println(newObj2);

获取父类接口
Class superClass = student.getSuperclass();
System.out.println(superClass.getName());
//获取实现的所有接口，一个类可以实现多个接口
Class[] interfaces = student.getInterfaces();
for (Class in : interfaces){
  System.out.println(in.getName());
}

反射获取类注解
if (student.isAnnotationPresent(MyAnnotation.class)) {//判断类上面是否有注解， 
  MyAnnotation myAnnotation = (MyAnnotation)student.getAnnotation(MyAnnotation.class);
  String value = myAnnotation.value();
  System.out.println(myAnnotation);
}
Method doSomeMethod = student.getDeclaredMethod("doSome");//方法名
if (doSomeMethod.isAnnotationPresent(MyAnnotation.class)){
  MyAnnotation myAnnotation = doSomeMethod.getAnnotation(MyAnnotation.class);
  System.out.println(myAnnotation.username());
  System.out.println(myAnnotation.password());
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)//这样才能被反射读取。
public @inteface MyAnnotation {
　　String value() default "北京大兴区";
}

src路径即类路径
//方法一：
String path = Thread.currentThread().getContextClassLoader().getResource("db.properties").getPath();//（获取的是类路径下的绝对路径）
FileReader reader = new FileReader(path)
//放法二(推荐)：
InputStream reader = Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties");
//ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
//reader = classLoader.getResourceAsStream("jdbc.properties");
Properties pro = new Properties();
pro.load(reader);
reader.close();
String className = pro.getProperty("className");
System.out.println(className);

Thread.currentThread().getContextClassLoader().getResource("com/cn86trading/test/db.properties").getPath();//（获取的是类路径下的绝对路径）

//复习：
FileInputStream/FileOutputStream/FileReader/FileWriter默认获取的是项目的上一个目录的路径（workspace）不通用。

启动类加载器 rt.jar
扩展类加载器 ext目录
应用类加载器 classpath目录

//文件只能放到类路径下classpath://
ResourceBundle bundle = ResourceBundle.getBundle("db");//不能写扩展名。默认加载.properties文件，只能加载这种文件
String className = bundle.getString("className");
System.out.println(className);

注解定义：
定义：[修饰符列表] @interface 注解类型名{}
使用：@注解类型名
可以出现类，属性，方法，变量上，注解还可以出现在注解类型上
@Deprecated 过期注解
@Override//编译期检查。运行期没有。
元注解：用来标注“注解类型”的注解。 
@Target 被标注的注解可以出现在哪些位置上(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, MODULE, PARAMETER, TYPE})
@Retention(RetentionPolicy.SOURCE) 该标注只被保留在java源文件中。
@Retention(RetentionPolicy.CLASS) 该标注只被保留在class文件中。
@Retention(RetentionPolicy.RUNTIME) 该标注只被保留在class文件中,并可被反射机制调用。

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override{}

 

 

 

 

 

 

 

 

 

动态代理：