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

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

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

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。

man仁newMan（）。

man1.height=180。

man1.age=20。

System.out.println（manl.height）。

System.out.println（manl.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）{

Class18ob仁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）{

Class佃ob=newClass19（）。

System.out.println（ob.a）。

}

}

2类的成员

2.1成员变量和局部变量

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

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

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

2.2关键字this

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

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

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

/*ThisDemo.java*/

classThisDemo1{inta1=1,a2=2。

voidss（）{

inta仁10,a2=20。

a1=this.a1。

System.out.println（a1）。

System.out.println（a2）。

}

publicclassThisDemo{

publicstaticvoidmain（Stringargs[]）{

ThisDemolaa=newThisDemo1（）。

aa.ss（）oSystem.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（Strin