void AgregarImpuesto(double impuesto){
Operaciones
}
¿Eso es un método de instancia? (Es decir sin el static ?)
Sí.
* Realizar un método de clase llamado “MostrarAuto”, que recibirá un
objeto de tipo “Auto” por parámetro y que mostrará todos los
atributos de dicho objeto.
public void MostrarAuto(Auto auto){
Codigo
}
Es esto un método de clase ?
Que diferencias hay entre un metodo de clase y de instancia ?
En mi opinión no deberías estudiar en Español ni leer tutoriales/ejercicios en Español, solo vas a conseguir acabar aprendiendo y acostumbrarte a un vocabulario tecnicista incorrecto que a la larga te va a confundir y te va a limitar en la comprensión del tecnicismo en el Idioma nativo y también el más extendido en el ámbito de la programación: el Inglés. El término "Método de clase" se podria interpretar de varias manera, como método estático, o por otro lado método de acceso privado que solo se pueda acceder a nivel de clase... asumiré que tú y el ejercicio se están refiriendo a métodos estáticos y no estáticos (o de instancia).
Respondiendo a la primera pregunta: eso que escribiste es un método de instancia. Si querías hacer hacer un método estático o "de clase" pues... a ese método le falta que le añadas el modificador
static.
Respondiendo a la segunda pregunta: un método de instancia necesita una instancia del tipo (clase, estructura) en el que fue declarado dicho método, y un método estático es un método que se puede llamar sin crear de forma explícita una instancia del tipo en el que fue declarado dicho método.
Pondré un ejemplo. Aquí tenemos una clase con ambos tipos de métodos:
public class Class1 {
public Class1() { }
public static void StaticMethod() {
Console.WriteLine("I'm a static method.");
}
public void NonStaticMethod() {
Console.WriteLine("I'm not a static method.");
}
}
Para poder llamar al método estático, lo harías de la siguienta manera, escribiendo el nombre de la clase donde se expone el miembro estático:
Class1.StaticMethod();
Para poder llamar al método no estático o de instancia, primero necesitarías crear una instancia de la clase Class1 y entonces es cuando puedes llamar al método a través de la referencia del objeto:
Class1 obj
= new Class1
();obj.NonStaticMethod();
Tiene que ver con el static y con el modificar de acceso a tal metodo (public, priv, ext, int, prot)?)
Los modificadores de acceso como
public,
private,
protected o
internal no tienen que ver con el modificador
static, son un tema aparte, los modificadores de acceso determinan que el miembro sea accesible a nivel de clase, de clase heredada, o de ensamblado. Los modificadores de acceso son combinables con el modificador "static". Por poner un ejemplo: un método puede ser estático y de acceso privado al mismo tiempo.
* Sobrecargar su constructor para poder instanciar objetos pasándole como parámetros:
i. La marca y el color (primera sobrecarga)
ii. La marca, color y el precio (segunda sobrecarga).
iii. Y tres sobrecargas más, de las cuales dos deben tener como parámetro la fecha.
Este punto no se ni por donde arrancarlo. Instanciar objetos sería "crear objetos" por lo que tengo entendido, pasandoselo como parámetros al constructor pero lo que no me queda claro es la parte de Sobrecargar su constructor, como modifico la sobrecarga a medida que corre el programa. Si me pueden dar una explicacion/tip/codigo para entender el funcionamiento de la sobrecarga del constructor sería excelente.
Está mal explicado eso de "un constructor para poder instanciar objetos", deja mucho margen a la libre interpretación. Yo no seguiría leyendo esos ejercicios en Español, ya te di mi consejo.
Las sobrecargas no se modifican o añaden en tiempo de ejecución, se declaran en tiempo de diseño. Un ejemplo de sobrecargas para un constructor de clase:
public sealed class Producto {
public string Nombre { get; set; }
public string Marca { get; set; }
public Color Color { get; set; }
public double Precio { get; set; }
public DateTime Fecha { get; set; }
public Producto() :
this(string.Empty,
string.Empty, Color
.Empty,
new double(),
new DateTime
()) {}
public Producto(string nombre) :
this(nombre,
string.Empty, Color
.Empty,
new double(),
new DateTime
()) {}
public Producto(string nombre, string marca) :
this(nombre, marca, Color
.Empty,
new double(),
new DateTime
()) {}
public Producto(string nombre, string marca, Color color) :
this(nombre, marca, color,
new double(),
new DateTime
()) {}
public Producto(string nombre, string marca, Color color, double precio) :
this(nombre, marca, color, precio,
new DateTime
()) {}
public Producto(string nombre, string marca, Color color, double precio, DateTime fecha) {
this.Nombre = nombre;
this.Marca = marca;
this.Color = color;
this.Precio = precio;
this.Fecha = fecha;
}
}
Por lo general, la finalidad de añadir sobrecargas (a cualquier tipo de miembro sobrecargable) es que las sobrecargas se limiten a adaptar (que no evaluar) los argumentos pasados a dicha sobrecarga para enviárselos a otra sobrecarga, la "principal", que es la que desempeñará el trabajo de verdad (y evaluará los argumentos pasados por la sobrecarga). Lo que puedes ver en el código de ejemplo que puse arriba, vaya, sería un ejemplo muy reducido. Hacer lo contrario se consideraría mal hábito de programación, tener sobrecargas y que cada una de ellas haga cosas diferentes dentro de cada bloque del método de la sobrecarga podría resultar en un código espagueti...
Saludos.
Autor
En línea
