标签：JAVA 成员 05 void public static final 变量

一. 抽象类

1、抽象类概述

案例：

Animal类（父类（抽象类））

package Package1;

//父类:动物类（抽象类）
public abstract class Animal {
    //抽象方法（特点：要求子类必须重写）
    public abstract void eat();
}

Dog类（子类）部分代码：

package Package1;

//子类：狗类
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

}

Mouse类（子类）部分代码：

package Package1;

//子类：老鼠类
public class Mouse extends Animal {
    @Override
    public void eat() {
        System.out.println("老鼠吃奶酪");
    }
}

Test测试类：

package Package1;

public class Test {
    public static void main(String[] args) {
        //测试狗类
        Dog dog = new Dog();
        dog.eat();

        //测试老鼠类
        Mouse mouse = new Mouse();
        mouse.eat();
        System.out.println("-----------------");

        //通过多态来测试
        Animal an = new Dog();
        an.eat();

    }
}

运行结果：

二. 关键字final

关键字final代表最终、不可改变的。在继承中，子类可以重写父类的方法，为了避免这种随意改写的情况，Java提供了 final 关键字，用于修饰不可改变内容。

常见四种用法：

可以用来修饰一个类

可以用来修饰一个方法

还可以用来修饰一个局部变量

还可以用来修饰一个成员变量

2.1 final 修饰类

格式：
public final class 类名称 {
    // ...
}
含义：当前这个类不能有任何的子类。
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写。

2.2 final 修饰方法

当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式：
修饰符 final 返回值类型 方法名称(参数列表) {
    // 方法体
}
注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

2.3 final 修饰局部变量

一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。

“一次赋值，终生不变”

对于基本类型来说，不可变说的是变量当中的数据不可改变

对于引用类型来说，不可变说的是变量当中的地址值不可改变

2.4 final 修饰成员变量

对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。

因为final修饰的成员变量，赋值后不可修改，所有不允许无参构造方法默认赋值null。

对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。

必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。

例如：
public class Person {

    // 直接赋值，一旦使用final修饰的成员变量进行了直接赋值，构造方法就不能再对其赋值。
    // private  final String name = "AAA"; 

    // 不使用直接赋值，构造方法必须进行赋值。
    private final String name;

    public Person() {
        name = "AAA";
    }

    public Person(String name) {
        this.name = name;
    }
}
三. static关键字

static关键字：

　　“静态”的意思，可以用来修饰成员变量和成员方法

1、静态成员变量：

　　1）用static修饰的成员变量叫静态成员变量，静态变量被被类下所有的对象共享

2）静态成员变量调用方式：类名.静态变量名

实例：定义研发成员类，让每位员工自我介绍
Developer.java
package cn.itcast.demo9;

public class Developer {
    //    成员变量
//姓名
    String name;
    //    工作内容
    String work;
    static String departmentName = "研发部";

    //    成员方法
    public void selfIntroduction() {
        System.out.println("我是" + departmentName + "的" + name + "我的工作内容是" + work);
    }

}
Test.java
package cn.itcast.demo9;

public class Test {
    public static void main(String[] args) {
        //需求创建两个员工，然后测试
        Developer d1 = new Developer();
        d1.name = "小明";
        d1.work = "写代码";
        d1.selfIntroduction();


        Developer d2 = new Developer();
        d2.name = "小红";
        d2.work = "鼓励师";

        System.out.println("+++++++++++++++分界线++++++++++++++++++++++++");
//        公司调整部门名称
//        直接通过类名.静态变量
        Developer.departmentName = "开发部";
        d1.selfIntroduction();
        d2.selfIntroduction();


    }

}
运行结果：
修改成员变量，全局生效，小明和小红的所属部门一起修改
2、静态成员方法：

◆静态方法：
　　静态方法中没有对象this，所以不能访问非静态成员
·静态方法的使用场景
　　只需要访问静态成员
　　不需要访问对象状态，所需参数都由参数列表显示提供

实例：
package cn.itcast.demo10;

public class Main {
    public static void main(String[] args) {
        Person.setNumber(99);
        System.out.println(Person.number);

    }
}

class Person {
    public static int number;

    public static void setNumber(int value) {
        number = value;
    }
}
返回结果：

四. 接口

1、接口创建对象特点：

　　1、接口不能实例化，需要创建其子类对象来完成实例化操作

　　2、接口的子类：

　　　　　　如果是普通类，则必须重写接口的所有的抽象方法

如果是抽象类，则不用重写接口中的抽象方法

接口和类之间的关系：

　　　　　　类与类之间：

　　　　　　　　继承关系，只能单继承，不能多继承，但是可以多层继承

类与接口之间:

　　　　　　　　继承关系，可以单继承，也可以多继承

总结：

　　对于一个类来讲，它的父类（继承关系）中定义的都是：共性内容

对于一个类来讲，它的父接口（实现的关系）中定义的都是：扩展内容

实例：

USB.java
package cn.test02.demo1;

public interface USB {

    //连接
    public abstract void open();

    //关闭
    public abstract void close();

}
Mouse.java
package cn.test02.demo1;

public class Mouse implements USB {

    @Override
    public void open() {
        System.out.println("连接鼠标");
    }

    @Override
    public void close() {
        System.out.println("断开鼠标连接");
    }
}
KeyBorad.java
package cn.test02.demo1;

//子类，键盘类
public abstract class KeyBoard implements USB {

    public void ChildClass() {
        System.out.println("ChildClass construtor");
    }
}
Test.java
package cn.test02.demo1;

public class Test {
    public static void main(String[] args) {
        USB usb = new Mouse();
        usb.open();
        usb.close();
       
    }
}
　　运行结果：

2、接口的成员特点：

接口中的成员待点：
成员变量：
　　接口中只有成员常量，没有成员变量
　　原因是因为接口中所有的变量都有默认修饰符：publio static final

成员方法：
　　JDK7及其以前，只能定义抽象方法，原因是所有方法都有默认修饰符：public abstract
　　JDK8以后，可以有带方法体的方法了。
　　静态方法直接写，非静态方法要用default修饰
　　JDK9以后，可以私有方法了，直接写即可
构造方法：
　　接口中没有构造方法

实例：

USB接口：
package cn.test02.demo2;

public interface USB {
    //    成员变量
    public static final int NUM = 10;

    //成员方法
    public abstract void open();

    public abstract void close();

    //jdk8 多了两种方法
    public static void method1() {
        System.out.println("我是jdk8特性");
    }

    public default void method2() {
        System.out.println("我是jdk9特性");
    }

    //jdk9多了一种写法
//    private void method3() {
//        System.out.println("我海jDK的新特性");
//    }


}
Test.java
package cn.test02.demo2;

public class Test {
    public static void main(String[] args) {
        //测试接口的成员变量
        System.out.println(USB.NUM);
        USB usb = new USB() {
            @Override
            public void open() {
                System.out.println("open");
            }

            @Override
            public void close() {
                System.out.println("close");

            }
        };

        USB.method1();
        usb.method2();
    }
}
运行结果：　　

　　