Artigo

public e public static

Fabrício de Medeiros

1. Visibilidade de Métodos e Propriedades

public: Acessível de qualquer lugar.
protected: Acessível dentro da própria classe e por classes que estendem essa classe.
private: Acessível apenas dentro da própria classe.

2. Restrições de Tipos e Validações

Tipos de Dados: Em PHP, você pode usar declarações de tipo em parâmetros e retornos de métodos para garantir que apenas certos tipos de dados sejam aceitos.

function somar(int $a, int $b): int {
    return $a + $b;
}

Validações: É comum validar dados de entrada e saída para garantir que atendam a certos critérios.

3. Constantes e Propriedades Estáticas

Constantes: São valores fixos e imutáveis definidos com a palavra-chave const.
Propriedades Estáticas: São compartilhadas entre todas as instâncias da classe.

1. Tipos de Variáveis

Em PHP, os principais tipos de variáveis que você pode usar são:

Inteiro (int): Números inteiros.
```
$idade = 30; // int
```

Ponto Flutuante (float): Números com casas decimais.
```
$preco = 19.99; // float
```

String (string): Sequências de caracteres.
```
$nome = "Maria"; // string
```

Booleano (bool): Verdadeiro ou falso.
```
$ativo = true; // bool
```

Array (array): Coleção de valores.

$cores = ['vermelho', 'verde', 'azul']; // array

Objeto (object): Instâncias de classes.

class Carro {
    public $marca;
}
$meuCarro = new Carro(); // object

NULL (null): Representa uma variável sem valor.
```
$nada = null; // null
```

123

Em PHP, public e public static têm significados distintos e são usados em contextos diferentes. Aqui está uma explicação de cada um e quando você deve implementá-los:

`public`

Definição: Quando você declara um método ou propriedade como public, isso significa que ele pode ser acessado de qualquer lugar, tanto dentro quanto fora da classe. public é o modificador de acesso mais permissivo.
Uso: Use public para métodos e propriedades que precisam ser acessíveis a partir de instâncias da classe. Por exemplo, se você tem uma classe Pessoa e quer que o nome dela possa ser lido e alterado, você pode usar public para a propriedade nome.

class Pessoa {
    public $nome;

    public function __construct($nome) {
        $this->nome = $nome;
    }

    public function mostrarNome() {
        return $this->nome;
    }
}

$pessoa = new Pessoa("João");
echo $pessoa->mostrarNome(); // João

`public static`

Definição: Um método ou propriedade public static é associado à própria classe, em vez de a uma instância específica da classe. Isso significa que você pode acessar métodos ou propriedades static sem criar uma instância da classe.
Uso: Use public static quando você tem um método ou propriedade que não depende de dados de instância e deve ser compartilhado entre todas as instâncias da classe. Métodos static são frequentemente usados para funções auxiliares ou utilitárias que não precisam acessar ou modificar o estado da instância da classe.

class Matematica {
    public static function somar($a, $b) {
        return $a + $b;
    }
}

echo Matematica::somar(5, 10); // 15

Quando Implementar:

public: Use quando você precisa que métodos ou propriedades possam ser acessados e modificados por qualquer instância da classe ou por código fora da classe. É ideal para propriedades e métodos que definem o comportamento e o estado de objetos específicos.
public static: Use quando você precisa de um método ou propriedade que pertence à classe em si e não a uma instância específica. É útil para utilitários ou métodos que não dependem do estado da instância e precisam ser acessíveis sem criar um objeto da classe.

Exemplo Prático:

Suponha que você tenha uma classe ContaBancaria com um método que calcula a taxa de juros, que deve ser o mesmo para todas as contas. Esse método pode ser static:

class ContaBancaria {
    public $saldo;
    private static $taxaJuros = 0.05;

    public function __construct($saldo) {
        $this->saldo = $saldo;
    }

    public static function calcularJuros($valor) {
        return $valor * self::$taxaJuros;
    }
}

Aqui, calcularJuros é um método static porque a taxa de juros é uma constante para todas as contas e o método não precisa acessar dados de instância.

1. Inteiro (`int`)

Descrição: A função somar é projetada para somar dois inteiros.

Exemplo de Uso:

$a = 10;

$b = 20;

$resultado = somar($a, $b);

echo "Resultado: " . $resultado; // Resultado: 30

Neste exemplo, $a e $b são inteiros, e a função retorna a soma correta de 30.

2. Ponto Flutuante (`float`)

Descrição: Para usar a função com números de ponto flutuante, você precisa garantir que os valores sejam convertidos para inteiros antes da soma.

Exemplo de Uso:

$a = 10.5;

$b = 20.7;

$resultado = somar((int)$a, (int)$b); // Converte os floats para inteiros

echo "Resultado: " . $resultado; // Resultado: 30

Aqui, $a e $b são convertidos para inteiros antes da soma. A conversão resulta em 10 e 20, então a soma é 30.

3. String (`string`)

Descrição: Se você passar strings que representam números inteiros, PHP pode convertê-las automaticamente para inteiros.

Exemplo de Uso:

$a = "15";

$b = "25";

$resultado = somar((int)$a, (int)$b); // Converte as strings para inteiros

echo "Resultado: " . $resultado; // Resultado: 40

As strings "15" e "25" são convertidas para inteiros 15 e 25, resultando em 40.

4. Booleano (`bool`)

Descrição: O booleano é convertido para inteiro (0 para false e 1 para true) quando usado em operações aritméticas.

Exemplo de Uso:

$a = true; // equivale a 1

$b = false; // equivale a 0

$resultado = somar((int)$a, (int)$b); // Converte booleanos para inteiros

echo "Resultado: " . $resultado; // Resultado: 1

Neste caso, true é convertido para 1 e false para 0, resultando em 1.

5. Array (`array`)

Descrição: Arrays não podem ser passados diretamente para a função sem processamento. Precisamos extrair valores inteiros do array.

Exemplo de Uso:

$valores = [5, 10];

$resultado = somar($valores[0], $valores[1]); // Passa valores individuais do array

echo "Resultado: " . $resultado; // Resultado: 15

Aqui, os valores do array são passados individualmente para a função, resultando na soma de 15.

6. Objeto (`object`)

Descrição: Para objetos, é necessário acessar as propriedades ou métodos que retornam inteiros.

Exemplo de Uso:

class Valores {

public int $a;

public int $b;

public function __construct(int $a, int $b) {

$this->a = $a;

$this->b = $b;

}

$obj = new Valores(7, 8);

$resultado = somar($obj->a, $obj->b); // Acessa propriedades do objeto

echo "Resultado: " . $resultado; // Resultado: 15

Aqui, as propriedades a e b do objeto são passadas para a função somar.

7. NULL (`null`)

Descrição: null não é diretamente utilizável em operações aritméticas. Deve ser tratado ou convertido.

Exemplo de Uso:

$a = null;

$b = 5;

$resultado = somar((int)$a, $b); // Converte null para 0

echo "Resultado: " . $resultado; // Resultado: 5

Neste caso, null é convertido para 0, resultando na soma com 5.

Espero que esses exemplos ajudem a entender como a função somar pode ser usada com diferentes tipos de variáveis em PHP!

1. String (`string`)

Descrição: Strings que representam números podem ser convertidas para inteiros automaticamente quando usadas em operações aritméticas.

Exemplo de Uso:

$a = "12";

$b = "8";

$resultado = somar((int)$a, (int)$b); // Converte strings para inteiros

echo "Resultado: " . $resultado; // Resultado: 20

Explicação: As strings "12" e "8" são convertidas para 12 e 8, respectivamente, e a soma resulta em 20.

2. Float (`float`)

Descrição: Números de ponto flutuante precisam ser convertidos para inteiros antes de serem passados para a função somar.

Exemplo de Uso:

$a = 10.75;

$b = 5.25;

$resultado = somar((int)$a, (int)$b); // Converte floats para inteiros

echo "Resultado: " . $resultado; // Resultado: 15

Explicação: Os valores 10.75 e 5.25 são convertidos para 10 e 5, respectivamente, resultando em uma soma de 15.

3. Booleano (`bool`)

Descrição: Booleanos são convertidos para inteiros (0 para false e 1 para true) em operações aritméticas.

Exemplo de Uso:

$a = true; // equivale a 1

$b = false; // equivale a 0

$resultado = somar((int)$a, (int)$b); // Converte booleanos para inteiros

echo "Resultado: " . $resultado; // Resultado: 1

Explicação: true é convertido para 1 e false para 0, então a soma é 1.

4. Array (`array`)

Descrição: Arrays não podem ser passados diretamente para a função. Precisamos acessar valores individuais do array.

Exemplo de Uso:

$valores = [7, 15];

$resultado = somar($valores[0], $valores[1]); // Passa valores individuais do array

echo "Resultado: " . $resultado; // Resultado: 22

Explicação: Os valores do array são passados individualmente para a função, resultando em 22.

5. Objeto (`object`)

Descrição: Para objetos, você precisa acessar as propriedades ou métodos que retornam inteiros.

Exemplo de Uso:

class Valores {

public int $a;

public int $b;

public function __construct(int $a, int $b) {

$this->a = $a;

$this->b = $b;

}

$obj = new Valores(9, 11);

$resultado = somar($obj->a, $obj->b); // Acessa propriedades do objeto

echo "Resultado: " . $resultado; // Resultado: 20

Explicação: As propriedades a e b do objeto são usadas diretamente na função, resultando na soma de 20.

6. NULL (`null`)

Descrição: null não pode ser diretamente usado em operações aritméticas. Deve ser convertido para inteiro, que é 0.

Exemplo de Uso:

$a = null;

$b = 5;

$resultado = somar((int)$a, $b); // Converte null para 0

echo "Resultado: " . $resultado; // Resultado: 5

Explicação: null é convertido para 0, então a soma com 5 resulta em 5.

Esses exemplos mostram como a função somar pode lidar com diferentes tipos de variáveis e como a conversão de tipos pode afetar o resultado da operação.

Para utilizar a função somar(int $a, int $b): int com strings que representam números, você precisará garantir que as strings sejam convertidas para inteiros antes de passá-las para a função. Isso é importante porque a função somar espera argumentos do tipo int.

Aqui está um exemplo de como você pode fazer isso:

Exemplo com Strings

<?php

function somar(int $a, int $b): int {

return $a + $b;

}

$string1 = "25"; // String representando um número inteiro

$string2 = "30"; // Outra string representando um número inteiro

// Convertendo strings para inteiros e passando para a função

$resultado = somar((int)$string1, (int)$string2);

echo "Resultado: " . $resultado; // Resultado: 55

Explicação

Definição da Função: A função somar espera dois parâmetros do tipo int e retorna a soma desses valores.
Strings de Entrada: As variáveis $string1 e $string2 contêm números como strings.
Conversão de Tipos: Usamos (int) para converter as strings para inteiros antes de passar para a função somar. A conversão é necessária porque a função somar não aceita strings diretamente.
Resultado: A função calcula a soma dos inteiros resultantes da conversão e exibe o resultado 55.

Este exemplo demonstra como você pode utilizar a função somar com variáveis que inicialmente são strings, convertendo-as para o tipo correto antes de passá-las para a função.

a função somar para lidar com diversos tipos de dados além de int. A função será modificada para aceitar diferentes tipos e lidar com conversões ou verificações necessárias. A seguir, mostro exemplos de como utilizar a função somar com os seguintes tipos:

String
Float
Boolean
Array
Object
NULL

Código da Função Adaptada

Para lidar com diferentes tipos, a função pode ser adaptada da seguinte forma:

<?php

function somar($a, $b) {

// Converte para inteiro se possível, caso contrário, considera como 0

return (int)$a + (int)$b;

}

// Exemplos de uso:

// 1. String

$string1 = "25";

$string2 = "30";

echo "Resultado com strings: " . somar($string1, $string2) . "\n"; // Resultado: 55

// 2. Float

$float1 = 12.7;

$float2 = 8.3;

echo "Resultado com floats: " . somar($float1, $float2) . "\n"; // Resultado: 21

// 3. Boolean

$bool1 = true; // equivale a 1

$bool2 = false; // equivale a 0

echo "Resultado com booleanos: " . somar($bool1, $bool2) . "\n"; // Resultado: 1

// 4. Array

$array1 = [5, 10];

$array2 = [15, 20];

echo "Resultado com arrays: " . somar($array1[0], $array2[1]) . "\n"; // Resultado: 30

// 5. Object

class Valores {

public $a;

public $b;

public function __construct($a, $b) {

$this->a = $a;

$this->b = $b;

}

$obj = new Valores(7.5, "5");

echo "Resultado com objetos: " . somar($obj->a, $obj->b) . "\n"; // Resultado: 12

// 6. NULL

$null1 = null;

$null2 = 10;

echo "Resultado com NULL: " . somar($null1, $null2) . "\n"; // Resultado: 10

Explicação dos Exemplos

String:
- Strings que representam números são convertidas para inteiros automaticamente. As strings "25" e "30" são convertidas para 25 e 30, resultando em 55.
Float:
- Flutuantes são convertidos para inteiros, descartando a parte decimal. 12.7 e 8.3 são convertidos para 12 e 8, resultando em 20.
Boolean:
- Booleanos são convertidos para 1 (para true) e 0 (para false). true e false são convertidos para 1 e 0, resultando em 1.
Array:
- Quando usado, é necessário acessar elementos específicos do array. Neste exemplo, os elementos 5 e 20 do array são somados, resultando em 25.
Object:
- Para objetos, os valores das propriedades são convertidos para inteiros. As propriedades 7.5 e "5" são convertidas para 7 e 5, resultando em 12.
NULL:
- NULL é convertido para 0. Quando somado com 10, o resultado é 10.

Esses exemplos mostram como a função somar pode ser usada com diversos tipos de variáveis, adaptando-se a diferentes tipos de dados com a conversão para inteiros quando necessário.

1. String

$a = "15";

$b = "25";

$resultado = somar($a, $b); // Chamada com strings

echo "Resultado: " . $resultado; // Resultado: 40

2. Float

$a = 10.5;

$b = 5.5;

$resultado = somar($a, $b); // Chamada com floats

echo "Resultado: " . $resultado; // Resultado: 15

3. Boolean

$a = true; // equivale a 1

$b = false; // equivale a 0

$resultado = somar($a, $b); // Chamada com booleanos

echo "Resultado: " . $resultado; // Resultado: 1

4. Array

$a = [10, 20];

$b = [30, 40];

$resultado = somar($a[0], $b[1]); // Chamada com elementos de arrays

echo "Resultado: " . $resultado; // Resultado: 50

5. Object

class Valores {

public $a;

public $b;

public function __construct($a, $b) {

$this->a = $a;

$this->b = $b;

}

$obj = new Valores(7, 8);

$resultado = somar($obj->a, $obj->b); // Chamada com propriedades de objeto

echo "Resultado: " . $resultado; // Resultado: 15

6. NULL

$a = null;

$b = 10;

$resultado = somar($a, $b); // Chamada com NULL

echo "Resultado: " . $resultado; // Resultado: 10

Esses exemplos ilustram como a função somar pode ser chamada com diferentes tipos de variáveis.

<?php

function concatenarNomes(string $nome, string $sobrenome): string {

return $nome . " " . $sobrenome;

}

// Exemplos de uso:

$nome = "João";

$sobrenome = "Silva";

$resultado = concatenarNomes($nome, $sobrenome);

echo "Nome completo: " . $resultado; // Nome completo: João Silva

Explicação

Função concatenarNomes:
- Parâmetros: Aceita dois parâmetros do tipo string: $nome e $sobrenome.
- Retorno: Retorna a concatenação dos dois parâmetros com um espaço entre eles.
Exemplo de Uso:
- Definimos o nome "João" e o sobrenome "Silva".
- Chamamos a função concatenarNomes passando esses dois valores.
- O resultado é uma string que combina o nome e o sobrenome, que é exibida como "João Silva".

Este exemplo mostra como você pode ajustar a função para lidar com strings ao invés de inteiros, utilizando a operação de concatenação para unir nomes e sobrenomes.

Para criar uma função no mesmo estilo da função somar, mas que manipule strings para retornar o nome completo a partir de um nome e sobrenome, você pode definir a função com parâmetros de tipo string e retornar a concatenação dos mesmos. Aqui está o modelo correspondente:

<?php

function concatenarNomes(string $nome, string $sobrenome): string {

return $nome . ' ' . $sobrenome;

}

// Exemplos de uso:

$nome = "Ana";

$sobrenome = "Pereira";

$resultado = concatenarNomes($nome, $sobrenome);

echo "Nome completo: " . $resultado; // Nome completo: Ana Pereira

Explicação:

Função concatenarNomes:
- Parâmetros: Aceita dois parâmetros do tipo string, $nome e $sobrenome.
- Retorno: Retorna a concatenação dos parâmetros com um espaço entre eles.
Exemplo de Uso:
- Definimos o nome "Ana" e o sobrenome "Pereira".
- Chamamos a função concatenarNomes passando esses valores.
- O resultado será a string "Ana Pereira", que é exibida com echo.

Essa função segue o mesmo estilo da função somar, mas trabalha com strings e realiza uma operação de concatenação ao invés de soma.

Aqui estão exemplos de funções seguindo o padrão da função somar, mas adaptadas para lidar com diferentes tipos de dados, como float, double e boolean. Em cada exemplo, as funções realizarão operações específicas baseadas no tipo de dado:

1. Float

<?php

function somarFloats(float $a, float $b): float {

return $a + $b;

}

// Exemplos de uso:

$float1 = 10.5;

$float2 = 5.25;

$resultado = somarFloats($float1, $float2);

echo "Resultado com floats: " . $resultado; // Resultado: 15.75

Explicação: A função somarFloats aceita dois parâmetros do tipo float e retorna a soma desses valores.

2. Double

Observação: Em PHP, double é equivalente a float, então a função para double será idêntica à de float. Se precisar, você pode usar a função somarFloats para double da mesma forma.

3. Boolean

<?php

function somarBooleans(bool $a, bool $b): int {

return (int)$a + (int)$b;

}

// Exemplos de uso:

$bool1 = true; // equivale a 1

$bool2 = false; // equivale a 0

$resultado = somarBooleans($bool1, $bool2);

echo "Resultado com booleanos: " . $resultado; // Resultado: 1

Explicação: A função somarBooleans converte os valores booleanos para inteiros (true para 1 e false para 0) e retorna a soma desses inteiros.

4. Inteiros (`int`)

Para referência, aqui está a função original para inteiros:

<?php

function somar(int $a, int $b): int {

return $a + $b;

}

// Exemplos de uso:

$int1 = 10;

$int2 = 20;

$resultado = somar($int1, $int2);

echo "Resultado com inteiros: " . $resultado; // Resultado: 30

Explicação: A função somar aceita dois inteiros e retorna a soma desses valores.

Esses exemplos seguem o mesmo padrão da função somar, ajustando-se para diferentes tipos de dados, e demonstram como cada tipo pode ser manipulado de acordo com suas características.

1. Array Associativo

No PHP, arrays associativos permitem usar chaves nomeadas para acessar valores. Vamos criar uma função que recebe dois arrays associativos e retorna a soma dos valores associados a chaves específicas.

<?php

function somarValoresAssociativos(array $arr1, array $arr2, string $chave): int {

return ($arr1[$chave] ?? 0) + ($arr2[$chave] ?? 0);

}

// Exemplos de uso:

$array1 = ['a' => 10, 'b' => 20];

$array2 = ['a' => 15, 'b' => 25];

$resultado = somarValoresAssociativos($array1, $array2, 'a');

echo "Resultado com array associativo: " . $resultado; // Resultado: 25

$resultado = somarValoresAssociativos($array1, $array2, 'b');

echo "Resultado com array associativo: " . $resultado; // Resultado: 45

Explicação:

Função somarValoresAssociativos: Aceita dois arrays associativos e uma chave. Soma os valores associados à chave fornecida em ambos os arrays.
Uso: Com os arrays associativos ['a' => 10, 'b' => 20] e ['a' => 15, 'b' => 25], a função soma os valores das chaves 'a' e 'b', resultando em 25 e 45, respectivamente.

2. Objetos

Vamos criar uma função que lida com objetos. A função irá somar propriedades de objetos, supondo que as propriedades contenham valores numéricos.

<?php

class Valor {

public int $a;

public int $b;

public function __construct(int $a, int $b) {

$this->a = $a;

$this->b = $b;

}

function somarPropriedades(Valor $obj1, Valor $obj2): int {

return $obj1->a + $obj2->a + $obj1->b + $obj2->b;

}

// Exemplos de uso:

$obj1 = new Valor(5, 10);

$obj2 = new Valor(15, 20);

$resultado = somarPropriedades($obj1, $obj2);

echo "Resultado com objetos: " . $resultado; // Resultado: 50

Explicação:

Classe Valor: Define um objeto com duas propriedades a e b, ambas do tipo int.
Função somarPropriedades: Recebe dois objetos Valor e soma as propriedades a e b de ambos os objetos.
Uso: Com os objetos Valor(5, 10) e Valor(15, 20), a função soma 5 + 15 + 10 + 20, resultando em 50.

Esses exemplos demonstram como você pode adaptar funções para trabalhar com arrays associativos e objetos, realizando operações específicas baseadas nas características desses tipos de dados.

Vamos criar um array associativo e um array de objetos, e depois explicar as sintaxes de cada um.

1. Array Associativo

Um array associativo em PHP é um array onde as chaves são nomeadas (strings) em vez de índices numéricos. Aqui está um exemplo:

<?php

// Array associativo com chaves nomeadas

$aluno = [

"nome" => "Fabrício",

"idade" => 25,

"curso" => "Engenharia de Software",

"matricula" => "qw0001"

];

// Acessando os valores pelo nome das chaves

echo "Nome: " . $aluno["nome"] . "\n"; // Nome: Fabrício

echo "Idade: " . $aluno["idade"] . "\n"; // Idade: 25

echo "Curso: " . $aluno["curso"] . "\n"; // Curso: Engenharia de Software

echo "Matrícula: " . $aluno["matricula"] . "\n"; // Matrícula: qw0001

Explicação da Sintaxe:

Chaves: As chaves do array associativo são strings (por exemplo, "nome", "idade").
Valores: Os valores podem ser de qualquer tipo, como string, inteiro, ou até outro array.
Acesso: Para acessar um valor, você usa a chave associada, por exemplo, $aluno["nome"].

2. Array de Objetos

Um array de objetos em PHP é um array que contém instâncias de uma classe. Cada elemento do array é um objeto. Aqui está um exemplo:

<?php

// Definindo uma classe Aluno

class Aluno {

public string $nome;

public int $idade;

public string $curso;

public string $matricula;

public function __construct(string $nome, int $idade, string $curso, string $matricula) {

$this->nome = $nome;

$this->idade = $idade;

$this->curso = $curso;

$this->matricula = $matricula;

}

public function exibirDados() {

return "Nome: $this->nome, Idade: $this->idade, Curso: $this->curso, Matrícula: $this->matricula";

}

// Criando um array de objetos

$alunos = [

new Aluno("Fabrício", 25, "Engenharia de Software", "qw0001"),

new Aluno("Ana", 22, "Ciência da Computação", "qw0002"),

new Aluno("Carlos", 28, "Sistemas de Informação", "qw0003")

];

// Acessando e exibindo os dados dos objetos

foreach ($alunos as $aluno) {

echo $aluno->exibirDados() . "\n";

}

Explicação da Sintaxe:

Classe Aluno: Define a estrutura do objeto, com propriedades como nome, idade, curso, e matricula.
Construtor: O método __construct() inicializa as propriedades ao criar uma nova instância da classe.
Array de Objetos: $alunos é um array que contém instâncias da classe Aluno.
Acesso: Para acessar os métodos ou propriedades de cada objeto no array, você pode usar um loop foreach ou acessar diretamente pelo índice, por exemplo, $alunos[0]->nome.

Comparação das Sintaxes:

Array Associativo: Simples e usado para armazenar dados relacionados por chaves nomeadas. Útil quando você precisa de um conjunto de pares chave-valor e não precisa de funcionalidades adicionais.
Array de Objetos: Mais complexo, mas poderoso. Usado quando você precisa de um conjunto de elementos com comportamentos e estados próprios (métodos e propriedades). Cada objeto é uma instância de uma classe, o que permite encapsular dados e comportamentos relacionados.

Esses exemplos mostram a diferença fundamental entre arrays associativos e arrays de objetos, e como você pode usar cada um dependendo da necessidade do seu código.

123

paragrafo

Deixe um comentário

Explore, Contribua e Cresça Conosco!

Obrigado por ler o nosso artigo! Esperamos que você tenha encontrado informações valiosas e inspiradoras. Se você está empolgado para saber mais, temos uma vasta coleção de artigos sobre tópicos variados, desde tendências tecnológicas até insights sobre desenvolvimento de software. Não deixe de explorar nossas outras publicações!

Quer fazer parte da nossa comunidade?

Inscreva-se no nosso site para receber as últimas atualizações e novidades diretamente no seu e-mail. Seu cadastro é o primeiro passo para se conectar com uma rede de entusiastas e profissionais apaixonados pelo que fazem.

Tem algo a compartilhar?

Adoraríamos ouvir suas ideias, inovações e experiências! Sinta-se à vontade para escrever e enviar seus próprios artigos, códigos ou projetos. Sua contribuição é fundamental para enriquecer nosso conteúdo e ajudar outros leitores a crescer junto com você. Juntos, podemos criar um espaço de aprendizado e troca de conhecimento enriquecedor. Seu conhecimento e entusiasmo são o que fazem nossa comunidade especial.

Inscreva-se Agora | Compartilhe | Contribua com um Artigo
Continue explorando e seja parte da transformação!

Voltar

Artigo

public e public static

1. Visibilidade de Métodos e Propriedades

2. Restrições de Tipos e Validações

3. Constantes e Propriedades Estáticas

1. Tipos de Variáveis

public

public static

Quando Implementar:

Exemplo Prático:

1. Inteiro (int)

2. Ponto Flutuante (float)

3. String (string)

4. Booleano (bool)

5. Array (array)

6. Objeto (object)

7. NULL (null)

1. String (string)

2. Float (float)

3. Booleano (bool)

4. Array (array)

5. Objeto (object)

6. NULL (null)

Exemplo com Strings

Explicação

Código da Função Adaptada

Explicação dos Exemplos

1. String

Explicação

Explicação:

1. Float

2. Double

3. Boolean

4. Inteiros (int)

1. Array Associativo

2. Objetos

1. Array Associativo

2. Array de Objetos

Comparação das Sintaxes:

Deixe um comentário

`public`

`public static`

1. Inteiro (`int`)

2. Ponto Flutuante (`float`)

3. String (`string`)

4. Booleano (`bool`)

5. Array (`array`)

6. Objeto (`object`)

7. NULL (`null`)

1. String (`string`)

2. Float (`float`)

3. Booleano (`bool`)

4. Array (`array`)

5. Objeto (`object`)

6. NULL (`null`)

4. Inteiros (`int`)