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
}