Java基礎（三）面向對象（下）

時間  2019-11-06
標籤 java 基礎 面向對象 欄目 Java 简体版
原文   原文鏈接

接口

接口中成員修飾符是固定的：java

成員常量：public static final 成員函數：public abstractide

經過接口間接實現了多重繼承函數

接口的特色

接口是對外暴露的規則 接口是程序的工功能擴展 接口的出現下降耦合性 接口能夠用來多實現 類與接口之間是實現關係，並且類能夠繼承一個類的同時實現多個接口 接口與接口之間能夠有繼承關係this

接口與抽象類

抽象類體現繼承關係，一個類只能單繼承 接口體現實現關係，一個類能夠多實現spa

抽象類中能夠定義非抽象方法，供子類直接使用 接口的方法都是抽象，接口中的成員都有固定修飾符日誌

一個簡單的實現例子：code

package study_java.ex7;

public class InterfaceDemo1 {
    public static void main(String[] args){
        PC pc = new PC();
        Mouse m = new Mouse();
        Iphone ip = new Iphone();
        pc.insertUSB(m);
        pc.insertUSB(ip);
    }
}

// 定義接口
interface USB{
    void connect();
}

// 類實現了接口
class Mouse implements USB{
    public void connect(){
        System.out.println("我是鼠標");
    }
}

class Iphone implements USB{
    public void connect(){
        System.out.println("我是Iphone");
    }
}

class PC {
    public void insertUSB(USB usb){
        System.out.println("插入了usb設備");
        usb.connect();
    }
}

若是有多個接口，而且接口存在繼承的時候，代碼例子以下：對象

package study_java.ex7;

public class InterfaceDemo2 {
    public static void main(String[] args){
        TuHao th = new TuHao();
        WomanStar ws = new WomanStar();
        th.marry(ws);
    }
}

interface White{
    public void white();
}

interface Rich{
    public void rich();
}

interface  Beautiful{
    public void beautiful();
}

interface BFM extends White,Rich,Beautiful{

}

class WomanStar implements BFM{
    public void white(){
        System.out.println("我很白");
    }
    public void rich(){
        System.out.println("我頗有錢");
    }
    public void beautiful(){
        System.out.println("我頗有漂亮");
    }
}


class TuHao{
    public void marry(BFM bfm){
        bfm.white();
        bfm.rich();
        bfm.beautiful();
    }
}

多態

定義：某一類事物的多種存在形態blog

多態的特色：繼承

成員函數 編譯時：要查看引用變量所屬類中是否有所調用的成員

在運行時：要查看對象所屬類是否有所調用的成員 成員變量 只看引用變量所屬的類

關於多態的一個代碼例子：

package study_java.ex7;

public class MutilstateDemo1 {
    public static void main(String[] args){
        Jing8 jing8 = new Jing8();
        jing8.meng();
        jing8.cry();

        Dog dog = new Jing8();
        dog.cry();
        dog.watch();



        Animal a = dog;
        a.cry();

        Pet pet = (Pet) a;
        pet.meng();


    }
}


abstract class Animal{
    public void cry(){
        System.out.println("crying...");
    }
}

class Dog extends Animal{
    public void watch(){
        System.out.println("來人了");
    }
}

class Jing8 extends Dog implements Pet{
    public void meng(){
        System.out.println("麼麼噠");
    }
}

interface Pet{
    void meng();
}

繼承中方法能夠被覆蓋，可是成員變量不能被覆蓋

代碼例子：

package study_java.ex7;

public class MultiStatDemo2 {
    public static void main(String[] args){
        Jing8 j = new Jing8();
        j.cry();

        Dog dog = j;
        dog.cry();
        System.out.println(j.name);
        System.out.println(dog.name);
    }
}

abstract class Animal{
    abstract public void cry();
}

class Dog extends Animal{
    public String name = "大黃";
    public void cry(){
        System.out.println("旺旺");
    }
}

class Jing8 extends Dog{
    public String name = "小黃";
    public void cry(){
        System.out.println("嘿嘿");
    }
}

異常

異常的體系： Throwable: Error:一般出現重大問題如：運行的類不存在或者內存溢出，不編寫代碼針對處理 Exception:運行時出現的一些狀況，能夠經過try catch finally

Exception 和Error的子類名都是以父類名做爲後綴的

Trowable中的方法

getMessage():獲取異常信息，返回字符串

toString():獲取異常信息和異常類名，返回字符串

printStackTrace():獲取異常類名和異常信息，以及異常出如今程序中的位置，返回值void

printStackTrace(printStram s):一般用該方法將異常內容保存在日誌文件中

throws和throw

throws用於標識函數暴露出的異常 throw用於拋出異常對象 throws和throw的區別： throws用在函數上，後面跟異常類名，聲明拋出異常時使用的關鍵字 throw用在函數內，後面跟異常對象，拋出異常的語句

異常處理

try { 須要檢測的代碼 } catch { 異常處理代碼 } finally { 必定會執行的代碼 }

Finally代碼只有一種狀況不會被執行，就是在以前執行了System.exit(0)

package study_java.ex8;

public class ThrowableDemo1 {
    public static void main(String[] args){
        float r = divide(4,0);
        System.out.println(r);
        int[] arr = null;
        int[] arr2 = new int[4];
//        System.out.println(getLength(arr2));
        System.out.println(getLength(arr));
    }

    public static float divide(int a, int b){
        return (float) a / b;
    }

    public static int getLength(int[] arr){
        int len = -1;
        try {
            len =  arr.length;
        }
        catch (Exception e){
            System.out.println("出錯了"+ e.getMessage());
            // return -2; 這裏通常也不會加return
        }
        finally {
            len += 1;
            System.out.println("程序執行完了");
            // return len; 這裏通常不會加return
        }
       return len;
    }
}

自定義異常

自定義類繼承Exception或者其子類

經過構造函數定義異常信息

經過throw將自定義異常拋出

一個簡單的例子：

package study_java.ex7;

public class ExceptionDemo1 {
    public static void main(String[] args){
        Person p = new Person();
        try{
            p.setAge(1000);
        }
        catch (Exception e){
            ((AgeTooBigException)e).printlnError();
        }

    }
}

class Person{
    private int age;
    public int getAge(){
        return age;
    }

    public void setAge(int age) throws  AgeTooBigException {
        if (age > 200) {
            throw new AgeTooBigException();
        }
        this.age = age;
    }
}


class AgeTooBigException extends Exception{
   private String info;
   public AgeTooBigException(String info){
       this.info=info;
   }
   public AgeTooBigException(){
       this("年齡太大了");
   }
   public void printlnError(){
       System.out.println(info);
   }
}

一個稍微複雜的例子：

package study_java.ex7;

public class ExceptionDemo1 {
    public static void main(String[] args){
        Person p = new Person();
        try{
            p.setAge(-10);
        }
        catch (AgeTooBigException e){
            e.printlnError();
        }
        catch (AgeTooSmallException e){
            e.printlnError();
        }
        catch (AgeInvalidException e){
            e.printlnError();
        }

    }
}

class Person{
    private int age;
    public int getAge(){
        return age;
    }

    public void setAge(int age) throws AgeTooBigException,
                                       AgeTooSmallException,
                                       AgeInvalidException {
        if (age > 200) {
            throw new AgeTooBigException();
        }
        else if (age <10 && age > 0){
            throw new AgeTooSmallException();
        }
        else if (age < 0){
            throw new AgeInvalidException("年齡非法");
        }
        else{
            this.age = age;
        }

    }
}

// 年齡非法異常
class AgeInvalidException extends Exception{
    private String info;
    public AgeInvalidException(String info){
        this.info = info;
    }
    public void printlnError(){
        System.out.println(info);
    }
}

// 年齡太大異常
class AgeTooBigException extends AgeInvalidException{
   public AgeTooBigException(String info){
       super(info);
   }
   public AgeTooBigException(){
       this("年齡太大了");
   }
}

// 年齡過小異常
class AgeTooSmallException extends AgeInvalidException{
    public AgeTooSmallException(String info){
        super(info);
    }
    public AgeTooSmallException(){
        this("年齡過小了");
    }
}

若是咱們不處理異常而是直接拋出能夠直接在man函數裏拋出異常，這樣就將異常拋給了java虛擬機

package study_java.ex8;

public class ExceptionDemo1 {
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        p.setAge(-10);
        // 處理異常
        /*
        try{
            p.setAge(2);
        }
        catch (AgeTooSmallException e){
            e.printlnError();
        }
        catch (AgeTooBigException e){
            e.printlnError();
        }
        catch (AgeInvalidException e){
            e.printlnError();
        }
        */
    }
}

class Person{
    private int age;
    public int getAge(){
        return age;
    }

    public void setAge(int age) throws AgeTooBigException,
                                       AgeTooSmallException,
                                       AgeInvalidException{
        if (age> 200){
            throw new AgeTooBigException();
        }
        else if (age < 10 && age > 0){
            throw new AgeTooSmallException();
        }
        else if (age < 0){
            throw new AgeInvalidException("年齡不合法");
        }
        else {
            this.age = age;
        }

    }
}

class AgeInvalidException extends Exception{
    private String info;

    public AgeInvalidException(String info){
        this.info = info;
    }

    public void printlnError(){
        System.out.println(info);
    }
}

class AgeTooBigException extends AgeInvalidException{
    public AgeTooBigException(String info){
        super(info);
    }
    public AgeTooBigException(){
        this("年齡太大了");
    }
}

class AgeTooSmallException extends AgeInvalidException{
    public AgeTooSmallException(String info){
        super(info);
    }
    public AgeTooSmallException(){
        this("年齡過小了");
    }
}

關於異常處理的細節：

RuntimeException 以及其子類若是在函數中被throw拋出，能夠不用再函數上聲明拋出語句，也不是必須用try catch語句處理 一個方法被覆蓋時，覆蓋它的方法必須拋出相同的異常或者異常的子類 若是父類拋出多個異常，那麼重寫（覆蓋）方法必須拋出那些異常的一個子集，不能拋出新的異常

CheckedException 待檢異常，也就是非運行時異常，必須使用try catch語句處理

包的概念

對類文件進行分類管理 給類提供多層命名空間 卸載程序文件的第一行 類名的全稱的是包名.類名 包也是一種封裝方式

如： javac -d classes PackageDemo1.java 編譯java源文件，制定存放目錄 java -cp classes com.zhaofan.java.PackageDemo1 運行程序，類全限定名

包之間的訪問： 被訪問的包中的類權限必須是public 類中的成員權限：public 或者protected protected是爲其餘包中的子類提供的一種權限

若是一個類是public 文件名必須是類名

這裏順便整理一下常見的幾種權限在java中：

 

import導入

一個程序文件中只有一個package,能夠有多個import 用來導包的類，不導入包中的包

小結：

private 私有的不能繼承

public

protected 受保護的，針對其餘包中的子類

default 默認，不寫，不一樣包不能繼承

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程