java基础-static/抽象类/接口/错误和异常/捕获和抛出错误

static关键字详解

1. 静态的变量

   public class Main {
       private static int age=18;
       private double score=100;
   
       public void run()
       {
           System.out.println("run");
       }
       public static void go()
       {
           System.out.println("go");
       }
       public static void main(String[] args) {
           System.out.println(age);
           go();
           /*
           定义为static的，可以直接使用
           System.out.println(score);
           run();
           */
       }
   }
   

2. 静态代码块

   public class Main {
       {
           System.out.println("匿名代码块");
       }
       static
       {
           System.out.println("静态代码块");
       }
       public Main()
       {
           System.out.println("构造方法");
       }
   
       public static void main(String[] args) {
           new Main();
       }
   }
   /*输出顺序
   静态代码块
   匿名代码块
   构造方法
   */
   

3. 静态导入包

4. final定义的类，不能被继承

抽象类

1. abstract抽象类

   public abstract class Main {
       public abstract void DoSomething();
       public abstract void Go();
   }
   

2. 抽象类定义的东西，只写名字。

3. 不能new，必须由继承它的类来实现。

4. java的类是单继承，接口是多继承的。

5. 抽象方法只能放在抽象类里，且抽象类可以写入普通方法。

接口

1. interface

   public interface Main {
     	//接口里定义的都是常量,public static final
     	int age=10;
     	//接口里定义的方法都是抽象的，public abstract
       void DoIt();
       int ReturnThis(int A);
   }
   

2. 接口必须有个实现类

3. 可以被多继承

   class Main3  implements Main,Main2{
   
       @Override
       public void DoIt() {
   
       }
   
       @Override
       public int ReturnThis(int A) {
           return 0;
       }
   }
   

内部类

1. 一个类中放入另一个类
2. 匿名内部类

Erroe 和 Exception

1. 检查性异常

2. 运行时异常

3. 错误

4. 异常处理体系

5. Error类对象由java虚拟机生成并抛出，大多数错误与代码编写者无关。
6. Exception类错误通常由程序员有关。
7. 区别：Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，java虚拟机一般选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

捕获和抛出异常

1. 五个关键词try,catch,finally,throw,throws

2. Try, catch,finally

   public class demo {
       public static void main(String[] args) {
           int a=1;
           int b=0;
           try{
               a=a/b;
           }catch(Exception e)
           {
               System.out.println("程序输出异常");
           }
           finally {
               System.out.println("无论如何都执行");
           }
       }
   }
   

3. 可以有多个catch来捕获多个异常

   最严重的写在最后

   public class demo {
       public static void main(String[] args) {
           int a=1;
           int b=0;
           try{
               a=a/b;
           }catch (Error e)
           {
               System.out.println("Error");
           }
           catch(Exception e)
           {
               System.out.println("Exception");
           }catch (Throwable e)
           {
               System.out.println("Throwable");
           }
           finally {
               System.out.println("无论如何都执行");
           }
       }
   }
   

4. 快捷键option+command+T

   可以把代码包裹起来

4. 打印错误

   catch(Exception e)
           {
               e.printStackTrace();
           }
   

5. 主动地抛出异常throw，一般放在方法中

   public class demo {//其实是没有异常的
       public static void main(String[] args) {
           new demo().a();
       }
       public void a(){
           throw new ArithmeticException();
       }
   }
   

6. 方法内无法处理这异常，可以在方法上抛出异常

   public class demo {
       public static void main(String[] args) {
           new demo().a();
       }
       public void a() throws ArithmeticException{
           throw new ArithmeticException();
       }
   }
   

7. Try catch当发生异常时可以进行处理

自定义异常

1. 自己写一个异常类继承exception