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 的异常.

  • 三种类型的异常

    • 检查性异常:最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时,一个异常就发生了,这些异常在编译时不能被简单地忽略。
    • 运行时异常: 运行时异常是可能被程序员避免的异常。与检查性异常相反,运行时异常可以在编译时被忽略。
    • 错误: 错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时,一个错误就发生了,它们在编译也检查不到的。
  • 处理异常

    1. try catch代码块
    try{
      // 程序代码 可能发生异常的代码
    }catch(异常类型1 异常的变量名1){
      // 程序代码 发生异常类型1, 会进入此代码块
    }catch(异常类型2 异常的变量名2){
      // 程序代码 发生异常类型2, 会进入此代码块
    }finally{
      // 程序代码 不论有没有异常, 都会进入finally块,都会执行里面的代码
    }
    
    1. 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();
      }
    }
    
    1. 自定义异常

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

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

      如果希望写一个检查性异常类,则需要继承 Exception 类。

      class MyException extends Exception{ }
      

      如果你想写一个运行时异常类,那么需要继承 RuntimeException 类。

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