Java面向对象设计

对象是什么？

对象是相关状态和行为的软件包。软件对象通常用于模拟在日常生活中发现的真实世界对象。本课解释如何在对象中表示状态和行为，介绍数据封装的概念，并解释以这种方式设计软件的好处。

类是什么？

类是创建对象的蓝图或原型。这个部分定义了一个模型化真实世界对象的状态和行为的类。 它有意地专注于基础，显示一个简单的类如何干净地建模状态和行为。

继承是什么？

继承提供了一个强大和自然的机制来组织和结构化软件。本节介绍类如何从其父类继承状态和行为，并解释如何使用Java编程语言提供的简单语法从另一个类派生一个类。

接口是什么？

接口是类和外部世界之间的契约。当一个类实现一个接口时，它承诺提供由该接口发布的行为。本节定义一个简单的接口，并解释实现它的任何类的必要的更改。

包是什么？

包是以逻辑方式组织类和接口的命名空间。将代码放入包中使得大型软件项目更容易管理。 本节解释为什么包是这么有用，并介绍由Java平台提供的应用程序编程接口(API)。

类是定义对象的数据字段和方法的模板，蓝图或约定。对象是类的实例。一个类可以创建多个实例。Java类使用变量来定义数据字段和方法来定义操作。此外，类提供了一种特殊类型的方法，称为构造函数，调用它们来创建一个新对象。构造函数可以执行任何操作，但构造函数一般设计为执行初始化操作，例如：初始化对象的数据字段。
参考以下图，类可被实例化为一个个的对象 -

对象由属性和方法组成。 属性是定义对象的特征; 属性中包含的值将同一个类的对象区分开来。为了更好地理解这一点，以手机(Mobile)作为一个对象。手机(Mobile)具有像模型，制造商，成本，操作系统等特性。因此，如果创建“华为”手机对象和“IPhone”手机对象，它们的特性是不一样的，因此每个对象是不一样的。对象的属性的值也称为对象的状态。

Java面向对象编程有三个主要特点。

1. 封装

2. 继承

3. 多态性

我们对上面每个特性作更详细讨论和学习。

封装

封装意味着将所有变量(实例变量)和方法放在一个称为类的单元中，在对象内隐藏数据和方法。 封装提供了保证数据和方法免于被意外更改的安全性。程序员有时将封装称为使用“黑盒”，或者可以使用而不考虑内部实现机制。 程序员可以访问和使用黑盒中包含的方法和数据，但不能更改它们。下面示例显示了Mobile类和属性，在使用构造函数参数创建对象时设置一次对象信息。可以使用具有公共(public)访问修饰符的getXXX()方法来访问属性。

package oopsconcept;  public class Mobile {     
    private String manufacturer;  
    private String operating_system;  
    public String model;  
    private int cost;  
    //Constructor to set properties/characteristics of object  
    Mobile(String man, String o,String m, int c){  
        this.manufacturer = man;  
        this.operating_system=o;  
        this.model=m;  
        this.cost=c;  
    }  
    //Method to get access Model property of Object  
    public String getModel(){  
        return this.model;  
    }  
    // We can add other method to get access to other properties  }Java

继承

面向对象程序的一个重要特性是继承 - 创建一个新类时共享现有类的属性和方法。继承主要用于代码可重用性。所以利用已有的类并作进一步扩展即可。这就是提高代码的可重用性的一种办法。一般来说，一个定义可以告诉从已有的类派生一个新类，这种实现称为继承。可以查看下面的继承概念示例。这里已有上面的步中创建的Mobile类，它被其他特定类如：Android类和Blackberry类扩展。

Android.java 代码如下 -

package oopsconcept;  public class Android extends Mobile{  
        //Constructor to set properties/characteristics of object  
        Android(String man, String o,String m, int c){  
                super(man, o, m, c);  
            }  
        //Method to get access Model property of Object  
        public String getModel(){  
            return "This is Android Mobile- " + model;  
        }  }Java

Blackberry.java 代码如下 -

package oopsconcept;  public class Blackberry extends Mobile{  
    //Constructor to set properties/characteristics of object  
    Blackberry(String man, String o,String m, int c){  
                    super(man, o, m, c);  
                }  
    public String getModel(){  
        return "This is Blackberry-"+ model;  
    }  }Java

多态性

在Java核心中，多态(Polymorphism)是一个容易理解的概念。 多态性定义是：Poly表示许多，morphos表示形式。它描述了允许在基于上下文的不同情况下正确解释相同字或符号的语言的特征。在Java中有两种类型的多态性。 例如，在英语中，动词“run”表示不同的东西，如果在“足迹”，“商业”或“电脑”这个东西关联。那么理解“run”的含义应该是基于与它使用的其他词。面向对象的程序可编写使用相同名称的方法，但在不同的上下文中执行不同的工作。 Java提供了两种实现多态的方法。

1. 静态多态性(编译时多态性/方法重载)：
通过改变方法名称和参数来执行不同方法实现的能力被称为方法重载。在下面的程序中，有三个打印(print())方法，每个方法有不同的参数。当要正确重载一个方法时，可以调用它提供不同的参数列表，并执行相应的方法版本。

package oopsconcept;  class Overloadsample {  
    public void print(String s){  
        System.out.println("First Method with only String- "+ s);  
    }  
    public void print (int i){  
        System.out.println("Second Method with only int- "+ i);  
    }  
    public void print (String s, int i){  
        System.out.println("Third Method with both- "+ s + "--" + i);  
    }  }  public class PolymDemo {  
    public static void main(String[] args) {  
        Overloadsample obj = new Overloadsample();  
        obj.print(10);  
        obj.print("Amit");  
        obj.print("Hello", 100);  
    }  }Java

执行上面代码，输出结果如下 -

2. 动态多态性(运行时多态性/方法覆盖)

当通过扩展现有类创建子类时，新子类包含在原始超类中定义的数据和方法。换句话说，任何子类对象都具有其父对象的所有属性。然而，有时，超类数据字段和方法不完全适合于子类对象; 在这些情况下可考虑覆盖父类成员。下面举个例子说明继承。

package oopsconcept;  public class OverridingDemo {  
    public static void main(String[] args) {  
        //Creating Object of SuperClass and calling getModel Method  
        Mobile m = new Mobile("Nokia", "Win8", "Lumia",10000);  
        System.out.println(m.getModel());  
        //Creating Object of Sublcass and calling getModel Method  
        Android a = new Android("Samsung", "Android", "Grand",30000);  
        System.out.println(a.getModel());  
        //Creating Object of Sublcass and calling getModel Method  
        Blackberry b = new Blackberry("BlackB", "RIM", "Curve",20000);  
        System.out.println(b.getModel());  
    }  }Java

抽象

所有编程语言都提供抽象。可以说，能够解决的问题的复杂性与抽象的种类和质量直接相关。面向对象编程的一个基本要素是抽象。人类通过抽象来管理复杂性。当你开车时，不必关心汽车的确切内部工作(除非你是一个技工)。关心的是通过其接口，如方向盘，制动踏板，加速踏板等与汽车交互。各种汽车制造商有不同的实施汽车工作，但其基本接口没有改变(即仍然使用方向盘，刹车踏板，加速踏板等与汽车互动)。 因此，对汽车的知识是抽象的。

管理抽象的强大方法是通过使用层次化分类。这允许分层复杂系统的语义，将它们分成更易于管理的部分。从外面，一辆汽车是一个单一的对象。汽车由几个子系统组成：转向，制动器，音响系统，安全带，暖气，蜂窝电话等。反过来，这些子系统中的每一个由更专门的单元组成。 例如，声音系统由无线电，CD播放器和/或磁带播放器组成。关键是通过使用分层抽象来管理汽车(或任何其他复杂系统)的复杂性。

抽象类是不完整的东西，不能创建抽象类的实例。如果想使用它，需要通过扩展它来完成或具体的实现。如果一个类不包含任何抽象方法，并且实现了所有抽象方法继承自已实现或扩展的抽象类或接口，那么它被称为具体类。顺便说一下，Java有抽象类的概念，抽象方法，但是变量不能在Java中抽象。

让我们举一个名为Vehicle的Java抽象类的例子。当创建一个类叫Vehicle，知道应该有像start()和Stop()的方法，但不知道每个车辆的启动和停止机制，因为可以有不同的启动和停止机制，例如：可以通过按按钮启动。

抽象的优点是：一个新类型的车辆只需要创建一个新类，扩展 VehicleAbstract  类并实现它的方法：启动-start()和停止-stop()方法的接口都是一样的。

package oopsconcept;public abstract class VehicleAbstract {
    public abstract void start();
    public void stop(){
        System.out.println("Stopping Vehicle in abstract class");
    }}class TwoWheeler extends VehicleAbstract{
    @Override
    public void start() {
        System.out.println("Starting Two Wheeler");        
    }    }class FourWheeler extends VehicleAbstract{
    @Override
    public void start() {
        System.out.println("Starting Four Wheeler");
    }}Java

package oopsconcept;public class VehicleTesting {
    public static void main(String[] args) {
        VehicleAbstract my2Wheeler = new TwoWheeler();
        VehicleAbstract my4Wheeler = new FourWheeler();
        my2Wheeler.start();
        my2Wheeler.stop();
        my4Wheeler.start();
        my4Wheeler.stop();
    }}Java

执行上面代码，输出结果如下 -