Java总结

第一章 Java概述

1.1 Java简介

特点：资源免费、跨平台（JVM）、健壮安全、高性能（解释执行）、简单（没有指针，垃圾自动回收）、面向对象（封装，继承，多态）、动态性（允许动态装入运行过程中所需要的类）、多线程

1.2 Java体系

    JDK，JRE，JVM（Java虚拟机）
    Java跨平台
    一次编译，随处运行

1.3 JDK工具

1.4 Hello World 程序

    文件名和主类名一致
    javac 编译
    java 运行

1.5 输出与注释

    System.out.print();
    单行注释：//
    多行注释：/**/
    文档注释：/*
              *
              *
              */

1.6 IDE集成开发环境

第二章 Java语言基础

2.1 字符

    字符集：ASCII，GB2312，Unicode
    分隔符：
    标识符：可以用_或$
    关键字：

2.2 变量和常量

    变量：int a=1;
    常量：用final定义

2.3 数据类型

    基本类型：整数类型（byte，short，int，long），浮点类型（float，double），字符类型（char），布尔类型（boolean）
    引用类型：数组，类，接口，枚举，空类型
    类型转换：自动类型转换，强制类型转换

2.4 操作符

    一元操作符：
                自增（++）
                自减（- -）
                逻辑非（！）
                按位非（~）
                强制类型转换（type）
    二元操作符：
                算数运算（+，-，*，/，%）
                位运算（&，|，^，<<，>>，>>>）
                关系运算（>，>=，<，<=，==，！=）
                逻辑运算（&&，||）
                赋值（=，+=，-=…）
    三元操作符：
                三元判断（？ ：）
注意：
    1. 取余（%）：double a=5.2,b=3.1; double c=a%b;（c的值为2.1）
    2. / 和%：如果 / 和 % 两个操作数都是整数类型，则除数不能是0，否则引发除以异常。如果两个操作数有一个是浮点数，或者两个数都是浮点数，此时允许除数是0或0.0，任何数除以0得到的结果是正无穷大（Infinity）或负无穷大（-Infinity），任何数对0取余得到的结果是非数：NaN
    3. >>：右移，N>>S，将N右移S位，左边空出来的如果是正数填充0，如果是负数填充1，相当于除2的S次方
    4. >>>：无符号右移，无论正数还是负数，左边空出来的位都填充0
    5. = =：如果进行比较的两个操作数都是数值类型，即使它们的数据类型不同，只要它们的值相等，都将返回true。如果两个操作数都是引用类型，则只有当两个引用变量的类型具有继承关系时才可以比较，且这两个引用必须指向同一个对象（地址相同）才会返回true
    6. &&与&：&&（短路与） a&&b，当a为false，则不会检测b，结果直接为false。&（逻辑与）a&b，a和b一定都会执行。|| 和 | 同理。
    7. 赋值（=）：float a=3.14f; double b=3.14d;

2.5 流程控制

    分支结构：
        if…else…（else if 必须在一行）
        switch语句：加break，default；
                    控制表达式的数据类型只能是byte、short、char、int、String和枚举类型。
    转移语句：break、continue、return

2.6 数组

    数组声明：int a[]=new int[100]; 或 int []a=new int[100];
    数组的长度：a.length=100;
    数组初始化：当数组使用new分配存储空间后，数组中的元素会有默认初始值。
        数值类型：0
        布尔类型：false
        字符型：’\0’
        引用类型：null（空引用）
    静态初始化：在定义数组的同时就对该数组进行初始化。
        int []a={1,2,3,4,5};
        int []a=new int[]{1,2,3,4,5};
    动态初始化：将数组的定义和数组的初始化分开进行。
        int []a=new int[2];
        a[0]=1;a[1]=2;
    foreach遍历数组：
        int []a={5,7,20};
        for(int e:a){
            System.out.println(e);
        }

第三章 面向对象基础

3.1 面向对象思想

    封装，继承，多态（重写和重载）

3.2 类与对象

    类的成员变量具有默认初始值，整数类型：0；带小数点的：0.0；boolean：flase；引用类型：null

3.3 方法

    值传递：当参数的数据类型是基本数据类型时，实参和形参之间是按值传递的。
    引用传递：当参数的数据类型是引用类型时，如类、数组，实参和形参之间是按引用传递的。
    this关键字：代表当前所在类将来产生的对象。当方法的参数或方法中的局部变量与类的属性同名时，类的属性就被屏蔽，可以用this.属性名访问类的属性
    默认构造方法：如果在类中没有定义任何构造方法，则编译器会自动加上一个不带任何参数的构造方法。一旦创建了自己的构造方法，默认构造方法将不复存在，如果还想使用，可以显示地写出来。
    方法重载：
        1. 在同一个类中
        2. 方法名相同
        3. 参数列表不同（参数的个数或对应位置上的类型不同）
    可变参数：public int add(int a,int …b){ }
        1. 可变参数只能处于参数列表的最后
        2. 一个方法中最多只能包含一个可变参数
        3. 可变参数的本质是一个数组，因此在调用一个包含可变参数的方法时，既可以传入多个参数，也可以传入一个数组。

3.4 封装和访问控制

    包：解决类的命名冲突，Java中的基础类库就是使用包进行管理的，java.lang、java.util等
    定义包：package mypackage;
            package com.qst.chapter03;
            编译结果（字节码文件.class）被存储在“ com \ qst \ chapter03 ”目录
    导入包：import 包名.*;//导入指定包中的所有类
            import 包名.类名;//导入指定包中指定的类
    访问控制符：
            private：只能被当前类中的其他成员访问，不能在类外看到
            默认friendly：可以被同一包中的所有类访问
            protected：既可以被同一个包中的其他类访问，也可以被不同包中的子类访问
            public：可以被同一包或不同包中的所有类访问

3.5 静态成员

    static：修饰类的成员变量、方法、代码段。在内存中只有一份，起到全局的作用
    final：修饰类、方法、变量

3.6 对象数组

    类名[] 数组名=new 类名[长度];

第四章 核心类

4.3 Object类（java.lang)

    所有类的顶级父类
    常用方法：
        equals()：判断指定的对象与传入的对象是否相等
            使用“==”表示地址是否相等
            使用equals()表示内容是否相等
        toString()：返回当前对象的字符串表示
            当使用System.out.println(obj)输出语句直接打印对象时，系统会自动调用对象的toString()方法

4.4 字符串类

    String：字符串不可变
    StringBuffer：字符串可变
    StringBuilder：字符串可变，但没有实现线程安全，因此性能较好
    字符串连接：
        String name=“abc”;
        String str1=name+10+20; // “abc1020”
        String str2=10+4.5+name; // “14.5abc”

4.5 Scanner类（java.util）

    获取用户从键盘上输入的不同数据
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    String str=scan.next();

4.6 Math类（静态）

    Math类提供的方法都是静态的，可以直接调用，无需实例化。（Math.abs()）

4.7 Date类

    时间是长整型，精确到毫秒
    toString()：将日期转换成字符串，格式：dow mon dd hh:mm:ss zzz yyyy（dow是周几，zzz是时间标准的缩写，如CST）

第五章 类之间的关系

5.1 关系概述

    纵向：继承、实现
    横向：依赖、关联、聚合、组成

5.2 继承与多态

    继承：extends
        实例化一个子类对象时，会先调用父类构造方法进行初始化，再调用子类自身的构造方法进行初始化
    域的隐藏：子类屏蔽掉父类的变量
    方法的重写：
        1. 方法名以及参数列表必须完全相同
        2. 子类方法的返回值类型与父类保持一致，或是父类方法返回值类型的子类
        3. 父类中的私有方法不能被子类重写
        4. 不能重写静态方法
    super关键字：
        1. 在子类的构造方法中调用父类的构造方法
        2. 在子类方法中访问父类的属性或方法
    final关键字：
        1. 修饰变量：表示是常量
        2. 修饰方法：表示该方法不能被子类重写，即最终方法
        3. 修饰类：表示该类不可被子类继承，即最终类

5.4 内部类

    成员内部类：在外部类的内部定义一个类。编译后，生成两个class文件，内部类的class文件形式是 “ 外部类名 $ 内部类名.class ”
    局部内部类：在方法中定义的内部类。e.g. 在main()方法中定义了两个局部内部类InnerBase和InnerSub，编译后生成的class文件：LocalInnerClass $ 1InnerBase.class、LocalInnerClass $ 1InnerSub.class 。 格式：“ 外部类名 $ N 内部类名 ”，其中N，是因为可能有两个以上的同名局部类（处于不同方法中）
    静态内部类：用static修饰一个内部类。属于外部类的本身，而不属于外部类的某个对象。只能访问外部类的静态成员。
    匿名内部类：没有名字的内部类。

第六章 抽象类和接口

6.1 抽象类（没有完全实现）

    定义：abstract class 类名{}
    抽象类不能被实例化
    抽象方法没有方法体，并以分号结束
    abstract和final不能修饰同一个类

6.2 接口（完全没有实现）

    定义：interface 接口名{}
    一个接口可以继承多个接口（多继承）
    默认成员变量：public static final
    默认方法：public abstract
    实现接口：class 类名 implements 接口{}
        一个类可以实现多个接口
        类必须完全实现接口中定义的所有抽象方法（实现时要加上public），否则该类必须定义为抽象类
    接口和抽象类的相同处：
        都不能被实例化
        可以包含抽象方法
        指向其实现类或子类的实例对象
    接口和抽象类的不同处：
        接口是一种规范，抽象类是一种模板
        接口中定义的方法都默认时public，抽象类默认friendly
        接口不包含构造方法

6.3 instanceof关键字

    判断前面的引用变量类型是否是后面的引用类型，或者其子类、实现类的实例。

第七章 异常

7.1 异常概述

    运行时发生错误。父类Throwable
    异常类：错误（Error）：一般指与虚拟机有关
            异常（Exception）：程序编码错误或外在因素
    Exception异常：非检查型异常：编译器不要求强制处置的异常（RuntimeException及其所有子类都属于非检查型异常）
                   检查型异常：编译器要求必须处理的异常（Exception及其子类，RuntimeException及其子类除外，都属于检查型异常）

7.2 捕获异常

    try…catch语句
        单catch语句：
            catch(Exception e) { e.printStackTrace(); //输出异常信息 }
            访问异常信息：getMessage()、printStackTrace()、printStackTrace(PrintStream s)、getStackTrace()
        多catch语句：首先捕获一些子类，然后捕获父类异常
            catch(NumberFormatException ex) { System.out.println(“数字格式化异常”); }
            catch(ArithmeticException ex) { System.out.println(“算数异常”); }
            catch(Exception ex) { System.out.println(“其他未知异常”); }
        try…catch…finally语句：try块是必须的，catch和finally块可选（至少出现其一）。finally是资源回收语句。
        多异常捕获：
            catch( 异常类A | 异常类B… | 异常类N 异常对象 ){ }

7.3 抛出异常

    throw：
        throw new Exception(“请输入。。。”);
    throws：
        <返回类型> 方法名（）throws 异常类A，异常类B…，异常类N { }

泛型与集合

8.1 泛型

    “菱形”语法实例化泛型类：
        类名<类型参数>对象 = new 类名<>(构造参数);
        Node < String > myNode = new Node<>();
        类型参数的类型只能是类类型。（String、Integer）

8.2 集合概述（java.util）

    两个接口：Collection和Map
    Collection：
        Set：无序，不可重复（HashSet、TreeSet、EnumSet）
        Queue：队列（FIFO），LinkedList（Deque和List）
        List：有序，可以重复
    Map：HashMap、TreeMap…
        key-value键值对
    迭代器接口：
        Iterator < String > iterator = list.iterator();