面向对象高级-抽象类、接口

一、final

1、认识final关键字

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

修饰类：该类被称为最终类，特点是不能被继承了。（一般是用在工具类中）

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

修饰变量（局部变量、成员变量（静态、实例））：该变量有且仅能被赋值一次。（一般是修饰静态变量）

final修饰变量的注意：

final修饰基本类型（int，double，boolean，char...）的变量，变量存储的数据不能被改变。

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

2、常量

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

作用：常用于记录系统的配置信息；常量都统一到常量包内（Constant），方便修改。

使用常量记录系统配置信息的优势、执行原理：

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

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

java">public class FinalDemo1{//final修饰静态成员变量//final修饰静态变量，这个变量今后被称为常量，可以记住一个固定值，并且程序中不能修改了，通常这个值作为系统的配置信息//常量的名称都要大写，使用下划线分割public static final double PI=3.14;//final修饰实例变量（一般没有意义）public final double rate=3.14;public static void main(String[] args){//认识final关键字的作用//3、final修饰变量，变量的值有且只能赋值一次/*变量有哪些呢？1、成员变量静态成员变量 实例成员变量2、局部变量*/final double rate=3.14;//rate=5.14;//第二次赋值 报错final int a=20;//a=30;//不能修改final int[] b={1,2,3};b[2]=4;}
}//1、fianl修饰类，类不能被继承
final class A{}
//class B extends A{}//2、final修饰方法，方法不能被重写
class C{public final void show(){System.out.println("show()");}
}class D extends C{//@Override//public void show(){//System.out.println("show()");//}
}

二、单例类（设计模式）

1、什么是设计模式：一个问题通常有n种解法，其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。（设计模式解决什么问题、怎么写）

2、单例设计模式：确保某个类只能创建一个对象。

3、单例有啥应用场景，有啥好处：任务管理器对象、获取运行时对象（有且仅需要一个对象）。在这些业务场景下，使用单例模式，可以避免浪费内存。

4、单例设计模式的写法，实现步骤：

把类的构造器私有。
定义一个静态变量记住类的一个对象。
定义一个静态方法，返回对象。

5、饿汉式单例类：在类加载的时候就创建对象，不管用不用，都会创建。

java">//设计单例设计模式
public class A{//1、私有化构造器：确保单例类对外不能创建太多对象，单例才有可能性private A(){}//2、定义一个静态变量，用于记住本类的一个唯一对象private static A a=new A();//3、提供静态方法，返回A对象public static A getInstance(){return a;}
}public class Test{public static void main(String[] args){//设计单例类A a1=A.getInstance();A a2=A.getInstance();System.out.println(a1==a2);}
}

6、懒汉式单例类：在类加载的时候不会创建对象，只有当调用getInstance()方法时才会创建对象（延迟加载对象）。

写法：

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

java">//懒汉式单例类
public class B{//1、私有化构造器private B(){}//2、创建一个静态的私有的B对象private static B instance;//3、提供一个静态的公共方法，返回B对象，真正需要对象的时候才开始创建对象public static B getInstance(){if(instance==null){//第一次拿对象时，会创建对象，给静态变量instance记住instance=new B();}return instance;}
}public class Test{public static void main(String[] args){B b1=B.getInstance();B b2=B.getInstance();System.out.println(b1==b2);}
}

三、枚举类

1、认识枚举类

枚举是一种特殊类。

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

特点：

枚举类中的第一行，只能写枚举类的对象名称，且要用逗号隔开。
这些名称，本质是常量，每个常量都记住了枚举类的一个对象。

枚举类的特点：

枚举都是最终类，不可以被继承，枚举类都是继承java.lang.Enum类的。
枚举类的第一行只能罗列一些名称，这些名称都是常量，并且每个常量会记住枚举类的一个对象。
枚举类的构造器都是私有的（写不写都只能是私有的），因此，枚举类对外不能创建对象。
编译器为枚举类新增了几个方法。

java">//枚举类
public enum A{//枚举类的第一行，只能罗列枚举对象的名称，这些名称本质是常量X,Y,Z;
}public class Test{public static void main(String[] args){//认识枚举类，搞清楚其本质特点A a=A.X;System.out.println(a);A b=A.Y;System.out.println(b);System.out.println(a.name());//XSystem.out.println(b.name());//YSystem.out.println(a.ordinal());//索引0System.out.println(b.ordinal());//索引1}
}

2、枚举类的常见应用场景

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

（枚举类常用于定义常量，枚举类中的常量只能是枚举类的实例，不能被修改。）

虽说也可以用常量类作为信息的标志与分类，但是参数值不受约束（就是传入的参数不是限定内的那四个都能行得通，写别的不报错），但是枚举类的话写限定外的就会报错。

java">public enum Direction{UP,DOWM,LEFT,RIGHT;
}public 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;//右
}public class Test2{public static void main(String[] args){//掌握枚举类的应用场景：做信息的分类和标志//需求：模拟上下左右移动图片//第一种是常量做信息标志和分类，但参数值不受约束move(Constant.UP);//第二种是枚举做信息标志和分类，参数值受枚举类约束move2(Constant.RIGHT);}public static void move2(Direction direction){//根据这个方向做移动：上下左右switch (direction){case Direction.UP:System.out.println("向上移动");break;case Direction.DOWN:System.out.println("向下移动");break;case Direction.LEFT:System.out.println("向左移动");break;case Direction.RIGHT:System.out.println("向右移动");break;default:System.out.println("输入有误");}}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("输入有误");}}
}

四、抽象类

1、认识抽象类

在java中有一个关键字叫：abstract，它就是抽象的意思，可以用它修饰类、成员方法。

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

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

抽象类的注意事项、特点：

抽象类中不一定要有抽象方法，有抽象方法的类必须是抽象类。
类有的成员：成员变量、方法、构造器，抽象类都可以有。
抽象类最主要的特点：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义为抽象类。

java">//抽象类
public abstract class A {private String name;private int age;public A(){System.out.println("A的无参构造器");}public A(String name,int age){this.name=name;this.age=age;}//抽象方法：必须用abstract修饰，没有方法体，只有方法声明public abstract void show();public void show1(){System.out.println("show1方法");}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}//一个类继承抽象类，必须重写完继承的全部抽象方法，否则这个类也必须定义成抽象类
public class B extends A{@Overridepublic void show() {System.out.println("B类重写show方法");}
}public class abstractdemo1 {public static void main(String[] args){//认识抽象类，抽象方法，搞清它们的特点//抽象类的核心特点：有的有失（得到了抽象方法的能力，失去了创建对象的能力//抽象类不能创建对象//A a = new A();//报错了//抽象类的使命就是被子类继承B b = new B();b.setName("jack");b.setAge(20);b.show();b.show1();}
}

2、使用抽象类的好处

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

抽象类简化了需要重写的父类方法的代码，更加便于调用子类时多态的实现，更具解耦性。

java">public abstract class Animal {//每个动物的叫声public abstract void cry();
}public class Cat extends Animal{@Overridepublic void cry() {System.out.println("猫是喵喵喵的叫");}
}public class Dog extends Animal{@Overridepublic void cry() {System.out.println("狗是汪汪汪的叫");}
}public class Test {public static void main(String[] args){//搞清楚使用抽象类的好处Animal a = new Cat();a.cry();}
}

3、模板方法设计模式

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

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

写法：

1、定义一个抽象类。

2、在里面定义2个方法。

一个是模板方法：把共同的实现步骤放里面去。

一个是抽象方法：不确定的实现步骤，交给具体的子类来完成。

建议使用final关键字修饰模板方法，为什么？

模板方法是给子类直接使用的，不能被子类重写。
一旦子类重写了模板方法，模板方法就失效了。

java">public abstract class People {//模板方法设计模式public final void write(){System.out.println("\t\t\t《我的爸爸》");System.out.println("\t我爸爸是一个好人，我特别喜欢他，他对我很好，我来介绍一下");//模板方法知道子类一定要写正文，但是每个子类写的信息是不同的，父类定义一个抽象方法//具体的实现交给子类来重写正文writeBody();System.out.println("\t我爸爸真好，你有这样的爸爸吗？");}public abstract void writeBody();
}public class Student extends People{@Overridepublic void writeBody() {System.out.println("\t我爸爸很牛逼");}
//    public void write(){
//        System.out.println("\t\t\t《我的爸爸》");
//        System.out.println("\t我爸爸是一个好人，我特别喜欢他，他对我很好，我来介绍一下");
//        System.out.println("\t我爸爸很牛逼");
//        System.out.println("\t我爸爸真好，你有这样的爸爸吗？");
//    }
}public class Teacher extends People{@Overridepublic void writeBody() {System.out.println("\t我爸爸给我买橘子");}
//    public void write(){
//        System.out.println("\t\t\t《我的爸爸》");
//        System.out.println("\t我爸爸是一个好人，我特别喜欢他，他对我很好，我来介绍一下");
//        System.out.println("\t我爸爸给我买橘子");
//        System.out.println("\t我爸爸真好，你有这样的爸爸吗？");
//    }
}public class Test {public static void main(String[] args){//理解抽象类的使用场景之一：模板方法设计模式//学生和老师都要写一篇作文：《我的爸爸》//第一段是一样的：我爸爸是一个好人，我特别喜欢他，他对我很好，我来介绍一下//第二段是不一样的：老师和学生各自写各自的//第三段是一样的：我爸爸真好，你有这样的爸爸吗？//解决：抽出一个父类，父类中还抽取一个模板方法给子类直接用Student s=new Student();s.write();}
}

五、接口

1、接口概述

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

接口不能创建对象。

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

java">//接口：使用interface关键字定义
public interface A {//JDK 8之前，接口中只能定义常量和抽象方法//常量：接口中定义常量可以省略public static final不写，默认会加String SCHOOL_NAME="黑马程序员";//抽象方法:接口中定义抽象方法可以省略public abstract不写，默认会加void show();String go();
}public interface B {void play();
}public class Test {public static void main(String[] args){//认识接口，搞清楚接口的特点，基本使用System.out.println(A.SCHOOL_NAME);//接口不能创建对象//接口是用来被类实现的C c = new C();c.show();System.out.println(c.go());c.play();}
}//C被称为实现类，同时实现了多个接口
//实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则这个类必须定义成抽象类
class C implements A,B{@Overridepublic void show() {System.out.println("C show");}@Overridepublic String go() {return "黑马程序员";}@Overridepublic void play() {System.out.println("C play");}
}

2、接口的好处

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

让程序可以面向接口编程，更利于程序的解耦合。

java">public class Test {public static void main(String[] args){//理解Java设计接口的好处、用处//接口弥补了类单继承的不足，可以让类拥有更多角色，类的功能更强大People p = new Student();Driver d = new Student();//多态BoyFriend bf = new Student();//接口可以实现面向接口编程，更利于解耦合Driver a = new Teacher();}
}interface Driver{}
interface BoyFriend{}class People{}
class Student extends People implements Driver, BoyFriend{}class Teacher implements Driver, BoyFriend{}

3、接口的综合小案例

java">import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {private String name;private char sex;private double score;
}public interface ClassDataInter {void printAllStudentInfos();void printAverageScore();
}public class ClassDataInterImpl1 implements ClassDataInter{private Student[] students;//记住送来的全班学生对象信息public ClassDataInterImpl1(Student[] students) {this.students = students;}@Overridepublic void printAllStudentInfos() {System.out.println("全班学生信息如下：");for (int i = 0; i < students.length; i++) {System.out.println(students[i].getName()+" "+students[i].getSex()+" "+students[i].getScore());}}@Overridepublic void printAverageScore() {double sum=0;for (int i = 0; i < students.length; i++) {sum+=students[i].getScore();}System.out.println("全班平均成绩为："+sum/students.length);}
}//定义第二套实现类，实现接口：实现打印学生信息（男女人数），实现打印平均分（去掉最高分和最低分）
public class ClassDataInterImpl2 implements ClassDataInter{private Student[] students;//记住送来的全班学生对象信息public ClassDataInterImpl2(Student[] students){this.students=students;}@Overridepublic void printAllStudentInfos() {int maleCount=0;System.out.println("全班学生信息如下：");for (int i = 0; i < students.length; i++) {System.out.println(students[i].getName()+" "+students[i].getSex()+" "+students[i].getScore());if(students[i].getSex()=='男')maleCount++;}System.out.println("男学生人数为："+maleCount);System.out.println("女学生人数为："+(students.length-maleCount));}@Overridepublic void printAverageScore() {double max=students[0].getScore();double min=students[0].getScore();double sum=0;for (int i = 0; i < students.length; i++) {if(students[i].getScore()>max)max=students[i].getScore();if(students[i].getScore()<min)min=students[i].getScore();sum+=students[i].getScore();}System.out.println("最高分是："+max);System.out.println("最低分是："+min);System.out.println("全班平均成绩为："+(sum-max-min)/(students.length-2));}
}public class Test {public static void main(String[] args){//完成接口的小案例//1、定义学生类，创建学生对象，封装学生数据，才能交给别人处理//2、准备学生数据，目前我们自己造一些测试数据Student[] allstudents=new Student[10];allstudents[0]=new Student("张三",'男',90);allstudents[1]=new Student("李四",'女',80);allstudents[2]=new Student("王五",'男',70);allstudents[3]=new Student("赵六",'女',60);allstudents[4]=new Student("钱七",'男',50);allstudents[5]=new Student("孙八",'女',40);allstudents[6]=new Student("周九",'男',30);allstudents[7]=new Student("吴十",'女',20);allstudents[8]=new Student("郑十一",'男',10);allstudents[9]=new Student("王十二",'女',0);//3、提供两套业务实现方案，支持灵活切换（解耦合）：面向接口编程//定义一个接口（规范思想）：必须完成打印全班学生信息，打印平均分//定义第一套实现类，实现接口：实现打印学生信息，实现打印平均分//定义第二套实现类，实现接口：实现打印学生信息（男女人数），实现打印平均分（去掉最高分和最低分）ClassDataInter cdi=new ClassDataInterImpl2(allstudents);cdi.printAllStudentInfos();cdi.printAverageScore();}
}

4、JDK8开始，接口新增的三种方法

默认方法：使用default修饰，使用实现类的对象调用。

静态方法：static修饰，必须用当前接口名调用。

私有方法：private修饰，jdk9开始才有的，只能在接口内部被调用。

他们都会默认被public修饰。

新增的方法增强接口能力，便于项目扩展与维护（若新增方法，可以直接写在接口中，不用修改实现类，更方便扩展）。

java">public interface A {//1、默认方法（普通实例方法）：必须加default修饰//默认用public修饰//如何调用？ 使用接口的实现类的对象来调用default void go(){System.out.println("go方法执行了");run();}//2、私有方法//私有的实例方法//如何调用？ 使用接口中的其他实例方法来调用它private void run(){System.out.println("run方法执行了");}//3、静态方法//默认会用public修饰//如何调用？ 只能使用当前接口名来调用static void show(){System.out.println("show方法执行了");}
}public class Test {public static void main(String[] args){//搞清楚接口新增的三种方法，并理解其好处AImpl a = new AImpl();a.go();A.show();}
}class AImpl implements A{}

5、接口的注意事项

1、接口与接口可以多继承：一个接口可以同时继承多个接口。

类与类：单继承，一个类只能有一个父类。

类与接口：多继承，一个类可以同时实现多个接口。

2、一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承，也不支持多实现。

3、一个类继承了父类，又同时实现了接口，如果父类中和接口中有同名的默认方法，实现类会优先用父类的。

4、一个类实现了多个接口，如果多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。

java">public class Test {public static void main(String[] args){//理解接口的几点注意事项Dog dog = new Dog();dog.go();C3 c3 = new C3();c3.show();}
}//4、一个类实现了多个接口，如果多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可
interface A3{default void show(){System.out.println("接口A3的show方法");}
}interface B3{default void show(){System.out.println("接口B3的show方法");}
}class C3 implements A3,B3{@Overridepublic void show() {A3.super.show();B3.super.show();}
}//3、一个类继承了父类，又同时实现了接口，如果父类中和接口中有同名的方法，实现类会优先用父类的
interface A2{default void show(){System.out.println("接口的show方法");}
}class Animal{public void show(){System.out.println("父类的show方法");}
}class Dog extends Animal implements A2{public void go(){show();//父类的super.show();//父类的A2.super.show();//接口的}
}//2、一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承，也不支持多实现
interface A1{void show();
}
interface B1{String show();
}
//interface C1 extends A1,B1{
//
//}
//class D1 implements A1,B1{
//
//}//1、接口与接口可以多继承：一个接口可以同时继承多个接口
//类与类：单继承 一个类只能继承一个直接父类
//类与接口：多实现 一个类可以同时实现多个接口
//接口与接口：多继承 一个接口可以同时继承多个接口
interface A{void show1();
}interface B{void show2();
}interface C extends A,B{void show3();
}class D implements C{public void show1(){}public void show2(){}public void show3(){}
}

6、抽象类、接口的区别对比

相同点：

1、都是抽象形式，都可以有抽象方法，都不能创建对象。

2、都是派生子类形式：抽象类是被子类继承使用，接口是被实现类实现。

3、一个类继承抽象类，或者实现接口，都必须重写完它们的抽象方法，否则自己要成为抽象类或者报错。

4、都能支持多态，都能实现解耦合。

不同点：

1、抽象类中可以定义类的全部普通成员，接口只能定义常量，抽象方法（JDK8新增的三种方式）。

2、抽象类只能被类单继承，接口可以被类多实现。

3、一个类继承抽象类就不能再继承其他类，一个类实现了接口（还可以继承其他类或者实现其他接口）。

4、抽象类体现模板思想：更利于作父类，实现代码的复用性。

5、接口更适合做功能的解耦合：解耦合性更强更灵活。

六、综合案例

某智能家居系统，可以让用户选择要控制的家用设备（吊灯，电视机，洗衣机，落地窗），并可以对它们进行打开或者关闭操作。

java">public interface Switch {void press();//按压
}import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;//家电
@Data
@AllArgsConstructor
@NoArgsConstructor
public class JD implements Switch{private String name;//状态：开或者关private boolean status;//false默认是关闭@Overridepublic void press() {//控制当前设备开和关status = !status;}
}//电视机
public class TV extends JD{public TV(String name, boolean status) {super(name, status);}
}//洗衣机
public class WashMachine extends JD{public WashMachine(String name, boolean status) {super(name, status);}
}//空调
public class Air extends JD{public Air(String name, boolean status) {super(name, status);}
}//灯
public class Lamp extends JD{public Lamp(String name, boolean status) {super(name, status);}
}//智能控制系统 单例类
public class SmartHome {private static final SmartHome sh=new SmartHome();private SmartHome(){}public static SmartHome getInstance(){return sh;}//多态public void control(JD jd){System.out.println(jd.getName()+"状态目前是："+(jd.isStatus()?"开":"关"));System.out.println("开始您的操作");jd.press();//按下开关System.out.println(jd.getName()+"状态目前是："+(jd.isStatus()?"开":"关"));}public void printAllStatus(JD[] jds){for(int i=0;i<jds.length;i++){System.out.println(jds[i].getName()+"状态目前是："+(jds[i].isStatus()?"开":"关"));}}
}import java.util.Scanner;public class Test {public static void main(String[] args) {//目标：面向对象编程实现智能家具控制系统//角色：设备（吊灯，电视机，洗衣机，落地窗，。。。）//具备的功能：开和关//谁控制他们：智能控制系统（单例对象），控制调用设备的开和关//1、定义设备类：创建设备对象代表家里的设备//2、准备这些设备对象，放到数组中，代表整个家庭的设备JD[] jds = new JD[4];jds[0] = new Lamp("吊灯",true);jds[1] = new TV("小米电视机",true);jds[2] = new WashMachine("美的洗衣机",false);jds[3] = new Air("美的空调",false);//3、为每个设备制定一个开和关的功能//4、创建智能控制系统对象，控制设备开和关SmartHome sh = SmartHome.getInstance();//5、控制吊灯//sh.control(jds[0]);//6、提示用户操作 a、展示全部设备的当前情况 b、让用户选择哪一个操作//打印全部设备的开和关的现状while (true) {sh.printAllStatus(jds);System.out.println("请选择要控制的设备");Scanner sc = new Scanner(System.in);String choice = sc.next();switch (choice){case "1":sh.control(jds[0]);break;case "2":sh.control(jds[1]);break;case "3":sh.control(jds[2]);break;case "4":sh.control(jds[3]);break;case "exit":System.out.println("退出程序");return;default:System.out.println("输入有误");}}}
}