JAVA基础总结

我们能活多少年并不重要。我们的生命无非是有无数的瞬间组成的。

我们永远无法知道，它会发生在何时何处。

但这些瞬间会伴我们一生，在灵魂上印上永远的印记

                                                                                                                ---《不死法医》

Java 的数据类型

八大基本类型 :

整数型： byte  int   short   long.

浮点型： float    double.

字符型： char

布尔型： boolean(ture( 真 )     false( 假 ) ) 

八大基本类型

byte   >   short   >   char（默认值为空格）  >    int   >    long   >   float   >    double

字节：

1           2             2        4            8        4               8

整数型：

（ 1 ） byte 型：使用关键字 byte 来定义 byte 型整型变量 .

byte i=12;( 声明同时赋值 ) 。

对于 byte 型变量，内存分配 1 个字节，有效位 8 位（ 1 个字节），因此 byte 型变量的取值范围是： -2 7 ~2 7 -1 。

（ 2 ） short 型：使用关键字 short 来定义 short 型整型变量

short i=12;( 声明同时赋值 );

对于 short 型变量，内存分配给 2 个字节，有效位 16 位（ 2 个字节），因此 short 型变量的取值范围是： -2 15 ~2 15 -1 。

（ 3 ） int 型：使用关键字 int 来定义 int 型整型变量

int i=12; ( 声明同时赋值 );

对于 int 型变量，内存分配给 4 个字节，占 32 位，因此 int 型变量的取值范围是： -2 31 ~2 31 -1 。

（ 4 ） long 型：使用关键字 long 来定义 long 型整型变量 （ 以 L 结尾）

lont  i = 12; ( 声明同时赋值 );

对于 long 型变量，内存分配给 8 个字节，占 64 位，因此 long 型变量的取值范围是： -2 63 ~2 63 -1 。

浮点型：

（ 1 ） float 型：使用关键字 float 来定义 float 型变量

float i = 1.1f; 注意：必须以 f 或 F 结尾

对于 float 型变量，内存分配给 4 个字节，占 32 位， 7 个有效十进制数位， float 型变量的取值范围大约是： 3.403E-038~~3.403E+038 。

（ 2 ） double 型：使用关键字 double 来定义 double 型变量

double  i = 1.1d; (d 可以不要 )

double 型变量，内存分配给 8 个字节，占 64 位， 15 个有效十进制数位， double 型变量的取值范围大约是： 1.798E-308~~1.798E+308

字符型：

（ 1 ） 使用关键字 char 来定义字符变量 ，

char i = ‘A’, char i = ‘ 我 ’;

对于 char 型的变量，内存分配给 2 个字节，占 16 位，因此 char 型变量的取值范围是： \u0000’~’\uFFFF

布尔型：

布尔型用于逻辑条件判断，只占 1 字节，它只有两个值： 1 （ true 和 false 。不能转换成任何数字。

boolean a = true;   boolean  a = fa l se

变量和常量

（ 1 ）变量：

1 ）定义：可变的量。

2）语法：类型 变量名 = 赋的值； 如： int  a = 10;

（ 1 ） 常量：

1 ）定义：不可变的量。

2）语法：final 类型 变量名 = 赋的值   final 是一个关键字   它的值是不能改变的 。

运算符

算术运算符：+ - * /  %

关系运算符： >< >=  <= ==

复合运算符：+=  -=  *=  /= %=  

自增自减 ： ++ --    

                    {

                        前++ ：先加后运算 （+  - /   * ）加是给自己加

                        后++：先运算后加

                       }

低精度向高精度转 例子：

int a = 10;

long b;

b = a;

高精度向低精度转

需要强制转换

例子：

long a = 10;

int b;

b = int(a);

String 型的判断

String 型的判断是 :equals.

例子：

String a = “张丽洪”;

String b = “张”;

if(a.equals(b)){

System.out.println(“成立”);

}

for 循环

for(int i = 0; i < 10; i++){

System.out.println(i);

}

效果：0,1,2,3,4,5,6,7,8,9

While 循环

While(布尔表达式){

//…要执行的语句（代码块）

}

if 语句

if( 条件表达式 ){

//… 要执行的语句（代码块）

}

Switch 语句

Switch(条件表达式){

case 1: 

break;                                                  小心vase穿刺    switch支持 int  char  short  byte  不支持long         JDK1.7之前不支持 String

case 2:

break;

default;

}

在 switch 语句中，可以有 default ，也可以没有，单独的 default 也可以，如果没有 break ，代码就会一直运行，一直到找到 break 或者 switch 语句结束。整形类型出了 long 不行，其它都行，剩下的类型出了 char 行，其它都不行 ( 它不是循环语句 )

do...while 语句

do{

//… 要执行的语句（代码块）

}while( 布尔表达式 )

先执行 do 里面的代码块，再进行判断，不管判断是否成立 do 里面的代码都会执行。

三元运算符：

    

int a =3;

int b=a<0?4:5

声明问题

    （ 1 ） 局部变量声明： 局部变量初始化的时候必须要赋初始值，否则会报尚未初始化变量的错。 ( variable r might not have been initialized )

    （ 2 ） 全局 变量声明： 就是凡事跟方法（ Js 中的函数）一起的时候就为全局变量或者属性。

全局变量时必须要有 static ，可以不赋初始值，如果没有 static 会报无法从静态上下文中引用非静态变量 ( non-static variable r cannot be referenced from a static context

)

    （ 3 ） 类（ class ） ：是由属性和方法组成。

java对象：

                  Java 中除了八大基本类型以外其它都称为引用类型或对象。

    数组和 St r ing 都是对象。

    不给对象赋值运行出来的就是： null

    八大类型只要一声明就有内存，引用类型和对象，必须 new 才会有内存， String 除外， String 要赋值才有内存。

    八大类型的初始值和默认值：

    整数型： “0“   浮点型： “0.0“    布尔型： “false“   字符型： “ 一个空格 “

数组：

    数组是用了存储相同类型的数据的一种数据结构。

    定义一维数组如下：

    类型 [] 数组名 = new 类型 [ 维数 / 长度 ];

             类型 [] 数组名 = new 类型 [ 维数 ][元素1，元素2];

             类型 [] 数组名 = {1，2，3，4}；

    例如-在定义时并赋值： 

            int[] array = new int[]{1,2,3};

    定义二维数组如下：

    类型 [][] 数组名 = new 类型 [ 维数 / 行 ][ 维数 / 列 ];

    例如-在定义时并赋值：

    int[][] array2 = new int[][]{{1,2,3,4,5},{6,7,8,9,10}};

    输出必须要用 for 循环

    需要注意的是数组的下标是从 0 开始的，如果数组长度只有 5 ，那么该数组的最后下标也就是 4 ，如果往下标 5 添加数据则会标以

    下异常： java.lan g .ArrayIndexOutOfBoundsException （数组下标越界）

数组加长：

例如：做学生系统增加的时候

int count = 0;//统计增加的个数.

String stu[][] = new String [2][5];//原数组，装学生信息。

    if(count>=arr.length){

        String a[][]=new String[count*2][5];//新数组，当count大于等于stu数组长度时候就把count*2.

        for(int i = 0 ; i <stu.length;i++){

            for(int j=0;j<stu[i].length;j++){

            a[i][j]= stu[i][j]; //把stu数组里面所有的数据都赋给a数组

            }

        }

    arr=a;//数组长度增加成功后把a数组里的数据又赋给stu.

}

Java方法:

    方法的定义： 把相同功能的代码块放在一起或把某个功能封装在一起。

    实参： 已定义并赋予初始值的变量和对象，是实实在在的数据。

    形参： 方法在定义的过程中只是为此功能定义了一个框架，以及需要参与运算的变量数据 。

冒泡排序：

    基本原理：对未排序的元素从头到尾依次比较相邻的两个元素是否逆序，若逆序就交换这两个元素，经过第一轮比较后便可把最大的（或最小的）元素排列好，然后再用同样的方法把剩下的元素逐个进行比较，就得到了你所需要的顺序。如果由n个元素，那么一共要进行比较n-1次比较，第i轮窑进行n-i轮比较。

例如：

class Test{

public static void main(String[] args){

        int[] array = new int[]{7,8,9,5,4,3,6,1,2,0};

        int temp = 0;

        for(int i=0;i<array.length;i++){

            for(int j=i+1;j<array.length;j++){

                if(array[i] > array[j]){

                    temp = array[j];

                        array[j] = array[i];

                    array[i] = temp;

                }

        }

}

    for(int i=0;i<array.length;i++){

        System.out.print(array[i]+”  ”);

        }

    }

}

对象 ：万物皆对象，是实实在在存在的实体

|   对象是类的实体

类：用来描述对象的一个抽象描述（类与对象的关系）

方法重载：

    定义： 在同一类里面 存在一个以上的同名方法的现象

    规则 ： 形参列表要不同 与返回值无关   同一个方法名相同

            优点： 1方便记忆  2.根据重载机制，方法调用根据形参列表不同自动匹配

  传值、传引用：

     1 ） 传值 （八大基本类型） ： 传递的是值

                                            特征 ： 形参痛引用传递一样也会单独开辟一块空间，形参发生改变不会影响到实参  所以要用return返回值

     2 ） 传引用（数组 非八大基本类型 或对象） ： 实际上传递的是 地址  是将不同名称的数组或对象指向同一个地址

                                            实参: 调用方法的参数叫实参（实际参数）

                                            形参 : 被调用的参数叫形参（形式布上的参数 ，形式上的参数跟实参操作的都是同一个地址，无内存） 

    

在不同类中对静态方法和属性与非静态方法和属性调用

有 static 的情况（静态的值调用）：

在静态上下文中（ main 方法中） , 我们要调同一路径中的另外一个类中的方法或属性（此类中没有 main 方法，有 static ）调法如下：

    调方法：类名 . 方法名（）

    调属性：类名 . 属性名 .

没有 static 的情况（非静态的值调用）：

在静态的上下文中 (main 函数中 ), 我们要调用同路径的另一个类的方法 ( 此类中无 main 函数 , 且无 static) 调法如下：

    首先要 main 方法中 new 出来： 类名 变量名（随便给） = new 类名（） ；

     然后调用的时候是： 变 量名 . 方法名（）； 这是方法的调用。

                                    变量名 . 属性名； 这是属性的调用。

Java数据结构：

                队列

特点： FIFO （先进先出）。 （好比是排队的时候）

        队列的主要运算：

                                                （ 1 ）：插入一个新队尾元素简称入队；

（ 2 ）：删除队首元素简称出队；

                                              （ 3 ）：队满（对里面为满的时候）；

                                                （ 4 ）：队空（队里面为空的时候）；

 

 

        队列： 是限定只能在表的一端进行插入运算，在表的另一端进行删除运算的线性表，在表中允许插入的一端叫做队尾，表中允许删除的一端叫队首

栈：

    特点： FILO( 先进后出 ) 。

    栈： 限定只能在表一端进行插入和删除的线性表，在表中允许插入和删除的一端叫做栈顶，而不允许插入和删除的一端叫栈底 。

    队列的主要运算：

            出栈的时候是从最后进来的哪个先出去。（好比是洗碗的时候）

单向链表：

        内容

        定义 ：用一组任意存储单元，存放线性表的数据元素，并且通过指针相连接结点的序列，称为链表。

        作用：为了表示数据元素之间的逻辑关系，除了存储数据本身外，还必须存放指示其后继元素的 “ 信息 ” 这一信息，我们称为指针或链，其作用是保存后继元素的存储位置。

    单向链表 ：若链表中的结点包含一个指针域，则称之为单线表或线性表。

    结点 ：包括数据区域和指针区域。

双向链表：

    内容

     缺点 ：只能顺着结点的直接后继查找结点。

     双向链表 ：由前指针、数据区域、后指针组成。

        顺序表和线性表的区别为：线性表的所有元素是存放在一组地址连续的存储单元中，数据元素在线性表中的顺序号可确定它在存储单元中的位置，因此顺序中不需要指针域。

        因此线性表便于查找，但是不利于插入和删除，也不便于扩充因为它是边续的地址。它也是静态的存储结构，而链表不便于查找但便于插入，删除且速度快。

结构 ：数据之间的关系；

数据结构 ：带有结构的数据对象；

线性结构 ：各数据元素之间的逻辑以用一个线性序列简单的表达出来，则称之为线性结构 ，否则称为为非线性结构

线性结构的特点： 在数据元素的非空有限集合中，有且仅有一个被称 “ 第一个 ” 数据元素，仅有一个被称为最后一个元素，除第一个元素外，其余所有元素有且仅有一个直接前驱元素除最后一个元素外其余所有且仅有一个后继元素。

线性的主要的运算： 1 ）存取：更新或添加某个数据元素。

                                    2 ）插入：在表的两个确定元素之间插入一个新的数据元素。

                                  3 ）删除：删除表中的某个数据元素。

                                  4 ）查找：查找满足条件的某数据元素。

                                  5 ）合并：把两个性表合并成一个线性表。

                                  6 ）分拆：把一个线性表分拆成多个线性表

键表： 有一组任意存储单元存放线性表的数据元素，并且通过指针键相连的节点的序列称为键表。

数据元素： 它是数据的基本单位，即数据集合的个体，有时数据也称做节点或记录等。

数据项： 它是有独立含义的数据最小可命名单位，有时也可以把数据项称做域，字段

数据对象： 具有相同特征的数据元素的集合。

树和二叉树

树：

    根节点 ：一棵树中没有父节点的节点为根如：A                                         

    叶节点（终端节点） ：没有子节点的节点为叶节点。如：K, L, F, G, M, I, J

    非叶节点 ：如：A, B, C, D, E, H      。                                 

    父节点 (parent) 和子节点 (child) ：E是 K,L 的父节点，K,L是 E 的字节点

    兄弟 (siblings) ：H, I, J  为兄弟，K, L  也是兄弟                            

    分支度 ：A 节点的分支度为 3 ，B 节点的分支度为 2 ，G 节点的分支度为 0

    树的最大分支度 ：树中所有节点的最大分支度。如图树的最大分支度为3 ，因为所有节点的分支度没有超过3 。

    树林 ：如果把A 移除，则形成B,C,D3 棵树的树林，或者森林。

    祖先(ancestors) 和子孙(descendants) ：B  的子孙为 E, F, K,L 。

    阶层(level) ：E 的阶层为3 ，K ，L 的阶层为4

    高度和深度： K, L, M 具有最大的阶层 为 4，所以 树的高度为4。

二叉树

    二叉树可以为空，树必须有根节点 。

    计算二叉树节点最多的个数 ： 在二叉树的第i层上最多有2的i次方减1（2i-1）个节点(i>=1) ; i 为二叉树的层

    一棵树如果是满二叉树，那么它一定是完全二叉树，一棵树如果是完全二叉树，它不一定是满二叉树。

满二叉树 ：树中所有节点均为同一阶层。

完全二叉树的条件 ：

1. 深度减一为满二叉树。
2. 从做到有如深度层不能为空。

二叉树的遍历：

树和二叉树的比较：

1. 二叉树可以为空，树不可以（至少要有根节点）
2. 二叉树的子树有顺序关系，树没有
3. 二叉树的度必须为0，1，2。树的节点可以大于2.

数组和链表的区别：

    数组（顺序表） ：定长（静态分配类存）逻辑上与物理上都相邻，便于查询和修改（因为是下标定位），不便于增加与删除（因为数据的移动量过大）。

    链表 ：变长（动态分配类存）逻辑上与物理上不相邻，便于增加与删除（因为可以指针直接指向），不便于查询与修改（需要从链头找到链尾数组量过大）。

Java 平台两大组件：

    1 ） Java 虚拟机（ J V M ）

        a.类装载器：把代码加载进来

                            类中静态变量的初始化就是在类装载器中实现的（将变量放入内存   给予他一个初始值）

                            类装载器的最小执行单位是class文件--->二进制文件

                             类装载器的原理就是用谁装谁（懒惰式加载）

        b.字节码校验器：检查一些错误

        c.解释器：执行一些二进制文件

2 ） Java 应用程序编程接口（ API   全写： Application program interface ）

java的特点  

        1.简单：设计java的初衷是为了构建一个无需深奥专业培训就可以进行编程，易于理解

        2.面向对象：是一种程序设计技术，它将重点放在对象（即数据 ）和对象接口上

        3.跨平台（java最大的特点）：不同版本的jdk，安装到不同的操作系统上，不同的操作系统有不同的虚拟机，java虚拟机屏蔽了底层运行平台的差别，实现了一次编译，四处运行

*.java-->(javac)--->*.class--(java)---到不同的操作系统上

        4.安全

        5.多线程

java4个基本特征 ： 抽象，继承，封装，多态

static：

                 1.static不能修饰类。但是可以修饰类里面内容

                2.static可以修改属性，修饰的属性可以被类名直接调用

                3.static可以修饰方法，修饰的方法为静态方法，可以用类名直接调用

                4.静态区域不能以任何形式访问非静态区域，反之可以

                   原因：静态方法在main方法没有执行时已经被装载到内存中了，这时分静态方法在内存中没有，所以会报错        非静态调用  new一个对象来调用方法

        5.代码块

                构造代码块  { }：可以有多个，new当前类就可以执行，且依次从上往下执行

                普通代码块

                静态代码块   static {    }：  不能放单方法中   1.可以有多个 2.只要动这个类（调用属性，方法  new等）就可以执行  且依次从上往下执行

        6 .对象变量和类变量

                对象变量 (又称全局变量，全局静态变量，属性，成员变量，实例变量)  在堆里

                                :对象变量是属于对象的，每一个对象都拥有自己各自的空间。随着对象的创建而创建，随着对象的回收而回收

                            类变量： （全局变量，全局静态变量） 在常量池   类变量是属于类的，空间是每个对象公共的空间。随着累的加载而加载，随着类的消失而消失

private：

            封装是一种信息隐藏技术（隐藏细节）

            属性私有化，重写set  get方法

            从具体到抽象（把一个具体的人抽象成一个类）

            从抽象到具体（当解决具体问题时，将抽象的代码数据具体成具体的数据给客户端）

方法重载：

        在一个类里面  存在一个以上同名方法的现象

    规则：1.形参列表不同（与类型有关，和形参名称无关）

                    2.与返回值无关

                    3.在同一个类方法名相同

        有点：1. 方便记忆  2.根据重载机制，方法调用根据形参列表的不同，自动匹配调用

继承 extends：父类的东西相当于子类的

        特征：1.父类是具有共同特征的一些方法或属性，我们单独把它拿出一个类来写

                    2.继承越子类越具体 越父类越共性

                    3.可以实现代码重用

         

        子类只能继承非私有的

        任何私有的属性，只能在本类中访问

        子类要想访问私有的的只有通过方法访问

 

重写：

          当我们从父类哪里继承来的方法不能满足子类的需求时，就要重新写一个同名的方法，这就是重写。重写的方法会将父类的方法覆盖

       规则：

                1.子类根据需求从父类继承的方法进行重写

                2.重写的方法要和被重写的方法具有相同的方法名，参数列表，返回值类型（基本等于拷贝）

                3.子类的权限大于等于父类的权限

                4.子类的异常小于等于父类的异常

重写和重载的区别

        1.重写要继承   重载不用继承

          2. 重载是一个类，重写是两个类

            3.重载的返回值类型可以不一样，而重写的返回值类型必须一致

构造方法（核心作用：数据初始化）：

              定义： 方法名和类名相同的方法，且没有返回类型，在new的时候会自动调用，遵行方法重载的原则。

            规则：

                1.可以使用任何权限修饰符  pirvate public 。。。

                2.构造方法不能用static修饰

                3.不能有void修饰符，但返回的是本类对象

                4.方法名和类名一致

                5.不能像调用普通方法一样调用构造方法。只能用new关键字自动调用

                6.构造方法可以使用return关键字

                7.构造方法可以重载

                8.构造方法不能被继承

                9.和new 关键字搭配使用构建一个新的对象

                10.分为  有参构造方法  和无参构造方法

当一个类没有任何构造方法时 JDK会提供一个默认的构造方法

如果写了 JDK就不会提供

良好的编程习惯：但凡在一个类中写构造方法，一定要写一个空构造方法

This 与super的区别：

1 ）、this指当前类里面的全局变量，this可以用在构造方法的互调（ 必须是本类中 ），必须放在第一行。

2 ）、一个构造方法的第一行只能是this 或 super

3 ）、构造调用只能出现在构造方法里，不能出现在普通方法里

4 ）、super是调父类，this是调本类。Super.方法名（）；super.属性名；不能同时使用

5）、只要动子类的构造方法，必定会调用父类的构造方法

6）、属性是在构造方法执行完第一行代码之后才分配内存

7）、属性空间的分配是从父类到子类（先父后子）

8）、构造方法的调用时先子类后父类

9）、构造方法的执行次序是从父类到子类

static 不能修饰super与this。

        

   多态     （父类的引用指向子类的实例）                   

    

定义 ：多态是建立在继承基础之上的，继承机制判断允许将某个对象看成所属类，也可以看成超类（父类），因为有了这种能力就可以将多个类看成一个类。子类重写父类的方法后，当方法被同一个类调用时，会根据对象的所属类而产生不同的行为，就叫多态。

面向对象 ：以数据为核心

面向过程：以方法为核心

方法时先调子类的 属性先调父类的

多态的3要素：

         继承

         封装

         父类的引用指向子类的实例

多态的好处：

         1.代码结构 提供最大的灵活性

         2.扩展性增强

         3.便于维护

抽象类 abstract

        抽象类是：逆这类的继承关系，类逐渐变的通用，我们把这个类用其他类的基础，定义此类事时可以仅声明方法而无方法体

    抽象类不能有抽象构造方法和抽象静态方法

    规则:

        1.普通类里面可以有的，抽象类也可以有（属性，构造方法，普通方法，构造代码块，静态代码块）

        2.抽象类不能被实例化（因为调用抽象方法没有意义）

        3.抽象类中没有抽象方法，也可以有

        4.含又抽象方法的类一定是抽象类

        5.如果父类有抽象方法，要么重写方法，要么子类就是抽象类

        6.抽象类只支持动态绑定机制

        7.抽象方法不可以又是 static native private final

接口 interface

    

    接口：接口是类似于类的一种结构，比抽象类更抽象，可以理解为 “纯”的抽象类，它不带任何实现细节，不与任何存储空间关联，支持多继承。

   规则：1.接口里面的方法都是抽象方法

            2.接口里面的所有方法都是public，也可省略，不写默认public 不能是private

            3.接口里面不能有构造方法

            4.接口里面直接定义属性  属性需赋值 且默认为普public

类 继承只能继承一个  

接口 implements 可以实现多个接口  弥补了java单一继承的缺陷

final 

1.final修饰的类为最终类，不能继承

2.final修饰的变量或属性为常量

3.final修饰的方法不能被继承可以被重写

4.final不能修饰构造方法

5.final可以修饰形参

对基本对象不可改变的是值对引用类型  不可改变的是地址

 

 . 抽象类可以继承抽象类以及普通类。

 * 抽象类可以实现接口

 * 接口不能继承抽象类

 * 接口可以继承接口

 *   接口中的变量都是 public static final 常量

==号与equals的区别：

       1.八大基本类型用== 比的是值

        2.非八大类型  比的是地址

        3.引用类型调用object里的equals方法  等价于引用类型使用==号  比的是地址

        4.如果想要使用引用类型里的equals方法  那么在其关联类中必须重写equals方法

谁无个见字如面斗转二十秋

谁家老者怕登楼谁人故旧不如旧

谁渐忘岁月忽晚梨花卧满头