2018.8.9 HelloWorld！

閒來無事，想起了還有java這個世界上最好的語言（別再強調是PHP了~

人生第一個用java實現的Hellworld，紀念一下！

			
public class HelloWorld {
		public static void main(String []args) {
			System.out.println("Hello World!");
		}
}

一入此門深似海吶，瞭解了java的輸入輸出，數組的創建。通過 Scanner 類的 next() 與 nextLine() 方法獲取輸入的字符串，在讀取前我們一般需要使用 hasNext 與 hasNextLine 判斷是否還有輸入的數據。

import java.util.Scanner;

public class Test1 {
	public static void main(String[] args) {
		Scanner io = new Scanner(System.in);
		int min = 1000;
		int[] array = new int [10];
		for(int i = 0; i < 10; i++) {
			array[i] = io.nextInt();
		}
		for(int i = 0; i < 10; i++) {
			if(array[i] < min)
				min = array[i];
		}
		System.out.println(min);
	}
}

2018.8.10 Are you sure？

菜雞第二天看完清華大神鄭莉老師的視頻才知道，原來輸入流還要關閉。

import java.util.Scanner;

public class Test2 {
	public static void main(String[] args) {
		Scanner io = new Scanner(System.in);
		int[] array = new int [10];
		for(int i = 0; i < 10; i++) {
			array[i] = io.nextInt();
		}
		io.close();
		int tmp;
		for(int i = 0; i < 10; i++) {
			for(int j = 0; j < 9-i; j++) {
				if(array[j] > array[j+1]) {
					tmp = array[j];
					array[j] = array[j+1];
					array[j+1] = tmp;
			    }
			}
		}
		for(int i = 0; i < 10; i++) {
			System.out.print(array[i] + " ");
		}
	}
}

2018.8.11 回車一下

next() 與 nextLine() 區別

next():

一定要讀取到有效字符後纔可以結束輸入。

對輸入有效字符之前遇到的空白，next() 方法會自動將其去掉。

只有輸入有效字符後纔將其後面輸入的空白作爲分隔符或者結束符。

next() 不能得到帶有空格的字符串。

nextLine()：

以Enter爲結束符,也就是說 nextLine()方法返回的是輸入回車之前的所有字符。

可以獲得空白。

import java.util.Scanner;
 
public class Test3 {
    public static void main(String[] args) {
        Scanner io = new Scanner(System.in);
        int i = 0;
        float f = 0.0f;
        System.out.print("輸入整數：");
        if (io.hasNextInt()) {
            i = io.nextInt();
            System.out.println("整數數據：" + i);
        } 
        else {
            System.out.println("輸入的不是整數！");
        }
        System.out.print("輸入小數：");
        if (io.hasNextFloat()) {
            f = io.nextFloat();
            System.out.println("小數數據：" + f);
        } 
        else {
            System.out.println("輸入的不是小數！");
        }
        io.close();
    }
}

2018.9.6 lili姐畫了一節課流程圖+Java繼承

lili姐說沒事多練練……眼過千遍，不如手過一遍（當然也看不了一千遍

Java繼承

繼承就是子類繼承父類的特徵和行爲，使得子類對象（實例）具有父類的實例域和方法，或子類從父類繼承方法，使得子類具有父類相同的行爲。

類的繼承格式

在 Java 中通過 extends 關鍵字可以申明一個類是從另外一個類繼承而來的，一般形式如下：

class 父類 {
}
 
class 子類 extends 父類 {
}

繼承類型

需要注意的是 Java 不支持多繼承，但支持多重繼承。

繼承的特性

子類擁有父類非private的屬性，方法。

子類可以擁有自己的屬性和方法，即子類可以對父類進行擴展。

子類可以用自己的方式實現父類的方法。

Java的繼承是單繼承，但是可以多重繼承，單繼承就是一個子類只能繼承一個父類，多重繼承就是，例如A類繼承B類，B類繼承C類，所以按照關係就是C類是B類的父類，B類是A類的父類，這是java繼承區別於C++繼承的一個特性。

提高了類之間的耦合性（繼承的缺點，耦合度高就會造成代碼之間的聯繫越緊密，代碼獨立性越差）。

繼承可以使用 extends 和 implements 這兩個關鍵字來實現繼承，而且所有的類都是繼承於 java.lang.Object，當一個類沒有繼承的兩個關鍵字，則默認繼承object（這個類在 java.lang 包中，所以不需要 import）祖先類。

extends關鍵字

在 Java 中，類的繼承是單一繼承，也就是說，一個子類只能擁有一個父類，所以 extends 只能繼承一個類。

public class Person { 
    private String name;   
    private int id; 
    public Person(String Name, String Id) { 
        //初始化
    } 
    public void eat() {  //喫飯屬性的實現  } 
    public void sleep() { //睡覺屬性的實現  } 
} 
 
public class Boy  extends  Person{ 

}

implements關鍵字

規矩是死的，人是活的！！！

使用 implements 關鍵字可以變相的使java具有多繼承的特性，使用範圍爲類繼承接口的情況，可以同時繼承多個接口。

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {

}

super 與 this 關鍵字

super關鍵字：我們可以通過super關鍵字來實現對父類成員的訪問，用來引用當前對象的父類。

this關鍵字：指向自己的引用。


class Person {
    void eat() {
    	System.out.println("Person : eat");
    }
}
 
class Boy extends Person {
    void eat() {
    	System.out.println("Boy : eat more");
    }
    void eatTest() {
    	this.eat();   // this 調用自己的方法
    	super.eat();  // super 調用父類方法
    }
}
 
public class Test10 {
	public static void main(String[] args) {
	    Person p = new Person();
	    //p.eat();
	    Boy b = new Boy();
	    b.eatTest();
	}
}

final關鍵字

final 關鍵字聲明類可以把類定義爲不能繼承的，即最終類；或者用於修飾方法，該方法不能被子類重寫。

final class 類名 {
    //類體
}

2018.9.13 Java重寫Override與重載Overload

lili姐頻繁拿對象數組舉例，我連對象都。。。攤手

重寫Override

重寫是子類對父類的允許訪問的方法的實現過程進行重新編寫, 返回值和形參都不能改變。即外殼不變，核心重寫！

重寫的好處在於子類可以根據需要，定義特定於自己的行爲。也就是說子類能夠根據需要實現父類的方法。

當需要在子類中調用父類的被重寫方法時，要使用super關鍵字。

class Persons extends Object{
		private String Name;
		private int Age;
		private int High;
		
		public String getName() {
			return Name;
		}
		public int getAge() {
			return Age;
		}
		public int getHigh() {
			return High;
		}
	
		public Persons(String name,int age,int high) {
			this.Name = name;
			this.Age = age;
			this.High = high;
		}
		
		//重寫string
		public String toString() {
			return (Name + " " + Age + " " + High);
		}
}

public class Test12 {

	public static void main(String[] args) {
			
		int n,age,high;
		String name;
		Persons[] people = new Persons[5];

		people[0] = new Persons("Peter",17,175);
		people[1] = new Persons("Alice",18,176);
		people[2] = new Persons("Rose",19,177);
		people[3] = new Persons("Tom",20,178);
		people[4] = new Persons("Grown",21,179);
			
	        for(int i = 0; i < people.length; i++) {
				System.out.println(people[i]);
		}
}

重載Overload

重載(overloading) 是在一個類裏面，方法名字相同，而參數不同。返回類型可以相同也可以不同。

每個重載的方法（或者構造函數）都必須有一個獨一無二的參數類型列表。

最常用的地方就是構造器的重載。

重載規則

被重載的方法必須改變參數列表(參數個數或類型不一樣)。

被重載的方法可以改變返回類型。

被重載的方法可以改變訪問修飾符。

被重載的方法可以聲明新的或更廣的檢查異常。

方法能夠在同一個類中或者在一個子類中被重載。

無法以返回值類型作爲重載函數的區分標準。

小結

方法的重寫(Overriding)和重載(Overloading)是java多態性的不同表現，重寫是父類與子類之間多態性的一種表現，重載可以理解成多態的具體表現形式。

2018.10.11 Java抽象類與接口

抽象類（abstract）

在Java語言中使用abstract class來定義抽象類。

在面向對象的概念中，所有的對象都是通過類來描繪的，但是反過來，並不是所有的類都是用來描繪對象的，如果一個類中沒有包含足夠的信息來描繪一個具體的對象，這樣的類就是抽象類。

抽象類除了不能實例化對象之外，類的其它功能依然存在，成員變量、成員方法和構造方法的訪問方式和普通類一樣。

由於抽象類不能實例化對象，所以抽象類必須被繼承，才能被使用。也是因爲這個原因，通常在設計階段決定要不要設計抽象類。

父類包含了子類集合的常見的方法，但是由於父類本身是抽象的，所以不能使用這些方法。

在Java中抽象類表示的是一種繼承關係，一個類只能繼承一個抽象類，而一個類卻可以實現多個接口。

抽象方法

abstract關鍵字同樣可以用來聲明抽象方法，抽象方法只包含一個方法名，而沒有方法體。

抽象方法沒有定義，方法名後面直接跟一個分號。

public abstract class Shape
{
   private double length;
   
   public abstract double getArea();    //獲取面積
   
   public abstract double getCircumference();   //獲取周長

   //其餘代碼
}

敲黑板！！！

如果一個類包含抽象方法，那麼該類必須是抽象類。

任何子類必須重寫父類的抽象方法，或者聲明自身爲抽象類。

class Circle extends Shape{
	
	public double getArea() {
		return length * length * Math.PI;
	}
	
        public double getCircumference() {
                return Math.PI * length * 2;
        }
}

小結

抽象類不能被實例化，如果被實例化，就會報錯，編譯無法通過。只有抽象類的非抽象子類可以創建對象。

抽象類中的抽象方法只是聲明，不包含方法體，就是不給出方法的具體實現。

構造方法，類方法（用static修飾的方法）不能聲明爲抽象方法。

抽象類的子類必須給出抽象類中的抽象方法的具體實現，除非該子類也是抽象類。

接口（interface）

接口並不是類，編寫接口的方式和類很相似，但是它們屬於不同的概念。類描述對象的屬性和方法，接口則包含類要實現的方法。

接口無法被實例化，但是可以被實現。一個實現接口的類，必須實現接口內所描述的所有方法，否則就必須聲明爲抽象類。

聲明：

[可見度] interface 接口名稱 [extends 其他的接口名名] {
        // 聲明變量
        // 抽象方法
}

定義接口：

public interface Shape {
	public double getArea();
}

實現接口：

class Circle implements Shape{
	double length;
	public double getArea() {
		return length * length * Math.PI;
	}
	Circle(double r) {
		length = r;
	}
}
class Rectangle implements Shape{
	double length;
	double width;
	public double getArea() {
		return length * width;
	}
	Rectangle(double l,double w) {
		length = l;
		width = w;
	}
}
public class Test1 {
	public static void main(String[] args) {
		Circle c = new Circle(2);
		Rectangle r = new Rectangle(4,5);
		System.out.println(c.getArea());
		System.out.println(r.getArea());
	}
}

運行結果：

12.566370614359172
20.0

接口特點：

接口是隱式抽象的，當聲明一個接口的時候，不必使用abstract關鍵字。

接口中每一個方法也是隱式抽象的，聲明時同樣不需要abstract關鍵字。

接口中的方法都是公有的。

接口與類相似點：

一個接口可以有多個方法。

接口文件保存在 .java 結尾的文件中，文件名使用接口名。

接口與類的區別：

接口不能用於實例化對象。

接口沒有構造方法。

接口中所有的方法必須是抽象方法。

接口不能包含成員變量，除了 static 和 final 變量。

接口不是被類繼承了，而是要被類實現。

接口支持多繼承。

接口和抽象類的區別：

抽象類中的方法可以有方法體，就是能實現方法的具體功能，但是接口中的方法不行。

抽象類中的成員變量可以是各種類型的，而接口中的成員變量只能是 public static final 類型的。

一個類只能繼承一個抽象類，而一個類卻可以實現多個接口。

一個蒟蒻萌新的Java之路

2018.8.9 HelloWorld！

2018.8.10 Are you sure？

2018.8.11 回車一下

2018.9.6 lili姐畫了一節課流程圖+Java繼承

Java繼承

類的繼承格式

繼承類型

繼承的特性

2018.9.13 Java重寫Override與重載Overload

重寫Override

重載Overload

2018.10.11 Java抽象類與接口

抽象類（abstract）

抽象方法

接口（interface）

NCTF-南郵網絡攻防平臺WriteUp：SQL注入1

CTF-實驗吧Writeup-Misc類（持續更新）

一個蒟蒻萌新的Java之路

計算機內存取證Volatility framework的使用手冊（長期跟進）

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

一個蒟蒻萌新的Java之路

2018.8.9 HelloWorld！

2018.8.10 Are you sure？

2018.8.11 回車一下

2018.9.6 lili姐畫了一節課流程圖+Java繼承

Java繼承

類的繼承格式

繼承類型

繼承的特性

2018.9.13 Java重寫Override與重載Overload

重寫Override

重載Overload

2018.10.11 Java抽象類與接口

抽象類 （abstract）

抽象方法

接口（interface）

抽象類（abstract）