Java面向对象程序设计基础.docx

Java面向对象程序设计基础.docx

《Java面向对象程序设计基础.docx》由会员分享，可在线阅读，更多相关《Java面向对象程序设计基础.docx（22页珍藏版）》请在冰豆网上搜索。

Java面向对象程序设计基础

Java面向对象程序设计基础

1类的结构

1.1类声明

类的定义：

classA{

成员变量与成员方法的定义

}

1.2创建对象

对象的创建：

Aa。

//对象的声明，即定义A类的一个对象，名为a

a=newA（）。

//对象的创建，即为a对象开辟一个内存区，

//并调用构造方法A（）对对象进行初始化

上面两步也可以合并为一步：

Aa=newA（）。

a

对象

变量

方法

/*Class1.java*/

classMan{

intheight。

intage。

}

publicclassClass1{

publicstaticvoidmain（String[]args）{

Manman1。

man1=newMan（）。

man1.height=180。

man1.age=20。

System.out.println（man1.height）。

System.out.println（man1.age）。

}

}

1.3构造方法

构造方法是在创建对象时调用执行的特殊函数，用于对对象进行初始化。

如果编程者没有编写构造方法，编译器会自动提供一个缺省的无参的空构造方法。

但如果编程者编写了构造方法，编译器将不再提供缺省的无参的空构造方法。

造方法的名字必须与类名相同，且没有任何返回值，也不可使用void关键字。

可以在构造方法中使用this（）来调用其他被重载的构造方法。

/*Class17.java*/

publicclassClass17{

inta。

publicClass17（）{//构造方法

a=10。

}

publicstaticvoidmain（String[]args）{

Class17ob=newClass17（）。

System.out.println（ob.a）。

}

}

/*Class18.java*/

publicclassClass18{

inta。

publicClass18（）{

a=10。

}

publicClass18（inta）{

this.a=a。

}

publicstaticvoidmain（String[]args）{

Class18ob1=newClass18（）。

Class18ob2=newClass18（20）。

Class18ob3=newClass18（30）。

System.out.println（ob1.a）。

System.out.println（ob2.a）。

System.out.println（ob3.a）。

}

}

/*Class19.java*/

publicclassClass19{

inta。

publicvoidClass19（）{//这里Class28（）不是构造函数

a=10。

}

publicstaticvoidmain（String[]args）{

Class19ob=newClass19（）。

System.out.println（ob.a）。

}

}

2类的成员

2.1成员变量和局部变量

类体中定义的变量称为成员变量，而类的成员方法中定义的变量以及方法中的形式参数则称为局部变量。

成员变量在整个类体中有效，而局部变量只在定义它的方法中有效。

使用局部变量之前必须对其进行初始化，否则编译时会出错。

2.2关键字this

this代表本类的对象；通过它可以引用本类的成员。

只能在实例方法中使用this关键字。

this（）可用于调用本类的构造方法。

/*ThisDemo.java*/

classThisDemo1{

inta1=1,a2=2。

voidss（）{

inta1=10,a2=20。

a1=this.a1。

System.out.println（a1）。

System.out.println（a2）。

}

}

publicclassThisDemo{

publicstaticvoidmain（Stringargs[]）{

ThisDemo1aa=newThisDemo1（）。

aa.ss（）。

System.out.println（aa.a1）。

}

}

2.3类方法和实例方法

有关键字static修饰的称为类方法（又称静态方法）和类变量（又称静态变量），而没有static修饰的称为实例方法和实例变量。

实例方法和实例变量只能通过对象名引用，而类方法和类变量既能通过对象名引用，也能通过类名引用。

类方法只能直接访问本类中的类成员。

/*ConstructorDemo.java*/

classConstructorDemo1{

inta1,a2。

ConstructorDemo1（）{//构造方法

a1=1。

a2=2。

}

staticvoidpntout（Strings）{//类方法

System.out.println（s）。

}

}

publicclassConstructorDemo{

publicstaticvoidmain（Stringargs[]）{

ConstructorDemo1abc=newConstructorDemo1（）。

System.out.print（"1+2="）。

System.out.println（abc.a2+abc.a1）。

ConstructorDemo1.pntout（"你们好，朋友们！

"）。

}

}

/*Class3.java*/

publicclassClass3{

inta。

staticvoidsetA（intb）{//静态方法

a=b。

//错，静态方法中不能直接访问非静态的成员变量a

}

publicstaticvoidmain（String[]args）{

Class3.setA（10）。

}

}

/*Class4.java*/

publicclassClass4{

staticinta。

//静态变量

staticvoidhello（）{//静态方法

System.out.println（"你好~~"）。

}

staticvoidsetA（intb）{//静态方法

a=b。

hello（）。

}

voidprintA（）{

System.out.println（a）。

//非静态方法可以访问静态变量a

hello（）。

//非静态方法也可以访问静态方法hello（）

}

publicstaticvoidmain（String[]args）{

Class4.setA（100）。

Class4ob=newClass15（）。

ob.printA（）。

}

}

2.4访问权限

（1）使用在成员变量和成员方法之前的访问控制符

成员访问控制符

含义

private

只能在类的内部被访问

public

能被所有的类访问

缺省（friendly）

只能被同一个包中的类访问

protected

可以被同一包中的类或其他包中的子类访问

（2）使用在类之前的访问控制符

类访问控制符

含义

public

能被所有的类使用

缺省（friendly）

只能被同一个包中的类使用

3类的继承和接口

3.1类的继承

一个类可以通过关键字extends继承另一个类，被继承的类称为父类，而继承的类称为子类。

子类可以继承父类所有的非私有的成员作为自己的成员。

/*ExtendsDemo.java*/

classExtendsDemo1{

intx=8。

privateinty=9。

publicdoublez=10。

voidpntout（Strings）{

System.out.println（s）。

}

}

classExtendsDemo2extendsExtendsDemo1{

floatw=100.0f。

}

publicclassExtendsDemo{

publicstaticvoidmain（Stringargs[]）{

ExtendsDemo2abc=newExtendsDemo2（）。

System.out.println（abc.x）。

System.out.println（abc.z）。

System.out.println（abc.w）。

abc.pntout（"你好，朋友！

"）。

}

}

3.2重写与关键字super

如果子类定义了与父类中完全相同的方法，则称在子类中重写或覆盖了父类的方法，如果子类定义了与父类中完全相同的变量，则称在子类中隐藏了父类的变量。

通过关键字super可以在子类中访问被隐藏的父类的变量。

super（）可以调用父类的构造方法。

与this关键字一样，也只能在实例方法中使用super关键字。

/*SuperDemo.java*/

classSuperDemo1{

Stringname="玲玲"。

intage=18。

longtel=66666666。

}

classSuperDemo2extendsSuperDemo1{

Stringname="张三"。

//与父类的成员变量同名

intage=30。

//与父类的成员变量同名

longtel=88888888。

//与父类的成员变量同名

voidSuperDemo2（）{//成员方法

name=super.name。

//引用父类的成员变量

age=super.age。

//引用父类的成员变量

System.out.println（"姓名：

"+name）。

System.out.println（"年龄：

"+age）。

System.out.println（"电话：

"+tel）。

}

}

publicclassSuperDemo{

publicstaticvoidmain（Stringargs[]）{

SuperDemo2abc=newSuperDemo2（）。

abc.SuperDemo2（）。

}

}

3.3final类和abstract类

用关键字final修饰的类称为最终类，即不能派生子类。

用关键字final修饰的变量称为最终变量，必须在声明时赋予初始值，使用中不能修改。

用关键字abstract修饰的方法称为抽象方法，抽象方法没有方法体。

包含有抽象方法的类就是抽象类，抽象类必须用关键字abstract加以修饰。

抽象类不能创建对象，但可以派生子类。

3.4接口

关键字interface用来声明一个接口，通过关键字implements来实现接口。

接口体中的所有方法都是抽象方法，所有的属性都默认为static，且都默认为public。

在Java中一个类只能继承一个父类，但可以实现多个接口。

实现一个接口必须实现接口中的所有抽象方法，哪怕是空实现。

/*AbstractDemo.java*/

interfaceAbstractDemo2{

intaa=100。

floatab=100.0f。

voidpntout（Stringss）。

//抽象方法

}

classAbstractDemo1implementsAbstractDemo2{//实现一个接口

publicvoidpntout（Stringss）{

System.out.println（ss）。

//实现接口中的抽象方法

}

}

publicclassAbstractDemo{

publicstaticvoidmain（Stringargs[]）{

AbstractDemo1abc=newAbstractDemo1（）。

System.out.println（abc.aa）。

System.out.println（abc.ab）。

abc.pntout（"Iamateacher."）。

}

}

4包与import语句

在Java中，包指的是接口和类的集合，这些接口和类根据功能的不同，被分别放在不同的包中。

包结构的表示方法与目录结构类似，但采用域名表示法，即用点“.”代替“\”。

包的创建使用package语句，它在当前目录下创建指定的包，并将编译后的类文件放入指定的包中。

为了在其他的包中使用所定义的类，必须使用import关键字导入要使用的类。

java.lang包是java语言的核心类库（System类和String类均在该包中），系统会自动导入该包中所有的类（importjava.lang.*）。

4.1package语句

/*Class10.java*/

packageMypack.pack1。

//建立用户自己的类库

publicclassClass10{//Class10修饰为public表示能被所有的类访问

publicvoidhi（）{

System.out.println（"Hi~~~~"）。

}

}

/*Class11.java*/

importMypack.pack1.Class10。

//使用用户自己的类库

publicclassClass11{

publicstaticvoidmain（String[]args）{

Class10ob=newClass10（）。

ob.hi（）。

}

}

4.2import语句

Java程序不但可以利用本程序中定义的类，还可以通过import语句引入Java提供的类。

/*Class12.java*/

importjava.util.Date。

//使用Java的类库

publicclassClass12{

publicstaticvoidmain（String[]args）{

Dated=newDate（）。

System.out.println（d）。

}

}

5String类

5.1字符串变量

（1）字符串变量的创建

字符串变量的创建主要有两种：

Stringstr1="Iamateacher"。

或

Stringstr2=newString（"Iamateacher"）。

/*StringDemo.java*/

publicclassStringDemo{

publicstaticvoidmain（Stringargs[]）{

Stringstr1="Iamastudent"。

System.out.println（str1）。

Stringstr2=newString（str1）。

System.out.println（str2）。

Stringstr3=newString（"Iamastudent"）。

System.out.println（str3）。

Stringstr4=newString（）。

str4="Iamateacher"。

System.out.println（str4）。

}

}

（2）字符串和字符数组的关系

可以通过字符数组来创建一个字符串变量：

charchr[]={'t','e','a','c','h','e','r'}。

Stringstr=newString（char）。

/*StringArrayDemo.java*/

publicclassStringArrayDemo{

publicstaticvoidmain（Stringargs[]）{

charchr[]={'t','e','a','c','h','e','r'}。

System.out.println（chr）。

System.out.println（chr[3]）。

Stringstr1=newString（chr）。

System.out.println（str1）。

Stringstr2=newString（chr,0,3）。

System.out.println（str2）。

System.out.println（str1.length（））。

System.out.println（str2.length（））。

}

}

5.2String类的方法

String类的常用方法

publicintcompareTo（StringanotherString）

比较当前字符串与anotherString的大小。

若当前字符串大，则返回正整数；若当前字符串小，则返回负整数；若相等，则返回0。

publicbooleanstartsWith（Stringprefix）

测试当前字符串是否以指定字符串prefix开始。

publicbooleanendsWith（Stringsuffix）

测试当前字符串是否以指定字符串suffix结尾。

publicbooleanequals（ObjectanObject）

将当前字符串与指定的对象anObject比较。

若对象内容相同返回true，否则返回false。

publicintindexOf（intch）

从当前字符串中查找指定字符ch，返回其首次出现处的索引。

若找不到，则返回-1。

publicintindexOf（intch,intfromIndex）

从当前字符串中formIndex处开始查找指定字符ch，返回其首次出现处的索引。

返回结果同（9）。

publicintindexOf（Stringstr）

从当前字符串中查找指定字符串str，返回其首次出现处的索引。

返回结果同（9）。

publicintindexOf（Stringstr,intfromIndex）

从当前字符串中formIndex处开始查找指定字符串str，返回其首次出现处的索引。

返回结果同（9）。

publicintlength（）

返回当前字符串的长度（字符个数）。

publicStringreplace（charoldChar,charnewChar）

将当前字符串中的oldChar字符替换为newChar字符。

publicStringsubstring（intbeginIndex）

返回当前字符串中从beginIndex开始至串尾的一个子字符串。

publicStringsubstring（intbeginIndex,intendIndex）

返回当前字符串中从beginIndex开始至endIndex-1处的一个子字符串。

publicStringtrim（）

去掉当前字符串的前后空格。

publicstaticStringvalueOf（基本数据类型）

将数值转换为字符串。

publicStringtoLowerCase（）

将字符串转换为小写形式。

publicStringtoUpperCase（）

将字符串转换为大写形式。

5.3数据类型的转换

（1）字符串转换为数值

字符串转换为数值的方法

publicstaticintparseInt（Strings）

将字符串转换为int型。

publicstaticdoubleparseDouble（Strings）

将字符串转换为double型。

publicstaticlongparseLong（Strings）

将字符串转换为long型。

publicstaticbyteparseByte（Strings）

将字符串转换为byte型。

publicstaticshortparseShort（Strings）

将字符串转换为short型。

publicstaticfloatparseFloat（Strings）

将字符串转换为float型。

这些方法分别属于Integer、Double、Long、Byte、Short和Float类。

转换时要注意转换的可行性。

/*StringToNumber*/

publicclassStringToNumber{

publicstaticvoidmain（Stringargs[]）{

System.out.println（Float.parseFloat（"12.34"））。

System.out.println（Integer.parseInt（"123456"））。

System.out.println（Long.parseLong（"123456789"））。

System.out.println（Byte.parseByte（"123"））。

System.out.println（Short.parseShort（"1234"））。

System.out.println（Double.parseDouble（"12.3456"））。

}

}

（2）数值转换为字符串

通过使用各数值类的toString（）方法，可以将数值转换为字符串：

publicstaticStringtoString（基本数据类型）

/*NumberToString*/

publicclassNumberToString{

publicstaticvoidmain（Stringargs[]）{

System.out.println（Float.toString（12.34f））。

System.out.println（Integer.toString（123456））。

System.out.println（Long.toString（123456789））。

System.out.println（Double.toString（12.3456））。

bytex1=5。

System.out.println（Byte.toString（x1））。

shortx2=6。

System.out.println（Short.toString（x2））。

}

}