Java零基础学习Day10——面向对象高级1

一.认识final

1.含义

final关键字是最终的意思，可以修饰：类，方法，变量

修饰类：该类被称为最终类，特点是不能被继承

修饰方法：该方法被称为最终方法，特点是不能被重写了

修饰变量：该变量有且仅能被赋值一次

final修饰静态变量，这个变量今后被称为常量，可以记住一个固定值，并且程序中不能修改了，通常这个值作为系统的配置信息，作为共享值所有人都可以用

常量的名称：建议全部大写，多个单词用下划线进行连接

注：final修饰实例变量一般情况下没有意义！！！

2.final修饰变量的注意

final修饰基本类型的变量，变量存储的数据不能被改变

final修饰引用类型的变量，变量存储的地址不能被改变，但地址所指向的对象的内容是可以被改变

final int[] arr = {11,22,33,44};
//arr = new int[]{33,44,55};  //第二次赋值，报错
arr[2]=90;//不报错，可以修改

二.常量

1.含义

使用了static final修饰的成员变量就被称为常量

作用：常用于记录系统的配置信息

注：命名规范建议使用大写英文字母，多个单词使用下划线连接起来

2.优点

代码可读性更好，可维护性更好

程序编译后，常量会被“宏（全部）替换”：出现常量的地方全部会被替换成其记住的字面量，这样可以保证使用常量和直接用字面量的性能是一样的

三.单例类（设计模式）

注：这个属于系统架构师层面的技术

1.什么是设计模式

一个问题通常有n种解法，其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，就称之为设计模式

2.关于设计模式，主要学什么

解决什么问题：确保某个类只能创建一个对象

怎么写

3.单例设计模式

作用：确保某个类只能创建一个对象

写法步骤：

• 把类的构造器私有：确保单例类对外不能创建太多对象，单例才有可能性
• 定义一个静态变量：用于基本本类的一个唯一对象
• 提供一个静态方法：用于返回对象

//单例类
public class A{
    //2.定义一个类变量记住类的一个变量
    private static A a = new A();
    
    //1.私有构造器
    private(){
    }


    //3.定义一个类方法返回对象
    public static A getobject(){
        return a;
    }
}

public static A a = new A();

//这两句其实是相同的意思，上面的 A就是跟下面的 int一样代表数据类型

//new A()代表的是对象

public static int a1 = 20;

 4.饿汉式单例的特点

在获取类的对象时，对象已经创建好了

5.单例有啥应用场景，有啥好处

任务管理器对象、获取运行时对象，避免浪费内存及无效资源浪费

6.懒汉式单例类

真正要用对象时，才开始创建对象

写法：

• 把类的构造器私有
• 定义一个静态变量用于存储对象
• 提供一个静态方法，保证返回的是同一个对象

public class B{
    //2.定于一个类变量用于存储对象
    private static B b;//null
    //1.单例必须私有构造器
    private B(){
    }

    //3.提供一个类方法返回类的的一个对象
    public static B getobject(){
        if(b == null){
            b = new B();
        }
        return b;
    }
}

四.枚举类

1.枚举类的写法

修饰符enum枚举类名{
    名称1，名称2，....;
    其他成员...
}


public enum A{
    X,Y,Z;
    ...
}

2.枚举类的特点

• 枚举类中的第一行，只能写枚举类的对象名称，且要用逗号隔开
• 这些名词，本质是常量，每个变量都记住了枚举类的一个对象
• 枚举都是最终类，不可以被继承，枚举类都是继承java.lang.Enum类的
• 枚举类的构造器都是私有的（写不写都只能时私有的），因此，枚举类对外不能创建对象
• 编译器为枚举类新增了几个方法
• 枚举是一种特殊类

public static A[] values();//将所有枚举的对象放到数组中

public static A valueOf(java.lang.String);
//通过枚举对象的名字去定位某个枚举对象

a1.name()可以拿枚举对象 的名称
a1.ordinal()可以拿枚举对象 的索引

3.枚举类的常见应用场景

枚举类很适合做信息分类和标志

package com.itheima;

public class Test {
    public static void main(String[] args) {
        //目标：掌握枚举类的应用场景，信息的分类和标志
        //需求：模拟上下左右移动图片
        move(Direction.UP);
    }

    public static void move(Direction direction){
        switch (direction){
            case UP://可直接写UP，因为枚举类中定义的常量值都是UP，Direction可以省略
                System.out.println("向上移动");
                break;
            case Down:
                System.out.println("向下移动");
                break;
            case Left:
                System.out.println("向左移动");
                break;
            case Right:
                System.out.println("向右移动");
                break;
            default:
                System.out.println("无效指令");
        }
    }
}

package com.itheima;

public enum Direction {
    UP,Down,Left,Right;

}

五.抽象类

1.含义

在Java中有一个关键字叫：abstract（抽象），用这个可以修饰类、成员方法

abstract修饰类，这个类就是抽象类

abstract修饰方法，这个方法就是抽象方法

2.语法

修饰符 abstract class 类名{
        修饰符 abstract 返回值类型 方法名称（形参列表）;
}


public abstract class A{
    //抽象方法：必须abstract修饰，只有方法签名，不能有方法体,意味着不能有大括号
    public abstract void test();
}

3.抽象类的注意事项、特点

抽象类中不一定要有抽象方法，有抽象方法的类必须是抽象类

类有的成员：成员变量、方法、构造器、抽象类都可以有

抽象类最主要的特点是：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现

一个类继承抽象类，必须重写玩抽象类的全部抽象方法，否则这个类也必须定义成抽象类

注：在实际开发中，会全部重写抽象方法，而不是再定义成抽象类，这样就可以自己创建对象

方法：Alt键+回车，即可全部重写

4.使用抽象类的优点（非必须）

父类知道每个子类都要做某个行为，但每个子类都要做到情况不一样。父类就定义成抽象方法，交给子类去重写实现，我们设计这样的抽象类，就是为了更好的支持多态

注：以后要做关于面向对象的设计时，如果所有子类都要做出功能，每个子类的功能又各不相同，即可把这个父类定义成抽象类和抽象方法

5.抽象类使用场景之一（模板方法设计模式）

提供给一个方法作为某类功能的模板，模板方法封装了每个实现步骤，但允许子类提供特定步骤的实现

模板方法设计模式：提高代码的复用、并简化子类设计

写法：

1.定义一个抽象类

2.在里面定义两个方法

• 一个是模板方法：把共同的实现步骤放里面去
• 一个是抽象方法：不确定的实现步骤，交给具体的子类来完成

注：建议使用final关键字修饰模板方法，控制方法不被重写

六.接口

1.含义

Java提供了一个关键字interface定义出接口

public interface 接口名{
    //成员变量（常量）
    //成员方法（抽象方法）
}

在JDK 8 之前，接口中只能定义常量和抽象方法。

在接口中定义常量可以省略public static final 不写，默认自动添加，抽象方法同理。

作用：接口是用来被类实现的，实现接口的类称为实现类，一个类可以同时实现多个接口。

修饰符 class 实现类类名 implements 接口1，接口2，接口3，....{
        //实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则实现需要定义成抽象类
}

2.注意

接口不能创建对象。

3.接口的优点

弥补了类单继承的不足，一个类同时可以实现多个接口，使类的角色更多，功能更强大。

让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现（更有利于程序的解耦合）。 

4.接口案例：学生信息系统

package com.iteheima.interface1;

public interface ClassDataInter {
    void printAllStudentInfos();
    void printAverageScore();
}

ClassDateinter.java

package com.iteheima.interface1;

public class Text {//把这个可以看作A公司提供的模板，其他两个实现类功能由另外公司完成，这就是协作开发

    public static void main(String[] args) {
        //目标：完成接口的小案例
        //1.定义学生类，创建学生对象，封装数据，才能交给别人进行调用
        //2.准备学生数据，人为制造数据
        Student[] allstudents = new Student[10];//创建数组allstudents并设计容量为10
        allstudents[0] = new Student("小王",'男',90.5);
        allstudents[1] = new Student("小张",'女',80.5);
        allstudents[2] = new Student("小李",'男',70.5);
        allstudents[3] = new Student("小赵",'女',60.5);
        allstudents[4] = new Student("小孙",'男',50.5);
        allstudents[5] = new Student("小周",'女',40.5);
        allstudents[6] = new Student("小吴",'男',30.5);
        allstudents[7] = new Student("小郑",'女',20.5);
        allstudents[8] = new Student("小王",'男',10.5);
        allstudents[9] = new Student("小王",'女',90.5);

        //3.提供两套业务实现方案，支持灵活切换（解耦合）
        //——定义一个接口（规范思想）：必须完成打印全班学生信息，打印平均分
        //——定义第一套实现类，实现接口：完成打印全班学生信息，实现打印平均分
        //——定义第二套实现类，实现接口：实现打印学生信息（男女人数），实现打印平均分（去掉最高分和最低分）
        ClassDataInter cdi = new ClassDataInterImpl1(allstudents);//接口创建对象不能用new，而是用实现类
        //上面这里就已经实现了解耦，如果要换实现类，只要换一个实现类，接口调用方法不变
        cdi.printAllStudentInfos();
        cdi.printAverageScore();

Text.java

package com.iteheima.interface1;

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

@Data//构建get和set方法
@NoArgsConstructor//无参构造器
@AllArgsConstructor//有参构造器
class Student {//创建学生类，封装数据
    private String name;
    private char sex;
    private double score;
}

Student.java

package com.iteheima.interface1;

public class ClassDataInterImpl1 implements ClassDataInter{
    //类名[] 变量名（声明数组变量）
    private Student[] students;//创建数组记住下面送进来的全部学生信息
    public ClassDataInterImpl1(Student[] students) {//用有参构造器接收学生信息
        this.students = students;//将外部传入的数组赋给成员变量students
    }
    @Override
    public void printAllStudentInfos() {
        System.out.println("所有学生的信息为：");
        for (int i = 0; i < students.length; i++) {
            Student student = students[i];
            System.out.println(student.getName() + " " + student.getSex() + " " + student.getScore());
        }


    }

    @Override
    public void printAverageScore() {
        double sum = 0;
        for (int i = 0; i < students.length; i++) {
            Student student = students[i];
            sum += student.getScore();
        }
        System.out.println("平均分是：" + sum / students.length);

    }
}

ClassDateInterImpl1.java

package com.iteheima.interface1;
//——定义第二套实现类，实现接口：实现打印学生信息（男女人数），实现打印平均分（去掉最高分和最低分）
public class ClassDataInterImpl2 implements ClassDataInter{
    private Student[] students;
    public ClassDataInterImpl2(Student[] students) {
        this.students = students;
    }
    @Override
    public void printAllStudentInfos() {
        int maleCount = 0;//男生人数
        for (int i = 0; i <students.length; i++) {
            Student student = students[i];
            if (student.getSex() == '男') {
                maleCount++;
            }
            System.out.println(student.getName() + " " + student.getSex() + " " + student.getScore());
            System.out.println("男性学生数量为：" + maleCount);
            System.out.println("女性学生数量为：" + (students.length - maleCount));


        }
    }

    @Override
    public void printAverageScore() {
        System.out.println("平均分如下：");
        Student s1 = students[0];
        //这边sum，max，min不能直接设计成0，万一值为0，那么后面求平均数就会出错
        double sum = s1.getScore();
        double max = s1.getScore();
        double min = s1.getScore();
        for (int i = 0; i < students.length; i++) {
            Student student = students[i];
            sum += student.getScore();

            if (student.getScore() > max) {
                max = student.getScore();
            } else if (student.getScore() < min) {
                min = student.getScore();
            }
        }
        System.out.println("最高分是：" + max);
        System.out.println("最低分是：" + min);
        System.out.println("平均分是：" + (sum-min-max) / (students.length-2));

    }
}

ClassDateInterImpl2.java

5.JDK开始，接口新增的三种方法

package com.iteheima.interface1.interface4;

public interface A {
    //1.默认方法（普通实例方法）：必须加default关键字修饰
    //默认会用public修饰
    //使用接口的实现类的对象来进行调用
    default void go(){
        System.out.println("==go方法执行==");
        run();
    }

    //2.私有方法：必须加private关键字修饰
    //使用接口中的其他实例方法来进行调用
    private void run(){
        System.out.println("==run方法执行==");
    }

    //3.静态方法：必须加static关键字修饰
    //只能使用当前接口名来调用
    static void show(){
        System.out.println("==show方法执行==");
    }

}

A.java

package com.iteheima.interface1.interface4;

public class Text {
    //目标：搞清楚接口新增的三种方法，并理解其好处
    public static void main(String[] args) {
        AImpl a = new AImpl();//创建对象
        a.go();//用实现类来进行调用

    }
}
//创建实现类AImpl
class AImpl implements A{

}

Text.java

好处：

增强了接口的能力，便于项目的扩展和维护

why：新增的这些方法可以直接在接口中定义好具体的方法，新增功能时可以不用重新写方法

6.接口的注意事项

• 接口与接口可以多继承：一个接口可以同时继承多个接口
• 一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承，也不支持多实现
• 一个类继承了父类，又同时实现了接口，如果父类中和接口有同名的默认方法，实现类会优先用父类的
• 一个类实现了多个接口，如果多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可

七.接口和抽象类的区别对比

1.相同点

• 多是抽象形式，都可以由抽象方法，都不能创建对象
• 都是派生子类形式：抽象类是被子类继承使用，接口是被实现类实现
• 一个类继承抽象类，或者实现接口，都必须重写抽象方法，否则自己成为抽象类
• 都能支持的多态，都能实现解耦合

2.不同点

• 抽象类中可以定义类的全部普通成员，接口只能定义常量，抽象方法（JDK8新增的三种方法）
• 抽象类只能被类单继承，接口可以被类多实现
• 一个类继承抽象类就不能再继承其他类，一个类实现了接口，还可以继承其他类或者其他接口
• 抽象类体现模板思想：更利于做父类，提高代码的复用性（最佳实践）
• 接口更适合做功能的解耦合：解耦合性更强更灵活（最佳实践）