Inicialización y limpieza (método de construcción, sobrecarga, esto, inicialización, lista de parámetros):
La inicialización y la limpieza proporcionan una forma segura para el desarrollo de la informática.
Los siguientes son los puntos principales y los puntos que deben tenerse en cuenta para la inicialización y limpieza:
1. Constructor:
La inicialización es uno de los métodos para garantizar la seguridad del programa Para garantizar que el programa se inicialice antes de operar el objeto, tenemos el concepto de constructor.
a. El nombre del constructor: el mismo que el nombre de la clase.
p.ej:
import java.util.Random;
class Gclass{
Gclass(){ //构造方法
System.out.println("我是一个构造方法");
}
}
class Pclass{
public void cclass(){ //普通方法
System.out.println("我是一个普通方法");
}
}
public class a {
public static void main(String[] args) {
new Gclass(); //构造方法的调用
Pclass t = new Pclass();
t.cclass(); //普通方法的调用
}
}
output:
我是一个构造方法
我是一个普通方法b. Parámetros del constructor:
Un constructor que no acepta ningún parámetro se denomina constructor sin parámetros.
p.ej:
import java.util.Random;
class Gclass{
Gclass(int i){ //构造方法
System.out.println("我是一个构造方法");
}
}
class Pclass{
public void cclass(int i){ //普通方法
System.out.println("我是一个普通方法");
}
}
public class a {
public static void main(String[] args) {
for(int i = 0;i < 5;i++){
new Gclass(i); //构造方法的调用
Pclass t = new Pclass();
t.cclass(i); //普通方法的调用
}
}
}
output:
我是一个构造方法
我是一个普通方法
我是一个构造方法
我是一个普通方法
我是一个构造方法
我是一个普通方法
我是一个构造方法
我是一个普通方法
我是一个构造方法
我是一个普通方法c. El valor de retorno del constructor: El constructor no tiene valor de retorno, incluso si es nulo.
2. Sobrecarga de métodos
La mayoría de los idiomas requieren un identificador único para cada método. Sin embargo, debido a que los nombres de los constructores son los mismos, existe el concepto de sobrecarga.En términos sencillos, sobrecarga significa que varios métodos tienen el mismo nombre. Sin embargo, para distinguir y utilizar el mismo método de nombre, la lista de parámetros sobrecargada debe ser diferente.
a. Sobrecarga de métodos:
p.ej:
class TreeHeight{
int h;
TreeHeight(){
System.out.println("This is tree!");
}
TreeHeight(int hh){
System.out.println("This is new tree "+hh+" feet tall");
}
}
public class d {
public static void main(String[] args) {
for(int i = 0;i < 5;i++){
new TreeHeight(i);
new TreeHeight();
}
}
}
output：
This is new tree 0 feet tall
This is tree!
This is new tree 1 feet tall
This is tree!
This is new tree 2 feet tall
This is tree!
This is new tree 3 feet tall
This is tree!
This is new tree 4 feet tall
This is tree!
b. La distinción entre métodos sobrecargados:
Cada método sobrecargado debe tener una lista de parámetros única, incluso si solo el orden de los parámetros es diferente.
3.esta palabra clave
Cuando usamos esto, generalmente aparece en el método de la clase, cuando no se llama a este método, se desconoce a quién se refiere, pero en realidad, si sale el nuevo objeto, esto se refiere al objeto actual. En términos sencillos, esto es para una fácil distinción y conveniencia, y puede reemplazarse por completo.
p.ej:
public class D {
int pp = 0;
String s = "initial value";
D(int p){
pp = p;
System.out.println("a w/ int oo,pp= " + pp);
}
D(String ss){
System.out.println("a w/ String oo,s = " + ss);
s = ss;
}
D(String s,int p){
this(p);
//this(s); //在构造发法中，使用this调用构造方法的语句必须放在第一行，且只能出现一次，
this.s = s;
System.out.println("Strign & int");
}
D(){
this("hi",47);
System.out.println("aaaaaaaa");
}
void Dd(){
//this(11); //只能在构造方法中使用this调用其它的的构造方法，不能再成员方法中使用。
System.out.println("pp = " + pp +" s = "+s);
}
public static void main(String[] args) {
D d = new D(); //执行构造方法
d.Dd();
}
}
output：
a w/ int oo,pp= 47
Strign & int
aaaaaaaa
pp = 47 s = hirequiere atención:
- 1. Esto solo se puede usar en el método de construcción para llamar a otros métodos de construcción, no en métodos de miembro.
- 2. En el método de construcción, la instrucción que usa esto para llamar al método de construcción debe colocarse en la primera línea y solo puede aparecer una vez.
- 3. No puede usar esto para llamarse entre sí en los dos métodos de construcción de una clase.
4. Inicialización
a. Inicialización de datos estáticos:
p.ej:
/*
* 初始化顺序：
* 1.先初始化变量,按照顺序
* 2.再处理构造器
* 3.再初始化静态对象
* 4.处理完静态对象后再处理非静态对象
* 通俗讲就是静态对象先执行。
*/
class Bowl{
Bowl(int marker){
System.out.println("Bowl("+ marker +")");
}
void f1(int marker){
System.out.println("f1("+ marker +")");
}
}
class Table{
static Bowl bowl1 = new Bowl(1);
Table(){
System.out.println("Table()");
bowl2.f1(1);
}
void f2(int marker){
System.out.println("f2("+ marker +")");
}
static Bowl bowl2 = new Bowl(2);
}
public class StaticClass {
public static void main(String[] args){
System.out.println("aaaaaaaaaaaaaa");
}
static Table table = new Table(); //静态对象先执行。
}
output：
Bowl(1)
Bowl(2)
Table()
f1(1)
aaaaaaaaaaaaaa
eg2: Comparado con el programa anterior, es más fácil de entender
class Bowl{
Bowl(int marker){
System.out.println("Bowl("+ marker +")");
}
void f1(int marker){
System.out.println("f1("+ marker +")");
}
}
class Table{
static Bowl bowl1 = new Bowl(1);
Table(){
System.out.println("Table()");
bowl2.f1(1);
}
void f2(int marker){
System.out.println("f2("+ marker +")");
}
static Bowl bowl2 = new Bowl(2);
}
class Cupboard{
Bowl bowl3 = new Bowl(3);
static Bowl bowl4 = new Bowl(4);
Cupboard(){
System.out.println("Cupboard()");
bowl4.f1(2);
}
void f3(int marker){
System.out.println("f3("+ marker +")");
}
static Bowl bowl5 = new Bowl(5);
}
public class StaticClass {
public static void main(String[] args){
System.out.println("aaaaaaaaaaaaaa");
new Cupboard();
System.out.println("aaaaaaaaaaaaaa");
new Cupboard();
table.f2(1);
cupboard.f3(1);
}
static Table table = new Table();
static Cupboard cupboard = new Cupboard();
}
output：
Bowl(1)
Bowl(2)
Table()
f1(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f1(2)
aaaaaaaaaaaaaa
Bowl(3)
Cupboard()
f1(2)
aaaaaaaaaaaaaa
Bowl(3)
Cupboard()
f1(2)
f2(1)
f3(1)b. Inicialización de instancia no estática:
/*
* 初始化顺序：
* 1.先初始化变量,按照顺序
* 2.再处理构造器
* 3.再初始化静态对象
* 4.处理完静态对象后再处理非静态对象
* 通俗讲就是静态对象先执行。
*/
class Bowl{
Bowl(int marker){
System.out.println("Bowl("+ marker +")");
}
void f1(int marker){
System.out.println("f1("+ marker +")");
}
}
class Table{
Table(){
System.out.println("Table()");
bowl2.f1(1);
}
void f2(int marker){
System.out.println("f2("+ marker +")");
}
Bowl bowl2 = new Bowl(2);Bowl bowl1 = new Bowl(1);
}
public class StaticClass {
public static void main(String[] args){
System.out.println("aaaaaaaaaaaaaa");
Table table = new Table();
table.f2(2);
}
}
output：
aaaaaaaaaaaaaa
Bowl(2)
Bowl(1)
Table()
f1(1)
f2(2)5. Lista de parámetros variables, tipo básico y clase de embalaje de tipo básico
a. Tipos básicos y tipos básicos de envases:
- Los tipos de datos básicos de Java incluyen 8 tipos de booleano, char, byte, short, int, float, long y double.
- Las clases de empaquetado correspondientes son: booleano, carácter, byte, corto, entero, flotante, largo, doble.
b. Lista de parámetros de variables:
Las listas de parámetros variables pueden crear fácilmente objetos y llamar a métodos, y se utilizan a menudo en situaciones en las que se desconoce el número y los tipos de parámetros.
- Todas las clases heredan directa o indirectamente de la clase Object.
c. Lista de parámetros de variables y ejemplos de empaquetado de tipo básico:
p.ej:
public class bie {
/*
* 所有的类都间接或直接继承于Object类。
* 定义了一个Object的可变参数列表数组
* 遍历打印每一个参数
*/
static void printarray(Object[] args){
for(Object obj : args){
System.out.println(obj + " ");
}
}
/*
* 定义了一个包装类型为Integer的的可变参数列表数组
* 遍历打印每一个参数
*/
static void inf(Integer...args){
for(Integer i : args){
System.out.println(i + " ");
}
}
public static void main(String args[]){
printarray(new Object[]{
new Integer(23), //可变参数为int型
new Float(3.14) //可变参数为float型
});
printarray(new Object[]{"one","two","three",new Integer(1)});
inf(111,222,333); //直接可以传入int型参数
}
}
Output:
23
3.14
one
two
three
1
111
222
333 En lo anterior, la inicialización de Java y la limpieza de problemas comunes, espero que mi artículo pueda ayudarlo a aprender.
Soy original, por favor explique al reimprimir, gracias!