Java类和接口

对象 Object

java 是面向对象的语言：对象包含了状态和行为，用户通过调用对象的方法、改变对象的属性来实现 java 程序的功能

Car myCar = new Car("BMW");                          // 创建对象       
me.brand = "Benz";                                   // 修改对象变量                   
me.go("London");                                     // 调用对象方法

在 java 程序中我们通过类和接口来定义对象的性质：每个 java 文件都是一个定义好的 public 类 / 接口，且类名 / 接口名与文件名相同。

java 文件可以含有多个类 / 接口，但只能有一个 public 类 / 接口供外部访问。

类 Class

对象的类型：定义对象含有的变量和方法。

public class Car {     
    // 变量
    String brand;
    String description = "this is a car";
    // static 变量 
    static int number_of_car;  
    // 构造方法
    public car(String brand){        
        this.brand = brand;
    } 
    // 方法  
    public void go(String loc){
        System.out.print("go to" + loc);
    }   
    // static 方法
    void static showNum(){            
        System.out.print(number_of_car);
    }
    // 初始化块
    {       
        number_of_car;                                      
    }
    // static 初始化块
    static{                                                              
        number_of_car = 0;
    }
    // 内部类
    public class Warranty{
        public void repair(){
            System.out.print("repair");
        }    
    }
}

• 变量

对象中存储的数据。

• 方法

调用时执行的代码。

• 初始化块

创建对象前自动执行的代码。

• 内部类

定义在类中的类。

• 构造方法

在创建对象时自动执行，不返回任何参数（先执行初始化块，再执行构造方法）。

未定义任何构造方法时，系统会自动添加无参构造方法。

终态声明

• final 常量： 只能赋值一次，不可更改。
• final 类： 不可被继承。
• final 方法：（弃用）不可被继承。现在所有的 private 方法都隐式地指定为 final。

对于 final 常量，如果编译时就可以确定值，编译器会在编译时直接把这个变量替换成它的值。

静态声明

• static 变量：该变量由该类的所有对象共享，不需要创建对象也可使用。
• static 方法：允许直接访问，不需要创建对象也可被调用。如 main 方法。
• static 初始化块：在创建类的第一个对象前自动执行（先执行静态初始化块，再执行初始化块）。
• static 内部类：外部类对象共享，只能访问外部类的静态成员。

权限声明

• public： 允许所有访问。
• protected： 只允许本类、同包和子类访问。
• [default]： 允许本类和同包访问。
• private： 只允许本类访问。

 接口 Interface

类的规范：只规定应含有哪些方法，而不负责具体实现。

public interface Move{  
    // abstract 方法                   
    public void go(String loc);
    // default 方法                                 
    default void stop() {      
        System.out.print("stop");
    };                  
}

1. 声明接口：必须且默认为 static final，通常为 public 。
2. 只允许声明静态常量：必须且默认为 public static final 。
3. 声明抽象方法：必须且默认为 abstract ，可以为 static。

JDK 1.8 以前，接口中抽象方法必须且默认为 public，不允许实现任何方法。 JDK 1.8 以后，接口中抽象方法可以且默认为 default，且允许实现 static 和 default 方法。 JDK 1.9 以后，接口中抽象方法可以是 private。*

         抽象声明

• abstract 方法：只有声明，而没有方法的具体实现。
• abstract 类：类的模板，不能实例化对象。必须由其他类继承才能使用。

public abstract class Vehicle {
    // 声明变量
    String brand;
    // 声明并实现方法
    public void go(String loc){
        System.out.print("go to" + loc);
    }   
}

接口和抽象类的区别

1. 接口不能实现普通方法，抽象类可以实现具体的方法、也可以不实现。
2. 接口只能定义静态常量，抽象类可以定义非静态变量。
3. 一个实体类可以实现多个接口，但只能继承一个抽象类。

更新声明

• default 方法：更新接口时添加的新方法，允许旧类实现接口而不实现该方法。

  • 可以直接在接口内实现，供没有定义的旧类直接使用。若类中实现了该方法则覆盖。

  • 如果类实现了多个接口且拥有同名 default 方法：

    1. 两个接口若存在继承关系，调用时优先使用子类方法。
    2. 否则，必须重写子类 default 方法，通过 super 关键字明确实现哪个接口：

class Plane implements Move, Fly{
    ...
    void go(){
        Fly.super.go();                 // 实现选定 default 方法
    }
}

包 Package


命名空间，表示 java 文件的存储路径。其路径记录在每个 java 文件首。

package com.company.project.module;                    // 声明存储路径

导入 import

在 java 文件中，如果要调用其他 java 文件中定义的类 / 接口，就需要进行导入：

• 同一存储路径（包）下的 java 文件不需要导入，可以直接调用。

• 已默认导入 java.lang 路径下所有 java 文件，包含 System、String、Object、Math 等常用类。

• 如果没有导入对应 java 文件，或者导入了多个同名 java 文件，在调用类 / 接口时需要标明路径。

package com.company.project.module;  

import java.util.Scanner;                             // 导入 java 文件，但不包括内部 static 变量和方法
import java.net.*;                                    // 导入路径下所有 java 文件，但不包括下属文件夹
import static java.lang.Math.PI;                      // 导入 java 文件中的 static 变量或方法

public class Test{
    public void main(String[] args){
        java.io.InputStream in = new java.io.InputStream(System.in);    // 未导入类，调用时需要标明路径
        Scanner sc = new Scanner(in);                                   // 已导入类，可直接调用
        Integer n = sc.nextInt();                                       // 默认导入类，可直接调用
        sc.close();           
    }
}