Conocimientos básicos de clases y objetos, constructores, sobrecarga de métodos y herencia.

(Lo siguiente es mi comprensión de las clases y los objetos, así como algunos otros conocimientos básicos de Java, bienvenido a señalar cualquier irregularidad)

1. El lenguaje de alto nivel se utiliza para ayudarnos a hablar con la computadora, y guiamos a la computadora para completar las funciones a través de la programación.

2. Análisis orientado a objetos:

 1) Clase y objeto

    Clase: se refiere a una colección con muchas similitudes, no entidades

El método para crear una nueva clase en eclipse:


<span style="color:#000000;">public class 类名</span>
<span style="color:#000000;">public class Teacher</span>

           Objeto: se refiere a los individuos que componen una clase, que es una entidad.

El método para crear una nueva clase es:

<span style="color:#000000;">类名 对象名=new 类名();</span>
<span style="font-size:14px;color:#000000;">Teacher t=new Teacher();</span>

2) Análisis de programación orientada a objetos

Orientado a objetos es enfocarse solo en quién es el ejecutor de la acción (método)

Por ejemplo: los estudiantes asisten a clase, este asunto se centra en los estudiantes en lugar de en cómo los estudiantes asisten a clase.


 3) Análisis de programación orientado a procesos

Orientado al proceso significa centrarse en cómo se ejecutan las acciones (métodos)

El método para definir las características de una clase:

public class 属性名;
<span style="font-size:14px;color:#000000;">public String name;</span>

El método de la definición de un método de clase:

public 返回类型 方法名(参数列表)
<pre class="html" name="code">public void teach(String stuname)
	{
		System.out.println(name+"老师正在给"+stuname+"学生上课");
	}
 
 

El formato de llamar a los atributos con objetos: nombre del objeto, nombre del atributo

Teacher t=new Teacher();
		//给对象命名
		t.name="张三";

El formato para llamar a un método con un objeto: nombre del objeto. Nombre del método (parámetro)

Teacher t=new Teacher();
	        //执行行为(调用方法)
		t.teach("李四");


 
 Método de construcción: construir un objeto

Tal como

Teacher t=new Teacher();

t es un objeto construido

La pila en memoria significa aproximadamente la siguiente figura:

El objeto recién creado se pasa al nombre del objeto y se almacena en el montón, y los atributos y métodos de la clase se almacenan en la pila.

 

El formato básico del método de construcción: nombre de clase pública (lista de parámetros) {}

public void teach(String stuname)
	{
		System.out.println(name+"老师正在给"+stuname+"学生上课");
	}


Sobrecarga de métodos:

Es decir, en la misma clase, los nombres de método de varios métodos son los mismos, pero los parámetros son diferentes.

  Como el siguiente

public class Teacher
{
public void teach(String stuname)
	{
		System.out.println(name+"老师正在给"+stuname+"学生上课");
	}
public void teach(String stuname)
	{
		System.out.println(...........);
	}
public void teach(String stuname,int stuage)
	{
		System.out.println(.......);
	}
public void teach(int stuage)
	{
		System.out.println(..........);
	}


}


Los tres métodos están sobrecargados entre sí


Herencia:

La subclase hereda todas las propiedades de la clase padre, excepto las propiedades privadas, y puede derivar sus propias propiedades o métodos.

Algunas de las clases principales, además de los atributos privados, las subclases tienen

Como las siguientes dos categorías:

public class A
{
	public String name;
	public void eat(){
		System.out.println("吃.......");
	}
}
public class B extends A
{
	B b=new B();
	b.eat();
}
B hereda el método de la clase padre A a través de la palabra clave extiende y lo llama


Método de reescritura:

La subclase anula el método de la clase principal anulando el método heredado de la clase principal, pero el nombre del método, los parámetros, el tipo de retorno, etc. no se pueden cambiar

Como el siguiente ejemplo:

public class A
{
	public String name;
	public void eat(){
		System.out.println("吃.......");
	}
}
public class B extends A
{
	B b=new B();
	public void eat(){
		System.out.println("吃fffffffffffffff");
	}
	b.eat();
}


Luego, la salida final debe ser "eat ffffffffffffffffffff" para
lograr la reescritura del método, que debe distinguirse de la sobrecarga


Transformación automática:

Cuando la subclase reescribe el método de la clase principal, se llama al método reescrito. Si no se reescribe, el método llamado sigue siendo el de la clase principal.

Mismo ejemplo que el anterior









Supongo que te gusta

Origin blog.csdn.net/dream_18/article/details/51532355
Recomendado
Clasificación