浅谈Java实现面向对象编程java oop

一、对象的综述

面向对象编程（OOP）具有多方面的吸引力。对管理人员，它实现了更快和更廉价的开发与维护过程。对分析与设计人员，建模处理变得更加简单，能生成清晰、易于维护的设计方案。对程序员，对象模型显得如此高雅和浅显。此外，面向对象工具以及库的巨大威力使编程成为一项更使人愉悦的任务。每个人都可从中获益，至少表面如此。

所有编程语言的最终目的都是解决企业又或者人在现实生活中所遇到的问题，最初我们的程序可能长这样“11111100001”，相信大家都不会陌生，只是大家没这么子去敲过代码。再后来出现了汇编语言，汇编语言便是对基础机器语言（二进制）的少量抽象，再到后来出现了许多“命令式”语言（如FORTRAN、BASIC和C），这些语言便是对汇编语言的一种抽象。这些语言都有了长足的进步，但它们的抽象原理依然要求我们着重考虑计算机的结构，而考虑的不是要解决的问题的本身结构。在机器与实际要解决的问题之间，程序员必须建立起一种联系，这个过程要求人们付出较大的精力，使得程序代码很难编写，写出来的代码又很难理解，要花较大的代价进行维护。

面向对象的程序便很好的解决了这一问题，程序员可利用程序来表达实际问题中的元素，我们便将这些元素在程序中的表示称为“对象”。我们可以根据现实中的问题来灵活配置对象，以便与特定的问题配合。与之前的语言相比，这无疑是一种更加灵活、更加强大的语言抽象。总之OOP允许我们根据问题来描述问题，而不是根据问题在机器中的方案。与现实世界中的“对象”或者“物体”相比，编程对象与它们也存在共通的地方：它们都有自己的特征和行为。

二、什么是对象

通过上面的文字或许大家已经有些明白什么是对象了吧？而上面的文字也是对对象的一种比较深入的理解，而我们最常见的理解方式无非是：对象(object)是任何看得见、摸得着、感觉得到，可以获得的东西，有自己的标识的任何东西。对象是某一类的事物的具体个例。比如这辆汽车、这个人、这间房子、这张桌子、这株植物、这张支票、这件雨衣，概括来说就是：万物皆对象。

在这里给大家摘录一些句子，希望看过的人能够花时间去思考一下：

①“对象一般以域的形式包含数据,通常称作属性；以程序的形式包含代码,通常称作方法”。
②“对象在域中储存自身状态并通过方法暴露自身行为”。
③“每个对象就如一个小型电脑——它有状态,并且它提供操作,你可以调用执行”。
④“一个类包含了存放数值的数据域和操作数值的的方法”。
⑤“一个对象就是储存某些类型的值的内存空间”。
⑥“一个对象包含一些私有内存空间和一些操作”。

三、面向对象程序设计方法

(1)所有东西都是对象。可将对象想象成一种新型变量；它保存着数据，但可要求它对自身进行操作。理论上讲，可从要解决的问题身上提出所有概念性的组件，然后在程序中将其表达为一个对象。
(2)程序是一大堆对象的组合；通过消息传递，各对象知道自己该做些什么。为了向对象发出请求，需向那个对象“发送一条消息”。更具体地讲，可将消息想象为一个调用请求，它调用的是从属于目标对象的一个子例程或函数。
(3)每个对象都有自己的存储空间，可容纳其他对象。或者说，通过封装现有对象，可制作出新型对象。所以，尽管对象的概念非常简单，但在程序中却可达到任意高的复杂程度。
(4)每个对象都有一种类型。根据语法，每个对象都是某个“类”的一个“实例”。其中，“类”（Class）是“类型”（Type）的同义词。一个类最重要的特征就是“能将什么消息发给它？”。
(5)同一类所有对象都能接收相同的消息。这实际是别有含义的一种说法。由于类型为“圆”（Circle）的一个对象也属于类型为“形状”（Shape）的一个对象，所以一个圆完全能接收形状消息。这意味着可让程序代码统一指挥“形状”，令其自动控制所有符合“形状”描述的对象，其中自然包括“圆”。这一特性称为对象的“可替换性”，是OOP 最重要的概念之一。
(6)一些语言设计者认为面向对象的程序设计本身并不足以方便解决所有形式的程序问题，提倡将不同的方法组合成“多形程序设计语言”。

四、对象的使用

下面让我们以电灯泡为例：

在这个例子中，类型／类的名称是 Light，可向 Light 对象发出的请求包括包括打开（ on）、关闭（ off）、变得更明亮（ brighten ）或者变得更暗淡（ dim）。通过简单地声明一个名字（ lt），我们为 Light 对象创建了一个“句柄”。然后用 new 关键字新建类型为 Light 的一个对象。再用等号将其赋给句柄。为了向对象发送一条消息，我们列出句柄名（ lt），再用一个句点符号（ .）把它同消息名称（ on）连接起来。从中可以看出，使用一些预先定义好的类时，我们在程序里采用的代码是非常简单和直观的。

五、封装

封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问权限来使用类的成员。隐藏之后，外部程序就不能接触和改变那些细节，所以不用担心自己的类会受到非法修改，可确保它们不会对其他程序造成影响。

封装的原则：

1. 将不需要对外提供的内容都隐藏起来；

2. 把属性都隐藏，提供公共方法对其访问。

简单示例代码：

package com.alanlee;

public class Student {

 //属性私有化，避免属性被直接使用和修改
 private Integer age;

 //对外提供公有的方法用来获取对象的属性值
 public Integer getAge() {
  return age;
 }

 //对外提供公有的方法，可以对对象的属性进行控制，避免不合法的操作
 public void setAge(Integer age) {
  if(age > 0 && age < 100){
   this.age =age;
  }else{
   System.out.println("输入的年龄不合法！");
  }
 }

 public static void main(String[] args) {
  Student stu = new Student();
  //赋值
  stu.setAge(10);
  //取值并打印
  System.out.println(stu.getAge());
 }
}

六、继承

我们费尽心思做出一种数据类型后，假如不得不又新建一种类型，令其实现大致相同的功能，那会是一件非常令人灰心的事情。但若能利用现成的数据类型，对其进行“克隆”，再根据情况进行添加和修改，情况就显得理想多了。“继承”正是针对这个目标而设计的。但继承并不完全等价于克隆。在继承过程中，若原始类（正式名称叫作基础类、超类或父类）发生了变化，修改过的“克隆”类（正式名称叫作继承类或者子类）也会反映出这种变化。在 Java 语言中，继承是通过 extends 关键字实现的。

使用继承时，相当于创建了一个新类。这个新类不仅包含了现有类型的所有成员（尽管private 成员被隐藏起来，且不能访问），但更重要的是，它复制了基础类的接口。也就是说，可向基础类的对象发送的所有消息亦可原样发给衍生类的对象。根据可以发送的消息，我们能知道类的类型。这意味着衍生类具有与基础类相同的类型！为真正理解面向对象程序设计的含义，首先必须认识到这种类型的等价关系。

由于基础类和衍生类具有相同的接口，所以那个接口必须进行特殊的设计。也就是说，对象接收到一条特定的消息后，必须有一个“方法”能够执行。若只是简单地继承一个类，并不做其他任何事情，来自基础类接口的方法就会直接照搬到衍生类。这意味着衍生类的对象不仅有相同的类型，也有同样的行为，这一后果通常是我们不愿见到的。

有两种做法可将新得的衍生类与原来的基础类区分开。第一种做法十分简单：为衍生类添加新函数（功能）。这些新函数并非基础类接口的一部分。进行这种处理时，一般都是意识到基础类不能满足我们的要求，所以需要添加更多的函数。这是一种最简单、最基本的继承用法，大多数时候都可完美地解决我们的问题(添加特定的方法，特殊的方法)。第二种做法是改变基础类一个现有函数的行为（重写父类的方法）。

简单示例代码：

public class Animal {
 private String name;
 private int id;
 public Animal(String myName, int myid) {
  name = myName;
  id = myid;
 }
 public void eat(){
  System.out.println(name+"正在吃");
 }
 public void sleep(){
  System.out.println(name+"正在睡");
 }
 public void introduction() {
  System.out.println("大家好！我是"   + id + "号" + name + ".");
 }
}

public class Penguin extends Animal { 
  public Penguin(String myName, int myid) { 
   super(myName, myid); 
  } 
 }

 public class Mouse extends Animal { 
  public Mouse(String myName, int myid) { 
   super(myName, myid); 
  } 
 }

Java是单继承的，一个类只能继承一个父类。

七、多态

多态是同一个行为具有多个不同表现形式或形态的能力，多态就是同一个接口，使用不同的实例而执行不同操作，多态性是对象多种表现形式的体现。

多态的优点：

• 1. 消除类型之间的耦合关系
• 2. 可替换性
• 3. 可扩充性
• 4. 接口性
• 5. 灵活性
• 6. 简化性

多态存在的三个必要条件：

• 继承
• 重写
• 父类引用指向子类对象

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

简单示例代码：

public class Test {
 public static void main(String[] args) {
  show(new Cat()); // 以 Cat 对象调用 show 方法
  show(new Dog()); // 以 Dog 对象调用 show 方法

  Animal a = new Cat(); // 向上转型
  a.eat();    // 调用的是 Cat 的 eat
  Cat c = (Cat)a;  // 向下转型
  c.work();  // 调用的是 Cat 的 catchMouse
 }

 public static void show(Animal a) {
  a.eat();
  // 类型判断
  if (a instanceof Cat) { // 猫做的事情
   Cat c = (Cat)a;
   c.work();
  } else if (a instanceof Dog) { // 狗做的事情
   Dog c = (Dog)a;
   c.work();
  }
 }
}

abstract class Animal {
 abstract void eat();
}

class Cat extends Animal {
 public void eat() {
  System.out.println("吃鱼");
 }
 public void work() {
  System.out.println("抓老鼠");
 }
}

class Dog extends Animal {
 public void eat() {
  System.out.println("吃骨头");
 }
 public void work() {
  System.out.println("看家");
 }
}

八、抽象类

设计程序时，我们经常都希望基础类只为自己的衍生类提供一个接口。也就是说，我们不想其他任何人实际创建基础类的一个对象，只对上溯造型成它，以便使用它们的接口。为达到这个目的，需要把那个类变成“抽象”的—— 使用 abstract 关键字。若有人试图创建抽象类的一个对象，编译器就会阻止他们。这种工具可有效强制实行一种特殊的设计。

亦可用 abstract 关键字描述一个尚未实现的方法—— 作为一个“根”使用，指出：“这是适用于从这个类继承的所有类型的一个接口函数，但目前尚没有对它进行任何形式的实现。”抽象方法也许只能在一个抽象类里创建。继承了一个类后，那个方法就必须实现，否则继承的类也会变成“抽象”类。通过创建一个抽象方法，我们可以将一个方法置入接口中，不必再为那个方法提供可能毫无意义的主体代码。

interface（接口）关键字将抽象类的概念更延伸了一步，它完全禁止了所有的函数定义。“接口”是一种相当有效和常用的工具。另外如果自己愿意，亦可将多个接口都合并到一起（不能从多个普通 class 或abstract class 中继承）。比如上面的示例代码就将父类以及父类的方法进行了抽象，因为父类并不需要做任何实际的事情。

九、对象在哪里

对象保存在内存堆。一种常规用途的内存池（也在 RAM 区域），其中保存了 Java 对象。和堆栈不同，“内存堆”或“堆”（ Heap）最吸引人的地方在于编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间。因此，用堆保存数据时会得到更大的灵活性。要求创建一个对象时，只需用new 命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存。当然，为达到这种灵活性，必然会付出一定的代价：在堆里分配存储空间时会花掉更长的时间。

到此这篇关于浅谈Java实现面向对象编程java oop的文章就介绍到这了,更多相关Java实现面向对象编程内容请搜索自学编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持自学编程网！