02-接口、static、final、代码块
1、Interface
1.1、概念
接口中全是抽象方法，接口是比抽象类还抽象的类，接口体现的是规范
1.2、格式
interface 接口名{
常量;
抽象方法;
}
1.3、类实现接口的格式
- 类和接口是实现关系----implements
- class 类名 implements 接口
- 实现了接口的类称为--实现类
1.4、接口使用步骤
-
- 定义类实现接口
- 重写抽象方法
- 使用实现类（创建实现类对象，调用方法）
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);
}
}
浙公网安备 33010602011771号