java基础部分学习心得.docx

java基础部分学习心得.docx

《java基础部分学习心得.docx》由会员分享，可在线阅读，更多相关《java基础部分学习心得.docx（65页珍藏版）》请在冰豆网上搜索。

java基础部分学习心得

一．Java

数据结构，链表~

一．Java简介

JAVA核心机制：

JAVA虚拟机（实现了一处编程，到处运行），因为其运行过程是先编译成.class字节码文件，然后在jvm（JavaVirtualMachines）运行，不同的操作系统有不同的虚拟机，所以实现了一处编程，到处运行。

垃圾收集机制:

（帮助解决了一些健壮性的问题，不像C/C++那样内存管理那样麻烦），在编程过程中，会创建许多对象，存储在堆空间里，占用内存，但是java的垃圾回收机制，会不定时的自动回收在堆空间里没有任何引用指向的对象，所以在编程时应习惯性及时将不用的引用设置为null。

可以通过System.gc（）;来快速执行垃圾回收机制。

J2SDK（JDK）:

JAVADevleopmentkit软件开发包，，开发需要JDK（包含JRE，编译运行开发工具）。

JRE：

JAVARuntimeEnvironment运行环境，，用户只需要JRE（包含系统类库和JVM）。

软件格式：

每一个类都对应一个class文件

如果一个源文件文件中包含public类，则该文件名必须以该类命名，每个源文件中最多有一个public类

JAVA的执行入口是main（）方法，固定格式：

publicstaticvoidmain（String[]args）{…}数组名字可以改变。

区分大写小~

2．Java语言基础

变量取名：

标识符选取取名：

一定要注意“见名知意”，，但不能和JAVA语言的关键字重合

‘字符常量’“字符串常量”

变量使用：

先声明，再赋值，才可以使用变量

基本类型：

4类8种;

Boolean类型：

逻辑运算，用于程序流程控制，只能取true,false

Char类型：

字符类型eg：

chareChar=’中’，Unicode编码（每个字符对应有一个编码）每个字符占两个字节，无论中午，英语，数字，每个字符都是占两个字节。

整数类型：

byte占一个字节-128-127

short2个字节

Int4个字节对应包装类Integer

long8个字节

浮点类型flaot4个字节

double8个字节对应包装类Double

格式很重要

1.大括号对齐

2.遇到{用TABorshift+Tab

3.程序块之间加空行

4.运算符两侧加空格

有特定的条件

5.并排语句之间加空格

6.{前面有空格

7.成对编程

异或^相异为true

逻辑&和逻辑|无论结果如何，后面的表达式一定会计算

短路&&和短路||第一个表达式已经可以得到结果了，后面的不算了

分支循环语句

If语句

If

elseif

elseif

elseif

else当只有一句语句要执行的时候，可以省略大括号{}~但是目前无论是否可以省略，都写上

循环语句

for循环，for（表达式1；表达式2；表达式3）{语句；...；}

while循环while（逻辑表达式）{语句；...；}

dowhile循环do（语句；...;）while（逻辑表达式）；注意，，dowhile循环while（逻辑表达式）；的分号

if语句后面注意不要加分号，不容易被查错~

break语句终止某个语句块的循环，用于循环中，强制跳出循环

continue语句，用在循环中，终止当前循环中下面的语句，到下一次循环

switch（）{

casexx:

语句；

casexx：

语句；

default：

语句；

}

这里注意case和break的搭配使用，如果没有break，则程序会一直向下执行。

方法public（static）返回值类型方法名称（形式参数；...）{方法体；java语句；

return返回值}当出现return时，立即返回。

无返回值时，类型为void

Static是静态方法，直接使用类名调用，非静态方法，需要使用对象调用。

方法只有当调用的时候，才会执行，方法中涉及的局部变量，在方法被调用时，出现在栈空间，一旦方法结束，所占用内存消失。

...{

method（实参；...）//调用

}

（面试）递归~~

三．面向对象

面向对象编程:

运用人类正常思维方式构造系统，常使用的原则和思想方法：

抽象，继承，分类，聚合，多态

1.使用人类自然语言，描述这个业务的需求

2.根据业务需求寻找涉及的事物类---对象

3.数据模型设计：

利用数据描述对象，以及对象之间的关系，将对象数据化。

4.概要设计

类的设计（概要设计）：

定义类的属性

数据如何初始化：

构造器，工厂方法。

详细设计

5.利用分析数据

6.根据数据设计算法实现功能

7.逐一实现算法

8.实现用户响应

9.界面状态管理

用面向对象考虑问题时，不应该考虑第一步，第二部要做什么，1.首先考虑的是，这个问题涉及哪些类和对象，2.考虑这些类和对象，每一种应该具有哪些行为和属性3.每类和类之间具备了什么关系。

类是一类事物的一个抽象

对象这个类具体的一个实例

类和对象多为关系：

关联关系

继承关系：

一般和特殊的关系，eg：

游泳运动员是运动员的一种，足球运动员是球类运动员的一种。

聚合关系：

整体和部分的关系，eg:

队长和队员是球队的一部分，是聚集关系，头和手是身体的一部分，是组合关系。

实现关系：

多态：

成员变量可以不初始化，JAVA默认会初始化

对象的创建和使用：

使用new关键词来创建对象

对象.成员变量来调用对象的成员变量（引用）

对象.方法来调用对象的方法（引用）

同一类的每个对象有不用的存储空间

同一类的每个对象共享该类的方法

构造方法：

构造方法的名字和类名要完全一样，和new一起使用来创建新对象，对对象进行初始化的。

在类中用来初始化对象的一个方法（函数）

Eg：

publicclassPerson{//创建一个person类

Intid；

Intage=20；//定义成员变量

Person（int_id,int_age）{//定义一个构造方法，方法名必须与类名完全一样

id=_id;

age=_age;

}

Publicstaticvoidmain（String[]args）{

PersonTom=newPerson（1，20）；//创建一个对象Tom,利用构造方法进行了初始化

}

没有指定构造方法时，编译器自动指定一个空的，一旦自己定义了，编译器就不定义了，构造方法前面没有返回值

类名首字母大写，方法名变量名小写，后面的每一个单词的首字母都要大写

方法一旦执行完毕，为这个方法所分配的局部变量的存储空间将消失

方法重载，构造方法的重载：

方法名相同，类型相同，但是参数变量类型不同的，可以构成重载，构成多个方法，调用时会根据不同的参数选择相应的方法

构造方法与普通方法一样，可以进行重载

关键字：

this

在那个对象，this就指向那个对象，指向对象本身自己的引用

static：

在类中用static声明的成员变量是静态成员变量，分布在dataseg内存空间里，在第一次使用时被初始化并且只有一份，整个类的所有对象都可以使用，可以用类名.静态成员变量，来直接调用。

用static声明的方法叫静态方法，动态方法通过某一个对象来调用，静态方法没有对象照样可以使用，eg：

类名.静态方法，来调用，不用写对象名字，所以在static方法里不能访问非static的成员

Static里不会隐式传递this关键字，即调用不了对象属性

所以当一个方法只和参数相关，则使用static方法，如果和成员变量相关，则不使用。

静态的方法不针对某个对象调用，非静态成员专属于某个对象，所以静态方法，不能访问，

可以通过对象引用，或者类名来访问静态成员

Static块：

在类加载期间就被执行的语句块，软件运行时，会先在jvm上加载类，则static块可以用来加载许多初始化资源。

包：

package和import、

在程序的第一行:

packagecom.satisfy（公司域名倒过来）.sun（具体名，项目名）

class文件应该放在与正确的目录下面，另外该类的源文件可能会产生影响，最好delete或者转移

其他的类要想访问的话：

1.需要写全类名，2.可以使用importcom.satisfy.sun.*（具体类名）；来引入，3.如果两个类位于同一个包，也可以。

如果其他类与该类不在同一包且不在同一目录下，在其他目录想访问时，需要配置classpath环境变量，将class文件的最上层包的上一级目录配置在classpath下

只要进行打包处理，生成的class都要放在正确的目录下，否则无法运行，同样要配置classpath

如果一个A类位于A包，引入了B类位于B包，如果想要执行A类，则要写全包名

JDK主要的包介绍：

Java.lang里面的类的不需要引入，直接使用

Jar-cvf××.jar*.*（当前目录）可以打包

访问控制，权限修饰符：

private，default，protectde，public

修饰符

类内部

同一个包

子类

任务地方

private

Yes

default

Yes

Yes

protected

Yes

Yes

Yes

public

Yes

Yes

Yes

yes

类的继承:

extends,,什么什么是一种什么什么，那么他们之间关系就是继承，通过继承，子类自动拥有基类（父类）的所有的方法和成员变量

Java只支持单继承，一个子类只能有一个基类，一个基类可以派生出很多子类

子类比父类大，子类对象包含父类对象

重写：

1.可以根据需要对从父类继承的方法，在子类中重写2.重写方法的返回类型，参数，方法名称必须相同3.重写方法不能使用比被重写方法更严格的访问权限

Super：

指向当前对象里的父对象

一．继承中的构造方法：

子类对象的构造过程中必须调用父类的构造方法

二．子类可以在自己的构造方法中使用super（argujment_list）来调用的父类的构造方法

1.使用this（argument_list）来调用本类中的其他构造方法

2.如果调用super，必须写在子类构造方法的第一行

三.如果子类的构造方法中没有显示调用的父类方法，则系统默认调用父类的无参构造方法

四.如果子类的构造方法中既没有显示调用的父类的构造方法，而且父类中也没有无参构造方法，则编译出错

Object类：

是所有java类的根基类

PublicclassPerson等价于publicclassPersonextendsObject

方法toString：

返回该对象的字符串表示，，通常是对象名+hashcode

一般情况下，所有的子类都要重写这个方法，重写请copy，

方法equals：

指示其他某个对象是否与此对象相等

当x与y是同一个对象时，才返回false，可以重写方法，改返回

一些其他的类，String，Date也重写了equals方法，

方法hashcode：

返回该对象的名字加哈希码，这里的哈希码就是返回的物理地址。

一般所有类的都要重写这三个方法。

对象转型：

casting

1.父类的引用类型变量可以指向子类的对象

2.一个父类的引用不可以访问其子类新增加的成员

这里a是父类animal的一个引用，当他指向其子类的一个对象时，不可以访问新增加的furname成员

3.可以使用instanceof来判断该引用变量所指对象是否该类或者该类的子类

a是父类的引用变量，ainstanceofAnimal判断a所指的对象是否在Animal类中。

4.子类的对象可以当作父类的对象来使用，upcasting，反之，downcasting。

加强制转换符

多态：

多态的存在条件

1.要有继承

2.要有重写

3.父类引用指向子类对象

这三个条件一旦满足，当你调用父类里面被重写这个方法时，实际当中，new的是哪个子类对象，就调用那个子类对象中重写的方法

用abstrack关键字来修饰一个类，这个类叫做抽象类

用abstrack关键字来一个方法时，这个方法叫做抽象方法

当一个类里面含有一个抽象方法，abstrack时，这个类也必须被声明为abstrack类

抽象方法，没有实现，publicabstrackvoidmethod（）；怎么实现，不用管，子类会去实现，子类会重写这个方法

如果子类也没有重写抽象方法，则出错，父类有抽象方法，子类继承了，就必须重写抽象方法，不然就需要重新再定该子类为抽象类，声明抽象方法，则该子类变为抽象类，不能new对象，他的子类来实现方法。

抽象类：

所以抽象类必须被继承，抽象方法必须被重写

抽象类的意义：

1.抽象类就是一个父类，可以封装所有子类所共有的成员变量和属性

2.为子类提供一个公共的类型

3.定义有抽象方法，虽然每个实现同一个行为的方法不一样，但是定义一样，抽象类可以封装

4.抽象类不可以被实例化

关键字final，，，

1.final定义的变量值（成员变量，局部变量）不能被改变

2.final的方法不能被重写

3.final的类不能被继承

Interface接口

接口是抽象方法和常量值定义的集合

接口是一种特殊的抽象类，这个类只包含常量和抽象方法，没有变量和方法实现

publicinterfacestudent{

publicstaticfinalintid=007；

publicrun（）；

publicstudy（）；

publicsleep（）；

publicsing（）；

}

接口的特性：

1.接口可以实现多种继承

2.接口之中声明的属性，默认为publicstaticfinal，也只能是这样，为了解决一些c++的问题

3.一个接口里的方法只能是抽象方法，只能是public

4.接口也可以继承其他的接口，添加自己新的属性和方法

implements当实现一个接口时，不是用extends而是implements

多个无关的类可以实现同一个接口

一个类也可以实现多个接口

与继承一样，接口与实现类之间也存在多态性

“内存分析非常重要”

四．异常处理：

运行期出现的错误：

观察错误的指示和行号最重要（程序永远都是调试调出来的）

概念：

是java提供的用于处理程序中出现错误的一种机制

这里所谓的错误是指在程序运行过程中，出现的一些异常事件（除0溢出啊，，数组下标越界，读取的文件不存在啊）

良好的程序，应该在发生异常时，提供处理这些错误的方法，使得程序不会因为异常的发生而阻断，或产生不可预见的结果

当执行java程序时，如果发生异常，可以生成一个异常类对象，该对象封装了异常事件的信息并被提交给java运行时系统，这个过程叫抛出（throw）

当java运行时系统接收到异常对象时，会寻找处理这一异常的代码，并把当前异常对象交给其处理，这过程叫捕获（catch）

关键字try{

有可能会发生异常的语句；

有可能发生异常的方法；

}catch（错误类名对象名）{

抓到这个异常了，如何提示

对象名.printStackTrace（）；//打印这个错误的堆栈信息

}

常见异常：

ArrayIndexOutOfBoundsException用非法索引访问数组时抛出的异常。

ArithmeticException当出现异常的运算条件时，抛出此异常。

所有类的老祖宗类，throwable类下面又分为两个类：

1.error类：

java运行时出现的异常，系统内部出错，java虚拟机出错了

2.Exception类：

能够处理的错误，网络故障，文件损坏，设备错误，用户输入非法等情况导致的异常

可以catch，可以捕获到，

A.分为普通exception，，必须捕获的，

B.RuntimeException，运行时出现的，经常出的，有时候可以不捕获

属于非检测异常

常见的5个

IllegalArgumentException向方法传递了一个不合法或不正确的异常

NullPointerException空指针异常

ArrayIndexOutOfBoundsException，数组下标越界

ClassCastException非法转换实例

NumberFormatException字符串非法转换为数值类型异常

publicvoidsomemethod（）throwsSomeException{声明该方法可能抛出的异常

If（someCondition）{当一些条件时

thrownewSomeException（“错误原因”）；构造并抛出异常对象

}

}

try{捕获异常

someMethod（）；

}catch（SomeExceptionex）{

如何处理的代码处理异常

}

try{

可能抛出异常的语句；

}catch（某个Exceptione）{

处理方法

}catch（某个Exception2e）{

处理方法;

}finally{//无论如何都会执行的语句

......

}

Trytry{......}捕获并处理例外的范围

可能一种或者几种类型的异常对象，分别后面跟着catch来处理相应的异常

如果没有例外发生，不执行catch

Catch相应的异常对象，在catch语句块中可以使用一些方法来获得一些信息

比如

getMessage（）：

用来得到相关异常事件的信息

printStackTrace（）用来跟踪异常事件发生时执行堆栈的内容

然后finally异常处理统一的出口，无论try是否抛出例外，finally里面的语句都要执行

所以通常finally语句中可以进行资源的清楚工作：

关闭打开的文件，删除临时文件

使用一个方法，或者使用一个类，有可能抛出除RuntimeException意外的异常时，一定要try{}catch，如果不想try{}catch，则需要继续抛出这个异常，交给上级处理

为程序的提供一个出口，使得程序流程在转到程序的其他部分的以前，能够对程序的状态做统一的管理

抛出异常throws，如果一个方法，无法处理这个异常，或者不想处理这个异常，那么就使用这个关键字抛出这个异常，在方法声明后面跟着写throws异常名就可以了。

抛出的异常按照先后顺序，从小到大，严格的来说，每一个异常都最好抛出

还有一个关键字throw，thrownewArrayIndexOfBoundException（）抛出一个异常对象

定义声明自己的异常类继承Exception

异常与继承的关系，

当继承的时候，重写了某方法，该方法原本是抛出某一个异常，你在重写的时候，如果要抛出异常，需要抛出与原方法一模一样的异常，或者不抛出异常，注意，如果抛出必须一模一样，范围不能大不能小

注意点：

A.一段代码可能产生多种异常，分别用catch捕获相应的异常，当发生这个相应的异常时候，会跳到相应的地方进行处理

B.如果没有异常发生，则不执行catch里面的语句

C.在catch中声明的异常对象封装异常该异常的信息，在语句块中，可以使用该对象的一些方法来处理

D.Catch从上到小的异常类顺序应该是从子类到父类，否则编译不通过

E.关键词finally语句是最后执行的，无论有没有抛出异常，finally指定的代码都要执行，通常用来释放资源

F.自行抛出异常，使用throw关键字

G.方法中抛出异常，可以用throws关键字，将异常抛出，交给调用这个方法的上一级来处理

H.三个方法getMessage（）得到有关异常事件的信息，printStackTrace打印异常的堆栈信息，getCause（）获取该异常出现的原因，有时候当一个异常由另一个异常导致的时候，这个方法很重要

I.有时候还是需要自己定义异常，继承Exception类自定义异常即可

捕获异常，先捕获小的，再捕获大的

五．数组~~~

多种相同类型的数据集合，在内存里面挨着分小格，每个小格里有东西，每个小格有个下标

Java的数组不能分配在栈上，属于引用类型，可以看成是一个对象，

一维数组声明

typevar[];或者，type[]var

比如inta1[]；int[]a1；double[]b；Personp[]；Strings1[];

在java里面声明数组不能指定数组的长度比如inta[5]；是错误的

使用new来创建数组对象

如果使用的是类名+[]来声明一个数组，则指向的是该类名的一个引用，然后new这个对象，该引用指向对象。

这里声明一个数组Datedays[];days=newDate[3];，，然后days[1]=newDate（构造方法）；days[2]=newDate（构造方法）；...

动态初始化：

先分配空间，然后再往里面赋值

静态初始化：

定义数组的同时就为数组分配空间和赋值

主方法中main（String[]args）就是声明了一个数组，如果想打印这个数组的内容，可以在执行程序时，后面增加命令行参数，来使用。

System.exit系统退出System.exit（-1）非正常退出，0正常退出

Java的数组声明，是按照从高维到低维的方式，简单一点说就是从左到右

六．API常用类

String类代表不可变的字符序列

String类常用构造方法

String（char[]value）AllocatesanewStringsothatitrepresentsthesequenceofcharacterscurrentlycontainedinthecharacterarrayargument.

分配一个新的String使其表示当前字符数组里所包含的字符序列。

String（char[]value,intoffset,intcount）AllocatesanewStringthatcontainscharactersfromasubarrayofthecharacterarrayargument.

分配一个新的String，包含当前字符数组里从offset个字符开始的共count个字符，截取一部分。

publicbooleanequals（ObjectanObject）

Comparesthisstringtothespecifiedobject.TheresultistrueifandonlyiftheargumentisnotnullandisaStringobjectthatrepresentsthesamesequenceofcharactersasthisobject.

String类重写的equals方法，将此字符串与指定的对象比较，如果字符串序列相同，则为true

String类常用方法

charAt（intindex）Returnsthechar