項目名為“零錢通” 細節參考：【零基礎快速學Java】韓順平零基礎30天學會Java 基本版： 1 package project; 2 3 import java.text.SimpleDateFormat; 4 import java.util.Date; 5 import java.ut ...

Java語法

準備階段

先學會IDEA的基本調試
插件目前在用的是漢化版，在熟悉後儘量使用英文版（現已改成英文版）
調節字體大小,行間距,註釋的顏色要會

註釋

單行註釋 //
多行註釋 /**/
文檔註釋 /** */

Java的基本語法

一、入門的科普

關於位元組
強制轉換

強制轉換的計算

package com.Ji.base;

public class Lesson4溢出問題 {
    public static void main(String[] args) {
        //當操作比較大的時候，註意溢出問題
        //JDK7 的新操作，數字之間可以用下劃線區分
        int number = 10_0000_0000;
        int b = 30;
        int m = number*b; //-64771072
        long m2 =  number*b; //-64771072
        long m3 = number*((long)b); //30000000000  將一個數轉化為另一個類型，好算

        System.out.println(m);
        System.out.println(m2);
        System.out.println(m3);
    }
}

2.強制轉換的註意點

註意點：
        1.不能對布爾值進行轉換
        2.不能把對象的類型轉換為不相干的類型 （如上）
        3.在把高容量轉換為低容量的時候，強制轉換
        4.轉換的時候可能存在記憶體溢出的問題

類型轉換
{ 自動類型轉換（高-->底）| 強制類型轉換（低-->高） }

  低------------------------------------------------->高      
  byte -> short -> char -> int -> long -> float -> double
  運算中，不同的類型的數據先轉化為同一信息，然後進行運算

常用的不同類型的定義方法

package com.Ji.base;

public class Lesson5常用定義方法 {
    public static void main(String[] args) {
        //int a,b,c
        //int a=1,b=2,c=3;
        String name="yuanhui";
        char a='A';
        double pi = 3.141;
    }
}

變數的類型以及初始化變數

變數的定義

type varName [=value] [{,varName[=value]}];
數據類型   變數名 = 值 ；可以使用逗號隔開來聲明多個同類型的變數

    public static void main(String[] args) {
        //局部變數；必須聲明和初始化值
        int i = 10;
        System.out.println(i);

        //變數類型 :new  Lesson6()
        Lesson6變數的所有類型 lesson6 = new  Lesson6變數的所有類型();
        System.out.println(new  Lesson6變數的所有類型().age);
        System.out.println(new  Lesson6變數的所有類型().name);

        System.out.println(salary);
    }

二、Java的數據類型

//整數類型  十進位   二進位0b  八進位0  十六進位0x
        int i = 10;
        int i2 = 010;//八進位0
        int i3 = 0x10;//十六進位0x   0~9  A~F 16

Java的數據類型分為兩大類

-基本類型
  1. 數值類型：
       整數類型:
                1. byte（占1個位元組）
                2. short（占2個位元組）
                3. int（占4個位元組）
                4. long（占8個位元組）
       浮點類型:
                1. float（占4個位元組）
                2. double（占8個位元組）
  2. 字元類型:
                char（占2個位元組）
2. boolean類型

eg float x = 100; 輸出x的值，為100.0，如果時double 則為100.00

 引用類型
   1. 類
   2. 介面
   3. 數組

三、 Java的運算符

運算符

    算數運算符：+  -  *  /  %  ++  --
    賦值運算符：=
    關係運算符：>  <  >=  <=  ==  !=instanceof
    邏輯運算符：&&  ||  !
    位運算符：&  |  ^  ~  >>  <<  
    條件運算符：? :
    擴展賦值運算符： +=  -=  *=  /=

package com.Ji.operator;//包 的定義

public class Lesson1運算符 {
    public static void main(String[] args) {
        //ctrl+D 複製當前的代碼行
        long a = 1234567891L;//long 類型要加L float類型要加f
        int b = 456;
        short c = 10;
        byte d = 7;

        System.out.println(a+b+c+d);//long 有long 轉為long型，預設是int型
        System.out.println(b+c+d);//int
        System.out.println(c+d);//int

        int x = 10;
        int y = 20 ;
        int z =  41 ;
        System.out.println(x==y);
        System.out.println(x>=y);
        System.out.println(x<=y);
        System.out.println(z%y);
        //預設關係運算符的結果是布爾值，取餘和C語言不一樣，不需要寫等號
    }

自增和自減

  package com.Ji.operator;

public class Lesson2自增和自減 {
    public static void main(String[] args) {
        int a = 5;
        int b = a++;//a = a + 1
        // a++ 後 a = 6 ，但是b的值為a++之前的值，輸出為5
        int c = ++a;//c = a+1 先自增 再給c 賦值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        //冪運算我們要用類來進行 計算2*2*2=8
        double pow = Math.pow(2,3);
        System.out.println(pow);
    }
}

關係運算符

package com.Ji.operator;

public class Lesson3關係運算符 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101

        A&B = 0000 1100 (如果二者都為1，則都取1)
        A|B = 0011 1101 (如果二至其中有一個是1，則取1)
        A^B = 0011 0001 (異或 如果相同則為0 不同則為1)
        ~B = 1111 0010
         */

        //問： 如何計算2*8最快
        //按位來運算
        /*
        二進位
        0000 0001  1
        0000 0010  2
        0000 0011  3
        0000 0100  4
        0000 1000  8
        0001 0000  16
        */
        System.out.println(2<<3);
    }
}

邏輯運算

        //短路運算
        int c = 5;
        boolean d = (c<4)&&(c++<4);//在遇到第一個false時，說明c沒有進行自增
        System.out.println(d);
        System.out.println(c);

簡化運算

package com.Ji.operator;

public class lesson5簡化運算 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        a+=b;//a = a+b
        a-=b;//a = a-b

        System.out.println(a);
        //字元串連接符 + ，string類型   **********
        System.out.println(""+a+b);// 前面加空字元串的時候就是拼接字元 1020
        System.out.println(a+b+"");// 在後面的話會進行運算   30
    }
}

三目運算符

public class Lesson6三目運算符 {
    public static void main(String[] args) {
        //三元運算符
        // x==true， 結果為y，否則結果為z
        int n = 80;
        String type = n <100 ? "1":"2";  
        System.out.println(type);
    }
}

四、 Java的關鍵字，標識符和作用域

關鍵字

與C語言關鍵字類似，可以看圖片
標識符
1. 所有的標識符都應該以字母（A-Z 或 a-z），美元符（$），下劃線開始(_)

2. 首字元之後的字元可以是字母（A-Z 或 a-z），美元符（$），下劃線（_）或是數字的任何字元組合

3. 註意：不能使用關鍵字作文變數名或方法名

4. 可以使用中文名來命名，但不推薦

作用域

類變數
實例變數
局部變數

public class Variable{
  static int allClicks = 0;//類變數
  String str = "hello world";//實例變數
  
  public void method(){
    int i = 0;//局部變數
  }
}

五、 Java的包機制

包語句的語法格式為：

package pkg1[. pkg2[. pkg3...]];

一般是利用公司功能變數名稱倒置作為包名；

導入包的語句

import package1[. package2...].(classname|*);

六、 Java生成的doc文檔

Javadoc的作用是針對整個方法或者整個類做一個簡要的概述的，使得別人不通過看具體方法代碼就能知道某個方法或者某個類的作用和功能。寫了Javadoc的在別人使用到類時，將滑鼠懸停到類上或者方法上，javadoc會以提示信息顯示出來，這樣開發者在跳進源代碼中就能知道類或者方法的作用。

Java的流程式控制制

一、 Java輸入流Scanner

獲取用戶的輸入：Scanner

    Scanner  s = new Scanner(System.in);

通過Scanner類的next()與nextLine()方法獲取輸入的字元串，在讀取前我們一般需要使用hasNext()與hasNextLine()判斷是否還有輸入的數據。

package com.Ji.Scanner;

import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
        // 創建一個掃描器對象，用於接收鍵盤數據
        Scanner scanner=new Scanner(System.in);
        System.out.println("請輸入數據：");

        //判斷用戶有無輸入字元串
        if(scanner.hasNext()){
            //使用next方式接受
            String str =scanner.next();
            System.out.println("輸出的內容為："+str);

            scanner.close();//凡是屬於IO（輸入輸出流）流類的，不用的話關掉，節省資源
        }
    }
}

hasNext()與hasNextLine()的區別

next()
1. 讀取到有效字元後才可以結束輸入
2. 對輸入有效字元前的空白，next()方法會自動將其去掉
  
  eg：Hello world 只輸出Hello 123 456 只輸出 123
3. 只有輸入有效的字元後才將其後面輸入的空白作為分隔符或者結束符
4. next()不能得到帶有空格的字元串
nextLine()
1. 以Enter為結束符，nextLine()方法返回的是輸入回車之前的所有字元
2. 可以獲得空白
  
  eg: 123 456 輸出123 456

hasNext()與hasNextLine()的衍生

hasNextInt 判斷緩衝是否有整數有整數就返回 true 否則 false。

hasNextInt 緩衝區沒有數據的時候就會等待，直到緩衝區有數據。

同：hasNextLine()， nextInt() ，nextByte()， nextShort() ， nextLong() ， nextFloat()， nextDouble()
9

二、 Switch case 語句

//case 具有穿透作用，如果不進行break的話會繼續輸出下一個case

package com.Ji.Scanner;

public class Demo5 {
    public static void main(String[] args) {
        String name = "遠輝";

        //JDK7的新特性，表達式結果可以為字元串
        //字元的本質時數字

        //反編譯   java---class （位元組碼文件）---反編譯IDEA  Ctrl+shift+S+Alt可以打開項目結構
        switch (name){
            case "遠輝"  :
                System.out.println("遠輝");
                break;
            case "狂神" :
                System.out.println("狂神");
                break;
            default:
                System.out.println("無");
        }
    }
}

生成的.class文件(反編譯)

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.Ji.Scanner;

public class Demo5 {
    public Demo5() {
    }

    public static void main(String[] args) {
        String name = "遠輝";
        byte var3 = -1;
        switch(name.hashCode()) {
        case 941788:
            if (name.equals("狂神")) {
                var3 = 1;
            }
            break;
        case 1178413:
            if (name.equals("遠輝")) {
                var3 = 0;
            }
        }

        switch(var3) {
        case 0:
            System.out.println("遠輝");
            break;
        case 1:
            System.out.println("狂神");
            break;
        default:
            System.out.println("無");
        }

    }
}

三、 For迴圈

for迴圈的簡寫版

package com.Ji.Scanner;

public class For迴圈增強版 {
    public static void main(String[] args) {
        int [] numbers = {10,20,30,40,50,60};
        //遍曆數組的元素
        for (int x:numbers){
            System.out.println(x);
        }
    }
}

Java的方法

一、方法的定義和調用

定義
- 方法是解決一類問題的步驟的有序組合
- 方法包含於類或對象中
- 方法在程式中被創建，在其他地方被引用
  
  一個方法只完成一個功能，一個項目有且只有一個main方法，其餘均通過調用來完成函數功能，類似於C語言的子函數
- 方法的定義
```
修飾符  返回值類型  方法名 （參數類型 參數名）{
    ...
     方法體
    ...
    return 返回值;
}
```
方法的實例:

package com.Ji.Method;

public class Demo2 {
    public static void main(String[] args) {
        int m = max(20,30);
        System.out.println(m);
    }
    //類似於C語言的子函數
    public static int  max(int a ,int b) {
        int result = 0;
        if(a==b){
            System.out.println("a==b");
            return 0;
        }
        if(a>b){
            result = a;
        }
        else {
            result = b;
        }
        return result;//記得加上返回值，因為這是一個可以返回的類型
    }

}

   public  String sayHello(){
       return "hello,world";
   }


    public  void print(){
        return;//返回一個空方法
    }

    public int max(int a,int b){
       return a>b? a : b; //三元運算符
    }

方法的調用
1. 調用方法：對象名.方法名(實參列表)
2. Java支持兩種調用方法的方式，根據方法是否返回值來選擇
3. 當方法返回一個值的時候，方法調用通常被當做一個值。
```
int larger =  max (30,40)
```
4. 如果方法返回值時void，方法調用一定時一條語句
```
System.out,println("Hello world");
```

靜態方法與非靜態方法的調用

package com.Ji.oop;

public class Demo2方法 {
    // 靜態方法 static  調用相同的類可以立刻輸出,註意類的名字
//    public static void main(String[] args) {
//        Demo3student.say();
//    }


    // 非靜態方法 實例化類
    // 對象類型   對象名 = 對象值
    public static void main(String[] args) {
        Demo3student student = new Demo3student();
        student.say();
    }

}

package com.Ji.oop;
// 學生類
public class Demo3student {
    // 非靜態方法
    public  void say() {
        System.out.println("學生說話啦!!!");
    }
}

參數類型
1. 形式參數：在方法被調用時用於接收外界輸入時的數據
2. 實參：調用方法時實際傳給方法的數據

package com.Ji.Method;

public class Demo1 {
    //main方法  a和b時實際參數
    public static void main(String[] args) {
            int sum = add(1,2);
            System.out.println(sum);
    }
    //此處的a和b時形式參數
    public static int add(int a,int b){
        return a+b;
    }
}

二、方法的重載

重載的定義：在一個類中，有相同函數名稱，但形參不同的函數

方法重載的規則：

方法名稱必須相同
參數列表必須不同（個體不同，或類型不同，參數排列順序不同等）
方法的返回類型可以相同也可以不相同
僅僅返回類型不同不足以成為方法的重載

   package com.Ji.Method;

 public class Demo3 {
 public static void main(String[] args) {
     int m = max(20,20,40);
     System.out.println(m);
 }

 //類似於C語言的子函數(通過改變max的類型，可以使得實參改變時適應於以下的函數)
 //1
 public static int  max(int a ,int b) {
     int result = 0;
     if(a==b){
         System.out.println("a==b");
         return 0;
     }
     if(a>b){
         result = a;
     }
     else {
         result = b;
     }
     return result;//記得加上返回值，因為這是一個可以返回的類型
 }

 //2.
 public static int  max(double a ,double b) {
     int result = 0;
     if(a==b){
         System.out.println("a==b");
         return 0;
     }
     if(a>b){
         result =(int) a;
     }
     else {
         result =(int) b;
     }
     return result;//記得加上返回值，因為這是一個可以返回的類型
 }

 //3.
 public static int  max(int a ,int b,int c) {
     int result = 0;
     if(a==b){
         System.out.println("a==b");
         result = c;
     }
     if(a>b){
         result = a;
     }
     else {
         result = b;
     }
     return result;//記得加上返回值，因為這是一個可以返回的類型
 }
 }

三、可變參數和遞歸

可變參數
定義：

JDK1.5開始，Java支持傳遞同類型的可變參數給一個方法
在方法聲明中，在指定參數類型後加一個省略號(...)
一個方法中只能指定一個可變參數，它必須是方法的最後一個參數。任何普通的參數必須在它之前聲明。

package com.Ji.Method;

public class Demo4 {
    public static void main(String[] args) {
    Demo4 demo4 = new Demo4();
    demo4.text(1,3,2,5,7);
    }

    public void text (int...i) //可變參數必須放在最後一個，在它之前的必須都進行聲明，且可變參數的類型都應該與main方法相同
    {
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
        System.out.println(i[5]);
    }
}

遞歸的寫法

package com.Ji.Method;

public class Demo5 {
    public static void main(String[] args) {
        int i = 5;
        System.out.println(i + "的階乘是" + f(5));
    }
    // 遞歸計算5！
     public static int f(int n){
        if(n == 1 || n == 0){
            return 1;
        }
        else{
            return n*f(n-1);
        }
     }
}

四、值傳遞和引用傳遞

值傳遞

package com.Ji.oop;

public class Demo4值傳遞 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);//值為1 實參的值是不變的

        Demo4值傳遞.change(a);
    }

    public static void change(int a){
        a = 10;  //傳遞的是形參的地址,最後返回值為空,值仍未1
    }
}

引用傳遞

package com.Ji.oop;

//引用傳遞,對象,本質還是值傳遞
public class Demo5引用傳遞 {
    public static void main(String[] args) {
        Person preson = new Person();
        System.out.println(preson.name);//null

        Demo5引用傳遞.change(preson);

        System.out.println(preson.name);//遠輝
    }

    public static void change(Person person){
        //person是一個對象;指向  Person person = new Person();這是一個具體的人
        person.name = "遠輝";
    }

//    定義了一個person類,有一個屬性:name
static class Person{
        String name;//null
}
}

Java的數組

一、數組的聲明和創建

數組的定義
首先必須聲明數組變數，才能在程式中使用數組

   dataType[]  arrayRefvar;  //首選的方法
   dataType  arrayRefvar[];  //效果相同，但不是首選方法

Java語言使用new創建數組

 dataType[] arrayRefVar = new dataType[arraySize];

數組從零開始，獲取數組的長度 arrays.length

數組的初始化
三種初始化

靜態初始化

int [] a = {1,2,3};
Man[] mans = {new Man(1,1) , new Man(2,2);}

動態初始化

int [] a = new int [2];
a[0]=1;
a[1]=2;

package com.Ji.Array;

public class 數組的初始化 {
    public static void main(String[] args) {
        //靜態初始化 創建 + 賦值
        int[] a = {1,2,3,4,5,6,7};
        System.out.println(a[0]);

        //動態初始化：包含預設初始化,int型的預設值是0 string類型的值為none
        int b [];
        b= new int[10];
        b[0] = 1;
        b[2] = 10;
        b[6] = 100;
        System.out.println(b[0]);
        System.out.println(b[1]);
        System.out.println(b[2]);
        System.out.println(b[3]);
        System.out.println(b[6]);
    }
}

數組的聲明

package com.Ji.Array;

public class 數組的聲明 {
    // 變數的類型  變數的名字 = 變數的值
    //數組的類型
    public static void main(String[] args) {
      int[] n;//     定義

        /*
       int n1[];//      與C/C++語法相同，便於向Java過度
       * */

        // 簡化的代碼還可以寫為   int[] n = new int[10];
        n =new int[10];

        n[0] = 1;
        n[1] = 2;
        n[2] = 3;
        n[3] = 4;
        n[4] = 5;
        n[5] = 6;
        n[6] = 7;
        n[7] = 8;
        n[8] = 9;
        n[9] = 10;
        //計算數組的長度 數組的長度用 array.length來表示
        int sum = 0;
        for (int i = 0;i < n.length;i++){
            sum = sum + n[i];
        }
        System.out.println("總和為" + sum);
    }
}

二、數組的增強

package com.Ji.Array;

public class 數組的增強 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //JDK 1.5 沒有下表 只限於輸出遍歷的數組
//        for (int array : arrays){
//            System.out.println(array); }

        // printArray方法
        printArray(arrays);
        }

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

三、數組的類

API中提供了一個工具類Arrays供我們使用，具有以下常用功能：

給數組賦值：通過fill方法。
對數組排序：通過sort，按升序。
比較數組：通過equals方法比較數組中元素是否相等。
查找數組元素：通過binarySearch方法能對排序好的數組進行二分查找法操作。

package com.Ji.Array;

import com.sun.org.apache.xpath.internal.res.XPATHErrorResources_sv;

import java.lang.reflect.Array;
import java.util.Arrays;

public class 數組的類 {
    public static void main(String[] args) {
        int[] a = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21};
        System.out.println(a); //[I@1b6d3586
        //列印數組的元素  toString（arrays）
        System.out.println("================================");
        System.out.println(Arrays.toString(a));
        printArray(a);
        /*
        *   數組類的本質，是人寫的  有int類 short類 char類
        *   public static String toString(int[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }
        *
        * */
    }
    public static void printArray(int[] a) {
        for (int i = 0; i < a.length; i++) {
            if (i == 0) {
                System.out.print("[");
                if (i == a.length - 1) {
                    System.out.println(a[i] + "]");
                } else {
                    System.out.println(a[i] + ",");
                }
            }
                                            }
    }
}

四、冒泡排序

package com.Ji.Array;

import java.util.Arrays;

public class 冒泡排序 {
    public static void main(String[] args) {
        int [] array = {1,3,5,51,63,20,7,9,12,17,23};

        int [] sort;//調用自己寫的排序的方法
        sort = sort(array);

        System.out.println(Arrays.toString(sort));
    }

    public static  int[] sort(int [] array) {
        int tem ;//臨時變數
        //外迴圈
        for (int i = 0; i < array.length - 1; i++) {
            boolean flag = false;//優化冒泡排序 如果數組已有部分排好序，則無需再進行排序

            for (int j = 0; j <= array.length -1-i; j++) {
                if (array[j + 1] < array[j]) {
                    tem = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tem;
                    flag = true;
                }
            }
            if (flag) {
                break;
            }
        }
        return array;
    }
}

五、二維數組

  int a[][] = new int [2][5];

Java的面向對象

一、類與對象的創建

類的定義：類是一種抽象的數據類型，它是對某一類事物整體描述/定義，但是並不能代表一個具體的事物。
對象是抽象概念的具體實例

能夠體現出特點，展現出功能的是具體的實例
eg：張三是人的一個具體實例，張三家的旺財是狗的一個具體實例。

二、什麼是面向對象

面向對象編程(Object-Oriented Programming,OOP)
面向對象的本質：以類的方式組織代碼，以對象的組織封裝數據

三、創建與初始化對象

使用關鍵字new來創建對象

使用new關鍵字創建的時候，除了分配記憶體空間之外，還會給創建好的對象進行預設的初始化以及對類中構造器的調用。
類中的構造器也稱為構造方法，是在進行創建對象的時候必須要調用的。有如下兩個特點：

1.必須和類的名字相同

2.必須沒有返回類型，也不能寫void

四、構造器

package com.Ji.oop;

public class Demo6構造器 {
    //一個類即使什麼都不寫，它 也會存在一個方法
    //顯示的定義一個構造器    構造器特點： 1. 必須和類的名字相同   2.沒有返回值，且沒有void
    String name;

    // 1. 使用new關鍵字，本質實在使用構造器，new出來預設產生一個構造器
    // 2.用來初始化值

    // 構造器
    public  Demo6構造器(){
//            這是無參構造
    }
    // 有參構造：一旦定義了有參構造，則無參就必須顯示定義
    public  Demo6構造器(String name){
        this.name = name;//參數傳遞下來的name
        //左邊：對象本身的name (String name;)
    }
//    快捷鍵 alt + insert
}

this.一般代表當前類的值，後面=一般是參數傳進來的

package com.Ji.oop;

public class Demo6構造器1 {
//
public static void main(String[] args) {
//
    Demo6構造器 Demo6構造器 = new Demo6構造器("yuanhui");
    System.out.println(Demo6構造器.name);
}
}

五、小結

記憶體分析

2.小結

類與對象
類是一個模板，抽象，對象是一個具體的實例
方法
定義，調用！
對應的引用
引用類型：基本類型（8）
對象是通過引用來操作的：棧-->堆
屬性
- 預設初始化：數字 0 0.0
- char :u0000
- boolean :false
- 引用：null
  
  修飾符屬性類型屬性名 = 屬性值！
對象的創建和使用
- 必須使用new 關鍵字創造對象，構造器 Person p1 = new Person();
- 對象的屬性 p1.name
- 對象的方法 p1.sleep
類
靜態的屬性屬性
動態的行為方法

Java的特性

一、封裝

封裝的定義：

類的內部數據操作細節自己完成，不允許外部干涉
經暴露少量的方法給外部的類
通常，應禁止直接訪問一個對象中數據的實際表示，而應通過介面來訪問，這稱為信息隱藏

屬性私有，get/set
Student類

    package com.Ji.oop.封裝;

public class Student {
    //屬性私有 private
    private String name; //名字
    private int id;       //學號
    private char sex;     //性別
    private int Age;

//    提供一些可以操作的這個屬性的方法
//    提供一些public的get，set的方法

    //  get 獲得這個數據
    public String getName() {
        return this.name;
    }

    //set 給這個數據設置值
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return Age;
    }

    public void setAge(int age) {
        if (age > 120 || age < 0) {
            this.Age = 0;
        } else {
            this.Age = age;
        }
    }
}

Application類

package com.Ji.oop.封裝;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("遠輝");

        System.out.println(s1.getName());

        s1.setAge(-1);//不合法的
        System.out.println(s1.getAge());
    }
}

二、繼承

繼承的定義：繼承的本質是對某一批類的抽象，從而實現對現實世界更好的建模
extands 子類是父類的擴展
Java中只有單繼承，沒有多繼承！
繼承是類與類之間的一種關係，此外，類與類之間的關係還有以來、組合和聚合等。
繼承關係的兩大類，一個為子類(派生類),()一個為父類(基類)

子類可以繼承父類的所有方法

Application類

package com.Ji.oop.繼承;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.money);
    }
}

Person類

package com.Ji.oop.繼承;

public class Person {
    //public
    //protected
    //default
    //private
        int money = 10_0000_0000;

    public void say(){
        System.out.println("學生說了一句話");
//        ctrl + H 找到繼承的類
//        在Java中，所有的項目都繼承Java的object的類
     }
}

Student類

package com.Ji.oop.繼承;
// 學生 is 人：派生類，子類
// 子類繼承了父類，就會擁有父類的所有方法！
public class Student extends Person{

}

super

super註意點
1. super調用父類的構造方法，必須在構造方法的第一個
2. super 必須只能出現在子類的方法或者構造方法中！
3. super和this 不能同時調用構造方法
  
  與this的對比
4. this 本身調用者這個對象
5. super 代表父類對象的應用
  
  前提
6. this 沒有繼承也可以使用
7. super 只能在繼承條件下使用
  
  構造方法
8. this()本類的構造
9. super()父類的構造

public void text(String name){
System.out.println(name);student.text(name:"")中的name
System.out.println(this.name);子類中的name
System.out.println(super.name);父類中的name
}