JavaOOP.docx

JavaOOP.docx

《JavaOOP.docx》由会员分享，可在线阅读，更多相关《JavaOOP.docx（41页珍藏版）》请在冰豆网上搜索。

JavaOOP

JavaCC#

编译javac编译编译

Classobj中间代码

Java虚拟机链接.netframework即时编译

解释执行exeexe

XXX.java-编译javac.exe字节码文件.XXX.classjava.exe解释执行

Java开发环境JDK

Bin:

binary二进制，存放可执行文件，编译程序、虚拟机程序

Demo:

演示程序

Include:

存放虚拟机本身运行所需的头文件

Jre:

javaruntimeenvironmentJava运行时环境

Lib:

存放JDK自带的标准类库dt.jartools.jar

Sample:

小例子

Src.zip:

JDK源代码的压缩包

配置环境变量：

配置环境变量主要目的是为了让系统能够自动搜索JDK目录下面的编译程序和虚拟机程序。

否则在编译时，就必须先进入JDK安装目录\bin。

系统在执行某个程序时，会先检查当前路径，如果找不到要执行的程序，就会到系统变量path下去寻找，所以要把bin的路径添加到path当中。

我的电脑-右键-属性-高级-系统环境变量

名称：

值

JAVA_HOMEJDK的安装路径如：

D:

\ProgramFiles\Java\jdk1.6.0_24

Path将bin添加到系统搜寻路径中，已有，不必新建

%JAVA_HOME%\bin;

classpath可选，类库路径。

JDK标准类库会自动加入，第三方类库就必须手工加

.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar

Java程序的结构

publicclass类名{

属性

...

方法

...

Int[]a=newint[4];

publicstaticvoidmain（String[]args）{

…代码

}

Publicvoida（）{

a[0]=3;

}

}

C#中Main方法的形式：

publicstaticvoidMain（）{}

publicstaticvoidMain（string[]args）{}

publicstaticintMain（）{}

publicstaticintMain（string[]args）{}

java源程序要注意的几点：

1、大小点敏感。

2、Main方法只有一种形式。

3、一个java文件可以包含多个类的定义，但是只能有一个类是public。

4、文件名必须和public类名相同。

5、Main方法只能存在于public类里面。

编译时：

Javac文件名.java

运行：

Java类名

生成帮助文档：

Javadoc文件名.java

Java命名规则：

1、类名、方法名、变量名都必须只能是字母、数字、下划线、$。

2、可以用下划线、字母、$开头，不能以数字开头。

3、不能使用关键字、保留字。

goto\const

Java命名规范：

1、类名首字母大写

2、方法名、变量名首字母小写

3、类名、方法名、变量名由多个单词组成的话，从第二个单词开始，首字母都用大写。

第二章

一、输入

Scanner：

JDK1.5以上才有。

在文件头导入包

Importjava.util.Scanner ;

在方法中创建Scanner的对象

Scannersc=newScanner（System.in） ;

注意：

Scanner类里有很多next方法，

next（）:

abcdefabc

nextInt（）

nextFloat（）

nextDouble（）

int.Parse（Console.ReadLine（））

do{

try{

sc.next（）;//出错后根本不会停留在这一步等待输入

break;

}catch（InputMismatchExceptione）{

Continue;

}

while（true）;

当接收到不匹配的数据时，会抛出java.util.InputMismatchException异常

当输入的一个字符串中间带空格时，Scanner会忽略空格后面的内容。

解决办法：

importjava.io.BufferReader;

importjava.io.InputStreamReader;

try{

BufferedReaderbr=newBufferedReader（newInputStreamReader（System.in））;

br.readLine（）;

}catch（IOExceptionex）{

}

InputStreamReader：

转换输入流

OutputStreamWriter：

转换输出流

在创建对象时必须使用try…catch包围，或直接在方法名后面加上throwsException.

二、输出

System.out.print（）：

PrintStreamextendsOutputStream

System.out.println（）：

区别：

后者自动换行

System.out.print（‘\n’）等价System.out.println（）

System.out.println（）允许不带参数，而print不可以没参数

三、数据类型：

1、基本数据类型：

int\float\double\char\boolean\...（编译期分配内存）

2、引用数据类型：

类、接口、数组（运行期分配内存）new

java.lang.String

区别：

基本数据类型按值传递。

引用数据类型按引用（地址）传递。

C符号常量

#definePI3.14

C#

constdoublePI=3.14

Java

finaldoublePI=3.14

1、表示不能被重写，方法

2、表示类不能被继承，类

3、常量，变量

方法的局部变量和类属性的区别：

1、可用的修饰符不同，类属性可使用四个访问权限修饰符，static，final，而局部变量只能使用final

2、类属性有缺省值（可以不赋值），局部变量一定要手动初始化

3、生命周期不同。

类属性可存在于整个对象（从创建到最终被垃圾回收）的生命周期，局部变量的生命周期从方法被调用开始，到方法执行结束而结束。

4、作用域不同。

类属性作用域整个类（访问修饰符），局部变量作用域仅仅是所在的方法{}

变量的作用域：

变量在哪一对{}里声明，作用域就对这一对{}有效。

如果类属性和方法内的局部变量重名，在方法里局部变量将会覆盖类的属性。

publicclassTest{

publicintj=1;

publicstaticvoidmain（String[]args）{

Testt=newTest（）;

t.a（）;

}

publicvoida（）{

intj=0;

System.out.println（j）;//0

System.out.println（this.j）;//1

}

}

类型转换：

1、自动（隐式转换）：

类型必须兼容，小类型向大类型转换

2、强制（显式转换）：

类型必须兼容，大类型向小类型转换

3、解析：

从字符串向基本类型去转换，类型不兼容

Java.lang.*

使用目标类型的包装器的parse...方法。

所有的parse方法都只能接收字符串参数。

所有包装器都位于java.lang包下

Stringint：

Integer.parseInt（字符串）

Stringdouble：

Double.parseDouble（字符串）

Stringfloat：

Float.parseFloat（字符串）

Stringboolean：

Boolean.parseBoolean（…）

Stringchar：

String.charAt（0）

作用：

1、将基本类型和引用类型互相转换（拆箱和装箱）

2、进行某些类型（String）向基本类型的解析

3、泛型类型参数只能使用引用类型

ArrayListlist;

4、集合类的元素只能是Object（没有使用泛型时）

基本类型向字符串转换

“”+基本类型变量

控制流：

C#

switch（变量、表达式）{

caseXX:

break;

}

变量、表达式类型必须是int\char\string

要求每个分支都必须有break，除非分支里没有任何语句，但至少要求一个分支有break。

Java

switch（变量、表达式）{

caseXX:

break;

}

变量、表达式类型必须是int\char

分支里可以不用break，贯穿

C#

int[]a={1,2,3};

foreach（intiina）{

//针对i进行操作，改写i的值不会对数组元素有影响

}

foreach可对数组、string、集合进行迭代处理。

Java：

该数组或集合还必须实现Iterable接口

int[]a={1,2,3};

for（inti:

a）{

//针对i进行操作，改写i的值不会对数组元素有影响

}

for可对数组、集合进行迭代处理。

数组

C#

Length

int[]a;

Java

length

int[]a或inta[]

初始化：

int[]a;

a=newint[4];//只指定大小，不给出初始值，元素都为0

a=newint[]{1,2,3,4};//不指定大小，由元素个数决定

注意：

数组如果指定了大小，就不可以给出初始值。

声明和初始化一步完成

int[]a={1,2,3,4};

int[]a;

a={1,2,3,4};//错误

对于任意类型的数组来说，如果在初始化时不给出初始值，初始值是什么？

对于数值类int,double,float，初始值是0

对于字符char，初始值是’\0’

对于引用数据类型，初始值是null

包：

为了避免命名冲突

Java.util.Date

Java.sql.Date

包路径必须与真实的物理路径（文件夹）一致

package包路径;//必须是文件中的第一个语句

packagea.b;

把类class放在src\a\b

Bin\a\b

编译时不变

运行：

退出包路径，java包路径.类名

MyEclipse的工程结构

.project：

记录工程的信息

.classpath：

记录类库的路径信息

src：

存放源文件

bin：

存放字节码文件

src和bin里的结构是完全相同

往MyEclipse添加外部的JDK

Windows-Preferences-Java-InstalledJres—Add

如果在新建工程的时候看到感叹号的警告信息，说明虚拟机版本和编译版本不一致。

Debugas…JavaApplication

StepInto：

会进入被调用的方法来进行断点调试

StepOver：

直接执行被调用的方法而不进入里面调试

类属性（变量）和方法内的局部变量的区别：

1、作用域不同。

前者是整个类，后者是所在的方法。

2、前者不需要给出初始值，编译器会自动赋值，对于数值类为0.对于布尔型是false。

对于字符是\0。

对于引用类型是null。

3、方法内的局部变量可以直接使用，类属性的使用要先创建所在类的对象，才能用对象去引用。

（成员方法除外）

4、生命周期不同。

类属性从类被加载时创建，一直到程序结束就销毁。

方法内的局部变量在方法被调用时创建，方法执行结束后就马上销毁。

5、使用的修饰符不同。

用来表示一个变量是否为常量，类属性的访问限制。

final\public\private\protected\默认（什么都不加）

方法内的局部变量只能使用final来表示为一个常量。

类的属性可以使用以上所有修饰符

public>protected>默认>private

public：

公开，在任意类都可以访问

protected：

受保护的，在同个包下的所有类及该类的子类可以访问

默认：

什么都不加，在同个包下的所有类可以访问

private：

私有的，在本类中其他成员可以访问

包：

要使用另一个包中类时，需要导入。

如果是同一个包，不用导入。

JDK的类库中，java.lang会自动导入。

package语句必须是第一个语句。

如果要导入某个包下的若干个类，可以使用*。

类和对象

OOA：

ObjectOrientedAnalysis面向对象分析

OOD：

ObjectOrientedDesign面向对象设计

OOP：

ObjectOrientedProgramming面向对象编程

对象：

指具体真实存在的一个实体，记录该实体的属性（特征）和行为（方法）。

类：

类是由具有相同属性的行为的对象组成的一个集合（模板）。

它是创建新类型的一种机制。

对象和类的区别和联系：

1、对象是特指的，是具体的。

类是泛指的，是抽象的，类是指对象所属的类型、种类

2、类是把对象里的属性的行为抽出来，放在模板中，表示的是该对象和同类型对象的共同特征和行为。

以后就可以由该类创建出任意该类的对象。

封装：

把一个类的属性和行为封闭在一个类里，对外提供相应的方法（接口）。

步骤：

1、把不能对外公开的属性加上私有的修饰符

2、为相应的属性加上get/set方法（访问器）

3、在set方法中对传递的值进行有效性的验证

publicclassBirthday{

privateintyear;

privateintmonth;

privateintdate;

…

}

publicclassAnimal{

privateBirthdaybirthday;

}

publicclassPerson{

privateStringname;

privatecharsex;

privateintage;

privatedoublesalary;

privateBirthdaybirthday;

publicBirthdaygetBirthday（）{

returnbirthday;

}

publicvoidsetBirthday（Birthdaybirthday）{

this.birthday=birthday;

}

//取值的方法get

publicStringgetName（）{

returnname;

}

publicchargetSex（）{

returnsex;

}

publicintgetAge（）{

returnage;

}

//赋值的方法set

publicvoidsetName（Stringname）{

this.name=name;

}

publicvoidsetSex（charsex）{

//先判断外界传入的值是否有效

if（sex!

='男'&&sex!

='女'）{

//如果无效，提示并赋默认值

System.out.println（"性别有误"）;

this.sex='男';

}else{

//有效时接受外界赋值

this.sex=sex;

}

}

publicvoidsetAge（intage）{

if（age<0||age>150）{

//无效范围

System.out.println（"年龄无效"）;

this.age=20;//默认

}else{

//正确的值

this.age=age;

}

}

publicvoidintroduction（）{

System.out.println（"姓名：

"+name+"\n"+"性别：

"+sex+"\n"+"年龄：

"

+age）;

}

}

封装的好处：

1、封装能使内部实现代码隐藏，保护知识产权。

2、封装能使类独立性好，独立性越高，重用性就越高。

3、封装能使后续可维护性提高，后续维护成本下降（由上一点决定）

4、有利于分工协作

构造方法：

当new对象调用，或一个类有多个构造方法时，一个构造方法可以调用另一个构造方法。

（除了这两种场合，构造方法一律不能调用）

构造方法作用：

为了构建一个对象，一般使用它来完成初始化工作

特征：

1、方法名跟类名相同

2、方法没有返回类型（连void都没有）

3、如果一个类里面没有构造方法，编译器会自动创建一个无参的默认的构造方法

4、如果有自定义的构造方法，编译器就不会再自动创建默认构造方法

5、构造方法是在new对象自动被调用，不能由普通方法调用。

6、如果构造方法为private，外界就不能创建对象，只有在本类中（自己）才能创建本类对象；如果为protected，同包下的其他类以及该类的子类可以创建对象。

导入工程文件夹

1、前提的工程的文件夹要保持目录结构

2、File—import—General—ExistingProjectintoWorkspace—Browse—CopyProjectintoWorkspace

构造方法只能在两个地方进行调用。

1、使用new关键字时自动调用。

2、一个类中有多个构造方法时，一个构造方法内部可以使用this（）调用另一个构造方法。

注意：

一个构造方法当调用另一个构造方法，this（）必须是构造方法中的第一个语句。

运行顺序：

new根据参数个数和类型自动寻找匹配的构造方法如果找到，就调用它。

调用另一个构造方法寻找匹配的构造方法…

static：

静态，可用于类的属性和方法。

意味着一个类不管创建多少个对象，所有对象都将共享static属性和方法。

和普通属性的区别：

1、普通属性的引用需要使用对象。

语法：

对象名.属性名/方法名。

静态属性和方法不需要对象去引用，直接用类名引用。

语法：

类名.属性名/方法名

2、不同对象中的普通属性属于不同对象。

但是静态属性属于所有对象。

在同一个类中，对静态属性的引用，对静态方法的调用和非静态的区别：

1、静态方法只能调用静态方法，只能引用静态属性

2、非静态方法可以调用非静态方法和静态方法，对属性也相同

在不同类中：

A（voida1（）staticvoida2（））

B（voidb1（）staticvoidb2（））

如果方法的访问修饰符允许的话，

1、a1要访问B中的方法，b1必须用B类的对象调用，b2必须用B类名调用

2、b1要访问A中的方法，a1必须用A类的对象调用，a2必须用A类名调用

Java：

包，组织程序类结构的一种方式，主要作用是为了避免命名冲突，同时也是protected\默认权限的组成部分。

打包：

package，必须放在第一个。

导入包：

import

importjava.util.Scanner;//类

importjava.sql.*;

importjava.io.*;

java.util.Scannersc;

包的路径以小写字母组成，有多级的话，以.隔开，与磁盘物理文件夹一一对应。

C#中命名空间，作用相同。

不与物理路径关联。

把类放到某个命名空间下：

namespace命名空间的名称

导入命名空间：

using

usingSystem.Data.SqlClient;//目录

SqlConnectionconn;

System.Data.SqlClient.SqlConnectionconn;

直接输出一个类的对象，将出输出以下格式信息：

包名.类名@对象的地址

但如果在类中定义了toString方法，将会以toString返回值代替以上信息。

建立教员类（Java、Net），学校类

教员的方法：

自我介绍

上课

学校的方法：

自我介绍

评估教员的方法（调用上课的方法）

继承：

子类继承父类，就继承了父类的属性和方法（构造方法不能继承）

单继承：

在Java中，子类只能继承一个父类，不能多继承；一个类可以有多个子类

继承使用extends关键字

class子类名extends父类名{}

继承必然符合Is-a关系：

子类对象可以认为是父类的对象

在继承关系树里，越往树根走，父类就越抽象，越广泛，越往树叶走，子类就越具体，越详细。

继承本质上是在扩展父类，同时，子类在继承父类行为的同时，选择要不要修改父类的行为（重写）

有了继承关系后，对象构建顺序不同：

在继承树里，必然是父类的对象先创建，然后才是子类对象

java.lang.Object类是所有类的共同父类，一个类只要没有继承任何类，那么就直接继承它。

如果继承了某个类，那就是间接继承Object。

Object里定义了很多公开方法：

toString（）

equals（）

notify（）

…

所有类都继承了以上这些方法

classTest{}==classTestextendsObject{}

super.方法名（）

classA{

publicvoida（）{}

}

classBextendsA{

publicvoidb（）{

a（）;

super.a（）;

}

//重写方法

publicvoida（）{}

//重载方法

publicinta（inta）{}

//重载方法

publicvoida（inta,Stringb）{}

publicvoida（Stringb,inta）{}

publicvoida（inta,intb）{}

publicvoida（intb,inta）{}//不是重载，a（4,5）

}

重写：

Override，存在于继续关系。

子类重新定义、实现父类的某个方法。

要求方法名称、参数列表、返回值都必须相同。

是实现多态的一种手段。

注意子类的重写方法访问修饰符权限不能小于父类中被重写的方法（子类>=父类）。

父类私有方法无法重写。

CannotreducethevisibilityoftheinheritedmethodfromParent

重载：

Overload，在一个类中，有多个方法名称相同，但参数列表不同。

返回值不是决定是否重载方法的要素。

参数列表不同是指符合以下任意一点到多点：

1、个数不同

2、类型不同

3、顺序不同

重写和重载的区别：

1、重写是存在于父类与子类之中（必须存在继承关系），重载是存在于同一个类当中。

2、重写要求方法名称、参数列表、