Java的面向对象 (对象,类,封装,继承,多态性,抽象,组合)

作者: Arvin Chen 分类: Java 来源: Break易站(www.breakyizhan.com)

面向对象概念

是相对于面向过程而言,过程其实就是函数,对象是将函数和属性进行了封装。

  1. 将复杂的事情简单化。
  2. 面对对象将一切的过程中的执行者,变成了指挥者
  3. 面向对象思想符合人们思考习惯的一种思想

面向对象和面向过程的区别

  • 面向过程:事物比较简单,可以用线性的思维去解决
  • 面向对象:事物比较复杂,使用简单的线性思维无法解决
  • 共同点:都是解决实际问题的一种思维方式。解决复杂问题,通过面向对象方式便于我们从宏观上把握事物之间的复杂关系,方便我们分析整个系统;具体到微观操作,仍然使用面向过程方式来处理

Java中的面向对象

对象表示真实的单词实体,如:笔,椅子,表等。面向对象编程是一种使用类和对象来设计程序的方法或模式。它通过提供一些概念简化了软件开发和维护:

  • 对象
  • 继承
  • 多态性
  • 抽象(Java的接口和抽象类)
  • 封装
  • 组合

Java中的面向对象(Object Oriented)是一种新兴的程序设计方法,或者是一种新的程序设计规范(paradigm),其基本思想是使用对象、类、继承、封装、多态等基本概念来进行程序设计。从现实世界中客观存在的事物(即对象)出发来构造软件系统,并且在系统构造中尽可能运用人类的自然思维方式。

Java中的对象

Java中的对象在前面的文章:Java中的类和对象 也有详细说明,这里再对Java的对象进行回顾与说明。

Java中的对象它是面向对象编程的基本单元,代表了真实的生活实体。一个典型的Java程序会创建许多对象,如您所知,通过调用方法进行交互。一个对象包括:

  1. 状态:它由对象的属性表示。它也反映了对象的属性。
  2. 行为:它由对象的方法表示。它也反映了对象与其他对象的响应。
  3. 身份:它为一个对象提供一个唯一的名称,并使一个对象与其他对象交互。

一个物体的例子:狗

Java中的类和对象

对象对应于现实世界中发现的事物。例如,图形程序可能具有诸如“圆形”,“方形”,“菜单”之类的对象。在线购物系统可能具有诸如“购物车”,“顾客”和“产品”之类的对象。

声明对象(也称为实例化类)

当一个类的对象被创建时,这个类被说成是实例化的。所有实例共享类的属性和行为。但是这些属性的值,即状态对每个对象都是唯一的。单个类可以有任意数量的实例。

示例:

Java中的类和对象

当我们声明像(type name;)这样的变量时。这会通知编译器,我们将使用name来引用类型为type的数据。对于原始变量,此声明还为变量保留适当的内存量。所以对于引用变量,类型必须严格是具体的类名。一般来说,我们不能创建抽象类或接口的对象。

Dog tuffy;

如果我们像这样声明引用变量(tuffy),那么它的值将是未确定的(null),直到实际创建并分配一个对象为止。简单地声明一个引用变量不会创建一个对象。

初始化一个对象

新运算符通过为新对象分配内存并返回对该内存的引用来实例化类。新的操作符也调用类的构造函数。

// Class Declaration

public class Dog
{
    // Instance Variables
    String name;
    String breed;
    int age;
    String color;

    // Constructor Declaration of Class
    public Dog(String name, String breed,
                   int age, String color)
    {
        this.name = name;
        this.breed = breed;
        this.age = age;
        this.color = color;
    }

    // method 1
    public String getName()
    {
        return name;
    }

    // method 2
    public String getBreed()
    {
        return breed;
    }

    // method 3
    public int getAge()
    {
        return age;
    }

    // method 4
    public String getColor()
    {
        return color;
    }

    @Override
    public String toString()
    {
        return("Hi my name is "+ this.getName()+
               ".\nMy breed,age and color are " +
               this.getBreed()+"," + this.getAge()+
               ","+ this.getColor());
    }

    public static void main(String[] args)
    {
        Dog tuffy = new Dog("tuffy","papillon", 5, "white");
        System.out.println(tuffy.toString());
    }
}

输出:

Hi my name is tuffy.
My breed,age and color are papillon,5,white
  • 这个类包含一个构造函数。我们可以识别构造函数,因为它的声明使用与类相同的名称,并且它没有返回类型。Java编译器根据参数的数量和类型区分构造函数。Dog类中的构造函数有四个参数。以下语句为这些参数提供“tuffy”,“papillon”,5,“white”作为值:
    Dog tuffy = new Dog("tuffy","papillon",5, "white");

    执行此语句的结果可以表示为:
    Java中的类和对象

注意:所有类都至少有一个构造函数。如果一个类没有显式声明任何东西,Java编译器会自动提供一个无参的构造函数,也称为默认构造函数。这个默认构造函数调用父类的无参数构造函数(因为它只包含一个语句,即super();),或者如果该类没有其他父类,则为Object类构造函数(因为Object类是所有类的父类,直接或间接)。

Java中的类

类是对某一类事物的描述,是抽象的、概念上的意义,对象是实际存在的该类事物的每一个个体,也被称为实例。对于生活中的类可以分为狗类,而一只哈士奇的小狗,就是一个对象,哈士奇的小狗属于狗类。类是具有相同属性和方法的一组对象的集合,它为属于该类的所有对象提供了统一的抽象描述,其内部包括属性和方法两个主要部分。在面向对象的编程语言中,类是一个独立的程序单位,它应该有一个类名并包括属性和方法两个主要部分。更多可以参照:Java中的类和对象

Java中的类实现包括两个部分:类声明和类体。

类声明

[public][abstract|final] class className [extends superclassName] [implements interfaceNameList]{……}

其中,修饰符public,abstract,final 说明了类的属性,className为类名,superclassName为类的父类的名字,interfaceNameList为类所实现的接口列表。

类体

class className{
[public | protected | private ] [static] [final] [transient] [volatile] type variableName;//成员变量
[public | protected | private ] [static] [final | abstract] [native] [synchronized] returnType methodName([paramList]) [throws exceptionList]{
statements
}//成员方法
}

成员变量限定词的含义:

  • static: 静态变量(类变量)
  • final: 常量;transient: 暂时性变量,用于对象存档,用于对象的串行化
  • volatile: 贡献变量,用于并发线程的共享

方法的实现也包括两部分内容:方法声明和方法体。

方法声明

方法声明中的限定词的含义:

  • static: 类方法,可通过类名直接调用
  • abstract: 抽象方法,没有方法体
  • final: 方法不能被重写
  • native: 集成其它语言的代码
  • synchronized: 控制多个并发线程的访问

方法声明包括方法名、返回类型和外部参数。其中参数的类型可以是简单数据类型,也可以是复合数据类型(又称引用数据类型)。
对于简单数据类型来说,java实现的是值传递,方法接收参数的值,但不能改变这些参数的值。如果要改变参数的值,则用引用数据类型,因为引用数据类型传递给方法的是数据在内存中的地址,方法中对数据的操作可以改变数据的值。

方法体

方法体是对方法的实现,它包括局部变量的声明以及所有合法的Java指令。方法体中声明的局部变量的作用域在该方法内部。若局部变量与类的成员变量同名,则类的成员变量被隐藏。
为了区别参数和类的成员变量,我们必须使用this。this用在一个方法中引用当前对象,它的值是调用该方法的对象。返回值须与返回类型一致,或者完全相同,或是其子类。当返回类型是接口时,返回值必须实现该接口。

构造方法

  • 构造方法是一个特殊的方法。Java 中的每个类都有构造方法,用来初始化该类的一个对象。
  • 构造方法具有和类名相同的名称,而且不返回任何数据类型。
  • 重载经常用于构造方法。
  • 构造方法只能由new运算符调用

Java中的抽象(Java的接口和抽象类)

数据抽象是仅凭基本细节显示给用户的。微不足道的或非必需的单位不显示给用户。例如:一辆汽车被视为一辆汽车而不是其各个部件。

数据抽象也可以被定义为只识别忽略不相关细节的对象的所需特征的过程。对象的属性和行为将其与其他类似类型的对象区分开来,并且还有助于对对象进行分类/分组。

考虑一个驾驶汽车的人的真实例子。该名男子只知道按下加速器会提高车速或应用刹车会停止车辆,但他不知道如何按下加速器时速度实际上正在增加,他不知道汽车的内部机制或在汽车中实施加速器,刹车等。这是抽象。

在java中,抽象是通过接口和抽象类来实现的。我们可以使用接口实现100%的抽象。对于Java抽象,请仔细阅读:Java中的抽象 章节,加深对Java抽象的理解。

Java中的接口

接口(英文:Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。

接口并不是类,编写接口的方式和类很相似,但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类,否则该类要定义接口中的所有方法。

接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。另外,在 Java 中,接口类型可用来声明一个变量,他们可以成为一个空指针,或是被绑定在一个以此接口实现的对象。对于Java中的接口,请仔细阅读:Java 接口 章节, 加深对Java接口的理解。

Java接口的实现实例

// Java接口的实现实例
// 接口.
import java.io.*;

//一个简单地接口
interface in1
{
// 公共,静态和final的变量
final int a = 10;

// 公共和抽象的方法
void display();
}

// 一个实现接口的类
class testClass implements in1
{
// 实现接口的方法
public void display()
{
System.out.println("Breakyizhan");
}

public static void main (String[] args)
{
testClass t = new testClass();
t.display();
System.out.println(a);
}
}

输出:

Breakyizhan
10

Java中的抽象类

在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。

抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。也是因为这个原因,通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法,但是由于父类本身是抽象的,所以不能使用这些方法。

在Java中抽象类表示的是一种继承关系,一个类只能继承一个抽象类,而一个类却可以实现多个接口。对于Java中的抽象类,请仔细阅读:Java中的抽象类 章节,加深对Java抽象类的理解。

Java抽象类的实例

abstract class Animal{
  private int age;
  public Animal(int age){
    this.age = age;
    System.out.println("初始化Animal");
  }
  public void move(){
    System.out.println("跑步数:"+this.age);
  }
}

abstract class Dog extends Animal{
  public Dog(int age){
    super(age);//去掉会报异常
    System.out.println("初始化Dog");
  }

}

public class BigDog extends Dog{
  public BigDog(){
    super(10);
    System.out.println("初始化BigDog");
  }

  public static void main(String[] args){
    BigDog a = new BigDog();
    a.move();
  }
}

Java中的继承

Java中的继承,在Java中的继承说得比较透彻了,当一个对象获取父对象的所有属性和行为时,称为继承。它提供代码可重用性,它用于实现运行时多态性。请仔细阅读:Java中的继承 章节,加深对Java继承的理解。
继承是面向对象的编程概念,一个对象基于另一个对象构建。继承是代码重用的机制, 被继承的类称为超类,继承超类的类称为子类。
在java中使用extends关键字来实现继承。下面是java中继承的一个简单示例。

class SuperClassA {
    public void foo(){
        System.out.println("SuperClassA");
    }

}
// 继承 SuperClassA 类
class SubClassB extends SuperClassA{

    public void bar(){
        System.out.println("SubClassB");
    }

}

public class Test {
    public static void main(String args[]){
        SubClassB a = new SubClassB();

        a.foo();
        a.bar();
    }
}

Java中的多态性

多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类,这样,不用修改源程序代码,就可以让引用变量绑定到各种不同的类实现上,从而导致该引用调用的具体方法随之改变,即不修改程序代码就可以改变程序运行时所绑定的具体代码,让程序可以选择多个运行状态,这就是多态性。

Java多态的作用

消除类型直接的耦合关系,使代码更加清晰明了。

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

 

Java多态的具体理解

简单的理解,就是用一个父类就能够引用不同的子类,这就是多态。 比如说我的一个Shape(父类),既可以是Triangle(子类),也可以是Square(子类),这样子的话,Shape呈现出了不同的形态,也是多态。

Java的多态理解

下面我们来看一个简单的例子:

Shape s = new Triangle();
s.draw();

上面的例子创建了一个指向子类的父类引用类型,调用的也是方法,会先调用父类Shape的方法,然后再是Triangle里面的方法。这是Java的一个“后期绑定”机制,只有在运行的时候,判断对象的类型,然后调用对应的方法。

创建一个指向子类的父类类型引用,该引用既可以处理父类Father对象,也可以处理子类Child对象,当相同的消息发送给子类或者父类对象时,该对象就会根据自己所属的引用而执行不同的行为,这就是多态。关于多态的实现方式:请仔细阅读:Java 多态 章节。

Java中的封装

在面向对象程式设计方法中,封装(英语:Encapsulation)是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。

封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据,必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码,而不用修改那些调用我们代码的程序片段。

适当的封装可以让程式码更容易理解与维护,也加强了程式码的安全性。

封装的优点

  1. 良好的封装能够减少耦合。
  2. 类内部的结构可以自由修改。
  3. 可以对成员变量进行更精确的控制。
  4. 隐藏信息,实现细节。

关于Java的封装,请阅读:Java中的封装章节。

Java中的组合

组合也是关联关系的一种特例,他体现的是一种contains-a的关系,这种关系比聚合更强,也称为强聚合。

先看一段代码:


public class Nose {
private Eye eye = new Eye(); //一个人有鼻子有眼睛
private Nose nose = new Nose();

// ....
}

组合同样体现整体与部分间的关系,但此时整体与部分是不可分的,整体的生命周期结束也就意味着部分的生命周期结束。

就像你有鼻子有眼睛,如果你一不小心结束了生命周期,鼻子和眼睛的生命周期也会结束,而且,鼻子和眼睛不能脱离你单独存在。

只看代码,你是无法区分关联,聚合和组合的,具体是哪一种关系,只能从语义级别来区分。

同样,组合关系中,两个类额关系也是不平等的。

关于Java的组合,请阅读:Java中的关联,组合和聚合章节。

Java的面向对象相关章节

Java中的继承相关章节(Java中的继承):

Java中的封装(Java中的封装

Java中的多态(Java 多态),相关章节:

Java中的接口(Java中的接口),Java中的抽象类(Java中的抽象类),相关章节:

Java面向对象的相关概念:

  •   本文标题:Java的面向对象 (对象,类,封装,继承,多态性,抽象,组合) - Break易站
    转载请保留页面地址:https://www.breakyizhan.com/java/14736.html
      微信返利机器人
      免费:淘宝,京东,拼多多优惠券
      腾讯,爱奇艺,优酷的VIP视频免费解析,免费看
      即刻扫描二维码,添加微信机器人!

    发表笔记

    电子邮件地址不会被公开。 必填项已用*标注