IntelliJ IDEA Community Edition 問題排除

1.軟體更新後，IDEA 的  GET  SET 方法無法使用  可以從新安裝  lombok  排除問題

Spring Data Jpa - Hibernate 一對一 單向 跟一對多 單向

 一對一 單向

package com.example.demo.dto;
import com.example.demo.model.Student;
public class PersonDTO2 {

    private Long id;    private String  author;    private int  price;    private String title;    private Student student ;

    public Student getStudent() {
        return student;    }

    public void setStudent(Student student) {
        this.student = student;    }

    public void setId(Long id) {
        this.id = id;    }

    public void setAuthor(String author) {
        this.author = author;    }

    public void setPrice(int price) {
        this.price = price;    }

    public void setTitle(String title) {
        this.title = title;    }

    public PersonDTO2() {
    }

    public Long getId() {
        return id;    }

    public String getAuthor() {
        return author;    }

    public int getPrice() {
        return price;    }

    public String getTitle() {
        return title;    }

    @Override    public String toString() {
        return "PersonDTO2 [id=" + id + ", author=" + author                + ", price=" + price + ", title=" +

                 title + ",  student " + student  +
                "]";    }
}

JAVA面試題

1.物件導向有哪些，並說說這些特性?

Ans:
           。物件導向有 :  抽象 、繼承 、多型、封裝。


           。 抽象 一個類中沒有包含足夠的信息來描述一個具體的對象就是抽象類 。

           。 繼承    類別物件的資源可以延伸和重複使用，在程式中可以利用extends 來實作繼承關係。

           。 多型    多個相同名稱的方法，傳入不同的參數，會執行不同的敘述。

           。 封裝  封裝是把數據和操作的方法封裝起來，對數據的訪問只能通過已定義的接口進行訪問。 


2.作用域  public  ,  private  , protected, 以及不寫時的區別
Ans:

作用域	當前類	同一package	子孫類	其他package
public	●	●	●	●
protected	●	●	●
friendly	●	●
private	●

不寫時 默認為  friendly

3.甚麼是 jira  、 jen kins

Hibernate 關係設定

A.   關系種類

1.   一對一: 一對一單向(主鍵,外鍵), 一對一雙向(主鍵,外鍵)

例:部門對於職位

   

2.   一對多: 一對多單向,多對一單向,多對一雙向

例:老闆對於員工 主控權是在多  效能會比較好  會減少很多查詢!

3.   多對多: 多對多單向,多對多雙向

例:餐廳位置，一個人有一個位置，多人有多人的位置

B.簡單  建立 H2 資料庫 的方法

   因為我們要先走資料庫可以比對所以要先建立資料庫來設定關係

1.先開啟資料檔創建 JAVA 

  創建 Book , Student  兩個資料夾

2.資料庫

BOOK的 Java 設定

package com.example.demo.model;
import lombok.Data;
import javax.persistence.*;
/** * An entity class which contains the information of a single person. * * @author Petri Kainulainen */@Entity@Table(name = "Book")
@Data  //提醒這邊要加上Data 才會幫忙建置public class Book  {

    @Id    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    //屬性      private String  author;    private int  price;    private String title;

    /**     * 一對一單向     * @OneToOne 設定主要關係     * @JoinColumn 對於有關聯進行設定     * 因為我們只有屬性 沒有get跟set的設置     * 本來要加在get 上面只要 加入在     * 屬性設定上面就可以了     */    @OneToOne    @JoinColumn(name="StudentId")
    private Student student;


    @Version    private long version = 0;

}

Student的 Java 設定

package com.example.demo.model;
import lombok.Data;
import javax.persistence.*;
@Entity@Table(name = "Student")
@Data //提醒這邊要加上Data 才會幫忙建置public class Student {

    @Id    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String Name;    private int    Book;
    @Version    private long version = 0;


}

3.接下來就可以進行連線設定

java - 繼承 inher itaue

 繼承  inher itaue     => 就是繼承父類別
( 一 ) 條件:
   同一機構(同一資料)
   多個Class 中將相同意思
   的 attribute (  field metlod)
   同定義在 Class

範例:

1)A => A () ;
=> reference
=> is a

A is a A
A is a school


A has a   eng
A has a shour()
A has a name
A has a chi


B  is a B
B  is a school
B har a math
B  has  a shiw( )
B has a name
B has a chi

例子:
class A extends school
{

int eng;

void show()
{
System.out.println("名:"+name+
"\t國文:"+chi+
"\t英文:"+eng);
}
}


class B extends school
{

int math;

void show()
{
System.out.println("名:"+name+
"\t國文:"+chi+
"\t數學:"+math);
}
}


class add
{
public static void main(String args[])
{
A a=new A();
B b=new B();

a.show();
b.show();

}
}

class school
{
String name;
double chi;

}
執行結果:

繼承 ( 應用 )
( 一 ) 先處理 1s - a 關係( 繼承 成功 )
  =>  coustrutors
 1.一定要繼承 一定會要執行
=> superClass  的建構式

2.superClass  與  subClass 都有建構式
執行 順序為 => super => sud
                           (父 ===>子)

3.superClass 的建構式 有設計需要為 合引數 =>   繼承的子類別 需透過子類別的建構式 給 superClass 引數
=> ※super (值; 變數);

4.父類別建構式為 Overloading
=> 繼承的子類別只需要選一個繼承 即可










( 二 ) 分析方式  = > 每個class
             1. coupling   => 耦合 = > 相依性 => 相同意思的屬性，每個class  共同屬性
 
             2.cohesion = > 內聚力 => 相關性=> 每個class 自己才有個屬性其他class沒有


          (  父 )                   ( 子 )                 ( 繼承 )
(三) superClass     ,     subClass        ,     extends


( 四 ) 新增物件方式 =>   new 子類別物件

( 五 ) 判斷物件的類型 (reference ) 與 屬性 (  field  , method )

先 => 1  is   a => 確定此子類別一共具有多少class  reference
          ( 包括自己與   super class  數量 )


在 =>  2. has - a => 確定 reference 後 在查找有多少屬性可以使用
              (  field  , method )    =>  cal  by value

給定下面程式碼，哪些選項的描述是對的?(選擇3個) (答案) : A .C .E
 02. class Dog extends Animal{Tail tail;}
 03. class Beagle extends Dog{public void jumper(){}}
 04. class Cat extends Animal{public void jumper(){}}

 A. Cat is-a Animal
 B. Cat is-a jumper
 C. Dog is-a Animal
 D. Dog is-a jumper
 E. Beagle has-a Tail

1.程式碼如下，請問最後結果為何?   

 01. class Excute{
 02.    public static void main(String args[]){
 03.       int[] a={4,3,2};
 04.       int i=a.length>0 ? a[0]:null;
 05.       System.out.println(i);
 06.     }
 07.  }

 A. 4
 B. 3
 C. 2
 D. null
 E. 編譯失敗

\\ 答案LB    length 為3  因{4,3,2}

2.程式碼如下，請問最後結果為何?  

 01. import java.util.Arrays;
 02. class Search{
 03.    public static void main(String args[]){
 04.       String a[]={"b","r","g","y","o"};
 05.       Arrays.sort(a);
 06.       int i1=Arrays.binarysearch(a,"o");
 07.       int i2=Arrays.binarySearch(a,"v");
 08.       System.out.println(i1+""+i2);
 09.   }
 10. }

 A.  3-4
 B.  3-5
 C.  2-5
 D.  2-4
 E.  編譯失敗
 F.  執行失敗

答案 :  C  因為 Arrays.sort會進行排序  順序變成
 a[]={"b","g","o","r","y"};    因為沒有 V  所以回傳 負數   
3.程式碼如下，請問最後結果為何?
 01.  import java.util.Arrays;
 02.  class Execute{
 03.    public static void main(String args[]){
 04.       String[] a[]={{"1","2"},{"3","4","5"}};
 05.       String[][] b=a;
 06.       System.out.println(b[1][2]);
 07.    }
 08. }

   

 A. 1
 B. 2
 C. 3
 D. 4
 E. 5
 F. 編譯失敗
 G. 執行失敗

答案 :  G     a 會傳直 給 B    所以 a 跟 B 一樣   [1][2] 會是 5 
4.程式碼如下，請問最後結果為何?
 01. String[] str=null;
 02. System.out.println(str.length);

 A. 0
 B. null
 C. 1
 D. 編譯失敗
 E. 執行失敗
答案是 E   因length  是陣列數量 但值為空值 故找不到  所以抱錯!  如果改成
                System.out.println(str);  答案會換成B 空值



5.程式碼如下，請問最後結果為何?
 01. import java.util.Arrays;
 02. class Execute{
 03.    public static void main(String args[]){
 04.     String[] s1={"1","2","3"};
 05.      String[] s2={"4","5","6"};
 06.      s1=s2;
 07.      for(String str:s1)
 08.       {System.out.println(str);}
 09.     }
 10.  }



 A. 123
 B. 456
 C. 編譯失敗
 D. 執行失敗

答案是 B  同第三題  S1 會跟S2 一樣 故打印出來 是 456

舉例:

class school
{
private String name;
private int chi;


school(String name)
{
this.name=name;
System.out.println("新增一位school學生 name="+this.name);
}

school(String name,int chi)
{
this.name=name;
System.out.println("新增一位school學生 name="+this.name+chi);
}




}
class A extends school
{
    ing eng;

A(String name,int eng)
{
super(name);
this.eng = eng;
System.out.println("A班學員"+this.eng);

}

A(String  name,int chi,int eng)
{
/*建構式的兩個值 (name,chi) 加上 eng

*/
super(name,chi);
this.eng=eng;   
System.out.println("A班學員 eng="+this.eng);
}

}
import java.util.Arrays;
class add
{
public static void main(String args[])
{

school s=new school("a",75);
//A a = new A("rr",98);


}

}

class A_1  extends A
{
private int word;
A_1(String name, int chi ,int eng.int word)
{
super(name,chi,eng);
this.word = word
System.out.println("111");
}
}

class B extends school
{
   private int math;
 
   B(String name,int chi ,int math)
   {
     super (name,chi);
this.math =math;
   }
}
class B_1 extends B
{
         private  int exxel;
         B_1 (String name,int chi ,int math,int excel)
{
super(name,chi,math);
this.exxel = excel;

}
}
執行結果:

繼承
( 三 ) has - a =>( field,method)
1.field  => 沒有 設定 封裝 直接繼承

2.method => 應用狀況
a)  Overriding => 多種狀況   同 一 classs 或 不同 class  都可設計


      1). 多稱一樣
     2)  引數不一樣

b) Override   => 子類別方法把反類別方法  至換掉.

               1) 名稱 一樣 引數 一樣
               2) 類型(傳值 ，不傳值) 也要一樣   只要符合第一點會強制要求

              3) 如果父類別的方法有設定封裝權限 子類別方法的權限 要比父類別大 或 相等
             
              => public > protected > (沒寫)   > private
              => super ".點"  方法


類別     變數    =   new      類別(引數);


類別 =>  call    by  referene    => 確定物件類型 (所有 is  - a)  => 檢查方法(名稱)

class school
{
private String name;
private int chi;


school(String name)
{
this.name=name;
System.out.println("新增一位school學生 name="+this.name);
}

school(String name,int chi)
{
this.name=name;
this.chi = chi;
//System.out.println("新增一位school學生 name="+this.name+chi"\t國文:" + chi);
}
 
String getName()
{
return name;
}

int getChi()
{
return chi;
}

void setName(String name)
{

this.name=name;
}

void setChi(int chi)
{

this.chi=chi;
}

void change(String name)
{
this.name=name;
}

void change(int chi)
{

this.chi=chi;
}
void change(String name,int chi)
{
this.name=name;
this.chi=chi;
}

protected String show()
{

return "名:"+name+"\t國文:"+chi;
}

}

class A extends school
{
    private  int eng;

A(String name,int eng)
{
super(name);
this.eng = eng;
System.out.println("A班學員"+this.eng);

}

A(String  name,int chi,int eng)
{
/*建構式的兩個值 (name,chi) 加上 eng

*/
super(name,chi);
this.eng=eng; 

//System.out.println("A班學員 eng="+this.eng);
}

int getEng()
{
return eng;
}
void change(String name,int chi,int eng)
{

}

void setEng(int eng)
{

this.eng=eng;

}

public String show()
{
return super.show()+"\t英文:"+eng;
}

/*
public String show()
{
return "名字:"+getName()+"\t國文 :"+getChi()+"\t英文:"+eng;
}
*/
}

import java.util.Arrays;
class add
{
public static void main(String args[])
{

//school s=new school("a",75);
//A a = new A("rr",98);
 


A a=new A("a",78,89);
System.out.println(a.show());
/*
System.out.println("======================");

a.setName("qq");

System.out.println("名:"+a.getName());
System.out.println(a.show()); //原本國文60  下面使用  方法修改
System.out.println("======================");
//a.setChi(60); //修改成60
achange("qq")

System.out.println("名:"+a.getChi());
System.out.println(a.show());
*/

}

}

class A_1  extends A
{
private int word;
A_1(String name, int chi ,int eng.int word)
{
super(name,chi,eng);
this.word=word;
}
}
執行結果:

Polymorphic  多型 (new 物件)
(一) 條件背景 => 繼承應用
        多個子類別  有共同 父類別
(二)   new  物件語法 :   異質 宣告物件

父類別    物件名  = new    子類別(引數)

.上面  父類別 跟 子類別   需要有  繼承關係


 父類別
1.call  by  refereme 
2. 物件  15 - a
3.確定 物件呼叫方法  有此名子

 子類別
1.call   by  value
2.執行時找內容的起點  class

※使用得方法 使限定
1.override
2.繼承

(三) 真正活用  => 搭配陣列

class student
{
private String name;

student(String name)
{
this.name=name;
}

String show()
{
return "名:"+name;
}


void setName(String name)
{

this.name=name;
}

void setWord(int word)
{
}


}

class SA extends student
{
private int word;

SA(String name,int word)
{
super(name);
this.word=word;

}
String show()
{

return super.show()+"\tword:"+word;
}
   
void setWord(int word)
{
this.word=word;
}

}


class SB extends student
{
private int excel;

SB(String name,int excel)
{
super(name);
this.excel=excel;

}
String show()
{

return super.show()+"\texcel:"+excel;
}

}


class add2
{
student[][] s=
{

{
new SA("a1",78),
new SA("a2",78),


}
,
{

new SB("b1",77),
new SB("b2",77),
new SB("b3",77),

}



};

for(int i=0;i<s.length;i++)
{
for(int j=0;j<s[i].length;j++)
{
System.out.println("s["+i+"]["+j+"]="+s[i][j]+"\t"+s[i][j].show());

}
System.out.println();

}
System.out.println("==========================");

s[0][0].setWord(88);
for(int i=0;i<s.length;i++)
{
for(int j=0;j<s[i].length;j++)
{
System.out.println("s["+i+"]["+j+"]="+s[i][j]+"\t"+s[i][j].show());

}
System.out.println();

}

/*
SA s1=new SA("a",78);
SB s2=new SB("b",77);


student s1=new SA("a",78);
student s2=new SB("b",77);

System.out.println(s1.show());
System.out.println(s2.show());

System.out.println("==========================");

s1.setName("rrr");
s1.setWord(88);

System.out.println(s1.show());
System.out.println(s2.show());
*/


}


}

執行結果:

JAVA 筆試 (二)

Q1.介面 interface 與 抽象類別(abstract class ) 差異

抽象類與介面的區別，這是一個經常被問到面試題，區別主要有以下幾點，可以從幾個方面進行分析：

(一) 繼承方面：
       (1) 抽象類只能單繼承；介面可以多實現
(二) 成員屬性方面：
       (1) 抽象類中可以有普通屬性，也可以有常量
       (2) 介面中的成員變量全部默認是常量，使用public static final修飾，這個可以省略不寫
(三) 代碼塊方面：
       (1) 抽象類可以含初始化塊；介面不能含初始化塊
(四) 構造函數方面：
       (1) 介面不能有構造函數
       (2) 抽象類可以有構函數，但是這裏的構造函數不是用來創建對象的，而且用來被實現類調用進行初始化操作的
(五) 方法方面：
       (1) 介面裏面不能定義靜態方法；抽象類裏面可以定義靜態方法
       (2) 介面裏面只能是抽象方法；抽象類裏面可以有抽象方法也可以有普通方法

上面就是介面與抽象類的區別，在說完區別之後，可以補充一下介面與抽象類之間的相同之處：
(1) 介面與抽象類都不能被實例化，需要被其他進行實現或繼承
(2) 介面與抽象類裏面都能包含抽象方法，實現介面或繼承抽象類的子類都必須實現這些抽象方法

針對相同之處的第二點，再細說一下
(一) 超類是介面：
       (1) 如果使用介面繼承(extends，無法使用implements)這個介面，那麼在這個子類介面中，可以實現其父類介面中的抽象方法（這種方法我從沒看見過，但是在今天的面試中，面試官問我介面中是否可以有具體的實現方法，可以將這種情況舉出來）
       (2) 如果使用抽象類實現這個介面，可以在這個子類抽象類中實現父類介面中的抽象方法
       (3) 如果使用具體類實現這個介面，那麼就必須實現父類介面中的所有抽象方法
(二) 超類是抽象類：
       (1) 介面不能繼承抽象類
       (2) 如果使用抽象類繼承這個抽象類，可以在這個子類抽象類中實現父類介面中的抽象方法
       (3) 如果使用具體類繼承這個抽象類，那麼就必須實現父類抽象類中的所有抽象方法

對於上面的說明，所以在相同之處的第二點處主要是針對具體類繼承抽象類或實現介面來說的。

小總結:

共同:
都是上層的抽象層
都不能被實例化
都包含抽象方法 （抽象方法沒有方法體，需要被實現，不能定義為 private)
         
 不共同:
1.在抽像類中可以寫非抽象的方法，介面中只能有抽象的方法
2.一個類只能繼承一個直接父類，這個父類可以是具體的類也可是抽像類；但是一個類可以實現多個介面。
3.抽像類和方法要加 abstract (抽象)來修飾
4.類是對具體事物的抽象，封閉的是具體事物的固有屬性；介面是對動作的抽象，不同的類可以實現介面中的動作方法
5.介面更多用來做契約或是約定，即規範約束

Q2. 集合常用 介面   List set map 的差別

Java集合的主要分為三種類型：

List（列表）
Set（集）
Map（映射）

1）List和Set是Collection(採集)的子介面,map不是。

2）List的底層是數組的方式實現，Set是散列表的方式實現，map是鍵值對的方式。

3）list是有序可重複的，Set是無序不可重複的，map是有序，key不重複，value(值)可重複

4）list和Set可直接使用itertator(迭代器)  來進行遍歷，map只能通過先遍歷Key在遍歷value(值).

Q3.JAVA  基礎型別有哪些

byte、short、int 和 long

Q4.Java面试题：什么是ORM？

對象關係映射（Object-Relational Mapping，簡稱ORM）是一種為了解決程序的面向對像模型與數據庫的關係模型互不匹配問題的技術；簡單的說，ORM是通過使用描述對象和數據庫之間映射的元數據（在Java中可以用XML或者是註解），將程序中的對象自動持久化到關係數據庫中或者將關係數據庫表中的行轉換成Java對象，其本質上就是將數據從一種形式轉換到另外一種形式。

Q5.Java面试题     JENKINS 是甚麼?

            

Jenkins 是一個可擴展的持續集成引擎。

主要用於：

• l 持續、自動地構建/測試軟件項目。
• l 監控一些定時執行的任務。

Jenkins擁有的特性包括：

• l 易於安裝-只要把jenkins.war部署到servlet容器，不需要數據庫支持。
• l 易於配置-所有配置都是通過其提供的web界面實現。
• l 集成RSS/E-mail通過RSS發布構建結果或當構建完成時通過e-mail通知。
• l 生成JUnit/TestNG測試報告。
• l 分佈式構建支持Jenkins能夠讓多台計算機一起構建/測試。
• l 文件識別:Jenkins能夠跟踪哪次構建生成哪些jar，哪次構建使用哪個版本的jar等。
• l 插件支持:支持擴展插件，你可以開發適合自己團隊使用的工具。

Q6.  Java面试题    JIRA  是甚麼?

JIRA，中文名常翻譯為：吉拉，但尚未有見到官方的譯名它是由澳大利亞的Atlassian的公司所開發的一款知名工具軟件，其主要作用是：軟件，移動應用程序開發過程中的bug（程序漏洞，缺陷）跟踪，問題跟踪（問題跟踪），以及敏捷項目管理（敏捷項目管理）。

有趣的是，“JIRA”這個名字實際上是由日文單詞“戈吉拉”演變而來，戈吉拉的意思是“哥斯拉”（哥斯拉）。由於JIRA內置對的Scrum，看板，Kanplan的支持，因此尤為適合敏捷開發項目.JIRA本身是由JAVA語言所開發。

Q7.  Java面试题   SOA  是甚麼?

（1）SOA的概念

SOA（Service-oriented archITecture，面向服務架構），而 WebService是實現 SOA 的其中一種方式，所以兩者並不是一個概念。WebService基於 SOAP 協議的，本質就是基於XML的，正是因為基於 XML，所以SOA才能整合不同的平台，不同的應用。

（2）SOA的作用：

①整合異構系統。準確點說，整合企業的遺留系統、正在開發的系統和即將開發的新系統。不同的系統可能採用不同的平台，如操作系統的選擇；不同的開發語言；不同的系統架構。


②及時的響應用戶的業務變化。大量的SOA組件，通過整合和拆散，然後打包成一個個的粒度合適的SOA組件，再經過流程管理工具的處理，實現業務的不斷變化。就像變形金剛那樣，零件還是那些零件，但是經過一定的變化，也就是對SOA組件的拆和並， 就可以玩不同的花樣。當然這是理想情況，至於到底實際情況如何，筆者也沒有搞過，所以不清楚。


Q8.鏈接這些構造函數以創建對像以從名為“in” 的文件中讀取並寫入名為“out”的文件。 

答：

解說：

串起這些建構子，用以建立物件來讀取檔案in ，並且寫入檔案out

Q10. 會打印甚麼?  

package com;

public class rrrt {

public static void main(String[] args) {

// TODO Auto-generated method stub

StringBuffer s = new StringBuffer("123456789");

System.out.println(s);

s.delete(0, 3).replace(1,3,"24").delete(4, 6);

System.out.println(s);

}

}

答 :123456789

4247

b

java - 抽象

抽象父類別 (抽象類別介面)
1) 與一般class 一樣也具有 fild contors , mothed

2)關鍵 ->  抽象方法
a) 只 宣告名稱  沒有內容   [ X ]  <不放入內容
b) abstrat    => 語法 :   abstrat  類型    方法名 (引數) :

3.所有繼承的子類別，要求: (條件2選一)
a) 抽象子類別
b) 如不是抽象的子類別，則一定要將抽象方法  Ouerride => 又稱實作抽象方法內容

○轉成抽象類別  就不能使用 " new"
繼承子類別 要實做出來
變成抽象類 無法實體化  無法" new "

一. instanceof
=> 檢查使用的物件是 是否有此class 類型 is - a

二.java lang .Objet
=> 所有 class 的 共同父類

三.  final  <=  只能用 不能繼承
a. field => 常數
b.method = > 不允許  ouerride
c.class => 不允許繼承
d.空find 需搭配建構式


.interface 介面
1.本身 即為抽象的父類別
2.自己無法" new " 物件，只能提供繼承或 "多型應用中宣告陣列變數用

3.組成元素
a) 常數
=> public   final  static 類型    常數名   = 初始值;

b) 抽象方法
=> public  abstract   類型 方法名 (引數);

c) 預設方法 => 有 {  }  body的內容
=>public default  類型  方法名  (引數) {...............};

d)類別類方法
=> public    static  類型 方法名(引數){..................};

c跟d  java 8 才有

4.implements
=> 繼承 實作

介面 => 多個 Super (父類別)

列子一:

/* abstract  */ class school
// 改成抽象方法 要加上 abstract 關鍵字
{
private String name;
final double pi=3.14;


school(String name)
{
this.name=name;
}

String show()
{
//pi=5.6;  以是 常數 不能給值
return "名:"+name;
}

void setName(String name)
{
this.name = name;
}
void setChi(int chi){}


void setEng(int eng){}


void setMath(int math){}




/*
abstract void setChi(int chi);
// 改成抽象方法 要加上 abstract 關鍵字

abstract void setEng(int eng);


abstract void setMath(int math);

     */
}

class add
{
public static void  main (String args[])
{
school [][] s=
{
{
new A("a1",74),
new A("a2",74)

}
,
{
new B("b1",86),
new B("b2",86),
new B("b3",86)

}
,
{
new C("c1",98),
new C("c2",98),
new C("c3",98)

}

};

for(int i=0;i<s.length;i++)
{
for(int j=0;j<s[i].length;j++)
{
System.out.println("s["+i+"]["+j+"]="+s[i][j]+"\t"+s[i][j].show());

}
System.out.println();
}
System.out.println("=====================================");
s[2][0].setName("q1");
s[0][1].setChi(85);
s[1][0].setEng(85);
s[2][1].setMath(85);


for(int i=0;i<s.length;i++)
{
for(int j=0;j<s[i].length;j++)
{
System.out.println("s["+i+"]["+j+"]="+s[i][j]+"\t"+s[i][j].show());

}
System.out.println();

}
System.out.println("=====================================");

System.out.println(s[0][0] instanceof A);
System.out.println(s[0][0] instanceof school);
System.out.println(s[0][0] instanceof B);
System.out.println("=====================================");

System.out.println(s[0][0]);
System.out.println(s[1][0]);
System.out.println(s[0][0].equals(s[1][0]));
System.out.println(s[0][0].getClass());
//.getClass 查找在哪一個class


System.out.println("=====================================");

s[0][0]=s[1][0];
System.out.println(s[0][0]);
System.out.println(s[1][0]);
System.out.println(s[0][0].equals(s[1][0]));
//判斷兩邊是否相同 equals

}

}

class A extends school
{
private int chi;

A(String name,int chi)
{
super(name);
this.chi=chi;

}
String show()
{

return super.show()+"\t國文:"+chi;
}
   

void setChi(int chi)
{
this.chi = chi;
}

void setEng(int eng)
{

}

 
     void setMath(int  math)
{

}
}


class B extends school
{
private int eng;

B(String name,int eng)
{
super(name);
this.eng =eng;

}
String show()
{

return super.show()+"\t英文:"+eng;
}


     void setEng(int eng)
{
this.eng = eng;
}
}


class C extends school
{
private int math;

C(String name,int math)
{
super(name);
this.math = math;

}
String show()
{

return super.show()+"\t數學:"+ math;
}

     void setMath(int  math)
{
this.math =  math;
}
}


class test
{
public static void main(String args[])
{

//bookstore b1=new bookstore();
book b1 = new  bookstore() ;
//更常搭配此種方法

System.out.println(b1.title);
System.out.println(b1.bookprice(50));
System.out.println(b1.bookprice2(50));
//System.out.println(b1.bookprice3(50));
//System.out.println(bookstore.bookprice3(50));
System.out.println(book.bookprice3(50));
//用父介面去呼叫，子介面不能去呼叫它



member m1=new member("abc","def");

m1.name="eee";
m1.username="tttt";

//book x=new book(); //不能NEW 因為抽象類型

}

}

class  member
{
final String username;
String name;
//不給值 只能使用建構式] 只能二選一

member(String username,String name)
{
this.username=username;
this.name=name;
//username 是常數不能給值
}

}

interface book
{
//抽象類使用


  /*public final static */ String title="GJUN";//要給一個值
  /*public abstract*/ int bookprice(int price);//前面沒寫 也會自己補上


  // 第八版  才有此方法   前面要加上 default
   /*public */default double bookprice2(double price)
{

return price*10;
}



//public  可以省略  使用 static   就不要使用 default
//只要選擇一種就好
/*public*/ static double bookprice3(double price)
{

return price*15;
}
}

class bookstore implements /*使用implements繼承*/ book
//父類別也是抽象的
{
    int bookprice(int price)
{
return price*150;
}
     // 編譯不會過 因為  上面 int bookprice  第三種預設權限
// 但是 book 的 介面 都是 public 權限  所以無法訪問

}



例子二.
interface book2
{


}


class bookstore extends book3 implements book,book2
/*上面為 可繼承多個父類別，實體要先寫
class bookstore extends  只能一個不能使用多個
*/
{
public int bookprice(int price)
{
return price*150;
}

}


class book3
{


}

interface book
{
/*public final static */ String title="GJUN";
/*public abstract*/ int bookprice(int price);

/*public */default double bookprice2(double price)
{

return price*10;
}

/*public*/ static double bookprice3(double price)
{

return price*15;
}

}

例子: