二維陣列

轉自：https://blog.csdn.net/weixin_36564655/article/details/79615479

兩種初始化形式

格式1: 動態初始化
資料型別 陣列名 [ ][ ] = new 資料型別[m][n]
資料型別 [ ][ ] 陣列名 = new 資料型別[m][n]
資料型別 [ ] 陣列名 [ ] = new 資料型別[m][n]

舉例：int [ ][ ] arr=new int [5][3]; 也可以理解為“5行3例”

格式2: 靜態初始化
資料型別 [ ][ ] 陣列名 = {{元素1,元素2…},{元素1,元素2…},{元素1,元素2…}…};

舉例：int [ ][ ] arr={{22,15,32,20,18},{12,21,25,19,33},{14,58,34,24,66},};

靜態初始化可用於不規則二維陣列的初始化

泛型

本質：將型別引數化
型別也可以作為引數
泛型的類，泛型的方法，泛型的介面

泛型的類

使用型別引數可以用一個泛型類構造出不同型別的物件，編譯的時候可以做型別檢查

class GeneralType <Type>{
    private Type object;

    public GeneralType(Type object){
        this.object = object;
    }

    public Type getObject() {
        return object;
    }
}

public class GeneralTypeTest { 
    public static void main(String[] args) {
        GeneralType <Integer> i = new GeneralType<Integer>(2);
        GeneralType <Double> d = new GeneralType<Double>(2.1);
        System.out.println(i.getObject());
        System.out.println(d.getObject());
        //System.out.println(d.object);
    }
}

泛型方法

在宣告方法的時候讓方法接收的引數或方法體內的資料型別可定製

public class GeneralMethodTest {
    public static void main(String[] args) {
        GeneralMethod gm = new GeneralMethod();
        gm.printClassName("hello");
        gm.printClassName(33);
        gm.printClassName(4.33f);
        gm.printClassName(4.23d);
    }
}
class GeneralMethod{
    <Type> void printClassName(Type object){
        System.out.println(object.getClass().getName());
    }
}

//輸出結果
java.lang.String
java.lang.Integer
java.lang.Float
java.lang.Double

使用 ？ 作萬用字元

class GeneralType <Type>{
    private Type object;

    public GeneralType(Type object){
        this.object = object;
    }

    public Type getObject() {
        return object;
    }
}
class ShowType{
    public void show (GeneralType<?> o){
        System.out.println(o.getObject().getClass().getName());
    }
}

public class GeneralTypeTest {
    public static void main(String[] args) {
        ShowType st = new ShowType();
        GeneralType <Integer> i = new GeneralType<Integer>(2);
        GeneralType <Double> d = new GeneralType<Double>(2.1);
        st.show(i);
        st.show(d);
    }
}

有限制的泛型

在引數Type後面使用extends關鍵字並加上類名或介面名，表明引數所代表的的型別必須是該類的子類或者實現了該介面
對於實現了某介面的有限制泛型，也是使用extends關鍵字，而不是implements關鍵字
限制這個型別引數必須是繼承自某個超類，或者是實現了某個介面，對型別引數的範圍作了一定限制。便於在程式的方法體中，對特定類家族的或者特定的實現了某介面的輸資料型別做專門的處理。

class GeneralType <Type extends Number>{
    private Type object;

    public GeneralType(Type object){
        this.object = object;
    }

    public Type getObject() {
        return object;
    }
}

public class GeneralTypeTest1 {
    public static void main(String[] args) {
        GeneralType<Integer> i = new GeneralType<Integer>(11);

        //GeneralType<String> s = new GeneralType<String>("sdasd");
        //非法
    }
}

類的組合

也是一種類的重用機制，表達一種包含關係
繼承表達的是從屬關係

組合的語法

class Cooker{ //類的語句}
class Refrigerator{//類的語句}
class Kitchen{
	Cooker myCooker;
	Refrigerator myRefrigerator;
}

組合舉例—線段

public class Point {
    private int x,y;
    public Point(int x,int y){
        this.x = x ;
        this.y = y ;
    }
    public int getX(){
        return x;
    }
    public int getY(){
        return y;
    }
}
class Line{
    private Point p1,p2;
    public Line(Point a,Point b){
        p1 = new Point(a.getX(),a.getY());
        p2 = new Point(b.getX(),b.getY());
    }
    public double Length(){
        return Math.sqrt(Math.pow(p2.getX()-p1.getX(),2))+Math.sqrt(Math.pow(p1.getY()-p2.getY(),2));
    }
}

模板方法設計模式

abstract public class Template {
    public final void getTime(){
        long start = System.currentTimeMillis();
        code();
        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }
    public abstract void code();
}
class SubTemplate extends Template{
    @Override
    public void code() {
        int k=0;
        for (int i = 0 ;i < 1000000 ; i++ ){
            k++;
        }
        System.out.println(k);
    }
}

public class TemplateTest {
    public static void main(String[] args) {
        SubTemplate s = new SubTemplate();
        s.getTime();
    }
}

介面

有時必須從及各類中派生出一個子類，繼承他們所有的屬性和方法，但是Java不支援多重繼承。有了介面（interface），就可以得到多重繼承的效果。
介面（interface）是抽象方法和常量值的定義的集合。
從本質上講，介面是一種特殊的抽象類，這種抽象類中只包含常量和方法的定義，而沒有變數和方法的實現
一個類可以實現多個介面，介面也可以繼承其他介面。

實現介面類：

	class SubClass implements InterfaceA{}

介面的語法

[介面修飾符] interface 介面名稱 [extends 父介面名]{
	//方法的原型宣告或靜態常量
}

藉口的資料成員一定要有初值，並且不能再被修改，可以省略final關鍵字
介面中的方法必須是抽象方法，不能有方法體，可以省略public以及abstract關鍵字

介面的特點

用interface定義
介面中所有的成員變數都預設是由public static final修飾的
介面中的所有方法都預設是由public abstract修飾的
介面中沒有構造器
介面採用多層繼承機制

介面定義舉例

public interface Runner {
    /*int ID = 1 ;  //預設的全域性常量，如下
    void start();   //預設的抽象方法，如下
    public void run();
    void stop();*/

    public static final int ID = 1;
    public abstract void start();
    public abstract void run();
    public abstract void stop();
}

實現介面

利用介面設計類，使用implements關鍵字

public class 類名稱 implements 介面名稱{
	//在類體中實現介面的方法
	//本類宣告的更多變數和方法
}

必須事先介面中所有的方法
來自介面的方法必須宣告為public

實現多個介面的語法

一個類可以實現多個介面，通過這種機制可實現對設計的多重繼承

[類修飾符] class 類名稱 implements 介面1,介面2,...{
... ...
}

例題

public interface Shape2D {
    public final double pi = 3.14;  //常量π
    public abstract double area();  //面積
}
interface Color {
    abstract void setColor(String str);     //顏色
}

//圓類
public class Circle1 implements Shape2D,Color {
     private double r;  //半徑

    //設定圓半徑
    public void setR(double r) {
        this.r = r;
    }
    // 返回圓半徑
    public double getR() {
        return r;
    }
    //對介面中方法的定義
    @Override
    public double area() {
        return pi * r * r ;
    }
    @Override
    public void setColor(String str) {
        System.out.println(str);
    }
}

public class Circle1Test {
    public static void main(String[] args) {
        Circle1 cir = new Circle1();//新建一個圓類引用
        cir.setR(9.9);//設定圓的半徑
        System.out.println("r = "+cir.getR());//返回圓半徑
        System.out.println("area = "+cir.area());//返回圓的面積
        cir.setColor("blue");//設定圓的顏色
    }
}

介面的擴充套件

實現一個介面的類也必須實現其超介面
一個介面可以繼承自多個超介面

介面擴充套件的語法

interface 子介面的名稱 extends 超介面的名稱1,超介面的名稱2,...
{
	... ...
}

例題

public interface Shape {
    public final double pi = 3.14;
    public abstract void Color1(String str);
}
interface Shape2D1 extends Shape{
    public abstract double area1();
}
interface Shape3D1 extends Shape{
    public abstract double volume();
    public abstract double area2();
}

public class Circle2 implements Shape2D1{
    @Override
    public double area1() {
        return 0;
    }

    @Override
    public void Color1(String str) {

    }
}
class Rectangle2 implements Shape2D1{
    int a,b;

    public void setAB(int a,int b) {
        this.a = a;
        this.b = b;
    }

    public int getA() {
        return a;
    }

    public int getB() {
        return b;
    }

    @Override
    public double area1() {
        return a*b;
    }

    @Override
    public void Color1(String str) {
        System.out.println("color = "+ str);
    }
}

型別轉換（塑性）

轉換方式：隱式的型別轉換（自動轉換）、顯式地型別轉換（強制型別轉換）
轉換方向：向上轉型、向下轉型

型別轉換規則

基本型別之間的轉換

將值從一種型別轉換成另一種型別

引用變數的型別轉換

將引用轉換為另一型別的引用，並不改變物件本身的型別
只能被轉為：
任何一個（直接或間接）超類的型別（向上轉型）；
物件所屬的類（或其超類）實現的一個介面（向上轉型）；
被轉為引用指向的物件的型別（唯一可以向下轉型的情況）。
某個介面型別或者某個超類型別的引用，可以指向一個實現介面的物件或者子類的物件
當一個引用被轉為其超類引用後，通過他能夠訪問的只有在超類中宣告過的方法

Manager物件 可以被塑型為Employee、Person、Object或Insurable，不能被塑型為Customer、Company或Car

隱式型別轉換（自動轉換）

基本資料型別

可以轉換的型別之間，儲存容量低的自動向儲存容量高的型別轉換

引用變數

被轉成更一般的類

Employee emp;
emp = new Manager();		//將Manager型別的物件直接賦給Employee類的引用變數，系統會自動將Manager物件塑型為Employee類

被塑型為物件所屬類實現的介面型別

//實現了介面的類的引用轉為介面的引用
Car jetta = new Car();
Insurable item = jetta;

顯式地型別轉換（強制型別轉換）

基本資料型別

(int)885.4343;//結果為885
(char)65;//結果為'A'
(long)453; //結果為453L

引用變數

Employee emp;
Manager man;
emp = new Manager();//將子型別的物件引用轉換為超類的物件引用，emp實際指向的物件就是子類物件，所以可以向下轉型
man = (Manager)emp;//將emp顯式轉換為它所指向的物件的型別

型別轉換的主要應用場合

賦值轉換

賦值運算子右邊的表示式或物件型別轉換為左邊的型別

方法呼叫轉換

實參的型別轉換為形參的型別

算數表示式轉換

算數混合運算時，不同型別的運算元轉換為相同的型別再進行運算

字串轉換

字串連線運算時如果一個運算元是字串，另一個運算元為其他型別，則會自動將其他型別轉換為字串

應用舉例

Manager類的引用轉換為Employee類的引用時，只能訪問Employee類以及其超類裡面的方法，不能通過超類的引用訪問Manager類的方法。
如果將Manager類的引用向上轉型為Employee類的引用，但實際還是指向Manager類物件，在這種情況下可以再轉回到Manager類的引用，然後就可以使用Manager類的方法