菜鳥學JAVA之——類、對象、方法

類、對象

萬事萬物皆對象
在這裏插入圖片描述

  • 抽象:提取關鍵特徵形成模板

  • 類:所有相似對象,關鍵特徵的集合

  • 很多個對象中具有相同的屬性和方法時,我們就可以將其抽象成類

  • 類中定義的屬性不需要賦初值;

  • 不同的場景對象抽象出的特徵不一樣

  • 行爲(方法):一系列動作的集合,參數是方法的條件 ,結束的動作是得到一個結果

面向過程與面向對象的區別

面向過程

面對過程編程,需要把過程描述的很詳細

面向對象

放在方法裏,對象學會了這個方法,控制對象就行了 【對象.方法(參數);】
eg:搬宿舍
面向過程,一個一個地搬行李;
面向對象,打包好,調用人來搬。

方法(把相同相似的過程包裹起來)

方法不能聲明在方法體中

格式

訪問控制 [static] 返回值類型 方法名 ( 參數列表 ) { 方法體 }

public static int[] sort(int[] args){

//方法體

[return[返回值];]

}

eg:現在需要給兩個數組進行排序

代碼示例

import java.util.*;
public class Sort{
    public static void main(String[] args){
        int[] arrays1 = {55,78,33,26,42,99,102,50,4};
        int[] arrays2 = {5,8,3,44,56,22,10,123,222,32}; 
        //arrays1排序
        for(int i = 0; i < arrays1.length; i++){
            for(int j = i; j > 0;j--){
                if(arrays1[j] < arrays1[j-1]){
                    int temp = arrays1[j];
                    arrays1[j] = arrays1[j-1];
                    arrays1[j-1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arrays1));
         //arrays1排序
        for(int i = 0; i < arrays2.length; i++){
            for(int j = i; j > 0;j--){
                if(arrays2[j] < arrays2[j-1]){
                    int temp = arrays2[j];
                    arrays2[j] = arrays2[j-1];
                    arrays2[j-1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arrays2)); 
    }
}

那麼問題來了,如果需要給100個數組排序,還需要寫100遍排序算法嗎?

這時發現每個排序大致都是一樣的,有變化的只是數組的名稱

所以將公共方法提取出來,打包成方法,這裏就引入了方法

代碼示例

import java.util.*;
public class Sort{//類名:大駝峯命名法
    public static void main(String[] args){
        int[] arrays1 = {55,78,33,26,42,99,102,50,4};
        int[] arrays2 = {5,8,3,44,56,22,10,123,222,32}; 
      	arrays1 = sort(arrays1); //調用sort方法給arrays1排序
        arrays2 = sort(arrays2); //調用sort方法給arrays2排序
        System.out.println(Arrays.toString(arrays1));               				System.out.println(Arrays.toString(arrays2));
    }
    //注意:方法不能聲明在方法體中!
     public static int[] sort(int[] arr){ //方法名:小駝峯命名法
         for(int i = 0; i < arr.length; i++){
            for(int j = i; j > 0;j--){
                if(arr[j] < arr[j-1]){
                    int temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                }
            }
        }
        return arr;
     }
}

這時,如果需要給100個數組排序只需調用100次sort()方法即可,這就大大降低了代碼的冗餘度。

這裏再說下方法中的一個特殊的形參——不定長參數集

public static void print(String... strs)
{
    for (int i = 0; i < strs.length; i++)   //獲取長度的方式跟數組的一樣
    {
        System.out.println(strs[i]);
    }
}

調用方法時,可以傳任意多個參數,傳之前並不需要定義他有多長。不定長參數集也可以不傳參數
有幾種形式:int… String… Object…(這個形式數爲可以傳任意類型任意多個參數)

舉例來看一下

public class Test {
    void hit(String... name) {
    
	}
}
public class Main {
    public static void main(Stirng) {
        hit("zhangaoqi","zhangsan","lisi");  //正確
        hit();   //正確
        hit("wangwu"); //正確
    }
}

注意:如果要用String… arg(類似這樣的不定長參數集) ,那一定要把他聲明在末尾。且不定長參數集在方法的形參中,最多隻能聲明一個

void hit(String... a,String... b){}  //錯誤,因爲傳參時就不知道是給那個傳了,無法區分
void hit(String.. a,int b ) //錯誤,如果String不傳,只傳一個int數字,也就錯了
void hit(int a,String... b) //正確,可區分了

這個不定長參數集其實就是一個不定長的數組,可以把它當作數組來操作(jdk5.0之前沒有不定長參數集,就是用數組來實現的)

public void show(String... arr) {
        for(int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

構造方法

作用:初始化對象

特點:

  1. 無返回值
  2. 方法名必須與類名相同
  3. 在創建對象時一定調用構造方法
  4. 在你未定義構造方法的時候系統會自動定義一個構造方法,如果你定義了構造方法,則此方法會覆蓋掉系統自定義的方法
public class Person{
    String name;
    Person(){  //構造方法
        
    }
}

靜態方法和動態方法的區別
動態方法:必須要有對象,才能調用
靜態方法(static):靜態方法是可以直接調用的方法,不需要對象的調用

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章