一、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()); //A@15db9742
System.out.println(a1); //A@15db9742
}
}
可以通過覆寫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）