Day8-笔记

时间:2021-07-13
本文章向大家介绍Day8-笔记,主要包括Day8-笔记使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。

接口

接口就是规范,定义的是一组规则。

接口的本质是契约。

OO的精髓,是对对象的抽象,最能体现这一点的就是接口。

接口的作用:

  1. 约束
  2. 定义一些方法,让不同的人实现~
  3. public abstract 方法前自动加
  4. public static final 定义属性时自动加,定义的为常量
  5. 接口不能被实例化,接口中没有构造方法
  6. implements 可以实现多个接口
  7. 必须要重写接口中的方法~
//interface 定义的关键字,接口都需要有实现类
public interface UserService {
    //常量~ public static final
    int age = 99;
    //接口中的所有定义其实都是抽象的public abstract
    void add(String name);

    void delete(String name);

    void update(String name);

    void query(String name);

}
public interface TimeService {
    void timer();
}
/*
* 抽象类;extends
* 类 可以实现接口 implements  接口
* 实现了接口的类,就需要重写接口中的方法
* */
//多继承~利用接口实现多继承
public class UserServiceImpl implements UserService, TimeService {

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

内部类

内部类:

​ 内部类就是在一个类的内部再定义一个类,比如A类中定义一个B类,那么B类相对A类来说就成为内部类,而A类相对B类来说就是外部类了

  • 成员内部类
  • 静态内部类
  • 局部内部类
  • 匿名内部类

成员内部类

public class Outer {
    private int id = 100;

    public void out() {
        System.out.println("外部类的方法");
    }

    public class Inner {
        public void in() {
            System.out.println("内部类的方法");
        }
        //获得外部类的私有属性~
        public void getID() {
            System.out.println(id);
        }
    }
}

    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }

静态内部类

public class Outer {
    public void out() {
        System.out.println("外部类的方法");
    }
    public static class Inner {
        public void in() {
            System.out.println("内部类的方法");
        }
    }
}

局部内部类

public class Outer {
    //一个JAVA类中可以有多个class类,但只能有一个public class
    class A {
    }

    //局部内部类
    public void method() {

        class Inner {
            public void in() {
            }
        }
    }
}

匿名内部类

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类,不用将实例保存到变量中
        new Apple().eat();

        UserService userService = new UserService() {
            @Override
            public void hello() {

            }
        }
    }
}

class Apple {
    public void eat() {
        System.out.println("吃苹果");
    }
}

interface UserService {
    void hello();
}

异常

异常:指程序运行中出现的不期而至的各种状况,如:文件找不到,网络连接失败,非法参数等等。

简单分类:

​ 检查性异常、运行时异常、错误(ERROR)

Java把异常当做对象来处理,并定义一个基类java.lang.Throwable作为所有异常的超类

两大类:

​ Error:

​ 由Java虚拟机生成并抛出,大多数错误与代码编写者所执行的操作无关。

​ Exception:

​ 重要的子类RuntimeException,一些常见的异常如下

  • ArrayIndexOutOfBoundsException(数组下标越界)

  • NullPointException(空指针异常)

  • ArithmeticException(算术异常)

  • MissingResourceException(丢失资源)

  • ClassNotFoundException(找不到类)

    程序应该从逻辑角度尽可能避免这类异常的发生

Error和Exception的区别:

​ Error通常是灾难性的致命的错误,是程序无法控制和处理的,当出现这些异常时,Java虚拟机(JVM)一般会选择终止线程;Exception通常情况下是可以被程序处理的,并且在程序中应该尽可能的去处理这些异常。

异常处理机制

抛出异常

捕获异常

异常处理的五个关键字

  • try、catch、finally、throw、throws
public class ExceptionTest {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;

        //假设要捕获多个异常:从小到大!否则编译就会报错
        try {
            System.out.println(a / b);
        } catch (Error e) {
            System.out.println(e);
            System.out.println("Error");
        } catch (Exception e) {
            System.out.println("Exception");
        } catch (Throwable e) {
            System.out.println("Throwable");
        } finally {//处理善后工作,必定执行,一般用来关闭
            System.out.println("finally");
        }
    }

}
public class ExceptionTest {
    public static void main(String[] args) {
        try {
            new ExceptionTest().test(1, 0);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //假设在这个方法中,处理不了这个异常。方法上抛出异常
    public void test(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException();//throw 主动抛出异常,一般在方法中使用
        }
        System.out.println(a / b);
    }
}

自定义异常

用户自定义异常类,只需要继承Exception类就可以了

//自定义异常类
public class MyException extends Exception {
    //传递数字>10
    private int detail;

    public MyException(int a) {
        this.detail = a;
    }

    //toString:异常的打印信息
    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}
public class Test {

    //可能会存在异常的方法  throws方法抛出异常
    static void test(int a) throws MyException {
        System.out.println("传递的参数:" + a);
        if (a > 10) {
            throw new MyException(a);  //抛出
        }
        System.out.println("ok");
    }

    public static void main(String[] args) {
        try {
            test(100);
        } catch (MyException e) {
            e.printStackTrace();
        }
    }
}

总结:

  • 处理运行时异常时,采用逻辑去合理规避同时辅助try-catch处理
  • 在多重catch块后面,可以加一个catch(Exception)来处理可能会被遗漏的异常
  • 对于不确定的代码,也可以加上try-catch,处理潜在的异常
    尽量去处理异常,切忌只是简单地调用printStackTrace()去打印输出
  • 具体如何处理异常,要根据不同的业务需求和异常类型去决定
  • 尽量添加finally语句块去释放占用的资源

JavaSE 总结

HashMap(重点,面试高频问点)

进程和线程

run(),Start(),

线程的创建方式:Thread,Runnable,Callable

Lambda表达式 new Thread(()->{System.out.println();}).start();

线程的状态:

  • 新建状态
  • 就绪
  • 运行
  • 阻塞
  • 死亡

常用的方法:sleep、join、yield、isLive、start、setPriority、interrupt

死锁:两个人都抱着对方的锁

​ 产生条件:互斥、请求与保持、不剥夺条件、循环等待条件

线程通信:

  • 缓冲区:消息队列
  • 标志位:红绿灯
  • wait()
  • notifyAll()

线程池:

  • 池化技术
  • 池的大小
  • 最大连接数
  • 保持时间等等

原文地址:https://www.cnblogs.com/xiaolibiji/p/15008691.html