Java———static关键字,代码块,abstract关键字,interface,内部类,异常处理

时间：2021-04-16 12:10:29 收藏：0 阅读：0

static关键字

被static修饰的成员变量属于类，不属于这个类的某个对象。（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）
被static修饰的成员可以通过类名直接访问

访问静态成员的格式:
1. 类名.静态成员变量名
2. 类名.静态成员方法名(参数)
静态的加载优先于对象,随着类的加载而加载
static的注意事项：
1. 静态方法：只能调用静态的成员变量/成员方法.
2. 非静态方法：能调用静态和非静态的成员变量/成员方法.
静态的优点:
1. 对对象的共享数据提供单独空间的存储，节省空间，没有必要每一个对象都存储一份
2. 可以直接被类名调用,不用在堆内存创建对象
3. 静态成员可以通过类名直接访问,相对创建对象访问成员方便
静态的缺点
1. 访问出现局限性。（静态虽好，但只能访问静态）

代码块

局部代码块

{
    /**
    局部代码块
    以”{}”划定的代码区域，此时只需要关注作用域的不同即可, 方法和类都是以代码块的方式划定边界的.
    */
}

静态代码块

static {
    /* 
    静态代码块
    它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。该类不管创建多少对象，静态代码块只执行一次.
    可用于给静态变量赋值，用来给类进行初始化.
    */
}

构造代码块

public/private Class{
    /*
    构造方法
    构造代码块用于执行所有对象均需要的初始化动作,每创建一个对象均会执行一次构造代码块。
    */
}

public class Student {
    public Student(){
        System.out.println("Student的构造方法");
    }
    static{
        System.out.println("Student静态代码块");
    }
    {
        System.out.println("Student局部代码块");
    }
}
public class Day05Test {
    public static void main(String[] args) {
        Student student = new Student();
    }
}
控制台输出:
Student静态代码块
Student局部代码块
Student的构造方法

Process finished with exit code 0

public class Person {
    public Person(){
        System.out.println("Person的构造方法");
    }
    static{
        System.out.println("Person静态代码块");
    }
    {
        System.out.println("Person局部代码块");
    }
}
public class Student extends Person{
    public Student(){
        System.out.println("Student的构造方法");
    }
    static{
        System.out.println("Student静态代码块");
    }
    {
        System.out.println("Student局部代码块");
    }
}
public class Day05Test {
    public static void main(String[] args) {
        Student student = new Student();
//        Person person = new Student();
    }
}
控制台输出:
Person静态代码块
Student静态代码块
Person局部代码块
Person的构造方法
Student局部代码块
Student的构造方法

Process finished with exit code 0

abstract关键字

abstract修饰的类叫做抽象类, 不能使用new 抽象类, 抽象类中可以有普通方法, 也可以有抽象方法.
abstract修饰的方法叫做抽象方法, 只有方法的定义,没有具体的实现, 只能让子类,子孙类去完成具体的实现.
一个类继承了抽象类, 要么把这个类声明为抽象类, 要么重写抽象类的所有抽象方法.

接口(interface)

接口像法律,像契约, 是一种设计好/定义好的约束, 没有具体的实现.
接口不能被实例化, 接口中没有构造方法
一个类可以实现(implements)多个接口, 需要重写接口中的方法
```
class A implements B, C, D{
}
```

内部类

public class Person {
    public static void main(String[] args) {
        new Person().get();
    }
    class A {
        // 内部类 可以访问到外部类的私有属性和方法
    }
    public static class B {
        // 静态内部类 可以访问到外部内的静态属性和静态方法
    }
    public void get(){
        class C{
            // 局部内部类
        }
    }
}

Java异常处理

异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的.

比如说，你的代码少了一个分号，那么运行出来结果是提示是错误 java.lang.Error.

如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出 java.lang.ArithmeticException 的异常.
三种类型的异常
- 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
- 运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
- 错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

处理异常

try catch代码块

try{
  // 程序代码 可能发生异常的代码
}catch(异常类型1 异常的变量名1){
  // 程序代码 发生异常类型1, 会进入此代码块
}catch(异常类型2 异常的变量名2){
  // 程序代码 发生异常类型2, 会进入此代码块
}finally{
  // 程序代码 不论有没有异常, 都会进入finally块,都会执行里面的代码
}

throws, throw关键字: 如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。

也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。

public class className
{
   public void withdraw(double amount) throws RemoteException,
                              InsufficientFundsException
   {
       // Method implementation
   }
}

public class className
{
  public void deposit(double amount) throws RemoteException
  {
    // Method implementation
    throw new RemoteException();
  }
}

自定义异常

在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。

所有异常都必须是 Throwable 的子类。

如果希望写一个检查性异常类，则需要继承 Exception 类。
```
class MyException extends Exception{ }
```
如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。

只继承Exception 类来创建的异常类是检查性异常类。