2019/9/25 学习记录

1.comparable接口

（1）实体类，实现comparable接口的CompareTo()方法：只能基于一个字段进行排序

public class Person implements Comparable<Person>

{

//重写接口方法,o为要比较的对象

     @Override

     public int compareTo(Person o) {

         //大于要比较的对象就返回1

         if(this.salary>o.getSalary()){

             return 1;

         }

         //小于则返回-1

         else if(this.salary<o.getSalary()){

             return -1;

         }

         //相等则返回0

         return 0;

     }

}

（2）排序：

List<Person> list=new ArrayList<>();

Collections.sort(list);

2.comparator接口

（1）创建实现接口的类，重写比较方法compare()

public class StaffComparator implements Comparator<Staff>

{

//不一定要自然排序即升序，可以反过来写成降序

      @Override

     public int compare(Staff o1, Staff o2) {

//先按照年龄降序，如果年龄相等比较工资

         if(o1.getAge()>o2.getAge()){

             return -1;

         }

         if(o1.getAge()<o2.getAge()){

            return 1;

         }

         //能到这里说明年龄相等，继续比较工资升序

         if(o1.getSalary()>o2.getSalary()){

             return 1;

         }

         if(o1.getSalary()<o2.getSalary()){

             return -1;

         }

         return 0;

}

参考：https://www.cnblogs.com/youngchaolin/p/11147384.html

2.抽象类：

（1）可以声明和定义构造函数

（2）可以定义普通成员变量，可以包含非抽象的普通方法，可以包含静态成员变量。

（3）可以实现接口：目的：抽象类实现接口中重复性高的基本的一些方法，子类继承后就不需要一一实现了。

（4）可以有static方法：还可以有main()方法

（5）不可以是final的

（6）不可以创建实例

（7）只需要被abstract修饰，不需要一定有抽象方法

3.接口：

（1）无构造函数，无普通成员变量，无非抽象方法，无静态方法。

（2）所有方法全是抽象的，public abstract

（3）可以定义静态成员变量，public static final

4 泛型

4.1

定义类、接口、方法、参数或成员变量的时候，指定它们操作对象的类型为通用类型。

使用 尖括号 <> 操作符 (The diamond operator )表示泛型, 尖括号内可以放置大写字母 （代表一个未知类型） 或问号 ? （代表若干个类型）作为参数。比如，习惯上选择以下字母代表某种类型：

1）T 意味某种类型  

2）E 意味链表、数组里的元素，如List<E> list 表示 list 里的元素。

3）K意味map(k,v) 里的键值 Key

4）V 意味返回或映射的值。

然而，泛型的运用要受到如下限制 ：

1）不能使用基本类型的类型参数，可以使用其包装类型代替。

2）静态成员无法使用类型参数。

3）不能使用泛型类异常

4）不能实例化泛型对象或数组，如：

         T t = new T();  T[] a=new T；

5） 不能使用泛型数组，如：

ist<String> arr[] = new ArrayList<String>[5]; //错误

6）代表若干类的，放在尖括号内的 通配符 ？：<?>，还分 上限通配符 (Upper Bounded Wildcards) 和 下限通配符 (Lower Bounded Wildcards)。

上限通配符 <?  extends  U> 可以代表这个未知类型 U，或者 通过关键字 extends 所能想象出的 U 类的任何一个子类。同样，下限通配符 <?  super  L> 可以代表这个未知类型 L，或者 通过关键字 super 所能想象出的 L类的任何一个超类。

参考：https://www.oschina.net/question/2491333_2273774

4.2 

泛型的本质是参数化类型也就是说，泛型就是将所操作的数据类型作为参数的一种语法。

public class Paly<T>{

T play(){} //T为类型参数

}

Play<Integer> playInteger=new Play<>();//T被实例化为Integer

参考：https://www.cnblogs.com/dengchengchao/p/9717097.html

4.3 泛型的使用

（1）泛型类

通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{

  private 泛型标识 /*（成员变量类型）*/ var;

  }

}

在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。

在实例化类的时候指明泛型的具体类型。

（2）泛型接口

泛型接口常被用在各种类的生产器中

//定义一个泛型接口

public interface Generator<T> {

public T next();

}

1）实现类未传入参数，需要声明为泛型类

class FruitGenerator<T> implements Generator<T>{

    @Override

    public T next() {

        return null;

    }

}

2）实现类传入参数

public class FruitGenerator implements Generator<String> {

    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

    @Override

//实现类中所有使用泛型的地方替换为传入的实参类型：String

    public String next() {

        Random rand = new Random();

        return fruits[rand.nextInt(3)];

    }

}

（3）泛型通配符<?>

类型通配符是使用？代替具体的类型实参，Number、String、Integer一样都是一种实际的类型。把？看成所有类型的父类，是一种真实的类型。

（4）泛型方法

1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。

2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。

3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。

4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。<T,K>

public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,

  IllegalAccessException{

        T instance = tClass.newInstance();

        return instance;

}

5）在泛型类中声明了一个泛型方法，使用泛型T，这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。

6）如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法 。因为静态方法无法访问类上定义的泛型。

（5）泛型的上下边界

1）泛型上边界Generic<? extends Number>，即传入的类型实参必须是指定类型的子类型。

2）泛型下边界Generic<?  super  Number>，即传入的类型实参必须是指定类型的父类型。

3）在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加

public <T extends Number> T showKeyName(Generic<T> container)

参考：https://www.cnblogs.com/coprince/p/8603492.html

5.输入流

（1）转换流读取键盘输入，并写入文件：

//以System.in作为读取的数据源，即从键盘读取

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        BufferedWriter bw = new BufferedWriter(new FileWriter(f,true)); //允许添加内容，不会清除原有数据源

        String s = null;

        while(!(s = br.readLine()).equals("")) {

            bw.write(s);

            bw.newLine();//空一行

        }

        bw.flush();       

        bw.close();

        br.close();

（2）字符流读取本地文件

BufferedReader br = new BufferedReader(new FileReader(path));//该缓冲流有一个readLine()独有方法

                String s = null;

                while ((s = br.readLine()) != null) {//readLine()每次读取一行

                    System.out.println(s);

                }

（3）字节流读取本地文件

file BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));

byte[] buf = new byte[1024];//创建字节数组，存储临时读取的数据

int len = 0;//记录数据读取的长度

 //循环读取数据

 while((len = bis.read(buf)) != -1) { //长度为-1则读取完毕

 System.out.println(new String(buf,0,len));   

}

 bis.close(); //关闭流

6.输出流

（1）字符流写入文件

Scanner sc = new Scanner(System.in);

        File f = new File("D:\\reviewIO\\WRITERTest.txt");

        BufferedWriter bw = new BufferedWriter(new FileWriter(f));

        if(!f.exists()) {

            f.createNewFile();

        }

        while(true) {

            String s = sc.nextLine();

            bw.write(s);

            bw.flush();

            if(s.equals("结束") || s.equals("")) {

                System.out.println("写入数据结束！");

                return;

            }

        }

（2）打印流写入文件

File f = new File("D:\\reviewIO\\PW.java");

        PrintWriter pw = new PrintWriter(f);

        //把指定内容打印至数据源中

        pw.println("AAAAAAAAA");

        pw.println("BBBBBBBBB");

        pw.println("CCCCCCCCC");

        pw.flush();

参考：https://www.cnblogs.com/fwnboke/p/8529492.html