摘要：在那里，可以理解為指針。局部變量不能夠被訪問控制符及修飾都可以被修飾變量的傳遞與語言相似調(diào)用對象方法時要傳遞參數(shù)。內(nèi)部類內(nèi)部類是所在類的成員。大體上相當(dāng)于其他語言的匿名函數(shù)或函數(shù)指針。

基本類型(primitive type):其值直接存于變量中。“在這里”

引用型(reference type) 的變量除占據(jù)一定的內(nèi)存空間外,它所引用的對象實體(由new 創(chuàng)建)也要占據(jù)一定空間。“在那里”，可以理解為指針。

MyDate m,n;
m=new MyDate();
n=m;

m和n都指向同一個對象，兩者都可以理解為一個指針。通過m和n都可以操縱同一個對象。

字段變量(Field)：又稱成員變量（member variable），域變量，在類中；上圖的latitude和longitude都是字段變量。

局部變量(Local variable)：又稱本地變量（local variable），在方法中定義的變量或方法的參變量。上圖的args和lima以及latIn和lonIn都是局部變量。

Memory Model的建立流程如下所示

上圖首先在堆中新建SimpleLocation類的對象，該對象擁有兩個變量latitude和longtiude-->>

上圖展示調(diào)用函數(shù)SimpleLocation(double latIn,double lonIn)期間，內(nèi)存中新建了臨時空間，如圖中constructor"s scope所示。-->>

如上所示，局部（臨時）變量laiIn，lonIn將值傳遞給SimpleLocation類的對象latitude和longtiude后，則對象的建立成功。該函數(shù)調(diào)用結(jié)束后，局部變量latIn和lonIn以及this會在內(nèi)存中消失。該構(gòu)造器（constructor） 先返回對象的地址（指針）給 lima 變量，然后消失。最終，lima將指向新對象。

生命周期：Field 是在隨著對象的創(chuàng)建，產(chǎn)生的在堆（The heap）中；Local variable 是隨著方法的調(diào)用期間按需生成相應(yīng)的內(nèi)存空間。
初始值：Filed 編譯器會自動賦初值，Local variable 需要顯式賦值，否則編譯無法通過；

字段變量屬于類,可以用public,private,static,final 修飾。

局部變量不能夠被訪問控制符及static修飾

都可以被final修飾

調(diào)用對象方法時,要傳遞參數(shù)。

在傳遞參數(shù)時,Java 是值傳遞,即,是將表達式的值復(fù)制給形式參數(shù)。

對于引用型變量,傳遞的值是引用值,而不是復(fù)制對象實體，可以改變對象的屬性。

返回基本類型。

返回引用類型。它就可以存取對象實體。

Object getNewObject() {
Object obj=new Object();
return obj; }

調(diào)用時:

Object p= GetNewObject();

是指一個程序中相同的名字表示不同的含義的情況。

重載(overload) (多個同名的不同方法)。

p.sayHello();
p.sayHello(“Wang”);

覆蓋(override) (子類對父類方法進行覆蓋)

Polymorphism means that a variable of a supertype can refer to a subtype object.

動態(tài)綁定(dynamic binding) ----虛方法調(diào)用(virtual method invoking)

在調(diào)用方法時,程序會正確地調(diào)用子類對象的方法。

多態(tài)優(yōu)點：大大提高了程序的抽象程度和簡潔性。

public class DynamicBindingDemo {
    public static void main(String[] args){
        m(new GraduateStudent());//傳遞的是子類對象，編譯通過
        m(new Student());//同上!
        m(new Person());//同上！
        m(new Object());
    }
    public static void m(Object x){
        System.out.println(x.toString());
    }
}
class GraduateStudent extends Student{
}
class Student extends Person{
    public String toString(){
        return "student";
    }
}
class Person{
    public String toString(){
        return "Person";
    }
}

運行結(jié)果：

student
student
Person
java.lang.Object@60e53b93

從以上測試代碼看來，雖然 m(Object x)定義的形參是Object類的，但允許實際參數(shù)傳遞子類對象：m(new GraduateStudent());，編譯通過。
另外：在類繼承關(guān)系鏈中，對同一個方法可能對應(yīng)有多個實現(xiàn)，但在運行時由JVM自動搜索綁定哪個實現(xiàn)。動態(tài)綁定流程：從最近的類（最低，最具體）找，直到 Object 類(最高，最抽象)。只要找到了實現(xiàn)方法就停止。比如現(xiàn)在GraduateStudent類中找，沒找到，就在Student類中找，結(jié)果找到了，就停止該搜索。
這里需要注意區(qū)別構(gòu)造函數(shù)的執(zhí)行流程。

上溯造型(upcasting) :是把派生類型（subclass）當(dāng)作基本類型(upclass)處理.

It is always possible to cast an instance of a subclass to a variable of a superclass(knowns as upcasting) .

Person p = new Student();
void fun(Person p ){...}

在這里，雖然P的聲明類型是Person，但它的實際類型是Student，Student是Person的子類。在被fun（Person p）調(diào)用時，仍可以casting。這也是動態(tài)綁定的范疇。

m(new Student());
//等價于
Object o = new Student();
m(o);

現(xiàn)在假設(shè)，要將o分配給一個Student類的變量，該如何做？
方法1

Student b = o;//編譯報錯，因為在編譯器看來，o是一個Object類的變量，并不一定是個Student類的變量

方法2

Student b = (Student)o;//這其實是downcasting了，把一個Object類的對象向下映射為Student類的，編譯通過。但是前提是得確保o變量的真實類型是Student類的，否則會拋出ClasCastException錯誤。

子類重載了父類方法時，運行時系統(tǒng)根據(jù)調(diào)用該方法的真實類型（actual type）來決定選擇哪個方法調(diào)用

所有的非final方法都會自動地進行動態(tài)綁定

instanceof 是 java 的關(guān)鍵字。

用變量 instanceof 來判斷一個對象的真實類型（actual type）。

結(jié)果是boolean 值

Object myObject = new Circle();
if(myObject instanceof Circle){
    System.out.println("The circle diameter is " + ((Circle)myObject).getDiameter());
}

在Object myObject = new Circle();新增一個Object類的myObject變量，但是，myObject的真實類型（actual type）是Circle()類型，所以myObject instanceof Circle 返回True。

編譯時，myObject 的聲明類型是Object，便于編譯器決定采用哪個方法，比如myObject.getDiameter()將會引起編譯錯誤，所以要類型轉(zhuǎn)換 (Circle)myObject。

將一個變量聲明為父類類型，是為了更好地抽象編程（generic programming），這樣myObject能夠接受任何子類對象

Java中,普通的方法是虛方法

但static,private方法不是虛方法調(diào)用

static的方法(從名字看，是靜態(tài)，與動態(tài)綁定相對),以聲明的類型為準(zhǔn),與實例類型無關(guān)

private方法子類看不見,也不會被虛化

final方法子類不能覆蓋,不存在虛化問題

public class InvokeStaticMethod {
/*調(diào)用靜態(tài)方法來
*/
    public static void main(String[] args){
        Circle c = new Circle();
        Shape s = new Shape();
        Shape d = new Circle();
        
        doSomething(c);
        doSomething(s);
        doSomething(d);

        doSomethingVer2(c);
        doSomethingVer2((Circle)d);//必須強制類型轉(zhuǎn)換為Circle（）
    }
    static void doSomething(Shape s){//注意該方法聲明為靜態(tài)，非虛調(diào)用，參量的聲明類型是Shape，所以只能匹配到Shape類型的參數(shù)。
        s.draw();
    }
    static void doSomethingVer2(Circle s){//注意該方法聲明為靜態(tài)，形參只能匹配到Circle類型的參數(shù)；
        s.draw();
    }
}
class Shape {
    static void draw(){
        System.out.println("draw shape");
    }
}
class Circle extends Shape{
    static void draw(){
        System.out.println("draw circle");

    }
}

輸出結(jié)果：

draw shape
draw shape
draw shape
draw circle
draw circle

對象都有構(gòu)造方法

如果沒有,編譯器加一個default構(gòu)造方法

類的成員變量和方法是可以繼承的，但是類的構(gòu)造器是不能繼承的。只能通過調(diào)用，又分為顯式調(diào)用和隱式調(diào)用。

this調(diào)用本類的其他構(gòu)造方法。

super調(diào)用直接父類的構(gòu)造方法

this或super要放在第一條語句,且只能夠有一條

如果既不是調(diào)用this，也不是調(diào)用super方法，則編譯器會自動加上super()，也就是調(diào)用直接父類的無參方法。

可以看出，原則上必須令所有父類的構(gòu)造方法都得到調(diào)用，否則對象的構(gòu)建就不成功。

In any case, constructing an instance of a class invokes the constructors of all the superclasses along the inheritance chain.  This is called constructor chaining.
--Introduction to Java Programming

調(diào)用本類或父類的構(gòu)造方法,直至最高一層(Object)

按照聲明順序執(zhí)行字段的初始化賦值

執(zhí)行構(gòu)造函數(shù)中的各語句。

簡單地說: 先父類構(gòu)造,再本類成員賦值,最后執(zhí)行構(gòu)造方法中的語句。

p = new NoConstructorTest(){{ a="A"; b="B"; }};

這樣可以針對沒有相應(yīng)構(gòu)造函數(shù)但又要賦值。

注意雙括號。

public class NoConstructorTest {
    String a;
    String b;
    //no constructors
    public static void main(String[] args){
        NoConstructorTest p = new NoConstructorTest(){{ a="A"; b="B"; }};
        System.out.println("the instance can be given value without defining constructor.
a is:
"+p.a+"
b is: 
"+p.b);
    }
}

輸出結(jié)果

the instance can be given value without defining constructor.
a is:
A
b is: 
B

可見，該對象的初始化是成功的。

內(nèi)部類( inner class )是在所在類中的特殊成員

匿名類( anonymous class)是一種特殊的內(nèi)部類,它沒有類名。

內(nèi)部類是所在類的成員。

編譯器生成xxxx$xxxx這樣的class文件

內(nèi)部類不能夠與外部類同名

優(yōu)點是：在某些程序中，使用內(nèi)部類來簡化程序（比如減少source file的個數(shù)）；內(nèi)部類可以引用所在外部類的屬性和方法。

在封裝它的類的內(nèi)部使用內(nèi)部類,與普通類的使用方式相同。

在其他地方使用類名前要冠以外部類的名字。在用new創(chuàng)建內(nèi)部類實例時,也要在 new 前面冠以對象變量，可以用 外部對象名.new 內(nèi)部類名(參數(shù)) 。

內(nèi)部類中可以直接訪問外部類的字段及方法。即使private也可以，因為內(nèi)部類本質(zhì)上也是一個類成員。

如果內(nèi)部類中有與外部類同名的字段或方法,則可以用 外部類名.this.字段及方法。

class A {
    private int s=3;
    public class B{
        private int s=2;
        public void mb(int s){
            System.out.println(s);
            System.out.println(this.s);
            System.out.println(A.this.s);
        }
    }
}

內(nèi)部類與類中的字段、方法一樣是外部類的成員,它的前面也可以有 訪問控制符和其他修飾符。

訪問控制符:public , protected,默認(rèn)及private。 注:外部類只能夠使用public修飾或者默認(rèn)

final , abstract。

用static修飾的內(nèi)部類，實際上是一種外部類。

因為它與外部類的實例無關(guān)

實例化static類時,在 new前面不需要用對象實例變量;

static類中不能訪問其外部類的非static的字段及方法,既只能夠訪問static成員。

static方法中不能訪問非static的域及方法,也不能夠不帶前綴地new 一個非
static的內(nèi)部類。

在一個方法中也可以定義類,這種類稱為”方法中的內(nèi)部類” ，或者叫局部類(local class)

同局部變量一樣,方法中的內(nèi)部類，不能夠被public ， private，protected ， static 修飾, 但可以被 final 或者 abstract 修飾。

可以訪問其外部類的成員

不能夠訪問該方法的局部變量,除非是final局部變量

匿名類( anonymous class)是一種特殊的內(nèi)部類

它沒有類名,在定義類的同時就生成該對象的一個實例

“一次性使用”的類

不取名字,直接用其父類或接口的名字。

也就是說,該類是父類的子類,或者實現(xiàn)了一個接口

編譯器生成 xxxxx$1之類的名字，其中1表示第一個匿名類。

類的定義的同時就創(chuàng)建實例,即類的定義前面有一個new

new 類名或接口名(){......}

不使用關(guān)鍵詞class,也不使用extends及implements。

在構(gòu)造對象時使用父類構(gòu)造方法

不能夠定義構(gòu)造方法,因為它沒有名字

如果new對象時,要帶參數(shù),則使用父類的構(gòu)造方法

        import javafx.application.Application;
        import javafx.event.ActionEvent;
        import javafx.event.EventHandler;
        import javafx.geometry.Pos;
        import javafx.scene.Scene;
        import javafx.scene.control.Button;
        import javafx.scene.layout.BorderPane;
        import javafx.scene.layout.HBox;
        import javafx.scene.layout.Pane;
        import javafx.scene.text.Text;
        import javafx.stage.Stage;

public class AnonymousHandlerDemo extends Application {
    @Override // Override the start method in the Application class
    public void start(Stage primaryStage) {
        Text text = new Text(40, 40, "Programming is fun");
        Pane pane = new Pane(text);

        // Hold four buttons in an HBox
        Button btUp = new Button("Up");
        Button btDown = new Button("Down");
        Button btLeft = new Button("Left");
        
        HBox hBox = new HBox(btUp, btDown , btLeft);
        hBox.setSpacing(10);
        hBox.setAlignment(Pos.CENTER);

        BorderPane borderPane = new BorderPane(pane);
        borderPane.setBottom(hBox);

        //在方法中定義的內(nèi)部類稱為 局部類（local class)
        //可以引用方法中的變量, 比如text
        class EnableEventHandler
                implements EventHandler{
            public void handle(ActionEvent e) {
                text.setY(text.getY() > 10 ? text.getY() - 5 : 10);
            }
        }
        //注意:必須先定義了類,才能使用.
        //否則編譯器會找不到這個類而報錯.
        btUp.setOnAction(
                new EnableEventHandler());

        //對比上面，非匿名類
        //下面開始使用匿名類
        btDown.setOnAction(new EventHandler() {
            @Override // Override the handle method
            public void handle(ActionEvent e) {
                text.setY(text.getY() < pane.getHeight() ?
                        text.getY() + 5 : pane.getHeight());
            }
        });
        
        //可見,使用匿名類的好處是:精簡了先定義類,后使用類這一過程.
        //匿名類的使用是「一次性」的。
        
        //進一步簡化,采用Lambda表達式
        btLeft.setOnAction(e -> {
            //但得遵循SAM原則
            text.setX(text.getX() > 0 ? text.getX() - 5 : 0);
        });
        
        // Create a scene and place it in the stage
        Scene scene = new Scene(borderPane, 400, 350);
        primaryStage.setTitle("AnonymousHandlerDemo"); // Set title
        primaryStage.setScene(scene); // Place the scene in the stage
        primaryStage.show(); // Display the stage
    }
    /**
     * The main method is only needed for the IDE with limited
     * JavaFX support. Not needed for running from the command line.
     */
    public static void main(String[] args) {
        launch(args);
    }
}

運行截圖

Lambda表達式是從Java8增加的新語法

Lambda表達式(λ expression)的基本寫法

(參數(shù))->結(jié)果

比如：(String s) -> s.length()將會返回s的長度

x->x*x將會返回x*x的運算結(jié)果，參數(shù)的類型都省略了。

大體上相當(dāng)于其他語言的“匿名函數(shù)”或“函數(shù)指針” 。

在Java中它實際上是“ 匿名類的一個實例”，即是定義后馬上使用，更加簡潔和高效。

A dolt = new A(){
    public void run(){
        System.out.println("OK");
    }
}

寫成Lamdba表達式：

() -> { System.out.println(“OK”); }

A dolt = new A(){
    public double run(double x){
        return Math.sin(x);
    }
}

以上寫成Lambda表達式：

(x) -> Math.sin(x);

btn.addActionListener( e -> ... } ) );//編譯器能夠自動識別e為ActionEvent類。

以上三個例子說明：Lambda表達式是接口或者說是接口函數(shù)的簡寫，基本寫法是 (參數(shù))->結(jié)果，這里,參數(shù)是()或(1個參數(shù))或 (多個參數(shù))，結(jié)果是指 表達式 或 語句 或 {語句}

由于Lambda只能表示一個函數(shù),所以

能寫成Lambda的接口要求包含且最多只能有一個抽象函數(shù)

這樣的接口可以用注記(但不強求)@FunctionalInterface來表示。稱為函數(shù)式接口，用于對編譯器的提示:

@FunctionalInterface
interface A { double A( double x );}

Comparator compareAge = (p1, p2) -> p1.age-p2.age;
Arrays.sort(people, compareAge);

Lambda表達式,不僅僅是簡寫了代碼, 更重要的是:它將代碼也當(dāng)成數(shù)據(jù)來處理。

從JDK1.5起,增加了一些新的語法
大部分是編譯器自動翻譯的,稱為Complier sugar。

基本類型并不是對象，但通過使用Java API的包裝類能夠把基本類型包裝成對象，從而方便某些方法的調(diào)用需求。

它將基本類型(primitive type) 包裝成Object(引用類型)

Java的八種包裝類（wrapper class）如下：
Boolean, Byte, Short, Character, Integer, Long, Float, Double

注：包裝類的名稱首字母亦是大寫。

裝箱(Boxing)

Integer I = new Integer(10);

或簡寫為

Integer I = 10;//編譯器自動將基本類型包裝為`Integer`對象

拆箱(Unboxing)

int i = I;

上述過程，被編譯器譯為:

Integer I= Integer.valueOf(10);
int i = I.intValue();

枚舉(enum)是一種特殊的class類型

在簡單的情況下,用法與其他語言的enum相似

enum Light { Red, Yellow, Green };
Light light = Light.Red;

但實際上，編譯后，它生成了 class Light extendsjava.lang.Enum，所以可以在enum定義體中,添加字段、方法、構(gòu)造方法，可以當(dāng)做一般的class，更加靈活。

enum Direction{
    EAST("東",1), SOUTH("南",2),
    WEST("西",3), NORTH("北",4);
    private Direction(String desc, int num){//允許添加構(gòu)造方法
    this.desc=desc; this.num=num; 
    }
    private String desc;
    private int num;
    public String getDesc(){ //允許添加一般方法
    return desc; 
    } 
    public int getNum(){ //允許添加一般方法
    return num; 
    }
}

又稱為注記、標(biāo)記、標(biāo)注、注釋(不同于comments)
是在各種語法要素上加上附加信息,以供編譯器或其他程序使用
所有的注解都是 java.lang.annotation.Annotation 的子類
常用的注解,如

@Override

@Deprecated 表示過時的方法

@SuppressWarnings 表示讓編譯器不產(chǎn)生警告

自定義注解,這個很少見啦。

public @interface Author {
    String name();
}

引用(reference)實質(zhì)就是指針(pointer)，但在Java中，引用是安全的指針。

Java標(biāo)榜其中對C/C++一個很大的改進就是：Java對程序員屏蔽了變量地址的概念，減少指針誤用。

比如:

會檢查空指引

沒有指針運算 *(p+5)

不能訪問沒有引用到的內(nèi)存

自動回收垃圾

Java引用類型（reference type）,引用本身就相當(dāng)于指針，可以用來修改對象的屬性、調(diào)用對象的方法。
如交換兩個整數(shù)，在C語言中：

void swap(int x, int y){ 
    int t=x; 
    x=y;
    y=t; 
} 
int a=8, b=9; 
swap(&a,&b);

在Java中，無法實現(xiàn)該交換。但可以使用一種變通的辦法,傳出一個有兩個分量x,y的對象。
變通辦法，但顯得很笨：

class Test{
    public static void swap2(final int [] arr, final int pos1, final int pos2){
        final int temp = arr[pos1];
        arr[pos1] = arr[pos2];
        arr[pos2] = temp;
    }
    public static void main(String [] args){
        int [] a ={1,2};
        swap2(a,0,1);
        System.out.println(a[0]+" "+a[1]);
    }
}

運行結(jié)果：

2 1

在C中的指針*(p+5) ，在Java中則可以用 args[5]

例如上述:求積分、線程、回調(diào)函數(shù)、事件處理。

在鏈表中有該類：

class Node {
    Object data;
    Node next; 
}

next就是一個指向?qū)ο蟮闹羔槨?/p> 5. 使用JNI

Java Native Interface(JNI) ，它允許Java代碼和其他語言寫的代碼進行交互。