前言:
现在大家对“java对象的概念是什么”大约比较珍视,你们都需要学习一些“java对象的概念是什么”的相关资讯。那么小编在网络上搜集了一些有关“java对象的概念是什么””的相关文章,希望兄弟们能喜欢,姐妹们快快来学习一下吧!面向对象编程通常被称为OOPS,是Java的主干,因为Java是一种完全面向对象的语言。Java围绕各种对象和定义良好的接口组织程序。在OOPS中有四个支柱,如下所示。这些概念目的是在程序中实现真实世界的实体。
抽象化封装继承多态
抽象是隐藏实现细节的过程,并且只向用户公开功能。在抽象方面,我们处理的是思想而不是事件。这意味着用户只知道“它做什么”,而不知道“它是如何做得”。
在Java中有两种实现抽象的方法
1.抽象类(0到100%)
2.接口(100%)
现实生活中的一个例子:一个司机会专注于汽车的功能(开始/停止->加速/中断),他/她不会对加速/制动机制的内部工作方式发牢骚。抽象就是这样运作的。
关于OOPS这一支柱,应记住以下几点:
如果一个类有一个或多个抽象方法,则类应该是抽象的。抽象类可以有构造函数、具体方法、静态方法和最终方法。类不能直接实例化抽象类。 新的 接线员。可以如下面的预标记所示:
A b = new B();子类应该覆盖父类的所有抽象方法,否则,应该用抽象关键字声明子类。例子:
// Abstract classpublic abstract class Car { public abstract void stop();} // Concrete classpublic class Honda extends Car { // Hiding implementation details @Override public void stop() { System.out.println( "Honda::Stop" ); System.out.println( "Mechanism to stop the car using break" ); }} public class Main { public static void main(String args[]) { Car obj = new Honda(); // Car object =>contents of Honda obj.stop(); // call the method }}
支柱2:封装
封装是将代码和数据封装到一个单元中的过程。
真实的例子:
由几种药物混合而成的胶囊。这些药物是给最终用户的隐藏数据。
为了在java中实现封装,请按照以下建议执行某些步骤:
将变量声明为私有变量声明SETETER和gettersto设置并获取变量值
注意:在java中封装很少有缺点,如下所示:
1.对数据的控制:我们可以在setter方法中写入逻辑,以避免存储整数的负值。这样我们就可以控制数据。
2.数据隐藏:数据成员是私有的,因此其他类无法访问数据成员。
3.易于测试:单元测试对于封装类很容易。
例子:
// A Java class which is a fully encapsulated class.public class Car{ // private variable private String name; // getter method for name public String getName() { return name; } // setter method for name public void setName(String name) { this .name = name } } // Java class to test the encapsulated class. public class Test{ public static void main(String[] args) { // creating instance of the encapsulated class Car car = new Car(); // setting value in the name member car.setName( "Honda" ); // getting value of the name member System.out.println(car.getName()); } }
支柱3:继承
继承是一个类在Java中从另一个类继承属性和方法的过程。当我们有是-a对象之间的关系。Java中的继承是通过以下方式实现的延展关键词。
现实生活的例子:
地球和火星继承了超级太阳系,太阳系继承了银河系。因此,银河系是一流的太阳系,地球和火星的超级等级。
在提出代码之前,让我们用一个通用示例来讨论继承在java应用程序中的使用。因此,考虑一个扩展Exception类的示例,以创建一个特定于应用程序的异常类,该类包含更多信息,如错误代码。例如,NullPointerException。
Java中有5种不同类型的继承,如下所示:
1.单一继承:类B使用扩展关键字继承B类
2.多级继承:C类继承B类,B类使用EXTEND关键字继承A类
3.等级继承:类B和C使用EXTEND关键字按层次顺序继承A类
4.多重继承:C类继承了A和B类,这里A和B都是超类,C只是一个子类。Java不支持多重继承,但我们可以使用接口实现。
5.混合继承:类D继承类B,C类继承A。这里,类D继承了两个超类,因此Java也不支持混合继承。
例子:
// super classclass Car { // the Car class have one field public String wheelStatus; public int noOfWheels; // the Car class has one constructor public Car(String wheelStatus, int noOfWheels) { this .wheelStatus = wheelStatus; this .noOfWheels = noOfWheels; } // the Car class has three methods public void applyBrake() { wheelStatus = "Stop" System.out.println( "Stop the car using break" ); } // toString() method to print info of Car public String toString() { return ( "No of wheels in car " + noOfWheels + "\n" + "status of the wheels " + wheelStatus); }} // sub classclass Honda extends Car { // the Honda subclass adds one more field public Boolean alloyWheel; // the Honda subclass has one constructor public Honda(String wheelStatus, int noOfWheels, Boolean alloyWheel) { // invoking super-class(Car) constructor super (wheelStatus, noOfWheels); alloyWheel = alloyWheel; } // the Honda subclass adds one more method public void setAlloyWheel(Boolean alloyWheel) { alloyWheel = alloyWheel; } // overriding toString() method of Car to print more // info @Override public String toString() { return ( super .toString() + "\nCar alloy wheel " + alloyWheel); }} // driver classpublic class Main { public static void main(String args[]) { Honda honda = new Honda( 3 , 100 , 25 ); System.out.println(honda.toString()); }}
支柱4:java的多态性
多态是以多种方式执行许多事情的能力。“多态”一词来自两个不同的希腊语单词--多态和变形。“Poly”的意思是很多,“变形”的意思是形式。所以多态意味着很多形式。在继承的情况下也可以存在多态性。根据实际实现,这些函数的行为不同。
现实生活的例子:
送货人将物品交付给用户。如果是邮递员,他会送信的。如果是送餐的男孩,他会把食物交给用户。像这样,多态性为传递函数实现了不同的方式。
有两种类型的多态性,如下所示:
1.静态或编译时多态性
2.动态或运行时多态性
静态或编译时多态性当编译器能够确定实际函数时,它被称为编译时多态编译时多态可以通过方法超载在爪哇。当类中的不同函数具有相同的名称但有不同的签名时,就称为方法重载。方法签名包含名称和方法参数。因此,重载方法有不同的参数。参数在数字或参数类型上可能有所不同。
例1:静态多态性
public class Car{ public void speed() { } public void speed(String accelerator) { } public int speed(String accelerator, int speedUp) { return carSpeed; }}
当编译器无法确定它是超类方法还是子类方法时,就会发生动态或运行时多态性。运行时间多态运行时多态是通过方法覆盖。当超类方法在子类中被重写时,它被称为方法重写。
例2:动态多态性
import java.util.Random; class DeliveryBoy { public void deliver() { System.out.println( "Delivering Item" ); } public static void main(String[] args) { DeliveryBoy deliveryBoy = getDeliveryBoy(); deliveryBoy.deliver(); } private static DeliveryBoy getDeliveryBoy() { Random random = new Random(); int number = random.nextInt( 5 ); return number % 2 == 0 ? new Postman() : new FoodDeliveryBoy(); }} class Postman extends DeliveryBoy { @Override public void deliver() { System.out.println( "Delivering Letters" ); }} class FoodDeliveryBoy extends DeliveryBoy { @Override public void deliver() { System.out.println( "Delivering Food" ); }}
输出量
Delivering Letters
标签: #java对象的概念是什么