目录

《java从入门到精通》学习记录 3

基础的基础部分： 3

一、 常量与变量 3

1、 掌握： 3

（1） 、常量与变量的声明方式： 3

（2） 、变量的命名规则： 3

（3） 、变量的作用范围： 3

a. 按作用范围：成员变量：类中定义，作用整个类。 3

二、 数据类型 3

1、 掌握： 4

（1） 、整数类型的分布： 4

（2） 、浮点数据类型的分布： 4

（3） 、字符型类数据： 4

（4） 、布尔类型数据： 4

2、 熟悉： 4

（1） 、基本数据类型默认值的意义和使用方法： 4

（2） 、数据类型转换：自动类型转换和强制类型转换。 4

三、 运算符、表达式和语句 4

1、 掌握： 5

（1） 各种运算符的用法。 5

（2） 各种表达式的用法。 5

（3） 表达式与运算符的关系。 5

（4） 表达式中数据类型的转换技巧。 5

四、 程序控制 5

五、 数组 6

1、 一维数组： 6

2、 二维数组： 6

3、 与数组操作相关的api： 6

（1）数组拷贝： 7

（2）数组排序： 7

基础的核心部分： 7

六、类和对象---面向对象的设计 7

1、类和对象简介 7

2、类 8

3、对象 8

4、 类的方法 8

七、类的封装、继承和多态 9

八、 抽象类和接口 13

（一）、抽象类 13

（二） 、接口 14

九、 类的专题研究 14

十、 java常用类库（api） 17

十一、 包及访问权限 19

1、 包的基本概念 20

2、 import的使用 20

3、 jdk中常见的包： 20

4、 类成员的访问控制权限 20

5、 java命名习惯 21

十二、 异常处理 21

 

《java从入门到精通》学习记录

基础的基础部分：

一、常量与变量

1、掌握：

（1）、常量与变量的声明方式：

a.语法：final 数据类型 常量名（=值）

b.规则：常量名通常全部大写，且常量用于成员变量时必须赋初值。

（2）、变量的命名规则：

1. 用相应的数据类型为变量命名后，内存会为其开辟相应大小的空间。
2. 变量属于标识符，命名规则同标识符。

（3）、变量的作用范围：

1. 按作用范围：成员变量：类中定义，作用整个类。

局部变量：循环中定义，跳出循环不能再用。

二、数据类型

 

 

 

1、掌握：

（1）、整数类型的分布：

（2）、浮点数据类型的分布：

（3）、字符型类数据：

（4）、布尔类型数据：

2、熟悉：

（1）、基本数据类型默认值的意义和使用方法：

（2）、数据类型转换：自动类型转换和强制类型转换。

 

三、运算符、表达式和语句

程序由语句构成，语句的基本单元就是表达式和运算符。

 

 

1、掌握：

（1）各种运算符的用法。

算术运算符

运算符分类： 关系运算符

逻辑运算符

位运算符

（2）各种表达式的用法。

（3）表达式与运算符的关系。

（4）表达式中数据类型的转换技巧。

四、程序控制

1、顺序结构、选择结构、循环结构

2、if、if…else、？：、swich、while、do…while、for、break、continue。

 

五、数组

1、一维数组：

语法：声明数组和分配内存：

int score[]；  //声明数组，未分配内存。

score[]=new int[3]；//分配内存，元素个数为3个整形量。

合为一句：

int score[]=new int[3]；

直接分配数值的声明：

int score[3]={3,4,5}；

2、二维数组：

语法：

int score[][]；  //声明数组，未分配内存。

score[][]=new int[3][4]；//分配内存，行数为3，列数为4。

合为一句：

int score[][]=new int[3][4]；

直接分配数值的声明：

int score[3][2]={{1,2},{3,4},{5,6}}；

值得一提的是，可以不限制每行数量都相同：

int score[][]={{0,1,2},{3,4,7,8,9},{5,6}}；

score.length     //二维数组score的行数

score[0].length   //二维数组score的第一行的元素的个数

3、与数组操作相关的api：

（1）数组拷贝：

system.arraycopy(a[3],0,b[4],0,x)

从a[3]的0到x的元素依次覆盖b[4]从0开始的元素。

（2）数组排序：

arrays.sort(a);

对a数组的元素进行从小到大的排序，需提前调用java.util包。

基础的核心部分：

六、类和对象---面向对象的设计

要求：

了解类和对象的概念；

掌握声明及创建类和对象的方法；

掌握对象的比较方法；

掌握类的方法的使用及调用。

1、类和对象简介

·万物皆对象，一个对象由对象的属性及对象的方法（对属性的操作或其他操作）构成。

·具有相同属性和行为的一组对象成为类，广义上讲，具有一系列特征和行为的对象的集合就是类。

·类被看成是一种抽象的数据类型，具有自己的成员变量和成员方法。

·类是一个抽象的概念，若想利用类解决问题，需要先实例化一个类的对象，让对象去访问类中的变量和方法从而实现程序功能

·面向对象的设计的三个主要特征：封装、多态和继承。

2、类

·类是对象的模板，对象是类的实例，所以面向对象的设计思想的重点是类的设计。

·类的命名首字母大写，定义用class，创建类的实例用new。

3、对象

·创建某类的对象：

可以先声明，再实例化（这个过程是不是觉得有点眼熟）

类名 对象名；        //声明一个对象

对象名=new 类名()；  //用new实例化刚刚声明的类的对象

也可以两步一起（是不是更眼熟了）：

类名 对象名=new 类名()；

·对象只有实例化之后才能使用，只有实例化了，对于程序而言这个对象才是真实存在的。

·对象的使用：

对象.属性;    //访问对象的属性

对象.方法();   //调用对象的方法

·比较：“==”比较的是内存地址，“equals()”方法比较的是值。

4、类的方法

主要说下构造方法：

（1）构造方法是特殊的方法，特征是方法名与类名相同。主要是用在实例化对象时自动调用的，且没有返回值。没有构造方法的话，系统会默认生成一个无参的构造方法。

（2）构造方法的基本作用就是对类中的私有属性初始化。

（3）构造方法若只有有参，则必须在实例化对象时写入相关参数。

5、this、static关键字和主方法

this代表类的一个对象，this主要用来调用成员变量或者成员方法。

static用来修饰共享的变量，该变量就是静态变量。

static：当不想或无法调用类中的对象，却还想用类中方法时，就可以用静态方法。例：类.静态变量、类.静态方法

主方法语法：

public static void main(string[] args){

//方法体

}

主方法是静态方法，所以想在主方法中直接调用的方法也必须是静态方法。

七、类的封装、继承和多态

类的封装通过private等修饰符，把一些属性或者方法放到外面看不到的“黑匣子”里，形成一个一个类似“功能块”的东西，不仅可以保护相关信息，还有利于实际应用和测试的简便性，使得软件工程化的思想的到贯彻；同时封装也可以通过访问private属性时设置一些过滤条件。

类的继承可以在快速开发新类的同时，降低内存的占用，形成金字塔形的类结构，是程序代码再利用的重要体现。

类的多态：封装和继承是多态的基础。

多态存在的三个必要条件：
一、要有继承；
二、要有重写；
三、父类引用指向子类对象。

1、类的封装就是相关属性用private修饰，对象想取得属性必须要用getxxx和setxxx方法。

2、class 子类名 extends 父类名  //类的继承只能多层继承和单继承，不允许多继承，即一个类只能继承一个类，子类可以直接继承父类的公有属性和方法，隐含的继承私有属性和方法。

3、实例化子类的对象时，会先调用父类的构造方法，再调用子类的构造方法。

4、super用来在子类中调用父类的属性和方法。同时可以再子类中用super调用被覆写的父类方法。

5、被final修饰的类、方法和变量不能被改变，类不能被继承，方法不能被重写，变量变为常量。

6、重写（覆写）：一个子类继承了一个父类，子类中有一个方法和父类中一个方法名称、参数个数、类型完全相同，就称这个子类的方法覆写了父类的方法，同理，子类的属性也可以覆写父类的属性。

7、重载：方法名称相同，却可以根据传入参数不同得到不同的效果。

8、加深理解多态的一些例子：

    

 

打印的结果会是什么呢？请自己思考下，答案在下一页。

答案是"son"，结合前面的解释，我们很容易判断出来。子类的getname()方法重写了父类中的方法，在main中，父类的引用father指向了子类的对象son，当我们调用father的getname()方法时，实际上是动态绑定到了子类的getname()上，所以会打印出"son"。

下一个例子如下图：

从程序的运行结果中我们发现，a.fun1()首先是运行父类wine中的fun1().然后再运行子类jnc中的fun2()。

      分析：在这个程序中子类jnc重载了父类wine的方法fun1()，重写fun2()，而且重载后的fun1(string a)与 fun1()不是同一个方法，由于父类中没有该方法，向上转型后会丢失该方法，所以执行jnc的wine类型引用是不能引用fun1(string a)方法。而子类jnc重写了fun2() ，那么指向jnc的wine引用会调用jnc中fun2()方法。

总结：指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）。

对于面向对象而已，多态分为编译时多态和运行时多态。其中编辑时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的函数，通过编辑之后会变成两个不同的函数，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是我们所说的多态性。

 

 

 

 

java实现多态有三个必要条件：继承、重写、向上转型。

         继承：在多态中必须存在有继承关系的子类和父类。

         重写（覆写）：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。（重载不可以，因为参数改变了）

         向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

八、抽象类和接口

掌握抽象类的基本概念

掌握抽象类实例的应用

掌握接口的基本概念

熟悉借口实例的应用

了解抽象类的使用

（一）、抽象类

1、java中有一种专门做父类的类，叫做抽象类，特殊之处在于其中含有抽象方法。抽象类必须用abstract class声明

2、抽象方法就是只声明未实现的方法，用abstract关键字声明。

3、抽象类不能被实例化，也就是new关键字无法产生对象。

4、抽象类的子类必须覆写所有的抽象方法后才能被实例化，否则这个子类依然是抽象类。

5、抽象类中声明了构造方法的话，子类必须明确调用。

（二）、接口

1、接口定义：接口的成员必须初始化且均为常量，接口的方法必须全部是抽象方法。

2、使用接口打造类的过程，叫做接口的实现，一个类可以实现多个接口。class 类 implements 接口a,接口b。

3、一个接口可以继承多个接口，这个和类不一样。interface 子接口 extends 父接口1，父接口2，…

九、类的专题研究

掌握object类的基本概念

掌握方法的运用技巧

掌握关键字的作用与使用技巧

熟悉内部类的使用

了解匿名对象的使用

1、object类是所有类的父类。object类的方法是所有类共用的，其中有个tostring方法，println默认会用。

2、在一个类内部可以再定义一个类，就叫内部类。内部类可以直接调用外部类的属性而不用先创建对象，但是外部类不能直接访问内部类属性。

3、用static修饰的内部类的属性可以被外部类访问了，但是此时的内部类无法访问非静态的外部类的属性。

 

 

4、类外部引用内部类，需内部类用public声明，如上图。

5、内部类也可以在外部类的方法中定义。

6、匿名内部类，匿名对象，主要是匿名的含义，没有明确的声明。

7、方法的重载：

 

 

8、java中用引用代替c++中的指针。声明一个类p的对象p1并实例化，将p1的引用给一个只声明却未实例化的p的对象p2，则p2就拥有p1的实例化结果。

9、接口对象的实例化。

10、this关键字：this表示当前对象，所谓当前对象表示调用类中方法或者属性的那个对象。

11、static可声明静态变量和静态方法。静态变量是所有对象共享的，修改一次永久生效。静态方法内不能调用非静态变量。

12、main方法是java虚拟机调用的主方法，所以必须是public属性，还要static保证可以不用创建对象直接被调用。

13、一个类可以使用不含有任何方法体的静态代码块static{}，静态代码块会在类执行时优先执行，且只执行一次。经常用来进行静态属性初始化。

14、final关键字：用final标记的类不能被继承、方法不能被覆写、变量变成常量且只能赋值一次。

15、instanceof可用来判断：一个类是否实现了某个接口或一个实例对象是否属于一个类。返回值是布尔值，语法如下：

类 instanceof 接口        对象 instanceof 类

十、
java常用类库（api）

掌握java类库的相关概念

熟悉system类和runtime类

熟悉math类和random类

了解对象克隆的相关知识

  java类库就是javaapi（应用程序接口），是系统提供的已实现的常用类的集合。

 

 

1、string类和stringbuffer类：string类一旦确定就无法更改，相比之下，stringbuffer类修改起来更方便，但是一旦确定就要用tostring转成string格式。

2、基本数据类型的包装类：可以强制转换类型。

3、“装箱”和“拆箱”的概念

4、system类：

5、runtime类：

 

 

6、date与calendar类和dateformat类

都是与时间相关的类，目前date比较少用，更多的是另外两个。

 

 

7、math类与random类：

math类里都是一些关于数学的静态方法，看jdk文档即可。

十一、包及访问权限

掌握包的基本概念

掌握import语句的使用

熟悉类成员的访问控制权限

了解jdk中常见的包、java的命名习惯、jar命令的使用。

  在开发大型项目的时候，需要把类分门别类地存到文件里，这样的程序代码更容易维护和实现。将类分开后，也就涉及到了相应的访问权限问题。

1、包的基本概念

package主要用来解决类的名称重复等问题，把一个相关项目的类和接口放在一个包里。

语法：package package名;

2、import的使用

若要访问不同包内的某个public类中的属性或者方法，则需要import来声明，语法为：

import 包名称.类名称；

ps：由于在java中导入一个类和导入一个包里所有的类，在程序运转中并无差异，所以一般我们会导入一个包内所有的类，这样比较方便。语法：import 包名称.*；

3、jdk中常见的包：

 

 

4、类成员的访问控制权限

简述如下图：

 

 

 

5、java命名习惯

 

 

十二、异常处理

掌握异常的基本概念

掌握对异常的处理机制

熟悉如何在程序和方法中抛出异常

了解如何编写自己的异常类

在程序设计时，必须要考虑到可能出现的异常，并做出相应的处理，才能最大限度的保证程序正常运行。

1、抛出（throw）一个异常：生成异常对象并把它交给运行时系统的过程。

2、捕获（catch）一个异常：运行时系统从异常生成的地方开始追溯，直到找到包含相应异常处理的办法为止的过程。

3、异常的处理：

 

 

其中final块可省略，那程序就从catch后开始继续执行。

通过异常机制，如果能catch准异常类型，就可以让程序运行到最后。

4、异常可分为两大类：error和exception。

5、程序抛出异常用throw，方法抛出异常用throws。

6、如果类的方法中用throws抛出了一个异常，那么在调用这个方法的时候，一定要用try…catch捕捉。

 

十三、类集框架

掌握类集接口的概念

掌握list接口、集合接口和sortedset接口

熟悉collection接口中的arraylist类、hashset类和treeset类的方法

了解通过迭代方法访问类集

首先，什么是集合，集合通俗的说就是某一类数据放在一起形成一个集合，所以这一章会有各种组合的大大小小的集合，比方说list集合就包括了list接口和实现list接口的所有实现类。

数组与集合的区别是，数组长度固定，集合则可变；数组可存放对象和基本数据，但是集合只能存放对象。

这章主要讲了3个重要集合，list集合（包含list接口和各种实现类）、set集合（同list）和map集合（同list）。其中list接口和set接口都是继承的collection接口。如下所示：

 

                                                                              collection接口

                                                                         

       map接口           set接口           list接口

 

hashmap     treemap       hashset         treeset        arraylist               linkedlist

                   常用实现类们                          

 

1、collection接口：是构造类集框架的基础，它声明所有集合类都将拥有的核心方法，即所有集合类都实现了此接口。

常用方法：add、remove、isempty、iterator、size。

2、list接口：除了继承collection的方法外，还有两个重要的方法：get（int index）获得指定索引位置上的元素、set（int index，object obj）将集合中指定索引为止的对象修改为指定的对象。

3、list接口的实现类arraylist：以数组形式保存集合中的元素，可以随机且快速地访问集合中的元素。

4、list接口的实现类linkedlist：以链表形式保存集合中的元素，随机访问性能较差，但是插入元素和删除元素性能出色。

以上两种类都可以实例化list接口。

5、set接口的实现类hashset：使用散列进行储存元素，不允许有重复元素。

6、set接口的实现类treeset：同时实现sortedset接口，在遍历使用treeset类实现的set集合中的元素，会默认将元素按照升序排列。

7、map集合：用来存储有映射关系的集合。实现类为hashmap和treemap。

8、注意：

list集合关注的是索引，元素有序存放，可重复

set集合关注唯一性，值不许重复。

map集合关注唯一的标识符（key），具有映射关系。

9、泛型：即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

 

十四、
枚举功能

掌握枚举的概念

掌握enum关键字

掌握枚举的定义方法

熟悉枚举的作用、接口及其中构造方法

了解类集对枚举的支持

 

枚举理解起来像是一种简化，同属一种属性的元素，比如周一到周日都属于星期几的范畴，那么建立一个枚举星期，那么某个元素如果是枚举中的一个，那么此元素必为枚举元素中的一个。

1、枚举类型的语法：

enum 枚举名{枚举值表}；

 

 

十五、多线程

掌握实现多线程的方法

熟悉线程的状态

熟悉线程同步和操作的方法

熟悉线程间通信的方法

了解进城和线程

 

1、进程的特征：一个程序的执行过程就是进程，都有自己独立的内存空间和系统资源。

2、线程的特征：程序是按照流程来执行的，单个的流控制就是线程。

一个进程可以包含多个线程，且同时运行多个线程，这样系统负担必单独再开一个进程要少的多。

3、实现多线程需要继承tread类或者实现runnable接口。

 

 

 

maven介绍：

 

maven的核心功能便是合理叙述项目间的依赖关系，通俗点讲，就是通过pom.xml文件的配置获取jar包，而不用手动去添加jar包，而这里pom.xml文件对于学了一点maven的人来说，就有些熟悉了，怎么通过pom.xml的配置就可以获取到jar包呢？pom.xml配置文件从何而来？等等类似问题我们需要搞清楚，如果需要使用pom.xml来获取jar包，那么首先该项目就必须为maven项目，maven项目可以这样去想，就是在java项目和web项目的上面包裹了一层maven，本质上java项目还是java项目，web项目还是web项目，但是包裹了maven之后，就可以使用maven提供的一些功能了(通过pom.xml添加jar包)。

 

 

 

　　　　所以，根据上一段的描述，我们最终的目的就是学会如何在pom.xml中配置获取到我们想要的jar包，在此之前我们就必须了解如何创建maven项目，maven项目的结构是怎样，与普通java,web项目的区别在哪里，还有如何配置pom.xml获取到对应的jar包等等，这里提前了解一下我们如何通过pom.xml文件获取到想要的jar的，具体后面会详细讲解该配置文件。