java基础总结

1  JAVA

        1.1   概述    

                 1991 年推出OAK

                 1995 年 改名为java推出

                 Java之父 詹姆斯·高斯林

                 javaSE,javaWeb,javaEE,JavaM

        1.2  特性

                  四大特性：跨平台，自动垃圾回收，面向对象，多线程

        1.3  运行机制

                  先编码——>由javac编译成class文件——>java运行class字节码文件——>jvm执行class文件

        1.4  注释

                    注释就是对内容进行描述或者解释

                    注释的好处，因为代码长时间之后容易导致遗忘，所以注释能起到提醒的作用，交接工作的时候也方便他人接手

        1.5  注意事项

                    1  标点全部用英文。2 大小写，java严格区分大小写。3 写代码的时候最好变写变保存，避免丢失。4 命名规则（1：强制规则 只能出现大小写字母，数字，下划线_美元符号$,且数字不能开头，不能使用关键字和保留字。2：非强制规则，编写的类名最好望文知义，驼峰命名法：两个单词之间用大写字母）

2  数据类型

           2.1  数据存储

                        程序：可执行文件，一群命令的集合，属于静态，一般保存在硬盘中

                        进程：正在执行的程序，是动态的，运行在内存中

                        数据存储在内存可以看做两端无限延伸的线，在硬盘中是螺旋线

           2.2  数据分类

                        基本数据类型

                                数值型      

                                        整数型：byte，short，int，long

                                浮点型：float,double

                                字符型：char

                                布尔型：boolean

                            引用数据类型：类，数组，接口

                2.3  数据类型的使用

                                数据类型 名字 = 值；

                                2.3.1  整数型

                                        byte 名字 = 值；

                                        short 名字 = 值；

                                        int 名字 = 值；

                                        long 名字 = 值L；

                                   2.3.2  浮点型

                                            float 名字 = 值F；

                                            double 名字 = 值；

                                     2.3.3  字符型

                                                chart 名字 ='值'；

                                     2.3.4  布尔型

                                                  boolean 名字 = false/true；

                

                                        

        2.3  数据类型转换

                        自动类型转换：低精度到高精度

                        强制类型转换：高精度到低精度

                                int num = 257；

                                例如：byte num1 = (byte)num;

                        强制类型转换可能会导致数据丢失

                        自动类型转换：byte->short->int->long->float->double

                        需要注意的是，混合运算会自动转换成int类型

3  变量

        3.1  常量

                常量在程序整个生命周期中，值不可更改

        3.2  变量

                可以更改的量，方便进行操作，并且可以复用

        3.3  分类

                分类 
            局部变量 : 在方法中声明的变量是局部变量,没有默认值,作用域只能在当前方法中使用
            静态变量 : 类中使用static修饰的变量
            成员变量 : 类中没有使用static修饰的变量
        调用
            局部变量 : 方法中,使用变量名直接调用
            静态变量 : 类名.静态变量名
            成员变量 : 对象.成员变量名

4  运算符

        4.1  运算符描述

                变量进行运算时，所用到的符号就是运算符。

        4.2  运算符分类

                算数运算符

                +、- 、* 、 %、 ++、 -- a++; a = a + 1

                赋值运算符

                =、 +=、-=、 *=、 /=、%=。 a +=5;  就相对于 a = a + 5;

                关系运算符

                >、>=、<、<=、==、!=

                逻辑运算符

                &&、||、！ （!贵 表示不贵，!便宜，表示不便宜，!不便宜）

                三目运算符（三元运算符）

                ? : String msg = price > 1000 : "贵", "不贵";

                位运算符

                位的概念：计算机当中存储数据的最小单位，每个位就存一个 数。0或者1.

                &、|、^、>>、<<

5  流程控制

              5.1  顺序结构

                      严格从上到下，从左到右

              5.2  分支结构  

                        通过指定的判断条件,选择性执行不同分支

                        if.....else.....

                                单分支:有不执行的情况

                                        if(布尔型表达式){为真执行代码

                                        }

                                   双分支：一定有一个分支执行   if(){}else{}

                                   多分支：多个if ......else

                        switch

                        语法：switch(值){case值1；break；........ default：执行语句；}

                                需要注意的是  不加break会导致case穿透

                5.3  循环结构

                                for 循环

                                        语法结构：for（表达式1；表达式2；表达式3；）{循环体，就是要循环的代码}

                                循环三要素：起始值，终止条件，步长

                                while

                                        语法结构：while（布尔型）{循环体}

                                do...while   ：保证先执行一次

                                        语法机构：do{   循环体

}while()

6  方法

                6.1概述：

                        方法：一堆代码的集合               

                        目的：代码复用，使得程序剪短清晰，提高开发效率

                6.2 方法声明

                         修饰符列表  返回值类型 方法名 （参数列表）{方法体}

                 6.3 方法分类

                                分类 
                                   静态方法 : 使用static修饰
                                   成员方法 : 没有使用static修饰
                                   构造方法
                                调用
                                    静态方法 : 类名.方法名(参数);
                                    成员方法 : 对象.方法名(参数);
                                    方法不调用不执行,调用才执行,并把结果返回到调用处
                                  方法重载 Overload
                                       方法名相同,参数列表不同
                                       列表不同分为 : 类型不同或个数不同

7  内存划分

                7.1 内存划分

                        

                7.2  运行机制

                        Java Runtime Data Area : java运行时区域,一般叫JVM内存
   程序计数器 : 
           一块较小的内存区域.作用可以看做是当前程序执行的位置指示器
   
   静态区/方法区 : 
           保存程序文件(class文件) 以及静态数据,方法被调用之前,也保存在静态区,内部还有运行时常量池  
   VM栈 : 又叫栈内存
           栈内存是以栈数据结构为模型开辟的一段空间, 特性是先进后出
           栈 : 是一种数据结构,先进后出,像弹夹  
     栈的构成因素
          栈空间 : 栈内存就是栈空间
          栈帧    : 栈空间中的每一个栈元素 就叫栈帧(比如 弹夹中的每一个子弹 就叫栈帧)
          栈底元素 : 第一个放进去的栈帧
          栈顶元素  : 最后一个放进去的栈帧
   栈操作 
          压栈 : 就是指把元素放入栈空间的过程
          弹栈 : 就是把元素弹出去的过程
  
  栈内存,是用来执行方法的,所有方法的执行,必须在栈内存进行 
  本地方法栈 : 
          用来执行一些本地方法,比如hashCode 等 , 模型和操作都和VM栈一致 , 不用管,  
   堆内存 : 
           用来保存对象
 

 8 递归

                递归：方法中调用方法

                递归思想：递归个迭代是等价的 就是循环        先进后出

                注意 递归如果没有终止条件会导栈内存溢出

9  数组

                数组就是引用数据类型，用来保存多个数据，是多个同一数据的集合

                        数组
                    数据结构 : 计算机存储和组织数据的一种方式,合理选择数据结构会提升执行效率和存储效率
                    数组特性 : 下标0开始,查询更改快,添加删除慢
                    数组声明
                        静态声明 : 已知数组中每个元素的时候使用静态声明 
                            数据类型[] 变量名 = {值,值,....}   | 数据类型[] 变量名 = new 数据类型[]{值,值,...}
                     动态声明 : 不知道数组中每个元素的时候使用动态声明
                            数据类型[] 变量名 = new 数据类型[长度];
                       数组使用
                            查询 : 数组[下标]
                            更改 : 数组[下标]=值
                       数组排序
                            API : Arrays.sort(数组);
                            冒泡 : 相邻比较....
                            选择 : 假设第一个是最小的,和后面挨个比较.....
                            二分查找 
                                起始位置
                                结束位置
                                中间位置
                                        目标大于中间 则 结束不变 起始=中间+1
                                        目标小于中间 则 起始不变 结束=中间-1
                                        重新生成中间位置
                                        当起始 大于 结束位置时终止 

                9.2  二维数组

                                静态声明：int[][] arr = {{数值}；}；

                                动态声明：int[][] arr = new int[5][];

10 传值和传址

                        传值 指的是传递基本数据类型的数据

                        传址 指的是传递数据的地址

11  面向对象

                概述 ：用来描述客观事物的一个实体（也叫实例），由一组属性和方法构成

                对象的创建和使用：

                通过new 关键字创建对象，通过点运算符来访问对象的属性和方法；

                        例如：Student s1 = new Student（）；

                对象：就是某一个具体的事物，就是类的实现，保存了属性的值

                类 ：描述这一类事物的属性和特征

                静态变量：如果对象和对象之间有相同的属性和相同的值，就使用静态变量

                成员变量：如果对象和对象之间有相同的属性不同的值（也可以相同）就使用成员变量

                11.1  实例化

                        1 加载对应的类文件

                        2 new在堆内存创建空间

                        3 执行构造方法，对堆内存对象进行初始化

                        4 构造方法弹栈，并把堆内存地址返回给变量

        就是公共的类,私有化的属性,公共的获取属性的方法(getter/setter),公共的无参构造（也可以说想访问私有属性时，可以调用其类里包含私有属性的方法，间接访问私有化属性）

                11.1 对象调用静态属性

                                1 可以使用类名直接调用

                                2 可以使用对象进行调用，因为在编译阶段会把对象转换为类名调用

                 11.2  静态调用成员

                                1静态方法中，无法直接使用非静态属性

                                2需要使用对象调用才可以调用

                                区分成员方法和构造方法

                                        没有返回值的是构造方法，连void都没有，有返回值的是成员方法

                11.3  This

                                this是什么：是每个对象中，保存自身地址的一个引用型变量  this就表示当前对象

                                this的功能

                                1 在成员方法或者构造方法中，区分同名的成员变量和局部变量

                                2 用在构造方法中，重载调用当前类中其它构造方法，但是必须写在构造方法第一行

                                3 return this 返回当前对象的内存地址，可以链式调用

                                实例语句块：可以用来初始化

12 封装

                                把所有组成部分组合到一起,还可以通过权限控制修饰符将数据隐藏起来,可以控制用户对类数据的修改程度

                                  适当的封装可以让代码更容易理解,易于维护,更提高了代码的安全性

                        12.1  权限控制

                                        public ：公共的 谁都可以访问

                                        private： 私有的，只能在当前类中可以访问

                                        default： 不写权限控制符 默认default，同包中即可访问

                                        protected： 受保护的，要么继承，要么同包，要么有继承关系。

                        

13  继承

        

                13.1  概述

                                       已有的类中，派生出新的类，新的类用于父类的属性和行为 

                       继承实现步骤
                                1. 编写父类

                                2. 编写子类，使用extends关键字继承

                                         注意：java当中的继承具有单根性，即一个子类只能有一个直接父类

                       子类访问父类成员

                                1. 父类的非私有成员可以直接访问

                                2. 可以通过this关键字访问

                                3. 特殊情况下可以通过super关键字访问

                         继承条件下的构造方法
                                子类构造方法没有通过super显式调用父类的有参构造方法，也没通过this显式调用自身其他构造方法

                                系统默认调用父类的无参构造方法

                                子类构造方法通过super显式调用父类的有参构造方法，执行父类相应构造方法，而不执行父类无参构造方法

                                子类构造方法通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则 

                                无论什么时候，都要在父类当中显示创建一个默认的无参构造方法以被子类调用

                            注意
                                如果在子类构造方法中,没有显示出现super() 也没有出现 this(xxx)  则 默认有一个super() 调用父类无参构造

                                并且 super(xxx) 必须出现在子类构造方法 第一行  所以 this(xxx) 和 super(xxx) 不能同时出现

                                因为构造方法第一行有super()调用父类构造,所以 某一个类如果构造方法私有化了,那么该类不会再被继承

14      方法重写

                方法的重写也叫方法覆盖

                        子类根据需求对从父类继承的方法进行重新编写

                        重写时，可以用super.方法的方式来保留父类的方法构造方法不能被重写

                        在输出某个对象的时候，会默认调用这个对象的toString方法

                  重写规则
                        方法名相同

                        参数列表相同

                        返回值类型相同或者是其子类

                        访问权限不能严于父类 父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法不能被子类覆盖为静态方法

                        子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法(注： 静态方法中无法使用super)

                        父类的私有方法不能被子类覆盖

                        不能抛出比父类方法更多的异常