Recientemente, un amigo dijo que quería decir que estaba aprendiendo Java recientemente. Todavía no entendía los lenguajes de programación orientados a objetos. Para ayudarlo a "transformarse" más rápido, escribí este artículo. Porque desde el nivel de superestructura. Las ideas de todos los lenguajes de programación orientados a objetos son similares, y estas tres características son los pilares en el pensamiento. A continuación, me centraré en explicar las tres características principales de Java.
Un lenguaje de programación orientado a objetos tiene tres características principales: "encapsulación", "herencia" y "polimorfismo".
Paquete
En la programación orientada a objetos, la encapsulación (encapsulación) es literalmente el significado del embalaje, lo que significa usar tipos de datos abstractos para encapsular datos y operaciones basadas en datos, lo que los convierte en una entidad independiente inseparable. De hecho, es para encapsular los métodos y datos requeridos para que el objeto se ejecute en el programa para publicar su interfaz. Los datos están protegidos dentro del tipo de datos abstractos, ocultando los detalles internos tanto como sea posible y solo conserva algunas interfaces externas para que se comunique con el exterior. En otras palabras, el usuario no necesita conocer los detalles dentro del objeto (por supuesto, no hay forma de saberlo), pero se puede acceder al objeto a través de la interfaz proporcionada por el objeto al exterior. En términos de Layman, otros objetos adjuntos a estas interfaces no necesitan preocuparse por la implementación del objeto para usar este objeto. El concepto es "No me digas cómo lo hiciste, solo hazlo".
Por lo tanto, la encapsulación privatiza las propiedades de un objeto y proporciona algunos métodos de atributos a los que el mundo exterior puede acceder. Si no queremos que el mundo exterior acceda a acceder, no tenemos que proporcionar métodos para acceder por el mundo exterior. Pero si una clase no proporciona métodos al mundo exterior para acceder, entonces esta clase no tiene sentido.
Por ejemplo, consideramos un objeto como una casa, y los hermosos fondos de pantalla en el interior, como sofás, televisores, aires acondicionados, etc., son atributos privados de la casa, pero si no hay cobertura de pared, ¡entonces no hay privacidad! Es debido al muro de bloqueo que no solo podemos tener nuestra propia privacidad, sino también cambiar las decoraciones interiores a voluntad sin afectar a los demás. Pero si no hay puertas y ventanas, ¿cuál es el significado de una caja negra bien envuelta? Por lo tanto, otros también pueden ver el paisaje dentro a través de puertas y ventanas. Por lo tanto, las puertas y las ventanas son las interfaces que dejan el objeto de la casa para que el mundo exterior acceda.
En general, el modificador privado debe agregarse antes del atributo en la clase. Luego defina los métodos Getter y Setter. Luego, los objetos en nuestra función principal ya no pueden llamar a las propiedades directamente, y solo pueden llamarse a través de los métodos de Getter y Setter.
Tres beneficios del embalaje
1. Un buen paquete puede reducir el acoplamiento.
2. La estructura dentro de la clase se puede modificar libremente.
3. Se puede dar un control más preciso de los miembros.
4. Ocultar información e implementar detalles.
Modificador
En primer lugar, debe entender qué es un modificador. Los modificadores de acceso se pueden usar para modificar el alcance de acceso de atributos y métodos.
En el proceso orientado a objetos, utilizamos el control de permisos para agregar permisos a la clase encapsulada para restringir la manipulación de la clase de los extraños, a fin de garantizar la seguridad de los datos y los métodos en la clase. Se puede decir que una clase es una entidad lógica que encapsula atributos y métodos relacionados. Para ciertas propiedades o métodos en un objeto, el mundo exterior no puede acceder a ellas. También se puede compartir y acceder a cualquier extraño. De esta manera, los objetos proporcionan diferentes niveles de protección para datos internos para evitar que las partes no relacionadas del programa cambien accidentalmente o usen partes privadas del objeto incorrectamente, lo que provoca errores innecesarios en el programa.
Los modificadores en Java son públicos, protegidos, predeterminados y privados. Esto muestra la encapsulación orientada a objetos, y debemos hacer todo lo posible para minimizar los permisos, para mejorar la seguridad.
Como se muestra en la figura, representa el alcance de acceso de diferentes modificadores de acceso, como las propiedades o métodos modificados por privado, a los que solo se puede acceder o usar en esta clase. Si no se agrega ningún modificador, el valor predeterminado es predeterminado, y se puede acceder y usar de forma predeterminada en la clase actual y el mismo paquete.
Acceso a los permisos de la clase Bun subclase Otros paquetes
público ∨ ∨ ∨ ∨
proteger ∨ ∨ ∨ ×
predeterminado ∨ ∨ × ×
Privado ∨ × × ×
Si no se agrega ningún modificador antes del atributo, el permiso predeterminado es predeterminado. Podemos modificar directamente el valor del atributo creando un objeto, y las características de encapsulación no se reflejan. Esto no es seguro en la programación, por lo que necesitamos usar la encapsulación para mejorar nuestro código.
Ejemplo de modificadores
Primero, definimos cuatro clases persona, padre, maestro, alumno, y comparamos las diferencias entre otros paquetes, subclases, paquetes y esta clase. Se muestra el diagrama de ubicación de cada clase.
paquete com.java.test; public class Person {public String Name = "Zhang San"; public void IntroucemySelf () {System.out.println (nombre); }}El nombre es público. Si no hay error en la compilación, significa que la variable pública tiene acceso a esta clase.
paquete com.java.test; estudiante de clase pública {persona p = nueva persona (); public void test () {System.out.println (p.uname); }}El estudiante y la persona están en el mismo paquete. Si no hay error en la compilación, significa que la variable tiene derechos de acceso en el mismo paquete.
paquete com.java.test1; import com.java.test.person; el maestro de clase pública extiende a la persona {public int Age; Persona p = nueva persona (); public void test1 () {System.out.println (p.uname); }}El estudiante y la persona no están en el mismo paquete, pero el maestro hereda la clase de la persona. Si no hay error en la compilación, significa que la variable tiene derechos de acceso en el subpackage.
paquete com.java.test1; import com.java.test.person; public class Padres {public String uname = "jaja"; Persona p = nueva persona (); public void test2 () {System.out.println (p.uname); }}El padre y la persona no están en el mismo paquete. Si no hay error en la compilación, significa que la variable no tiene permisos de acceso.
Después de la prueba anterior, si todos ellos pueden ser compilados y aprobados, significa que las clases modificadas con público pueden acceder entre sí en esta clase, el mismo paquete, subclase y otros paquetes.
También comenzamos a probar el problema de permiso protegido. Si la persona, el maestro y el alumno pueden compilar y pasar, significa que las clases modificadas con protegidos pueden acceder entre sí en esta clase, el mismo paquete y subclases. Si el padre no se compila y no pasa, significa que protegidos no pueden acceder entre sí en clases sin relaciones de herencia fuera del paquete.
También comience a probar el problema de permiso predeterminado. Si la persona y el estudiante pueden compilar y pasar, significa que las clases modificadas con el valor predeterminado pueden acceder entre sí en esta clase, el mismo paquete y subclases. La compilación de padres y maestros sin aprobar la clase de padres y maestros no puede acceder entre sí, independientemente de si existe una relación de herencia.
También comenzamos a probar el problema de permiso privado. Si la persona puede ser compilada y aprobada, significa que las clases modificadas con privadas pueden acceder entre sí en esta clase, el mismo paquete y subclases. El padre, el maestro y el alumno no pueden compilar sin aprobar el privado para indicar que las clases modificadas con privado solo pueden acceder en esta clase.
En general, se deben agregar modificadores privados antes de los atributos en la clase. Luego defina los métodos Getter y Setter. Luego, los objetos en nuestra función principal ya no pueden llamar a las propiedades directamente, y solo pueden llamarse a través de los métodos de Getter y Setter.
Bolsa
Déjame decirte la función de la bolsa
A veces, cuando te encuentras, el nombre de clase del programa puede duplicarse, podemos usar el concepto de paquete para resolver nuestro problema. El propósito del paquete es administrar archivos Java y resolver conflictos de archivos con el mismo nombre. Esto es similar a un armario. ¿Tenemos diferentes particiones y cajones en el armario? Colocamos la ropa por separado en diferentes categorías, lo que es más propicio para nuestra gestión.
Para definir un paquete, usamos la palabra clave del paquete, además de nuestro nombre de paquete.
paquete com.java.test; // NOTA: debe colocarse en la primera línea del programa fuente, y el nombre del paquete puede ser separado por el "". firmar. La especificación de nombres del paquete se deletrea con todas las letras minúsculas.
Paquetes de uso común en el sistema Java
Java. (Función). (Clase) Java.lang. (Clase) contiene los conceptos básicos del lenguaje Java Java.util. (Clase) contiene varias clases de herramientas en el idioma java.io. (clase) contiene clases relacionadas con la entrada y salida.
Para usar la clase en otro archivo en diferentes paquetes, debe usar la palabra clave de importación. Por ejemplo, importa com.java.test1.test.java. Al mismo tiempo, si importe com.java.test1*, importe todos los archivos en el paquete.
esta palabra clave
1. Hay tres aplicaciones principales de esta palabra clave:
(1) Esto llama a los atributos en esta clase, es decir, las variables del miembro en la clase;
(2) Esto llama a otros métodos en esta clase;
(3) Esto llama a otros constructores en esta clase, y debe colocarse en la primera línea del constructor al llamar.
Public Class Student {Public Student (nombre de cadena) {// Defina un constructor con parámetros formales} Public Student () {// Defina un método, el nombre es el mismo que la clase, por lo que es el constructor esto ("¡Hola!"); } Nombre de cadena; // Definir un nombre de variable de miembro privado setname (nombre de cadena) {// Defina un parámetro (variable local) nombre this.name = name; // Pase el valor de la variable local a la variable miembro}}Como en el código anterior, hay un nombre de variable miembro, y hay un parámetro formal en el método, y el nombre también es el nombre. Luego, el valor del nombre del parámetro formal se pasa al nombre de la variable miembro en el método.
La palabra clave esto representa variables o métodos miembros en el objeto. Es decir, si se agrega una variable con esta palabra clave, se refiere a la variable o el método del miembro del objeto, en lugar de los parámetros formales o las variables locales del método miembro. Por esta razón, en el código anterior, este.name representa la variable miembro en el objeto, también conocida como propiedades del objeto, y el nombre seguido es el parámetro formal del método. El código this.name = name es pasar el valor del parámetro formal a la variable miembro.
Si hay múltiples constructores en una clase porque sus nombres son los mismos y los mismos que el nombre de la clase, ¿qué constructor se llama esto? De hecho, este es lo mismo que usar otros métodos para referirse a constructores, y se llaman a través de parámetros formales. Como en el ejemplo anterior, si se agrega un parámetro después de esta palabra clave, significa que se refiere a un constructor con parámetros. Si ahora hay tres métodos de construcción, a saber, sin parámetros, un parámetro y dos parámetros. Luego, el compilador Java determinará qué constructor llamar en función del número de parámetros aprobados. Como se puede ver en el ejemplo anterior, esta palabra clave se puede usar no solo para hacer referencia a las variables de los miembros, sino también a los constructores de referencia.
Clase interna
La clase interior es muy fácil de entender desde el exterior. La clase interna es colocar la definición de una clase dentro de la definición de otra clase. Por supuesto, correspondiente a esto, una clase que contiene una clase interna se llama clase externa.
Muchos principiantes definitivamente preguntarán por qué una clase debería definirse en otra clase.
A veces hay algunos problemas en nuestra programación que son difíciles de resolver usando interfaces. En este momento, podemos usar la capacidad proporcionada por las clases internas para heredar múltiples clases concretas o abstractas para resolver estos problemas de programación. Se puede decir que las interfaces solo resuelven algunos problemas, mientras que las clases internas hacen que la solución de la herencia múltiple sea más completa.
Hay una oración en "Think in Java": la razón más atractiva para usar clases internas es que cada clase interior puede heredar independientemente una implementación (interfaz) de forma independiente, por lo que si la clase periférica ha heredado una cierta implementación (interfaz) no tiene ningún efecto en la clase interna.
Interfaz pública Padre {} Public Interface Madre {} Hijo de clase pública Implementa Padre, Madre {} Hija de clase pública Implementa Padre {Class Mother_ implementa Madre {}}Características de clase internas
1. La clase interna puede usar múltiples instancias, cada instancia tiene su propia información de estado y es independiente de otra información de objetos periféricos.
2. En una sola clase periférica, múltiples clases internas pueden implementar la misma interfaz de diferentes maneras o heredar la misma clase.
3. El momento en que se cree un objeto de clase interna no depende de la creación de objetos de clase periférica.
4. No hay una relación confusa "IS-A" en la clase interna, es una entidad independiente.
5. La clase interna proporciona una mejor encapsulación, y no se puede acceder a otras clases, excepto para la clase periférica.
paquete com.java.test; public class OuterClass {Nombre de cadena privada; edad privada int; public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } public int getAge () {return Age; } public void setAge (int Age) {this.age = edad; } public void display () {System.out.println ("se llama la visualización de clases exteriores"); } public class InnClass {public innClass () {name = "Chenssy"; edad = 23; } public OuterClass getouterClass () {return outterClass.This; } public void display () {System.out.println ("name:" + getName () + "; edad:" + getage ()); }} public static void main (string [] args) {OuterClass OuterClass = new OuterClass (); OuterClass.innerClass InnClass = OuterClass.New InnClass (); inNerClass.display (); innerClass.getouterClass (). Display (); }} Nombre: Chenssy; Edad: 23La visualización de la clase externa se llama
Necesitamos tener claro que las clases internas son un concepto de tiempo de compilación. Una vez compilados con éxito, pertenecen a dos clases completamente diferentes de clases periféricas (por supuesto, todavía están relacionadas).
También vemos cómo hacer referencia a la clase interna: refiriéndose a la clase interna necesitamos especificar el tipo de este objeto: OuterClasname.innerClassName. Al mismo tiempo, si necesitamos crear un objeto de clase interna, debemos usar el objeto de clase externa para crear una clase interna a través de .new: OuterClass.innerClass InnerClass = OuterClass.New Innerclass ();.
Al mismo tiempo, si necesitamos generar una referencia al objeto de clase externa, podemos usar OuterClassName.o, para que podamos generar una referencia a la clase externa correctamente.
En Java, las clases internas se dividen principalmente en clases internas de miembros, clases internas locales, clases internas anónimas y clases internas estáticas.
Clase interna del miembro
La clase interna del miembro también es la clase interna más común. Es un miembro de la clase periférica, por lo que puede acceder a todos los atributos y métodos de los miembros de la clase periférica sin limitación. Aunque es privado, si la clase periférica quiere acceder a los atributos y métodos del miembro de la clase interna, debe acceder a través de la instancia de clase interna.
Se deben prestar dos puntos en la clase interna de miembros.
No puede haber variables y métodos estáticos en la clase interna del miembro;
Las clases internas de los miembros están conectadas a clases periféricas, por lo que las clases internas solo se pueden crear si las clases periféricas se crean primero.
clase pública OuterClass {private String Str; public void outerdisplay () {System.out.println ("OuterClass ..."); } public class Innclass {public void innerdisplay () {// use el atributo STR en el periférico str = "Chenssy ..."; System.out.println (str); // use el método exterdisplay (); }} /*Recomendado para usar getxxx () para obtener clases internas del miembro, especialmente cuando el constructor de la clase interna no tiene parámetros* / public innclass getInnerClass () {return new InnerClass (); } public static void main (string [] args) {outerClass outer = new OuterClass (); OuterClass.innerClass Inner = Outer.getInnerClass (); inner.innerdisplay (); }}Personalmente, recomiendo usar getxxx () para obtener la clase interna del miembro, especialmente cuando el constructor de esta clase interna no tiene parámetros.
Oración clase interna local
Las clases internas locales están anidadas dentro de métodos y ámbitos. El uso de esta clase es principalmente para aplicar y resolver problemas relativamente complejos. Quiero crear una clase para ayudar a nuestra solución. En ese momento, no quiero que esta clase sea pública, por lo que podemos crear clases internas locales.
Las clases internas locales se compilan como clases internas de miembros. Solo se pueden usar en este método y atributo. Si no están en este método y atributo, no serán válidos.
Definido en el método:
public class parcel5 {Public Destionation Destination (String Str) {class PDestionation implementa Destion {private String Label; Private PDestion (String Whereto) {Label = WhereTo; } public String readLabel () {etiqueta de retorno; }} return New PDestion (STR); } public static void main (string [] args) {parcel5 parcel5 = new parcel5 (); Destion D = Parcel5.destionation ("Chenssy"); }}Definido dentro del alcance:
Public Class Parcel6 {private void internalTracking (boolean b) {if (b) {class rastreyingslip {private string id; Rackingslip (string s) {id = s; } Cadena getSlip () {return id; }} Backingslip ts = new TrackingsLip ("Chenssy"); String String = ts.getslip (); }} public void Track () {internalTracking (true); } public static void main (string [] args) {parcel6 parcel6 = new parcel6 (); parcel6.track (); }}Clase interna anónima
public class OuterClass {public InnClass getInnerClass (final int num, string str2) {return new InnerClass () {int number = num + 3; public int getNumber () {número de retorno; }}; / * NOTA: Los semicolones no pueden salvar */} public static void main (string [] args) {outerClass out = new OuterClass (); InnerClass inner = out.getInnerClass (2, "Chenssy"); System.out.println (inner.getNumber ()); }} Interface InnClass {int getNumber ();}1. Las clases internas anónimas no tienen modificadores de acceso.
2. Nueva clase interna anónima, esta clase debe existir primero. Si comentamos que la interfaz de la Clase Interna, se producirá un error de compilación.
3. Presta atención a los parámetros formales del método getInnerClass (). El primer parámetro formal se modifica con final, mientras que el segundo no. Al mismo tiempo, también descubrimos que el segundo parámetro formal no se ha utilizado en la clase interna anónima, por lo que cuando el parámetro formal del método debe ser utilizado por la clase interna anónima, entonces este parámetro formal debe ser final.
4. No hay constructor para clases internas anónimas. Porque ni siquiera tiene un nombre para construirlo.
Clase interior estática
Static puede modificar variables de miembros, métodos, bloques de código y otras clases internas. Llamamos a clases internas modificadas con estática como estática, pero preferimos llamarlas clases internas anidadas. La mayor diferencia entre las clases internas estáticas y las clases internas no estáticas es que después de completar la compilación, se ocultará una referencia y el uso apuntará a su periferia. Pero la clase interna estática no lo hace, lo que significa que la creación de clase interna estática no necesita confiar en clases periféricas, y no puede usar variables y métodos de miembros no estáticos de ninguna clase periférica.
Clase pública OuterClass {privado de sexo de cadena; Nombre de cadena estática pública = "Chenssy"; / ***Clase interna estática*/ Clase estática InnClass1 {/*Los miembros estáticos pueden existir en la clase interna estática*/ public static String _name1 = "Chenssy_static"; Public void Display () { /** La clase interna estática solo puede acceder a variables y métodos de miembros estáticos de la clase periférica* no puede acceder a variables de miembros no estáticos y métodos de clase periférica* / system.out.println ("Nombre de clase:" + nombre); }} / *** clase interna no estática* / clase InnClass2 { /* Los miembros estáticos no pueden existir en clases internas no estáticas* / public String _name2 = "Chenssy_inner"; / * Cualquier miembro de la clase periférica puede llamarse en clases internas no estáticas, ya sean estáticas o no estáticas */ public void Display () {System.out.println ("Nombre de la clase externas:" + nombre); }} /** * @Desc Método de clase periférica * @author Chenssy * @data 2013-10-25 * @return void * /public void display () { / * La clase periférica accesos la clase interna estática: clase interna. */ System.out.println (innerClass1._name1); /* Una clase interna estática se puede crear directamente sin confiar en las clases periféricas*/ new InnerClass1 (). Display (); /* Una creación interna no estática debe confiar en las clases periféricas*/ externa. /* Los miembros de la clase interna no estática deben usar instancias de clase interna no estática*/ system.out.println (inner2._name2); inner2.display (); } public static void main (string [] args) {outerClass outer = new OuterClass (); externo.display (); }}Resumir
Lo anterior es el resumen de las tres características principales de Java: conocimiento encapsulado que el editor le presentó. Espero que te sea útil. Si tiene alguna pregunta, déjame un mensaje y el editor le responderá a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!