Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Curso de Introducción a Java SE

Curso de Introducción a Java SE

Anahí Salgado Díaz de la Vega

Anahí Salgado Díaz de la Vega

Actualizando variables

11/39
Recursos

Java nos permite actualizar nuestras variables reutilizando los valores que tenían anteriormente, de esta forma evitamos errores o inconsistencias en nuestro código:

public class UpdatingVariable {
  public static void main(String[] args) {
    // Actualizar datos numéricos:
    int salary = 1000;
    salary = salary + 200;
    System.out.println(salary); // 1200

    salary += 300;
    System.out.println(salary); // 1500

    // Actualizar variables de tipo String:
    String employeeName = "Anahí";
    employeeName = employeeName + "Salgado";
    System.out.println(salary); // Anahí Salgado

    employeeName += "Díaz de la Vega";
    System.out.println(employeeName); // Anahí Salgado Díaz de la Vega

    employeeName = "Irene" + employeeName;
    System.out.println(employeeName); // Irene Anahí Salgado Díaz de la Vega
  }
}

Aportes 303

Preguntas 9

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Qué suerte que la profe tuviera un nombre tan compuesto para esta clase jajaja ¡quedó muy claro todo! Gracias.

salary +=  200;

Muy bien, ahora conocemos las maneras de actualizar variables numéricas y de texto o cadenas, entre las numéricas tenemos estos tres como los métodos más usados:
 
Asignando valores específicos (No es recomendable)

int salary = 1000;
salary = 1000 + 200; 
//Resultado en terminal: 1200

Asignando valores junto a la variable principal

int salary = 1000;
salary = salary +200;
//Resultado en terminal: 1200

Asignando valores con el uso del += a la variable

int salary = 1000;
salary += 200;
//Resultado en terminal: 1200

Esta última es la que te ayudara a ahorrar más líneas de código y además viene con su hermano -= ideal para reducir valores.

Wow que nombre... Me imagine la planas que nos ponían hacer de niños 😅
public class PrimeraAplicacion {
	
	public static void main(String[] args) {
		
		int salary = 1000;
		int bono = 200;
		int salarioTotal = salary + bono;
		
		System.out.println("El salario total es de " + salarioTotal + "$");
	}
}```

Una variable static es aquella que puede ser accedida desde otra clase sin necesidad de instaciar.

Aporte: otra forma que tambien se puede usar para adiconar es usando el operador +=
eso seria

String name = "Anahi"; name += " Salgado"; System.out.println(name);

int salary =1000;
//bono 200
salary=salary+200;
System.out.println(salary);

Profe, ¿si cupo todo tú nombre en la cédula o DNI?

public class UpdatingVariables {
    public static void main(String[] args) {
        int salary = 1000;
        int bono = 350;
        int total = salary+bono;
        String empleado = "Daniel";
        System.out.println("El Salario Total del empleado "+empleado+" es de "+total+".");
    }
}
public class UpdatingVariables {

    public static void main(String[] args) {

        int salary = 1000;
        System.out.println(salary);

        //Bono $200
        int bono = 200;

        salary += bono;

        System.out.println(salary);


    }
}

public class Variables {
    public static void main(String[] args) {
        String employeeName = "Nicolas Von Muhlinen";
        double salary = 160;
        System.out.println("\nSalario de " + employeeName + ": $" + salary);

        //bono=$50
        salary += 50;
        System.out.println("\nSalario+bono de " + employeeName + "= $" + salary );

        //aportes: 11%
        double aportes = 0.11;
        double resto = salary * aportes;
        double result = salary - resto;
        System.out.println("\nSalario+bono de " + employeeName + "-aportes= $" + result );
    }
}
public class UpgradeSalary {
    public static void main(String[] args) {

        int salary = 1000;
        salary += 200;
        System.out.println(salary);

        // Pension: -$50
        salary -= 50;
        System.out.println(salary);

        // 2 horas entra $30 c/u
        //comida : $45

        salary = salary + (30 * 2) - 45;
        System.out.println(salary);

        // Actualizacion de cadenas de texto
        String Name = "Victor Adrian Ramirez";
        Name += " de la Cruz";
        System.out.println(Name);
    }
}

🐱‍💻 Otorgando un bono al salario que percibe.

public static void main(String[] args) {
        int salary = 1000;
        salary += 200;
        System.out.println("Tu salario total es: " + salary);
}

geniaal

public class UpdatingVariables {

	public static void main(String[] args) {
		int salary = 1000, bono = 200;
		// bono de 200
		salary += bono;
		System.out.println(salary);
	}

}```

int salary2 = 1000;
int bono=200;
int comida=45;
int horasExtras = 30;
int descuento = 50;

    salary2=(salary2 + bono +(2*horasExtras)  ) - (comida + descuento);

    System.out.println(salary2);

Ya con las horas extra al doble

public class Main
{
public static void main(String[] args) {
int Salary=1000;
int arrayInt[];
arrayInt=new int[4];
arrayInt[0]=200;
arrayInt[1]=-50;
arrayInt[2]=30*2;
arrayInt[3]=-45;

    for(int i=0;i<4;i++)
    {
        Salary+=arrayInt[i];
    }
    
    System.out.println(Salary);
}

}

Si realizas la suma de las dos variables en el System.out.println te da 1200 pero al agregarle texto y la variable String el resultado me daba 100200 así que lo encerré en paréntesis para que me realizara la operación

Primera parte:

Resultado:

Segunda parte:

Resultado:

El += y -= también es un recurso que nos ayuda a simplificar mas

public class UpdatingVariables {
    public static void main(String[] args) {
        int salario = 1000;

        //bono de 200
        salario +=200;
        System.out.println(salario);

        //descuento 50
        salario-=50;
        System.out.println(salario);

        //2 horas extra 30
        //comida 45

        salario+=(30*2) - 45;
        System.out.println(salario);

        //actualizando cadenas de texto

        String nombreEmpleado = "Sebastian";

        nombreEmpleado = nombreEmpleado+" Obando";

        System.out.println(nombreEmpleado);

    }
}

Acá utilicé operadores para poder facilitar la tarea.

public class UpdatingVariable {
    public static void main(String[] args) {
        int salary = 1000;
        int bono = 35;
        salary += bono;
        System.out.println(salary);
        int pension = 50;
        salary -= pension;
        System.out.println(salary);
        int extraHours = 30;
        int cupon = 45;
        salary += (extraHours * 2) + 45;
        System.out.println(salary);
        String employeeName = "SanT";
        employeeName += " Chiquillo";
        System.out.println(employeeName);
        employeeName = "Martin " + employeeName;
        System.out.println(employeeName);
    }
}
Output
1035
985
1090
Felipe Chiquillo
Daniel Felipe Chiquillo

Process finished with exit code 0

Aquí mi aporte de la clase.

public class UpdatingVariables {
    public static void main(String[] arg){
        int salary = 1000;
        int bono = 200;
        int pension = 50;
        int horExtras = 2;
        int valHorExtras = 30;
        int cupon = 45;

        valHorExtras *= horExtras;
        salary += ((bono + valHorExtras) - pension - cupon);

        System.out.println(salary);

        String employeeName = "Junior Torres ";

        employeeName += "Pérez";

        employeeName = "Ricardo " + employeeName;

        System.out.println("Mi nombre es: " + employeeName);

    }
}

Muy buena clase, me encanta.

Salary = salary +200

Yo crearía 2 variables, una para su salario base, otra para la bonificación y posteriormente las sumaría

hay diferentes opciones.

  1. Crear una nueva variable para bonos y luego se suman estas dos.

int salary = 2000000;
int bono = 100;
String employeeName = “Juan Camilo”;

System.out.println(employeeName +" Gana " + salary + bono);

“Juan Camilo Gana 2000000100”

  1. Asignarle un nuevo valor a la variable utilisando el +=.

int salary = 2000000;
salary += 100;

System.out.println(salary);

“2000100”

  1. concatenar el valor que desea adicionar.

int salary = 2000000;
String employeeName = “Juan Camilo”;

System.out.println(employeeName +" Gana " + salary + 1000);

“Juan Camilo Gana 20000001000”

Yo lo que hubiera hecho para sumarle el bono al salario es simplemente agregar los 200 a la variable salario

La forma mas sencilla seria:

  • salario = salario + bono;
    esto se puede ver como:
  • salario = salario + 200;
    o tambien para que pueda verse mejor (solo para eso):
  • salario = 1000 + 200;
    esta ultima es como se desempaquetáramos el valor de la variable pero es solo para que se pueda apreciar mejor.

A mi me dio un buen resultado con este código 😅

public class UpdatingVariables {
    public static void main(String[] args) {
        int salary=1000;
        //bono 200$
        salary=salary+200;
        //imprimir
        System.out.println(salary);
    }
}

Code:

public class updatingVariables {
public static void main(String[] args) {
int salary = 1000;

    //bono $200
    salary += 200;
    System.out.println(salary);

    //pension: $50 (discount)
    salary = salary - 50;
    System.out.println(salary);

    //2 horas extra 30$ c/u
    //Food: $45

    salary = salary + (30*2) - 45;
    System.out.println(salary);

    //Upgrading text chains
    String employeeName = "Esteban Hidrobo";
    employeeName = employeeName + " Vega";
    System.out.printf("\n"+employeeName);

    employeeName = "\nAngel " + employeeName;
    System.out.printf(employeeName);


}

}

Excelente explicación; lo hizo ver muy fácil. Hasta su nombre lo ayudo. Bendiciones

Así quedaría

![](

salary += 200;


Otra forma de concatenar cadenas de texto a una varible es con el metodo concat()

public class Variables {
    public static void main(String[] args) {

//        declarando una variable
        int age = 31;   // tipo entero
        String name = "Marcos"; // tipo cadena

        System.out.println("My names is " + name + " and my age is " + age);

        name = name.concat(" Vzq");

        System.out.println(name);

    }
}

public class UpdatingVariables {
public static void main(String[] args) {
int salary = 1000;
int bono = 200;
System.out.println("su salario es: " + (salary + bono));
}
}

public class ActualizarVariable {
    public static void main(String[] args) {
        int salary = 1000;
        int bono = 200;
        int suma_total = salary + bono;
        System.out.println("El salario total es de: " + suma_total);

    }
}

Practicing updating variables 😃😃

Se podría hacer de dos formas:

salary = salary + 200;

o de esta otra forma:

salary += 200;

así fue como puse yo mis ejemplos 😄

public class UpgratingVariable {
    public static void main(String[] args) {
        //actualizar datos numéricos:
        int salary = 1000;

        //bono $200
        salary = salary + 200;
        System.out.println("nuevo salario: " + salary);

        //pension: descuento $50
        salary = salary - 50;
        System.out.println("salario después del descuento: " + salary);

        //2 horas extra $30 c/u
        //comida: $45
        salary = salary + (30 * 2) - 45;
        System.out.println("Salario con horas y extra y comida: " + salary);

        //bono de $300
        salary += 300;
        System.out.println("Nuevo salario con bono de 300: " + salary);

        //actualizar variables de tipo String
        String employeeName = "Angie";
        employeeName = employeeName + "Matiz";
        System.out.println("Nombre del empleado: " + employeeName);

        employeeName += "UwU";
        System.out.println("Usuario del empleado: " + employeeName);


    }
}

public class UpdatedVariables {
public static void main(String[] args) {
int salary = 1000;
int bono = 200;
int descuento = 50;
int horasextra = 2;
int preciohora = 30;
int cupon = 45;
String NameEmployed = “Rosangela”;
String LastEmployed = “medina”;

 //recibio un bono 200
 
 salary = ( (salary + bono) - descuento) + (horasextra*preciohora) - cupon;
 System.out.println(salary);
 
 NameEmployed = NameEmployed  + " "+ LastEmployed;
 System.out.println(NameEmployed);
}

}

public class UpdatedVariables {
public static void main(String[] args) {
int salary = 1000;
int bono = 200;
int descuento = 50;
int horasextra = 2;
int preciohora = 30;
int cupon = 45;

 //recibio un bono 200
 
 salary = ( (salary + bono) - descuento) + (horasextra*preciohora) - cupon;
 System.out.println(salary);
}

}

int bono= 200;
int total_salary= bono + salary;

Here is 😃

Tu salario es: 5500
Salario con descuento de pensión: 5450
Salario más hora extra menos bono de comida: 5465
Tu nombre es: Alan Brito
Tu nombre completo es: John Alan Brito

Process finished with exit code 0
public class UpdatingVariables {
    public static void main(String[] args) {
        int salary = 5000;

        //Bono $500
        salary = salary + 500;
        System.out.println("Tu salario es: " + salary);

        //pensión: $50 descontar
        salary = salary - 50;
        System.out.println("Salario con descuento de pensión: " + salary);

        //2 horas extra $ 35 c/u
        //Comida: $ 45

        salary = salary + (30 * 2) - 45;
        System.out.println("Salario más hora extra menos bono de comida: " + salary);

        //Actualizando cadena de texto
        String employeeName = "Alan ";
        employeeName = employeeName + "Brito";
        System.out.println("Tu nombre es: " + employeeName);

        employeeName = "John " + employeeName;
        System.out.println("Tu nombre completo es: " + employeeName);
    }

}

MIs apuntes de esta clase:

public class updatingVariables {
    public static void main(String[] args) {
        //Digamos que un trabajador gana un salario de $1000 mxn
        int salary = 1000;
        System.out.println(salary);

        //Ahora el trabajador recibe un bono de $200 mxn
        salary = salary + 200;
        System.out.println(salary);
        //Utilizando la variable ya existente, le agregamos el bono de $200
        //Haciéndolo de esta forma, si el salario original se modifica, 
        //ese valor actualizado se podrá usar en la suma del bono.

        //Ahora a nuestro trabajador se le descuentan $50 mxn por la pensión
        salary = salary - 50;
        System.out.println(salary);

        //Nuestro amigo quizo trabajar 2 horas extra porque andaba con ganas
        // cada hora extra le dan $30 mxn
        //Después de un largo día quizo irse a comer unas chimichangas
        // Las chimichangas cuestan $45 mxn
        salary = salary + (30*2) - 45;
        System.out.println(salary);

        //Actualizando cadenas de texto
        String trabajador = "Fidelio Buenrostro";
        //A Fidelio se le olvidó poner su segundo apellido
        trabajador = trabajador + " Chubaca";
        System.out.println(trabajador);
        //Listo, ya quedó agregado

        //Resulta que Fidelio nos mintió y tiene otro nombre
        trabajador = "Tirado " + trabajador;
        System.out.println(trabajador);
        //Ya tenemos el nombre completo de Fidelio

        
        
    }
    
}

Es muy importante que tomes en cuenta los espacios, el editor de código los tomará en cuenta cuando quieras unir palabras o cualquier cosa.

String myname = "Arturo";
myname = myname + "Torres";
//Aquí la variable myname dará como resultado ArturoTorres

String myname = "Arturo";
myname = myname + " Torres";
//En cmbio, aquí el resultado sería Arturo Torres

En algunos lenguaje si no es la mayoria se puede usar
int a = 0;
a++;
Que es lo mismo:
a = a + 1;

    //bono por un bun trabajo

    int bono = 200;

    // sueldo
    int salary = 1000;

    salary = salary + bono;

public class UpdatingVariables2022 {

public static void main(String[] args) {
    int salary = 1000;

    //Bono
    int bono = 200;
    salary = salary + bono;
    System.out.println(salary);
}

}

public class UpdatingVariables {
    public static void main(String[] args) {
        int salary=2500;
        System.out.println("El valor del salario es: "+salary);

        //bono de $200
        salary = salary+200;
        System.out.println("El valor del salario más el bono es: "+salary);

        //Pension $50
        salary = salary-50;
        System.out.println("El valor del salario menos el descuento para la pension es: "+salary);

        //2 horas extra a $30 USD c/u
        //1 consumo de un cupon de comida por $45 USD
        salary = salary + (2*30) - 45;
        System.out.println("El valor del salario + horas extra - descuento del bono de comida: "+salary);

        String employeeName = "Diego ";
        employeeName = employeeName + " de la Plata";

        employeeName="Juan " + employeeName;
        System.out.println("Tu nombre es: " + employeeName);


    }
}

Y si el bono es variable:

int salary = 1000;
int bono = 200;
salary = salary + bono;
System.out.println(salary);

int Bono = 200;

Mi aporte de la practica 11 de la forma clasica

salar += 200

esto para no tener que poner la suma

public class UpDatingVariables {
public static void main(String[] args) {
// Actualizar datos numéricos:
int salary = 1000;
salary = salary + 200;
System.out.println("SALARY : " + salary); // 1200

    //Bono = 300
    salary += 300;
    //salary = salary + 300;
    System.out.println("SALARY + BONO : " + salary); // 1500

    // Actualizar variables de tipo String:
    String employeeName = "Anahí ";
    employeeName = employeeName + "Salgado";
    System.out.println("EMPLOYEE NAME : " + employeeName); // Anahí Salgado

    //employeeName += " Díaz de la Vega";
    employeeName = employeeName + " Díaz de la Vega";
    System.out.println("EMPLOYEE NAME - LASTNAME: " + employeeName); // Anahí Salgado Díaz de la Vega

    employeeName = "Irene " + employeeName;
    System.out.println("FULL EMPLOYEE NAME: " + employeeName); // Irene Anahí Salgado Díaz de la Vega
}

}

Variables estaticas
del metodo main o tambien variable de clase o sea que se pueden acceder con el nombre y su alcance es mas global.

public class UpdatingVariables {
public static void main(String[] args) {
int salary = 1000;
salary +=200;
System.out.println("El nuevo salario es: " + salary);

//Asignación de varible
int salary = 1000;
//llamamos a la variable iniciarl y le agregamos la cantidad extra
//bono 200
salary+=200;

El ‘print’ tambien admite operadores! 😄

<public class UpVaribles {
    public static void main(String[] args) {
        int salary = 1000;
        int bono = 200;
        int pension = 50;

        System.out.println(salary+bono-pension);
    }
}
> 
int salary = 1000;
salary = salary + 200;
		int salary = 1000;
		
		//bono: 200$
		int bono = 200;
		
		//pension: 50$ descuento
		int pension = -50;
		
		//2 horas extras, 30$ c/u
		int horasExtras = 2*30;
		
		//comida 45$
		int comida = 45;
		
		//salario final :
		salary = salary + bono + pension + horasExtras + comida; 
		System.out.println(salary);	

Las dos formas que yo usaría para sumar a la variable salary serían:

int salary;
salary = 1000;

//Formas de sumar un valor a la variable
salary = salary + 200;
salary += 200;

Otra forma de cambiar el valor de una variable

salary += 200 ;//<-- salary = salary + 200

Del Sagrado Corazón ♥

salario = salario+200

salary = salary + 200;

public class UpdatingVariables {
public static void main(String[] args) {

    int salary = 1000;
    int bono = 200;
    int overtime = 150;
    int deduction = 50;

    String Nombre = "Camilo";
    String Apellido = "Rojas";

    int salarioTotal = salary + bono + overtime - deduction;

    System.out.println("El salario total de " + Nombre + " " +  Apellido + " es de: " + salarioTotal);
     }

}

yo agregaría una nueva variable, llamada bono, y luego cuando quiera saber cuanto es el aumento del salario… imprimiría el salario, lo pondría de esta manera, (salary+bono) por así decirlo.

Excelente clase!!

public class UpdatingVariables {
    public static void main(String[] args) {
        int salary = 1000;

        //bono $200
        salary += 200;
        System.out.println(salary);

        //pension: $50 descuento
        salary -= 50;
        System.out.println(salary);

        //2 horas extra $30 c/u
        //comida: $45

        salary = salary + (30*2) - 45;
        System.out.println(salary);

        //Actualizando cadenas de texto
        String employeeName = "Carlos";
        employeeName = employeeName + " Herrera Rojas";
        System.out.println(employeeName);

        employeeName = "Juan " + employeeName;
        System.out.println("Tu nombre es: " + employeeName);
    }


} 

En la seccion Recursos (abajo del video) Esta mal la linea 13 dentro del System.out.println() iria employeeName en ves de salary.

salary = salary = 200;

o

salary += 200;

//Bono
salary +=200;
//Pension
salary -= 50;

Love Java 💚

int salary = 1000;
int bono = 200;
salary += bono;

int descuento = 50;
salary -= descuento;

int extras = 30;
int comida = 45;

salary = salary + (extras * 2) -45;

salary = salary + 200;

Está muy bien explicado el tema, los ejemplos son perfectos para la explicación de la super profe Anahí. 💚

Ánimo, la verdad está muy bueno este curso!

public class UpdatingVariables {
public static void main(String[] args) {
int salary=1000;
int bonos =200;
int descuento=50;
int horasExtras=30;
int cantidadHoras=2;
int comida=40;
String employeeName=“anahi saldado”;
employeeName+=" Diaz de la vega";
employeeName="irene "+employeeName;
//bono de 200 pesos
salary += bonos;
//pension 50 peso descuento
salary-=descuento;

    System.out.println(salary);
    //2 horas extras 30 peso cada una
    //comida:45
    salary+=(30*2)-comida;
    System.out.println(salary);
    System.out.println(employeeName);


}

}

le puse nombre a todas las varibles ya que es una buena practica asi solo tienes ue cambiar el valor de la variable y no ir cambiando numero por numeros y tambien pueden usar += para no tener que llamar a la variable otra vez igual con -= ect

Aqui mi cod completo con ejecución

int salario = 1000;
int bono = 200;

int sueldo = salario + bono;

Yo lo deje asi

int salary = 1000;

        //bono $200
        salary += 200;
        System.out.println(salary);

        //pension: $50 descuento
        salary -= 50;
        System.out.println(salary);

        //2 horas extra $30 c/u
        //Cupón de comida: 45
        salary += (30*2) - 45;
        System.out.println(salary);
public class UpdatedingVariables {

    public static void main(String[] args) {

        int salary = 1000;
        int bono = 200;
        //bono por 200 pesos
        salary = salary + bono;
        System.out.println(salary);
        //pension $50
        int pension = 50;

        salary = salary - pension;
        System.out.println(salary);

        //2 horas extras x $30
        int hrextra = 30;
        //cupon comida $45
        int cuponCompida = 45;

        salary = salary + (hrextra * 2);
        salary = salary - cuponCompida;
        System.out.println(salary);

        //Actualizar cadenas

        String employeeName = "Daniel Mendoza";
        employeeName = employeeName + " Rodríguez";
        System.out.println(employeeName);

        employeeName = "Luis " + employeeName;
        System.out.println("Tu nombre es " + employeeName);
    }
}

<public class updatingvariables {
    public static void main(String[] args) {
        int salary = 1000;
        //bono $200
        int bono = 200;

        int total_salary = salary + bono;

        System.out.println(total_salary);
    }
}> 

Al saber el nombre completo de la instructora, mi cerebro finalizo pensando: Amén!

PREDICCION:
Entrada:

Salida:

Aquí les dejo compañeros.

public class updatingVariables {
    public static void main(String[] args){
        int salary = 1000;

        // Bono por 200
        int bono = 200;
        int salaryTotal = salary + bono;

        System.out.println("Su salario es: " + salary + " con el bono de " + bono + " asciende a: " + salaryTotal);
    }
}

Y yo que pensaba que mi nombre era largo.

lo que se podria hacer es:

int salary = 1000;
// Bono de 200

salary = salary + 200;
System.out.println(salary);

public class UpdatingVariables {
public static void main(String[] args) {
int salary = 1000;

    //bono $200
    int bono = 200;

    //descuento = $50;
    int descuento = 50;

    //2 Horas Extra c/u $30
    int numeroHorasExtra;
    numeroHorasExtra = 2;
    
    int valorHoraExtra;
    valorHoraExtra=30;
    
    int ingresoHorasExtra=numeroHorasExtra*valorHoraExtra;

    //Cupon Comida = $45
    int cuponComida;
    cuponComida=45;

    int salarioTotal;
    salarioTotal = (salary + bono + ingresoHorasExtra) - descuento - cuponComida;
    System.out.println(salarioTotal);

    //Actualizando Cadenas de Texto
    String employeeName = "Anahí Salgado";

    //Primer Nombre = Irene
    String primerNombre;
    primerNombre="Irene";

    //Agregar segundo Apellido "Diaz de la Vega"
    String segundoApellido = " Diaz de la Vega";

    //nombreCompleto = employeeName + segundoApellido
    String nombreCompleto = employeeName + segundoApellido;
    System.out.println(primerNombre + " " + nombreCompleto + " gana :" + salarioTotal);
}

}

<code> 

public class updating_variables {
    public static void main(String[] args) {
        int salary = 1000;
        int bono =200;

        salary = salary + bono;
        System.out.println(salary);
    }
}

Asi es como hice yo el mio , declarando variables multiples en horas extras .
Tambien puse nombre y apellido para que se cambie sin problemas

queria hacer una formula donde pueda poner valores no predeterminados para que sea con valores diferentes y sea mas como uno de esos programas para calcular sueldos de verdad…

Se podría de dos formas:
sueldo = salary + 200;

O también se podría:
bono = 200;
sueldo = salary + bono;

Actualizacion de variables:
💻

crear otra variable bono y después salario total es = salary + bono

int salary = 1000;
salary=salary+200;
System.out.println(salary);