面向对象程序设计课件

面向对象程序设计

【学习目标】了解Java的历史和发展了解Java的工作方式初步接触Java程序的两种方式：

JavaApplication和JavaApplet学习阅读Java帮助文档，并安装Java开发环境和帮助文档第一章Java编程语言概述1.1Java的历史与发展1.1.1Java的历史最初命名为Oak（橡树）小组主要成员：JamesGosling等最初目的：与家用电器一起使用1994年，小组意识到Oak非常适合用于Internet于1995年5月发布第一个非试用版本于1996年发布Java技术是免费的JamesGoslingJavaOne大会1996年5月，第一界JavaOne大会在旧金山召开。1.1.2Java的发展1995.5.23Java诞生1997.2.18JDK1.1(Java1.1API)

VJ++、cafe、JBuilder….支持

1998.12JDK1.2(Java2SDK1.2)

目前版本J2SDK1.4.2网址（查询新动向）《ThinkinginJava》，BruceEckel， 机械工业出版社1.1.3Java的设计目标

创建一种面向对象的程序设计语言

易于移植到不同的平台（一次编译，到处运行）

吸收C和C＋＋的优点，使程序员容易掌握

去掉C和C＋＋中影响程序健壮性的部分，例如指针、内存申请和释放，使程序更安全稳定

实现多线程，使得程序能够同时执行多个任务

为分布式环境提供动态下载程序代码的机制

提供代码校验机制以保证安全性1.2Java的工作方式计算机的高级编程语言类型: -编译型

-解释型编译型:跨平台性差解释型:跨平台，速度慢Java文件类型.java Java源文件.class 二进制字节码文件Java编译器Importjava.io.*;classtest{….}test.javaDFBA0988……..test.class编译过程Java虚拟机Java虚拟机的建立需要针对不同的软硬件平台做专门的实现，既要考虑处理器的型号，也要考虑操作系统的种类。如下图所示，目前在SPARC、X86、MIPS和PPC等嵌入式处理芯片上、在UNIX、Linux、windows和部分实时操作系统上都有java虚拟机的实现。Java源程序编译字节码文件Java虚拟机执行LinuxWindowsMac

1.2.2Java平台 TheJavaVirtualMachine(JVM)

TheJava应用编程接口(JavaAPI)：

Java应用编程接口是已编译的可在我们的程序中使用的代码库(基础类库)。它们使我们能够添加现成的可定制的功能，以节约编程时间。

JavaPlatform2J2SE:StandardEdition针对桌面计算机开发（主要有JavaApplet和JavaApplication应用程序J2EE:EnterpriseEdition用来开发企业应用的平台，基于组件技术的应用开发框架J2ME:MircoEdition针对嵌入式技术1.3Java语言的特点

Asimple,object-oriented,distributed,interpreted,robust,secure,architecture-neutral,portable,high-performance,multi-threaded,dynamiclanguage1．简单、面向对象和分布式

2．解释执行、鲁棒并且安全

3．结构中立并且可以移植

4．高性能

5．多线程并且是动态的简单：KISSC++like无指针自动内存回收面向对象完全基于类、对象封装、继承、多态取消多继承、模版、运算符重载分布式动态下载程序代码的机制完全是为了适应网络分布式计算的特点Java简化了网络支持，使得网络编程比较简单。远程方法调用（RMI）技术使得分布式计算实现起来非常容易。Java对XML的强大支持进一步提高了分布式环境下的计算。解释执行稳定性检查数据类型的匹配，数组下标越界检查无指针自动内存管理，保护内存数据、程序碎片收集例外控制机制，正确处理运行时错误

安全性代码检测垃圾收集机制，自动内存回收无指针可移植

JVM统一的数据类型

int-32bit char-16bitunicode高效JIT(Just-In-Time)及时编译器的代码生成技术可按需编译字节代码为机器代码，提高运行速度。多线程支持多任务动态动态下载程序代码的机制，程序可以根据需要把代码实时的从服务器中下载过来执行

对象（object）我们可以把生活所在的真实世界（RealWorld）当作是由许多大小不同的对象所组成的。对象可以是有生命的个体，比如一个人或一只鸟。对象

对象也可以是无生命的个体，比如一辆汽车或一台计算机。对象也可以是一件抽象的概念，如天气的变化或鼠标所产生的事件。对象的特征

对象有两个特征：属性和行为例如： 人有他的身高或体重作属性，有他的行为——如唱歌、打球、骑摩托车、开汽车。 狗有它的颜色作属性，有它的行为，如吠叫或跳跃。

电视机有它的外形、尺寸和颜色，有它的行为，如开、关，接收信号，转换频道，调节音量。换档开大灯煞车开冷气颜色排档数排气量轮胎型号汽车对象

以汽车为例，我们可定义其属性与方法如：

本教程

中使用下面的示例来应用面向对象的分析与设计原理。公司名称：DirectClothing公司按月生成目录客户可以打电话、使用邮寄和传真必须每个检查订购项的存货水平DirectClothing接受支票和信用卡案例研究

系统建模技术尝试描述一个系统在现实生活中的情形定义系统的：对象——让对象工作的问题对象属性——对象的特征对象操作——所能执行的任务面向对象概述

对象:

找出问题描述领域中的主要名词对象可能是：简单的或复杂的（衬衣，银行）真实的或概念的（银行出纳员，帐户）对象有：属性(颜色，尺寸)操作（下订单，取消订单）确定对象

属性：是对象的特征可以是数据或对象对Order对象来说，可能包括orderID和items操作：是对象执行的动作可以是对象做出的或施加给对象的动作对Order对象来说，可能是place和cancel确定对象属性和操作

建模对象

属性类型

与问题域的相关性对象是否在问题陈述的界限之内？系统是否必须有此对象才能完成任务？在用户与系统的交互中是否必须有此对象？独立存在性属性和操作测试对象

分析问题域实验目标：找出问题域中的对象，及其属性和操作步骤：1、列出有关的对象（名词）

2、列出这些对象的属性和操作

3、为对象设置合理的属性和操作

4、应用上述的3条评判规则检验对 象的有效性练习 Anobject-orienteddesignforaJavaapplicationthattrackssoccerscores.Theprogramshouldtrack:ThenumberofgoalseachplayerscoresineachgameWhatteamstheplayersplayforandwhatseasonthegameswereplayin

类（class）在真实世界里，有许多同“种类”的对象。而这些同“种类”的对象可被归类为一个“类”。例如我们可将世界上所有的汽车归类为汽车类，所有的动物归为动物类。动物类汽车类什么是类?是同种对象的集合与抽象

类与对象的关系 类

对象抽象定义实例

电视机

一台长虹电视机学生

学生王强

类与对象如果将对象比作汽车，那么类就是汽车的设计图纸。所以面向对象程序设计的重点是类的设计，而不是对象的设计。

实例（instance）汽车类有些共同的状态（汽缸排气量，排档数，颜色，轮胎数……）和行为（换档，开灯，开冷气……），但每一台汽车个别的状态及方法可不同于且独立于其他汽车。你的汽车只是这世界中许多汽车中的一个。我们就称你的汽车对象是汽车类中的一个实例（instance）。汽车类（class)实例（instance)NEW你的车OO的真正意义

OO的真正意义是使得软件开发接近人类的正常思维，将许多原来由人完成的工作交给机器去完成：

-机器语言 汇编语言 高级语言

-面向过程 面向模块 面向对象

OO包括一套比较完整的方法，程序设计只是其中一个环节。

-面向对象的分析

-面向对象的设计

-面向对象的程序设计

-代码重用面向对象与面向过程公共数据函数函数函数函数算法＋数据结构属性数据方法方法属性数据方法方法过程式程序设计OOP程序设计对象＋消息消息面向过程面向对象OOP三大特性：封装、继承与多态

封装（encapsulation）

封装是一种信息隐藏技术。是指利用抽象数据类型将数据和基于数据的操作封装在一起，数据被保护在抽象数据类型的内部，系统的其他部分只有通过在数据外面的被授权的操作才能够与这个抽象数据类型进行交互。在面向对象的编程中，用类来封装相关的数据和方法，保证了数据的安全和系统的严密性。

仓库属性操作价格表,物品,账单，电话,等等提供物品，账单等等考虑一个仓库，外部只能通过管理员获取物品。抽象封装的优点隐藏类的实现细节,实现了信息的隐藏及安全性；提高了程序的模块化，且易于维护；具体实现是编写该类的人控制的,让使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作继承(inheritance)

OOP是以类来定义一个对象的。当一个类拥有另一个类的所有数据和方法时，就称这两个类之间具有继承关系。现以下图来说明：汽车类轿车巴士计程车轿车、出租车、巴士都是汽车，故属汽车类，我们称其继承(inherit)汽车类，而轿车、出租车、巴士也都可自成一种类。这样汽车类就称为超类（superclass）或父类，而轿车、出租车、巴士就称作子类。继承交通工具车船飞机汽车火车父类/超类（superclass）子类（subclass）Java仅支持单继承优点： 使程序结构清晰，减少了编码和维护的工作量，子类可以使用父类所提供的方法，实现了代码的复用。多态用同一个名字调用实现不同操作的方法方式1：父类和子类之间的同名方法（覆盖：子类方法的名称和参数与父类方法的名称和参数相同，在执行过程中，子类的方法将覆盖父类的方法）方式2：同一类中参数不同的同名方法（重载：不是子类对父类同名方法的重新定义，而是类对自身已有的同名方法的重新定义。重载方法的参数必须不同，或者是参数个数不同，或者是参数类型不同）使用方便，且降低了维护和编程量

覆盖

classA { publicintx,y; A(inta,intb) { x=a; y=b; } publicvoiddisplay() { intz; z=x+y; System.out.println(“add=”+z); } } classBextendsA { B(inta,intb) { super(a,b); } publicvoiddisplay() { intz; z=x*y; System.out.println(“product=”+z); } }classABextendsB { AB(intx,inty) { super(x,y); } publicstaticvoidmain(String[]args) { Anum1=newA(4,10); Bnum2=newB(4,10); ABnum3=newAB(4,10); num1.display(); num2.display(); num3.display();

} }重载classMethodOverloading { voidreceive(inti) { System.out.println(“一个整数”); System.out.println(“i=”+i); } voidreceive(intx,inty) { System.out.println(“两个整数”); System.out.println(“x=”+x+”y=”+y); } voidreceive(doubled) { System.out.println(“一个浮点数”); System.out.println(“d=”+d); } voidreceive(Strings) { System.out.println(“一个字符串”); System.out.println(“s=”+s); } }

publicclassMethodOverloadingTest { publicstaticvoidmain(String[]args) { MethodOverloadingMO=newMethodOverloading(); mo.receive(1); mo.receive(2,3); mo.receive(12.56); mo.receive(“Hello”);

} }面向对象的三大特征1.封装：将数据成员（DataMember）和属于此数据的操作方法（OperatingMethod），放在同一个实体（Entity）或对象中。2.继承：父类定义（Define）一些通用的属性与行为，其孩子继续使用。3.多态：在同一个类中可有许多同名的方法，但其参数数量与数据类型不同，而且操作过程与返回值也可能会不同。（1）模块化

（2）信息隐藏

（1）实现代码复用

（2）简化设计过程解决其他语言中不能重名的问题

接口Interface这个英文字的意思是一种装置或系统，使得不同性质的实体（entities）能够交互地运作。比如，计算机的操作系统（operatingsystem），可把它称作是一种“人机接口”。可使得使用者（人）与计算机（机），通过鼠标或键盘等装置，而作为一种沟通接口，来与计算机做沟通，以指挥计算机做事。另外像RS232串行端口，常作为输入/输出设备传输接口，是计算机与输入/输出设备间的接口。而在Java里，设计接口的用意，是可使得类不必受限于单一继承的关系，而可灵活地同时继承一些共有的特性，达到多重继承的目的，而免去C++中多重继承的复杂关系所产生的bug。像下图中的出租车，可继承“营业车”、“小车”、“汽油车”等类，却不一定非要与同样继承“自用车”、“小车”，“汽油车”的轿车有上下继承的关系。汽车类自用车营业车小车大车汽油车柴油车轿车出租车巴士上类接口次类改变程序的一部分不影响其他部分。程序的其他部分与类的接口（“外部”）进行交互更改类的实现（“内部”）而不更改接口封装的汽车：实现细节隐藏在车盖下；驾驶员不必知道汽车是怎样工作的汽车的部分零件改变或更换，驾驶员不必改变对汽车的驾驶接口和实现

接口的定义

接口可以理解为一个特殊的类，只有常量和抽象方法组成的特殊类。

interfaceCollection { intMAX_NUM=100; voidadd(inta); voiddelete(intb); intfind(intc); intcurrentCount(); }以前编写的操作可以在其他工程中再次使用，可提高开发效率，缩短开发周期复用

继承概述有重复成员的类继承:Manager和CSR继承Employee继承的定义一个类中定义一些公共成员（变量和方法）,其他类可以扩展该类而共享成员被扩展的类是:超类或父类继承了的类是:子类查看结果：Employee.java继承:Employee和Customer继承Person测试继承类一次只能继承一个父类（单继承）使用“是一个（isa）”短语验证继承Employee、Manager和CSR示例中继承是正确的一个Manager是一个Employee一个CSR是一个Employee测试继承错误原因：不满足“isa”短语正确原因：满足“isa”短语查看结果：AddTest.javasupersuper用来引用当前对象的父类(1)访问父类被隐藏的成员变量，如：

super.variable;(2)调用父类中被重写的方法，如：

super.Method([paramlist]);(3)调用父类的构造函数，如：

super([paramlist]);查看结果：OverTest.java包import语句格式：importpackage1[.package2…].(classname|*);从目录classpath\package1\package2…中查找。

classname指明所要引入的类，例如：

importjava.awt.Button;*表明要从一个包中引入多个类,例如：

importjava.awt.*;新术语在Java技术中：变量=属性方法=操作类仍然称作类所谓类就是一类属性（变量）和操作（方法）的描述。其中，属性可用一系列的变量表达，而操作用一系列方法表示。一类人员Person：抽象出下列属性：名字、年龄、身高、婚否、性别，分别用变量name、age、height、marriage、sex表示（见名知义），吃饭，讲话，走路等行为可表示为相应的方法eat()，speak()，walk()等。用Java语言描述Person类如下：classPerson{//以下5个是变量Stringname;intage;doubleheight;booleanmarriage;charsex;

speak(…)//方法{…}

eat(…)//方法{…}}

对Person类中某一特定的人，上述变量就有特定的值，如name（张三），age（20），height（1.76），marriage（false），sex（’m’）。主要的应用程序组件类代码块是程序的主要结构变量是程序执行所使用的数据方法代码块是用于程序操作的结构使用大括号{和}来定义代码块在操作的结尾使用分号查看结果：Shirt.java

javacHello.javaD:\Lesson3>

javaHelloD:\Lesson3>Hello,JavaWorld!编译、运行应用程序Application:Debugging调试检查错误消息中指出的行检查分号检查大括号数是否为偶数使用基本数据类型将数据存储在变量中基本类型包括：整型——byte,short,int和long浮点型——float和double字符型——char逻辑型——boolean基本数据类型

数据类型名占用内存空间数值范围缺省值说明byte1字节(-128)～1270整型short2字节(-32768)～327670int4字节(-2147483648)～21474836470long8字节(-9223372036854775808)～92233720368547758070float4字节0.0F浮点型double8字节0.0Dchar2字节字符型boolean——true或falsefalse布尔型类型长度范围byte8bit-27~27-1（-128~127）short16bit-215~215-1（-32768~32767）int32bit-231~231-1(-2147483648~2147483647)long64bit-263~263-1(-9223372036854775808~9223372036854775807)存储没有小数部分的数据类型

Java各整数类型有固定的表数范围和字段长度，而不受具体操作系统的影响，以保证Java程序的可移植性1、整型

数值20在内存中的存储形式

00010100

byte（1字节）00000000

00010100

short

（2字节）高位置000000000

00000000

00000000

00010100

int

（4字节）00000000

00000000

00000000

00000000

00000000

00000000

00000000

00010100

Long

（8字节）2、浮点型

浮点型是带有小数部分的数据类型，包括两种不同的数据类型：float和double。float类型的变量占用4个字节（32位），double类型的数据则需要8个字节（64位）内存。在许多程序中，就其表示的数值范围而言，使用float类型来存储浮点数已经足够了。浮点数据有两种表示形式十进制数形式，必须含有小数点，例如: 3.14314.0.314科学记数法形式，如3.14e23.14E-12Java浮点数据默认为double型,如要声明一个常量为float型，则需在数字后面加f或F，如：

doubled=3.14; floatf=3.14f;3、布尔型（boolean）

布尔数据类型用于表达两个逻辑状态之一的值：true（真）或false（假）。布尔型数据只有两个值true和false，且它们不对应于任何整数值。布尔型变量的定义如：

booleanb=true;

4、字符型(char)字符型数据类型用于存放单个字符，每个字符占用2个字节（16位）的存储空间。将一个字符放到一个字符变量中，实际上并不是把该字符本身放到内存单元中去，而是将该字符的相应的Unicode代码放到存储单元中。

charc1=‘t’; charc2=‘3’;char基于Unicode编码，\u前缀标志着这是一个Unicode值 例如，\u0061代表字符’a’。标识符Java保留字（又称关键字）

关键字不能作为标识符； 关键字是具有专门的意义和用途，不能当作一般的标识符使用，这些标识符称为保留字(reservedword),下面列出了java语言中的所有保留字：abstractdoimplementsprotectedthrowsbooleandoubleimportpublictransientbreakelseinstanceofreturntruethisthrowbyteextendsintshorttrysynchronizedcasefalseinterfacestaticvoidcontinuecatchfinallongstrictpfvolatilegotodefaultcharfinallynativesuperwhilepackageclassfloatnewswitchconstfornullifprivatejava中的关键字均用小写字母表示。合法的标识符identifieruserNameUser_Name_sysval$change A98_23

_abc非法的标识符

2mail room# classA-4

3_1

>the变量（属性）

变量是用来存放指定类型的数据，其值在程序运行过程中是可变的。

在使用Java中的每个变量之前，都必须对它进行声明。变量的声明形式如下：

类型

变量名；

变量声明包括指明变量的数据类型、变量名和作用域其中数据类型说明了这个变量能存放什么样的数据。变量名是用来标识该变量的，我们存取变量的内容（变量的值）都是通过变量名来实现的。变量名

在Java中用标识符来表示变量名。象Person这个类，我们使用了name、age、tall、marriage、sex这几个标识符，分别定义了五个变量。程序员应该为变量取有意义的名称，以利于程序的阅读和理解。（见名知义）但变量取名时还有一些限制：变量名由字母、数字、下划线或美元符“$”组成的变量名不能以数字作为第一个字符区分大小写下面是合法的变量名：

Month（不同于month），student_name，class1，dollar$，$abc而下面的变量名都不合法：

3a46，a>b，abc-d，#ef.

变量名

变量名中字母大写和小写是有区别的，name和Name表示两个不同的变量名。Java中约定，变量名以小写字母开头，若一个变量名由超过一个单词所组成，则第一个单词之后的所有单词都以大写字母开头，以便于理解该变量名。例如：anIntVar表示一个整型变量。变量的初始化

赋予变量一个初值，称为变量的初始化。可在定义变量的同时进行变量的初始化，如：intanIntVar=1;charaCharVar=’A’;floataFloatVar=1.23f;booleanaBooleanVar=true;也可定义变量后再单独初始化，如：intanIntVar;charaCharVar;floataFloatVar;booleanaBooleanVar;anIntVar=1;aCharVar=’A’;aFloatVar=1.23f;aBooleanVar=true;两种方法都完成了定义变量：anIntVar、aCharVar、aFloatVar、aBooleanVar，并分别给它们赋初值：1、’A’、1.23、true。变量的作用域

变量的作用域：变量的使用范围。假定在某代码段中能够使用一特定变量，则此段代码即是该变量的作用域。在类中声明的类成员变量，可在该类的各个成员方法中使用；在某个方法体中或参数表中声明的变量，只能在该方法体中使用；在某个语句块中声明的变量，只能在该语句块中使用。变量的作用域publicclassVariableLifeTime{ publicstaticvoidmain(String[]args) { intsum=0；

intA=10; for(intx=1;x<=5;x++) {

inty=0; y=y+A; sum=sum+y; System.out.print("x="+x); System.out.print("y="+y); System.out.println("sum="+sum); } System.out.println("sum="+sum); }}查看结果：VariableLifeTime.javaclassPerson{//以下5个成员变量

Stringname; intage; doubletall; booleanmarriage; charsex;

//以下2个方法

eat(Stringeatwhat){ System.out.println(name+”ateupthe“+eatwhat); }}

Speak(Stringsaywhat，inttime){inti;for(i=0;i<time;i++)System.out.println(name+”say:”+saywhat);}变量name、age、tall、marriage、sex的作用域变量i的作用域下图为变量作用域的示意图:由左图可以看出，变量name、age、tall、marriage、sex和变量i的作用域是不同的。变量name、age、tall、marriage、和sex的作用域是整个类，在类的方法中也可使用它们。这种变量称之为成员变量。确切地讲，成员变量是在类当中、但不是在其类的方法中定义的变量。而变量i是定义在speak方法中，它的作用域仅限于speak方法中。这类定义在某方法中的变量叫做局部变量。注意：同一作用域中不可有同名的变量。如上面的代码在speak方法中不能再定义一个名字为i的变量。常量

常量是指在程序运行过程中其值不变的量。定义常量的方法有两种：（1）在定义变量的类型前面加final关键字，并同时进行初始化，如下所示：finalintaFinalVar=0;finaldoublePI=3.14159;

（2）在定义变量的类型前面加final关键字，不进行初始化。通过另外的语句进行赋值。如下所示：finalintaFinalVar;…aFinalVar=0;常量和变量常量与变量之间最根本的区别是：常量在经过定义并给它一个值之后，不能再对它进行修改。而变量则无此限制。对于常量a，进行如下的操作是错误的：finalinta=1;….a=2;

而对于变量a，如下这段代码则是正确的。inta=1;…a=2;示例：

publicclassAssign{

publicstaticvoidmain(String[]args) {

intx;

inty;//定义x,y两个整型变量

floatz=1.234f;//指定变量z为float型，且赋初值为1.234

doublew=1.234;//指定变量w为double型，且赋初值为1.234

booleanflag=true;//指定变量flag为boolean型，且赋初值为true

charc;//定义字符型变量c

Stringstr;//定义字符串变量str

Stringstr1="Hi";//指定变量str1为String型，且赋初值为Hi

c='A';//给字符型变量c赋值'A'

str="bye";//给字符串变量str赋值"bye"

x=12;//给整型变量x赋值为12

y=x;//给整型变量y赋值为12

}

}

Java区分大小写类定义不能嵌套一个程序中可以有一个或多个类，但其中只能有一个public类源程序编写完毕，应该以主类名作为文件名，再加后缀.java存储编写Java程序需要注意的几点在Java中嵌套的程序块的内层和外层，不允许定义相同的变量名，否则将导致编译错误。publicclassScopeError{ publicstaticvoidmain(String[]args) { intE=999；

{ intE=999; System.out.println(“E="+E); }

}}变量类型转换短类型

长类型：默认长类型

短类型：强制例：inta; longb; b=a; a=(int)b;不同类型数据间的优先关系如下：

低------------------------------------------->高byte,short,char->int->long->float->double高级数据类型要转换成低级数据类型，需要用到强制类型转换。 其一般形式为：（类型名）（表达式）如：int i；byteb；i=356；b=（byte）i；//强制转换后丢失一部分数据，使得b的值为100。一般使用强制类型转换可能会导致数值溢出或精度的下降，应尽量避免。

创建一个引用对象的变量需要分3个步骤：1、声明一个对对象的引用2、创建对象3、赋值创建对象引用变量

步骤1——声明

ClassName

identifier;例：Shirt

myShirt;变量类型是reference_to_ClassName(对Shirt的引用)步骤2——初始化

identifier=newClassName();

例：myShirt=newShirt();或者声明和初始化同时进行ClassNameidentifier=newClassName();例：ShirtmyShirt=newShirt();步骤3——赋值还未给对象变量赋值，如myShirt.price变量初始化为缺省值。要给对象变量赋值：声明并初始化对象变量设定值时指定对象引用创建对象

基本数据类型的值：428802，’A’等对象引用的值：对对象的引用，指向对象变量的值基本变量和对象引用变量的值查看结果：Equivalence.java查看结果：BoxDemo.java查看结果：Assign.java

使用String类存储一串非数值型字符。在JavaAPI中包含有String。形成String有两种方式：使用或不使用new修饰符。将String类用作数据类型声明

ClassName

identifier;例：String

myName;初始化和赋值

identifier=newClassName(“string_value”);例：myName=newString(“DavidSt.Hubbins”);或者在一行中完成两个步骤：

StringmyName=newString(“DavidSt.Hubbins”);StringmyString=newString(“Thisisatest”);使用String和new修饰符声明

ClassName

identifier;例：String

myName;初始化和赋值

identifier=string_value;例：myName=“DavidSt.Hubbins”;或者在一行中完成两个步骤：

StringmyName=“DavidSt.Hubbins”;StringmyString=“Thisisatest”;System.out.println(myString);使用String但不用new修饰符类似于基本类型：字符常量Stringname=”NigelTufnel“；表达式：Stringname=”Nigel”+“Tufnel“；其它变量：StringhisName=”NigelTufnel“；StringmyName=hisName；方法调用“abCDef”.toUpperCase();Strings=“abCDef”;s.toUpperCase();可以赋给String的值方法包含程序要做的工作。所有的类都可以使用“全能”的main方法。main方法是JVM的入口点。main调用并协调程序的其余部分。使用main方法查看结果：Hello.java查看结果：CustomerInfo.java使用pringln添加回车换行；print则没有。 System.out.print(“Carpediem”);System.out.println(“Seizetheday”); System.out.println();可以用空的显示语句来显示一个空行在一个语句中显示多个内容：文本用引号括起来；使用空格时将空格放在引号内用+连接多个内容（”Priceis:”+price）还可以显示表达式结果（price*discount）使用System.out.println利用（Stringargs[]）可以将值从命令行传递到main。

publicclassIntroductions{publicstaticvoidmain(Stringargs[]){System.out.println(“Mynameis”+ars[0]+”andIam”+args[1]);}}

命令行输入：javaintroductionsFloyd29显示：MynameisFloydandIam29使用main方法获取命令行输入查看结果：Introductions.javamain将所有参数都看作是String。使用Integer.parseInt可以将参数转换成int

Integer.parseInt（variable_to_convert）例：Intgrade=Integer.parseInt（args[0]）；将String参数转换成整数查看结果：Introductions.java区分引用变量和变量如果数据类型是一个类的名字，就是引用变量String

是个类firstNumber,secondNumber是引用变量如果数据类型是一个基本数据类型，就是变量double

是一个基本数据类型number1,number2是变量StringfirstNumber;

StringsecondNumber;

doublenumber1;

doublenumber2;

写类声明来表示基于OOD的对象。类声明中包含类名称、变量、方法。声明类查看结果：Person.java

算术运算符：运算符优先级别优先级规则：（）

乘除（从左到右）

加减（从左到右）复杂的表达式：C=25-5*4/2-10+4；从左到右的规则求值，结果是：34按照优先级规则求值，结果是：9用（）来表述想要的结构升级和类型转换赋值和表达式可能引起计算的数据类型与保存结果的存储位置之间的不匹配。右边的数据类型小于左边的数据类型：

bytenum1=53;bytenum2=47;longnum3;num3=num1*num2;

右边的数据类型大于左边的数据类型：

intnum1=53;intnum2=47;bytenum3;num3=num1+num2;右边的数据类型和数据大于左边的数据类型：intnum1=53;intnum2=47;bytenum3;num3=num1*num2;注意：Java是强类型语言，因此，在进行赋值操作时要对类型进行检查；当将占位数少的类型赋值给占位数多的类型时，Java自动使用隐式类型转换(升级)；当将占位数多的类型赋值给占位数少的类型时，需要由用户使用显式的强制类型转换；

其一般形式为： （类型名）（表达式）类型转换短类型

长类型：自动升级长类型

短类型

：强制转换自动升级规则

1.(byte或short)opint→int2.(byte或short或int)oplong→long3.(byte或short或int或long)opfloat→float4.(byte或short或int或long或float)opdouble→double5.charopint→int其中，箭头左边表示参与运算的数据类型op为运算符(如加、减、乘等)右边表示运算结果的数据类型。如：3+4.5，因为4.5是float型，所以3先被转换为float型，然后再于4.5相加，其结果也为float型。

例:自动升级实例

publicclassPromotion{publicstaticvoidmain(Stringargs[]){byte b=10;char c='a';int i=90;float f=3.5f;doubled=1.234;float f1; f1=f*b;int i1; i1=c+i;doubled1; d1=f1/i1–d; }}

查看结果：Test.java查看结果：Promotion.java强制类型转换类型转换可缩小值的范围例：inta; longb; b=a; a=(int)b;/*把long型变量b强制转换为int型*/ intx=365; bytey=(byte)x;/*把int型变量i强制转换为byte型*///强制转换后丢失一部分数据，使得y的值为100。一般使用强制类型转换可能会导致数值溢出或精度的下降，应尽量避免。浮点类型转换为整数类型将使所有小数部分丢失。

publicclassAge{ publicstaticvoidmain(Stringargs[]) { intageYears; intageDays; longageSeconds; ageYears=Integer.parseInt(args[0]); ageDays=ageYears*365; ageSeconds=(ageYears*365*24L*60*60); System.out.print(“Youare”+ageDays+”daysold.”); System.out.print(“Youare”+ageSeconds+”secondsold.”); }}查看结果：Age.java

逻辑运算符：

布尔运算符：JAVA的流程控制语句结构化程序设计的三种基本控制语句顺序分支循环按语句书写的先后顺序执行在若干路径中有条件地择一执行当某条件成立时，反复执行一段代码条件语句if-else if(boolean-expression) statement1; [elsestatement2;］注意：1、boolean-expression必须返回为布尔型数据的表达式，不能用整型数值代替；2、每个单一语句后边都要有分号；3、如果statement1、statement2为多条语句，那么要用{}将它们括起来。4、else总是与最近的if配合If结构的基本部分If条件AIf条件B{ 1……… }else{ 2……… }

例：比较两个数的大小，并按照从大到小的顺序输出到屏幕上。publicclassCompareTwo{publicstaticvoidmain(Stringargs[]) {doubled1=23.4;doubled2=56.9;if(d1>=d2)System.out.println(d1+”>=“+d2);elseSystem.out.println(d2+”>=“+d1);}}

查看结果：Coffee.java

多重If结构

查看结果：Coffee.java

测试String之间的等同性使用==比较String在内存中的引用是否相等要测试两个字符串之间是否具有等同性用equalsif语句中内嵌的语句1或语句2又是if语句的情况称为if语句的嵌套。如： if(布尔表达式1) {

语句1 }elseif(布尔表达式2) {

语句2 }……

elseif(布尔表达式m) {

语句m }

else

{

语句n }if语句的嵌套

if(x==1)

{if(y==1)aa=1;elseaa=2;}if(x==1){

if(y==1)aa=1;}elseaa=2;

程序从上往下依次判断表达式的条件，一旦某个条件满足，就执行相关的语句，然后就不再判断其余的条件，直接转到if语句的后续语句执行。如果需要，可以通过使用{}来改变配对关系。使用if的程序

switch语句

switch语句根据表达式的结果来执行多个操作中的一个，它的语法形式如下：switch（表达式）{case判断值1：语句块1；

[break；]case判断值2：语句块2；

[break；]…case判断值n：语句块n；

[break；][default:缺省处理语句；

break；]}1.要注意表达式必须是符合byte,char,short,int类型的表达式，而不能使用浮点类型或long类型，也不能为一个字符串；2.

将表达式的值依次与每个case子句中的判断值相比较。如果匹配成功，则执行该case子句中常量值后的语句，直到遇到break语句为止；3.

case子句中判断值的类型必须与表达式的类型相容，且每个case子句中判断值的值必须是不同的；4.default子句是可选的，当表达式的值与任一case中的判断值都不匹配时，就执行default后的语句。如果表达式的值与任一case中的判断值都不匹配且没有default子句，则程序不执行任何操作，直接跳出switch语句，进入后续程序段的执行。switch语句的流程如图所示：

表达式break语句1break语句2break语句nbreak缺省处理语句后续语句判断值1判断值2判断值ndefault…….switch语句的注意点5.

break语句用来在执行完一个case分支后，使程序跳出switch语句，执行switch语句的后续语句。因此一般情况下，在每个case分支后，要用break来终止后面的case分支语句的执行；6.

在一些特殊的情况下，例如多个不同的case值要执行一组相同的操作，可以写成如下形式：

…case判断值n：

case判断值n+1：语句

[break；]…7.case分支中包括多个执行语句时，可以不用花括号“{}”括起；8.通过if-else语句可以实现switch语句所有的功能。但通常使用switch语句更简练，且可读性强，程序的执行效率也高；9.if-else语句可以基于一个范围内的值或一个条件来进行不同的操作，但switch语句中的每个case子句都必须对应一个单值。

查看结果：SwitchTest.java

查看结果：SwitchDaysInMonth.java循环循环语句的作用是反复执行同一块代码直到满足结束条件。在现实世界的许多问题中需要用到循环控制。例如：累加求和。while循环

语法形式为：while(布尔表达式){

语句组；}执行过程：1、先计算布尔表达式2、若为真则执行语句组，并转回再计算布尔表达式3、若为假

则跳出循环，执行后面的语句。小心：一定不要在while（布尔表达式）后面加；while循环的流程图

truefalse循环体布尔表达式例：用while语句求1+2+…+10的和。

publicclassWhileTry{ publicstaticvoidmain(String[]args){ inti; intsum=0;//累加器清0 i=1; //i的初始值为1

while(i<=10){ sum+=i; i++; }

System.out.println("sum="+sum); }}查看结果：WhileTry.java要打印一个如下所示的矩形@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@内部循环打印列，外部循环打印行“行慢列快”嵌套循环查看结果：NestedWhileLoop.java按照预先定义好的次数循环执行一组语句等同于while循环，但有更集中的结构for循环语法形式为：

for(表达式1；表达式2；表达式3) {

语句组；

}

例如，要使循环执行某一段代码1000次，可以表达为：for(intnumber=0;number<1000;number++){ … //一段代码}for循环的流程图

每个for语句都有一个用于决定循环开始和结束的变量，通常称这个变量为循环控制变量。表达式1用来给循环控制变量赋初值，它只在循环开始的时候执行一次。表达式2是一个布尔表达式，用来决定何时终止循环。表达式3用于改变循环控制变量的值。

for语句的执行过程如下：1、先求解表达式12、求解表达式2，若其值为true，则执行for语句中的循环体，然后执行下面第3步。若值为false，则结束循环，转到第5步3、求解表达式34、转回上面第2步继续执行5、执行for语句下面的一个语句

truefalse求解表达式3表达式2循环体for语句的下一句求解表达式1

for循环示例for(inti=1;i<=100;i++)for(inti=100;i>=1;i--)for(inti=7;i<=77;i+=7)

嵌套for循环查看结果：NestedForLoop.java例：用for语句求1+2+…+10的和

publicclassForTry{ publicstaticvoidmain(String[]args){ inti,sum; sum=0; //累加器清0 for(i=1;i<=10;i++){ sum+=i; } System.out.println("sum="+sum); }}

do循环是：类似于while循环的循环一个一层/多层重复循环

while循环和for循环都是0层/多层重复循环do循环语法形式

do{

语句组；

}While(布尔表达式);执行过程：

先执行一次循环体中的语句，然后测试布尔表达式的值。如果布尔表达式的值为真，那就返回执行循环体中的内容。do-while语句将不断地测试布尔表达式的值并执行循环体中的内容直到布尔表达式的值为假为止。

注意：While(布尔表达式)后面必须有;do循环do-while循环的流程图

true循环体布尔表达式false查看结果：FindAThree.javado…while循环与while循环的不同在于：while是先检查条件是否成立后执行语句而do…while是先执行语句后再检查继续的条件。While——可以无限次地重复执行语句，并且执行语句的次数可以是0次或多次Do——可以无限次地重复执行语句，并且执行语句的次数可以是1次或多次For——可以按照预先定义好的次数循环执行语句比较多种循环结构查看结果：TestDo.javacontinue语句

Continue语句只能用在while、for和do循环内部。 它和break语句的区别是:break语句使程序的流程从一个语句块内部转移出去。continue语句是终止当前这一轮的循环，直接进入下一轮的循环。而不是终止整个循环的执行。查看结果：BreakLoop.java和BreakLoop2.java查看结果：Multiples.java方法使用概述到目前为止所示的程序都是main内的操作使用方法，可以用适当的方法来执行操作。使用方法的优点要求对象做某一事情精确地定义对象可以做什么获取和设置值使程序的可读性更好而且更易维护使开发和维护更快捷可重复使用软件

方法有两种：一种是标准方法，JavaAPI提供了丰富的类和方法，这些方法提供了程序员所需的许多功能。另一种是用户自定义的方法，以解决用户专门需要。

Java应用程序中，程序的执行从main方法开始，调用其他方法后又回到main方法，在main方法中结束整个程序的运行。操作方法和调用方法

publicclassAllInMain { publicstaticvoidmain(Stringargs[]) { intint1=42; intint2=24; System.out.println(int1+int2); } }这种方法是简洁的，但是它：在较大的应用程序中是不现实的没有使用面向对象的思想还有其它缺点操作方法和调用方法

调用方法让对象用它的一个方法来为你做某件事情。调用方法除调用操作方法外，通常还有普通的方法操作对象的调用方法可以为您：获得输入信息返回一条信息查看结果：BoxDemo3.java调用方法与操作方法的独立存在：声明方法操作方法和调用方法具有相同的语法结构在所有示例中并不包含全部可能的方法查看结果：BoxDemo4.java调用方法

特别是从不同的方法中调用方法调用方法暂停，操作方法接着执行调用方法从它调用操作方法的调用点后继续执行调用方法和操作方法可以在同一个类中或在不同的类中可以按任何顺序调用方法传递参数将参数放在调用方法的括号内传递字面值或变量按方法声明中的顺序列出参数查看结果：BoxDemo5.java参数传递

—基本数据类型的参数传递

查看结果：PassParam.java参数传递

—引用数据类型的参数传递

查看结果：PassObject1.java查看结果：CallByValue.java查看结果：PassObject2.java接收返回值返回值返回到代码中调用它时所在的位置mathRef.add(2,4);调用了方法的表达式等于返回值使用返回值时，可以将调用和返回值的使用在同一行内完成intaddedNumbers=mathRef.add(2,4);方法体中如果指定了非void的返回值类型，方法中就必须包含一条return语句保证任何情况下都有返回值，return语句之后不能跟任何表达式；查看结果：BoxDemo4.java对象方法和Static（静态）方法对象方法需要创建一个对象静态方法的运行可以没有对象这些方法与类相关，但又不对与某一特定对象关联的变量进行操作

static方法是属于整个类的，而不是属于某个实例（具体的对象）。 而对象方法属于每个实例，只能在类的实例和子类的实例中调用。static静态变量

当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。查看结果：TestChinese.javastatic静态方法在静态方法里只能直接调用同类中其它的静态成员（包括变量和方法），而不能直接访问类中的非静态成员。这是因为，对于非静态的方法和变量，需要先创建类的实例对象后才可使用，而静态方法在使用前不用创建任何对象。

main()方法是静态的，因此JVM在执行main方法时不创建main方法所在的类的实例对象，因而在main()方法中，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。理解main方法的语法

由于