Java-數組-面向對象

阿新 • • 發佈：2018-08-21

測試類 style 我們計數器 java sea 做的不同出現

數組的應用練習:

數組的復制:

/*
數組的復制：重點考察是否需要返回值
int[] arr = {1,2,3};

思路:
    1.創建一個和原數組一樣大小的數組
    2.遍歷原數組,將每個元素依次賦值給新數組的每個元素

    
== 比較運算符:    
基本數據類型:比較的就是數值
    int a = 10;int b = 20;
    a == b
引用數據類型:比較的是內存地址值    
    int[] arr = {};
    int[] arr2 = {};
    arr == arr2
*/
public class 
 CopyArrayDemo{
    public static void main(String[] args){
        
        int[] src = {1,2,3};
        
        int[] copy = copyArray(src);
        //打印源數組
        print(src);
        print(copy);
        //為了驗證兩個數組變量確實是不同的內存地址值,可以比較
        //由於是引用數據類型,== 比較的是它們引用的地址值.
        System.out.println(src == copy);
        
    }
     
public static int[] copyArray(int[] src){
        //根據原數組的長度,創建一個新數組
        int len = src.length;
        
        int[] dest = new int[len];
        //遍歷並賦值
        for(int i = 0;i<len;i++){
            
            dest[i] = src[i];
            
        }
        
        return dest;
    }
     
public static void print(int[] arr){
        
        for(int i = 0;i<arr.length;i++){
            
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
    
}

View Code

數組的合並:

分析:

創建新數組,長度是兩個駐足的長度之和

遍歷第一個數組,依次賦值給目標數組

遍歷第二個數組,依次賦值給目標數組(代碼查看)

/*
合並兩個數組
data1 = [1,2,3]  data2 = [4,5,6]

思路:
    1.創建一個大的數組:其長度是兩個小數組長度之和.
    2.遍歷小數組,依次賦值給大數組的元素

*/
public class CombineArray{
    public static void main(String[] args){
        
        int[] arr1 = {1,2,3};
        int[] arr2 = {4,5,6};
        
        //調用方法,合並兩個數組
        print(arr1);
        print(arr2);
        int[] dest = combine(arr1,arr2);
        print(dest);
        
        
    }
    public static int[] combine(int[] arr1,int[] arr2){
        
        //創建一個大數組,長度是兩個參數數組的長度之和
        int[] dest = new int[arr1.length + arr2.length];
        //遍歷第一個數組
        for(int i = 0;i<arr1.length;i++){
            
            dest[i] = arr1[i];
        }
        //遍歷第二個數組
        for(int i = 0;i<arr2.length;i++){
            
            dest[arr1.length + i] = arr2[i];
        }
        
        return dest;
        /*
        //用一個變量記錄目標數組的賦值的位置
        int index = 0;
        //創建一個大數組,長度是兩個參數數組的長度之和
        int[] dest = new int[arr1.length + arr2.length];
        //遍歷第一個數組
        for(int i = 0;i<arr1.length;i++){
            dest[index] = arr1[i];
            index++;
        }
        //遍歷第二個數組
        for(int i = 0;i<arr2.length;i++){
            dest[index] = arr2[i];
            index++;
        }
        return dest;
        */
        /*
        //用一個變量記錄目標數組的賦值的位置
        int index = 0;
        //創建一個大數組,長度是兩個參數數組的長度之和
        int[] dest = new int[arr1.length + arr2.length];
        //遍歷第一個數組
        for(int i = 0;i<arr1.length;i++){
            dest[index++] = arr1[i];
            // index++;
        }
        //遍歷第二個數組
        for(int i = 0;i<arr2.length;i++){
            dest[index++] = arr2[i];
            // index++;
        }
        return dest;
        */

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

View Code

還有奇偶數索引元素的抽取,數組逆序等問題.(代碼查看)

/*
抽取奇數索引的元素(偶數的自己練習)

分析:
1.得到原始數組中奇數索引的個數,
2.根據奇數索引的個數創建目標數組
3.遍歷原始數組,把奇數索引的元素賦值給目標數組

推算奇數索引個數的過程:

1      0
11     1
111    1
1111   2
11111  2
...

*/
public class GetOddIndexElementDemo{
    public static void main(String[] args){
        int[] src = {1,5,2,7,8,5,6};
        print(src);
        
        int[] dest = getOddIndex(src);
        print(dest);
        
    }
    //打印數組元素
    public static void print(int[] arr){
        for(int i = 0;i<arr.length;i++){
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
    //定義方法,抽取原始數組的奇數索引的元素值.
    public static int[] getOddIndex(int[] src){
        //1.得到原始數組中奇數索引的個數
        int len = src.length / 2;
        //2.根據奇數索引的個數創建目標數組
        int[] dest = new int[len];
        
        //
        int index = 0;
        //
        for(int i = 0;i<src.length;i++){
            
            if(i % 2 != 0){
                dest[index++] = src[i];
            }
        }
        return dest;
        
    }
    
}

View Code

/*

    數組的逆序:
        兩兩交換!!
        次數問題:
            元素的個數 / 2
        交換兩個變量的值的操作是重復執行的動作.    
*/
public class ReverseArrayDemo{
    public static void main(String[] args){
        int[] arr = {1,2,3,4,5};
        
        System.out.println("逆序之前:");
        print(arr);
        
        reverse(arr);
        System.out.println("逆序之後:");
        print(arr);
        
    }
    
    public static void print(int[] arr){
        for(int i = 0;i<arr.length;i++){
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }    
    
    //自定義方法,實現數組的逆序:
    //返回值類型:void
    //形參列表:int[]
    public static void reverse(int[] arr){
        //計算出兩兩交換的次數
        int count = arr.length / 2;
        
        //
        for(int i = 0;i<count;i++){
            //交換兩個變量的值
            int tmp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = tmp;
        }
        
    }    
    
}

View Code

Java中參數傳遞的原則:

Java中所有的參數傳遞原則是:值傳遞

不論是基本數據類型還是引用數據類型,傳遞給形參的都是實參的副本!

基本數據類型的形參,在方法體內的更改,在方法外看不到.

應用數據類型的形參,在方法體內對應用內存地址中的元素的更改,在方法外可以看到.

(代碼中詳細介紹)

/*
    參數傳遞的原則:
        若參數是基本數據類型:傳遞是實參的一個副本.
            方法體內對形參數據的更改,在方法外看不到
            
        若參數是引用數據類型:傳遞是實參的一個副本.
            方法體內對形參指向的對象的數據的更改,在方法外可以看到!!!
*/
public class PassArgsDemo{
    public static void main(String[] args){
        /*
        //
        int x = 10;
        int y = 20;
        clear(x,y);
        System.out.println(x +","+ y);//10,20
        */
        
        //
        int[] arr = {1,2,3};
        //
        print(arr);
        
        //單獨調用
        clear(arr);
        
        //查看數組的元素值
        print(arr);
        
    }
    
    public static void print(int[] arr){
        for(int i = 0;i<arr.length;i++){
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
    
    //自定義方法,參數是基本數據類型
    public static void clear(int a,int b){//形參上的a,b實際上只是接收了實參的值的副本!!
        System.out.println("clear方法被調用");
        //把傳遞進來的參數設置為0
        a = 0;
        b = 0;
    }
    
    
    //自定義方法,參數是引用數據類型
    public static void clear(int[] arr){
        //遍歷數組,都賦值為0
        for(int i = 0;i<arr.length;i++){
            arr[i] = 0;
        }
    }
    
}
值傳遞:
不論是基本數據類型還是引用數據類型,傳遞給形參的都是實參的副本!!
只不過:
基本數據類型的形參,在方法體內的更改,在方法外不看到.
引用數據類型的形參,在方法體內的更改,在方法外可以看到.

public static void test1(int a){
    //這裏對形參a做的所有改變,都是對副本的改變,在方法外部是看不到的!!!
}

public static void test2(int[] arr){
    //這裏對arr指向的內存空間的更改,在方法外可以看到,
    //因為兩個引用都指向的是同樣的內存空間

    //但是對arr重新賦值,在方法外是看不到的.
    arr = null;
    //表示把形參引用的地址值改了,並不是把arr原來指向的內存地址的內容改了.
    //此時在方法外是看不到改變的.
}

View Code

二維數組:

元素本身是一維數組的一維數組.

初始化方式:

動態初始化:

int[][] arr = new int[3][];

int[][] arr = new int[3][2];

靜態初始化:

int[][] arr = new int[][]{{1},{2,3},{4,5,6}};

int[][] arr = {{7},{8,9},{10,11,12}};

二維數組的應用(查看代碼):

/*
    二維數組:元素本身是一維數組的 一維數組.
        int[][] arr = new int[3][];    //定義一個有三個元素的二維數組,它的每個元素又是另一個一維數組
        arr[0] = new int[2];
        arr[1] = {1,2,3};
        
    二維數組的遍歷:
        關鍵是第二維數組的長度的確定.
            二維數組名[index].length
*/
public class Dem2Array{
    public static void main(String[] args){
        /*
        //定義一個二維數組,動態初始化,指定長度是3
        int[][] arr = new int[3][];
        //指定每個元素指向的一維數組是...
        arr[0] = new int[2];
        arr[1] = new int[3];
        //打印二維數組的各個元素值:
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        
        //訪問二維數組中的元素
        System.out.println(arr[0][0]);//0
        
        //第二種格式:二維數組的每個元素指向的一維數組長度是一致的.
        int[][] arr2 = new int[2][4];
        
        //第三種格式:靜態初始化,指定值,不指定長度!
        int[][] arr3 = new int[][]{{1},{2,3,4,5,6},{1,2}};
        */
        
        int[][] arr3 = new int[][]{{1},{2,3,4,5,6},{1,2}};
        //遍歷二維數組
        //外層循環控制的是二維數組的元素的遍歷
        for(int i = 0;i<arr3.length;i++){
            //內層循環控制的是最裏層的一維數組的元素的遍歷
            for(int j = 0;j<arr3[i].length;j++){
                System.out.print(arr3[i][j] + " ");
            }
            System.out.println();
        }
        
        
    }
}

View Code

/*
    獲取二維數組所有元素的個數:
    
    計數器思想:
        定義一個變量,初始值必須為0,滿足條件時,加1.
        
*/
public class GetCountDemo{
    public static void main(String[] args){
        int[][] arr = {{1},{2,3},{4,5,6},null};
        arr[3] = new int[]{7,8,9};//在二維數組動態初始化時,一維數組的初始化,不能簡寫!!!
        
        //
        int count = 0;
        for(int i = 0;i<arr.length;i++){
            for(int j = 0;j<arr[i].length;j++){
                count++;
            }
        }
        //
        System.out.println("二維數組的元素個數是: " + count);
    }
}

View Code

/*
    假設以下是某公司四個季度的銷售記錄,將數據保存在一個二維數組中,並統計全年的銷量之和
        第一季度：10,20,30
        第二季度：40,50,60
        第三季度：70,80,90
        第四季度：30,30,30

*/
public class GetSum{
    public static void main(String[] args){
        int[][] arr = {{10,20,30},{40,50,60},{70,80,90},{30,30,30}};
        int sum = 0;
        for(int i = 0;i<arr.length;i++){
            for(int j = 0;j<arr[i].length;j++){
                sum += arr[i][j];
            }
        }
        System.out.println("全年的銷量之和是 :" + sum);
        
    }
    
}

View Code

/*

楊輝三角形:
1
11
121
1331
...


規律:
每行的數字個數和行數相同!
行首和行尾都為1,
其它的數字:是它正上方的數字和緊鄰的前一個數字之和.

*/
public class YangHuiDemo{
    public static void main(String[] args){
        int[][] arr = new int[8][];
        //給每個二維數租的元素賦值
        for(int i = 0;i<arr.length;i++){
            //創建一個新的數組
            arr[i] = new int[i+1];
            
            //循環新建的一維數組
            for(int j = 0;j<arr[i].length;j++){
                //對新建的一維數組賦值
                if(i == 0 || j == 0 || j == i){
                    arr[i][j] = 1;
                }else{
                    arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
                }
            }
            
        }
        
        for(int i = 0;i<arr.length;i++){
            for(int j = 0;j<arr[i].length;j++){
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

View Code

面向對象編程:

類和對象的關系:

定義一個Dog類:
        成員變量:
            String color;
            int price;
            String name;
            int age;
            
        成員方法:
            public void eat(){
                
            }
            public void sleep(){
                
            }
    類是一個抽象的概念:
        作用主要是用來創建對象!!!
        
    創建對象的格式:
        類名 對象名 = new 類名();
        Dog d = new Dog();
*/

定義類,使用類:

/*
    定義一個Dog類:
        成員變量:
            String color;
            int price;
            String name;
            int age;
            
        成員方法:
            public void eat(){
                
            }
            public void sleep(){
                
            }
    類是一個抽象的概念:
        作用主要是用來創建對象!!!
        
    創建對象的格式:
        類名 對象名 = new 類名();
        Dog d = new Dog();
*/
public class Dog{//成員變量(屬性),如果定義時沒有賦值,成員變量都有默認值:null,0
    String name;  // null
    int age = 2;  // 2
    String color; // null
    //成員方法:和之前定義方法的格式一致,把static去掉!!!
    public void eat(){
        System.out.println("eat");
    }
    public void run(){
        System.out.println("run");
    }
}
/*
//可以在自定義類中寫main方法測試,但是不好!
public static void main(String[] args){
    //使用之前定義Dog類創建對象:
    Dog d = new Dog();
    //調用對象的方法
    d.eat();
    d.run();
    
    //訪問對象的屬性
    System.out.println(d.name);
    System.out.println(d.age);
    System.out.println(d.color);
}
*/

View Code

/*
    Dog類的測試類
*/
public class DogDemo{
    
    public static void main(String[] args){
        Dog d = new Dog();
        d.eat();
        d.run();
        
        System.out.println(d.name);
        System.out.println(d.age);
        System.out.println(d.color);
    }
}
/*
程序在編譯時,會自動檢測源文件中使用到的類,如果這個類是我們自定義的類,並且沒有經過編譯的話,那麽系統就會自動的把程序中使用到的類進行編譯.這樣在程序運行時,就不會出現找不到類的錯誤.
*/

創建對象:

訪問對象的變量:

調用對象的方法:

Java-數組-面向對象

測試類 style 我們計數器 java sea 做的不同出現數組的應用練習: 數組的復制: /* 數組的復制：重點考察是否需要返回值 int[] arr = {1,2,3}; 思路: 1.創建一個和原數組一樣大小的數組 2

java面向對象練習---銀行業務模擬（數組+面向對象）

++ 添加 sta void 菜單入門 mar 否則 ges 編程實現：a) 用戶類：賬號（int）、姓名(String)、密碼(int:6位數字)、地址（String）、存款余額(double)、註冊時間(date)、開戶行（與銀行的名稱對應,String）b) 地

二維數組面向對象編程的概念、類、對象以及引用和成員方法

一個功能相同內存面向過程沒有初始娛樂值類型 1.二維數組(熟悉)1.1 基本概念一維數組本質上就是一段連續的存儲單元，用於存放多個類型相同的數據內容。二維數組本質上就是由多個一維數組組成的數組，也就是說二維數組中的每個元素都是一維數組，而一維數組

JavaSE基礎數組面向對象編程理解部分關鍵字的解釋及用法

java 開發一維數組數組：可以存儲多個元素並且多個元素是同一種類型的容器數組的定義: 數據類型[] 數組名; 例如：int[]a; 意義：定義了一個int類型的數組變量a 數據類型數組名[]; 例如：int a[]; 意

Java 學習筆記二維數組和對象數組

int tro 返回是個列數一個二維數組 [] 學習定義二維數組 int[][] a = new int[4][5]; 可以不指定列數 int[][] a = new int[4][]; 獲取行 int i = a.length(); 如果使用第一個例子，這裏就

JS中數組和對象的區別

src 區別 nbsp log 對象 img images image ima JS中數組和對象的區別

json對象數組按對象屬性排序

ret turn bsp per sort stringify ring pro esc var staffs=[{name:"join",age:20},{name:"ajax",age:21},{name:"trim",age:22}]; function compar

關於vue數組中對象屬性變更頁面沒重新渲染的問題

時間 index 檢測 self eno 解決數據屬性 rep 前段時間做開發的時候用mqtt監聽了服務端信息，推送過來的數據要變更數組裏面的對象的數據，修改好後但是頁面並沒有更新，因為javascript機制，vue並不能檢測到數組變化，也是查閱知道了$set()函數

後臺返回對象數組，對象屬性相同時，只取一個對象

元素屬性 con als bsp class total code log 後臺返回的數據： [ {confirmCharge: "0.00", orderId: "--", changeId: "1", realName: "王五", totalConfirm

每天一個JS 小demo之韓雪冬輪播圖。主要知識點：html，css布局，對於數組和對象的理解和運用

身高全局 borde ava ebo 空間 use mouseout desc 1 @charset "utf-8"; 2 /* CSS Document */ 3 4 * { padding: 0; margin: 0; } 5 li { list-st

Java學習之面向對象一

.cn this 關鍵字裝機實現 run 運行變量方法 1 面向對象 1.1 理解什麽是面向過程、面向對象面向過程與面向對象都是我們編程中，編寫程序的一種思維方式。 l 面向過程的程序設計方式，是遇到一件事時，思考“我該怎麽做”，然後一步步實現的過程。

（精華）將json數組和對象轉換成List和Map(小龍哥和牛徳鶴的對話)

put span ray add sonar string val out 和數將java標準的數據結構ArrayList和HashMap轉換成json對象和數組很簡單只需要JSONArray.fromObject(obj);或者JSONObject.fromObjec

java學習之面向對象的四個特性

修改行為 per 具體化建立編譯器版本自動 fin 對象：由行為、狀態和唯一標誌組成。一抽象抽象是忽略一個主題中與當前目標無關的方面，把現實世界中的概念轉換為對象,可以是表示數據的VO對象或抽象類，也可以是表示一類行為的接口。有利於從眾多變化的狀態中抽

Java學習之面向對象四

性別代碼塊完整權限私有屬性屬性包含 get sets 1、構造方法的格式是什麽？有哪些註意事項？　權限修飾符類名(參數列表){方法體} 　註意事項：　? 構造方法沒有返回值類型。也不需要寫返回值。因為它是為構建對象的，對象創建完，方法就執行結束。　? 構造方

sessionStorage、localStorage 存儲及如何存儲數組與對象

return parse div func code 瀏覽器 typeof urn log 1、存儲，獲取，清楚 sessionStorage.setItem("key",val) sessionStorage.getItem("key") sessionStorage.

Java數據訪問對象模式

從數據查看 pat span add 值對象結構 object tar 數據訪問對象模式或DAO模式用於將低級數據訪問API或操作與高級業務服務分離。以下是數據訪問對象模式的參與者。數據訪問對象接口 - 此接口定義要對模型對象執行的標準操作。數據訪問對象具

Java學習9——面向對象

static 一個函數 src cnblogs 對象關鍵字沒有 public （重點：內存分析）類的定義 1 //用class關鍵字定義一個類 2 class Person { 3 //成員變量定義 4 private int id; 5

Java基礎總結--面向對象1

維護 [] 棧內存多個事物生成單純其他基礎總結 ---面向對象的概念---1.面向過程與面向對象的區別面向過程：是一種思維習慣，解決一個問題的時候靠的是一個個方法調用--核心是動作面向對象：是一種更接近生活中解決問題的思維習慣，解決特定的問題靠對象完成--核心是

類數組轉數組，對象轉數組

urn lov 常見 npr doc prop rip aso prototype 1、類數組轉數組 //類數組示例 //javascript中常見的類數組有arguments對象和DOM方法的返回結果。//比如 document.getElementsByTagName

使用java中，面向對象封裝+繼承的方法算題

去掉空格方法 amp get urn 余數 oid pan 新的 1.第一種：給定一行字符，逆序輸出此字符串（空格.數字不輸出），如“ab 23,(4 cd”輸出“dc(,ba”。（要求：使用面向對象封裝+繼承） class Bu { private Strin

Java-數組-面向對象

數組的應用練習:

Java中參數傳遞的原則:

二維數組:

面向對象編程:

相關推薦