java基础

Corejava

Java概述

1.    java总共有52条指令由计算机的CPU识别。

2.    java虚拟机（JVM）是包裹在OS外的一层虚拟环境，上面定义了一层能被java源程序识别的接口，使应用程序不需要考虑具体OS的差异。是JRE的子集。Java运行的核心部分。

3.    java的编译：XXX.java→（编译）字节码（二进制，可跨平台）→（运行）JVM。

4.    java字节码是中立的与平台无关的。

5.    JDK（java开发工具包）：包括java的开发、调试、运行等的一整套工具包。

6.    JRE（java的运行环境）：不包含java的开发调试工具，只包含java运行的一个包，JRE为JDK的一个子集，包含基础类库。

7.    java程序的运行过程：

（1）启动JVM；

（2）找到类的字节码文件并加载到JVM；

（3）运行类的main方法。

8.  一个java的源文件中可以定义多个类。但最多只有一个Public类。同时Public类的类名应和文件名一致。

9.  源文件中有多少个类的定义，编译后就得到多少个字节码文件。

10. 一个可运行的java程序，必须有且仅有一个main方法。

11．“//+注释” 单行注释，表明代码的意思。

12.“/* */”多行注释。

13，“/** */”文档注释，说明类定义，属性定义和方法定义。

14. $jar 打包发送。格式如下：jar cvf tools（压缩文件名）.jar\com（打包内容）C：创建jar文件；v：可视化；f：指定文件名

15. 编码的规范：1.有良好的可阅读性；2.有严格的缩进

16. java的安装：

（1）java_home：jdk的安装目录。

（2）classpath：类的搜素路径。

（3）path：bin目录加到path。

17． $javadoc生成一份程序文档

18. javac –d .XXX.java.java 打包后字节码存放的位置–d.命令的显像；“.”表示把编译好的文件存到指定的位置。

20. javadoc 提取文档注释，生成网页性质的文档。

21. 包实际上是一个用来组织类和接口的目录结构。包提供了一套软件复用的机制和唯一类命名的约定。

Java语法

注释

1.“//+注释” 单行注释，表明代码的意思。

2.“/* */”多行注释。

3．“/** */”文档注释，说明类定义，属性定义和方法定义。

4. javadoc 提取文档注释，生成网页性质的文档。

标识符

1.    标识符包括：类名、方法、变量。

2.    标识符明明可以由下划线、$、字母、数字组成。数字不能开头。

3.    严格区分大小写。

4.    没有长度限制。

命名规则

1.    类名的每个单词的首字母大写。

2.    接口名的每个单词也需大写。

3.    方法名的首字母小写，其余单词首字母大写。

4.    变量名第一个单词全小写，从第二个单词开始以后每个单词首字母大写其他字母小写。

5.    常量：值在程序中不可改变，每个字母都大写，单词与单词间用下划线隔开。

6.    包的命名习惯是字母全小写。

关键字：略

Java数据类型

1. 引用类型（类、接口、枚举、标注）特点（复合、多值、可分割）

2. 8种基本数据类型 特点（简单、单值、院子、不可分割的类型）

空类型

3. 8种基本数据类型：

1.    Boolean：布尔类型表示或真或假的值。值的范围：true or false

2.    byte：8位二进制数，用一个字节存储的整数。范围-2⁷-2⁷-1

3.    char：单一的字符。范围0-2¹⁶-1

4.    double：用8个字节来存储一个浮点数。

5.    float：用4个字节来存储一个浮点数。

6.    int：用4个字节来存储的整数。范围-2³¹-2³¹-1

7.    long：8个字节来存储的整数。范围-2⁶³-2⁶³-1

8.    short：2个字节存储的整数。范围-2¹⁵-2¹⁵-1

9.    基本数据类型之间的转换：从窄范围到宽范围可以自动转换，反之则需要强制转换。强制转化可能有数据和精度的丢失，也有可能改变数据的正负性。Byte→short→int→long→float→double以及char→int可以自动转化；其他情况则需强制转化。

10.整数在内存的存储状态存在一一对应的关系，而实数则为近似存储，只有在整数的范围内才能用存储空间大小判断。

11.强转规则：大范围转换成小范围整数，将二进制位中的高位去掉保留低位，实数→整数，则只需将小数截掉保留整数。

12.java中默认的数值类型为double。

引用和对象

1.    引用其实就是存储了一个地址值的变量，类似于c语言和C++中的指针。

2.    一个引用只能连接一个对象。

3.    一些用能够指向同一个对象。

4.    如果没有一个引用指向对象，则会被JVM当垃圾处理。

5.    空指针异常（定义看一个引用，但在程序中并没有在程序中使用它）

运算符

++ ；--；其他略

1.    ++ 实现变量的自加运算。b=a++；等价于 b=a；a=a+1；b=++a；等价于a=a+1;b=a;

2.    运算符的优先级别：. ，【】，（）优先级最高，其次，依次是：单目运算符、算术运算符、移位运算符、关系运算符、等值运算符、位运算符、逻辑运算法、条件运算符、赋值运算。

流程控制

if-else语句

实现选择。可以嵌套，根据if（）括号里面的语句，如果为真则执行if后面跟的大括号里面的内容。如果为假则执行else大括号里面的内容。可以多重嵌套。

如：if（）{

       if（）{

}else{

   

}

……

}else{

 

}

或者if（）{

 

}else if（）{

 

}else if（）{

 

}

……

else if（）{

 

}else{

 

}

switch语句

switch语句格式如下：

int a；

switch（a）{

case1：……；break；

case2：……；break；

case3：……；break；

……

default：……；

}

case后面跟常量，可以的数据类型有：byte、short、char、int和枚举。

循环语句

1. for循环：格式for（1；2；3）1.代表初始化语句，2.循环条件，3.步长语句。

for循环适合做循环次数预先已知的循环。

2. while循环：格式while（statement=true）{……}；为真则执行循环体内语句，再判断循环条件。当条件为假时则跳出循环。while适合用于做循环次数预先未知的循环。

3. do—while循环：格式为：do{……}while（statement=true）先执行do后面循环体语句，然后再判断while的循环条件，为真时继续执行循环体语句，为假时则跳出循环。Do—while适合做至少循环一次的循环。

4. continue和break

continue：结束本次循环，重新开始下一次循环。continue+语句标号：结束语句标号的那一遍循环，执行下一遍循环。

break：结束本个循环。break+语句标号；结束语句标识得那一层循环。

数组

1.    数组定义：把多个同类型的数据组织在一起的空间。

2.    数组的声明，格式如：int [] a；

3.    将数组实例化：格式：int [] a=new int []{……（元素值）}。

4.    java语言将数组也当成对象来看，数组变量相当于对象的引用。数组存储空间相当于对象空间。

5.    数组长度的获取a.length来获得。a表示数组名。

6.    二维数组的声明：格式如：int[][]a；

7.    二维数组的初始化：int[][]a=new int a[][]{{},{}}。

8.    二维数组其实可以看做是两个一维数组的组合体，对数组元素的访问格式如a[行数][列数]。

9.    **数组基本上同二维数组。对多为数组的长度的访问有：a.length表示数组的行数，a[0].length表示列数。

10.在使用数组时一定要注意下标越界问题，数组的下标一定是从0开始。下标越界则java会产生ArrayIndexOutOfBoundException。

11.java.util.Arrays类提供了一些让我们对数组进行操作的方法。比如：排序、查找。使用时我们不需要自己去实现排序和查找的算法。

Java面向对象

面向对象基础

1.    软件设计的本质工作就是对现实世界做抽象，而抽象又可分为数据的抽象和业务过程的抽象。

2.    如果以业务过程的抽象作为整个软件的抽象导向，那么我们的软件中只有业务过程的定义（函数），这就是面向过程的程序设计方法。

3.    如果以数据的抽象作为整个软件抽象的导向，那么我们的软件中就只有数据类型的定义（类），所有的业务过程都封装在数据类型的定义中，这就是面向对象的设计方法。

4.    对象中使用的数据抽象主要是类，等同于面向过程中的函数，但是又有本质上的区别。生成对象的语法：用关键字new。

5.    创建对象的三个基本步骤：分配空间，初始化属性，调用构造方法。

6.    A类中通过一个引用去访问B类，则叫做关联关系。面向对象中的关联关系有一对一的关联、一对多的关联和多对多的关联。

类

1．是一种抽象的数据类型。是数据和代码的集合。

2．对象是类的实例。

3．在java语言中类的声明与实现的接口是在同一时间进行的。在c++中，类的声明和实现的接口是可以分开的。

4．在包中可以建立一个新的类，也可以声明一个其他的类来使用这个新建的类，可以定义类的使用范围，如果在其他类中需要使用这个类则要为这个类建立一个构造函数，在类中可以定义许多的方法。在类的定义中可定义多个属性，多个方法且可重名，也可相互调用。

5．类的声明可以包含如下3个选项：类修饰符、父类、类实现的接口。

6．public表示这个类可以在其他任何类中使用。abstract表明这是个抽象类，不可以被实例化，final表示这个类不能被继承，即没有子类。

7．在类中可以声明多个成员变量。成员变量即是类和对象的特征属性，一般在声明成员方法之前声明成员变量。不带static关键字的成员变量都是实例变量。用static修饰的变量是一个类变量。

8．类变量和实例变量的差别是，不管为类创建了多少对象，系统仅在第一调用类的时候为变量分配内存，所有对象共享该类的类标量。可以通过类本身或者某个对象来访问类变量。

9．类的封装，类中的属性必须隐藏。让外部程序按照类规定的操作去访问。

10.抽象类不能创建对象，必须首先创建它的的子类，然后由子类创建对象。

方法

1.    方法的定义：修饰符返回值类型 方法名 （参数列表）{代码块}。

2.    方法一定有返回值类型（构造方法除外）。

3.    如果在方法中没有返回值产生则将返回值类型定义为void，定义为void则可以没有return语句，否则一定需要有return语句。

4.    在方法的调用时一定要注意：                                          

（1）    方法声明的形参个数、类型、次序要和调用该方法是传给它的实参个数，类型、次序要一致。

（2）    方法声明的返回值类型要和return语句中返回值类型匹配。

5.    方法是类的动态属性，对象的行为是由它的方法来实现。一个对象可以通过调用另一个对象的方法来访问该对象。

6.    实例方法可以对当前对象的实例变量进行操作，而且可以访问类变量。

7.    使用static修饰的方法为类方法。类方法能操作类变量，但不能访问类中定义的实例变量。

8.    实例成员和类成员的另外一个不同点就是类成员可以通过类名直接访问，重载的方法参数必须有所区别。参数类型不同，参数的顺序也不同，参数的个数也不相同。

9.    如果用户没有定义构造方法，则系统自动创建缺省的构造方法，无实参。

10.当通过return语句从方法返回信息时基本数据类型的变量总是以值的形式返回，而对象总是以引用的方式返回。

11.构造方法的特殊性表现在：

（1）    构造方法名与类名重名

（2）    构造方法没有返回值类型。

（3）    构造方法的主要作用是完成对象的初始化工作。

（4）    构造方法不能像一般方法那样直接调用，应该要用new关键字调用构造方法为新对象初始化。

12.构造方法一般是生成对象时系统自动调用的，构造方法的调用总是伴随着对象的生成，反之亦然。

13.方法参数是方法或者构造方法的形式参数。用于传递值给方法和构造方法。方法参数的作用域是整个方法或者构造方法。

14.this关键字的用法：

    （1） 直接写this代表当前对象。

（2） this.XXX：访问当前对象的的实例成员。仅当方法中定义有与属性同名的局部变量时，在方法中访问类的属性才需要用this。XXX。

     （3） this（）；调用本类的其他构造方法，这种用法只能出现在构造方法的

           的第一行。

15. 类中的属性私有后，如果外部需要访问则在外部提供访问方法。get+属性名或是set+属性名。

继承

1.    如果某个类没有明确声明父类，则默认继承自java.lang.Abject，所以Object类。Object类是所有类的直接或间接父类，Object类中的多有方法搜将被其他类继承。

2.    继承实现了代码的复用，任何子类的构造方法都会调用父类的构造方法。

3.    java的继承结构是单一继承结构，一个父类可以派生出多个子类，一个子类只有唯一的一个父类，类似树状结构。

4.    super关键字的用法：

（1）    super.XXX：访问父类中定义的实例成员。仅当子类有与父类同名的成员时类中访问父类成员需要使用super.XXX。

（2）    super.（XXX）：调用父类的构造方法，该用法只能出现在构造方法的第一行。

5.    父类、子类之间的挂席具有：

（1）    共享性：即子类可以共享父类的公共域和方法。

（2）    差异性：即子类和父类一定会存在差异，否则应该是同一个类。

（3）    层次性：单继承性，每个类都处于继承关系中的某一个层面。

6.    构造方法的继承遵循以下原则：

（1）    子类无条件的继承父类的无参数构造方法。

（2）    如果子类没有定义构造方法，则它将继承父类的无参数构造方法作为自己的构造方法，如果子类定义了构造方法，则在新建对象时，将先执行继承自父类的无参数构造方法，然后执行自己的构造方法。

（3）    对于父类带参数的构造方法，子类可以通过在自己的构造方法中使用super类关键字来调用它，这个调用语句必须是子类构造方法的第一个可执行语句。

多态

1.    对象的多态：一个对象多种形态。

2.    对象多态的基础：子类对象可以当做父类对象来看。

3.    对象多态的核心定理：

（1）    如果我们把子类对象当做父类对象来看，那么我们就只能访问父类中已有的属性和方法（不能访问子类扩展的属性和方法）。

（2）    如果子类把父类方法覆盖了，再把子类对象当做父类对象来看，去调用该方法，调用的是覆盖之后的方法。

4.    Animal a=new Bird（）；

该语句可以这样理解：

（1）    左边是编译时的类型——编译器认为a是什么类型。右边是运行时类型—即java虚拟机认为a是什么类型。

（2）    左边是主观认为（我们把a当做什么看？），右边是客观存在（a实际上是什么？）。

（3）    编译器认为a是Animal没有Bird中定义的方法。JVM认为a是Bird。

5. 如果子类中定义与父类相同的方法，有两种情况：

（1） 同名不同参，叫做方法的重载。

（2） 同名同参，叫做方法的覆盖或者重写。

6. 方法覆盖中需要注意的问题是：子类在重新定义父类已有的方法时，应保持与父类完全相同的方法头部的声明，即应与父类有完全相同的方法名、返回值类型、和参数列表。否则不是方法的覆盖，而是子类定义了与父类无关的方法，父类方法仍然存在于子类中。

7. 方法的覆盖与对象的隐藏不同之处在于：子类隐藏父类对象只是使之不可见，父类的同名对象在子类对象中仍占有自己独立的内存空间，而子类方法对父类同名方法的覆盖将清除父类方法占用的内存空间，从而使父类方法在子类对象中不复存在。

8. 对象类型的强转：如知识点4，只有当a本来就是Bird的实例是，才能将a转化成Bird，否则会报告错误。

9. 我们经常在强制类型转换之前首先使用instanceof判断某个对象是否是某种类型的实例，这样可以避免错误的转换。如：

if（a instanceof Bird）{

       Bird b=（Bird）a；

}

是否是一个类型的实例，考察时考虑其运行时的类型，原本是一个类型可自动向上转化。

访问控制修饰符

static

1.    static 静态的，static描述的属性和方法是用来描述整个类的特征和行为的，不是用来描述某个对象个体的行为特征的。

2.    静态属性在整个类中只保留一份，在类加载时为其分配龙健。

3.    static 可以修饰代码快，不属于任何方法是独立的。

（1）    无名、无参、无返回的“三无”方法虚拟机会在核实的时机调用。、

（2）    非静态的三无方法会在创建类对象时被JVM自动调用。

（3）    静态的三无防腐一般会在类加载时被JVM自动调用。

类加载的时机：

（1）java XXX启动java虚拟机、找到类的字节码文件、找到类的主方法。

（2）在创建一个新的对象的时候。

（3）访问类的一个静态属性和方法。

（4）手动加载类，格式如class.forName（“类名”）。在整个JVM运行的过程中一个类只加载一次。

4.    静态方法中不能使用this，不能直接访问本类的非静态成员。

5.    静态方法不能被覆盖，没有多态。

6.    静态方法不与任何对象相关联。

7.    静态代码块定义在静态属性之后，初始化类的静态属性。

8.    静态代码块在类加载时自动执行一次，经常用来做类初始化工作，构造方法用来做对象的初始化的工作。

final

1.    final的属性只有两个机会可以复制：在定义时赋值和在构造方法中赋值。

2.    一般static final的属性都在定义时赋值，非static的final属性在构造方法中赋值。

3.    final用来修饰类，则不能够有派生类和子类，也不能被继承。

4.    final用来修饰类的属性，表示属性的值在对象生成的周期内不会被改变。

5.    修饰方法，则表示该方法不能不覆盖。

6.    修饰方法体内的局部变量，表示值不可改变。

abstract

1.    用abstract修饰的方法是类方法。

2.    抽象方法：在面向对象过程中，有一些方法不知道该如何实现，但可以确定该方法一定会需要实现，则可以定义为抽象方法。

3.    如果类中包含一个抽象方法则该类一定要申明为抽象类，但如果类中包含的方法都是实例方法，该类也可以申明为抽象类。

4.    抽象类不能被实例化。

5.    抽象类的构造方法子类可以调用。

6.    抽象方法是可以继承的。

7.    子类实现父类的抽象方法实际上也是一种覆盖。

8.    如果非抽象的子类继承抽象的父类，在调用抽象方法时必须将父类的抽象方法进行重写。

接口

1.    接口是用来实现类间多重继承功能的一种结构，是相对独立完成特定功能的属性集合。接口调用实际上就是获得了多个特殊父类的属性，即实现了多重继承。

2.    接口定义看若干个抽象的方法和常量，形成一个属性集合，该属性集合通常对应了某一组功能。接口的定义仅实现了某个特定功能的一组对外接口和规范，而这个功能的真正实现是在继承这个接口的各个类中完成的要由这些类来具体定义接口中各抽象方法的方法体和适合某种特定的行为。

3.    接口的方法必须都是抽象方法。

4.    接口中的所以属性都是默认公开的静态常量。

5.    接口不能被实例化。因为接口没有构造方法。

6.    类与类之间的关系叫做继承为单一的关系，类与接口之间的关系叫做实现可以是多重关系。即一个类可用以实现多个接口，接口名用逗号隔开。接口与接口之间的关系是可以是多对一的关系。即一个接口可以继承多个接口。

7.    定义接口用interface关键字。

8.    接口编程的最大好处：将服务的提供者和服务的使用者分离开来，这样服务的使用者只需要关心标准而不需要关心具体实现，如果以后服务的实现变化了，而上层不需要做任何改变，从而降低系统的耦合。

9.    基于抽象（接口）的编程还能让程序具有更好的兼容性和通用性，能够使用抽象类型的地方一般不要使用具体类型。

10.接口与抽象类的区别：

（1）    接口不能够有任何可以实现的方法，抽象类可以有。

（2）    类可以继承多个接口，但只能继承一个父类。

（3）    类有严格的层次结构，而接口不是类层次结构的一部分，没有联系的类可以实现相同的接口。

11.当类实现一个接口中的抽象方法时，这个方法的名字和参数类型及数目必须与接口中的方法一致。

12.实现接口时应该注意：

（1）    类的声明部分用implements关键字声明该类将要实现那些接口。

（2）    类在实现抽象方法时，必须用public修饰符。

（3）    除抽象类外，在类的定义部分必须为接口中所有的抽象方法体定义方法体切方法体的首部应该与接口中的定义完全一致。

（4）    若实现某接口的类是抽象类，则它可以不实现该接口中所有的方法，但是对于这个抽象类的任何一个非抽象子类，不允许存在未被实现的借口方法。那些非抽象类中不能存在抽象的方法。

（5）    定义一个接口实际上定义了一个新的引用数据类型，可以在使用接口类型外的其他类型的名字的地方，都可以使用这个接口名。

（6）    接口不能被覆盖。

高级语法

1. 顶层类可用的修饰符有：public、protected、default、final、abstract. private、static不能用来修饰顶层类。

2. 类的属性可用的修饰符有：public、protected、default、private、static、final。abstract不能用来修饰属性。

3. 方法可用的修饰符有：public、protected、default、private、static、final、abstract。

局部变量可用的修饰符有：final。不可用public、protected、default、private、static、abstract修饰符来修饰。

4. 内部类可用的修饰符有：public、protected、default、private、static、final、abstract。

修饰符的访问控制权限：public：在类的内部可以访问，同包可以访问，子类可以访问，其他也可以访问。

5. protected：在类的类部可以访问，在相同的包内也可以访问、子类可以访问。其他则不可以访问。

6. default：在类的累不可以访问，在相同的包内可以访问，子类不可以访问，其他也不能访问。

7. private：在类的内部可以访问，在相同的包内不可以访问，子类中也不能访问，其他也不能访问。

8. 注意：不能用生成的对象去直接访问父类中的protected属性。

 

java.lang包下的Object类：

1. Object clone（）：创建和返回一个当前对象的拷贝。

2. 在程序中完成一个当前对象的拷贝需要在自己的类中将clone方法重写。

3. 重写的过程有：

1、在自己的类中写一个clone（）方法，覆盖Object类中的clone（）；并声明为public。

2、在重写的方法中调用父类的clone（）方法。格式为super.clone（）。

3、在派生的类中要实现cloneable接口。该接口只起标记的作用。

 

boolean equals（Object obj）：用来判断对象的值是否相等。

equals与“==”的区别：

1、如果Object类中的equals（）方法没有重写，则与“==”相同，判断对象是否相等，实际上比较的是以用的值（对象的地址值）。

2、如果equals（）方法已经由程序员自己重写，则会覆盖父类中的equals()方法，比较时则根据程序员自己定义的比较规则，进行比较如果相等则为true，不等则为false。

同时equals（）方法必须遵循以下的几条规则：

1、自反性：对于任何一个非空以用值x，x.equals（x）的返回值必须为true。

2、对称性：对于任何非空引用值x和y，x.equlas(y)返回值为true当且仅当y.equals(x)返回值为true。

3、传递性：对于任何非空引用值x、y和z，如果x.equals(y)返回值为true和y.equals(z)返回值为true，那么x.equals(z)的返回值也为true。

4、一致性：对于任何非空引用值x和y。多次调用x.equals(y),要么始终返回true，要么始终返回false，前提条件是对象上的所有信息没有被修改。

5、对于任何非空引用值x，x.equals(null),返回值一定为false。

String类和对象池

1.    在JDK5.0里面，java虚拟机在启动时会实例化9个对象池，这9个对象池分别用来存储8中基本类型的包装类对象和String对象。我们在程序中直接用双引号括起来一个字符串时，JVM就到String的对象池里去寻找是否有一个值相同的对象，如果有，就拿现成的对象，如果没有就在对象池里面创建一个对象，并返回。

2.    字符串池中的值是不可变的。

3.    String str2=new String（“hello”），是直接生成一个新对象。

4.    String s=new String（“hello”）创建了两个对象，在程序中有双引号引起的字符串首先创建了一个新的字符串，有在字符串池中构造了一个新的对象。

5.    在任何情况下，只要你去new了一个String对象那都是创建了一个新的对象。