重载java_方法重载

1、方法重载

/*

方法重载

我们将名字相同，参数列表不同的两个(或多个)方法

称为重载方法。

参数列表的不同体现在以下两点：

1 参数的类型不同

2 参数的个数不同

方法参数列表的不同，是编译器用来区分调用哪一个

重载方法的依据。

*/

public class Overload {

public void f(int x) {

System.out.println("f(int x)");

}

public void f(float a) {

System.out.println("f(float a)");

}

public void g() {

System.out.println("g()");

}

public void g(int x) {

System.out.println("g(int x)");

}

public void g(int x, int y) {

System.out.println("g(int x, int y)");

}

public static void main(String[] args) {

Overload o = new Overload();

int r = 1;

float t = 1.0f;

//调用f(int x)方法

o.f(r);

//调用f(float a)方法

o.f(t);

//调用g()方法

o.g();

//调用g(int x)方法

o.g(r);

//调用g(int x, int y)方法

o.g(r, r);

}

}

/*

以下条件不同，是否构成方法重载：

1 参数名字的不同

2 方法的返回类型不同

*/

public class Overload2 {

/*

仅参数名字不同的方法，不能构成重载。

public void f(int a) {

}

public void f(int b) {

}

*/

/*

仅方法返回类型不同，不能构成重载。

因为我们在调用方法时，可以忽略返回值。

public int g() {

return 5;

}

public String g() {

return "";

}

public byte g() {

return (byte)5;

}

*/

public static void main(String[] args) {

Overload2 o = new Overload2();

//o.f(5);

//int x = o.g();

//String s = o.g();

//double d = o.g();

//o.g();

}

}

2、重载方法

/*

重载方法：

声明原则：我们应该将功能相似的两个(或多个)

方法声明为重载方法。而不应该将功能不相关的

两个(或多个)方法声明为重载方法。因为这样会

带来混淆。

实现原则：因为重载方法具有功能上的相似性，

因此，重载方法的代码也会有很大的相似性，此时，

很可能会出现重复的代码。所以，我们应该考虑

一个重载方法使用另外一个重载方法来实现，而不是

每个重载方法都有各自的实现。

调用原则：参数少的方法调用参数多的方法。

*/

public class Overload3 {

/*

非常不合适

public void operation(int a, int b) {

//相加操作

int sum = a + b;

}

public void operation() {

System.out.println("输出操作");

}

*/

//标准格式*输出

public void printStar() {

/*for (int i = 1; i <= 5; i++) {

for (int j = 1; j <= i; j++) {

System.out.print("*");

}

System.out.println();

}*/

printStar(5);

}

public void printStar(int row) {

for (int i = 1; i <= row; i++) {

for (int j = 1; j <= i; j++) {

System.out.print("*");

}

System.out.println();

}

}

public static void main(String[] args) {

}

}

3、构造器

/*

构造器

声明：

构造器与类名相同，并且没有返回类型(没有返回类型与

返回类型是void不同)。访问权限与参数列表与普通方法

相同，没有限制。

构造器会在创建对象时，由系统自动调用。

默认的构造器

当类中没有显式的声明构造器时，编译器会为该类自动

生成一个默认的构造器。默认的构造器访问权限与

类的访问权限相同，参数列表为空。

如果我们显式的声明了构造器，不论我们声明的构造器

是否含有参数，默认的构造器都将不复存在。

*/

public class Cons {

int x;

int y;

int z;

//构造器

/*public Cons() {

//System.out.println("构造器执行了。");

x = 1;

y = 1;

z = 1;

}*/

//含有参数的构造器

//可以进行更加灵活的初始化。

public Cons(int x, int y, int z) {

this.x = x;

this.y = y;

this.z = z;

}

public static void main(String[] args) {

/*Cons c = new Cons();

System.out.println(c.x);

System.out.println(c.y);

System.out.println(c.z);*/

/*c.x = 1;

c.y = 1;

c.z = 1;

Cons c2 = new Cons();

c2.x = 2;

c2.y = 2;

c2.z = 2;*/

Cons c = new Cons(1, 2, 3);

Cons c2 = new Cons(4, 5, 6);

}

}

4、构造器重载

/*

构造器重载

可以在类中声明多个构造器，因为构造器的名字与

类名相同，因此，如果声明了多个构造器，则

多个构造器必然会重载。

我们可以在类中声明多个构造器，进而可以实现

多种初始化方式。

*/

public class ConOverload {

int x;

int y;

//默认的初始化方式

public ConOverload() {

//x = 10;

//y = 20;

//错误

//ConOverload(10, 20);

this(10, 20);

}

//指定初始化方式

public ConOverload(int x, int y) {

this.x = x;

this.y = y;

}

public static void main(String[] args) {

ConOverload c = new ConOverload();

ConOverlaod c2 = new ConOverload(50, 100);

}

}

5、构造器调用的原则

/*

构造器调用的原则：

1 在调用方式上

需要使用this来调用构造器，而不能通过构造器的

名字调用构造器。

2 在调用位置上

只能在构造器中对构造器进行调用，而不能在构造器

之外对构造器进行调用。

3 在语句顺序上

调用构造器的语句必须是构造器中的第一条语句。

*/

public class ConCall {

public ConCall() {

//错误！

//ConCall(5);

//System.out.println("abc");

this(5);

}

public void outCon() {

//错误！

//this(5);

}

/*

public void ConCall(int x) {

}

*/

public ConCall(int x) {

}

}

6、this的使用

/*

this的使用：

1 this指代当前的对象，可以通过this访问

类中声明的成员。

2 可以通过this来调用构造器。

this：this指代当前的对象。

当前对象：谁调用的该方法(构造器)，当前对象

就是谁。

*/

public class ThisTest {

int x;

public ThisTest() {

//通过this调用构造器。

this(5);

}

public ThisTest(int x) {

this.x = x;

}

public void setX(int x) {

//通过this访问被局部变量所遮蔽的成员变量。

this.x = x;

}

public void f() {

this.x = 1;

this.setX(5);

x = 1;

setX(5);

}

/*

public void f(ThisTest this) {

this.x = 1;

this.setX(5);

x = 1;

setX(5);

}

*/

public static void main(String[] args) {

ThisTest t = new ThisTest();

//ThisTest t = new ThisTest(t);

t.f();

//t.f(t);

ThisTest t2 = new ThisTest();

t2.f();

//t2.f(t2);

}

}

7、成员变量的初始化

/*

成员变量的初始化(实例成员变量)

1 在实例变量声明处初始化

2 使用初始化块

3 使用构造器

三种初始化的顺序：

1 实例变量声明处初始化与初始化块按照类中声明

的顺序执行。

2 实例变量声明处初始化与初始化块会在构造器之前

得到执行。

*/

public class Init {

//在实例变量声明处初始化

//int x = 1;

//int x = System.out.println("初始化块1执行");

int x = initX();

//初始化块

{

//x = 1;

System.out.println("初始化块1执行");

}

//构造器

public Init() {

//x = 1;

System.out.println("构造器执行");

}

{

x = 1;

System.out.println("初始化块2执行");

}

int y = initY();

public int initX() {

System.out.println("x声明处初始化执行");

return 1;

}

public int initY() {

System.out.println("y声明处初始化执行");

return 1;

}

public static void main(String[] args) {

Init i = new Init();

//System.out.println(i.x);

}

}

/*

声明处初始化与初始化块中的语句会复制到

每个构造器的最前面。(init)。

如果构造器中，使用this调用了其他的构造器，

则不会进行上述的复制。(避免重复的初始化。)

*/

public class Init2 {

/*

{

System.out.println(this.x);

}

*/

//int x = 1;

int x = initX();

int y = 2;

{

System.out.println("aaa");

}

public int initX() {

System.out.println(y);

return 1;

}

/*public Init2() {

this(10);

//System.out.println("bbb");

}*/

public Init2(int k) {

//x = 1;

//y = 2;

//System.out.println("aaa");

}

public static void main(String[] args) {

//Init2 i = new Init2();

new Init2(5);

}

}

/*

public class Init2 {

int x;

int y;

//

public Init2() {

System.out.println(x);

x = 1;

y = 2;

System.out.println("aaa");

System.out.println("bbb");

}

public static void main(String[] args) {

//Init2 i = new Init2();

new Init2();

}

}

*/

8、可变参数

/*

可变参数

可变参数使用...表示，可以接受0个到多个参数。

可变参数实际上就是一个数组。每个实参都是作为

数组的一个元素。

对于main方法的String[] args，实际上就是一个可变

参数。因此，main方法也可以写成如下形式：

public static void main(String... args) {

}

可变参数的限制：

可变参数必须作为方法参数列表的最后一个参数。

这意味着，方法的参数列表最多只能有一个类型

为可变参数类型。

*/

public class VarArgs {

public static void main(String... args) {

VarArgs v = new VarArgs();

System.out.println(v.add());

System.out.println(v.add(2));

System.out.println(v.add(2, 3));

System.out.println(v.add(2, 3, 4, 5, 6));

}

/*

public int add(int x, int y) {

return x + y;

}

public int add(int x, int y, int z) {

return x + y + z;

}

*/

public int add(int... x) {

int sum = 0;

for (int i : x) {

sum += i;

}

return sum;

}

/*

add(1, 2, 3, 4, 5);

public int add(int... x, int k) {

//实现

}

public int add(int... x, int... y) {

}

public int add(int k, int... x) {

}

*/

}

9、可变参数的重载

/*

可变参数的重载

当可变参数参与重载时，可变参数的方法会后考虑，

这是为了做到对以前程序的兼容。

*/

public class VarOverload {

public void f(int x) {

System.out.println("f(int x)");

}

public void f(int... x) {

System.out.println("f(int... x)");

}

public static void main(String[] args) {

VarOverload v = new VarOverload();

v.f(10);

v.f();

}

}