JavaSE面向对象后的主要知识点总结

面向对象的三个特点：封装、继承、多态
一、封装：将属性私有化，然后提供公有方法让外部访问私有属性。
    关键词：private            公有方法，get,set方法
        private 修饰属性的特点：只能在本类中访问，其他类访问不到
    优点：增加了对数据的访问限制，提高了代码的安全性、可扩展性和可维护性。

    构造方法：（构造函数/构造器）与类名一致，不写返回值。
        作用：创建并初始化（有参数的时候）对象
        new 对象的时候，一般默认调用该类的无参构造方法。类中没有构造方法时，系统会提供一个无参构造方法；显示写了构造方法时，则调用自己写的构造方法，系统不提供。

二、继承：当两个类存在 is - a  的包含关系时，可以是使用继承。
    关键词：extends
    被继承的类称为 父类、基类、超类，继承而来的类称为 子类、派生类
    优点：提高了代码的复用性、可复用性和可扩展性。为多态提供了条件
    缺点：Java 中的类只支持 单继承，即一个子类只有一个直接父类；但是可以多重继承，即父类可以有父类，子类可以子类。

    子类可以继承父类所有的属性和方法，包括私有的，但是，继承而来的私有的东西没办法访问。

    里氏代换：称向上转型：父类引用指向子类对象。 如 Animal a = new Dog();这种方法的对象只能使用父类所有的方法和子类重写父类的方法，不能使用子类独有的方法。

三、多态：多个不同的类对象可以对同一消息做出不同的响应。
    编译时多态：向上转型
                            向下转型
    运行时多态：    子类继承父类，子类重写父类方法。父类类型作为参数传入方法，运行时要使用哪个对象的方法就传入哪个类的对象
            子类继承父类，子类重写父类方法。父类类型作为方法的返回值类型，使用中间参数区分具体子类，进行返回。

构造方法：
    * new 对象的时候，如果该类没有显示写构造方法，则调用该类的无参构造方法，该无参构造方法由系统给。
    * 构造方法可以重载，不能重写--构造方法必须与类名相同。
    * 可以自定义有参构造方法，new 对象的时候，直接在构造方法中传入相对应的参数即可。
    * 存在继承关系时，如果父类显示写了构造方法，则子类必须在自己的构造方法中的第一行使用super()，把父类的构造方法继承过来，父类的构造方法有参数时，
        super()括号中必须有参数，并且参数个数和顺序必须与父类相同。子类构造方法中的参数个数必须大于等于父类构造方法中的参数个数，但是顺序可以随意。
    *
this 与 super
    * this 指代当前对象，一般用来区分形参和当类属性。this.属性 调用本类属性，this.方法名() 调用本类方法，通常省略 this。
    * super 一般用来调用父类的属性和方法，super.属性 调用父类属性， super.方法名() 调用父类方法

方法重写(override)与重载(overload)
    重载：    * 发生在一个类中
        * 一同三不同一无关：方法名相同，参数列表（参数类型、或参数个数、或参数顺序）不同，与返回值无关
        *
    重写：    * 发生在父子类中，子类重写父类的方法
        * 三同一不同，方法名、返回值、参数列表相同，方法体不同
        *
访问修饰符：
    修饰符        本类        同包        不同包子类        其他包
    private        ok
    默认default    ok        ok 
    protected    ok            ok           ok
    public         ok            ok            ok                       ok

抽象类：abstract
    含有抽象方法的类。
    抽象类里可以有成员变量，局部变量，构造方法，普通方法，抽象方法等
    不能 new 对象
    其中的属性和方法的修饰符任一

接口(interface)：是特殊的抽象类 
    接口里只有公开的抽象方法和公有的静态的常量
    接口支持多继承，多实现
    接口的实现类必须实现接口的所有方法。
    不能 new 对象，没有构造方法
    接口方便了对程序的扩展，实现了代码间的弱耦合性。
    其中的修饰符只能是公开的

内部类：
    1. 成员内部类: 写在类里面，方法外面，与成员变量类似
        * 可以访问外部类的私有属性，且不破坏封装
        * 创建成员内部类的对象时，必须先创建外部类的对象。如 Outer.Inner in = new Outer().new Inner();
        * 成员内部类的访问修饰符任一
        * 成员内部类不能定义静态的属性和方法
    2. 静态内部类：class 前面有 static 修饰
        * 静态内部类可以有静态成员和非静态成员
        * 其中的静态成员直接通过 Outer.Inner.静态成员 访问
        * 其中的非静态成员需要先创建对象，通过对象来访问
        * 其中的静态方法只能访问外部的静态方法和静态属性
        * 在继承时，静态的方法只能被静态的方法重写
    3. 局部内部类：写在方法里面，同局部变量类似
        * 目的是隐藏该类，外部类只能通过该方法类访问该局部内部类
        * 局部内部类不能用 static 修饰
        * JDK1.7及以下的版本，局部内部类访问外部类的局部变量时，该局部变量必须声明为 final 。但是 JDK1.8开始可以直接访问了
    4. 匿名内部类：是一种特殊的局部内部类
        * 没有名字，在其生命周期内只能使用(实例化)一次
        * 前提 必须继承父类或实现接口
        * 其中不能定义静态成员、静态方法和类
        * 没有构造方法
        * 通常建议匿名内部类中的方法不要超过三个

        优点：类非常小，方法结束就不存在，节省内存

包装类：
    由于基本类型不能 new 对象， 就提供了它们的包装类，可以用包装类 new 对象
    基本数据类型            包装类
    byte                             Byte
    short                           Short
    int                                Integer   **
    long                            Long
    float                            Float
    double                       Double
    char                           Character **
    boolean                    Boolean

    int Integer String 之间的转换
        int --> Integer
            1. int i;  Integer ig = new Integer(i);
            2. Integer ig = i;    --- i 的值在 -128--127之间时，可以使用。底层提供了转换。
        Integer --> int
            1. Integer  ig = new Integer(23);  int i = ig.intValue();
            2. int i = ig;        ---同上
        int --> String
            1. int i; String s = Integer.toString(i);
            2. String s = i + " ";    
        Integer --> String
            Integer ig = new Integer(); String s = ig.toString();
        String --> int
            String s = "23";  int i = Integer.parseInt(s);
        String --> Integer
            String s = "23"; Integer ig = Integer.valueOf(s);

异常：
    错误 Error ：表示系统级的错误和程序不必处理的异常，是java运行环境中的内部错误或者硬件问题。
            比如：内存资源不足等。对于这种错误，程序基本无能为力，除了退出运行外别无选择，它是由Java虚拟机抛出的。
    异常 Exception ：表示程序可以处理的异常，可以捕获且可能恢复。

异常分编译时异常和运行时异常
    编译时异常：在运行之前就能发现的错误（工具下），因为 Java 程序是边写边编译的
    运行时异常：在编程时即运行之前没有发现错误，但是执行的时候程序会终止。

异常处理
    消极处理：使用 throws 把异常往上抛，最终抛给虚拟机，由虚拟机处理。不推荐
            可以抛出多个异常，用逗号分隔。多个异常平级时，顺序无所谓，有父子关系时，先子后父。
            子类不能抛出比父类更大的异常
    积极处理：使用 try catch finally 捕获处理。
            可以 catch 多个异常，但是只能捕获一个异常后程序就会终止。有父子关系时，必须先子后父。
            这三个关键字的出现必须有 try，其他两个可有可无。

throw 与 throws 的区别
    throw 抛出一个具体的异常，可抛出自定义异常
    throws 是方法抛出的异常声明，该异常可能发生，也可能不发生

IO流：
    以 Stream 结尾的是字节流， 以 Reader 或 Writer 结尾的是字符流
    按方向分：输出流，输入流
    按单位分：字节流，字符流
    按功能分：节点流，过滤流

    常用过滤流：BufferedInputStream/BufferedOutputStream
            BufferedWriter/BufferedReader
            DataInputStream/DataOutputStream
 
    字节流 --> 字符流：InputStreamReader
    字符流 --> 字节流：OutputStreamWriter
    文件 --> 控制台：FileInputStream,FileReader
    控制台 --> 文件：FileOutputStream, FileWriter
    文件 --> 文件：先读入后写出

    集合 --> 文件：Properties    ---集合指的是以Map集合的形式。

                               Properies 是一个特殊的集合，键和值都是 String 类型，可以与流建立联系      

import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.util.Properties;public class PropertiesPra {public static void main(String[] args) throws IOException {mapToFile();fileToMap();}private static void fileToMap() throws IOException {Properties p = new Properties();//一个特殊集合，可以与流建立联系FileInputStream fis = new FileInputStream("text.txt");//文件中的每一行是一个数据，第一个空格之前是键，后面的都是值，键相同则覆盖，汉字会乱码p.load(fis);System.out.println(p);fis.close();}private static void mapToFile() throws IOException {Properties p = new Properties();p.setProperty("xiao", "23");//键和值均为 Stringp.setProperty("23", "a");//Properties特有的方法p.put("an", "kd");//也可以用 Map 的方法p.put("an", "apple");//apple 覆盖了 kdFileOutputStream fos = new FileOutputStream("out.txt");p.store(fos, "name, num");//第二个参数相当于键和值的名字，自定义//写到文件后，文件有一行键和值的名字，有一行时间。//数据写入的顺序不一定是输出到文件中的数据fos.close();}}

——————————————————————————————

IO基本节点流的用法测试

IO常用过滤流BufferedInputStream/DataInputStream用法测试

序列化反序列化实现

线程

参考线程基础

集合

       Collection     List        ArrayList

                                          LinkedList

                                          Vector

 

                            Set          HashSet

                                          TreeSet

                                          LinkedHashSet

 

       Map             HashMap

                            TreeMap

                            LinkedHashMap

Collection 和 Map 是两个平级的接口，List 和 Set 是 Collection 的两个子接口， List 和 Set 都有三个常见比较常用的实现类。 Map 有三个常见的实现类。

Collection 是单列集合， Map 是双列集合（键值对）键唯一，值可以重复。

List：存取有序，输出按存入的顺序输出。可以存相同的值，可以存 null；

ArrayList：底层是数组实现，可以用下标直接寻找值。但是增加删除数据麻烦，增加或删除一个数据可能需要移动整个数组。查询快，增删慢。

LinkedList：底层是链表实现，遍历只能从头依次执行，因此查询慢。但是增加或删除数据时，只需改动前后数据的链接引用即可，非常方便。查询慢，增删快。

Vector：与 ArrayList 类似，但是 Vector 是线程安全的，效率低；ArrayList 和 LinkedList 是线程不安全的，效率高。

 

Set：无序，输出不一定按存入的顺序输出。只能存放不同的值，可以存 null。当存放的元素的对象时，必须中对象所属类中重写hashCode方法和 equals 方法。

HashSet ：数据唯一且无序。底层是哈希表实现，哈希表保证唯一性。(其方法其实在底层调用了HashMap 的方法)

       LinkedHashSet ：数据唯一且存取有序。继承了HashSet

TreeSet ：数据唯一且有序(一定规则的排序)，底层是二叉树实现。(其方法中底层调用了 TreeMap 的方法)

1.       自然排序：如果元素是基本数据类型和String类型，其自身可以实现自然排序，即字典顺序。如果元素是对象，则对象所属类需实现 Comparable 接口，并重写 compareTo(Object o) 方法，该方法返回值为 -1,0,1 。返回 0 表示两个对象相同，不存储。

2.       比较器排序：对象需要实现Comparator 接口

HashMap ：唯一、无序

LinkedHashMap ：输出按存入顺序输出，唯一

TreeMap：数据排序（自然排序，比较器排序）

Hashtable ：被HashMap取代，线程安全，HashMap线程不安全

遍历：

List下的集合 ：  1. 直接打印输出（前提是实现或重写了 toSting 方法）

2. for 循环/增强 for

                            3. while 循环

                            4.迭代器循环（Iterator）

Set下的集合：     1. 直接答应输出

2.       增强for

3.       迭代器

Map下的集合 ： 1. 直接打印输出

2.  entrySet() 方法

3.       keyset() 方法

嵌套

————————————————

ArrayList/LinkedList用法测试

HashMap用法测试

HashSet/LinkedHashSet 用法测试

TreeSet 用法测试

TreeMap 用法测试