and - java abstraction

Java: Setter Getter y constructor.

Question

Estoy un poco confundido sobre el uso de getter / setters y constructores (ver el código de abajo para un ejemplo)

    public class ExampleClass {

        private int value = 0; 

        public ExampleClass () {
            value = 0; 
        }

        public ExampleClass (int i) {
            this.value = i;
        }

        public int getValue() {
            return value; 
        }

        public void setValue(int val) {
            this.value = val; 
        }

        public static void main(String[] args) {     
            ExampleClass example = new ExampleClass (20);
            example.setValue(20); 
            //Both lines above do same thing - why use constructor? 
            System.out.println(example.getvalue());
        }
   }

Todo lo que he aprendido es que necesitamos captadores / configuradores para la seguridad y que también se pueden usar para cambiar o editar valores más adelante .

Mi pregunta es que si el constructor es el punto de inicialización y siempre está presente un constructor predeterminado, ¿por qué usar un constructor con parámetros para inicializar valores en lugar de getters / setters? . El uso de get y setter no proporcionaría seguridad, así como poder cambiar fácilmente los valores en cualquier etapa. Por favor aclaren este punto para mi.

Answer 1

Mi pregunta es que si el constructor es el punto de inicialización y el constructor predeterminado siempre está ahí, ¿por qué usamos el constructor con parámetros para inicializar los valores en lugar de establecer el conjunto?

Si piensa en la transición de un objeto a diferentes estados, entonces tiene sentido tener un constructor parametrizado junto con los configuradores y los captadores. Permítame tratar de poner un escenario de la vida real: piense en una clase de Empleado, un nuevo empleado se une, usted no conoce muchos detalles, pero pocos y crea el objeto de Empleado con el valor predeterminado y el valor base de sus atributos. Debe registrar al empleado en el sistema y, por lo tanto, utilizó el constructor parametrizado. Una vez que obtenga más detalles sobre el empleado, utilizará captadores y configuradores para actualizar los atributos.

Answer 2

constructor por defecto siempre está ahí

Bueno, en realidad no siempre está ahí. Un constructor predeterminado es el que proporciona el compilador (por supuesto, es un constructor sin argumentos) solo si no hay otro constructor definido en la clase

¿Por qué usamos el constructor con parámetros para inicializar valores en lugar de establecer get?

Debido a que podría haber una condición para que un objeto siempre se pueda crear solo cuando se proporcionan todos los valores en el momento de la inicialización en sí y no hay un valor predeterminado. Por lo tanto, todos los valores deben proporcionarse, de lo contrario el código no se compilará.

Considera esta clase de Book

public class Book {

    private String title;
    private String author;

    public Book(String title, String author){
        this.title = title;
        this.author = author;
    }
     //getters and setters here 
}

Considere una condición en la que se puede crear un libro solo si tiene title y author .

• No puede hacer un new Book() porque el constructor no-arg está ausente y el compilador no proporcionará uno porque un constructor ya está definido.
• Además, no puede hacer un new Book() porque nuestra condición no se cumple, ya que todos los libros requieren un título y un autor.

Esta es la condición en la que el constructor parametrizado es útil.

Answer 3

A veces no es necesario establecer todos los campos en valores específicos al momento de crear. Por ejemplo, cuando haces una matriz. Además, como ya se dijo, es más seguro cuando usas getters, no puedes obtener un puntero nulo.

Recuerde escribir el constructor predeterminado cuando haya definido el constructor con parámetros. O asegúrate de no usarlo.

Answer 4

A veces, al crear un nuevo objeto de una clase, algunos valores DEBEN proporcionarse. Por ejemplo, al conectarse a la base de datos y al crear un objeto de clase de conexión, debe proporcionar una cadena de conexión para que sepa a qué se está conectando. Crear una nueva conexión sin especificar una base de datos de destino sería bastante inútil, ¿verdad?

También, mira esto

Foo foo=new Foo(1,2,3,4,5,6,7);

y esto

Foo foo=new Foo();
foo.setP1(1);
foo.setP2(2);
foo.setP3(3);
foo.setP4(4);
foo.setP5(5);
foo.setP6(6);
foo.setP7(7);

Primero se ve mejor, ¿verdad?

Answer 5

El constructor con argumentos te hace obtener el objeto completamente construido. Si desea utilizar uno predeterminado, deberá asegurarse de que los campos se configuran con los configuradores. Durante el conjunto de alguna propiedad, suponga que se lanza la excepción, ahora tiene un objeto que no se puede utilizar. En varios casos, el setter no estaría expuesto, sino los getters. En esos casos, tener el constructor con argumentos o un constructor nombrado es la opción correcta. En pocas palabras, los captadores y definidores tienen su propia importancia en lugar de inicializar el objeto.

¿Por qué usar getters y setters?

Answer 6

Es más fácil y seguro inicializar sus variables de objeto a través de su constructor para evitar nullpointers.

Si crea una instancia de su objeto sin inicializar sus variables primero y realiza una operación de obtención en una de sus variables nulas, es posible que obtenga una excepción de puntero nulo en tiempo de ejecución porque olvidó establecer su valor manualmente.

Por otro lado, si siempre inicializa sus variables de objeto en su constructor predeterminado, tiene un riesgo muy reducido de obtener excepciones de puntero nulo durante el tiempo de ejecución porque ninguna de sus variables puede ser nula a menos que las establezca específicamente a través de un configurador (que no es recomendado).

Answer 7

Porque lo escribe utilizando un código menos, más elegante y mejor legible cuando configura los valores como parámetros en un constructor. Además, a veces algunos campos son indispensables para el objeto, por lo que un constructor de parámetros evita que el usuario cree un objeto omitiendo los campos necesarios para la funcionalidad del objeto. Uno no está "obligado" a llamar a los setters.

Answer 8

Primero, ambos métodos: Constructor y Setter son formas seguras de cambiar los atributos del objeto. Se espera que el autor de la Clase exponga o no maneras seguras de modificar una instancia.

1. El constructor predeterminado siempre se proporciona si no ha escrito uno:

   // Example of a Class with a Default Constructor 
   public class GetSet {
   
       private String value;
   
       public String getValue() {
           return value;
       }
       public void setValue(String value) {
           this.value = value;
       }
   
   
       public static void main(String[] args) {
           // Theres a implicit Default Constructor here
           // Its ok to do that
           // GetSet obj = new GetSet();
           GetSet obj = new GetSet();
       }
   
   }
   
   
   // Example of a Class without a Default Constructor 
   public class GetSet2 {
   
       public GetSet2(String value) {
           this.value = value;
       }
   
       private String value;
   
       public String getValue() {
           return value;
       }
       public void setValue(String value) {
           this.value = value;
       }
   
       public static void main(String[] args) {
           // GetSet2 obj = new GetSet2(); // compile time error
           // Default constructor is not provided, since u wrote one
       }
   
   }

2. Acerca de cuál es mejor: usar un constructor o mediante un configurador, depende de lo que quieras. Si solo modificará un atributo de un objeto existente, u puede usar el setter, o para un objeto completamente lleno, puede preferir el constructor.

    // Example of modifing an obj via Setter and Constructor
    public class GetSet3 {

        public GetSet3(String value1, String value2, String value3, String value4) {
            this.value1 = value1;
            this.value2 = value2;
            this.value3 = value3;
            this.value4 = value4;
        }

        private String value1;
        private String value2;
        private String value3;
        private String value4;


        // ... Getters and Setters



        public static void main(String[] args) {

            // Its easier to this
            GetSet3 obj;

            obj= new GetSet3("j", "a", "v", "a");

            // instead that
            // its also easy to forget or do something wrong
            // when u have a lot of attributes to set
            obj.setValue1("j");
            obj.setValue2("a");
            obj.setValue3("v");
            obj.setValue4("a");

        }
    }

Answer 9

Sólo para hacerlo más fácil. Se necesita menos código para usar un constructor que para crear un objeto y usar los configuradores.

Answer 10

esto es puramente hasta su estilo de codificación. Pero IMO, usaría constructor parametrizado:

1. Inicializar aquellos valores que no deben ser cambiados. (como parámetro de nombre de usuario para un objeto persona)

2. para inicializar esos valores, sin establecer cuáles, el objeto estará en un estado no válido.

Digamos que estás enviando parámetros de inicio de sesión a un método. Se puede utilizar en estas formas.

Login obj = new Login();
obj.setUsername("user");
obj.setPassword("pw")// what if someone commented this out, or you forget to call it


and otherway,
Login obj = new Login("user", "pw");

Si bien puede enviar el objeto de inicio de sesión justo después de configurar el nombre de usuario en el primer caso, no será válido al final de la recepción. pero el segundo método es menos propenso a los errores, porque se hace necesario pasar todos los parámetros requeridos.