{1} orientadas a objetos Java
Una visión general orientada a objetos
Concepto
El llamado orientado a objetos es una especie de pensamiento de programación, a través de este tipo de pensamiento, la vida se puede simplificar, desde el ejecutor original hasta el comandante, el orientado a objetos se basa en el proceso de superficie.
A menudo decimos que la programación orientada a objetos (oop, programación orientada a objetos)
Process-oriented and emphasized time process, such as:
1. Open the refrigerator 2. Put the elephant in it 3. Close the refrigerator
Object-oriented emphasizes the result: for example:
When you are hungry, go to the platform to order food. This action is object-oriented. You didn't go to the market to buy vegetables, wash vegetables and cook. . . As long as there is an app
Característica:
Paquete:
Heredar:
Polimorfismo:
Dos, clases y objetos
1. Concepto
Clase:
1. El más básico del lenguaje java es la clase, que es similar al tipo:
2. La abstracción de una clase de cosas
3. Se puede entender como una plantilla o dibujo de diseño
Objeto:
Cada objeto tiene tres características: el estado del objeto, el comportamiento del objeto y la identidad del objeto
1. El estado del objeto se utiliza para describir las características básicas del objeto.
2. El comportamiento del objeto se utiliza para describir la función del objeto.
3. La identificación de un objeto significa que un objeto tiene una dirección única en la memoria para distinguirlo de otros objetos.
4. Una clase es una abstracción de una clase de cosas, y un objeto es una realización concreta
2. La relación entre los dos
El lenguaje informático se utiliza para describir el mundo real, a través de atributos + comportamiento
Describir las cosas a través de clases, considerar los atributos de transacción como variables miembro y el comportamiento como métodos miembro.
Analizar asuntos de teléfonos móviles:
Atributos: color, tamaño, marca, precio. . .
Método: llamar, enviar mensajes de texto, escuchar música. . . .
Clase: clase de teléfono móvil, extracción de los mismos atributos y comportamientos
Objeto: Muchos teléfonos móviles se pueden producir de acuerdo con la plantilla, como el objeto de teléfono móvil Nº 1, que contiene variables de miembro únicas y métodos de miembro
3. Creación y uso de clases y objetos
3.1 Creación y uso de una sola clase y objeto
Cree una clase a través de la palabra clave class y cree un objeto a través de la nueva palabra clave
package cn.tedu.hello.day06;
public class Test_Object1 {
public static void main(String[] args) {
// 4. Create an object test
//new Phone();//Anonymous object
//5. Create an object through the new keyword. The variable p of the reference type saves an address value
Phone phone = new Phone();
//Can the p object call the attributes and behaviors in the template?
phone.call();
phone.message();
phone.music();
//6, set the value of the attribute
phone.color = "red";
phone.size = 7;
phone.pinpai = "Xiaomi";
phone.price = 2999.0;
//7, print the value of the attribute
System.out.println(phone.color);
System.out.println(phone.size);
System.out.println(phone.pinpai);
System.out.println(phone.price);
}
}
//1. Create a class through the class keyword to describe things: attributes + behavior
class Phone {
//2. Attributes: color, size, brand, price - use member variables/member attributes to describe
String color;
int size;
String pinpai;
double price;
//3. Behavior: call, send text messages, listen to music - use member method to describe
//Method modifier method return value method name (parameter list) {method body}
public void call() {
System.out.println("On a call...");
}
public void message() {
System.out.println("sending...");
}
public void music() {
System.out.println("Now Playing...");
}
}
3.2 Almacenamiento de objetos en la memoria
Céntrese en la pila:
1. En términos generales, las variables locales existen en la pila y la memoria se liberará después de ejecutar el método.
2. El objeto (cosa nueva) existe en el montón, y la memoria se liberará cuando el objeto ya no se utilice;
3. Cada elemento de la memoria del montón tiene un valor de dirección
4. Las propiedades del objeto tienen valores predeterminados
3.3 Gráfico de memoria de un solo objeto
Proceso de implementación:
1. En la memoria de pila, abra espacio para almacenar variables locales/ variables de aplicación p;
2. En la memoria de la pila, abra el espacio, almacene los objetos y complete la inicialización;
3. En el elemento de memoria del montón, asigne un signo único —- valor de dirección y fígnelo a p para su custodia,
4.p,color = «red.p.size = 7; Espere a que la intercepción encuentre el valor de dirección único en la memoria del montón, busque el objeto de teléfono y modifique y asigne sus atributos.
5.p.call y otros métodos, simplemente vaya a la memoria del montón para encontrar el valor de dirección único, encontrar el objeto de teléfono, y ejecutar el método del teléfono.
** 3.4 Uso y creación de múltiples clases y objetos **
Crear la clase de coche
package cn.tedu.hello.day07;
//1, create a car class
class Car {
//Member Variables/Member Attributes - Characteristics
String color;
String pinpai;
String model;
double price;
//Member method-behavior
public void run() {
System.out.println("turning on...");
}
public void fly() {
System.out.println("Flying...");
}
}
Probar varios objetos
package cn.tedu.hello.day07;
//This class is used to test multiple objects
public class Test_Object {
public static void main(String[] args) {
//2, create a car object test (famous object)
Car car = new Car();
//Anonymous objects are also available, but anonymous objects can only do one thing at a time
// new Car().run();
// new Car().fly();
//Call the function in the template
car.run();
car.fly();
//Set the default value
car.color = "white";
car.model = "H6";
car.pinpai = "Hover";
car.price = 180000;
System.err.println(car.color);
System.err.println(car.model);
System.err.println(car.pinpai);
System.err.println(car.price);
System.out.println();
//Create multiple objects
Car car2 = new Car();
//Set the default value
car.color = "black";
car.model = "H9";
car.pinpai = "Hover";
car.price = 200000;
System.err.println("c2="+car.color);
System.err.println("c2="+car.model);
System.err.println("c2="+car.pinpai);
System.err.println("c2="+car.price);
System.out.println();
//Pass the attributes of car2 to car3
//The memory address recorded by car2 is handed over to car3 for storage. They are all reference-type variables, so all addresses are stored
//Used and car2 is an attribute
Car car3 = car2;
System.err.println("c3="+car.color);
System.err.println("c3="+car.model);
System.err.println("c3="+car.pinpai);
System.err.println("c3="+car.price);
}
}
3.5 Gráfico de memoria de varios objetos
Tres, embalaje
1 Visión general
Encapsulación hace referencia a ocultar las propiedades y los detalles de implementación de un objeto y solo proporcionar acceso público al exterior.
Beneficios de la encapsulación
Mejorar la seguridad
Proporcionar disponibilidad
2. Palabra clave privada
Es un modificador de permisos utilizado para modificar variables miembro y funciones miembro. Solo se puede acceder a los miembros privatizados en esta clase.
Si desea modificar, solo puede proporcionar métodos públicos, get y set para el objeto.
3. Paquete de contacto
Lea el código cuidadosamente y lentamente se dé cuenta de los beneficios de
package cn.tedu.privatedemo;
public class Test_Student {
//Test package
public static void main(String[] args) {
//Create student object
Student student = new Student();
//Call the method of the student class
//student.study();//Private methods, except for this class, cannot be accessed by the outside world
student.game();//Call the study method indirectly while calling the game method
// student.age = 20;
student.setAge(13);//Setting of private variables, set method
student.name = "Daniel";
student.subject = "mathematics";
System.out.println(student.getAge());//Use get method to get
System.out.println(student.name);
System.out.println(student.subject);
}
}
Clase de estudiante
package cn.tedu.privatedemo;
//Create a student class: attributes + behavior
class Student {
//If the modifier is not written, it is the default default, but if it is written, an error will be reported
// default int age;
//1, through the private keyword to achieve encapsulation
//2, if it is privatized, it can only be accessed in this class, and other classes can’t see it, and can’t use it
private int age;
// int age;
String name;
String subject;
//Create a get/set method to provide a global access point to the outside world
//set sets the value, get gets the value
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//Create method
//3, private can modify member variables or member methods
//private void study() {}
// public void study() {
// System.out.println("Learning...");
// }
private void study() {
System.out.println("Currently learning...");
}
public void game() {
study();//4. The study() method is privatized and cannot be accessed directly by the outside world, but can be accessed indirectly
System.out.println("Eating chicken...");
}
}
Expansión del conocimiento
1. El proceso de creación de un objeto
Person p = new Person();//A lot of things happened in this short line of code
1. Cargue el archivo de clase de persona en la memoria
2. Abra espacio en la memoria de pila para almacenar la variable p
3. En la memoria del montón, abra el espacio para almacenar objetos person
4. La inicialización predeterminada de las variables miembro
5. Mostrar e inicializar variables miembro
6. Ejecute el método de construcción (si hay un bloque de código de construcción, ejecute primero el bloque de código de construcción antes de ejecutar el método de construcción)
7. Memoria del montón completada
8. Asigne el valor de dirección de la memoria del montón a la variable p, p es una variable de referencia, que hace referencia al valor de dirección del objeto Perpon
2. Objetos anónimos
Un objeto sin nombre es una representación simplificada del objeto.
escenas que se utilizarán:
Cuando se llama al objeto llamado una vez (se crearán varios objetos varias veces, desperdiciando memoria)
Demo d = new Demo();
d.sleep();
d.game();
//This d is the name of the object.
También se puede escribir como
new Demo().show();//Created an object call method
new Demo().game();//Create another object call method
.
