重载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();

}

重载java_方法重载相关推荐

mysql 函数重载_C#方法重载（函数重载）
在讲解<C#构造方法>时提到定义构造方法时提到可以定义带 0 到多个参数的构造方法,但构造方法的名称必须是类名.实际上,这就是一个典型的方法重载,即方法名称相同.参数列表不同. 参数列表不 ...
java final 方法重载_java方法重载和覆写的定义,static和final修饰符的讲解,java面试题...
方法重载的规则: 1.必须发生在同一个类的下面 2.必须保证方法名字相同 3.参数列表不同参数的类型不同参数的个数不同参数的顺序不同 4.返回值:和返回值无关 5.修饰符:和修饰符无关 6.抛出 ...
java 面向对象重载_Java方法重载
在同一类中具有多个具有相同名称的方法称为方法重载.类中具有相同名称的方法可以是声明的方法,继承的方法或两者的组合. 重载方法必须具有不同数量的参数,不同类型的参数或两者.方法的返回类型,访问级别和th ...
Java如何调用方法的重载_java方法重载时的调用选择
重载:方法名相同,参数列表不同:参数列表包括参数的个数,类型,不包括参数的返回值,抛出的异常等. 对于方法重载时具体调用的选择,往往不是很清晰,看代码: public class TestOverlo ...
类与接口（四）方法重载解析
###一.方法重载简介方法重载: 当两个(或多个)方法的名称相同,而参数的对应类型或个数不同时,我们就说方法重载了.当然,编译器也能识别出来. 编译器是如何识别调用了哪个方法? 在往下讲前,我们先来 ...
Java05-day05【方法(概述、调用过程图解)、带参方法、带返回值方法、重载、方法参数传递(基本类型、引用类型)】
java零基础入门到精通(2019版)[黑马程序员] 视频+资料:[链接:https://pan.baidu.com/s/1MdFNUADVSFf-lVw3SJRvtg 提取码:zjxs] &qu ...
JAVA SE、EE、ME，JRE、JDK，基本数据类型，访问修饰符、函数、封装的概念、UML类图、构造方法、this关键字、static关键字、方法重载、方法重写、包（packahe）
运行第一个JAVA程序: 这里使用的开发环境是eclipse,新建一个java工程,然后可以看到src这个是存放java代码的地方,然后在src文件右击新建一个class(类),然后可以看到下图,同样 ...
scala 方法重载_Scala中的方法重载
scala 方法重载 Scala方法重载 (Scala method overloading) Method overloading is a method that is redefined in ...
JAVA不同类型数组重载_JAVA补课-DAY1：方法重载和数组
IDEA简单方法使用快捷键 Ctrl+Alt+L,IDEA代码格式化 Ctrl+/单行注释,重复按取消 Ctrl+Shift+/多行注释,重复可取消 5.fori<==>for (int ...

重载java_方法重载

重载java_方法重载相关推荐

最新文章

热门文章