面向对象，集合，反射，IO

一、面向对象

什么是面向过程

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了（百度百科）。

C语言是典型的面向过程的编程语言。在C语言中，你就是上帝（主函数就是上帝意志的体现…），你把想做的事“封装”成一个一个函数模块，然后在主函数中通过调用不同的函数完成不同的功能，最后达到你想到的效果（得到你想要的输出）。

如：定义一个 Student 结构体，然后定义一个study函数。在主函数中调用study函数，打印“XXX is studying ! ”语句。

有人说，面向对象就是结构体里面包含了函数，好像对也好像不对：面向对象编程确实把数据（属性）和函数（方法）放到了一块，但是它还有许许多多面向过程编程没有的特性。

什么是面向对象

面向对象就是是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为（百度百科）。

JAVA是典型的面向对象编程语言之一。在JAVA（或者说面向对象编程语言）中，你还是上帝，但是你是一个“简政放权”了的上帝。你创建了一个个对象，然后这些对象干这干那的。

如：创建一个Student对象，然后这个Student对象在主函数中调用自己study函数，打印“XXX is studying ! ”语句。

主函数还是上帝，但是study行为不是上帝发出的了，Student也不用被当做原材料了，study这个行为是Student主动发出的。

面向对象的特性

封装

对象把自己的数据（属性）隐藏起来，外部无论是访问还是赋值，都必须按照类自己定义规范来。

如，你可以在setter中，规范age的范围：

继承

当一个class（类），和一个已经定义好的class有“is-a”关系（如猫 Cat 是动物 Animal，Cat is Animal），那么 Cat 就可以继承 Animal。Animal 中的属性，Cat就可以使用了（达到了代码复用的效果）。

多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

以下是一个多态实例的演示，详细说明请看注释：

public class Test {public static void main(String[] args) {show(new Cat());  // 以 Cat 对象调用 show 方法show(new Dog());  // 以 Dog 对象调用 show 方法Animal a = new Cat();  // 向上转型  a.eat();               // 调用的是 Cat 的 eatCat c = (Cat)a;        // 向下转型  c.work();        // 调用的是 Cat 的 work}  public static void show(Animal a)  {a.eat();  a.work();// 类型判断if (a instanceof Cat)  {  // 猫做的事情 Cat c = (Cat)a;  c.work();c.eatFish();} else if (a instanceof Dog) { // 狗做的事情 Dog c = (Dog)a;  c.work(); }  }
}abstract class Animal {  abstract void eat();  abstract void work();
}  class Cat extends Animal {  public void eat() {  System.out.println("吃鱼");  }  public void work() {  System.out.println("抓老鼠");  }  public void eatFish(){System.out.println("吃鱼");  }
}  class Dog extends Animal {  public void eat() {  System.out.println("吃骨头");  }  public void work() {  System.out.println("看家");  }
}

接口

官方解释：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

接口指明了一个类必须要做什么和不能做什么，相当于类的蓝图。
一个接口就是描述一种能力，比如“运动员”也可以作为一个接口，并且任何实现“运动员”接口的类都必须有能力实现奔跑这个动作（或者implement move()方法），所以接口的作用就是告诉类，你要实现我这种接口代表的功能，你就必须实现某些方法，我才能承认你确实拥有该接口代表的某种能力。
一个JAVA库中接口的例子是：Comparator 接口，这个接口代表了“能够进行比较”这种能力，任何类只要实现了这个Comparator接口的话，这个类也具备了“比较”这种能力，那么就可以用来进行排序操作了。

为什么要用接口

接口被用来描述一种抽象。
因为Java不像C++一样支持多继承，所以Java可以通过实现接口来弥补这个局限。
接口也被用来实现解耦。

接口和抽象类的区别：

1.接口可以多继承，抽象类不能实现多继承。

2.接口只能定义抽象规则，抽象类既能定义抽象规则也可以提供已经实现的成员。

3.接口只包含方法，属性，索引器，事件的签名，但不能定义字段和包含实现的方法，抽象类可以定义属性，字段，包含有实现的方法。

4.抽象类应主要用于关系密切的对象，而接口则是适合为不相关的类提供通用功能。

5.接口着重于Can——Do关系类型，抽象类则偏重于IS——A式关系

6.接口多定义对象的行为，抽象类多定义对象的属性

二、集合

List , Set, Map都是接口，前两个继承至Collection接口，Map为独立接口
Set下有HashSet，LinkedHashSet，TreeSet
List下有ArrayList，Vector，LinkedList
Map下有Hashtable，LinkedHashMap，HashMap，TreeMap
Collection接口下还有个Queue接口，有PriorityQueue类

![](https://img-blog.csdn.net/20180612094225630?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5ncXVuc2h1YWk=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70

Connection接口:

List 有序,可重复

ArrayList

优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程不安全，效率高

Vector

优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程安全，效率低

LinkedList

优点: 底层数据结构是链表，查询慢，增删快。
缺点: 线程不安全，效率高

Set 无序,唯一

HashSet

底层数据结构是哈希表。(无序,唯一)
如何来保证元素唯一性?
1.依赖两个方法：hashCode()和equals()

基于HashMap实现

LinkedHashSet

底层数据结构是链表和哈希表。(FIFO插入有序,唯一)
1.由链表保证元素有序
2.由哈希表保证元素唯一

基于LinkedHashMap实现

TreeSet

底层数据结构是红黑树。(唯一，有序)

如何保证元素排序的呢?
自然排序
比较器排序
2.如何保证元素唯一性的呢?
根据比较的返回值是否是0来决定

TreeSet的应用，自定义排序规则

public class MyClass {public static void main(String[] args) {TreeSet<Student> ts=new TreeSet<Student>();//创建元素对象Student s1=new Student("zhangsan",20);Student s2=new Student("lis",22);Student s3=new Student("wangwu",24);Student s4=new Student("chenliu",26);Student s5=new Student("zhangsan",22);Student s6=new Student("qianqi",24);//将元素对象添加到集合对象中ts.add(s1);ts.add(s2);ts.add(s3);ts.add(s4);ts.add(s5);ts.add(s6);//遍历for(Student s:ts){System.out.println(s.getName()+"-----------"+s.getAge());}}
}

public class Student implements Comparable<Student>{private String name;private int age;public Student() {super();// TODO Auto-generated constructor stub}public Student(String name, int age) {super();this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic int compareTo(Student s) {//return -1; //-1表示放在红黑树的左边,即逆序输出//return 1;  //1表示放在红黑树的右边，即顺序输出//return o;  //表示元素相同，仅存放第一个元素//主要条件 姓名的长度,如果姓名长度小的就放在左子树，否则放在右子树int num=this.name.length()-s.name.length();//姓名的长度相同，不代表内容相同,如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数。//如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。//如果这两个字符串相等，则结果为 0int num1=num==0?this.name.compareTo(s.name):num;//姓名的长度和内容相同，不代表年龄相同，所以还要判断年龄int num2=num1==0?this.age-s.age:num1;return num2;}
}

针对Collection集合我们到底使用谁呢?

唯一吗?

是：Set

排序吗?

是：TreeSet或LinkedHashSet
否：HashSet
如果你知道是Set，但是不知道是哪个Set，就用HashSet。

否：List

要安全吗?

是：Vector
否：ArrayList或者LinkedList

查询多：ArrayList
增删多：LinkedList

Map接口:

上图:

Map接口有三个比较重要的实现类，分别是HashMap、TreeMap和HashTable。ConcurrentHashMap

是否需要排序？

需要排序 TreeMap

不需要排序线程安全 ConcurrentHashMap

线程不安全 HashMap

TreeMap是有序的，HashMap和HashTable是无序的。
Hashtable的方法是同步的，HashMap的方法不是同步的。这是两者最主要的区别。
这就意味着:
- Hashtable是线程安全的，HashMap不是线程安全的。
- HashMap效率较高，Hashtable效率较低。如果对同步性或与遗留代码的兼容性没有任何要求，建议使用HashMap。查看Hashtable的源代码就可以发现，除构造函数外，Hashtable的所有 public 方法声明中都有 synchronized关键字，而HashMap的源码中则没有。
- Hashtable不允许null值，HashMap允许null值（key和value都允许）
  父类不同：Hashtable的父类是Dictionary，HashMap的父类是AbstractMap

三、IO

commons-io的使用方法：

https://github.com/itheimaxia/commons-io

字节流：InputStream和OutputStream是java中可以按照最小字节单位读取的流，即每次读写一个字节，字节流是直接连接到输入源的流。

**字符流：**是以字符为单位进行数据处理的IO流。本质其实就是基于字节流读取时，去查找指定的码表。

字节流与字符流之间的区别：

1.读写单位不同：字节流式以字节（8位2进制）为单位，字符流是以字符为单位，根据码表映射字符，一次可能读多个字节。

2.处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。

3.一次读入或读出是8位二进制。

4.字符流：一次读入或读出是16位二进制。

结论：只要是纯文本数据优先使用字符流，除此之外都使用字节流。

归纳：

编码大小支持语言

ASCII 1个字节英文

Unicode 2个字节（生僻字4个）所有语言

UTF-8 1-6个字节，英文字母1个字节，汉字3个字节，生僻字4-6个字节

四、反射

定义

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

用途

在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。当然，也不是所有的都适合反射，之前就遇到一个案例，通过反射得到的结果与预期不符。阅读源码发现，经过层层调用后在最终返回结果的地方对应用的权限进行了校验，对于没有权限的应用返回值是没有意义的缺省值，否则返回实际值起到保护用户的隐私目的。

反射机制的相关类

与Java反射相关的类如下：

类名	用途
Class类	代表类的实体，在运行的Java应用程序中表示类和接口
Field类	代表类的成员变量（成员变量也称为类的属性）
Method类	代表类的方法
Constructor类	代表类的构造方法

为了演示反射的使用，首先构造一个与书籍相关的model——Book.java，然后通过反射方法示例创建对象、反射私有构造方法、反射私有属性、反射私有方法，最后给出两个比较复杂的反射示例——获得当前ZenMode和关机Shutdown。

示例

被反射类Book.java

public class Book{private final static String TAG = "BookTag";private String name;private String author;@Overridepublic String toString() {return "Book{" +"name='" + name + '\'' +", author='" + author + '\'' +'}';}public Book() {}private Book(String name, String author) {this.name = name;this.author = author;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getAuthor() {return author;}public void setAuthor(String author) {this.author = author;}private String declaredMethod(int index) {String string = null;switch (index) {case 0:string = "I am declaredMethod 1 !";break;case 1:string = "I am declaredMethod 2 !";break;default:string = "I am declaredMethod 1 !";}return string;}
}

反射逻辑封装在ReflectClass.java

public class ReflectClass {private final static String TAG = "peter.log.ReflectClass";// 创建对象public static void reflectNewInstance() {try {Class<?> classBook = Class.forName("com.android.peter.reflectdemo.Book");Object objectBook = classBook.newInstance();Book book = (Book) objectBook;book.setName("Android进阶之光");book.setAuthor("刘望舒");Log.d(TAG,"reflectNewInstance book = " + book.toString());} catch (Exception ex) {ex.printStackTrace();}}// 反射私有的构造方法public static void reflectPrivateConstructor() {try {Class<?> classBook = Class.forName("com.android.peter.reflectdemo.Book");Constructor<?> declaredConstructorBook = classBook.getDeclaredConstructor(String.class,String.class);declaredConstructorBook.setAccessible(true);Object objectBook = declaredConstructorBook.newInstance("Android开发艺术探索","任玉刚");Book book = (Book) objectBook;Log.d(TAG,"reflectPrivateConstructor book = " + book.toString());} catch (Exception ex) {ex.printStackTrace();}}// 反射私有属性public static void reflectPrivateField() {try {Class<?> classBook = Class.forName("com.android.peter.reflectdemo.Book");Object objectBook = classBook.newInstance();Field fieldTag = classBook.getDeclaredField("TAG");fieldTag.setAccessible(true);String tag = (String) fieldTag.get(objectBook);Log.d(TAG,"reflectPrivateField tag = " + tag);} catch (Exception ex) {ex.printStackTrace();}}// 反射私有方法public static void reflectPrivateMethod() {try {Class<?> classBook = Class.forName("com.android.peter.reflectdemo.Book");Method methodBook = classBook.getDeclaredMethod("declaredMethod",int.class);methodBook.setAccessible(true);Object objectBook = classBook.newInstance();String string = (String) methodBook.invoke(objectBook,0);Log.d(TAG,"reflectPrivateMethod string = " + string);} catch (Exception ex) {ex.printStackTrace();}}}

调用相应反射逻辑方法

        try {// 创建对象ReflectClass.reflectNewInstance();// 反射私有的构造方法ReflectClass.reflectPrivateConstructor();// 反射私有属性ReflectClass.reflectPrivateField();// 反射私有方法ReflectClass.reflectPrivateMethod();} catch (Exception ex) {ex.printStackTrace();}Log.d(TAG," zenmode = " + ReflectClass.getZenMode());

Log输出结果如下：

08-27 15:11:37.999 11987-11987/com.android.peter.reflectdemo D/peter.log.ReflectClass: reflectNewInstance book = Book{name='Android进阶之光', author='刘望舒'}
08-27 15:11:38.000 11987-11987/com.android.peter.reflectdemo D/peter.log.ReflectClass: reflectPrivateConstructor book = Book{name='Android开发艺术探索', author='任玉刚'}
08-27 15:11:38.000 11987-11987/com.android.peter.reflectdemo D/peter.log.ReflectClass: reflectPrivateField tag = BookTag
08-27 15:11:38.000 11987-11987/com.android.peter.reflectdemo D/peter.log.ReflectClass: reflectPrivateMethod string = I am declaredMethod 1 !
08-27 15:11:38.004 11987-11987/com.android.peter.reflectdemo D/peter.log.ReflectDemo:  zenmode = 0

作用

优点：增强程序的灵活性，避免将程序写死在代码里面

缺点：反射会导致性能降低，复杂度增加

Spring中IOC实现原理

1.如果我们不用反射机制实现工厂模式可以这样写：

interface Worker {public void work();
}class Coder implements Worker {public void work() {System.out.println("I am coding.");}
}class Leader implements Worker {public void work() {System.out.println("I am talking.");}
}// 构造工厂，以后如果新增工种，在该方法中添加
class Factory {public static Worker getInstance(String workerClassName) {Worker worker = null;if("Coder".equals(workerClassName)){worker = new Coder();}if("Leader".equals(workerClassName)){worker = new Leader();}return worker;}
}// 测试类
class Test {public static void main(String args[]){Worker worker = Factory.getInstance("Coder");worker.work();}
}

上述写法存在一定问题：当新增工种时，如Trainer时，除了要新增一个Trainer类，同时还要去修改构造工厂的方法。

2.如果用反射机制的话则可以避免这个问题，如下：

interface Worker {public abstract void work();
}class Coder implements Worker {public void work() {System.out.println("I am coding.");}
}class Leader implements Worker {public void work() {System.out.println("I am talking.");}
}// 构造工厂
class Factory{public static Worker getInstance(String ClassName) {Worker worker = null;try{worker = (Worker)Class.forName(ClassName).newInstance();}catch (Exception e) {e.printStackTrace();}return worker;}
}// 测试类
class Test {public static void main(String args[]){Worker worker = Factory.getInstance("worker.Coder"); // worker为Coder所在包名，此处传入的是该类的完整路径if(worker!=null) {worker.work();}}
}

该方法仍然存在问题：通过类名创建对象时，需要传入完整的包名和类名。有哪些类可以被创建也并不直观。

3.下面我们看看使用反射机制并结合属性配置文件的方法(IOC)应该怎么写：

首先是属性配置文件，一般以xxx.properties的格式命名,此处为worker.properies

coder=worker.Coder
leader=worker.Leader

然后是主类的编写

interface Worker {public abstract void work();
}class Coder implements Worker {public void work() {System.out.println("I am coding.");}
}class Leader implements Worker {public void work() {System.out.println("I am talking.");}
}// 操作属性文件类
class init{public static Properties getPro() throws FileNotFoundException, IOException{Properties pro=new Properties();File f=new File("worker.properties");if(f.exists()){pro.load(new FileInputStream(f));}else{pro.setProperty("coder", "worker.Coder");pro.setProperty("leader", "worker.Leader");pro.store(new FileOutputStream(f), "WORKER CLASS");}return pro;}
}// 构造工厂
class Factory{public static Worker getInstance(String ClassName) {Worker worker = null;try{worker = (Worker)Class.forName(ClassName).newInstance();}catch (Exception e) {e.printStackTrace();}return worker;}
}// 测试类
class Test {public static void main(String args[]){Properties pro=init.getPro();Worker worker = Factory.getInstance(pro.getProperty("coder")); // if(worker!=null) {worker.work();}}
}

把IOC容器的工作模式看做是工厂模式的升华，可以把IOC容器看作是一个工厂，这个工厂里要生产的对象都在配置文件中给出定义，然后利用编程语言提供的反射机制，根据配置文件中给出的类名生成相应的对象。