Café y Código
PresentaciónPPT 📊

6. Variables y Convenciones: El ADN del código

Si los lenguajes fueran personas, las convenciones de nombres serían su forma de vestir. Todos hacen lo mismo —guardar datos en variables—, pero cada uno lo escribe distinto. Entenderlo te evita errores al saltar de Python a Java o de JavaScript a C#.

💡 Ruta progresiva: primero tipos de datos → luego funciones → luego una clase simple → herencia → crear objetos. Usa el selector de lenguaje y ve el mismo ejemplo escrito en 6 sabores.

¿Cómo se declara una variable? — paso a paso

La lógica siempre es nombre = valor (con tipo si el lenguaje lo exige). Aprende en orden:1. tipos → 2. métodos → 3. clase → 4. herencia → 5. instancias.

1 Tipos de datos — lo más básico

Python es dinámico: no escribes el tipo, solo nombre = valor en snake_case.

tipos.py
PYTHON
1edad = 25 # int
2precio = 19.99 # float
3nombre = "Ana" # str
4activo = True # bool
5nada = None # NoneType
6
7# constante → UPPER_SNAKE_CASE (convención)
8MAX_LIMITE = 10000

2 Métodos / Funciones

Funciones sueltas con def y snake_case. Siempre con : y indentación.

funciones.py
PYTHON
1def saludar(nombre):
2 return f"Hola {nombre}"
3
4def sumar(a, b):
5 return a + b
6
7print(saludar("Ana")) # Hola Ana
8print(sumar(2, 3)) # 5

3 POO — una clase con atributos y métodos

Clase en PascalCase, atributos y métodos en snake_case. self es la propia caja.

clase.py
PYTHON
1class CuentaBancaria: # PascalCase
2 def __init__(self):
3 self.saldo_actual = 0 # snake_case
4 self.titular = ""
5
6 def depositar(self, monto): # snake_case
7 self.saldo_actual += monto
8
9 def consultar_saldo(self):
10 return self.saldo_actual

4 Herencia

Una clase hija extiende a la base con (Padre) y usa super().

herencia.py
PYTHON
1class CuentaAhorro(CuentaBancaria): # hereda
2 def __init__(self):
3 super().__init__()
4 self.tasa_interes = 0.02
5
6 def calcular_interes(self):
7 return self.saldo_actual * self.tasa_interes

5 Crear instancias (objetos)

Instanciar es Clase() sin new. Luego llamas a sus métodos con ..

instancias.py
PYTHON
1# crear objetos
2cuenta = CuentaBancaria()
3cuenta.depositar(1000)
4print(cuenta.consultar_saldo()) # 1000
5
6ahorro = CuentaAhorro()
7ahorro.depositar(1000)
8print(ahorro.calcular_interes()) # 20.0

PEP 8: todo en snake_case excepto clases. Si ves saldoActual en Python, es code smell.

1 Tipos de datos

Java es estático: debes decir tipo nombre = valor; en camelCase.

Tipos.java
JAVA
1int edad = 25;
2double precio = 19.99;
3String nombre = "Ana"; // String con mayúscula
4boolean activo = true;
5final int MAX_LIMITE = 10000; // constante → UPPER_SNAKE + final

2 Métodos / Funciones

Métodos siempre dentro de una clase, en camelCase. Necesitan tipo de retorno y parámetros tipados.

Metodos.java
JAVA
1public class Util {
2 // método estático → camelCase
3 public static String saludar(String nombre) {
4 return "Hola " + nombre;
5 }
6 public static int sumar(int a, int b) {
7 return a + b;
8 }
9}
10// uso: Util.saludar("Ana")

3 POO — clase con atributos y métodos

Clase en PascalCase, atributos/métodos en camelCase.

CuentaBancaria.java
JAVA
1public class CuentaBancaria { // PascalCase
2 private int saldoActual = 0; // camelCase
3 private String titular = "";
4
5 public void depositar(int monto) { // camelCase
6 saldoActual += monto;
7 }
8 public int consultarSaldo() {
9 return saldoActual;
10 }
11}

4 Herencia

Se usa extends. La hija hereda atributos y métodos de la base.

CuentaAhorro.java
JAVA
1public class CuentaAhorro extends CuentaBancaria {
2 private double tasaInteres = 0.02;
3
4 public double calcularInteres() {
5 return consultarSaldo() * tasaInteres;
6 }
7}

5 Crear instancias

Siempre con new Clase().

Main.java
JAVA
1CuentaBancaria cuenta = new CuentaBancaria();
2cuenta.depositar(1000);
3System.out.println(cuenta.consultarSaldo()); // 1000
4
5CuentaAhorro ahorro = new CuentaAhorro();
6ahorro.depositar(1000);
7System.out.println(ahorro.calcularInteres()); // 20.0

Java exige tipo + punto y coma. Olvidar ; es error inmediato.

1 Tipos de datos

Dinámico como Python, pero con let/const y camelCase.

tipos.js
JAVASCRIPT
1let edad = 25; // number
2let precio = 19.99;
3let nombre = "Ana"; // string
4let activo = true; // boolean
5let nada = null;
6const MAX_LIMITE = 10000; // constante → UPPER_SNAKE

2 Funciones

Con function o arrow =>, siempre camelCase.

funciones.js
JAVASCRIPT
1function saludar(nombre) {
2 return `Hola ${nombre}`;
3}
4function sumar(a, b) {
5 return a + b;
6}
7const saludarArrow = (nombre) => `Hola ${nombre}`;

3 POO — clase

Clase PascalCase, atributos/métodos camelCase. constructor() inicializa.

CuentaBancaria.js
JAVASCRIPT
1class CuentaBancaria { // PascalCase
2 constructor() {
3 this.saldoActual = 0; // camelCase
4 this.titular = "";
5 }
6 depositar(monto) { // camelCase
7 this.saldoActual += monto;
8 }
9 consultarSaldo() {
10 return this.saldoActual;
11 }
12}

4 Herencia

Con extends y super() igual que Java.

herencia.js
JAVASCRIPT
1class CuentaAhorro extends CuentaBancaria {
2 constructor() {
3 super();
4 this.tasaInteres = 0.02;
5 }
6 calcularInteres() {
7 return this.consultarSaldo() * this.tasaInteres;
8 }
9}

5 Crear instancias

instancias.js
JAVASCRIPT
1const cuenta = new CuentaBancaria();
2cuenta.depositar(1000);
3console.log(cuenta.consultarSaldo()); // 1000
4
5const ahorro = new CuentaAhorro();
6ahorro.depositar(1000);
7console.log(ahorro.calcularInteres()); // 20

JS = Java sin tipos. PascalCase solo para clases, resto camelCase.

1 Tipos de datos

Estático como Java, pero con string minúscula y convención mixta.

Tipos.cs
CSHARP
1int edad = 25;
2double precio = 19.99;
3string nombre = "Ana";
4bool activo = true;
5const int MAX_LIMITE = 10000; // o MaxLimite en PascalCase

2 Métodos

¡Diferencia clave! Métodos públicos en PascalCase.

Metodos.cs
CSHARP
1public class Util {
2 public static string Saludar(string nombre) { // PascalCase
3 return $"Hola {nombre}";
4 }
5 public static int Sumar(int a, int b) {
6 return a + b;
7 }
8}

3 POO — clase

Clase y métodos públicos en PascalCase, campos privados en _camelCase.

CuentaBancaria.cs
CSHARP
1public class CuentaBancaria { // PascalCase
2 private int saldoActual = 0; // o _saldoActual
3 private string titular = "";
4
5 public void Depositar(int monto) { // PascalCase
6 saldoActual += monto;
7 }
8 public int ConsultarSaldo() {
9 return saldoActual;
10 }
11 // propiedad pública → PascalCase
12 public int SaldoActual { get; set; }
13}

4 Herencia

Con : en lugar de extends.

CuentaAhorro.cs
CSHARP
1public class CuentaAhorro : CuentaBancaria { // : hereda
2 private double tasaInteres = 0.02;
3 public double CalcularInteres() {
4 return ConsultarSaldo() * tasaInteres;
5 }
6}

5 Crear instancias

Program.cs
CSHARP
1var cuenta = new CuentaBancaria();
2cuenta.Depositar(1000);
3Console.WriteLine(cuenta.ConsultarSaldo()); // 1000
4
5var ahorro = new CuentaAhorro();
6ahorro.Depositar(1000);
7Console.WriteLine(ahorro.CalcularInteres()); // 20

C# ama el PascalCase para lo público. Usa _saldoActual para lo privado.

1 Tipos de datos

Todo lleva $ y camelCase. Tipado opcional desde PHP 7.

tipos.php
PHP
1<?php
2$edad = 25; // int
3$precio = 19.99; // float
4$nombre = "Ana"; // string
5$activo = true; // bool
6const MAX_LIMITE = 10000; // constante
7?>

2 Funciones

funciones.php
PHP
1<?php
2function saludar(string $nombre): string { // camelCase, $ en params
3 return "Hola $nombre";
4}
5function sumar(int $a, int $b): int {
6 return $a + $b;
7}
8?>

3 POO — clase

Clase PascalCase, atributos/métodos camelCase con $ y $this.

CuentaBancaria.php
PHP
1<?php
2class CuentaBancaria { // PascalCase
3 private int $saldoActual = 0; // $camelCase
4 private string $titular = "";
5
6 public function depositar(int $monto): void { // camelCase
7 $this->saldoActual += $monto;
8 }
9 public function consultarSaldo(): int {
10 return $this->saldoActual;
11 }
12}
13?>

4 Herencia

CuentaAhorro.php
PHP
1<?php
2class CuentaAhorro extends CuentaBancaria {
3 private float $tasaInteres = 0.02;
4 public function calcularInteres(): float {
5 return $this->consultarSaldo() * $this->tasaInteres;
6 }
7}
8?>

5 Crear instancias

uso.php
PHP
1<?php
2$cuenta = new CuentaBancaria();
3$cuenta->depositar(1000);
4echo $cuenta->consultarSaldo(); // 1000
5
6$ahorro = new CuentaAhorro();
7$ahorro->depositar(1000);
8echo $ahorro->calcularInteres(); // 20
9?>

PHP = Java + $. Olvidar -> o $ es error inmediato.

1 Tipos de datos

Estático y con ;. Elige camelCase o snake_case y sé consistente.

tipos.cpp
CPP
1int edad = 25;
2double precio = 19.99;
3std::string nombre = "Ana";
4bool activo = true;
5const int MAX_LIMITE = 10000; // UPPER_SNAKE

2 Funciones

funciones.cpp
CPP
1#include <string>
2std::string saludar(std::string nombre) { // camelCase o snake_case
3 return "Hola " + nombre;
4}
5int sumar(int a, int b) {
6 return a + b;
7}

3 POO — clase

CuentaBancaria.cpp
CPP
1class CuentaBancaria { // PascalCase
2private:
3 int saldoActual = 0; // o saldo_actual
4 std::string titular = "";
5public:
6 void depositar(int monto) { // camelCase
7 saldoActual += monto;
8 }
9 int consultarSaldo() {
10 return saldoActual;
11 }
12};

4 Herencia

CuentaAhorro.cpp
CPP
1class CuentaAhorro : public CuentaBancaria { // : public
2private:
3 double tasaInteres = 0.02;
4public:
5 double calcularInteres() {
6 return consultarSaldo() * tasaInteres;
7 }
8};

5 Crear instancias

main.cpp
CPP
1int main() {
2 CuentaBancaria cuenta;
3 cuenta.depositar(1000);
4 // std::cout << cuenta.consultarSaldo();
5
6 CuentaAhorro ahorro;
7 ahorro.depositar(1000);
8 // ahorro.calcularInteres()
9 return 0;
10}

C++: sin new para objetos en stack. Elige un estilo y no lo mezcles.

La tabla que te salva en cualquier codebase

Guárdala. Es lo que los reclutadores revisan en segundos en tu GitHub:

LenguajeClases / InterfacesMétodos / FuncionesVariables / AtributosConstantes
PythonPascalCase
CuentaBancaria		snake_case
calcular_total()		snake_case
saldo_actual		UPPER_SNAKE
MAX_LIMITE
JavaPascalCase
CuentaBancaria		camelCase
calcularTotal()		camelCase
saldoActual		UPPER_SNAKE
MAX_LIMITE
JavaScriptPascalCase
CuentaBancaria		camelCase
calcularTotal()		camelCase
saldoActual		UPPER_SNAKE
MAX_LIMITE
C#PascalCase
CuentaBancaria		PascalCase
CalcularTotal()		camelCase
saldoActual / _saldoActual		PascalCase / UPPER_SNAKE
MaxLimite
PHPPascalCase
CuentaBancaria		camelCase
calcularTotal()		camelCase
$saldoActual		UPPER_SNAKE
MAX_LIMITE
C++PascalCase
CuentaBancaria		camelCase o snake_case
calcularTotal() / calcular_total()		camelCase o snake_case
saldoActual / saldo_actual / m_saldoActual		UPPER_SNAKE
MAX_LIMITE

Detalles clave (para no mezclar)

🐍 Python (PEP 8)

El único donde todo lo ejecutable (funciones, métodos, variables, atributos) va en snake_case. Solo las clases usan PascalCase. Si ves calcularTotal en Python, es code smell.

☕ Java

El estándar absoluto: PascalCase para clases, camelCase para todo lo demás (métodos, variables, parámetros). MAX_LIMITE siempre en mayúsculas.

🟨 JavaScript

Mismo estándar que Java. La confusión típica: usar snake_case por costumbre de Python. En JS profesional, todo es camelCase excepto clases.

🎮 C#

La gran diferencia: métodos y propiedades públicas en PascalCase (CalcularTotal(), SaldoActual { get; set; }). Lo privado usa _saldoActual.

🐘 PHP (PSR-12)

Clases PascalCase, métodos y variables camelCase con $. Olvidar el $ es error de sintaxis inmediato.

⚙️ C++

Conviven dos escuelas: Google/Qt (camelCase) y STL (snake_case). Lo importante: elige una y sé consistente en todo el archivo.

🧪 Mini reto: traduce el nombre

Tienes la variable saldo actual del usuario y el método calcular total del carrito. Escríbelos como se verían en Python vs Java:

Ver solución
Python
PYTHON
1saldo_actual_usuario = 0
2def calcular_total_carrito():
3 return saldo_actual_usuario
Java
JAVA
1int saldoActualUsuario = 0;
2int calcularTotalCarrito() {
3 return saldoActualUsuario;
4}

Pista C#: sería CalcularTotalCarrito() (PascalCase) y saldoActualUsuario o _saldoActualUsuario.

Ponte a prueba

¿Dominas el cambio de chip entre lenguajes?

Ko-fi
Donaciones
Apoyá cafeycodigo con un café en Ko-fi. Colaboradores: insignia, muro y zona exclusiva.
Ir a Ko-fi →Programa sponsors