En C#, puede crear una variable de referencia de un tipo de interfaz o, en otras palabras, puede crear una variable de referencia de interfaz. Este tipo de variable puede referirse a cualquier objeto que implemente su interfaz. Una variable de referencia de interfaz solo conoce los métodos declarados por su declaración de interfaz. No permite acceder a otras variables o métodos que puedan ser compatibles con los objetos . Este concepto es similar cuando usa una referencia de clase principal para acceder a un objeto de clase secundaria.
A continuación se muestran los ejemplos para ilustrar el concepto de Referencias de interfaz:
Ejemplo 1:
// C# program to illustrate the
// concept of Interface References
using System;
// interface declaration
public interface Race {
// declaration of abstract methods of
// interface that will be implemented
// by the class which inherits the interface
void Speed(int s);
void Distance(int d);
}
// class implementing interface
public class Person1 : Race {
int sp1, di1;
// abstract method of
// Race interface
public void Speed(int p1s) {
sp1 = p1s;
Console.WriteLine("Speed Method implemented by Person1");
}
// abstract method of
// Race interface
public void Distance(int p1d) {
di1 = p1d;
Console.WriteLine("Distance Method implemented by Person1");
}
// method of class Person1
public void display1() {
Console.WriteLine("The Speed of 1st person is: "+sp1);
Console.WriteLine("The distance covered by 1st person is: "+di1);
}
}
// class implementing interface
public class Person2 : Race {
int sp2, di2;
// abstract method of
// Race interface
public void Speed(int p2s) {
sp2 = p2s;
Console.WriteLine("Speed Method implemented by Person2");
}
// abstract method of
// Race interface
public void Distance(int p2d) {
di2 = p2d;
Console.WriteLine("Distance Method implemented by Person2");
}
// method of class Person2
public void display2() {
Console.WriteLine("The Speed of 2nd person is: "+sp2);
Console.WriteLine("The distance covered by 2nd person is: "+di2);
}
}
// Driver Class
public class GFG {
// Main method
public static void Main(String []args) {
// creating an instance of Person1 class
Person1 obj1 = new Person1();
// creating an instance of Person2 class
Person2 obj2 = new Person2();
// creating an Reference
// of interface Race
Race r;
// ----- For Person1 Class ----------
// assigning Person1 object 'obj1'
// to interface Reference 'r'
r = obj1;
// Now you can access the abstract method
// of Race interface which are implemented
// by class Person1
r.Speed(10);
r.Distance(50);
// if you will try to call display1()
// method using 'r' it will give error
//r.display1();
// calling the display1()
// method of Person1 Class
obj1.display1();
// ----- For Person2 Class ----------
// assigning Person2 object 'obj2'
// to interface Reference 'r'
r = obj2;
// Now you can access the abstract method
// of Race interface which are implemented
// by class Person2
r.Speed(15);
r.Distance(45);
// if you will try to call display2()
// method using 'r' it will give error
//r.display2();
// calling the display1()
// method of Person1 Class
obj2.display2();
}
}
Speed Method implemented by Person1 Distance Method implemented by Person1 The Speed of 1st person is: 10 The distance covered by 1st person is: 50 Speed Method implemented by Person2 Distance Method implemented by Person2 The Speed of 2nd person is: 15 The distance covered by 2nd person is: 45
Explicación: En el ejemplo anterior, tenemos una interfaz llamada Race y dos clases Person1 y Person2 que implementan los métodos de la interfaz. La clase Person1 tiene su propio método llamado display1() y la clase Person2 similar tiene su propio método display2() al que no se puede llamar usando la referencia de la interfaz. Para llamar a los métodos usando la referencia de la interfaz (aquí r es la referencia de la interfaz), debe asignarle un objeto de clase. Como si estuviera asignando el objeto obj1 de Person1 a r , es decir , r = obj1; luego llamas a Speed()y los métodos Distance() que implementa la clase Person1 . Para llamar al método display1() , debe tener que usar obj1. De manera similar, usando r = obj2; estamos llamando a métodos de la clase Person2 .
Ejemplo 2:
// C# program to illustrate the
// concept of Interface References
using System;
// interface declaration
interface Vehicle {
// all are the abstract methods.
void changeGear(int a);
void speedUp(int a);
void applyBrakes(int a);
void printStates();
}
// class implements interface
class Bicycle : Vehicle {
int speed;
int gear;
// to change gear
public void changeGear(int newGear)
{
gear = newGear;
}
// to increase speed
public void speedUp(int increment)
{
speed = speed + increment;
}
// to decrease speed
public void applyBrakes(int decrement)
{
speed = speed - decrement;
}
public void printStates()
{
Console.WriteLine("speed: " + speed + " gear: " + gear);
}
}
// Driver Class
class GFG {
// Main Method
public static void Main(String[] args)
{
// creating an instance of Bicycle
Bicycle bicycle = new Bicycle();
// Creating interface references
Vehicle obj;
// assigning Bicycle object 'bicycle'
// to interface Reference 'obj'
obj = bicycle;
// calling the abstract methods
// implemented by class Bicycle
obj.changeGear(4);
obj.speedUp(5);
obj.applyBrakes(2);
Console.WriteLine("Bicycle Present State:");
// calling the method of class Bicycle
obj.printStates();
}
}
Bicycle Present State: speed: 3 gear: 4
Explicación: En el ejemplo anterior, Vehicle es una interfaz y la clase Bicycle implementa esta interfaz. Aquí se declara que obj es una referencia a la interfaz del vehículo en el método Main(). Ahora este obj se usa para referir el objeto bicicleta de la clase Bicicleta.
Publicación traducida automáticamente
Artículo escrito por ankita_saini y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA