Orientado a objetos
Java es un lenguaje orientado a objetos, así que antes de aprender formalmente Java, primero comprendamos qué es la orientación a objetos.
Orientado a objetos se refiere a un paradigma de programación, así como a un método de programación. El objeto es la realización concreta de la clase. Toma los objetos como la unidad básica del programa y encapsula el programa y los datos para mejorar la reutilización, la flexibilidad y la escalabilidad del software. Todo es un objeto. A través de una forma orientada a objetos, abstrae las cosas del mundo real en objetos. Realidad Las relaciones en el mundo se abstraen en clases y se heredan para ayudar a las personas a realizar la abstracción y el modelado digital del mundo real.
Tres características de la orientación a objetos: encapsulación, herencia, polimorfismo
La encapsulación se refiere a la privatización de atributos, el propósito es mejorar la seguridad de los datos, no permitir que otros usuarios accedan y modifiquen los datos a voluntad, simplificar la programación, los usuarios no necesitan preocuparse por los detalles específicos de implementación, sino solo a través de la interfaz externa para acceder a los miembros de la clase
- Proporcione métodos de establecimiento y obtención para acceder a las propiedades según sea necesario
- Oculte atributos específicos y detalles de implementación, y solo abra interfaces al mundo exterior
- Controlar el nivel de acceso de los atributos en el programa.
Por ejemplo, el siguiente código:
En la clase User, se definen tres variables miembro, a saber, idCard, name y user, su modificación de acceso es privada, y estas variables se establecen y valoran a través de los métodos setter y getter.
public class User {
private String idCard;
private String name;
private User user;
public String getIdCard() {
return idCard;
}
public void setIdCard(String idCard) {
this.idCard = idCard;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}La herencia se refiere a la construcción de una nueva clase (subclase) sobre la base de una clase existente (clase principal), la subclase puede acceder y utilizar las variables de miembros no privados en la clase principal y reescribir los miembros no privados en el método de clase padre. Pero no se puede acceder ni llamar a las variables y métodos de miembros privados en la clase principal). El papel de la herencia es mejorar la reutilización del código.
- Una clase en Java solo puede heredar una clase principal y solo puede heredar derechos de acceso, atributos y métodos no privados.
- La subclase puede anular el método en la clase principal y nombrar el atributo con el mismo nombre en la clase principal.
Por ejemplo, el siguiente código define una altura de variable privada, un peso de variable pública, un método privado showHeight () y un método público showWeight () en la clase principal respectivamente;
Llamadas y reescritas por separado en la subclase, las variables y métodos privados no son accesibles por la subclase, la subclase solo tiene acceso a una variable y método públicos, y la subclase anula el método público showWeight () de la clase principal;
padre:
public class User {
private String idCard;
private String name;
private int height=180;//父类私有变量
public int weight=90;//父类公有变量
private User user;
public String getIdCard() {
return idCard;
}
public void setIdCard(String idCard) {
this.idCard = idCard;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
//父类私有方法
private void showHeight() {
System.out.println("user showheight:"+height);
}
//父类公有方法
public void showWeight() {
System.out.println("user showheight:"+weight);
}
}
Subclase:
public class Women extends User{
@Override
public void showWeight() {
System.out.println("user showheight:子类的体重为"+weight);
}
public static void main(String[] args) {
Women women=new Women();
// women.height=150; //子类对象对父类的私有成员变量使用报错
women.weight=88;//子类对象对父类的公有成员变量使用正常
// women.showHeight(); //子类对象调用父类的私有方法使用报错
women.showWeight(); //子类对象调用父类的私有方法使用正常
}
}
El polimorfismo se puede dividir en dos tipos: polimorfismo en tiempo de diseño y polimorfismo en tiempo de ejecución.
Polimorfismo durante el diseño (compilación): Sobrecarga, lo que significa que Java permite el mismo nombre de método pero diferentes parámetros (el valor de retorno puede ser el mismo o diferente), y una o más funciones con el mismo nombre están permitidas en la misma clase. siempre que el tipo de parámetro o el número de parámetros sea diferente
Polimorfismo en tiempo de ejecución: la anulación debe estar en el sistema de herencia, la subclase anula el método de la clase principal y el tiempo de ejecución de la JVM determina a qué método llamar de acuerdo con el tipo de método llamado.
El código se muestra en el siguiente ejemplo
public class Women extends User{
int CurrentWeight;
//重写showWeight方法
@Override
public void showWeight() {
System.out.println("user showheight:子类的体重为"+weight);
}
//重载showWeight方法
public void showWeight(int CurrentWeight) {
System.out.println("当前体重为"+CurrentWeight);
}
public static void main(String[] args) {
Women women=new Women();
// women.height=150; //子类对象对父类的私有成员变量使用报错
women.weight=88;//子类对象对父类的公有成员变量使用正常
// women.showHeight(); //子类对象调用父类的私有方法使用报错
women.showWeight(); //子类对象调用父类的私有方法使用正常
women.showWeight(66);//重载的方法
}
}