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;
//<init>
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();
}
}