国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

java5-8新特性的理解

Jinkey / 613人閱讀

摘要：引用特定類型的方法特定類普通方法引用構造方法類名稱引用構造方法內建函數式接口方法引用操作可能出現的函數式接口有四類有參數有返回值有參數無返回值無參數有返回值判斷真假。

可變參數

在java程序中調用方法時，必須嚴格按照方法定義的變量進行參數傳遞。但是在開發過程中可能會出現一種情況：不確定要傳遞的參數個數。解決這個問題的思路是將多個參數封裝為數組。這是一個打折扣的方法，因為數組并不代表任意多個數據。

在JDK1.5中，引入了可變參數的概念。可變參數的語法形式為:

[public/protected/private] [static/final/abstract] 返回值類型 func(參數類型 ... 變量){
    [return [返回值] ;]
}

參數變量傳遞到方法中，以指定類型的數組進行保存。

public class varargs{
    public static void main(String args[]){
        System.out.println(add(1,2,3));
        System.out.println(add(10,20));
    }
    public static int add(int ... data){
        int sum = 0;
        for(int i = 0; i < data.length; i++){
            sum += data[i];
        }
        return sum;
    }
}
foreach循環

java中的foreach語句是一種加強型for循環操作。for循環的輸出方式需要控制索引，過于麻煩。因此，在JDK1.5中引入foreach形式。

for(數據類型 變量:數組/集合){
    //每一次循環，會將數組內容賦值個變量
}

每次循環自動將數組或集合的內容取出，避免了索引問題。

public class foreach{
    public static void main(String args[]){
        int data[] = new int[]{1,2,3,4,5};
        for(int x : data){
            System.out.println(x + " ");
        }
    }
靜態導入

如果一個類中的方法全部屬于static型方法，其他類在引用此類時，必須先使用import導入所需要的包。然后使用“類名.方法()”進行調用。
如果在調用這些方法時不希望出現類的名稱，JDK1.5引入靜態導入功能。

import static 包.類.*;
package com.qi.demo;
public class myMath{
    public static int div(int x, int y) throws Exception{
        System.out.println("===start===");
        int result = 0;
        try{
            result = x / y;
        }catch(Exception e){
            throw e;
        }finally{
            System.out.println("===end===");
        }
        return result;
    }
    public static int add(int x, int y){
        return x + y;
    }
}
import static com.qi.demo.myMath.*;
public class static_import{
    public static void main(String args[]){
        System.out.println("Add operation:" + add(10,20));
        try{
            System.out.println("divide operation: " + div(10,2));
        }catch(Exception e){
            e.printStackTrace();
        }
        
    }
}

靜態導入可以減少代碼量，但是過多的靜態導入會降低代碼的可讀性。

泛型

JDk5提供泛型技術。類屬性或方法的參數在定義數據類型時，可以直接使用一個標記進行占位，再具體使用時才設置其對應的實際數據類型。這樣當設置的數據類型出現錯誤后，就可以在程序編譯時檢測出來。使用泛型時，能夠采用的類型只能是類，也就是說不能是基本類型，只能是引用類型。例如泛型采用整型，應用Integer，而不是int。

class Point{
    private T x;
    private T y;
    public void setX(T x){
        this.x = x;
    }
    public void setY(T y){
        this.y = y;
    }
    public T getX(){
        return x;
    }
    public T getY(){
        return y;
    }
}
public class generic{
    public static void main(String args[]){
        Point p = new Point<>();
        p.setX(10);
        p.setY(20);
        Integer x = p.getX();
        Integer y = p.getY();
        System.out.println("coordinate x: " + x + " y: " +y);
    }
}
通配符

對于同一類，由于設置泛型類型不同，其對象表示的含義也不同，因此不能夠直接進行引用操作。例如通過泛型定義Message，Message和Message雖然都是Message類的對象，但這兩個對象不能夠直接進行引用傳遞操作。通過使用通配符“？”解決參數傳遞問題。通配符可以接受類對象，但是不能修改對象屬性。

class Message{
    private T msg;
    public void setMsg(T msg){
        this.msg = msg;
    }
    public T getMsg(){
        return msg;
    }
}
public class generic_wildcard{
    public static void main(String args[]){
        Message m1 = new Message<>();
        Message m2 = new Message<>();
        m1.setMsg(100);
        m2.setMsg("hello");
        fun(m1);
        fun(m2);
    }
    public static void fun(Message temp){
        System.out.println(temp.getMsg());
    }
}

在“？”通配符的基礎上還有兩個子通配符。

? extends 類

設置泛型上限，在聲明和方法中使用。表示可以設置該類或其子類。

? super 類

設置泛型下限，在方法中使用。表示只能設置該類或其父類。

泛型接口

泛型可以定義在接口上。使用接口必須定義相應子類。對于使用泛型的接口，有兩種實現方式。一是在子類繼續設置泛型標記。二是在子類中為父類接口明確定義一個泛型類型。

泛型方法

泛型也可以在方法中定義。在方法中定義泛型時，方法不一定要在泛型類中定義，但要在方法返回值類型前明確定義泛型類型。

Annotation

JDK1.5提出并應用了注解技術。在java SE中，最常見的Annotation是：

@Override

準確覆寫操作。保證子類覆寫的方法是父類中定義過的方法。當覆寫方法出現錯誤時，可以在編譯時檢查出來。

@Deprecated

聲明過期操作。用于聲明過期不建議使用的方法。

@SuppressWarnings

壓制警告。開發者明確知道會出現警告信息卻執意按照固定方式處理，可以使用@SuppressWarnings壓制出現的警告信息。

class Book{
    private T title;
    public void setTitle(T title){
        this.title = title;
    }
    public T getTitle(){
        return title;
    }
}
public class annotation_suppresswarnings{
    @SuppressWarnings({"rawtypes", "unchecked"})
    public static void main(String args[]){
        Book book = new Book();
        book.setTitle("hello");
        System.out.println(book.getTitle());
    }
}
接口定義加強

JDK1.8開始，接口中可以定義普通方法與靜態方法。java增加這個特性原因如下。隨著接口的子類越來越多，如果這個接口功能不足，需要增加新的方法，則需要對所有接口子類覆寫新增加的方法。這個設計的工作量是重復的且是巨大的，因此通過放寬接口定義，接口可以定義普通方法和靜態方法，接口的方法擴充問題就能得到很好的解決。
在接口中定義普通方法，該方法必須使用default來進行定義。使用default定義的普通方法，需要利用實例化對象明確調用。在接口中定義靜態方法，該方法可以由接口名稱直接調用。

lambda表達式

JDK1.8中引入lambda表達式。lambda表達式是應用在單一抽象方法接口環境下的一種簡化定義形式，解決匿名內部類定義復雜問題。單一抽象方法接口使用@FunctionalInterface注解，表示此為函數式接口，里面只允許定義一個抽象方法。lambda表達式有三種形式。

(params) -> expression
(params) -> statement
(params) -> {statements}
@FunctionalInterface
interface IMessage{
    public int add(int ... args);
    static int sum(int ... args){
        int sum = 0;
        for(int temp:args){
            sum += temp;
        }
        return sum;
    }
}
public class lambda{
    public static void main(String args[]){
        //()內是參數，->后是子類覆寫抽象方法的方法體
        fun((int ... param) -> IMessage.sum(param));
    }
    public static void fun(IMessage msg){
        System.out.println(msg.add(10,20,30));
    }
}
方法引用

JDK1.8支持方法的引用操作，相當于為方法定義別名。java8定義了四種方法引用操作形式。

引用靜態方法

類名稱::static方法名稱

interface Imessage{
    public R change(P p);
}
public class method_reference_static{
    public static void main(String args[]){
        //將String.valueOf()方法變為IMessage接口的change()方法
        //valueOf()方法接收int型數據，返回String型數據
        Imessage msg = String::valueOf;
        String str = msg.change(1000);
        System.out.println(str.replaceAll("0","9"));
    }
}

引用某個對象的方法

實例化對象::普通方法

@FunctionalInterface
interface IMessage{
    public R upper();
}
public class method_reference_common{
    public static void main(String args[]){
        //String類的toUpperCase()定義：public String toUpperCase()。
        //該方法沒有參數，有返回值。
        IMessage msg = "hello"::toUpperCase;
        String str = msg.upper();
        System.out.println(str);
    }
}

引用特定類型的方法

特定類::普通方法

@FunctionalInterface
interface IMessage
{
    public int compare(P p1, P p2);
}
public class method_reference_special{
    public static void main(String args[]){
        IMessage msg = String::compareTo;
        System.out.println(msg.compare("A","B"));
    }
}

引用構造方法

類名稱::new

@FunctionalInterface
interface IMessage{
    public C create(String t, double p);
}
class Book{
    private String title;
    private double price;
    public Book(String title, double price){
        this.title = title;
        this.price = price;
    }
    @Override
    public String toString(){
        return "book: " + this.title + ", price: " + this.price;
    }
}
public class metheod_reference_constructor{
    public static void main(String args[]){
        IMessage msg = Book::new; //引用構造方法
        Book book = msg.create("JAVA", 100);
        System.out.println(book);
    }
}
內建函數式接口

方法引用操作可能出現的函數式接口有四類：有參數有返回值、有參數無返回值、無參數有返回值、判斷真假。JDK1.8提供了一個新的開發包：

java.util.function

該開發包提供四個核心函數式接口，簡化開發者的定義，實現操作的統一。
1、功能型接口

@FunctionalInterface
public interface Function{
    public R apply(T t); //接收**一個**參數，并返回一個處理結果
}
import java.util.function.Function;
public class funcifc_function{
    public static void main(String args[]){
        Function fun = "##hello"::startsWith; //利用對象調用startsWith()
        System.out.println(fun.apply("##"));
    }
}

注意引用的方法只能有一個輸入和一個返回結果。否則，引用方法不能與apply()匹配。
2、消費型接口

@FunctionalInterface
public interface Comsumer{
    public void accept(T t); //只接收數據，不返回結果
}
import java.util.function.Consumer;
public class funcifc_consumer{
    public static void main(String[] args){
        Consumer cons = System.out::print;
        cons.accept("hello world");
    }
}

3、供給型接口

@FunctionalInterface
public interface Supplier{
    public T get(); //不接收數據，只返回結果   
}
import java.util.function.Supplier;
public class funcifc_supplier{
    public static void main(String args[]){
        Supplier sup = "hello"::toUpperCase;
        System.out.println(sup.get());
    }
}

4、斷言型接口

@FunctionalInterface
public intereface Predicate{
    public boolean test(T t); //判斷
}
import java.util.function.Predicate;
public class funcifc_predicate{
    public static void main(String args[]){
        Predicate pre = "hello"::equalsIgnoreCase;
        System.out.println(pre.test("HELLO"));
    }
}

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://m.specialneedsforspecialkids.com/yun/76937.html

相關文章

  • 讀《javaScript高級程序設計－第6章》之理解對象

    摘要：把對象定義為無序屬性的集合，其屬性可以包含基本值對象或函數。接受兩個參數屬性所在的對象和要讀取其特性的屬性名返回的時其特性的對象例如讀高級程序設計這本書的第章面向對象的程序設計，我做了篇筆記。這是第一篇，后面還有兩篇，分別是封裝類和繼承。 ECMA－262把對象定義為：無序屬性的集合，其屬性可以包含基本值、對象或函數。所以，我們可以理解對象就是名值對的集合，名就是對象的每個屬性的名字，...

    KoreyLee 評論0 收藏0

  • Javascript面向對象的程序設計_理解對象

    摘要：面向對象的程序設計理解對象前言最近在細讀高級程序設計，對于我而言，中文版，書中很多地方翻譯的差強人意，所以用自己所理解的，嘗試解讀下。總結如果英語水平足夠好的話，建議看英文原版書籍或者國外大師的博客。 JS面向對象的程序設計_理解對象 前言：最近在細讀Javascript高級程序設計，對于我而言，中文版，書中很多地方翻譯的差強人意，所以用自己所理解的，嘗試解讀下。 如有紕漏或錯誤，會非...

    劉厚水 評論0 收藏0

  • 理解Object.defineProperty的作用

    摘要：對象是由多個名值對組成的無序的集合。對象中每個屬性對應任意類型的值。目標屬性所擁有的特性返回值傳入函數的對象。給對象的屬性添加特性描述，目前提供兩種形式數據描述和存取器描述。兼容性在下只能在對象上使用，嘗試在原生的對象使用會報錯。 對象是由多個名/值對組成的無序的集合。對象中每個屬性對應任意類型的值。定義對象可以使用構造函數或字面量的形式： var obj = new Object; ...

    yexiaobai 評論0 收藏0

  • 尋找一種易于理解的一致性算法（擴展版）

    摘要：摘要是一種為了管理復制日志的一致性算法。接下來，這篇論文會介紹以下內容復制狀態機問題第節，討論的優點和缺點第節，討論我們為了可理解性而采取的方法第節，闡述一致性算法第節，評價算法第節，以及一些相關的工作第節。 摘要 Raft 是一種為了管理復制日志的一致性算法。它提供了和 Paxos 算法相同的功能和性能，但是它的算法結構和 Paxos 不同，使得 Raft 算法更加容易理解并且更容易...

    FuisonDesign 評論0 收藏0

發表評論

0條評論

Jinkey

男|高級講師

TA的文章

閱讀更多
最新活動
閱讀需要支付1元查看
<