Aprendizaje Java: orientado a objetos (1)

Cuarto, orientado a objetos (1)

4.1 Orientado a procesos y orientado a objetos

Orientado a procesos (POP) vs. Orientado a objetos (OOP)

• Ambos son un tipo de pensamiento, y la orientación a objetos es relativa a la orientación a procesos. Orientado a procesos, el énfasis está encomportamiento funcional, tomando la función como la unidad más pequeña, considereCómo hacerlo. Orientado a objetos, encapsulando funciones en objetos, enfatizandoobjeto funcional, tomando clase/objeto como la unidad más pequeña, considerequien lo hara。
• Orientado a objetos enfatiza el uso de métodos y principios de pensamiento utilizados por humanos en la lógica del pensamiento diario, como abstracción, clasificación, herencia, agregación, polimorfismo, etc.

Tres características de la orientación a objetos

• Encapsulación
• Herencia
• Polimorfismo

4.2 Elementos básicos del lenguaje Java: clases y objetos

Clase (Class) y object (Object) son los conceptos centrales de la orientación a objetos.

• Una clase es una descripción de una clase de cosas, una definición conceptual abstracta.
• Un objeto es cada individuo de este tipo de cosa que realmente existe, por lo que también se le llama instancia.
• Puede entenderse como: clase = concepto abstracto persona; objeto = persona real
• El enfoque de la programación orientada a objetos es
  el diseño de la clase.El diseño de la clase es en realidad el diseño de los miembros de la clase.

Miembros de la clase
Los miembros comunes de la clase son:

• Atributo: variable miembro en la clase correspondiente
• Comportamiento: el formato gramatical de la clase de método miembro en la clase correspondiente
  
  

修饰符 class 类名 {
    
    
	属性声明;
	方法声明;
}
说明：修饰符public：类可以被任意访问
		类的正文要用{
    
     }括起来

举例：
public class Person{
    
    
	private int age ; //声明私有变量 age
	public void showAge(int i) {
    
     //声明方法showAge( )
		age = i;
	}
}

4.3 Creación y uso de objetos

Crear sintaxis de objetos: nombre de clase nombre de objeto = nuevo nombre de clase ();
use " nombre de objeto. miembro de objeto " para acceder a los miembros de objetos (incluidas las propiedades y los métodos).

举例：
public class Zoo{
    
    
	public static void main(String args[]){
    
    
		//创建对象
		Animal xb=new Animal();
		xb.legs=4;//访问属性
		System.out.println(xb.legs);
		xb.eat();//访问方法
		xb.move();//访问方法
	}
}

Ejercicio: escriba una clase de maestro y una clase de estudiante, y cree objetos a través de la clase de prueba para probar

//Student类
package demo04;

public class Student {
    
    
    private String name;
    private int age;
    private String major;
    private String interests;

    public Student(String name, int age, String major, String interests) {
    
    
        this.name = name;
        this.age = age;
        this.major = major;
        this.interests = interests;
    }

    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 getMajor() {
    
    
        return major;
    }

    public void setMajor(String major) {
    
    
        this.major = major;
    }

    public String getInterests() {
    
    
        return interests;
    }

    public void setInterests(String interests) {
    
    
        this.interests = interests;
    }
    public void study(){
    
    
        System.out.println("学生姓名："+name);
        System.out.println("学生年龄："+age);
        System.out.println("学科："+major);
        System.out.println("兴趣："+interests);
    }
}

//Teacher类
package demo04;

public class Teacher {
    
    
    private String name;
    private int age;
    private int teachAge;
    private String course;

    public Teacher(String name, int age, int teachAge, String course) {
    
    
        this.name = name;
        this.age = age;
        this.teachAge = teachAge;
        this.course = course;
    }

    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 int getTeachAge() {
    
    
        return teachAge;
    }

    public void setTeachAge(int teachAge) {
    
    
        this.teachAge = teachAge;
    }

    public String getCourse() {
    
    
        return course;
    }

    public void setCourse(String course) {
    
    
        this.course = course;
    }
    public void teach(){
    
    
        System.out.println("教师姓名："+name);
        System.out.println("教师年龄："+age);
        System.out.println("教龄："+teachAge);
        System.out.println("教授课程："+course);
    }
}

//test类
package demo04;

public class test {
    
    
    public static void main(String[] args) {
    
    
        //教师类创建新对象
        Teacher teacher = new Teacher("李老师",35,10,"数学");
        teacher.teach();

        //学生类创建新对象
        Student student = new Student("田天赐",20,"Java","编程");
        student.study();
    }
}

->运行结果：
教师姓名：李老师
教师年龄：35
教龄：10
教授课程：数学
学生姓名：田天赐
学生年龄：20
学科：Java
兴趣：编程

Suplemento: tecla de atajo de idea

Serie "Alt +"

Alt + / Código de finalización rápida (debe recordarse, también es el más utilizado)
Alt + Ingresar finalización rápida, cuando puede haber problemas gramaticales en el código, IDEA le indicará que use esta tecla de método abreviado para corregir rápida y automáticamente (muy potente , el uso más común)
Alt + insertar para generar rápidamente constructores con parámetros arbitrarios y métodos Getter/Setter para propiedades privadas, etc. (más comúnmente utilizado) Alt+
Q Mostrar la declaración del método actual
Alt + 7 Mostrar rápidamente la clase estructura, que puede mostrar la clase que contiene Todas las propiedades y métodos de
Alt + izquierda / derecha Cambiar rápidamente la vista del código
Alt + Arriba / Abajo Mover y ubicar rápidamente entre métodos (es decir, el cursor se mueve en unidades de métodos)

"Ctrl + "Serie

Ctrl + W Selecciona el texto, presiona continuamente para expandir el rango seleccionado (en palabras)
Ctrl + Y Elimina la línea actual
Ctrl + D Copia la línea actual, copia la línea actual directamente en la siguiente línea (Copia duplicada)
Ctrl + / Agregar comentarios y cancelar comentarios, [la primera vez es para agregar comentarios, la segunda vez es para descomentar]
Ctrl + F para buscar texto en el archivo actual (Buscar búsqueda)
Ctrl + R para buscar y reemplazar texto (básicamente puede completar la función de Ctrl + F), admitir varias líneas Buscar, o solo buscar en el código, o solo buscar en los comentarios, o usar expresiones regulares para buscar (Reemplazar reemplazar) Ctrl + O para reescribir rápidamente el método
en la clase base o interfaz (Anular reescribir)
Ctrl + H para mostrar la estructura de clases Diagrama (jerarquía de herencia de clases) (nivel de jerarquía)
Ctrl + G Navegar rápidamente a la fila y columna especificadas
Ctrl + [ Navegar rápidamente al principio del bloque de código
Ctrl + ] Navegar rápidamente a el final del bloque de código
Ctrl + N Busque rápidamente y abra la clase
Ctrl + B Localice rápidamente el código fuente, coloque el cursor en el método e ingrese, puede ir al código fuente del método
Ctrl + U ir rápidamente al clase padre de la clase actual

Serie de llaves combinadas

Ctrl + Alt + T Ajusta el código seleccionado con if, while, try/catch y otros bloques de código (potente)
Ctrl + Alt + L Código de formato rápido
Ctrl + Alt + I Sangría automáticamente para
Ctrl+Alt+O para optimizar las clases de importación y paquetes

4.4 Uno de los miembros de la clase: atributo (campo)

Formato de gramática : nombre de atributo de tipo de datos modificador = valor de inicialización;

• Nota 1: Modificadores
  Los modificadores de permisos comúnmente utilizados son: privado, predeterminado, protegido, público
  Otros modificadores: estático, final (aún no considerado)
• Nota 2: Tipo de datos
  Cualquier tipo de datos básico (como int, booleano) o cualquier tipo de datos de referencia.
• Nota 3: El nombre del atributo
  es un identificador y solo debe cumplir con las reglas y especificaciones de denominación.

举例：
public class Person{
    
    
	private int age; //声明private变量 age
	public String name = “Lila”; //声明public变量 name
}

Clasificación de variables: variables miembro y variables locales

• Fuera del cuerpo del método, las variables declaradas en el cuerpo de la clase se denominan variables miembro.

• Las variables declaradas dentro del cuerpo del método se denominan variables locales.
  
  == Nota ==: Las similitudes y diferencias entre los dos en términos de valores de inicialización:

    同：都有生命周期
    异：局部变量除形参外，均需显式初始化。
  

La diferencia entre las variables miembro (atributos) y las variables locales:

4.5 El segundo miembro de la clase: method (método)

• Un método es una abstracción de las características de comportamiento de una clase u objeto, y se utiliza para completar una determinada operación funcional. También conocida como función o procedimiento en algunos lenguajes.
• El propósito de encapsular funciones como métodos es lograr la reutilización del código y simplificar el código.
• Los métodos en Java no pueden existir de forma independiente, todos los métodos deben estar definidos en la clase.

Formato de declaración de método:

修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
	方法体程序代码
	return 返回值;
｝
其中：
修饰符：public,缺省,private, protected等
返回值类型：
>没有返回值：void。
>有返回值，声明出返回值的类型。与方法体中“return 返回值”搭配使用
方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”
形参列表：可以包含零个，一个或多个参数。多个参数时，中间用“,”隔开
返回值：方法在执行完毕后返还给调用它的程序的数据。

举例：
public class Person{
    
    
	private int age;
	public int getAge() {
    
     //声明方法getAge()
		return age; 
}
	public void setAge(int i) {
    
     //声明方法setAge
		age = i; //将参数i的值赋给类的成员变量age
	}
}

Clasificación de métodos: según existan parámetros formales y valores de retorno

Aviso:
(1) Primero debe declararse y luego usarse, y el método debe definirse dentro de la clase
(2) Se ejecutará una vez que se llame, y no se ejecutará si no se llama.
(3) Los métodos o atributos de la clase se pueden llamar en el método y los métodos no se pueden definir dentro del método.

Ejemplo correcto:

类{
    
    
    方法1(){
    
    
        
    }
    方法2(){
    
    
        
    }
}

Ejemplo de error:

类{
    
    
    方法1(){
    
    
        方法2(){
    
      //位置错误
        
   		}
    }
}

4.5.1 Sobrecarga de métodos

El concepto de sobrecarga:
En una misma clase, se permite más de un método con el mismo nombre, siempre que su número de parámetros o tipos de parámetros sea diferente.
Características de la sobrecarga:
no tiene nada que ver con el tipo de valor de retorno, solo mire la lista de parámetros y la lista de parámetros debe ser diferente. (número de parámetro o tipo de parámetro). Al llamar, se distingue según la lista de parámetros del método.
Llamada de método sobrecargada : la JVM llama al método coincidente a través de la lista de parámetros del método.

Primero busque el número y el tipo que mejor coincidan
y, a continuación, busque el número y el tipo que sean compatibles. Si varios métodos son compatibles al mismo tiempo, se informará un error.

Ejemplo de sobrecarga :

//返回两个整数的和
int add(int x,int y){
    
    return x+y;}
//返回三个整数的和
int add(int x,int y,int z){
    
    return x+y+z;}
//返回两个小数的和
double add(double x,double y){
    
    return x+y;}

举例：
public class PrintStream {
    
    
	public static void print(int i) {
    
    ……}
	public static void print(float f) {
    
    ……}
	public static void print(String s) {
    
    ……}
	public static void main(String[] args) {
    
    
		print(3);
		print(1.2f);
		print("hello!");
	}
}

4.5.2 Mecanismo de paso de valor de los parámetros del método

Un método debe ser llamado por su clase u objeto para que sea significativo. Si el método tiene parámetros:

• Parámetro formal: el parámetro cuando se declara el método
• Parámetro real: el valor del parámetro realmente pasado al parámetro formal cuando se llama al método

¿Cómo pasar el valor del parámetro real de Java al método?

Solo hay una forma de pasar parámetros a métodos en Java: pasar por valor. Es decir, se pasa una copia (réplica) del valor del parámetro real al método, mientras que el parámetro en sí no se ve afectado.
El parámetro formal es un tipo de dato básico: el parámetro real de la variable de tipo de dato básico "valor de los datos"Pasar a
parámetro formal El parámetro formal es un tipo de datos de referencia: la variable de tipo de datos de referencia del parámetro real"valor de dirección"pasado al parámetro

练习：
1.定义一个int型的数组：int[] arr = new int[]{
    
    12,3,3,34,56,77,432};
让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组
//正确写法1
for(int i = arr.length – 1;i >= 0;i--){
    
    
	arr[i] = arr[i] / arr[0];
}
//正确写法2
int temp = arr[0];
for(int i= 0；i < arr.length;i++){
    
    
	arr[i] = arr[i] / temp;
}

2.
int[] arr = new int[10];
System.out.println(arr);//地址值? [I@d716361
char[] arr1 = new char[10];
System.out.println(arr1); //地址值?           10个空值

3.
（1）定义一个Circle类，包含一个double型的radius属性代表圆的半径，一个findArea()方法返回圆的面积
（2）定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：public void printAreas(Circle c, int time)在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。
（3）在main方法中调用printAreas()方法，调用完毕后输出当前半径值。

//Circle类
package demo05;

public class Circle {
    
    
    private double radius;

    public Circle(double radius) {
    
    
        this.radius = radius;
    }

    public double getRadius() {
    
    
        return radius;
    }

    public void setRadius(double radius) {
    
    
        this.radius = radius;
    }

    public double findArea(){
    
    
        return  radius*radius*Math.PI;

    }
}
//PassObject类
package demo05;

public class PassObject {
    
    
    public void printAreas(Circle c,int time){
    
    
        System.out.println("Radius\t\tArea");
        for (int i = 1;i <= time;i++) {
    
    
            c.setRadius(i);
            System.out.println(c.getRadius() + "\t\t" + c.findArea());
        }
    }
}

//Main类
package demo05;

public class Main {
    
    
    public static void main(String[] args) {
    
    
        PassObject passObject = new PassObject();
        Circle circle = new Circle(0);
        passObject.printAreas(circle, 5);
        System.out.println("nuw radius is: " + circle.getRadius());
    }
}

>运行结果
Radius		Area
1.0		3.141592653589793
2.0		12.566370614359172
3.0		28.274333882308138
4.0		50.26548245743669
5.0		78.53981633974483
nuw radius is: 5.0

4.5.3 Métodos recursivos

**Llamada a método recursivo:** El fenómeno que un método llama a sí mismo se llama recursividad.

Clasificación de la recursión: recursión directa, recursión indirecta.

• Recurrencia directa: el método en sí mismo se llama a sí mismo.

  public void methodA(){
        
        
  	methodA();
  }
  

• Recursión indirecta: se puede entender que el método A() llama al método B(), el método B() llama al método C() y el método C() llama al método A().

```java
  ```java
  public static void A(){
    
    
  	B();
  }
  
  public static void B(){
    
    
  	C();
  }
  
  public static void C(){
    
    
  	A();
  }

Descripción :

• Un método recursivo contiene uno 隐式的循环.
• Un método recursivo ejecuta 重复执行una determinada pieza de código, pero esta ejecución repetida no requiere un control de bucle.
• La recursión debe ir a 已知方向la recursión, de lo contrario, esta recursión se convierte en recursión infinita, que no se puede detener, similar a 死循环. eventualmente sucedió 栈内存溢出.

Ejemplo 1: Calcular la suma de 1 ~ n

Ejemplo 2:
Calcular el valor n de la sucesión de Fibonacci (Fibonacci), la sucesión de Fibonacci cumple las siguientes reglas,

1,1,2,3,5,8,13,21,34,55,....

Es decir, a partir del tercer número, un número es igual a la suma de los dos primeros números. Supongamos que f(n) representa el valor n de la sucesión de Fibonacci, entonces f(n) satisface: f(n)
= f(n-2) + f(n-1);

	//使用递归的写法
    int f(int n) {
    
    //计算斐波那契数列第n个值是多少
        if (n < 1) {
    
    //负数是返回特殊值1，表示不计算负数情况
            return 1;
        }
        if (n == 1 || n == 2) {
    
    
            return 1;
        }
        return f(n - 2) + f(n - 1);
    }

    //不用递归
    int fValue(int n) {
    
    //计算斐波那契数列第n个值是多少
        if (n < 1) {
    
    //负数是返回特殊值1，表示不计算负数情况
            return 1;
        }
        if (n == 1 || n == 2) {
    
    
            return 1;
        }
        //从第三个数开始，  等于 前两个整数相加
        int beforeBefore = 1; //相当于n=1时的值
        int before = 1;//相当于n=2时的值
        int current = beforeBefore + before; //相当于n=3的值
        //再完后
        for (int i = 4; i <= n; i++) {
    
    
            beforeBefore = before;
            before = current;
            current = beforeBefore + before;
            /*
            假设i=4
                beforeBefore = before; //相当于n=2时的值
                before = current; //相当于n=3的值
                current = beforeBefore + before; //相当于n = 4的值
            假设i=5
                beforeBefore = before; //相当于n=3的值
                before = current; //相当于n = 4的值
                current = beforeBefore + before; //相当于n = 5的值
                ....
             */
        }
        return current;
    }

4.6 Matrices de Objetos

Los elementos de una matriz pueden ser tipos de datos primitivos o tipos de datos de referencia. Cuando los elementos son clases en un tipo de referencia, lo llamamos matriz de objetos.
ejemplo:

1.定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。 
创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
提示：
1) 生成随机数：Math.random()，返回值类型double; 
2) 四舍五入取整：Math.round(double d)，返回值类型long。

//Student类
public class Student {
    
    
	int number;//学号
	int state;//年级
	int score;//成绩		
	public void info(){
    
    
		System.out.println("number : " + number 
				+ ",state : " + state + ",score : " + score);
	}	
}
//StudentTest类
public class StudentTest {
    
    
    public static void main(String[] args) {
    
    
        // 数组的创建
        Student[] students = new Student[20];
        // 通过循环结构给数组的属性赋值
        for (int i = 0; i < students.length; i++) {
    
    
            // 数组元素的赋值
            students[i] = new Student();
            // 数组元素是一个对象，给对象的各个属性赋值
            students[i].number = (i + 1);
            students[i].state = (int) (Math.random() * 6 + 1);// [1,6]
            students[i].score = (int) (Math.random() * 101);// [0,100]
        }

        // 问题一：打印出3年级(state值为3）的学生信息。
        System.out.println("问题一：打印出3年级(state值为3）的学生信息。");
        for (int i = 0; i < students.length; i++) {
    
    
            if (students[i].state == 3) {
    
    
//				System.out.println(
//						"number:" + students[i].number + ",state:" + students[i].state + ",score:" + students[i].score);
                students[i].info();

            }

        }
        System.out.println("******************************");
        // 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
        // 排序前
        System.out.println("问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息");
        System.out.println("排序前");
        for (int i = 0; i < students.length; i++) {
    
    
//			System.out.println(
//					"number:" + students[i].number + ",state:" +
//							students[i].state + ",score:" + students[i].score);

            students[i].info();
        }

        System.out.println();
        // 排序：
        for (int i = 0; i < students.length - 1; i++) {
    
    
            for (int j = 0; j < students.length - 1 - i; j++) {
    
    
                if (students[j].score > students[j + 1].score) {
    
    
                    Student temp = students[j];
                    students[j] = students[j + 1];
                    students[j + 1] = temp;
                }
            }
        }

        // 排序后：
        System.out.println("排序后");
        for (int i = 0; i < students.length; i++) {
    
    
//			System.out.println(
//					"number:" + students[i].number + ",state:" +
//							students[i].state + ",score:" + students[i].score);

            students[i].info();
        }

    }

}

>运行结果：
问题一：打印出3年级(state值为3）的学生信息。
number : 1,state : 3,score : 98
number : 2,state : 3,score : 60
number : 5,state : 3,score : 71
number : 7,state : 3,score : 72
number : 8,state : 3,score : 72
number : 9,state : 3,score : 24
number : 14,state : 3,score : 0
number : 16,state : 3,score : 68
number : 18,state : 3,score : 29
number : 20,state : 3,score : 61
******************************
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
排序前
number : 1,state : 3,score : 98
number : 2,state : 3,score : 60
number : 3,state : 1,score : 22
number : 4,state : 6,score : 78
number : 5,state : 3,score : 71
number : 6,state : 5,score : 72
number : 7,state : 3,score : 72
number : 8,state : 3,score : 72
number : 9,state : 3,score : 24
number : 10,state : 1,score : 73
number : 11,state : 2,score : 0
number : 12,state : 2,score : 99
number : 13,state : 6,score : 65
number : 14,state : 3,score : 0
number : 15,state : 5,score : 61
number : 16,state : 3,score : 68
number : 17,state : 2,score : 41
number : 18,state : 3,score : 29
number : 19,state : 2,score : 14
number : 20,state : 3,score : 61

排序后
number : 11,state : 2,score : 0
number : 14,state : 3,score : 0
number : 19,state : 2,score : 14
number : 3,state : 1,score : 22
number : 9,state : 3,score : 24
number : 18,state : 3,score : 29
number : 17,state : 2,score : 41
number : 2,state : 3,score : 60
number : 15,state : 5,score : 61
number : 20,state : 3,score : 61
number : 13,state : 6,score : 65
number : 16,state : 3,score : 68
number : 5,state : 3,score : 71
number : 6,state : 5,score : 72
number : 7,state : 3,score : 72
number : 8,state : 3,score : 72
number : 10,state : 1,score : 73
number : 4,state : 6,score : 78
number : 1,state : 3,score : 98
number : 12,state : 2,score : 99

4.7 Palabras clave: paquete, importación

4.7.1 paquete (paquete)

paquete, llamado paquete, se usa para indicar el paquete donde se encuentran las clases, interfaces y otras estructuras definidas en el archivo.

package 顶层包名.子包名 ;

Ejemplo: paquete1\paquete2\PaqueteTest.java

package pack1.pack2;    //指定类PackageTest属于包pack1.pack2

public class PackageTest{
    
    
	public void display(){
    
    
		System.out.println("in  method display()");
	}
}

ilustrar:

• Un archivo fuente solo puede tener una instrucción de paquete que declare un paquete
• La declaración del paquete aparece como la primera declaración en un archivo fuente de Java. Si esta declaración está predeterminada, se especifica un paquete sin nombre.
• El nombre del paquete, que pertenece al identificador, cumple con las reglas y especificaciones de nomenclatura del identificador (todo en minúsculas), ve el nombre
  • Los paquetes generalmente usan la inversión del nombre de dominio de la empresa, no use " java.xx"paquete cuando tome el nombre del paquete
• El paquete corresponde al directorio del sistema de archivos, y "." se usa en la declaración del paquete para indicar el nivel del paquete (directorio), y cada vez significa una capa del directorio de archivos.
• Se pueden declarar múltiples estructuras (clases, interfaces) bajo el mismo paquete, pero no se pueden definir estructuras (clases, interfaces) con el mismo nombre. Las estructuras (clases, interfaces) con el mismo nombre se pueden definir en diferentes paquetes

El papel del paquete.

• Los paquetes pueden contener clases y subpaquetes, divididos 项目层次para facilitar la gestión
• Sistema de ayuda 管理大型软件: divide las clases con funciones similares en el mismo paquete. Por ejemplo: patrón de diseño MVC
• 类命名冲突problema resuelto
• control访问权限

patrón de diseño MVC

MVC es un patrón de componente de software, el propósito es reducir el acoplamiento del negocio de código en el desarrollo de programas.

El patrón de diseño MVC divide todo el programa en tres niveles: 视图模型(Viewer)层, 控制器(Controller)层y 数据模型(Model)层. Este patrón de diseño, que separa la entrada y salida del programa, el procesamiento de datos y la visualización de datos, hace que la estructura del programa sea flexible y clara. También describe el método de comunicación entre varios objetos del programa, lo que reduce el acoplamiento del programa.

视图层viewer：显示数据,为用户提供使用界面，与用户直接进行交互。
 >相关工具类   view.utils
 >自定义view  view.ui

控制层controller：解析用户请求，处理业务逻辑，给予用户响应
 >应用界面相关    controller.activity
 >存放fragment   controller.fragment
 >显示列表的适配器 controller.adapter
 >服务相关的        controller.service
 >抽取的基类        controller.base
    
模型层model：主要承载数据、处理数据
 >数据对象封装 model.bean/domain
 >数据库操作类 model.dao
 >数据库      model.db

Introducción del paquete principal en JDK

java.lang---- Contiene algunas clases básicas del lenguaje Java, como String, Math, Integer, System y Thread, que proporcionan funciones comunes
java.net---- Contiene clases e interfaces que realizan operaciones relacionadas con la red.
java.io---- Contiene clases que pueden proporcionar varias funciones de entrada/salida.
java.util---- Contiene algunas clases de utilidad, como la definición de las características del sistema, las clases de marco de colección de las interfaces y el uso de funciones relacionadas con la fecha y el calendario.
java.text---- Contiene algunas clases relacionadas con el formato Java
java.sql---- Contiene clases/interfaces relacionadas para la programación de bases de datos JDBC en Java
java.awt---- Contiene múltiples clases que constituyen los kits de herramientas de ventana abstractos. Estas clases se utilizan para construir y administrar la aplicación interfaz gráfica de usuario (GUI).

4.7.2 importar (importar)

Para usar las clases de Java definidas en otros paquetes, debe usar la declaración de importación para introducir explícitamente las clases requeridas en el paquete especificado. equivalente a import语句告诉编译器到哪里去寻找这个类.

formato gramatical

import 包名.类名;

Ejemplos de aplicación

import pack1.pack2.Test;   //import pack1.pack2.*;表示引入pack1.pack2包中的所有结构

public class PackTest{
    
    
	public static void main(String args[]){
    
    
		Test t = new Test();          //Test类在pack1.pack2包中定义
		t.display();
	}
}

Precauciones

• La declaración de importación, declarada entre la declaración de paquete y la declaración de clase.

• Si necesita importar varias clases o interfaces, puede especificar explícitamente varias declaraciones de importación en paralelo

• Si usa a.*la estructura de importación, significa que puede importar todas las estructuras en un paquete. Ejemplo: Puede usar java.util.* para importar todas las clases o interfaces bajo el paquete util al mismo tiempo.

• Si la clase o interfaz importada está bajo el paquete java.lang, o bajo el paquete actual, esta declaración de importación puede omitirse.

• Si las clases del paquete java.a se han importado, entonces, si necesita usar las clases de los subpaquetes del paquete a, aún debe importarlas.

• Si usa clases con el mismo nombre en diferentes paquetes en su código, necesita usar el nombre completo de la clase para indicar a qué clase se está llamando.

• (Comprender) import staticel uso de la combinación: llame a la propiedad o método estático bajo la clase o interfaz especificada

4.8 Característica 1: encapsulación

La llamada encapsulación consiste en encapsular cosas objetivas en clases de conceptos abstractos, y las clases solo pueden abrir sus datos y métodos a clases u objetos confiables y ocultar información de clases u objetos innecesarios.

En términos sencillos, ocultar lo que debería ocultarse y exponer lo que debería exponerse. Esta es la idea de diseño de la encapsulación.

Java implementa la encapsulación de datos

• Lograr la encapsulación es controlar el alcance de la visibilidad de una clase o miembro. Esto debe controlarse confiando en los modificadores de control de acceso, también conocidos como modificadores de permisos.
• Modificadores de permisos: public, protected, 缺省, private. El ámbito de acceso específico es el siguiente:

modificador	Dentro de esta clase	en este paquete	Subclases de otros paquetes	otro paquete no subclase
privado	√	×	×	×
por defecto	√	√	×	×
protegido	√	√	√	×
público	√	√	√	√

• Estructura específicamente modificada:
  • Clase externa: pública, predeterminada
  • Variables de miembros, métodos de miembros, constructores, clases internas de miembros: public, protected, default, private

4.8.1 Realización de la encapsulación

Descripción general de la privatización de variables/propiedades miembro
: privatice las variables miembro de la clase, proporcione métodos públicos de obtención y establecimiento, y exponga la función de obtener y modificar propiedades.

Pasos de implementación:

① Usar privatepara modificar variables miembro

private 数据类型 变量名 ；

el código se muestra a continuación:

public class Person {
    
    
    private String name;
  	private int age;
    private boolean marry;
}

②Proporcionar métodos getXxx/ setXxxmétodos para acceder a las variables miembro, el código es el siguiente:

public class Person {
    
    
    private String name;
  	private int age;
    private boolean marry;

	public void setName(String n) {
    
    
		name = n;
    }

    public String getName() {
    
    
        return name;
	}

    public void setAge(int a) {
    
    
        age = a;
    }

    public int getAge() {
    
    
        return age;
    }
    
    public void setMarry(boolean m){
    
    
        marry = m;
    }
    
    public boolean isMarry(){
    
    
        return marry;
    }
}

③Prueba :

public class PersonTest {
    
    
    public static void main(String[] args) {
    
    
        Person p = new Person();

        //实例变量私有化，跨类是无法直接使用的
		/* p.name = "张三";
        p.age = 23;
        p.marry = true;*/

        p.setName("张三");
        System.out.println("p.name = " + p.getName());

        p.setAge(23);
        System.out.println("p.age = " + p.getAge());

        p.setMarry(true);
        System.out.println("p.marry = " + p.isMarry());
    }
}

Los beneficios de la encapsulación de variables miembro:

• Permita que el usuario use solo el método predeterminado 访问数据, de modo que la lógica de control se pueda agregar al método para limitar el acceso irrazonable a las variables miembro. La inspección de datos también se puede realizar para ayudar a garantizar la integridad de la información del objeto.
• 便于修改, mejorar la capacidad de mantenimiento del código. Lo principal es que la parte oculta se ha modificado internamente, si el método de acceso externo sigue siendo el mismo, la modificación no se sentirá en absoluto externamente. Por ejemplo: Java8->Java9, String se convierte de char[] a byte[] para la implementación interna, pero el método externo permanece sin cambios y nuestros usuarios no pueden sentir su modificación interna en absoluto.

4.8.2 Método de privatización

public class ArrayUtil {
    
    
	/**
	 * 
	 * @Description 求int型数组的最大值
	 * @param arr
	 * @return
	 */
	public int max(int[] arr) {
    
    
		int maxValue = arr[0];
		for(int i = 1;i < arr.length;i++){
    
    
			if(maxValue < arr[i]){
    
    
				maxValue = arr[i];
			}
		}
		return maxValue;
	}

	/**
	 * 
	 * @Description 求int型数组的最小值
	 * @param arr
	 * @return
	 */
	public int min(int[] arr){
    
    
		int minValue = arr[0];
		for(int i = 1;i < arr.length;i++){
    
    
			if(minValue > arr[i]){
    
    
				minValue = arr[i];
			}
		}
		return minValue;
	}

	/**
	 * 
	 * @Description 求int型数组的总和
	 * @param arr
	 * @return
	 */
	public int sum(int[] arr) {
    
    
		int sum = 0;
		for(int i = 0;i < arr.length;i++){
    
    
			sum += arr[i];
		}
		return sum;
	}

	/**
	 * 
	 * @Description 求int型数组的元素的平均值
	 * @param arr
	 * @return
	 */
	public int avg(int[] arr) {
    
    
		int sumValue = sum(arr);
		return sumValue / arr.length;
	}

	// 创建一系列重载的上述方法
	// public double max(double[] arr){}
	// public float max(float[] arr){}
	// public byte max(byte[] arr){}

	/**
	 * 
	 * @Description 遍历数组
	 * @param arr
	 */
	public void print(int[] arr) {
    
    
		for(int i = 0;i < arr.length;i++){
    
    
			System.out.print(arr[i] + "  ");
		}
		System.out.println();
	}

	/**
	 * 
	 * @Description 复制数组arr
	 * @param arr
	 * @return
	 */
	public int[] copy(int[] arr) {
    
    
		int[] arr1 = new int[arr.length];
		for(int i = 0;i < arr.length;i++){
    
    
			arr1[i] = arr[i];
		}
		return arr1;
	}

	/**
	 * 
	 * @Description 反转数组
	 * @param arr
	 */
	public void reverse(int[] arr) {
    
    
		for(int i = 0,j = arr.length - 1;i < j;i++,j--){
    
    
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}

	/**
	 * 
	 * @Description 数组的排序
	 * @param arr
	 * @param desc 指明排序的方式。 ascend:升序    descend:降序
	 */
	public void sort(int[] arr,String desc) {
    
    
		
		if("ascend".equals(desc)){
    
    //if(desc.equals("ascend")){
    
    
			for (int i = 0; i < arr.length - 1; i++) {
    
    
				for (int j = 0; j < arr.length - 1 - i; j++) {
    
    
					if (arr[j] > arr[j + 1]) {
    
    
//						int temp = arr[j];
//						arr[j] = arr[j + 1];
//						arr[j + 1] = temp;
						swap(arr,j,j+1);
					}
				}
			}
		}else if ("descend".equals(desc)){
    
    
			for (int i = 0; i < arr.length - 1; i++) {
    
    
				for (int j = 0; j < arr.length - 1 - i; j++) {
    
    
					if (arr[j] < arr[j + 1]) {
    
    
//						int temp = arr[j];
//						arr[j] = arr[j + 1];
//						arr[j + 1] = temp;
						swap(arr,j,j+1);
					}
				}
			}
		}else{
    
    
			System.out.println("您输入的排序方式有误！");
		}
	}
	
	private void swap(int[] arr,int i,int j){
    
    
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	/**
	 * 
	 * @Description 查找指定的value值在arr数组中出现的位置
	 * @param arr
	 * @param value
	 * @return 返回value值出现的位置 或 -1：未找到
	 */
	public int getValue(int[] arr, int value) {
    
    
		//方法：线性查找
		for(int i = 0;i < arr.length;i++){
    
    
			if(value == arr[i]){
    
    
				return i;
			}
		}
		
		return - 1;
	}
}

Aviso:

En el desarrollo, las variables de instancia de miembros generales se usan para usar la modificación privada y luego proporcionar el acceso al método get/set de permiso público correspondiente.

Para las variables de instancia final, no se proporciona el método set(). (Hablando de la palabra clave final más adelante)

Para las variables de miembro final estáticas, se acostumbra usar la modificación pública.

4.9 El tercer miembro de la clase: el constructor (Constructor)

El papel del constructor.

nuevo objeto y asignar valores a las variables de instancia cuando se crean nuevos objetos.

Ejemplo: Persona p = nuevo Person(“Peter”,15);

Explicación: Así como estipulamos que cada "persona" debe bañarse nada más nacer, podemos agregar el código del programa para completar el "baño" en el constructor de la "persona", para que cada "persona" completar automáticamente el "baño" tan pronto como nazca. "Báñate" en lugar de decirle a cada individuo que "se bañe" uno por uno cuando son recién nacidos.

La sintaxis del constructor.

[修饰符] class 类名{
    
    
    [修饰符] 构造器名(){
    
    
    	// 实例初始化代码
    }
    [修饰符] 构造器名(参数列表){
    
    
        // 实例初始化代码
    }
}

ilustrar:

1. El nombre del constructor debe ser el mismo que el nombre de la clase en la que reside.
2. No tiene valor de retorno, por lo que no se necesita ningún tipo de retorno, ni es nulo.
3. El modificador del constructor solo puede ser un modificador de permiso y no puede ser modificado por ningún otro. Por ejemplo, no puede ser modificado por estático, final, sincronizado, abstracto, nativo y no puede tener un valor de retorno de declaración de retorno.

el código se muestra a continuación:

public class Student {
    
    
    private String name;
    private int age;

    // 无参构造
    public Student() {
    
    }

    // 有参构造
    public Student(String n,int a) {
    
    
        name = n;
        age = a;
    }

    public String getName() {
    
    
        return name;
    }
    public void setName(String n) {
    
    
        name = n;
    }
    public int getAge() {
    
    
        return age;
    }
    public void setAge(int a) {
    
    
        age = a;
    }

    public String getInfo(){
    
    
        return "姓名：" + name +"，年龄：" + age;
    }
}

public class TestStudent {
    
    
    public static void main(String[] args) {
    
    
        //调用无参构造创建学生对象
        Student s1 = new Student();

        //调用有参构造创建学生对象
        Student s2 = new Student("张三",23);

        System.out.println(s1.getInfo());
        System.out.println(s2.getInfo());
    }
}

Instrucciones de uso

1. Cuando no declaramos explícitamente el constructor en la clase, el sistema proporcionará un constructor sin parámetros por defecto y el modificador del constructor es el mismo que el modificador de la clase por defecto.

2. Cuando definimos explícitamente el constructor de clase, el sistema ya no proporciona un constructor predeterminado sin argumentos.

3. En una clase, habrá al menos un constructor.

4. Los constructores pueden estar sobrecargados.

práctica:

(1)定义Student类,有4个属性：
  String name; 
  int age; 
  String school; 
  String major;

(2)定义Student类的3个构造器:

- 第一个构造器Student(String n, int a)设置类的name和age属性；
- 第二个构造器Student(String n, int a, String s)设置类的name, age 和school属性；
- 第三个构造器Student(String n, int a, String s, String m)设置类的name, age ,school和major属性；

(3)在main方法中分别调用不同的构造器创建的对象，并输出其属性值。


public class Student {
    
    
    String name;
    int age;
    String school;
    String major;

    public Student(String n, int a) {
    
    
        name = n;
        age = a;
    }

    public Student(String n, int a, String s) {
    
    
        name = n;
        age = a;
        school = s;
    }

    public Student(String n, int a, String s, String m) {
    
    
        name = n;
        age = a;
        school = s;
        major = m;
    }

    public static void main(String[] args) {
    
    
        Student s1 = new Student("田大赐", 20);
        Student s2 = new Student("田二赐", 21, "北大");
        Student s3 = new Student("田三赐", 22, "清华", "Java");

        System.out.println(s1.name + " " + s1.age + " " + s1.school + " " + s1.major);
        System.out.println(s2.name + " " + s2.age + " " + s2.school + " " + s2.major);
        System.out.println(s3.name + " " + s3.age + " " + s3.school + " " + s3.major);
    }
}

>运行结果
田大赐 20 null null
田二赐 21 北大 null
田三赐 22 清华 Java