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