方法重载
先来看下方法重载（Overloading）的定义：如果有两个方法的方法名相同，但参数不一致，哪么可以说一个方法是另一个方法的重载。 具体说明如下：
- 方法名相同
- 方法的参数类型，参数个不一样
- 方法的返回类型可以不相同
- 方法的修饰符可以不相同
- main 方法也可以被重载
以下实例演示了如何重载 MyClass 类的 info 方法：
class MyClass { int height; MyClass() { System.out.println("无参数构造函数"); height = 4; } MyClass(int i) { System.out.println("房子高度为 " + i + " 米"); height = i; } void info() { System.out.println("房子高度为 " + height + " 米"); } void info(String s) { System.out.println(s + ": 房子高度为 " + height + " 米"); } } public class MainClass { public static void main(String[] args) { MyClass t = new MyClass(3); t.info(); t.info("重载方法"); //重载构造函数 new MyClass(); } }
以上代码运行输出结果为：
房子高度为 3 米 房子高度为 3 米 重载方法: 房子高度为 3 米 无参数构造函数
输出数组元素
以下实例演示了如何通过重载 MainClass 类的 printArray 方法输出不同类型(整型, 双精度及字符型)的数组：
public class MainClass { public static void printArray(Integer[] inputArray) { for (Integer element : inputArray){ System.out.printf("%s ", element); System.out.println(); } } public static void printArray(Double[] inputArray) { for (Double element : inputArray){ System.out.printf("%s ", element); System.out.println(); } } public static void printArray(Character[] inputArray) { for (Character element : inputArray){ System.out.printf("%s ", element); System.out.println(); } } public static void main(String args[]) { Integer[] integerArray = { 1, 2, 3, 4, 5, 6 }; Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7 }; Character[] characterArray = { 'H', 'E', 'L', 'L', 'O' }; System.out.println("输出整型数组:"); printArray(integerArray); System.out.println("\n输出双精度型数组:"); printArray(doubleArray); System.out.println("\n输出字符型数组:"); printArray(characterArray); } }
以上代码运行输出结果为：
输出整型数组: 1 2 3 4 5 6 输出双精度型数组: 1.1 2.2 3.3 4.4 5.5 6.6 7.7 输出字符型数组: H E L L O
斐波那契数列
斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368……
特别指出：第0项是0，第1项是第一个1。
这个数列从第三项开始，每一项都等于前两项之和。
以下实例演示了 Java 斐波那契数列的实现：
public class MainClass { public static long fibonacci(long number) { if ((number == 0) || (number == 1)) return number; else return fibonacci(number - 1) + fibonacci(number - 2); } public static void main(String[] args) { for (int counter = 0; counter <= 10; counter++){ System.out.printf("Fibonacci of %d is: %d\n", counter, fibonacci(counter)); } } }
以上代码运行输出结果为：
Fibonacci of 0 is: 0 Fibonacci of 1 is: 1 Fibonacci of 2 is: 1 Fibonacci of 3 is: 2 Fibonacci of 4 is: 3 Fibonacci of 5 is: 5 Fibonacci of 6 is: 8 Fibonacci of 7 is: 13 Fibonacci of 8 is: 21 Fibonacci of 9 is: 34 Fibonacci of 10 is: 55
阶乘
一个正整数的阶乘（英语：factorial）是所有小于及等于该数的正整数的积，并且有0的阶乘为1。自然数n的阶乘写作n!。
亦即n!=1×2×3×...×n。阶乘亦可以递归方式定义：0!=1，n!=(n-1)!×n。
以下实例演示了 Java 阶乘代码的实现：
public class MainClass { public static void main(String args[]) { for (int counter = 0; counter <= 10; counter++){ System.out.printf("%d! = %d\n", counter, factorial(counter)); } } public static long factorial(long number) { if (number <= 1) return 1; else return number * factorial(number - 1); } }
以上代码运行输出结果为：
0! = 1 1! = 1 2! = 2 3! = 6 4! = 24 5! = 120 6! = 720 7! = 5040 8! = 40320 9! = 362880 10! = 3628800
方法覆盖
方法重载与方法覆盖区别如下：
- 方法重载(Overloading)：如果有两个方法的方法名相同，但参数不一致，哪么可以说一个方法是另一个方法的重载。
- 方法覆盖（Overriding）：如果在子类中定义一个方法，其名称、返回类型及参数签名正好与父类中某个方法的名称、返回类型及参数签名相匹配，那么可以说，子类的方法覆盖了父类的方法。
以下实例演示了 Java 方法覆盖（Overriding）代码的实现：
public class Findareas{ public static void main (String []agrs){ Figure f= new Figure(10 , 10); Rectangle r= new Rectangle(9 , 5); Figure figref; figref=f; System.out.println("Area is :"+figref.area()); figref=r; System.out.println("Area is :"+figref.area()); } } class Figure{ double dim1; double dim2; Figure(double a , double b) { dim1=a; dim2=b; } Double area() { System.out.println("Inside area for figure."); return(dim1*dim2); } } class Rectangle extends Figure { Rectangle(double a, double b) { super(a ,b); } Double area() { System.out.println("Inside area for rectangle."); return(dim1*dim2); } }
以上代码运行输出结果为：
Inside area for figure. Area is :100.0 Inside area for rectangle. Area is :45.0
instanceof 关键字用法
instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。
instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。
以下实例创建了 displayObjectClass() 方法来演示 Java instanceof 关键字用法：
/* author by runoob.com Main.java */ import java.util.ArrayList; import java.util.Vector; public class Main { public static void main(String[] args) { Object testObject = new ArrayList(); displayObjectClass(testObject); } public static void displayObjectClass(Object o) { if (o instanceof Vector) System.out.println("对象是 java.util.Vector 类的实例"); else if (o instanceof ArrayList) System.out.println("对象是 java.util.ArrayList 类的实例"); else System.out.println("对象是 " + o.getClass() + " 类的实例"); } }
以上代码运行输出结果为：
对象是 java.util.ArrayList 类的实例
标签(Label)
Java 中的标签是为循环设计的，是为了在多重循环中方便的使用break 和coutinue 。
以下实例当在循环中使用 break 或 continue 循环时跳到指定的标签处：
public class Main { public static void main(String[] args) { String strSearch = "This is the string in which you have to search for a substring."; String substring = "substring"; boolean found = false; int max = strSearch.length() - substring.length(); testlbl: for (int i = 0; i <= max; i++) { int length = substring.length(); int j = i; int k = 0; while (length-- != 0) { if(strSearch.charAt(j++) != substring.charAt(k++)){ continue testlbl; } } found = true; break testlbl; } if (found) { System.out.println("发现子字符串。"); } else { System.out.println("字符串中没有发现子字符串。"); } } }
以上代码运行输出结果为：
发现子字符串。
enum 和 switch 语句使用
Java 创建枚举类型要使用 enum 关键字，隐含了所创建的类型都是 java.lang.Enum 类的子类
对enum进行遍历和switch的操作示例代码：
enum Car { lamborghini,tata,audi,fiat,honda } public class Main { public static void main(String args[]){ Car c; c = Car.tata; switch(c) { case lamborghini: System.out.println("你选择了 lamborghini!"); break; case tata: System.out.println("你选择了 tata!"); break; case audi: System.out.println("你选择了 audi!"); break; case fiat: System.out.println("你选择了 fiat!"); break; case honda: System.out.println("你选择了 honda!"); break; default: System.out.println("我不知道你的车型。"); break; } } }
以上代码运行输出结果为：
你选择了 tata!
Enum（枚举）构造函数及方法的使用
以下实例演示了Enum（枚举）构造函数及方法的使用：
enum Car { lamborghini(900),tata(2),audi(50),fiat(15),honda(12); private int price; Car(int p) { price = p; } int getPrice() { return price; } } public class Main { public static void main(String args[]){ System.out.println("所有汽车的价格："); for (Car c : Car.values()) System.out.println(c + " 需要 " + c.getPrice() + " 千美元。"); } }
以上代码运行输出结果为：
所有汽车的价格： lamborghini 需要 900 千美元。 tata 需要 2 千美元。 audi 需要 50 千美元。 fiat 需要 15 千美元。 honda 需要 12 千美元。
for 和 foreach循环使用
for 语句比较简单，用于循环数据。
for循环执行的次数是在执行前就确定的。语法格式如下：
for(初始化; 布尔表达式; 更新) { //代码语句 }
foreach语句是java5的新特征之一，在遍历数组、集合方面，foreach为开发人员提供了极大的方便。
foreach 语法格式如下：
for(元素类型t 元素变量x : 遍历对象obj){ 引用了x的java语句; }
以下实例演示了 for 和 foreach循环使用：
public class Main { public static void main(String[] args) { int[] intary = { 1,2,3,4}; forDisplay(intary); foreachDisplay(intary); } public static void forDisplay(int[] a){ System.out.println("使用 for 循环数组"); for (int i = 0; i < a.length; i++) { System.out.print(a[i] + " "); } System.out.println(); } public static void foreachDisplay(int[] data){ System.out.println("使用 foreach 循环数组"); for (int a : data) { System.out.print(a+ " "); } } }
以上代码运行输出结果为：
使用 for 循环数组 1 2 3 4 使用 foreach 循环数组 1 2 3 4
实例：
import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Main { public static void main(String[] args) { int[] arr = {1, 2, 3, 4, 5}; System.out.println("----------使用 for 循环------------"); for(int i=0; i<arr.length; i++) { System.out.println(arr[i]); } System.out.println("---------使用 For-Each 循环-------------"); //增强的 for 循环 For-Each for(int element:arr) { System.out.println(element); } System.out.println("---------For-Each 循环二维数组-------------"); //遍历二维数组 int[][] arr2 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} ; for(int[] row : arr2) { for(int element : row) { System.out.println(element); } } //以三种方式遍历集合 List List<String> list = new ArrayList<String>(); list.add("Google"); list.add("Runoob"); list.add("Taobao"); System.out.println("----------方式1：普通for循环-----------"); for(int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } System.out.println("----------方式2：使用迭代器-----------"); for(Iterator<String> iter = list.iterator(); iter.hasNext();) { System.out.println(iter.next()); } System.out.println("----------方式3：For-Each 循环-----------"); for(String str: list) { System.out.println(str); } } }
以上代码运行输出结果为：
----------使用 for 循环------------ 1 2 3 4 5 ---------使用 For-Each 循环------------- 1 2 3 4 5 ---------For-Each 循环二维数组------------- 1 2 3 4 5 6 7 8 9 ----------方式1：普通for循环----------- Google Runoob Taobao ----------方式2：使用迭代器----------- Google Runoob Taobao ----------方式3：For-Each 循环----------- Google Runoob Taobao
Varargs 可变参数使用
Java1.5提供了一个叫varargs的新功能，就是可变长度的参数。
"Varargs"是"variable number of arguments"的意思。有时候也被简单的称为"variable arguments"
定义实参个数可变的方法：只要在一个形参的"类型"与"参数名"之间加上三个连续的"."（即"..."，英文里的句中省略号），就可以让它和不确定个实参相匹配。
以下实例创建了 sumvarargs() 方法来统计所有数字的值：
public class Main { static int sumvarargs(int... intArrays){ int sum, i; sum=0; for(i=0; i< intArrays.length; i++) { sum += intArrays[i]; } return(sum); } public static void main(String args[]){ int sum=0; sum = sumvarargs(new int[]{10,12,33}); System.out.println("数字相加之和为: " + sum); } }
以上代码运行输出结果为：
数字相加之和为: 55
重载(overloading)方法中使用 Varargs
以下实例演示了如何在重载方法中使用可变参数：
public class Main { static void vaTest(int ... no) { System.out.print("vaTest(int ...): " + "参数个数: " + no.length +" 内容: "); for(int n : no) System.out.print(n + " "); System.out.println(); } static void vaTest(boolean ... bl) { System.out.print("vaTest(boolean ...) " + "参数个数: " + bl.length + " 内容: "); for(boolean b : bl) System.out.print(b + " "); System.out.println(); } static void vaTest(String msg, int ... no) { System.out.print("vaTest(String, int ...): " + msg +"参数个数: "+ no.length +" 内容: "); for(int n : no) System.out.print(n + " "); System.out.println(); } public static void main(String args[]){ vaTest(1, 2, 3); vaTest("测试: ", 10, 20); vaTest(true, false, false); } }
以上代码运行输出结果为：
vaTest(int ...): 参数个数: 3 内容: 1 2 3 vaTest(String, int ...): 测试: 参数个数: 2 内容: 10 20 vaTest(boolean ...) 参数个数: 3 内容: true false false
1278
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
