1. 面向过程和面向对象的区别
面向过程和面向对象都是对软件分析、设计和开发的一种思想,它指导着人们以不同的 方式去分析、设计和开发软件。早期先有面向过程思想,随着软件规模的扩大,问题复杂性 的提高,面向过程的弊端越来越明显的显示出来,出现了面向对象思想并成为目前主流的方 式。两者都贯穿于软件分析、设计和开发各个阶段,对应面向对象就分别称为面向对象分析 (OOA)、面向对象设计(OOD)和面向对象编程(OOP)。C 语言是一种典型的面向过 程语言,Java 是一种典型的面向对象语言。
面向过程思想思考问题时,我们首先思考“怎么按步骤实现?”并将步骤对应成方法, 一步一步,最终完成。 这个适合简单任务,不需要过多协作的情况下。比如,如何开车? 我们很容易就列出实现步骤:
面向过程适合简单、不需要协作的事务,重点关注如何执行。
但是当我们思考比较复杂的设计任务时,比如“如何造车?”,就会发现列出 1234 这 样的步骤,是不可能的。那是因为,造车太复杂,需要很多协作才能完成。此时面向对象思 想就应运而生了。
面向对象(Oriented-Object)思想更契合人的思维模式。我们首先思考的是“怎么设计 这个事物?” 比如思考造车,我们就会先思考“车怎么设计?”,而不是“怎么按步骤造 车的问题”。这就是思维方式的转变。
比如,我们用面向对象思想思考“如何设计车”:
天然的,我们就会从“车由什么组成”开始思考。发现,车由如下对象组成:
为了便于协作,我们找轮胎厂完成制造轮胎的步骤,发动机厂完成制造发动机的步骤; 这样,发现大家可以同时进行车的制造,最终进行组装,大大提高了效率。但是,具体到轮 胎厂的一个流水线操作,仍然是有步骤的,还是离不开执行者、离不开面向过程思维!
因此,面向对象可以帮助我们从宏观上把握、从整体上分析整个系统。 但是,具体到 实现部分的微观操作(就是一个个方法),仍然需要面向过程的思路去处理。
我们千万不要把面向过程和面向对象对立起来。他们是相辅相成的。面向对象离不开面 向过程!
·面向对象和面向过程思想的总结
都是解决问题的思维方式,都是代码组织的方式。
面向过程是一种“执行者思维”,解决简单问题可以使用面向过程。
面向对象是一种“设计者思维”,解决复杂、需要协作的问题可以使用面向对象。
面向对象离不开面向过程:
di 宏观上:通过面向对象进行整体设计
微观上:执行和处理数据,仍然是面向过程。
2. 面向对象是“设计者思维”
面向对象是一种“设计者思维”。设计时,先从问题中找名词,然后确立这些名词哪些 可以作为类,再根据问题需求确定的类的属性和方法,确定类之间的关系。
设计一款企业管理软件,我们需要进行面向对象分析(OOA:Object-Oriented Analysis),写一首诗、一篇文章、一篇小说也需要进行面向对象分析。
因此,面向对象这种思维是任何人都需要学习、任何人都需要掌握的。
第二节 对象和类的详解
1. 类和对象的概念
我们人认识世界,其实就是面向对象的(此对象可不是男女谈对象的彼对象呀) 。比 如现在让大家认识一下“天使”这个新事物,天使大家没见过吧,怎么样认识呢?最好的办 法就是,给你们面前摆 4 个天使,带翅膀的美女,让大家看,看完以后,即使我不说,大 家下一次是不是就都认识天使了。
但是,看完 10 个天使后,我们总要总结一下,什么样的东东才算天使?天使是无数的, 总有没见过的!所以必须总结抽象,便于认识未知事物!总结的过程就是抽象的过程。小时 候,我们学自然数时怎么定义的?像 1,2,3,4…这样的数就叫做自然数。 通过抽象,我 们发现天使有这样一下特征:
1. 带翅膀(带翅膀不一定是天使,还可能是鸟人)
2. 女孩(天使掉下来脸着地,也是天使!)
3. 善良
4. 头上有光环
那么通过这 4 个具体的天使,我们进行抽象,抽象出了天使的特征,我们也可以归纳一 个天使类。 通过这个过程,类就是对象的抽象。
类可以看做是一个模版,或者图纸,系统根据类的定义来造出对象。我们要造一个汽车, 怎么样造?类就是这个图纸,规定了汽车的详细信息,然后根据图纸将汽车造出来。
类:我们叫做 class。 对象:我们叫做 Object,instance(实例)。以后我们说某个类的对 象,某个类的实例。是一样的意思。
2. 类的定义
做了关于对象的很多介绍,终于进入代码编写阶段。本节中重点介绍类和对象的基本定 义,属性和方法的基本使用方式。
属性(field 成员变量)
**属性用于定义该类或该类对象包含的数据或者说静态特征。**属性作用范围是整个类体。 在定义成员变量时可以对其初始化,如果不对其初始化,Java 使用默认的值对其初始化。
方法
方法用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽 象。方法很类似于面向过程中的函数。面向过程中,函数是最基本单位,整个程序由一个个 函数调用组成。面向对象中,整个程序的基本单位是类,方法是从属于类和对象的。
方法定义格式:
[修饰符] 方法返回值类型 方法名(形参列表) { // n 条语句 }
示例
public class Stu {
//属性 int id; String sname; int age;
//方法 void
public void study(){
System.out.println(“我正在学习,正在敲代码,正在听课!!不要 打扰我!”);
}
}
1. 构造方法基础用法
构造器也叫构造方法(constructor),用于对象的初始化。构造器是一个创建对象时被 自动调用的特殊方法,目的是对象的初始化。构造器的名称应与类的名称一致。Java 通过 new 关键字来调用构造器,从而返回该类的实例,是一种特殊的方法。
声明格式:
[修饰符] 类名(形参列表){ //n 条语句 }
构造器 4 个要点:
构造器通过 new 关键字调用!!
构造器虽然有返回值,但是不能定义返回值类型(返回值的类型肯定是本类),不能 在构造器里使用 return 返回某个值。
如果我们没有定义构造器,则编译器会自动定义一个无参的构造方法。如果已定则编译器不会自动添加!
构造器的方法名必须和类名一致!
2. 构造方法的重载
构造方法也是方法,只不过有特殊的作用而已。与普通方法一样,构造方法也可以重载。
示例
public class User {
int id; // id
String name; // 账户名
String pwd; // 密码
public User() {
}
public User(int id, String name) {
this.id = id; this.name = name;
}
public User(int id, String name, String pwd) {
this.id = id; this.name = name; this.pwd = pwd;
}
public static void main(String[ ] args) {
User u1 = new User();
User u2 = new User(101, "贝西");
User u3 = new User(100, "贾志杰", "123456");
}
}
3.面向对象的内存结构
示例
编写 Person 类
public class Person {
String name;
int age;
public void show(){
System.out.println("姓名:"+name+",年龄:"+age);
}
}
创建 Person 类对象并使用
public class TestPerson {
public static void main(String[ ] args) {
// 创建p1对象
Person p1 = new Person();
p1.age = 24;
p1.name = "张三";
p1.show();
// 创建p2对象
Person p2 = new Person();
p2.age = 35;
p2.name = "李四";
p2.show();
}
}
执行结果
运行时的内存分配图
4.参数传值机制
Java 中,方法中所有参数都是“值传递”,也就是“传递的是值的副本”。 也就是说, 我们得到的是“原参数的复印件,而不是原件”。因此,复印件改变不会影响原件。
基本数据类型参数的传值
传递的是值的副本。副本改变不会影响原件。
引用类型参数的传值
传递的是值的副本。但是引用类型指的是“对象的地址”。因此,副本和原参数都指向 了同一个“地址”,改变“副本指向地址对象的值,也意味着原参数指向对象的值也发生了 改变”。
对象创建的过程和 this 的本质
构造方法是创建 Java 对象的重要途径,通过 new 关键字调用构造器时,构造器也确实 返回该类的对象,但这个对象并不是完全由构造器负责创建。创建一个对象分为如下四步:
this 最常的用法:
在程序中产生二义性之处,应使用 this 来指明当前对象;普通方法中,this 总是指 向调用该方法的对象。构造方法中,this 总是指向正要初始化的对象。
使用 this 关键字调用重载的构造方法,避免相同的初始化代码。但只能在构造方法 中用,并且必须位于构造方法的第一句。
this 不能用于 static 方法中。
static 关键字
在类中,用 static 声明的成员变量为静态成员变量,也称为类变量。 类变量的生命周 期和类相同,在整个应用程序执行期间都有效。它有如下特点:
为该类的公用变量,属于类,被该类的所有实例共享,在类被载入时被显式初始化。
对于该类的所有对象来说,static 成员变量只有一份。被该类的所有对象共享!!
一般用“类名.类属性/方法”来调用。(也可以通过对象引用或类名(不需要实例 化)访问静态成员。)
在 static 方法中不可直接访问非 static 的成员。
包机制是 Java 中管理类的重要手段。 开发中,我们会遇到大量同名的类,通过包我们 很容易对解决类重名的问题,也可以实现对类的有效管理。 包对于类,相当于文件夹对于 文件的作用。
package
我们通过 package 实现对类的管理,package 的使用有两个要点:
com.sun.test;
com.oracle.test;
cn.sxt.gao.test;
cn.sxt.gao.view;
cn.sxt.gao.view.model;
导入类 import
如果我们要使用其他包的类,需要使用 import 导入,从而可以在本类中直接通过类名 来调用,否则就需要书写类的完整包名和类名。import 后,便于编写代码,提高可维护性。
1.继承
继承是面向对象编程的三大特征之一,它让我们更加容易实现对于已有类的扩展、更加 容易实现对于现实世界的建模。
继承有两个主要作用:
1.1 继承的实现
继承让我们更加容易实现类的扩展。 比如,我们定义了人类,再定义 Boy 类就只需要 扩展人类即可。实现了代码的重用,不用再重新发明轮子(don’t reinvent wheels)。 从英文字面意思理解,extends 的意思是“扩展”。子类是父类的扩展。现实世界中的 继承无处不在。比如:
上图中,哺乳动物继承了动物。意味着,动物的特性,哺乳动物都有;在我们编程中,如果 新定义一个 Student 类,发现已经有 Person类包含了我们需要的属性和方法,那么 Student 类只需要继承 Person 类即可拥有 Person 类的属性和方法。
示例
public class Test{
public static void main(String[ ] args) {
Student s = new Student("贝西",172,"Java");
s.rest(); s.study();
}
}
class Person {
String name;
int height;
public void rest(){
System.out.println("休息一会!");
}
}
class Student extends Person {
String major; //专业
public void study(){
System.out.println("在双体系,学习Java");
}
public Student(String name,int height,String major) {
//天然拥有父类的属性
this.name = name; this.height = height;
this.major = major;
}
}
1.2 instanceof 运算符
instanceof 是二元运算符,左边是对象,右边是类;当对象是右面类或子类所创建对 象时,返回 true;否则,返回 false。
1.3 继承使用要点
1.4 方法的重写 override
子类通过重写父类的方法,可以用自身的行为替换父类的行为。方法的重写是实现多态 的必要条件。
方法的重写需要符合下面的三个要点:
1.5 final 关键字
final 关键字的作用:
修饰变量: 被他修饰的变量不可改变。一旦赋了初值,就不能被重新赋值。 final int MAX_SPEED = 120;
修饰方法:该方法不可被子类重写。但是可以被重载!
final void study(){}
修饰类: 修饰的类不能被继承。比如:Math、String 等。
final class A {}
1.6 super 关键字
super“可以看做”是直接父类对象的引用。可以通过 super 来访问父类中被子类覆盖 的方法或属性。
使用 super 调用普通方法,语句没有位置限制,可以在子类中随便调用。
在一个类中,若是构造方法的第一行代码没有显式的调用 super(…)或者 this(…);那么 Java 默认都会调用 super(),含义是调用父类的无参数构造方法。这里的 super()可以省略。
2.封装(encapsulation)
封装是面向对象三大特征之一。对于程序合理的封装让外部调用更加方便,更加利于写 作。同时,对于实现者来说也更加容易修正和改版代码。
2.1 封装的作用和含义
我要看电视,只需要按一下开关和换台就可以了。有必要了解电视机内部的结构吗?有 必要碰碰显像管吗?制造厂家为了方便我们使用电视,把复杂的内部细节全部封装起来,只 给我们暴露简单的接口,比如:电源开关。具体内部是怎么实现的,我们不需要操心。
需要让用户知道的才暴露出来,不需要让用户知道的全部隐藏起来,这就是封装。说的 专业一点,封装就是把对象的属性和操作结合为一个独立的整体,并尽可能隐藏对象的内部 实现细节。
我们程序设计要追求“高内聚,低耦合”。高内聚就是类的内部数据操作细节自己完成, 不允许外部干涉;低耦合是仅暴露少量的方法给外部使用,尽量方便外部调用。
编程中封装的具体优点:
提高代码的安全性。
提高代码的复用性。
“高内聚”:封装细节,便于修改内部代码,提高可维护性。
“低耦合”:简化外部调用,便于调用者使用,便于扩展和协作
2.2封装的实现—使用访问控制符
Java 是使用“访问控制符”来控制哪些细节需要封装,哪些细节需要暴露的。 Java 中 4 种“访问控制符”分别为 private、default、protected、public,它们说明了面向对 象的封装性,所以我们要利用它们尽可能的让访问权限降到最低,从而提高安全性。
第三节 多态(polymorphism)
3.1 多态概念和实现
多态指的是同一个方法调用,由于对象不同可能会有不同的行为。现实生活中,同一个 方法,具体实现会完全不同。 比如:同样是调用人的“休息”方法,张三是睡觉,李四是 旅游,贝西老师是敲代码,数学教授是做数学题; 同样是调用人“吃饭”的方法,中国人 用筷子吃饭,英国人用刀叉吃饭,印度人用手吃饭。
多态的要点:
完整示例:
package com.stx.demo1;
/*
* 多态:前提继承或者实现
*
*/
class Animal{
String name;
int age;
//动物种有叫和吃两个方法
//叫
public void cry() {
System.out.println("我不知道怎么叫");
}
//吃
public void eat() {
System.out.println("我不知道怎么吃");
}
}
class Dog extends Animal{
public void cry() {
System.out.println("汪汪汪");
}
public void eat() {
System.out.println("狗爱吃骨头");
}
}
class Cat extends Animal{
public void cry() {
System.out.println("喵喵喵");
}
public void eat() {
System.out.println("猫爱吃鱼");
}
}
public class Test2 {
public static void main(String[] args) {
/*
* Animal a=new Animal(); a.cry(); Dog d=new Dog(); d.cry(); d.eat(); Cat c=new
* Cat(); c.cry(); c.eat();
*/
/*
* Animal a1=new Dog(); a1.cry();
*/
Dog d=new Dog();
Cat c=new Cat();
getCry(c);
}
//多态的应用
public static void getCry(Animal a) {
//Animal a=new Cat();
a.cry();
a.eat();
}
}
3.2 接口 interface
接口就是规范,定义的是一组规则,体现了现实世界中“如果你是…则必须能…”的思 想。如果你是天使,则必须能飞。如果你是汽车,则必须能跑。如果你是好人,则必须能干掉坏人;如果你是坏人,则必须欺负好人。
接口的本质是契约,就像我们人间的法律一样。制定好后大家都遵守。
面向对象的精髓,是对对象的抽象,最能体现这一点的就是接口。为什么我们讨论设计 模式都只针对具备了抽象能力的语言(比如 C++、Java、C#等),就是因为设计模式所研 究的,实际上就是如何合理的去抽象。
3.3如何定义和使用接口
声明格式:
[访问修饰符] interface 接口名 [extends 父接口 1,父接口 2…] {
常量定义;
方法定义;
}
定义接口的详细说明:
访问修饰符:只能是 public 或默认。
接口名:和类名采用相同命名机制。
extends:接口可以多继承。
常量:接口中的属性只能是常量,总是:public static final 修饰。不写也是。
方法:接口中的方法只能是:public abstract。 省略的话,也是 public abstract。