Java语言基础复习

语言基础：
1、JVM、JRE、JDK
JVM：Java虚拟机，加载并运行.class文件
JRE：Java运行环境，JVM+运行所需要的环境
JKD：Java开发工具，JRE+开发所需要的命令工具

2、变量、8种基本类型、类型间的转换
a.变量：
        定义
        标识符的命名规范：由字母、数字、_、$组成，数字不能放在开头
        字面量
        实例变量和静态变量
b.8种基本类型：
    byte:字节型，占1个字节，用来表示整型数据，范围是-128-127
    short：短整型，用来表示整数，占2个字节，范围是-32768-32767
    int ：整型，用来表示整数，占4个字节，范围是-2147483648-2147483647
    long ：长整型，用来表示整数，占8个字节，范围是2^-63 - 2^63-1
    float：单精度浮点型，用来表示小数，占4个字节，不能精确表示数据
    double：双精度浮点型，用来表示小数，占8个字节，不能精确表示数据
    char：字符型，底层采用的Unicode编码，占2个字节，范围是0-65535
    boolean：布尔型，占1个字节，只有true和false两个值
从小到大：
byte-->short-->int-->long-->float-->double
          char

c.类型间的转换:小转大，直接转，大转小，要强转，浮变整，小数没
d.    byte a = 1;
    byte b = 2;
    byte c = (byte)(a+b);
//底层做运算的时候，会将a和b看成是整型，两个整型相加，结果是整型，所以不加
(byte)会报编译错误

3、运算符、分支结构
a.运算符：
    数字运算符：+、-、*、/、%、++、--
    比较运算符：<、>、==、>=、<=、!=
    逻辑运算符：&&、||、!
    关系运算符：(三目运算符) boolean ? true : false
    赋值运算符：=、+=、-=、*=、/=
    连接运算符：+
b.分支结构：
    单路分支：if (boolean) {

                    }
    双路分支：if (boolean) {

                    } else {

                    }
    多路分支：if (boolean) {

                    } else if (boolean) {

                    } else if (boolean) {

                    } ....else {

                    }
                switch(type){
                        case a:
                                break;
                        case b:
                                break;
                        default:
                        }
            其中，type可以为byte/short/int/char/String/枚举类型
4、循环结构：
    循环三要素：
    循环变量初始化
    循环的条件
    循环变量的改变
while(循环的条件){
        循环变量初始化
        循环变量的改变
        }
do{  (当第一和第三要素相同时，首选do..while，先执行，后判断，至少执行一次)
        循环变量初始化
        循环变量的改变
    }while(循环的条件);
(当循环与次数相关时，首选for循环)
for(循环变量初始化;循环的条件;循环变量的改变){
    循环体
    }

break;用于跳出循环
continue;用于跳过当前循环，继续下一次循环

5、数组：
    a.数组的定义：(基本类型数组)
        三种方式：
        int[] arr = new int[数组长度];----动态创建数组
        使用这种方式创建数组会有默认值0
        int[] arr = {};---------------------静态创建数组
        int[] arr = new int[]{};-----------静态创建数组
    b.数组下标：
        从0开始，最大到数组长度-1
        如果超过数组长度，会报数组下标越界异常
            ArrayIndexOutOfBoundException
    b.获取数组的长度(属性)
        arr.length
    c.遍历数组
        for(int i = 0 ; i < arr.length ; i++){
            System.out.println(arr[i]);
        }

        System.out.println(Arrays.toString(arr));

6、方法
    a.方法的定义：
        修饰符   返回值类型   方法名 （参数列表）{
                方法体
        }
    b.方法是用来封装业务功能的
    c.方法的重载：
        发生在同一个类中，方法名相同，参数列表不同，就是方法的重载
     d.方法的重写：
        发生在超类和派生类这种，方法名相同，参数列表相同
        方法重写要遵循两同两小一大原则：
            两同：方法名和参数列表要相同
            两小：返回值类型要小于或等于被重写的方法
            一大：方法的修饰符要大于或等于被重写的方法
    e.return结束方法

面向对象：
面向对象三大特征：封装、继承、多态

1、类和对象
    类，用class关键词修饰的，是一系列对象的模板
    对象，是具体的个体
    类中包含对象的属性和功能
    一个类可以创建多个对象

2、构造方法、this
    构造方法：
        用来给实例变量初始化的
        创建对象的时候自动调用构造方法
        如果类中没有构造方法，会默认提供一个无参构造，如果有含参构造或者全参构造就不再提供
    this：
        三种方式：
            this.变量--------指代当前对象的成员变量
            this.方法--------指代当前对象的实例方法
            this()-----------指代当前对象的构造方法
        用来指向当前对象
        系统会默认在构造方法以及实例方法中给一个this
        当构造方法或实例方法的参数中有与实例变量同名的参数，this不能省略

3、引用类型数组、继承、super
    引用类型数组：
    a.定义：与基本类型相似-----引用类型[]  数组名字 = new 引用类型[数组长度]；
                                       引用类型[]  数组名字 = {};
                                       引用类型[]  数组名字 = new 引用类型[]{};
    b.数组下标也是从0开始，数组长度也是----数组名字.length；
    c.引用类型数组默认值为null

    继承：
    a.符合is a 的关系就可以使用extends关键字继承
    b.派生类继承超类
    c.超类中是派生类中共有的属性和方法
    d.Java只支持单继承，即单一继承或者是继承的单根性
    e.继承具有传递性

    super：
    a.三种方式：
        super.变量------------指代超类对象的成员变量
        super.方法------------指代超类对象的方法
        super()----------------指代超类对象的构造方法
    b.派生类的构造方法中会默认一个super()，用来调用超类的构造，
        当派生类被创建对象时会先执行super()
        如果超类中没有无参构造，则不提供super()

4、向上造型
    a.超类引用指向派生类对象
    b.用于实现多态
    c.能点出来什么看引用
    d.重写过后的方法的调用看对象

5、-package
    包，用于区分相同名称的类，在类的最上面
    -import
    导入，用于导入不同包中的类，以实现在本类中创建对象
    -访问控制修饰符：
    用于控制访问权限
        权限从小到大依次是
        private--- 默认--- protected--- public
        private:私有的，当前类中访问
        默认：同包类和当前类中访问
        protected:受保护的，同包类、当前类和派生类中访问
        public:公开的，所有类都可以访问
    -static 静态的
        修饰变量、方法
        静态变量是用来描述类的，属于类，通过类名.来访问，在静态方法中被调用
        静态方法也属于类，通过类名.来访问
    -final 最后的，最终的
        修饰变量，方法和类
        修饰变量时，表示该变量的值不能被修改
        修饰方法时，表示该方法不能被重写
        修饰类时，表示该类不能被继承

6、static final 常量、抽象方法、抽象类
    -static final 常量
        一般是永远不会改变的数据并且会被多次使用的才会设置为常量
        一般都是公开的，给别人用的
        常量在定义的时候就要赋值
    -抽象方法
        使用abstract关键词修饰，没有方法体
    -抽象类
        使用abstract关键词修饰
        抽象类不能实例化
        包含抽象方法的类一定是抽象类
        派生类继承的时候必须要重写抽象方法
        派生类如果不重写抽象方法则必须定义为抽象的

7、成员内部类、匿名内部类
    -成员内部类：
        类中套类，内部类能访问外部类的实例变量和实例方法
        内部类的对象只能在外部类创建
        其他类无法访问内部类
    -匿名内部类
        一般只创建一次对象时使用
        可以使代码更加简洁

8、接口
    使用instance关键字定义的类就是接口
    接口中的变量都是常量，默认有public static final
    接口中的方法都是抽象方法，默认有public abstract
    接口不能实例化
    实现接口要使用关键字implements
    接口中是派生类部分共有的功能或属性
    接口的实现类要重写接口中的抽象方法
    接口用于实现多继承

9、多态
    多种形态
    方法可以是多态的：抽象方法
    所有对象都是多态的：所有对象都有他本身以及直接或间接继承了Object类两种形态
    作用可以实现代码的复用

10、内存管理
    a.内存由JVM负责管理
    b.内存中有栈、堆、方法区
        栈中存储的是引用以及局部变量，方法中的参数
        堆中存储的是对象以及String常量池，实例变量
        方法区中存储的是.class 字节码文件静态变量以及所有方法

11、String
    字符串类型，是一种引用类型，在java.lang包中
    给一个字符串赋了字面量，会将该字面量的地址存入常量池中，若后面使用该字面量对象时，直接从常量池中复用
    一旦创建了对象，就不可改变字符串的内容和长度

API和二进制：
1、String的常用方法
    a.  int length()
        表示字符串的长度，这是一个方法，不是属性
    b.  String trim(String str)
        去除指定字符串中首尾两端的空白字符
    c.  char charAt(int index)
        根据给定的下标找到对应的字符
    d.  int indexOf(String str)
        根据给定的字符串找到第一次出现的位置
        int indexOf(String str,int n)
        根据给定的字符串找到从n位置以后第一次出现的位置
    e.  int lastIndexOf(String str)
        根据给定的字符串找到最后一次出现的位置
    f.   boolean startsWith(String str)
        根据给定的字符串，判断是否是以该字符串开头
    g.  boolean endsWith(String str)
        根据给定的字符串，判断是否是以该字符串结尾
    h.  String substring(int n)
        根据下标n来截取字符串
        String substring(int n,int m)
        从n位置开始一直截取到m位置之前一个
    i.   String toUpperCase()
        将指定字符串中的英文部分转成大写
    j.   String toLowerCase()
        将指定字符串中的英文部分转成小写
    k.  valueOf()
        静态方法，将其他类型的数据转成String类型

    L.concat(String s)

        在原字符串后拼接s,不改变原字符串

    M.byte[] getBytes()

        将字符串转为byte类型的数组

    n.hashCode()

        根据字符串的内容生成哈希码值

    o.equals()

        比较两个字符串的内容是否相等

    p.toString()

        打印字符串

2、StringBulider
    在java.lang包下
    由于String字符串的长度和内容无法改变，每次要改变都要重新创建一个对象
    不适合做频繁的修改
    所以Java就提供了StringBulider来对字符串进行增、删、改、插、翻转等操作
        增：append()
        删：delete()
        改：replace()
        插：insert()
        翻转：reverse()

3、正则表达式
        用于匹配信息是否符合要求
    String 中提供了支持正则表达式的方法
        boolean matches(String regex)
            检验当前字符串是否符合正则表达式的格式
        String replaceAll(String regex , String str)
            将满足正则表达式的字符串替换成想要输出的字符串
        String[] split(String regex)
            将当前字符串按照正则表达式的格式分隔成数组

4、Object
        顶级超类，所有类都直接或者间接继承
        重写最多的toString()和equals()方法
        因为Object中的toString()是一个地址值，没有参考意义，所以要重写
        equals()比较的也是一个地址，没有参考意义，所以要重写

5、包装类
        Java为基本类型提供的类，解决基本类型不能用于创建对象的缺点
        8种包装类有：
            Byte/Short/Integer/Long/Float/Double/Character/Boolean
        包装类引用在指向基本类型时会自动拆装箱

6、二进制
        计算机底层运用的就是二进制算法，运行速度快
        特点：
            逢2进1
            基数--2
            权---8 4 2 1
    二进制与十六进制转换
        将二进制数从低位到高位4个一组分开，依次转换
    二进制：    0100 1111 0111
    十六进制：    4       f       7---------0x4f7
    Java中用0x 表示十六进制，用0b表示二进制