02-接口、static、final、代码块

1、Interface

1.1、概念

​ 接口中全是抽象方法，接口是比抽象类还抽象的类，接口体现的是规范

1.2、格式

interface 接口名{
  常量;
  抽象方法;
}

1.3、类实现接口的格式

• 类和接口是实现关系----implements
• class 类名 implements 接口
• 实现了接口的类称为--实现类

1.4、接口使用步骤

• 1. 定义类实现接口
  2. 重写抽象方法
  3. 使用实现类（创建实现类对象，调用方法）

1.5、示例代码

USB接口

// Usb接口 接口=规范, 交给实现类做具体实现
public interface Usb {
    // 连接电脑
    public abstract void connect();
    // 传输数据
    public abstract void sendData();
    // 断开连接
    public abstract void disconnect();
}

USB鼠标

// Usb鼠标实现Usb接口
public class UsbMouse implements Usb {
    @Override
    public void connect() {
        System.out.println("Usb鼠标连接啦");
    }
 
    @Override
    public void sendData() {
        System.out.println("Usb鼠标发送数据");
    }
 
    @Override
    public void disconnect() {
        System.out.println("Usb鼠标断开");
    }
}

USB键盘

// Usb键盘实现Usb接口
public class UsbKeyboard implements  Usb {
    @Override
    public void connect() {
        System.out.println("Usb键盘连接啦!");
    }
 
    @Override
    public void sendData() {
        System.out.println("Usb键盘发送数据!");
    }
 
    @Override
    public void disconnect() {
        System.out.println("Usb键盘断开连接!");
    }
}

测试类

public class Demo05 {
    public static void main(String[] args) {
        // 不能创建接口对象
        // Usb usb = new Usb();
 
        // 使用接口的实现类
        // 创建Usb鼠标
        UsbMouse usbMouse = new UsbMouse();
        usbMouse.connect();
        usbMouse.sendData();
        usbMouse.disconnect();
 
        System.out.println("--------------------------------------");
 
        // 创建Usb键盘
        UsbKeyboard usbKeyboard = new UsbKeyboard();
        usbKeyboard.connect();
        usbKeyboard.sendData();
        usbKeyboard.disconnect();
    }
}

1.6、接口中成员的特点

• 接口中的方法默认就是抽象方法，会自动添加：public abstract
• 接口中定义的变量是常量，会自动添加：public static final

1.7、接口的多实现

1.7.1、Java中类只能单继承

• 一个类只有一个父类
  • class 子类 extends 父类

1.7.2、Java中类可以同时实现多个接口

• class 类名 implements 接口1,接口2,接口3,....

1.8、接口的多继承

• interface 接口名 extends 接口1,接口2,....
• 开发中一般很少用接口多继承，主要是源代码中可能会看到

1.8.1 面试题

• Java中有多继承吗？
  • 有
  • 类只能单继承
  • 接口可以多继承

1.9 JDK1.8以后有关接口的新增方法

1.9.1、默认方法

• 默认方法的格式
  • public default 返回值类型 方法名(参数列表)
• 默认方法的使用
  • 实现类直接使用
  • 重写接口的默认方法

1.9.2、静态方法

• 静态方法的格式
  • 修饰符 static 返回值类型 方法名()
• 静态方法的使用
  • 接口名.静态方法名();

1.9.3、私有方法

• 私有方法格式
  • private 返回值类型 方法名()
• 私有方法的使用
  • 给本接口的默认方法或静态方法使用

示例代码

接口类

public interface Aaa {
    // JDK8接口新增默认方法
    // 1.实现直接使用
    // 2.重写接口的默认方法
    default void test01() {
        System.out.println("我是接口默认方法");
        test03();
        test03();
    }
 
    // JDK8接口新增静态方法
    // 接口名.静态方法名();
    static void test02() {
        System.out.println("我是接口静态方法");
        test03();
    }
 
     // JDK9接口新增私有方法 (给本接口的其他方法使用)
    // 接口的私有方法是JDK9推出的.如果同学们使用JDK1.8会报错,不识别,忽略即可
    private static void test03() {
        System.out.println("我是接口私有方法");
    }
}

测试类

public class Demo09 {
    public static void main(String[] args) {
        Bbb bbb = new Bbb();
        bbb.test01();
 
        // 接口名.静态方法名();
        // bbb.test02();
        Aaa.test02();
 
        // bbb.test03();
    }
}

2、static

2.1 static修饰成员变量

2.1.1、概念

• static是静态的意思，可以修饰成员变量和成员方法

2.1.2、 作用

• static修饰的变量在内存中只有一份，可以被这个类的所有对象直接共享访问，解决特定场景问题，同时减少内存消耗。

2.1.3、格式

• 对象名.静态成员变量
• 类名.静态成员变量（建议使用的格式）

2.2、static修饰成员方法

2.2.1、概念

​ static修饰的方法是静态方法

2.2.2、作用

​ 可以使用类名调用

2.2.3、格式

• 对象名.静态方法()
  • eg: new Student().daKa();
• 类名.静态成员方法()---（建议使用的格式）
  • Student.daKa();

2.2.4、注意事项

• 同一个类中，静态方法只能访问静态修饰的成员
  • 静态只能访问静态
• 静态方法中没有this关键字

3、modifier

3.1、概念

​ 是用来控制一个类中成员能够被访问的范围

3.2、使用

​ 可以修饰成员变量，成员方法，构造器，内部类

3.3、作用范围

• 作用范围从小到大
  • private < 缺省 < protected < public

3.4、常用的modifier

• private，私有的，只有本类可以使用
• public，公开的，所有地方都能使用

3.5、不常用的modifier

• 缺省的（即默认的），给本包的类使用
• protected，受保护的，给子类使用

3.6、定义成员的一般要求

• 成员变量一般私有，并设置get、set方法
• 方法一般公开

4、final

4.1、概念

​ final关键字是最终、不可变的意思

4.2、使用

​ 可以修饰类、方法、变量

4.3、final关键字修饰的特点

• 修饰类
  • 表明该类是最终类，不能被继承
• 修饰方法
  • 表明该方法是最终方法，不能被重写
• 修饰变量
  • 表示该变量是常量，即该变量第一次赋值后，不能多次被赋值

4.4、注意事项

• 变量是基本类型
  • final修饰指的是基本类型的数据值不能发生改变
• 变量是引用类型
  • final修饰指的是引用类型的地址置不能发生改变，但是地址里面的内容是可以发生改变的

5、code block

5.1、概念

​ {}括号括起来的代码被称为代码块

5.2、构造代码块

• 格式
  • {}
• 特点
  • 每次创建对象，调用构造器执行前，都会执行该代码块中的代码

5.3、静态代码块

• 格式
  • static {}
• 特点
  • 随着类的加载而加载，执行的最早，并且自动触发一次
• 使用场景
  • 做一些静态数据初始化的操作

5.4、示例代码

Student类

public class Student {
    public Student() {
        System.out.println("构造器执行啦!");
    }
 
    // 静态代码块
    static {
        System.out.println("静态代码块执行啦!");
    }
 
    // 构造代码块
    {
        System.out.println("构造代码块执行啦!");
    }
}

测试类

public class Demo14 {
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
        Student s3 = new Student();
    }
}

执行效果

静态代码块执行啦!
 
构造代码块执行啦!
构造器执行啦!
 
构造代码块执行啦!
构造器执行啦!
 
构造代码块执行啦!
构造器执行啦!

5.5、静态代码块案例：斗地主游戏

• 定义一个静态的ArrayList集合存储牌
• 使用静态代码块进行静态集合的初始化操作，将54张牌存入到静态集合中去

Room类

// 房间, 创建一个房间就要准备好一副牌 (54张)
public class Room {
    //             类型 变量名 = 值;
    private static String name = "房间一";
    // 静态的成员变量
    private static ArrayList<String> pokerList = new ArrayList<>();
    // 一创建房间就要有一副牌,我们选在在静态代码块中创建
    static {
        pokerList.add("大王");
        pokerList.add("小王");
        String[] numbers = {"2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3"};
        String[] colors = {"♠", "♥", "♣", "♦"};
        // 遍历花色
        for (int i = 0; i < colors.length; i++) {
            String color = colors[i];
            // 遍历数字
            for (int j = 0; j < numbers.length; j++) {
                String number = numbers[j];
 
                String poker = color + number;
                pokerList.add(poker);
            }
        }
 
        System.out.println("静态代码块初始化好了一副牌: " + pokerList);
    }
}