1. static
1.1 static 修饰静态代码块
1.1.1 代码块问题
什么是代码块?
{} 只有大括号,里面的内容就是代码块内容
1、构造代码块
定义在类内
2、局部代码块
定义在方法内
构造代码块一般存放位置:在成员变量之后,构造方法之前。
1、构造代码块在调用执行构造方法时,一定执行
2、构造代码块在调用执行构造方法时,首先执行
可以将构造方法相同的功能模块, 使用构造代码块封装/归纳/总结,并且可以提供给所有构造方法使用。
// 构造代码块案例
public class Person {
private int id;
private String name;
private int age;
{
System.out.println("构造代码块执行");
}
public Person() {
System.out.println("构造方法");
}
public Person(int id) {
this.id = id;
System.out.println("构造方法");
}
public Person(int id, String name) {
this.id = id;
this.name = name
System.out.println("构造方法");
}
}
//局部代码块
public class Demo2 {
public static void main(String[] args) {
int num = 10;
/*
* 局部代码块,优化变量内存占用的时间,提升代码内存效率,降低内存占用
* 目前属于淘汰阶段
*/
{
int num2 = 20;
}
System.out.println(num);
// System.out.println(num2);
}
}
1.1.2 static 修饰静态代码块基本句法和代码案例
// 静态代码块要求在 class 大括号以内
static {
}
class SingleDog {
public int num = 10;
public static int test = 10;
/*
* 静态代码块
* 在类文件加载阶段执行,有且只执行一次,因为 Java 中的所有类型都是在
* 执行之前加载一次,不会重新加载。
*/
static{
/*
* Cannot make a static reference to the non-static field num
* 不能使用一个静态引用执行一个非静态成员变量 num
* static 修饰的静态代码块可以认为是一个静态区域,无法直接使用类内的非静态成员变量,因为【没有对象】
*/
// System.out.println(num);
/*
* static 修饰的静态代码块,可以直接使用类内的静态成员变量,因为【没有对象,难兄难弟,互不嫌弃】
*/
System.out.println(test);
/*
* Cannot make a static reference to the non-static method test() from the type SingleDog
* 不能使用一个静态的引用执行/调用 SingleDog 类内非静态成员方法 test
*
* static 修饰的静态代码块可以认为是一个静态区域,无法直接使用类内的非静态成员变量,因为【没有对象】
*/
// test();
/*
* static 修饰的静态代码块,可以直接使用类内的静态成员方法,因为【没有对象,难兄难弟,互不嫌弃】
*/
testStaticMethod();
System.out.println("静态代码块内容");
}
public void test() {
System.out.println("非静态成员方法");
}
public static void testStaticMethod() {
System.out.println("静态成员方法");
}
}
public class Demo3 {
public static void main(String[] args) {
System.out.println("测试");
SingleDog s1 = new SingleDog();
SingleDog s2 = new SingleDog();
SingleDog s3 = new SingleDog();
SingleDog s4 = new SingleDog();
SingleDog s5 = new SingleDog();
SingleDog s6 = new SingleDog();
SingleDog s7 = new SingleDog();
SingleDog s8 = new SingleDog();
SingleDog s9 = new SingleDog();
SingleDog s10 = new SingleDog();
}
}
1.1.3 静态代码块特征
1、static 修饰静态代码块,在程序加载阶段一定执行,有且只执行一次。
2、static 修饰静态代码块,不能直接使用类内的非静态成员(成员变量和成员方法),因为【没有对象】
3、static 修饰静态代码块,可以直接使用类内的静态成员(类变量和类方法),因为【没有对象】
4、static 修饰静态代码块,用于项目启动过程中的初始化操作。
可以利用static 代码加载阶段执行的特征,将一些项目执行所需的配置操作前置
用于 读取配置文件,加载相关驱动,加载第三方资源。。。。
1.2 static 面试题
class Demo {
public static Demo d1 = new Demo();
public static Demo d2 = new Demo();
static {
System.out.println("静态代码块");
}
{
System.out.println("构造代码块");
}
public Demo(){
System.out.println("构造方法");
}
public static void main(String[] args) {
Demo d = new Demo();
}
}
以上代码的执行流程时:
构造代码块 构造方法 构造代码块 构造方法 静态代码块 构造代码块 构造方法
2. interface
2.1 java中的定义接口格式
关键字:interface
格式:
interface 接口名 {
成员变量
成员方法
}
1、接口是一个特殊的类,也是一个数据类型
2、接口要求符合命名规则,见名知意,大驼峰命名法
3、接口类型变量也是一个引用数据类型变量
/*
* 自定义 接口 A
*/
interface A {
/*
* 成员变量
* The blank final field num may not have been initialized
* final 修饰的 num 可能尚未初始化
*
* final从而而来? 斜体因为何事???
*
* 接口中成员变量的【缺省属性/默认属性】 public static final
* public 表示数据公开,任何位置都可以使用 ==> USB 接口所有设备使用者都可以知晓对应的尺寸信息
* static 静态修饰,独一份 ==> USB 相关数据独一份,大家都需要遵守
* final 最终修饰/不可修改修饰 ,常量 ==> USB 接口数据不可以修改
*
* 【带有名称的常量】 ==> 下划线命名法处理,所有字母全部大写,不同英文单词之间使用 _ 下划线分割
*/
int NUM = 10;
/*
* Abstract methods do not specify a body
* abstract 修饰的方法没有方法体
*
* 接口中的成员方法【缺省属性/默认属性】 public abstract
* public 表示方法公开,标志公开 ==> USB 接口需要公开连接规则,连接方式,连接要求
* abstract 修饰没有方法体 ==> USB 接口仅制定方法要求,具体实现看对应设备,USB ==> 鼠标, 键盘...
* USB 接口具体做什么,不是 USB 接口本身决定,是由 USB 接口连接的设备决定。
*/
void test();
}
2.3 遵从接口
类遵从接口
关键字:
implements
格式:
class 类名 implements 接口名 {
}
/**
* 一个非 abstract 修饰类【遵从】接口,要求实现接口中所有缺省属性为
* public abstract 修饰的方法
* @author Anonymous
*
*/
class TypeA implements A {
@Override
public void test() {
System.out.println("TypeA 类遵从接口 A 实现 test 方法");
}
}
2.4 接口的特殊用法
2.4.1 类可以遵从多个接口
语法要求:
1. 遵从多个接口的类,要求分别实现各个接口中的方法要求
2. 如果出现多个接口中存在完全相同的方法声明,实现类中有且只实现一个方法即可
interface B {
void testB();
// 和 接口 C 方法声明一致的方法
void test();
}
interface C {
void testC();
// 和 接口 B 方法声明一致的方法
void test();
}
/*
* TypeB 类同时遵从两个接口, 分别是 interface B 和 interface C
* 不同的接口直接使用, + 空格隔开
*
*
* 语法要求:
* 1. 遵从多个接口的类,要求分别实现各个接口中的方法要求
* 2. 如果出现多个接口中存在完全相同的方法声明,实现类中有且只实现一个方法即可
*/
class TypeB implements B, C {
@Override
public void testC() {
System.out.println("TypeB 遵从接口 C 实现 testC 方法");
}
@Override
public void testB() {
System.out.println("TypeB 遵从接口 B 实现 testB 方法");
}
@Override
public void test() {
System.out.println("TypeB 遵从接口 B 和 接口 C 实现的两个接口中同规则方法");
}
}
public class Demo2 {
public static void main(String[] args) {
TypeB typeB = new TypeB();
typeB.testB();
typeB.testC();
}
}
2.4.2 类可以继承父类同时遵从接口
class SuperClass {
public void testA() {
System.out.println("父类成员方法");
}
}
interface D {
void testD();
}
/*
* TypeC 类继承 SuperClass 同时遵从接口 D
*/
class TypeC extends SuperClass implements D {
/*
* implements com.qfedu.b_interface.D.testD
* 紫色空心箭头 --> 实现接口中的方法
*/
@Override
public void testD() {
System.out.println("TypeC 遵从接口 D 实现的 testD 方法");
}
/*
* overrides com.qfedu.b_interface.SuperClass.testA
* 绿色实心箭头 --> 重写父类继承到子类的方法
*/
@Override
public void testA() {
System.out.println("子类重写父类方法");
}
}
public class Demo3 {
public static void main(String[] args) {
TypeC typeC = new TypeC();
typeC.testA();
typeC.testD();
}
}
2.4.3 接口可以继承其他接口,并且可以多继承
interface USB1_0 {
void usb1_0Connect();
}
interface USB2_0 {
void usb2_0Connect();
}
/*
* 接口可以继承其他接口,同时允许多继承
*/
interface USB3_0 extends USB1_0, USB2_0 {
void usb3_0Connect();
}
/*
* 类遵从接口,要求实现接口中所有的缺省属性/默认属性为 public abstract 修饰方法
* 包括当前接口的父接口要求方法。
*/
class TypeD implements USB3_0 {
@Override
public void usb1_0Connect() {
System.out.println("USB 1.0 协议规定方法");
}
@Override
public void usb2_0Connect() {
System.out.println("USB 2.0 协议规定方法");
}
@Override
public void usb3_0Connect() {
System.out.println("USB 3.0 协议规定方法");
}
}
public class Demo4 {
public static void main(String[] args) {
TypeD typeD = new TypeD();
typeD.usb1_0Connect();
typeD.usb2_0Connect();
typeD.usb3_0Connect();
}
}
2.4.4 JDK 1.8 版本以上特征
允许在接口中使用 default 关键字修饰方法,修饰的方法为默认方法,允许有方法体。
interface E {
void test();
default void testDefaultMethod() {
System.out.println("JDK 1.8 以上版本允许的默认方法 default 修饰");
}
}
class TypeE implements E {
@Override
public void test() {
System.out.println("TypeD 有且只需要完成即可 E 中的缺省属性为 public abstract 对应方法");
}
/*
* 重写接口中的 default 关键字修饰的方法
*/
// @Override
// public void testDefaultMethod() {
// System.out.println("重写接口中的 default 关键字修饰的默认成员方法");
// }
}
public class Demo5 {
public static void main(String[] args) {
TypeE typeE = new TypeE();
typeE.test();
typeE.testDefaultMethod();
}
}
2.4.5 接口语法细节
接口中是否可以用 static 修饰静态成员方法?
可以
static 修饰的方法直接通过该接口名调用。
一个方法是否可以同时使用 abstract 和 static 关键字修饰?
不行
abstract 关键字修饰的方法没有方法体
static 修饰的方法是在类文件加载阶段已经准备就绪,已具备执行能力,必须明确所有和执行相关的内容,权限修饰符符,返回值类型,方法名,形式参数列表和方法体。
【static 修饰的方法必须有方法体】
【abstract 修饰的方法必须没有方法体】
两者无法合作!!!