Java面向对象编程概念

sojson将通过示例帮助您了解Java OOP的概念。让我们讨论一下面向对象编程的特点是什么。编写面向对象的程序涉及创建类、从这些类创建对象以及创建应用程序，应用程序是使用这些对象的独立可执行程序。

介绍

类是一个模板、蓝图或契约，它定义了对象的数据字段和方法。对象是类的实例。您可以创建一个类的多个实例。 Java 类使用变量来定义数据字段，使用方法来定义操作。此外，类提供了一种特殊类型的方法，称为构造函数，调用这些方法可以创建新对象。构造函数可以执行任何操作，但构造函数旨在执行初始化操作，例如初始化对象的数据字段。

对象由属性和方法组成。属性是定义对象的特征；属性中包含的值将同一类的对象彼此区分开来。为了更好地理解这一点，我们以 Mobile 作为对象为例。移动设备具有型号、制造商、成本、操作系统等特征。因此，如果我们创建“三星”移动对象和“iPhone”移动对象，我们可以通过特征来区分它们。对象的属性值也称为对象的状态。

OOPS 具有三个主要特征

1）封装

2）继承

3）多态性

让我们详细讨论一下这些功能。

封装

封装意味着将所有变量（实例变量）和方法放在一个称为类的单元中。它还意味着隐藏对象内的数据和方法。封装提供了保证数据和方法免受意外更改的安全性。程序员有时将封装称为使用“黑匣子”，或无需考虑内部机制即可使用的设备。程序员可以访问和使用黑匣子中包含的方法和数据，但不能更改它们。下面的示例显示了具有属性的 Mobile 类，可以在使用构造函数参数创建对象时设置一次。可以使用具有公共访问修饰符的 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
}jjic

继承

面向对象程序的一个重要特征是继承——创建共享现有类的属性和方法的类的能力，但具有更具体的功能。继承主要用于代码的可重用性。因此，您正在利用已经编写的类并进一步扩展它。这就是我们讨论代码可重用性这一概念的原因。在一般的一行定义中，我们可以看出从现有类派生一个新类，这称为继承。您可以查看以下示例以了解继承概念。这里我们有由其他特定类（如 Android 和 Blackberry）扩展的 Mobile 类。

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;
		}
}

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;
	}
}

多态性

在Core中，Java多态性是一个容易理解的概念之一。多态性的定义是，Poly 表示许多，morphos 表示形式。它描述了语言的特征，即允许根据上下文在不同情况下正确解释相同的单词或符号。 Java 中有两种类型的多态性。例如，在英语中，动词“跑步”如果与“赛跑”、“商业”或“计算机”一起使用，则意味着不同的含义。您可以根据与“跑”一起使用的其他单词来理解“跑”的含义。编写面向对象的程序时，具有相同名称的方法在不同的上下文中会有不同的工作方式。 Java提供了两种方式来实现多态性。

静态多态性（编译时多态性/方法重载）：

通过更改与方法名称一起使用的参数来执行不同方法实现的能力称为方法重载。在下面的程序中，我们有三个打印方法，每个方法都有不同的参数。当您正确重载方法时，您可以调用它并提供不同的参数列表，并且执行该方法的适当版本。

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);
	}
}

动态多态性（运行时多态性/方法重写）

当您通过扩展现有类来创建子类时，新的子类包含原始超类中定义的数据和方法。换句话说，任何子类对象都具有其父类的所有属性。然而，有时，超类的数据字段和方法并不完全适合子类对象；在这些情况下，您希望重写父类成员。让我们以继承解释中使用的示例为例。

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());
	}
}

抽象

所有编程语言都提供抽象。可以说，您能够解决的问题的复杂性与抽象的种类和质量直接相关。面向对象编程的一个基本元素是抽象。人类通过抽象来管理复杂性。当您驾驶汽车时，您不必关心汽车的确切内部工作情况（除非您是机械师）。你关心的是通过方向盘、刹车踏板、油门踏板等接口与你的汽车进行交互。不同的汽车制造商对汽车工作有不同的实现，但其基本接口没有改变（即你仍然使用方向盘）、制动踏板、油门踏板等与您的汽车互动）。因此，您对汽车的了解是抽象的。

管理抽象的一种有效方法是使用层次分类。这允许您对复杂系统的语义进行分层，将它们分解成更易于管理的部分。从外部看，汽车是一个单一的物体。进入车内，您会看到汽车由多个子系统组成：转向、制动、音响系统、安全带、暖气、手机等。反过来，每个子系统又由更专业的单元组成。例如，音响系统由收音机、CD播放器和/或磁带播放器组成。关键是您可以通过使用分层抽象来管理汽车（或任何其他复杂系统）的复杂性。

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

让我们以名为 Vehicle 的 Java 抽象类为例。当我创建一个名为 Vehicle 的类时，我知道应该有像 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");		
w	}	
}
class FourWheeler extends VehicleAbstract{
	@Override
	public void start() {
		System.out.println("Starting Four Wheeler");
	}
}

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();
	}
}