黑马java基础笔记

static -- 类变量（静态成员变量），内存中只有一份，会被类创建的全部对象所共享，可用类名和对象调
                应用：某个数据只需要一份，且希望能够被共享
          类方法（静态方法）  可用类名和对象调，作为工具类（因为实例方法需要占内存），工具类无需创建对象，可将构造器私有化
                 类方法不可以出现this
                 类方法可以直接访问类变量和类方法，但是不可访问实例变量和实例方法
          静态代码块 static{ } 只执行一次



修饰符：public > protected > 缺省 > private

类不支持多继承，但支持多层继承
私有方法、静态方法不能被重写（@override）

子类的全部构造器都会先调用父类的构造器 super()



对象多态、行为多态


final 防止方法被子类重写


抽象类  abstract 一定不能有方法体，不能创建对象  方便多态
        父类知道子类都有某个行为，但子类做的情况不一样。父类就可定义抽象方法，子类重写


接口   一个类可以实现多个接口  接口能够多继承
        public interface 接口名{
            //成员变量   （常量）
            //成员方法  （抽象方法）
        }


内部类   静态内部类只能直接访问外部类的静态成员
        匿名内部类  本质是一个子类，通常作为一个参数传输给方法
                new 类或方法{
                    //一般是方法重写
                }


枚举类   无法创建对象，构造器私有，第一行都是常量
        抽象枚举 重写
        应用：信息标志和分类   可读性好


泛型     把具体的数据类型作为参数传给类型变量 <E>  不支持基本数据类型，只支持对象类型（引用数据类型）
        自定义泛型类
                class 类名<类型变量，类型变量...>{

                }
        泛型方法    ？--通配符   使用泛型的时候代表一切类型
           上限： ？extends 类   下限：？super 类
                public <类型变量，类型变量...>  返回值类型  方法名(形参列表){

                }


Object类
       toString()  equals()  子类重写
       clone() -- 需要类继承cloneable接口
            浅克隆
            深克隆 -- 创建新对象

包装类   自动装箱：转换为包装类型（对象）
        自动拆箱：转换为基本数据类型
        转为字符串：Integer.toString(int)
        转为基本类型：Integer.parseInt(str)

StringBuilder 可变字符串对象（容器），方便字符串的修改操作  效率更高
                支持链式编程
                线程不安全


StringBuffer  线程安全

Math
    abs 绝对值
    ceil 向上取整
    floor 向下取整
    round 四舍五入


BigDecimal
    double变为字符串封装成BigDecimal来运算 BigDecimal.valueOf()
    BigDecimal转为double   doubleValue()

Calender  获取日历对象：Calender.getInstance()
Date Calender   可变对象


Arrays实现自定义类的排序
        1.在自定义类中重写compareTo方法，继承自Comparable
        2.Comparator比较器对象


lambda表达式   只能简化函数式接口的匿名内部类，即只有一个方法的接口
           参数类型可以省略不写
           如果只有一个参数，()也可以省略
           方法体只有一行代码：省略大括号，同时省略分号；如果是return语句，必须去掉return

静态方法引用
        类名::静态方法
        Lambda表达式只是调用一个静态方法，且前后参数形式一致

实例方法引用
        对象名::实例方法
        Lambda表达式只是调用一个实例方法，且前后参数形式一致



构造器引用
        类名::new
        Lambda表达式只是在创建对象，且前后参数形式一致



集合                                                  collection(接口,单列集合)
           List(接口,有序、可重复、有索引,for循环)                                         set(接口，无序、不可重复、无索引，对象不重复(若认为两个内容一样的对象重复，即重写equals()和hashCode()))
    ArrayList(数组，查快、增删慢）    LinkedList(双链表，增删快、查慢，首尾操作)          HashSet(哈希表)                TreeSet(排序，自定义排序规则(1.Comparable  2.Comparator))
                                                                             LinkerHashSet(有序,哈希表+双链表)

遍历方式： 1.迭代器 Iterator
         2.增强for循环
         3.lambda表达式  forEach()
并发修改异常：
        增强for循坏遍历集合，删除元素时可能报错
        解决：迭代器自己的删除方法 it.remove()
             for循坏 i--或倒着删除

可变参数 ：   数据类型...参数名
        在方法内部，就是一个数组
        一个形参列表中，只能有一个可变参数，可变参数必须放在形参列表最后
Collections : addAll() , shuffle() , sort()




Map<K,V>（接口）:  一一对应，由键决定，值不做要求
        HashMap<K,V> : 无序、不重复、无索引
                LinkedHashMap<>: 有序
        TreeMap<>: 可排序（按照大小默认升序）
遍历：
    1.键找值
    2.键值对 Map.Entry
    3.Lambda表达式  forEach


stream  支持链式编程
        数据源(集合、数组)[获取stream流]  ---> 常见的中间方法(过滤，去重，排序) ---> 获取结果(常见的终结方法，遍历，统计，收集)
        中间方法：filter, sorted, limit, skip, distinct(自定义类型，重写hashCode和equal), map(映射，流上的一种数据加工成另一种), contact(合并)
        终结方法：不会返回新的stream流    max  min count forEach  collect toArray   流只能收集一次



File类只能操作文件本身，而不能读写文件中的数据
    mkdir  只能创建一级文件夹
    mkdirs  创建多级文件夹
    delete  只能删除文件和空文件夹
    list  一级文件名称
    listFiles  一级文件对象

字符集
    编码 getBytes
    解码 new String

IO流读写数据
    流的方向：输入、输出
    数据最小单位：字符流（纯文本）、字节流（所有类型）
    字节输入流：InputStream  -->  FileInputStream(低级) -->  BufferFileInputStream(高级)  DataInputStream 高级流中包入低级流  eg:BufferedInputStream bis = new BufferedInputStream(new FileInputStream(""))
    字节输出流：OutputStream  -->  FileOutputStream --> BufferFileOutputStream   PrintStream  DataOutputStream
    字符输入流：Reader  --> FileReader --> BufferFileReader  InputStreamReader
    字符输出流：Writer  --> FileWriter --> BufferFileWriter  OutputStreamWriter  PrintWriter
0
资源释放：try-catch-finally
        try-with-resource(资源一般指的是最终实现了AutoCloseable接口)  会自动调用资源的close方法
               try(定义资源1;定义资源2...){
                    可能出现的异常代码
               }catch(){
                    异常的处理代码
               }
字符输出流写出数据后，必须刷新流，或者关闭流，写出的数据才有效

转换流：解决文本乱码问题
       InputStreamReader(字符输入转换流)
       OutputStreamWriter(字符输出转换流)

打印流：主要解决打印问题
      PrintStream(继承自字节输出流)   println()  write()
      PrintWriter(继承自字符输出流)   println()  write()

数据流：
      DataInputStream(数据输入流)
      DataOutputStream(数据输出流)

序列化流：  对象如果要序列化，必须实现序列化接口Serializable   对类中的变量用transient修饰将不参与序列化
      ObjectInputStream(对象字节输入流)   反序列化  把存储在文件中的对象读出来到内存
      ObjectOutputStream(对象字节输出流)  序列化    把java对象存入到文件中



Properties 属性文件的键值对数据  load()读   store()存

XML：可扩展标记语言
    框架：dom4j(解析)  文档对象模型
        SAXReader解析器 --> Document(整个文档) --> Element(元素、标签) --> Attribute、子元素、文本
    写入XML文件：将数据拼接成XML格式，IO流写入
    约束文档(约束XML格式):DTD、Schema


日志：
    Logback框架  核心配置文件logback.xml
    日志级别(依次升高)：
        trace 追踪
        debug 调试
        info 重要信息
        warn 警告
        error 错误


线程：
    创建：
        1.继承Thread重写run方法  单继承
        2.Runnable任务对象交给Thread处理
        3.Callable对象重写call(),封装成FutureTask线程任务对象交给Thread处理  可通过FutureTask的get方法获取线程执行结果

        join方法：让当前调用这个方法的线程先执行完

    线程安全：将共享资源上锁
        1.同步代码块  synchronized
            使用共享资源作为锁对象，实例方法用this
            静态方法用字节码(类名.class)
        2.同步方法
        3.Lock锁

    线程通信：
        等待锁,知道线程被唤醒 wait()
        唤醒单个线程 notify()
        唤醒所有 notifyAll()
        PS:使用同步锁对象调用！ 先唤醒别人再等待自己

    线程池：复用线程
        接口：ExecutorService
        得到线程池对象：1.实现类ThreadPoolExecutor
                     2.Executors(线程池的工具类)调用方法  大型项目有风险


    并发：cpu轮询为每个线程服务
    并行：同一时刻，同时有多个线程被cpu调度
    多线程是并发和并行同时进行的！！！(如：16核cpu执行5000个线程，即每16个线程同时轮询)

    线程的状态：
        新建 New                   线程刚被创建
        可运行 Runnable             调用了start()，等待CPU调度
        锁阻塞 Blocked             未竞争到锁对象
        无限等待 Waiting            另一个线程唤醒
        计时等待 Timed Waiting      sleep  wait等方法有超时参数
        被终止 Teminated            正常退出，或没有捕获的异常终止

    悲观锁：一上来就加锁，没有安全感。每次只能一个线程进入访问完毕后，再解锁。线程安全，性能较差，需要等待
    乐观锁：一开始不上锁，认为是没有问题的，大家一起跑，等要出现线程安全问题的时候才开始控制。线程安全，性能较好。  CAS算法：比较和修改


网络通信：
    IP  地址、域名 ： 定位主机
    端口 ： 定位应用程序
    协议 ：UDP  TCP


反射：加载类，并允许以编程的方式解剖类中的成分(成员变量、方法、构造器)
    1.加载类，获取类的字节码:class对象
    2.获取类的构造器：Constructor对象
    3.获取类的成员变量：Field对象
    4.获取类的成员方法：Method对象
    作用：可以得到一个类的全部成分然后操作
         破坏封装性 setAccessible
         适合做java框架

注解 动态代理