【46】WEB安全學習----JAVA基礎三
一、String類
在JAVA中，String字串用雙引號引起來，字串嚴格來說就是字元的陣列集合：
在JDK1.8及以前，String類使用char []字元陣列儲存字串，而1.9及以上使用byte []位元組陣列儲存字串。
1、字串的比較：
字串如果用 "==" 進行比較，比較的是兩個物件的記憶體地址是否相同，用equals()才是比較內容是否相同：
public class Test{ public static void main(String args[]) { String s1 = "hello"; String s2 = new String("hello"); System.out.println(s1 == s2); //false System.out.println(s1.equals(s2));//true } }
String類常用方法：
int->String.length()：返回字串的長度
boolean->String.isEmpty()：判斷字串是否為空或者長度為0
char->String.charAt()：返回char指定索引的值
boolean->String.equals()：字串比較
int->String.indexOf()：返回指定字元第一次出現的索引位置
String->String.substring()：返回擷取的子字串
String->String.replace()：字串替換：一個
String->String.replaceAll()：字串替換:全部
String []->String.split()：字串分割
String->String.join()：字串組合
String->String.trim()：刪除首尾空格
二、繼承性
定義：class 子類 extends 父類 {}
子類也叫派生類，父類也叫超類。繼承實現的主要目的是在於子類可以重用父類中的結構，並且實現功能的擴充，描述的範圍更小。
class A { public void getinfo() { System.out.print("子類繼承父類結構"); } } class B extends A {} //B子類繼承父類A public class Test { public static void main(String[] args) { B b1 = new B(); b1.getinfo();//得到父類的方法 } }
super()方法：
表示子類構造呼叫父類構造的語句，該方法只允許放在子類構造方法首行，預設呼叫的是父類的無參構造方法。所以不允許super()和super(引數)同時出現。
class A {
private String name;
private int age;
public A() {
System.out.println("子類例項化會首先例項化父類構造方法");
}
public A(String name,int age) {
this.name = name;
this.age = age;
}
public void getinfo() {
System.out.print("姓名：" + this.name + " 年齡：" + this.age);
}
}
class B extends A {
private String addr;
// public B() {
// super(); //子類呼叫父類的無參構造方法
// }
public B(String name, int age ,String addr) {
super(name,age); //子類呼叫父類的有參構造方法
this.addr = addr;
}
}
public class Test {
public static void main(String[] args) {
// B b1 = new B();
// b1.getinfo();
B b2 = new B("小明",20,"重慶");
b2.getinfo();
}
}
JAVA不支援多重繼承（同時繼承多個父類 clss C extends A,B{} ），但是可以多層繼承：B繼承A，C繼承B，那麼C就有了A和B的結構。
class A{}
class B extends A{}
class C extends b{}方法覆寫：
當子類中出現的方法和父類中出現的方法相同時（方法名和引數），就叫做覆寫（類似於方法的過載），那麼例項化後就呼叫的是子類的方法，若要呼叫父類的方法可使用super.方法()：
class A{
public void getinfo() {
System.out.print("父類getinfo方法");
}
}
class B extends A{
public void getinfo() {
super.getinfo(); //呼叫父類的getinfo方法
System.out.print("子類getinfo方法");
}
}
public class Test {
public static void main(String[] args) {
B b1 = new B();
b1.getinfo(); //父類getinfo方法子類getinfo方法
}
}
若只是方法名相同，那麼會根據傳入的引數自動呼叫子類或父類的方法：
class A{
public void getinfo(String name) {
System.out.print("父類getinfo方法" + name);
}
}
class B extends A{
public void getinfo() {
System.out.print("子類getinfo方法");
}
}
public class Test {
public static void main(String[] args) {
B b1 = new B();
b1.getinfo("AA"); //父類getinfo方法AA
B b2 = new B();
b2.getinfo(); //子類getinfo方法
}
}
屬性覆寫：
若子類定義了和父類相同的屬性時，那麼例項化後呼叫的是子類的屬性，若要訪問父類的屬性，可以使用super.屬性名：
class A{
public String name = "父類屬性";
}
class B extends A{
public String name = "子類屬性";
public void getinfo() {
System.out.println(super.name); //父類屬性
System.out.println(this.name); //子類屬性
}
}
public class Test {
public static void main(String[] args) {
B b1 = new B();
b1.getinfo();
}
}
覆寫限制：
子類覆寫父類方法或屬性時，訪問限制要和父類相同或更寬鬆：public > default > private。若父類是private修飾的則不能進行覆寫（私有屬性和方法子類不能直接呼叫）。
final關鍵字：
在JAVA中，使用final關鍵字可以定義不能繼承的類、方法、常量。
public class Test {
public static void main(String[] args) {
public static final double PI = 3.141592653; //定義全域性常量
}
}
三、Annotation註解：
@Override：
明確表示該方法是一個覆寫來的方法：
class A{
public void getinfo() {
System.out.println("111111");
}
}
class B extends A{
@Override //加上此註解可以在編譯時防止要覆寫的方法單詞寫錯了或繼承父類沒寫。
public void getinfo() {
System.out.println("222222");
}
}
public class Test {
public static void main(String[] args) {
B b1 = new B();
b1.getinfo();
}
}
@Deprecated：
過期操作，用此註解修飾的方法表示此方法不建議使用（但能使用），已淘汰。但又不能直接刪除此方法，因為以前的某些程式碼可能呼叫了此過期的方法。
@SuppressWarings：
壓制警告，通過此註解修飾的方法在編譯時如果有警告資訊出現，如呼叫了過期的方法，可以使用此註解使其編譯器不在顯示警告資訊。簡單來說就是遮蔽警告資訊。
四、多型性
多型是在繼承性的基礎之上擴展出來的概念，可以實現父子之間轉換關係。
JAVA對於多型有兩種實現模式：
方法的多型性：
1、方法過載：同一方法名稱可以根據傳入的引數型別或個數的不同實現不同功能。
2、方法覆寫：同一個方法可能根據子類的不同有不同的實現。
物件的多型性：
1、物件向上轉型：父類 父類例項 = 子類例項 ； 自動完成轉換。
class A{
public void getinfo() {
System.out.println("111111");
}
}
class B extends A{
public void getinfo() {
System.out.println("2222222");
}
}
public class Test {
public static void main(String[] args) {
A a1 = new B(); //物件向上轉型,自動轉換
a1.getinfo();
}
}
2、物件9向下轉型：子類 子類例項 = （子類）父類例項；強制完成轉換。
在進行向下轉型時，必須要進行向上轉型。
五、Object類
使用object類可以解決引數的統一問題，也就說可以接受任何資料型別。
Object類是不存在有繼承關係的，也就是說所有的類都是Object類的子類。
class A{}
public class Test {
public static void main(String[] args) {
Object obj = new A(); //Object類可以接受任何資料型別，是所有類的父類
Object obj1 = new String[] {"11","22"};
}
}
Object.toString()：
toString()方法可以獲取物件資訊，但預設返回的是物件記憶體編號：
class A{}
public class Test {
public static void main(String[] args) {
A a1 = new A();
System.out.println(a1.toString()); //[email protected]
System.out.println(a1); //[email protected]
}
}
可以通過覆寫toString方法得到自定義物件資訊：
class A{
public String toString() {
return "覆寫toString()方法";
}
}
public class Test {
public static void main(String[] args) {
A a1 = new A();
System.out.println(a1.toString()); //覆寫toString()方法
System.out.println(a1); //覆寫toString()方法
}
}
Object.equals()：
可以使用此方法比較兩個物件內容是否相同。
六、抽象類
對子類中覆寫方法進行約定（子類繼承後一定要覆寫此方法），一般寫父類都為抽象類。
使用abstract關鍵字定義的且沒有提供方法體的方法。（就是規定了方法名，但方法體由子類自己實現）
abstract class A{
public abstract String getinfo();
}
class B extends A{
public String getinfo() {
return "子類必須覆寫父類抽象類定義的方法";
}
}
public class Test {
public static void main(String[] args) {
}
}
七、包裝類
之前說過Object類是所有類的父類，可以接受任意引用型別，但Object類不能接受JAVA的八種基本資料型別（int、long、double等），因為基本資料型別不是引用型別(類)，所以把基本資料型別包裝成引用型別來使用就是包裝類的作用。
JDK中包裝類一共提供了兩種型別：
物件型包裝類（Object直接子類）：Boolean、Character；
數值型的包裝類：（Number直接子類）：Byte、Short、Integer、Long、Double、Float
八、介面
可以理解為一個純粹的抽象類（最原始的定義介面之中是隻包含有抽象方法和全域性常量）。
使用interface關鍵字定義介面，implements實現介面：
interface A{ //定義一個介面A
public static final String INFO = "111";//全域性常量
public abstract String getinfo(); //抽象方法
}
class B implements A{
public String getinfo() {
return "222"; //必須實現介面的抽象方法
}
}
public class Test {
public static void main(String[] args) {
}
}
用介面可以實現一個子類可以實現多個介面：也就是多重繼承。
九、包
為了方便類的管理（如類重名），JAVA採用包的機制來管理類。其實包相當於目錄，用不同的目錄儲存類，在通過目錄呼叫類。
package cn.a.demo; //定義包
public class Hello{
public static void main(String args[]){
System.out.println("Hello");
}
}
// javac -d . Hello.java 打包操作
//javac cn.a.demo.Hello 執行類包的匯入：
使用import關鍵字匯入相關包：
package cn.b.demo;
import cn.a.demo;//匯入指定包的類
import cn.a.*;//使用萬用字元匯入指定包的所有類
public class Demo{
public static void main(String args[]){
cn.a.demo.Hello h1 = new cn.a.demo.Hello(); //若匯入的包有類重名，則使用全路徑包名稱
Hello h2 = new Hello(); //若匯入的包沒有重名的，則可以直接使用類名稱
}
}
靜態匯入：
若要匯入的包的類方法都是靜態定義的，那麼JAVA提供了靜態匯入方式：
package cn.a.test;
import static cn.a.demo.*; //靜態匯入
public class Test{
public static void main(String args[]){
add(1,2); //通過靜態匯入，使用時可以不加類名.方法()
}
}生成jar檔案：
當專案完成後，會有大量的包及class檔案，為了方便管理及使用，可以把這些包及class檔案壓縮成一個檔案，這就是生成JAR檔案：
生成命令：jar -cvf test.jar cn ：-c建立一個新的jar檔案，-v資訊輸出，-f設定要生成的jar，cn包名
系統常見包：
java.lang：基礎類，像String、Number、Object都在這裡，系統會預設載入。
java.util：工具類，包括資料結構的定義
java.io：進行輸入與輸出流操作的程式包
java.net：網路程式開發的程式包
java.sql：資料庫程式設計的開發包
java.awt、java.swing：JAVA圖形介面開發包（GUI）