Inicialização e limpeza (método de construção, sobrecarga, isto, inicialização, lista de parâmetros):
A inicialização e a limpeza fornecem uma maneira segura para o desenvolvimento da ciência da computação.
A seguir estão os principais pontos e pontos a serem observados para inicialização e limpeza:
1. Construtor:
A inicialização é um dos métodos para garantir a segurança do programa.Para garantir que o programa seja inicializado antes de operar o objeto, temos o conceito de um construtor.
a. O nome do construtor: igual ao nome da classe.
por exemplo:
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 do construtor:
Um construtor que não aceita nenhum parâmetro é chamado de construtor sem parâmetros
por exemplo:
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. O valor de retorno do construtor: O construtor não tem valor de retorno, mesmo que seja nulo.
2. Sobrecarga de método
A maioria das linguagens requer um identificador exclusivo para cada método. Mas, como os nomes dos construtores são iguais, existe o conceito de sobrecarga.Em termos genéricos, sobrecarga significa que vários métodos têm o mesmo nome. Para distinguir e usar o mesmo método de nome, no entanto, a lista de parâmetros sobrecarregada deve ser diferente.
a. Sobrecarga do método:
por exemplo:
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. A distinção entre métodos sobrecarregados:
Cada método sobrecarregado deve ter uma lista de parâmetros exclusiva, mesmo que apenas a ordem dos parâmetros seja diferente.
3. esta palavra-chave
Quando o usamos, geralmente aparece no método da classe, quando esse método não é chamado, a quem se refere é desconhecido, mas na realidade, se o novo objeto sair, se refere ao objeto atual. Em termos gerais, isso é para facilitar a distinção e conveniência e pode ser completamente substituído.
por exemplo:
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 = hirequer atenção:
- 1. Isso só pode ser usado no método de construção para chamar outros métodos de construção, não em métodos de membro.
- 2. No método de construção, a instrução que usa isso para chamar o método de construção deve ser colocada na primeira linha e só pode aparecer uma vez.
- 3. Você não pode usar isso para chamar um ao outro nos dois métodos de construção de uma classe.
4. Inicialização
a. Inicialização de dados estáticos:
por exemplo:
/*
* 初始化顺序：
* 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 com o programa anterior, é mais 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. Inicialização de instância não 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 variáveis, tipo básico e classe de embalagem do tipo básico
a. Tipos básicos e tipos básicos de embalagem:
- Os tipos de dados básicos do Java incluem 8 tipos de booleano, char, byte, short, int, float, long e double.
- As classes de empacotamento correspondentes são: Boolean, Character, Byte, Short, Integer, Float, Long, Double.
b. Lista de parâmetros variáveis:
Listas de parâmetros variáveis podem facilmente criar objetos e métodos de chamada e são freqüentemente usadas em situações onde o número e os tipos de parâmetros são desconhecidos.
- Todas as classes herdam indiretamente ou diretamente da classe Object.
c. Lista de parâmetros variáveis e exemplo de embalagem de tipo básico:
por exemplo:
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 Acima, inicialização do Java e limpeza de problemas comuns, espero que meu artigo possa ajudá-lo a aprender.
Sou original, explique quando reimprimir, obrigado!