黑馬程式員——面向對象09（内部類、異常上）

——- android教育訓練、java教育訓練、期待與您交流！ ———-

1.1，内部類

1，将一個類定義在另一個類的裡面，對裡面那個類就稱為内部類（内置類，嵌套類）。

當描述事物時，事物的内部還有事物，該事物用内部類來描述。因為内部事務在使用外部事物的内容。

2，編譯時，如果代碼中有内部類，生成的class檔案中會含有這樣的檔案：Test 1.class。編譯器将會把内部類翻譯成用（美元符号）分隔外部類名和内部類名的正常類檔案。這是内部類的一

種編譯現象。

1.2，内部類的通路規則

1、内部類可以直接通路外部類中的成員，包括私有。

之是以可以直接通路外部類中的成員，是因為内部類中持有了一個外部類的引用，格式：外部類名.this。

2、外部類要通路内部類，必須建立内部類對象。

1.3，通路格式

1、當内部類定義在外部類的成員位置上，而且非私有，可以在外部其他類中。可以直接建立内部類對象。

格式：

外部類名.内部類名變量名 =外部類對象.内部類對象；

如： Outer.Inner in =new Outer().new Inner();

2，當内部類在外部類中的成員位置上時，可以被成員修飾符所修飾。比如：

private：将内部類在外部類中進行封裝。

static：内部類就局部static的特性。

但是當内部類被static修飾後，隻能直接通路外部類中的static成員。出現了通路局限。

在外部其他類中，直接通路static内部類的非靜态成員的格式為：

new Outer.Inner().function();

在外部其他類中，直接通路static内部類的靜态成員格式為：

Outer.Inner.function();

注意：當内部類中定義了靜态成員，該内部類必須是static的。
      當外部類中的靜态方法通路内部類時，内部類也必須是static的。

示例：

//内部類定義在外部類的成員位置上
class Outer
{
    private static  int x = ;


    static class Inner//靜态内部類
    {
        static void function()
        {
            System.out.println("innner :"+x);
        }
    }

    static class Inner2
    {
        void show()
        {
            System.out.println("inner2 show");
        }
    }

    public static void method()
    {
        //Inner.function();
        new Inner2().show();
    }

}


class  InnerClassDemo2
{
    public static void main(String[] args) 
    {
        Outer.method();
        //Outer.Inner.function();
        //new Outer.Inner().function();
        //直接通路内部類中的成員。
//      Outer.Inner in = new Outer().new Inner();
//      in.function();
    }
}

3，内部類定義在局部

1，不可以被成員修飾符修飾。如public、private、static等修飾符修飾。它的作用域被限定

在了聲明這個局部類的代碼塊中

2，可以直接通路外部類中的成員，因為還持有外部類中的引用。

但是不可以通路它所在的局部中的變量。隻能通路被final修飾的局部變量。

示例：

/*
内部類定義在局部時，

*/
class Outer
{
    int x = ;

    void method(final int a)
    {
        final int y = ;
        class Inner
        {
            void function()
            {
                System.out.println(y);
            }
        }

        new Inner().function();

    }
}


class  InnerClassDemo3
{
    public static void main(String[] args) 
    {
        Outer out = new Outer();
        out.method();
        out.method();
    }

}

1.4，匿名内部類

1，匿名内部類其實就是内部類的簡寫格式。

2，定義匿名内部類的前提：

内部類必須是繼承一個類或者實作接口。

特殊情況：因為是以的類都有一個父類Object，是以在定義時也可以用Object。

3，匿名内部類的格式： new父類或者接口(){定義子類的内容}

4，其實匿名内部類就是一個匿名子類對象。可以了解為帶内容的對象。

5，匿名内部類中定義的方法最好不要超過3個。

示例：

/*  
匿名内部類:

*/
abstract class AbsDemo
{
    abstract void show();

}


class Outer
{
    int x = ;

    /*
    class Inner extends AbsDemo
    {
        int num = 90;
        void show()
        {
            System.out.println("show :"+num);
        }
        void abc()
        {
            System.out.println("hehe");
        }
    }
    */

    public void function()
    {
        //AbsDemo a = new Inner();
//      Inner in = new Inner();
//      in.show();
//      in.abc();


        AbsDemo d = new AbsDemo()
        {
            int num = ;
            void show()
            {
                System.out.println("num==="+num);
            }
            void abc()
            {
                System.out.println("haha");
            }
        };

        d.show();
        //d.abc();//編譯失敗;





    }
}



class InnerClassDemo4 
{
    public static void main(String[] args) 
    {
        new Outer().function();
    }
}

2.1，異常概述

1，異常：就是程式在運作時出現不正常情況。

2，異常由來：問題也是現實生活中一個具體的事物，也可以通過java的類的形式進行描述。

并封裝成對象。其實就是java對不正常情況進行描述後的對象展現。

2.2，異常體系

對于問題的劃分：兩種：一種是嚴重的問題，一種非嚴重的問題。。

對于嚴重的問題，java通過Error類進行描述。對Error類一般不編寫針對性的代碼對其進行處理。

對于非嚴重的，java通過Exception類進行描述。對于Exception可以使用針對性的處理方式進行處理。

無論Error或者Exception都具有一些共性内容。比如：不正常情況的資訊，引發原因等。

這也就構成了Java的異常體系：
    Throwable
            |---Error：通常出現重大問題如：運作的類不存在或者記憶體溢出等。
            |---Exception：運作時出現的一起情況
                        |---RuntimeException：特殊異常類，抛時不需要聲明

異常體系的特點：
    1、異常體系中的所有類以及建立的對象都具備可抛性。
    2、也就是說可以被throw和throws關鍵字所操作。
    3、隻有異常體系具備這個特點。

2.3：異常的處理

1、 java提供了特有的語句進行處理。

try

{

需要被檢測的代碼。

}

catch（異常類變量）

{

處理異常的代碼；（處理方式）

}

finally

{

一定會執行的語句；

}

有三個結合格式：

a、try

{

}

catch ()

{

}

b、try

{

}

finally

{

}

c、try

{

}

catch ()

{

}

finally

{

}

2，對捕獲到的異常對象進行常見方法操作：

String getMessage（）；//擷取異常的資訊。傳回字元串。

toString（）；//擷取異常類名和異常資訊，傳回字元串。

printStackTrace();//擷取異常類名和異常資訊，以及異常出現在程式中的位置.傳回值void.

//其實JVM預設的異常處理機制，就是在調用printStackTrace方法，

列印異常的堆棧的跟蹤資訊。

printStackTrace(PrintStream s)//通常用該方法将異常内容儲存在日志檔案中，以便查閱。

3，對多異常的處理。

(1)，聲明異常時，建議聲明更為具體的異常。這樣處理的可以更具體。

(2)，對方聲明幾個異常，就對應有幾個catch塊。不要定義多餘的catch塊。

如果多個catch塊中的異常出現繼承關系，父類異常catch塊放在最下面。

4，建立在進行catch處理時，catch中一定要定義具體處理方式。

不要簡單定義一句 e.printStackTrace(),

也不要簡單的就書寫一條輸出語句。

2.4，異常有兩種：

1，編譯時被檢測異常

該異常在編譯時，如果沒有處理(沒有抛也沒有try)，編譯失敗。

該異常被辨別，代表着可以被處理。

2，運作時異常(編譯時不檢測)

在編譯時，不需要處理，編譯器不檢查。該異常的發生，建議不處理，讓程式停止。

需要對代碼進行修正。如：RuntimeException以及其子類。

2.5，自定義異常

1，因為項目中會出現特有的問題，而這些問題并未被java所描述并封裝對象。是以對這些特有的

問題可以按照java中的面向對象思想。将特有的問題，進行自定義的異常封裝。

自定義異常必須是自定義類繼承Exception。

2，如何定義異常資訊呢？

因為父類中已經把異常資訊的操作都完成了。

是以子類隻要在構造時，将異常資訊傳遞給父類通過super語句。

那麼就可以直接通過getMessage方法擷取自定義的異常資訊。

3，繼承Exception原因：

異常體系有一個特點：因為異常類和異常對象都被抛出。

他們都具備可抛性。這個可抛性是Throwable這個體系中獨有特點。

隻有這個體系中的類和對象才可以被throws和throw操作。

4，throws和throw的差別

throws使用在函數上，throw使用在函數内。

throws後面跟的異常類，可以跟多個。用逗号隔開。

throw後跟的是異常對象。

示例1：

自定義異常。

需求：在本程式中，對于除數是-，也視為是錯誤的是無法進行運算的。
那麼就需要對這個問題進行自定義的描述。

當在函數内部出現了throw抛出異常對象，那麼就必須要給對應的處理動作。
要麼在内部try catch處理。
要麼在函數上聲明讓調用者處理。

一般情況在，函數内出現異常，函數上需要聲明。


發現列印的結果中隻有異常的名稱，卻沒有異常的資訊。
因為自定義的異常并未定義資訊。

如何定義異常資訊呢？
因為父類中已經把異常資訊的操作都完成了。
是以子類隻要在構造時，将異常資訊傳遞給父類通過super語句。
那麼就可以直接通過getMessage方法擷取自定義的異常資訊。



自定義異常：
必須是自定義類繼承Exception。


繼承Exception原因：
異常體系有一個特點：因為異常類和異常對象都被抛出。
他們都具備可抛性。這個可抛性是Throwable這個體系中獨有特點。

隻有這個體系中的類和對象才可以被throws和throw操作。



throws和throw的差別
throws使用在函數上。
throw使用在函數内。

throws後面跟的異常類。可以跟多個。用逗号隔開。
throw後跟的是異常對象。



*/
class FuShuException extends Exception //getMessage();
{
    private int value;

    FuShuException()
    {
        super();
    }
    FuShuException(String msg,int value)
    {
        super(msg);
        this.value = value;
    }

    public int getValue()
    {
        return value;
    }

}



class Demo
{
    int div(int a,int b)throws FuShuException
    {
        if(b<)
            throw new FuShuException("出現了除數是負數的情況------ / by fushu",b);//手動通過throw關鍵字抛出一個自定義異常對象。

        return a/b;
    }
}


class  ExceptionDemo3
{
    public static void main(String[] args) 
    {
        Demo d = new Demo();
        try
        {
            int x = d.div(,-);
            System.out.println("x="+x);     
        }
        catch (FuShuException e)
        {
            System.out.println(e.toString());
            //System.out.println("除數出現負數了");
            System.out.println("錯誤的負數是："+e.getValue());
        }



        System.out.println("over");

    }
}

/*
class Throwable
{
    private String message;
    Throwable(String message)
    {
        this.message = message;
    }

    public String getMessage()
    {
        return message;
    }
}

class Exception extends Throwable
{
    Exception(String message)
    {
        super(message);
    }
}


class Person
{
    String name;
    Person(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
        }
}

class Student extends Person
{
    Student (String name)
    {
        super(name);
    }
}

new Sttdent("lisi").getName();

*/

示例2：

/*
畢老師用電腦上課。

開始思考上課中出現的問題。


比如問題是
    電腦藍屏。
    電腦冒煙。

要對問題進行描述，封裝成對象。


可是當冒煙發生後，出現講課進度無法繼續。

出現了講師的問題：課時計劃無法完成。


*/

class LanPingException extends Exception
{
    LanPingException(String message)
    {
        super(message);
    }
}

class MaoYanException extends Exception
{
    MaoYanException(String message)
    {
        super(message);
    }
}


class NoPlanException extends Exception
{
    NoPlanException(String msg)
    {
        super(msg);
    }
}

class Computer
{
    private int state = ;
    public void run()throws LanPingException,MaoYanException
    {
        if(state==)
            throw new LanPingException("藍屏了");
        if(state==)
            throw new MaoYanException("冒煙了");

        System.out.println("電腦運作");
    }
    public void reset()
    {
        state = ;
        System.out.println("電腦重新開機");

    }
}

class Teacher
{
    private String name;
    private Computer cmpt;

    Teacher(String name)
    {
        this.name = name;
        cmpt = new Computer();

    }

    public void prelect()throws NoPlanException
    {
        try
        {
            cmpt.run();         
        }
        catch (LanPingException e)
        {
            cmpt.reset();
        }
        catch (MaoYanException e)
        {

            test();
            throw new NoPlanException("課時無法繼續"+e.getMessage());

        }
        System.out.println("講課");
    }
    public void test()
    {
        System.out.println("練習");
    }

}



class ExceptionTest 
{
    public static void main(String[] args) 
    {
        Teacher t = new Teacher("畢老師");
        try
        {
            t.prelect();
        }
        catch (NoPlanException e)
        {
            System.out.println(e.toString());
            System.out.println("換老師或者放假");
        }

    }
}

5，Exceptoin中有一個特殊的子類異常RuntimeException 運作時異常。

如果在函數内容抛出該異常，函數上可以不用聲明，編譯一樣通過。

如果在函數上聲明了該異常。調用者可以不用進行處理。編譯一樣通過；

之是以不用在函數聲明，是因為不需要讓調用者處理。

當該異常發生，希望程式停止。因為在運作時，出現了無法繼續運算的情況，希望停止程式後，

對代碼進行修正。

示例1：

/*
Exceptoin中有一個特殊的子類異常RuntimeException 運作時異常。

如果在函數内容抛出該異常，函數上可以不用聲明，編譯一樣通過。

如果在函數上聲明了該異常。調用者可以不用進行處理。編譯一樣通過；

之是以不用在函數聲明，是因為不需要讓調用者處理。
當該異常發生，希望程式停止。因為在運作時，出現了無法繼續運算的情況，希望停止程式後，
對代碼進行修正。




自定義異常時：如果該異常的發生，無法在繼續進行運算，
就讓自定義異常繼承RuntimeException。


對于異常分兩種：
1，編譯時被檢測的異常。

2，編譯時不被檢測的異常(運作時異常。RuntimeException以及其子類)

*/

class FuShuException extends RuntimeException
{
    FuShuException(String msg)
    {
        super(msg);
    }
}
class Demo
{
    int div(int a,int b)throws Exception//throws ArithmeticException
    {

        if(b<)
            throw new Exception("出現了除數為負數了");
        if(b==)
            throw new ArithmeticException("被零除啦");
        return a/b;
    }
}

class ExceptionDemo4 
{
    public static void main(String[] args) 
    {

        Demo d = new Demo();

        int x = d.div(,-);
        System.out.println("x="+x);     

        System.out.println("over");
    }
}

/*
class Person
{
    public void checkName(String name)
    {

        //if(name.equals("lisi"))//NullPointerException
        if("lisi".equals(name))//if(name!=null && name.equals("lisi"))
            System.out.println("YES");
        else
            System.out.println("no");
    }
}

main()
{
    Person p = new Person();
    p.checkName(null);
}
*/

——- android教育訓練、java教育訓練、期待與您交流！ ———-

黑馬程式員——面向對象09（内部類、異常上）

繼續閱讀

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

Android APK檔案反編譯Android APK檔案反編譯

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method