詹姆斯·高斯林

1、javaSE，标准版，各应用平台的基础，桌面开发和低端商务应用的解决方案。

2、javaEE，企业版，以企业为环境而开发应用程序的解决方案。

3、javaME，微型版，致力于消费产品和嵌入式设备的最佳方案。

1、开发桌面应用程序。

2、开发面向Internet的web应用程序。

3、提供各行业的解决方案。

4、开发android手机应用程序。

1、一种面向对象的编程语言。

2、一种与平台无关的语言（根据JVM实现的）。

3、一种健壮性语言。

4、具有较高的安全性。

先编译（.class），在解释运行。

1、编写源程序，java源代码文件。

2、编译源程序，编译器编译编译成java字节码文件。

3、运行，java虚拟机（JVM）。

在java运行过程中自动启动，程序员无法干预。

JDK：java开发工具包

    先编译（编译器javec），后运行（解释器java）

JRE：java运行环境

    加载代码（加载器），校验代码（校验器），执行代码（解释器）

  java虚拟机实际上只是一层接口，一层Java程序和操作系统通讯的接口。java文件编译生成class文件，

而java虚拟机就是这些class文件能够在上面运行的一个平台，你把class文件看成一个软件，java虚拟机就是这个软件可以运行的操作系统。

1、一个源文件中只能有一个public修饰的类，其他类个数不限。

2、一个源文件有n个类时，编译结果的class文件就有n个。

3、源文件的名字必须和public修饰的类名相同

4、java语言中单词拼写大小写严格区分。

5、main方法入口

6、每一句以分号（;）结束

1、单行注释//

2、多行注释/* */

3、java文档注释/**  */

1、命名规则：由字母、下划线、数字和美元符号组成，不能以数字开头，区分大小写，不能是关键字和保留字（goto、const），长度一般不超过15个字符。

2、驼峰式命名：

    类名：单个单词，首字母大写，多个单词，首字母都大写。

    方法名、参数名、变量名：单个单词，首字母小写，多个单词，第一单词首字母小写，其他单词首字母大写。

    包名：全部小写。

1、基本数据类型：

    数值型：byte     1字节   8位   -128~127

        short    2字节   16位  -32768~32767

        int      4字节   32位  -2^31~2^31-1

        long     8字节   64位  2^63~2^63-1

    浮点类型：

        float    4字节   32位  

        double   8字节   64位

    字符型：char     2字节   16位   0~65535

    布尔型：boolean  true    false

2、引用类型：

    字符串 String、 类 class 、枚举 enum、接口interface

1、计算机中的数据都以二进制数据保存。

2、计算机信息的存储单位：

    位（bit）：是计算机存储处理信息的最基本的单位

    字节（byte）：一个字节有8个位组成。

\n 换行  \r 回车  \t 水平制表  ‘ 单引号  " 双引号  \斜杠

1、自动类型转换：范围小→范围大

    byte→short→int→long→float→double；

    char→int→long→float→double          

2、强制类型转换：范围大→范围小

    需要加强制转换符

1、数据类型划分：

    基本类型变量：数据的值

    引用类型变量：数据的地址

2、声明的位置划分：

    局部变量

    全局变量

        区别：

        1、默认值

            局部没有默认值，使用前必须初始化。

            全局有默认值，默认为0，不必须初始化。

        2、声明位置

            局部在方法内。

            全局在方法外类内。

        3、作用位置

            局部只能在自己声明的方法里。

            全局在整个类中

算术运算符：+ 、 - 、 * 、 / 、 % 、 ++ 、 --

赋值运算符：= 、 += 、 -= 、 *= 、 /= 、 %=

关系运算符：> 、 >= 、 == 、 !=

逻辑运算符：! 、 & （只要有一个false  最终结果就是false） 、

         | （但凡有一个true   最终结果就是true） 、

         ^ （如果两边一样     最终结果为false   如果两边不同   最终结果为true）、

         &&（如果第一个是false 那第二个不执行  最终结果是false）、

         ||（如果第一个表达式的结果是true 那第二个表达式 就不去计算了 ,最终结果是true）

位运算符： ~ 、 >> 、 >>>

字符串连接运算符：+

三目运算符：X ? Y : Z

            X为boolean类型表达式，先计算x的值，若为true，整个三目运算的结果为表达式Y的值，否则整个运算结果为表达式Z的值。

结构化程序的三种结构：

    顺序、选择（分支）、循环

1、if（）{}

2、if（）{}else{}

3、if（）{}else if(){}

4、if（）{if(){}else()}    

5、if（）执行语句 esle   执行语句 注意：执行语句只有一条语句的时候.可以将if esle 的大括号省略

注意：（）内是boolean类型表达式，{}是语句块

    比较字符串用equals，比较内容。比较数值用==，比较地址。

    基本数据类型：变量名、变量值在栈中。

    引用数据类型：变量名在栈中，变量值在常量池中。

switch(表达式expr){

    case const1:

        statement1;

        break;

    … …

    case constN:

        statementN;

        break;

    [default:

        statement_dafault;

        break;]

}

注意：1、表达式必须是int、byte、char、short、enmu、String类型

      2、constN必须是常量或者finall变量，不能是范围

      3、所有的case语句的值不能相同，否则编译会报错

      4、default可要可不要

      5、break用来执行完一个分支后使程序跳出switch语句块，否则会一直会执行下去。

1、if可以判断范围，也可以判断一个值

    switch只能判断指定的值

2、若只判断指定的值，则使用switch语句，效率快

   if判断范围，对数据判断灵活，自身的格式也比较灵活

for ([循环变量初始值设定]; [循环条件判断]; [改变循环变量的值])｛

        循环体

｝

注意：1、表达式2一般不可以省略，否则死循环

      2、表达式3可以省略，但是在循环体中必须有语句修改变量，以使表达式2在某一时刻为false结束循环。

      3、若同时省略表达式1，表表达式3，则相当于while（表达式2）语句

      4、三个表达式均省略 即for(;;)语句，此时相当于while(true)语句

      5、表达式1、表达式3可以是逗号表达式,以使循环变量值在修改时可以对其它变量赋值

while( 条件表达式语句)｛

     循环体语句;

     }

  [初始条件]


  do｛

    循环体;

[迭代]

｝while( 循环条件判断); 

  注意：1、当第一次执行时，若表达式=false时，则while语句不执行，而do/while语句执行一次后面的语句
  2、一定要切记在switch循环中，如果没有break跳出语句，每一个case都要执行一遍，在计算最终结果。

break跳出某个循环

continue跳过某个循环

注意：if外有循环可以用break、continue，单纯if不可以用。

1、为什么使用方法？

    减少重复代码，提供代码复用性

    使用方法将功能提炼出来

    写在类内

2、声明格式

    [修饰符] 返回值类型 方法名([形式参数列表]){

              程序代码;

              [return 返回值;]

            }

   注意：1、方法是给外界提供内容的位置，形式参数是外界提供的

     2、方法调用的时候写的是实际参数

     3、实际参数的类型、顺序和形参要对应上

     4、支持自动转换类型，不支持强制类型转换

1、将数据返回给调用者，除了void外，return后必须跟着返回值，只能返回一个。

2、终止方法的执行，返回数据类型必须是void，return后不能添加数据。

注意：1、当return结束方法的时候，要让其后面的代码有可能被执行到。

      2、一个方法里可以有多个return，在void里不能有返回值，其他的必须有返回值。        

1、在一个类中，方法名字相同，参数类型不同。

   参数类型不同：个数、数据类型、顺序。

注意：

    1、重载和返回值类型，修饰符没有任何关系。

    2、参数变量名修改也不能够重载

1、有返回值

2、有参数

3、能够有跳出循环的控制语句

4、自己调用自己

1、面向对象：是以具体的事物为单位，考虑的是它的特征（属性）和行为（方法）。

2、面向过程：是以具体的流程为单位，考虑功能的实现。

1、对象：看得见摸得着的具体事物。

     类：抽象化的概念

2、类和对象的关系：

     类是对象的模板/抽象化的概念，对象是类的实例。

3、创建类和对象

     类：

    特征：全局变量/属性/成员变量

    动作：方法

    对象：

    类名 对象名=new 类名（）

    注意：一个类可以创建多个对象，，每个对象之间没有关系。

1、栈：先进后出，存放基本数据类型变量名和变量值，引用数据类型的变量名，方法执行的时候进入栈中。

2、堆：先进先出，new出来的对象的实例，包括类的属性个方法。

1、构造方法是new关键字调用的，用来帮助构建对象

2、显示构造对象

3、隐示构造对象（没有显示的情况下存在）

4、构造对象可以重载，参数类型不一致。

1、static调用格式：

    1、同一个类中：

        静态的：

            方法名     属性名

            类名.方法名  类名.属性名

            对象名.方法名 对象名.属性名

        非静态的：

            对象名.属性名 对象名.方法名

    2、不同类中:

        静态的：

            对象名.方法名 对象名.属性名

            类名.方法名  类名.属性名

        非静态的：

            对象名.属性名 类名.方法名

    注意：1、static可以修饰属性、方法、代码块，不可以修饰类和构造方法。

          2、静态方法随着类的加载而加载。

          3、在静态方法区内的东西只有一份，所有的对象共享这一份空间，只要有一个对象对属性进行修改，所有的对象调用都是修改后的数据。

          4、代码块的执行顺序：静态代码块（只被调用一次）>构造代码块{}>构造方法>普通方法（需调用）

2、this关键字

    1、可以调用属性和方法。

        this.属性名（全局变量）

        this.方法名（）;

    2、在构造方法中：

        1、this();括号内的参数个数、顺序、类型根据调用的方法来决定。

        2、必须放在第一行，只能调用一次。

        3、调用构造方法时只能在构造方法中调用，调用属性和方法时可以在构造方法中可以在普通方法中。

        4、当全局变量和局部变量有重名字的时候，用this来区分。

3、super关键字

    1、super指代父类对象。

    2、super可以调用属性、方法、构造方法。

    3、super调用父类的构造方法。

    4、super调用构造方法时候必须放在第一行。

4、final最终的

    1、可以修饰全局变量，声明的时候必须赋值，只能赋值一次。

    2、可以修饰局部变量，声明时候可以不赋值，但也只能赋值一次。

    3、可以修饰方法，可以正常使用，不能被重写。

    4、可以修饰类，可以正常使用，不能被继承。

    5、用final修饰的属性通常叫常量。

    6、static final 全局变量。每个字母都要大写。

5、this和super的区别

    1、this指的是本类创建的对象。                           super指代的是父类的对象

    2、this可以调用属性、方法、构造方法。                   super也可以调用属性、方法、构造方法。

    3、this调用属性和方法的时候，调用自己本类的属性和方法。 如果本类没有，那就用super去父类中找

    4、this调用构造方法调用，调用本类的其他构造方法。       super调用父类的构造方法。

    5、this和super在调用构造方法的时候必须放在第一行。

    6、this和super不能同时存在

6、最小作用域最强原则：

    局域变量在此方法中，比全局变量在此方法中的作用强。

        作用：提高代码的安全性

        1、将属性私有化，并提供对外界的接口（get/set方法）。

        2、用private修饰的属性和方法，只能在本类中使用。

  　作用：提高代码的复用性，减少重复代码

    1、子类可以继承父类非私有的属性和方法，不能继承构造方法和私有的属性和方法。

    2、可以综合子类的共同特征来去提炼父亲的类。

    3、子类在继承父类的各种属性和方法时，也可以有自己的属性和方法。

    4、一个子类只能有一个父类，java只能单继承，不能多继承，因为多个类中的方法名相同，方法体不同，不知使用哪个。

    5、一个类继承最顶端叫做基类或者超类，所有的超类叫做object 。

    6、在继承关系中，如果父类没有无参数的构造方法，如何解决？

           1>子类中添加一个和父类构造方法参数列表相同的构造方法，通过super参数传递给父类的构造方法

           2>如果父类允许修改的时候，可以在父类中创建一个无参的构造方法

    7、在继承关系中，代码块的执行顺序：父静>子静>父构造代码块>父构造方法>子构造代码块>子构造方法

    1、分类

        编译时多态：在编译过程中察觉的多态，重载，向上转型。

        运行时多态：在运行过程中察觉的多态，向下转型。

    2、向上转型、向下转型是在继承关系中，向下转型必须在向上转型的基之上。

    3、在继承关系中，父类的对象可以指向子类的实例，父类引用实体方法的时候，是调用子类重写以后的方法。

    4、向上转型

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

        父类类名 对象名=new 子类类();

        优点：减少重复代码，提高代码的复用性

        缺点:父类的引用无法调用子类特有的属性和方法

        解决方案：向下转型

    5、向下转型：

        子类对象的父类引用赋给子类

        子类类名 对象名=（子类类名）父类对象;

    6、 instanceof 判断左边的对象是否属于右边的类  对象名 instanceof 类名（子类类名）

    7、匿名对象

        new 类名（）  只有堆空间，没有栈空间，只能属于一次，为了节省代码。

作用：节省代码，提高代码的复用性

1、抽象类格式：访问权限修饰符   abstract class 类名{}

2、抽象方法格式：访问权限修饰符  abstract 返回值类型  方法名(形式参数列表);

注意：

    1、如果一个类里有抽象方法，那么这个类必须声明成抽象类。

    2、一个类里面可以没有抽象方法，可以有非抽象方法，

    3、类继承抽象类：

        把子类也用abstract修饰，变成抽象类。

        子类重写父类的抽象的方法

    4、抽象类不能创建对象。

    5、抽象类可以有构造方法，在创建子类的时候，super隐式调用父类的构造方法，将父类的属性和方法放到子类的对象空间里。

    6、在继承你关系中，子类能够继承抽象类的各种属性和方法，除了私有的和构造方法。

    7、只有公开的才可以和abstract连用，static final private 都不可以。

        static属于类方法，不允许覆盖，abstract必须被覆盖。final不能被重写。

作用：规范了代码，提高代码的拓展性

1、格式：访问权限修饰符  interface 接口名称{}

2、实现类的格式：访问权限修饰符  class 实现类名  implements 接口名{必须重写接口中的所有的抽象方法}

3、接口中只有全局常量和抽象方法。

4、书写的时候可以省略部分修饰符，系统会默认给添上。

5、接口在实现的同时去继承，extends在implement前面。

6、接口可以多实现，实现的也必须是接口，方法名可以重复，实现类实现一个就行了，因为没有方法体，不会发生冲突。

1、关键字：抽象类 abstract      接口interface

2、抽象类继承 extends         接口实现 implements

3、子类继承抽象类和          实现类实现接口的格式不同

4、接口中只有全局变量和抽象方法        抽象类中有各种属性和方法

5、抽象类只能单继承              接口可以多实现

6、抽象类的子类只能继承一个父类    实现类可以实现多个接口，并且还可以继承父类

7、抽象类的作用：提高代码的复用性   接口的作用：1、规范代码2、提高代码的拓展新

1.在子类中。

2、返回值相同、方法名相同、参数列表相同。

3、访问权限修饰符不能比父类更严格。

4、父类的方法不能够满足子类需求的时候，子类需要重写父类的方法。

1、重写是在继承关系中             重载是在同一个类中

2、重写是方法名、参数列表和父类相同      重载，方法名相同，参数列表不相同（个数、类型、顺序）

3、重写返回值类型和父类相同          重载和返回值无关

4、重写访问权限修饰符不能比父类更加严格 重载没有要求

              本类中       本包中        其他包子类       其他包非子类

  public         √        √       √        √

  protected      √        √       √        ×

  default        √        √       ×        ×

  private        √        ×           ×        ×

object中的equals比较的是地址，底层封装的是==

==比较的是基本数据类型，比较的是内容

    引用数据类型比较的是地址

String中也有equals，String中的equals被重写过了，比较的是内容。

1、声明了对象名，但没有给对象初始化，然后使用这个对象

2、遇到了类类型作为属性的时候，就必须初始化，否则就会报错

   分类：成员内部类、静态内部类、局部内部类、匿名内部类

1、成员内部类：

    1、可以用四种访问权限修饰符修饰

    2、可以有自己的属性和方法，除了静态的。

    3、可以使用外部类的所有属性和方法，包括私有的。

    4、创建对象

        1、通过创建外部类对象的方式创建对象

        外部类 外部类对象=new 外部类();

        内部类 对象名=外部类对象.new 内部类();

        2、内部类 对象名=new 外部类.new 内部类();

2、静态内部类

    1、格式：static class 类名{}

    2、可以声明静态的属性和方法

    3、可以使用外部的静态的属性和方法

    4、创建对象

        内类名 对象名=new 内类名();(可以直接创建)

        外部类名.内部类 对象名=new  外部类.内部类();

        包名.外部类名.内部类 对象名=new  包名.外部类.内部类();

    5、外部类与内部类同名时，默认是使用内部类对象调用外部类属性

        this代表内部类对象

    6、要想使用外部类属性，需要使用外部类对象调用

3、局部内部类

    1、在方法中声明

    2、只能用default修饰

    3、可以声明属性和方法，但不能是静态的

    4、创建对象，必须在声明内部类的方法内创建

    5、调用方法的时候，局部内部类才会被执行

4、匿名内部类

    1、匿名内部类只是用一次

    2、格式：

    父类或接口名 对象名=new  父类或接口名（参数列表）{

       重写抽象方法

            }

    调用抽象方法：对象名.方法名

1、单例模式

    分类：懒汉式、饿汉式

    1、构造方法私有化

    2、在本类中创建本类对象

    3、保证对象的唯一性final

    4、给外界提供得到对象的方法 static

    5、在多线程中，饿汉式安全，懒汉式不安全

2、简单工厂模式

    批量创建对象

    1 创建工厂类 : 创建对象的方法

    2 果汁类 是所有种类果汁的父类

    3 在工厂类的方法中返回果汁类

    4 根据测试类中传递的字符串判断到底返回哪种果汁

    5 测试类通过工厂类返回果汁对象

3、建造者模式 

    内部类使用场景

    目的：静态内部类创建外部类对象

    1、 创建外部类，在其中创建一个静态内部类

    2、静态内部类中写属性，构造方法和set get方法

    3、静态内部类中写一个方法，必须返回外部类对象

    4、 给外部类创建对象，传递参数。

4、装饰者模式

    1、在处理流中使用

    2、子类重写父类的方法,提高父类方法的功能及效率

    3、为了尽可能减少重复代码,在重写的方法中用父类的对象调用父类原来的方法

    4、得到父类对象可以通过将父类对象作为子类属性,通过子类构造方法传递父类对象

1、声明：

  int a[];  int []b;

2、初始化：

    动态初始化：1、a=new int[2]; int[0]=1;...

    动态初始化：2、b=new b[]{3,4};

    静态初始化：int [] c={5,6};

3、数组常用的方法：

    排序：Array.sort();

    查找：Array.binarySearch();

    打印：Array.toString();

    复制：Array.copyof();

4、常用操作

    1、冒泡排序

    for(int i=0;i.length-1;i++){//控制外循环的次数

        for(int j=0;j.length-1-i;j++){//控制内循环次数，比外循环少一次，与下一个比较

            if(a[j]>a[j+1]){

                int temp=a[j];

                a[j]=a[j+1];

                a[j+1]=temp;

            }

        }

    }

    2、选择排序

    for (int i = 0; i .length-1; i++) {

        int k=i;

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

            if (a[k]>a[j+1]) {

                k=j+1;

            }

        }

        if(i!=k){

            int temp=a[i];

            a[i]=a[k];

            a[k]=temp;

        }

    }

    3、顺序查找

    public static int find(int []b,int a){

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

        if (a==b[i]) {

            return i;

        }

    }

    return -1