La esencia del pensamiento orientado a objetos de Java (4)

1. Paquete y referencia de paquete

（一） paquete 、 importar

• paquete:

1. Rol: Para evitar conflictos de nombres de clases.
2. El nombre del paquete puede tener una estructura jerárquica. El nombre completo de la clase : nombre del paquete. Nombre de la clase .
3. Sugerencia: Todas las letras del nombre del paquete deben estar en minúsculas.
4. Los nombres de clase de las clases del mismo paquete no pueden ser iguales.

• importar:

1. Se puede acceder directamente a las clases del mismo paquete, pero no se puede acceder directamente a las clases de diferentes paquetes. Sólo hay dos formas de acceder a ellas:
   1.1. Primero, declare la clase por importación y use la clase ------ Sugerencia.
   1.2 El nombre completo de la clase es demasiado engorroso y no se recomienda.

Dos, modificador de control de acceso

(1) Público, privado, protegido, predeterminado

• public: public, se puede acceder a cualquier clase.
• privado: privado, solo accesible en esta clase.
• protegido: protegido, se puede acceder a esta clase, las clases derivadas (subclases) y las clases en el mismo paquete.
• El valor predeterminado (otra forma de decirlo es bueno): no hay nada escrito, accesible en esta clase y en la misma clase de paquete.
• Descripción:
  • El modificador de acceso de la clase solo puede ser público o el predeterminado (no escrito).
  • Los modificadores de acceso de los miembros de la clase pueden ser cualquiera de los 4 tipos anteriores.

Castaño de código:

package oop.day05;
//同包类：同一个包下的 class 类文件
//演示访问控制修饰符
public class Aoo {
    
    
	public int a;    //任何类
	protected int b; //本类、派生类、同包类
	private int d;   //本类
	int c;           //本类、同包类
	
	
	public void show() {
    
    
		a = 1;
		b = 2;
		c = 3;
		d = 4;
	}
}

class Boo{
    
     //演示private
	public void show() {
    
    
		Aoo o = new Aoo();
		o.a = 1;
		o.b = 2;
		o.c = 3;
		//o.d = 4;
	}
}

Misma clase de paquete (igual que la clase del paquete oop.day05)

package oop.day05;
public class Coo {
    
     //演示同包类
	public void show() {
    
    
		Aoo o = new Aoo();
		o.a = 1;
		o.b = 2;
		o.c = 3;
		//o.d = 4;
	}
}

//同包中
class Doo extends Aoo{
    
     //演示protected
	public void show() {
    
    
		a = 1;
		b = 2;
		c = 3;
//		d = 4;
	}
}

Diferentes clases de paquetes

package oop.day06;
import oop.day05.Aoo;//先导包
//跨包继承
public class Doo extends Aoo{
    
    
	public void show() {
    
    
		Aoo aoo = new Aoo();
		aoo.a = 1;
		aoo.show();
	}
}

Tres, el papel de la modificación final de la palabra clave

• Medios finales: definitivos e inmodificables.
• Las funciones y descripciones de las variables finales modificadas, los métodos modificados y las clases modificadas son las siguientes:

1. Variables modificadas: las variables no se pueden modificar.

   /*
    * final修饰成员变量，只能在如下两种方式下初始化:
    * 1)声明同时初始化
    * 2)在构造方法中初始化
    * final修饰局部变量，只要在用之前初始化即可
    */
   //演示final修饰变量
   class Eoo{
         
         
   	final int num = 5;
   	final int count;
   	Eoo(){
         
         
   		count = 5;
   	}
   	void show() {
         
         
   		final int Number;
   		//count = 8; //编译错误，final修饰的变量不能被改变
   	}
   }
   

2. Método de modificación: el método no se puede anular.

   //演示final修饰方法
   class Foo{
         
         
   	final void show() {
         
         }
   	void say() {
         
         }
   }
   class Goo extends Foo{
         
         
   	//void show() {} //编译错误，final修饰的方法不能被重写
   	void say() {
         
         }
   }
   

3. Clase modificada: la clase no se puede heredar.

   //演示final修饰类
   final class Hoo{
         
         }
   //class Ioo extends Hoo{} //编译错误，final的类不能被继承
   class Joo{
         
         }
   final class Koo extends Joo{
         
         
   
   }
   

Cuatro, estático

(1) Variables estáticas

1. Modificado por estática.
2. Los que pertenecen a la clase se almacenan en el área de métodos y solo tienen una copia.
3. A menudo se accede a través del punto de nombre de clase.
4. Cuándo usarlo: datos compartidos por todos los objetos.
5. Nota: Declare e inicialice al mismo tiempo.

(Dos) método estático

1. Modificado por estática.
2. Solo hay una copia de las que pertenecen a la clase en el área de métodos.
3. A menudo se accede a través del punto de nombre de clase.
4. Esta transferencia no está implícita en los métodos estáticos, por lo que no se puede acceder directamente a los miembros de la instancia en los métodos estáticos.
5. Cuándo usarlo: El funcionamiento del método solo está relacionado con los parámetros, no con el objeto.

(Tres) bloque estático

1. Modificado por estática.
2. Perteneciente a una clase, se ejecuta automáticamente durante la carga de la clase; la clase solo se carga una vez y todos los bloques estáticos se ejecutan una vez.
3. Cuándo usarlo: La carga / o inicialización de bloques estáticos se ejecuta automáticamente durante la carga de la clase (se ejecuta una vez).
4. Escenarios de uso: por ejemplo, al abrir el programa, debe inicializar recursos estáticos (imágenes, audio, video, etc.); después de aprender que hay un contenido de conocimiento JDBC en la etapa posterior, la conexión entre el proyecto y la base de datos, primero debe cargar el controlador de la interfaz de la base de datos ...

Demostración de código:

//static的演示
public class StaticDemo {
    
    
	public static void main(String[] args) {
    
    
		Loo o1 = new Loo();
		o1.show();
		Loo o2 = new Loo();
		o2.show();
		Loo o3 = new Loo();
		o3.show();
		System.out.println("最后的静态变量:"+Loo.b); //常常通过类名点来访问
		
		System.out.println("------------------------------------------");
		
		Moo m = new Moo();
		System.out.println(Moo.b);//通过类名点来访问
		System.out.println(m.a);
		int s = m.test2();
		System.out.println(s);
		
		System.out.println("------------------------------------------");
		
		Noo o4 = new Noo();
		Noo o5 = new Noo();
		Noo o6 = new Noo();
	}
}

class Loo{
    
     //演示静态变量
	int a;
	static int b;
	Loo(){
    
    
		a++;
		b++;
	}
	void show() {
    
    
		System.out.println("静态变量:"+a+","+b);
	}
}
//静态变量，static修饰 属于类的，存储在方法区中，只有一份



class Moo{
    
     //演示静态方法
	int a=88;
	static int b=56;
	void show() {
    
     //有隐式this
		System.out.println(this.a);
		System.out.println(Moo.b);
	}
	static void test() {
    
     //没有隐式this
		//静态方法没有隐式的this传递
		//没有this就意味着没有对象
		//而实例变量a必须通过对象点来访问
		//所以此处编译错误，因为静态方法中不能直接访问实例成员,得先创建对象再访问。
		
		//System.out.println(a); //编译错误
		System.out.println(b);
	}
	int test2() {
    
    
		return a;
	}
}


class Noo{
    
    
	static {
    
    
		System.out.println("静态块");//静态块只加载一次
	}
	Noo(){
    
    
		System.out.println("构造方法");
	}
}

Gráfico de resultado:

Cinco, constante final estática

1. Debe declarar e inicializar al mismo tiempo antes de que pueda usarse.
2. Por lo general, se accede a través del punto del nombre de la clase y no se puede cambiar.
3. Sugerencia: Todas las letras del nombre constante deben escribirse en mayúscula y las palabras múltiples deben estar separadas por _ subrayado.
4. El compilador reemplaza directamente las constantes con números específicos durante la compilación, lo cual es muy eficiente.
5. Cuándo usar: cuando los datos deban permanecer sin cambios, utilícelos con frecuencia.

//static final常量的演示
public class StaticFinalDemo {
    
    
	public static void main(String[] args) {
    
    
		System.out.println(Aoo1.PI); //常量通过类名点来访问
		//Aoo.PI = 3.1415926; //编译错误，常量不能被改变
		
		
		//1)加载Boo.class到方法区中
		//2)静态变量num也存储到方法区中
		//3)到方法区中获取num的值并输出
		System.out.println(Boo.num);
		
		
		//编译器在编译时将常量直接替换为具体的值，效率高
		//相当于System.out.println(5);
		System.out.println(Boo.COUNT);
		
	}
}

class Boo{
    
    
	public static int num = 5; //静态变量
	public static final int COUNT = 5; //常量，常量名所有字母都大写
}

class Aoo1{
    
    
	public static final double PI = 3.14159;
	//public static final int NUM; //编译错误，常量必须声明同时初始化
}

¡Tenga paciencia con el contenido de seguimiento y venga pronto! Escribir no es fácil, por favor dale un pulgar hacia arriba 3Q, ¡Gracias!

La lista de capítulos está aquí: https://blog.csdn.net/qq_41254299/article/details/106638651

Indique la fuente de la reimpresión: https://blog.csdn.net/qq_41254299
Este artículo es del [blog de Superclover_]