以下内容均来自抖音号【it楠老师教java】的设计模式课程。
1、原理概述
子类对象（objectofsubtype/derivedclass）能够替换程序（program）中父类对象（objectofbase/parentclass）出现的任何地方，并且保证原来程序的逻辑行为（behavior）不变及正确性不被破坏。
2、简单的示例1
//
基类：鸟类
public class
Bird
{
public
void
fly
() {
System
.
out
.
println
(
"I can fly"
);
}
}
//
子类：企鹅类
public class
Penguin
extends
Bird
{
//
企鹅不能飞，所以覆盖了基类的
fly
方法，但这违反了里氏替换原则
public
void
fly
() {
throw new
UnsupportedOperationException
(
"Penguins can't fly"
);
}
}
为了遵循LSP，我们可以重新设计类结构，将能飞的行为抽象到一个接口中，让需要飞行能力的鸟类实现这个接口：
//
飞行行为接口
public interface
Flyable
{
void
fly
();
}
//
基类：鸟类
public class
Bird
{
}
//
子类：能飞的鸟类
public class
FlyingBird
extends
Bird
implements
Flyable
{
@Override
public
void
fly
() {
System
.
out
.
println
(
"I can fly"
);
}
}
//
子类：企鹅类，不实现
Flyable
接口
public class
Penguin
extends
Bird
{
}
这里就该明确那些方法是通用的，哪些方法是部分能用的。
比如通用的方法可以放到class bird里。
public void say(){ System.out.println("我属于鸟科")}
public void say(){ System.out.println("我又一双翅膀，尽管不能飞")}
不同的用的方法，可以放到接口里比如有的鸟很小 有的鸟很大
interface BigBird{ double height()}
interface SmallBird{ double height()}
上述可能不太准确，但是核心思想就是抽取公共的方法到类里，抽取特殊的方法到接口里。
再举个例 比如
class door{
//核心方法 只要是门 不管你啥样的 你肯定又面积吧，有价格吧
int price();
int area();
}
但是有的门市防火门 有的是防盗门， 有的是....
interface FangHuo{ void canFangHuo()};
interface FangDao{ void canFangDao()};
3、示例2
我们再来看一个基于数据库操作的案例。假设我们正在开发一个支持多种数据库的程序，包括MySQL、PostgreSQL和SQLite。我们可以使用里氏替换原则来设计合适的类结构，确保代码的可维护性和扩展性。 首先，我们定义一个抽象的Database 基类，它包含一些通用的数据库操作方法， 如 connect() 、disconnect() 和 executeQuery() 。这些方法的具体实现将在 子类中完成。
public abstract class
Database
{
public abstract
void
connect
();
public abstract
void
disconnect
();
public abstract
void
executeQuery
(
String
query
);
}
然后，为每种数据库类型创建一个子类，继承自 Database 基类。这些子类需要实现基类中定义的抽象方法，并可以添加特定于各自数据库的方法。
这里新手要思考下 为什么用abstract class 怎么不用class 怎么不用interface
不用class，因为我这里还没有具体到那类数据源，其实可以定义个jdbcDatabase ，定义属性driver，url，user ,password。就是更一部的抽取
不用interface 因为connect close 和query是所有数据源都有操作！！！
public class
MySQLDatabase
extends
Database
{
@Override
public
void
connect
() {
//
实现
MySQL
的连接逻辑
}
@Override
public
void
disconnect
() {
//
实现
MySQL
的断开连接逻辑
}
@Override
public
void
executeQuery
(
String
query
) {
//
实现
MySQL
的查询逻辑
}
//
其他针对
MySQL
的特定方法
}
public class
PostgreSQLDatabase
extends
Database
{
//
类似地，为
PostgreSQL
实现相应的方法
}
public class
SQLiteDatabase
extends
Database
{
//
类似地，为
SQLite
实现相应的方法
}
这样设计的好处是，我们可以在不同的数据库类型之间灵活切换，而不需要修改大量代码。只要这些子类遵循里氏替换原则，我们就可以放心地使用基类的引用来操作不同类型的数据库。例如：
public class
DatabaseClient
{
private
Database database
;
public
DatabaseClient
(
Database database
) {
this
.
database
=
database
;
}
public
void
performDatabaseOperations
() {
database
.
connect
();
database
.
executeQuery
(
"SELECT * FROM users"
);
database
.
disconnect
();
}
}
public class
Main
{
public static
void
main
(
String
[]
args
) {
//
使用
MySQL
数据库
DatabaseClient client1
=
new
DatabaseClient
(
new
MySQLDatabase
());
client1
.
performDatabaseOperations
();
//
切换到
PostgreSQL
数据库
DatabaseClient client2
=
new
DatabaseClient
(
new
PostgreSQLDatabase
());
client2
.
performDatabaseOperations
();
//
切换到
SQLite
数据库
DatabaseClient client3
=
new
DatabaseClient
(
new
SQLiteDatabase
());
client3
.
performDatabaseOperations
();
}
}
好了，我们稍微总结一下。虽然从定义描述和代码实现上来看，多态和里式替换有点类似，但它们关注的角度是不一样的。多态是面向对象编程的一大特性，也是面向对象编程语言的一种语法。它是一种代码实现的思路。而里式替换是一种设计原则，是用来指导继承关系中子类该如何设计的，子类的设计要保证在替换父类的时候，不改变原有程序的逻辑以及不破坏原有程序的正确性。
2
、哪些代码明显违背了
LSP
？
1.子类覆盖或修改了基类的方法
当子类覆盖或修改基类的方法时，可能导致子类无法替换基类的实例而不引起问题。这违反了LSP，会导致代码变得脆弱和不易维护。
public class
Bird
{
public
void
fly
() {
System
.
out
.
println
(
"I can fly"
);
}
}
public class
Penguin
extends
Bird
{
@Override
public
void
fly
() {
throw new
UnsupportedOperationException
(
"Penguins can't fly"
);
}
}
在这个例子中，
Penguin
类覆盖了
Bird
类的
fly()
方法，抛出了一个异常。这违反了LSP，因为现在 Penguin 实例无法替换 Bird 实例而不引发问题。
2、子类违反了基类的约束条件
当子类违反了基类中定义的约束条件（如输入、输出或异常等），也会违反LSP。
public class
Stack
{
private
int
top
;
private
int
[]
elements
;
public
Stack
(
int
size
) {
elements
=
new
int
[
size
];
top
= -
1
;
}
public
void
push
(
int
value
) {
if
(
top
>=
elements
.
length
-
1
) {
throw new
IllegalStateException
(
"Stack is full"
);
}
elements
[
++
top
]
=
value
;
}
public
int
pop
() {
if
(
top
<
0
) {
throw new
IllegalStateException
(
"Stack is empty"
);
}
return
elements
[
top
--
];
}
}
//
正数的栈
public class
NonNegativeStack
extends
Stack
{
public
NonNegativeStack
(
int
size
) {
super
(
size
);
}
@Override
public
void
push
(
int
value
) {
if
(
value
<
0
) {
throw new
IllegalArgumentException
(
"Only non-negative values are allowed"
);
}
super
.
push
(
value
);
}
}
//
正确的写法
public class
NonNegativeStack
extends
Stack
{
public
NonNegativeStack
(
int
size
) {
super
(
size
);
}
public
void
pushNonNegative
(
int
value
) {
if
(
value
<
0
) {
throw new
IllegalArgumentException
(
"Only non-negative values are allowed"
);
}
super
.
push
(
value
);
}
}
这里感觉给的资料有问题。。。等我看完视频在说
