Latest web development tutorials

objetos Java y las clases

Java como un lenguaje orientado a objetos. Es compatible con los siguientes conceptos básicos:

  • polimorfismo
  • heredar
  • paquete
  • abstracto
  • categoría
  • objetos
  • Ejemplos
  • camino
  • sobrecargado

En esta sección nos centramos en el concepto de objetos y clases.

  • Objeto: El objeto es una instancia de una clase (objeto no es encontrar una novia), hay estado y el comportamiento. Por ejemplo, un perro es un objeto cuyos estados son: color, nombre, raza, comportamiento: moviendo la cola, llamada, comer y así sucesivamente.
  • Clase: La clase es una plantilla que describe el comportamiento de una clase de objetos y de estado.

Los niños y niñas por debajo de la cifra correspondiente a la clase, y específicos para cada clase de objetos artificiales:

objetos Java

Ahora vamos a entender lo que es un objeto. Mire a su alrededor el mundo real, se encuentra en torno a una gran cantidad de objetos, coches, perros, personas, y así sucesivamente. Todos estos objetos tienen su propio estado y el comportamiento.

Para sacar al perro, por ejemplo, se afirma son: nombre, raza, color, comportamiento: llamada, mueve la cola y corrió.

Comparación de objetos reales y objetos de software son muy similares entre ellas.

Los objetos de software tienen estado y el comportamiento. Estado objeto de software es atribuir el comportamiento por el método de expresión.

En el desarrollo de software, llame a la otra para cambiar el método de funcionamiento del estado interno de un objeto, el objeto se logra por el método.

Las clases Java

Class puede ser visto como una plantilla para crear objetos Java.

Siguiendo una definición de clase simple de entender Java en clase: 

public class Dog{
   String breed;
   int age;
   String color;
   void barking(){
   }
   
   void hungry(){
   }
   
   void sleeping(){
   }
}

Una clase puede contener los siguientes tipos de variables:

  • Las variables locales: la variable en un método, constructor o una declaración definiciones de bloque se llaman variables locales. Las variables se declaran e inicializan en el método, después de que el final del método, las variables serán destruidos automáticamente.
  • Las variables de miembro: variables miembro de clase se definen, la variable fuera del cuerpo del método. Esta variable se crea cuando se crea una instancia del objeto. Las variables de miembro se puede acceder en la clase bloque de instrucciones métodos, constructores y métodos de una clase particular.
  • Las variables de clase: las variables de clase declarada en una clase, un método que no sea el cuerpo, sino que deben ser declarados como de tipo estático.

Una clase puede tener varios métodos, en el ejemplo anterior: ladrar (), hambre () y dormir () son la clase de perro.

constructor

Cada clase tiene un constructor. Si no se define explícitamente el constructor de la clase, el compilador de Java proporcionará un constructor predeterminado para la clase.

Creación de un objeto, al menos, a ser llamado un constructor. El nombre del constructor debe ser el mismo nombre que la clase, una clase puede tener varios constructores.

Este es un ejemplo del constructor: 

public class Puppy{
   public Puppy(){
   }

   public Puppy(String name){
      // 这个构造器仅有一个参数：name
   }
}

crear objeto

Los objetos se crean sobre la base de la clase. En Java, utilice la palabra clave new para crear un objeto nuevo. Crear un objeto requiere los siguientes tres pasos:

  • Exención de responsabilidad: declarar un objeto, incluyendo el nombre del objeto y el tipo de objeto.
  • Ejemplos: la nueva palabra clave para crear un objeto.
  • Inicialización: Crear un nuevo objeto utilizando el constructor por defecto para inicializar el objeto será llamado.

He aquí un ejemplo de cómo crear un objeto: 

public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("Passed Name is :" + name ); 
   }
   public static void main(String []args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

Compilar y ejecutar el programa anterior y se mostrarán los siguientes resultados: 

Passed Name is :tommy

variables de instancia y métodos de acceso

Para acceder a las variables miembro y métodos miembros a través de un objeto que se ha creado, de la siguiente manera: 

/* 实例化对象 */
ObjectReference = new Constructor();
/* 访问其中的变量 */
ObjectReference.variableName;
/* 访问类中的方法 */
ObjectReference.MethodName();

Ejemplos

El siguiente ejemplo muestra cómo acceder a las variables de instancia y métodos miembro de llamadas: 

public class Puppy{
   int puppyAge;
   public Puppy(String name){
      // 这个构造器仅有一个参数：name
      System.out.println("Passed Name is :" + name ); 
   }

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

   public int getAge( ){
       System.out.println("Puppy's age is :" + puppyAge ); 
       return puppyAge;
   }

   public static void main(String []args){
      /* 创建对象 */
      Puppy myPuppy = new Puppy( "tommy" );
      /* 通过方法来设定age */
      myPuppy.setAge( 2 );
      /* 调用另一个方法获取age */
      myPuppy.getAge( );
      /*你也可以像下面这样访问成员变量 */
      System.out.println("Variable Value :" + myPuppy.puppyAge ); 
   }
}

Compilar y ejecutar el programa anterior produce los siguientes resultados: 

Passed Name is :tommy
Puppy's age is :2
Variable Value :2

reglas de declaración de archivo de origen

En la última parte de esta sección, vamos a aprender las reglas declaran el archivo de origen. Al definir varias clases en un archivo de origen, y hay declaraciones de importación y sentencia de paquete, prestar especial atención a estas reglas.

  • Un archivo de origen puede tener sólo una clase pública
  • Un archivo de origen puede tener varias clases no públicas
  • El nombre de archivo de origen y clase pública nombre de la clase debe ser coherente. Por ejemplo: nombre de la clase en el archivo de origen es public class Empleado, a continuación, el archivo de origen debe ser nombrado Employee.java.
  • Si una clase se define en un paquete, la sentencia de paquete debe ser la primera línea del archivo de origen.
  • Si el archivo de origen que contiene la declaración de importación, la declaración debe colocarse entre las definiciones de paquetes y de clase. Si no hay una sentencia de paquete, las declaraciones de importación deben ser lo más importante en el archivo de origen.
  • declaraciones y declaraciones de todas las clases definidas en el archivo de origen del paquete de importación son válidos. En el mismo archivo de origen, no a las diferentes clases de diferentes paquetes comunicado.

Hay varios niveles de acceso de clase, y la clase se pueden dividir en diferentes tipos: las clases abstractas y las clases finales y similares. Estos se describen en la sección de control de acceso.

Además de los tipos antes mencionados, Java hay algunas categorías especiales, tales como: las clases internas, clases de anónimos.

paquete de Java

El paquete se utiliza principalmente para clasificar clases y las interfaces. Cuando se desarrolla un programa Java podrían escribir cientos de clases, por lo que es necesario clasificar las clases e interfaces.

Declaración de importación

En Java, si se les da un nombre completo, incluyendo el nombre del paquete, nombre de la clase, el compilador Java puede localizar fácilmente el código fuente o categoría. declaración de importación se utiliza para proporcionar un camino razonable, por lo que el compilador puede encontrar una clase.

Por ejemplo, el siguiente comando de línea de comandos del compilador se cargará todas las clases java_installation / java / io de ruta 

import java.io.*;

Un ejemplo sencillo

En este ejemplo, creamos dos clases: los empleados y EmployeeTest.

En primer lugar, abrir un editor de texto para pegar el código siguiente en él. Nota Guarde el archivo como Employee.java.

clase empleado tiene cuatro variables miembro: nombre, edad, designación y salariales. Clase declare explícitamente un método constructor, que es sólo un parámetro. 

import java.io.*;
public class Employee{
   String name;
   int age;
   String designation;
   double salary;
   // Employee 类的构造器
   public Employee(String name){
      this.name = name;
   }
   // 设置age的值
   public void empAge(int empAge){
      age =  empAge;
   }
   /* 设置designation的值*/
   public void empDesignation(String empDesig){
      designation = empDesig;
   }
   /* 设置salary的值*/
   public void empSalary(double empSalary){
      salary = empSalary;
   }
   /* 打印信息 */
   public void printEmployee(){
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

La ejecución del programa se inicia desde el método principal. Para ejecutar el programa, y ​​debe contener un método main crea una instancia de un objeto.

Aquí son de clase EmployeeTest, una instancia de dos instancias de la clase Empleado, y llame al método para establecer el valor de la variable.

El siguiente código se almacena en el archivo EmployeeTest.java. 

import java.io.*;
public class EmployeeTest{

   public static void main(String args[]){
      /* 使用构造器创建两个对象 */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // 调用这两个对象的成员方法
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

Compilar los dos archivos y ejecutar la clase EmployeeTest, se puede ver los siguientes resultados: 

C :> javac Employee.java
C :> vi EmployeeTest.java
C :> javac  EmployeeTest.java
C :> java EmployeeTest
Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.0