Java --- Capítulo seis
Un paquete (encapsulación)
Introducción del paquete
¿Qué es la encapsulación?
La encapsulación consiste en ocultar algunas propiedades y métodos de una clase y no permite el acceso directo de programas externos. Solo se puede acceder a las propiedades y métodos definidos en la clase a través de los métodos proporcionados públicamente por la clase. La encapsulación es uno de los tres principales Características de la orientación a objetos .
¿Cómo utilizar la encapsulación?
Ejemplo:
crear una clase de persona
public class Person {
public String name;//姓名
public int age;//年龄
public String secret;//秘密
public Person(String name,int age,String secret){
this.name=name;
this.age=age;
this.secret=secret;
}
}
Modificar la visibilidad de los atributos: modificar todos los atributos definidos en la clase a modificación privada
public class Person {
private String name;//姓名
private int age;//年龄
private String secret;//秘密
public Person(String name,int age,String secret){
this.name=name;
this.age=age;
this.secret=secret;
}
}
Si modifica el valor de edad directamente, se informará un error.
public class PersonTest {
public static void main(String[] args){
Person p1 = new Person("刘德华",54,"双重人格");
p1.age=30;//报错
}
}
Crear métodos públicos getter/setter: para leer/modificar valores de propiedades
public class Person {
private String name;//姓名
private int age;//年龄
private String secret;//秘密
public Person(String name,int age,String secret) {
this.name=name;
this.age=age;
this.secret=secret;
}
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;
}
public String getSecret() {
return secret;
}
public void setSecret(String secret) {
this.secret = secret;
}
}
public class PersonTest {
public static void main(String[] args){
Person p1 = new Person("刘德华",54,"双重人格");
p1.setName("伍六七");
String name = p1.getName();
}
}
Agregue una declaración de control al método getter/setter: se utiliza para verificar la validez del valor del atributo
En la clase, agregue una declaración de verificación al atributo correspondiente
public int getAge() {
return age;
}
public void setAge(int age) {
if (age < 0) {
System.out.println("年龄不合法,必须大于0");
} else {
this.age = age;
}
}
en el método
public class PersonTest {
public static void main(String[] args){
Person p1 = new Person("刘德华",54,"双重人格");
p1.setAge(-1);
//输出
//年龄不合法,必须大于0
}
}
¿Por qué utilizar la encapsulación?
- La encapsulación aumenta la reutilización del código.
Debido a que la encapsulación proporciona métodos públicos para acceso externo y los métodos se pueden reutilizar, la encapsulación mejora la reutilización del código. - La encapsulación mejora la mantenibilidad del código.
Al modificar el código, solo es necesario modificar una parte del código, pero otros códigos no se verán afectados.
Por ejemplo: la edad solo se considera en el caso de números negativos en el diseño, pero no en la vida real. La edad de una persona generalmente no supera los 200 años, por lo que es necesario agregar una capa de verificación.
public void setAge(int age) {
if (age < 0 || age > 200) {
System.out.println("年龄不合法,必须大于0并且小于200");
} else {
this.age = age;
}
}
- La encapsulación oculta los detalles de implementación específicos de la clase y protege la lógica de implementación del código.
Dos paquetes (Paquete)
Introducción del paquete
¿Qué es un paquete?
Un paquete es un vocabulario profesional en Java y la esencia de un paquete es una carpeta.
¿Por qué utilizar paquetes?
- Los paquetes pueden clasificar las clases que escribimos.
- Puede evitar conflictos de nombres
- control de acceso
¿Cómo crear un paquete?
gramática:
package 包名;
Entre ellos, com, ly y chat11 son respectivamente una carpeta.
La convención de nomenclatura del nombre del paquete:
- Los nombres de los paquetes generalmente se componen de letras minúsculas y números, y cada paquete está separado por '.'. En otras palabras, cada aparición de un '.' es un paquete.
- Los nombres de los paquetes generalmente contienen prefijos.
- La persona/organización suele ser org.name
- La empresa suele ser com. abreviatura del nombre de la empresa o cn. abreviatura del nombre de la empresa
- Si hay una definición de paquete en una clase, entonces la primera línea de código válido en esta clase debe ser la definición del paquete.
¿Cómo importar paquetes?
Para usar clases que no están en el mismo paquete, necesita usar la palabra clave import para introducir esta sintaxis de clase en su programa Java
:
import 包名.类名;
package com.ly.chat11;
//类的全限定名：包名+'.'+类名
import java.util.Scanner;//告诉JVM,到Java.util包下去找一个名为Scanner的类
public class User {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
}
}
¿Por qué importar paquetes?
Debido a que la JVM solo puede reconocer todas las clases en el paquete actual, si desea usar clases en otros paquetes además del paquete actual, debe decirle a la JVM qué clase en qué paquete usar.
Una clase se refiere a dos clases con el mismo nombre de diferentes paquetes al mismo tiempo, las cuales deben distinguirse por el nombre completo de la clase (nombre completo de la clase)
Descripción de paquetes de uso común:
Java.lang 包
Pertenece al paquete de desarrollo del lenguaje Java y las clases de este paquete se pueden utilizar directamente sin importar el paquete. Porque la JVM introducirá automáticamente
cosas como: el sistema, la cadena y las matemáticas que usamos a menudo
Java.util 包
Pertenece a algunas clases de uso y clases de herramientas proporcionadas por Java.
Por ejemplo: el escáner que utilizamos a menudo
Modificador de acceso triple
Introducción a los modificadores de acceso.
concepto:
Los modificadores de acceso son símbolos modificadores que controlan los permisos de acceso.
Modificadores de acceso a clases:
solo existen dos tipos de modificadores de acceso a clases:
- modificador público
- Modificador predeterminado (ningún modificador es predeterminado)
El modificador público modifica una clase para indicar que la clase es de acceso público.
El modificador predeterminado modifica la clase, lo que indica que solo se puede acceder a la clase en el mismo paquete.
Modificador de acceso de miembros de clase:
los miembros de clase incluyen propiedades de miembros y métodos de miembros.
Los modificadores de acceso de miembros de clase son, en otras palabras, modificadores de acceso para propiedades y métodos de miembros.
Cuatro memorias estáticas
El ámbito de aplicación del modificador estático:
el modificador estático solo se puede utilizar para modificar las variables miembro, los métodos miembro, los bloques de código y las clases internas definidas en la clase (hay capítulos especiales para explicar las clases internas)
Variables miembro modificadas estáticas:
las variables miembro modificadas estáticas se llamanvariable de clase. Compartido por todos los miembros de la clase.
Si el valor inicial del país es: "China", después de la modificación es "Japón", entonces el valor de llamada es "Japón", que
no es una variable miembro y no cambiará con los miembros.
Si la variable de clase es pública, entonces puedes usarnombre de clase.nombre de variableacceso directo a la variable
Bloque de código modificado estático:
El bloque de código modificado estático se denomina bloque de código estático y se ejecuta cuando la JVM registra la clase por primera vez.
Por lo tanto, los bloques de código estático solo se pueden ejecutar una vez y generalmente se usan en algunos escenarios de configuración del sistema.
static {
}
Cinco herencia (Herencia)
Introducción a la herencia
Concepto:
El concepto de herencia es simple pero poderoso; cuando desea crear una nueva clase y ya existe una clase que contiene el código requerido, puede derivar la nueva clase a partir de la clase existente. De esta manera, puede reutilizar campos y métodos de clases existentes sin tener que escribirlos (depurarlos) usted mismo.
Una subclase hereda todos los miembros (campos, métodos y clases anidadas) de su clase principal,Los constructores no son miembros, por lo que las subclases no los heredan., pero el constructor de la superclase se puede llamar desde la subclase.
Una clase derivada de una clase se llama subclase (también puede ser una clase derivada, una clase extendida o una subclase ), y una clase derivada de una subclase se llama superclase (también llamada clase base o clase padre ) .
La herencia es también una de las tres características principales de la orientación a objetos.
¿Cómo utilizar la herencia?
gramática:
publis class 子类名 extends 父类名{
}
Ejemplo:
public class Person{
public String name;
public String sex;
public int age;
public void eat(){
System.out.println("吃饭");
}
}
public class PersonTest extends Person{
public void show(){
System.out.println(name);
//本类中未定义name变量，但却可以使用，说明name变量是从父类中继承过来的
}
}
Propiedades y métodos heredados:
No importa en qué paquete se encuentre la subclase, la subclase hereda todos los miembros públicos y protegidos (incluidos campos y métodos) de la clase principal. Si la subclase y la clase principal están en el mismo paquete, la subclase también heredará los miembros de la clase principal protegidos por paquete.
Las subclases no heredan miembros privados definidos en la clase principal; sin embargo, si la clase principal tiene métodos que brindan acceso público o protegido al campo, estos métodos también se pueden usar en la subclase.
Código repetitivo:
public class Person{
public String name;
public String sex;
public int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat(){
System.out.println("吃饭");
}
}
Clases específicas para médicos:
public class Doctor extends Person{
private String professional;
public String getProfessional() {
return professional;
}
public void setProfessional(String professional) {
this.professional = professional;
}
public void cure(){
System.out.println("治病");
}
}
Probar, crear objeto:
public class PersonTest{
public static void main(String[] args) {
Doctor d =new Doctor();
d.setName("Miss");
d.setSex("女");
d.setAge(19);
d.setProfessional("临床");
//优化之后
Person p1 = new Doctor();
p1.setName("Miss");
p1.setSex("女");
p1.setAge(19);
p1.setProfessional("临床");//报错，因为该类不在Person里
//但是我们可以使用强制类型转换
((Doctor)p1).setProfessional("临床");
}
}
La relación entre la subclase y la clase principal es una relación es-a, lo que significa que si
un objeto se asigna a su referencia de clase principal, en este momento, si desea llamar al método único del objeto, debe convertirlo.
Reescritura de seis métodos (Anulación)
Introducción a la anulación de métodos
Un método miembro de la subclase tiene la misma firma que el método miembro de la clase principal (el nombre del método más el número y tipo de parámetros) y el método de instancia del tipo de valor de retorno anula el método de la clase principal.
Cómo utilizar la anulación de método:
La capacidad de una subclase para anular un método permite que una clase herede de una clase principal que se comporta "lo suficientemente cerca" y luego modifique el comportamiento según sea necesario, el método anulado tiene el mismo nombre, número y tipos de parámetros que el método anulado, y tiene el mismo tipo de retorno , el método principal también puede devolver un subtipo del tipo devuelto por el método principal, este subtipo se denomina tipo de retorno covariante.
Ejemplo:
public Number getScore(){
return 0;
}
Cuando la subclase anula el método de la clase principal, el tipo de valor de retorno puede ser una subclase del tipo de valor de retorno del método de la clase principal
El nivel del modificador de acceso no se puede reducir al anular un método
public Integer getScore(){
return 90;
}
Al anular métodos, es posible que necesite utilizar@anularpara anotar, lo que indica al compilador que desea anular el método en la clase principal. Si, por alguna razón, el compilador detecta que el método no existe en la clase principal, generará un error.
Los números que hemos aprendido antes incluyen byte short int long float double tipo
, luego sus correspondientesSubclases de número:Byte Entero corto Largo Flotante Doble
Siete súper palabras clave
concepto:
Si el constructor de la subclase no llama explícitamente al constructor de la clase principal, el compilador de Java insertará automáticamente una llamada a la construcción sin argumentos de la clase principal. Si la superclase no tiene un constructor sin argumentos, obtendrá un error en tiempo de compilación.
La clase de objeto tiene un constructor sin argumentos, por lo que si la clase de objeto es la única clase principal, esto no es un problema.
Ejemplo 1: Ni la subclase ni la clase principal definen un constructor
Clase principal:
public class Person{
public String name;
public Person(){
super();
}
public Number getScore(){
return 0;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Subclase:
public class Doctor extends Person{
private String professional;
//如果一个类中没有定义构造方法，那么编译器将会给该类插入一个无参构造方法
public Doctor(){
super();//如果子类构造方法中没有明显调用父类的构造方法，那么编译器会
//自动插入一个父类的无参构造的调用
}
public String getProfessional() {
return professional;
}
public void setProfessional(String professional) {
this.professional = professional;
}
public void cure(){
System.out.println("治病");
}
}
Ejemplo 2: la subclase tiene un constructor definido, pero la clase principal no define un constructor.
Clase principal:
public class Person{
public String name;
// public Person(){
// super();
// }
public Number getScore(){
return 0;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Subclase:
public class Doctor extends Person{
private String professional;
public Doctor(){
super();
}
public Doctor(String name){
super();
this.name = name;
}
public String getProfessional() {
return professional;
}
public void setProfessional(String professional) {
this.professional = professional;
}
public void cure(){
System.out.println("治病");
}
}
Ejemplo 3: hay constructores definidos tanto en la subclase como en la clase principal Clase principal
:
public class Person{
public String name;
public Person(String name,String sex){
this.name = name;
this.sex = sex;
}
public Number getScore(){
return 0;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Subclase:
public class Doctor extends Person{
private String professional;
public Doctor(String name,String sex){
super(name,sex);
//如果父类中定义了带参构造，并且没有定义无参构造，
//那么必须在子类的带参构造方法中显示的调用父类的带参构造
}
public String getProfessional() {
return professional;
}
public void setProfessional(String professional) {
this.professional = professional;
}
public void cure(){
System.out.println("治病");
}
}
Cuando se usa super para llamar al constructor de la clase principal, debe ser la primera declaración del constructor.
public class Doctor extends Person{
private String professional;
public Doctor(String name,String sex){
//报错，不是第一条语句
System.out.println("abc);
super(name,sex);
}
}
Si su método anula uno de los métodos de la clase principal, puede llamar al método anulado en la clase principal utilizando la palabra clave super .
También puedes usar super para hacer referencia a campos ocultos (aunque no se recomiendan los campos ocultos )
Campo oculto:
clase padre:
public class Person{
protected String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Subclase:
public class Doctor extends Person{
private String name;
public Doctor(String name){
this.name = name;
}
}
public class PersonTest{
public static void main(String[] args) {
Doctor d = new Doctor("Mis");
System.out.println(d.getName());
//null
}
}
Si desea obtener el nombre correspondiente, puede anular el método
Subclase:
public class Doctor extends Person{
private String name;
public Doctor(String name){
this.name = name;
}
@Override
public String getName() {
return name;
}
}
¿Qué sucede si desea obtener tanto las variables de la clase principal como las variables de la subclase?
Subclase:
public class Doctor extends Person{
private String name;
public Doctor(String name){
this.name = name;
}
public void show(){
System.out.println(this.name);//访问本类中定义的name变量
System.out.println(super.name);//访问父类中定义的变量
}
}
Si la subclase y la clase principal no tienen la misma variable miembro, puede usar this y super para llamar a la variable miembro de la clase principal en este momento
.
public class PersonTest{
public static void main(String[] args) {
Doctor d = new Doctor("Mis");
System.out.println(d.getName());
d.show();
}
}
todo es un objeto
Con la excepción de Objeto, que no tiene padre, cada clase tiene uno y sólo un padre directo (herencia única). En ausencia de cualquier otra superclase explícita, cada clase es implícitamente una subclase de Objeto.
Una clase puede derivarse de otra clase, que a su vez puede derivarse de otra clase, y así sucesivamente, y finalmente derivarse de la clase superior Objeto. Se dice que dicha clase es descendiente de todas las clases en la cadena de herencia, que se extiende hasta el Objeto.
Todas las clases son subclases de Objeto, por lo que al crear un objeto, debe llamar al constructor sin argumentos en la clase Objeto, y el Objeto en sí representa un objeto, por lo que se crean todos los objetos.
modificador final
Ámbito de aplicación:
el modificador final debe usarse en clases, variables y métodos.
Clase de modificación final:
Puedes declarar algunos o todos los métodos de una clase como finales. El uso de la palabra clave final en una declaración de método indica que las subclases no pueden anular el método.
La clase de objeto hace precisamente eso: muchos de sus métodos son finales.
Si una clase es modificada por final, significa que la clase es final, por lo que esta clase no se puede heredar, porque la herencia es para extender la clase.
public final class Person{
public void show(){
System.out.println("这里是最终类里的方法");
}
}
La subclase informa un error directamente.
public class Doctor extends Person{
}
método de modificación final
Nota:También puede declarar final toda la clase, y una clase declarada final no puede subclasificarse (heredarse). Por ejemplo: esto es especialmente útil
al crear clases inmutables como la clase String
public class Person{
public final void show(){
System.out.println("这是一个最终方法，不能被重写");
}
}
Informar un error directamente
public class Doctor extends Person{
public void show(){
}
}
variable modificadora final
Cuando final modifica una variable, la variable debe inicializarse cuando se construye el objeto.
Las variables modificadas por final se llaman constantes.
public class Doctor extends Person{
private final int number;
public Doctor(){
this.number = 10;
}
}