Pausa para café #174. Diferentes maneiras de criar um objeto em Java.String para Int em Java - Como converter String em Inteiro

Diferentes maneiras de criar um objeto em Java

Fonte: Médio Neste tutorial, aprenderemos diferentes maneiras de criar um objeto em Java. Um objeto Java é uma instância de uma classe Java. Cada objeto possui um estado, um comportamento e um identificador. Os campos (variáveis) armazenam o estado de um objeto, enquanto os métodos (funções) mostram a ação de um objeto. As classes servem como “modelos” a partir dos quais as instâncias de objetos são criadas em tempo de execução.

Criando um objeto em Java

A criação de objetos é o processo de alocação de memória para armazenar dados em campos de classe (também chamados de variáveis). Esse processo costuma ser chamado de criação de uma instância de uma classe. Existem quatro maneiras diferentes de criar objetos em Java:

1. usando a nova palavra-chave
2. método novaInstância()
3. Método clone()
4. desserializando um objeto

Agora vamos examinar detalhadamente cada um dos métodos mencionados.

Palavra-chave nova

Esta é a maneira mais comum de criar um objeto em Java. A palavra-chave new cria uma instância de uma classe alocando memória para uma nova instância do tipo especificado. Depois de new vem o construtor - um método especial responsável por criar um objeto e inicializar os campos do objeto criado. Um objeto é criado com o operador new e inicializado com um construtor. Aqui está um exemplo de criação de um objeto Java com o operador new :

Date today = new Date();

Esta expressão gera um novo objeto Date ( Date é uma classe dentro do pacote java.util ). Esta cláusula única no código executa três operações: declaração, instanciação e inicialização. Date hoje é uma declaração de variável que informa ao compilador que hoje se referirá a um objeto do tipo Date . O operador new instancia a classe Date (criando um novo objeto Date na memória) e Date() inicializa o objeto. Considere o exemplo abaixo:

public class Person {
    private String name;
    private int uid;

    public Person() {
        this.name = "Michael Cole";
        this.uid = 101;
    }

    public Person(String name, int uid) {
        super();
        this.name = name;
        this.uid = uid;
    }

    // getters and setters...

    public static void main(String[] args) {

        Person p1 = new Person();
        Person p2 = new Person("John Bodgan", 102);
        System.out.println("Name: " + p1.getName() + " UID: " + p1.getUid());
        System.out.println("Name: " + p2.getName() + " UID: " + p2.getUid());
    }
}

A partir deste código, criamos um objeto Person usando a palavra-chave new :

• O objeto p1 chama um construtor não parametrizado com o valor do nome da variável definido como “Michael Cole” e o UID definido como 101.
• O objeto p2 chama o construtor parametrizado, onde passa para o construtor o valor “John Bodgan” e 102. Esses valores recebem então um nome de variável e UID.

Usando o método newInstance()

O método newInstance() em Java é usado para criar dinamicamente uma instância de um objeto de uma determinada classe. Existem dois usos padrão do método newInstance() :

• Método newInstance() da API java.lang.Class
• Método newInstance() da API java.lang.reflect.Constructor

Usando newInstance() da API de classe

Para criar um objeto de uma classe em tempo de execução, devemos chamar o método newInstance() da API Class, que retorna um objeto dessa classe. O método newInstance() da classe java.lang.Class não aceita nenhum parâmetro ou argumento e pode ser chamado de construtor sem argumento para essa classe. Vejamos alguns exemplos de código para criar um objeto da classe Person usando o método newInstance() da classe java.lang.Class :

public class Person {
    private String name;
    private int uid;

    public Person() {
        this.name = "Carl Max";
        this.uid = 101;
    }

   // getters and setters...
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Class c = Class.forName("com.medium.option2.Person");
        @SuppressWarnings("deprecation")
        Person p = (Person) c.newInstance();
        System.out.println("Name: " + p.getName());
        System.out.println("UID: " + p.getUid());
    }
}

Class.forName (o nome completo da classe) carrega uma classe chamada Person , então newInstance() cria um novo objeto do tipo Person e retorna uma referência a ele. Agora, usando a referência Person para p , podemos chamar seus getters() e setter() para realizar determinadas ações. Observe:

• Tanto Class.forName() quanto newIstance() lançam exceções que devem ser tratadas usando blocos try e catch ou a palavra-chave throws .
• O método newInstance() da API Class está obsoleto desde Java 9.

Usando newInstance() da API Construtor

O método newInstance() da classe Constructor ( java.lang.reflect.Constructor ) é semelhante ao método newInstance() da classe Class , exceto que aceita parâmetros para construtores parametrizados. Vamos demonstrar essa abordagem criando um objeto da classe Person usando o método newInstance() da classe java.lang.reflect.Constructor :

public class PersonTwo {
    private String name;
    private int uid;

    public PersonTwo() {
        this.name = "Maya Kumari";
        this.uid = 101;
    }

    public PersonTwo(String name) {
        this.name = name;
        this.uid = 102;
    }

    public PersonTwo(String name, Integer uid) {
        this.name = name;
        this.uid = uid;
    }

    // getters and setters...
    public static void main(String[] args) {
        try {
            Class.forName("com.medium.option2.PersonTwo");

            Constructor c1 = PersonTwo.class.getConstructor();
            PersonTwo p1 = (PersonTwo) c1.newInstance();
            System.out.println("Name: " + p1.getName());
            System.out.println("UID: " + p1.getUid());

            Constructor c2 = PersonTwo.class.getConstructor(String.class);
            PersonTwo p2 = (PersonTwo) c2.newInstance("James Gunn");
            System.out.println("Name: " + p2.getName());
            System.out.println("UID: " + p2.getUid());

            Constructor c3 = PersonTwo.class.getConstructor(String.class, Integer.class);
            PersonTwo p3 = (PersonTwo) c3.newInstance("Mark Brown", 103);
            System.out.println("Name: " + p3.getName());
            System.out.println("UID: " + p3.getUid());

        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

No código acima, primeiro precisamos carregar a classe usando o método Class.forName() . A seguir, chamaremos o método getConstructor() para corresponder aos tipos de dados dos parâmetros passados. Finalmente, no método newInstance() passamos o parâmetro requerido ( null se não houver argumento). O método newInstance() retornará um novo objeto da classe PersonTwo chamando o construtor apropriado.

Usando o método clone()

O método clone() faz parte da classe Object e é usado para criar uma cópia de um objeto existente. Ele cria um objeto da classe sem chamar nenhum construtor de classe. Para clonar um método, a classe correspondente deve ter implementada a interface Cloneable , que é uma interface marcadora. Agora vamos criar um objeto da classe Person e depois cloná-lo em outro objeto da classe Person :

public class Person implements Cloneable {
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    private String name;
    private int uid;

    public Person(String name, int uid) {
        super();
        this.name = name;
        this.uid = uid;
    }

    // getters and setters...

    public static void main(String[] args) {
        Person p1 = new Person("Ryan", 101);
        try {
            Person p2 = (Person) p1.clone();
            System.out.println("Name: " + p2.getName());
            System.out.println("UID: " + p2.getUid());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

    }
}

Observação. O objeto clonado fará referência ao mesmo objeto original por meio da referência p2 . No entanto, o objeto clonado terá uma atribuição de memória separada. Isso significa que quaisquer alterações feitas no objeto Person referenciado por p2 não alterarão o objeto Person original referenciado por p1 . Isso ocorre porque o método clone() cria uma cópia superficial dos objetos.

Usando desserialização de objetos

A desserialização de objetos é o processo de extrair um objeto de uma série de fluxos de bytes. A serialização faz o oposto. Seu principal objetivo é recuperar um objeto armazenado do banco de dados/rede de volta para a memória. Se quisermos serializar ou desserializar um objeto, precisamos implementar a interface Serializable (interface token). Considere o exemplo abaixo:

public class PersonDriver {

    public static void main(String[] args) {
        Person p1 = new Person("Max Payne", 101);
        FileOutputStream fileOutputStream;
        try {
            fileOutputStream = new FileOutputStream("link to text file");
            ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);
            outputStream.writeObject(p1);
            outputStream.flush();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        FileInputStream fileInputStream;
        try {
            fileInputStream = new FileInputStream("link to text file");
            ObjectInputStream inputStream = new ObjectInputStream(fileInputStream);
            Person p2 = (Person) inputStream.readObject();
            System.out.println("Name: " + p2.getName());
            System.out.println("UID: " + p2.getUid());
            inputStream.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Aqui primeiro serializamos o objeto Person pela referência p1 em um arquivo de texto. O método writeObject() gravará o fluxo de bytes do objeto em um arquivo de texto. Então, usando a desserialização de objetos, extraímos o objeto Person de volta para p2 . Da mesma forma, o método readObject() lerá um objeto do fluxo de entrada do objeto. Por fim, imprimiremos os dados do objeto Person no console.

Conclusão

Neste artigo, aprendemos sobre as diferentes maneiras de criar um objeto em Java. Primeiro, analisamos a criação de objetos usando a palavra-chave new , que é a forma mais comum. Em seguida, aprendemos o método newInstance() das classes Class e Constructor , que é outra forma popular de criar objetos. Em seguida, usamos o método clone() , que cria uma cópia superficial do objeto existente em vez de criar um novo objeto. Por último, usamos o conceito de serialização e desserialização de objetos para criar objetos em Java.

String para Int em Java - como converter uma string em um inteiro

Fonte: FreeCodeCamp Hoje você aprenderá como converter uma string em um inteiro em Java usando dois métodos da classe Integer - parseInt() e valueOf() . Isso o ajudará ao realizar operações matemáticas usando o valor de uma variável string.

Como converter uma string em um número inteiro em Java usando Integer.parseInt

Esta opção assume que o método parseInt() usa uma string para converter em um número inteiro como parâmetro:

Integer.parseInt(string_varaible)

Antes de ver um exemplo de seu uso, vamos ver o que acontece quando você adiciona um valor de string e um número inteiro sem qualquer conversão:

class StrToInt {
    public static void main(String[] args) {
        String age = "10";
        
        System.out.println(age + 20);
        // 1020
    }
}

Neste código, criamos uma variável idade com o valor da string “10”. Quando adicionamos o número 20 a um valor inteiro, recebemos erroneamente 1020 em vez da resposta correta de 30. Isso pode ser corrigido usando o método parseInt() :

class StrToInt {
    public static void main(String[] args) {
        String age = "10";
        
        int age_to_int = Integer.parseInt(age);
        
        System.out.println(age_to_int + 20);
        // 30
    }
}

Aqui, para converter a variável idade em um número inteiro, passamos ela como parâmetro para o método parseInt() - Integer.parseInt(age) - e a armazenamos em uma variável chamada age_to_int . Agora, quando somado a outro número inteiro, obtemos a adição correta: age_to_int + 20 .

Como converter uma string em um número inteiro em Java usando Integer.valueOf

O método valueOf() funciona da mesma forma que o método parseInt() . Toma como parâmetro uma string que precisa ser convertida para um número inteiro. Aqui está um exemplo:

class StrToInt {
    public static void main(String[] args) {
        String age = "10";
        
        int age_to_int = Integer.valueOf(age);
        
        System.out.println(age_to_int + 20);
        // 30
    }
}

No código acima você pode ver a mesma coisa que na seção anterior:

• Passamos uma string como parâmetro para valueOf() : Integer.valueOf(age) . Foi armazenado em uma variável chamada age_to_int .
• Em seguida, adicionamos 10 à variável criada: age_to_int + 20 . O resultado foi 30 em vez de 1020.

Conclusão

Neste artigo, discutimos a conversão de strings em inteiros em Java. Para converter uma string em um número inteiro, foram usados ​​​​dois métodos da classe Integer - parseInt() e valueOf() . Boa codificação!