二级JAVA总结

时间:2019-05-14 21:13:09下载本文作者:会员上传
简介:写写帮文库小编为你整理了多篇相关的《二级JAVA总结》,但愿对你工作学习有帮助,当然你在写写帮文库还可以找到更多《二级JAVA总结》。

第一篇:二级JAVA总结

对长度为n的线性表进行冒泡排序,最坏情况先需要比较的次数为log2n。

对长度为n的线性表进行顺序排序,最坏情况先需要比较的次数为n。

高内聚低耦合有利于模块的独立性。

二叉树属于非线性结构。

算法具有可行性、确定性、有穷性和拥有足够的情报四个基本特征。

JAVA的反汇编命令是javap。

软件(程序)调试的任务是诊断和改正程序中的错误。

数据库应用系统中的核心问题是数据库设计。

在JAVA中,线程是抢占式的。

Object是所有类的根。

在软件开发中,需求分析阶段常使用的工具有数据流图(DFD)、数据字典(DD)、判断树和判断表。

关系数据库管理系统能实现的专门关系运算包括选择、投影、连接。

支持子程序调用的数据结构是栈。

init()方法用于初始化Applet ,start()方法用于激活Applet,paint()方法执行Applet的绘制功能。前序是根—左—右,中序是左—根—右,后序是左—右—根。

JAVA中,负责并发管理的机制是虚拟机。

JAVA中单精度常量以f或F结尾。

软件工程的理论和技术性研究的内容主要包括软件开发技术和软件工程管理。

相对于数据库系统,文件系统的主要缺陷有数据依赖、数据不一致性和冗余性。顺序存储结构的存储一定是连续的,链式存储结构的存储空间不一定是连续的。结构化程序设计的3种基本结构是顺序、选择、重复。

栈的特点是先进后出。队列的特点是先进先出。有序线性表既可以采用顺序存储结构,也可以采用链式存储结构。

数据库设计中反映用户对数据要求的模式是外模式。

对象具有如下特征:标识唯一性、分类型、多态性、封装性和模块独立性。

面向对象方法中,继承是指类之间共享属性和操作的机制。

类Pane默认的布局管理器是FlowLayout。

Frame默认的布局管理器是BorderLayout。

第二篇:2018年二级Java复习资料

一、Java的历史、现状

1.Java历史

在上世纪90年代初,sun公司有一个叫做Green的项目,目的是为家用消费电子产品开发一个分布式代码系统,这样就可以对家用电器进行控制,和它们进行信息交流。詹姆斯·高斯林(JamesGosling)等人基于C++开发一种新的语言Oak(Java的前身)。Oak是一种用于网络的精巧而安全的语言。Sun公司曾依此投标一个交互式电视项目,但结果是被SGI打败,Sun打算抛弃Oak。随着互联网的发展,Sun看到了Oak在计算机网络上的广阔应用前景,于是改造Oak,在1995年5月以“Java”的名称正式发布,从此Java走上繁荣之路。

当然提到Java历史,不得不提的一个故事就是Java的命名。开始“Oak”的命名是以项目小组办公室外的树而得名,但是Oak商标被其他公司注册了,必须另外取一个名字,传说有一天,几位Java成员组的会员正在讨论给这个新的语言取什么名字,当时他们正在咖啡馆喝着Java(爪哇)咖啡,有一个人灵机一动说就叫Java怎样,得到了其他人的赞同,于是,Java这个名字就这样传开了。当然对于传说,了解一下就好了,不必过于认真。

2.Java 作为学习Java的人士,对Java历史上发生的大事件有一个了解是应该的。

JDK(JavaSoftwareDevelopKit)):Java软件开发工具包。JDK是Java的核心,包括了Java运行环境,一系列Java开发工具和Java基础的类库。目前主流的JDK是Sun公司发布的JDK,除了Sun之外,还有很多公司和组织都开发了自己的JDK,例如IBM公司开发的JDK,BEA公司的Jrocket,还有GNU组织开发的JDK等等。

3.Java特点

简单地说,Java具有如下特点:简单的、面向对象、平台无关、多线程、分布式、安全、高性能、可靠的、解释型、自动垃圾回收等特点。

这里只解释一下平台无关和分布式,其余的在后面会逐步接触到。

3.1平台无关

所谓平台无关指的是:用Java写的程序不用修改就可在不同的软硬件平台上运行。这样就能实现同样的程序既可以在Windows下运行,到了Unix或者Linux环境不用修改就直接可以运行了。Java主要靠Java虚拟机(JVM)实现平台无关性。

平台无关性就是一次编写,到处运行:Write Once, Run Anywhere 3.2分布式

分布式指的是:软件由很多个可以独立执行的模块组成,这些模块被分布在多台计算机上,可以同时运行,对外看起来还是一个整体。也就是说,分布式能够把多台计算机集合起来就像一台计算机一样,从而提供更好的性能。

4.Java标准组织——JCP JCP(Java Community Process)是一个开放的国际组织,成立于 1995 年,主要职能是发展和更新 Java 技术规范、参考实现(RI)、技术兼容包(TCK)。Java 技术和 JCP 两者的原创者都是 SUN 计算机公司。组织成员可以提交 JSR(Java Specification Requests),通过讨论、认可、审核以后,将进入到下一版本的规范里面。

也就是说 JCP 是目前 Java 技术发展事实上的控制者和领领导者。

二、Java从代码到运行

用一个图来描述这个过程会比较容易理解:

1.编写代码

首先把我们想要计算机做的事情,通过 Java 表达出来,写成 Java 文件,这个过程就是编写代码的过程。如上图所示的 Hello.java 文件。

2.编译

写完 Java 代码后,机器并不认识我们写的 Java 代码,需要进行编译成为字节码,编译后的文件叫做 class 文件。如上图所示的 Hello.class 文件。

3.类装载ClassLoader 类装载的功能是为执行程序寻找和装载所需要的类。

ClassLoader能够加强代码的安全性,主要方式是:把本机上的类和网络资源类相分离,在调入类的时候进行检查,因而可以限制任何“特洛伊木马”的应用。

4.字节码(byte-code)校验

功能是对 class 文件的代码进行校验,保证代码的安全性。

Java 软件代码在实际运行之前要经过几次测试。JVM 将代码输入一个字节码校验器以测试代码段格式并进行规则检查--检查伪造指针、违反对象访问权限或试图改变对象类型的非法代码。注意----所有源于网络的类文件都要经过字节码校验器字节码校验器对程序代码进行四遍校验,这可以保证代码符合JVM 规范并且不破坏系统的完整性。如果校验器在完成四遍校验后未返回出错信息,则下列各点可被保证:

-类符合JVM规范的类文件格式所有操作代码的参数类型将总是正确的对象域访问是合法的

5.解释(Interpreter)可是机器也不能认识 class 文件,还需要被解释器进行解释,机器才能最终理解我们所要表达的东西。

6.运行

最后由运行环境中的 Runtime 对代码进行运行,真正实现我们想要机器完成的工作。

7.说明

由上面的讲述,大家看到,Java通过一个编译阶段和一个运行阶段,来让机器最终理解我们想要它完成的工作,并按照我们的要求进行运行。

在这两个阶段中,需要我们去完成的就是编译阶段的工作,也就是说:我们需要把我们想要机器完成的工作用 Java 语言表达出来,写成 Java 源文件,然后把源文件进行编译,形成 class 文件,最后就可以在 Java 运行环境中运行了。运行阶段的工作由 Java平台自身提供,我们不需要做什么工作。

三、Java程序设计基础

1.Java编程概况

现在你可以复习一下Java语言的背景材料,它的基本结构象C/C++,但任何用面向过程语言编写过程序的人都可以了解Java语言的大部分结构.1.1程序结构

Java语言的源程序代码由一个或多个编译单元(compilationunit)组成,每个编译单元只能包含下列内容(空格和注释除外):*一个程序包语句(packagestatement)*入口语句(importstatements)*类的声明(classdeclarations)*界面声明(interfacedeclarations)每个Java的编译单元可包含多个类或界面,但是每个编译单元最多只能有一个类或者界面是公共的。Java的源程序代码被编译后,便产生了Java字节代码。Java的运行系统工作起来如同一台虚拟机。在当前的Java实现中,每个编译单元就是一个以.java为后缀的文件。每个编译单元有若干个类,编译后,每个类生成一个.class文件。.class文件是Java虚拟机能够识别的代码。

1.2注释

三种类型如下://注释一行/*一行或多行注释*//**文档注释**/文档注释一般放在一个变量或函数定义前,指示在任何自动生成文档系统中调入。

1.3标识符

变量,函数,类和对象的名称都是标识符,程序员需要标识和使用的东西都需要标识符。在Java语言里,标识符以字符或_,$开头,后面可以包含数字,标识符是大小写有区别的,没有长度限制。

有效的标识符mynameict_networkHello_sys_path$bill 例子:inta_number;char_onechar;float$bill;1.4数据类型

Java使用五种基本类型:integer(整数),floating(浮点数),point(指针),Boolean(布尔变量),CharacterorString(字符或字符串)。

integer整数下边给出的数据表示都是整数的例子:4,15,089,0xAD00整数长度数据类型表示8bitsbyte16bitsshort32bitsint64bitslong floating浮点数下边给出的数据表示都是浮点数的例子:6.37,3.7E15,3e8 浮点数长度数据类型表示32bitsfloat64bitsdouble Boolean布尔变量下边是布尔变量的两种可能取值:

truefalseCharacter字符下边给出的都是字符的例子:a(tab)u(unicode)String字符串下边给出的都是字符串的例子:

“Thisisastringliteral”“中国科学院计算所”数组你可以定义任意类型的数组.chars[];这是字符型数组;int[]array;这是整型数组;你还可以定义数组的数组.intblock[][]=newint[2][3];数组边界在运行时被检测,避免堆栈溢出和内存崩溃.在Java里,数组实际上是一个对象,数组有一个成员变量: length。你可以用这个成员函数来查看任意数组的长度.inta[][]=newint[10][3]a.length/*10*/a[0].length/*3*/创建数组在Java里创建数组,你可使用两种基本方法:

创建一个空数组:intlist[]=newint[50];或你可以用初始数值填充数组.Stringnames[]={“Chenji”,“Yuan”,“Chun”,“Yang”};相当于下面功能:Stringnames[];names=newString[4];names[0]=newString(“Chenji”);names[1] =newString(“Yuan”);names[2]=newString(“Chun”);names[3]=newString(“Yang”);在编译时你不能象下例那样创建静态数组。intname[50];//将产生一个编译错误你也不能用new操作去填充一个没定义大小的数组。intname[];for(inti=0;i 1.5表达式

Java语言的表达式和C语言非常类似。运算符运算符(operator)优先级从高到底排列如下:.[]()++--!~instanceof*/%+-==!=&^&&||?:=op=,整数运算符在整数运算时,如果操作数是long类型,则运算结果是long类型,否则为int类型,绝不会是byte,short或char型。这样,如果变量i被声明为short或byte,i+1的结果会是int。如果结果超过该类型的取值范围,则按该类型的最大值取模。单目整数运算符是:运算符操作-单目非~位补码++加1--减1++运算符用于表示直接加1操作。增量操作也可以用加运算符和赋值操作间接完成。++lvalue(表示lvalue+=1,++lvalue也表示lvalue=lvalue+1(只要lvalue没有副作用)。--运算符用于表示减1操作。++和--运算符既可以作为前缀运算符,也可以做为后缀运算符。双目整数运算符是:运算符操作**+加-减*乘/除%取模&位与|位或^位异或=,==和!=产生boolean类型的数据。

布尔运算符布尔(boolean)变量或表达式的组合运算可以产生新的boolean值。单目运算符!是布尔非。双目运算符&,|和^是逻辑AND,OR和XOR运算符,它们强制两个操作数求布尔值。为避免右侧操作数冗余求值,用户可以使用短路求值运算符&&和||。用户可以使用==和!=,赋值运算符也可以用&=、|=、^=。三元条件操作符?:和C语言中的一样。

浮点运算符浮点运算符可以使用常规运算符的组合:如单目运算符++、--,双目运算符+、-、*和/,以及赋值运算符+=,-=,*=,和/=。此外,还有取模运算:%和%=也可以作用于浮点数,例如:a%b和a-((int)(a/b)*b)的语义相同。这表示a%b的结果是除完后剩下的浮点数部分。只有单精度操作数的浮点表达式按照单精度运算求值,产生单精度结果。如果浮点表达式中含有一个或一个以上的双精度操作数,则按双精度运算,结果是双精度浮点数。数组运算符数组运算符形式如下:

[]可给出数组中某个元素的值。合法的取值范围是从0到数组的长度减1。取值范围的检查只在运行时刻实。运算符以String对象实现。运算符“+”完成并操作,如果必要则自动把操作数转换为String型。如果操作数是一个对象,它可定义一个方法toString()返回该对象的String方式,例如floata=1.0print(“Thevalueofais”+a+“");+运算符用到例子Strings=”a=“+a;+=运算符也可以用于String。注意,左边(下例中的s1)仅求值一次。s1+=a;//s1=s1+a//若a非String型,自动转换为String型。对象运算符双目运算符instanceof测试某个对象是否是指定类或其子类的实例。例如:if(myObjectinstanceofMyClass){MyClassanothermyObject=(MyClass)myObject;„}是判定myObject是否是MyClass的实例或是其子类的实例。强制和转换Java语言和解释器限制使用强制和转换,以防止出错导致系统崩溃。整数和浮点数之间可以来回

强制转换,但整数不能强制转换成数组或对象。对象不能被强制为基本类型。

1.6Java流控制

下面几个控制结构是从C语言借鉴的。分支结构 if/else分支结构if(Boolean){statemanets;}else{statements;} switch分支结构switch(expr1){caseexpr2:statements;break;caseexpr3:statements;break;default:statements;break;} 循环结构for循环结构for(initexpr1;testexpr2;incrementexpr3){statements;} While循环结构While(Boolean){statements;} Do循环结构do{statements;}while(Boolean);一般顺序控制break[label]continue[label]reutrnexpr;label:statement;for循环例子下面是一个程序例子,画几条线,分别用红,绿,蓝颜色,这段程序可能是Java函数的一部分:intcount;for(count=1;count 2.Java变量和函数的实例

Java的类包含变量和函数。数据变量可以是一些原始的类型,如int,char等。成员函数是一些可执行的过程。例如,下面程序里:publicclassClassOne{inti;publicClassOne(){i=10;}publicvoidAdd_i(intj){i=i+j;}}ClassOne包含一个变量i和两个成员函数,ClassOne(intfirst)和Add_i(intj)。成员函数成员函数是一些可被其它类或自己类调用的处理子程序。一个特殊的成员函数叫构造函数,这个函数名称一般与本类名程相同。它没有返回值。构造函数和成员函数当你在Java里定义一个类时,你可定义一个或多个可选的构造函数,当创建本类的一个对象时用某一个构造函数来初始化本对象。用前面的程序例子来说明,当ClassOne类创建一个新实例时,所有成员函数和变量被创建(创建实例)。构造函数被调用。ClassOnemc:mc=newClassOne();关键词new用来创建一个类的实例,一个类用new初始化前并不占用内存,它只是一个类型定义,当mc对象初始化后,mc对象里的i变量等于10。你可以通过对象名来引用变量i。(有时称为实例变量)mc.i++;//mc实例变量加1因为mc有ClassOne类的所有变量和成员函数,我们可以使用同样的语法来调用成员函数Add_i:Add_i(10);现在mc.i变量等于21.结束函数Java并不支持析构函数(C++里的定义),因为java本身提供对象无用时自动清除的功能,同时它也提供了一个自动拉圾箱的成员函数,在清除对象时被调用:Protectedvoidfinalize(){close();} 3.对象

有效范围和废物自动回收对象有一定的生命期并在它的生命期间使用资源,当一个对象不再被使用时,它应释放内存,避免内存溢出。在Java里,收集和释放内存是一个叫自动废品回收站的线程的责任。这个线程监视对象有效范围并给一个走出有效范围的对象作上标识。

例如:Strings;//没有分配内存s=newString(”oldstring“);//分配内存s=”newstring“;//重新分配内存(创建新对象)我们将在以后访问String类时将更加明白它的工作过程,但它的快速工作过程是这样的:1.创建一个新的String类对象并填充以”oldstring“2.创建另一个String对象并填充以”newstring“注意我们创建了两个对象。Stirng对象”oldstring“Stirng对象”newstring“在第三条语句里,第一个包括”oldstring“的叫做s的对象已走出了有效范围,没有任何方法可以再访问他,我们现在有一个新的对象也叫s,包含”newstring“。在下一个废品回收线程,前一个对象将被标识并清除。

4.子类

子类是利用存在的对象创建一个新对象的机制,比如,如果你有一个Horse类,你可以创建一个Zebra子类,Zebra是Horse的一种。

classZebraextendsHorse{intnumber_OF_stripes:}关键词extends来定义对象有的子类.Zebra是Horse的子类。Horse类里的所有特征都将拷贝到Zebra类里,而Zebra类里可以定义自己的成员函数和实例变量。Zebra称为Horse的派生类或继承。另外,你也许还想覆盖基类的成员函数。用ClassOne说明,下面是一个派生类覆盖Add_i功能的例子.importClassOne;publicclassNewClassextendsClassOne{publicvoid Add_i(intj){i=i+(j/2);}} 当NewClass类的实例创建时,变量i初始化值为10,但调用Add_i产生不同的结果。NewClassmnc;mnc=newNewClass();mnc.Add_i(10);访问控制Java里当你创建一个新类时,你可以标明变量和成员函数的访问层次。

publicpublicvoidAnyOneCanAccess(){}public实例变量和成员函数可以任意其它类调用。protectedprotectedvoidOnlySubClasses(){}protected实例变量和成员函数只能被其子类调用.privateprivateStringCreditCardNumber;private实例变量和成员函数只能在本类里调用.friendlyvoidMyPackageMethod(){}缺省的,如果没有定义任何防火控制,实例变量或函数缺省定义成friendly,意味着可以被本包里的任意对象访问,但其它包里的对象不可访问。所有这个类的对象都只有实例变量的同一个拷贝,这种方法的关键词是static,例如:classBlock{staticintnumber=50;} 所有从Block类创建的对象的number变量值都是相同的。无任在哪个对象里改变了number的值,所有对象的number都跟着改变。同样的,你可以定义static成员函数,但这个成员函数不能访问非static函数和变量。classBlock{staticintnumber=50;intlocalvalue;staticvoidadd_local(){localvalue++;//没有运行}staticvoidadd_static(){number++;//运行}} 5.this和super 访问一个类的实例变量时,this关键词是指向这个类本身的指针,在前面ClassOne例子中,我们可以增加构造函数如下:

publicclassClassOne{inti;publicClassOne(){i=10;} publicClassOne(intvalue)this.i=value;} publicvoidAdd_i(intj){i=i+j;}} 这里,this指向ClassOne类的指针。如果在一个子类里覆盖了父类的某个成员函数,但又想调用父类的成员函数,你可以用super关键词指向父类的成员函数。

importClassOne;publicclassNewClassextendsClassOne{publicvoidAdd_i(intj){i=i+(j/2);super.Add_i(j);}} 下面程序里,i变量被构造函数设成10,然后15,最后被父类(ClassOne)设成25。NewClassmnc;mnc=newNewClass();mnc.Add_i(10);6.类的类型

至今为止,我用在类前面只用了一个public关键词,其实它有下面4种选择:abstract一个abstract类必须至少有一个虚拟函数,一个abstract类不能直接创建对象,必须继承子类后才能。

final一个final类声明了子类链的结尾,用final声明的类不能再派生子类。publicpublic类能被其它的类访问。在其它包里,如果想使用这个类必须先import,则它只能在它定义的package里使用。

7.抽象类

面向对象的一个最大优点就是能够定义怎样使用这个类而不必真正定义好成员函数。如果程序由不同的用户实现时是很有用的,这不需用户使用相同的成员函数名。

在java里Graphics类里一个abstract类的例子如下:publicabstractclassGraphics{publicabstractvoiddrawLine(intx1,inty1,intx2,inty2);publicabstractvoiddrawOval(intx,inty,intwidth,intheight);publicabstractvoiddrawRect(intx,inty,intwidth,intheight);...} 在Graphics类里声明了几个成员函数,但成员函数的实际代码是在另外一处地方实现的。publicclassMyClassextendsGraphics{publicvoiddrawLine(intx1,inty1,intx2,inty2){}} 当一个类包含一个abstract成员函数,这个类必须定义为abstract类。然而并不是abstract类的所有的成员函数都是abstract的。Abstract类不能有私有成员函数(它们不能被实现),也不能有静态成员函数。

8.包(Packages)包(Package)由一组类(class)和界面(interface)组成。它是管理大型名字空间,避免名字冲突的工具。每一个类和界面的名字都包含在某个包中。按照一般的习惯,它的名字是由”.“号分隔的单词构成,第一个单词通常是开发这个包的组织的名称。

定义一个编译单元的包编译单元的包由package语句定义。如果使用package语句,编译单元的第一行必须无空格,也无注释。其格式如下:packagepackageName;若编译单元无package语句,则该单元被置于一个缺省的无名的包中。使用其它包中的类和界面在Java语言里提供;一个包可以使用另一个包中类和界面的定义和实现的机制。用import关键词来标明来自其它包中的类。一个编译单元可以自动把指定的类和界面输入到它自己的包中。在一个包中的代码可以有两种方式来定义来自其它包中的类和界面:*在每个引用的类和界面前面给出它们所在的包的名字;//前缀包名法acme.project.FooBarobj=newacme.project.FooBar();*使用import语句,引入一个类或一个界面,或包含它们的包。引入的类和界面的名字在当前的名字空间可用。引入一个包时,则该包所有的公有类和界面均可用。其形式如下://从acme.project引入所有类importacme.project.*;这个语句表示acme.project中所有的公有类被引入当前包。以下语句从acme.project包中进入一个类Employec_List。//从acme.project而引入Employee_Listimportacme.project.Employee_list;Employee_Listobj=newEmployee _List();在使用一个外部类或界面时,必须要声明该类或界面所在的包,否则会产生编译错误。import(引用)类包(classpackage)用import关键词调入,指定package名字如路径和类名,用*匹配符可以调入多于一个类名。

importjava.Date;importjava.awt.*;如果java源文件不包含package,它放在缺省的无名package。这与源文件同目录,类可以这样引入:importMyClass。

Java系统包:Java语言提供了一个包含窗口工具箱,实用程序,一般I/O,工具和网络功能的包。

java.applet这个包包含量了设计applet的类,用一个类Applet和三个接口.AppletContext;AppletStub;和AudioClip.java.awt另一个窗口工具箱包.awt,包含了产生装饰物和GUI成员的类。这个package包括:

Button,Checkbox,Choice,Component,Graphics,Menu,Pane1,TextArea和TextField。java.ioI/Opackage包含文件输入/输出类,FileInputStream和FileOutputStream.java.lang这个包包含Java语言类,包含:对象,线程,异常出口,系统,整数,原点,数学,字符等。java.net这个类支持TCP/IP网络协议,并包含Socket类,URL和URL相联系的类。java.util这个类包含程序的同步类,它包含Date,Dictionary类等。

四、Java程序编写

象其它编程语言一样,Java 编程语言也被用来创建应用程序。一个共同的应用程序范例是在屏幕上显示字串“Hello World!”。下列代码给出了这个 Java 应用程序。

虽然很多你可能都不明白,没有关系,主要是来体会一下 Java 程序是什么样子,你可以先看看,有个印象,然后可以先模仿着做。1.HelloWorldApp 1.// 2.// HelloWorld 应用示例 3.// 4.public class HelloWorldApp{ 5.public static void main(String args[]){ 6.System.out.println(”Hello World!“);7.} 8.} 以上程序行是在你的屏幕上打印“Hello World!”所需的最少代码。

2.描述HelloWorldApp 第 1-3 行

程序中的 1-3 行是注释行 1 // 2 // HelloWorld 应用示例 3 // 第 4 行

第 4 行声明类名为 HelloWorldApp。类名(Classname)是在源文件中指明的,它可在与源代码相同的目录上创建一个 classname · class 文件。在本例题中,编译器创建了一个称为HelloWorldApp.class的文件, 它包含了公共类HelloWorldApp的编译代码。public class HelloWorldApp{ 第 5 行

第 5 行是程序执行的起始点。Java 解释器必须发现这一严格定义的点,否则将拒绝运行程序。

其它程序语言(特别是 C 和 C++)也采用 main()声明作为程序执行的起始点。此声明的不同部分将在本课程的后几部分介绍。如果在程序的命令行中给出了任何自变量(命令行参数),它们将被传递给 main()方法中被称作 args 的 String 数组。在本例题中,未使用自变量。

public static void main(String args[]){ public-方法 main()可被任何程序访问,包括 Java 解释器。

static-是一个告知编译器 main()是用于类 HelloWorldApp 中的方法的关键字。为使 main()在程序做其它事之前就开始运行,这一关键字是必要的。

void-表明 main()不返回任何信息。这一点是重要的,因为 Java 编程语言要进行谨慎的类型检查,包括检查调用的方法确实返回了这些方法所声明的类型。

String args[]使代码更好维护 封装迫使用户通过方法访问数据能保护对象的数据不被误修改,还能使对象的重用变得更简单。数据隐藏通常指的就是封装。它将对象的外部界面与对象的实现区分开来,隐藏实现细节。迫使用户去使用外部界面,即使实现细节改变,还可通过界面承担其功能而保留原样,确保调用它的代码还继续工作。封装使代码维护更简单。

2.继承

is a 关系—— 子对象

在面向对象世界里面,常常要创建某对象(如:一个职员对象),然后需要一个该基本对象的更专业化的版本,比如,可能需要一个经理的对象。显然经理实际上是一个职员,经理和职员具有 is a 的关系,经理只是一个带有附加特征的职员。因此,需要有一种办法从现有对象来创建一个新对象。这个方式就是继承。

“继承”是面向对象软件技术当中的一个概念。如果一个 对象 A 继承自另一个 对象 B,就把这个 A 称为”B 的子 对象 “,而把 B 称为”A 的父 对象 "。继承可以使得子 对象 具有父 对象 的各种属性和方法,而不需要再次编写相同的代码。在令子 对象 继承父 对象 的同时,可以重新定义某些属性,并重写某些方法,即覆盖父 对象 的原有属性和方法,使其获得与父对象不同的功能。

3.多态

同一行为的多种不同表达,或者同一行为的多种不同实现就叫做多态。

还是用刚才经理和职员这个例子来举例:人事部门需要对公司所有职员统一制作胸卡(一般也就是门禁卡,进出公司证明身份使用),制作的师傅说,只要告诉我一个人员的信息,就可以制作出一份胸卡,简化一下就是:一位职员的信息对应一份胸卡。

这个时候,对胸卡制作的师傅而言,所有的人都是职员,无所谓是经理还是普通职员。也就是说,对于传递职员信息这样一个行为,存在多种不同的实现,既可以传递经理的信息,也可以传递普通职员的信息。这就是多态的表现。

再举一个例子:比如我们说“笔”这个对象,它就有很多不同的表达或实现,比如有钢笔、铅笔、圆珠笔等等。那么我说“请给我一支笔”,你给我钢笔、铅笔或者圆珠笔都可以,这里的“笔”这个对象就具备多态。

八、Java类的基本构成

1.Java类的定义形式

一个完整的 Java 类通常由下面六个部分组成: 包定义语句 import 语句 类定义{ 成员变量 构造方法 成员方法 } 其中:只有类定义和“{}”是不可或缺的,其余部分都可以根据需要来定义。下面分别来学习各个部分的基本规则,看看如何写 Java 的类。

2.包

2.1.包是什么

在 Java 中,包是类、接口或其它包的集合,包主要用来将类组织起来成为组,从而对类进行管理。

2.2.包能干什么

包对于下列工作非常有用:

(1):包允许您将包含类代码的文件组织起来,易于查找和使用适当的类。(2):包不止是包含类和接口,还能够包含其它包。形成层次的包空间。

(3):它有助于避免命名冲突。当您使用很多类时,确保类和方法名称的唯一性是非常困难的。包能够形成层次命名空间,缩小了名称冲突的范围,易于管理名称。

为便于管理数目众多的类,Java 语言中引入了“包”的概念,可以说是对定义的 Java类进行“分组”,将多个功能相关的类定义到一个“包”中,以解决命名冲突、引用不方便、安全性等问题。就好似当今的户籍制度,每个公民除有自己的名字“张三”、“李四”外还被规定了他的户籍地。假定有两个人都叫张三,只称呼名字就无法区分他们,但如果事先登记他们的户籍分别在北京和上海,就可以很容易的用“北京的张三”、“上海的张三”将他们区分开来。如果北京市仍有多个张三,还可以细分为“北京市.海淀区的张三”、“北京市.西城区.平安大街的张三”等等,直到能惟一标识每个“张三”为止。

JDK 中定义的类就采用了“包”机制进行层次式管理,下图显示了其组织结构的一部分:

从图中可以看出,一个名为 java 的包中又包含了两个子包:io 包和 lang 包。lang 包中包含了 System, String, Object 三个类的定义。事实上,Java 包中既可以包含类的定义,也可以包含子包,或同时包含两者。

简而言之:从逻辑上讲,包是一组相关类的集合;从物理上讲,同包即同目录。

2.1.JDK中常用的包

java.lang----包含一些 Java 语言的核心类,包含构成 Java 语言设计基础的类。在此包中定义的最重要的一个类是“Object”,代表类层次的根,Java 是一个单根系统,最终的根就是“Object”,这个类会在后面讲到。

Java 并不具有“自由”的方法,例如,不属于任何类的方法,Java 中的所有方法必须始终属于某个类。经常需要使用数据类型转换方法。Java 在 Java.lang 包中定义了“包装对象”类,使我们能够实现数据类型转换。如 Boolean、Character、Integer、Long、Float 和Double,这些在后面会讲到。

此包中的其它类包括:

? Math——封装最常用的数学方法,如正弦、余弦和平方根。? String,StringBuffer——封装最常用的字符串操作。你不必显示导入该包,该 Java 包通常已经导入。

java.awt----包含了构成抽象窗口工具集(abstract window toolkits)的多个类,这些类被用来构建和管理应用程序的图形用户界面(GUI)。

javax.swing----完全 Java 版的图形用户界面(GUI)解决方案,提供了很多完备的组件,可以应对复杂的桌面系统构建。

java.net----包含执行与网络相关的操作的类,如 URL, Socket, ServerSocket 等。java.io----包含能提供多种输入/输出功能的类。java.util----包含一些实用工具类,如定义系统特性、使用与日期日历相关的方法。还有重要的集合框架。

2.2.Java中如何表达包——package语句

Java 语言使用 package 语句来实现包的定义。package 语句必须作为 Java 源文件的第一条语句,指明该文件中定义的类所在的包。若缺省该语句,则指定为无名包,其语法格式为:

package pkg1[.pkg2[.pkg3„]];//“[]”表示可选Java 编译 器 把包对 应 于 文 件系 统 的目 录管 理,因此包也可以嵌套使用,即一个包中可以含有类的定义也可以含有子包,其嵌套层数没有限制。package 语句中,用‘.’来指明包的层次;Java 语言要求包声明的层次和实际保存类的字节码文件的目录结构存在对应关系,以便将来使用该类时能通过包名(也就是目录名)查找到所需要的类文件。简单地说就是包的层次结构需要和文件夹的层次对应。

注意:每个源文件只有一个包的声明,而且包名应该全部小写。具体来说,程序员要做以下工作:

2.3.编译和生成包

如果在程序 Test.java 中已定义了包 p1,就必须将编译生成的字节码文件 Test.class 保存在与包名同名的子目录中,可以选用下述两种方式之一:

采用下述命令编译: javac Test.java 则编译器会在当前目录下生成 Test.class 文件,再在适合位置手动创建一个名为 p1 的子目录,将 Test.class 复制到该 p1 目录下。

采用简化的编译命令,就是可以带包编译 javac-d destpath Test.java 归入该包的类的字节代码文件应放在 java 的类库所在路径的 destpath 子目录下。现在包的相对位置已经决定了,但 java 类库的路径还是不定的。事实上,java 可以有多个存放类库的目录,其中的缺省路径为 java 目录下的 lib 子目录,你可以通过使用-classpath 选项来确定你当前想选择的类库路径。除此之外,你还可以在 CLASSPATH 环境变量中设置类库路径。destpath 为目标路径,可以是本地的任何绝对或相对路径。则编译器会自动在 destpath目录下建立一个子目录 p1,并将生成的.class 文件自动保存到 destpath/p1 下。例如: javac-d.Test.java javac-d C:test Test.java 2.4.带包运行

运行带包的程序,需要使用类的全路径,也就是带包的路径,比如上面的那个程序,就使用如下的代码进行运行:

java p1.Test 3.import 为了能够使用某一个包的成员,我们需要在 Java 程序中明确导入该包。使用“import”语句可完成此功能。在 java 源文件中 import 语句应位于 package 语句之后,所有类的定义之前,可以有 0~多条,其语法格式为:

import package1[.package2„].(classname|*);java 运行时环境将到 CLASSPATH + package1.[package2„]路径下寻找并载入相应的字节码文件 classname.class。“*”号为通配符,代表所有的类。也就是说 import 语句为编译器指明了寻找类的途径。

例,使用 import 语句引入类程序:TestPackage.java

java 编译器默认为所有的 java 程序引入了 JDK 的 java.lang 包中所有的类(import java.lang.*;),其中定义了一些常用类:System、String、Object、Math 等。因此我们可以直接使用这些类而不必显式引入。但使用其它非无名包中的类则必须先引入、后使用。

3.1.Java类搜寻方式

程序中的 import 语句标明要引入 p1 包中的 Test 类,假定环境变量 CLASSPATH 的值为

“.;C:jdk6lib;D:ex”,java 运行环境将依次到下述可能的位置寻找并载入该字节码 文件 Test.class:.p1Test.class C:jdk6libp1Test.class D:exp1Test.class 其中,“.”代表当前路径,如果在第一个路径下就找到了所需的类文件,则停止搜索。否则依次搜索后续路径,如果在所有的路径中都未找到所需的类文件,则编译或运行出错。

4.访问修饰符

Java 语言允许对类中定义的各种属性和方法进行访问控制,即规定不同的保护等级来限制对它们的使用。为什么要这样做?Java 语言引入类似访问控制机制的 目的 在 于实 现 信息的 封 装 和 隐藏。Java 语言为对类中的属性和方法进行有效地访问控制,将它们分为四个等级:private, 无修饰符, protected, public,具体规则如下:

变量和方法可以处于四个访问级别中的一个:公共,受保护,无修饰符或私有。类可以在公共或无修饰级别。

变量、方法或类有缺省(无修饰符)访问性,如果它没有显式受保护修饰符作为它的声明的一部分的话。这种访问性意味着,访问可以来自任何方法,当然这些方法只能在作为对象的同一个包中的成员类当中。

以修饰符 protected 标记的变量或方法实际上比以缺省访问控制标记的更易访问。一个protected 方法或变量可以从同一个包中的类当中的任何方法进行访问,也可以是从任何子类中的任何方法进行访问。当它适合于一个类的子类但不是不相关的类时,就可以使用这种受保护访问来访问成员。5.类定义

Java 程序的基本单位是类,你建立类之后,就可用它来建立许多你需要的对象。Java把每一个可执行的成分都变成类。

类的定义形式如下:

这里,类名要是合法的标识符。在类定义的开始与结束处必须使用花括号。你也许想建立一个矩形类,那么可以用如下代码:

6.构造方法

6.1.什么是构造方法

类有一个特殊的成员方法叫作构造方法,它的作用是创建对象并初始化成员变量。在创建对象时,会自动调用类的构造方法。

6.2.构造方法定义规则

Java 中的构造方法必须与该类具有相同的名字,并且没有方法的返回类型(包括没有void)。另外,构造方法一般都应用 public 类型来说明,这样才能在程序任意的位置创建类的实例--对象。

6.3.示例

下面是一个 Rectangle 类的构造方法,它带有两个参数,分别表示矩形的长和宽:

6.4.说明

每个类至少有一个构造方法。如果不写一个构造方法,Java 编程语言将提供一个默认的,该构造方法没有参数,而且方法体为空。

注意:如果一个类中已经定义了构造方法则系统不再提供默认的构造方

7.析构方法

析构方法 finalize 的功能是: 当对象被从内存中删除时,该成员方法将会被 自动调用。通常,在析构方法内,你可以填写用来回收对象内部的动态空间的代码。

特别注意:当我们去调用析构方法的时候,并不会引起该对象实例从内存中删除,而是不会起到任何作用。

在 Java 编程里面,一般不需要我们去写析构方法,这里只是了解一下就可以了。

8.属性

8.1.属性是什么

简单点说,属性就是对象所具有的静态属性。

8.2.定义规则

Java 类中属性的声明采用如下格式: 访问修饰符 修饰符 类型 属性名称=初始值;访问修饰符:可以使用四种不同的访问修饰符中的一种,包括 public(公共的)、protected(受保护的),无修饰符和 private(私有的)。public 访问修饰符表示属性可以从任何其它代码调用。private 表示属性只可以由该类中的其它方法来调用。protected 将在以后的课程中讨论。

修饰符:是对属性特性的描述,例如后面会学习到的:static、final 等等。类型:属性的数据类型,可以是任意的类型。属性名称:任何合法标识符

初始值:赋值给属性的初始值。如果不设置,那么会自动进行初始化,基本类型使用缺省值,对象类型自动初始化为 null。

8.3.说明

属性有时候也被称为成员变量、实例变量、域,它们经常被互换使用。

9.方法

9.1.方法是什么

方法就是对象所具有的动态功能。

9.2.定义规则

Java 类中方法的声明采用以下格式:访问修饰符 修饰符 返回值类型 方法名称(参数列表)throws 异常列表 {方法体} 访问修饰符:可以使用四种不同的访问修饰符中的一种,包括 public(公共的)、protected(受保护的),无修饰符和 private(私有的)。public 访问修饰符表示方法可以从任何其它代码调用。private 表示方法只可以由该类中的其它方法来调用。protected 将在以后的课程中讨论。

修饰符:是对方法特性的描述,例如后面会学习到的:static、final、abstract、synchronized 等等。

返回值类型::表示方法返回值的类型。如果方法不返回任何值,它必须声明为 void(空)。

Java 技术对返回值是很严格的,例如,如果声明某方法返回一个 int 值,那么方法必须从所有可能的返回路径中返回一个 int 值(只能在等待返回该 int 值的上下文中被调用。)方法名称:可以是任何合法标识符,并带有用已经使用的名称为基础的某些限制条件。参数列表:允许将参数值传递到方法中。列举的元素由逗号分开,而每一个元素包含一个类型和一个标识符。在下面的方法中只有一个形式参数,用 int 类型和标识符 days 来声明:public void test(int days){} throws 异常列表:子句导致一个运行时错误(异常)被报告到调用的方法中,以便以合适的方式处理它。异常在后面的课程中介绍。

花括号内是方法体,即方法的具体语句序列。9.3.示例

比如现在有一个“车”的类——Car,“车”具有一些基本的属性,比如四个轮子,一个方向盘,车的品牌等等。当然,车也具有自己的功能,也就是方法,比如车能够“开动”——run。要想车子能够开动,需要给车子添加汽油,也就是说,需要为 run 方法传递一些参数“油”进去。车子跑起来过后,我们需要知道当前车辆运行的速度,就需要 run 方法具有返回值“当前的速度”。

9.4.形参和实参

形参:就是形式参数的意思。是在定义方法名的时候使用的参数,用来标识方法接收的参数类型,在调用该方法时传入。

实参:就是实际参数的意思。是在调用方法时传递给该方法的实际参数。

比如:上面的例子中“int oil”就是个形式参数,这里只是表示需要加入汽油,这个方法才能正常运行,但具体加入多少,要到真正使用的时候,也就是调用这个方法的时候才具体确定,加入调用的时候传入“80”,这就是个实际参数。

形参和实参有如下基本规则:

(1):形参和实参的类型必须要一致,或者要符合隐含转换规则(2):形参类型不是引用类型时,在调用该方法时,是按值传递的。在该方法运行时,形参和实参是不同的变量,它们在内存中位于不同的位置,形参将实参的值复制一份,在该方法运行结束的时候形参被释放,而实参内容不会改变。

(3):形参类型是引用类型时,在调用该方法时,是按引用传递的。运行时,传给方法的是实参的地址,在方法体内部使用的也是实参的地址,即使用的就是实参本身对应的内存空间。所以在函数体内部可以改变实参的值。

9.5.参数可变的方法

从 JDK5.0 开始,提供了参数可变的方法。

当不能确定一个方法的入口参数的个数时,5.0 以前版本的 Java 中,通常的做法是将多个参数放在一个数组或者对象集合中作为参数来传递,5.0 版本以前的写法是:

int sum(Integer[] numbers){„} //在别处调用该方法

sum(new Integer[] {12,13,20});而在 5.0 版本中可以写为:

int sum(Integer...numbers){//方法内的操作} 注意:方法定义中是三个点 //在别处调用该方法 sum(12,13,20);//正确 sum(10,11);//正确

也就是说,传入参数的个数并不确定。但请注意:传入参数的类型必须是一致的,究其本质,就是一个数组。

显然,JDK5.0 版本的写法更为简易,也更为直观,尤其是方法的调用语句,不仅简化很多,而且更符合通常的思维方式,更易于理解。

第三篇:JAVA总结专题

在这忙忙碌碌的这段时间里,经过老师的辅导,迅速的将一点没有学的JAVA基础搞定了!有了基础学习还是好,万事开头难这句话说的太对了,学计算机语言我觉得记忆好的方法就是多打代码,课前预习,课堂上认真听讲,把现学的方法把以前所做的作业用最简便的方法再一次巩固,创新最重要,在后续的学习中,得要加倍努力学习。

其实学java有不懂,要先自己思考。想清楚这句代码是什么意思。为什么要写在这,等等之类的。等你真的搞不明白的时候,就一定要向老师咨询,不要感到有什么丢人的。因为不会是很正常的事。并不是每个人都是天才,一学就会,一学就能运用自如的。学java有一点是非常重要的,就是练习。一段代码要不停的敲,多敲几遍,尤其是自己不熟悉或者不熟练的代码,更要敲。不要感觉到厌烦,其实我感觉敲代码挺好玩的,并不是一件很枯燥的事。

老师平常布置的课后上机练习题一定要做,课后的练习题能够让你把新学到的知识巩固一遍,能够加深记忆,不会让你在以后做题的时候感到没一点思路。

当感觉到不会的时候,千万不要气馁,因为这很正常,现在的学习就是为了培养你有一个逻辑思维,为了以后开发软件的时候有个完整,清晰的思路。

其实,总体来说。学习java很快乐。尤其是当你遇到一道自己不会的题,然后,又通过自己的努力解决了,那时候,那种心情不是用言语来表达的。就好像你遇到一个数学难题,自己解决了之后那种成就感一样。

学java的时候一定要,放松心情,轻轻松松的来学,随时让自己快乐着,这样能够让你能够更快的接受java,千万不要有什么心理负担,因为java的特点之一就是--简单易懂。只要自己努力到了,就一定能够学好java。

学完了JAVA今天我们用项目案例:迷你DVD管理器来巩固了我们所学的所有内容,通过这项目的操练,首先,1、项目用到了会使用顺序、分支、循环、跳转语句编写程序,2、要会使用数组、操作字符串,3、会使用带参的方法;

4、会定义类、创建和使用对象,看到这些脑袋里一片迷茫啊!不知道怎样写,然后想到早写晚写都一样,就照着书上写起来了,到现在还是弄不懂的就是那个对象数组,不知道怎样去理解,抽象的把我抽晕了,有望老师来给我们补补这一章,在实现DVD的业务处理时,计算时差还是不懂,照着书上打了一遍,可还是得不到想要的结果,经过网上的搜寻与老师讲解,现在已略懂一二了,在做完这项目后,真不知道当时是怎样敲出来的,难道这就是所说的灵感!感觉很高兴,现在已习惯了代码报错,其实代码报错是一件值得鼓励的事,因为没有错就觉得自己什么都懂了,在学习中相信每一个人都遇到过挫折吧!但一定要想方法战胜挫折!我的战胜挫折方法就是不懂思考后还不懂就问,懂了以后就笔记本记下当时的解决方案!学习刚开始!后面的路很长,慢慢的去磨炼了!总结完毕!

第四篇:Java总结

Java实验

1.调试HelloWorld程序

2.this,super,get ,set,把课本90页程序4.7中的name改成私有变量

3.继承,重写,父类引用指向子类对象

4.验证数组Arrays类和Collection类

5.编写一个自己的异常类并捕获之。

6.编写一个类,将该类的几个对象装入TreeSet容器中,并将该容器的内容通过输出流写入文件中。

前三章重点

0.java的数据类型:四类八种-(1)布尔类型Boolean;(2)字符类型char;(3)整数byte,short,int,long;(4)浮点类型:float,double;1.面向对象的3个基本特征:封装,继承,多态。

2.构造方法和普通方法的区别:对构造方法而言,它有以下特性---(1)方法名必须与要创建对象的类名相同。(2)不允许声明返回类型,即使声明为void也不被允许。

3.this关键字:是一个引用,this引用指向的是其本身所在方法的当前对象。this的使用方法:(1)调用成员变量;(2)可以用this()调用其他构造函数。

4.java中只对类成员变量进行自动初始化,而方法内部的局部变量在使用前必须手动初始化。

5.static 关键字:可用来修饰类的成员变量和成员方法,需要注意两点--(1)静态方法不能调用类的非静态方法,不能访问类的非静态变量。(2)静态方法和静态变量(非私有的)可以有两种调用方式,一是实例对象调用,二是类名直接调用。

6.类成员访问控制修饰符public、private、default(可不写,即缺省状态)、protected的使用:public-公用的;private-私有的,只在定义它的类内部使用;default-可以被同一包中的类访问;protected-既可以被同一包中的类访问,也可以被不在同一包中的子类访问。

7.方法的重载:指方法名相同,而方法的参数列表不相同。参数列表不同有三层意思:(1)参数类型不同。(2)参数顺序不同。(3)参数个数不同。另外需注意,在同一个类中,当方法名和参数列表都相同时,访问控制修饰符或方法返回类型不相同并不是方法的重载,而且这种情况在java中是不被允许的。

第四五章重点

1.继承:需使用关键字extends.在使用继承时需注意--(1)每个子类只能定义一个超类(父类),即extends后面应且仅应跟一个类名作为该类的父类。(2)父类中的私有属性和私有方法不能被继承。

2.方法的重写:即子类对超类中的方法保持方法名、返回类型和参数列表不变,重写了方法体,使子类和超类完成不同的工作。重写需注意下面几个关键点:(1)超类中的私有方法不能被重写。(2)访问限制符强度由低到高依次是:public、protected、default、private,在重写过程中,如果子类和父类中方法的返回值、方法名及方法的参数列表都相同,这时,要求子类中该方法的访问限制符强度不能超过父类的。即如果父类中为public时,子类也只能为public,而不能是余下的三种。

3.重载(overload)和覆盖(override)的区别:(1)重载—发生在一个类的内部或子类与父类之间,要求方法名相同而参数列表不一样。(2)覆盖—只能发生在继承过程中,要求子类方法的返回类型,方法名和参数列表同父类的都相同,而方法体不一样。

4.构造器的调用顺序:先祖先,再客人,最后自己。

5.多态:指在类继承中子类和父类中可以有同名但意义或实现方式不同的属性和方法。分为:覆盖和重载。多态的优点:因为多态,可以在程序中对类进行扩展,而不需改变那些操作基类接口的方法。

6.动态绑定:指在代码执行期间,判断所引用对象的实际类型,根据其实际类型调用相应方法。动态绑定存在的三个必要条件--(1)要有继承;(2)要有重写(覆盖);(3)父类引用指向子类对象(向上转型)。

7.Object中常用的方法总结:toString();wait();equals();notify();notifyAll();hashCode();getClass();clone();finalize();(呵呵,尽可能记几个,以防老师让咱们列举)注:java中Object类是所有类的父类,即java中所有的类都有上述9种方法。

8.对象的比较:注意关键字instanceof的使用。

9.抽象类:

抽象方法—用关键字abstract修饰的方法,该方法只需方法的声明,而不需方法的实现(即无方法体)。

抽象类——至少包含一个抽象方法的类,也用abstract关键字声明。(注:(1)抽象类中可以有一些具体方法。(2)抽象类不能实例化。(3)子类继承抽象类必须实现其抽象方法。)

10.接口:

(1)可以看成是高度抽象的抽象类,但是接口不是类。

(2)用关键字interface来声明接口,用关键字imlpements来实现接口。

(3)接口不能有具体方法,不能有实例数据,但可以定义常量。

(4)实现接口的非抽象类必须实现接口的所有方法。

(5)每个类可以实现多个接口,这些接口用逗号隔开,同时,一个接口可以被多个类实现。

第六章:重点看一下实验四

1.容器——Collection(接口)和Map(接口).Collection——Set(接口)和List(接口)。其中,List必须保持元素的特定顺序,常见的实现类有ArrayList和LinkedList;Set不能有重复元素,常见的实现类有HashSet和TreeSet。

Map——一组成对的“键值对”对象,即其元素是成对的对象,常见的实现类有HashMap和TreeMap。

第七章 1.异常类的根类是Throwable类,它的两个直接子类是Error类和Exception类。

2.异常中常用的5个关键字为:try,catch,finally,throw,throws.其中,try和catch:用于捕获异常;finally:无论try块中的异常是否抛出,finally中的代码块总能被执行;throw:抛出异常;throws:声明异常。

3.“未被检查的异常(Unchecked Exceptions)”和“受检查的异常(Checked Exceptions)”——

Unchecked Exceptions :编译器不检查方法是否处理或抛出的异常,即不做处理,编译时不报错。

Checked Exceptions:受编译器检查的异常,即不做处理编译时通不过。

4.常见的几种Checked Exceptions:ClassNotFoundExceptionIOExceptionInterruptedExceptionFileNotFoundException.(尽可能的记几个吧,以防不测)第八章

1.流--字节流和字符流;

流--节点流和处理流。

2.所有的输入流都是从抽象类InputStream和Reader继承而来。所有输出流都是从抽象类OutputStream和Writer继承而来。3.字节流:InputStream和OutputStream;字符流:Reader和Writer;

4.节点流:直接与文件等底层打交道,如FileInputStreamFileOutputStreamFileReaderFileWriter.处理流:相当于包装流,套在节点流上,方便数据处理。相关一些用法,具体参考最后一次实验。

第五篇:java总结

调用父类构造方法

 在子类的构造方法中可使用super(argument_list)语句调用父类的构造方法

 如果子类的构造方法中没有显示地调用父类构造方法,也没有使用this关键字调用重载的其它构造方法,则系统默认调用父类无参数的构造方法

 如果子类构造方法中既未显式调用父类构造方法,而父类中又没有无参的构造方法,则编译出错

1public class Person {

3private String name;

4private int age;private Date birthDate;

7public Person(String name, int age, Date d){ 8this.name = name;

9this.age = age;

10this.birthDate = d;

11}

12public Person(String name, int age){ 13this(name, age, null);

14}

15public Person(String name, Date d){ 16this(name, 30, d);

17}

18public Person(String name){

19this(name, 30);}

21// ……

22}

1public class Student extends Person {

2private String school;

4public Student(String name, int age, String s){ 5super(name, age);

6school = s;

7}

8public Student(String name, String s){

9super(name);

10school = s;

11}

12public Student(String s){ // 编译出错: no super()13school = s;

14}

15}

对象构造和初始化细节

 分配存储空间并进行默认的初始化

 按下述步骤初始化实例变量

1.绑定构造方法参数

2.如有this()调用,则调用相应的重载构造方法,然后跳转到步骤5

3.显式或隐式追溯调用父类的构造方法(Object类除外)

4.进行实例变量的显式初始化操作

5.执行当前构造方法的方法体

==操作符与equals方法

==操作符与equals方法的区别:

 引用类型比较引用;基本类型比较值;

 equals()方法只能比较引用类型,“==”可以比较引用类型及基本类型;

 特例:当用equals()方法进行比较时,对类File、String、Date及封装类(Wrapper Class)来说,是比较类型及内容而不考虑引用的是否是同一个实例;

 用“==”进行比较时,符号两边的数据类型必须一致(可自动转换的基本数据类型除外),否则编译出错;

由装箱引发的——Integer比较的来龙去脉

前置知识: 众所周之,java是保留了int,char等基本数据类型的,也就是说int类型的并不是对象,然而有些方法却需要object 类型的变量,所以java使用了装箱机制,我们可一自豪的这样声明一个整型变量:Integer a = new Integer(10);那么整型的a也就是对象了,那这句是什么意思呢:Integer a= 10;java中可以这样声明一个对象吗?当然不是,从jdk1.5后,java实现了自动装箱,也就是自动将Integer a =10 中的int类型的10转化为了 Integer类型。好,有了前面的只是我们且先看一个题目:

Integer a = 127;

Integer b = 127;

Integer c = 128;

Integer d = 128;

System.out.println(a==b);

System.out.println(c==d);

答案是什么呢? 如果您回答true,false,那么很遗憾的告诉你,哈哈,其实你答对了!!

那我们晕了就相差1的两个数为啥走向了“反目成仇”的地步呢?凭啥127等于127,我128就不等于128呢?且听我慢慢道来,Integer a =127,Integer a=128。

127,128应该不会造成什么差异吧,难道是自动装箱的过程有猫腻?找下源码看看:

private static class IntegerCache {

private IntegerCache(){}

static final Integer cache[] = new Integer[-(-128)+ 127 + 1];static {

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

cache[i] = new Integer(i128);

}

这是用一个for循环对数组cache赋值,cache[255] = new Integer(255-128),也就是newl一个Integer(127),并把引用赋值给cache[255],好了,然后是Integer b= 127,流程基本一样,最后又到了cache[255] = new Integer(255-128),这一句,那我们迷糊了,这不是又new了一个对象127吗,然后把引用赋值给cache[255],我们比较这两个引用(前面声明a的时候也有一个),由于是不同的地址,所以肯定不会相等,应该返回false啊!呵呵,这么想你就错了,请注意看for语句给cache[i]初始化的时候外面还一个{}呢,{}前面一个大大的static关键字大咧咧的杵在哪呢,对静态的,那么我们就可以回想下static有什么特性了,只能初始化一次,在对象间共享,也就是不同的对象共享同一个static数据,那么当我们Integer b = 127的时候,并没有new出一个新对象

来,而是共享了a这个对象的引用,记住,他们共享了同一个引用!!,那么我们进行比较a==b时,由于是同一个对象的引用(她们在堆中的地址相同),那当然返回true了!!

然后我们在看Integer c = 128;Integer d = 128;这两句。现在不用我说就应该能明白了吧,当数据不再-128到127之间时,是不执行return

IntegerCache.cache[i + offset];这句的,也就是不会返回一个static的引用,而是执行了return new Integer(i);于是当 Integer d = 128 时,又会重新返回一个引用,两个不同的引用

在做c==d 的比较时当然返回false了!

下面附上本程序的字节码以供喜欢底层的读者参考:

Compiled from “CompareInteger.java”

public class CompareInteger extends java.lang.Object{

public CompareInteger();

Code:

0:aload_0

1:invokespecial#1;//Method java/lang/Object.“”:()V4:return

public static void main(java.lang.String[]);

Code:

0:bipush 127

2:invokestatic#2;//Method

java/lang/Integer.valueOf:(I)Ljava/lang/Int

eger;

5:astore_1

6:bipush 127

8:invokestatic#2;//Method

java/lang/Integer.valueOf:(I)Ljava/lang/Int

eger;

11: astore_2

12: sipush 128

15: invokestatic#2;//Method

java/lang/Integer.valueOf:(I)Ljava/lang/Int

eger;

18: astore_3

19: sipush 128

22: invokestatic#2;//Method

java/lang/Integer.valueOf:(I)Ljava/lang/Int

eger;

25: astore 4

27: getstatic#3;//Field

java/lang/System.out:Ljava/io/PrintStream;

30: aload_1

31: aload_2

32: if_acmpne39

35: iconst_1

36: goto40

39: iconst_0

40: invokevirtual#4;//Method java/io/PrintStream.println:(Z)V43: getstatic#3;//Field

java/lang/System.out:Ljava/io/PrintStream;

46: aload_3

47: aload4

49: if_acmpne56

52: iconst_1

53: goto57

56: iconst_0

57: invokevirtual#4;//Method java/io/PrintStream.println:(Z)V60: return

}

评论:呵呵,这么想你就错了,请注意看for语句给cache[i]初始化的时候外面还一个{}呢,{}前面一个大大的static关键字大咧咧的杵在哪呢,对静态的,那么我们就可以回想下static有什么特性了,只能初始化一次,在对象间共享,也就是不同的对象共享同一个static数据,那么当我们Integer b = 127的时候,并没有new出一个新对象来,而是共享了a这个对象的引用,记住,他们共享了同一个引用!!

呵呵,博主我被你这句话小小的误导了一下,其实你这里说的原理没错,但是把位置说错了,这段代码只是初始化cache:

static {

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

cache[i] = new Integer(i-128);

}

但真正让cache[i]为static变量的是这句代码:

static final Integer cache[] = new Integer[-(-128)+ 127 + 1];

下载二级JAVA总结word格式文档
下载二级JAVA总结.doc
将本文档下载到自己电脑,方便修改和收藏,请勿使用迅雷等下载。
点此处下载文档

文档为doc格式


声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:645879355@qq.com 进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。

相关范文推荐

    Java个人总结参考

    1、Java中取消指针运算防止了内存泄露的可能性。Java中的引用其实就是指针。JAVA语言不支持C++友元方法或友类。 2、编写完java源代码后,首先将其编译为一种中间状态字的字节......

    Java笔记总结

    1、Java是一种可以编译 跨平台、面向对象的高级计算机语言。 2、Java语言的特点:简单、安全、跨平台、面向对象、支持多线程。 3、Java的三个技术平台分别是 JavaSE、JavaEE......

    java实习总结

    java实习总结 java实习总结1 实习第五个礼拜,使用collection框架做派叫号系统首先分析项目需求,概述如下:1.产品参与者顾客:到营业大厅排队取号柜员:提供业务服务的柜台业务员管......

    java培训总结(范文大全)

    在现在这个科技飞速发展的时代,计算机已经悄然走进我们的生活,并且占据了不可动摇与替代的地位,无论是在工作还是生活,学习还是娱乐中,当我们意识到的时候,却突然发现我们已经离不......

    java学习总结

    第三周学习总结这周从HTML学到了mysql: 1. HTML:Hypertext Markup Language超文本标记语言 后缀名为.html或.htm 由两部分组成:head和body 2.body属性:bgcolor、background、bgp......

    Java实习总结

    Java实习总结Java实习总结1进一步了解Java开发的相关知识,掌握Java开发的基本技术,丰富Java开发的实战经验。学习SQL的基础知识及正确的运用方法,ssh等企业应用框架和有用的相......

    Java排序总结

    倒叙排序 第一种利用一个数组来盛放后,再来倒叙输出 public class daoxu { } 第二种利用一个变量来转换后,倒序输出 public class daoxu { public static void main(String......

    Java线程总结

    Java线程总结 首先要理解线程首先需要了解一些基本的东西,我们现在所使用的大多数操作系统都属于多任务,分时操作系统。正是由于这种操作系统的出现才有了多线程这个概念。我......