java中函數
『壹』 java中,什麼是類,方法,函數 三者又有什麼區別
類 就是 指一個種類，比如 人 ，是一個類，動物 也是一個類，等等
而如果特指某個人，則是實體。
在Java中，類的定義是 : < class> <類名> ,通常，我們在Java 中提到class，就是指類的意思。
（ <> 符號要去掉）
另外，方法與函數其實一樣的，只是在C語言中我們習慣叫函數，而在Java中我們習慣叫方法，不管怎麼叫，都是指同一個意思。
方法（或函數，為了方便，下面我都說 方法 ） 必須在類中。方法的定義 ：
<修飾符><返回值><方法名> (<參數類型> <參數名>){.....}
（ <> 符號要去掉）
通常你看到一個帶()的就是方法了，例如: aa.XXX(); 是指調用實體 aa的XXX()方法。
類 可以擁有 屬性跟方法。方法在類中。
在 類 和 方法 中均創建 某個類 的實體，可以調用類的方法。
程序運行時，首先是從main()方法開始運行的。
main()函數必須放在 跟你文件名同名的類中，另外一個class文件中只能有一個mian()方法,
否則，在編譯運行的時候會出錯。
『貳』 java函數是什麼意思
函數就是一個動作一個行為哈，比如殺人防火這個動作，那就需要寫兩個函數，一個函數是殺人另一個函數是放火。
在寫函數時，只需要關注函數的返回值和參數就可以了，比如兩個數相加的函數，那參數肯定就是2個數，我要實現那兩個數的相加，那返回值就是兩個數的之和。
只要明白了上面的東西，函數的寫法就很容易了。
第一個是寫函數訪問修飾符
後面是函數的返回值
函數名稱（參數列表）
{
函數體（就是要實現函數的功能）
}
『叄』 java中都有哪些函數
1:數組方面:
數組是一個對象,數組名可以理解和C++裡面一樣,
1):System.array(src,srcindex,dst,dstindex,src.length);
2):java.util.Arrays.sort(數組名);//塊數排序法進行排序
3):java.util.Arrays.binarySearch(arr,key);//從哪裡收,關鍵值,返回索引.沒有的話返回-1
4):java.util.Array.fill(arr,value),設置數組初始值
5):Array.equals(arr1,arr2)//比較兩個數組中元素是不是全部相等,是返回true,不是返回false
2:時間方面:
public static String dateToStr(java.util.Date date)
{
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = sdf.format(date);
return str;
}
import java.text.SimpleDateFormat;
import java.util.Calendar;
public class DateUtil
『肆』 java中是否有函數概念
方法是一個類中的，也就是說給類創建一個對象，而這個方法是屬於這個對象的。而函數並不是方法，比如在JS中，函數直接聲明，就可以通過調用來執行，而它並不屬於一個對象。但是，在Java中，屬性和方法都是屬於一個類的，因此，准確來說，在Java中，沒有函數概念，也盡量不要用函數來稱呼Java方法。個人理解，勿噴
『伍』 哪位高手幫下忙,java中如何使用函數
}
}
要使用此函數時需要將此類導入即;
最後就可以使用創建的對象調用函數了aapackage
test.print(":import
test;
對於系統函數道理也是一樣;sss".out.println(str);).testTest;
然後就是創建對象
testTest
aa
=
new
testTest()。希望對你有幫助;
public
class
testTest
{
public
void
print(String
str)
{
System
『陸』 Java中如何調用函數和自定義函數
調用函數
System.out.println("hello world");
println即為函數，out為是輸出對象，System為java系統類。
Java源程序（.java文件）——>java位元組碼文件（.class文件）——>由解釋執行器（java.exe）將位元組碼文件載入到java虛擬機（jvm）——>位元組碼文件（.class）就會在java虛擬機中執行。
Java的基本包
java.lang其中包含有：
介面：Comparable、Cloneable、Runable等
類：八個基本數據類型封裝類、Math、Runtime、Object、String、StringBuffer、Thread、Exception等
『柒』 java中的函數調用怎麼理解
函數調用可以理解為：
你想去買一樣東西，這時，可能會叫你的秘書去幫你買它。
您的秘書可能不熟悉市場，這時她委任采購部門去幫她購買你需要的東西。
不好意思，昨天有事匆忙留下一段，還有一段沒有完成。。。
在JAVA中怎麼使用 什麼時候能用到？
我就大致的回答一下吧。如果不合心意，還請諒解！
OOP強調低耦合，高內聚。單一職責原則。還有許多模式以及原則，使你的系統富有彈性，易於擴展，修改，維護。
內聚就是一個模塊內各個元素彼此結合的緊密程度，高內聚就是一個模塊內各個元素彼此結合的緊密程度高。
所謂高內聚是指一個軟體模塊是由相關性很強的代碼組成，只負責一項任務，也就是常說的單一責任原則。
耦合：一個軟體結構內不同模塊之間互連程度的度量(耦合性也叫塊間聯系。指軟體系統結構中各模塊間相互聯系緊密程度的一種度量。模塊之間聯系越緊密，其耦合性就越強，模塊的獨立性則越差，模塊間耦合的高低取決於模塊間介面的復雜性，調用的方式以及傳遞的信息。) 對於低耦合，粗淺的理解是：
一個完整的系統，模塊與模塊之間，盡可能的使其獨立存在。
也就是說，讓每個模塊，盡可能的獨立完成某個特定的子功能。
模塊與模塊之間的介面，盡量的少而簡單。
如果某兩個模塊間的關系比較復雜的話，最好首先考慮進一步的模塊劃分。
這樣有利於修改和組合。[1]
引用：http://ke..com/view/3082578.html
代碼的話，我就不多說了。自己估量估量，就知道是怎麼回事了。
『捌』 java中函數的聲明和定義
Java中，我們應該知道最基本的就是定義變數和聲明變數了，那麼定義與聲明這兩者有沒有區別呢?具體的區別又是哪些呢?下面學習啦小編來告訴你定義與聲明的區別。
定義和聲明的定義區別
1、一種是需要建立存儲空間的。例如：int a 在聲明的時候就已經建立了存儲空間。
2、另一種是不需要建立存儲空間的。 例如：extern int a 其中變數a是在別的文件中定義的。
聲明是向編譯器介紹名字--標識符。它告訴編譯器「這個函數或變數在某處可找到，它的模樣象什麼」。
而定義是說：「在這里建立變數」或「在這里建立函數」。它為名字分配存儲空間。無論定義的是函數還是變數，編譯器都要為它們在定義點分配存儲空間。
對於變數，編譯器確定變數的大小，然後在內存中開辟空間來保存其數據，對於函數，編譯器會生成代碼，這些代碼最終也要佔用一定的內存。
總之就是：把建立空間的聲明成為「定義」，把不需要建立存儲空間的成為「聲明」。
基本類型變數的聲明和定義(初始化)是同時產生的;而對於對象來說，聲明和定義是分開的。
下面小編給大家舉個例子說明一下。
例如：類A
如果A a;就是一個聲明，告訴編譯器a是A類的一個對象變數，但是不進行初始化;
如果以後a=new A();這就是初始化，分配了空間。
需要注意的是我們聲明的最終目的是為了提前使用，即在定義之前使用，如果不需要提前使用就沒有單獨聲明的必要，變數是如此，函數也是如此，所以聲明不會分配存儲空間，只有定義時才會分配存儲空間。
用static來聲明一個變數的作用有二：
(1)對於局部變數用static聲明，則是為該變數分配的空間在整個程序的執行期內都始終存在。
(2)外部變數用static來聲明，則該變數的作用只限於本文件模塊。
定義和聲明的具體區別
所謂定義就是(編譯器)創建一個對象，為這個對象分配一塊內存，並給它取上一個名字，這個名字就是就是我們經常所說的變數名或對象名。
聲明有2重含義：
(1) 告訴編譯器，這個名字已經匹配到一塊內存上，下面的代碼用到變數或者對象是在別的地方定義的。聲明可以出現多次。
(2) 告訴編譯器，這個名字已經被預定了，別的地方再也不能用它來作為變數名或對象名。
定義和聲明最重要區別
定義創建對象並為這個對象分配了內存，聲明沒有分配內存。
『玖』 java中基礎函數問題
一、函數的定義及特點
1) 什麼是函數？
函數就是定義在類中的具有特定功能的一段獨立小程序，函數也稱為方法
2)Java中函數的格式：
修飾符 返回值類型函數名（參數類型 形式參數1，參數類型 形式參數2，。。）
｛ 執行語句;
return 返回值；
｝
返回值類型：函數運行後的結果的數據類型
參數類型：是形式參數的數據類型
形式參數：是一個變數，用於存儲調用函數時傳遞給函數的實際參數
實際參數：傳遞給形式參數的具體數值
return：用於結束函數
返回值：該值會返回給調用者
3) 函數的特點
a) 定義函數可以將功能代碼進行封裝
b) 便於對該功能進行復用
c) 函數只有被調用才會被執行
d) 函數的出現提高了代碼的復用性
e) 對於函數沒有具體返回值的情況，返回值類型用關鍵字void表示，那麼該函數中的return語句如果在最後一行可以省略不寫，系統會幫你自動加上。
註：
a) 函數中只能調用函數，不可以在函數內部定義函數。
b) 定義函數時，函數的結果應該返回給調用者，交由調用者處理。
c) 當函數運算後，沒有具體的返回值時，這是返回值類型用一個特殊的關鍵字來標識該關鍵字就是void，void：代表的是函數沒有具體返回值的情況。
d) 當函數的返回值類型是void時，函數中的return語句可以省略不寫。
4) 如何定義一個函數？
函數其實就是一個功能，定義函數就是實現功能，通過兩個明確來完成：
1）、明確該功能的運算完的結果，其實是在明確這個函數的返回值類型。
2）、在實現該功能的過程中是否有未知內容參與了運算，其實就是在明確這個函數的參數列表(參數類型&參數個數)。
5) 函數的作用：
1）、用於定義功能。
2）、用於封裝代碼提高代碼的復用性。
注意：函數中只能調用函數，不能定義函數。
6) 主函數：
1）、保證該類的獨立運行。
2）、因為它是程序的入口。
3）、因為它在被jvm調用。
7) 函數定義名稱是為什麼呢？
答：1）、為了對該功能進行標示，方便於調用。
2）、為了通過名稱就可以明確函數的功能，為了增加代碼的閱讀性。
二、函數的應用
1) 兩個明確
a) 明確要定義的功能最後的結果是什麼？
b) 明確在定義該功能的過程中，是否需要未知內容參與運算
2) 示例：
舉例1：
復制代碼代碼如下:
class FunctionDemo
{
public static void main(String[] args)
{
int x = 4;
System.out.println(x*3+5);
x = 6;
System.out.println(x*3+5);
int y = 4*3+5;
int z = 6*3+5;
System.out.println(y);
System.out.println(z);
}
}
發現以上的運算，因為獲取不同數據的運算結果，代碼出現了重復。
為了提高代碼的復用性。對代碼進行抽取。將這個部分定義成一個獨立的功能。方便與日後使用。
java中對功能的定義是通過函數的形式來體現的。
明確功能：需要定義功能，完成一個整數的*3+5的運算，
1,先明確函數定義的格式。
/*
修飾符返回值類型函數名(參數類型形式參數1，參數類型形式參數2，)
{
執行語句;
return 返回值;
}
復制代碼代碼如下:
class FunctionDemo
{
public static void getResult(int num)
{
System.out.println(num * 3 + 5);
return;//可以省略
}
public static void main(String[] args)
{
getResult(5);
}
}
對上述關於return是否省略這一小小知識點的總結：
當函數運算後，沒有具體的返回值時，這是返回值類型用一個特殊的關鍵字來標識。
該關鍵字就是void。void:代表的是函數沒有具體返回值的情況。
當函數的返回值類型是void時，函數中的return語句可以省略不寫。
舉例2：
復制代碼代碼如下:
class FunctionDemo2
{
public static void main(String[] args)
{
int sum = getSum(4,6);
System.out.println("sum="+sum);
sum = getSum(2,7);
System.out.println("sum="+sum);
}
/*下面的這個功能定義思想有問題，為什麼呢？因為只為完成加法運算，至於是否要對和進行列印操作，
那是調用者的事，不要在該功能中完成。*/
public static void get(int a,int b)
{
System.out.println(a+b);
return ;
}
}
如何定義一個函數呢？
1，既然函數是一個獨立的功能，那麼該功能的運算結果是什麼先明確
因為這是在明確函數的返回值類型。
2，在明確在定義該功能的過程中是否需要未知的內容參與運算。
因為是在明確函數的參數列表（參數的類型和參數的個數）。
復制代碼代碼如下:
class FunctionDemo2
{
public static void main(String[] args)
{
/*
int sum = getSum(4,6);
System.out.println("sum="+sum);
sum = getSum(2,7);
System.out.println("sum="+sum);
*/
//get(4,5);
int x = getSum(4,4);
int y = getSum(7,9);
int num = getMax(x,y);
}
//需求：定義一個功能。完成3+4的運算。並將結果返回給調用者。
/*
1，明確功能的結果：是一個整數的和。
2，在實現該功能的過程中是否有未知內容參與運算，沒有。
其實這兩個功能就是在明確函數的定義。
1，是在明確函數的返回值類型。
2，明確函數的參數列表( 參數的類型和參數的個數)。
*/
public static int getSum()
{
return 3+4;
}
/*
以上這個函數的功能，結果是固定的，毫無擴展性而言。
為了方便用戶需求。由用戶來指定加數和被加數。這樣，功能才有意義。
思路：
1，功能結果是一個和。返回值類型是int。
2，有未知內容參與運算。有兩個。這個兩個未知內容的類型都是int。
*/
public static int getSum(int x,int y)
{
return x+y;
}
/*
需求：判斷兩個數是否相同。
思路：
1，明確功能的結果：結果是：boolean 。
2，功能是否有未知內容參與運算。有，兩個整數。
*/
public static boolean compare(int a,int b)
{
/*
if(a==b)
return true;
//else
return false;
*/
//return (a==b)?true:false;
return a==b;
}
/*
需求：定義功能，對兩個數進行比較。獲取較大的數。
*/
public static int getMax(int a,int b)
{
/*
if(a>b)
return a;
else
return b;
//或者用下面的三元運算符
*/
return (a>b)?a:b;
}
}
3) 練習：
1，定義一個功能，用於列印矩形。
2，定義一個列印99乘法表功能的函數。
復制代碼代碼如下:
class FunctionTest
{
public static void main(String[] args)
{
draw(5,6);
printHr();
draw(7,9);
printHr();
print99();
}
/*
定義一個功能，用於列印矩形。
思路：
1，確定結果：沒有，因為直接列印。所以返回值類型是void
2，有未知內容嗎？有，兩個，因為矩形的行和列不確定。
*/
public static void draw(int row,int col)
{
for(int x=0; x<row; x++)
{
for(int y=0; y<col; y++)
{
System.out.print("*");
}
System.out.println();
}
}
public static void printHr()
{
System.out.println("------------------------------");
}
/*
定義一個列印99乘法表功能的函數。
*/
public static void print99()
{
for(int x=1; x<=9; x++)
{
for(int y=1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
}
三、函數的重載（overload）
重載的概念：
在同一個類中，允許存在一個以上的同名函數，只要它們的參數個數或者參數類型不同即可。
重載的特點：
與返回值類型無關，只看參數列表。
重載的好處：
方便於閱讀，優化了程序設計。
重載示例：
返回兩個整數的和
int add(int x,int y){return x+y;}
返回三個整數的和
int add（int x,int y, int z）{return x+y+z;}
返回兩個小數的和
double add(double x,double y){return x+y;}
什麼時候用重載？
當定義的功能相同，但參與運算的未知內容不同。
那麼，這時就定義一個函數名稱以表示起功能，方便閱讀，而通過參數列表的不同來區分多個同名函數。
重載範例：
復制代碼代碼如下:
class FunctionOverload
{
public static void main(String[] args)
{
add(4,5);
add(4,5,6);
print99();
}
public static void print99(int num)
{
for(int x=1; x<=num; x++)
{
for(int y=1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
//列印99乘法表
public static void print99()
{
print99(9);
}
//定義一個加法運算，獲取兩個整數的和。
public static int add(int x,int y)
{
return x+y;
}
//定義一個加法，獲取三個整數的和。
public static int add(int x,int y,int z)
{
return add(x,y)+z;
}
}
練習：區分是否是重載
復制代碼代碼如下:
void show(int a,char b,double c){}
下面的a,b,c,d,e,f與上述一句的區別：
a.
void show(int x,char y,double z){}//沒有，因為和原函數一樣。
b.
int show(int a,double c,char b){}//重載，因為參數類型不同。注意：重載和返回值類型沒關系。
c.
void show(int a,double c,char b){}//重載，因為參數類型不同。注意：重載和返回值類型沒關系。
d.
boolean show(int c,char b){}//重載了，因為參數個數不同。
e.
void show(double c){}//重載了，因為參數個數不同。
f.
double show(int x,char y,double z){}//沒有，這個函數不可以和給定函數同時存在與一個類中。
如何區分重載：當函數同名時，只看參數列表。和返回值類型沒關系。
『拾』 為什麼Java的"函數"叫做方法（為什麼用'method'，而不是'function'）
java是面向對象語言，對象只有屬性和方法。一般將面向過程語言中的函數稱為函數，面向對象，屬於對象的函數稱為方法。