程序猿程式-筆記: 2019

2019年8月30日星期五

IntelliJ IDEA Community Edition 問題排除

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

2019年8月15日星期四

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  +
                "]";    }
}

2019年8月13日星期二

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.接下來就可以進行連線設定

2019年6月22日星期六

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());
*/

}

}

執行結果:

2019年5月4日星期六

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

訂閱：文章 (Atom)

2019年8月30日 星期五

2019年8月15日 星期四

2019年8月13日 星期二

2019年6月22日 星期六

2019年5月4日 星期六