static修饰静态代码块 ，interface

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 修饰的方法必须没有方法体】
    两者无法合作！！！