1.final关键字

class Demo{
    public static void main(String[] args) {
        final int[] a=new int[]{1,2,3};
       // a=new int[]{4,5,6};  报错
        a[0]=5;//可以，解释了final修饰引用性变量，变量存储的地址不能被改变，但地址所指向的对象的内容可以改变
    }
}

什么是常量？

2.单例设计模式-懒汉式单例-饿汉式单例

3.枚举类

//常规写法
class Constant{
    public static final int UP=0;
    public static final int DOWN=1;
    public static final int LEFT=2;
    public static final int RIGHT=3;
}
class Demo{
    public static void move(int direction){
        switch (direction){
            case Constant.UP:
                System.out.println("向上移动");
                break;
            case Constant.DOWN:
                System.out.println("向下移动");
                break;
            case Constant.LEFT:
                System.out.println("向左移动");
                break;
            case Constant.RIGHT:
                System.out.println("向右移动");
                break;
            default:
                System.out.println("无效方向");
        }
    }
}
//枚举类写法，相较于常规的好处是
/*类型安全：枚举提供了更好的类型安全，因为它们限制了变量只能取预定义的值，而常规的静态常量类则没有这种限制。
可读性：枚举通常更易于阅读和理解，因为它们使用名称而不是数字或字符串来表示常量值。
维护性：使用枚举可以更容易地管理和维护一组相关的常量值，因为它们是集中定义的。
功能扩展：枚举可以有自己的方法和属性，这为扩展功能提供了可能，而常规的静态常量类则没有这样的能力。*/
enum Direction{
    UP,DOWN,LEFT,RIGHT
}
class Demo2{
    public static void move(Direction direction){
        switch (direction){
            case UP:
                System.out.println("向上移动");
                break;
            case DOWN:
                System.out.println("向下移动");
                break;
            case LEFT:
                System.out.println("向左移动");
                break;
            case RIGHT:
                System.out.println("向右移动");
                break;
        }
    }
}

4.认识抽象类

5.模板方法设计模式

class A extends fu{
    public void writemain(){
        System.out.println("特殊方法A");
    }
}
class B extends fu{
    public void writemain(){
        System.out.println("特殊方法B");
    }
}
abstract class fu{
    public final void write(){
        System.out.println("公用方法1");
        writemain();
        System.out.println("公用方法2");
    }
    public abstract void writemain();
}
class Demo{
    public static void main(String[] args) {
        fu a=new A();
        a.write();
    }
}
/*
输出：
公用方法1
特殊方法A
公用方法2
 */

6.认识接口

//jdk 8之前，接口中只能定义常量和抽象方法
//接口不能创建对象
public interface A {
    String STUDENT_NAME="li hua"; //接口中默认加上 public static final
    // 等价于 public static final String STUDENT_NAME="li hua";
    void run();//接口中给方法默认加上public abstract
    //等价于 public abstract void run();
}


//Demo被称为实现类，可以同时实现多个接口，
//实现类实现多个接口必须重写全部抽象方法，否则必须定义成抽象类
public class Demo implements A{
    @Override
    public void run() {
    }
}

public class Demo{
    public static void main(String[] args) {
        people p=new student();
        doctor d=new student();
        driver dr=new student();
    }
}
interface driver{}
interface doctor{}
class student extends people implements driver,doctor{}
class people{}

接口的应用案例

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

public class Demo{
    public static void main(String[] args) {
        student[] s=new student[3];
        s[0]=new student("li hua","boy",90);
        s[1]=new student("zhang san","boy",100);
        s[2]=new student("tu xin yue","girl",95);
        tool t=new imp2(s);
        t.listallinfo();
        t.sumscore();
    }
}

class student{
    private String name;
    private String sex;
    private double score;

    public student(String name, String sex, double score) {
        this.name = name;
        this.sex = sex;
        this.score = score;
    }
    public student(){}
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }
}
interface tool{
    public void listallinfo();
    public void sumscore();
}
class imp1 implements tool{
    private student[] s;
    public imp1(student[] s){
        this.s=s;
    }
    @Override
    public void listallinfo() {
        for(int i=0;i<s.length;i++){
            System.out.println(s[i].getName()+" "+s[i].getSex()+" "+s[i].getScore());
        }
    }

    @Override
    public void sumscore() {
        double sum=0;
        for(int i=0;i<s.length;i++){
            sum+=s[i].getScore();
        }
        System.out.println(sum/s.length);
    }
}
class imp2 implements tool{
    private student[] s;
    public imp2(student[] s){
        this.s=s;
    }
    @Override
    public void listallinfo() {
        int flag=0;
        for(int i=0;i<s.length;i++){
            System.out.println(s[i].getName()+" "+s[i].getSex()+" "+s[i].getScore());
            if(s[i].getSex()=="boy"){
                flag++;
            }
        }
        System.out.println("男生人数:"+flag+"女生人数:"+(s.length-flag));
    }

    @Override
    public void sumscore() {
        double max=s[0].getScore();
        double min=s[0].getScore();
        double sum=0;
        for(int i=0;i<s.length;i++){
            sum+=s[i].getScore();
            if(max<s[i].getScore()){
                max=s[i].getScore();
            }
            if(min>s[i].getScore()){
                min=s[i].getScore();
            }
        }
        System.out.println("去掉一个最高分和最低分后的平均分为"+(sum-max-min)/(s.length-2));
    }
}

7.JDK8开始，接口新增的三种方法

public class Demo{
    public static void main(String[] args) {
        A a=new impA();
        a.run();
        A.show();
    }
}
class impA implements A{}
interface A{
    //1.大部分情况下，接口只能写抽象方法，jdk8之后，可以写普通实例方法了，但必须加default修饰
    //默认用public修饰
    //但是接口不能构建对象，应该怎么调用该方法？利用接口的实现类的对象来调用
    default void run(){
        System.out.println("--run--");
        go();
    }
    //2.jdk9开始支持私有方法，他是私有的，利用接口的实现类的对象也不能调用了，只能使用接口中的其他实例方法来调用
    private void go(){
        System.out.println("--go--");
    }
    //3.静态方法，默认用public方法，如何调用？只能通过接口名字直接调用
    static void show(){
        System.out.println("--show--");
    }
}

8.接口的注意事项

//
public class Demo{
    public static void main(String[] args) {
        
    }
}
class D implements C{
    @Override
    public void show3() {}
    @Override
    public void show1() {}
    @Override
    public void show2() {}
}
interface A{
    void show1();
}
interface B{
    void show2();
}
interface C extends A,B{
    void show3();
}

9.抽象类和接口的区别

相同点：
1.都是抽象形式，都可以抽象方法，都不能创建对象
2.都是派生子类形式，抽象类是被子类继承使用，接口是被实现类实现
3.一个类继承抽象类，或者实现接口，都必须重写玩他们的抽象方法，否则自己要成为抽象类不然会报错
4.都能支持多态，都能实现解耦合
不同点：
1.抽象类可以定义类的全部普通成员，接口只能定义常量和抽象方法（以及JDK8以后的三种新方法）
2.抽象类只能被类单继承，接口可以被类多实现
3.一个类继承抽象类就不能再继承其它类，一个类实现了接口还可以继承其他类或实现其他接口
4.抽象类体现模板思想，更利于做父类，实现代码的复用性
5.接口更适合做功能的解耦合，解耦合性更强更灵活。
6.设计目的
抽象类
主要用于代码复用和提供一个通用的模板。它体现了一种 “is - a” 的关系，即子类是一种特殊的抽象类。例如，Dog是一种Animal，Dog类可以继承Animal抽象类，复用Animal类中的属性和方法，同时实现自己特有的行为（如makeSound()方法实现狗叫）。
接口
用于定义行为规范，实现接口的类必须遵循这个规范。它体现了一种 “can - do” 的关系，即类可以做接口定义的事情。例如，如果一个类实现了Flyable接口，就表示这个类可以飞行，不管这个类是Bird还是Airplane，只要实现了Flyable接口，就必须实现fly()方法来定义飞行的行为。

10.一个案例