接口 & 多態 & 類型強制轉換 & 內部類 & 內部匿名類 & 異常

一個類最多只能有一個直接的父類, 但是有多個間接的父類, java是單繼承

接口概述

接口：拓展功能, 類似于: usb接口(可以連接外設等, 拓展功能)
接口的定義格式：

interface 接口名{
    
}

接口要注意的事項：
1. 接口是一個特殊的類
2. 接口的成員變量默認的修飾符為 : public static final, 也就是說接口中的成員變量都是常量
3. 接口中的方法都是抽象的方法，默認的修飾符為 : public abstract
4. 接口不能創建對象
5. 接口是沒有構造方法的
6. 接口是給類去實現使用的，非抽象類實現一個接口的時候，必須要把接口中所有方法全部實現

實現接口的格式：

    class  類名 implements 接口名{
    
    }

interface A{

    //成員變量
    public static final int i=10;
    //成員函數
    public void print();
}


class Demo  implements A{ // Demo就實現了A接口
    public static void main(String[] args) 
    {
        Demo7 d = new Demo7();
        d.print();
    }
    //實現接口中的方法
    public void print(){
        System.out.println("這個是接口中的print方法...");
    }
}

接口的作用：

程序的解耦 ( 低耦合 )
定義約束規范
拓展功能

//普通的鉛筆類
class Pencil{
    
    String name;
    public Pencil(String name){
        this.name = name;
    }

    public void write(){
        System.out.println(name+"沙沙的寫...");
    }
}

//橡皮接口
interface Eraser{
    public void remove();
}

//帶橡皮的鉛筆
class PencilWithEraser extends Pencil implements Eraser {

    public PencilWithEraser(String name){
        super(name);
    }
    public void remove(){
        System.out.println("涂改,涂改....");
    }
}

class Demo{
    public static void main(String[] args) {
        //System.out.println("Hello World!");
    
        PencilWithEraser p = new PencilWithEraser("2B鉛筆");
        p.write();
        p.remove();
    }
}

類與接口之間關系 : 實現關系

類與接口要注意的事項：
1. 非抽象類實現一個接口時，必須要把接口中所有方法全部實現
2. 抽象類實現一個接口時，可以實現也可以不實現接口中的方法
3. 一個類可以實現多個接口
  疑問： java為什么不支持多繼承，而支持了多實現呢？

            class A{
                
                public void print(){
                    System.out.println("AAAAAA");
                }
            }

            class B{

                public void print(){
                    System.out.println("BBBBBB");
                }
            }


            class C extends A ,B{
            
            }
            
            new C().print();

接口與接口之間關系：繼承關系
接口與接口之間要注意事項：
1. 一個接口是可以繼承多個接口的

多態

面向對象的三大特征：
1. 封裝
2. 繼承
3. 多態
多態：一個對象具備多種形態。(父類的引用類型變量指向了子類的對象)或者是接口的引用類型變量指向了接口實現類的對象)
多態的前提：必須存在繼承或者實現關系
動物 a = new 狗();
多態要注意的細節：
1. 多態情況下，子父類存在同名的成員變量時，訪問的是父類的成員變量
2. 多態情況下，子父類存在同名的非靜態的成員函數時，訪問的是子類的成員函數
3. 多態情況下，子父類存在同名的靜態的成員函數時，訪問的是父類的成員函數
4. 多態情況下，不能訪問子類特有的成員
  總結：多態情況下，子父類存在同名的成員時，訪問的都是父類的成員，除了在同名非靜態函數時才是訪問子類的
編譯看左邊，運行不一定看右邊
編譯看左邊：java編譯器在編譯的時候，會檢查引用類型變量所屬的類是否具備指定的成員，如果不具備馬上編譯報錯
多態的應用：
1. 多態用于形參類型的時候，可以接收更多類型的數據
2. 多態用于返回值類型的時候，可以返回更多類型的數據
多態的好處：提高了代碼的拓展性

類型強制轉換

目前多態情況下不能訪問子類特有的成員, 如果需要訪問子類特有的成員，那么需要進行類型強制轉換
基本數據類型的轉換
小數據類型-------->大的數據類型 ( 自動類型轉換 )
大數據類型--------->小數據類型 ( 強制類型轉換 ) 小數據類型變量名 = （小數據類型）大數據類型

引用數據類型的轉換
小數據類型--------->大數據類型自動類型轉換
大數據類型--------->小數據類型強制類型轉換
類型轉換最場景的問題： java.lang.ClassCastException。強制類型轉換失敗

//動物類
abstract class Animal{
    String name;
    public Animal(String name){
        this.name = name;
    }
    public abstract void run();
}

//老鼠
class  Mouse extends Animal{
    public Mouse(String name){
        super(name);
    }
    
    public  void run(){
        System.out.println(name+"四條腿慢慢的走!");
    }

    //老鼠特有方法---打洞
    public void dig(){
        System.out.println("老鼠在打洞..");
    }
}

//魚
class Fish extends Animal{
    public Fish(String name){
        super(name);
    }

    public  void run(){
        System.out.println(name+"搖搖尾巴游啊游 !");
    }
    //吹泡泡
    public void bubble(){
        System.out.println(name+"吹泡泡...!");
    }
}

class Demo
{
    public static void main(String[] args) 
    {
        /*
        Animal a = new Mouse("老鼠");  //多態
        //調用子類特有的方法
        Mouse m  = (Mouse)a;  //強制類型轉換
        m.dig();
        */

        Mouse m = new Mouse("米老鼠");
        Fish f = new Fish("草魚");
        print(f);
    }

    //需求： 定義一個函數可以接收任意類型的動物對象，在函數內部要調用到動物特有的方法
    public static void print(Animal a){ // Animal a   = new Mouse("米老鼠");
        if(a instanceof Fish){
            Fish f = (Fish)a;
            f.bubble();
        }else if(a instanceof Mouse){
            Mouse m = (Mouse)a;
            m.dig();
        }
    }
}

多態下的類型強制轉換

多態 : 父類的引用類型變量指向了子類的對象或者是接口類型的引用類型變量指向了接口實現類的對象
實現關系下的多態：
接口變量 = new 接口實現類的對象

interface Dao{  //接口的方法全部都是非靜態的方法。
    public void add();
    public void delete();
}

//接口的實現類
class UserDao implements Dao{
    
    public void add(){
        System.out.println("添加員工成功！！");
    }
    public void delete(){
        System.out.println("刪除員工成功！！");
    }
}

class Demo
{
    public static void main(String[] args) 
    {
        //實現關系下的多態
        Dao d = new UserDao(); //接口的引用類型變量指向了接口實現類的對象。
        d.add();
    }
}

內部類

內部類：一個類定義在另外一個類的內部，那么該類就稱作為內部類
內部類的class文件名：外部類$內部類. 好處：便于區分該class文件是屬于哪個外部類的
內部類的類別：
1. 成員內部類:
  成員內部類的訪問方式：
  方式一：在外部類提供一個方法創建內部類的對象進行訪問。
  方式二：在其他類直接創建內部類的對象。格式：外部類.內部類變量名 = new 外部類().new 內部類();
  注意：如果是一個靜態內部類，那么在其他類創建的格式 : 外部類.內部類變量名 = new 外部類.內部類();
內部類的應用場景：我們在描述A事物的時候，發現描述的A事物內部還存在另外一個比較復雜的事物B時候，而且這個比較復雜事物B還需要訪問A事物的屬性等數據，那么這時候我們就可以使用內部類描述B事物
比如：人--->心臟
class 人{
血
氧氣
等....
```
              class 心臟{

              }       
            }
```
內部類的好處：內部類可以直接訪問外部類的所有成員
內部類要注意的細節：
1. 如果外部類與內部類存在同名的成員變量時，在內部類中默認情況下是訪問內部類的成員變量, 可以通過"外部類.this.成員變量名" 指定訪問外部類的成員
2. 私有的成員內部類只能在外部類提供一個方法創建內部類的對象進行訪問，不能在其他類創建對象了
3. 成員內部類一旦出現了靜態的成員，那么該類也必須使用static修飾

//外部類
class Outer{
    
    //成員變量
    int x = 100; // Outer.class文件被加載到內存的時候存在內存中。  靜態的成員數據是不需要對象存在才能訪問。

    //成員內部類
    static  class  Inner{      

        static  int i = 10;
        public void print(){
            System.out.println("這個是成員內部類的print方法！"+i);
        }
    }

    //在外部的方法中創建了內部類的對象，然后調用內部 方法。
    public void instance(){
        Inner inner = new Inner();
        inner.print();
    }
}

//其他類
class Demo{
    public static void main(String[] args) {
        /*
        System.out.println(Outer.Inner.i);
        
        Outer outer = new Outer();
        outer.instance();
        
        Outer.Inner inner = new Outer().new Inner();
        inner.print();
        */

        Outer.Inner inner = new Outer.Inner();
        inner.print();
    }
}

局部內部類

局部內部類 : 在一個類的方法內部定義另外一個類，那么另外一個類就稱作為局部內部類
局部內部類要注意的細節：
1. 如果局部內部類訪問了一個局部變量，那么該局部變量必須使用final修飾

class  Outer{

    String name= "外部類的name";
    public void test(){
        //局部變量
        final   int y =100;  // y 什么時候從內存中消失？ 方法執行完畢之后y消失。

        //局部內部類
        class Inner{     /*
        當test方法執行完畢之后，那么y馬上從內存中消失，而Inner對象在方法執行完畢的時候還沒有從內存中消失，而inner對象的print方法還在訪問著y變量，這時候的y變量已經消失了，那么就給人感覺y的生命變量已經被延長了

        解決方案： 如果一個局部內部類訪問一個局部變量的時候，那么就讓該局部內部類訪問這個局部變量的復制品               
                      */
            int x = 10;

            public void print(){
                System.out.println("這個是局部內部類的print方法.."+y);
            }   
        }
        
        Inner inner = new Inner();  //這個inner對象什么時候消失？  Inner對象的生命周期比局部變量y的生命周期要長。
        inner.print();
    }
}

class Demo{
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.test();
    }
}

內部匿名類

匿名內部類：沒有類名的類就稱作為匿名內部類
匿名內部類的好處 : 簡化書寫
匿名內部類的使用前提：必須存在繼承或者實現關系才能使用
匿名內部類一般是用于實參

abstract class Animal{
    public abstract Animal run();
    public abstract void sleep();
}

class Outer{
    public void print(){
        //需求： 在方法內部定義一個類繼承Animal類，然后調用run方法與sleep()。
        
        /*
        //局部內部類
        class Dog extends Animal{
            
            public void run(){
                System.out.println("狗在跑..");
            }
            public void sleep(){
                System.out.println("狗趴在睜開眼睛睡..");
            }
        }
        
        //創建對象
        Dog d = new Dog();
        d.run();    
        d.sleep();
        */  
        //匿名內部類 ：匿名內部類只是沒有類名，其他的一概成員都是具備的。
        // 匿名內部類與Animal是繼承 的關系。  目前是創建Animal子類的對象. 
    Animal  a = new Animal(){  //多態
        
            //匿名內部的成員 
            public Animal run(){
                System.out.println("狗在跑..");
                return this;
            }
            
            public void sleep(){
                System.out.println("狗趴在睜開眼睛睡..");
            }

            //特有的方法
            public void bite(){
                System.out.println("狗在咬人..");
            }
        };
    
        a.bite();
        a.run();
        a.sleep();
    }
}

class Demo
{
    public static void main(String[] args) 
    {
        //System.out.println("Hello World!");
        
        Outer outer = new Outer();
        outer.print();
    }
}

異常

異常 : 我們的java程序也是會存在某些不正常的情況的，這些不正常的情況我們就統稱異常
異常的體系：
----------| Throwable 所以異常或者錯誤類的超類
--------------|Error 錯誤錯誤一般是用于jvm或者是硬件引發的問題，所以我們一般不會通過代碼去處理錯誤的
--------------|Exception 異常是需要通過代碼去處理的
Throwable常用的方法：
toString() 返回當前異常對象的完整類名+病態信息
getMessage() 返回的是創建Throwable傳入的字符串信息
printStackTrace() 打印異常的棧信息

class Demo
{
    public static void main(String[] args) 
    {
        /*
        //創建了一個Throwable對象。
        Throwable t = new Throwable("頭暈，感冒..");
        String info = t.toString();
        String message = t.getMessage();
        System.out.println("toString: "+ info);  // java.lang.Throwable  包名+類名 = 完整類名
        System.out.println("message: "+ message);
        */
        test();
    }

    public static void test(){
        //
        Throwable t = new Throwable();
        t.printStackTrace();
    }
}

如何區分錯誤與異常呢：
如果程序出現了不正常的信息，如果不正常的信息的類名是以Error結尾的，那么肯定是一個錯誤; 如果是以Exception結尾的，那么肯定就是一個異常

class Demo
{
    public static void main(String[] args) 
    {
        //java虛擬機在默認的情況下只能管理64m內存。
        byte[] buf = new byte[1024*1024];
        System.out.println("Hello World!");
    }
}

異常處理

疑問 : 下面的信息是通過printStackTrace方法打印出來，那么異常對象從何而來呢？
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Demo10.div(Demo10.java:10)
at Demo10.main(Demo10.java:5)
jvm運行到a/b這個語句的時候，發現b為0，除數為0在我們現實生活中是屬于不正常的情況，jvm一旦發現了這種不正常的情況時候，那么jvm就會馬上創建一個對應的異常對象，并且會調用這個異常對象的printStackTrace的方法來處理
異常的處理：
- 方式一：捕獲處理

捕獲處理的格式：
            try{
                可能發生異常的代碼；
            }catch(捕獲的異常類型 變量名){
                處理異常的代碼....
            }

  - 捕獲處理要注意的細節：
        1. 如果try塊中代碼出了異常經過了處理之后，那么try-catch塊外面的代碼可以正常執行
        2. 如果try塊中出了異常的代碼，那么在try塊中出現異常代碼后面的代碼是不會執行了
        3. 一個try塊后面是可以跟有多個catch塊的，也就是一個try塊可以捕獲多種異常的類型
        4. 一個try塊可以捕獲多種異常的類型,但是捕獲的異常類型必須從小到大進行捕獲，否則編譯報錯

- 方式二：拋出處理（throw throws）
  - 拋出處理要注意的細節：
        1. 如果一個方法的內部拋出了一個異常對象, 那么必須要在方法上聲明拋出
        2. 如果調用了一個聲明拋出異常 的方法, 那么調用者必須要處理異常
        3. 如果一個方法內部拋出了一個異常對象, 那么throw語句后面的代碼都不會再執行了（一個方法遇到了throw關鍵字, 該方法也會馬上停止執行的）
        4. 在一種情況下, 只能拋出一種類型異常對象

  - throw 與 throws 兩個關鍵字：
        1. throw關鍵字是用于方法內部的，throws是用于方法聲聲明上的
        2. throw關鍵字是用于方法內部拋出一個異常對象的，throws關鍵字是用于在方法聲明上聲明拋出異常類型的
        3. throw關鍵字后面只能有一個異常對象，throws后面一次可以聲明拋出多種類型的異常

疑問：何時使用拋出處理？何時捕獲處理？原則是如何？
如果你需要通知到調用者, 你代碼出了問題, 那么這時候就使用拋出處理
如果代碼是直接與用戶打交道遇到了異常千萬不要再拋，再拋的話，就給了用戶了, 這時候就應該使用捕獲處理

class Demo
{
    public static void main(String[] args) 
    {
        try{
            int[] arr = null;
            div(4,0,arr); //調用了一個 聲明拋出異常類型 的方法
        }catch(Exception e){
            System.out.println("出現異常了...");
            e.printStackTrace();
        }
        
    }


    public static void div(int a, int b,int[] arr) throws Exception,NullPointerException {
        if(b==0){
            throw new Exception(); //拋出一個異常對象...
        }else if(arr==null){
            throw new  NullPointerException();
        }
        int c = a/b;
        System.out.println("c="+c);
    }
}

疑問一 : 異常的處理感覺沒有多大作用，因為都是輸出一個話而已?
異常處理非常有用，只不過是由于我們目前所接觸的知識點太過于局限而已
疑問二：以后捕獲處理的時候是否就是捕獲Exception即可？
錯的，因為我們在現實開發中遇到不同的異常類型的時候，我往往會有不同的處理方式, 所以要分開不同的異常類型處理

class Demo
{
    public static void main(String[] args) 
    {
        int[] arr = null;
        div(4,0,arr);
    }

    public static void div(int a , int b,int[] arr){
        int c = 0;
        try{
            c = a/b;  //jvm在這句話的時候發現了不正常的情況，那么就會創建一個對應的異常對象。
            System.out.println("數組的長度："+ arr.length);
        }catch(ArithmeticException e){
            //處理異常的代碼....
            System.out.println("異常處理了....");
            System.out.println("toString:"+ e.toString());
        }catch(NullPointerException e){
            System.out.println("出現了空指針異常....");
        }catch(Exception e){  
            System.out.println("我是急診室，包治百病！");
        }
        System.out.println("c="+c);
    }
}

自定義異常類

sun提供了很多的異常類給我們用于描述程序中各種的不正常情況，但是sun 給我提供異常類還不足以描述我們現實生活中所有不正常情況，那么這時候我們就需要自定義異常類
需求: 模擬feiQ上線的時候,如果沒有插上網線，那么就拋出一個沒有插上網線的異常，如果已經插上了網上，那么就正常顯示好友列表
自定義異常類的步驟：自定義一個類繼承Exception即可

//自定義了一個沒有網線的異常類
class NoIpException extends Exception{
    public NoIpException(String message){
        super(message);  //調用了Exception一個參數的構造函數
    }
}

class Demo 
{
    public static void main(String[] args) 
    {
        String ip = "192.168.10.100";
        ip = null;
        try{
            myQ(ip);  // 如果調用一個聲明拋出異常類型的方法, 那么調用者必須要處理
        }catch(NoIpException e){
            e.printStackTrace();
            System.out.println(" 插上網線！");
        }
    }
    public static void myQ(String ip) throws NoIpException{
        if(ip==null){
            throw new  NoIpException("沒有插網線啊，小白！");
        }
        System.out.println("正常顯示好友列表..");
    }
}

異常體系

Throwable 所有錯誤或者異常的父類
Error（錯誤）
Exception(異常) 異常一般都通過代碼處理
1. 運行時異常: 如果一個方法內部拋出了一個運行時異常，那么方法上可以聲明也可以不聲明，調用者可以以處理也可以不處理。
2. 編譯時異常(非運行時異常、受檢異常): 如果一個方法內部拋出了一個編譯時異常對象，那么方法上就必須要聲明，而且調用者也必須要處理

運行時異常： RuntimeException以及RuntimeException子類都是屬于運行時異常
編譯時異常：除了運行時異常就是編譯異常

疑問：為什么java編譯器會如此嚴格要求編譯時異常，對運行時異常如此寬松？
運行時異常都是可以通過程序員良好的編程習慣去避免，所以java編譯器就沒有嚴格要求處理運行時異常

最后編輯于：2017.12.03 07:30:42

?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

人面猴
序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
沈念sama閱讀 229,327評論 6贊 537
死咒
序言：濱河連續發生了三起死亡事件，死亡現場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發現死者居然都...
沈念sama閱讀 98,996評論 3贊 423
救了他兩次的神仙讓他今天三更去死
文/潘曉璐我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事。” “怎么了？”我有些...
開封第一講書人閱讀 177,316評論 0贊 382
道士緝兇錄：失蹤的賣姜人
文/不壞的土叔我叫張陵，是天一觀的道長。經常有香客問我，道長，這世上最難降的妖魔是什么？我笑而不...
開封第一講書人閱讀 63,406評論 1贊 316
?港島之戀（遺憾婚禮）
正文為了忘掉前任，我火速辦了婚禮，結果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
茶點故事閱讀 72,128評論 6贊 410
惡毒庶女頂嫁案：這布局不是一般人想出來的
文/花漫我一把揭開白布。她就那樣靜靜地躺著，像睡著了一般。火紅的嫁衣襯著肌膚如雪。梳的紋絲不亂的頭發上，一...
開封第一講書人閱讀 55,524評論 1贊 324
城市分裂傳說
那天，我揣著相機與錄音，去河邊找鬼。笑死，一個胖子當著我的面吹牛，可吹牛的內容都是我干的。我是一名探鬼主播，決...
沈念sama閱讀 43,576評論 3贊 444
雙鴛鴦連環套：你想象不到人心有多黑
文/蒼蘭香墨我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側響起，我...
開封第一講書人閱讀 42,759評論 0贊 289
萬榮殺人案實錄
序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當地人在樹林里發現了一具尸體，經...
沈念sama閱讀 49,310評論 1贊 335
?護林員之死
正文獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛以下內容為張勛視角年9月15日...
茶點故事閱讀 41,065評論 3贊 356
?白月光啟示錄
正文我和宋清朗相戀三年，在試婚紗的時候發現自己被綠了。大學時的朋友給我發了我未婚夫和他白月光在一起吃飯的照片。...
茶點故事閱讀 43,249評論 1贊 371
活死人
序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
沈念sama閱讀 38,821評論 5贊 362
?日本核電站爆炸內幕
正文年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質發生泄漏。R本人自食惡果不足惜，卻給世界環境...
茶點故事閱讀 44,479評論 3贊 347
男人毒藥：我在死后第九天來索命
文/蒙蒙一、第九天我趴在偏房一處隱蔽的房頂上張望。院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
開封第一講書人閱讀 34,909評論 0贊 28
一樁弒父案，背后竟有這般陰謀
文/蒼蘭香墨我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監牢的瞬間，已是汗流浹背。一陣腳步聲響...
開封第一講書人閱讀 36,140評論 1贊 290
情欲美人皮
我被黑心中介騙來泰國打工，沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。一個月前我還...
沈念sama閱讀 51,984評論 3贊 395
代替公主和親
正文我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
茶點故事閱讀 48,228評論 2贊 375

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

接口 & 多態 & 類型強制轉換 & 內部類 & 內部匿名類 & 異常

接口 & 多態 & 類型強制轉換 & 內部類 & 內部匿名類 & 異常

接口概述

接口的作用：

類與接口之間關系 : 實現關系

多態

類型強制轉換

多態下的類型強制轉換

內部類

局部內部類

內部匿名類

異常

異常處理

自定義異常類

異常體系

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

接口 & 多態 & 類型強制轉換 & 內部類 & 內部匿名類 & 異常

接口概述

接口的作用：

類與接口之間關系 : 實現關系

多態

類型強制轉換

多態下的類型強制轉換

內部類

局部內部類

內部匿名類

異常

異常處理

自定義異常類

異常體系

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频