2. 程式人生 > >Java基礎 內部類 異常try catch throw RuntimeException

Java基礎 內部類 異常try catch throw RuntimeException

阿新 • • 發佈：2019-01-27

內部類

  • 將一個類定義在另一個類的裡面，對裡面那個類就稱為內部類（內建類，巢狀類）。
  • 訪問特點：
    • 內部類可以直接訪問外部類中的成員，包括私有成員。
    • 而外部類要訪問內部類中的成員必須要建立內部類的物件。

內部類訪問規則

  1. 內部類可以直接訪問外部類中的成員，包括私有。
    • 之所以可以直接訪問外部類中的成員，是因為內部類中持有了一個外部類的引用，格式 外部類名.this
  2. 外部類要訪問內部類，必須建立內部類物件。

訪問格式：

  1. 當內部類定義在外部類的成員位置上，而且非私有，可以在外部其他類中。可以直接建立內部類物件。
    • 格式
    • 外部類名.內部類名 變數名 = 外部類物件.內部類物件;
    • Outer.Inner in = new Outer().new Inner();
  2. 當內部類在成員位置上，就可以被成員修飾符所修飾
    • 比如，private:將內部類在外部類中進行封裝。
    • static:內部類就具備static的特性
    • 當內部類被static修飾後，只能直接訪問外部類中的static成員。出現了訪問侷限。
    • 在外部其他類中，如何直接訪問static內部類呢?
    • Outer.Inner.function();

注意：

  • 當內部類中定義了靜態成員，該內部類必須是static的。
  • 當外部類中的靜態方法訪問內部類時，內部類也必須是static的。
package 內部類1;

class Outer
{
    private
 
 int x=10;

    class Inner//內部類
    {
        int x=1;//內外有同名變數時
        void function(){
            System.out.println("inner:"+Outer.this.x);
            //用"外部類名"呼叫外部類的成員變數供內部類使用
        }
    }
    /*
    class Inner
    {
        void function(){
            System.out.println("inner:"+x);//內部類可以直接使用外部類的成員變數
        }
    }
    */
 

    void method()
    {
        Inner in=new Inner();//外部類使用內部類,需要建立物件
        in.function();
    }
}



public class InnerClassDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Outer out=new Outer();
        out.method();
    }

}

輸出:
inner:10

//直接訪問內部類的成員。
        Outer.Inner in=new Outer().new Inner();
        in.function();

內部類可以使用 private 修飾

內部類定義在區域性時

  1. 不可以被成員修飾符修飾
  2. 可以直接訪問外部類中的成員，因為還持有外部類中的引用。
  3. 但是不可以訪問它所在的區域性中的變數。只能訪問被 final 修飾的區域性變數。
class Outer
{
    int x=3;

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

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

匿名內部類

  1. 匿名內部類其實就是內部類的簡寫格式。
  2. 定義匿名內部類的前提：內部類必須是繼承一個類或者實現介面。
  3. 匿名內部類的格式： new 父類或者介面(){定義子類的內容}
  4. 其實匿名內部類就是一個匿名子類物件。而且這個物件有點胖。可以理解為帶內容的物件。

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

    abstract class AbsDemo
{
     abstract void show();
}

class Outer
{
     int x=3;

     public void function()
     {
         new AbsDemo()//匿名內部類
         {
             void show()
             {
                 System.out.println("x==="+Outer.this.x);
             }
         }.show();
     }
}
class Test
{
     public static void main(String [] args)
     {
         Outer ot=new Outer();
         ot.function();
     }
}

靜態方法獲取內部類

題目:
interface Inner
{
    public abstract void method();
}

class Outer
{
    //補充程式碼
    static  function()
    {

    }
}

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

實現

interface Inner
{
    public abstract void method();
}

class Outer
{

    static Inner function()
    {
        return new Inner()
        {
            public void method()
            {
                System.out.println("Inner method.");
            }
        };  
    }
}

class InnerDemo
{
    public static void main(String [] args)
    {
        Outer.function().method();//呼叫類靜態方法得到一個內部類引用,並使用他的方法method();
    }
}

異常

1.異常概述

異常：就是程式在執行時出現不正常情況

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

其實就是java對不正常情況進行描述後的物件體現。

對於問題的劃分：

  1. 嚴重的問題
  2. 非嚴重的問題

對於嚴重的，java通過Error類進行描述.
對於Error一般不編寫針對性的程式碼對其進行處理。

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

2.異常的處理 try catch

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

try
{
    需要被檢測的程式碼;
}
catch(異常類  變數)
{
    處理異常的程式碼;（處理方式）
}
finally
{
    一定會執行的語句;
}

對捕獲到的異常物件進行常見方法操作
String getMessage();獲取異常資訊

class Demo
{
    int div(int a,int b)
    {
        return a/b;
    }
}

public class ExceptionDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Demo d=new Demo();
        try
        {
            int x=d.div(4, 0);
            System.out.println("x=="+x);
        }
        catch(Exception e)
        {
            System.out.println("除零了");
            System.out.println(e.getMessage());//   /by zero;
            System.out.println(e.toString());// 異常名稱：異常資訊。

            e.printStackTrace();//異常名稱，異常資訊，異常出現的位置
                                //其實jvm預設的異常處理機制，就是在呼叫printStackTrace()方法，列印異常的堆疊的跟蹤資訊。
        }

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

}

輸出:
除零了
/ by zero
java.lang.ArithmeticException: / by zero
java.lang.ArithmeticException: / by zeroOver

at 異常.異常概述.Demo.div(ExceptionDemo.java:7)
at 異常.異常概述.ExceptionDemo.main(ExceptionDemo.java:18)

3.異常宣告throws

class Demo
{
    int div(int a,int b)throws Exception//在功能上通過throws的關鍵字聲明瞭該功能有可能會出現問題。
    {
        return a/b;
    }
}

public class ExceptionDemo 
{
    public static void main(String[] args)throws Exception //main把Exception丟擲給虛擬機器處理
    {
        // TODO Auto-generated method stub
        Demo d=new Demo();
        int x=d.div(4, 0);
        System.out.println("x="+x);
    }
}

也可以去掉main的throws 自己使用try catch處理異常

try
        {
            int x=d.div(4, 0);
            System.out.println("x=="+x);
        }
        catch(Exception e)//Exeption e = new ArithmeticException();
        {

            e.printStackTrace();//異常名稱，異常資訊，異常出現的位置
                                //其實jvm預設的異常處理機制，就是在呼叫printStackTrace()方法，列印異常的堆疊的跟蹤資訊。
        }

4.對多異常的處理

  1. 宣告異常時，建議宣告更為具體的異常，這樣處理的可以更具體。
  2. 對方宣告幾個異常，就對應有幾個catch塊。不要定義多餘的catch塊。
  3. 如果多個catch塊中的異常出現繼承關係，父類異常catch塊放在最下面
    建議在catch處理時，catch中一定要定義具體處理方式。
    不要簡單定義一句 e.printStackTrace();
    也不要簡單的就書寫一條輸出語句。
class Demo
{
    int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//丟出指定異常
    {
        int[] arr = new int[a];
        System.out.println(arr[4]);
        return a/b;
    }
}
public class ExceptionDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Demo d=new Demo();

        try
        {
            int x=d.div(4, 0);
            System.out.println("x=="+x);
        }
         //捕獲指定異常
        catch(ArithmeticException e)//Exeption e = new ArithmeticException();
        {
            System.out.println(e.toString());
            System.out.println("被零除了");
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            System.out.println(e.toString());
            System.out.println("角標越界");
        }
        catch(Exception e)
        {
            System.out.println(e.toString());
        }

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

}

5.自定義異常

因為專案中會出現特有的問題，而這些問題未被java所描述並封裝物件。
所以對於這些特有的問題可以按照java的對問題封裝的思想。
將特有的問題，進行自定義的異常封裝。

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

當在函式內部出現了throw丟擲異常物件，那麼就必須要給對應的處理動作。
要麼在內部try catch處理。
要麼在函式上宣告讓呼叫者處理。

一般情況下函式內出現異常，函式上需要宣告。

如何定義異常資訊？

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

繼承Exception原因:
異常體系有一個特點：因為異常類和異常物件都被丟擲。
他們都具備可拋性。這個可拋性是Throwable這個體系中獨有特點。
只有這個體系中的類和物件才可以被throws和throw操作

package 異常.自定義異常;

class FuShuException extends Exception
{
    private int value;
    FuShuException()
    {
        super();
    }
    FuShuException(String msg)
    {
        super(msg);
    }
    FuShuException(String msg,int value)
    {
        super(msg);
        this.value=value;
    }
    int getValue()
    {
        return this.value;
    }
}
class Demo
{

    int div(int a,int b)throws FuShuException
    {
        if(b<0)
            throw new FuShuException("出現負數.",b);
        return a/b;
    }
}


public class ExceptionDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Demo d=new Demo();
        try
        {
            d.div(5, -2);
        }
        catch(FuShuException e)
        {
            System.out.println(e.toString());
            System.out.println("負數是:"+e.getValue());
        }
    }

}

輸出:
異常.自定義異常.FuShuException: 出現負數.
負數是:-2

throws和throw的區別

throws使用在函式上。
throw使用在函式內。

throws後面跟的異常類，可以跟多個。用逗號隔開。
throw後面跟的是異常物件。

RuntimeException

Exception中有一個特殊的子類異常RuntimeException執行時異常。
RuntimeException的子類使用throw在函式內丟擲，不需要在函式上使用throws宣告。編譯一樣通過。
並且在呼叫函式內不用try catch處理。編譯一樣通過。

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

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

對於異常分兩種：
1. 編譯時被檢測的異常。
2. 編譯時不被檢測的異常(執行時異常。RuntimeException以及其子類)

package 異常.RuntimeException;

class FuShuException extends RuntimeException
{
    FuShuException(String msg)
    {
        super(msg);
    }
}
class Demo
{
    int div(int a,int b)
    {
        if(b<0)
            throw new FuShuException("出現了除數為負數");
        if(b==0)
            throw new ArithmeticException("被零除了 /0");
        return a/b;
    }
}

public class ExceptionDemoR {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Demo d=new Demo();
        int x=d.div(4, -1);
        System.out.println("x="+x);
    }

}

Exception in thread “main” 異常.RuntimeException.FuShuException: 出現了除數為負數
at 異常.RuntimeException.Demo.div(ExceptionDemoR.java:15)
at 異常.RuntimeException.ExceptionDemoR.main(ExceptionDemoR.java:27)

相關推薦

Java基礎 內部類 異常try catch throw RuntimeException

內部類 將一個類定義在另一個類的裡面，對裡面那個類就稱為內部類（內建類，巢狀類）。 訪問特點： 內部類可以直接訪問外部類中的成員，包括私有成員。 而外部類要訪問內部類中的成員必須要建立內部類的物件。 內部類訪問規則 內部類可以直接訪問外部類中的

黑馬程式設計師——Java基礎---內部類與異常

                                                                                                   第二講  內部類與異常 一、內部類 1、內部類：將一個類定義在另一個類的裡

java基礎——————內部類 靜態內部類、成員內部類、匿名內部類

內部類包括四種類型：靜態內部類，例項（成員）內部類，匿名內部類，本地內部類（不多用） 主要分析前三種內部類的建立以及物件的建立和方法的如何呼叫 一、靜態內部類 1）訪問內部類的資料成員和方法 訪問內部類資料成員方法： 內部類物件直接呼叫 內部類物件呼叫外部類非靜態資料成員和方法：

[JAVA基礎]內部類詳解

public class OuterClass { private String sex; public static String name = "chenssy"; /** *靜態內部類 */ static class InnerClass

java基礎——內部類的剖析

內部類 可以將一個類的定義放在另一個類的定義內部，這就是內部類。 1.建立內部類 最簡單的建立內部類的方法就是把類的定義至於外圍類裡面。更典型的就是，外部類有一個方法，該方法返回一個指向內部的引用。 public class Parcel { class Contents

C++處理異常 try,catch,throw

內容導讀： 本文包括2個大的異常實現概念：C++的標準異常和SHE異常。 C++標準異常：也許我們瞭解過他，但你有考慮過，其實你根本不會使用，你不相信，那我問你：垃圾回收在C++中怎麼實現？其實不需要實現，C++已經有了，但是你不會用，那麼從<構造和析構中的異常丟擲>開始看把。也許很高

Java基礎 -- 內部類

ole object c tin public 需要 ott sequence 對象 是否 可以將一個類的定義放在另一個類的內部定義，這就是內部類。 內部類是一個非常有用的特性。因為它允許你把一些邏輯相關的類組織在一起，並控制位於內部的類的可視性。 一 創建內部類 創

Java基礎-19總結IO流，異常try…catch，throws，File類

1:異常(理解) (1)程式出現的不正常的情況。 (2)異常的體系 Throwable |--Error嚴重問題，我們不處理。 |--Exception |--RuntimeException執行期異常，我們需要修正程式碼

java異常 try-catch 和throw

異常處理1：try和catch捕獲異常 package com.MissXu.blogTest; import java.util.Scanner; public class Exception

java中的異常 try catch

bsp 17. 輸出 pro war 提示 編譯 無法 .get 1.學習異常的原因？ 如果沒有異常處理機制，那麽程序的一點小問題，都會導致【程序終止運行】。實際開發中顯然是不可能的，所以異常對於程序來說是非常重要的。 2.處理異常的方式： A.if結

基礎 | Java的內部類

「內部類」 在面試時問的並不是很多，但是本人在面試Synopsys時就被問到過，建議還是要重點關注一下。 相信大家對於內部類都不陌生，但肯定也會感覺不太熟悉，因為在開發中的應用場景並不是很多，在此主要梳理一下 「談談對內部類的理解？在什麼場景中使用過內部類？」 相關問題。

【c#】異常處理：try catch throw

        異常處理，是程式語言或計算機硬體裡的一種機制，用於處理軟體或資訊系統中出現的異常狀況（即超出程式正常執行流程的某些特殊條件）。 也就是說，在程式執行時出現的任何意外或異常情況時，處理這種意外或情況的方法，叫做異常處理。  

【第20、21天】Java的內部類、異常處理機制

1 內部類 1.1 成員內部類 1.2 靜態內部類 1.3 區域性內部類 1.4 匿名內部類 2 異常處理機制 2.1 異常類的體系結構及各部分介紹 2.2

C++異常處理 try-catch throw

try-catch throw 示意圖 throw 介紹 出現異常時發出一個異常資訊 throw 離開後，流程立即離開本函式 throw a；throw b；等等作用相同 throw 找不到與之匹配的catch塊時，系統會呼叫terminate終止程式

Java基礎之內部類、匿名類和異常處理知識點總結

Object是java中已有的一個所有類的父類。也稱為根類，你可以把它理解為java中的上帝。java中的類都是直接或者間接繼承自object類。 該類的出現：是封裝了所有物件都具備的方法。所有物件都具備方法有哪些呢？ boolean  equals

Java中內部類和異常處理

1、 內部類 內部類的訪問規則： 1） 內部類可以訪問外部類的成員包括私有。 之所以可以直接訪問外部類的成員，是因為內部類持有一個外部類的引用 ， 格式： 外部類名.this 2） 外部類要訪問內部類，必須建立內部類物件。 當內部類處於外

Java基礎之內部類（2）---內部類的訪問規則

ps：案例來源於畢向東老師Java基礎教程 知識點一：內部類的訪問規則 1，內部類可以直接訪問外部類中的成員，包括私有。 之所以可以直接訪問外部類中的成員，是因為內部類中持有了一個外部類的

Java學習筆記31：捕獲異常try-catch語句

//異常處理通常用try-catch-finally語句實現 package Demo_exception; import java.util.Scanner; public class Test1_Exception { public static void m

Java基礎8——深入理解java的內部類

深入理解內部類 內部類基礎   在Java中，可以將一個類定義在另一個類裡面或者一個方法裡面，這樣的類稱為內部類。廣泛意義上的內部類一般來說包括這四種：成員內部類、區域性內部類、匿名內部類和靜態內部類。 問題：為什麼要使用內部類？   在《Think in java》中有這樣一句

java中內部類和異常類

這是在eclipse中建立的一個Example8_2的類,其中有些錯誤，我想在這裡註明一下。只是想以後自己看看，希望不要在出現這樣的錯誤。 package s8_2; /**  * @author Administrator  *本節主要是講內部類和異常類  */ /