Artigo Diretório
A diferença entre orientado a processos e orientado a objetos
Orientado para o processo, preste atenção ao processo e escreva os detalhes do código você mesmo.
Orientado a objetos presta atenção ao objeto. Ao escrever o código, consulte os métodos das classes existentes no jdk para realizar a função, em vez de escrevê-la você mesmo.
A relação entre classe e objeto
O que é uma aula?
Uma classe é uma coleção de atributos e comportamentos relacionados . É uma descrição de uma classe de coisas e é abstrata.
Atributos : o que (usando cachorro como exemplo, cor, raça, idade, nome)
corresponde à classe Java, os atributos são variáveis de membro
String name;//名字
int age;//年龄
Comportamento : O que fazer (tome o cachorro como exemplo, comer, dormir, brincar)
corresponde à classe Java, o comportamento é o método membro
(nota: o método membro não escreve a palavra-chave estática !!!)
public void eat(){
}//吃
public void sleep() {
}//睡
O que é um objeto?
Os objetos são instâncias de uma classe de coisas e são concretos.
A classe é o modelo do objeto e o objeto é a entidade da classe.
A analogia pode ser comparada ao desenho de um telefone móvel, e o objeto pode ser comparado a um telefone móvel real.
Para atingir a funcionalidade, devemos instanciar um objeto específico com base na classe, ou seja, criar um objeto.
Criação e uso de objetos
1.
Importe o nome do pacote de importação do pacote. Nome da classe;
e a classe atual no mesmo pacote, você não pode importar o pacote
2. Crie o
formato:
nome da classe nome do objeto = nome da nova classe ();
3.
Use a variável de membro: nome do objeto. Variáveis de
membro Use métodos de membro: nome do objeto. Método de membro (parâmetros)
(se você quiser usá-lo, use o nome do objeto. Quem)
Exemplo de exercício - definir uma classe para simular coisas de "telefone celular"
public class Phone {
// 成员变量
String brand; // 品牌
double price; // 价格
String color; // 颜色
// 成员方法
public void call(String who) {
System.out.println("给" + who + "打电话");
}
public void sendMessage() {
System.out.println("群发短信");
}
}
public class Demo01PhoneOne {
public static void main(String[] args) {
// 根据Phone类，创建一个名为one的对象
// 格式：类名称 对象名 = new 类名称();
Phone one = new Phone();
one.brand = "苹果";
one.price = 8388.0;
one.color = "黑色";
System.out.println(one.brand); // 苹果
System.out.println(one.price); // 8388.0
System.out.println(one.color); // 黑色
System.out.println("=========");
one.call("乔布斯"); // 给乔布斯打电话
one.sendMessage(); // 群发短信
}
}
Gráfico de memória de um objeto
Use o tipo de objeto como parâmetro do método
Quando um objeto é passado como parâmetro para um método, ele realmente passa o valor do endereço.
public class Demo04PhoneParam {
public static void main(String[] args) {
Phone one = new Phone();
one.brand = "苹果";
one.price = 5999.0;
one.color = "玫瑰金";
method(one); // 传递进去的参数其实就是地址值
}
public static void method(Phone param) {
System.out.println(param.brand); // 苹果
System.out.println(param.price); // 5999.0
System.out.println(param.color); // 玫瑰金
}
}
Use o tipo de objeto como o valor de retorno do método
public class Demo05PhoneReturn {
public static void main(String[] args) {
Phone two = getPhone();
System.out.println(two.brand); // 苹果
System.out.println(two.price); // 5999.0
System.out.println(two.color); // 玫瑰金
}
public static Phone getPhone() {
Phone one = new Phone();
one.brand = "苹果";
one.price = 5999.0;
one.color = "玫瑰金";
return one;
}
}
Variáveis locais e variáveis de membro
1. A localização da definição é diferente
Variáveis locais: dentro do método
Variáveis membro: fora do método, escritas diretamente na classe
2. O escopo de ação é diferente
Variáveis locais: só podem ser usadas em métodos, e não podem mais ser usadas quando os métodos estão fora
Variáveis-membro: toda a classe pode ser usada em geral.
3. Os valores padrão são diferentes.
Variáveis locais: não há valor padrão. Se você quiser usá-lo, deve atribuir um valor manualmente.
Variáveis de membro: se você não tiver um valor, haverá um padrão valor. As regras são iguais às matrizes.
4. A localização da memória é diferente
Variáveis locais: localizadas na memória stack
Variáveis-membro: localizadas na memória heap
5. O ciclo de vida é diferente.
Variáveis locais: nascem quando os métodos
são colocados na pilha e desaparecem quando os métodos são retirados da pilha Variáveis-membro: nascem quando os objetos são criados e desaparecem quando os objetos são coletados no lixo
public class Demo01VariableDifference {
String name; // 成员变量
public void methodA() {
int num = 20; // 局部变量
System.out.println(num);
System.out.println(name);
}
public void methodB(int param) {
// 方法的参数就是局部变量
// 参数在方法调用的时候，必然会被赋值的。
System.out.println(param);
int age; // 局部变量
// System.out.println(age); // 没赋值不能用
// System.out.println(num); // 错误写法！
System.out.println(name);
}
}
O encapsulamento das três características da orientação a objetos
A manifestação de encapsulamento em Java:
- Método é um tipo de encapsulamento
- A palavra-chave privada também é um tipo de encapsulamento
- O encapsulamento é para ocultar algumas informações detalhadas, invisíveis para o mundo exterior, fáceis de modificar e aumentar a capacidade de manutenção do código.
- O encapsulamento pode restringir os usuários da manipulação irracional de atributos.
Caso: Ao definir a idade de Pessoa, é impossível evitar que um valor irracional seja definido.
Solução: Use a palavra-chave privada para modificar as variáveis de membro que precisam ser protegidas.
Depois que private for usado para modificação, essa classe ainda poderá ser acessada à vontade.
No entanto, ele não pode ser acessado diretamente fora do escopo desta categoria!
Portanto, defina um par de métodos Getter / Setter para acessar indiretamente variáveis de membro privado.
Devem ser regras de nomenclatura setXxx ou getXxx.
(Observação: para o valor booleano no tipo básico, o método Getter deve ser escrito na forma de isXxx e a regra setXxx permanece inalterada.)
- 例如 ： public boolean isMale () { return male; }
Para Getter, não pode haver parâmetros e o tipo de valor de retorno corresponde à variável de membro;
para Setter, não pode haver valor de retorno e o tipo de parâmetro corresponde à variável de membro.
public class Person {
String name; // 姓名
private int age; // 年龄
public void show() {
System.out.println("我叫：" + name + "，年龄：" + age);
}
// 这个成员方法，专门用于向age设置数据
public void setAge(int num) {
if (num < 100 && num >= 9) {
// 如果是合理情况
age = num;
} else {
System.out.println("数据不合理！");
}
}
// 这个成员方法，专门用于获取age的数据
public int getAge() {
return age;
}
}
public class Demo03Person {
public static void main(String[] args) {
Person person = new Person();
person.show();
person.name = "小明";
person.setAge(20);
person.show();
}
}
A função desta palavra-chave
Quando a variável local do método e a variável membro da classe têm o mesmo nome, a variável local é preferida de acordo com o "princípio de proximidade".
Se você precisa acessar as variáveis de membro nesta classe, você precisa usar o formato:
this. Member variable name
"Por quem o método é chamado, quem quer que seja."
public class Person {
String name; // 我自己的名字
// 参数name是对方的名字
// 成员变量name是自己的名字
public void sayHello(String name) {
System.out.println(name + "，你好。我是" + this.name);
//System.out.println(this);
}
}
public class Demo01Person {
public static void main(String[] args) {
Person person = new Person();
// 设置我自己的名字
person.name = "老哈";
person.sayHello("小哈");
// System.out.println(person); // 地址值
}
}
Método de construção
O método de construção é um método usado especificamente para criar um objeto.Quando criamos um objeto por meio da palavra-chave new, estamos na verdade chamando o método de construção.
Formato:
nome da classe pública (nome do parâmetro do tipo de parâmetro) { corpo do método }
Precauções:
- O nome do construtor deve ser exatamente igual ao nome da classe e o caso deve ser o mesmo
- Não escreva o tipo de valor de retorno no construtor, e nem mesmo escreva void
- O construtor não pode retornar um valor de retorno específico
- Se nenhum método de construção for escrito, o compilador terá um método de construção padrão, sem parâmetros, o corpo do método não faz nada.
public class Student {
public Student() {}
}
- Depois de escrever pelo menos um construtor, o compilador não terá mais um construtor padrão.
- O método de construção também pode ser sobrecarregado.
(Sobrecarga: o nome do método é o mesmo, mas a lista de parâmetros é diferente.)
public class Student {
// 成员变量
private String name;
private int age;
// 无参数的构造方法
public Student() {
System.out.println("无参构造方法执行啦！");
}
// 全参数的构造方法
public Student(String name, int age) {
System.out.println("全参构造方法执行啦！");
this.name = name;
this.age = age;
}
// Getter Setter
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}
public class Demo02Student {
public static void main(String[] args) {
Student stu1 = new Student(); // 无参构造
System.out.println("============");
Student stu2 = new Student("小哈", 20); // 全参构造
System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
// 如果需要改变对象当中的成员变量数据内容，仍然还需要使用setXxx方法
stu2.setAge(21); // 改变年龄
System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
}
}
Defina uma classe padrão
Uma classe padrão geralmente tem os seguintes quatro componentes:
- Todas as variáveis de membro devem ser modificadas com a palavra-chave privada
- Escreva um par de métodos Getter / Setter para cada variável membro
- Escreva um método de construção sem parâmetros
- Escreva um método de construção de parâmetros completos
Essa classe padrão também é chamada de Java Bean
ublic class Student {
private String name; // 姓名
private int age; // 年龄
//定义完成员变量之后，光标放在下面的空白层，按住Alt+Insert键，选择"Getter和Setter" 就会自动生成Getter和Setter方法
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
Ao escrever o código, após definir as variáveis membro, coloque o cursor na camada em branco abaixo, segure Alt + Insert para
selecionar "Getter e Setter", segure Shift para selecionar tudo e clique em ok, os métodos Getter e Setter serão automaticamente gerado.
Selecione "Construtor" e clique em Selecionar Nenhum para gerar automaticamente um método sem parâmetros; mantenha pressionada a tecla Shift para selecionar tudo e clique em ok para gerar automaticamente um método com parâmetros completos
Tecla Alt + Insert (geralmente à esquerda da tecla Delete), você também pode encontrar código-Gerar na barra de menu
