初始化与清理（构造方法，重载，this，初始化，参数列表）：
初始化与清理为计算机科学的发展提供了一种安全的处理方式。
下面是初始化与清理的几个要点和需要注意的地方：
1.构造器：
初始化是保证程序安全的方法之一，为了保证程序在操作对象之前被初始化，我们就有了构造器这个概念。
a.构造器的名字：与类名相同。
eg：
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.构造器参数：
不接受任何参数的构造器叫做无参构造器
eg:
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.构造器的返回值：构造器没有返回值，即使void也不行。
2.方法重载
多数语言要求每个方法都提供独一无二的标识符。但是由于构造器名字相同，所以就有了重载的概念，通俗说，重载就是几个方法名字相同。为了区别和使用相同名字的方法，但是，重载的参数列表必须不同。
a.方法重载：
eg：
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.重载方法的区分：
每个重载的方法都必须有一个独一无二的参数列表，即便仅仅是参数的顺序不同。
3.this关键字
在我们使用this时，this一般出现在类的方法里面，当这个方法还没有调用的时候this指的是谁并不知道，但是实际当中如果new一个对象出来之后，this指的就是当前这个对象。通俗讲，this就是为了便于区分和方便，完全可以被替代。
eg：
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 = hi需要注意：
- 1、只能在构造方法中使用this调用其它的的构造方法，不能在成员方法中使用。
- 2、在构造发法中，使用this调用构造方法的语句必须放在第一行，且只能出现一次，
- 3、不能在一个类的两个构造方法中使用this互相调用。
4.初始化
a.静态数据初始化：
eg：
/*
* 初始化顺序：
* 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)
aaaaaaaaaaaaaaeg2：对照上个程序，更易理解
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.非静态实例初始化：
/*
* 初始化顺序：
* 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.可变参数列表，基本类型与基本类型包装类
a.基本类型与基本类型包装类：
- Java的基本数据类型包括boolean、char、byte、short、int、float、long、double 8种。
- 其分别对应的包装类是：Boolean、Character、Byte、Short、Integer、Float、Long、Double类。
b.可变参数列表：
可变参数列表可以方便的创建对象并调用方法，常应用于参数个数和类型未知的场合。
- 所有的类都间接或直接继承于Object类。
c.可变参数列表与基本类型包装实例：
eg：
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 以上时Java初始化与清理常见的问题，希望通过我的文章可以对大家的学习有所帮助。
本人原创，转载请说明，谢谢！