Java方法
2019-08-17 本文已影响0人
南风_001
方法重载
先来看下方法重载（Overloading）的定义：如果有两个方法的方法名相同，但参数不一致，哪么可以说一个方法是另一个方法的重载。 具体说明如下：
-
方法名相同
-
方法的参数类型，参数个不一样
-
方法的返回类型可以不相同
-
方法的修饰符可以不相同
-
main 方法也可以被重载
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 OverrideDemo {
public static void main(String[] args) {
MyClass t = new MyClass(3);
t.info();
t.info("重载方法");
//重载构造函数
new MyClass();
}
}
编译后的结果为：
房子高度为 3 米
房子高度为 3 米
重载方法: 房子高度为 3 米
无参数构造函数
Java 实例 - 输出数组元素
以下实例演示了如何通过重载 MainClass 类的 printArray 方法输出不同类型(整型, 双精度及字符型)的数组：
public class PrintArrayClass {
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
Java 实例 - 汉诺塔算法
汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
后来，这个传说就演变为汉诺塔游戏，玩法如下:
-
有三根杆子A,B,C。A杆上有若干碟子
-
每次移动一块碟子,小的只能叠在大的上面
-
把所有碟子从A杆全部移到C杆上
以下实例演示了汉诺塔算法的实现：
public class DoTowersDemo {
public static void main(String[] args) {
int nDisks = 3;
doTowers(nDisks, 'A', 'B', 'C');
}
public static void doTowers(int topN, char from, char inter, char to) {
if (topN == 1){
System.out.println("Disk 1 from "
+ from + " to " + to);
}else {
doTowers(topN - 1, from, to, inter);
System.out.println("Disk "
+ topN + " from " + from + " to " + to);
doTowers(topN - 1, inter, from, to);
}
}
}
编译后的结果为：
Disk 1 from A to C
Disk 2 from A to B
Disk 1 from C to B
Disk 3 from A to C
Disk 1 from B to A
Disk 2 from B to C
Disk 1 from A to C
Java 实例 - 斐波那契数列
斐波那契数列指的是这样一个数列 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 FibonacciDemo{
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
Java 实例 - 阶乘
一个正整数的阶乘（英语：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
Java 实例 - 方法覆盖
前面章节中我们已经学习了 Java 方法的重写，本文我们来看下 Java 方法覆盖的实现。
方法重载与方法覆盖区别如下：
-
方法重载(Overloading)：如果有两个方法的方法名相同，但参数不一致，哪么可以说一个方法是另一个方法的重载。
-
方法覆盖（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
Java 实例 - instanceof 关键字用法
instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。
instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。
以下实例创建了 displayObjectClass() 方法来演示 Java instanceof 关键字用法
import java.util.ArrayList;
import java.util.Vector;
public class DisplayObjectClassDemo {
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 类的实例
Java 实例 - break 关键字用法
Java break 语句可以直接强行退出当前的循环，忽略循环体中任何其他语句和循环条件测试。
以下实例使用了 break 关键字来跳出当前循环：
public class BreakDemo {
public static void main(String[] args) {
int[] intary = { 99,12,22,34,45,67,5678,8990 };
int no = 5678;
int i = 0;
boolean found = false;
for ( ; i < intary.length; i++) {
if (intary[i] == no) {
found = true;
break;
}
}
if (found) {
System.out.println(no + " 元素的索引位置在: " + i);
}
else {
System.out.println(no + " 元素不在数组中");
}
}
}
编译后的结果为：
5678 元素的索引位置在: 6
Java 实例 - continue 关键字用法
Java continue 语句语句用来结束当前循环，并进入下一次循环，即仅仅这一次循环结束了，不是所有循环结束了，后边的循环依旧进行。
以下实例使用了 continue 关键字来跳过当前循环并开始下一次循环：
public class ContinueDemo {
public static void main(String[] args) {
StringBuffer searchstr = new StringBuffer("hello how are you. ");
int length = searchstr.length();
int count = 0;
for (int i = 0; i < length; i++) {
if (searchstr.charAt(i) != 'h')
continue;
count++;
searchstr.setCharAt(i, 'h');
}
System.out.println("发现 " + count
+ " 个 h 字符");
System.out.println(searchstr);
}
}
编译后的结果为：
发现 2 个 h 字符
hello how are you.
Java 实例 - 标签(Label)
Java 中的标签是为循环设计的，是为了在多重循环中方便的使用break 和coutinue 。
以下实例当在循环中使用 break 或 continue 循环时跳到指定的标签处：
public class TestlblDemo {
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("字符串中没有发现子字符串。");
}
}
}
编译后的结果为：
发现子字符串。
Java 实例 - enum 和 switch 语句使用
Java 创建枚举类型要使用 enum 关键字，隐含了所创建的类型都是 java.lang.Enum 类的子类
对enum进行遍历和switch的操作示例代码：
public class EnumAndSwitchDemo {
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;
}
}
}
enum Car {
lamborghini,tata,audi,fiat,honda
}
编译后的结果为：
你选择了 tata!
Java 实例 - Enum（枚举）构造函数及方法的使用
以下实例演示了Enum（枚举）构造函数及方法的使用：
public class EnumAndFuncDemo {
public static void main(String[] args) {
System.out.println("所有汽车的价格：");
for (Bus c : Bus.values())
System.out.println(c + " 需要 "
+ c.getPrice() + " 千美元。");
}
}
enum Bus {
lamborghini(900),tata(2),audi(50),fiat(15),honda(12);
private int price;
Bus(int p) {
price = p;
}
int getPrice() {
return price;
}
}
编译后的结果为：
所有汽车的价格：
lamborghini 需要 900 千美元。
tata 需要 2 千美元。
audi 需要 50 千美元。
fiat 需要 15 千美元。
honda 需要 12 千美元。
Java 实例 - for 和 foreach循环使用
for 语句比较简单，用于循环数据。
for循环执行的次数是在执行前就确定的。语法格式如下：
for(初始化; 布尔表达式; 更新) {
//代码语句
}
foreach语句是java5的新特征之一，在遍历数组、集合方面，foreach为开发人员提供了极大的方便。
foreach 语法格式如下：
for(元素类型t 元素变量x : 遍历对象obj){
引用了x的java语句;
}
以下实例演示了 for 和 foreach循环使用：
public class ForEachDemo {
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 ForEachDemoPlus {
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
Java 实例 - Varargs 可变参数使用
Java1.5提供了一个叫varargs的新功能，就是可变长度的参数。
"Varargs"是"variable number of arguments"的意思。有时候也被简单的称为"variable arguments"
定义实参个数可变的方法：只要在一个形参的"类型"与"参数名"之间加上三个连续的"."（即"..."，英文里的句中省略号），就可以让它和不确定个实参相匹配。
以下实例创建了 sumvarargs() 方法来统计所有数字的值：
public class VarsDemo {
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
Java 实例 - 重载(overloading)方法中使用 Varargs
以下实例演示了如何在重载方法中使用可变参数：
public class VarsOverloadingDemo {
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
源地址：Java 实例
github地址：Java学习
