一 面向对象
1.1面向过程与面向对象
面向过程与面向对象都是我们编程中,编写程序的一种思维方式。
面向过程的程序设计方式,是遇到一件事时,思考“我该怎么做”,然后一步步实现的过程。
例如:公司打扫卫生(擦玻璃、扫地、拖地、倒垃圾等),按照面向过程的程序设计方式会思考“打扫卫生我该怎么做,然后一件件的完成”,最后把公司卫生打扫干净了。
面向对象的程序设计方式,是遇到一件事时,思考“我该让谁来做”,然后那个“谁”就是对象,他要怎么做这件事是他自己的事,反正最后一群对象合力能把事就好就行了。
例如,公司打扫卫生(擦玻璃、扫地、拖地、倒垃圾等),按照面向对象的程序设计方式会思考“我该让谁来做,如小明擦玻璃、让小丽扫地、让小郭拖地、让小强倒垃圾等”,这里的“小明、小丽、小郭、小强”就是对象,他们要打扫卫生,怎么打扫是他们自己的事,反正最后一群对象合力把公司卫生打扫干净了。1.2面向对象举例
以买电脑(组装机)为例。
先使用面向过程说明买电脑这件事:假如我们需要买组装电脑,这时首先会在网上查询具体每一个硬件的参数和报价。然后会去电脑城进行多家询价,接着询价结束后回家根据具体的结果分析出自己比较满意的哪家报价,接着会到这家店里进行组装,组装时还需要进行现场监督,组装完成安装相应的系统,然后电脑抱回家。
分析上述整个过程大体分一下几步:上网查询参数和报价、电脑城询价、现场安装和监督、抱电脑回家。在整个过程中我们参与了每一个细节,并且会感觉相当累。
使用面向对象说明买电脑这件事:假如我们需要买组装机,这时应该找一个懂电脑硬件的人,让他帮我们查看参数和报价,并进行询价和杀价,以及现场组装监督。而我们自己并不需要亲历亲为具体怎么做,只要告诉这个人我们想要的具体需求即可。
分析上述整个过程,发现瞬间变的十分轻松,只要找到懂电脑硬件的这个人,我们的问题都可以解决。并且在这个过程中我们不用那么辛苦。
1.3面向对象思维方式的好处
通过生活中的真实场景使用面向对象分析完之后,我们开始分析面向过程和面向对象的差异做出总结:
面向对象思维方式是一种更符合人们思考习惯的思想。
面向过程思维方式中更多的体现的是执行者(自己做事情),面向对象中更多的体现是指挥者(指挥对象做事情)。
面向对象思维方式将复杂的问题简单化。
二 类与对象
2.1类与对象的区别
面向对象的编程思想力图在程序中对事物的描述与该事物在现实中的形态保持一致。为了做到这一点,面向对象的思想中提出两个概念,即类和对象。其中,类是对某一类事物的抽象描述,而对象用于表示现实中该类事物的个体。接下来通过一个图例来抽象描述类与对象的关系,如下图所示。
在上图中,可以将玩具模型看作是一个类,将一个个玩具看作对象,从玩具模型和玩具之间的关系便可以看出类与对象之间的关系。类用于描述多个对象的共同特征,它是对象的模板。对象用于描述现实中的个体,它是类的实例。从上图中可以明显看出对象是根据类创建的,并且一个类可以对应多个对象,接下来分别讲解什么是类和对象。
经过前面几个知识点的学习,基本上掌握了类是用于描述事物的,类中可以定义事物的属性和行为。而对象是通过描述的这个类,使用new关键字创建出来,通过对象就可以调用该对象具体的属性和功能了。
2.2对象的内存图解
我们虽然可以将生活中的事物使用Java代码描述出来,但是这些代码在内存中是如何执行的,接下来我们需要研究下对象在内存的图解。
2.3局部变量和成员变量的区别
理解清楚了类和对象之后,发现在描述类的属性和前面学习定义变量差别不大,唯一区别就是位置发生了改变,那么类中定义的变量,和在方法定义的变量有啥差别呢?
回忆以前学习时变量的定义方式,和位置,以及现在定义类中属性的特点。总结下面几点异同
区别一:定义的位置不同
定义在类中的变量是成员变量
定义在方法中或者{}语句里面的变量是局部变量
区别二:在内存中的位置不同
成员变量存储在堆内存的对象中
局部变量存储在栈内存的方法中
区别三:声明周期不同
成员变量随着对象的出现而出现在堆中,随着对象的消失而从堆中消失
局部变量随着方法的运行而出现在栈中,随着方法的弹栈而消失
区别四:初始化不同
成员变量因为在堆内存中,所有默认的初始化值
局部变量没有默认的初始化值,必须手动的给其赋值才可以使用
2.4基本类型和引用类型作为参数传递
引用类型数据和基本类型数据作为参数传递有没有差别呢?我们用如下代码进行说明,并配合图解让大家更加清晰。
基本类型作为参数传递时,其实就是将基本类型变量x空间中的值复制了一份传递给调用的方法show(),当在show()方法中x接受到了复制的值,再在show()方法中对x变量进行操作,这时只会影响到show中的x。当show方法执行完成,弹栈后,程序又回到main方法执行,main方法中的x值还是原来的值。
当引用变量作为参数传递时,这时其实是将引用变量空间中的内存地址(引用)复制了一份传递给了show方法的d引用变量。这时会有两个引用同时指向堆中的同一个对象。当执行show方法中的d.x=6时,会根据d所持有的引用找到堆中的对象,并将其x属性的值改为6.show方法弹栈。由于是两个引用指向同一个对象,不管是哪一个引用改变了引用的所指向的对象的中的值,其他引用再次使用都是改变后的值。
三 封装
3.1封装概述
面向对象共有三个特征:封装,继承,多态。
提起封装,大家并不陌生。前面我们学习方法时,就提起过,将具体功能封装到方法中,学习对象时,也提过将方法封装在类中,其实这些都是封装。
封装,它也是面向对象思想的特征之一。接下来我们具体学习封装。
封装表现:
1、方法就是一个最基本封装体。
2、类其实也是一个封装体。
3、变量:使用private 修饰,这就是变量的封装
从以上两点得出结论,封装的好处:
1、提高了代码的复用性。
2、隐藏了实现细节,还要对外提供可以访问的方式。便于调用者的使用。这是核心之一,也可以理解为就是封装的概念。
3、提高了安全性。
举个例子,拿机箱来说:
一台电脑,它是由CPU、主板、显卡、内存、硬盘、电源等部件组长,其实我们将这些部件组装在一起就可以使用电脑了,但是发现这些部件都散落在外面,很容造成不安全因素,于是,使用机箱壳子,把这些部件都装在里面,并在机箱壳上留下一些插口等,若不留插口,大家想想会是什么情况。
总结:机箱其实就是隐藏了办卡设备的细节,对外提供了插口以及开关等访问内部细节的方式。
3.2私有private
总结:类中不需要对外提供的内容都私有化,包括属性和方法。
以后再描述事物,属性都私有化,并提供setXxx getXxx方法对其进行访问。
注意:私有仅仅是封装的体现形式而已。
3.3this关键字
当在方法中出现了局部变量和成员变量同名的时候,那么在方法中怎么区别局部变量成员变量呢?
可以在成员变量名前面加上this.来区别成员变量和局部变量。下图是内存对象创建使用过程。
程序执行流程说明:
1、先执行main方法(压栈),执行其中的 Person p = new Person();
2、在堆内存中开辟空间,并为其分配内存地址0x1234,紧接着成员变量默认初始化(age = 0);将内存地址0x1234赋值给栈内中的Person p 变量
3、继续执行p.setAge(30)语句,这时会调用setAge(int age)方法,将30赋值为setAge方法中的“age”变量;执行this.age= age语句,将age变量值30 赋值给成员变量,this.age为30;
4、setAge()方法执行完毕后(弹栈),回到main()方法,执行输出语句System.out.println(),控制台打印p对象中的age年龄值。
注意:
this到底代表什么呢?this代表的是对象,具体代表哪个对象呢?哪个对象调用了this所在的方法,this就代表哪个对象。
this什么时候存在的?当创建对象的时候,this存在的。
上述代码中的 p.setAge(30)语句中,setAge(int age)方法中的this代表的就是p对象。
四 继承
4.1继承的概念
在程序中,继承描述的是事物之间的所属关系,通过继承可以使多种事物之间形成一种关系体系。例如公司中的研发部员工和维护部员工都属于员工,程序中便可以描述为研发部员工和维护部员工继承自员工,同理,JavaEE工程师和Android工程师继承自研发部员工,而维网络维护工程师和硬件维护工程师继承自维护部员工。
在Java中,类的继承是指在一个现有类的基础上去构建一个新的类,构建出来的新类被称作子类,现有类被称作父类,子类会自动拥有父类所有可继承的属性和方法。
在程序中,如果想声明一个类继承另一个类,需要使用extends关键字。格式:class 子类 extends 父类 {}
4.2继承的好处及注意
继承的好处:
1、继承的出现提高了代码的复用性,提高软件开发效率。
2、继承的出现让类与类之间产生了关系,提供了多态的前提。
在类的继承中,需要注意一些问题,具体如下:
1、在Java中,类只支持单继承,不允许多继承,也就是说一个类只能有一个直接父类(但接口可以多继承)。
2、多个类可以继承一个父类。
3、在Java中,多层继承是可以的,即一个类的父类可以再去继承另外的父类,例如C类继承自B类,而B类又可以去继承A类,这时,C类也可称作A类的子类。
4、在Java中,子类和父类是一种相对概念,也就是说一个类是某个类父类的同时,也可以是另一个类的子类。
4.3继承-子父类中成员变量特点
了解了继承给我们带来的好处,提高了代码的复用性。继承让类与类或者说对象与对象之间产生了关系。那么,当继承出现后,类的成员之间产生了那些变化呢?
类的成员重点学习成员变量、成员方法的变化。
成员变量:如果子类父类中出现不同名的成员变量,这时的访问是没有任何问题。
当子父类中出现了同名成员变量时,在子类中若要访问父类中的成员变量,必须使用 关键字super来完成。super用来表示当前对象中包含的父类对象空间的引用。4.4继承-子父类中成员方法特点:重写
1)子父类中成员方法的特点:
当在程序中通过对象调用方法时,会先在子类中查找有没有对应的方法,若子类中存在就会执行子类中的方法,若子类中不存在就会执行父类中相应的方法。2)成员方法特殊情况——覆盖/重写
子类中出现与父类一模一样的方法时,会出现覆盖操作,也称为override重写、复写或者覆盖。
3)方法重写(覆盖)的应用:
当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容。
举例:比如手机,当描述一个手机时,它具有发短信,打电话,显示来电号码功能,后期由于手机需要在来电显示功能中增加显示姓名和头像,这时可以重新定义一个类描述智能手机,并继承原有描述手机的类。并在新定义的类中覆盖来电显示功能,在其中增加显示姓名和头像功能。
4)重写需要注意的细节问题:
子类方法覆盖父类方法,必须要保证权限大于等于父类权限。
写法上稍微注意:必须一模一样的有:方法的返回值类型 方法名 参数列表都要一样。
总结:当一个类是另一个类中的一种时,可以通过继承,来继承属性与功能。如果父类具备的功能内容需要子类特殊定义时,进行方法重写。
五 抽象类
5.1抽象类产生及定义
当编写一个类时,我们往往会为该类定义一些方法,这些方法是用来描述该类的功能具体实现方式,那么这些方法都有具体的方法体。
但是有的时候,某个父类只是知道子类应该包含怎么样的方法,但是无法准确知道子类如何实现这些方法。比如一个图形类应该有一个求周长的方法,但是不同的图形求周长的算法不一样。那该怎么办呢?
分析事物时,发现了共性内容,就出现向上抽取。会有这样一种特殊情况,就是方法功能声明相同,但方法功能主体不同。那么这时也可以抽取,但只抽取方法声明,不抽取方法主体。那么此方法就是一个抽象方法。
描述JavaEE工程师:行为:工作。
描述Android工程师:行为:工作。
JavaEE工程师和Android工程师之间有共性,可以进行向上抽取。抽取它们的所属共性类型:研发部员工。由于JavaEE工程师和Android工程师都具有工作功能,但是他们具体工作内容却不一样。这时在描述研发部员工时,发现了有些功能(工作)不具体,这些不具体的功能,需要在类中标识出来,通过java中的关键字abstract(抽象)。
当定义了抽象函数的类也必须被abstract关键字修饰,被abstract关键字修饰的类是抽象类。
抽象方法定义的格式:public abstract 返回值类型 方法名(参数); //没有大括号!!
抽象类定义的格式:abstract class 类名 { }
5.2抽象类特点
1、抽象类和抽象方法都需要被abstract修饰。抽象方法一定要定义在抽象类中。
2、抽象类不可以直接创建对象,原因:调用抽象方法没有意义。
3、只有覆盖了抽象类中所有的抽象方法后,其子类才可以创建对象。否则该子类还是一个抽象类。
之所以继承抽象类,更多的是在思想,是面对共性类型操作会更简单。
关于抽象类有以下几个问题:
1、抽象类一定是个父类?
是的,因为不断抽取而来的。
2、抽象类中是否可以不定义抽象方法。
是可以的,那这个抽象类的存在到底有什么意义呢?不让该类创建对象,方法可以直接让子类去使用。
3、抽象关键字abstract不可以和哪些关键字共存?
①private:私有的方法子类是无法继承到的,也不存在覆盖,而abstract和private一起使用修饰方法,abstract既要子类去实现这个方法,而private修饰子类根本无法得到父类这个方法。互相矛盾。
②final,因为final修饰的方法不能被重写,修饰的类不能被继承。
③static,表示可以通过类名直接调用。
注意:抽象类面试题:
1 抽象类中是否可以没有抽象方法?如果可以,那么,该类还定义成抽象类有意义吗?为什么?
可以没有抽象方法,有意义,不会让其他人直接创建该类对象。
六 接口
6.1接口概述
接口是功能的集合,同样可看做是一种数据类型,是比抽象类更为抽象的”类”。
接口只描述所应该具备的方法,并没有具体实现,具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离,优化了程序设计。请记住:一切事物均有功能,即一切事物均有接口。
与定义类的class不同,接口定义时需要使用interface关键字。
定义接口所在的仍为.java文件,虽然声明时使用的为interface关键字的编译后仍然会产生.class文件。这点可以让我们将接口看做是一种只包含了功能声明的特殊类。
注意:使用interface代替了原来的class,其他步骤与定义类相同:
接口中的方法均为公共访问的抽象方法
接口中无法定义普通的成员变量
定义格式:
public interface 接口名 {
抽象方法1;
抽象方法2;
抽象方法3;
}
6.2类实现接口
类与接口的关系为实现关系,即类实现接口。实现的动作类似继承,只是关键字不同,实现使用implements。其他类(实现类)实现接口后,就相当于声明:”我应该具备这个接口中的功能”。实现类仍然需要重写方法以实现具体的功能。
格式:
class 类 implements 接口 {
重写接口中方法
}
在类实现接口后,该类就会将接口中的抽象方法继承过来,此时该类需要重写该抽象方法,完成具体的逻辑。
接口中定义功能,当需要具有该功能时,可以让类实现该接口,只声明了应该具备该方法,是功能的声明。
在具体实现类中重写方法,实现功能,是方法的具体实现。
于是,通过以上两个动作将功能的声明与实现便分开了。(此时请重新思考:类是现实事物的描述,接口是功能的集合。)
6.3接口中成员的特点
1、接口中可以定义变量,但是变量必须有固定的修饰符修饰,public(权限) static(可被类名直接调用) final(最终,固定住变量的值)所以接口中的变量也称之为常量,其值不能改变。后面我们会讲解static与final关键字。修饰符可以不写,但并不代表没有,默认就为上面三个。
2、接口中可以定义方法,方法也有固定的修饰符,public abstract
3、接口不可以创建对象。
4、子类必须覆盖掉接口中所有的抽象方法后,子类才可以实例化。否则子类是一个抽象类。
6.4接口的多实现
接口最重要的体现:解决多继承的弊端。将多继承这种机制在java中通过多实现完成了。
怎么解决多继承的弊端呢?
弊端:多继承时,当多个父类中有相同功能时,子类调用会产生不确定性。
其实核心原因就是在于多继承父类中功能有主体,而导致调用运行时,不确定运行哪个主体内容。
为什么多实现能解决了呢?
因为接口中的功能都没有方法体,由子类来明确。
6.5接口的多继承
接口和类之间可以通过实现产生关系,同时也学习了类与类之间可以通过继承产生关系。当一个类已经继承了一个父类,它又需要扩展额外的功能,这时接口就派上用场了。
子类通过继承父类扩展功能,通过继承扩展的功能都是子类应该具备的基础功能。如果子类想要继续扩展其他类中的功能呢?这时通过实现接口来完成。即:class Zi extends Fu implements Jiekou { }
接口与接口之间会有什么关系?多个接口之间可以使用extends进行继承。接口之间可以实现多继承。
即:interface Zi extends Fu1,Fu2,Fu3{ } 在开发中如果多个接口中存在相同方法,这时若有个子类实现了这些接口,那么就要实现接口中的方法,由于接口中的方法是抽象方法,子类实现后也不会发生调用的不确定性。
前面学习了接口的代码体现,现在来学习接口的思想,接下里从生活中的例子进行说明。
举例:我们都知道电脑上留有很多个插口,而这些插口可以插入相应的设备,这些设备为什么能插在上面呢?主要原因是这些设备在生产的时候符合了这个插口的使用规则,否则将无法插入接口中,更无法使用。发现这个插口的出现让我们使用更多的设备。
总结:接口在开发中的好处
1、接口的出现扩展了功能。
2、接口其实就是暴漏出来的规则。
3、接口的出现降低了耦合性,即设备与设备之间实现了解耦。
接口的出现方便后期使用和维护,一方是在使用接口(如电脑),一方在实现接口(插在插口上的设备)。例如:笔记本使用这个规则(接口),电脑外围设备实现这个规则(接口)。
问题:Java中有多继承吗??
答:类没有多继承,接口之间有多继承~
6.6接口和抽象的区别
相同点:
1)都位于继承的顶端,用于被其他类实现或继承;
2)都不能直接实例化对象;
3)都包含抽象方法,其子类都必须覆写这些抽象方法;
区别:
1)抽象类为部分方法提供实现,避免子类重复实现这些方法,提高代码重用性;接口只能包含抽象方法;
2)一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)
3)抽象类是这个事物中应该具备的内容, 继承体系是一种 is..a关系
4)接口是这个事物中的额外内容,继承体系是一种 like..a关系
二者的选用:
优先选用接口,尽量少用抽象类;
需要定义子类的行为,又要为子类提供共性功能时才选用抽象类。
七 多态
7.1多态概述
多态是继封装、继承之后,面向对象的第三大特性。现实事物经常会体现出多种形态,如学生,学生是人的一种,则一个具体的同学张三既是学生也是人,即出现两种形态。
Java作为面向对象的语言,同样可以描述一个事物的多种形态。如Student类继承了Person类,一个Student的对象便既是Student,又是Person。Java中多态的代码体现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引用变量赋值,又可以给这个子类(实现类对象)的父类(接口)变量赋值。如Student类可以为Person类的子类。那么一个Student对象既可以赋值给一个Student类型的引用,也可以赋值给一个Person类型的引用。
最终多态体现为父类引用变量可以指向子类对象。
多态的前提是必须有子父类关系或者类实现接口关系,否则无法完成多态。在使用多态后的父类引用变量调用方法时,会调用子类重写后的方法。
普通类多态定义的格式:父类 变量名 = new 子类();
抽象类多态定义的格式:抽象类 变量名 = new 抽象类子类();
接口多态定义的格式:接口 变量名 = new 接口实现类();
注意事项:同一个父类的方法会被不同的子类重写。在调用方法时,调用的为各个子类重写后的方法。当变量名指向不同的子类对象时,由于每个子类重写父类方法的内容不同,所以会调用不同的方法。
7.2多态-成员的特点
掌握了多态的基本使用后,那么多态出现后类的成员有啥变化呢?前面学习继承时,我们知道子父类之间成员变量有了自己的特定变化,那么当多态出现后,成员变量在使用上有没有变化呢?
1)多态成员变量
当子父类中出现同名的成员变量时,多态调用该变量时:
编译时期:参考的是引用型变量所属的类(父类)中是否有被调用的成员变量。没有,编译失败。
运行时期:也是调用引用型变量所属的类(父类)中的成员变量。
简单记:编译和运行都参考等号的左边。编译运行都看左边(父类)。
2)多态成员方法
编译时期:参考引用变量所属的类(父类),如果没有类中没有调用的方法,编译失败。
运行时期:参考引用变量所指的对象所属的类(子类),并运行对象所属类中的成员方法。
简而言之:编译看左边(父类),运行看右边(子类)。
7.3instanceof关键字
我们可以通过instanceof关键字来判断某个对象是否属于某种数据类型。如学生的对象属于学生类,学生的对象也属于人类。格式:boolean b = 对象 instanceof 数据类型;
如:Person p1 = new Student(); // 前提条件,学生类已经继承了人类
boolean flag = p1 instanceof Student; //flag结果为true
boolean flag2 = p2 instanceof Teacher; //flag结果为false
7.4多态-转型
多态的转型分为向上转型与向下转型两种:
向上转型:当有子类对象赋值给一个父类引用时,便是向上转型,多态本身就是向上转型的过程。
使用格式:父类类型 变量名 = new 子类类型(); 如:Person p = new Student();
向下转型:一个已经向上转型的子类对象可以使用强制类型转换的格式,将父类引用转为子类引用,这个过程是向下转型。如果是直接创建父类对象,是无法向下转型的!
使用格式:子类类型变量名 = (子类类型) 父类类型的变量; 如:Student stu = (Student) p; //变量p 实际上指向Student对象
7.5多态的利弊
当父类的引用指向子类对象时,就发生了向上转型,即把子类类型对象转成了父类类型。向上转型的好处是隐藏了子类类型,提高了代码的扩展性。
但向上转型也有弊端,只能使用父类共性的内容,而无法使用子类特有功能,功能有限制。例如:
我们来总结一下:
1)什么时候使用向上转型:
当不需要面对子类类型时,通过提高扩展性,或者使用父类的功能就能完成相应的操作,这时就可以使用向上转型。
如:Animal a = new Dog();
a.eat();
2)什么时候使用向下转型
当要使用子类特有功能时,就需要使用向下转型。
如:Dog d= (Dog) a; //向下转型
d.lookHome();//调用狗类的lookHome方法
3)向下转型的好处:可以使用子类特有功能。弊端是:需要面对具体的子类对象;在向下转型时容易发生ClassCastException类型转换异常。在转换之前必须做类型判断。如上图中:if(!a instanceof Dog){…}
学习到这里,面向对象的三大特征学习完了。
八 总结
学习到这里,面向对象的三大特征学习完了。总结下封装、继承、多态的作用:
封装:把对象的属性与方法的实现细节隐藏,仅对外提供一些公共的访问方式
继承:子类会自动拥有父类所有可继承的属性和方法。
多态:配合继承与方法重写提高了代码的复用性与扩展性;如果没有方法重写,则多态同样没有意义。