java面向对象整理Word文档格式.docx
- 文档编号:17382964
- 上传时间:2022-12-01
- 格式:DOCX
- 页数:16
- 大小:25.58KB
java面向对象整理Word文档格式.docx
《java面向对象整理Word文档格式.docx》由会员分享,可在线阅读,更多相关《java面向对象整理Word文档格式.docx(16页珍藏版)》请在冰豆网上搜索。
,3.4);
voidbark(Stringm,doublel)//注意:
重载的方法的返回值都是一样的,
abarkingdog!
this.bark(5,\"
China\"
voidbark(inta,Stringn)//不能以返回值区分重载方法,而只能以“参数类型”和“类名”来区分
ahowlingdog\"
publicstaticvoidmain(String[]args)
Dogdog=newDog();
//dog.bark();
[Page]
//dog.bark(\"
male\"
\"
yellow\"
//dog.bark(5,\"
重写(Overriding)
(1)父类与子类之间的多态性,对父类的函数进行重新定义。
如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写(Overriding)。
在Java中,子类可继承父类中的方法,而不需要重新编写相同的方法。
但有时子类并不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法的重写。
方法重写又称方法覆盖。
(2)若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表,则新方法将覆盖原有的方法。
如需父类中原有的方法,可使用super关键字,该关键字引用了当前类的父类。
(3)子类函数的访问修饰权限不能少于父类的;
下面是重写的例子:
概念:
即调用对象方法的机制。
动态绑定的内幕:
1、编译器检查对象声明的类型和方法名,从而获取所有候选方法。
试着把上例Base类的test注释掉,这时再编译就无法通过。
2、重载决策:
编译器检查方法调用的参数类型,从上述候选方法选出唯一的那一个(其间会有隐含类型转化)。
如果编译器找到多于一个或者没找到,此时编译器就会报错。
试着把上例Base类的test(byteb)注释掉,这时运行结果是11。
3、若方法类型为priavtestaticfinal,java采用静态编译,编译器会准确知道该调用哪
个方法。
4、当程序运行并且使用动态绑定来调用一个方法时,那么虚拟机必须调用对象的实际类型相匹配的方法版本。
在例子中,b所指向的实际类型是TestOverriding,所以b.test(0)调用子类的test。
但是,子类并没有重写test(byteb),所以b.test((byte)0)调用的是父类的test(byteb)。
如果把父类的(byteb)注释掉,则通过第二步隐含类型转化为int,最终调用的是子类的test(inti)。
学习总结:
多态性是面向对象编程的一种特性,和方法无关,
简单说,就是同样的一个方法能够根据输入数据的不同,做出不同的处理,即方法的
重载——有不同的参数列表(静态多态性)
而当子类继承自父类的相同方法,输入数据一样,但要做出有别于父类的响应时,你就要覆盖父类方法,
即在子类中重写该方法——相同参数,不同实现(动态多态性)
OOP三大特性:
继承,多态,封装。
publicclassBase
voidtest(inti)
System.out.print(i);
voidtest(byteb)
System.out.print(b);
publicclassTestOverridingextendsBase
i++;
System.out.println(i);
publicstaticvoidmain(String[]agrs)
Baseb=newTestOverriding();
b.test(0)
b.test((byte)0)
这时的输出结果是1
0,这是运行时动态绑定的结果。
重写的主要优点是能够定义某个子类特有的特征:
public
class
Father{
void
speak(){
System.out.println(Father);
}
Son
extends
System.out.println("
son"
这也叫做多态性,重写方法只能存在于具有继承关系中,重写方法只能重写父类非私有的方法。
当上例中Father类speak()方法被private时,Son类不能重写出Father类speak()方法,此时Son类speak()方法相当与在Son类中定义的一个speak()方法。
Father类speak()方法一但被final时,无论该方法被public,protected及默认所修饰时,Son类根本不能重写Father类speak()方法,
试图编译代码时,编译器会报错。
例:
final
Father"
}
//编译器会报错;
Father类speak()方法被默认修饰时,只能在同一包中,被其子类被重写,如果不在同一包则不能重写。
Father类speak()方法被protoeted时,不仅在同一包中,被其子类被重写,还可以不同包的子类重写。
重写方法的规则:
1、参数列表必须完全与被重写的方法相同,否则不能称其为重写而是重载。
2、返回的类型必须一直与被重写的方法的返回类型相同,否则不能称其为重写而是重载。
3、访问修饰符的限制一定要大于被重写方法的访问修饰符(public>
protected>
default>
private)
4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。
例如:
父类的一个方法申明了一个检查异常IOException,在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常,可以抛出非检查异常。
而重载的规则:
1、必须具有不同的参数列表;
2、可以有不责骂的返回类型,只要参数列表不同就可以了;
3、可以有不同的访问修饰符;
4、可以抛出不同的异常;
重写与重载的区别在于:
重写多态性起作用,对调用被重载过的方法可以大大减少代码的输入量,同一个方法名只要往里面传递不同的参数就可以拥有不同的功能或返回值。
用好重写和重载可以设计一个结构清晰而简洁的类,可以说重写和重载在编写代码过程中的作用非同一般.
Java关键字this、super使用总结
一、this
Java关键字this只能用于方法方法体内。
当一个对象创建后,Java虚拟机(JVM)就会给这个对象分配一个引用自身的指针,这个指针的名字就是this。
因此,this只能在类中的非静态方法中使用,静态方法和静态的代码块中绝对不能出现this,这在“Java关键字static、final使用总结”一文中给出了明确解释。
并且this只和特定的对象关联,而不和类关联,同一个类的不同对象有不同的this。
下面给出一个使用this的综合实例,以便说明问题:
packageorg.leizhimin;
publicclassTest6{
privateintnumber;
privateStringusername;
privateStringpassword;
privateintx=100;
publicTest6(intn){
number=n;
//这个还可以写为:
this.number=n;
publicTest6(inti,Stringusername,Stringpassword){
//成员变量和参数同名,成员变量被屏蔽,用"
this.成员变量"
的方式访问成员变量.
this.username=username;
this.password=password;
//默认不带参数的构造方法
publicTest6(){
this(0,"
未知"
"
空"
//通过this调用另一个构造方法
publicTest6(Stringname){
this(1,name,"
publicstaticvoidmain(Stringargs[]){
Test6t1=newTest6();
Test6t2=newTest6("
游客"
t1.outinfo(t1);
t2.outinfo(t2);
privatevoidoutinfo(Test6t){
-----------"
System.out.println(t.number);
System.out.println(t.username);
System.out.println(t.password);
f();
//这个可以写为:
this.f();
privatevoidf(){
//局部变量与成员变量同名,成员变量被屏蔽,用"
intx;
x=this.x++;
System.out.println(x);
System.out.println(this.x);
//返回当前实例的引用
privateTest6getSelf(){
returnthis;
运行结果如下:
-----------
未知
空
100
101
游客
看着上面的例子,说明在什么情况下需要用到this:
第一、通过this调用另一个构造方法,用发是this(参数列表),这个仅仅在类的构造方法中,别的地方不能这么用。
第二、函数参数或者函数中的局部变量和成员变量同名的情况下,成员变量被屏蔽,此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。
当然,在没有同名的情况下,可以直接用成员变量的名字,而不用this,用了也不为错,呵呵。
第三、在函数中,需要引用该函所属类的当前对象时候,直接用this。
其实这些用法总结都是从对“this是指向对象本身的一个指针”这句话的更深入的理解而来的,死记不然容易忘记而且容易搞错,要理解!
二、super
super关键和this作用类似,是被屏蔽的成员变量或者成员方法或变为可见,或者说用来引用被屏蔽的成员变量和成员成员方法。
不过super是用在子类中,目的是访问直接父类中被屏蔽的成员,注意是直接父类(就是类之上最近的超类)。
下面是一个综合运用super的例子,有两个类:
一个Father类,一个Father类的子类Son,通过这两个类完全演示了super的用法,一下是代码:
publicclassFather{
publicStringv="
;
publicStringx="
输出了Father类的public成员变量x!
!
"
publicFather(){
Father构造方法被调用!
publicFather(Stringv){
this.v="
Father类的带参数构造方法!
运行了."
publicvoidoutinfo(){
Father的outinfo方法被调用"
publicstaticvoidmain(String[]args){
//TODO自动生成方法存根
publicclassSonextendsFather{
Son"
publicSon(){
super();
//调用超类的构造方法,只能放到第一行.
Son无参数构造方法被调用!
//super();
//错误的,必须放到构造方法体的最前面.
publicSon(Stringstr){
super(str);
Son带参数构造方法被调用!
//覆盖了超类成员方法outinfo()
publicvoidoutinfo(){
Son的outinfo()方法被调用"
publicvoidtest(){
Stringv="
哈哈哈哈!
//局部变量v覆盖了成员变量v和超类变量v
------1-----"
System.out.println(v);
//输出局部变量v
System.out.println(this.v);
//输出(子类)成员变量v
System.out.println(super.v);
//输出超类成员变量v
------2-----"
//输出超类成员变量v,子类继承而来
System.out.println(super.x);
//输出超类成员变量v
------3-----"
outinfo();
//调用子类的outinfo()方法
this.outinfo();
super.outinfo();
//调用父类的outinfo()方法
newSon().test();
子类Son运行结果:
------1-----
Son
Father
------2-----
------3-----
Son的outinfo()方法被调用
Father的outinfo方法被调用
说明:
次例子仅仅为了说明super的用法,实际在设计类的时候一般都尽可能私有(private)化。
通过上面的例子,下面总结一下super的用法:
第一、在子类构造方法中要调用父类的构造方法,用“super(参数列表)”的方式调用,参数不是必须的。
同时还要注意的一点是:
“super(参数列表)”这条语句只能用在子类构造方法体中的第一行。
第二、当子类方法中的局部变量或者子类的成员变量与父类成员变量同名时,也就是子类局部变量覆盖父类成员变量时,用“super.成员变量名”来引用父类成员变量。
当然,如果父类的成员变量没有被覆盖,也可以用“super.成员变量名”来引用父类成员变量,不过这是不必要的。
第三、当子类的成员方法覆盖了父类的成员方法时,也就是子类和父类有完全相同的方法定义(但方法体可以不同),此时,用“super.方法名(参数列表)”的方式访问父类的方法。
this、super的用法也不过这些,只有理解了其中的原理,才不会跌入陷阱!
Java中abstractclass和interface的解释和他们的异同点
(一)概述
在Java语言中,abstractclass和interface是支持抽象类定义的两种机制。
正是由于这两种机制的存在,才赋予了Java强大的面向对象能力。
abstractclass和interface之间在对于抽象类定义的支持方面具有很大的相似性,甚至可以相互替换,因此很多开发者在进行抽象类定义时对于abstractclass和interface的选择显得比较随意。
其实,两者之间还是有很大的区别的,对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。
abstractclass和interface在Java语言中都是用来进行抽象类(本文中的抽象类并非从abstractclass翻译而来,它表示的是一个抽象体,而abstractclass为Java语言中用于定义抽象类的一种方法,请读者注意区分)定义的,那么什么是抽象类,使用抽象类能为我们带来什么好处呢?
在面向对象的概念中,我们知道所有的对象都是通过类来描绘的,但是反过来却不是这样。
并不是所有的类都是用来描绘对象的(把类具体化),如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。
抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。
比如:
如果我们进行一个图形编辑软件的开发,就会发现问题领域存在着圆、三角形这样一些具体概念,它们是不同的,但是它们又都属于形状这样一个概念,形状这个概念在问题领域是不存在的,它就是一个抽象概念。
正是因为抽象的概念在问题领域没有对应的具体概念,所以用以表征抽象概念的抽象类是不能够实例化的。
在面向对象领域,抽象类主要用来进行类型隐藏。
我们可以构造出一个固定的一组行为的抽象描述,但是这组行为却能够有任意个可能的具体实现方式。
这个抽象描述就是抽象类,而这一组任意个可能的具体实现则表现为所有可能的派生类。
好比,动物是一个抽象类,人、猴子、老虎就是具体实现的派生类,我们就可以用动物类型来隐藏人、猴子和老虎的类型。
(二)从语法定义来分析
在语法层面,Java语言对于abstractclass和interface给出了不同的定义方式,下面以定义一个名为Demo的抽象类为例来说明这种不同。
使用abstractclass的方式定义Demo抽象类的方式如下:
abstractclassDemo{
abstractvoidmethod1();
abstractvoidmethod2();
…
}
使用interface的方式定义Demo抽象类的方式如下:
interfaceDemo{
voidmethod1();
voidmethod2();
在abstractclass方式中,Demo可以有自己的数据成员,也可以有非abstract的成员方法,而在interface方式的实现中,Demo只能够有静态的不能被修改的数据成员(也就是必须是staticfinal的,不过在interface中一般不定义数据成员),所有的成员方法都是abstract的。
从某种意义上说,interface是一种特殊形式的abstractclass。
从编程的角度来看,abstractclass和interface都可以用来实现"
designbycontract"
的思想。
但是在具体的使用上面还是有一些区别的。
首先,abstractclass在Java语言中表示的是一种继承关系,一个
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- java 面向 对象 整理