Primer día del juego de disparos:
1. Creé 6 clases de objetos y creé una prueba de clase mundial
El segundo día del juego de disparos:
1. Agregue métodos de construcción a 6 clases de objetos y pruebe
Día 3 del juego de disparos:
1. Diseña aviones enemigos pequeños, aviones enemigos grandes, abejas pequeñas, matrices de balas y prueba
2. Diseña la superclase FlyingObject, hereda 6 clases de objetos respectivamente
3. Diseña dos métodos de construcción para la superclase FlyingObject , La clase de objeto se llama por separado
Comentario:
Sobrecarga 1. Método (sobrecarga):
. 1) se produce en una clase, el mismo nombre de método, una lista de los diferentes parámetros, un cuerpo de método diferente
2) El método del compilador en tiempo de compilación llamada a un método de firma obligado automáticamente
2. Constructor:
asigne un valor inicial a una variable miembro
, que se llama automáticamente al crear un objeto con el mismo nombre que la clase y sin tipo de valor de retorno.
Si no lo escribe, el valor predeterminado no es la construcción de parámetros. Si lo escribe usted mismo, ya no se proporcionará por defecto.
Puede sobrecargar
3.este: que El método de invocación de objeto se refiere a qué objeto
está. Nombre de la variable miembro ------------ variable de miembro de acceso
este. Nombre del método () -------------- método de llamada
this () --------------------- Llame al constructor
4. nulo: vacío, ninguna
referencia a ningún valor de objeto es nulo, entonces la referencia no puede ser Operado,
si la operación ocurre NullPointerException Excepción de puntero nulo
5. Variable de tipo de referencia dibujar signo igual:
apunte al mismo objeto, afectará a la
variable de tipo básico dibujar signo igual:
asignación, no afectará
笔记:
1. 引用 类型 数组:
1) Estudiante [] stus = nuevo Estudiante [3];
stus [0] = nuevo Estudiante ("zhangsan", 25, "LF");
stus [1] = nuevo Estudiante ("lisi", 26, "JMS");
stus [2] = nuevo estudiante ("wangwu", 28, "SD");
stus [1] .age = 36;
2) Estudiante [] stus = estudiante nuevo [] {
estudiante nuevo ("zhangsan", 25, "LF"),
estudiante nuevo ("lisi", 26, "JMS"),
estudiante nuevo ("wangwu", 28, " SD ")
};
3) int [] [] arr = nuevo int [3] []; ------ 数组 的 数组
arr [0] = nuevo int [4];
arr [1] = nuevo int [4];
arr [2] = nuevo int [4];
arr [1] [0] = 100;
para (int j = 0; j <arr [i] .length; j ++) {
arr [i] [j] = (int) (Math.random () * 100);
System.out.println (arr [i] [j]);
}
}
2. Herencia:
1) Rol: reutilización de código
2) Herencia a través de extensiones
3) Superclase / clase padre: Propiedades y comportamientos comunes a todas las clases
derivadas Clase / subclase derivada: clase derivada Atributos y comportamientos únicos
4) Después de que la clase derivada herede la superclase, la clase derivada tiene: clase derivada + superclase
5) Una superclase puede tener múltiples clases derivadas,
una clase derivada solo puede tener una superclase ---- - Herencia simple
6) La herencia es transitiva
7) Regulaciones de Java: antes de construir una clase derivada, primero debe construir una
clase derivada de superclase si no se llama a un constructor de superclase
------- entonces el super () predeterminado llama a la superclase el constructor sin argumentos
deriva constructor de la clase llamada cuando la superclase
ya no se proporciona ------- predeterminado
para ser colocado en la primera fila cuando el constructor súper clase derivada () constructor llama súper
3.Super: medios
Uso del super objeto super en nombre del objeto actual :
1) super. Nombre de la variable miembro ---- acceso a las variables miembro de la superclase
2) super. Nombre del método () ---------- llamar al método super class (mañana)
3) super () ----------------- call Método de construcción de superclase
1) Crear clase Persona, incluyendo:
1.1) Variables miembro: nombre, edad, dirección
1.2) Método de construcción: Persona (3 parámetros) {}
1.3) Método: sayHi () {Salida de 3 variables miembro Valor}
2) Crear clase Estudiante, heredar Persona, incluyendo:
2.1) Variable miembro: studentId
2.2) Constructor: Estudiante (4 parámetros) {}
3) Crear clase Profesor, heredar Persona, incluyendo:
3.1) Variable miembro: salario
3.2 ) Constructor: Profesor (4 parámetros) {}
4) Crear clase Doctor, heredando Persona, incluyendo:
4.1) Variable miembro: nivel
4.2) Constructor: Doctor (4 parámetros) {}
5) Crear clase Prueba, principal ( ) En:
5.1) Crear una matriz de Estudiante, que contiene 3 elementos, y saludar al recorrido
5.2) Crear una matriz de Profesor, que contiene 3 elementos, saludar a la travesía
5.3) Crear una matriz de Doctor, que contiene 2 elementos, saludar a la travesía
clase Aoo {----------------------- a
int a;
}
clase Boo extiende Aoo {----------- b + a
int b;
}
clase Coo extiende Boo {----------- c + b + a
int c;
}
clase Doo extiende Coo {----------- d + c + b + a
int d;
}
Estudiante zs = nuevo Estudiante ();
zs.stuId / study ();
zs.name/age/address/eat () / sleep ();
Profesor ls = nuevo profesor ();
ls.salario / enseñar ();
ls.name/age/address/eat () / sleep ();
clase Persona {------------------------ // 超 类
Nombre de cadena;
int edad;
Dirección de cadena;
void eat () {}
void sleep () {}
}
clase El estudiante extiende a la Persona {--------- 派生 类
String stuId;
estudio nulo () {}
}
clase Profesor extiende Persona {--------- 派生 类
doble salario;
void teach () {}
}
clase Doctor extiende Persona {---------- 派生 类
Nivel de cadena;
corte nulo () {}
}
Herencia en el programa: el
código se puede usar sin escribir
La vida en la sucesión:
1) la herencia:
el dinero no tiene que ganar, podría pasar
2) para heredar el trono:
país no jugar a mí mismo, me podría sentar
3) el trabajo Herencia:
el trabajo no tiene que buscar, y él es capaz
3: la longitud de arr
4: la longitud de cada elemento en arr
int [] [] arr = nuevo int [3] [4]; // 3 行 4 列
for (int i = 0; i <arr.length; i ++) {
for (int j = 0; j <arr [i] .length; j ++) {
arr [i] [j] = 100 ;
}
}
int [] arr = nuevo int [3];
Estudiante [] stus = nuevo Estudiante [3];
// Declara una matriz de int [], contiene 3 elementos
// Cada elemento es de tipo int [], el valor predeterminado es nulo
int [] [] arr = new int [3] [];
arr [0] = new int [2];
arr [1] = nuevo int [3];
arr [2] = nuevo int [2];
// Al primer elemento del segundo elemento en arr se le asigna el valor 100
arr [1] [ 0] = 100;
arr -------------------- int [] []
arr [0] ----------------- int []
arr [0] [0] -------------- int
int [] arr = nuevo int [] {
1,
5,
7
};
Estudiante [] stus = nuevo Estudiante [] {
nuevo Estudiante (),
nuevo Estudiante (),
nuevo Estudiante ()
};
Variable de tipo básico -------- número específico de instalación
Variable de tipo de referencia -------- dirección de instalación
int [] arr = nuevo int [3];
arr [0] = 100;
Estudiante [] stus = nuevo Estudiante [3]; // Crear objeto de matriz de Estudiante
stus [0] = nuevo Estudiante (); // Crear objeto de Estudiante
Avión [] as = nuevo Avión [5];
como [0] = nuevo Avión ();
// Declara la matriz entera arr, contiene 3 elementos
// Cada elemento es de tipo int, el valor predeterminado es 0
int [] arr = new int [3];
// Declara la matriz de Student, que contiene 3 elementos
// Cada elemento es de tipo Student, el valor predeterminado es nulo
Student [] stus = new Student [3];
// Declara la matriz de Avión como, que contiene 20 elementos
// Cada elemento es de tipo Avión, el valor predeterminado es nulo
Avión [] as = new Airplane [20];
// Declara la matriz bas de BigAirplane, que contiene 23 elementos
// Cada elemento es del tipo BigAirplane, el valor predeterminado es nulo
BigAirplane [] bas = new BigAirplane [23];
Abeja [] bs;
Bullet [] bts;
Tipo básico ------------ Un
tipo de matriz ------------ Mismo tipo Crea
tu propio tipo de datos
class Emp {
Nombre de cadena;
int edad;
doble salario;
}
impresión vacía (nombre de cadena, edad int, doble salario) {
}
