# 類別實作介面

public interface IMoter {
    public void moter(); //告訴幾cc..
}

//要使用介面, 創立類別實作介面..
public class Toyata implements IMoter{ //會出現紅字, 因還位實作moter()
    
}
===往下修改..
public class Toyata implements IMoter{ //按alt+enter,選實作抽像方法..

    @Override
    public void moter() {
        System.out.println("2000cc");
    }
    
}
=====主測式程式.
public class A1122 {

    public static void main(String[] args) {
        System.out.println("Hello World!");
           Toyata car1=new Toyata(); 
           car1.moter();
    }
}

# 使用匿名類別

>使用介面 要透過類別實作, 例如Toyata..
>若不想透過類別實作 給類別名稱..可使用匿名類別..
>使用匿名類別.

        IMoter car2=new IMoter(){ //alt+enter
               
        };

加入以下方法:
        IMoter car2=new IMoter(){//alt+enter 
                @Override
                public void moter() {
                    System.out.println("2000cc in 匿名類別");
                }               
        };
        car2.moter();

===主測式程式
public class A1122 {
    public static void main(String[] args) {
        System.out.println("Hello World!");
           Toyata car1=new Toyata(); 
           car1.moter();
           IMoter obj=new IMoter(){ //alt+enter
            @Override
            public void moter() {
                System.out.println("hello moter is 2000cc");
            }                
           };
           obj.moter();
        
        
           new IMoter(){
            @Override
            public void moter() {
                System.out.println("2000 cc");
            }
           }.moter(); 
        
    }
}

# 介面的方法加上default宣告

> 一般界面內的方法宣告 不能有實作程式碼 { }
> java 8.0.. 只要加入default宣告後..就可實作程式碼..

public interface IMoter {
    public void moter(); //告訴幾cc..
    //一般界面內的方法宣告 不能有實作程式碼 {}
    //java 8.0.. 只要加入default宣告後..就可實作程式碼..
    public default void do1(){ //因加了default宣告..ok.
        moter(); //default方法一般是呼叫 abstract方法..例如moter()
    }
    public default void do2(){
        moter();
        System.out.println("do2() in IMoter");
    }
}

===主測式程式
public class A1122 {
    public static void main(String[] args) {           
        new IMoter(){
            @Override
            public void moter() {
                System.out.println("2000 cc in new IMoter(){} ");
            }
        }.do1(); //do1()是defulat宣告已有程式碼 
        

        new IMoter(){
            @Override
            public void moter() {
                System.out.println("3000 cc in new IMoter(){} ");
            }
            @Override
            public void do1(){ //可蓋掉介面中defulat方法
               System.out.println("do1()...");
               moter();
            }
        }.do1(); 
    }
}

# 類別沒寫extends = 繼承Object

> 類別沒有寫extends, 一般就是直接繼承Object

public class Animal { // extends Object{ //沒有寫一般就是直接繼承Object
    //所以就省略 extends Object
    String name;
    int age;
    public Animal(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void working(){
        System.out.println(name + " " + age + " years old is working()");
    }
    @Override  //toString 是Object類別裡的方法..繼承者修改它 要加@Override
    public String toString(){ //回傳一個你設定的字串..當列印此物件時呼叫toString()
        return name + " " + age + " years old is working()";
    }    
}

# 類別People繼承Animal

類別People繼承Animal{
    //為何要繼承..因想新增一些方法..例如 新增吃的方法 eat()  
    //或者改寫 Override 原先的方法.
    
}

public class People extends Animal{
        
}

新增吃的方法..

public class People extends Animal{
    public void eat(){
            System.out.println("用手持餐具盛食物就食");
    }
    
    //按右鍵 選Insert Code..選Override code..
    @Override
    public void working() {
        super.working(); 
        System.out.println("用兩隻腳走路");
    }        
}


public class People extends Animal{
    //因為父類別 Animal建構子只有兩個參數的..因此也要有兩個參數的建構子.. 
    public People(){
        super(null, 0); //呼叫父類別的建構子.等於呼叫Animal(null,0)
    }
    public People(String name, int age){
        super(name, age);//呼叫父類別的建構子, 等於呼叫Animal(name,age)
    }
    public void eat(){
       System.out.println("用手持餐具盛食物就食");
    }
    
    //按右鍵 選Insert Code..選Override code..

    @Override
    public void working() {
        //super.working(); 
        System.out.println("用兩隻腳走路");
    }        
}

==主測試程式
public class A1122 {
    public static void main(String[] args) { 
           People person1=new People("wang", 12);
           person1.working();           
          
    }
}

# 匿名 類別

> 子類別名稱想要匿名..
> 直接使用 new 父類別() { 程式碼; };

public class A1122 {
    public static void main(String[] args) { 
           People person1=new People("wang", 12);
           person1.working();           
           //匿名 介面 interface..
           
           //匿名 類別..  可使用var 宣告型態..         
           var obj1=new Animal("chen", 20){
                public void eat(){
                    System.out.println("用手持餐具盛食物就食");
                }
                @Override
                public void working() {
                    super.working(); 
                    System.out.println("用兩隻腳走路");
                } 
           };
           //可使用var 宣告型態..
           obj1.working(); 
           
            //可直接new 物件後直接呼叫使用.
           new Animal("chen", 20){
                public void eat(){
                    System.out.println("用手持餐具盛食物就食");
                }
                @Override
                public void working() {
                    super.working(); 
                    System.out.println("用兩隻腳走路");
                } 
           }.working();
        
    }
}

> 若是想要匿名 創新的類別..可使用下法

            //若是想要匿名 創新的類別..可使用下法, 但只能無參數的建構子..
           new Object(){
               public void working(){
                   System.out.println("working()....");
               }
           }.working(); 

# [介面語法細節](https://openhome.cc/zh-tw/java/interface/syntax/)

# 介面Comparator <T>
java.util.Comparators
https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html
java.util
Interface Comparator<T>

https://www.javatpoint.com/Comparator-interface-in-collection-framework
https://www.geeksforgeeks.org/comparator-interface-java/

public class Student {
    String name;
    int age;
    int score;
    public Student(String name, int age, int score){
        this.name=name; //用this代表此物件. 區分變數
        this.age=age;
        this.score=score; 
    }
    
    //按右鍵 insert code ..選Override method..
    @Override
    public String toString() {
       String str=name+" "+age + " " + score;
       return str;
    }
}

====== 創立類別StudentSort 實作界面Comparator    
import java.util.Comparator;
public class StudentSort implements Comparator{//alt+enter 
    //選add import java.util.Comparator
    //再一次alt+enter, 選implements abstract method
    @Override
    public int compare(Object o1, Object o2) {
        return 0;
    }  
}
======================
改成針對Student的比較..
Comparator 後面加上 <Student>

public class StudentSort implements Comparator <Student>{//alt+enter 
    //選add import java.util.Comparator
    //再一次alt+enter, 選implements abstract method
    @Override
    public int compare(Student o1, Student o2) {
        return 0;
    }  
}
======================
修改compare方法..
public class StudentSort implements Comparator <Student>{//alt+enter 
    //選add import java.util.Comparator
    //再一次alt+enter, 選implements abstract method
    @Override
    public int compare(Student o1, Student o2) { //使用age來排序..
        if(o1.age>o2.age) return 1;
        else if(o1.age < o2.age) return -1;
        else return 0;
    }  
}

public class A1122 {
    public static void main(String[] args) { 
            Student stu1=new Student("wang", 18, 60);
            Student stu2=new Student("chen", 23, 100);
            Student stu3=new Student("liu", 15, 40);
            Student [] arr={stu1, stu2, stu3};
            for(Student s:arr){
                System.out.println(s);
            }
            
            //Arrays.sort(類別, 有實作Comparator的物件 );
            //static <T> void	sort(T[] a, Comparator<? super T> c)   
            Arrays.sort(arr, new StudentSort());
            for(Student s:arr){
                System.out.println(s);
            }
    }
}

輸出結果：
wang 18 60
chen 23 100
liu 15 40
排序後： （按age由小排到大）
liu 15 40
wang 18 60
chen 23 100


public class A1122 {
    public static void main(String[] args) { 
            Student stu1=new Student("wang", 18, 60);
            Student stu2=new Student("chen", 23, 100);
            Student stu3=new Student("liu", 15, 60);
            Student stu4=new Student("tan", 15, 60);
            Student stu5=new Student("lu", 15, 60);
            Student [] arr={stu1, stu2, stu3,stu4, stu5};

            System.out.println("排序前:");
            for(Student s:arr){
                System.out.println(s);
            }
            
            //Arrays.sort(類別, 有實作Comparator的物件 );
            //static <T> void	sort(T[] a, Comparator<? super T> c)   
            Arrays.sort(arr, new StudentSort());

            System.out.println("排序後:");
            for(Student s:arr){
                System.out.println(s);
            }
    }
}                                


=================================                                
 
    public int compare(Student stu1, Student stu2){
        if(stu1.score>stu2.score)
            return 1; //1,-1是切換排序順序..由小到大..由大到小..
        else if(stu1.score<stu2.score)
            return -1; //-1, 1 是切換排序順序 配合上面的修改..
        else{ //0  score相同..比較age..
            if(stu1.age>stu.age)
                return 1;
            else if(stu1.age<stu.age) 
                return -1;
            else  {//這裡是score相同,age相同..再比較name. //調整1,-1的值. 
                int result=stu1.name.compareTo(stu2.name);
                if(result>0) return 1;
                else if(result < 0) return -1;
                else return 0;
            }
                          
        }
    }    

====不一定要回傳1, -1, 也可正負數, 可改成直接相減, 
    public int compare(Student stu1, Student stu2){
        int result=stu1.score-stu2.score;
        //或result=stu2.score-stu1.score
        if(result ！=0) return result; 
        else{
            result=stu1.age-stu2.age; 
            //或result= stu2.age-stu1.age
            if(result !=0) return result;
            else{
                result=stu1.name.compareTo(stu2.name); 
                //或 result=stu2.name.compareTo(stu1.name);
                return result;
            }
        }
    }                                       

<hr>
String 使用 compareTo() 方法比較 Java 中的字串
它對兩個字串進行詞法上的比較。它的工作原理是首先給字串中的每個字元分配一個 Unicode 值，然後比較這兩個字串。這個過程將結果返回為零、正數或負數。
compareTo() 區分大小寫的
當兩個比較的字串在詞法上相等時，結果為零。
如果第一個字串比第二個字串大，結果為正數。
當第二個字串大於第一個字串時，結果為負。
<hr>

    String string1 = "hello";
    String string2 = "world";
    int result = string1.compareTo(string2);
    if(result >0) return 1;
    else if(result <0) return -1;
    else return 0;

//compareToIgnoreCase() 忽略了大小寫
    int result = string1.compareToIgnoreCase(string2);

<hr>
=====
# 11/22 作業：
按score由大排到小...修改compare()中的內容..
若同分的..再按age由小排到大
若age再相同..則按名字a--z 排序

<hr>

https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html
static <T> void sort(T[] a, Comparator<? super T> c)
https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#sort-T:A-java.util.Comparator-