Java第九天：static【重点】，接口

static【重点】，接口

1. static【重点，难点】

static修饰的所有内容和对象无关

1.1 static修饰静态成员变量

1.1.1 生活中静态成员变量

饮水机
	1. 有一定的数量
	2. 在公共区供大家使用
	3. 你来之前，饮水机在这里，你走之后，饮水机依然在这里

共享单车
	1. 有一定的数量
	2. 一定在公共区域内
	3. 共享单车在与不在和你没有关系，你来这里之前，他已经存在，你走之后他依旧存在
	
开发中有没有类似的数据:
	1. 数据
	2. 在公共区域
	3. 和对象无关
中华人民共和国 7个字 UTF-8 21byte
14亿人口

1.1.2 代码中使用静态成员变量【重点】

package com.qfedu.a_staticfield;

class Person {

    // 成员变量
    String name;
    int age;

    // 静态修饰并且初始化的成员变量
    static String country = "中华人民共和国";

    public Person() {}

    public void test() {
        System.out.println("FPX总冠军 我们又是冠军，我们总是冠军");
        name = "骚磊";
        age = 16;

        country = "中国";
    }
}

/*
特征：
    1. 静态成员变量使用类对象调用时，提示有警告，但是可以使用，【墙裂不推荐】
    2. 静态成员变量使用类名调用时，没有任何问题，【墙裂推荐】
    3. 静态成员变量是一个共享数据，不管通过哪一个方式来修改对应成员变量的数据，所有使用
    该成员变量的地方都会受影响，例如: 饮水机里放巴豆
    4. 类内的非静态成员方法可以直接使用类内的静态成员变量，和非静态成员变量
 */
public class Demo1 {
    public static void main(String[] args) {
        System.out.println(Person.country);
    }
}

1.1.3 静态成员变量使用注意事项【重点】

1. 静态成员变量推荐使用类名调用，不推荐使用类对象调用
	因为【没有对象】
2. 通过内存图分析，发现静态成员变量和类对象不属于同一个内存空间，所以可以认为静态成员变量和类对象没有关系
	简称【没有对象】
3. 静态成员变量是随着类文件的加载而直接定义在内存【数据区】，已经可以使用。
	也可以看做【没有对象】
	说明：
		静态成员变量在没有创建类对象之前，已经可以通过类名来调用使用，而且在
		代码运行过程中，类对象已经被JVM的GC垃圾回收机制销毁，静态成员变量依
		旧可以使用。
		通过这个现象我们可以得出，静态成员变量的生存周期是远远长于类对象的。
		所以类对象使用静态成员变量会存在警告提示，其实也是IDE工具给予开发者
		的提示，告知你类对象和静态成员变量无关，
		
4. 静态成员变量一处修改，所有使用到的地方，全部受影响
	【共享资源概念】

1.1.4 静态成员变量和构造代码块完成计数操作

构造代码块是什么?
	{
	
	}
	在类内，方法外，并且一般定义在成员变量之后，构造方法之前。
	用于初始化当前类的所有类对象，只要当前代码中执行了对应类的构造方法，一定
	会执行对应的构造代码块。

package com.qfedu.a_staticfield;

class SingleDog {
    // 成员变量
    int id;
    String name;
    int age;
    char gender;

    // 静态成员变量计数器
    static int count = 1;

    /*
    一般用于类对象的整体初始化，例如: 计数
    使用构造代码块完成一个ID号生成
    变量选择:
        静态成员变量:
            1. 内存数据区
            2. 从类文件加载开始出现，整个程序退出之后销毁，【持久性】
            3. 每一个类对象都可以使用该静态成员变量，是一个相对而言唯一的共享资源。【共享性】
            4. 一处修改，处处受影响。数据存在一定的【持续性】
        普通成员变量:
            存放于内存的堆区，是随着类对象的创建而创建的，并且在每一个类对象中，使用的
            成员变量都是不一样的。没有数据的共享性，并且不具备持久性。【不可以使用】
        局部变量:
            构造代码块使用一个局部变量，使用一次，创建一次，销毁一次，不能持久性记录数据
            这里需要记录上一次数据，以及下一次需要使用的数据，局部变量不具有这样的特征。
            【不可以使用】
     */
    {
        // 给予成员变量ID赋值
        id = count;
        // count += 1 持续赋值。
        count += 1;
        System.out.println("只要执行构造方法，我就会出现！！！来了，老弟~~~");
    }

    public SingleDog() {}

    public SingleDog(String name) {
        this.name = name;
    }

    public SingleDog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public SingleDog(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
}

public class Demo2 {
    public static void main(String[] args) {
        SingleDog singleDog = new SingleDog();
        SingleDog singleDog1 = new SingleDog("小岳岳小龙女");
        SingleDog singleDog2 = new SingleDog("贾玲", 30);
        SingleDog singleDog3 = new SingleDog("刘亦菲", 30, '女');

        System.out.println(singleDog.id); // 1
        System.out.println(singleDog1.id); // 2
        System.out.println(singleDog2.id); // 3
        System.out.println(singleDog3.id); // 4
    }
}

1.2 static修饰静态成员方法

1.2.1 生活中的静态成员方法

对事不对人，也没有对象。

上课不允许迟到，你来千锋学习之前，这规矩就在，你离开千锋之后，这规矩还在。
规矩制定者，执行者，都不是你，而且你只是一个使用者，和遵从者。

没有对象特征，非常明显。

1.2.2 静态成员方法格式【最熟悉的陌生人】

/*
public static 返回值类型 方法名(形式参数列表) {
	方法体
}
*/

package com.qfedu.b_staticmethod;

class SingleDog {
    // 非静态成员变量
    String name;
    int age;

    // 静态成员变量
    static int test = 20;

    public SingleDog() {}

    // 非静态成员方法
    public void game() {
        System.out.println("DNF单身狗模式");
    }

    public static void singleDogLeague() {
        System.out.println("单身狗联盟！！！");
    }

    // 静态成员方法
    public static void testStatic() {
        System.out.println("静态成员方法");
        // 非静态成员变量不能用于静态代码区域
        // name = "Saolei";
        // 非静态成员方法不能用于静态代码区域
        // game();
        // this关键字不能用于静态代码区域
        // this.game();
        test = 10;
        singleDogLeague();
    }
}

/*
静态成员方法使用注意事项:
    1. 静态成员方法推荐使用类名直接调用，不建议使用类对象来调用执行静态成员方法

    2. 静态成员方法在没有类对象是就已经可以使用，而且类对象销毁之后依然可以使用
        静态成员方法的生存周期是早于类对象出现，晚于类对象销毁，和类对象没有关系
        【没有对象】
        静态成员方法时随着类文件的加载而直接定义在内存的【方法区】，并且已经可以
        执行，直到当前程序退出之后，才会销毁内存【代码区】的【静态成员方法】

    3. 请问静态成员方法可以使用非静态成员变量和非静态成员方法吗?
        不能使用，因为【没有对象】

    4. 请问静态成员方法中能不能使用this关键字?
        this关键字是调用当前方法的类对象，但是静态成员方法时可以通过类名调用的，在
        使用类名调用时，this不能表示类名，同时也【没有对象】

    5. 请问静态成员方法中能不能使用类内的其他静态成员变量和静态成员方法?
        可以使用，难兄难弟，都没有对象！！！
 */
public class Demo1 {
    public static void main(String[] args) {
        SingleDog.testStatic();

        new SingleDog().game();
        new SingleDog().testStatic();

        SingleDog.testStatic();
    }
}

1.2.3 静态成员方法的作用【工具类使用】

/*
Arrays 数组工具类
	public static void sort(int[] arr)
		排序数组，默认从小到大
		
	public static int binarySearch(int[] arr, int number)
		二分法查找，在一个排序完成的数组中找出指定元素所在的下标位置
		
	public static String toString(int[] arr)
		例如:
			int[] array = {1, 3, 5, 7, 9}
			String类型 [1, 3, 5, 7, 9]
			
在工具类中都是static修饰的静态方法，方法运行所需的参数都是类外提供的！！！
类内基本上没有对应的成员变量。
好处：
	1. 调用方便
		可以摆脱类对象约束，直接私用类名调用
	2. 节约资源
		摆脱类对象的约束，节约类对象占用的堆区内存空间，也降低了程序压力
	3. 复用度高
		可以适用于很多地方！！！
项目中给你找例子
	JdbcUtil工具类
	StringUtil
*/

package com.qfedu.b_staticmethod;

import java.util.Arrays;

class TestUtil {
    public static void testUtil(String str) {
        System.out.println(str);
    }
}

public class Demo2 {
    public static void main(String[] args) {
        int[] array = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
        // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        // sort排序
        Arrays.sort(array);

        // toString 展示
        System.out.println(Arrays.toString(array));

        /*
        找出对应元素在数组中的下标位置，要求数组是已经是排序完成的数组
        如果没有找返回负数，找到返回值大于等于0
         */
        int i = Arrays.binarySearch(array, 15);
        System.out.println(i);

        TestUtil.testUtil("FPX总冠军 Tian FMVP");
    }
}

1.3 静态代码块

1.3.1 构造代码块的大哥

// 静态代码块
static {
	
}
/*
只要当前类对应的.class文件加载到内存中，就一定会执行对应的static修饰的静态代码块。并且只执行一次！！！
一般用于:
	整个程序的初始化过程！！！
*/

class Demo1 {
    static Demo1 demo1 = new Demo1();
    static Demo1 demo2 = new Demo1();
    
    {
        System.out.println("构造代码块");
    }
    
    static {
        System.out.println("静态代码块");
    }
    
    public Demo1() {
        System.out.println("构造方法");
    }
    
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
    }
}
/*
提示:
	1. 静态修饰的内容都是在文件加载阶段就已经完成运行
	2. 基本的代码运行顺序结构
	3. 构造代码块执行优先级高于构造方法，但是整个类对象中成员变量的初始化权重
	最高是构造方法
	4. 静态代码块有且只执行一次！！！因为类文件有且只加载一次！！！
结果:
	构造代码块
	构造方法
			static Demo1 demo1 = new Demo1();
	构造代码块
	构造方法
			static Demo1 demo2 = new Demo1();
	静态代码块
			static {}
	构造代码块
	构造方法
			main方法中
			Demo1 demo1 = new Demo1();
*/

2. 接口

2.1 生活中的接口

USB Type-C Micro-USB USB-C
HDMI Display Port VGA串口 RJ45 DIV PCI-E

USB能做什么？
	充电 数据传输 键盘 鼠标 音响 声卡 耳机 麦克风 U盘 移动硬盘 摄像头
	小风扇 散热器
	
USB连接的设备决定了当前USB接口做什么
所有设备必须【遵从】USB接口协议

接口的使用给当前设备带来了什么?
	拓宽了设备的功能性

2.2 Java中接口的使用

关键字
	interface A {}
【遵从】接口的关键字 
    implements

interface A {
    // 成员变量
    // 成员方法
}

【补充知识点final关键字】

final
	1. 修饰成员变量
		a. 定义时必须初始化
		b. 一旦被赋值不能被修改，不能重新赋值
	2. 修饰成员方法
		不能被子类重写
	3. 修饰局部变量
		一旦被赋值不能被修改！！！
	4. 修饰类
		没有子类，不能被继承
		Java中String就是使用final修饰的类，没有子类

package com.qfedu.d_interface;

interface A {
    // 成员变量
    int num = 0; // 缺省属性: public static final修饰
    // 成员方法
    void testA(); // 缺省属性: public abstract

    /*
    JDK1.8之后加了一个特征，允许非必要实现方法存在
    在接口中使用default修饰的默认方法是可以有方法体的
    */
    default void testDefault() {
        System.out.println("默认方法");
    }
}

interface C {
    void testC();
}

class TypeA implements A, C {

    @Override
    public void testA() {
        System.out.println("遵从接口A实现的方法");
    }

    @Override
    public void testC() {
        System.out.println("遵从接口C实现的方法");
    }
}

public class Demo1 {
    public static void main(String[] args) {
        TypeA typeA = new TypeA();
        typeA.testA();
        typeA.testDefault();
        typeA.testC();

    }
}

希望大家关注我一波,防止以后迷路,有需要的可以加我Q讨论互相学习java ,学习路线探讨,经验分享与java Q:2415773436