面向对象思想

最新推荐文章于 2021-04-23 16:42:29 发布

贝西奇谈

最新推荐文章于 2021-04-23 16:42:29 发布

阅读量1.3k

点赞数

分类专栏： java 文章标签： java 面向对象编程

本文链接：https://blog.csdn.net/beixishuo/article/details/104720473

版权

java 专栏收录该内容

26 篇文章 4 订阅

订阅专栏

第一节面向过程和面向对象思想

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(“我正在学习，正在敲代码，正在听课！！不要打扰我!”);
}
}

第三节构造方法(构造器 constructor)

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、static 关键字

对象创建的过程和 this 的本质
构造方法是创建 Java 对象的重要途径，通过 new 关键字调用构造器时，构造器也确实返回该类的对象，但这个对象并不是完全由构造器负责创建。创建一个对象分为如下四步：

分配对象空间，并将对象成员变量初始化为 0 或空
执行属性值的显式初始化
执行构造方法
返回对象的地址给相关的变量 this 的本质就是“创建好的对象的地址”！由于在构造方法调用前，对象已经创建。因此，在构造方法中也可以使用 this 代表“当前对象”。

this 最常的用法：
 在程序中产生二义性之处，应使用 this 来指明当前对象；普通方法中，this 总是指向调用该方法的对象。构造方法中，this 总是指向正要初始化的对象。
 使用 this 关键字调用重载的构造方法，避免相同的初始化代码。但只能在构造方法中用，并且必须位于构造方法的第一句。
 this 不能用于 static 方法中。

static 关键字
在类中，用 static 声明的成员变量为静态成员变量，也称为类变量。类变量的生命周期和类相同，在整个应用程序执行期间都有效。它有如下特点：
 为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化。
 对于该类的所有对象来说，static 成员变量只有一份。被该类的所有对象共享！！
 一般用“类名.类属性/方法”来调用。（也可以通过对象引用或类名（不需要实例化）访问静态成员。）
 在 static 方法中不可直接访问非 static 的成员。

第五节包机制(package、import)

包机制是 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 继承使用要点

父类也称作超类、基类。子类：派生类等。
Java 中只有单继承，没有像 C++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。
Java 中类没有多继承，接口有多继承。
子类继承父类，可以得到父类的全部属性和方法 (除了父类的构造方法)，但不见得可以直接访问(比如，父类私有的属性和方法)。
如果定义一个类时，没有调用 extends，则它的父类是：java.lang.Object。

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，它们说明了面向对象的封装性，所以我们要利用它们尽可能的让访问权限降到最低，从而提高安全性。
在这里插入图片描述

private 表示私有，只有自己类能访问
default 表示没有修饰符修饰，只有同一个包的类能访问
protected 表示可以被同一个包的类以及其他包中的子类访问
public 表示可以被该项目的所有包中的所有类访问

第三节多态(polymorphism)
3.1 多态概念和实现
多态指的是同一个方法调用，由于对象不同可能会有不同的行为。现实生活中，同一个方法，具体实现会完全不同。比如：同样是调用人的“休息”方法，张三是睡觉，李四是旅游，贝西老师是敲代码，数学教授是做数学题；同样是调用人“吃饭”的方法，中国人用筷子吃饭，英国人用刀叉吃饭，印度人用手吃饭。
多态的要点：

多态是方法的多态，不是属性的多态（多态与属性无关）。
多态的存在要有 3 个必要条件：继承，方法重写，父类引用指向子类对象。
父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

完整示例：

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。

贝西奇谈

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
面向对象思想

第一节面向过程和面向对象思想1. 面向过程和面向对象的区别面向过程和面向对象都是对软件分析、设计和开发的一种思想,它指导着人们以不同的方式去分析、设计和开发软件。早期先有面向过程思想，随着软件规模的扩大，问题复杂性的提高，面向过程的弊端越来越明显的显示出来，出现了面向对象思想并成为目前主流的方式。两者都贯穿于软件分析、设计和开发各个阶段，对应面向对象就分别称为面向对象分析（OOA...
复制链接

扫一扫