Java基础---面向对象---抽象类与接口与异常

于 2022-04-11 11:19:32 发布
阅读量179 收藏 1
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MUYUFANSHENXUE/article/details/124094316
版权

1，抽象类

抽象类其实就是相当于“是不是”，

比如：小狗是动物，那么小狗就是继承父抽象类动物，再比如：黑白打印机的是打印机，那么黑把打印机就是继承抽象类打印机

一个类中如果存在抽象方法，那么他必须是抽象类

抽象类VS普通类

抽象类不能被直接实例化，可以创建一个引用变量，其类型是一个抽象类，指向非抽象的子类实例

普通类可以被实例化

抽象方法必须存在与抽象类当中，抽象类其实就是相当于“是不是”，比如：小狗是动物，那么小狗就是继承父抽象类动物，再比如：黑白打印机的是打印机，那么黑把打印机就是继承抽象类打印机

由于世界上不存在一个真正单纯是“动物”的东西，你只能说狗是动物，猫是动物，但是你不会真的实例化出一个所谓的“动物”，所以动物就是抽象类，黑白打印机是打印机，你可以创造出一台黑白打印机，但一般情况你不会去创造一个打印机。

“你是人，我是人，但没有人是人”

 

//抽象方法打印
public abstract class Printer{
    public abstract void print();
}

//重写打印方法的彩色打印机类
public class CPrinter extends Printer{
    @Override
    public void print() {
        System.out.println("这是一个彩色打印机，打印了彩色的文案");
    }
}

//重写打印方法的黑白打印机类
public class BWPrinter extends Printer{
    @Override
    public void print() {
        System.out.println("这是一个黑白打印机，他打印了一张黑色图片");
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        while(true){
            System.out.println("请问你要什么打印机？ 1（黑白打印机） 2（彩色打印机）");
            int flag = input.nextInt();
            Printer printer;
            if(1==flag){
                printer = new BWPrinter();
            }else{
                printer = new CPrinter();
            }
            printer.print();
            System.out.println("-----------------------------------------------------------------");
        }
    }
}

1，抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类

2，如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类

3，没有抽象构造方法，也没有抽象静态方法

4，抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用

2，接口

能不能？

2，1接口是一个引用数据类型，编译之后也是class文件

2，2接口是完全抽象

2，3接口定义：

public interface xxx{
    
}

例如：

public class Test2 {
    public static void main(String[] args) {
        LockDoor lockDoor = new LockDoor();
        lockDoor.close();
        lockDoor.open();
        lockDoor.lock();
        lockDoor.unlock();
    }
}

//防盗门
public class LockDoor extends Door implements Lock{
    @Override
    public void close() {
        System.out.println("防盗门被关上了");
    }

    @Override
    public void open() {
        System.out.println("防盗门被打开了");
    }

    @Override
    public void lock() {
        System.out.println("防盗门被上锁了");
    }

    @Override
    public void unlock() {
        System.out.println("防盗门被解锁了");
    }
}

public interface Lock {
     void lock();
     void unlock();
}

public abstract class Door {
    public abstract void open();
    public abstract void close();
}

3，匿名内部类

public interface Lock{
    void lock();
    void unlock();
}
Lock l = new Lock() {
            @Override
            public void lock() {
                System.out.println("1");
            }

            @Override
            public void unlock() {

            }
        }
//此时lock方法调用的是第4行代码所重写的方法--输出1
l.lock();

Lock l2 = new Lock() {
            @Override
            public void lock() {
                System.out.println("2");
            }

            @Override
            public void unlock() {

            }
        }
//此时lock方法调用的是第18行代码所重写的方法--输出2
l2.lock();

由于抽象方法没有具体实现（无方法体），所以若被实例化，无法具体调用该方法，所以使用匿名内部类方法，将抽象的方法重写（写方法体），此时实例化出的对象就可以用该重写调用具体方法，允许被此方法实例化实例化

4，面向对象的设计原则

多用组合，少用继承

针对接口编程

针对扩展开放，针对改变关闭

5，异常

异常发生时候的顺序：

以如下代码为例：

try代码块中执行的为有可能会抛出异常的代码，一般异常会出现三种情况：

第一种情况：如果try代码块执行顺利，没有抛出异常，那么以下代码的执行顺序为：

2，3，6，7，8，9，16

第二种情况：如果try代码块出现抛出异常，如第9行抛出算数异常，并且次异常被catch捕获

public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        System.out.println("请输入被除数：");
        try{
            //尝试代码，看看会不会出现异常
            int num1  = in.nextInt();
            System.out.println("请输入除数");
            int num2 = in.nextInt();
            System.out.println(num1 + "/" + num2 + "=" + num1 / num2);
        }catch (ArithmeticException e){
            //成功捕获异常
            System.out.println("我抓住异常了！！！");
            System.out.println("异常内容为");
            e.printStackTrace();
        }
        System.out.println("感谢使用本程序");
    }

6，打印异常内容

打印异常内容有两种方法

public staic void main(String[] atgs){
     try{
            //尝试代码，看看会不会出现异常
            int num1  = in.nextInt();
            System.out.println("请输入除数");
            int num2 = in.nextInt();
            System.out.println(num1 + "/" + num2 + "=" + num1 / num2);
        }catch (ArithmeticException e){
            //成功捕获异常
            System.out.println("我抓住异常了！！！");
            System.out.println("异常内容为");
         //第一种方法：
         //这种方法会将所有的报错顺序执行打印
            e.printStackTrace();
         //第二种方法
         //此方法，只会讲错误的信息打印，不会打印具体的报错行号
         System.err.println(e.getMessage());
        }
        System.out.println("感谢使用本程序");
}

7，finally关键字

如下代码：我们在try-catch块之后增加finally代码块，这一块代码块在之前提到的三种情况中都会执行

public class Test01 {
    public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        System.out.println("请输入被除数：");
        try{
            //尝试代码，看看会不会出现异常
            int num1  = in.nextInt();
            System.out.println("请输入除数");
            int num2 = in.nextInt();
            System.out.println(num1 + "/" + num2 + "=" + num1 / num2);
        }catch (ArithmeticException e){
            //成功捕获异常
            System.out.println("我抓住异常了！！！");
            System.out.println("异常内容为");
            e.printStackTrace();
        }finally {
            {
                System.out.println("无论代码怎样，我们都会执行");
            }
        }
        System.out.println("感谢使用本程序");
    }
}

8，多重catch块

对于try-catch块，我们可以存在多个catch，不同的catch可以捕获不同的异常，所有的异常自上而下进行匹配，如果匹配到了，就进入该catch块执行对应的逻辑

由于我们提到多重catch块是为了解决针对不同的异常采取不同的措施，所以catch块的异常理论应该是不同的逻辑代码，如果你执行的逻辑是相同的，并且被捕获的类存在父子关系，你只需要写父类的catch，子类不需要写，因为匹配异常，子类也会被父类类型匹配上

如果你需要针对不同的异常，做出不同的处理，那么你将catch块顺序进行排序，将最大的父类放在最后，最小的子类放最上面

package com.kgc.day15.KeTang;

import java.util.InputMismatchException;
import java.util.Scanner;

public class Test03 {
    public static void main(String[] args) {
        int flag=0;
        Scanner input = new Scanner(System.in);
        System.out.println("请输入被除数：");
        try{
            //尝试代码。看看会不会出现异常
            int num1 = input.nextInt();
            System.out.println("请输入除数");
            int num2 = input.nextInt();
            System.out.println(num1 + "/" + num2 + "=" + num1 / num2);
        }catch(ArithmeticException e){
            //成功捕获异常
            System.out.println("我抓住异常了！！1");
            System.out.println("异常内容为：");
            e.printStackTrace();
            flag++;
        }catch(InputMismatchException e){
            //成功捕获异常
            System.out.println("我抓住异常了！！2");
            System.out.println("异常内容为：");
            e.printStackTrace();
            flag++;
        }catch (Exception e){
            //成功捕获异常
            System.out.println("我抓住异常了！！3");
            System.out.println("异常内容为：");
            e.printStackTrace();
            flag++;
        }finally {
            {
                System.out.println("无论代码怎样都会执行");
            }
            System.out.println("感谢使用本程序");
            System.out.println("发现异常情况" + flag);
        }
    }
}

9，try-catch-finally存在return情况

public static void main(String[] args) {
        A a = new A();
        m1(a);
        System.out.println(a.i);
        int i = 0;
        i = m2(i);
        System.out.println(i);
    }  

  //注意此方法传递为基本数据类，基本数据类型传传递，传递值
        public statc  int m2(int i){
            try{
                i++;
                return i;
            }finally{
                i++;
            }
        }
    }

//注意此方法传递为引用数据类型，引用数据类型传递，传递地址
public static void m1(A a){
    try{
        a.i++;
        return;
    }finally{
        a.i++;
    }
}

10，throws关键字

方法中可以使用throws关键字抛出所有可能发生的异常，并且不去再当前方法处理，交由调用该方法的方法处理这个异常

我们也可以在main方法中抛出异常，不过这样抛出异常是没有任何意义的，因为没有方法会调用这个方法

public static void main(String[] args){
    try{
        m2();
    }catch(Exception e){
        e.prinstackTrace();
    }
    System.out.println(1123);
}

public static void m2() throws AritmeticException,NullPointerExcept{
    m1();
}

public static void m1() throws AritmeticException,NullPointerExcept{
    int i=1/0;
}

11，throw关键字

throw和throws完全是两个概念，throws是将已经发生的异常进行抛出处理，而throw关键字用于抛出一个新发生的异常

 

public staticn void main(String[] args){
    try{
        m1(1);
    }catch(Exception e){
        e.prinstackTrace();
    }
}

public static void m1(int i) throws Exception{
    if(i==1){
        throw new Exception("这里参数不能为1 为1抛异常");
    }else{
        System.out.println("你的参数不是1");
    }
}

 

12，RuntimeException和CheckedException的区别

13，自定义异常

根据情况，我们可以选择将我们的自定义异常声明成为要给checkedException或者RuntimeException选择哪种情况，完全取决于你的业务场景

 

人性背后-白云苍狗
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值