静态代码块、抽象类、接口、内部类、异常

1.Static关键字

  	{
        System.out.println("匿名代码块");
    }

    static{
        System.out.println("静态代码块");
    }

    public Person(){
        System.out.println("构造方法");
    }

	
	 public static void main(String[] args) {

        Person person1= new Person();
        Person person2= new Person();
    }

结果：
	静态代码块
    匿名代码块
    构造方法
    匿名代码块
    构造方法

静态代码块在类一开始加载时就执行，并且只执行一次，匿名代码块在构造方法执行前执行，会执行多次，可用于初始化值

import static java.lang.Math.random;


public class DemoTest {
    public static void main(String[] args) {
        System.out.println(Math.random());
        System.out.println(random());
        
    }
    
}

静态导入包，可以直接调用方法，不需要写类名称

2.abstract

抽象类，作用就是在抽象类写一些抽象方法，由子类去继承实现，目的是对子类进行一个约束，但由于java的单继承特性，一般我们使用接口来实现这个效果

特点：

• 不能new抽象类，只能通过子类实现
• 抽象类中是可以写普通方法的，普通方法子类可以重写，也可以不重写，无论是否重写，子类都可以调用这个普通方法
• 抽象方法必须写在抽象类中

public abstract class Action {

   public abstract void say();

   public void run(){
       System.out.println("run");
   }
}

public class ActionSon extends Action{
    @Override
    public void say() {
        System.out.println("say");
    }

    @Override
    public void run(){
        System.out.println("run-son");
    }
}

public class DemoTest {
    public static void main(String[] args) {
      ActionSon son = new ActionSon();
      son.run();
      son.say();

    }
}

3.接口

public interface UserService {
    void add();
}

public interface PersonService {
    void delete();
}

public class serviceImpl implements UserService, PersonService {
    @Override
    public void delete() {

    }

    @Override
    public void add() {

    }
}

接口通过interface关键字定义，implements关键字实现，一个类可以实现多个接口，实现接口后，必须重写其中的方法

接口中的方法默认是 public abstract,接口中也可以定义常量，常量默认是 public static final，但一般不会在接口中定义常量

4.N种内部类了解

成员内部类

public class Outer {

    private int id;

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

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

    }
    
}

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

静态内部类 内部类前面加static修饰

public class Outer {

    private int id;

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

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

    }
    
}

局部内部类 在一个类中的方法中，再次写一个类

public class Outer {

    public void method(){

        class A{
        }
    }

}

匿名内部类

public interface UserService {
    void add();
}

public class DemoTest {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存到变量中
        new UserService(){
            @Override
            public void add() {

            }
        };
    }
}

5.异常

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

异常发生在程序运行期间,它影响了正常的程序执行流程。

1.异常的类型：

检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如

要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。

运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译

时被忽略。

错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出

时，一个错误就发生了，它们在编译也检查不到的。

异常体系结构

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

2.处理异常

五个关键字分别是： try 、 catch 、 finally 、 throw 、 throws

try -- 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内，当try语句块内发生异常

时，异常就被抛出。

catch -- 用于捕获异常。catch用来捕获try语句块中发生的异常。

fifinally -- fifinally语句块总是会被执行。它主要用于回收在try块里打开的物力资源(如数据库连接、网络

连接和磁盘文件)。只有fifinally块，执行完成之后，才会回来执行try或者catch块中的return或者throw语

句，如果fifinally中使用了return或者throw等终止方法的语句，则就不会跳回执行，直接停止。

throw -- 用于抛出异常。

throws -- 用在方法签名中，用于声明该方法可能抛出的异常。

3.自定义异常

可以通过继承Exception类来自定义异常，一般情况下用不到。

狂神说视频链接 : 73~79